diff --git a/test/entt/entity/registry.cpp b/test/entt/entity/registry.cpp
index 553a15201..e77c4ffa7 100644
--- a/test/entt/entity/registry.cpp
+++ b/test/entt/entity/registry.cpp
@@ -2098,7 +2098,7 @@ TEST(Registry, Storage) {
     entt::registry registry;
     const auto entity = registry.create();
 
-    auto &storage = registry.storage<int>("int"_hs);
+    auto &storage = registry.storage<int>("other"_hs);
     storage.emplace(entity);
 
     for(auto [id, pool]: registry.storage()) {
@@ -2107,8 +2107,18 @@ TEST(Registry, Storage) {
 
         ASSERT_TRUE(pool.contains(entity));
         ASSERT_EQ(std::addressof(storage), std::addressof(pool));
-        ASSERT_EQ(id, "int"_hs);
+        ASSERT_EQ(id, "other"_hs);
     }
+}
+
+TEST(Registry, ConstStorage) {
+    using namespace entt::literals;
+
+    entt::registry registry;
+    const auto entity = registry.create();
+
+    auto &storage = registry.storage<int>("other"_hs);
+    storage.emplace(entity);
 
     for(auto &&curr: std::as_const(registry).storage()) {
         testing::StaticAssertTypeEq<decltype(curr.second), const entt::sparse_set &>();
@@ -2116,7 +2126,7 @@ TEST(Registry, Storage) {
 
         ASSERT_TRUE(curr.second.contains(entity));
         ASSERT_EQ(std::addressof(storage), std::addressof(curr.second));
-        ASSERT_EQ(curr.first, "int"_hs);
+        ASSERT_EQ(curr.first, "other"_hs);
     }
 }
 
@@ -2125,54 +2135,93 @@ TEST(Registry, RegistryStorageIterator) {
     const auto entity = registry.create();
     registry.emplace<int>(entity);
 
-    auto test = [entity](auto iterable) {
-        auto end{iterable.begin()};
-        decltype(end) begin{};
-        begin = iterable.end();
-        std::swap(begin, end);
+    auto iterable = registry.storage();
 
-        ASSERT_EQ(begin, iterable.cbegin());
-        ASSERT_EQ(end, iterable.cend());
-        ASSERT_NE(begin, end);
+    auto end{iterable.begin()};
+    decltype(end) begin{};
+    begin = iterable.end();
+    std::swap(begin, end);
 
-        ASSERT_EQ(begin++, iterable.begin());
-        ASSERT_EQ(begin--, iterable.end());
+    ASSERT_EQ(begin, iterable.cbegin());
+    ASSERT_EQ(end, iterable.cend());
+    ASSERT_NE(begin, end);
 
-        ASSERT_EQ(begin + 1, iterable.end());
-        ASSERT_EQ(end - 1, iterable.begin());
+    ASSERT_EQ(begin++, iterable.begin());
+    ASSERT_EQ(begin--, iterable.end());
 
-        ASSERT_EQ(++begin, iterable.end());
-        ASSERT_EQ(--begin, iterable.begin());
+    ASSERT_EQ(begin + 1, iterable.end());
+    ASSERT_EQ(end - 1, iterable.begin());
 
-        ASSERT_EQ(begin += 1, iterable.end());
-        ASSERT_EQ(begin -= 1, iterable.begin());
+    ASSERT_EQ(++begin, iterable.end());
+    ASSERT_EQ(--begin, iterable.begin());
 
-        ASSERT_EQ(begin + (end - begin), iterable.end());
-        ASSERT_EQ(begin - (begin - end), iterable.end());
+    ASSERT_EQ(begin += 1, iterable.end());
+    ASSERT_EQ(begin -= 1, iterable.begin());
 
-        ASSERT_EQ(end - (end - begin), iterable.begin());
-        ASSERT_EQ(end + (begin - end), iterable.begin());
+    ASSERT_EQ(begin + (end - begin), iterable.end());
+    ASSERT_EQ(begin - (begin - end), iterable.end());
 
-        ASSERT_EQ(begin[0u].first, iterable.begin()->first);
-        ASSERT_EQ(std::addressof(begin[0u].second), std::addressof((*iterable.begin()).second));
+    ASSERT_EQ(end - (end - begin), iterable.begin());
+    ASSERT_EQ(end + (begin - end), iterable.begin());
 
-        ASSERT_LT(begin, end);
-        ASSERT_LE(begin, iterable.begin());
+    ASSERT_EQ(begin[0u].first, iterable.begin()->first);
+    ASSERT_EQ(std::addressof(begin[0u].second), std::addressof((*iterable.begin()).second));
 
-        ASSERT_GT(end, begin);
-        ASSERT_GE(end, iterable.end());
+    ASSERT_LT(begin, end);
+    ASSERT_LE(begin, iterable.begin());
 
-        ASSERT_EQ(begin[0u].first, entt::type_id<int>().hash());
-        ASSERT_TRUE(begin[0u].second.contains(entity));
-    };
+    ASSERT_GT(end, begin);
+    ASSERT_GE(end, iterable.end());
 
-    test(registry.storage());
-    test(std::as_const(registry).storage());
+    ASSERT_EQ(begin[0u].first, entt::type_id<int>().hash());
+    ASSERT_TRUE(begin[0u].second.contains(entity));
+}
 
-    decltype(std::as_const(registry).storage().begin()) cit = registry.storage().begin();
+TEST(Registry, RegistryConstStorageIterator) {
+    entt::registry registry;
+    const auto entity = registry.create();
+    registry.emplace<int>(entity);
 
-    ASSERT_EQ(cit, registry.storage().begin());
-    ASSERT_NE(cit, std::as_const(registry).storage().end());
+    auto iterable = std::as_const(registry).storage();
+
+    auto end{iterable.begin()};
+    decltype(end) begin{};
+    begin = iterable.end();
+    std::swap(begin, end);
+
+    ASSERT_EQ(begin, iterable.cbegin());
+    ASSERT_EQ(end, iterable.cend());
+    ASSERT_NE(begin, end);
+
+    ASSERT_EQ(begin++, iterable.begin());
+    ASSERT_EQ(begin--, iterable.end());
+
+    ASSERT_EQ(begin + 1, iterable.end());
+    ASSERT_EQ(end - 1, iterable.begin());
+
+    ASSERT_EQ(++begin, iterable.end());
+    ASSERT_EQ(--begin, iterable.begin());
+
+    ASSERT_EQ(begin += 1, iterable.end());
+    ASSERT_EQ(begin -= 1, iterable.begin());
+
+    ASSERT_EQ(begin + (end - begin), iterable.end());
+    ASSERT_EQ(begin - (begin - end), iterable.end());
+
+    ASSERT_EQ(end - (end - begin), iterable.begin());
+    ASSERT_EQ(end + (begin - end), iterable.begin());
+
+    ASSERT_EQ(begin[0u].first, iterable.begin()->first);
+    ASSERT_EQ(std::addressof(begin[0u].second), std::addressof((*iterable.begin()).second));
+
+    ASSERT_LT(begin, end);
+    ASSERT_LE(begin, iterable.begin());
+
+    ASSERT_GT(end, begin);
+    ASSERT_GE(end, iterable.end());
+
+    ASSERT_EQ(begin[0u].first, entt::type_id<int>().hash());
+    ASSERT_TRUE(begin[0u].second.contains(entity));
 }
 
 TEST(Registry, RegistryStorageIteratorConversion) {