From 97d49b4bf398f956b7cd8b04f2c8fc940e352596 Mon Sep 17 00:00:00 2001
From: Michele Caini <michele.caini@gmail.com>
Date: Tue, 3 Oct 2023 14:49:43 +0200
Subject: [PATCH] test: rework storage tests (work in progress)

---
 test/entt/entity/storage.cpp | 989 +++++++++++++++++++----------------
 1 file changed, 527 insertions(+), 462 deletions(-)

diff --git a/test/entt/entity/storage.cpp b/test/entt/entity/storage.cpp
index 2b0c554af..32970e0e7 100644
--- a/test/entt/entity/storage.cpp
+++ b/test/entt/entity/storage.cpp
@@ -14,6 +14,467 @@
 #include "../common/throwing_type.hpp"
 #include "../common/tracked_memory_resource.hpp"
 
+TEST(Storage, Constructors) {
+    entt::storage<int> pool;
+
+    ASSERT_EQ(pool.policy(), entt::deletion_policy::swap_and_pop);
+    ASSERT_NO_FATAL_FAILURE([[maybe_unused]] auto alloc = pool.get_allocator());
+    ASSERT_EQ(pool.type(), entt::type_id<int>());
+
+    pool = entt::storage<int>{std::allocator<int>{}};
+
+    ASSERT_EQ(pool.policy(), entt::deletion_policy::swap_and_pop);
+    ASSERT_NO_FATAL_FAILURE([[maybe_unused]] auto alloc = pool.get_allocator());
+    ASSERT_EQ(pool.type(), entt::type_id<int>());
+}
+
+TEST(BasicStorage, Move) {
+    entt::storage<int> pool;
+
+    pool.emplace(entt::entity{3}, 3);
+
+    ASSERT_TRUE(std::is_move_constructible_v<decltype(pool)>);
+    ASSERT_TRUE(std::is_move_assignable_v<decltype(pool)>);
+
+    entt::storage<int> other{std::move(pool)};
+
+    ASSERT_TRUE(pool.empty());
+    ASSERT_FALSE(other.empty());
+
+    ASSERT_EQ(pool.type(), entt::type_id<int>());
+    ASSERT_EQ(other.type(), entt::type_id<int>());
+
+    ASSERT_EQ(pool.at(0u), static_cast<entt::entity>(entt::null));
+    ASSERT_EQ(other.at(0u), entt::entity{3});
+
+    ASSERT_EQ(other.get(entt::entity{3}), 3);
+
+    entt::storage<int> extended{std::move(other), std::allocator<int>{}};
+
+    ASSERT_TRUE(other.empty());
+    ASSERT_FALSE(extended.empty());
+
+    ASSERT_EQ(other.type(), entt::type_id<int>());
+    ASSERT_EQ(extended.type(), entt::type_id<int>());
+
+    ASSERT_EQ(other.at(0u), static_cast<entt::entity>(entt::null));
+    ASSERT_EQ(extended.at(0u), entt::entity{3});
+
+    ASSERT_EQ(extended.get(entt::entity{3}), 3);
+
+    pool = std::move(extended);
+
+    ASSERT_FALSE(pool.empty());
+    ASSERT_TRUE(other.empty());
+    ASSERT_TRUE(extended.empty());
+
+    ASSERT_EQ(pool.type(), entt::type_id<int>());
+    ASSERT_EQ(other.type(), entt::type_id<int>());
+    ASSERT_EQ(extended.type(), entt::type_id<int>());
+
+    ASSERT_EQ(pool.at(0u), entt::entity{3});
+    ASSERT_EQ(other.at(0u), static_cast<entt::entity>(entt::null));
+    ASSERT_EQ(extended.at(0u), static_cast<entt::entity>(entt::null));
+
+    ASSERT_EQ(pool.get(entt::entity{3}), 3);
+
+    other = entt::storage<int>{};
+    other.emplace(entt::entity{42}, 42);
+    other = std::move(pool);
+
+    ASSERT_TRUE(pool.empty());
+    ASSERT_FALSE(other.empty());
+
+    ASSERT_EQ(pool.type(), entt::type_id<int>());
+    ASSERT_EQ(other.type(), entt::type_id<int>());
+
+    ASSERT_EQ(pool.at(0u), static_cast<entt::entity>(entt::null));
+    ASSERT_EQ(other.at(0u), entt::entity{3});
+
+    ASSERT_EQ(other.get(entt::entity{3}), 3);
+}
+
+TEST(BasicStorage, Swap) {
+    entt::storage<int> pool;
+    entt::storage<int> other;
+
+    ASSERT_EQ(pool.type(), entt::type_id<int>());
+    ASSERT_EQ(other.type(), entt::type_id<int>());
+
+    pool.emplace(entt::entity{42}, 41);
+
+    other.emplace(entt::entity{9}, 8);
+    other.emplace(entt::entity{3}, 2);
+    other.erase(entt::entity{9});
+
+    ASSERT_EQ(pool.size(), 1u);
+    ASSERT_EQ(other.size(), 1u);
+
+    pool.swap(other);
+
+    ASSERT_EQ(pool.type(), entt::type_id<int>());
+    ASSERT_EQ(other.type(), entt::type_id<int>());
+
+    ASSERT_EQ(pool.size(), 1u);
+    ASSERT_EQ(other.size(), 1u);
+
+    ASSERT_EQ(pool.at(0u), entt::entity{3});
+    ASSERT_EQ(other.at(0u), entt::entity{42});
+
+    ASSERT_EQ(pool.get(entt::entity{3}), 2);
+    ASSERT_EQ(other.get(entt::entity{42}), 41);
+}
+
+TEST(BasicStorage, Capacity) {
+    entt::storage<int> pool;
+    constexpr auto page_size = decltype(pool)::traits_type::page_size;
+
+    pool.reserve(42);
+
+    ASSERT_EQ(pool.capacity(), page_size);
+    ASSERT_TRUE(pool.empty());
+
+    pool.reserve(0);
+
+    ASSERT_EQ(pool.capacity(), page_size);
+    ASSERT_TRUE(pool.empty());
+}
+
+TEST(BasicStorage, ShrinkToFit) {
+    entt::storage<int> pool;
+    constexpr auto page_size = decltype(pool)::traits_type::page_size;
+
+    for(std::size_t next{}; next < page_size; ++next) {
+        pool.emplace(entt::entity(next));
+    }
+
+    pool.emplace(entt::entity{page_size});
+    pool.erase(entt::entity{page_size});
+
+    ASSERT_EQ(pool.capacity(), 2 * page_size);
+    ASSERT_EQ(pool.size(), page_size);
+
+    pool.shrink_to_fit();
+
+    ASSERT_EQ(pool.capacity(), page_size);
+    ASSERT_EQ(pool.size(), page_size);
+
+    pool.clear();
+
+    ASSERT_EQ(pool.capacity(), page_size);
+    ASSERT_EQ(pool.size(), 0u);
+
+    pool.shrink_to_fit();
+
+    ASSERT_EQ(pool.capacity(), 0u);
+    ASSERT_EQ(pool.size(), 0u);
+}
+
+TEST(BasicStorage, Raw) {
+    entt::storage<int> pool;
+
+    pool.emplace(entt::entity{3}, 3);
+    pool.emplace(entt::entity{12}, 6);
+    pool.emplace(entt::entity{42}, 9);
+
+    ASSERT_EQ(pool.get(entt::entity{3}), 3);
+    ASSERT_EQ(std::as_const(pool).get(entt::entity{12}), 6);
+    ASSERT_EQ(pool.get(entt::entity{42}), 9);
+
+    ASSERT_EQ(pool.raw()[0u][0u], 3);
+    ASSERT_EQ(std::as_const(pool).raw()[0u][1u], 6);
+    ASSERT_EQ(pool.raw()[0u][2u], 9);
+}
+
+TEST(BasicStorage, Iterator) {
+    using iterator = typename entt::storage<int>::iterator;
+
+    testing::StaticAssertTypeEq<iterator::value_type, int>();
+    testing::StaticAssertTypeEq<iterator::pointer, int *>();
+    testing::StaticAssertTypeEq<iterator::reference, int &>();
+
+    entt::storage<int> pool;
+    pool.emplace(entt::entity{3}, 42);
+
+    iterator end{pool.begin()};
+    iterator begin{};
+
+    begin = pool.end();
+    std::swap(begin, end);
+
+    ASSERT_EQ(begin, pool.begin());
+    ASSERT_EQ(end, pool.end());
+    ASSERT_NE(begin, end);
+
+    ASSERT_EQ(begin.index(), 0);
+    ASSERT_EQ(end.index(), -1);
+
+    ASSERT_EQ(begin++, pool.begin());
+    ASSERT_EQ(begin--, pool.end());
+
+    ASSERT_EQ(begin + 1, pool.end());
+    ASSERT_EQ(end - 1, pool.begin());
+
+    ASSERT_EQ(++begin, pool.end());
+    ASSERT_EQ(--begin, pool.begin());
+
+    ASSERT_EQ(begin += 1, pool.end());
+    ASSERT_EQ(begin -= 1, pool.begin());
+
+    ASSERT_EQ(begin + (end - begin), pool.end());
+    ASSERT_EQ(begin - (begin - end), pool.end());
+
+    ASSERT_EQ(end - (end - begin), pool.begin());
+    ASSERT_EQ(end + (begin - end), pool.begin());
+
+    ASSERT_EQ(begin[0u], *pool.begin().operator->());
+
+    ASSERT_LT(begin, end);
+    ASSERT_LE(begin, pool.begin());
+
+    ASSERT_GT(end, begin);
+    ASSERT_GE(end, pool.end());
+
+    ASSERT_EQ(begin.index(), 0);
+    ASSERT_EQ(end.index(), -1);
+
+    pool.emplace(entt::entity{42}, 3);
+    begin = pool.begin();
+
+    ASSERT_EQ(begin.index(), 1);
+    ASSERT_EQ(end.index(), -1);
+
+    ASSERT_EQ(begin[0u], 3);
+    ASSERT_EQ(begin[1u], 42);
+}
+
+TEST(BasicStorage, ConstIterator) {
+    using iterator = typename entt::storage<int>::const_iterator;
+
+    testing::StaticAssertTypeEq<iterator::value_type, int>();
+    testing::StaticAssertTypeEq<iterator::pointer, const int *>();
+    testing::StaticAssertTypeEq<iterator::reference, const int &>();
+
+    entt::storage<int> pool;
+    pool.emplace(entt::entity{3}, 42);
+
+    iterator cend{pool.cbegin()};
+    iterator cbegin{};
+    cbegin = pool.cend();
+    std::swap(cbegin, cend);
+
+    ASSERT_EQ(cbegin, std::as_const(pool).begin());
+    ASSERT_EQ(cend, std::as_const(pool).end());
+    ASSERT_EQ(cbegin, pool.cbegin());
+    ASSERT_EQ(cend, pool.cend());
+    ASSERT_NE(cbegin, cend);
+
+    ASSERT_EQ(cbegin.index(), 0);
+    ASSERT_EQ(cend.index(), -1);
+
+    ASSERT_EQ(cbegin++, pool.cbegin());
+    ASSERT_EQ(cbegin--, pool.cend());
+
+    ASSERT_EQ(cbegin + 1, pool.cend());
+    ASSERT_EQ(cend - 1, pool.cbegin());
+
+    ASSERT_EQ(++cbegin, pool.cend());
+    ASSERT_EQ(--cbegin, pool.cbegin());
+
+    ASSERT_EQ(cbegin += 1, pool.cend());
+    ASSERT_EQ(cbegin -= 1, pool.cbegin());
+
+    ASSERT_EQ(cbegin + (cend - cbegin), pool.cend());
+    ASSERT_EQ(cbegin - (cbegin - cend), pool.cend());
+
+    ASSERT_EQ(cend - (cend - cbegin), pool.cbegin());
+    ASSERT_EQ(cend + (cbegin - cend), pool.cbegin());
+
+    ASSERT_EQ(cbegin[0u], *pool.cbegin().operator->());
+
+    ASSERT_LT(cbegin, cend);
+    ASSERT_LE(cbegin, pool.cbegin());
+
+    ASSERT_GT(cend, cbegin);
+    ASSERT_GE(cend, pool.cend());
+
+    ASSERT_EQ(cbegin.index(), 0);
+    ASSERT_EQ(cend.index(), -1);
+
+    pool.emplace(entt::entity{42}, 3);
+    cbegin = pool.cbegin();
+
+    ASSERT_EQ(cbegin.index(), 1);
+    ASSERT_EQ(cend.index(), -1);
+
+    ASSERT_EQ(cbegin[0u], 3);
+    ASSERT_EQ(cbegin[1u], 42);
+}
+
+TEST(BasicStorage, ReverseIterator) {
+    using reverse_iterator = typename entt::storage<int>::reverse_iterator;
+
+    testing::StaticAssertTypeEq<reverse_iterator::value_type, int>();
+    testing::StaticAssertTypeEq<reverse_iterator::pointer, int *>();
+    testing::StaticAssertTypeEq<reverse_iterator::reference, int &>();
+
+    entt::storage<int> pool;
+    pool.emplace(entt::entity{3}, 42);
+
+    reverse_iterator end{pool.rbegin()};
+    reverse_iterator begin{};
+    begin = pool.rend();
+    std::swap(begin, end);
+
+    ASSERT_EQ(begin, pool.rbegin());
+    ASSERT_EQ(end, pool.rend());
+    ASSERT_NE(begin, end);
+
+    ASSERT_EQ(begin.base().index(), -1);
+    ASSERT_EQ(end.base().index(), 0);
+
+    ASSERT_EQ(begin++, pool.rbegin());
+    ASSERT_EQ(begin--, pool.rend());
+
+    ASSERT_EQ(begin + 1, pool.rend());
+    ASSERT_EQ(end - 1, pool.rbegin());
+
+    ASSERT_EQ(++begin, pool.rend());
+    ASSERT_EQ(--begin, pool.rbegin());
+
+    ASSERT_EQ(begin += 1, pool.rend());
+    ASSERT_EQ(begin -= 1, pool.rbegin());
+
+    ASSERT_EQ(begin + (end - begin), pool.rend());
+    ASSERT_EQ(begin - (begin - end), pool.rend());
+
+    ASSERT_EQ(end - (end - begin), pool.rbegin());
+    ASSERT_EQ(end + (begin - end), pool.rbegin());
+
+    ASSERT_EQ(begin[0u], *pool.rbegin().operator->());
+
+    ASSERT_LT(begin, end);
+    ASSERT_LE(begin, pool.rbegin());
+
+    ASSERT_GT(end, begin);
+    ASSERT_GE(end, pool.rend());
+
+    ASSERT_EQ(begin.base().index(), -1);
+    ASSERT_EQ(end.base().index(), 0);
+
+    pool.emplace(entt::entity{42}, 3);
+    end = pool.rend();
+
+    ASSERT_EQ(begin.base().index(), -1);
+    ASSERT_EQ(end.base().index(), 1);
+
+    ASSERT_EQ(begin[0u], 42);
+    ASSERT_EQ(begin[1u], 3);
+}
+
+TEST(BasicStorage, ConstReverseIterator) {
+    using const_reverse_iterator = typename entt::storage<int>::const_reverse_iterator;
+
+    testing::StaticAssertTypeEq<const_reverse_iterator::value_type, int>();
+    testing::StaticAssertTypeEq<const_reverse_iterator::pointer, const int *>();
+    testing::StaticAssertTypeEq<const_reverse_iterator::reference, const int &>();
+
+    entt::storage<int> pool;
+    pool.emplace(entt::entity{3}, 42);
+
+    const_reverse_iterator cend{pool.crbegin()};
+    const_reverse_iterator cbegin{};
+    cbegin = pool.crend();
+    std::swap(cbegin, cend);
+
+    ASSERT_EQ(cbegin, std::as_const(pool).rbegin());
+    ASSERT_EQ(cend, std::as_const(pool).rend());
+    ASSERT_EQ(cbegin, pool.crbegin());
+    ASSERT_EQ(cend, pool.crend());
+    ASSERT_NE(cbegin, cend);
+
+    ASSERT_EQ(cbegin.base().index(), -1);
+    ASSERT_EQ(cend.base().index(), 0);
+
+    ASSERT_EQ(cbegin++, pool.crbegin());
+    ASSERT_EQ(cbegin--, pool.crend());
+
+    ASSERT_EQ(cbegin + 1, pool.crend());
+    ASSERT_EQ(cend - 1, pool.crbegin());
+
+    ASSERT_EQ(++cbegin, pool.crend());
+    ASSERT_EQ(--cbegin, pool.crbegin());
+
+    ASSERT_EQ(cbegin += 1, pool.crend());
+    ASSERT_EQ(cbegin -= 1, pool.crbegin());
+
+    ASSERT_EQ(cbegin + (cend - cbegin), pool.crend());
+    ASSERT_EQ(cbegin - (cbegin - cend), pool.crend());
+
+    ASSERT_EQ(cend - (cend - cbegin), pool.crbegin());
+    ASSERT_EQ(cend + (cbegin - cend), pool.crbegin());
+
+    ASSERT_EQ(cbegin[0u], *pool.crbegin().operator->());
+
+    ASSERT_LT(cbegin, cend);
+    ASSERT_LE(cbegin, pool.crbegin());
+
+    ASSERT_GT(cend, cbegin);
+    ASSERT_GE(cend, pool.crend());
+
+    ASSERT_EQ(cbegin.base().index(), -1);
+    ASSERT_EQ(cend.base().index(), 0);
+
+    pool.emplace(entt::entity{42}, 3);
+    cend = pool.crend();
+
+    ASSERT_EQ(cbegin.base().index(), -1);
+    ASSERT_EQ(cend.base().index(), 1);
+
+    ASSERT_EQ(cbegin[0u], 42);
+    ASSERT_EQ(cbegin[1u], 3);
+}
+
+TEST(BasicStorage, IteratorConversion) {
+    entt::storage<int> pool;
+    pool.emplace(entt::entity{3}, 42);
+
+    typename entt::storage<int>::iterator it = pool.begin();
+    typename entt::storage<int>::const_iterator cit = it;
+
+    testing::StaticAssertTypeEq<decltype(*it), int &>();
+    testing::StaticAssertTypeEq<decltype(*cit), const int &>();
+
+    ASSERT_EQ(*it.operator->(), 42);
+    ASSERT_EQ(*it.operator->(), *cit);
+
+    ASSERT_EQ(it - cit, 0);
+    ASSERT_EQ(cit - it, 0);
+    ASSERT_LE(it, cit);
+    ASSERT_LE(cit, it);
+    ASSERT_GE(it, cit);
+    ASSERT_GE(cit, it);
+    ASSERT_EQ(it, cit);
+    ASSERT_NE(++cit, it);
+}
+
+TEST(BasicStorage, IteratorPageSizeAwareness) {
+    entt::storage<int> pool;
+    constexpr auto page_size = decltype(pool)::traits_type::page_size;
+    const int check{42};
+
+    for(unsigned int next{}; next < page_size; ++next) {
+        pool.emplace(entt::entity{next});
+    }
+
+    pool.emplace(entt::entity{page_size}, check);
+
+    // test the proper use of component traits by the storage iterator
+    ASSERT_EQ(*pool.begin(), check);
+}
+
+// <<<<<<<<<<<< REWORK IN PROGRESS [common/empty/stable/void/entity] <<<<<<<<<<<<
+
 struct pinned_type {
     const int value{42};
 };
