basic testing for reference

Bigfoot/Sources/Engine/Asset/AssetLibrary.cpp

@@ -0,0 +1,15 @@
+/*********************************************************************
+ * \file   AssetLibrary.cpp
+ *
+ * \author Romain BOULLARD
+ * \date   August 2026
+ *********************************************************************/
+#include <Engine/Asset/AssetLibrary.hpp>
+
+namespace Bigfoot
+{
+void SetActiveAssetLibrary(AssetLibrary* p_assetLibrary)
+{
+    g_activeAssetLibrary = p_assetLibrary;
+}
+}   // namespace Bigfoot

Bigfoot/Sources/Engine/Include/Engine/Asset/AssetContainer.hpp

@@ -27,6 +27,17 @@ class ContainerHandle
 
     ~ContainerHandle() = default;
 
+    /*
+     * Get the HardRef count
+     *
+     * \return The HardRef count.
+     */
+    [[nodiscard]]
+    std::uint32_t GetHardRefCount() const
+    {
+        return m_hardRefCount;
+    }
+
     /*
      * Increment the HardRef count
      *
@@ -45,6 +56,17 @@ class ContainerHandle
         --m_hardRefCount;
     }
 
+    /*
+     * Get the SoftRef count
+     *
+     * \return The SoftRef count.
+     */
+    [[nodiscard]]
+    std::uint32_t GetSoftRefCount() const
+    {
+        return m_softRefCount;
+    }
+
     /*
      * Increment the SoftRef count
      *

Bigfoot/Sources/Engine/Include/Engine/Asset/AssetLibrary.hpp

@@ -163,13 +163,22 @@ inline AssetLibrary* g_activeAssetLibrary = &g_assetLibrary;
 
 /****************************************************************************************/
 
