From 1232d7c285dd3f7c9984d644d9dfd29ca7f8b894 Mon Sep 17 00:00:00 2001 From: skypjack Date: Wed, 17 Dec 2025 11:11:11 +0100 Subject: [PATCH] test: cleanup --- test/entt/entity/sparse_set.cpp | 154 ++++++++++++++++++-------------- 1 file changed, 88 insertions(+), 66 deletions(-) diff --git a/test/entt/entity/sparse_set.cpp b/test/entt/entity/sparse_set.cpp index ef6dfa43f..aeae4f25f 100644 --- a/test/entt/entity/sparse_set.cpp +++ b/test/entt/entity/sparse_set.cpp @@ -181,7 +181,8 @@ TYPED_TEST(SparseSet, FreeList) { const entity_type other{2}; switch(policy) { - case entt::deletion_policy::swap_and_pop: { + using enum entt::deletion_policy; + case swap_and_pop: { ASSERT_EQ(set.size(), 0u); ASSERT_EQ(set.free_list(), traits_type::to_entity(entt::tombstone)); @@ -197,7 +198,7 @@ TYPED_TEST(SparseSet, FreeList) { ASSERT_EQ(set.size(), 0u); ASSERT_EQ(set.free_list(), traits_type::to_entity(entt::tombstone)); } break; - case entt::deletion_policy::in_place: { + case in_place: { ASSERT_EQ(set.size(), 0u); ASSERT_EQ(set.free_list(), traits_type::to_entity(entt::tombstone)); @@ -213,7 +214,7 @@ TYPED_TEST(SparseSet, FreeList) { ASSERT_EQ(set.size(), 0u); ASSERT_EQ(set.free_list(), traits_type::to_entity(entt::tombstone)); } break; - case entt::deletion_policy::swap_only: { + case swap_only: { ASSERT_EQ(set.size(), 0u); ASSERT_EQ(set.free_list(), 0u); @@ -253,11 +254,12 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, FreeList) { set.push(entity_type{3}); switch(policy) { - case entt::deletion_policy::swap_and_pop: - case entt::deletion_policy::in_place: { + using enum entt::deletion_policy; + case swap_and_pop: + case in_place: { ASSERT_DEATH(set.free_list(0u), ""); } break; - case entt::deletion_policy::swap_only: { + case swap_only: { ASSERT_NO_THROW(set.free_list(0u)); ASSERT_NO_THROW(set.free_list(1u)); ASSERT_DEATH(set.free_list(2u), ""); @@ -297,7 +299,8 @@ TYPED_TEST(SparseSet, ShrinkToFit) { ASSERT_EQ(set.extent(), 0u); switch(policy) { - case entt::deletion_policy::swap_and_pop: { + using enum entt::deletion_policy; + case swap_and_pop: { set.push(entity_type{traits_type::page_size - 1u}); set.push(entity_type{traits_type::page_size}); @@ -338,7 +341,7 @@ TYPED_TEST(SparseSet, ShrinkToFit) { ASSERT_FALSE(set.contains(entity_type{traits_type::page_size - 1u})); ASSERT_FALSE(set.contains(entity_type{traits_type::page_size})); } break; - case entt::deletion_policy::in_place: { + case in_place: { set.push(entity_type{traits_type::page_size - 1u}); set.push(entity_type{traits_type::page_size}); @@ -379,7 +382,7 @@ TYPED_TEST(SparseSet, ShrinkToFit) { ASSERT_FALSE(set.contains(entity_type{traits_type::page_size - 1u})); ASSERT_FALSE(set.contains(entity_type{traits_type::page_size})); } break; - case entt::deletion_policy::swap_only: { + case swap_only: { set.push(entity_type{traits_type::page_size - 1u}); set.push(entity_type{traits_type::page_size}); @@ -462,11 +465,12 @@ TYPED_TEST(SparseSet, Pagination) { set.shrink_to_fit(); switch(policy) { - case entt::deletion_policy::swap_and_pop: - case entt::deletion_policy::in_place: { + using enum entt::deletion_policy; + case swap_and_pop: + case in_place: { ASSERT_EQ(set.extent(), 0u); } break; - case entt::deletion_policy::swap_only: { + case swap_only: { ASSERT_EQ(set.extent(), 2 * traits_type::page_size); } break; } @@ -493,15 +497,16 @@ TYPED_TEST(SparseSet, Contiguous) { set.erase(entity); switch(policy) { - case entt::deletion_policy::swap_only: - case entt::deletion_policy::swap_and_pop: { + using enum entt::deletion_policy; + case swap_only: + case swap_and_pop: { ASSERT_TRUE(set.contiguous()); set.clear(); ASSERT_TRUE(set.contiguous()); } break; - case entt::deletion_policy::in_place: { + case in_place: { ASSERT_FALSE(set.contiguous()); set.compact(); @@ -541,7 +546,8 @@ TYPED_TEST(SparseSet, Data) { ASSERT_FALSE(set.contains(entity)); switch(policy) { - case entt::deletion_policy::swap_and_pop: { + using enum entt::deletion_policy; + case swap_and_pop: { ASSERT_FALSE(set.contains(traits_type::next(entity))); ASSERT_EQ(set.size(), 1u); @@ -550,7 +556,7 @@ TYPED_TEST(SparseSet, Data) { ASSERT_EQ(set.data()[0u], other); } break; - case entt::deletion_policy::in_place: { + case in_place: { ASSERT_FALSE(set.contains(traits_type::next(entity))); ASSERT_EQ(set.size(), 2u); @@ -560,7 +566,7 @@ TYPED_TEST(SparseSet, Data) { ASSERT_EQ(set.data()[0u], static_cast(entt::tombstone)); ASSERT_EQ(set.data()[1u], other); } break; - case entt::deletion_policy::swap_only: { + case swap_only: { ASSERT_TRUE(set.contains(traits_type::next(entity))); ASSERT_EQ(set.size(), 2u); @@ -771,12 +777,13 @@ TYPED_TEST(SparseSet, FindErased) { set.erase(entity); switch(policy) { - case entt::deletion_policy::swap_and_pop: - case entt::deletion_policy::in_place: { + using enum entt::deletion_policy; + case swap_and_pop: + case in_place: { ASSERT_EQ(set.find(entity), set.cend()); ASSERT_EQ(set.find(traits_type::next(entity)), set.cend()); } break; - case entt::deletion_policy::swap_only: { + case swap_only: { ASSERT_EQ(set.find(entity), set.cend()); ASSERT_NE(set.find(traits_type::next(entity)), set.cend()); } break; @@ -860,17 +867,18 @@ TYPED_TEST(SparseSet, ContainsErased) { set.erase(entity); switch(policy) { - case entt::deletion_policy::swap_and_pop: { + using enum entt::deletion_policy; + case swap_and_pop: { ASSERT_EQ(set.size(), 0u); ASSERT_FALSE(set.contains(entity)); ASSERT_FALSE(set.contains(traits_type::next(entity))); } break; - case entt::deletion_policy::in_place: { + case in_place: { ASSERT_EQ(set.size(), 1u); ASSERT_FALSE(set.contains(entity)); ASSERT_FALSE(set.contains(traits_type::next(entity))); } break; - case entt::deletion_policy::swap_only: { + case swap_only: { ASSERT_EQ(set.size(), 1u); ASSERT_FALSE(set.contains(entity)); ASSERT_TRUE(set.contains(traits_type::next(entity))); @@ -921,15 +929,16 @@ TYPED_TEST(SparseSet, CurrentErased) { set.erase(entity); switch(policy) { - case entt::deletion_policy::swap_and_pop: { + using enum entt::deletion_policy; + case swap_and_pop: { ASSERT_EQ(set.size(), 0u); ASSERT_EQ(set.current(entity), traits_type::to_version(entt::tombstone)); } break; - case entt::deletion_policy::in_place: { + case in_place: { ASSERT_EQ(set.size(), 1u); ASSERT_EQ(set.current(entity), traits_type::to_version(entt::tombstone)); } break; - case entt::deletion_policy::swap_only: { + case swap_only: { ASSERT_EQ(set.size(), 1u); ASSERT_EQ(set.current(entity), traits_type::to_version(traits_type::next(entity))); } break; @@ -957,17 +966,18 @@ TYPED_TEST(SparseSet, Index) { set.erase(entity); switch(policy) { - case entt::deletion_policy::swap_and_pop: { + using enum entt::deletion_policy; + case swap_and_pop: { ASSERT_EQ(set.size(), 1u); ASSERT_FALSE(set.contains(traits_type::next(entity))); ASSERT_EQ(set.index(other), 0u); } break; - case entt::deletion_policy::in_place: { + case in_place: { ASSERT_EQ(set.size(), 2u); ASSERT_FALSE(set.contains(traits_type::next(entity))); ASSERT_EQ(set.index(other), 1u); } break; - case entt::deletion_policy::swap_only: { + case swap_only: { ASSERT_EQ(set.size(), 2u); ASSERT_TRUE(set.contains(traits_type::next(entity))); ASSERT_EQ(set.index(traits_type::next(entity)), 1u); @@ -986,11 +996,12 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Index) { // index works the same in all cases, test only once switch(policy) { - case entt::deletion_policy::swap_and_pop: + using enum entt::deletion_policy; + case swap_and_pop: ASSERT_DEATH([[maybe_unused]] const auto pos = set.index(entity_type{1}), ""); break; - case entt::deletion_policy::in_place: - case entt::deletion_policy::swap_only: + case in_place: + case swap_only: SUCCEED(); break; } @@ -1022,11 +1033,12 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Indexing) { // operator[] works the same in all cases, test only once switch(policy) { - case entt::deletion_policy::swap_and_pop: + using enum entt::deletion_policy; + case swap_and_pop: ASSERT_DEATH([[maybe_unused]] auto value = set[0u], ""); break; - case entt::deletion_policy::in_place: - case entt::deletion_policy::swap_only: + case in_place: + case swap_only: SUCCEED(); break; } @@ -1058,11 +1070,12 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Value) { // value works the same in all cases, test only once switch(policy) { - case entt::deletion_policy::swap_and_pop: + using enum entt::deletion_policy; + case swap_and_pop: ASSERT_DEATH([[maybe_unused]] auto *value = set.value(entity_type{3}), ""); break; - case entt::deletion_policy::in_place: - case entt::deletion_policy::swap_only: + case in_place: + case swap_only: SUCCEED(); break; } @@ -1079,7 +1092,8 @@ TYPED_TEST(SparseSet, Push) { const std::array entity{entity_type{1}, entity_type{3}}; switch(policy) { - case entt::deletion_policy::swap_and_pop: { + using enum entt::deletion_policy; + case swap_and_pop: { ASSERT_EQ(set.size(), 0u); ASSERT_EQ(*set.push(entity[0u]), entity[0u]); ASSERT_EQ(*set.push(entity[1u]), entity[1u]); @@ -1117,7 +1131,7 @@ TYPED_TEST(SparseSet, Push) { ASSERT_EQ(set.push(entity.begin(), entity.begin()), set.end()); ASSERT_EQ(set.size(), 0u); } break; - case entt::deletion_policy::in_place: { + case in_place: { ASSERT_EQ(set.size(), 0u); ASSERT_EQ(*set.push(entity[0u]), entity[0u]); ASSERT_EQ(*set.push(entity[1u]), entity[1u]); @@ -1156,7 +1170,7 @@ TYPED_TEST(SparseSet, Push) { ASSERT_EQ(set.push(entity.begin(), entity.begin()), set.end()); ASSERT_EQ(set.size(), 0u); } break; - case entt::deletion_policy::swap_only: { + case swap_only: { ASSERT_EQ(set.size(), 0u); ASSERT_EQ(set.free_list(), 0u); ASSERT_EQ(*set.push(entity[0u]), entity[0u]); @@ -1279,13 +1293,14 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Bump) { // bump works the same in all cases, test only once switch(policy) { - case entt::deletion_policy::swap_and_pop: + using enum entt::deletion_policy; + case swap_and_pop: ASSERT_DEATH(set.bump(entt::null), ""); ASSERT_DEATH(set.bump(entt::tombstone), ""); ASSERT_DEATH(set.bump(entity_type{3}), ""); break; - case entt::deletion_policy::in_place: - case entt::deletion_policy::swap_only: + case in_place: + case swap_only: SUCCEED(); break; } @@ -1303,7 +1318,8 @@ TYPED_TEST(SparseSet, Erase) { const std::array entity{entity_type{1}, entity_type{3}, traits_type::construct(2, 4)}; switch(policy) { - case entt::deletion_policy::swap_and_pop: { + using enum entt::deletion_policy; + case swap_and_pop: { ASSERT_EQ(set.size(), 0u); ASSERT_EQ(set.free_list(), traits_type::entity_mask); @@ -1326,7 +1342,7 @@ TYPED_TEST(SparseSet, Erase) { ASSERT_EQ(set.free_list(), traits_type::entity_mask); ASSERT_FALSE(set.contains(entity[2u])); } break; - case entt::deletion_policy::in_place: { + case in_place: { ASSERT_EQ(set.size(), 0u); ASSERT_EQ(set.free_list(), traits_type::entity_mask); @@ -1357,7 +1373,7 @@ TYPED_TEST(SparseSet, Erase) { ASSERT_EQ(set.free_list(), 4u); ASSERT_FALSE(set.contains(entity[2u])); } break; - case entt::deletion_policy::swap_only: { + case swap_only: { ASSERT_EQ(set.size(), 0u); ASSERT_EQ(set.free_list(), 0u); @@ -1439,7 +1455,8 @@ TYPED_TEST(SparseSet, Remove) { const std::array entity{entity_type{1}, entity_type{3}, traits_type::construct(2, 4)}; switch(policy) { - case entt::deletion_policy::swap_and_pop: { + using enum entt::deletion_policy; + case swap_and_pop: { ASSERT_EQ(set.size(), 0u); ASSERT_EQ(set.free_list(), traits_type::entity_mask); @@ -1471,7 +1488,7 @@ TYPED_TEST(SparseSet, Remove) { ASSERT_EQ(set.free_list(), traits_type::entity_mask); ASSERT_FALSE(set.contains(entity[2u])); } break; - case entt::deletion_policy::in_place: { + case in_place: { ASSERT_EQ(set.size(), 0u); ASSERT_EQ(set.free_list(), traits_type::entity_mask); @@ -1511,7 +1528,7 @@ TYPED_TEST(SparseSet, Remove) { ASSERT_EQ(set.free_list(), 4u); ASSERT_FALSE(set.contains(entity[2u])); } break; - case entt::deletion_policy::swap_only: { + case swap_only: { ASSERT_EQ(set.size(), 0u); ASSERT_EQ(set.free_list(), 0u); @@ -1595,7 +1612,8 @@ TYPED_TEST(SparseSet, Compact) { set.push(other); switch(policy) { - case entt::deletion_policy::swap_and_pop: { + using enum entt::deletion_policy; + case swap_and_pop: { ASSERT_EQ(set.size(), 2u); ASSERT_EQ(set.index(entity), 0u); ASSERT_EQ(set.index(other), 1u); @@ -1616,7 +1634,7 @@ TYPED_TEST(SparseSet, Compact) { ASSERT_EQ(set.size(), 1u); ASSERT_EQ(set.index(other), 0u); } break; - case entt::deletion_policy::in_place: { + case in_place: { ASSERT_EQ(set.size(), 2u); ASSERT_EQ(set.index(entity), 0u); ASSERT_EQ(set.index(other), 1u); @@ -1653,7 +1671,7 @@ TYPED_TEST(SparseSet, Compact) { ASSERT_EQ(set.size(), 1u); ASSERT_EQ(set.index(other), 0u); } break; - case entt::deletion_policy::swap_only: { + case swap_only: { ASSERT_EQ(set.size(), 2u); ASSERT_EQ(set.index(entity), 0u); ASSERT_EQ(set.index(other), 1u); @@ -1717,11 +1735,12 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, SwapElements) { // swap_elements works the same in all cases, test only once switch(policy) { - case entt::deletion_policy::swap_and_pop: - case entt::deletion_policy::in_place: + using enum entt::deletion_policy; + case swap_and_pop: + case in_place: SUCCEED(); break; - case entt::deletion_policy::swap_only: + case swap_only: ASSERT_DEATH(set.swap_elements(entity, other), ""); set.push(entity); @@ -1822,11 +1841,12 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, Sort) { set.erase(entity); switch(policy) { - case entt::deletion_policy::swap_and_pop: - case entt::deletion_policy::swap_only: { + using enum entt::deletion_policy; + case swap_and_pop: + case swap_only: { SUCCEED(); } break; - case entt::deletion_policy::in_place: { + case in_place: { ASSERT_DEATH(set.sort(std::less{}), ""); } break; } @@ -1885,14 +1905,15 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, SortN) { set.erase(entity); switch(policy) { - case entt::deletion_policy::swap_and_pop: { + using enum entt::deletion_policy; + case swap_and_pop: { SUCCEED(); } break; - case entt::deletion_policy::in_place: { + case in_place: { ASSERT_EQ(set.size(), 2u); ASSERT_DEATH(set.sort_n(1u, std::less{}), ""); } break; - case entt::deletion_policy::swap_only: { + case swap_only: { ASSERT_EQ(set.size(), 2u); ASSERT_NO_THROW(set.sort_n(1u, std::less{})); ASSERT_DEATH(set.sort_n(2u, std::less{}), ""); @@ -2089,10 +2110,11 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, SortAs) { sparse_set_type rhs{policy}; switch(policy) { - case entt::deletion_policy::swap_and_pop: { + using enum entt::deletion_policy; + case swap_and_pop: { SUCCEED(); } break; - case entt::deletion_policy::in_place: { + case in_place: { const entity_type entity{4}; lhs.push(entity); @@ -2100,7 +2122,7 @@ ENTT_DEBUG_TYPED_TEST(SparseSetDeathTest, SortAs) { ASSERT_DEATH(lhs.sort_as(rhs.begin(), rhs.end()), ""); } break; - case entt::deletion_policy::swap_only: { + case swap_only: { const std::array entity{entity_type{1}, entity_type{4}, entity_type{2}}; lhs.push(entity.begin(), entity.end());