Bigfoot/Bigfoot/Tests/Engine/Asset/AssetContainer.cpp

/*********************************************************************
 * \file   AssetContainer.cpp
 *
 * \author Romain BOULLARD
 * \date   July 2026
 *********************************************************************/
#include <Engine/Asset/AssetContainer.hpp>

#include <AssetsForTesting/Asset/AssetA.hpp>

#include <gtest/gtest.h>

namespace Bigfoot
{
class ContainerHandleFixture: public ::testing::Test
{
  protected:
    void SetUp() override
    {
        const auto key = m_containerA.Insert();

        m_uuid = m_containerA.Get(key)->GetHeader().uuid;

        m_handle = m_containerA.AcquireContainerHandle(m_uuid);
    }

    AssetContainer<AssetA> m_containerA;

    UUID m_uuid;

    ContainerHandle* m_handle;
};

/****************************************************************************************/

TEST_F(ContainerHandleFixture, GetAsset_ShouldReturnTheAsset)
{
    EXPECT_NE(m_handle->GetAsset(), nullptr);
}

/****************************************************************************************/

TEST_F(ContainerHandleFixture, GetAsset_ShouldReturnNullptrIfTheAssetHasBeenRemoved)
{
    m_containerA.Remove(m_uuid);
    EXPECT_EQ(m_handle->GetAsset(), nullptr);
}

/****************************************************************************************/

TEST_F(ContainerHandleFixture, IncrementHardRefCount_ShouldIncrementTheHardRefCount)
{
    const std::uint32_t original = m_handle->GetHardRefCount();
    m_handle->IncrementHardRefCount();
    EXPECT_EQ(original + 1, m_handle->GetHardRefCount());
}

/****************************************************************************************/

TEST_F(ContainerHandleFixture, IncrementSoftRefCount_ShouldIncrementTheSoftRefCount)
{
    const std::uint32_t original = m_handle->GetSoftRefCount();
    m_handle->IncrementSoftRefCount();
    EXPECT_EQ(original + 1, m_handle->GetSoftRefCount());
}

/****************************************************************************************/

TEST_F(ContainerHandleFixture, DecrementHardRefCount_ShouldDecrementTheHardRefCount)
{
    m_handle->IncrementHardRefCount();

    const std::uint32_t original = m_handle->GetHardRefCount();
    m_handle->DecrementHardRefCount();
    EXPECT_EQ(original - 1, m_handle->GetHardRefCount());
}

/****************************************************************************************/

TEST_F(ContainerHandleFixture, DecrementSoftRefCount_ShouldDecrementTheSoftRefCount)
{
    m_handle->IncrementSoftRefCount();

    const std::uint32_t original = m_handle->GetSoftRefCount();
    m_handle->DecrementSoftRefCount();
    EXPECT_EQ(original - 1, m_handle->GetSoftRefCount());
}

/****************************************************************************************/

class AssetContainerFixture: public ::testing::Test
{
  protected:
    AssetContainer<AssetA> m_containerA;
};

/****************************************************************************************/

TEST_F(AssetContainerFixture, Has_ShouldReturnTrueIfTheContainerHasTheAsset)
{
    const auto key = m_containerA.Insert();
    EXPECT_TRUE(m_containerA.Has(m_containerA.Get(key)->GetHeader().uuid));
}

/****************************************************************************************/

TEST_F(AssetContainerFixture, Has_ShouldReturnFalseIfTheContainerDoesNotHaveTheAsset)
{
    EXPECT_FALSE(m_containerA.Has(UUID {}));
}

/****************************************************************************************/

TEST_F(AssetContainerFixture, AcquireHandle_ShouldReturnTheAssociatedContainerHandle)
{
    const auto key = m_containerA.Insert();

    const ContainerHandle* handle = m_containerA.AcquireContainerHandle(m_containerA.Get(key)->GetHeader().uuid);
    EXPECT_EQ(static_cast<const AssetA*>(handle->GetAsset())->GetHeader().uuid,
              m_containerA.Get(key)->GetHeader().uuid);
}

/****************************************************************************************/

TEST_F(AssetContainerFixture, AcquireHandle_ShouldCreateTheAssociatedContainerHandleIfItDoesNotExists)
{
    const ContainerHandle* handle = m_containerA.AcquireContainerHandle(UUID {});
    EXPECT_EQ(handle->GetAsset(), nullptr);
}

/****************************************************************************************/

TEST_F(AssetContainerFixture, Insert_ShouldReturnValidAndUniqueSlotKeyOnInsert)
{
    const SlotMapKey slotKey = m_containerA.Insert();
    EXPECT_TRUE(slotKey.Valid());
    EXPECT_NE(slotKey, m_containerA.Insert());
}

/****************************************************************************************/

TEST_F(AssetContainerFixture, Insert_ShouldReturnTheSameSlotKeyInCaseOfDuplicatedUUID)
{
    const SlotMapKey slotKey = m_containerA.Insert();

    AssetA duplicate;
    duplicate.Unpack(m_containerA.Get(slotKey)->Pack());

    EXPECT_EQ(slotKey, m_containerA.Insert(std::move(duplicate)));
}

/****************************************************************************************/

TEST_F(AssetContainerFixture, Get_ShouldReturnTheAssetWithTheSlotKey)
{
    const SlotMapKey slotKey = m_containerA.Insert();

    EXPECT_NE(m_containerA.Get(slotKey), nullptr);
    EXPECT_NE(std::as_const(m_containerA).Get(slotKey), nullptr);
}

/****************************************************************************************/

TEST_F(AssetContainerFixture, Get_ShouldReturnNullptrIfSlotKeyNotInContainer)
{
    EXPECT_EQ(m_containerA.Get(SlotMapKey<> {1, 0}), nullptr);
    EXPECT_EQ(std::as_const(m_containerA).Get(SlotMapKey<> {1, 0}), nullptr);
}

/****************************************************************************************/

TEST_F(AssetContainerFixture, Remove_ShouldRemoveTheAsset)
{
    const SlotMapKey slotKey = m_containerA.Insert();
    const UUID uuid = m_containerA.Get(slotKey)->GetHeader().uuid;

    m_containerA.Remove(uuid);

    EXPECT_EQ(m_containerA.Get(slotKey), nullptr);
    EXPECT_FALSE(m_containerA.Has(uuid));
}
}   // namespace Bigfoot