diff --git a/Bigfoot/Tests/Engine/Asset/Reference.cpp b/Bigfoot/Tests/Engine/Asset/Reference.cpp
index 06d33a1..22805c4 100644
--- a/Bigfoot/Tests/Engine/Asset/Reference.cpp
+++ b/Bigfoot/Tests/Engine/Asset/Reference.cpp
@@ -106,6 +106,146 @@ TEST_F(HardReferenceFixture, ShouldTouchTheHardRefCountOfTheHandle)
 
 /****************************************************************************************/
 
+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:
@@ -196,4 +336,144 @@ TEST_F(SoftReferenceFixture, ShouldTouchTheSoftRefCountOfTheHandle)
 
     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