Scarfski/entt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test: use page size variables

Browse Source
This commit is contained in:
Michele Caini
2022-05-06 12:01:37 +02:00
parent e0a1a338a5
commit c608e735d2
5 changed files with 52 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
TODO
View File

@@ -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

14
test/entt/entity/helper.cpp
View File

@@ -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);

3
test/entt/entity/registry.cpp
View File

@@ -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) {

14
test/entt/entity/sigh_storage_mixin.cpp
View File

@@ -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);

64
test/entt/entity/sparse_set.cpp
View File

@@ -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}));
}