@@ -96,15 +557,15 @@ inline bool operator==(const boxed_int &lhs, const boxed_int &rhs) {
     return lhs.value == rhs.value;
 }
 
-struct Storage: ::testing::Test {
+struct StorageOld: ::testing::Test {
     void SetUp() override {
         aggregate_tracking_type::counter = 0;
     }
 };
 
-using StorageDeathTest = Storage;
+using StorageOldDeathTest = StorageOld;
 
-TEST_F(Storage, Functionalities) {
+TEST_F(StorageOld, Functionalities) {
     entt::storage<int> pool;
     constexpr auto page_size = decltype(pool)::traits_type::page_size;
 
@@ -172,71 +633,7 @@ TEST_F(Storage, Functionalities) {
     ASSERT_EQ(pool.capacity(), 0u);
 }
 
-TEST_F(Storage, Move) {
-    entt::storage<int> pool;
-    pool.emplace(entt::entity{3}, 3);
-
-    ASSERT_TRUE(std::is_move_constructible_v<decltype(pool)>);
-    ASSERT_TRUE(std::is_move_assignable_v<decltype(pool)>);
-    ASSERT_EQ(pool.type(), entt::type_id<int>());
-
-    entt::storage<int> other{std::move(pool)};
-
-    ASSERT_TRUE(pool.empty());
-    ASSERT_FALSE(other.empty());
-    ASSERT_EQ(other.type(), entt::type_id<int>());
-    ASSERT_EQ(pool.at(0u), static_cast<entt::entity>(entt::null));
-    ASSERT_EQ(other.at(0u), entt::entity{3});
-    ASSERT_EQ(other.get(entt::entity{3}), 3);
-
-    pool = std::move(other);
-
-    ASSERT_FALSE(pool.empty());
-    ASSERT_TRUE(other.empty());
-    ASSERT_EQ(pool.at(0u), entt::entity{3});
-    ASSERT_EQ(pool.get(entt::entity{3}), 3);
-    ASSERT_EQ(other.at(0u), static_cast<entt::entity>(entt::null));
-
-    other = entt::storage<int>{};
-    other.emplace(entt::entity{42}, 42);
-    other = std::move(pool);
-
-    ASSERT_TRUE(pool.empty());
-    ASSERT_FALSE(other.empty());
-    ASSERT_EQ(pool.at(0u), static_cast<entt::entity>(entt::null));
-    ASSERT_EQ(other.at(0u), entt::entity{3});
-    ASSERT_EQ(other.get(entt::entity{3}), 3);
-}
-
-TEST_F(Storage, Swap) {
-    entt::storage<int> pool;
-    entt::storage<int> other;
-
-    pool.emplace(entt::entity{42}, 41);
-
-    other.emplace(entt::entity{9}, 8);
-    other.emplace(entt::entity{3}, 2);
-    other.erase(entt::entity{9});
-
-    ASSERT_EQ(pool.size(), 1u);
-    ASSERT_EQ(other.size(), 1u);
-
-    pool.swap(other);
-
-    ASSERT_EQ(pool.type(), entt::type_id<int>());
-    ASSERT_EQ(other.type(), entt::type_id<int>());
-
-    ASSERT_EQ(pool.size(), 1u);
-    ASSERT_EQ(other.size(), 1u);
-
-    ASSERT_EQ(pool.at(0u), entt::entity{3});
-    ASSERT_EQ(pool.get(entt::entity{3}), 2);
-
-    ASSERT_EQ(other.at(0u), entt::entity{42});
-    ASSERT_EQ(other.get(entt::entity{42}), 41);
-}
-
-TEST_F(Storage, StableSwap) {
+TEST_F(StorageOld, StableSwap) {
     entt::storage<stable_type> pool;
     entt::storage<stable_type> other;
 
@@ -264,7 +661,7 @@ TEST_F(Storage, StableSwap) {
     ASSERT_EQ(other.get(entt::entity{42}).value, 41);
 }
 
-TEST_F(Storage, VoidType) {
+TEST_F(StorageOld, VoidType) {
     entt::storage<void> pool;
     pool.emplace(entt::entity{99});
 
@@ -282,7 +679,7 @@ TEST_F(Storage, VoidType) {
     ASSERT_FALSE(other.contains(entt::entity{99}));
 }
 
-TEST_F(Storage, EmptyType) {
+TEST_F(StorageOld, EmptyType) {
     entt::storage<empty_stable_type> pool;
     pool.emplace(entt::entity{99});
 
@@ -304,7 +701,7 @@ TEST_F(Storage, EmptyType) {
     ASSERT_EQ(pool.get_as_tuple(entt::entity{99}), std::tuple<>{});
 }
 
-ENTT_DEBUG_TEST_F(StorageDeathTest, EmptyType) {
+ENTT_DEBUG_TEST_F(StorageOldDeathTest, EmptyType) {
     entt::storage<empty_stable_type> pool;
     pool.emplace(entt::entity{99});
 
@@ -312,7 +709,7 @@ ENTT_DEBUG_TEST_F(StorageDeathTest, EmptyType) {
     ASSERT_DEATH([[maybe_unused]] auto tup = pool.get_as_tuple(entt::entity{3}), "");
 }
 
-TEST_F(Storage, Patch) {
+TEST_F(StorageOld, Patch) {
     entt::storage<int> pool;
     entt::entity entity{42};
     auto callback = [](int &value) { ++value; };
@@ -328,13 +725,13 @@ TEST_F(Storage, Patch) {
     ASSERT_EQ(pool.get(entity), 3);
 }
 
-ENTT_DEBUG_TEST_F(StorageDeathTest, Patch) {
+ENTT_DEBUG_TEST_F(StorageOldDeathTest, Patch) {
     entt::storage<int> pool;
 
     ASSERT_DEATH(pool.patch(entt::null), "");
 }
 
-TEST_F(Storage, PatchEmptyType) {
+TEST_F(StorageOld, PatchEmptyType) {
     entt::storage<empty_stable_type> pool;
     entt::entity entity{42};
 
@@ -352,13 +749,13 @@ TEST_F(Storage, PatchEmptyType) {
     ASSERT_EQ(counter, 3);
 }
 
-ENTT_DEBUG_TEST_F(StorageDeathTest, PatchEmptyType) {
+ENTT_DEBUG_TEST_F(StorageOldDeathTest, PatchEmptyType) {
     entt::storage<empty_stable_type> pool;
 
     ASSERT_DEATH(pool.patch(entt::null), "");
 }
 
-TEST_F(Storage, Insert) {
+TEST_F(StorageOld, Insert) {
     entt::storage<stable_type> pool;
     entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
     entt::storage<stable_type>::iterator it{};
@@ -394,7 +791,7 @@ TEST_F(Storage, Insert) {
     ASSERT_EQ(it->value, 42);
 }
 
-TEST_F(Storage, InsertEmptyType) {
+TEST_F(StorageOld, InsertEmptyType) {
     entt::storage<empty_stable_type> pool;
     entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
 
@@ -417,7 +814,7 @@ TEST_F(Storage, InsertEmptyType) {
     ASSERT_EQ(pool.index(entity[1u]), 2u);
 }
 
-TEST_F(Storage, Erase) {
+TEST_F(StorageOld, Erase) {
     entt::storage<int> pool;
     entt::entity entity[3u]{entt::entity{3}, entt::entity{42}, entt::entity{9}};
 
@@ -450,7 +847,7 @@ TEST_F(Storage, Erase) {
     ASSERT_EQ(*pool.begin(), 1);
 }
 
-TEST_F(Storage, CrossErase) {
+TEST_F(StorageOld, CrossErase) {
     entt::sparse_set set;
     entt::storage<int> pool;
     entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
@@ -465,7 +862,7 @@ TEST_F(Storage, CrossErase) {
     ASSERT_EQ(pool.raw()[0u][0u], 3);
 }
 
-TEST_F(Storage, StableErase) {
+TEST_F(StorageOld, StableErase) {
     entt::storage<stable_type> pool;
     entt::entity entity[3u]{entt::entity{3}, entt::entity{42}, entt::entity{9}};
 
@@ -559,7 +956,7 @@ TEST_F(Storage, StableErase) {
     ASSERT_EQ(pool.get(entity[2u]).value, 1);
 }
 
-TEST_F(Storage, CrossStableErase) {
+TEST_F(StorageOld, CrossStableErase) {
     entt::sparse_set set;
     entt::storage<stable_type> pool;
     entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
@@ -574,7 +971,7 @@ TEST_F(Storage, CrossStableErase) {
     ASSERT_EQ(pool.raw()[0u][0u].value, 3);
 }
 
-TEST_F(Storage, Remove) {
+TEST_F(StorageOld, Remove) {
     entt::storage<int> pool;
     entt::entity entity[3u]{entt::entity{3}, entt::entity{42}, entt::entity{9}};
 
@@ -608,7 +1005,7 @@ TEST_F(Storage, Remove) {
     ASSERT_EQ(*pool.begin(), 1);
 }
 
-TEST_F(Storage, CrossRemove) {
+TEST_F(StorageOld, CrossRemove) {
     entt::sparse_set set;
     entt::storage<int> pool;
     entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
@@ -623,7 +1020,7 @@ TEST_F(Storage, CrossRemove) {
     ASSERT_EQ(pool.raw()[0u][0u], 3);
 }
 
-TEST_F(Storage, StableRemove) {
+TEST_F(StorageOld, StableRemove) {
     entt::storage<stable_type> pool;
     entt::entity entity[3u]{entt::entity{3}, entt::entity{42}, entt::entity{9}};
 
@@ -720,7 +1117,7 @@ TEST_F(Storage, StableRemove) {
     ASSERT_EQ(pool.get(entity[2u]).value, 1);
 }
 
-TEST_F(Storage, CrossStableRemove) {
+TEST_F(StorageOld, CrossStableRemove) {
     entt::sparse_set set;
     entt::storage<stable_type> pool;
     entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
@@ -735,7 +1132,7 @@ TEST_F(Storage, CrossStableRemove) {
     ASSERT_EQ(pool.raw()[0u][0u].value, 3);
 }
 
-TEST_F(Storage, TypeFromBase) {
+TEST_F(StorageOld, TypeFromBase) {
     entt::storage<int> pool;
     entt::sparse_set &base = pool;
     entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
@@ -769,7 +1166,7 @@ TEST_F(Storage, TypeFromBase) {
     ASSERT_TRUE(pool.empty());
 }
 
-TEST_F(Storage, EmptyTypeFromBase) {
+TEST_F(StorageOld, EmptyTypeFromBase) {
     entt::storage<empty_stable_type> pool;
     entt::sparse_set &base = pool;
     entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
@@ -820,7 +1217,7 @@ TEST_F(Storage, EmptyTypeFromBase) {
     }
 }
 
-TEST_F(Storage, NonDefaultConstructibleTypeFromBase) {
+TEST_F(StorageOld, NonDefaultConstructibleTypeFromBase) {
     entt::storage<non_default_constructible> pool;
     entt::sparse_set &base = pool;
     entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
@@ -859,7 +1256,7 @@ TEST_F(Storage, NonDefaultConstructibleTypeFromBase) {
     ASSERT_TRUE(pool.empty());
 }
 
-TEST_F(Storage, NonCopyConstructibleTypeFromBase) {
+TEST_F(StorageOld, NonCopyConstructibleTypeFromBase) {
     entt::storage<std::unique_ptr<int>> pool;
     entt::sparse_set &base = pool;
     entt::entity entity[2u]{entt::entity{3}, entt::entity{42}};
@@ -898,7 +1295,7 @@ TEST_F(Storage, NonCopyConstructibleTypeFromBase) {
     ASSERT_FALSE(pool.empty());
 }
 
-TEST_F(Storage, Compact) {
+TEST_F(StorageOld, Compact) {
     entt::storage<stable_type> pool;
 
     ASSERT_TRUE(pool.empty());
@@ -944,37 +1341,7 @@ TEST_F(Storage, Compact) {
     ASSERT_TRUE(pool.empty());
 }
 
-TEST_F(Storage, ShrinkToFit) {
-    entt::storage<int> pool;
-    constexpr auto page_size = decltype(pool)::traits_type::page_size;
-
-    for(std::size_t next{}; next < page_size; ++next) {
-        pool.emplace(entt::entity(next));
-    }
-
-    pool.emplace(entt::entity{page_size});
-    pool.erase(entt::entity{page_size});
-
-    ASSERT_EQ(pool.capacity(), 2 * page_size);
-    ASSERT_EQ(pool.size(), page_size);
-
-    pool.shrink_to_fit();
-
-    ASSERT_EQ(pool.capacity(), page_size);
-    ASSERT_EQ(pool.size(), page_size);
-
-    pool.clear();
-
-    ASSERT_EQ(pool.capacity(), page_size);
-    ASSERT_EQ(pool.size(), 0u);
-
-    pool.shrink_to_fit();
-
-    ASSERT_EQ(pool.capacity(), 0u);
-    ASSERT_EQ(pool.size(), 0u);
-}
-
-TEST_F(Storage, AggregatesMustWork) {
+TEST_F(StorageOld, AggregatesMustWork) {
     ASSERT_TRUE(std::is_aggregate_v<aggregate_tracking_type>);
     entt::storage<aggregate_tracking_type> storage{};
 
@@ -989,7 +1356,7 @@ TEST_F(Storage, AggregatesMustWork) {
     ASSERT_EQ(aggregate_tracking_type::counter, 1);
 }
 
-TEST_F(Storage, SelfMoveSupport) {
+TEST_F(StorageOld, SelfMoveSupport) {
     // see #37 - this test shouldn't crash, that's all
     entt::storage<std::unordered_set<int>> pool;
     entt::entity entity{};
@@ -1002,7 +1369,7 @@ TEST_F(Storage, SelfMoveSupport) {
     ASSERT_FALSE(pool.contains(entity));
 }
 
-TEST_F(Storage, SelfMoveSupportInPlaceDelete) {
+TEST_F(StorageOld, SelfMoveSupportInPlaceDelete) {
     // see #37 - this test shouldn't crash, that's all
     entt::storage<std::unordered_set<char>> pool;
     entt::entity entity{};
@@ -1015,293 +1382,7 @@ TEST_F(Storage, SelfMoveSupportInPlaceDelete) {
     ASSERT_FALSE(pool.contains(entity));
 }
 
-TEST_F(Storage, Iterator) {
-    using iterator = typename entt::storage<boxed_int>::iterator;
-
-    testing::StaticAssertTypeEq<iterator::value_type, boxed_int>();
-    testing::StaticAssertTypeEq<iterator::pointer, boxed_int *>();
-    testing::StaticAssertTypeEq<iterator::reference, boxed_int &>();
-
-    entt::storage<boxed_int> pool;
-    pool.emplace(entt::entity{3}, 42);
-
-    iterator end{pool.begin()};
-    iterator begin{};
-    begin = pool.end();
-    std::swap(begin, end);
-
-    ASSERT_EQ(begin, pool.begin());
-    ASSERT_EQ(end, pool.end());
-    ASSERT_NE(begin, end);
-
-    ASSERT_EQ(begin.index(), 0);
-    ASSERT_EQ(end.index(), -1);
-
-    ASSERT_EQ(begin++, pool.begin());
-    ASSERT_EQ(begin--, pool.end());
-
-    ASSERT_EQ(begin + 1, pool.end());
-    ASSERT_EQ(end - 1, pool.begin());
-
-    ASSERT_EQ(++begin, pool.end());
-    ASSERT_EQ(--begin, pool.begin());
-
-    ASSERT_EQ(begin += 1, pool.end());
-    ASSERT_EQ(begin -= 1, pool.begin());
-
-    ASSERT_EQ(begin + (end - begin), pool.end());
-    ASSERT_EQ(begin - (begin - end), pool.end());
-
-    ASSERT_EQ(end - (end - begin), pool.begin());
-    ASSERT_EQ(end + (begin - end), pool.begin());
-
-    ASSERT_EQ(begin[0u].value, pool.begin()->value);
-
-    ASSERT_LT(begin, end);
-    ASSERT_LE(begin, pool.begin());
-
-    ASSERT_GT(end, begin);
-    ASSERT_GE(end, pool.end());
-
-    ASSERT_EQ(begin.index(), 0);
-    ASSERT_EQ(end.index(), -1);
-
-    pool.emplace(entt::entity{42}, 3);
-    begin = pool.begin();
-
-    ASSERT_EQ(begin.index(), 1);
-    ASSERT_EQ(end.index(), -1);
-
-    ASSERT_EQ(begin[0u], boxed_int{3});
-    ASSERT_EQ(begin[1u], boxed_int{42});
-}
-
-TEST_F(Storage, ConstIterator) {
-    using iterator = typename entt::storage<boxed_int>::const_iterator;
-
-    testing::StaticAssertTypeEq<iterator::value_type, boxed_int>();
-    testing::StaticAssertTypeEq<iterator::pointer, const boxed_int *>();
-    testing::StaticAssertTypeEq<iterator::reference, const boxed_int &>();
-
-    entt::storage<boxed_int> pool;
-    pool.emplace(entt::entity{3}, 42);
-
-    iterator cend{pool.cbegin()};
-    iterator cbegin{};
-    cbegin = pool.cend();
-    std::swap(cbegin, cend);
-
-    ASSERT_EQ(cbegin, std::as_const(pool).begin());
-    ASSERT_EQ(cend, std::as_const(pool).end());
-    ASSERT_EQ(cbegin, pool.cbegin());
-    ASSERT_EQ(cend, pool.cend());
-    ASSERT_NE(cbegin, cend);
-
-    ASSERT_EQ(cbegin.index(), 0);
-    ASSERT_EQ(cend.index(), -1);
-
-    ASSERT_EQ(cbegin++, pool.cbegin());
-    ASSERT_EQ(cbegin--, pool.cend());
-
-    ASSERT_EQ(cbegin + 1, pool.cend());
-    ASSERT_EQ(cend - 1, pool.cbegin());
-
-    ASSERT_EQ(++cbegin, pool.cend());
-    ASSERT_EQ(--cbegin, pool.cbegin());
-
-    ASSERT_EQ(cbegin += 1, pool.cend());
-    ASSERT_EQ(cbegin -= 1, pool.cbegin());
-
-    ASSERT_EQ(cbegin + (cend - cbegin), pool.cend());
-    ASSERT_EQ(cbegin - (cbegin - cend), pool.cend());
-
-    ASSERT_EQ(cend - (cend - cbegin), pool.cbegin());
-    ASSERT_EQ(cend + (cbegin - cend), pool.cbegin());
-
-    ASSERT_EQ(cbegin[0u].value, pool.cbegin()->value);
-
-    ASSERT_LT(cbegin, cend);
-    ASSERT_LE(cbegin, pool.cbegin());
-
-    ASSERT_GT(cend, cbegin);
-    ASSERT_GE(cend, pool.cend());
-
-    ASSERT_EQ(cbegin.index(), 0);
-    ASSERT_EQ(cend.index(), -1);
-
-    pool.emplace(entt::entity{42}, 3);
-    cbegin = pool.cbegin();
-
-    ASSERT_EQ(cbegin.index(), 1);
-    ASSERT_EQ(cend.index(), -1);
-
-    ASSERT_EQ(cbegin[0u], boxed_int{3});
-    ASSERT_EQ(cbegin[1u], boxed_int{42});
-}
-
-TEST_F(Storage, ReverseIterator) {
-    using reverse_iterator = typename entt::storage<boxed_int>::reverse_iterator;
-
-    testing::StaticAssertTypeEq<reverse_iterator::value_type, boxed_int>();
-    testing::StaticAssertTypeEq<reverse_iterator::pointer, boxed_int *>();
-    testing::StaticAssertTypeEq<reverse_iterator::reference, boxed_int &>();
-
-    entt::storage<boxed_int> pool;
-    pool.emplace(entt::entity{3}, 42);
-
-    reverse_iterator end{pool.rbegin()};
-    reverse_iterator begin{};
-    begin = pool.rend();
-    std::swap(begin, end);
-
-    ASSERT_EQ(begin, pool.rbegin());
-    ASSERT_EQ(end, pool.rend());
-    ASSERT_NE(begin, end);
-
-    ASSERT_EQ(begin.base().index(), -1);
-    ASSERT_EQ(end.base().index(), 0);
-
-    ASSERT_EQ(begin++, pool.rbegin());
-    ASSERT_EQ(begin--, pool.rend());
-
-    ASSERT_EQ(begin + 1, pool.rend());
-    ASSERT_EQ(end - 1, pool.rbegin());
-
-    ASSERT_EQ(++begin, pool.rend());
-    ASSERT_EQ(--begin, pool.rbegin());
-
-    ASSERT_EQ(begin += 1, pool.rend());
-    ASSERT_EQ(begin -= 1, pool.rbegin());
-
-    ASSERT_EQ(begin + (end - begin), pool.rend());
-    ASSERT_EQ(begin - (begin - end), pool.rend());
-
-    ASSERT_EQ(end - (end - begin), pool.rbegin());
-    ASSERT_EQ(end + (begin - end), pool.rbegin());
-
-    ASSERT_EQ(begin[0u].value, pool.rbegin()->value);
-
-    ASSERT_LT(begin, end);
-    ASSERT_LE(begin, pool.rbegin());
-
-    ASSERT_GT(end, begin);
-    ASSERT_GE(end, pool.rend());
-
-    ASSERT_EQ(begin.base().index(), -1);
-    ASSERT_EQ(end.base().index(), 0);
-
-    pool.emplace(entt::entity{42}, 3);
-    end = pool.rend();
-
-    ASSERT_EQ(begin.base().index(), -1);
-    ASSERT_EQ(end.base().index(), 1);
-
-    ASSERT_EQ(begin[0u], boxed_int{42});
-    ASSERT_EQ(begin[1u], boxed_int{3});
-}
-
-TEST_F(Storage, ConstReverseIterator) {
-    using const_reverse_iterator = typename entt::storage<boxed_int>::const_reverse_iterator;
-
-    testing::StaticAssertTypeEq<const_reverse_iterator::value_type, boxed_int>();
-    testing::StaticAssertTypeEq<const_reverse_iterator::pointer, const boxed_int *>();
-    testing::StaticAssertTypeEq<const_reverse_iterator::reference, const boxed_int &>();
-
-    entt::storage<boxed_int> pool;
-    pool.emplace(entt::entity{3}, 42);
-
-    const_reverse_iterator cend{pool.crbegin()};
-    const_reverse_iterator cbegin{};
-    cbegin = pool.crend();
-    std::swap(cbegin, cend);
-
-    ASSERT_EQ(cbegin, std::as_const(pool).rbegin());
-    ASSERT_EQ(cend, std::as_const(pool).rend());
-    ASSERT_EQ(cbegin, pool.crbegin());
-    ASSERT_EQ(cend, pool.crend());
-    ASSERT_NE(cbegin, cend);
-
-    ASSERT_EQ(cbegin.base().index(), -1);
-    ASSERT_EQ(cend.base().index(), 0);
-
-    ASSERT_EQ(cbegin++, pool.crbegin());
-    ASSERT_EQ(cbegin--, pool.crend());
-
-    ASSERT_EQ(cbegin + 1, pool.crend());
-    ASSERT_EQ(cend - 1, pool.crbegin());
-
-    ASSERT_EQ(++cbegin, pool.crend());
-    ASSERT_EQ(--cbegin, pool.crbegin());
-
-    ASSERT_EQ(cbegin += 1, pool.crend());
-    ASSERT_EQ(cbegin -= 1, pool.crbegin());
-
-    ASSERT_EQ(cbegin + (cend - cbegin), pool.crend());
-    ASSERT_EQ(cbegin - (cbegin - cend), pool.crend());
-
-    ASSERT_EQ(cend - (cend - cbegin), pool.crbegin());
-    ASSERT_EQ(cend + (cbegin - cend), pool.crbegin());
-
-    ASSERT_EQ(cbegin[0u].value, pool.crbegin()->value);
-
-    ASSERT_LT(cbegin, cend);
-    ASSERT_LE(cbegin, pool.crbegin());
-
-    ASSERT_GT(cend, cbegin);
-    ASSERT_GE(cend, pool.crend());
-
-    ASSERT_EQ(cbegin.base().index(), -1);
-    ASSERT_EQ(cend.base().index(), 0);
-
-    pool.emplace(entt::entity{42}, 3);
-    cend = pool.crend();
-
-    ASSERT_EQ(cbegin.base().index(), -1);
-    ASSERT_EQ(cend.base().index(), 1);
-
-    ASSERT_EQ(cbegin[0u], boxed_int{42});
-    ASSERT_EQ(cbegin[1u], boxed_int{3});
-}
-
-TEST_F(Storage, IteratorConversion) {
-    entt::storage<boxed_int> pool;
-    pool.emplace(entt::entity{3}, 42);
-
-    typename entt::storage<boxed_int>::iterator it = pool.begin();
-    typename entt::storage<boxed_int>::const_iterator cit = it;
-
-    testing::StaticAssertTypeEq<decltype(*it), boxed_int &>();
-    testing::StaticAssertTypeEq<decltype(*cit), const boxed_int &>();
-
-    ASSERT_EQ(it->value, 42);
-    ASSERT_EQ(it->value, cit->value);
-
-    ASSERT_EQ(it - cit, 0);
-    ASSERT_EQ(cit - it, 0);
-    ASSERT_LE(it, cit);
-    ASSERT_LE(cit, it);
-    ASSERT_GE(it, cit);
-    ASSERT_GE(cit, it);
-    ASSERT_EQ(it, cit);
-    ASSERT_NE(++cit, it);
-}
-
-TEST_F(Storage, IteratorPageSizeAwareness) {
-    entt::storage<std::unordered_set<char>> pool;
-    constexpr auto page_size = decltype(pool)::traits_type::page_size;
-    const std::unordered_set<char> check{'c'};
-
-    for(unsigned int next{}; next < page_size; ++next) {
-        pool.emplace(entt::entity{next});
-    }
-
-    pool.emplace(entt::entity{page_size}, check);
-
-    // test the proper use of component traits by the storage iterator
-    ASSERT_EQ(*pool.begin(), check);
-}
-
-TEST_F(Storage, Iterable) {
+TEST_F(StorageOld, Iterable) {
     using iterator = typename entt::storage<boxed_int>::iterable::iterator;
 
     testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity, boxed_int &>>();
@@ -1345,7 +1426,7 @@ TEST_F(Storage, Iterable) {
     }
 }
 
-TEST_F(Storage, ConstIterable) {
+TEST_F(StorageOld, ConstIterable) {
     using iterator = typename entt::storage<boxed_int>::const_iterable::iterator;
 
     testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity, const boxed_int &>>();
@@ -1389,7 +1470,7 @@ TEST_F(Storage, ConstIterable) {
     }
 }
 
-TEST_F(Storage, IterableIteratorConversion) {
+TEST_F(StorageOld, IterableIteratorConversion) {
     entt::storage<boxed_int> pool;
     pool.emplace(entt::entity{3}, 42);
 
@@ -1403,7 +1484,7 @@ TEST_F(Storage, IterableIteratorConversion) {
     ASSERT_NE(++cit, it);
 }
 
-TEST_F(Storage, EmptyTypeIterable) {
+TEST_F(StorageOld, EmptyTypeIterable) {
     using iterator = typename entt::storage<empty_stable_type>::iterable::iterator;
 
     testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity>>();
@@ -1444,7 +1525,7 @@ TEST_F(Storage, EmptyTypeIterable) {
     }
 }
 
-TEST_F(Storage, EmptyTypeConstIterable) {
+TEST_F(StorageOld, EmptyTypeConstIterable) {
     using iterator = typename entt::storage<empty_stable_type>::const_iterable::iterator;
 
     testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity>>();
@@ -1485,7 +1566,7 @@ TEST_F(Storage, EmptyTypeConstIterable) {
     }
 }
 
-TEST_F(Storage, IterableAlgorithmCompatibility) {
+TEST_F(StorageOld, IterableAlgorithmCompatibility) {
     entt::storage<boxed_int> pool;
     pool.emplace(entt::entity{3}, 42);
 
@@ -1495,7 +1576,7 @@ TEST_F(Storage, IterableAlgorithmCompatibility) {
     ASSERT_EQ(std::get<0>(*it), entt::entity{3});
 }
 
-TEST_F(Storage, ReverseIterable) {
+TEST_F(StorageOld, ReverseIterable) {
     using iterator = typename entt::storage<boxed_int>::reverse_iterable::iterator;
 
     testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity, boxed_int &>>();
@@ -1539,7 +1620,7 @@ TEST_F(Storage, ReverseIterable) {
     }
 }
 
-TEST_F(Storage, ConstReverseIterable) {
+TEST_F(StorageOld, ConstReverseIterable) {
     using iterator = typename entt::storage<boxed_int>::const_reverse_iterable::iterator;
 
     testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity, const boxed_int &>>();
@@ -1583,7 +1664,7 @@ TEST_F(Storage, ConstReverseIterable) {
     }
 }
 
-TEST_F(Storage, ReverseIterableIteratorConversion) {
+TEST_F(StorageOld, ReverseIterableIteratorConversion) {
     entt::storage<boxed_int> pool;
     pool.emplace(entt::entity{3}, 42);
 
@@ -1597,7 +1678,7 @@ TEST_F(Storage, ReverseIterableIteratorConversion) {
     ASSERT_NE(++cit, it);
 }
 
-TEST_F(Storage, EmptyTypeReverseIterable) {
+TEST_F(StorageOld, EmptyTypeReverseIterable) {
     using iterator = typename entt::storage<empty_stable_type>::reverse_iterable::iterator;
 
     testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity>>();
@@ -1638,7 +1719,7 @@ TEST_F(Storage, EmptyTypeReverseIterable) {
     }
 }
 
-TEST_F(Storage, EmptyTypeConstReverseIterable) {
+TEST_F(StorageOld, EmptyTypeConstReverseIterable) {
     using iterator = typename entt::storage<empty_stable_type>::const_reverse_iterable::iterator;
 
     testing::StaticAssertTypeEq<iterator::value_type, std::tuple<entt::entity>>();
@@ -1679,7 +1760,7 @@ TEST_F(Storage, EmptyTypeConstReverseIterable) {
     }
 }
 
-TEST_F(Storage, ReverseIterableAlgorithmCompatibility) {
+TEST_F(StorageOld, ReverseIterableAlgorithmCompatibility) {
     entt::storage<boxed_int> pool;
     pool.emplace(entt::entity{3}, 42);
 
@@ -1689,23 +1770,7 @@ TEST_F(Storage, ReverseIterableAlgorithmCompatibility) {
     ASSERT_EQ(std::get<0>(*it), entt::entity{3});
 }
 
-TEST_F(Storage, Raw) {
-    entt::storage<int> pool;
-
-    pool.emplace(entt::entity{3}, 3);
-    pool.emplace(entt::entity{12}, 6);
-    pool.emplace(entt::entity{42}, 9);
-
-    ASSERT_EQ(pool.get(entt::entity{3}), 3);
-    ASSERT_EQ(std::as_const(pool).get(entt::entity{12}), 6);
-    ASSERT_EQ(pool.get(entt::entity{42}), 9);
-
-    ASSERT_EQ(pool.raw()[0u][0u], 3);
-    ASSERT_EQ(std::as_const(pool).raw()[0u][1u], 6);
-    ASSERT_EQ(pool.raw()[0u][2u], 9);
-}
-
-TEST_F(Storage, SwapElements) {
+TEST_F(StorageOld, SwapElements) {
     entt::storage<int> pool;
 
     pool.emplace(entt::entity{3}, 3);
@@ -1727,7 +1792,7 @@ TEST_F(Storage, SwapElements) {
     ASSERT_EQ(pool.index(entt::entity{42}), 0u);
 }
 
-TEST_F(Storage, StableSwapElements) {
+TEST_F(StorageOld, StableSwapElements) {
     entt::storage<stable_type> pool;
 
     pool.emplace(entt::entity{3}, 3);
@@ -1749,7 +1814,7 @@ TEST_F(Storage, StableSwapElements) {
     ASSERT_EQ(pool.index(entt::entity{42}), 0u);
 }
 
-TEST_F(Storage, SortOrdered) {
+TEST_F(StorageOld, SortOrdered) {
     entt::storage<boxed_int> pool;
     entt::entity entity[5u]{entt::entity{12}, entt::entity{42}, entt::entity{7}, entt::entity{3}, entt::entity{9}};
     boxed_int values[5u]{{12}, {9}, {6}, {3}, {1}};
@@ -1761,7 +1826,7 @@ TEST_F(Storage, SortOrdered) {
     ASSERT_TRUE(std::equal(std::rbegin(values), std::rend(values), pool.begin(), pool.end()));
 }
 
-TEST_F(Storage, SortReverse) {
+TEST_F(StorageOld, SortReverse) {
     entt::storage<boxed_int> pool;
     entt::entity entity[5u]{entt::entity{12}, entt::entity{42}, entt::entity{7}, entt::entity{3}, entt::entity{9}};
     boxed_int values[5u]{{1}, {3}, {6}, {9}, {12}};
@@ -1773,7 +1838,7 @@ TEST_F(Storage, SortReverse) {
     ASSERT_TRUE(std::equal(std::begin(values), std::end(values), pool.begin(), pool.end()));
 }
 
-TEST_F(Storage, SortUnordered) {
+TEST_F(StorageOld, SortUnordered) {
     entt::storage<boxed_int> pool;
     entt::entity entity[5u]{entt::entity{12}, entt::entity{42}, entt::entity{7}, entt::entity{3}, entt::entity{9}};
     boxed_int values[5u]{{6}, {3}, {1}, {9}, {12}};
@@ -1798,7 +1863,7 @@ TEST_F(Storage, SortUnordered) {
     ASSERT_EQ(pool.data()[4u], entity[2u]);
 }
 
-TEST_F(Storage, SortRange) {
+TEST_F(StorageOld, SortRange) {
     entt::storage<boxed_int> pool;
     entt::entity entity[5u]{entt::entity{12}, entt::entity{42}, entt::entity{7}, entt::entity{3}, entt::entity{9}};
     boxed_int values[5u]{{3}, {6}, {1}, {9}, {12}};
@@ -1838,7 +1903,7 @@ TEST_F(Storage, SortRange) {
     ASSERT_EQ(pool.data()[4u], entity[2u]);
 }
 
-TEST_F(Storage, RespectDisjoint) {
+TEST_F(StorageOld, RespectDisjoint) {
     entt::storage<int> lhs;
     entt::storage<int> rhs;
 
@@ -1855,7 +1920,7 @@ TEST_F(Storage, RespectDisjoint) {
     ASSERT_TRUE(std::equal(std::rbegin(lhs_values), std::rend(lhs_values), lhs.begin(), lhs.end()));
 }
 
-TEST_F(Storage, RespectOverlap) {
+TEST_F(StorageOld, RespectOverlap) {
     entt::storage<int> lhs;
     entt::storage<int> rhs;
 
@@ -1888,7 +1953,7 @@ TEST_F(Storage, RespectOverlap) {
     ASSERT_EQ(lhs.data()[2u], lhs_entity[1u]);
 }
 
-TEST_F(Storage, RespectOrdered) {
+TEST_F(StorageOld, RespectOrdered) {
     entt::storage<int> lhs;
     entt::storage<int> rhs;
 
@@ -1912,7 +1977,7 @@ TEST_F(Storage, RespectOrdered) {
     ASSERT_TRUE(std::equal(std::rbegin(rhs_values), std::rend(rhs_values), rhs.begin(), rhs.end()));
 }
 
-TEST_F(Storage, RespectReverse) {
+TEST_F(StorageOld, RespectReverse) {
     entt::storage<int> lhs;
     entt::storage<int> rhs;
 
@@ -1951,7 +2016,7 @@ TEST_F(Storage, RespectReverse) {
     ASSERT_EQ(rhs.data()[5u], rhs_entity[0u]);
 }
 
-TEST_F(Storage, RespectUnordered) {
+TEST_F(StorageOld, RespectUnordered) {
     entt::storage<int> lhs;
     entt::storage<int> rhs;
 
@@ -1990,7 +2055,7 @@ TEST_F(Storage, RespectUnordered) {
     ASSERT_EQ(rhs.data()[5u], rhs_entity[5u]);
 }
 
-TEST_F(Storage, CanModifyDuringIteration) {
+TEST_F(StorageOld, CanModifyDuringIteration) {
     entt::storage<int> pool;
     auto *ptr = &pool.emplace(entt::entity{0}, 42);
     constexpr auto page_size = decltype(pool)::traits_type::page_size;
@@ -2007,7 +2072,7 @@ TEST_F(Storage, CanModifyDuringIteration) {
     [[maybe_unused]] const int &value = *it;
 }
 
-TEST_F(Storage, ReferencesGuaranteed) {
+TEST_F(StorageOld, ReferencesGuaranteed) {
     entt::storage<boxed_int> pool;
 
     pool.emplace(entt::entity{0}, 0);
@@ -2035,17 +2100,17 @@ TEST_F(Storage, ReferencesGuaranteed) {
     ASSERT_EQ(pool.get(entt::entity{1}).value, 3);
 }
 
-TEST_F(Storage, MoveOnlyComponent) {
+TEST_F(StorageOld, MoveOnlyComponent) {
     // the purpose is to ensure that move only components are always accepted
     [[maybe_unused]] entt::storage<std::unique_ptr<int>> pool;
 }
 
-TEST_F(Storage, PinnedComponent) {
+TEST_F(StorageOld, PinnedComponent) {
     // the purpose is to ensure that non-movable components are always accepted
     [[maybe_unused]] entt::storage<pinned_type> pool;
 }
 
-ENTT_DEBUG_TEST_F(StorageDeathTest, PinnedComponent) {
+ENTT_DEBUG_TEST_F(StorageOldDeathTest, PinnedComponent) {
     entt::storage<pinned_type> pool;
     const entt::entity entity{0};
     const entt::entity destroy{1};
@@ -2062,7 +2127,7 @@ ENTT_DEBUG_TEST_F(StorageDeathTest, PinnedComponent) {
     ASSERT_DEATH(pool.sort([](auto &&lhs, auto &&rhs) { return lhs < rhs; }), "");
 }
 
-TEST_F(Storage, UpdateFromDestructor) {
+TEST_F(StorageOld, UpdateFromDestructor) {
     auto test = [](const auto target) {
         constexpr auto size = 10u;
 
@@ -2093,7 +2158,7 @@ TEST_F(Storage, UpdateFromDestructor) {
     test(entt::entity{0u});
 }
 
-TEST_F(Storage, CreateFromConstructor) {
+TEST_F(StorageOld, CreateFromConstructor) {
     entt::storage<create_from_constructor> pool;
     const entt::entity entity{0u};
     const entt::entity other{1u};
@@ -2104,7 +2169,7 @@ TEST_F(Storage, CreateFromConstructor) {
     ASSERT_EQ(pool.get(other).child, static_cast<entt::entity>(entt::null));
 }
 
-TEST_F(Storage, CustomAllocator) {
+TEST_F(StorageOld, CustomAllocator) {
     auto test = [](auto pool, auto alloc) {
         pool.reserve(1u);
 
@@ -2151,7 +2216,7 @@ TEST_F(Storage, CustomAllocator) {
     test(entt::basic_storage<stable_type, entt::entity, test::throwing_allocator<stable_type>>{allocator}, allocator);
 }
 
-TEST_F(Storage, ThrowingAllocator) {
+TEST_F(StorageOld, ThrowingAllocator) {
     auto test = [](auto pool) {
         using pool_allocator_type = typename decltype(pool)::allocator_type;
         using value_type = typename decltype(pool)::value_type;
@@ -2215,7 +2280,7 @@ TEST_F(Storage, ThrowingAllocator) {
     test(entt::basic_storage<stable_type, entt::entity, test::throwing_allocator<stable_type>>{});
 }
 
-TEST_F(Storage, ThrowingComponent) {
+TEST_F(StorageOld, ThrowingComponent) {
     entt::storage<test::throwing_type> pool;
     test::throwing_type::trigger_on_value = 42;
 
@@ -2269,7 +2334,7 @@ TEST_F(Storage, ThrowingComponent) {
 
 #if defined(ENTT_HAS_TRACKED_MEMORY_RESOURCE)
 
-TEST_F(Storage, NoUsesAllocatorConstruction) {
+TEST_F(StorageOld, NoUsesAllocatorConstruction) {
     test::tracked_memory_resource memory_resource{};
     entt::basic_storage<int, entt::entity, std::pmr::polymorphic_allocator<int>> pool{&memory_resource};
     const entt::entity entity{};
@@ -2284,7 +2349,7 @@ TEST_F(Storage, NoUsesAllocatorConstruction) {
     ASSERT_EQ(memory_resource.do_deallocate_counter(), 0u);
 }
 
-TEST_F(Storage, UsesAllocatorConstruction) {
+TEST_F(StorageOld, UsesAllocatorConstruction) {
     using string_type = typename test::tracked_memory_resource::string_type;
 
     test::tracked_memory_resource memory_resource{};
@@ -2303,13 +2368,13 @@ TEST_F(Storage, UsesAllocatorConstruction) {
 
 #endif
 
-TEST_F(Storage, StorageType) {
+TEST_F(StorageOld, StorageType) {
     // just a bunch of static asserts to avoid regressions
     testing::StaticAssertTypeEq<entt::storage_type_t<char, entt::entity>, entt::sigh_mixin<entt::basic_storage<char, entt::entity>>>();
     testing::StaticAssertTypeEq<entt::storage_type_t<int>, entt::sigh_mixin<entt::storage<int>>>();
 }
 
-TEST_F(Storage, StorageFor) {
+TEST_F(StorageOld, StorageFor) {
     // just a bunch of static asserts to avoid regressions
     testing::StaticAssertTypeEq<entt::storage_for_t<const double, entt::entity>, const entt::sigh_mixin<entt::basic_storage<double, entt::entity>>>();
     testing::StaticAssertTypeEq<entt::storage_for_t<char, entt::entity>, entt::sigh_mixin<entt::basic_storage<char, entt::entity>>>();