build: review entity tests

test/CMakeLists.txt

@@ -212,11 +212,14 @@ if(ENTT_BUILD_SNAPSHOT)
 
     FetchContent_MakeAvailable(cereal)
 
-    SETUP_BASIC_TEST_DEPRECATED(cereal_snapshot snapshot/snapshot.cpp)
+    SETUP_BASIC_TEST(
+        NAME snapshot
+        SOURCES snapshot/snapshot.cpp
+    )
 
-    target_link_libraries(cereal_snapshot PRIVATE cereal)
-    target_compile_options(cereal_snapshot PRIVATE $<$<NOT:$<STREQUAL:"${CMAKE_CXX_COMPILER_ID}","MSVC">>:-Wno-conversion>)
-    set_target_properties(cereal_snapshot PROPERTIES CXX_CLANG_TIDY "")
+    target_link_libraries(snapshot PRIVATE cereal)
+    target_compile_options(snapshot PRIVATE $<$<NOT:$<STREQUAL:"${CMAKE_CXX_COMPILER_ID}","MSVC">>:-Wno-conversion>)
+    set_target_properties(snapshot PROPERTIES CXX_CLANG_TIDY "")
 endif()
 
 # Test config
@@ -260,24 +263,34 @@ SETUP_BASIC_TEST(
 
 # Test entity
 
-SETUP_BASIC_TEST_DEPRECATED(component entt/entity/component.cpp)
-SETUP_BASIC_TEST_DEPRECATED(entity entt/entity/entity.cpp)
-SETUP_BASIC_TEST_DEPRECATED(group entt/entity/group.cpp)
-SETUP_BASIC_TEST_DEPRECATED(handle entt/entity/handle.cpp)
-SETUP_BASIC_TEST_DEPRECATED(helper entt/entity/helper.cpp)
-SETUP_BASIC_TEST_DEPRECATED(organizer entt/entity/organizer.cpp)
-SETUP_BASIC_TEST_DEPRECATED(reactive_mixin entt/entity/reactive_mixin.cpp)
-SETUP_BASIC_TEST_DEPRECATED(registry entt/entity/registry.cpp)
-SETUP_BASIC_TEST_DEPRECATED(runtime_view entt/entity/runtime_view.cpp)
-SETUP_BASIC_TEST_DEPRECATED(sigh_mixin entt/entity/sigh_mixin.cpp)
-SETUP_BASIC_TEST_DEPRECATED(snapshot entt/entity/snapshot.cpp)
-SETUP_BASIC_TEST_DEPRECATED(sparse_set entt/entity/sparse_set.cpp)
-SETUP_BASIC_TEST_DEPRECATED(storage entt/entity/storage.cpp)
-SETUP_BASIC_TEST_DEPRECATED(storage_entity entt/entity/storage_entity.cpp)
-SETUP_BASIC_TEST_DEPRECATED(storage_no_instance entt/entity/storage_no_instance.cpp)
-SETUP_BASIC_TEST_DEPRECATED(storage_utility entt/entity/storage_utility.cpp)
-SETUP_BASIC_TEST_DEPRECATED(storage_utility_no_mixin entt/entity/storage_utility.cpp ENTT_NO_MIXIN)
-SETUP_BASIC_TEST_DEPRECATED(view entt/entity/view.cpp)
+SETUP_BASIC_TEST(
+    NAME entity
+    SOURCES
+        entt/entity/component.cpp
+        entt/entity/entity.cpp
+        entt/entity/group.cpp
+        entt/entity/handle.cpp
+        entt/entity/helper.cpp
+        entt/entity/organizer.cpp
+        entt/entity/reactive_mixin.cpp
+        entt/entity/registry.cpp
+        entt/entity/runtime_view.cpp
+        entt/entity/sigh_mixin.cpp
+        entt/entity/snapshot.cpp
+        entt/entity/sparse_set.cpp
+        entt/entity/storage.cpp
+        entt/entity/storage_entity.cpp
+        entt/entity/storage_no_instance.cpp
+        entt/entity/storage_utility.cpp
+        entt/entity/view.cpp
+)
+
+SETUP_BASIC_TEST(
+    NAME entity_no_mixin
+    SOURCES
+        entt/entity/storage_utility.cpp
+    DEFS ENTT_NO_MIXIN
+)
 
 # Test graph
 

test/common/entity.h

@@ -1,13 +0,0 @@
-#ifndef ENTT_COMMON_ENTITY_H
-#define ENTT_COMMON_ENTITY_H
-
-#include <cstdint>
-
-namespace test {
-
-enum entity : std::uint32_t {};
-enum other_entity : std::uint32_t {};
-
-} // namespace test
-
-#endif

test/entt/entity/component.cpp

@@ -4,49 +4,53 @@
 #include <entt/entity/component.hpp>
 #include "../../common/boxed_type.h"
 #include "../../common/empty.h"
-#include "../../common/entity.h"
 #include "../../common/non_movable.h"
 
-struct self_contained {
-    static constexpr auto in_place_delete = true;
-    static constexpr auto page_size = 4u;
-};
+struct ComponentBase: testing::Test {
+    enum class my_entity : std::uint32_t {};
+    enum class other_entity : std::uint32_t {};
 
-struct traits_based {};
+    struct self_contained {
+        static constexpr auto in_place_delete = true;
+        static constexpr auto page_size = 4u;
+    };
+
+    struct traits_based {};
+};
 
 template<>
-struct entt::component_traits<traits_based /*, entt::entity */> {
-    using entity_type = entt::entity;
-    using element_type = traits_based;
+struct entt::component_traits<ComponentBase::traits_based, ComponentBase::my_entity> {
+    using entity_type = ComponentBase::my_entity;
+    using element_type = ComponentBase::traits_based;
 
     static constexpr auto in_place_delete = true;
     static constexpr auto page_size = 8u;
 };
 
 template<>
-struct entt::component_traits<traits_based, test::entity> {
-    using entity_type = test::entity;
-    using element_type = traits_based;
+struct entt::component_traits<ComponentBase::traits_based, ComponentBase::other_entity> {
+    using entity_type = ComponentBase::other_entity;
+    using element_type = ComponentBase::traits_based;
 
     static constexpr auto in_place_delete = false;
     static constexpr auto page_size = 16u;
 };
 
 template<typename Entity>
-struct entt::component_traits<traits_based, Entity> {
+struct entt::component_traits<ComponentBase::traits_based, Entity> {
     using entity_type = Entity;
-    using element_type = traits_based;
+    using element_type = ComponentBase::traits_based;
 
     static constexpr auto in_place_delete = true;
     static constexpr auto page_size = 32u;
 };
 
 template<typename Type>
-struct Component: testing::Test {
+struct Component: ComponentBase {
     using entity_type = Type;
 };
 
-using EntityTypes = ::testing::Types<entt::entity, test::entity, test::other_entity>;
+using EntityTypes = ::testing::Types<entt::entity, ComponentBase::my_entity, ComponentBase::other_entity>;
 
 TYPED_TEST_SUITE(Component, EntityTypes, );
 
@@ -79,19 +83,19 @@ TYPED_TEST(Component, NonMovable) {
 }
 
 TYPED_TEST(Component, SelfContained) {
-    using traits_type = entt::component_traits<self_contained, typename TestFixture::entity_type>;
+    using traits_type = entt::component_traits<ComponentBase::self_contained, typename TestFixture::entity_type>;
 
     ASSERT_TRUE(traits_type::in_place_delete);
     ASSERT_EQ(traits_type::page_size, 4u);
 }
 
 TYPED_TEST(Component, TraitsBased) {
-    using traits_type = entt::component_traits<traits_based, typename TestFixture::entity_type>;
+    using traits_type = entt::component_traits<ComponentBase::traits_based, typename TestFixture::entity_type>;
 
-    if constexpr(std::is_same_v<typename traits_type::entity_type, entt::entity>) {
+    if constexpr(std::is_same_v<typename traits_type::entity_type, ComponentBase::my_entity>) {
         ASSERT_TRUE(traits_type::in_place_delete);
         ASSERT_EQ(traits_type::page_size, 8u);
-    } else if constexpr(std::is_same_v<typename traits_type::entity_type, test::entity>) {
+    } else if constexpr(std::is_same_v<typename traits_type::entity_type, ComponentBase::other_entity>) {
         ASSERT_FALSE(traits_type::in_place_delete);
         ASSERT_EQ(traits_type::page_size, 16u);
     } else {

test/entt/entity/entity.cpp

@@ -3,40 +3,44 @@
 #include <gtest/gtest.h>
 #include <entt/config/config.h>
 #include <entt/entity/entity.hpp>
-#include "../../common/entity.h"
-
-struct entity_traits {
-    using value_type = test::entity;
-    using entity_type = std::uint32_t;
-    using version_type = std::uint16_t;
-    static constexpr entity_type entity_mask = 0x3FFFF; // 18b
-    static constexpr entity_type version_mask = 0x0FFF; // 12b
-};
 
-struct other_entity_traits {
-    using value_type = test::other_entity;
-    using entity_type = std::uint32_t;
-    using version_type = std::uint16_t;
-    static constexpr entity_type entity_mask = 0xFFFFFFFF; // 32b
-    static constexpr entity_type version_mask = 0x00;      // 0b
+struct EntityBase: testing::Test {
+    enum my_entity : std::uint32_t {};
+    enum other_entity : std::uint32_t {};
+
+    struct entity_traits {
+        using value_type = my_entity;
+        using entity_type = std::uint32_t;
+        using version_type = std::uint16_t;
+        static constexpr entity_type entity_mask = 0x3FFFF; // 18b
+        static constexpr entity_type version_mask = 0x0FFF; // 12b
+    };
+
+    struct other_entity_traits {
+        using value_type = other_entity;
+        using entity_type = std::uint32_t;
+        using version_type = std::uint16_t;
+        static constexpr entity_type entity_mask = 0xFFFFFFFF; // 32b
+        static constexpr entity_type version_mask = 0x00;      // 0b
+    };
 };
 
 template<>
-struct entt::entt_traits<test::entity>: entt::basic_entt_traits<entity_traits> {
+struct entt::entt_traits<EntityBase::my_entity>: entt::basic_entt_traits<EntityBase::entity_traits> {
     static constexpr std::size_t page_size = ENTT_SPARSE_PAGE;
 };
 
 template<>
-struct entt::entt_traits<test::other_entity>: entt::basic_entt_traits<other_entity_traits> {
+struct entt::entt_traits<EntityBase::other_entity>: entt::basic_entt_traits<EntityBase::other_entity_traits> {
     static constexpr std::size_t page_size = ENTT_SPARSE_PAGE;
 };
 
 template<typename Type>
-struct Entity: testing::Test {
+struct Entity: EntityBase {
     using type = Type;
 };
 
-using EntityTypes = ::testing::Types<entt::entity, test::entity, test::other_entity>;
+using EntityTypes = ::testing::Types<entt::entity, EntityBase::my_entity, EntityBase::other_entity>;
 
 TYPED_TEST_SUITE(Entity, EntityTypes, );
 

test/entt/entity/group.cpp

@@ -15,7 +15,7 @@
 #include "../../common/config.h"
 #include "../../common/empty.h"
 
-TEST(NonOwningGroup, Functionalities) {
+TEST(GroupNonOwning, Functionalities) {
     entt::registry registry;
     auto group = registry.group(entt::get<int, char>);
     auto cgroup = std::as_const(registry).group_if_exists(entt::get<const int, const char>);
@@ -79,7 +79,7 @@ TEST(NonOwningGroup, Functionalities) {
     ASSERT_FALSE(invalid);
 }
 
-TEST(NonOwningGroup, Handle) {
+TEST(GroupNonOwning, Handle) {
     entt::registry registry;
     const auto entity = registry.create();
 
@@ -99,7 +99,7 @@ TEST(NonOwningGroup, Handle) {
     ASSERT_EQ(&handle, &group.handle());
 }
 
-TEST(NonOwningGroup, Invalid) {
+TEST(GroupNonOwning, Invalid) {
     entt::registry registry{};
     auto group = std::as_const(registry).group_if_exists(entt::get<const test::empty, const int>);
 
@@ -123,7 +123,7 @@ TEST(NonOwningGroup, Invalid) {
     ASSERT_EQ(group.back(), entt::entity{entt::null});
 }
 
-TEST(NonOwningGroup, ElementAccess) {
+TEST(GroupNonOwning, ElementAccess) {
     entt::registry registry;
     auto group = registry.group(entt::get<int, char>);
     auto cgroup = std::as_const(registry).group_if_exists(entt::get<const int, const char>);
@@ -142,7 +142,7 @@ TEST(NonOwningGroup, ElementAccess) {
     }
 }
 
-TEST(NonOwningGroup, Contains) {
+TEST(GroupNonOwning, Contains) {
     entt::registry registry;
     auto group = registry.group(entt::get<int, char>);
 
@@ -160,7 +160,7 @@ TEST(NonOwningGroup, Contains) {
     ASSERT_TRUE(group.contains(e1));
 }
 
-TEST(NonOwningGroup, Empty) {
+TEST(GroupNonOwning, Empty) {
     entt::registry registry;
 
     const auto e0 = registry.create();
@@ -176,7 +176,7 @@ TEST(NonOwningGroup, Empty) {
     ASSERT_TRUE(registry.group(entt::get<double, char, int, float>).empty());
 }
 
-TEST(NonOwningGroup, Each) {
+TEST(GroupNonOwning, Each) {
     entt::registry registry;
     std::array entity{registry.create(), registry.create()};
 
@@ -228,7 +228,7 @@ TEST(NonOwningGroup, Each) {
     }
 }
 
-TEST(NonOwningGroup, Sort) {
+TEST(GroupNonOwning, Sort) {
     entt::registry registry;
     auto group = registry.group(entt::get<const int, unsigned int>);
 
@@ -295,7 +295,7 @@ TEST(NonOwningGroup, Sort) {
     ASSERT_FALSE(group.contains(e3));
 }
 
-TEST(NonOwningGroup, SortAsAPool) {
+TEST(GroupNonOwning, SortAsAPool) {
     entt::registry registry;
     auto group = registry.group(entt::get<const int, unsigned int>);
 
@@ -337,7 +337,7 @@ TEST(NonOwningGroup, SortAsAPool) {
     }
 }
 
-TEST(NonOwningGroup, IndexRebuiltOnDestroy) {
+TEST(GroupNonOwning, IndexRebuiltOnDestroy) {
     entt::registry registry;
     auto group = registry.group(entt::get<int, unsigned int>);
 
@@ -371,7 +371,7 @@ TEST(NonOwningGroup, IndexRebuiltOnDestroy) {
     }
 }
 
-TEST(NonOwningGroup, ConstNonConstAndAllInBetween) {
+TEST(GroupNonOwning, ConstNonConstAndAllInBetween) {
     entt::registry registry;
     auto group = registry.group(entt::get<int, test::empty, const char>);
 
@@ -414,7 +414,7 @@ TEST(NonOwningGroup, ConstNonConstAndAllInBetween) {
     }
 }
 
-TEST(NonOwningGroup, Find) {
+TEST(GroupNonOwning, Find) {
     entt::registry registry;
     auto group = registry.group(entt::get<int, const char>);
 
@@ -459,7 +459,7 @@ TEST(NonOwningGroup, Find) {
     ASSERT_EQ(group.find(e4), group.end());
 }
 
-TEST(NonOwningGroup, ExcludedComponents) {
+TEST(GroupNonOwning, ExcludedComponents) {
     entt::registry registry;
 
     const auto e0 = registry.create();
@@ -507,7 +507,7 @@ TEST(NonOwningGroup, ExcludedComponents) {
     }
 }
 
-TEST(NonOwningGroup, EmptyAndNonEmptyTypes) {
+TEST(GroupNonOwning, EmptyAndNonEmptyTypes) {
     entt::registry registry;
     const auto group = registry.group(entt::get<int, test::empty>);
 
@@ -538,7 +538,7 @@ TEST(NonOwningGroup, EmptyAndNonEmptyTypes) {
     ASSERT_EQ(group.size(), 2u);
 }
 
-TEST(NonOwningGroup, TrackEntitiesOnComponentDestruction) {
+TEST(GroupNonOwning, TrackEntitiesOnComponentDestruction) {
     entt::registry registry;
     const auto group = registry.group(entt::get<int>, entt::exclude<char>);
     const auto cgroup = std::as_const(registry).group_if_exists(entt::get<const int>, entt::exclude<char>);
@@ -556,7 +556,7 @@ TEST(NonOwningGroup, TrackEntitiesOnComponentDestruction) {
     ASSERT_FALSE(cgroup.empty());
 }
 
-TEST(NonOwningGroup, EmptyTypes) {
+TEST(GroupNonOwning, EmptyTypes) {
     entt::registry registry;
     const auto entity = registry.create();
 
@@ -603,7 +603,7 @@ TEST(NonOwningGroup, EmptyTypes) {
     ASSERT_EQ(iterable.begin(), iterable.end());
 }
 
-TEST(NonOwningGroup, FrontBack) {
+TEST(GroupNonOwning, FrontBack) {
     entt::registry registry;
     auto group = registry.group<>(entt::get<const int, const char>);
 
@@ -625,7 +625,7 @@ TEST(NonOwningGroup, FrontBack) {
     ASSERT_EQ(group.back(), e0);
 }
 
-TEST(NonOwningGroup, SignalRace) {
+TEST(GroupNonOwning, SignalRace) {
     entt::registry registry;
     registry.on_construct<double>().connect<&entt::registry::emplace_or_replace<int>>();
     const auto group = registry.group(entt::get<int, double>);
@@ -636,7 +636,7 @@ TEST(NonOwningGroup, SignalRace) {
     ASSERT_EQ(group.size(), 1u);
 }
 
-TEST(NonOwningGroup, ExtendedGet) {
+TEST(GroupNonOwning, ExtendedGet) {
     using type = decltype(std::declval<entt::registry>().group(entt::get<int, test::empty, char>).get({}));
 
     ASSERT_EQ(std::tuple_size_v<type>, 2u);
@@ -656,7 +656,7 @@ TEST(NonOwningGroup, ExtendedGet) {
     ASSERT_EQ(std::get<1>(tup), 'c');
 }
 
-TEST(NonOwningGroup, IterableGroupAlgorithmCompatibility) {
+TEST(GroupNonOwning, IterableGroupAlgorithmCompatibility) {
     entt::registry registry;
     const auto entity = registry.create();
 
@@ -670,7 +670,7 @@ TEST(NonOwningGroup, IterableGroupAlgorithmCompatibility) {
     ASSERT_EQ(std::get<0>(*it), entity);
 }
 
-TEST(NonOwningGroup, Storage) {
+TEST(GroupNonOwning, Storage) {
     entt::registry registry;
     const auto entity = registry.create();
     auto group = registry.group(entt::get<int, const char>, entt::exclude<double, const float>);
@@ -743,7 +743,7 @@ TEST(NonOwningGroup, Storage) {
     ASSERT_EQ(group.storage<const float>(), nullptr);
 }
 
-TEST(NonOwningGroup, Overlapping) {
+TEST(GroupNonOwning, Overlapping) {
     entt::registry registry;
 
     auto group = registry.group(entt::get<char>, entt::exclude<double>);
@@ -769,7 +769,7 @@ TEST(NonOwningGroup, Overlapping) {
     ASSERT_TRUE(other.empty());
 }
 
-TEST(OwningGroup, Functionalities) {
+TEST(GroupOwning, Functionalities) {
     entt::registry registry;
     auto group = registry.group<int>(entt::get<char>);
     auto cgroup = std::as_const(registry).group_if_exists<const int>(entt::get<const char>);
@@ -831,7 +831,7 @@ TEST(OwningGroup, Functionalities) {
     ASSERT_FALSE(invalid);
 }
 
-TEST(OwningGroup, Handle) {
+TEST(GroupOwning, Handle) {
     entt::registry registry;
     const auto entity = registry.create();
 
@@ -851,7 +851,7 @@ TEST(OwningGroup, Handle) {
     ASSERT_EQ(&handle, &group.handle());
 }
 
-TEST(OwningGroup, Invalid) {
+TEST(GroupOwning, Invalid) {
     entt::registry registry{};
     auto group = std::as_const(registry).group_if_exists<const int>(entt::get<const test::empty>);
 
@@ -873,7 +873,7 @@ TEST(OwningGroup, Invalid) {
     ASSERT_EQ(group.back(), entt::entity{entt::null});
 }
 
-TEST(OwningGroup, ElementAccess) {
+TEST(GroupOwning, ElementAccess) {
     entt::registry registry;
     auto group = registry.group<int>(entt::get<char>);
     auto cgroup = std::as_const(registry).group_if_exists<const int>(entt::get<const char>);
@@ -892,7 +892,7 @@ TEST(OwningGroup, ElementAccess) {
     }
 }
 
-TEST(OwningGroup, Contains) {
+TEST(GroupOwning, Contains) {
     entt::registry registry;
     auto group = registry.group<int>(entt::get<char>);
 
@@ -910,7 +910,7 @@ TEST(OwningGroup, Contains) {
     ASSERT_TRUE(group.contains(e1));
 }
 
-TEST(OwningGroup, Empty) {
+TEST(GroupOwning, Empty) {
     entt::registry registry;
 
     const auto e0 = registry.create();
@@ -926,7 +926,7 @@ TEST(OwningGroup, Empty) {
     ASSERT_TRUE((registry.group<double, float>(entt::get<char, int>).empty()));
 }
 
-TEST(OwningGroup, Each) {
+TEST(GroupOwning, Each) {
     entt::registry registry;
     std::array entity{registry.create(), registry.create()};
 
@@ -978,7 +978,7 @@ TEST(OwningGroup, Each) {
     }
 }
 
-TEST(OwningGroup, SortOrdered) {
+TEST(GroupOwning, SortOrdered) {
     entt::registry registry;
     auto group = registry.group<test::boxed_int, char>();
 
@@ -1018,7 +1018,7 @@ TEST(OwningGroup, SortOrdered) {
     ASSERT_FALSE(group.contains(entity[4]));
 }
 
-TEST(OwningGroup, SortReverse) {
+TEST(GroupOwning, SortReverse) {
     entt::registry registry;
     auto group = registry.group<test::boxed_int, char>();
 
@@ -1058,7 +1058,7 @@ TEST(OwningGroup, SortReverse) {
     ASSERT_FALSE(group.contains(entity[4]));
 }
 
-TEST(OwningGroup, SortUnordered) {
+TEST(GroupOwning, SortUnordered) {
     entt::registry registry;
     auto group = registry.group<test::boxed_int>(entt::get<char>);
 
@@ -1102,7 +1102,7 @@ TEST(OwningGroup, SortUnordered) {
     ASSERT_FALSE(group.contains(entity[6]));
 }
 
-TEST(OwningGroup, SortWithExclusionList) {
+TEST(GroupOwning, SortWithExclusionList) {
     entt::registry registry;
     auto group = registry.group<test::boxed_int>(entt::get<>, entt::exclude<char>);
 
@@ -1135,7 +1135,7 @@ TEST(OwningGroup, SortWithExclusionList) {
     ASSERT_FALSE(group.contains(entity[2]));
 }
 
-TEST(OwningGroup, IndexRebuiltOnDestroy) {
+TEST(GroupOwning, IndexRebuiltOnDestroy) {
     entt::registry registry;
     auto group = registry.group<int>(entt::get<unsigned int>);
 
@@ -1169,7 +1169,7 @@ TEST(OwningGroup, IndexRebuiltOnDestroy) {
     }
 }
 
-TEST(OwningGroup, ConstNonConstAndAllInBetween) {
+TEST(GroupOwning, ConstNonConstAndAllInBetween) {
     entt::registry registry;
     auto group = registry.group<int, const char>(entt::get<test::empty, double, const float>);
 
@@ -1224,7 +1224,7 @@ TEST(OwningGroup, ConstNonConstAndAllInBetween) {
     }
 }
 
-TEST(OwningGroup, Find) {
+TEST(GroupOwning, Find) {
     entt::registry registry;
     auto group = registry.group<int>(entt::get<const char>);
 
@@ -1269,7 +1269,7 @@ TEST(OwningGroup, Find) {
     ASSERT_EQ(group.find(e4), group.end());
 }
 
-TEST(OwningGroup, ExcludedComponents) {
+TEST(GroupOwning, ExcludedComponents) {
     entt::registry registry;
 
     const auto e0 = registry.create();
@@ -1317,7 +1317,7 @@ TEST(OwningGroup, ExcludedComponents) {
     }
 }
 
-TEST(OwningGroup, EmptyAndNonEmptyTypes) {
+TEST(GroupOwning, EmptyAndNonEmptyTypes) {
     entt::registry registry;
     const auto group = registry.group<int>(entt::get<test::empty>);
 
@@ -1348,7 +1348,7 @@ TEST(OwningGroup, EmptyAndNonEmptyTypes) {
     ASSERT_EQ(group.size(), 2u);
 }
 
-TEST(OwningGroup, TrackEntitiesOnComponentDestruction) {
+TEST(GroupOwning, TrackEntitiesOnComponentDestruction) {
     entt::registry registry;
     const auto group = registry.group<int>(entt::get<>, entt::exclude<char>);
     const auto cgroup = std::as_const(registry).group_if_exists<const int>(entt::get<>, entt::exclude<char>);
@@ -1366,7 +1366,7 @@ TEST(OwningGroup, TrackEntitiesOnComponentDestruction) {
     ASSERT_FALSE(cgroup.empty());
 }
 
-TEST(OwningGroup, EmptyTypes) {
+TEST(GroupOwning, EmptyTypes) {
     entt::registry registry;
     const auto entity = registry.create();
 
@@ -1413,7 +1413,7 @@ TEST(OwningGroup, EmptyTypes) {
     ASSERT_EQ(iterable.begin(), iterable.end());
 }
 
-TEST(OwningGroup, FrontBack) {
+TEST(GroupOwning, FrontBack) {
     entt::registry registry;
     auto group = registry.group<const char>(entt::get<const int>);
 
@@ -1435,7 +1435,7 @@ TEST(OwningGroup, FrontBack) {
     ASSERT_EQ(group.back(), e0);
 }
 
-TEST(OwningGroup, SignalRace) {
+TEST(GroupOwning, SignalRace) {
     entt::registry registry;
     registry.on_construct<double>().connect<&entt::registry::emplace_or_replace<int>>();
     const auto group = registry.group<int>(entt::get<double>);
@@ -1446,7 +1446,7 @@ TEST(OwningGroup, SignalRace) {
     ASSERT_EQ(group.size(), 1u);
 }
 
-TEST(OwningGroup, StableLateInitialization) {
+TEST(GroupOwning, StableLateInitialization) {
     entt::registry registry;
     constexpr auto number_of_entities = 30u;
 
@@ -1460,7 +1460,7 @@ TEST(OwningGroup, StableLateInitialization) {
     ASSERT_EQ((registry.group<int, char>().size()), 5u);
 }
 
-TEST(OwningGroup, PreventEarlyOptOut) {
+TEST(GroupOwning, PreventEarlyOptOut) {
     entt::registry registry;
 
     registry.emplace<int>(registry.create(), 3);
@@ -1477,7 +1477,7 @@ TEST(OwningGroup, PreventEarlyOptOut) {
     });
 }
 
-TEST(OwningGroup, SwapElements) {
+TEST(GroupOwning, SwapElements) {
     entt::registry registry;
     std::array entity{registry.create(), registry.create(), registry.create()};
 
@@ -1496,7 +1496,7 @@ TEST(OwningGroup, SwapElements) {
     ASSERT_EQ(registry.storage<char>().index(entity[0u]), 1u);
 }
 
-TEST(OwningGroup, SwappingValuesIsAllowed) {
+TEST(GroupOwning, SwappingValuesIsAllowed) {
     entt::registry registry;
     const auto group = registry.group<test::boxed_int>(entt::get<test::empty>);
 
@@ -1514,7 +1514,7 @@ TEST(OwningGroup, SwappingValuesIsAllowed) {
     });
 }
 
-TEST(OwningGroup, ExtendedGet) {
+TEST(GroupOwning, ExtendedGet) {
     using type = decltype(std::declval<entt::registry>().group<int, test::empty>(entt::get<char>).get({}));
 
     ASSERT_EQ(std::tuple_size_v<type>, 2u);
@@ -1534,7 +1534,7 @@ TEST(OwningGroup, ExtendedGet) {
     ASSERT_EQ(std::get<1>(tup), 'c');
 }
 
-TEST(OwningGroup, IterableGroupAlgorithmCompatibility) {
+TEST(GroupOwning, IterableGroupAlgorithmCompatibility) {
     entt::registry registry;
     const auto entity = registry.create();
 
@@ -1548,7 +1548,7 @@ TEST(OwningGroup, IterableGroupAlgorithmCompatibility) {
     ASSERT_EQ(std::get<0>(*it), entity);
 }
 
-TEST(OwningGroup, Storage) {
+TEST(GroupOwning, Storage) {
     entt::registry registry;
     const auto entity = registry.create();
     auto group = registry.group<int>(entt::get<const char>, entt::exclude<double, const float>);
@@ -1621,7 +1621,7 @@ TEST(OwningGroup, Storage) {
     ASSERT_EQ(group.storage<const float>(), nullptr);
 }
 
-ENTT_DEBUG_TEST(OwningGroupDeathTest, Overlapping) {
+ENTT_DEBUG_TEST(GroupOwningDeathTest, Overlapping) {
     entt::registry registry;
     registry.group<char>(entt::get<int>, entt::exclude<double>);
 

test/entt/entity/helper.cpp

@@ -11,18 +11,16 @@
 #include <entt/signal/sigh.hpp>
 #include "../../common/pointer_stable.h"
 
-struct clazz {
-    void func(entt::registry &, entt::entity curr) {
-        entt = curr;
-    }
-
-    entt::entity entt{entt::null};
+struct Invoke: testing::Test {
+    struct clazz {
+        void func(entt::registry &, entt::entity curr) {
+            entt = curr;
+        }
+
+        entt::entity entt{entt::null};
+    };
 };
 
-void sigh_callback(int &value) {
-    ++value;
-}
-
 template<typename Type>
 struct ToEntity: testing::Test {
     using type = Type;
@@ -36,6 +34,12 @@ using ToEntityTypes = ::testing::Types<int, test::pointer_stable>;
 TYPED_TEST_SUITE(ToEntity, ToEntityTypes, );
 TYPED_TEST_SUITE(ToEntityDeprecated, ToEntityTypes, );
 
+struct SighHelper: testing::Test {
+    static void sigh_callback(int &value) {
+        ++value;
+    }
+};
+
 TEST(AsView, Functionalities) {
     entt::registry registry;
     const entt::registry cregistry;
@@ -55,7 +59,7 @@ TEST(AsGroup, Functionalities) {
     ([](entt::group<entt::owned_t<const double>, entt::get_t<const char>, entt::exclude_t<const int>>) {})(entt::as_group{cregistry});
 }
 
-TEST(Invoke, Functionalities) {
+TEST_F(Invoke, Functionalities) {
     entt::registry registry;
     const auto entity = registry.create();
 
@@ -121,7 +125,7 @@ TYPED_TEST(ToEntity, Functionalities) {
     ASSERT_EQ(entt::to_entity(storage, storage.get(other)), other);
 }
 
-TEST(SighHelper, Functionalities) {
+TEST_F(SighHelper, Functionalities) {
     using namespace entt::literals;
 
     entt::registry registry{};

test/entt/entity/organizer.cpp

@@ -10,31 +10,33 @@
 #include <entt/entity/registry.hpp>
 #include <entt/entity/view.hpp>
 
-void ro_int_rw_char_double(entt::view<entt::get_t<const int, char>>, double &) {}
-void ro_char_rw_int(entt::group<entt::owned_t<int>, entt::get_t<const char>>) {}
-void ro_char_rw_double(entt::view<entt::get_t<const char>>, double &) {}
-void ro_int_double(entt::view<entt::get_t<const int>>, const double &) {}
-void sync_point(entt::registry &, entt::view<entt::get_t<const int>>) {}
-
-struct clazz {
-    void ro_int_char_double(entt::view<entt::get_t<const int, const char>>, const double &) {}
-    void rw_int(entt::view<entt::get_t<int>>) {}
-    void rw_int_char(entt::view<entt::get_t<int, char>>) {}
-    void rw_int_char_double(entt::view<entt::get_t<int, char>>, double &) {}
-
-    static void ro_int_with_payload(const clazz &, entt::view<entt::get_t<const int>>) {}
-    static void ro_char_with_payload(const clazz &, entt::group<entt::owned_t<const char>>) {}
-    static void ro_int_char_with_payload(clazz &, entt::view<entt::get_t<const int, const char>>) {}
-
-    static void const_registry_first(const entt::registry &, entt::view<entt::get_t<int>>) {}
-    static void const_registry_second(const entt::registry &, entt::view<entt::get_t<double>>) {}
+struct Organizer: testing::Test {
+    static void ro_int_rw_char_double(entt::view<entt::get_t<const int, char>>, double &) {}
+    static void ro_char_rw_int(entt::group<entt::owned_t<int>, entt::get_t<const char>>) {}
+    static void ro_char_rw_double(entt::view<entt::get_t<const char>>, double &) {}
+    static void ro_int_double(entt::view<entt::get_t<const int>>, const double &) {}
+    static void sync_point(entt::registry &, entt::view<entt::get_t<const int>>) {}
+
+    struct clazz {
+        void ro_int_char_double(entt::view<entt::get_t<const int, const char>>, const double &) {}
+        void rw_int(entt::view<entt::get_t<int>>) {}
+        void rw_int_char(entt::view<entt::get_t<int, char>>) {}
+        void rw_int_char_double(entt::view<entt::get_t<int, char>>, double &) {}
+
+        static void ro_int_with_payload(const clazz &, entt::view<entt::get_t<const int>>) {}
+        static void ro_char_with_payload(const clazz &, entt::group<entt::owned_t<const char>>) {}
+        static void ro_int_char_with_payload(clazz &, entt::view<entt::get_t<const int, const char>>) {}
+
+        static void const_registry_first(const entt::registry &, entt::view<entt::get_t<int>>) {}
+        static void const_registry_second(const entt::registry &, entt::view<entt::get_t<double>>) {}
+    };
+
+    static void to_args_integrity(entt::view<entt::get_t<int>> view, std::size_t &value, entt::registry &) {
+        value = view.size();
+    }
 };
 
-void to_args_integrity(entt::view<entt::get_t<int>> view, std::size_t &value, entt::registry &) {
-    value = view.size();
-}
-
-TEST(Organizer, EmplaceFreeFunction) {
+TEST_F(Organizer, EmplaceFreeFunction) {
     entt::organizer organizer;
     entt::registry registry;
 
@@ -101,7 +103,7 @@ TEST(Organizer, EmplaceFreeFunction) {
     ASSERT_EQ(organizer.graph().size(), 0u);
 }
 
-TEST(Organizer, EmplaceMemberFunction) {
+TEST_F(Organizer, EmplaceMemberFunction) {
     entt::organizer organizer;
     entt::registry registry;
     clazz instance;
@@ -167,7 +169,7 @@ TEST(Organizer, EmplaceMemberFunction) {
     ASSERT_EQ(organizer.graph().size(), 0u);
 }
 
-TEST(Organizer, EmplaceFreeFunctionWithPayload) {
+TEST_F(Organizer, EmplaceFreeFunctionWithPayload) {
     entt::organizer organizer;
     entt::registry registry;
     clazz instance;
@@ -240,7 +242,7 @@ TEST(Organizer, EmplaceFreeFunctionWithPayload) {
     ASSERT_EQ(organizer.graph().size(), 0u);
 }
 
-TEST(Organizer, EmplaceDirectFunction) {
+TEST_F(Organizer, EmplaceDirectFunction) {
     entt::organizer organizer;
     entt::registry registry;
     clazz instance;
@@ -322,7 +324,7 @@ TEST(Organizer, EmplaceDirectFunction) {
     ASSERT_EQ(organizer.graph().size(), 0u);
 }
 
-TEST(Organizer, SyncPoint) {
+TEST_F(Organizer, SyncPoint) {
     entt::organizer organizer;
     entt::registry registry;
     clazz instance;
@@ -385,7 +387,7 @@ TEST(Organizer, SyncPoint) {
     }
 }
 
-TEST(Organizer, ConstRegistry) {
+TEST_F(Organizer, ConstRegistry) {
     entt::organizer organizer;
     entt::registry registry;
 
@@ -414,7 +416,7 @@ TEST(Organizer, ConstRegistry) {
     }
 }
 
-TEST(Organizer, Override) {
+TEST_F(Organizer, Override) {
     entt::organizer organizer;
 
     organizer.emplace<&ro_int_rw_char_double, const char, const double>("t1");
@@ -446,7 +448,7 @@ TEST(Organizer, Override) {
     ASSERT_EQ(graph[1u].out_edges()[0u], 2u);
 }
 
-TEST(Organizer, Prepare) {
+TEST_F(Organizer, Prepare) {
     entt::organizer organizer;
     entt::registry registry;
     clazz instance;
@@ -477,7 +479,7 @@ TEST(Organizer, Prepare) {
     ASSERT_EQ(std::as_const(registry).storage<double>(), nullptr);
 }
 
-TEST(Organizer, Dependencies) {
+TEST_F(Organizer, Dependencies) {
     entt::organizer organizer;
     clazz instance;
 
@@ -524,7 +526,7 @@ TEST(Organizer, Dependencies) {
     ASSERT_EQ(*buffer[0u], entt::type_id<char>());
 }
 
-TEST(Organizer, ToArgsIntegrity) {
+TEST_F(Organizer, ToArgsIntegrity) {
     entt::organizer organizer;
     entt::registry registry;
 

test/entt/entity/reactive_mixin.cpp

@@ -13,31 +13,33 @@
 #include <entt/signal/sigh.hpp>
 #include "../../common/config.h"
 #include "../../common/empty.h"
-#include "../../common/entity.h"
 #include "../../common/linter.hpp"
 #include "../../common/registry.h"
 #include "../../common/throwing_allocator.hpp"
 
-template<typename Type, std::size_t Value>
-void emplace(Type &storage, const typename Type::registry_type &, const typename Type::entity_type entity) {
-    if((entity == typename Type::entity_type{Value}) && !storage.contains(entity)) {
-        storage.emplace(entity);
-    }
-}
+struct ReactiveMixinBase: testing::Test {
+    enum class my_entity : std::uint32_t {};
+};
 
 template<typename Type>
-void remove(Type &storage, const typename Type::registry_type &, const typename Type::entity_type entity) {
-    storage.remove(entity);
-}
+struct ReactiveMixin: ReactiveMixinBase {
+    using type = Type;
 
-template<typename Type>
-struct entt::storage_type<Type, test::entity, std::allocator<Type>, std::enable_if_t<!std::is_same_v<Type, test::entity>>> {
-    using type = entt::basic_sigh_mixin<entt::basic_storage<Type, test::entity>, test::custom_registry<test::entity>>;
+    template<std::size_t Value>
+    static void emplace(entt::reactive_mixin<entt::storage<Type>> &storage, const typename entt::registry &, const entt::entity entity) {
+        if((entity == entt::entity{Value}) && !storage.contains(entity)) {
+            storage.emplace(entity);
+        }
+    }
+
+    static void remove(entt::reactive_mixin<entt::storage<Type>> &storage, const typename entt::registry &, const entt::entity entity) {
+        storage.remove(entity);
+    }
 };
 
 template<typename Type>
-struct ReactiveMixin: testing::Test {
-    using type = Type;
+struct entt::storage_type<Type, ReactiveMixinBase::my_entity, std::allocator<Type>, std::enable_if_t<!std::is_same_v<Type, ReactiveMixinBase::my_entity>>> {
+    using type = entt::basic_sigh_mixin<entt::basic_storage<Type, ReactiveMixinBase::my_entity>, test::custom_registry<ReactiveMixinBase::my_entity>>;
 };
 
 template<typename Type>
@@ -206,7 +208,7 @@ TYPED_TEST(ReactiveMixin, OnConstructCallback) {
     const std::array entity{registry.create(), registry.create(entt::entity{3})};
 
     pool.bind(registry);
-    pool.template on_construct<test::empty, &emplace<entt::reactive_mixin<entt::storage<value_type>>, 3u>>();
+    pool.template on_construct<test::empty, &TestFixture::template emplace<3u>>();
     registry.emplace<test::empty>(entity[0u]);
 
     ASSERT_TRUE(pool.empty());
@@ -279,7 +281,7 @@ TYPED_TEST(ReactiveMixin, OnUpdateCallback) {
     const std::array entity{registry.create(), registry.create(entt::entity{3})};
 
     pool.bind(registry);
-    pool.template on_update<test::empty, &emplace<entt::reactive_mixin<entt::storage<value_type>>, 3u>>();
+    pool.template on_update<test::empty, &TestFixture::template emplace<3u>>();
     registry.insert<test::empty>(entity.begin(), entity.end());
     registry.patch<test::empty>(entity[0u]);
 
@@ -357,7 +359,7 @@ TYPED_TEST(ReactiveMixin, OnDestroyCallback) {
     const std::array entity{registry.create(), registry.create(entt::entity{3})};
 
     pool.bind(registry);
-    pool.template on_destroy<test::empty, &emplace<entt::reactive_mixin<entt::storage<value_type>>, 3u>>();
+    pool.template on_destroy<test::empty, &TestFixture::template emplace<3u>>();
     registry.insert<test::empty>(entity.begin(), entity.end());
     registry.erase<test::empty>(entity[0u]);
 
@@ -393,7 +395,7 @@ TYPED_TEST(ReactiveMixin, EntityLifecycle) {
     const entt::entity entity{registry.create()};
 
     pool.bind(registry);
-    pool.template on_construct<test::empty>().template on_destroy<entt::entity, &remove<decltype(pool)>>();
+    pool.template on_construct<test::empty>().template on_destroy<entt::entity, &TestFixture::remove>();
 
     ASSERT_FALSE(pool.contains(entity));
 
@@ -455,10 +457,11 @@ ENTT_DEBUG_TYPED_TEST(ReactiveMixinDeathTest, Registry) {
 
 TYPED_TEST(ReactiveMixin, CustomRegistry) {
     using value_type = TestFixture::type;
-    using registry_type = test::custom_registry<test::entity>;
+    using entity_type = ReactiveMixinBase::my_entity;
+    using registry_type = test::custom_registry<entity_type>;
 
     registry_type registry;
-    entt::basic_reactive_mixin<entt::basic_storage<value_type, test::entity>, registry_type> pool;
+    entt::basic_reactive_mixin<entt::basic_storage<value_type, entity_type>, registry_type> pool;
     const std::array entity{registry.create(), registry.create()};
 
     ASSERT_FALSE(pool);
@@ -477,8 +480,9 @@ TYPED_TEST(ReactiveMixin, CustomRegistry) {
 
 ENTT_DEBUG_TYPED_TEST(ReactiveMixinDeathTest, CustomRegistry) {
     using value_type = TestFixture::type;
-    using registry_type = test::custom_registry<test::entity>;
-    entt::basic_reactive_mixin<entt::basic_storage<value_type, test::entity>, registry_type> pool;
+    using entity_type = ReactiveMixinBase::my_entity;
+    using registry_type = test::custom_registry<entity_type>;
+    entt::basic_reactive_mixin<entt::basic_storage<value_type, entity_type>, registry_type> pool;
     ASSERT_DEATH([[maybe_unused]] auto &registry = pool.registry(), "");
     ASSERT_DEATH([[maybe_unused]] const auto &registry = std::as_const(pool).registry(), "");
 }

test/entt/entity/registry.cpp

@@ -22,70 +22,75 @@
 #include "../../common/aggregate.h"
 #include "../../common/config.h"
 #include "../../common/empty.h"
-#include "../../common/entity.h"
 #include "../../common/mixin.hpp"
 #include "../../common/non_default_constructible.h"
 #include "../../common/pointer_stable.h"
 
-struct no_eto_type {
-    static constexpr std::size_t page_size = 1024u;
-};
+struct Registry: testing::Test {
+    enum class my_entity : std::uint32_t {};
 
-bool operator==(const no_eto_type &lhs, const no_eto_type &rhs) {
-    return &lhs == &rhs;
-}
+    struct no_eto_type {
+        static constexpr std::size_t page_size = 1024u;
+    };
 
-struct listener {
-    template<typename Type>
-    static void sort(entt::registry &registry) {
-        registry.sort<Type>([](auto lhs, auto rhs) { return lhs < rhs; });
-    }
+    struct listener {
+        template<typename Type>
+        static void sort(entt::registry &registry) {
+            registry.sort<Type>([](auto lhs, auto rhs) { return lhs < rhs; });
+        }
 
-    void incr(const entt::registry &, entt::entity entity) {
-        last = entity;
-        ++counter;
-    }
+        void incr(const entt::registry &, entt::entity entity) {
+            last = entity;
+            ++counter;
+        }
 
-    void decr(const entt::registry &, entt::entity entity) {
-        last = entity;
-        --counter;
-    }
+        void decr(const entt::registry &, entt::entity entity) {
+            last = entity;
+            --counter;
+        }
 
-    entt::entity last{entt::null};
-    int counter{0};
-};
+        entt::entity last{entt::null};
+        int counter{0};
+    };
 
-struct owner {
-    void receive(const entt::registry &ref) {
-        parent = &ref;
-    }
+    struct owner {
+        void receive(const entt::registry &ref) {
+            parent = &ref;
+        }
 
-    const entt::registry *parent{nullptr};
-};
+        const entt::registry *parent{nullptr};
+    };
 
-struct destruction_order {
-    using ctx_check_type = int;
+    struct destruction_order {
+        using ctx_check_type = int;
 
-    destruction_order(const entt::registry &ref, bool &ctx)
-        : registry{&ref},
-          ctx_check{&ctx} {
-        *ctx_check = (registry->ctx().find<ctx_check_type>() != nullptr);
-    }
+        destruction_order(const entt::registry &ref, bool &ctx)
+            : registry{&ref},
+              ctx_check{&ctx} {
+            *ctx_check = (registry->ctx().find<ctx_check_type>() != nullptr);
+        }
 
-    destruction_order(const destruction_order &) = delete;
-    destruction_order &operator=(const destruction_order &) = delete;
+        destruction_order(const destruction_order &) = delete;
+        destruction_order &operator=(const destruction_order &) = delete;
 
-    ~destruction_order() {
-        *ctx_check = *ctx_check && (registry->ctx().find<ctx_check_type>() != nullptr);
-    }
+        ~destruction_order() {
+            *ctx_check = *ctx_check && (registry->ctx().find<ctx_check_type>() != nullptr);
+        }
 
-private:
-    const entt::registry *registry;
-    bool *ctx_check{};
+    private:
+        const entt::registry *registry;
+        bool *ctx_check{};
+    };
 };
 
+using RegistryDeathTest = Registry;
+
+bool operator==(const Registry::no_eto_type &lhs, const Registry::no_eto_type &rhs) {
+    return &lhs == &rhs;
+}
+
 struct entity_traits {
-    using value_type = test::entity;
+    using value_type = Registry::my_entity;
     using entity_type = uint32_t;
     using version_type = uint16_t;
     static constexpr entity_type entity_mask = 0xFF;
@@ -93,11 +98,11 @@ struct entity_traits {
 };
 
 template<>
-struct entt::entt_traits<test::entity>: entt::basic_entt_traits<entity_traits> {
+struct entt::entt_traits<Registry::my_entity>: entt::basic_entt_traits<entity_traits> {
     static constexpr auto page_size = ENTT_SPARSE_PAGE;
 };
 
-TEST(Registry, Functionalities) {
+TEST_F(Registry, Functionalities) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::registry registry{};
@@ -248,7 +253,7 @@ TEST(Registry, Functionalities) {
     ASSERT_TRUE(registry.storage<int>().empty());
 }
 
-TEST(Registry, Constructors) {
+TEST_F(Registry, Constructors) {
     entt::registry registry{};
     entt::registry other{64u};
 
@@ -261,7 +266,7 @@ TEST(Registry, Constructors) {
     ASSERT_EQ(other.storage().begin(), other.storage().end());
 }
 
-TEST(Registry, Move) {
+TEST_F(Registry, Move) {
     entt::registry registry{};
     const auto entity = registry.create();
     owner test{};
@@ -290,7 +295,7 @@ TEST(Registry, Move) {
     ASSERT_EQ(test.parent, &registry);
 }
 
-TEST(Registry, Swap) {
+TEST_F(Registry, Swap) {
     entt::registry registry{};
     const auto entity = registry.create();
     owner test{};
@@ -322,7 +327,7 @@ TEST(Registry, Swap) {
     ASSERT_EQ(test.parent, &registry);
 }
 
-TEST(Registry, StorageIterable) {
+TEST_F(Registry, StorageIterable) {
     using namespace entt::literals;
 
     entt::registry registry{};
@@ -341,7 +346,7 @@ TEST(Registry, StorageIterable) {
     }
 }
 
-TEST(Registry, ConstStorageIterable) {
+TEST_F(Registry, ConstStorageIterable) {
     using namespace entt::literals;
 
     entt::registry registry{};
@@ -360,7 +365,7 @@ TEST(Registry, ConstStorageIterable) {
     }
 }
 
-TEST(Registry, RegistryStorageIterator) {
+TEST_F(Registry, RegistryStorageIterator) {
     entt::registry registry{};
     const auto entity = registry.create();
     registry.emplace<int>(entity);
@@ -407,7 +412,7 @@ TEST(Registry, RegistryStorageIterator) {
     ASSERT_TRUE(begin[0u].second.contains(entity));
 }
 
-TEST(Registry, RegistryConstStorageIterator) {
+TEST_F(Registry, RegistryConstStorageIterator) {
     entt::registry registry{};
     const auto entity = registry.create();
     registry.emplace<int>(entity);
@@ -454,7 +459,7 @@ TEST(Registry, RegistryConstStorageIterator) {
     ASSERT_TRUE(begin[0u].second.contains(entity));
 }
 
-TEST(Registry, RegistryStorageIteratorConversion) {
+TEST_F(Registry, RegistryStorageIteratorConversion) {
     entt::registry registry{};
     registry.storage<int>();
 
@@ -482,7 +487,7 @@ TEST(Registry, RegistryStorageIteratorConversion) {
     ASSERT_NE(++cit, it);
 }
 
-TEST(Registry, Storage) {
+TEST_F(Registry, Storage) {
     using namespace entt::literals;
 
     entt::registry registry{};
@@ -528,7 +533,7 @@ TEST(Registry, Storage) {
     ASSERT_FALSE(registry.any_of<test::empty>(entity));
 }
 
-ENTT_DEBUG_TEST(RegistryDeathTest, Storage) {
+ENTT_DEBUG_TEST_F(RegistryDeathTest, Storage) {
     using namespace entt::literals;
 
     entt::registry registry{};
@@ -541,7 +546,7 @@ ENTT_DEBUG_TEST(RegistryDeathTest, Storage) {
     ASSERT_DEATH([[maybe_unused]] const auto *storage = std::as_const(registry).storage<entt::entity>("other"_hs), "");
 }
 
-TEST(Registry, StorageReset) {
+TEST_F(Registry, StorageReset) {
     using namespace entt::literals;
 
     entt::registry registry{};
@@ -564,7 +569,7 @@ TEST(Registry, StorageReset) {
     ASSERT_EQ(registry.storage("other"_hs), nullptr);
 }
 
-ENTT_DEBUG_TEST(RegistryDeathTest, StorageReset) {
+ENTT_DEBUG_TEST_F(RegistryDeathTest, StorageReset) {
     entt::registry registry{};
     const entt::entity entity = registry.create();
 
@@ -573,7 +578,7 @@ ENTT_DEBUG_TEST(RegistryDeathTest, StorageReset) {
     ASSERT_TRUE(registry.valid(entity));
 }
 
-TEST(Registry, Identifiers) {
+TEST_F(Registry, Identifiers) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::registry registry{};
@@ -596,7 +601,7 @@ TEST(Registry, Identifiers) {
     ASSERT_EQ(registry.current(invalid), traits_type::to_version(entt::tombstone));
 }
 
-TEST(Registry, MoreOnIdentifiers) {
+TEST_F(Registry, MoreOnIdentifiers) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::registry registry{};
@@ -617,7 +622,7 @@ TEST(Registry, MoreOnIdentifiers) {
     ASSERT_EQ(registry.current(entity[1]), traits_type::to_version(entity[1]) + 1u);
 }
 
-TEST(Registry, VersionOverflow) {
+TEST_F(Registry, VersionOverflow) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::registry registry{};
@@ -635,7 +640,7 @@ TEST(Registry, VersionOverflow) {
     ASSERT_EQ(registry.current(entity), traits_type::version_type{});
 }
 
-TEST(Registry, NullEntity) {
+TEST_F(Registry, NullEntity) {
     entt::registry registry{};
     const entt::entity entity = entt::null;
 
@@ -643,7 +648,7 @@ TEST(Registry, NullEntity) {
     ASSERT_NE(registry.create(entity), entity);
 }
 
-TEST(Registry, TombstoneVersion) {
+TEST_F(Registry, TombstoneVersion) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::registry registry{};
@@ -659,7 +664,7 @@ TEST(Registry, TombstoneVersion) {
     ASSERT_NE(registry.create(required), required);
 }
 
-TEST(Registry, CreateManyEntitiesAtOnce) {
+TEST_F(Registry, CreateManyEntitiesAtOnce) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::registry registry{};
@@ -686,7 +691,7 @@ TEST(Registry, CreateManyEntitiesAtOnce) {
     ASSERT_EQ(traits_type::to_version(entity[2]), 0u);
 }
 
-TEST(Registry, CreateManyEntitiesAtOnceWithListener) {
+TEST_F(Registry, CreateManyEntitiesAtOnceWithListener) {
     entt::registry registry{};
     std::array<entt::entity, 3u> entity{};
     listener listener;
@@ -711,7 +716,7 @@ TEST(Registry, CreateManyEntitiesAtOnceWithListener) {
     ASSERT_EQ(listener.counter, 6);
 }
 
-TEST(Registry, CreateWithHint) {
+TEST_F(Registry, CreateWithHint) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::registry registry{};
@@ -745,7 +750,7 @@ TEST(Registry, CreateWithHint) {
     ASSERT_EQ(traits_type::to_version(e0), 0u);
 }
 
-TEST(Registry, CreateClearCycle) {
+TEST_F(Registry, CreateClearCycle) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::registry registry{};
@@ -789,7 +794,7 @@ TEST(Registry, CreateClearCycle) {
     ASSERT_EQ(registry.current(pre), registry.current(post));
 }
 
-TEST(Registry, CreateDestroyReleaseCornerCase) {
+TEST_F(Registry, CreateDestroyReleaseCornerCase) {
     entt::registry registry{};
 
     const auto e0 = registry.create();
@@ -804,15 +809,15 @@ TEST(Registry, CreateDestroyReleaseCornerCase) {
     ASSERT_EQ(registry.current(e1), 1u);
 }
 
-ENTT_DEBUG_TEST(RegistryDeathTest, CreateTooManyEntities) {
-    entt::basic_registry<test::entity> registry{};
-    std::vector<test::entity> entity(entt::entt_traits<test::entity>::to_entity(entt::null));
+ENTT_DEBUG_TEST_F(RegistryDeathTest, CreateTooManyEntities) {
+    entt::basic_registry<Registry::my_entity> registry{};
+    std::vector<Registry::my_entity> entity(entt::entt_traits<Registry::my_entity>::to_entity(entt::null));
     registry.create(entity.begin(), entity.end());
 
     ASSERT_DEATH([[maybe_unused]] const auto entt = registry.create(), "");
 }
 
-TEST(Registry, DestroyVersion) {
+TEST_F(Registry, DestroyVersion) {
     entt::registry registry{};
 
     const auto e0 = registry.create();
@@ -828,7 +833,7 @@ TEST(Registry, DestroyVersion) {
     ASSERT_EQ(registry.current(e1), 3u);
 }
 
-ENTT_DEBUG_TEST(RegistryDeathTest, DestroyVersion) {
+ENTT_DEBUG_TEST_F(RegistryDeathTest, DestroyVersion) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -838,7 +843,7 @@ ENTT_DEBUG_TEST(RegistryDeathTest, DestroyVersion) {
     ASSERT_DEATH(registry.destroy(entity, 3), "");
 }
 
-TEST(Registry, DestroyRange) {
+TEST_F(Registry, DestroyRange) {
     entt::registry registry{};
     const auto iview = registry.view<int>();
     const auto icview = registry.view<int, char>();
@@ -914,7 +919,7 @@ TEST(Registry, DestroyRange) {
     ASSERT_EQ(registry.storage<int>().size(), 0u);
 }
 
-TEST(Registry, StableDestroy) {
+TEST_F(Registry, StableDestroy) {
     entt::registry registry{};
     const auto iview = registry.view<int>();
     const auto icview = registry.view<int, test::pointer_stable>();
@@ -956,7 +961,7 @@ TEST(Registry, StableDestroy) {
     ASSERT_EQ(registry.storage<double>().size(), 0u);
 }
 
-TEST(Registry, Emplace) {
+TEST_F(Registry, Emplace) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -969,7 +974,7 @@ TEST(Registry, Emplace) {
     ASSERT_EQ(ref, 4);
 }
 
-TEST(Registry, EmplaceEmpty) {
+TEST_F(Registry, EmplaceEmpty) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -980,7 +985,7 @@ TEST(Registry, EmplaceEmpty) {
     ASSERT_TRUE(registry.all_of<test::empty>(entity));
 }
 
-TEST(Registry, EmplaceAggregate) {
+TEST_F(Registry, EmplaceAggregate) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -993,7 +998,7 @@ TEST(Registry, EmplaceAggregate) {
     ASSERT_EQ(ref.value, 4);
 }
 
-TEST(Registry, EmplaceTypesFromStandardTemplateLibrary) {
+TEST_F(Registry, EmplaceTypesFromStandardTemplateLibrary) {
     // see #37 - the test shouldn't crash, that's all
     entt::registry registry{};
     const auto entity = registry.create();
@@ -1001,26 +1006,26 @@ TEST(Registry, EmplaceTypesFromStandardTemplateLibrary) {
     registry.destroy(entity);
 }
 
-TEST(Registry, EmplaceWithComponents) {
+TEST_F(Registry, EmplaceWithComponents) {
     // it should compile, that's all
     entt::registry registry{};
     const auto value = 0;
     registry.emplace<int>(registry.create(), value);
 }
 
-TEST(Registry, EmplaceMoveOnlyComponent) {
+TEST_F(Registry, EmplaceMoveOnlyComponent) {
     entt::registry registry{};
     // the purpose is to ensure that move only types are always accepted
     registry.emplace<std::unique_ptr<int>>(registry.create());
 }
 
-TEST(Registry, EmplaceNonDefaultConstructibleComponent) {
+TEST_F(Registry, EmplaceNonDefaultConstructibleComponent) {
     entt::registry registry{};
     // the purpose is to ensure that non default constructible type are always accepted
     registry.emplace<test::non_default_constructible>(registry.create(), 1);
 }
 
-TEST(Registry, StableEmplace) {
+TEST_F(Registry, StableEmplace) {
     entt::registry registry{};
     registry.on_construct<int>().connect<&listener::sort<int>>();
     registry.emplace<int>(registry.create(), 0);
@@ -1028,7 +1033,7 @@ TEST(Registry, StableEmplace) {
     ASSERT_EQ(registry.emplace<int>(registry.create(), 1), 1);
 }
 
-ENTT_DEBUG_TEST(RegistryDeathTest, Emplace) {
+ENTT_DEBUG_TEST_F(RegistryDeathTest, Emplace) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -1037,7 +1042,7 @@ ENTT_DEBUG_TEST(RegistryDeathTest, Emplace) {
     ASSERT_DEATH(registry.emplace<int>(entity), "");
 }
 
-TEST(Registry, Insert) {
+TEST_F(Registry, Insert) {
     entt::registry registry{};
     std::array<entt::entity, 3u> entity{};
 
@@ -1074,7 +1079,7 @@ TEST(Registry, Insert) {
     ASSERT_EQ(registry.get<float>(entity[2u]), 2.f);
 }
 
-ENTT_DEBUG_TEST(RegistryDeathTest, Insert) {
+ENTT_DEBUG_TEST_F(RegistryDeathTest, Insert) {
     entt::registry registry{};
     const std::array entity{registry.create()};
     const std::array value{0};
@@ -1085,7 +1090,7 @@ ENTT_DEBUG_TEST(RegistryDeathTest, Insert) {
     ASSERT_DEATH(registry.insert<int>(entity.begin(), entity.end(), value.begin()), "");
 }
 
-TEST(Registry, EmplaceOrReplace) {
+TEST_F(Registry, EmplaceOrReplace) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -1102,7 +1107,7 @@ TEST(Registry, EmplaceOrReplace) {
     ASSERT_EQ(ref, 0);
 }
 
-TEST(Registry, EmplaceOrReplaceEmpty) {
+TEST_F(Registry, EmplaceOrReplaceEmpty) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -1117,7 +1122,7 @@ TEST(Registry, EmplaceOrReplaceEmpty) {
     ASSERT_EQ(registry.storage<test::empty>().size(), 1u);
 }
 
-TEST(Registry, EmplaceOrReplaceAggregate) {
+TEST_F(Registry, EmplaceOrReplaceAggregate) {
     entt::registry registry{};
     const auto entity = registry.create();
     auto &instance = registry.emplace_or_replace<test::aggregate>(entity, 1);
@@ -1125,7 +1130,7 @@ TEST(Registry, EmplaceOrReplaceAggregate) {
     ASSERT_EQ(instance.value, 1);
 }
 
-ENTT_DEBUG_TEST(RegistryDeathTest, EmplaceOrReplace) {
+ENTT_DEBUG_TEST_F(RegistryDeathTest, EmplaceOrReplace) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -1134,7 +1139,7 @@ ENTT_DEBUG_TEST(RegistryDeathTest, EmplaceOrReplace) {
     ASSERT_DEATH(registry.emplace_or_replace<int>(entity), "");
 }
 
-TEST(Registry, Patch) {
+TEST_F(Registry, Patch) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -1151,7 +1156,7 @@ TEST(Registry, Patch) {
     ASSERT_EQ(registry.get<int>(entity), 1);
 }
 
-TEST(Registry, Replace) {
+TEST_F(Registry, Replace) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -1168,7 +1173,7 @@ TEST(Registry, Replace) {
     ASSERT_EQ(registry.get<int>(entity), 1);
 }
 
-TEST(Registry, ReplaceAggregate) {
+TEST_F(Registry, ReplaceAggregate) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -1178,7 +1183,7 @@ TEST(Registry, ReplaceAggregate) {
     ASSERT_EQ(instance.value, 1);
 }
 
-TEST(Registry, Remove) {
+TEST_F(Registry, Remove) {
     entt::registry registry{};
     const auto iview = registry.view<int>();
     const auto icview = registry.view<int, char>();
@@ -1253,7 +1258,7 @@ TEST(Registry, Remove) {
     ASSERT_TRUE(registry.orphan(entity[2u]));
 }
 
-TEST(Registry, StableRemove) {
+TEST_F(Registry, StableRemove) {
     entt::registry registry{};
     const auto iview = registry.view<int>();
     const auto icview = registry.view<int, test::pointer_stable>();
@@ -1299,7 +1304,7 @@ TEST(Registry, StableRemove) {
     ASSERT_EQ(registry.storage<double>().size(), 1u);
 }
 
-TEST(Registry, Erase) {
+TEST_F(Registry, Erase) {
     entt::registry registry{};
     const auto iview = registry.view<int>();
     const auto icview = registry.view<int, char>();
@@ -1367,7 +1372,7 @@ TEST(Registry, Erase) {
     ASSERT_TRUE(registry.orphan(entity[2u]));
 }
 
-ENTT_DEBUG_TEST(RegistryDeathTest, Erase) {
+ENTT_DEBUG_TEST_F(RegistryDeathTest, Erase) {
     entt::registry registry{};
     const std::array entity{registry.create()};
 
@@ -1376,7 +1381,7 @@ ENTT_DEBUG_TEST(RegistryDeathTest, Erase) {
     ASSERT_DEATH(registry.erase<int>(entity[0u]), "");
 }
 
-TEST(Registry, StableErase) {
+TEST_F(Registry, StableErase) {
     entt::registry registry{};
     const auto iview = registry.view<int>();
     const auto icview = registry.view<int, test::pointer_stable>();
@@ -1418,7 +1423,7 @@ TEST(Registry, StableErase) {
     ASSERT_EQ(registry.storage<double>().size(), 1u);
 }
 
-TEST(Registry, EraseIf) {
+TEST_F(Registry, EraseIf) {
     using namespace entt::literals;
 
     entt::registry registry{};
@@ -1451,7 +1456,7 @@ TEST(Registry, EraseIf) {
     ASSERT_FALSE(registry.storage<char>().contains(entity));
 }
 
-TEST(Registry, Compact) {
+TEST_F(Registry, Compact) {
     entt::registry registry{};
     std::array<entt::entity, 2u> entity{};
 
@@ -1482,7 +1487,7 @@ TEST(Registry, Compact) {
     ASSERT_EQ(registry.storage<test::pointer_stable>().size(), 0u);
 }
 
-TEST(Registry, AllAnyOf) {
+TEST_F(Registry, AllAnyOf) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -1503,7 +1508,7 @@ TEST(Registry, AllAnyOf) {
     ASSERT_TRUE((registry.any_of<int, char>(entity)));
 }
 
-TEST(Registry, Get) {
+TEST_F(Registry, Get) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -1520,7 +1525,7 @@ TEST(Registry, Get) {
     ASSERT_EQ((registry.get<int, char>(entity)), std::make_tuple(3, 'a'));
 }
 
-TEST(Registry, GetOrEmplace) {
+TEST_F(Registry, GetOrEmplace) {
     entt::registry registry{};
     const auto entity = registry.create();
     const auto value = 3;
@@ -1535,7 +1540,7 @@ TEST(Registry, GetOrEmplace) {
     ASSERT_EQ(registry.get<double>(entity), other);
 }
 
-TEST(Registry, GetOrEmplaceEmpty) {
+TEST_F(Registry, GetOrEmplaceEmpty) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -1546,7 +1551,7 @@ TEST(Registry, GetOrEmplaceEmpty) {
     ASSERT_TRUE((registry.all_of<test::empty>(entity)));
 }
 
-ENTT_DEBUG_TEST(RegistryDeathTest, GetOrEmplace) {
+ENTT_DEBUG_TEST_F(RegistryDeathTest, GetOrEmplace) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -1555,7 +1560,7 @@ ENTT_DEBUG_TEST(RegistryDeathTest, GetOrEmplace) {
     ASSERT_DEATH([[maybe_unused]] const auto value = registry.get_or_emplace<int>(entity), "");
 }
 
-TEST(Registry, TryGet) {
+TEST_F(Registry, TryGet) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -1572,7 +1577,7 @@ TEST(Registry, TryGet) {
     ASSERT_EQ(std::as_const(registry).try_get<int>(entity), &elem);
 }
 
-TEST(Registry, Clear) {
+TEST_F(Registry, Clear) {
     entt::registry registry{};
     const std::array entity{registry.create(), registry.create()};
 
@@ -1602,7 +1607,7 @@ TEST(Registry, Clear) {
     ASSERT_TRUE(registry.storage<char>().empty());
 }
 
-TEST(Registry, Orphan) {
+TEST_F(Registry, Orphan) {
     entt::registry registry{};
     std::array<entt::entity, 3u> entity{};
 
@@ -1622,7 +1627,7 @@ TEST(Registry, Orphan) {
     }
 }
 
-TEST(Registry, Signals) {
+TEST_F(Registry, Signals) {
     entt::registry registry{};
     std::array<entt::entity, 2u> entity{};
     listener listener;
@@ -1727,7 +1732,7 @@ TEST(Registry, Signals) {
     ASSERT_EQ(listener.last, entity[0u]);
 }
 
-TEST(Registry, SignalsOnRuntimePool) {
+TEST_F(Registry, SignalsOnRuntimePool) {
     using namespace entt::literals;
 
     entt::registry registry{};
@@ -1753,7 +1758,7 @@ TEST(Registry, SignalsOnRuntimePool) {
     ASSERT_EQ(listener.counter, 3);
 }
 
-TEST(Registry, SignalsOnEntity) {
+TEST_F(Registry, SignalsOnEntity) {
     entt::registry registry{};
     listener listener;
 
@@ -1805,7 +1810,7 @@ TEST(Registry, SignalsOnEntity) {
     ASSERT_NE(listener.last, other);
 }
 
-TEST(Registry, SignalWhenDestroying) {
+TEST_F(Registry, SignalWhenDestroying) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -1824,7 +1829,7 @@ TEST(Registry, SignalWhenDestroying) {
     ASSERT_FALSE(registry.valid(entity));
 }
 
-TEST(Registry, SelfSignal) {
+TEST_F(Registry, SelfSignal) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -1856,7 +1861,7 @@ TEST(Registry, SelfSignal) {
     ASSERT_FALSE(registry.all_of<double>(entity));
 }
 
-TEST(Registry, View) {
+TEST_F(Registry, View) {
     entt::registry registry{};
     std::array<entt::entity, 3u> entity{};
 
@@ -1921,7 +1926,7 @@ TEST(Registry, View) {
     });
 }
 
-TEST(Registry, ExcludeOnlyView) {
+TEST_F(Registry, ExcludeOnlyView) {
     entt::registry registry{};
     std::array<entt::entity, 4u> entity{};
 
@@ -1950,7 +1955,7 @@ TEST(Registry, ExcludeOnlyView) {
     });
 }
 
-TEST(Registry, CleanViewAfterRemoveAndClear) {
+TEST_F(Registry, CleanViewAfterRemoveAndClear) {
     entt::registry registry{};
     auto view = registry.view<int, char>();
 
@@ -1981,7 +1986,7 @@ TEST(Registry, CleanViewAfterRemoveAndClear) {
     ASSERT_EQ(view.size_hint(), 0u);
 }
 
-TEST(Registry, NonOwningGroupInitOnFirstUse) {
+TEST_F(Registry, NonOwningGroupInitOnFirstUse) {
     entt::registry registry{};
     std::array<entt::entity, 3u> entity{};
 
@@ -1998,7 +2003,7 @@ TEST(Registry, NonOwningGroupInitOnFirstUse) {
     ASSERT_EQ(cnt, 2u);
 }
 
-TEST(Registry, NonOwningGroupInitOnEmplace) {
+TEST_F(Registry, NonOwningGroupInitOnEmplace) {
     entt::registry registry{};
     std::array<entt::entity, 3u> entity{};
     auto group = registry.group(entt::get<int, char>);
@@ -2015,7 +2020,7 @@ TEST(Registry, NonOwningGroupInitOnEmplace) {
     ASSERT_EQ(cnt, 2u);
 }
 
-TEST(Registry, FullOwningGroupInitOnFirstUse) {
+TEST_F(Registry, FullOwningGroupInitOnFirstUse) {
     entt::registry registry{};
     std::array<entt::entity, 3u> entity{};
 
@@ -2034,7 +2039,7 @@ TEST(Registry, FullOwningGroupInitOnFirstUse) {
     ASSERT_EQ(cnt, 2u);
 }
 
-TEST(Registry, FullOwningGroupInitOnEmplace) {
+TEST_F(Registry, FullOwningGroupInitOnEmplace) {
     entt::registry registry{};
     std::array<entt::entity, 3u> entity{};
     auto group = registry.group<int, char>();
@@ -2053,7 +2058,7 @@ TEST(Registry, FullOwningGroupInitOnEmplace) {
     ASSERT_EQ(cnt, 2u);
 }
 
-TEST(Registry, PartialOwningGroupInitOnFirstUse) {
+TEST_F(Registry, PartialOwningGroupInitOnFirstUse) {
     entt::registry registry{};
     std::array<entt::entity, 3u> entity{};
 
@@ -2072,7 +2077,7 @@ TEST(Registry, PartialOwningGroupInitOnFirstUse) {
     ASSERT_EQ(cnt, 2u);
 }
 
-TEST(Registry, PartialOwningGroupInitOnEmplace) {
+TEST_F(Registry, PartialOwningGroupInitOnEmplace) {
     entt::registry registry{};
     std::array<entt::entity, 3u> entity{};
     auto group = registry.group<int>(entt::get<char>);
@@ -2091,7 +2096,7 @@ TEST(Registry, PartialOwningGroupInitOnEmplace) {
     ASSERT_EQ(cnt, 2u);
 }
 
-TEST(Registry, CleanNonOwningGroupViewAfterRemoveAndClear) {
+TEST_F(Registry, CleanNonOwningGroupViewAfterRemoveAndClear) {
     entt::registry registry{};
     auto group = registry.group(entt::get<int, char>);
 
@@ -2122,7 +2127,7 @@ TEST(Registry, CleanNonOwningGroupViewAfterRemoveAndClear) {
     ASSERT_EQ(group.size(), 0u);
 }
 
-TEST(Registry, CleanFullOwningGroupViewAfterRemoveAndClear) {
+TEST_F(Registry, CleanFullOwningGroupViewAfterRemoveAndClear) {
     entt::registry registry{};
     auto group = registry.group<int, char>();
 
@@ -2153,7 +2158,7 @@ TEST(Registry, CleanFullOwningGroupViewAfterRemoveAndClear) {
     ASSERT_EQ(group.size(), 0u);
 }
 
-TEST(Registry, CleanPartialOwningGroupViewAfterRemoveAndClear) {
+TEST_F(Registry, CleanPartialOwningGroupViewAfterRemoveAndClear) {
     entt::registry registry{};
     auto group = registry.group<int>(entt::get<char>);
 
@@ -2184,7 +2189,7 @@ TEST(Registry, CleanPartialOwningGroupViewAfterRemoveAndClear) {
     ASSERT_EQ(group.size(), 0u);
 }
 
-ENTT_DEBUG_TEST(RegistryDeathTest, NestedGroups) {
+ENTT_DEBUG_TEST_F(RegistryDeathTest, NestedGroups) {
     entt::registry registry{};
     registry.group<int, double>(entt::get<char>);
 
@@ -2194,14 +2199,14 @@ ENTT_DEBUG_TEST(RegistryDeathTest, NestedGroups) {
     ASSERT_DEATH((registry.group<int, double>()), "");
 }
 
-ENTT_DEBUG_TEST(RegistryDeathTest, ConflictingGroups) {
+ENTT_DEBUG_TEST_F(RegistryDeathTest, ConflictingGroups) {
     entt::registry registry{};
 
     registry.group<char>(entt::get<int>, entt::exclude<double>);
     ASSERT_DEATH(registry.group<char>(entt::get<float>, entt::exclude<double>), "");
 }
 
-TEST(Registry, GroupIfExists) {
+TEST_F(Registry, GroupIfExists) {
     entt::registry registry{};
     const auto entity = registry.create();
     auto group = std::as_const(registry).group_if_exists<int>(entt::get<char>, entt::exclude<double>);
@@ -2233,7 +2238,7 @@ TEST(Registry, GroupIfExists) {
     ASSERT_TRUE(group);
 }
 
-TEST(Registry, SortSingle) {
+TEST_F(Registry, SortSingle) {
     entt::registry registry{};
 
     int val = 0;
@@ -2253,7 +2258,7 @@ TEST(Registry, SortSingle) {
     }
 }
 
-TEST(Registry, SortMulti) {
+TEST_F(Registry, SortMulti) {
     entt::registry registry{};
 
     unsigned int uval = 0u;
@@ -2285,7 +2290,7 @@ TEST(Registry, SortMulti) {
     }
 }
 
-TEST(Registry, SortEmpty) {
+TEST_F(Registry, SortEmpty) {
     entt::registry registry{};
 
     registry.emplace<test::empty>(registry.create());
@@ -2301,7 +2306,7 @@ TEST(Registry, SortEmpty) {
     ASSERT_GT(registry.storage<test::empty>().data()[1], registry.storage<test::empty>().data()[2]);
 }
 
-TEST(Registry, Context) {
+TEST_F(Registry, Context) {
     entt::registry registry{};
     auto &ctx = registry.ctx();
     const auto &cctx = std::as_const(registry).ctx();
@@ -2365,7 +2370,7 @@ TEST(Registry, Context) {
     ASSERT_FALSE(ctx.contains<int>());
 }
 
-TEST(Registry, ContextHint) {
+TEST_F(Registry, ContextHint) {
     using namespace entt::literals;
 
     entt::registry registry{};
@@ -2404,7 +2409,7 @@ TEST(Registry, ContextHint) {
     ASSERT_EQ(ctx.find<int>("other"_hs), nullptr);
 }
 
-TEST(Registry, ContextAsRef) {
+TEST_F(Registry, ContextAsRef) {
     entt::registry registry{};
     int value{3};
 
@@ -2426,7 +2431,7 @@ TEST(Registry, ContextAsRef) {
     ASSERT_EQ(std::as_const(registry).ctx().get<const int>(), value);
 }
 
-TEST(Registry, ContextAsConstRef) {
+TEST_F(Registry, ContextAsConstRef) {
     entt::registry registry{};
     int value{3};
 
@@ -2442,7 +2447,7 @@ TEST(Registry, ContextAsConstRef) {
     ASSERT_EQ(std::as_const(registry).ctx().get<const int>(), value);
 }
 
-TEST(Registry, ContextPoolMemberDestructionOrder) {
+TEST_F(Registry, ContextPoolMemberDestructionOrder) {
     auto registry = std::make_unique<entt::registry>();
     const auto entity = registry->create();
     bool ctx_check = false;
@@ -2454,7 +2459,7 @@ TEST(Registry, ContextPoolMemberDestructionOrder) {
     ASSERT_TRUE(ctx_check);
 }
 
-TEST(Registry, Constness) {
+TEST_F(Registry, Constness) {
     testing::StaticAssertTypeEq<decltype(std::declval<entt::registry>().emplace<int>({})), int &>();
     testing::StaticAssertTypeEq<decltype(std::declval<entt::registry>().emplace<test::empty>({})), void>();
 
@@ -2487,7 +2492,7 @@ TEST(Registry, Constness) {
     testing::StaticAssertTypeEq<decltype(std::declval<const entt::registry>().ctx().find<const char>()), const char *>();
 }
 
-TEST(Registry, AssignEntities) {
+TEST_F(Registry, AssignEntities) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::registry registry{};
@@ -2511,7 +2516,7 @@ TEST(Registry, AssignEntities) {
     ASSERT_EQ(traits_type::to_entity(other.create()), traits_type::to_integral(entity[1]));
 }
 
-TEST(Registry, ScramblingPoolsIsAllowed) {
+TEST_F(Registry, ScramblingPoolsIsAllowed) {
     entt::registry registry{};
     registry.on_destroy<int>().connect<&listener::sort<int>>();
 
@@ -2528,7 +2533,7 @@ TEST(Registry, ScramblingPoolsIsAllowed) {
     });
 }
 
-TEST(Registry, AssureMixinLoop) {
+TEST_F(Registry, AssureMixinLoop) {
     entt::registry registry{};
     const auto entity = registry.create();
 
@@ -2544,7 +2549,7 @@ TEST(Registry, AssureMixinLoop) {
     ASSERT_FALSE(registry.all_of<int>(entity));
 }
 
-TEST(Registry, VoidType) {
+TEST_F(Registry, VoidType) {
     using namespace entt::literals;
 
     entt::registry registry{};
@@ -2560,7 +2565,7 @@ TEST(Registry, VoidType) {
     ASSERT_EQ(registry.storage<void>("custom"_hs).info(), entt::type_id<void>());
 }
 
-TEST(Registry, NoEtoType) {
+TEST_F(Registry, NoEtoType) {
     entt::registry registry{};
     const auto entity = registry.create();
 

test/entt/entity/sigh_mixin.cpp

@@ -12,7 +12,6 @@
 #include <entt/entity/storage.hpp>
 #include <entt/signal/sigh.hpp>
 #include "../../common/config.h"
-#include "../../common/entity.h"
 #include "../../common/linter.hpp"
 #include "../../common/non_default_constructible.h"
 #include "../../common/pointer_stable.h"
@@ -20,37 +19,41 @@
 #include "../../common/throwing_allocator.hpp"
 #include "../../common/throwing_type.hpp"
 
-struct auto_signal final {
-    auto_signal(bool &cflag, bool &uflag, bool &dflag)
-        : created{&cflag},
-          updated{&uflag},
-          destroyed{&dflag} {}
+struct SighMixinBase: testing::Test {
+    enum class my_entity : std::uint32_t {};
 
-    static void on_construct(entt::registry &registry, const entt::entity entt) {
-        *registry.get<auto_signal>(entt).created = true;
-    }
+    struct auto_signal final {
+        auto_signal(bool &cflag, bool &uflag, bool &dflag)
+            : created{&cflag},
+              updated{&uflag},
+              destroyed{&dflag} {}
 
-    static void on_update(entt::registry &registry, const entt::entity entt) {
-        *registry.get<auto_signal>(entt).updated = true;
-    }
+        static void on_construct(entt::registry &registry, const entt::entity entt) {
+            *registry.get<auto_signal>(entt).created = true;
+        }
 
-    static void on_destroy(entt::registry &registry, const entt::entity entt) {
-        *registry.get<auto_signal>(entt).destroyed = true;
-    }
+        static void on_update(entt::registry &registry, const entt::entity entt) {
+            *registry.get<auto_signal>(entt).updated = true;
+        }
 
-private:
-    bool *created{};
-    bool *updated{};
-    bool *destroyed{};
-};
+        static void on_destroy(entt::registry &registry, const entt::entity entt) {
+            *registry.get<auto_signal>(entt).destroyed = true;
+        }
 
-template<typename Registry>
-void listener(std::size_t &counter, Registry &, typename Registry::entity_type) {
-    ++counter;
-}
+    private:
+        bool *created{};
+        bool *updated{};
+        bool *destroyed{};
+    };
+
+    template<typename Registry>
+    static void listener(std::size_t &counter, Registry &, typename Registry::entity_type) {
+        ++counter;
+    }
+};
 
 template<typename Type>
-struct SighMixin: testing::Test {
+struct SighMixin: SighMixinBase {
     using type = Type;
 };
 
@@ -84,8 +87,8 @@ TYPED_TEST(SighMixin, Functionalities) {
     ASSERT_EQ(on_construct, 0u);
     ASSERT_EQ(on_destroy, 0u);
 
-    pool.on_construct().template connect<&listener<entt::registry>>(on_construct);
-    pool.on_destroy().template connect<&listener<entt::registry>>(on_destroy);
+    pool.on_construct().template connect<&SighMixinBase::listener<entt::registry>>(on_construct);
+    pool.on_destroy().template connect<&SighMixinBase::listener<entt::registry>>(on_destroy);
 
     ASSERT_NE(pool.push(entity[0u]), pool.entt::sparse_set::end());
 
@@ -149,7 +152,7 @@ TYPED_TEST(SighMixin, InsertWeakRange) {
 
     ASSERT_EQ(on_construct, 0u);
 
-    pool.on_construct().template connect<&listener<entt::registry>>(on_construct);
+    pool.on_construct().template connect<&SighMixinBase::listener<entt::registry>>(on_construct);
     pool.insert(view.begin(), view.end());
 
     ASSERT_EQ(on_construct, 2u);
@@ -174,8 +177,8 @@ TEST(SighMixin, NonDefaultConstructibleType) {
     ASSERT_EQ(on_construct, 0u);
     ASSERT_EQ(on_destroy, 0u);
 
-    pool.on_construct().connect<&listener<entt::registry>>(on_construct);
-    pool.on_destroy().connect<&listener<entt::registry>>(on_destroy);
+    pool.on_construct().connect<&SighMixinBase::listener<entt::registry>>(on_construct);
+    pool.on_destroy().connect<&SighMixinBase::listener<entt::registry>>(on_destroy);
 
     ASSERT_EQ(pool.push(entity[0u]), pool.entt::sparse_set::end());
 
@@ -226,8 +229,8 @@ TEST(SighMixin, VoidType) {
     std::size_t on_construct{};
     std::size_t on_destroy{};
 
-    pool.on_construct().connect<&listener<entt::registry>>(on_construct);
-    pool.on_destroy().connect<&listener<entt::registry>>(on_destroy);
+    pool.on_construct().connect<&SighMixinBase::listener<entt::registry>>(on_construct);
+    pool.on_destroy().connect<&SighMixinBase::listener<entt::registry>>(on_destroy);
 
     pool.emplace(entity);
 
@@ -264,8 +267,8 @@ TEST(SighMixin, StorageEntity) {
     std::size_t on_construct{};
     std::size_t on_destroy{};
 
-    pool.on_construct().connect<&listener<entt::registry>>(on_construct);
-    pool.on_destroy().connect<&listener<entt::registry>>(on_destroy);
+    pool.on_construct().connect<&SighMixinBase::listener<entt::registry>>(on_construct);
+    pool.on_destroy().connect<&SighMixinBase::listener<entt::registry>>(on_destroy);
 
     pool.push(entt::entity{1});
 
@@ -328,8 +331,8 @@ TYPED_TEST(SighMixin, Move) {
     std::size_t on_destroy{};
 
     pool.bind(registry);
-    pool.on_construct().template connect<&listener<entt::registry>>(on_construct);
-    pool.on_destroy().template connect<&listener<entt::registry>>(on_destroy);
+    pool.on_construct().template connect<&SighMixinBase::listener<entt::registry>>(on_construct);
+    pool.on_destroy().template connect<&SighMixinBase::listener<entt::registry>>(on_destroy);
 
     pool.emplace(entt::entity{3}, 3);
 
@@ -390,12 +393,12 @@ TYPED_TEST(SighMixin, Swap) {
     std::size_t on_destroy{};
 
     pool.bind(registry);
-    pool.on_construct().template connect<&listener<entt::registry>>(on_construct);
-    pool.on_destroy().template connect<&listener<entt::registry>>(on_destroy);
+    pool.on_construct().template connect<&SighMixinBase::listener<entt::registry>>(on_construct);
+    pool.on_destroy().template connect<&SighMixinBase::listener<entt::registry>>(on_destroy);
 
     other.bind(registry);
-    other.on_construct().template connect<&listener<entt::registry>>(on_construct);
-    other.on_destroy().template connect<&listener<entt::registry>>(on_destroy);
+    other.on_construct().template connect<&SighMixinBase::listener<entt::registry>>(on_construct);
+    other.on_destroy().template connect<&SighMixinBase::listener<entt::registry>>(on_destroy);
 
     pool.emplace(entt::entity{4}, 1);
 
@@ -435,28 +438,28 @@ TEST(SighMixin, AutoSignal) {
     bool updated{};
     bool destroyed{};
 
-    registry.emplace<auto_signal>(entity, created, updated, destroyed);
-    registry.replace<auto_signal>(entity, created, updated, destroyed);
-    registry.erase<auto_signal>(entity);
+    registry.emplace<SighMixinBase::auto_signal>(entity, created, updated, destroyed);
+    registry.replace<SighMixinBase::auto_signal>(entity, created, updated, destroyed);
+    registry.erase<SighMixinBase::auto_signal>(entity);
 
     ASSERT_TRUE(created);
     ASSERT_TRUE(updated);
     ASSERT_TRUE(destroyed);
 
-    ASSERT_TRUE(registry.storage<auto_signal>().empty());
+    ASSERT_TRUE(registry.storage<SighMixinBase::auto_signal>().empty());
     ASSERT_TRUE(registry.valid(entity));
 
     created = updated = destroyed = false;
 
-    registry.emplace<auto_signal>(entity, created, updated, destroyed);
-    registry.replace<auto_signal>(entity, created, updated, destroyed);
+    registry.emplace<SighMixinBase::auto_signal>(entity, created, updated, destroyed);
+    registry.replace<SighMixinBase::auto_signal>(entity, created, updated, destroyed);
     registry.destroy(entity);
 
     ASSERT_TRUE(created);
     ASSERT_TRUE(updated);
     ASSERT_TRUE(destroyed);
 
-    ASSERT_TRUE(registry.storage<auto_signal>().empty());
+    ASSERT_TRUE(registry.storage<SighMixinBase::auto_signal>().empty());
     ASSERT_FALSE(registry.valid(entity));
 }
 
@@ -484,10 +487,10 @@ ENTT_DEBUG_TYPED_TEST(SighMixinDeathTest, Registry) {
 
 TYPED_TEST(SighMixin, CustomRegistry) {
     using value_type = TestFixture::type;
-    using registry_type = test::custom_registry<test::entity>;
+    using registry_type = test::custom_registry<SighMixinBase::my_entity>;
 
     registry_type registry;
-    entt::basic_sigh_mixin<entt::basic_storage<value_type, test::entity>, registry_type> pool;
+    entt::basic_sigh_mixin<entt::basic_storage<value_type, SighMixinBase::my_entity>, registry_type> pool;
     const std::array entity{registry.create(), registry.create()};
 
     ASSERT_FALSE(pool);
@@ -499,8 +502,8 @@ TYPED_TEST(SighMixin, CustomRegistry) {
     std::size_t on_construct{};
     std::size_t on_destroy{};
 
-    pool.on_construct().template connect<&listener<registry_type>>(on_construct);
-    pool.on_destroy().template connect<&listener<registry_type>>(on_destroy);
+    pool.on_construct().template connect<&SighMixinBase::listener<registry_type>>(on_construct);
+    pool.on_destroy().template connect<&SighMixinBase::listener<registry_type>>(on_destroy);
 
     pool.emplace(entity[0u]);
     pool.emplace(entity[1u]);
@@ -516,8 +519,8 @@ TYPED_TEST(SighMixin, CustomRegistry) {
 
 ENTT_DEBUG_TYPED_TEST(SighMixinDeathTest, CustomRegistry) {
     using value_type = TestFixture::type;
-    using registry_type = test::custom_registry<test::entity>;
-    entt::basic_sigh_mixin<entt::basic_storage<value_type, test::entity>, registry_type> pool;
+    using registry_type = test::custom_registry<SighMixinBase::my_entity>;
+    entt::basic_sigh_mixin<entt::basic_storage<value_type, SighMixinBase::my_entity>, registry_type> pool;
     ASSERT_DEATH([[maybe_unused]] auto &registry = pool.registry(), "");
     ASSERT_DEATH([[maybe_unused]] const auto &registry = std::as_const(pool).registry(), "");
 }
@@ -535,8 +538,8 @@ TYPED_TEST(SighMixin, CustomAllocator) {
     std::size_t on_destroy{};
 
     pool.bind(registry);
-    pool.on_construct().template connect<&listener<registry_type>>(on_construct);
-    pool.on_destroy().template connect<&listener<registry_type>>(on_destroy);
+    pool.on_construct().template connect<&SighMixinBase::listener<registry_type>>(on_construct);
+    pool.on_destroy().template connect<&SighMixinBase::listener<registry_type>>(on_destroy);
 
     pool.reserve(1u);
 
@@ -597,8 +600,8 @@ TYPED_TEST(SighMixin, ThrowingAllocator) {
     std::size_t on_destroy{};
 
     pool.bind(registry);
-    pool.on_construct().template connect<&listener<registry_type>>(on_construct);
-    pool.on_destroy().template connect<&listener<registry_type>>(on_destroy);
+    pool.on_construct().template connect<&SighMixinBase::listener<registry_type>>(on_construct);
+    pool.on_destroy().template connect<&SighMixinBase::listener<registry_type>>(on_destroy);
 
     pool.get_allocator().template throw_counter<value_type>(0u);
 
@@ -665,8 +668,8 @@ TEST(SighMixin, ThrowingComponent) {
     std::size_t on_destroy{};
 
     pool.bind(registry);
-    pool.on_construct().connect<&listener<registry_type>>(on_construct);
-    pool.on_destroy().connect<&listener<registry_type>>(on_destroy);
+    pool.on_construct().connect<&SighMixinBase::listener<registry_type>>(on_construct);
+    pool.on_destroy().connect<&SighMixinBase::listener<registry_type>>(on_destroy);
 
     const std::array entity{entt::entity{3}, entt::entity{1}};
     const std::array<test::throwing_type, 2u> value{true, false};

test/entt/entity/snapshot.cpp

@@ -15,15 +15,23 @@
 #include "../../common/empty.h"
 #include "../../common/pointer_stable.h"
 
-struct shadow {
-    entt::entity target{entt::null};
+struct SnapshotCommonBase: testing::Test {
+    struct shadow {
+        entt::entity target{entt::null};
 
-    static void listener(entt::entity &elem, entt::registry &registry, const entt::entity entt) {
-        elem = registry.get<shadow>(entt).target;
-    }
+        static void listener(entt::entity &elem, entt::registry &registry, const entt::entity entt) {
+            elem = registry.get<shadow>(entt).target;
+        }
+    };
 };
 
-TEST(BasicSnapshot, Constructors) {
+struct BasicSnapshot: SnapshotCommonBase {};
+struct BasicSnapshotLoader: SnapshotCommonBase {};
+struct BasicContinuousLoader: SnapshotCommonBase {};
+
+using BasicSnapshotLoaderDeathTest = BasicSnapshotLoader;
+
+TEST_F(BasicSnapshot, Constructors) {
     static_assert(!std::is_default_constructible_v<entt::basic_snapshot<entt::registry>>, "Default constructible type not allowed");
     static_assert(!std::is_copy_constructible_v<entt::basic_snapshot<entt::registry>>, "Copy constructible type not allowed");
     static_assert(!std::is_copy_assignable_v<entt::basic_snapshot<entt::registry>>, "Copy assignable type not allowed");
@@ -37,7 +45,7 @@ TEST(BasicSnapshot, Constructors) {
     ASSERT_NO_THROW(snapshot = std::move(other));
 }
 
-TEST(BasicSnapshot, GetEntityType) {
+TEST_F(BasicSnapshot, GetEntityType) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
 
@@ -85,7 +93,7 @@ TEST(BasicSnapshot, GetEntityType) {
     ASSERT_EQ(entt::any_cast<entt::entity>(data[4u]), storage.data()[2u]);
 }
 
-TEST(BasicSnapshot, GetType) {
+TEST_F(BasicSnapshot, GetType) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
 
@@ -132,7 +140,7 @@ TEST(BasicSnapshot, GetType) {
     ASSERT_EQ(entt::any_cast<int>(data[4u]), value[2u]);
 }
 
-TEST(BasicSnapshot, GetPointerStableType) {
+TEST_F(BasicSnapshot, GetPointerStableType) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
 
@@ -182,7 +190,7 @@ TEST(BasicSnapshot, GetPointerStableType) {
     ASSERT_EQ(entt::any_cast<test::pointer_stable>(data[5u]), value[2u]);
 }
 
-TEST(BasicSnapshot, GetEmptyType) {
+TEST_F(BasicSnapshot, GetEmptyType) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
 
@@ -222,7 +230,7 @@ TEST(BasicSnapshot, GetEmptyType) {
     ASSERT_EQ(entt::any_cast<entt::entity>(data[2u]), entity[2u]);
 }
 
-TEST(BasicSnapshot, GetTypeSparse) {
+TEST_F(BasicSnapshot, GetTypeSparse) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
 
@@ -271,7 +279,7 @@ TEST(BasicSnapshot, GetTypeSparse) {
     ASSERT_EQ(entt::any_cast<int>(data[5u]), value[2u]);
 }
 
-TEST(BasicSnapshotLoader, Constructors) {
+TEST_F(BasicSnapshotLoader, Constructors) {
     static_assert(!std::is_default_constructible_v<entt::basic_snapshot_loader<entt::registry>>, "Default constructible type not allowed");
     static_assert(!std::is_copy_constructible_v<entt::basic_snapshot_loader<entt::registry>>, "Copy constructible type not allowed");
     static_assert(!std::is_copy_assignable_v<entt::basic_snapshot_loader<entt::registry>>, "Copy assignable type not allowed");
@@ -290,14 +298,14 @@ TEST(BasicSnapshotLoader, Constructors) {
     ASSERT_NO_THROW(loader = std::move(other));
 }
 
-ENTT_DEBUG_TEST(BasicSnapshotLoaderDeathTest, Constructors) {
+ENTT_DEBUG_TEST_F(BasicSnapshotLoaderDeathTest, Constructors) {
     entt::registry registry;
     registry.emplace<int>(registry.create());
 
     ASSERT_DEATH([[maybe_unused]] const entt::basic_snapshot_loader loader{registry}, "");
 }
 
-TEST(BasicSnapshotLoader, GetEntityType) {
+TEST_F(BasicSnapshotLoader, GetEntityType) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
 
@@ -348,7 +356,7 @@ TEST(BasicSnapshotLoader, GetEntityType) {
     ASSERT_EQ(registry.create(), entity[2u]);
 }
 
-TEST(BasicSnapshotLoader, GetType) {
+TEST_F(BasicSnapshotLoader, GetType) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
 
@@ -396,7 +404,7 @@ TEST(BasicSnapshotLoader, GetType) {
     ASSERT_EQ(storage.get(entity[1u]), value[1u]);
 }
 
-TEST(BasicSnapshotLoader, GetEmptyType) {
+TEST_F(BasicSnapshotLoader, GetEmptyType) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
 
@@ -437,7 +445,7 @@ TEST(BasicSnapshotLoader, GetEmptyType) {
     ASSERT_TRUE(storage.contains(entity[1u]));
 }
 
-TEST(BasicSnapshotLoader, GetTypeSparse) {
+TEST_F(BasicSnapshotLoader, GetTypeSparse) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
 
@@ -488,7 +496,7 @@ TEST(BasicSnapshotLoader, GetTypeSparse) {
     ASSERT_EQ(storage.get(entity[1u]), value[1u]);
 }
 
-TEST(BasicSnapshotLoader, GetTypeWithListener) {
+TEST_F(BasicSnapshotLoader, GetTypeWithListener) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::registry registry;
@@ -515,7 +523,7 @@ TEST(BasicSnapshotLoader, GetTypeWithListener) {
     ASSERT_EQ(check, entity);
 }
 
-TEST(BasicSnapshotLoader, Orphans) {
+TEST_F(BasicSnapshotLoader, Orphans) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
 
@@ -552,7 +560,7 @@ TEST(BasicSnapshotLoader, Orphans) {
     ASSERT_FALSE(registry.valid(entity[1u]));
 }
 
-TEST(BasicContinuousLoader, Constructors) {
+TEST_F(BasicContinuousLoader, Constructors) {
     static_assert(!std::is_default_constructible_v<entt::basic_continuous_loader<entt::registry>>, "Default constructible type not allowed");
     static_assert(!std::is_copy_constructible_v<entt::basic_continuous_loader<entt::registry>>, "Copy constructible type not allowed");
     static_assert(!std::is_copy_assignable_v<entt::basic_continuous_loader<entt::registry>>, "Copy assignable type not allowed");
@@ -566,7 +574,7 @@ TEST(BasicContinuousLoader, Constructors) {
     ASSERT_NO_THROW(loader = std::move(other));
 }
 
-TEST(BasicContinuousLoader, GetEntityType) {
+TEST_F(BasicContinuousLoader, GetEntityType) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
 
@@ -701,7 +709,7 @@ TEST(BasicContinuousLoader, GetEntityType) {
     ASSERT_EQ(storage[1u], loader.map(entity[1u]));
 }
 
-TEST(BasicContinuousLoader, GetType) {
+TEST_F(BasicContinuousLoader, GetType) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
 
@@ -758,7 +766,7 @@ TEST(BasicContinuousLoader, GetType) {
     ASSERT_EQ(storage.get(loader.map(entity[1u])), value[1u]);
 }
 
-TEST(BasicContinuousLoader, GetTypeExtended) {
+TEST_F(BasicContinuousLoader, GetTypeExtended) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
 
@@ -811,7 +819,7 @@ TEST(BasicContinuousLoader, GetTypeExtended) {
     ASSERT_EQ(storage.get(loader.map(entity[1u])).target, loader.map(entity[0u]));
 }
 
-TEST(BasicContinuousLoader, GetEmptyType) {
+TEST_F(BasicContinuousLoader, GetEmptyType) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
 
@@ -861,7 +869,7 @@ TEST(BasicContinuousLoader, GetEmptyType) {
     ASSERT_TRUE(storage.contains(loader.map(entity[1u])));
 }
 
-TEST(BasicContinuousLoader, GetTypeSparse) {
+TEST_F(BasicContinuousLoader, GetTypeSparse) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
 
@@ -921,7 +929,7 @@ TEST(BasicContinuousLoader, GetTypeSparse) {
     ASSERT_EQ(storage.get(loader.map(entity[1u])), value[1u]);
 }
 
-TEST(BasicContinuousLoader, GetTypeWithListener) {
+TEST_F(BasicContinuousLoader, GetTypeWithListener) {
     using traits_type = entt::entt_traits<entt::entity>;
 
     entt::registry registry;
@@ -948,7 +956,7 @@ TEST(BasicContinuousLoader, GetTypeWithListener) {
     ASSERT_EQ(check, entity);
 }
 
-TEST(BasicContinuousLoader, Orphans) {
+TEST_F(BasicContinuousLoader, Orphans) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
 

test/entt/entity/sparse_set.cpp

@@ -12,38 +12,41 @@
 #include <entt/entity/entity.hpp>
 #include <entt/entity/sparse_set.hpp>
 #include "../../common/config.h"
-#include "../../common/entity.h"
 #include "../../common/linter.hpp"
 #include "../../common/throwing_allocator.hpp"
 
-struct entity_traits {
-    using value_type = test::entity;
-    using entity_type = std::uint32_t;
-    using version_type = std::uint16_t;
-    static constexpr entity_type entity_mask = 0x3FFFF; // 18b
-    static constexpr entity_type version_mask = 0x0FFF; // 12b
+struct SparseSetBase: testing::Test {
+    enum class my_entity : std::uint32_t {};
+
+    struct entity_traits {
+        using value_type = my_entity;
+        using entity_type = std::uint32_t;
+        using version_type = std::uint16_t;
+        static constexpr entity_type entity_mask = 0x3FFFF; // 18b
+        static constexpr entity_type version_mask = 0x0FFF; // 12b
+    };
+
+    inline static const std::array<entt::deletion_policy, 3u> deletion_policy{
+        entt::deletion_policy::swap_and_pop,
+        entt::deletion_policy::in_place,
+        entt::deletion_policy::swap_only,
+    };
 };
 
 template<>
-struct entt::entt_traits<test::entity>: entt::basic_entt_traits<entity_traits> {
+struct entt::entt_traits<SparseSetBase::my_entity>: entt::basic_entt_traits<SparseSetBase::entity_traits> {
     static constexpr std::size_t page_size = ENTT_SPARSE_PAGE;
 };
 
 template<typename Type>
-struct SparseSet: testing::Test {
+struct SparseSet: SparseSetBase {
     using type = Type;
-
-    inline static const std::array<entt::deletion_policy, 3u> deletion_policy{
-        entt::deletion_policy::swap_and_pop,
-        entt::deletion_policy::in_place,
-        entt::deletion_policy::swap_only,
-    };
 };
 
 template<typename Type>
 using SparseSetDeathTest = SparseSet<Type>;
 
-using SparseSetTypes = ::testing::Types<entt::entity, test::entity>;
+using SparseSetTypes = ::testing::Types<entt::entity, SparseSetBase::my_entity>;
 
 TYPED_TEST_SUITE(SparseSet, SparseSetTypes, );
 TYPED_TEST_SUITE(SparseSetDeathTest, SparseSetTypes, );

test/entt/entity/view.cpp

@@ -12,7 +12,7 @@
 #include "../../common/empty.h"
 #include "../../common/pointer_stable.h"
 
-TEST(SingleStorageView, Functionalities) {
+TEST(ViewSingleStorage, Functionalities) {
     entt::storage<char> storage{};
     const entt::basic_view view{storage};
     const entt::basic_view cview{std::as_const(storage)};
@@ -64,7 +64,7 @@ TEST(SingleStorageView, Functionalities) {
     ASSERT_FALSE(invalid);
 }
 
-TEST(SingleStorageView, Conversion) {
+TEST(ViewSingleStorage, Conversion) {
     entt::basic_view<entt::get_t<entt::storage<char>>, entt::exclude_t<>> view{};
     entt::basic_view<entt::get_t<const entt::storage<char>>, entt::exclude_t<>> cview{view};
 
@@ -88,7 +88,7 @@ TEST(SingleStorageView, Conversion) {
     ASSERT_FALSE(cview.empty());
 }
 
-TEST(SingleStorageView, InvalidView) {
+TEST(ViewSingleStorage, InvalidView) {
     entt::basic_view<entt::get_t<entt::storage<int>>, entt::exclude_t<>> view{};
     auto iterable = view.each();
 
@@ -120,7 +120,7 @@ TEST(SingleStorageView, InvalidView) {
     ASSERT_TRUE(view);
 }
 
-TEST(SingleStorageView, Constructors) {
+TEST(ViewSingleStorage, Constructors) {
     entt::storage<int> storage{};
 
     const entt::basic_view<entt::get_t<entt::storage<int>>, entt::exclude_t<>> invalid{};
@@ -135,7 +135,7 @@ TEST(SingleStorageView, Constructors) {
     ASSERT_EQ(from_storage.handle(), from_tuple.handle());
 }
 
-TEST(SingleStorageView, Handle) {
+TEST(ViewSingleStorage, Handle) {
     entt::storage<int> storage{};
     const entt::basic_view view{storage};
     const entt::entity entity{0};
@@ -155,7 +155,7 @@ TEST(SingleStorageView, Handle) {
     ASSERT_EQ(handle, view.handle());
 }
 
-TEST(SingleStorageView, ElementAccess) {
+TEST(ViewSingleStorage, ElementAccess) {
     entt::storage<int> storage{};
     const entt::basic_view view{storage};
     const entt::basic_view cview{std::as_const(storage)};
@@ -168,7 +168,7 @@ TEST(SingleStorageView, ElementAccess) {
     ASSERT_EQ(cview[entity[1u]], 1);
 }
 
-TEST(SingleStorageView, Contains) {
+TEST(ViewSingleStorage, Contains) {
     entt::storage<int> storage{};
     const entt::basic_view view{storage};
     const std::array entity{entt::entity{1}, entt::entity{3}};
@@ -182,7 +182,7 @@ TEST(SingleStorageView, Contains) {
     ASSERT_TRUE(view.contains(entity[1u]));
 }
 
-TEST(SingleStorageView, Empty) {
+TEST(ViewSingleStorage, Empty) {
     entt::storage<int> storage{};
     const entt::basic_view view{storage};
 
@@ -191,7 +191,7 @@ TEST(SingleStorageView, Empty) {
     ASSERT_EQ(view.rbegin(), view.rend());
 }
 
-TEST(SingleStorageView, Each) {
+TEST(ViewSingleStorage, Each) {
     std::tuple<entt::storage<int>, entt::storage<double>> storage{};
     const entt::basic_view view{std::forward_as_tuple(std::get<0>(storage)), std::forward_as_tuple(std::get<1>(storage))};
     const entt::basic_view cview{std::as_const(std::get<0>(storage))};
@@ -236,7 +236,7 @@ TEST(SingleStorageView, Each) {
     }
 }
 
-TEST(SingleStorageView, ConstNonConstAndAllInBetween) {
+TEST(ViewSingleStorage, ConstNonConstAndAllInBetween) {
     entt::storage<int> storage{};
     const entt::basic_view view{storage};
     const entt::basic_view cview{std::as_const(storage)};
@@ -277,7 +277,7 @@ TEST(SingleStorageView, ConstNonConstAndAllInBetween) {
     }
 }
 
-TEST(SingleStorageView, ConstNonConstAndAllInBetweenWithEmptyType) {
+TEST(ViewSingleStorage, ConstNonConstAndAllInBetweenWithEmptyType) {
     entt::storage<test::empty> storage{};
     const entt::basic_view view{storage};
     const entt::basic_view cview{std::as_const(storage)};
@@ -303,7 +303,7 @@ TEST(SingleStorageView, ConstNonConstAndAllInBetweenWithEmptyType) {
     }
 }
 
-TEST(SingleStorageView, Find) {
+TEST(ViewSingleStorage, Find) {
     entt::storage<int> storage{};
     const entt::basic_view view{storage};
     const std::array entity{entt::entity{0}, entt::entity{1}, entt::entity{2}};
@@ -325,7 +325,7 @@ TEST(SingleStorageView, Find) {
     ASSERT_EQ(++it, view.end());
 }
 
-TEST(SingleStorageView, EmptyType) {
+TEST(ViewSingleStorage, EmptyType) {
     entt::storage<test::empty> storage{};
     const entt::basic_view view{storage};
     const entt::entity entity{0};
@@ -347,7 +347,7 @@ TEST(SingleStorageView, EmptyType) {
     }
 }
 
-TEST(SingleStorageView, FrontBack) {
+TEST(ViewSingleStorage, FrontBack) {
     entt::storage<char> storage{};
     const entt::basic_view view{std::as_const(storage)};
     const std::array entity{entt::entity{1}, entt::entity{3}};
@@ -362,7 +362,7 @@ TEST(SingleStorageView, FrontBack) {
     ASSERT_EQ(view.back(), entity[0u]);
 }
 
-TEST(SingleStorageView, DeductionGuide) {
+TEST(ViewSingleStorage, DeductionGuide) {
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage<int>>, entt::exclude_t<>>, decltype(entt::basic_view{std::declval<entt::storage<int> &>()})>();
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage<int>>, entt::exclude_t<>>, decltype(entt::basic_view{std::declval<const entt::storage<int> &>()})>();
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage<test::pointer_stable>>, entt::exclude_t<>>, decltype(entt::basic_view{std::declval<entt::storage<test::pointer_stable> &>()})>();
@@ -372,7 +372,7 @@ TEST(SingleStorageView, DeductionGuide) {
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage<test::pointer_stable>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(std::declval<entt::storage<test::pointer_stable> &>())})>();
 }
 
-TEST(SingleStorageView, IterableViewAlgorithmCompatibility) {
+TEST(ViewSingleStorage, IterableViewAlgorithmCompatibility) {
     entt::storage<char> storage{};
     const entt::basic_view view{storage};
     const entt::entity entity{0};
@@ -385,7 +385,7 @@ TEST(SingleStorageView, IterableViewAlgorithmCompatibility) {
     ASSERT_EQ(std::get<0>(*it), entity);
 }
 
-TEST(SingleStorageView, StableType) {
+TEST(ViewSingleStorage, StableType) {
     entt::storage<test::pointer_stable> storage{};
     entt::basic_view<entt::get_t<entt::storage<test::pointer_stable>>, entt::exclude_t<>> view{};
     const std::array entity{entt::entity{1}, entt::entity{3}};
@@ -451,7 +451,7 @@ TEST(SingleStorageView, StableType) {
     ASSERT_EQ(view->size(), 0u);
 }
 
-TEST(SingleStorageView, Storage) {
+TEST(ViewSingleStorage, Storage) {
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     entt::basic_view view{std::get<0>(storage)};
     entt::basic_view cview{std::as_const(std::get<1>(storage))};
@@ -500,7 +500,7 @@ TEST(SingleStorageView, Storage) {
     ASSERT_EQ(cview.storage<const char>(), nullptr);
 }
 
-TEST(SingleStorageView, ArrowOperator) {
+TEST(ViewSingleStorage, ArrowOperator) {
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     entt::basic_view view{std::get<0>(storage)};
     entt::basic_view cview{std::as_const(std::get<1>(storage))};
@@ -531,7 +531,7 @@ TEST(SingleStorageView, ArrowOperator) {
     ASSERT_EQ(cview.operator->(), nullptr);
 }
 
-TEST(SingleStorageView, SwapStorage) {
+TEST(ViewSingleStorage, SwapStorage) {
     std::tuple<entt::storage<int>, entt::storage<int>> storage{};
     entt::basic_view<entt::get_t<entt::storage<int>>, entt::exclude_t<>> view{};
     entt::basic_view<entt::get_t<const entt::storage<int>>, entt::exclude_t<>> cview{};
@@ -564,7 +564,7 @@ TEST(SingleStorageView, SwapStorage) {
     ASSERT_TRUE(cview.empty());
 }
 
-TEST(SingleStorageView, StorageEntity) {
+TEST(ViewSingleStorage, StorageEntity) {
     entt::storage<entt::entity> storage{};
     entt::basic_view<entt::get_t<entt::storage<entt::entity>>, entt::exclude_t<>> view{};
     const std::array entity{storage.generate(), storage.generate()};
@@ -641,7 +641,7 @@ TEST(SingleStorageView, StorageEntity) {
     ASSERT_EQ(view.back(), static_cast<entt::entity>(entt::null));
 }
 
-TEST(MultiStorageView, Functionalities) {
+TEST(ViewMultiStorage, Functionalities) {
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     const entt::basic_view view{std::get<0>(storage), std::get<1>(storage)};
     const entt::basic_view cview{std::as_const(std::get<0>(storage)), std::as_const(std::get<1>(storage))};
@@ -682,7 +682,7 @@ TEST(MultiStorageView, Functionalities) {
     ASSERT_FALSE(invalid);
 }
 
-TEST(MultiStorageView, Conversion) {
+TEST(ViewMultiStorage, Conversion) {
     entt::basic_view<entt::get_t<entt::storage<int>, const entt::storage<char>>, entt::exclude_t<entt::storage<double>, const entt::storage<float>>> view1{};
     entt::basic_view<entt::get_t<const entt::storage<int>, const entt::storage<char>>, entt::exclude_t<const entt::storage<double>, const entt::storage<float>>> view2{view1};
     entt::basic_view<entt::get_t<entt::storage<int>>, entt::exclude_t<const entt::storage<double>>> view3{view1};
@@ -730,7 +730,7 @@ TEST(MultiStorageView, Conversion) {
     ASSERT_EQ(1u, view4.size());
 }
 
-TEST(MultiStorageView, InvalidView) {
+TEST(ViewMultiStorage, InvalidView) {
     entt::basic_view<entt::get_t<entt::storage<int>>, entt::exclude_t<entt::storage<char>>> view{};
     auto iterable = view.each();
 
@@ -779,7 +779,7 @@ TEST(MultiStorageView, InvalidView) {
     ASSERT_TRUE(view);
 }
 
-TEST(MultiStorageView, Constructors) {
+TEST(ViewMultiStorage, Constructors) {
     entt::storage<int> storage{};
 
     const entt::basic_view<entt::get_t<entt::storage<int>, entt::storage<int>>, entt::exclude_t<>> invalid{};
@@ -794,7 +794,7 @@ TEST(MultiStorageView, Constructors) {
     ASSERT_EQ(from_storage.handle(), from_tuple.handle());
 }
 
-TEST(MultiStorageView, Handle) {
+TEST(ViewMultiStorage, Handle) {
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     entt::basic_view view{std::get<0>(storage), std::get<1>(storage)};
 
@@ -829,7 +829,7 @@ TEST(MultiStorageView, Handle) {
     ASSERT_EQ(handle, view.handle());
 }
 
-TEST(MultiStorageView, Iterator) {
+TEST(ViewMultiStorage, Iterator) {
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     const entt::basic_view view{std::get<0>(storage), std::get<1>(storage)};
     const std::array entity{entt::entity{0}, entt::entity{1}};
@@ -857,7 +857,7 @@ TEST(MultiStorageView, Iterator) {
     ASSERT_EQ(++begin, view.end());
 }
 
-TEST(MultiStorageView, ElementAccess) {
+TEST(ViewMultiStorage, ElementAccess) {
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     const entt::basic_view view{std::get<0>(storage), std::get<1>(storage)};
     const entt::basic_view cview{std::as_const(std::get<0>(storage)), std::as_const(std::get<1>(storage))};
@@ -873,7 +873,7 @@ TEST(MultiStorageView, ElementAccess) {
     ASSERT_EQ(cview[entity[1u]], std::make_tuple(1, '1'));
 }
 
-TEST(MultiStorageView, Contains) {
+TEST(ViewMultiStorage, Contains) {
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     const entt::basic_view view{std::get<0>(storage), std::get<1>(storage)};
     const std::array entity{entt::entity{1}, entt::entity{3}};
@@ -890,7 +890,7 @@ TEST(MultiStorageView, Contains) {
     ASSERT_TRUE(view.contains(entity[1u]));
 }
 
-TEST(MultiStorageView, SizeHint) {
+TEST(ViewMultiStorage, SizeHint) {
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     entt::basic_view view{std::get<0>(storage), std::get<1>(storage)};
     const std::array entity{entt::entity{1}, entt::entity{3}};
@@ -913,7 +913,7 @@ TEST(MultiStorageView, SizeHint) {
     ASSERT_EQ(++view.begin(), view.end());
 }
 
-TEST(MultiStorageView, UseAndRefresh) {
+TEST(ViewMultiStorage, UseAndRefresh) {
     std::tuple<entt::storage<int>, entt::storage<char>, entt::storage<double>> storage{};
     entt::basic_view view{std::forward_as_tuple(std::get<0>(storage), std::get<1>(storage)), std::forward_as_tuple(std::get<2>(storage))};
     const std::array entity{entt::entity{0u}, entt::entity{1u}, entt::entity{2u}};
@@ -942,7 +942,7 @@ TEST(MultiStorageView, UseAndRefresh) {
     ASSERT_EQ(view.handle()->info(), entt::type_id<int>());
 }
 
-TEST(MultiStorageView, Each) {
+TEST(ViewMultiStorage, Each) {
     std::tuple<entt::storage<int>, entt::storage<char>, entt::storage<double>> storage{};
     const entt::basic_view view{std::forward_as_tuple(std::get<0>(storage), std::get<1>(storage)), std::forward_as_tuple(std::get<2>(storage))};
     const entt::basic_view cview{std::as_const(std::get<0>(storage)), std::as_const(std::get<1>(storage))};
@@ -993,7 +993,7 @@ TEST(MultiStorageView, Each) {
     }
 }
 
-TEST(MultiStorageView, EachWithSuggestedType) {
+TEST(ViewMultiStorage, EachWithSuggestedType) {
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     entt::basic_view view{std::get<0>(storage), std::get<1>(storage)};
     const std::array entity{entt::entity{0}, entt::entity{1}, entt::entity{2}, entt::entity{3}};
@@ -1046,7 +1046,7 @@ TEST(MultiStorageView, EachWithSuggestedType) {
     }
 }
 
-TEST(MultiStorageView, EachWithHoles) {
+TEST(ViewMultiStorage, EachWithHoles) {
     std::tuple<entt::storage<char>, entt::storage<test::boxed_int>> storage{};
     const entt::basic_view view{std::get<0>(storage), std::get<1>(storage)};
     const std::array entity{entt::entity{0}, entt::entity{1}, entt::entity{2}};
@@ -1070,7 +1070,7 @@ TEST(MultiStorageView, EachWithHoles) {
     }
 }
 
-TEST(MultiStorageView, ConstNonConstAndAllInBetween) {
+TEST(ViewMultiStorage, ConstNonConstAndAllInBetween) {
     std::tuple<entt::storage<int>, entt::storage<test::empty>, entt::storage<char>> storage{};
     const entt::basic_view view{std::get<0>(storage), std::get<1>(storage), std::as_const(std::get<2>(storage))};
     const entt::entity entity{0};
@@ -1105,7 +1105,7 @@ TEST(MultiStorageView, ConstNonConstAndAllInBetween) {
     }
 }
 
-TEST(MultiStorageView, Find) {
+TEST(ViewMultiStorage, Find) {
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     const entt::basic_view view{std::get<0>(storage), std::as_const(std::get<1>(storage))};
     const std::array entity{entt::entity{0}, entt::entity{1}, entt::entity{2}};
@@ -1131,7 +1131,7 @@ TEST(MultiStorageView, Find) {
     ASSERT_EQ(++it, view.end());
 }
 
-TEST(MultiStorageView, Exclude) {
+TEST(ViewMultiStorage, Exclude) {
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     const entt::basic_view view{std::forward_as_tuple(std::get<0>(storage)), std::forward_as_tuple(std::as_const(std::get<1>(storage)))};
     const std::array entity{entt::entity{0}, entt::entity{1}, entt::entity{2}, entt::entity{3}};
@@ -1174,7 +1174,7 @@ TEST(MultiStorageView, Exclude) {
     }
 }
 
-TEST(MultiStorageView, EmptyType) {
+TEST(ViewMultiStorage, EmptyType) {
     std::tuple<entt::storage<int>, entt::storage<test::empty>> storage{};
     entt::basic_view view{std::get<0>(storage), std::get<1>(storage)};
     const entt::entity entity{0};
@@ -1207,7 +1207,7 @@ TEST(MultiStorageView, EmptyType) {
     }
 }
 
-TEST(MultiStorageView, FrontBack) {
+TEST(ViewMultiStorage, FrontBack) {
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     const entt::basic_view view{std::as_const(std::get<0>(storage)), std::as_const(std::get<1>(storage))};
     const std::array entity{entt::entity{0}, entt::entity{1}, entt::entity{2}};
@@ -1227,7 +1227,7 @@ TEST(MultiStorageView, FrontBack) {
     ASSERT_EQ(view.back(), entity[0u]);
 }
 
-TEST(MultiStorageView, ExtendedGet) {
+TEST(ViewMultiStorage, ExtendedGet) {
     using type = decltype(std::declval<entt::basic_view<entt::get_t<entt::storage<int>, entt::storage<test::empty>, entt::storage<char>>, entt::exclude_t<>>>().get({}));
 
     ASSERT_EQ(std::tuple_size_v<type>, 2u);
@@ -1236,7 +1236,7 @@ TEST(MultiStorageView, ExtendedGet) {
     testing::StaticAssertTypeEq<std::tuple_element_t<1, type>, char &>();
 }
 
-TEST(MultiStorageView, DeductionGuide) {
+TEST(ViewMultiStorage, DeductionGuide) {
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage<int>, entt::storage<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::declval<entt::storage<int> &>(), std::declval<entt::storage<double> &>()})>();
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage<int>, entt::storage<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::declval<const entt::storage<int> &>(), std::declval<entt::storage<double> &>()})>();
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage<int>, const entt::storage<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::declval<entt::storage<int> &>(), std::declval<const entt::storage<double> &>()})>();
@@ -1256,7 +1256,7 @@ TEST(MultiStorageView, DeductionGuide) {
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage<int>>, entt::exclude_t<entt::storage<test::pointer_stable>>>, decltype(entt::basic_view{std::forward_as_tuple(std::declval<entt::storage<int> &>()), std::forward_as_tuple(std::declval<entt::storage<test::pointer_stable> &>())})>();
 }
 
-TEST(MultiStorageView, IterableViewAlgorithmCompatibility) {
+TEST(ViewMultiStorage, IterableViewAlgorithmCompatibility) {
     std::tuple<entt::storage<int>, entt::storage<char>> storage{};
     const entt::basic_view view{std::as_const(std::get<0>(storage)), std::as_const(std::get<1>(storage))};
     const entt::entity entity{0};
@@ -1270,7 +1270,7 @@ TEST(MultiStorageView, IterableViewAlgorithmCompatibility) {
     ASSERT_EQ(std::get<0>(*it), entity);
 }
 
-TEST(MultiStorageView, StableType) {
+TEST(ViewMultiStorage, StableType) {
     std::tuple<entt::storage<int>, entt::storage<test::pointer_stable>> storage{};
     entt::basic_view view{std::get<0>(storage), std::get<1>(storage)};
     const std::array entity{entt::entity{1}, entt::entity{3}};
@@ -1318,7 +1318,7 @@ TEST(MultiStorageView, StableType) {
     ASSERT_EQ(view.size_hint(), 1u);
 }
 
-TEST(MultiStorageView, StableTypeWithExclude) {
+TEST(ViewMultiStorage, StableTypeWithExclude) {
     std::tuple<entt::storage<test::pointer_stable>, entt::storage<int>> storage{};
     const entt::basic_view view{std::forward_as_tuple(std::get<0>(storage)), std::forward_as_tuple(std::get<1>(storage))};
     const std::array entity{entt::entity{1}, entt::entity{3}};
@@ -1356,7 +1356,7 @@ TEST(MultiStorageView, StableTypeWithExclude) {
     });
 }
 
-TEST(MultiStorageView, SameStorageTypes) {
+TEST(ViewMultiStorage, SameStorageTypes) {
     std::tuple<entt::storage<int>, entt::storage<int>> storage{};
     entt::basic_view view{std::get<0>(storage), std::get<1>(storage)};
     const std::array entity{entt::entity{1}, entt::entity{3}};
@@ -1395,7 +1395,7 @@ TEST(MultiStorageView, SameStorageTypes) {
     ASSERT_EQ(view.handle(), &std::get<1>(storage));
 }
 
-TEST(MultiStorageView, Storage) {
+TEST(ViewMultiStorage, Storage) {
     std::tuple<entt::storage<int>, entt::storage<char>, entt::storage<double>, entt::storage<float>> storage{};
     entt::basic_view view{std::forward_as_tuple(std::get<0>(storage), std::as_const(std::get<1>(storage))), std::forward_as_tuple(std::get<2>(storage), std::as_const(std::get<3>(storage)))};
     const entt::entity entity{0};
@@ -1463,7 +1463,7 @@ TEST(MultiStorageView, Storage) {
     ASSERT_EQ(view.storage<const float>(), nullptr);
 }
 
-TEST(MultiStorageView, SwapStorage) {
+TEST(ViewMultiStorage, SwapStorage) {
     std::tuple<entt::storage<int>, entt::storage<char>, entt::storage<int>, entt::storage<char>> storage{};
     entt::basic_view<entt::get_t<entt::storage<int>>, entt::exclude_t<const entt::storage<char>>> view{};
     const entt::entity entity{0};
@@ -1495,7 +1495,7 @@ TEST(MultiStorageView, SwapStorage) {
     ASSERT_EQ(view.size_hint(), 0u);
 }
 
-TEST(MultiStorageView, StorageEntity) {
+TEST(ViewMultiStorage, StorageEntity) {
     std::tuple<entt::storage<entt::entity>, entt::storage<char>> storage{};
     const entt::basic_view view{std::get<0>(storage), std::get<1>(storage)};
     const std::array entity{std::get<0>(storage).generate(), std::get<0>(storage).generate()};
@@ -1528,7 +1528,7 @@ TEST(MultiStorageView, StorageEntity) {
     });
 }
 
-TEST(MultiStorageView, StorageEntityWithExclude) {
+TEST(ViewMultiStorage, StorageEntityWithExclude) {
     std::tuple<entt::storage<entt::entity>, entt::storage<int>, entt::storage<char>> storage{};
     const entt::basic_view view{std::forward_as_tuple(std::get<0>(storage), std::get<1>(storage)), std::forward_as_tuple(std::get<2>(storage))};
     const std::array entity{std::get<0>(storage).generate(), std::get<0>(storage).generate(), std::get<0>(storage).generate()};
@@ -1565,7 +1565,7 @@ TEST(MultiStorageView, StorageEntityWithExclude) {
     });
 }
 
-TEST(MultiStorageView, StorageEntityExcludeOnly) {
+TEST(ViewMultiStorage, StorageEntityExcludeOnly) {
     std::tuple<entt::storage<entt::entity>, entt::storage<int>> storage{};
     const entt::basic_view view{std::forward_as_tuple(std::get<0>(storage)), std::forward_as_tuple(std::get<1>(storage))};
     const std::array entity{std::get<0>(storage).generate(), std::get<0>(storage).generate(), std::get<0>(storage).generate()};