XCEngine/tests/Resources/test_resource_handle.cpp

#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