+/*
+ * Set the active asset library
+ *
+ * \param p_assetLibrary The asset library to set g_activeAssetLibrary to.
+ */
+void SetActiveAssetLibrary(AssetLibrary* p_assetLibrary);
+
+/****************************************************************************************/
+
 class ScopedActiveAssetLibrary
 {
   public:
     ScopedActiveAssetLibrary(AssetLibrary* p_assetLibrary):
         m_previous(g_activeAssetLibrary)
     {
-        g_activeAssetLibrary = p_assetLibrary;
+        SetActiveAssetLibrary(p_assetLibrary);
     }
 
     ScopedActiveAssetLibrary(const ScopedActiveAssetLibrary& p_scopedActiveAssetLibrary) = default;
@@ -177,7 +186,7 @@ class ScopedActiveAssetLibrary
 
     ~ScopedActiveAssetLibrary()
     {
-        g_activeAssetLibrary = m_previous;
+        SetActiveAssetLibrary(m_previous);
     }
 
     ScopedActiveAssetLibrary& operator=(const ScopedActiveAssetLibrary& p_scopedActiveAssetLibrary) = default;

Bigfoot/Sources/Utils/Include/Utils/Containers/SlotMap.hpp

@@ -692,7 +692,7 @@ class StableSlotMap
     [[nodiscard]]
     T* Get(const SlotMapKey p_key)
     {
-        return const_cast<T*>(std::as_const(*this).Get(p_key));
+        return Has(p_key) ? GetPageAt(GetPageIndex(p_key))->Get(GetDataOffset(p_key)) : nullptr;
     }
 
     [[nodiscard]]

Bigfoot/Tests/Engine/Asset/AssetContainer.cpp

@@ -43,6 +43,46 @@ TEST_F(ContainerHandleFixture, GetAsset_ShouldReturnNullptrIfTheAssetHasBeenRemo
 
 /****************************************************************************************/
 
+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:
@@ -114,7 +154,7 @@ TEST_F(AssetContainerFixture, Get_ShouldReturnTheAssetWithTheSlotKey)
     const SlotMapKey slotKey = m_containerA.Insert(asset);
 
     EXPECT_EQ(m_containerA.Get(slotKey)->GetHeader().uuid, asset.GetHeader().uuid);
-    EXPECT_EQ(const_cast<const AssetContainer<AssetA>&>(m_containerA).Get(slotKey)->GetHeader().uuid,
+    EXPECT_EQ(std::as_const(m_containerA).Get(slotKey)->GetHeader().uuid,
               asset.GetHeader().uuid);
 }
 
@@ -123,7 +163,7 @@ TEST_F(AssetContainerFixture, Get_ShouldReturnTheAssetWithTheSlotKey)
 TEST_F(AssetContainerFixture, Get_ShouldReturnNullptrIfSlotKeyNotInContainer)
 {
     EXPECT_EQ(m_containerA.Get(SlotMapKey<> {1, 0}), nullptr);
-    EXPECT_EQ(const_cast<const AssetContainer<AssetA>&>(m_containerA).Get(SlotMapKey<> {1, 0}), nullptr);
+    EXPECT_EQ(std::as_const(m_containerA).Get(SlotMapKey<> {1, 0}), nullptr);
 }
 
 /****************************************************************************************/

Bigfoot/Tests/Engine/Asset/AssetLibrary.cpp

@@ -58,12 +58,12 @@ TEST_F(AssetLibraryFixture, GetAssetContainer_ShouldReturnTheAssetContainerIfAva
     EXPECT_EQ(m_library.GetAssetContainer<AssetC>(), &m_containerC);
     EXPECT_EQ(m_library.GetAssetContainer(GetAssetTypeID<AssetC>()), &m_containerC);
 
-    EXPECT_EQ(const_cast<const AssetLibrary&>(m_library).GetAssetContainer<AssetA>(), &m_containerA);
-    EXPECT_EQ(const_cast<const AssetLibrary&>(m_library).GetAssetContainer(GetAssetTypeID<AssetA>()), &m_containerA);
-    EXPECT_EQ(const_cast<const AssetLibrary&>(m_library).GetAssetContainer<AssetB>(), &m_containerB);
-    EXPECT_EQ(const_cast<const AssetLibrary&>(m_library).GetAssetContainer(GetAssetTypeID<AssetB>()), &m_containerB);
-    EXPECT_EQ(const_cast<const AssetLibrary&>(m_library).GetAssetContainer<AssetC>(), &m_containerC);
-    EXPECT_EQ(const_cast<const AssetLibrary&>(m_library).GetAssetContainer(GetAssetTypeID<AssetC>()), &m_containerC);
+    EXPECT_EQ(std::as_const(m_library).GetAssetContainer<AssetA>(), &m_containerA);
+    EXPECT_EQ(std::as_const(m_library).GetAssetContainer(GetAssetTypeID<AssetA>()), &m_containerA);
+    EXPECT_EQ(std::as_const(m_library).GetAssetContainer<AssetB>(), &m_containerB);
+    EXPECT_EQ(std::as_const(m_library).GetAssetContainer(GetAssetTypeID<AssetB>()), &m_containerB);
+    EXPECT_EQ(std::as_const(m_library).GetAssetContainer<AssetC>(), &m_containerC);
+    EXPECT_EQ(std::as_const(m_library).GetAssetContainer(GetAssetTypeID<AssetC>()), &m_containerC);
 }
 
 /****************************************************************************************/
@@ -75,8 +75,8 @@ TEST_F(AssetLibraryFixture, GetAssetContainer_ShouldReturnNullptrIfTheContainerD
     EXPECT_EQ(m_library.GetAssetContainer<AssetA>(), nullptr);
     EXPECT_EQ(m_library.GetAssetContainer(GetAssetTypeID<AssetA>()), nullptr);
 
-    EXPECT_EQ(const_cast<const AssetLibrary&>(m_library).GetAssetContainer<AssetA>(), nullptr);
-    EXPECT_EQ(const_cast<const AssetLibrary&>(m_library).GetAssetContainer(GetAssetTypeID<AssetA>()), nullptr);
+    EXPECT_EQ(std::as_const(m_library).GetAssetContainer<AssetA>(), nullptr);
+    EXPECT_EQ(std::as_const(m_library).GetAssetContainer(GetAssetTypeID<AssetA>()), nullptr);
 }
 
 /****************************************************************************************/
@@ -99,9 +99,9 @@ TEST_F(AssetLibraryFixture, FindAssetContainerContainerForUUID_ShouldReturnTheAs
     EXPECT_EQ(m_library.FindAssetContainerContainerForUUID(uuidB), &m_containerB);
     EXPECT_EQ(m_library.FindAssetContainerContainerForUUID(uuidC), &m_containerC);
 
-    EXPECT_EQ(const_cast<const AssetLibrary&>(m_library).FindAssetContainerContainerForUUID(uuidA), &m_containerA);
-    EXPECT_EQ(const_cast<const AssetLibrary&>(m_library).FindAssetContainerContainerForUUID(uuidB), &m_containerB);
-    EXPECT_EQ(const_cast<const AssetLibrary&>(m_library).FindAssetContainerContainerForUUID(uuidC), &m_containerC);
+    EXPECT_EQ(std::as_const(m_library).FindAssetContainerContainerForUUID(uuidA), &m_containerA);
+    EXPECT_EQ(std::as_const(m_library).FindAssetContainerContainerForUUID(uuidB), &m_containerB);
+    EXPECT_EQ(std::as_const(m_library).FindAssetContainerContainerForUUID(uuidC), &m_containerC);
 }
 
 /****************************************************************************************/
@@ -118,7 +118,16 @@ TEST_F(AssetLibraryFixture, FindAssetContainerContainerForUUID_ShouldReturnNullp
 
     EXPECT_EQ(m_library.FindAssetContainerContainerForUUID(UUID {}), nullptr);
 
-    EXPECT_EQ(const_cast<const AssetLibrary&>(m_library).FindAssetContainerContainerForUUID(UUID {}), nullptr);
+    EXPECT_EQ(std::as_const(m_library).FindAssetContainerContainerForUUID(UUID {}), nullptr);
+}
+
+/****************************************************************************************/
+
+TEST_F(AssetLibraryFixture, SetActiveAssetLibrary_ShouldSetTheActiveAssetLibraryToTheGivenLibrary)
+{
+    SetActiveAssetLibrary(&m_library);
+    EXPECT_EQ(g_activeAssetLibrary, &m_library);
+    SetActiveAssetLibrary(&g_assetLibrary);
 }
 
 /****************************************************************************************/

Bigfoot/Tests/Engine/Asset/Reference.cpp

@@ -0,0 +1,125 @@
+/*********************************************************************
+ * \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);
+}
+
+/****************************************************************************************/
+
+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);
+}
+}   // namespace Bigfoot

