Bigfoot/Bigfoot/Tests/Engine/Asset/Reference.cpp

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

#include <AssetsForTesting/Asset/AssetA.hpp>
#include <AssetsForTesting/Asset/AssetB.hpp>
#include <AssetsForTesting/Asset/AssetC.hpp>

#include <gtest/gtest.h>

namespace Bigfoot
{
class HardReferenceFixture: public ::testing::Test
{
  protected:
    void SetUp() override
    {
        SetActiveAssetLibrary(&m_library);

        std::ignore = m_library.Insert(&m_containerA);
    }

    void TearDown() override
    {
        SetActiveAssetLibrary(&g_assetLibrary);
    }

    AssetContainer<AssetA> m_containerA;

    AssetLibrary m_library;
};

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

TEST_F(HardReferenceFixture, GetUUID_ShouldReturnTheUUID)
{
    UUID uuid;
    HardReference<AssetA> hardRef {uuid};

    EXPECT_EQ(hardRef.GetUUID(), uuid);
}

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

TEST_F(HardReferenceFixture, Get_ShouldReturnTheAsset)
{
    const auto key = m_containerA.Insert();
    const UUID uuid = m_containerA.Get(key)->GetHeader().uuid;

    HardReference<AssetA> hardRef {uuid};

    EXPECT_EQ(hardRef.Get(), m_containerA.Get(key));
    EXPECT_EQ(std::as_const(hardRef).Get(), std::as_const(m_containerA).Get(key));
}

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

TEST_F(HardReferenceFixture, Get_ShouldReturnNullptrIfTheAssetDoesNotExist)
{
    UUID uuid;
    HardReference<AssetA> hardRef {uuid};

    EXPECT_EQ(hardRef.Get(), nullptr);
    EXPECT_EQ(std::as_const(hardRef).Get(), nullptr);
}

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

TEST_F(HardReferenceFixture, Get_ShouldReturnNullptrAfterTheAssetIsRemovedFromTheContainer)
{
    const auto key = m_containerA.Insert();
    const UUID uuid = m_containerA.Get(key)->GetHeader().uuid;

    HardReference<AssetA> hardRef {uuid};

    m_containerA.Remove(uuid);

    EXPECT_EQ(hardRef.Get(), nullptr);
    EXPECT_EQ(std::as_const(hardRef).Get(), nullptr);
}

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

TEST_F(HardReferenceFixture, ShouldTouchTheHardRefCountOfTheHandle)
{
    UUID uuid;
    const ContainerHandle* handle = m_containerA.AcquireContainerHandle(uuid);

    EXPECT_EQ(handle->GetHardRefCount(), 0);

    {
        HardReference<AssetA> hardRef1 {uuid};
        EXPECT_EQ(handle->GetHardRefCount(), 1);
        {
            HardReference<AssetA> hardRef2 {uuid};
            EXPECT_EQ(handle->GetHardRefCount(), 2);
        }
        EXPECT_EQ(handle->GetHardRefCount(), 1);
    }

    EXPECT_EQ(handle->GetHardRefCount(), 0);
}

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

TEST_F(HardReferenceFixture, CopyConstructor_ShouldIncrementTheHardRefCountAndCopyTheState)
{
    const auto key = m_containerA.Insert();
    const UUID uuid = m_containerA.Get(key)->GetHeader().uuid;
    const ContainerHandle* handle = m_containerA.AcquireContainerHandle(uuid);

    HardReference<AssetA> hardRef1 {uuid};
    EXPECT_EQ(handle->GetHardRefCount(), 1);

    HardReference<AssetA> hardRef2 {hardRef1};

    EXPECT_EQ(handle->GetHardRefCount(), 2);
    EXPECT_EQ(hardRef2.GetUUID(), uuid);
    EXPECT_EQ(hardRef2.Get(), m_containerA.Get(key));
}

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

TEST_F(HardReferenceFixture, MoveConstructor_ShouldTransferTheStateWithoutChangingTheHardRefCount)
{
    const auto key = m_containerA.Insert();
    const UUID uuid = m_containerA.Get(key)->GetHeader().uuid;
    const ContainerHandle* handle = m_containerA.AcquireContainerHandle(uuid);

    HardReference<AssetA> hardRef1 {uuid};
    EXPECT_EQ(handle->GetHardRefCount(), 1);

    HardReference<AssetA> hardRef2 {std::move(hardRef1)};

    EXPECT_EQ(handle->GetHardRefCount(), 1);
    EXPECT_EQ(hardRef2.GetUUID(), uuid);
    EXPECT_EQ(hardRef2.Get(), m_containerA.Get(key));
    EXPECT_EQ(hardRef1.GetUUID(), UUID::NULL_UUID);
    EXPECT_EQ(hardRef1.Get(), nullptr);
}

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

TEST_F(HardReferenceFixture, CopyAssignment_ShouldReleaseThePreviousHandleAndAcquireTheNewOne)
{
    UUID uuidA;
    UUID uuidB;
    const ContainerHandle* handleA = m_containerA.AcquireContainerHandle(uuidA);
    const ContainerHandle* handleB = m_containerA.AcquireContainerHandle(uuidB);

    HardReference<AssetA> hardRefA {uuidA};
    HardReference<AssetA> hardRefB {uuidB};
    EXPECT_EQ(handleA->GetHardRefCount(), 1);
    EXPECT_EQ(handleB->GetHardRefCount(), 1);

    hardRefB = hardRefA;

    EXPECT_EQ(handleA->GetHardRefCount(), 2);
    EXPECT_EQ(handleB->GetHardRefCount(), 0);
    EXPECT_EQ(hardRefB.GetUUID(), uuidA);
    EXPECT_EQ(hardRefB.Get(), hardRefA.Get());
}

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

TEST_F(HardReferenceFixture, CopyAssignment_SelfAssignment_ShouldNotChangeTheHardRefCount)
{
    UUID uuid;
    const ContainerHandle* handle = m_containerA.AcquireContainerHandle(uuid);

    HardReference<AssetA> hardRef {uuid};
    EXPECT_EQ(handle->GetHardRefCount(), 1);

    HardReference<AssetA>* selfPtr = &hardRef;
    hardRef = *selfPtr;

    EXPECT_EQ(handle->GetHardRefCount(), 1);
    EXPECT_EQ(hardRef.GetUUID(), uuid);
}

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

TEST_F(HardReferenceFixture, MoveAssignment_ShouldReleaseThePreviousHandleAndTransferTheNewOne)
{
    UUID uuidA;
    UUID uuidB;
    const ContainerHandle* handleA = m_containerA.AcquireContainerHandle(uuidA);
    const ContainerHandle* handleB = m_containerA.AcquireContainerHandle(uuidB);

    HardReference<AssetA> hardRefA {uuidA};
    HardReference<AssetA> hardRefB {uuidB};
    EXPECT_EQ(handleA->GetHardRefCount(), 1);
    EXPECT_EQ(handleB->GetHardRefCount(), 1);

    hardRefB = std::move(hardRefA);

    EXPECT_EQ(handleA->GetHardRefCount(), 1);
    EXPECT_EQ(handleB->GetHardRefCount(), 0);
    EXPECT_EQ(hardRefB.GetUUID(), uuidA);
    EXPECT_EQ(hardRefA.GetUUID(), UUID::NULL_UUID);
    EXPECT_EQ(hardRefA.Get(), nullptr);
}

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

TEST_F(HardReferenceFixture, MoveAssignment_SelfAssignment_ShouldNotChangeTheHardRefCount)
{
    UUID uuid;
    const ContainerHandle* handle = m_containerA.AcquireContainerHandle(uuid);

    HardReference<AssetA> hardRef {uuid};
    EXPECT_EQ(handle->GetHardRefCount(), 1);

    HardReference<AssetA>* selfPtr = &hardRef;
    hardRef = std::move(*selfPtr);

    EXPECT_EQ(handle->GetHardRefCount(), 1);
    EXPECT_EQ(hardRef.GetUUID(), uuid);
}

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

TEST_F(HardReferenceFixture, EqualityOperator_ShouldReturnTrueForReferencesWithTheSameUUID)
{
    UUID uuid;
    HardReference<AssetA> hardRef1 {uuid};
    HardReference<AssetA> hardRef2 {uuid};

    EXPECT_EQ(hardRef1, hardRef2);
}

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

TEST_F(HardReferenceFixture, EqualityOperator_ShouldReturnFalseForReferencesWithDifferentUUIDs)
{
    UUID uuid1;
    UUID uuid2;
    HardReference<AssetA> hardRef1 {uuid1};
    HardReference<AssetA> hardRef2 {uuid2};

    EXPECT_NE(hardRef1, hardRef2);
}

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

class SoftReferenceFixture: public ::testing::Test
{
  protected:
    void SetUp() override
    {
        SetActiveAssetLibrary(&m_library);

        std::ignore = m_library.Insert(&m_containerA);
    }

