test(Resources): Add ResourceHandle tests (11 test cases)

tests/Resources/test_resource_handle.cpp

@@ -0,0 +1,194 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/ResourceHandle.h>
+#include <XCEngine/Resources/IResource.h>
+#include <XCEngine/Resources/ResourceTypes.h>
+#include <XCEngine/Resources/ResourceManager.h>
+#include <XCEngine/Containers/String.h>
+
+using namespace XCEngine::Resources;
+using namespace XCEngine::Containers;
+
+namespace {
+
+class TestResource : public IResource {
+public:
+    ResourceType GetType() const override { return ResourceType::Texture; }
+    const String& GetName() const override { return m_name; }
+    const String& GetPath() const override { return m_path; }
+    ResourceGUID GetGUID() const override { return m_guid; }
+    bool IsValid() const override { return m_isValid; }
+    size_t GetMemorySize() const override { return m_memorySize; }
+    void Release() override { 
+        m_released = true; 
+    }
+    
+    bool m_released = false;
+};
+
+TEST(ResourceHandle, DefaultConstructor) {
+    ResourceHandle<TestResource> handle;
+    EXPECT_FALSE(handle.IsValid());
+    EXPECT_EQ(handle.Get(), nullptr);
+}
+
+TEST(ResourceHandle, PointerConstructor) {
+    TestResource* resource = new TestResource();
+    resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
+    
+    ResourceHandle<TestResource> handle(resource);
+    EXPECT_TRUE(handle.IsValid());
+    EXPECT_EQ(handle.Get(), resource);
+    EXPECT_EQ(handle->GetName(), "Test");
+    
+    handle.Reset();
+    EXPECT_FALSE(handle.IsValid());
+}
+
+TEST(ResourceHandle, CopyConstructor) {
+    TestResource* resource = new TestResource();
+    resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
+    
+    ResourceHandle<TestResource> handle1(resource);
+    ResourceHandle<TestResource> handle2(handle1);
+    
+    EXPECT_TRUE(handle1.IsValid());
+    EXPECT_TRUE(handle2.IsValid());
+    EXPECT_EQ(handle1.Get(), handle2.Get());
+    
+    handle1.Reset();
+    EXPECT_TRUE(handle2.IsValid());
+    
+    handle2.Reset();
+    EXPECT_FALSE(handle1.IsValid());
+    EXPECT_FALSE(handle2.IsValid());
+}
+
+TEST(ResourceHandle, MoveConstructor) {
+    TestResource* resource = new TestResource();
+    resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
+    
+    ResourceHandle<TestResource> handle1(resource);
+    ResourceHandle<TestResource> handle2(std::move(handle1));
+    
+    EXPECT_FALSE(handle1.IsValid());
+    EXPECT_TRUE(handle2.IsValid());
+    EXPECT_EQ(handle2.Get(), resource);
+    
+    handle2.Reset();
+}
+
+TEST(ResourceHandle, AssignmentOperator) {
+    TestResource* resource = new TestResource();
+    resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
+    
+    ResourceHandle<TestResource> handle1(resource);
+    EXPECT_TRUE(handle1.IsValid());
+    
+    ResourceHandle<TestResource> handle2;
+    handle2 = handle1;
+    EXPECT_TRUE(handle2.IsValid());
+    EXPECT_EQ(handle1.Get(), handle2.Get());
+    
+    handle1.Reset();
+    EXPECT_TRUE(handle2.IsValid());
+    
+    handle2.Reset();
+}
+
+TEST(ResourceHandle, MoveAssignment) {
+    TestResource* resource = new TestResource();
+    resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
+    
+    ResourceHandle<TestResource> handle1(resource);
+    ResourceHandle<TestResource> handle2;
+    handle2 = std::move(handle1);
+    
+    EXPECT_FALSE(handle1.IsValid());
+    EXPECT_TRUE(handle2.IsValid());
+    
+    handle2.Reset();
+}
+
+TEST(ResourceHandle, GetGUID) {
+    TestResource* resource = new TestResource();
+    resource->Initialize({ "Test", "test.png", ResourceGUID(12345), 100 });
+    
+    ResourceHandle<TestResource> handle(resource);
+    EXPECT_EQ(handle.GetGUID().value, 12345u);
+    
+    ResourceHandle<TestResource> emptyHandle;
+    EXPECT_EQ(emptyHandle.GetGUID().value, 0u);
+    
+    handle.Reset();
+}
+
+TEST(ResourceHandle, GetResourceType) {
+    TestResource* resource = new TestResource();
+    resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
+    
+    ResourceHandle<TestResource> handle(resource);
+    EXPECT_EQ(handle.GetResourceType(), ResourceType::Texture);
+    
+    ResourceHandle<TestResource> emptyHandle;
+    EXPECT_EQ(emptyHandle.GetResourceType(), ResourceType::Unknown);
+    
+    handle.Reset();
+}
+
+TEST(ResourceHandle, BoolOperator) {
+    TestResource* resource = new TestResource();
+    resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
+    
+    ResourceHandle<TestResource> handle(resource);
+    if (handle) {
+        EXPECT_TRUE(true);
+    } else {
+        EXPECT_TRUE(false);
+    }
+    
+    handle.Reset();
+    if (handle) {
+        EXPECT_TRUE(false);
+    } else {
+        EXPECT_TRUE(true);
+    }
+}
+
+TEST(ResourceHandle, Swap) {
+    TestResource* resource1 = new TestResource();
+    resource1->Initialize({ "Test1", "test1.png", ResourceGUID(100), 100 });
+    
+    TestResource* resource2 = new TestResource();
+    resource2->Initialize({ "Test2", "test2.png", ResourceGUID(200), 200 });
+    
+    ResourceHandle<TestResource> handle1(resource1);
+    ResourceHandle<TestResource> handle2(resource2);
+    
+    handle1.Swap(handle2);
+    
+    EXPECT_EQ(handle1.Get(), resource2);
+    EXPECT_EQ(handle2.Get(), resource1);
+    
+    handle1.Reset();
+    handle2.Reset();
+}
+
+TEST(ResourceHandle, EqualityOperators) {
+    TestResource* resource = new TestResource();
+    resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
+    
+    ResourceHandle<TestResource> handle1(resource);
+    ResourceHandle<TestResource> handle2(handle1);
+    
+    EXPECT_TRUE(handle1 == handle2);
+    EXPECT_FALSE(handle1 != handle2);
+    
+    ResourceHandle<TestResource> handle3;
+    EXPECT_FALSE(handle1 == handle3);
+    EXPECT_TRUE(handle1 != handle3);
+    
+    handle1.Reset();
+    handle2.Reset();
+}
+
+} // namespace