From c41f6aebf4c20c899770c7329f7019d8f0d2d7e1 Mon Sep 17 00:00:00 2001 From: Michele Caini Date: Thu, 19 Sep 2019 22:34:14 +0200 Subject: [PATCH] sorting: more tests --- test/entt/entity/group.cpp | 78 +++++++++++++++++++++++---------- test/entt/entity/sparse_set.cpp | 24 ++++++++++ test/entt/entity/storage.cpp | 24 ++++++++++ 3 files changed, 103 insertions(+), 23 deletions(-) diff --git a/test/entt/entity/group.cpp b/test/entt/entity/group.cpp index 56ae956c4..e49d48410 100644 --- a/test/entt/entity/group.cpp +++ b/test/entt/entity/group.cpp @@ -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); @@ -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(e0, 0u); registry.assign(e1, 1u); registry.assign(e2, 2u); + registry.assign(e3, 3u); registry.assign(e0, 0); registry.assign(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(e0)), (std::make_tuple(0, 0u))); + ASSERT_EQ((group.get(e1)), (std::make_tuple(1, 1u))); + ASSERT_EQ((group.get(e2)), (std::make_tuple(2, 2u))); + + ASSERT_FALSE(group.contains(e3)); + group.sort([](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(e0)), (std::make_tuple(0, 0u))); + ASSERT_EQ((group.get(e1)), (std::make_tuple(1, 1u))); + ASSERT_EQ((group.get(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(e0, uval++); registry.assign(e1, uval++); registry.assign(e2, uval++); + registry.assign(e3, uval+1); registry.assign(e0, ival++); registry.assign(e1, ival++); @@ -243,6 +263,12 @@ TEST(NonOwningGroup, SortAsAPool) { registry.sort(std::less{}); group.sort(); + ASSERT_EQ((group.get(e0)), (std::make_tuple(0, 0u))); + ASSERT_EQ((group.get(e1)), (std::make_tuple(1, 1u))); + ASSERT_EQ((group.get(e2)), (std::make_tuple(2, 2u))); + + ASSERT_FALSE(group.contains(e3)); + for(auto entity: group) { ASSERT_EQ(group.get(entity), uval++); ASSERT_EQ(group.get(entity), ival++); @@ -628,13 +654,8 @@ TEST(OwningGroup, SortOrdered) { entt::registry registry; auto group = registry.group(); - 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(entities[0], 12); registry.assign(entities[0], 'a'); @@ -667,19 +688,21 @@ TEST(OwningGroup, SortOrdered) { ASSERT_EQ(*(group.raw() + 0u), 'a'); ASSERT_EQ(*(group.raw() + 1u), 'b'); ASSERT_EQ(*(group.raw() + 2u), 'c'); + + ASSERT_EQ((group.get(entities[0])), (std::make_tuple(boxed_int{12}, 'a'))); + ASSERT_EQ((group.get(entities[1])), (std::make_tuple(boxed_int{9}, 'b'))); + ASSERT_EQ((group.get(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(); - 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(entities[0], 6); registry.assign(entities[0], 'a'); @@ -712,21 +735,21 @@ TEST(OwningGroup, SortReverse) { ASSERT_EQ(*(group.raw() + 0u), 'c'); ASSERT_EQ(*(group.raw() + 1u), 'b'); ASSERT_EQ(*(group.raw() + 2u), 'a'); + + ASSERT_EQ((group.get(entities[0])), (std::make_tuple(boxed_int{6}, 'a'))); + ASSERT_EQ((group.get(entities[1])), (std::make_tuple(boxed_int{9}, 'b'))); + ASSERT_EQ((group.get(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(entt::get); - 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(entities[0], 6); registry.assign(entities[0], 'c'); @@ -771,6 +794,15 @@ TEST(OwningGroup, SortUnordered) { ASSERT_EQ(*(group.raw() + 2u), 'a'); ASSERT_EQ(*(group.raw() + 3u), 'd'); ASSERT_EQ(*(group.raw() + 4u), 'e'); + + ASSERT_EQ((group.get(entities[0])), (std::make_tuple(boxed_int{6}, 'c'))); + ASSERT_EQ((group.get(entities[1])), (std::make_tuple(boxed_int{3}, 'b'))); + ASSERT_EQ((group.get(entities[2])), (std::make_tuple(boxed_int{1}, 'a'))); + ASSERT_EQ((group.get(entities[3])), (std::make_tuple(boxed_int{9}, 'd'))); + ASSERT_EQ((group.get(entities[4])), (std::make_tuple(boxed_int{12}, 'e'))); + + ASSERT_FALSE(group.contains(entities[5])); + ASSERT_FALSE(group.contains(entities[6])); } TEST(OwningGroup, IndexRebuiltOnDestroy) { diff --git a/test/entt/entity/sparse_set.cpp b/test/entt/entity/sparse_set.cpp index 2b22b8fac..e19a557e6 100644 --- a/test/entt/entity/sparse_set.cpp +++ b/test/entt/entity/sparse_set.cpp @@ -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}); diff --git a/test/entt/entity/storage.cpp b/test/entt/entity/storage.cpp index 186dd278f..bbb677e64 100644 --- a/test/entt/entity/storage.cpp +++ b/test/entt/entity/storage.cpp @@ -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);