    void TearDown() override
    {
        SetActiveAssetLibrary(&g_assetLibrary);
    }

    AssetContainer<AssetA> m_containerA;

    AssetLibrary m_library;
};

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

TEST_F(SoftReferenceFixture, GetUUID_ShouldReturnTheUUID)
{
    UUID uuid;
    SoftReference<AssetA> hardRef {uuid};

    EXPECT_EQ(hardRef.GetUUID(), uuid);
}

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

TEST_F(SoftReferenceFixture, Get_ShouldReturnTheAsset)
{
    const auto key = m_containerA.Insert();
    const UUID uuid = m_containerA.Get(key)->GetHeader().uuid;

    SoftReference<AssetA> hardRef {uuid};

    EXPECT_EQ(hardRef.Get(), m_containerA.Get(key));
    EXPECT_EQ(std::as_const(hardRef).Get(), std::as_const(m_containerA).Get(key));
}

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

TEST_F(SoftReferenceFixture, Get_ShouldReturnNullptrIfTheAssetDoesNotExist)
{
    UUID uuid;
    SoftReference<AssetA> hardRef {uuid};

    EXPECT_EQ(hardRef.Get(), nullptr);
    EXPECT_EQ(std::as_const(hardRef).Get(), nullptr);
}

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

TEST_F(SoftReferenceFixture, Get_ShouldReturnNullptrAfterTheAssetIsRemovedFromTheContainer)
{
    const auto key = m_containerA.Insert();
    const UUID uuid = m_containerA.Get(key)->GetHeader().uuid;

    SoftReference<AssetA> hardRef {uuid};

    m_containerA.Remove(uuid);

    EXPECT_EQ(hardRef.Get(), nullptr);
    EXPECT_EQ(std::as_const(hardRef).Get(), nullptr);
}

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

TEST_F(SoftReferenceFixture, ShouldTouchTheSoftRefCountOfTheHandle)
{
    UUID uuid;
    const ContainerHandle* handle = m_containerA.AcquireContainerHandle(uuid);

    EXPECT_EQ(handle->GetSoftRefCount(), 0);

    {
        SoftReference<AssetA> softRef1 {uuid};
        EXPECT_EQ(handle->GetSoftRefCount(), 1);
        {
            SoftReference<AssetA> softRef2 {uuid};
            EXPECT_EQ(handle->GetSoftRefCount(), 2);
        }
        EXPECT_EQ(handle->GetSoftRefCount(), 1);
    }

    EXPECT_EQ(handle->GetSoftRefCount(), 0);
}

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

TEST_F(SoftReferenceFixture, CopyConstructor_ShouldIncrementTheSoftRefCountAndCopyTheState)
{
    const auto key = m_containerA.Insert();
    const UUID uuid = m_containerA.Get(key)->GetHeader().uuid;
    const ContainerHandle* handle = m_containerA.AcquireContainerHandle(uuid);

    SoftReference<AssetA> softRef1 {uuid};
    EXPECT_EQ(handle->GetSoftRefCount(), 1);

    SoftReference<AssetA> softRef2 {softRef1};

    EXPECT_EQ(handle->GetSoftRefCount(), 2);
    EXPECT_EQ(softRef2.GetUUID(), uuid);
    EXPECT_EQ(softRef2.Get(), m_containerA.Get(key));
}

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

TEST_F(SoftReferenceFixture, MoveConstructor_ShouldTransferTheStateWithoutChangingTheSoftRefCount)
{
    const auto key = m_containerA.Insert();
    const UUID uuid = m_containerA.Get(key)->GetHeader().uuid;
    const ContainerHandle* handle = m_containerA.AcquireContainerHandle(uuid);

    SoftReference<AssetA> softRef1 {uuid};
    EXPECT_EQ(handle->GetSoftRefCount(), 1);

    SoftReference<AssetA> softRef2 {std::move(softRef1)};

    EXPECT_EQ(handle->GetSoftRefCount(), 1);
    EXPECT_EQ(softRef2.GetUUID(), uuid);
    EXPECT_EQ(softRef2.Get(), m_containerA.Get(key));
    EXPECT_EQ(softRef1.GetUUID(), UUID::NULL_UUID);
    EXPECT_EQ(softRef1.Get(), nullptr);
}

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

TEST_F(SoftReferenceFixture, CopyAssignment_ShouldReleaseThePreviousHandleAndAcquireTheNewOne)
{
    UUID uuidA;
    UUID uuidB;
    const ContainerHandle* handleA = m_containerA.AcquireContainerHandle(uuidA);
    const ContainerHandle* handleB = m_containerA.AcquireContainerHandle(uuidB);

    SoftReference<AssetA> softRefA {uuidA};
    SoftReference<AssetA> softRefB {uuidB};
    EXPECT_EQ(handleA->GetSoftRefCount(), 1);
    EXPECT_EQ(handleB->GetSoftRefCount(), 1);

    softRefB = softRefA;

    EXPECT_EQ(handleA->GetSoftRefCount(), 2);
    EXPECT_EQ(handleB->GetSoftRefCount(), 0);
    EXPECT_EQ(softRefB.GetUUID(), uuidA);
    EXPECT_EQ(softRefB.Get(), softRefA.Get());
}

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

TEST_F(SoftReferenceFixture, CopyAssignment_SelfAssignment_ShouldNotChangeTheSoftRefCount)
{
    UUID uuid;
    const ContainerHandle* handle = m_containerA.AcquireContainerHandle(uuid);

    SoftReference<AssetA> softRef {uuid};
    EXPECT_EQ(handle->GetSoftRefCount(), 1);

    SoftReference<AssetA>* selfPtr = &softRef;
    softRef = *selfPtr;

    EXPECT_EQ(handle->GetSoftRefCount(), 1);
    EXPECT_EQ(softRef.GetUUID(), uuid);
}

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

TEST_F(SoftReferenceFixture, MoveAssignment_ShouldReleaseThePreviousHandleAndTransferTheNewOne)
{
    UUID uuidA;
    UUID uuidB;
    const ContainerHandle* handleA = m_containerA.AcquireContainerHandle(uuidA);
    const ContainerHandle* handleB = m_containerA.AcquireContainerHandle(uuidB);

    SoftReference<AssetA> softRefA {uuidA};
    SoftReference<AssetA> softRefB {uuidB};
    EXPECT_EQ(handleA->GetSoftRefCount(), 1);
    EXPECT_EQ(handleB->GetSoftRefCount(), 1);

    softRefB = std::move(softRefA);

    EXPECT_EQ(handleA->GetSoftRefCount(), 1);
    EXPECT_EQ(handleB->GetSoftRefCount(), 0);
    EXPECT_EQ(softRefB.GetUUID(), uuidA);
    EXPECT_EQ(softRefA.GetUUID(), UUID::NULL_UUID);
    EXPECT_EQ(softRefA.Get(), nullptr);
}

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

TEST_F(SoftReferenceFixture, MoveAssignment_SelfAssignment_ShouldNotChangeTheSoftRefCount)
{
    UUID uuid;
    const ContainerHandle* handle = m_containerA.AcquireContainerHandle(uuid);

    SoftReference<AssetA> softRef {uuid};
    EXPECT_EQ(handle->GetSoftRefCount(), 1);

    SoftReference<AssetA>* selfPtr = &softRef;
    softRef = std::move(*selfPtr);

    EXPECT_EQ(handle->GetSoftRefCount(), 1);
    EXPECT_EQ(softRef.GetUUID(), uuid);
}

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

TEST_F(SoftReferenceFixture, EqualityOperator_ShouldReturnTrueForReferencesWithTheSameUUID)
{
    UUID uuid;
    SoftReference<AssetA> softRef1 {uuid};
    SoftReference<AssetA> softRef2 {uuid};

    EXPECT_EQ(softRef1, softRef2);
}

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

TEST_F(SoftReferenceFixture, EqualityOperator_ShouldReturnFalseForReferencesWithDifferentUUIDs)
{
    UUID uuid1;
    UUID uuid2;
    SoftReference<AssetA> softRef1 {uuid1};
    SoftReference<AssetA> softRef2 {uuid2};

    EXPECT_NE(softRef1, softRef2);
}
}   // namespace Bigfoot