Scarfski/entt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sorting: more tests

Browse Source
This commit is contained in:
Michele Caini
2019-09-19 22:39:13 +02:00
parent 5e6cda7c5e
commit c41f6aebf4
3 changed files with 103 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/entt/entity/group.cpp
+55 -23
View File
@@ -10,6 +10,10 @@
struct empty_type {};
struct boxed_int { int value; };
bool operator==(const boxed_int &lhs, const boxed_int &rhs) {
return lhs.value == rhs.value;
}
TEST(NonOwningGroup, Functionalities) {
entt::registry registry;
auto group = registry.group(entt::get<int, char>);
@@ -170,10 +174,12 @@ TEST(NonOwningGroup, Sort) {
const auto e0 = registry.create();
const auto e1 = registry.create();
const auto e2 = registry.create();
const auto e3 = registry.create();
registry.assign<unsigned int>(e0, 0u);
registry.assign<unsigned int>(e1, 1u);
registry.assign<unsigned int>(e2, 2u);
registry.assign<unsigned int>(e3, 3u);
registry.assign<int>(e0, 0);
registry.assign<int>(e1, 1);
@@ -207,6 +213,12 @@ TEST(NonOwningGroup, Sort) {
ASSERT_EQ(*(group.data() + 1u), e1);
ASSERT_EQ(*(group.data() + 2u), e0);
ASSERT_EQ((group.get<const int, unsigned int>(e0)), (std::make_tuple(0, 0u)));
ASSERT_EQ((group.get<const int, unsigned int>(e1)), (std::make_tuple(1, 1u)));
ASSERT_EQ((group.get<const int, unsigned int>(e2)), (std::make_tuple(2, 2u)));
ASSERT_FALSE(group.contains(e3));
group.sort<const int>([](const int lhs, const int rhs) {
return lhs > rhs;
});
@@ -214,6 +226,12 @@ TEST(NonOwningGroup, Sort) {
ASSERT_EQ(*(group.data() + 0u), e0);
ASSERT_EQ(*(group.data() + 1u), e1);
ASSERT_EQ(*(group.data() + 2u), e2);
ASSERT_EQ((group.get<const int, unsigned int>(e0)), (std::make_tuple(0, 0u)));
ASSERT_EQ((group.get<const int, unsigned int>(e1)), (std::make_tuple(1, 1u)));
ASSERT_EQ((group.get<const int, unsigned int>(e2)), (std::make_tuple(2, 2u)));
ASSERT_FALSE(group.contains(e3));
}
TEST(NonOwningGroup, SortAsAPool) {
@@ -223,6 +241,7 @@ TEST(NonOwningGroup, SortAsAPool) {
const auto e0 = registry.create();
const auto e1 = registry.create();
const auto e2 = registry.create();
const auto e3 = registry.create();
auto uval = 0u;
auto ival = 0;
@@ -230,6 +249,7 @@ TEST(NonOwningGroup, SortAsAPool) {
registry.assign<unsigned int>(e0, uval++);
registry.assign<unsigned int>(e1, uval++);
registry.assign<unsigned int>(e2, uval++);
registry.assign<unsigned int>(e3, uval+1);
registry.assign<int>(e0, ival++);
registry.assign<int>(e1, ival++);
@@ -243,6 +263,12 @@ TEST(NonOwningGroup, SortAsAPool) {
registry.sort<unsigned int>(std::less<unsigned int>{});
group.sort<unsigned int>();
ASSERT_EQ((group.get<const int, unsigned int>(e0)), (std::make_tuple(0, 0u)));
ASSERT_EQ((group.get<const int, unsigned int>(e1)), (std::make_tuple(1, 1u)));
ASSERT_EQ((group.get<const int, unsigned int>(e2)), (std::make_tuple(2, 2u)));
ASSERT_FALSE(group.contains(e3));
for(auto entity: group) {
ASSERT_EQ(group.get<unsigned int>(entity), uval++);
ASSERT_EQ(group.get<const int>(entity), ival++);
@@ -628,13 +654,8 @@ TEST(OwningGroup, SortOrdered) {
entt::registry registry;
auto group = registry.group<boxed_int, char>();
entt::entity entities[5] = {
registry.create(),
registry.create(),
registry.create(),
registry.create(),
registry.create()
};
entt::entity entities[5]{};
registry.create(std::begin(entities), std::end(entities));
registry.assign<boxed_int>(entities[0], 12);
registry.assign<char>(entities[0], 'a');
@@ -667,19 +688,21 @@ TEST(OwningGroup, SortOrdered) {
ASSERT_EQ(*(group.raw<char>() + 0u), 'a');
ASSERT_EQ(*(group.raw<char>() + 1u), 'b');
ASSERT_EQ(*(group.raw<char>() + 2u), 'c');
ASSERT_EQ((group.get<boxed_int, char>(entities[0])), (std::make_tuple(boxed_int{12}, 'a')));
ASSERT_EQ((group.get<boxed_int, char>(entities[1])), (std::make_tuple(boxed_int{9}, 'b')));
ASSERT_EQ((group.get<boxed_int, char>(entities[2])), (std::make_tuple(boxed_int{6}, 'c')));
ASSERT_FALSE(group.contains(entities[3]));
ASSERT_FALSE(group.contains(entities[4]));
}
TEST(OwningGroup, SortReverse) {
entt::registry registry;
auto group = registry.group<boxed_int, char>();
entt::entity entities[5] = {
registry.create(),
registry.create(),
registry.create(),
registry.create(),
registry.create()
};
entt::entity entities[5]{};
registry.create(std::begin(entities), std::end(entities));
registry.assign<boxed_int>(entities[0], 6);
registry.assign<char>(entities[0], 'a');
@@ -712,21 +735,21 @@ TEST(OwningGroup, SortReverse) {
ASSERT_EQ(*(group.raw<char>() + 0u), 'c');
ASSERT_EQ(*(group.raw<char>() + 1u), 'b');
ASSERT_EQ(*(group.raw<char>() + 2u), 'a');
ASSERT_EQ((group.get<boxed_int, char>(entities[0])), (std::make_tuple(boxed_int{6}, 'a')));
ASSERT_EQ((group.get<boxed_int, char>(entities[1])), (std::make_tuple(boxed_int{9}, 'b')));
ASSERT_EQ((group.get<boxed_int, char>(entities[2])), (std::make_tuple(boxed_int{12}, 'c')));
ASSERT_FALSE(group.contains(entities[3]));
ASSERT_FALSE(group.contains(entities[4]));
}
TEST(OwningGroup, SortUnordered) {
entt::registry registry;
auto group = registry.group<boxed_int>(entt::get<char>);
entt::entity entities[7] = {
registry.create(),
registry.create(),
registry.create(),
registry.create(),
registry.create(),
registry.create(),
registry.create()
};
entt::entity entities[7]{};
registry.create(std::begin(entities), std::end(entities));
registry.assign<boxed_int>(entities[0], 6);
registry.assign<char>(entities[0], 'c');
@@ -771,6 +794,15 @@ TEST(OwningGroup, SortUnordered) {
ASSERT_EQ(*(group.raw<char>() + 2u), 'a');
ASSERT_EQ(*(group.raw<char>() + 3u), 'd');
ASSERT_EQ(*(group.raw<char>() + 4u), 'e');
ASSERT_EQ((group.get<boxed_int, char>(entities[0])), (std::make_tuple(boxed_int{6}, 'c')));
ASSERT_EQ((group.get<boxed_int, char>(entities[1])), (std::make_tuple(boxed_int{3}, 'b')));
ASSERT_EQ((group.get<boxed_int, char>(entities[2])), (std::make_tuple(boxed_int{1}, 'a')));
ASSERT_EQ((group.get<boxed_int, char>(entities[3])), (std::make_tuple(boxed_int{9}, 'd')));
ASSERT_EQ((group.get<boxed_int, char>(entities[4])), (std::make_tuple(boxed_int{12}, 'e')));
ASSERT_FALSE(group.contains(entities[5]));
ASSERT_FALSE(group.contains(entities[6]));
}
TEST(OwningGroup, IndexRebuiltOnDestroy) {
test/entt/entity/sparse_set.cpp
+24
View File
@@ -244,6 +244,12 @@ TEST(SparseSet, SortOrdered) {
set.sort(set.begin(), set.end(), std::less{});
ASSERT_EQ(set.index(entt::entity{42}), 0u);
ASSERT_EQ(set.index(entt::entity{12}), 1u);
ASSERT_EQ(set.index(entt::entity{9}), 2u);
ASSERT_EQ(set.index(entt::entity{7}), 3u);
ASSERT_EQ(set.index(entt::entity{3}), 4u);
ASSERT_EQ(*(set.data() + 0u), entt::entity{42});
ASSERT_EQ(*(set.data() + 1u), entt::entity{12});
ASSERT_EQ(*(set.data() + 2u), entt::entity{9});
@@ -278,6 +284,12 @@ TEST(SparseSet, SortReverse) {
set.sort(set.begin(), set.end(), std::less{});
ASSERT_EQ(set.index(entt::entity{42}), 0u);
ASSERT_EQ(set.index(entt::entity{12}), 1u);
ASSERT_EQ(set.index(entt::entity{9}), 2u);
ASSERT_EQ(set.index(entt::entity{7}), 3u);
ASSERT_EQ(set.index(entt::entity{3}), 4u);
ASSERT_EQ(*(set.data() + 0u), entt::entity{42});
ASSERT_EQ(*(set.data() + 1u), entt::entity{12});
ASSERT_EQ(*(set.data() + 2u), entt::entity{9});
@@ -312,6 +324,12 @@ TEST(SparseSet, SortUnordered) {
set.sort(set.begin(), set.end(), std::less{});
ASSERT_EQ(set.index(entt::entity{42}), 0u);
ASSERT_EQ(set.index(entt::entity{12}), 1u);
ASSERT_EQ(set.index(entt::entity{9}), 2u);
ASSERT_EQ(set.index(entt::entity{7}), 3u);
ASSERT_EQ(set.index(entt::entity{3}), 4u);
ASSERT_EQ(*(set.data() + 0u), entt::entity{42});
ASSERT_EQ(*(set.data() + 1u), entt::entity{12});
ASSERT_EQ(*(set.data() + 2u), entt::entity{9});
@@ -370,6 +388,12 @@ TEST(SparseSet, SortRange) {
set.sort(++set.begin(), --set.end(), std::less{});
ASSERT_EQ(set.index(entt::entity{9}), 0u);
ASSERT_EQ(set.index(entt::entity{12}), 1u);
ASSERT_EQ(set.index(entt::entity{7}), 2u);
ASSERT_EQ(set.index(entt::entity{3}), 3u);
ASSERT_EQ(set.index(entt::entity{42}), 4u);
ASSERT_EQ(*(set.data() + 0u), entt::entity{9});
ASSERT_EQ(*(set.data() + 1u), entt::entity{12});
ASSERT_EQ(*(set.data() + 2u), entt::entity{7});
test/entt/entity/storage.cpp
+24
View File
@@ -338,6 +338,12 @@ TEST(Storage, SortOrdered) {
return lhs.value < rhs.value;
});
ASSERT_EQ(pool.index(entt::entity{12}), 0u);
ASSERT_EQ(pool.index(entt::entity{42}), 1u);
ASSERT_EQ(pool.index(entt::entity{7}), 2u);
ASSERT_EQ(pool.index(entt::entity{3}), 3u);
ASSERT_EQ(pool.index(entt::entity{9}), 4u);
ASSERT_EQ((pool.raw() + 0u)->value, 12);
ASSERT_EQ((pool.raw() + 1u)->value, 9);
ASSERT_EQ((pool.raw() + 2u)->value, 6);
@@ -374,6 +380,12 @@ TEST(Storage, SortReverse) {
return pool.get(lhs).value < pool.get(rhs).value;
});
ASSERT_EQ(pool.index(entt::entity{9}), 0u);
ASSERT_EQ(pool.index(entt::entity{3}), 1u);
ASSERT_EQ(pool.index(entt::entity{7}), 2u);
ASSERT_EQ(pool.index(entt::entity{42}), 3u);
ASSERT_EQ(pool.index(entt::entity{12}), 4u);
ASSERT_EQ((pool.raw() + 0u)->value, 12);
ASSERT_EQ((pool.raw() + 1u)->value, 9);
ASSERT_EQ((pool.raw() + 2u)->value, 6);
@@ -410,6 +422,12 @@ TEST(Storage, SortUnordered) {
return lhs.value < rhs.value;
});
ASSERT_EQ(pool.index(entt::entity{9}), 0u);
ASSERT_EQ(pool.index(entt::entity{3}), 1u);
ASSERT_EQ(pool.index(entt::entity{12}), 2u);
ASSERT_EQ(pool.index(entt::entity{42}), 3u);
ASSERT_EQ(pool.index(entt::entity{7}), 4u);
ASSERT_EQ((pool.raw() + 0u)->value, 12);
ASSERT_EQ((pool.raw() + 1u)->value, 9);
ASSERT_EQ((pool.raw() + 2u)->value, 6);
@@ -476,6 +494,12 @@ TEST(Storage, SortRange) {
return lhs.value < rhs.value;
});
ASSERT_EQ(pool.index(entt::entity{12}), 0u);
ASSERT_EQ(pool.index(entt::entity{3}), 1u);
ASSERT_EQ(pool.index(entt::entity{42}), 2u);
ASSERT_EQ(pool.index(entt::entity{7}), 3u);
ASSERT_EQ(pool.index(entt::entity{9}), 4u);
ASSERT_EQ((pool.raw() + 0u)->value, 6);
ASSERT_EQ((pool.raw() + 1u)->value, 9);
ASSERT_EQ((pool.raw() + 2u)->value, 3);