BigfootDev/Bigfoot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Basic asset system serialization
Bigfoot / Build & Test Debug with ./ConanProfiles/clang (Unity Build: OFF) (push) Successful in 7m7s
Details
Bigfoot / Build & Test Debug with ./ConanProfiles/clang (Unity Build: ON) (push) Successful in 5m16s
Details
Bigfoot / Build & Test Debug with ./ConanProfiles/clang_asan (Unity Build: OFF) (push) Successful in 5m40s
Details
Bigfoot / Build & Test Debug with ./ConanProfiles/clang_asan (Unity Build: ON) (push) Successful in 5m39s
Details
Bigfoot / Build & Test RelWithDebInfo with ./ConanProfiles/clang (Unity Build: OFF) (push) Successful in 6m3s
Details
Bigfoot / Build & Test RelWithDebInfo with ./ConanProfiles/clang (Unity Build: ON) (push) Successful in 6m2s
Details
Bigfoot / Build & Test RelWithDebInfo with ./ConanProfiles/clang_asan (Unity Build: OFF) (push) Successful in 6m56s
Details
Bigfoot / Build & Test RelWithDebInfo with ./ConanProfiles/clang_asan (Unity Build: ON) (push) Successful in 7m4s
Details
Bigfoot / Build & Test Release with ./ConanProfiles/clang (Unity Build: OFF) (push) Successful in 6m6s
Details
Bigfoot / Build & Test Release with ./ConanProfiles/clang (Unity Build: ON) (push) Successful in 5m58s
Details
Bigfoot / Build & Test Release with ./ConanProfiles/clang_asan (Unity Build: OFF) (push) Successful in 6m34s
Details
Bigfoot / Build & Test Release with ./ConanProfiles/clang_asan (Unity Build: ON) (push) Successful in 6m45s
Details
Bigfoot / Clang Format Checks (push) Failing after 10s
Details