Bigfoot/Tests/Utils/Containers/SlotMap.cpp

@@ -274,7 +274,7 @@ TYPED_TEST(SlotMapFixture, Get_ShouldReturnTheValue)
 
     const SlotMapKey key = this->m_slotMap.Insert(42);
     EXPECT_EQ(*this->m_slotMap.Get(key), 42);
-    EXPECT_EQ(*const_cast<const TypeParam&>(this->m_slotMap).Get(key), 42);
+    EXPECT_EQ(*std::as_const(this->m_slotMap).Get(key), 42);
 }
 
 /****************************************************************************************/
@@ -285,7 +285,7 @@ TYPED_TEST(SlotMapFixture, Get_ShouldNullptrIfTheValueIsNotInMap)
 
     const SlotMapKey key {1, 0};
     EXPECT_EQ(this->m_slotMap.Get(key), nullptr);
-    EXPECT_EQ(const_cast<const TypeParam&>(this->m_slotMap).Get(key), nullptr);
+    EXPECT_EQ(std::as_const(this->m_slotMap).Get(key), nullptr);
 }
 
 /****************************************************************************************/
@@ -299,7 +299,7 @@ TYPED_TEST(SlotMapFixture, Get_ShouldReturnNullptrForStaleKey)
     std::ignore = this->m_slotMap.Insert(69);
 
     EXPECT_EQ(this->m_slotMap.Get(staleKey), nullptr);
-    EXPECT_EQ(const_cast<const TypeParam&>(this->m_slotMap).Get(staleKey), nullptr);
+    EXPECT_EQ(std::as_const(this->m_slotMap).Get(staleKey), nullptr);
 }
 
 /****************************************************************************************/