test: use page size variables

TODO

@@ -12,7 +12,6 @@ DOC:
 
 WIP:
 * use conditional noexcept properly
-* don't use entt_packed/sparse_page directly
 * add storage getter for filters to views and groups
 * emitter: runtime handlers, allocator support (ready for both already)
 * view: no storage_traits dependency -> use storage instead of components for the definition

test/entt/entity/helper.cpp

@@ -48,6 +48,7 @@ TEST(Helper, Invoke) {
 TEST(Helper, ToEntity) {
     entt::registry registry;
     const entt::entity null = entt::null;
+    constexpr auto page_size = entt::component_traits<int>::page_size;
     const int value = 42;
 
     ASSERT_EQ(entt::to_entity(registry, 42), null);
@@ -57,7 +58,7 @@ TEST(Helper, ToEntity) {
     auto &&storage = registry.storage<int>();
     storage.emplace(entity);
 
-    while(storage.size() < (ENTT_PACKED_PAGE - 1u)) {
+    while(storage.size() < (page_size - 1u)) {
         storage.emplace(registry.create(), value);
     }
 
@@ -71,14 +72,14 @@ TEST(Helper, ToEntity) {
     ASSERT_EQ(entt::to_entity(registry, registry.get<int>(other)), other);
     ASSERT_EQ(entt::to_entity(registry, registry.get<int>(next)), next);
 
-    ASSERT_EQ(&registry.get<int>(entity) + ENTT_PACKED_PAGE - 1u, &registry.get<int>(other));
+    ASSERT_EQ(&registry.get<int>(entity) + page_size - 1u, &registry.get<int>(other));
 
     registry.destroy(other);
 
     ASSERT_EQ(entt::to_entity(registry, registry.get<int>(entity)), entity);
     ASSERT_EQ(entt::to_entity(registry, registry.get<int>(next)), next);
 
-    ASSERT_EQ(&registry.get<int>(entity) + ENTT_PACKED_PAGE - 1u, &registry.get<int>(next));
+    ASSERT_EQ(&registry.get<int>(entity) + page_size - 1u, &registry.get<int>(next));
 
     ASSERT_EQ(entt::to_entity(registry, 42), null);
     ASSERT_EQ(entt::to_entity(registry, value), null);
@@ -87,6 +88,7 @@ TEST(Helper, ToEntity) {
 TEST(Helper, ToEntityStableType) {
     entt::registry registry;
     const entt::entity null = entt::null;
+    constexpr auto page_size = entt::component_traits<stable_type>::page_size;
     const stable_type value{42};
 
     ASSERT_EQ(entt::to_entity(registry, stable_type{42}), null);
@@ -96,7 +98,7 @@ TEST(Helper, ToEntityStableType) {
     auto &&storage = registry.storage<stable_type>();
     registry.emplace<stable_type>(entity);
 
-    while(storage.size() < (ENTT_PACKED_PAGE - 2u)) {
+    while(storage.size() < (page_size - 2u)) {
         storage.emplace(registry.create(), value);
     }
 
@@ -110,14 +112,14 @@ TEST(Helper, ToEntityStableType) {
     ASSERT_EQ(entt::to_entity(registry, registry.get<stable_type>(other)), other);
     ASSERT_EQ(entt::to_entity(registry, registry.get<stable_type>(next)), next);
 
-    ASSERT_EQ(&registry.get<stable_type>(entity) + ENTT_PACKED_PAGE - 2u, &registry.get<stable_type>(other));
+    ASSERT_EQ(&registry.get<stable_type>(entity) + page_size - 2u, &registry.get<stable_type>(other));
 
     registry.destroy(other);
 
     ASSERT_EQ(entt::to_entity(registry, registry.get<stable_type>(entity)), entity);
     ASSERT_EQ(entt::to_entity(registry, registry.get<stable_type>(next)), next);
 
-    ASSERT_EQ(&registry.get<stable_type>(entity) + ENTT_PACKED_PAGE - 1u, &registry.get<stable_type>(next));
+    ASSERT_EQ(&registry.get<stable_type>(entity) + page_size - 1u, &registry.get<stable_type>(next));
 
     ASSERT_EQ(entt::to_entity(registry, stable_type{42}), null);
     ASSERT_EQ(entt::to_entity(registry, value), null);

test/entt/entity/registry.cpp

@@ -7,7 +7,6 @@
 #include <unordered_set>
 #include <utility>
 #include <gtest/gtest.h>
-#include <entt/config/config.h>
 #include <entt/core/hashed_string.hpp>
 #include <entt/core/type_info.hpp>
 #include <entt/entity/entity.hpp>
@@ -16,7 +15,7 @@
 struct empty_type {};
 
 struct no_eto_type {
-    static constexpr std::size_t page_size = ENTT_PACKED_PAGE;
+    static constexpr std::size_t page_size = 1024u;
 };
 
 bool operator==(const no_eto_type &lhs, const no_eto_type &rhs) {

test/entt/entity/sigh_storage_mixin.cpp

@@ -475,6 +475,8 @@ TEST(SighStorageMixin, ThrowingAllocator) {
         using value_type = typename decltype(pool)::value_type;
 
         typename std::decay_t<decltype(pool)>::base_type &base = pool;
+        constexpr auto packed_page_size = entt::component_traits<typename decltype(pool)::value_type>::page_size;
+        constexpr auto sparse_page_size = entt::entt_traits<typename decltype(pool)::entity_type>::page_size;
         entt::registry registry;
 
         counter on_construct{};
@@ -491,8 +493,8 @@ TEST(SighStorageMixin, ThrowingAllocator) {
 
         pool_allocator_type::trigger_after_allocate = true;
 
-        ASSERT_THROW(pool.reserve(2 * ENTT_PACKED_PAGE), typename pool_allocator_type::exception_type);
-        ASSERT_EQ(pool.capacity(), ENTT_PACKED_PAGE);
+        ASSERT_THROW(pool.reserve(2 * packed_page_size), typename pool_allocator_type::exception_type);
+        ASSERT_EQ(pool.capacity(), packed_page_size);
 
         pool.shrink_to_fit();
 
@@ -518,21 +520,21 @@ TEST(SighStorageMixin, ThrowingAllocator) {
         ASSERT_TRUE(pool.empty());
 
         pool.emplace(entt::entity{0}, 0);
-        const entt::entity entities[2u]{entt::entity{1}, entt::entity{ENTT_SPARSE_PAGE}};
+        const entt::entity entities[2u]{entt::entity{1}, entt::entity{sparse_page_size}};
         test::throwing_allocator<entt::entity>::trigger_after_allocate = true;
 
         ASSERT_THROW(pool.insert(std::begin(entities), std::end(entities), value_type{0}), test::throwing_allocator<entt::entity>::exception_type);
         ASSERT_TRUE(pool.contains(entt::entity{1}));
-        ASSERT_FALSE(pool.contains(entt::entity{ENTT_SPARSE_PAGE}));
+        ASSERT_FALSE(pool.contains(entt::entity{sparse_page_size}));
 
         pool.erase(entt::entity{1});
-        const value_type components[2u]{value_type{1}, value_type{ENTT_SPARSE_PAGE}};
+        const value_type components[2u]{value_type{1}, value_type{sparse_page_size}};
         test::throwing_allocator<entt::entity>::trigger_on_allocate = true;
         pool.compact();
 
         ASSERT_THROW(pool.insert(std::begin(entities), std::end(entities), std::begin(components)), test::throwing_allocator<entt::entity>::exception_type);
         ASSERT_TRUE(pool.contains(entt::entity{1}));
-        ASSERT_FALSE(pool.contains(entt::entity{ENTT_SPARSE_PAGE}));
+        ASSERT_FALSE(pool.contains(entt::entity{sparse_page_size}));
 
         ASSERT_EQ(on_construct.value, 1);
         ASSERT_EQ(on_destroy.value, 1);

test/entt/entity/sparse_set.cpp

@@ -139,7 +139,7 @@ TEST(SparseSet, Current) {
     ASSERT_NE(set.current(traits_type::construct(3, 3)), traits_type::to_version(entt::tombstone));
     ASSERT_EQ(set.current(traits_type::construct(3, 0)), traits_type::to_version(traits_type::construct(3, 3)));
     ASSERT_EQ(set.current(traits_type::construct(42, 1)), traits_type::to_version(entt::tombstone));
-    ASSERT_EQ(set.current(traits_type::construct(ENTT_SPARSE_PAGE, 1)), traits_type::to_version(entt::tombstone));
+    ASSERT_EQ(set.current(traits_type::construct(traits_type::page_size, 1)), traits_type::to_version(entt::tombstone));
 
     set.remove(entt::entity{0});
 
@@ -226,38 +226,40 @@ TEST(SparseSet, Swap) {
 }
 
 TEST(SparseSet, Pagination) {
-    entt::sparse_set set;
+    using traits_type = entt::entt_traits<entt::entity>;
+
+    entt::sparse_set set{};
 
     ASSERT_EQ(set.extent(), 0u);
 
-    set.emplace(entt::entity{ENTT_SPARSE_PAGE - 1u});
+    set.emplace(entt::entity{traits_type::page_size - 1u});
 
-    ASSERT_EQ(set.extent(), ENTT_SPARSE_PAGE);
-    ASSERT_TRUE(set.contains(entt::entity{ENTT_SPARSE_PAGE - 1u}));
+    ASSERT_EQ(set.extent(), traits_type::page_size);
+    ASSERT_TRUE(set.contains(entt::entity{traits_type::page_size - 1u}));
 
-    set.emplace(entt::entity{ENTT_SPARSE_PAGE});
+    set.emplace(entt::entity{traits_type::page_size});
 
-    ASSERT_EQ(set.extent(), 2 * ENTT_SPARSE_PAGE);
-    ASSERT_TRUE(set.contains(entt::entity{ENTT_SPARSE_PAGE - 1u}));
-    ASSERT_TRUE(set.contains(entt::entity{ENTT_SPARSE_PAGE}));
-    ASSERT_FALSE(set.contains(entt::entity{ENTT_SPARSE_PAGE + 1u}));
+    ASSERT_EQ(set.extent(), 2 * traits_type::page_size);
+    ASSERT_TRUE(set.contains(entt::entity{traits_type::page_size - 1u}));
+    ASSERT_TRUE(set.contains(entt::entity{traits_type::page_size}));
+    ASSERT_FALSE(set.contains(entt::entity{traits_type::page_size + 1u}));
 
-    set.erase(entt::entity{ENTT_SPARSE_PAGE - 1u});
+    set.erase(entt::entity{traits_type::page_size - 1u});
 
-    ASSERT_EQ(set.extent(), 2 * ENTT_SPARSE_PAGE);
-    ASSERT_FALSE(set.contains(entt::entity{ENTT_SPARSE_PAGE - 1u}));
-    ASSERT_TRUE(set.contains(entt::entity{ENTT_SPARSE_PAGE}));
+    ASSERT_EQ(set.extent(), 2 * traits_type::page_size);
+    ASSERT_FALSE(set.contains(entt::entity{traits_type::page_size - 1u}));
+    ASSERT_TRUE(set.contains(entt::entity{traits_type::page_size}));
 
     set.shrink_to_fit();
-    set.erase(entt::entity{ENTT_SPARSE_PAGE});
+    set.erase(entt::entity{traits_type::page_size});
 
-    ASSERT_EQ(set.extent(), 2 * ENTT_SPARSE_PAGE);
-    ASSERT_FALSE(set.contains(entt::entity{ENTT_SPARSE_PAGE - 1u}));
-    ASSERT_FALSE(set.contains(entt::entity{ENTT_SPARSE_PAGE}));
+    ASSERT_EQ(set.extent(), 2 * traits_type::page_size);
+    ASSERT_FALSE(set.contains(entt::entity{traits_type::page_size - 1u}));
+    ASSERT_FALSE(set.contains(entt::entity{traits_type::page_size}));
 
     set.shrink_to_fit();
 
-    ASSERT_EQ(set.extent(), 2 * ENTT_SPARSE_PAGE);
+    ASSERT_EQ(set.extent(), 2 * traits_type::page_size);
 }
 
 TEST(SparseSet, Emplace) {
@@ -296,17 +298,19 @@ TEST(SparseSetDeathTest, Emplace) {
 }
 
 TEST(SparseSet, EmplaceOutOfBounds) {
+    using traits_type = entt::entt_traits<entt::entity>;
+
     entt::sparse_set set{entt::deletion_policy::in_place};
-    entt::entity entities[2u]{entt::entity{0}, entt::entity{ENTT_SPARSE_PAGE}};
+    entt::entity entities[2u]{entt::entity{0}, entt::entity{traits_type::page_size}};
 
     ASSERT_NE(set.emplace(entities[0u]), set.end());
-    ASSERT_EQ(set.extent(), ENTT_SPARSE_PAGE);
+    ASSERT_EQ(set.extent(), traits_type::page_size);
     ASSERT_EQ(set.index(entities[0u]), 0u);
 
     set.erase(entities[0u]);
 
     ASSERT_NE(set.emplace(entities[1u]), set.end());
-    ASSERT_EQ(set.extent(), 2u * ENTT_SPARSE_PAGE);
+    ASSERT_EQ(set.extent(), 2u * traits_type::page_size);
     ASSERT_EQ(set.index(entities[1u]), 0u);
 }
 
@@ -1312,6 +1316,8 @@ TEST(SparseSet, CustomAllocator) {
 }
 
 TEST(SparseSet, ThrowingAllocator) {
+    using traits_type = entt::entt_traits<entt::entity>;
+
     entt::basic_sparse_set<entt::entity, test::throwing_allocator<entt::entity>> set{};
 
     test::throwing_allocator<entt::entity>::trigger_on_allocate = true;
@@ -1323,37 +1329,37 @@ TEST(SparseSet, ThrowingAllocator) {
     test::throwing_allocator<entt::entity>::trigger_on_allocate = true;
 
     ASSERT_THROW(set.emplace(entt::entity{0}), test::throwing_allocator<entt::entity>::exception_type);
-    ASSERT_EQ(set.extent(), ENTT_SPARSE_PAGE);
+    ASSERT_EQ(set.extent(), traits_type::page_size);
     ASSERT_EQ(set.capacity(), 0u);
 
     set.emplace(entt::entity{0});
     test::throwing_allocator<entt::entity>::trigger_on_allocate = true;
 
     ASSERT_THROW(set.reserve(2u), test::throwing_allocator<entt::entity>::exception_type);
-    ASSERT_EQ(set.extent(), ENTT_SPARSE_PAGE);
+    ASSERT_EQ(set.extent(), traits_type::page_size);
     ASSERT_TRUE(set.contains(entt::entity{0}));
     ASSERT_EQ(set.capacity(), 1u);
 
     test::throwing_allocator<entt::entity>::trigger_on_allocate = true;
 
     ASSERT_THROW(set.emplace(entt::entity{1}), test::throwing_allocator<entt::entity>::exception_type);
-    ASSERT_EQ(set.extent(), ENTT_SPARSE_PAGE);
+    ASSERT_EQ(set.extent(), traits_type::page_size);
     ASSERT_TRUE(set.contains(entt::entity{0}));
     ASSERT_FALSE(set.contains(entt::entity{1}));
     ASSERT_EQ(set.capacity(), 1u);
 
-    entt::entity entities[2u]{entt::entity{1}, entt::entity{ENTT_SPARSE_PAGE}};
+    entt::entity entities[2u]{entt::entity{1}, entt::entity{traits_type::page_size}};
     test::throwing_allocator<entt::entity>::trigger_after_allocate = true;
 
     ASSERT_THROW(set.insert(std::begin(entities), std::end(entities)), test::throwing_allocator<entt::entity>::exception_type);
-    ASSERT_EQ(set.extent(), 2 * ENTT_SPARSE_PAGE);
+    ASSERT_EQ(set.extent(), 2 * traits_type::page_size);
     ASSERT_TRUE(set.contains(entt::entity{0}));
     ASSERT_TRUE(set.contains(entt::entity{1}));
-    ASSERT_FALSE(set.contains(entt::entity{ENTT_SPARSE_PAGE}));
+    ASSERT_FALSE(set.contains(entt::entity{traits_type::page_size}));
     ASSERT_EQ(set.capacity(), 2u);
     ASSERT_EQ(set.size(), 2u);
 
     set.emplace(entities[1u]);
 
-    ASSERT_TRUE(set.contains(entt::entity{ENTT_SPARSE_PAGE}));
+    ASSERT_TRUE(set.contains(entt::entity{traits_type::page_size}));
 }