Browse Source
This commit is contained in:
Romain BOULLARD
2026-05-09 23:41:04 +02:00
parent 4c9c4d5547
commit 4261ddd393
51 changed files with 1266 additions and 618 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Bigfoot/Tests/Engine/Asset/Asset.cpp
+172 -36
View File
@@ -15,8 +15,7 @@
#include <EngineTests/Asset/AssetA.hpp>
#include <EngineTests/Asset/AssetB.hpp>
#include <flatbuffers/reflection.h>
#include <EngineTests/Asset/AssetC.hpp>
#include <gtest/gtest.h>
@@ -35,7 +34,7 @@ class AssetFixture: public ::testing::Test
/****************************************************************************************/
TEST_F(AssetFixture, Asset)
TEST_F(AssetFixture, AssetATests)
{
constexpr eastl::string_view name = "Hello";
constexpr std::uint32_t version = 42;
@@ -48,61 +47,198 @@ TEST_F(AssetFixture, Asset)
assetA.GetAsset().health = health;
assetA.GetAsset().mana = mana;
const eastl::vector<std::byte> test = assetA.Pack();
const eastl::vector<std::byte> test = assetA.Save();
AssetA assetB {test};
AssetA assetA_dup {test};
EXPECT_EQ(assetA.GetHeader().uuid, assetB.GetHeader().uuid);
EXPECT_EQ(assetA.GetHeader().uuid, assetA_dup.GetHeader().uuid);
EXPECT_EQ(assetA.GetHeader().type_id, AssetA::GetTypeID());
EXPECT_EQ(assetA.GetHeader().type_id, assetB.GetHeader().type_id);
EXPECT_EQ(assetA.GetHeader().type_id, assetA_dup.GetHeader().type_id);
EXPECT_EQ(assetA.GetHeader().type_name, AssetA::GetTypeName());
EXPECT_EQ(assetA.GetHeader().type_name, assetB.GetHeader().type_name);
EXPECT_EQ(assetA.GetHeader().type_name, assetA_dup.GetHeader().type_name);
EXPECT_EQ(assetA.GetHeader().name, name);
EXPECT_EQ(assetA.GetHeader().name, assetB.GetHeader().name);
EXPECT_EQ(assetA.GetHeader().name, assetA_dup.GetHeader().name);
EXPECT_EQ(assetA.GetHeader().version, version);
EXPECT_EQ(assetA.GetHeader().version, assetB.GetHeader().version);
EXPECT_EQ(assetA.GetHeader().version, assetA_dup.GetHeader().version);
EXPECT_EQ(assetA.GetHeader().dependencies, assetB.GetHeader().dependencies);
EXPECT_TRUE(assetA.GetHeader().dependencies.empty());
EXPECT_EQ(assetA.GetHeader().dependencies, assetA_dup.GetHeader().dependencies);
EXPECT_EQ(assetA.GetAsset().health, health);
EXPECT_EQ(assetA.GetAsset().health, assetB.GetAsset().health);
EXPECT_EQ(assetA.GetAsset().health, assetA_dup.GetAsset().health);
EXPECT_EQ(assetA.GetAsset().mana, mana);
EXPECT_EQ(assetA.GetAsset().mana, assetB.GetAsset().mana);
EXPECT_EQ(assetA.GetAsset().mana, assetA_dup.GetAsset().mana);
}
/****************************************************************************************/
TEST_F(AssetFixture, Reflection)
TEST_F(AssetFixture, AssetBTests)
{
[[maybe_unused]]
const reflection::Schema* reflection = reflection::GetSchema(AssetA::ReflectionInfo().data());
constexpr eastl::string_view nameA = "Hello";
constexpr std::uint32_t versionA = 42;
constexpr std::uint32_t healthA = 100;
constexpr std::uint32_t manaA = 50;
for (const auto test: *reflection->root_table()->fields())
{
eastl::string typeName;
AssetA assetA;
assetA.SetName(nameA);
assetA.SetVersion(versionA);
assetA.GetAsset().health = healthA;
assetA.GetAsset().mana = manaA;
if (test->type()->base_type() == reflection::BaseType::Obj)
{
const reflection::Object* obj = reflection->objects()->Get(test->type()->index());
typeName = obj->name()->c_str();
}
else if (test->type()->base_type() == reflection::BaseType::Vector &&
test->type()->element() == reflection::BaseType::Obj)
{
const reflection::Object* obj = reflection->objects()->Get(test->type()->index());
typeName = eastl::string("[") + obj->name()->c_str() + "]";
}
else
{
typeName = reflection::EnumNameBaseType(test->type()->base_type());
}
constexpr eastl::string_view nameAA = "There";
constexpr std::uint32_t versionAA = 42;
constexpr std::uint32_t healthAA = 100;
constexpr std::uint32_t manaAA = 50;
BIGFOOT_LOG_INFO(ENGINE_LOGGER, "{} {}", typeName, test->name()->c_str());
}
AssetA assetAA;
assetAA.SetName(nameAA);
assetAA.SetVersion(versionAA);
assetAA.GetAsset().health = healthAA;
assetAA.GetAsset().mana = manaAA;
constexpr eastl::string_view nameB = "Kenobi";
constexpr std::uint32_t versionB = 1;
AssetB assetB;
assetB.SetName(nameB);
assetB.SetVersion(versionB);
assetB.GetAsset().asset_a_ref = HardRef<AssetA> {assetA.GetHeader().uuid};
assetB.GetAsset().asset_a_refs = {SoftRef<AssetA> {assetA.GetHeader().uuid},
SoftRef<AssetA> {assetAA.GetHeader().uuid}};
const eastl::vector<std::byte> test = assetB.Save();
AssetB assetB_dup {test};
EXPECT_EQ(assetB.GetHeader().uuid, assetB_dup.GetHeader().uuid);
EXPECT_EQ(assetB.GetHeader().type_id, AssetB::GetTypeID());
EXPECT_EQ(assetB.GetHeader().type_id, assetB_dup.GetHeader().type_id);
EXPECT_EQ(assetB.GetHeader().type_name, AssetB::GetTypeName());
EXPECT_EQ(assetB.GetHeader().type_name, assetB_dup.GetHeader().type_name);
EXPECT_EQ(assetB.GetHeader().name, nameB);
EXPECT_EQ(assetB.GetHeader().name, assetB_dup.GetHeader().name);
EXPECT_EQ(assetB.GetHeader().version, versionB);
EXPECT_EQ(assetB.GetHeader().version, assetB_dup.GetHeader().version);
EXPECT_EQ(assetB.GetHeader().dependencies.size(), 1);
EXPECT_NE(eastl::find(assetB.GetHeader().dependencies.begin(),
assetB.GetHeader().dependencies.end(),
assetA.GetHeader().uuid),
assetB.GetHeader().dependencies.end());
EXPECT_EQ(assetB.GetHeader().dependencies, assetB_dup.GetHeader().dependencies);
EXPECT_EQ(assetB.GetAsset().asset_a_ref, HardRef<AssetA> {assetA.GetHeader().uuid});
EXPECT_EQ(assetB.GetAsset().asset_a_ref, assetB_dup.GetAsset().asset_a_ref);
EXPECT_EQ(assetB.GetAsset().asset_a_refs,
(eastl::vector<SoftRef<AssetA>> {SoftRef<AssetA> {assetA.GetHeader().uuid},
SoftRef<AssetA> {assetAA.GetHeader().uuid}}));
EXPECT_EQ(assetB.GetAsset().asset_a_refs, assetB_dup.GetAsset().asset_a_refs);
}
/****************************************************************************************/
TEST_F(AssetFixture, AssetCTests)
{
constexpr eastl::string_view nameA = "Hello";
constexpr std::uint32_t versionA = 42;
constexpr std::uint32_t healthA = 100;
constexpr std::uint32_t manaA = 50;
AssetA assetA;
assetA.SetName(nameA);
assetA.SetVersion(versionA);
assetA.GetAsset().health = healthA;
assetA.GetAsset().mana = manaA;
constexpr eastl::string_view nameAA = "There";
constexpr std::uint32_t versionAA = 42;
constexpr std::uint32_t healthAA = 100;
constexpr std::uint32_t manaAA = 50;
AssetA assetAA;
assetAA.SetName(nameAA);
assetAA.SetVersion(versionAA);
assetAA.GetAsset().health = healthAA;
assetAA.GetAsset().mana = manaAA;
constexpr eastl::string_view nameB = "Kenobi";
constexpr std::uint32_t versionB = 1;
AssetB assetB;
assetB.SetName(nameB);
assetB.SetVersion(versionB);
assetB.GetAsset().asset_a_ref = HardRef<AssetA> {assetA.GetHeader().uuid};
assetB.GetAsset().asset_a_refs = {SoftRef<AssetA> {assetA.GetHeader().uuid},
SoftRef<AssetA> {assetAA.GetHeader().uuid}};
constexpr eastl::string_view nameC = "General";
constexpr std::uint32_t versionC = 1;
AssetC assetC;
assetC.SetName(nameC);
assetC.SetVersion(versionC);
assetC.GetAsset().inner_table->asset_a_ref = HardRef<AssetA> {assetA.GetHeader().uuid};
assetC.GetAsset().inner_table->asset_a_refs = {HardRef<AssetA> {assetA.GetHeader().uuid},
HardRef<AssetA> {assetAA.GetHeader().uuid}};
assetC.GetAsset().asset_b_ref = HardRef<AssetB> {assetB.GetHeader().uuid};
assetC.GetAsset().asset_b_refs = {SoftRef<AssetB> {assetB.GetHeader().uuid}};
const eastl::vector<std::byte> test = assetC.Save();
AssetC assetC_dup {test};
EXPECT_EQ(assetC.GetHeader().uuid, assetC_dup.GetHeader().uuid);
EXPECT_EQ(assetC.GetHeader().type_id, AssetC::GetTypeID());
EXPECT_EQ(assetC.GetHeader().type_id, assetC_dup.GetHeader().type_id);
EXPECT_EQ(assetC.GetHeader().type_name, AssetC::GetTypeName());
EXPECT_EQ(assetC.GetHeader().type_name, assetC_dup.GetHeader().type_name);
EXPECT_EQ(assetC.GetHeader().name, nameC);
EXPECT_EQ(assetC.GetHeader().name, assetC_dup.GetHeader().name);
EXPECT_EQ(assetC.GetHeader().version, versionC);
EXPECT_EQ(assetC.GetHeader().version, assetC_dup.GetHeader().version);
EXPECT_EQ(assetC.GetHeader().dependencies.size(), 3);
EXPECT_NE(eastl::find(assetC.GetHeader().dependencies.begin(),
assetC.GetHeader().dependencies.end(),
assetB.GetHeader().uuid),
assetC.GetHeader().dependencies.end());
EXPECT_NE(eastl::find(assetC.GetHeader().dependencies.begin(),
assetC.GetHeader().dependencies.end(),
assetA.GetHeader().uuid),
assetC.GetHeader().dependencies.end());
EXPECT_NE(eastl::find(assetC.GetHeader().dependencies.begin(),
assetC.GetHeader().dependencies.end(),
assetAA.GetHeader().uuid),
assetC.GetHeader().dependencies.end());
EXPECT_EQ(assetC.GetHeader().dependencies, assetC_dup.GetHeader().dependencies);
EXPECT_EQ(assetC.GetAsset().asset_b_ref, HardRef<AssetB> {assetB.GetHeader().uuid});
EXPECT_EQ(assetC.GetAsset().asset_b_ref, assetC_dup.GetAsset().asset_b_ref);
EXPECT_EQ(assetC.GetAsset().asset_b_refs,
(eastl::vector<SoftRef<AssetB>> {SoftRef<AssetB> {assetB.GetHeader().uuid}}));
EXPECT_EQ(assetC.GetAsset().asset_b_refs, assetC_dup.GetAsset().asset_b_refs);
EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_ref, HardRef<AssetA> {assetA.GetHeader().uuid});
EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_ref, assetC_dup.GetAsset().inner_table->asset_a_ref);
EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_refs,
(eastl::vector<HardRef<AssetA>> {HardRef<AssetA> {assetA.GetHeader().uuid},
HardRef<AssetA> {assetAA.GetHeader().uuid}}));
EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_refs, assetC_dup.GetAsset().inner_table->asset_a_refs);
}
} // namespace Bigfoot