From 87d59a00c1327a5642e3201a094f31cca28b9e9c Mon Sep 17 00:00:00 2001 From: Romain BOULLARD Date: Sat, 16 May 2026 16:47:01 +0200 Subject: [PATCH] AssetContainer --- .../Engine/Include/Engine/Asset/Asset.hpp | 23 ++-- .../Include/Engine/Asset/AssetContainer.hpp | 115 +++++++++--------- .../Include/Engine/Asset/AssetHelper.hpp | 10 +- .../Engine/Include/Engine/Asset/Reference.hpp | 8 +- .../Sources/Utils/Include/Utils/Singleton.hpp | 50 +------- Bigfoot/Tests/Engine/Asset/Asset.cpp | 94 +++++++------- Bigfoot/Tests/Engine/Asset/AssetContainer.cpp | 73 +++++++++++ Bigfoot/Tests/Utils/Singleton.cpp | 29 ----- 8 files changed, 199 insertions(+), 203 deletions(-) create mode 100644 Bigfoot/Tests/Engine/Asset/AssetContainer.cpp diff --git a/Bigfoot/Sources/Engine/Include/Engine/Asset/Asset.hpp b/Bigfoot/Sources/Engine/Include/Engine/Asset/Asset.hpp index f430662..eb71f11 100644 --- a/Bigfoot/Sources/Engine/Include/Engine/Asset/Asset.hpp +++ b/Bigfoot/Sources/Engine/Include/Engine/Asset/Asset.hpp @@ -24,13 +24,19 @@ class Asset public: using FLAT_ASSET = typename ASSET::FLAT; - Asset() + Asset(): + m_header(::Flat::Bigfoot::AssetHeaderT {.uuid = UUID {}, + .name = eastl::string {}, + .type_id = TypeID(), + .type_name = eastl::string {TypeName()}, + .version = 0}), + m_hardRefCount(0), + m_softRefCount(0) { - m_header.type_id = GetTypeID(); - m_header.type_name = GetTypeName(); } - explicit Asset(const eastl::span p_flatbuffer) + explicit Asset(const eastl::span p_flatbuffer): + Asset() { #ifdef BIGFOOT_NOT_OPTIMIZED flatbuffers::Verifier verifier {std::bit_cast(p_flatbuffer.data()), p_flatbuffer.size()}; @@ -56,7 +62,7 @@ class Asset ~Asset() = default; [[nodiscard]] - const ::Flat::Bigfoot::AssetHeaderT& GetHeader() const + const ::Flat::Bigfoot::AssetHeaderT& Header() const { return m_header; } @@ -102,7 +108,7 @@ class Asset } [[nodiscard]] - static std::uint64_t GetTypeID() + static std::uint64_t TypeID() { static const std::uint64_t typeID = rapidhash(FLAT_ASSET::GetFullyQualifiedName(), std::strlen(FLAT_ASSET::GetFullyQualifiedName())); @@ -110,7 +116,7 @@ class Asset } [[nodiscard]] - static eastl::string_view GetTypeName() + static eastl::string_view TypeName() { return FLAT_ASSET::GetFullyQualifiedName(); } @@ -121,6 +127,9 @@ class Asset private: ::Flat::Bigfoot::AssetHeaderT m_header; typename FLAT_ASSET::NativeTableType m_asset; + + std::uint32_t m_hardRefCount; + std::uint32_t m_softRefCount; }; } // namespace Bigfoot diff --git a/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetContainer.hpp b/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetContainer.hpp index edae881..9d14800 100644 --- a/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetContainer.hpp +++ b/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetContainer.hpp @@ -6,9 +6,10 @@ *********************************************************************/ #ifndef BIGFOOT_ENGINE_ASSET_ASSETCONTAINER_HPP #define BIGFOOT_ENGINE_ASSET_ASSETCONTAINER_HPP +#include #include -#include +#include #include @@ -20,86 +21,82 @@ template class AssetContainer { public: - AssetContainer() + AssetContainer() = default; + + AssetContainer(const AssetContainer& p_container) = default; + AssetContainer(AssetContainer&& p_container) = default; + + ~AssetContainer() = default; + + template + [[nodiscard]] + typename SlotMap::SlotKey Insert(ARGS&&... p_args) { - CRITICAL_ASSERT(EngineAssertHandler, !ms_instance, "Asset container already exists!"); - ms_instance = this; + const typename SlotMap::SlotKey slotKey = m_assets.Insert(std::forward(p_args)...); + m_uuidToSlotKey.insert({m_assets.Get(slotKey)->Header().uuid, slotKey}); + + return slotKey; } - AssetContainer(const AssetContainer&) = delete; - AssetContainer& operator=(const AssetContainer&) = delete; - - ~AssetContainer() + [[nodiscard]] + ASSET* Get(const typename SlotMap::SlotKey p_key) { - ms_instance = nullptr; + return m_assets.Get(p_key); } - struct Entry + [[nodiscard]] + const ASSET* Get(const typename SlotMap::SlotKey p_key) const { - std::uint32_t m_hardRefCount = 0; - std::uint32_t m_softRefCount = 0; - }; - - void IncrementHardRefCount(const UUID& p_uuid) - { - ++m_entries[p_uuid].m_hardRefCount; + return m_assets.Get(p_key); } - void DecrementHardRefCount(const UUID& p_uuid) + [[nodiscard]] + typename SlotMap::SlotKey SlotKey(const UUID& p_uuid) const { - if (const auto entry = m_entries.find(p_uuid); entry != m_entries.end()) + if (const auto it = m_uuidToSlotKey.find(p_uuid); it != m_uuidToSlotKey.end()) { - CRITICAL_ASSERT( - EngineAssertHandler, - entry->second.m_hardRefCount > 0, - "Double release detected! Decrementing a hard reference to an asset that already does not have any " - "more hardrefs"); - --entry->second.m_hardRefCount; + return it->second; + } + return typename SlotMap::SlotKey {}; + } + + [[nodiscard]] + bool Has(const typename SlotMap::SlotKey p_key) const + { + return m_assets.Has(p_key); + } + + [[nodiscard]] + bool Has(const UUID& p_uuid) const + { + return m_uuidToSlotKey.contains(p_uuid); + } + + void Remove(const typename SlotMap::SlotKey p_key) + { + if (const ASSET* asset = Get(p_key)) + { + const UUID uuid = asset->Header().uuid; + m_assets.Remove(p_key); + m_uuidToSlotKey.erase(uuid); } } - void IncrementSoftRefCount(const UUID& p_uuid) + void Remove(const UUID& p_uuid) { - ++m_entries[p_uuid].m_softRefCount; - } - - void DecrementSoftRefCount(const UUID& p_uuid) - { - if (const auto entry = m_entries.find(p_uuid); entry != m_entries.end()) + if (const auto it = m_uuidToSlotKey.find(p_uuid); it != m_uuidToSlotKey.end()) { - CRITICAL_ASSERT( - EngineAssertHandler, - entry->second.m_softRefCount > 0, - "Double release detected! Decrementing a soft reference to an asset that already does not have any " - "more softrefs"); - --entry->second.m_softRefCount; + Remove(it->second); } } - [[nodiscard]] - std::uint32_t HardRefCount(const UUID& p_uuid) const - { - const auto entry = m_entries.find(p_uuid); - return entry != m_entries.end() ? entry->second.m_hardRefCount : 0; - } - - [[nodiscard]] - std::uint32_t SoftRefCount(const UUID& p_uuid) const - { - const auto entry = m_entries.find(p_uuid); - return entry != m_entries.end() ? entry->second.m_softRefCount : 0; - } - - [[nodiscard]] - static AssetContainer& Get() - { - return *ms_instance; - } + AssetContainer& operator=(const AssetContainer& p_container) = default; + AssetContainer& operator=(AssetContainer&& p_container) = default; private: - ankerl::unordered_dense::segmented_map m_entries; + ankerl::unordered_dense::segmented_map::SlotKey> m_uuidToSlotKey; - inline static constinit AssetContainer* ms_instance = nullptr; + SlotMap m_assets; }; } // namespace Bigfoot diff --git a/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetHelper.hpp b/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetHelper.hpp index d8bece8..063619d 100644 --- a/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetHelper.hpp +++ b/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetHelper.hpp @@ -24,19 +24,11 @@ Bigfoot::HardReference UnPackHardReference##AssetName(const Flat::Bigfoot::HardReference& p_hardRef); \ } -#define ASSET_CONTAINER(AssetName, AssetType) \ - namespace Bigfoot \ - { \ - inline AssetContainer g_##AssetName##Container; \ - } - #define ASSET_REF_DECL(AssetName, AssetType) \ ASSET_SOFT_REF_DECL(AssetName, AssetType) \ ASSET_HARD_REF_DECL(AssetName, AssetType) -#define ASSET_DECL(AssetName, AssetType) \ - ASSET_REF_DECL(AssetName, AssetType) \ - ASSET_CONTAINER(AssetName, AssetType) +#define ASSET_DECL(AssetName, AssetType) ASSET_REF_DECL(AssetName, AssetType) /****************************************************************************************/ diff --git a/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.hpp b/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.hpp index 610daf9..8007dc9 100644 --- a/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.hpp +++ b/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.hpp @@ -80,7 +80,7 @@ class HardReference { if (m_uuid) { - AssetContainer::Get().IncrementHardRefCount(m_uuid); + // AssetContainer::Get().IncrementHardRefCount(m_uuid); } } @@ -88,7 +88,7 @@ class HardReference { if (m_uuid) { - AssetContainer::Get().DecrementHardRefCount(m_uuid); + // AssetContainer::Get().DecrementHardRefCount(m_uuid); } } @@ -161,7 +161,7 @@ class SoftReference { if (m_uuid) { - AssetContainer::Get().IncrementSoftRefCount(m_uuid); + // AssetContainer::Get().IncrementSoftRefCount(m_uuid); } } @@ -169,7 +169,7 @@ class SoftReference { if (m_uuid) { - AssetContainer::Get().DecrementSoftRefCount(m_uuid); + // AssetContainer::Get().DecrementSoftRefCount(m_uuid); } } diff --git a/Bigfoot/Sources/Utils/Include/Utils/Singleton.hpp b/Bigfoot/Sources/Utils/Include/Utils/Singleton.hpp index a49c735..0899ad5 100644 --- a/Bigfoot/Sources/Utils/Include/Utils/Singleton.hpp +++ b/Bigfoot/Sources/Utils/Include/Utils/Singleton.hpp @@ -6,11 +6,7 @@ *********************************************************************/ #ifndef BIGFOOT_UTILS_SINGLETON_HPP #define BIGFOOT_UTILS_SINGLETON_HPP -#include -#include #include -#include -#include namespace Bigfoot { @@ -51,9 +47,6 @@ class Singleton /** * Constructor. * - * Initializes the singleton; this lifetime owns the instance and - * finalizes it on destruction. - * * \param p_args Arguments for the singleton */ template @@ -62,53 +55,16 @@ class Singleton Initialize(std::forward(p_args)...); } - struct EmptyLifetime - { - }; - - static inline constexpr EmptyLifetime EMPTY_LIFETIME; - - /** - * Non-owning constructor. - * - * Does not initialize the singleton and owns nothing. Such a lifetime - * only becomes an owner if it later receives ownership through move - * assignment. - */ - explicit Lifetime(EmptyLifetime) noexcept: - m_owner(false) - { - } - Lifetime(const Lifetime& p_lifetime) = delete; - - explicit Lifetime(Lifetime&& p_lifetime) noexcept: - m_owner(eastl::exchange(p_lifetime.m_owner, false)) - { - } + Lifetime(Lifetime&& p_lifetime) = delete; ~Lifetime() { - if (m_owner) - { - Finalize(); - } + Finalize(); } Lifetime& operator=(const Lifetime& p_lifetime) = delete; - - Lifetime& operator=(Lifetime&& p_lifetime) noexcept - { - m_owner = eastl::exchange(p_lifetime.m_owner, false); - - return *this; - } - - private: - /** - * Whether this lifetime owns the singleton instance or not. - */ - bool m_owner = true; + Lifetime& operator=(Lifetime&& p_lifetime) noexcept = delete; }; Singleton& operator=(const Singleton& p_singleton) = delete; diff --git a/Bigfoot/Tests/Engine/Asset/Asset.cpp b/Bigfoot/Tests/Engine/Asset/Asset.cpp index 03050b2..3e4da51 100644 --- a/Bigfoot/Tests/Engine/Asset/Asset.cpp +++ b/Bigfoot/Tests/Engine/Asset/Asset.cpp @@ -6,8 +6,6 @@ *********************************************************************/ #include -#include - #include #include #include @@ -40,19 +38,19 @@ TEST_F(AssetFixture, AssetATests) AssetA assetA_dup {test}; - EXPECT_EQ(assetA.GetHeader().uuid, assetA_dup.GetHeader().uuid); + EXPECT_EQ(assetA.Header().uuid, assetA_dup.Header().uuid); - EXPECT_EQ(assetA.GetHeader().type_id, AssetA::GetTypeID()); - EXPECT_EQ(assetA.GetHeader().type_id, assetA_dup.GetHeader().type_id); + EXPECT_EQ(assetA.Header().type_id, AssetA::TypeID()); + EXPECT_EQ(assetA.Header().type_id, assetA_dup.Header().type_id); - EXPECT_EQ(assetA.GetHeader().type_name, AssetA::GetTypeName()); - EXPECT_EQ(assetA.GetHeader().type_name, assetA_dup.GetHeader().type_name); + EXPECT_EQ(assetA.Header().type_name, AssetA::TypeName()); + EXPECT_EQ(assetA.Header().type_name, assetA_dup.Header().type_name); - EXPECT_EQ(assetA.GetHeader().name, name); - EXPECT_EQ(assetA.GetHeader().name, assetA_dup.GetHeader().name); + EXPECT_EQ(assetA.Header().name, name); + EXPECT_EQ(assetA.Header().name, assetA_dup.Header().name); - EXPECT_EQ(assetA.GetHeader().version, version); - EXPECT_EQ(assetA.GetHeader().version, assetA_dup.GetHeader().version); + EXPECT_EQ(assetA.Header().version, version); + EXPECT_EQ(assetA.Header().version, assetA_dup.Header().version); EXPECT_EQ(assetA.GetAsset().health, health); EXPECT_EQ(assetA.GetAsset().health, assetA_dup.GetAsset().health); @@ -93,34 +91,34 @@ TEST_F(AssetFixture, AssetBTests) AssetB assetB; assetB.SetName(nameB); assetB.SetVersion(versionB); - assetB.GetAsset().asset_a_ref = HardReference {assetA.GetHeader().uuid}; - assetB.GetAsset().asset_a_refs = {SoftReference {assetA.GetHeader().uuid}, - SoftReference {assetAA.GetHeader().uuid}}; + assetB.GetAsset().asset_a_ref = HardReference {assetA.Header().uuid}; + assetB.GetAsset().asset_a_refs = {SoftReference {assetA.Header().uuid}, + SoftReference {assetAA.Header().uuid}}; const eastl::vector test = assetB.Save(); AssetB assetB_dup {test}; - EXPECT_EQ(assetB.GetHeader().uuid, assetB_dup.GetHeader().uuid); + EXPECT_EQ(assetB.Header().uuid, assetB_dup.Header().uuid); - EXPECT_EQ(assetB.GetHeader().type_id, AssetB::GetTypeID()); - EXPECT_EQ(assetB.GetHeader().type_id, assetB_dup.GetHeader().type_id); + EXPECT_EQ(assetB.Header().type_id, AssetB::TypeID()); + EXPECT_EQ(assetB.Header().type_id, assetB_dup.Header().type_id); - EXPECT_EQ(assetB.GetHeader().type_name, AssetB::GetTypeName()); - EXPECT_EQ(assetB.GetHeader().type_name, assetB_dup.GetHeader().type_name); + EXPECT_EQ(assetB.Header().type_name, AssetB::TypeName()); + EXPECT_EQ(assetB.Header().type_name, assetB_dup.Header().type_name); - EXPECT_EQ(assetB.GetHeader().name, nameB); - EXPECT_EQ(assetB.GetHeader().name, assetB_dup.GetHeader().name); + EXPECT_EQ(assetB.Header().name, nameB); + EXPECT_EQ(assetB.Header().name, assetB_dup.Header().name); - EXPECT_EQ(assetB.GetHeader().version, versionB); - EXPECT_EQ(assetB.GetHeader().version, assetB_dup.GetHeader().version); + EXPECT_EQ(assetB.Header().version, versionB); + EXPECT_EQ(assetB.Header().version, assetB_dup.Header().version); - EXPECT_EQ(assetB.GetAsset().asset_a_ref, HardReference {assetA.GetHeader().uuid}); + EXPECT_EQ(assetB.GetAsset().asset_a_ref, HardReference {assetA.Header().uuid}); EXPECT_EQ(assetB.GetAsset().asset_a_ref, assetB_dup.GetAsset().asset_a_ref); EXPECT_EQ(assetB.GetAsset().asset_a_refs, - (eastl::vector> {SoftReference {assetA.GetHeader().uuid}, - SoftReference {assetAA.GetHeader().uuid}})); + (eastl::vector> {SoftReference {assetA.Header().uuid}, + SoftReference {assetAA.Header().uuid}})); EXPECT_EQ(assetB.GetAsset().asset_a_refs, assetB_dup.GetAsset().asset_a_refs); } @@ -156,9 +154,9 @@ TEST_F(AssetFixture, AssetCTests) AssetB assetB; assetB.SetName(nameB); assetB.SetVersion(versionB); - assetB.GetAsset().asset_a_ref = HardReference {assetA.GetHeader().uuid}; - assetB.GetAsset().asset_a_refs = {SoftReference {assetA.GetHeader().uuid}, - SoftReference {assetAA.GetHeader().uuid}}; + assetB.GetAsset().asset_a_ref = HardReference {assetA.Header().uuid}; + assetB.GetAsset().asset_a_refs = {SoftReference {assetA.Header().uuid}, + SoftReference {assetAA.Header().uuid}}; constexpr eastl::string_view nameC = "General"; constexpr std::uint32_t versionC = 1; @@ -166,43 +164,43 @@ TEST_F(AssetFixture, AssetCTests) AssetC assetC; assetC.SetName(nameC); assetC.SetVersion(versionC); - assetC.GetAsset().inner_table->asset_a_ref = HardReference {assetA.GetHeader().uuid}; - assetC.GetAsset().inner_table->asset_a_refs = {HardReference {assetA.GetHeader().uuid}, - HardReference {assetAA.GetHeader().uuid}}; - assetC.GetAsset().asset_b_ref = HardReference {assetB.GetHeader().uuid}; - assetC.GetAsset().asset_b_refs = {SoftReference {assetB.GetHeader().uuid}}; + assetC.GetAsset().inner_table->asset_a_ref = HardReference {assetA.Header().uuid}; + assetC.GetAsset().inner_table->asset_a_refs = {HardReference {assetA.Header().uuid}, + HardReference {assetAA.Header().uuid}}; + assetC.GetAsset().asset_b_ref = HardReference {assetB.Header().uuid}; + assetC.GetAsset().asset_b_refs = {SoftReference {assetB.Header().uuid}}; const eastl::vector test = assetC.Save(); AssetC assetC_dup {test}; - EXPECT_EQ(assetC.GetHeader().uuid, assetC_dup.GetHeader().uuid); + EXPECT_EQ(assetC.Header().uuid, assetC_dup.Header().uuid); - EXPECT_EQ(assetC.GetHeader().type_id, AssetC::GetTypeID()); - EXPECT_EQ(assetC.GetHeader().type_id, assetC_dup.GetHeader().type_id); + EXPECT_EQ(assetC.Header().type_id, AssetC::TypeID()); + EXPECT_EQ(assetC.Header().type_id, assetC_dup.Header().type_id); - EXPECT_EQ(assetC.GetHeader().type_name, AssetC::GetTypeName()); - EXPECT_EQ(assetC.GetHeader().type_name, assetC_dup.GetHeader().type_name); + EXPECT_EQ(assetC.Header().type_name, AssetC::TypeName()); + EXPECT_EQ(assetC.Header().type_name, assetC_dup.Header().type_name); - EXPECT_EQ(assetC.GetHeader().name, nameC); - EXPECT_EQ(assetC.GetHeader().name, assetC_dup.GetHeader().name); + EXPECT_EQ(assetC.Header().name, nameC); + EXPECT_EQ(assetC.Header().name, assetC_dup.Header().name); - EXPECT_EQ(assetC.GetHeader().version, versionC); - EXPECT_EQ(assetC.GetHeader().version, assetC_dup.GetHeader().version); + EXPECT_EQ(assetC.Header().version, versionC); + EXPECT_EQ(assetC.Header().version, assetC_dup.Header().version); - EXPECT_EQ(assetC.GetAsset().asset_b_ref, HardReference {assetB.GetHeader().uuid}); + EXPECT_EQ(assetC.GetAsset().asset_b_ref, HardReference {assetB.Header().uuid}); EXPECT_EQ(assetC.GetAsset().asset_b_ref, assetC_dup.GetAsset().asset_b_ref); EXPECT_EQ(assetC.GetAsset().asset_b_refs, - (eastl::vector> {SoftReference {assetB.GetHeader().uuid}})); + (eastl::vector> {SoftReference {assetB.Header().uuid}})); EXPECT_EQ(assetC.GetAsset().asset_b_refs, assetC_dup.GetAsset().asset_b_refs); - EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_ref, HardReference {assetA.GetHeader().uuid}); + EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_ref, HardReference {assetA.Header().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> {HardReference {assetA.GetHeader().uuid}, - HardReference {assetAA.GetHeader().uuid}})); + (eastl::vector> {HardReference {assetA.Header().uuid}, + HardReference {assetAA.Header().uuid}})); EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_refs, assetC_dup.GetAsset().inner_table->asset_a_refs); } } // namespace Bigfoot diff --git a/Bigfoot/Tests/Engine/Asset/AssetContainer.cpp b/Bigfoot/Tests/Engine/Asset/AssetContainer.cpp new file mode 100644 index 0000000..53e6958 --- /dev/null +++ b/Bigfoot/Tests/Engine/Asset/AssetContainer.cpp @@ -0,0 +1,73 @@ +/********************************************************************* + * \file BigFile.cpp + * + * \author Romain BOULLARD + * \date December 2025 + *********************************************************************/ +#include + +#include + +#include + +namespace Bigfoot +{ +class AssetContainerFixture: public ::testing::Test +{ + protected: + AssetContainer m_container; +}; + +/****************************************************************************************/ + +TEST_F(AssetContainerFixture, Insert) +{ + std::ignore = m_container.Insert(); +} + +/****************************************************************************************/ + +TEST_F(AssetContainerFixture, Get) +{ + const auto key = m_container.Insert(); + + const auto& constContainer = m_container; + + const auto validateKey = [&](auto& p_assetContainer) + { + const auto asset = p_assetContainer.Get(key); + EXPECT_NE(asset, nullptr); + }; + validateKey(m_container); + validateKey(constContainer); +} + +/****************************************************************************************/ + +TEST_F(AssetContainerFixture, SlotKey) +{ + const auto key = m_container.Insert(); + const auto asset = m_container.Get(key); + EXPECT_EQ(m_container.SlotKey(asset->Header().uuid), key); +} + +/****************************************************************************************/ + +TEST_F(AssetContainerFixture, Has) +{ + const auto key = m_container.Insert(); + EXPECT_TRUE(m_container.Has(key)); + EXPECT_TRUE(m_container.Has(m_container.Get(key)->Header().uuid)); +} + +/****************************************************************************************/ + +TEST_F(AssetContainerFixture, Remove) +{ + const auto key1 = m_container.Insert(); + m_container.Remove(key1); + + const auto key2 = m_container.Insert(); + m_container.Remove(m_container.Get(key2)->Header().uuid); +} +} // namespace Bigfoot diff --git a/Bigfoot/Tests/Utils/Singleton.cpp b/Bigfoot/Tests/Utils/Singleton.cpp index 0570059..2b04b4b 100644 --- a/Bigfoot/Tests/Utils/Singleton.cpp +++ b/Bigfoot/Tests/Utils/Singleton.cpp @@ -92,35 +92,6 @@ TEST_F(SingletonFixture, ConstructorAndDestructorShouldBeCalled) /****************************************************************************************/ -TEST_F(SingletonFixture, ConstructorAndDestructorShouldNotBeCalledForEmptyLifetime) -{ - ::testing::InSequence seq; - - EXPECT_CALL(*m_mock, Construct()).Times(0); - EXPECT_CALL(*m_mock, Destruct()).Times(0); - - Singleton::Lifetime singleton {Singleton::Lifetime::EMPTY_LIFETIME}; -} - -/****************************************************************************************/ - -TEST_F(SingletonFixture, MovingALifetimeKeepsTheSIngletonAlive) -{ - ::testing::InSequence seq; - - EXPECT_CALL(*m_mock, Construct()).Times(1); - EXPECT_CALL(*m_mock, Destruct()).Times(1); - - Singleton::Lifetime emptyLifetime {Singleton::Lifetime::EMPTY_LIFETIME}; - { - Singleton::Lifetime singleton {42}; - emptyLifetime = std::move(singleton); - } - EXPECT_EQ(Singleton::Instance().Data(), 42); -} - -/****************************************************************************************/ - TEST_F(SingletonFixture, Instance_ShouldReturnTheInstance) { Singleton::Lifetime singleton {42};