test: basic snapshot loader

test/entt/entity/snapshot.cpp

@@ -168,6 +168,119 @@ TEST(BasicSnapshot, GetTypeSparse) {
     ASSERT_EQ(entt::any_cast<int>(data[5u]), values[2u]);
 }
 
+TEST(BasicSnapshotLoader, Constructors) {
+    static_assert(!std::is_default_constructible_v<entt::basic_snapshot_loader<entt::registry>>);
+    static_assert(!std::is_copy_constructible_v<entt::basic_snapshot_loader<entt::registry>>);
+    static_assert(!std::is_copy_assignable_v<entt::basic_snapshot_loader<entt::registry>>);
+    static_assert(std::is_move_constructible_v<entt::basic_snapshot_loader<entt::registry>>);
+    static_assert(std::is_move_assignable_v<entt::basic_snapshot_loader<entt::registry>>);
+
+    entt::registry registry;
+    entt::basic_snapshot_loader loader{registry};
+    entt::basic_snapshot_loader other{std::move(loader)};
+
+    ASSERT_NO_FATAL_FAILURE(loader = std::move(other));
+}
+
+TEST(BasicSnapshotLoader, GetEntityType) {
+    using namespace entt::literals;
+    using traits_type = entt::entt_traits<entt::entity>;
+
+    entt::registry registry;
+    entt::basic_snapshot_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(0u, 0u), traits_type::construct(2u, 0u), traits_type::construct(1u, 1u)};
+
+    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_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(registry.valid(entities[0u]));
+    ASSERT_TRUE(registry.valid(entities[1u]));
+    ASSERT_TRUE(registry.valid(entities[2u]));
+
+    ASSERT_EQ(storage.size(), 3u);
+    ASSERT_EQ(storage.in_use(), 2u);
+
+    ASSERT_EQ(storage[0u], entities[0u]);
+    ASSERT_EQ(storage[1u], entities[1u]);
+    ASSERT_EQ(storage[2u], entities[2u]);
+
+    ASSERT_EQ(registry.create(), entities[2u]);
+}
+
+TEST(BasicSnapshotLoader, GetType) {
+    using namespace entt::literals;
+    using traits_type = entt::entt_traits<entt::entity>;
+
+    entt::registry registry;
+    entt::basic_snapshot_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(registry.valid(entities[0u]));
+    ASSERT_FALSE(registry.valid(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(registry.valid(entities[0u]));
+    ASSERT_FALSE(registry.valid(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(registry.valid(entities[0u]));
+    ASSERT_TRUE(registry.valid(entities[1u]));
+
+    ASSERT_EQ(storage.size(), 2u);
+    ASSERT_TRUE(storage.contains(entities[0u]));
+    ASSERT_TRUE(storage.contains(entities[1u]));
+    ASSERT_EQ(storage.get(entities[0u]), values[0u]);
+    ASSERT_EQ(storage.get(entities[1u]), values[1u]);
+}
+
 template<typename Storage>
 struct output_archive {
     output_archive(Storage &instance)