test: cleanup

test/entt/entity/storage.cpp

@@ -91,6 +91,7 @@ TYPED_TEST_SUITE(StorageDeathTest, StorageTypes, );
 TYPED_TEST(Storage, Constructors) {
     using value_type = typename TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
+
     entt::storage<value_type> pool;
 
     ASSERT_EQ(pool.policy(), entt::deletion_policy{traits_type::in_place_delete});
@@ -106,9 +107,11 @@ TYPED_TEST(Storage, Constructors) {
 
 TYPED_TEST(Storage, Move) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
+    const std::array entity{entt::entity{3}, entt::entity{2}};
 
-    pool.emplace(entt::entity{3}, 3);
+    pool.emplace(entity[0u], 3);
 
     static_assert(std::is_move_constructible_v<decltype(pool)>, "Move constructible type required");
     static_assert(std::is_move_assignable_v<decltype(pool)>, "Move assignable type required");
@@ -121,8 +124,8 @@ TYPED_TEST(Storage, Move) {
     ASSERT_FALSE(other.empty());
 
     ASSERT_EQ(other.type(), entt::type_id<value_type>());
-    ASSERT_EQ(other.index(entt::entity{3}), 0u);
-    ASSERT_EQ(other.get(entt::entity{3}), value_type{3});
+    ASSERT_EQ(other.index(entity[0u]), 0u);
+    ASSERT_EQ(other.get(entity[0u]), value_type{3});
 
     entt::storage<value_type> extended{std::move(other), std::allocator<value_type>{}};
 
@@ -132,8 +135,8 @@ TYPED_TEST(Storage, Move) {
     ASSERT_FALSE(extended.empty());
 
     ASSERT_EQ(extended.type(), entt::type_id<value_type>());
-    ASSERT_EQ(extended.index(entt::entity{3}), 0u);
-    ASSERT_EQ(extended.get(entt::entity{3}), value_type{3});
+    ASSERT_EQ(extended.index(entity[0u]), 0u);
+    ASSERT_EQ(extended.get(entity[0u]), value_type{3});
 
     pool = std::move(extended);
     test::is_initialized(extended);
@@ -143,11 +146,11 @@ TYPED_TEST(Storage, Move) {
     ASSERT_TRUE(extended.empty());
 
     ASSERT_EQ(pool.type(), entt::type_id<value_type>());
-    ASSERT_EQ(pool.index(entt::entity{3}), 0u);
-    ASSERT_EQ(pool.get(entt::entity{3}), value_type{3});
+    ASSERT_EQ(pool.index(entity[0u]), 0u);
+    ASSERT_EQ(pool.get(entity[0u]), value_type{3});
 
     other = entt::storage<value_type>{};
-    other.emplace(entt::entity{2}, 2);
+    other.emplace(entity[1u], 2);
     other = std::move(pool);
     test::is_initialized(pool);
 
@@ -155,13 +158,14 @@ TYPED_TEST(Storage, Move) {
     ASSERT_FALSE(other.empty());
 
     ASSERT_EQ(other.type(), entt::type_id<value_type>());
-    ASSERT_EQ(other.index(entt::entity{3}), 0u);
-    ASSERT_EQ(other.get(entt::entity{3}), value_type{3});
+    ASSERT_EQ(other.index(entity[0u]), 0u);
+    ASSERT_EQ(other.get(entity[0u]), value_type{3});
 }
 
 TYPED_TEST(Storage, Swap) {
     using value_type = typename TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
+
     entt::storage<value_type> pool;
     entt::storage<value_type> other;
 
@@ -195,6 +199,7 @@ TYPED_TEST(Storage, Swap) {
 TYPED_TEST(Storage, Capacity) {
     using value_type = typename TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
+
     entt::storage<value_type> pool;
 
     pool.reserve(64);
@@ -211,6 +216,7 @@ TYPED_TEST(Storage, Capacity) {
 TYPED_TEST(Storage, ShrinkToFit) {
     using value_type = typename TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
+
     entt::storage<value_type> pool;
 
     for(std::size_t next{}; next < traits_type::page_size; ++next) {
@@ -242,6 +248,7 @@ TYPED_TEST(Storage, ShrinkToFit) {
 
 TYPED_TEST(Storage, Raw) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
 
     pool.emplace(entt::entity{1}, 1);
@@ -511,6 +518,7 @@ TYPED_TEST(Storage, ConstReverseIterator) {
 
 TYPED_TEST(Storage, IteratorConversion) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
 
     pool.emplace(entt::entity{1}, 2);
@@ -537,6 +545,7 @@ TYPED_TEST(Storage, IteratorConversion) {
 TYPED_TEST(Storage, IteratorPageSizeAwareness) {
     using value_type = typename TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
+
     entt::storage<value_type> pool;
 
     static_assert(!std::is_same_v<value_type, int> || (traits_type::page_size != entt::component_traits<value_type *>::page_size), "Different page size required");
@@ -554,9 +563,11 @@ TYPED_TEST(Storage, IteratorPageSizeAwareness) {
 
 TYPED_TEST(Storage, Getters) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
+    const entt::entity entity{1};
 
-    pool.emplace(entt::entity{1}, 3);
+    pool.emplace(entity, 3);
 
     testing::StaticAssertTypeEq<decltype(pool.get({})), value_type &>();
     testing::StaticAssertTypeEq<decltype(std::as_const(pool).get({})), const value_type &>();
@@ -564,35 +575,40 @@ TYPED_TEST(Storage, Getters) {
     testing::StaticAssertTypeEq<decltype(pool.get_as_tuple({})), std::tuple<value_type &>>();
     testing::StaticAssertTypeEq<decltype(std::as_const(pool).get_as_tuple({})), std::tuple<const value_type &>>();
 
-    ASSERT_EQ(pool.get(entt::entity{1}), value_type{3});
-    ASSERT_EQ(std::as_const(pool).get(entt::entity{1}), value_type{3});
+    ASSERT_EQ(pool.get(entity), value_type{3});
+    ASSERT_EQ(std::as_const(pool).get(entity), value_type{3});
 
-    ASSERT_EQ(pool.get_as_tuple(entt::entity{1}), std::make_tuple(value_type{3}));
-    ASSERT_EQ(std::as_const(pool).get_as_tuple(entt::entity{1}), std::make_tuple(value_type{3}));
+    ASSERT_EQ(pool.get_as_tuple(entity), std::make_tuple(value_type{3}));
+    ASSERT_EQ(std::as_const(pool).get_as_tuple(entity), std::make_tuple(value_type{3}));
 }
 
 ENTT_DEBUG_TYPED_TEST(StorageDeathTest, Getters) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
+    const entt::entity entity{4};
 
-    ASSERT_DEATH([[maybe_unused]] const auto &value = pool.get(entt::entity{4}), "");
-    ASSERT_DEATH([[maybe_unused]] const auto &value = std::as_const(pool).get(entt::entity{4}), "");
+    ASSERT_DEATH([[maybe_unused]] const auto &value = pool.get(entity), "");
+    ASSERT_DEATH([[maybe_unused]] const auto &value = std::as_const(pool).get(entity), "");
 
-    ASSERT_DEATH([[maybe_unused]] const auto value = pool.get_as_tuple(entt::entity{4}), "");
-    ASSERT_DEATH([[maybe_unused]] const auto value = std::as_const(pool).get_as_tuple(entt::entity{4}), "");
+    ASSERT_DEATH([[maybe_unused]] const auto value = pool.get_as_tuple(entity), "");
+    ASSERT_DEATH([[maybe_unused]] const auto value = std::as_const(pool).get_as_tuple(entity), "");
 }
 
 TYPED_TEST(Storage, Value) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
+    const entt::entity entity{2};
 
-    pool.emplace(entt::entity{2});
+    pool.emplace(entity);
 
-    ASSERT_EQ(pool.value(entt::entity{2}), &pool.get(entt::entity{2}));
+    ASSERT_EQ(pool.value(entity), &pool.get(entity));
 }
 
 ENTT_DEBUG_TYPED_TEST(StorageDeathTest, Value) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
 
     ASSERT_DEATH([[maybe_unused]] const void *value = pool.value(entt::entity{2}), "");
@@ -600,6 +616,7 @@ ENTT_DEBUG_TYPED_TEST(StorageDeathTest, Value) {
 
 TYPED_TEST(Storage, Emplace) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
 
     testing::StaticAssertTypeEq<decltype(pool.emplace({})), value_type &>();
@@ -648,9 +665,9 @@ TEST(Storage, EmplaceSelfMoveSupportInPlaceDelete) {
 TYPED_TEST(Storage, TryEmplace) {
     using value_type = typename TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
+
     entt::storage<value_type> pool;
     entt::sparse_set &base = pool;
-
     const std::array entity{entt::entity{1}, entt::entity{3}};
     value_type instance{4};
 
@@ -702,7 +719,6 @@ TEST(Storage, TryEmplaceNonDefaultConstructible) {
 
     entt::storage<value_type> pool;
     entt::sparse_set &base = pool;
-
     const std::array entity{entt::entity{1}, entt::entity{3}};
 
     ASSERT_EQ(pool.type(), entt::type_id<value_type>());
@@ -746,7 +762,6 @@ TEST(Storage, TryEmplaceNonCopyConstructible) {
 
     entt::storage<value_type> pool;
     entt::sparse_set &base = pool;
-
     const std::array entity{entt::entity{1}, entt::entity{3}};
 
     ASSERT_EQ(pool.type(), entt::type_id<value_type>());
@@ -785,8 +800,8 @@ TEST(Storage, TryEmplaceNonCopyConstructible) {
 
 TYPED_TEST(Storage, Patch) {
     using value_type = typename TestFixture::type;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const entt::entity entity{2};
 
     auto callback = [](auto &&elem) {
@@ -810,6 +825,7 @@ TYPED_TEST(Storage, Patch) {
 
 ENTT_DEBUG_TYPED_TEST(StorageDeathTest, Patch) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
 
     ASSERT_DEATH(pool.patch(entt::null), "");
@@ -818,8 +834,8 @@ ENTT_DEBUG_TYPED_TEST(StorageDeathTest, Patch) {
 TYPED_TEST(Storage, Insert) {
     using value_type = typename TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const std::array entity{entt::entity{1}, entt::entity{3}};
     typename entt::storage<value_type>::iterator it{};
 
@@ -863,8 +879,8 @@ TYPED_TEST(Storage, Insert) {
 TYPED_TEST(Storage, Erase) {
     using value_type = typename TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const std::array entity{entt::entity{1}, entt::entity{3}, entt::entity{2}};
     const std::array value{value_type{1}, value_type{2}, value_type{4}};
 
@@ -902,9 +918,9 @@ TYPED_TEST(Storage, Erase) {
 
 TYPED_TEST(Storage, CrossErase) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
     entt::sparse_set set;
-
     const std::array entity{entt::entity{1}, entt::entity{3}};
 
     pool.emplace(entity[0u], 1);
@@ -920,8 +936,8 @@ TYPED_TEST(Storage, CrossErase) {
 TYPED_TEST(Storage, Remove) {
     using value_type = typename TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const std::array entity{entt::entity{1}, entt::entity{3}, entt::entity{2}};
     const std::array value{value_type{1}, value_type{2}, value_type{4}};
 
@@ -962,9 +978,9 @@ TYPED_TEST(Storage, Remove) {
 
 TYPED_TEST(Storage, CrossRemove) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
     entt::sparse_set set;
-
     const std::array entity{entt::entity{1}, entt::entity{3}};
 
     pool.emplace(entity[0u], 1);
@@ -980,8 +996,8 @@ TYPED_TEST(Storage, CrossRemove) {
 TYPED_TEST(Storage, Clear) {
     using value_type = typename TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const std::array entity{entt::entity{1}, entt::entity{3}, entt::entity{2}};
 
     pool.insert(entity.begin(), entity.end());
@@ -1005,6 +1021,7 @@ TYPED_TEST(Storage, Clear) {
 TYPED_TEST(Storage, Compact) {
     using value_type = typename TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
+
     entt::storage<value_type> pool;
 
     ASSERT_TRUE(pool.empty());
@@ -1050,6 +1067,7 @@ TYPED_TEST(Storage, Compact) {
 TYPED_TEST(Storage, SwapElements) {
     using value_type = typename TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
+
     entt::storage<value_type> pool;
 
     pool.emplace(entt::entity{1}, 1);
@@ -1167,6 +1185,7 @@ TYPED_TEST(Storage, ConstIterable) {
 
 TYPED_TEST(Storage, IterableIteratorConversion) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
 
     pool.emplace(entt::entity{3}, 1);
@@ -1183,6 +1202,7 @@ TYPED_TEST(Storage, IterableIteratorConversion) {
 
 TYPED_TEST(Storage, IterableAlgorithmCompatibility) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
 
     pool.emplace(entt::entity{3}, 1);
@@ -1289,6 +1309,7 @@ TYPED_TEST(Storage, ConstReverseIterable) {
 
 TYPED_TEST(Storage, ReverseIterableIteratorConversion) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
 
     pool.emplace(entt::entity{3}, 1);
@@ -1305,6 +1326,7 @@ TYPED_TEST(Storage, ReverseIterableIteratorConversion) {
 
 TYPED_TEST(Storage, ReverseIterableAlgorithmCompatibility) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
 
     pool.emplace(entt::entity{3}, 1);
@@ -1317,8 +1339,8 @@ TYPED_TEST(Storage, ReverseIterableAlgorithmCompatibility) {
 
 TYPED_TEST(Storage, SortOrdered) {
     using value_type = typename TestFixture::type;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const std::array entity{entt::entity{8}, entt::entity{16}, entt::entity{2}, entt::entity{1}, entt::entity{4}};
     const std::array value{value_type{8}, value_type{4}, value_type{2}, value_type{1}, value_type{0}};
 
@@ -1331,8 +1353,8 @@ TYPED_TEST(Storage, SortOrdered) {
 
 TYPED_TEST(Storage, SortReverse) {
     using value_type = typename TestFixture::type;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const std::array entity{entt::entity{8}, entt::entity{16}, entt::entity{2}, entt::entity{1}, entt::entity{4}};
     const std::array value{value_type{0}, value_type{1}, value_type{2}, value_type{4}, value_type{8}};
 
@@ -1345,8 +1367,8 @@ TYPED_TEST(Storage, SortReverse) {
 
 TYPED_TEST(Storage, SortUnordered) {
     using value_type = typename TestFixture::type;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const std::array entity{entt::entity{8}, entt::entity{16}, entt::entity{2}, entt::entity{1}, entt::entity{4}};
     const std::array value{value_type{2}, value_type{1}, value_type{0}, value_type{4}, value_type{8}};
 
@@ -1372,8 +1394,8 @@ TYPED_TEST(Storage, SortUnordered) {
 
 TYPED_TEST(Storage, SortN) {
     using value_type = typename TestFixture::type;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const std::array entity{entt::entity{8}, entt::entity{16}, entt::entity{2}, entt::entity{1}, entt::entity{4}};
     const std::array value{value_type{1}, value_type{2}, value_type{0}, value_type{4}, value_type{8}};
 
@@ -1415,9 +1437,9 @@ TYPED_TEST(Storage, SortN) {
 
 TYPED_TEST(Storage, SortAsDisjoint) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> lhs;
     const entt::storage<value_type> rhs;
-
     const std::array entity{entt::entity{1}, entt::entity{2}, entt::entity{4}};
     const std::array value{value_type{0}, value_type{1}, value_type{2}};
 
@@ -1434,9 +1456,9 @@ TYPED_TEST(Storage, SortAsDisjoint) {
 
 TYPED_TEST(Storage, SortAsOverlap) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
-
     const std::array lhs_entity{entt::entity{1}, entt::entity{2}, entt::entity{4}};
     const std::array lhs_value{value_type{0}, value_type{1}, value_type{2}};
 
@@ -1470,9 +1492,9 @@ TYPED_TEST(Storage, SortAsOverlap) {
 
 TYPED_TEST(Storage, SortAsOrdered) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
-
     const std::array lhs_entity{entt::entity{1}, entt::entity{2}, entt::entity{4}, entt::entity{8}, entt::entity{16}};
     const std::array lhs_value{value_type{0}, value_type{1}, value_type{2}, value_type{4}, value_type{8}};
 
@@ -1497,9 +1519,9 @@ TYPED_TEST(Storage, SortAsOrdered) {
 
 TYPED_TEST(Storage, SortAsReverse) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
-
     const std::array lhs_entity{entt::entity{1}, entt::entity{2}, entt::entity{4}, entt::entity{8}, entt::entity{16}};
     const std::array lhs_value{value_type{0}, value_type{1}, value_type{2}, value_type{4}, value_type{8}};
 
@@ -1539,9 +1561,9 @@ TYPED_TEST(Storage, SortAsReverse) {
 
 TYPED_TEST(Storage, SortAsUnordered) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
-
     const std::array lhs_entity{entt::entity{1}, entt::entity{2}, entt::entity{4}, entt::entity{8}, entt::entity{16}};
     const std::array lhs_value{value_type{0}, value_type{1}, value_type{2}, value_type{4}, value_type{8}};
 
@@ -1614,8 +1636,8 @@ ENTT_DEBUG_TEST(StorageDeathTest, NonMovableComponent) {
 TYPED_TEST(Storage, CanModifyDuringIteration) {
     using value_type = typename TestFixture::type;
     using traits_type = entt::component_traits<value_type>;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     auto *ptr = &pool.emplace(entt::entity{0}, 2);
 
     ASSERT_EQ(pool.capacity(), traits_type::page_size);
@@ -1632,6 +1654,7 @@ TYPED_TEST(Storage, CanModifyDuringIteration) {
 
 TYPED_TEST(Storage, ReferencesGuaranteed) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
 
     pool.emplace(entt::entity{0}, 0);
@@ -1710,6 +1733,7 @@ TEST(Storage, ClassLevelNewDelete) {
 
 TYPED_TEST(Storage, CustomAllocator) {
     using value_type = typename TestFixture::type;
+
     const test::throwing_allocator<entt::entity> allocator{};
     entt::basic_storage<value_type, entt::entity, test::throwing_allocator<value_type>> pool{allocator};
 
@@ -1754,6 +1778,7 @@ TYPED_TEST(Storage, CustomAllocator) {
 
 TYPED_TEST(Storage, ThrowingAllocator) {
     using value_type = typename TestFixture::type;
+
     entt::basic_storage<value_type, entt::entity, test::throwing_allocator<value_type>> pool{};
     typename std::decay_t<decltype(pool)>::base_type &base = pool;
 
@@ -1813,7 +1838,6 @@ TYPED_TEST(Storage, ThrowingAllocator) {
 
 TEST(Storage, ThrowingComponent) {
     entt::storage<test::throwing_type> pool;
-
     const std::array entity{entt::entity{4}, entt::entity{1}};
     const std::array value{test::throwing_type{true}, test::throwing_type{false}};
 
@@ -1866,6 +1890,7 @@ TEST(Storage, ThrowingComponent) {
 
 TYPED_TEST(Storage, NoUsesAllocatorConstruction) {
     using value_type = typename TestFixture::type;
+
     test::tracked_memory_resource memory_resource{};
     entt::basic_storage<value_type, entt::entity, std::pmr::polymorphic_allocator<value_type>> pool{&memory_resource};
     const entt::entity entity{2};
@@ -1882,6 +1907,7 @@ TYPED_TEST(Storage, NoUsesAllocatorConstruction) {
 
 TEST(Storage, UsesAllocatorConstruction) {
     using string_type = typename test::tracked_memory_resource::string_type;
+
     test::tracked_memory_resource memory_resource{};
     entt::basic_storage<string_type, entt::entity, std::pmr::polymorphic_allocator<string_type>> pool{&memory_resource};
     const entt::entity entity{2};

test/entt/entity/storage_entity.cpp

@@ -30,8 +30,9 @@ TEST(StorageEntity, Constructors) {
 
 TEST(StorageEntity, Move) {
     entt::storage<entt::entity> pool;
+    const std::array entity{entt::entity{3}, entt::entity{2}};
 
-    pool.emplace(entt::entity{3});
+    pool.emplace(entity[0u]);
 
     static_assert(std::is_move_constructible_v<decltype(pool)>, "Move constructible type required");
     static_assert(std::is_move_assignable_v<decltype(pool)>, "Move assignable type required");
@@ -44,7 +45,7 @@ TEST(StorageEntity, Move) {
     ASSERT_FALSE(other.empty());
 
     ASSERT_EQ(other.type(), entt::type_id<void>());
-    ASSERT_EQ(other.index(entt::entity{3}), 0u);
+    ASSERT_EQ(other.index(entity[0u]), 0u);
 
     entt::storage<entt::entity> extended{std::move(other), std::allocator<entt::entity>{}};
 
@@ -54,7 +55,7 @@ TEST(StorageEntity, Move) {
     ASSERT_FALSE(extended.empty());
 
     ASSERT_EQ(extended.type(), entt::type_id<void>());
-    ASSERT_EQ(extended.index(entt::entity{3}), 0u);
+    ASSERT_EQ(extended.index(entity[0u]), 0u);
 
     pool = std::move(extended);
     test::is_initialized(extended);
@@ -64,10 +65,10 @@ TEST(StorageEntity, Move) {
     ASSERT_TRUE(extended.empty());
 
     ASSERT_EQ(pool.type(), entt::type_id<void>());
-    ASSERT_EQ(pool.index(entt::entity{3}), 0u);
+    ASSERT_EQ(pool.index(entity[0u]), 0u);
 
     other = entt::storage<entt::entity>{};
-    other.emplace(entt::entity{2});
+    other.emplace(entity[1u]);
     other = std::move(pool);
     test::is_initialized(pool);
 
@@ -75,7 +76,7 @@ TEST(StorageEntity, Move) {
     ASSERT_FALSE(other.empty());
 
     ASSERT_EQ(other.type(), entt::type_id<void>());
-    ASSERT_EQ(other.index(entt::entity{3}), 0u);
+    ASSERT_EQ(other.index(entity[0u]), 0u);
 }
 
 TEST(StorageEntity, Swap) {
@@ -108,8 +109,9 @@ TEST(StorageEntity, Swap) {
 
 TEST(StorageEntity, Getters) {
     entt::storage<entt::entity> pool;
+    const entt::entity entity{4};
 
-    pool.emplace(entt::entity{4});
+    pool.emplace(entity);
 
     testing::StaticAssertTypeEq<decltype(pool.get({})), void>();
     testing::StaticAssertTypeEq<decltype(std::as_const(pool).get({})), void>();
@@ -117,21 +119,22 @@ TEST(StorageEntity, Getters) {
     testing::StaticAssertTypeEq<decltype(pool.get_as_tuple({})), std::tuple<>>();
     testing::StaticAssertTypeEq<decltype(std::as_const(pool).get_as_tuple({})), std::tuple<>>();
 
-    ASSERT_NO_THROW(pool.get(entt::entity{4}));
-    ASSERT_NO_THROW(std::as_const(pool).get(entt::entity{4}));
+    ASSERT_NO_THROW(pool.get(entity));
+    ASSERT_NO_THROW(std::as_const(pool).get(entity));
 
-    ASSERT_EQ(pool.get_as_tuple(entt::entity{4}), std::make_tuple());
-    ASSERT_EQ(std::as_const(pool).get_as_tuple(entt::entity{4}), std::make_tuple());
+    ASSERT_EQ(pool.get_as_tuple(entity), std::make_tuple());
+    ASSERT_EQ(std::as_const(pool).get_as_tuple(entity), std::make_tuple());
 }
 
 ENTT_DEBUG_TEST(StorageEntityDeathTest, Getters) {
     entt::storage<entt::entity> pool;
+    const entt::entity entity{4};
 
-    ASSERT_DEATH(pool.get(entt::entity{4}), "");
-    ASSERT_DEATH(std::as_const(pool).get(entt::entity{4}), "");
+    ASSERT_DEATH(pool.get(entity), "");
+    ASSERT_DEATH(std::as_const(pool).get(entity), "");
 
-    ASSERT_DEATH([[maybe_unused]] const auto value = pool.get_as_tuple(entt::entity{4}), "");
-    ASSERT_DEATH([[maybe_unused]] const auto value = std::as_const(pool).get_as_tuple(entt::entity{4}), "");
+    ASSERT_DEATH([[maybe_unused]] const auto value = pool.get_as_tuple(entity), "");
+    ASSERT_DEATH([[maybe_unused]] const auto value = std::as_const(pool).get_as_tuple(entity), "");
 }
 
 TEST(StorageEntity, Emplace) {
@@ -580,7 +583,6 @@ TEST(StorageEntity, ReverseIterableAlgorithmCompatibility) {
 
 TEST(StorageEntity, SortOrdered) {
     entt::storage<entt::entity> pool;
-
     const std::array entity{entt::entity{16}, entt::entity{8}, entt::entity{4}, entt::entity{2}, entt::entity{1}};
 
     pool.push(entity.begin(), entity.end());
@@ -591,7 +593,6 @@ TEST(StorageEntity, SortOrdered) {
 
 TEST(StorageEntity, SortReverse) {
     entt::storage<entt::entity> pool;
-
     const std::array entity{entt::entity{1}, entt::entity{2}, entt::entity{4}, entt::entity{8}, entt::entity{16}};
 
     pool.push(entity.begin(), entity.end());
@@ -602,7 +603,6 @@ TEST(StorageEntity, SortReverse) {
 
 TEST(StorageEntity, SortUnordered) {
     entt::storage<entt::entity> pool;
-
     const std::array entity{entt::entity{4}, entt::entity{2}, entt::entity{1}, entt::entity{8}, entt::entity{16}};
 
     pool.push(entity.begin(), entity.end());
@@ -617,7 +617,6 @@ TEST(StorageEntity, SortUnordered) {
 
 TEST(StorageEntity, SortN) {
     entt::storage<entt::entity> pool;
-
     const std::array entity{entt::entity{2}, entt::entity{4}, entt::entity{1}, entt::entity{8}, entt::entity{16}};
 
     pool.push(entity.begin(), entity.end());
@@ -644,7 +643,6 @@ TEST(StorageEntity, SortN) {
 TEST(StorageEntity, SortAsDisjoint) {
     entt::storage<entt::entity> lhs;
     const entt::storage<entt::entity> rhs;
-
     const std::array entity{entt::entity{1}, entt::entity{2}, entt::entity{4}};
 
     lhs.push(entity.begin(), entity.end());
@@ -659,7 +657,6 @@ TEST(StorageEntity, SortAsDisjoint) {
 TEST(StorageEntity, SortAsOverlap) {
     entt::storage<entt::entity> lhs;
     entt::storage<entt::entity> rhs;
-
     const std::array lhs_entity{entt::entity{1}, entt::entity{2}, entt::entity{4}};
     const std::array rhs_entity{entt::entity{2}};
 
@@ -679,7 +676,6 @@ TEST(StorageEntity, SortAsOverlap) {
 TEST(StorageEntity, SortAsOrdered) {
     entt::storage<entt::entity> lhs;
     entt::storage<entt::entity> rhs;
-
     const std::array lhs_entity{entt::entity{1}, entt::entity{2}, entt::entity{4}, entt::entity{8}, entt::entity{16}};
     const std::array rhs_entity{entt::entity{32}, entt::entity{1}, entt::entity{2}, entt::entity{4}, entt::entity{8}, entt::entity{16}};
 
@@ -697,7 +693,6 @@ TEST(StorageEntity, SortAsOrdered) {
 TEST(StorageEntity, SortAsReverse) {
     entt::storage<entt::entity> lhs;
     entt::storage<entt::entity> rhs;
-
     const std::array lhs_entity{entt::entity{1}, entt::entity{2}, entt::entity{4}, entt::entity{8}, entt::entity{16}};
     const std::array rhs_entity{entt::entity{16}, entt::entity{8}, entt::entity{4}, entt::entity{2}, entt::entity{1}, entt::entity{32}};
 
@@ -720,7 +715,6 @@ TEST(StorageEntity, SortAsReverse) {
 TEST(StorageEntity, SortAsUnordered) {
     entt::storage<entt::entity> lhs;
     entt::storage<entt::entity> rhs;
-
     const std::array lhs_entity{entt::entity{1}, entt::entity{2}, entt::entity{4}, entt::entity{8}, entt::entity{16}};
     const std::array rhs_entity{entt::entity{4}, entt::entity{2}, entt::entity{32}, entt::entity{1}, entt::entity{8}, entt::entity{16}};
 

test/entt/entity/storage_no_instance.cpp

@@ -59,6 +59,7 @@ TYPED_TEST_SUITE(StorageNoInstanceDeathTest, StorageNoInstanceTypes, );
 
 TYPED_TEST(StorageNoInstance, Constructors) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
 
     ASSERT_EQ(pool.policy(), entt::deletion_policy::swap_and_pop);
@@ -74,9 +75,11 @@ TYPED_TEST(StorageNoInstance, Constructors) {
 
 TYPED_TEST(StorageNoInstance, Move) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
+    const std::array entity{entt::entity{3}, entt::entity{2}};
 
-    pool.emplace(entt::entity{3});
+    pool.emplace(entity[0u]);
 
     static_assert(std::is_move_constructible_v<decltype(pool)>, "Move constructible type required");
     static_assert(std::is_move_assignable_v<decltype(pool)>, "Move assignable type required");
@@ -89,7 +92,7 @@ TYPED_TEST(StorageNoInstance, Move) {
     ASSERT_FALSE(other.empty());
 
     ASSERT_EQ(other.type(), entt::type_id<value_type>());
-    ASSERT_EQ(other.index(entt::entity{3}), 0u);
+    ASSERT_EQ(other.index(entity[0u]), 0u);
 
     entt::storage<value_type> extended{std::move(other), std::allocator<value_type>{}};
 
@@ -99,7 +102,7 @@ TYPED_TEST(StorageNoInstance, Move) {
     ASSERT_FALSE(extended.empty());
 
     ASSERT_EQ(extended.type(), entt::type_id<value_type>());
-    ASSERT_EQ(extended.index(entt::entity{3}), 0u);
+    ASSERT_EQ(extended.index(entity[0u]), 0u);
 
     pool = std::move(extended);
     test::is_initialized(extended);
@@ -109,10 +112,10 @@ TYPED_TEST(StorageNoInstance, Move) {
     ASSERT_TRUE(extended.empty());
 
     ASSERT_EQ(pool.type(), entt::type_id<value_type>());
-    ASSERT_EQ(pool.index(entt::entity{3}), 0u);
+    ASSERT_EQ(pool.index(entity[0u]), 0u);
 
     other = entt::storage<value_type>{};
-    other.emplace(entt::entity{2}, 2);
+    other.emplace(entity[1u], 2);
     other = std::move(pool);
     test::is_initialized(pool);
 
@@ -120,11 +123,12 @@ TYPED_TEST(StorageNoInstance, Move) {
     ASSERT_FALSE(other.empty());
 
     ASSERT_EQ(other.type(), entt::type_id<value_type>());
-    ASSERT_EQ(other.index(entt::entity{3}), 0u);
+    ASSERT_EQ(other.index(entity[0u]), 0u);
 }
 
 TYPED_TEST(StorageNoInstance, Swap) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
     entt::storage<value_type> other;
 
@@ -154,9 +158,11 @@ TYPED_TEST(StorageNoInstance, Swap) {
 
 TYPED_TEST(StorageNoInstance, Getters) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
+    const entt::entity entity{4};
 
-    pool.emplace(entt::entity{4}, 3);
+    pool.emplace(entity, 3);
 
     testing::StaticAssertTypeEq<decltype(pool.get({})), void>();
     testing::StaticAssertTypeEq<decltype(std::as_const(pool).get({})), void>();
@@ -164,35 +170,40 @@ TYPED_TEST(StorageNoInstance, Getters) {
     testing::StaticAssertTypeEq<decltype(pool.get_as_tuple({})), std::tuple<>>();
     testing::StaticAssertTypeEq<decltype(std::as_const(pool).get_as_tuple({})), std::tuple<>>();
 
-    ASSERT_NO_THROW(pool.get(entt::entity{4}));
-    ASSERT_NO_THROW(std::as_const(pool).get(entt::entity{4}));
+    ASSERT_NO_THROW(pool.get(entity));
+    ASSERT_NO_THROW(std::as_const(pool).get(entity));
 
-    ASSERT_EQ(pool.get_as_tuple(entt::entity{4}), std::make_tuple());
-    ASSERT_EQ(std::as_const(pool).get_as_tuple(entt::entity{4}), std::make_tuple());
+    ASSERT_EQ(pool.get_as_tuple(entity), std::make_tuple());
+    ASSERT_EQ(std::as_const(pool).get_as_tuple(entity), std::make_tuple());
 }
 
 ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Getters) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
+    const entt::entity entity{4};
 
-    ASSERT_DEATH(pool.get(entt::entity{4}), "");
-    ASSERT_DEATH(std::as_const(pool).get(entt::entity{4}), "");
+    ASSERT_DEATH(pool.get(entity), "");
+    ASSERT_DEATH(std::as_const(pool).get(entity), "");
 
-    ASSERT_DEATH([[maybe_unused]] const auto value = pool.get_as_tuple(entt::entity{4}), "");
-    ASSERT_DEATH([[maybe_unused]] const auto value = std::as_const(pool).get_as_tuple(entt::entity{4}), "");
+    ASSERT_DEATH([[maybe_unused]] const auto value = pool.get_as_tuple(entity), "");
+    ASSERT_DEATH([[maybe_unused]] const auto value = std::as_const(pool).get_as_tuple(entity), "");
 }
 
 TYPED_TEST(StorageNoInstance, Value) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
+    const entt::entity entity{4};
 
-    pool.emplace(entt::entity{4});
+    pool.emplace(entity);
 
     ASSERT_EQ(pool.value(entt::entity{4}), nullptr);
 }
 
 ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Value) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
 
     ASSERT_DEATH([[maybe_unused]] const void *value = pool.value(entt::entity{4}), "");
@@ -200,8 +211,8 @@ ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Value) {
 
 TYPED_TEST(StorageNoInstance, Emplace) {
     using value_type = typename TestFixture::type;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const std::array entity{entt::entity{1}, entt::entity{3}};
 
     testing::StaticAssertTypeEq<decltype(pool.emplace({})), void>();
@@ -212,8 +223,8 @@ TYPED_TEST(StorageNoInstance, Emplace) {
 
 ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Emplace) {
     using value_type = typename TestFixture::type;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const entt::entity entity{4};
 
     testing::StaticAssertTypeEq<decltype(pool.emplace({})), void>();
@@ -226,9 +237,9 @@ ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Emplace) {
 
 TYPED_TEST(StorageNoInstance, TryEmplace) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
     entt::sparse_set &base = pool;
-
     const std::array entity{entt::entity{1}, entt::entity{3}};
 
     ASSERT_NE(this->push_instance(pool, entity[0u]), base.end());
@@ -255,8 +266,8 @@ TYPED_TEST(StorageNoInstance, TryEmplace) {
 
 TYPED_TEST(StorageNoInstance, Patch) {
     using value_type = typename TestFixture::type;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const entt::entity entity{4};
 
     int counter = 0;
@@ -275,6 +286,7 @@ TYPED_TEST(StorageNoInstance, Patch) {
 
 ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Patch) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
 
     ASSERT_DEATH(pool.patch(entt::null), "");
@@ -282,8 +294,8 @@ ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Patch) {
 
 TYPED_TEST(StorageNoInstance, Insert) {
     using value_type = typename TestFixture::type;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const std::array entity{entt::entity{1}, entt::entity{3}};
 
     pool.insert(entity.begin(), entity.end());
@@ -302,8 +314,8 @@ TYPED_TEST(StorageNoInstance, Insert) {
 
 ENTT_DEBUG_TYPED_TEST(StorageNoInstanceDeathTest, Insert) {
     using value_type = typename TestFixture::type;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const std::array entity{entt::entity{1}, entt::entity{3}};
 
     pool.insert(entity.begin(), entity.end());
@@ -400,6 +412,7 @@ TYPED_TEST(StorageNoInstance, ConstIterable) {
 
 TYPED_TEST(StorageNoInstance, IterableIteratorConversion) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
 
     pool.emplace(entt::entity{3});
@@ -416,14 +429,16 @@ TYPED_TEST(StorageNoInstance, IterableIteratorConversion) {
 
 TYPED_TEST(StorageNoInstance, IterableAlgorithmCompatibility) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
+    const entt::entity entity{3};
 
-    pool.emplace(entt::entity{3});
+    pool.emplace(entity);
 
     const auto iterable = pool.each();
-    const auto it = std::find_if(iterable.begin(), iterable.end(), [](auto args) { return std::get<0>(args) == entt::entity{3}; });
+    const auto it = std::find_if(iterable.begin(), iterable.end(), [entity](auto args) { return std::get<0>(args) == entity; });
 
-    ASSERT_EQ(std::get<0>(*it), entt::entity{3});
+    ASSERT_EQ(std::get<0>(*it), entity);
 }
 
 TYPED_TEST(StorageNoInstance, ReverseIterable) {
@@ -514,6 +529,7 @@ TYPED_TEST(StorageNoInstance, ConstReverseIterable) {
 
 TYPED_TEST(StorageNoInstance, ReverseIterableIteratorConversion) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
 
     pool.emplace(entt::entity{3});
@@ -530,20 +546,22 @@ TYPED_TEST(StorageNoInstance, ReverseIterableIteratorConversion) {
 
 TYPED_TEST(StorageNoInstance, ReverseIterableAlgorithmCompatibility) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> pool;
+    const entt::entity entity{3};
 
-    pool.emplace(entt::entity{3});
+    pool.emplace(entity);
 
     const auto iterable = pool.reach();
-    const auto it = std::find_if(iterable.begin(), iterable.end(), [](auto args) { return std::get<0>(args) == entt::entity{3}; });
+    const auto it = std::find_if(iterable.begin(), iterable.end(), [entity](auto args) { return std::get<0>(args) == entity; });
 
-    ASSERT_EQ(std::get<0>(*it), entt::entity{3});
+    ASSERT_EQ(std::get<0>(*it), entity);
 }
 
 TYPED_TEST(StorageNoInstance, SortOrdered) {
     using value_type = typename TestFixture::type;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const std::array entity{entt::entity{16}, entt::entity{8}, entt::entity{4}, entt::entity{2}, entt::entity{1}};
 
     pool.insert(entity.begin(), entity.end());
@@ -554,8 +572,8 @@ TYPED_TEST(StorageNoInstance, SortOrdered) {
 
 TYPED_TEST(StorageNoInstance, SortReverse) {
     using value_type = typename TestFixture::type;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const std::array entity{entt::entity{1}, entt::entity{2}, entt::entity{4}, entt::entity{8}, entt::entity{16}};
 
     pool.insert(entity.begin(), entity.end());
@@ -566,8 +584,8 @@ TYPED_TEST(StorageNoInstance, SortReverse) {
 
 TYPED_TEST(StorageNoInstance, SortUnordered) {
     using value_type = typename TestFixture::type;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const std::array entity{entt::entity{4}, entt::entity{2}, entt::entity{1}, entt::entity{8}, entt::entity{16}};
 
     pool.insert(entity.begin(), entity.end());
@@ -582,8 +600,8 @@ TYPED_TEST(StorageNoInstance, SortUnordered) {
 
 TYPED_TEST(StorageNoInstance, SortN) {
     using value_type = typename TestFixture::type;
-    entt::storage<value_type> pool;
 
+    entt::storage<value_type> pool;
     const std::array entity{entt::entity{2}, entt::entity{4}, entt::entity{1}, entt::entity{8}, entt::entity{16}};
 
     pool.insert(entity.begin(), entity.end());
@@ -609,9 +627,9 @@ TYPED_TEST(StorageNoInstance, SortN) {
 
 TYPED_TEST(StorageNoInstance, SortAsDisjoint) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> lhs;
     const entt::storage<value_type> rhs;
-
     const std::array entity{entt::entity{1}, entt::entity{2}, entt::entity{4}};
 
     lhs.insert(entity.begin(), entity.end());
@@ -625,9 +643,9 @@ TYPED_TEST(StorageNoInstance, SortAsDisjoint) {
 
 TYPED_TEST(StorageNoInstance, SortAsOverlap) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
-
     const std::array lhs_entity{entt::entity{1}, entt::entity{2}, entt::entity{4}};
     const std::array rhs_entity{entt::entity{2}};
 
@@ -646,9 +664,9 @@ TYPED_TEST(StorageNoInstance, SortAsOverlap) {
 
 TYPED_TEST(StorageNoInstance, SortAsOrdered) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
-
     const std::array lhs_entity{entt::entity{1}, entt::entity{2}, entt::entity{4}, entt::entity{8}, entt::entity{16}};
     const std::array rhs_entity{entt::entity{32}, entt::entity{1}, entt::entity{2}, entt::entity{4}, entt::entity{8}, entt::entity{16}};
 
@@ -665,9 +683,9 @@ TYPED_TEST(StorageNoInstance, SortAsOrdered) {
 
 TYPED_TEST(StorageNoInstance, SortAsReverse) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
-
     const std::array lhs_entity{entt::entity{1}, entt::entity{2}, entt::entity{4}, entt::entity{8}, entt::entity{16}};
     const std::array rhs_entity{entt::entity{16}, entt::entity{8}, entt::entity{4}, entt::entity{2}, entt::entity{1}, entt::entity{32}};
 
@@ -689,9 +707,9 @@ TYPED_TEST(StorageNoInstance, SortAsReverse) {
 
 TYPED_TEST(StorageNoInstance, SortAsUnordered) {
     using value_type = typename TestFixture::type;
+
     entt::storage<value_type> lhs;
     entt::storage<value_type> rhs;
-
     const std::array lhs_entity{entt::entity{1}, entt::entity{2}, entt::entity{4}, entt::entity{8}, entt::entity{16}};
     const std::array rhs_entity{entt::entity{4}, entt::entity{2}, entt::entity{32}, entt::entity{1}, entt::entity{8}, entt::entity{16}};