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

test: basic continuous loader

Browse Source
This commit is contained in:
Michele Caini
2023-06-11 12:52:20 +02:00
parent c4e2416621
commit 93e8e94e60
1 changed files with 366 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

366
test/entt/entity/snapshot.cpp
View File

@@ -412,6 +412,7 @@ TEST(BasicSnapshotLoader, GetTypeSparse) {
ASSERT_EQ(storage.get(entities[0u]), values[0u]);
ASSERT_EQ(storage.get(entities[1u]), values[1u]);
}
TEST(BasicSnapshotLoader, Orphans) {
using namespace entt::literals;
using traits_type = entt::entt_traits<entt::entity>;
@@ -449,6 +450,371 @@ TEST(BasicSnapshotLoader, Orphans) {
ASSERT_FALSE(registry.valid(entities[1u]));
}
TEST(BasicContinuousLoader, Constructors) {
static_assert(!std::is_default_constructible_v<entt::basic_continuous_loader<entt::registry>>);
static_assert(!std::is_copy_constructible_v<entt::basic_continuous_loader<entt::registry>>);
static_assert(!std::is_copy_assignable_v<entt::basic_continuous_loader<entt::registry>>);
static_assert(std::is_move_constructible_v<entt::basic_continuous_loader<entt::registry>>);
static_assert(std::is_move_assignable_v<entt::basic_continuous_loader<entt::registry>>);
entt::registry registry;
entt::basic_continuous_loader loader{registry};
entt::basic_continuous_loader other{std::move(loader)};
ASSERT_NO_FATAL_FAILURE(loader = std::move(other));
}
TEST(BasicContinuousLoader, GetEntityType) {
using namespace entt::literals;
using traits_type = entt::entt_traits<entt::entity>;
entt::registry registry;
entt::basic_continuous_loader loader{registry};
const auto &storage = registry.storage<entt::entity>();
std::vector<entt::any> data{};
auto archive = [&data, pos = 0u](auto &value) mutable { value = entt::any_cast<std::remove_reference_t<decltype(value)>>(data[pos++]); };
const entt::entity entities[3u]{traits_type::construct(1u, 0u), traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
ASSERT_FALSE(registry.valid(entities[0u]));
ASSERT_FALSE(registry.valid(entities[1u]));
ASSERT_FALSE(registry.valid(entities[2u]));
data.emplace_back(static_cast<typename traits_type::entity_type>(0u));
data.emplace_back(static_cast<typename traits_type::entity_type>(0u));
loader.get<entt::entity>(archive);
ASSERT_FALSE(registry.valid(entities[0u]));
ASSERT_FALSE(registry.valid(entities[1u]));
ASSERT_FALSE(registry.valid(entities[2u]));
ASSERT_FALSE(loader.contains(entities[0u]));
ASSERT_FALSE(loader.contains(entities[1u]));
ASSERT_FALSE(loader.contains(entities[2u]));
ASSERT_EQ(loader.map(entities[0u]), static_cast<entt::entity>(entt::null));
ASSERT_EQ(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
ASSERT_EQ(loader.map(entities[2u]), static_cast<entt::entity>(entt::null));
ASSERT_EQ(storage.size(), 0u);
ASSERT_EQ(storage.in_use(), 0u);
data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
data.emplace_back(entities[0u]);
data.emplace_back(entities[1u]);
data.emplace_back(entities[2u]);
loader.get<entt::entity>(archive, "ignored"_hs);
ASSERT_TRUE(loader.contains(entities[0u]));
ASSERT_TRUE(loader.contains(entities[1u]));
ASSERT_FALSE(loader.contains(entities[2u]));
ASSERT_NE(loader.map(entities[0u]), static_cast<entt::entity>(entt::null));
ASSERT_NE(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
ASSERT_EQ(loader.map(entities[2u]), static_cast<entt::entity>(entt::null));
ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
ASSERT_EQ(storage.size(), 2u);
ASSERT_EQ(storage.in_use(), 2u);
ASSERT_EQ(storage[0u], loader.map(entities[0u]));
ASSERT_EQ(storage[1u], loader.map(entities[1u]));
ASSERT_EQ(registry.create(), entities[2u]);
data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
data.emplace_back(entities[0u]);
data.emplace_back(entities[1u]);
data.emplace_back(entities[2u]);
loader.get<entt::entity>(archive);
ASSERT_TRUE(loader.contains(entities[0u]));
ASSERT_TRUE(loader.contains(entities[1u]));
ASSERT_TRUE(loader.contains(entities[2u]));
ASSERT_NE(loader.map(entities[0u]), static_cast<entt::entity>(entt::null));
ASSERT_NE(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
ASSERT_NE(loader.map(entities[2u]), static_cast<entt::entity>(entt::null));
ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
ASSERT_TRUE(registry.valid(loader.map(entities[2u])));
ASSERT_EQ(storage.size(), 4u);
ASSERT_EQ(storage.in_use(), 4u);
ASSERT_EQ(storage[0u], loader.map(entities[0u]));
ASSERT_EQ(storage[1u], loader.map(entities[1u]));
ASSERT_EQ(storage[3u], loader.map(entities[2u]));
registry.destroy(loader.map(entities[1u]));
ASSERT_TRUE(loader.contains(entities[1u]));
ASSERT_NE(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
data.emplace_back(entities[1u]);
loader.get<entt::entity>(archive);
ASSERT_TRUE(loader.contains(entities[1u]));
ASSERT_NE(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
ASSERT_EQ(storage[3u], loader.map(entities[1u]));
data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
data.emplace_back(entities[1u]);
data.emplace_back(entities[2u]);
data.emplace_back(entities[0u]);
loader.get<entt::entity>(archive, "ignored"_hs);
ASSERT_FALSE(loader.contains(entities[0u]));
ASSERT_TRUE(loader.contains(entities[1u]));
ASSERT_FALSE(loader.contains(entities[2u]));
ASSERT_EQ(loader.map(entities[0u]), static_cast<entt::entity>(entt::null));
ASSERT_NE(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
ASSERT_EQ(loader.map(entities[2u]), static_cast<entt::entity>(entt::null));
ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
ASSERT_EQ(storage.size(), 4u);
ASSERT_EQ(storage.in_use(), 2u);
ASSERT_EQ(storage[1u], loader.map(entities[1u]));
}
TEST(BasicContinuousLoader, GetType) {
using namespace entt::literals;
using traits_type = entt::entt_traits<entt::entity>;
entt::registry registry;
entt::basic_continuous_loader loader{registry};
const auto &storage = registry.storage<int>();
std::vector<entt::any> data{};
auto archive = [&data, pos = 0u](auto &value) mutable { value = entt::any_cast<std::remove_reference_t<decltype(value)>>(data[pos++]); };
const entt::entity entities[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
const int values[2u]{1, 3};
ASSERT_FALSE(loader.contains(entities[0u]));
ASSERT_FALSE(loader.contains(entities[1u]));
ASSERT_FALSE(registry.valid(loader.map(entities[0u])));
ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
data.emplace_back(entities[0u]);
data.emplace_back(values[0u]);
loader.get<int>(archive, "other"_hs);
ASSERT_TRUE(loader.contains(entities[0u]));
ASSERT_FALSE(loader.contains(entities[1u]));
ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
ASSERT_EQ(storage.size(), 0u);
ASSERT_EQ(registry.storage<int>("other"_hs).size(), 1u);
data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
data.emplace_back(entities[0u]);
data.emplace_back(values[0u]);
data.emplace_back(entities[1u]);
data.emplace_back(values[1u]);
loader.get<int>(archive);
ASSERT_TRUE(loader.contains(entities[0u]));
ASSERT_TRUE(loader.contains(entities[1u]));
ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
ASSERT_EQ(storage.size(), 2u);
ASSERT_TRUE(storage.contains(loader.map(entities[0u])));
ASSERT_TRUE(storage.contains(loader.map(entities[1u])));
ASSERT_EQ(storage.get(loader.map(entities[0u])), values[0u]);
ASSERT_EQ(storage.get(loader.map(entities[1u])), values[1u]);
}
TEST(BasicContinuousLoader, GetEmptyType) {
using namespace entt::literals;
using traits_type = entt::entt_traits<entt::entity>;
entt::registry registry;
entt::basic_continuous_loader loader{registry};
const auto &storage = registry.storage<empty>();
std::vector<entt::any> data{};
auto archive = [&data, pos = 0u](auto &value) mutable { value = entt::any_cast<std::remove_reference_t<decltype(value)>>(data[pos++]); };
const entt::entity entities[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
ASSERT_FALSE(loader.contains(entities[0u]));
ASSERT_FALSE(loader.contains(entities[1u]));
ASSERT_FALSE(registry.valid(loader.map(entities[0u])));
ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
data.emplace_back(entities[0u]);
loader.get<empty>(archive, "other"_hs);
ASSERT_TRUE(loader.contains(entities[0u]));
ASSERT_FALSE(loader.contains(entities[1u]));
ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
ASSERT_EQ(storage.size(), 0u);
ASSERT_EQ(registry.storage<empty>("other"_hs).size(), 1u);
data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
data.emplace_back(entities[0u]);
data.emplace_back(entities[1u]);
loader.get<empty>(archive);
ASSERT_TRUE(loader.contains(entities[0u]));
ASSERT_TRUE(loader.contains(entities[1u]));
ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
ASSERT_EQ(storage.size(), 2u);
ASSERT_TRUE(storage.contains(loader.map(entities[0u])));
ASSERT_TRUE(storage.contains(loader.map(entities[1u])));
}
TEST(BasicContinuousLoader, GetTypeSparse) {
using namespace entt::literals;
using traits_type = entt::entt_traits<entt::entity>;
entt::registry registry;
entt::basic_continuous_loader loader{registry};
const auto &storage = registry.storage<int>();
std::vector<entt::any> data{};
auto archive = [&data, pos = 0u](auto &value) mutable { value = entt::any_cast<std::remove_reference_t<decltype(value)>>(data[pos++]); };
const entt::entity entities[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
const int values[2u]{1, 3};
ASSERT_FALSE(loader.contains(entities[0u]));
ASSERT_FALSE(loader.contains(entities[1u]));
ASSERT_FALSE(registry.valid(loader.map(entities[0u])));
ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
data.emplace_back(static_cast<entt::entity>(entt::null));
data.emplace_back(entities[0u]);
data.emplace_back(values[0u]);
loader.get<int>(archive, "other"_hs);
ASSERT_TRUE(loader.contains(entities[0u]));
ASSERT_FALSE(loader.contains(entities[1u]));
ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
ASSERT_EQ(storage.size(), 0u);
ASSERT_EQ(registry.storage<int>("other"_hs).size(), 1u);
data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
data.emplace_back(entities[0u]);
data.emplace_back(values[0u]);
data.emplace_back(static_cast<entt::entity>(entt::null));
data.emplace_back(entities[1u]);
data.emplace_back(values[1u]);
loader.get<int>(archive);
ASSERT_TRUE(loader.contains(entities[0u]));
ASSERT_TRUE(loader.contains(entities[1u]));
ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
ASSERT_EQ(storage.size(), 2u);
ASSERT_TRUE(storage.contains(loader.map(entities[0u])));
ASSERT_TRUE(storage.contains(loader.map(entities[1u])));
ASSERT_EQ(storage.get(loader.map(entities[0u])), values[0u]);
ASSERT_EQ(storage.get(loader.map(entities[1u])), values[1u]);
}
TEST(BasicContinuousLoader, Shrink) {
entt::registry registry;
entt::basic_continuous_loader loader{registry};
ASSERT_NO_FATAL_FAILURE(loader.shrink());
}
TEST(BasicContinuousLoader, Orphans) {
using namespace entt::literals;
using traits_type = entt::entt_traits<entt::entity>;
entt::registry registry;
entt::basic_continuous_loader loader{registry};
std::vector<entt::any> data{};
auto archive = [&data, pos = 0u](auto &value) mutable { value = entt::any_cast<std::remove_reference_t<decltype(value)>>(data[pos++]); };
const entt::entity entities[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
const int value = 42;
ASSERT_FALSE(registry.valid(entities[0u]));
ASSERT_FALSE(registry.valid(entities[1u]));
data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
data.emplace_back(entities[0u]);
data.emplace_back(entities[1u]);
data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
data.emplace_back(entities[0u]);
data.emplace_back(value);
loader.get<entt::entity>(archive);
loader.get<int>(archive);
ASSERT_TRUE(loader.contains(entities[0u]));
ASSERT_TRUE(loader.contains(entities[1u]));
ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
loader.orphans();
ASSERT_TRUE(loader.contains(entities[0u]));
ASSERT_TRUE(loader.contains(entities[1u]));
ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
}
template<typename Storage>
struct output_archive {