test: minor changes

test/entt/entity/registry.cpp

@@ -22,9 +22,9 @@ bool operator==(const no_eto_type &lhs, const no_eto_type &rhs) {
     return &lhs == &rhs;
 }
 
-struct stable_type {
+struct pointer_stable {
     static constexpr auto in_place_delete = true;
-    int value;
+    int value{};
 };
 
 struct non_default_constructible {
@@ -748,17 +748,17 @@ TEST(Registry, DestroyRange) {
 TEST(Registry, StableDestroy) {
     entt::registry registry;
     const auto iview = registry.view<int>();
-    const auto icview = registry.view<int, stable_type>();
+    const auto icview = registry.view<int, pointer_stable>();
     entt::entity entity[3u];
 
     registry.create(std::begin(entity), std::end(entity));
 
     registry.emplace<int>(entity[0u]);
-    registry.emplace<stable_type>(entity[0u]);
+    registry.emplace<pointer_stable>(entity[0u]);
     registry.emplace<double>(entity[0u]);
 
     registry.emplace<int>(entity[1u]);
-    registry.emplace<stable_type>(entity[1u]);
+    registry.emplace<pointer_stable>(entity[1u]);
 
     registry.emplace<int>(entity[2u]);
 
@@ -773,7 +773,7 @@ TEST(Registry, StableDestroy) {
     ASSERT_TRUE(registry.valid(entity[2u]));
 
     ASSERT_EQ(registry.storage<int>().size(), 1u);
-    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
+    ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
     ASSERT_EQ(registry.storage<double>().size(), 0u);
 
     registry.destroy(iview.begin(), iview.end());
@@ -783,7 +783,7 @@ TEST(Registry, StableDestroy) {
     ASSERT_EQ(icview.size_hint(), 0u);
 
     ASSERT_EQ(registry.storage<int>().size(), 0u);
-    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
+    ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
     ASSERT_EQ(registry.storage<double>().size(), 0u);
 }
 
@@ -1577,17 +1577,17 @@ ENTT_DEBUG_TEST(RegistryDeathTest, Erase) {
 TEST(Registry, StableErase) {
     entt::registry registry;
     const auto iview = registry.view<int>();
-    const auto icview = registry.view<int, stable_type>();
+    const auto icview = registry.view<int, pointer_stable>();
     entt::entity entity[3u];
 
     registry.create(std::begin(entity), std::end(entity));
 
     registry.emplace<int>(entity[0u]);
-    registry.emplace<stable_type>(entity[0u]);
+    registry.emplace<pointer_stable>(entity[0u]);
     registry.emplace<double>(entity[0u]);
 
     registry.emplace<int>(entity[1u]);
-    registry.emplace<stable_type>(entity[1u]);
+    registry.emplace<pointer_stable>(entity[1u]);
 
     registry.emplace<int>(entity[2u]);
 
@@ -1595,16 +1595,16 @@ TEST(Registry, StableErase) {
     ASSERT_TRUE(registry.all_of<int>(entity[1u]));
     ASSERT_TRUE(registry.any_of<int>(entity[2u]));
 
-    registry.erase<int, stable_type>(entity[0u]);
-    registry.erase<int, stable_type>(icview.begin(), icview.end());
-    registry.erase<int, stable_type>(icview.begin(), icview.end());
+    registry.erase<int, pointer_stable>(entity[0u]);
+    registry.erase<int, pointer_stable>(icview.begin(), icview.end());
+    registry.erase<int, pointer_stable>(icview.begin(), icview.end());
 
     ASSERT_FALSE(registry.any_of<int>(entity[0u]));
     ASSERT_FALSE(registry.all_of<int>(entity[1u]));
     ASSERT_TRUE(registry.any_of<int>(entity[2u]));
 
     ASSERT_EQ(registry.storage<int>().size(), 1u);
-    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
+    ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
     ASSERT_EQ(registry.storage<double>().size(), 1u);
 
     registry.erase<int>(iview.begin(), iview.end());
@@ -1612,7 +1612,7 @@ TEST(Registry, StableErase) {
     ASSERT_FALSE(registry.any_of<int>(entity[2u]));
 
     ASSERT_EQ(registry.storage<int>().size(), 0u);
-    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
+    ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
     ASSERT_EQ(registry.storage<double>().size(), 1u);
 }
 
@@ -1727,17 +1727,17 @@ TEST(Registry, Remove) {
 TEST(Registry, StableRemove) {
     entt::registry registry;
     const auto iview = registry.view<int>();
-    const auto icview = registry.view<int, stable_type>();
+    const auto icview = registry.view<int, pointer_stable>();
     entt::entity entity[3u];
 
     registry.create(std::begin(entity), std::end(entity));
 
     registry.emplace<int>(entity[0u]);
-    registry.emplace<stable_type>(entity[0u]);
+    registry.emplace<pointer_stable>(entity[0u]);
     registry.emplace<double>(entity[0u]);
 
     registry.emplace<int>(entity[1u]);
-    registry.emplace<stable_type>(entity[1u]);
+    registry.emplace<pointer_stable>(entity[1u]);
 
     registry.emplace<int>(entity[2u]);
 
@@ -1745,17 +1745,17 @@ TEST(Registry, StableRemove) {
     ASSERT_TRUE(registry.all_of<int>(entity[1u]));
     ASSERT_TRUE(registry.any_of<int>(entity[2u]));
 
-    registry.remove<int, stable_type>(entity[0u]);
+    registry.remove<int, pointer_stable>(entity[0u]);
 
-    ASSERT_EQ((registry.remove<int, stable_type>(icview.begin(), icview.end())), 2u);
-    ASSERT_EQ((registry.remove<int, stable_type>(icview.begin(), icview.end())), 0u);
+    ASSERT_EQ((registry.remove<int, pointer_stable>(icview.begin(), icview.end())), 2u);
+    ASSERT_EQ((registry.remove<int, pointer_stable>(icview.begin(), icview.end())), 0u);
 
     ASSERT_FALSE(registry.any_of<int>(entity[0u]));
     ASSERT_FALSE(registry.all_of<int>(entity[1u]));
     ASSERT_TRUE(registry.any_of<int>(entity[2u]));
 
     ASSERT_EQ(registry.storage<int>().size(), 1u);
-    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
+    ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
     ASSERT_EQ(registry.storage<double>().size(), 1u);
 
     ASSERT_EQ((registry.remove<int>(iview.begin(), iview.end())), 1u);
@@ -1766,7 +1766,7 @@ TEST(Registry, StableRemove) {
     ASSERT_FALSE(registry.any_of<int>(entity[2u]));
 
     ASSERT_EQ(registry.storage<int>().size(), 0u);
-    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
+    ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
     ASSERT_EQ(registry.storage<double>().size(), 1u);
 }
 
@@ -1777,28 +1777,28 @@ TEST(Registry, Compact) {
     registry.create(std::begin(entity), std::end(entity));
 
     registry.emplace<int>(entity[0u]);
-    registry.emplace<stable_type>(entity[0u]);
+    registry.emplace<pointer_stable>(entity[0u]);
 
     registry.emplace<int>(entity[1u]);
-    registry.emplace<stable_type>(entity[1u]);
+    registry.emplace<pointer_stable>(entity[1u]);
 
     ASSERT_EQ(registry.storage<int>().size(), 2u);
-    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
+    ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
 
     registry.destroy(std::begin(entity), std::end(entity));
 
     ASSERT_EQ(registry.storage<int>().size(), 0u);
-    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
+    ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
 
     registry.compact<int>();
 
     ASSERT_EQ(registry.storage<int>().size(), 0u);
-    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
+    ASSERT_EQ(registry.storage<pointer_stable>().size(), 2u);
 
     registry.compact();
 
     ASSERT_EQ(registry.storage<int>().size(), 0u);
-    ASSERT_EQ(registry.storage<stable_type>().size(), 0u);
+    ASSERT_EQ(registry.storage<pointer_stable>().size(), 0u);
 }
 
 TEST(Registry, NonOwningGroupInterleaved) {

test/entt/entity/runtime_view.cpp

@@ -5,9 +5,9 @@
 #include <entt/entity/registry.hpp>
 #include <entt/entity/runtime_view.hpp>
 
-struct stable_type {
+struct pointer_stable {
     static constexpr auto in_place_delete = true;
-    int value;
+    int value{};
 };
 
 template<typename Type>
@@ -341,12 +341,12 @@ TYPED_TEST(RuntimeView, StableType) {
     registry.emplace<int>(e1);
     registry.emplace<int>(e2);
 
-    registry.emplace<stable_type>(e0);
-    registry.emplace<stable_type>(e1);
+    registry.emplace<pointer_stable>(e0);
+    registry.emplace<pointer_stable>(e1);
 
-    registry.remove<stable_type>(e1);
+    registry.remove<pointer_stable>(e1);
 
-    view.iterate(registry.storage<int>()).iterate(registry.storage<stable_type>());
+    view.iterate(registry.storage<int>()).iterate(registry.storage<pointer_stable>());
 
     ASSERT_EQ(view.size_hint(), 2u);
     ASSERT_TRUE(view.contains(e0));
@@ -378,11 +378,11 @@ TYPED_TEST(RuntimeView, StableTypeWithExcludedComponent) {
     const auto entity = registry.create();
     const auto other = registry.create();
 
-    registry.emplace<stable_type>(entity, 0);
-    registry.emplace<stable_type>(other, 42);
+    registry.emplace<pointer_stable>(entity, 0);
+    registry.emplace<pointer_stable>(other, 42);
     registry.emplace<int>(entity);
 
-    view.iterate(registry.storage<stable_type>()).exclude(registry.storage<int>());
+    view.iterate(registry.storage<pointer_stable>()).exclude(registry.storage<int>());
 
     ASSERT_EQ(view.size_hint(), 2u);
     ASSERT_FALSE(view.contains(entity));

test/entt/entity/sigh_mixin.cpp

@@ -8,7 +8,7 @@
 
 struct empty_type {};
 
-struct stable_type {
+struct pointer_stable {
     static constexpr auto in_place_delete = true;
     int value{};
 };
@@ -109,7 +109,7 @@ TEST(SighMixin, GenericType) {
 
 TEST(SighMixin, StableType) {
     entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
-    entt::sigh_mixin<entt::storage<stable_type>> pool;
+    entt::sigh_mixin<entt::storage<pointer_stable>> pool;
     entt::sparse_set &base = pool;
     entt::registry registry;
 
@@ -156,7 +156,7 @@ TEST(SighMixin, StableType) {
     ASSERT_EQ(on_destroy.value, 4);
     ASSERT_EQ(pool.size(), 4u);
 
-    pool.insert(std::begin(entity), std::end(entity), stable_type{3});
+    pool.insert(std::begin(entity), std::end(entity), pointer_stable{3});
 
     ASSERT_EQ(on_construct.value, 6);
     ASSERT_EQ(on_destroy.value, 4);
@@ -540,7 +540,7 @@ TEST(SighMixin, CustomAllocator) {
 
     test(entt::sigh_mixin<entt::basic_storage<int, entt::entity, test::throwing_allocator<int>>>{allocator}, allocator);
     test(entt::sigh_mixin<entt::basic_storage<std::true_type, entt::entity, test::throwing_allocator<std::true_type>>>{allocator}, allocator);
-    test(entt::sigh_mixin<entt::basic_storage<stable_type, entt::entity, test::throwing_allocator<stable_type>>>{allocator}, allocator);
+    test(entt::sigh_mixin<entt::basic_storage<pointer_stable, entt::entity, test::throwing_allocator<pointer_stable>>>{allocator}, allocator);
 }
 
 TEST(SighMixin, ThrowingAllocator) {
@@ -616,7 +616,7 @@ TEST(SighMixin, ThrowingAllocator) {
     };
 
     test(entt::sigh_mixin<entt::basic_storage<int, entt::entity, test::throwing_allocator<int>>>{});
-    test(entt::sigh_mixin<entt::basic_storage<stable_type, entt::entity, test::throwing_allocator<stable_type>>>{});
+    test(entt::sigh_mixin<entt::basic_storage<pointer_stable, entt::entity, test::throwing_allocator<pointer_stable>>>{});
 }
 
 TEST(SighMixin, ThrowingComponent) {

test/entt/entity/view.cpp

@@ -8,9 +8,9 @@
 
 struct empty_type {};
 
-struct stable_type {
+struct pointer_stable {
     static constexpr auto in_place_delete = true;
-    int value;
+    int value{};
 };
 
 TEST(SingleComponentView, Functionalities) {
@@ -420,15 +420,15 @@ TEST(SingleComponentView, FrontBack) {
 TEST(SingleComponentView, DeductionGuide) {
     entt::registry registry;
     entt::storage_type_t<int> istorage;
-    entt::storage_type_t<stable_type> sstorage;
+    entt::storage_type_t<pointer_stable> sstorage;
 
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>>, entt::exclude_t<>>, decltype(entt::basic_view{istorage})>();
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>>, entt::exclude_t<>>, decltype(entt::basic_view{std::as_const(istorage)})>();
-    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<stable_type>>, entt::exclude_t<>>, decltype(entt::basic_view{sstorage})>();
+    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<pointer_stable>>, entt::exclude_t<>>, decltype(entt::basic_view{sstorage})>();
 
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(istorage), std::make_tuple()})>();
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(std::as_const(istorage))})>();
-    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<stable_type>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(sstorage)})>();
+    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<pointer_stable>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(sstorage)})>();
 }
 
 TEST(SingleComponentView, IterableViewAlgorithmCompatibility) {
@@ -446,13 +446,13 @@ TEST(SingleComponentView, IterableViewAlgorithmCompatibility) {
 
 TEST(SingleComponentView, StableType) {
     entt::registry registry;
-    auto view = registry.view<stable_type>();
+    auto view = registry.view<pointer_stable>();
 
     const auto entity = registry.create();
     const auto other = registry.create();
 
-    registry.emplace<stable_type>(entity);
-    registry.emplace<stable_type>(other);
+    registry.emplace<pointer_stable>(entity);
+    registry.emplace<pointer_stable>(other);
     registry.destroy(entity);
 
     ASSERT_EQ(view.size_hint(), 2u);
@@ -465,18 +465,18 @@ TEST(SingleComponentView, StableType) {
     ASSERT_EQ(*view.begin(), other);
     ASSERT_EQ(++view.begin(), view.end());
 
-    view.each([other](const auto entt, stable_type) {
+    view.each([other](const auto entt, pointer_stable) {
         ASSERT_EQ(other, entt);
     });
 
-    view.each([check = true](stable_type) mutable {
+    view.each([check = true](pointer_stable) mutable {
         ASSERT_TRUE(check);
         check = false;
     });
 
     for(auto [entt, st]: view.each()) {
         testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
-        testing::StaticAssertTypeEq<decltype(st), stable_type &>();
+        testing::StaticAssertTypeEq<decltype(st), pointer_stable &>();
         ASSERT_EQ(other, entt);
     }
 
@@ -1256,25 +1256,25 @@ TEST(MultiComponentView, DeductionGuide) {
     entt::registry registry;
     entt::storage_type_t<int> istorage;
     entt::storage_type_t<double> dstorage;
-    entt::storage_type_t<stable_type> sstorage;
+    entt::storage_type_t<pointer_stable> sstorage;
 
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{istorage, dstorage})>();
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>, entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::as_const(istorage), dstorage})>();
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, const entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{istorage, std::as_const(dstorage)})>();
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>, const entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::as_const(istorage), std::as_const(dstorage)})>();
-    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, entt::storage_type_t<stable_type>>, entt::exclude_t<>>, decltype(entt::basic_view{istorage, sstorage})>();
+    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, entt::storage_type_t<pointer_stable>>, entt::exclude_t<>>, decltype(entt::basic_view{istorage, sstorage})>();
 
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(istorage, dstorage), std::make_tuple()})>();
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>, entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(std::as_const(istorage), dstorage)})>();
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, const entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(istorage, std::as_const(dstorage))})>();
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>, const entt::storage_type_t<double>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(std::as_const(istorage), std::as_const(dstorage))})>();
-    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, entt::storage_type_t<stable_type>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(istorage, sstorage)})>();
+    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, entt::storage_type_t<pointer_stable>>, entt::exclude_t<>>, decltype(entt::basic_view{std::forward_as_tuple(istorage, sstorage)})>();
 
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>>, entt::exclude_t<entt::storage_type_t<double>>>, decltype(entt::basic_view{std::forward_as_tuple(istorage), std::forward_as_tuple(dstorage)})>();
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>>, entt::exclude_t<entt::storage_type_t<double>>>, decltype(entt::basic_view{std::forward_as_tuple(std::as_const(istorage)), std::forward_as_tuple(dstorage)})>();
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>>, entt::exclude_t<const entt::storage_type_t<double>>>, decltype(entt::basic_view{std::forward_as_tuple(istorage), std::forward_as_tuple(std::as_const(dstorage))})>();
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<int>>, entt::exclude_t<const entt::storage_type_t<double>>>, decltype(entt::basic_view{std::forward_as_tuple(std::as_const(istorage)), std::forward_as_tuple(std::as_const(dstorage))})>();
-    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>>, entt::exclude_t<entt::storage_type_t<stable_type>>>, decltype(entt::basic_view{std::forward_as_tuple(istorage), std::forward_as_tuple(sstorage)})>();
+    testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>>, entt::exclude_t<entt::storage_type_t<pointer_stable>>>, decltype(entt::basic_view{std::forward_as_tuple(istorage), std::forward_as_tuple(sstorage)})>();
 }
 
 TEST(MultiComponentView, IterableViewAlgorithmCompatibility) {
@@ -1293,20 +1293,20 @@ TEST(MultiComponentView, IterableViewAlgorithmCompatibility) {
 
 TEST(MultiComponentView, StableType) {
     entt::registry registry;
-    auto view = registry.view<int, stable_type>();
+    auto view = registry.view<int, pointer_stable>();
 
     const auto entity = registry.create();
     const auto other = registry.create();
 
     registry.emplace<int>(entity);
     registry.emplace<int>(other);
-    registry.emplace<stable_type>(entity);
-    registry.emplace<stable_type>(other);
+    registry.emplace<pointer_stable>(entity);
+    registry.emplace<pointer_stable>(other);
     registry.destroy(entity);
 
     ASSERT_EQ(view.size_hint(), 1u);
 
-    view.use<stable_type>();
+    view.use<pointer_stable>();
 
     ASSERT_EQ(view.size_hint(), 2u);
     ASSERT_FALSE(view.contains(entity));
@@ -1318,11 +1318,11 @@ TEST(MultiComponentView, StableType) {
     ASSERT_EQ(*view.begin(), other);
     ASSERT_EQ(++view.begin(), view.end());
 
-    view.each([other](const auto entt, int, stable_type) {
+    view.each([other](const auto entt, int, pointer_stable) {
         ASSERT_EQ(other, entt);
     });
 
-    view.each([check = true](int, stable_type) mutable {
+    view.each([check = true](int, pointer_stable) mutable {
         ASSERT_TRUE(check);
         check = false;
     });
@@ -1330,7 +1330,7 @@ TEST(MultiComponentView, StableType) {
     for(auto [entt, iv, st]: view.each()) {
         testing::StaticAssertTypeEq<decltype(entt), entt::entity>();
         testing::StaticAssertTypeEq<decltype(iv), int &>();
-        testing::StaticAssertTypeEq<decltype(st), stable_type &>();
+        testing::StaticAssertTypeEq<decltype(st), pointer_stable &>();
         ASSERT_EQ(other, entt);
     }
 
@@ -1341,13 +1341,13 @@ TEST(MultiComponentView, StableType) {
 
 TEST(MultiComponentView, StableTypeWithExcludedComponent) {
     entt::registry registry;
-    auto view = registry.view<stable_type>(entt::exclude<int>);
+    auto view = registry.view<pointer_stable>(entt::exclude<int>);
 
     const auto entity = registry.create();
     const auto other = registry.create();
 
-    registry.emplace<stable_type>(entity, 0);
-    registry.emplace<stable_type>(other, 42);
+    registry.emplace<pointer_stable>(entity, 0);
+    registry.emplace<pointer_stable>(other, 42);
     registry.emplace<int>(entity);
 
     ASSERT_EQ(view.size_hint(), 2u);
@@ -1629,12 +1629,12 @@ TEST(View, Pipe) {
 
     registry.emplace<int>(other);
     registry.emplace<char>(other);
-    registry.emplace<stable_type>(other);
+    registry.emplace<pointer_stable>(other);
 
     auto view1 = registry.view<int>(entt::exclude<const double>);
     auto view2 = registry.view<const char>(entt::exclude<float>);
     auto view3 = registry.view<empty_type>();
-    auto view4 = registry.view<stable_type>();
+    auto view4 = registry.view<pointer_stable>();
 
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<entt::storage_type_t<int>, const entt::storage_type_t<char>>, entt::exclude_t<const entt::storage_type_t<double>, entt::storage_type_t<float>>>, decltype(view1 | view2)>();
     testing::StaticAssertTypeEq<entt::basic_view<entt::get_t<const entt::storage_type_t<char>, entt::storage_type_t<int>>, entt::exclude_t<entt::storage_type_t<float>, const entt::storage_type_t<double>>>, decltype(view2 | view1)>();
@@ -1668,7 +1668,7 @@ TEST(View, Pipe) {
 
     ASSERT_EQ(pack14.storage<int>(), nullptr);
     ASSERT_EQ(pack14.storage<const double>(), nullptr);
-    ASSERT_NE(pack14.storage<stable_type>(), nullptr);
+    ASSERT_NE(pack14.storage<pointer_stable>(), nullptr);
 
     ASSERT_EQ(pack32.storage<empty_type>(), nullptr);
     ASSERT_NE(pack32.storage<const char>(), nullptr);