refactor(tests): reorganize tests directory to match engine structure

- Created tests/Core/Asset/ with tests for IResource, ResourceTypes, ResourceHandle, ResourceCache, ResourceDependencyGraph, ResourceGUID
- Created tests/Core/IO/ with tests for IResourceLoader, ResourcePath, ResourceFileSystem, FileArchive, ResourcePackage
- Reorganized tests/Resources/ into subdirectories: Texture/, Mesh/, Material/, Shader/, AudioClip/
- Added CMakeLists.txt for each new test subdirectory
- Fixed Material.h missing ResourceManager.h include (lost during engine refactor)
- tests/Core/CMakeLists.txt updated to include Asset/ and IO/ subdirectories

tests/Core/Asset/test_iresource.cpp

@@ -0,0 +1,69 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Core/Asset/IResource.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+#include <XCEngine/Core/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 { delete this; }
+};
+
+TEST(IResource, Initialize) {
+    TestResource* resource = new TestResource();
+    
+    IResource::ConstructParams params;
+    params.name = "TestTexture";
+    params.path = "textures/test.png";
+    params.guid = ResourceGUID(12345);
+    params.memorySize = 1024;
+    
+    resource->Initialize(params);
+    
+    EXPECT_EQ(resource->GetName(), "TestTexture");
+    EXPECT_EQ(resource->GetPath(), "textures/test.png");
+    EXPECT_EQ(resource->GetGUID().value, 12345u);
+    EXPECT_EQ(resource->GetMemorySize(), 1024u);
+    EXPECT_TRUE(resource->IsValid());
+    
+    resource->Release();
+}
+
+TEST(IResource, SetInvalid) {
+    TestResource* resource = new TestResource();
+    
+    IResource::ConstructParams params;
+    params.name = "Test";
+    params.path = "test.png";
+    params.guid = ResourceGUID(1);
+    params.memorySize = 100;
+    
+    resource->Initialize(params);
+    EXPECT_TRUE(resource->IsValid());
+    
+    resource->SetInvalid();
+    EXPECT_FALSE(resource->IsValid());
+    
+    resource->Release();
+}
+
+TEST(IResource, DefaultValues) {
+    TestResource* resource = new TestResource();
+    
+    EXPECT_EQ(resource->GetMemorySize(), 0u);
+    EXPECT_FALSE(resource->IsValid());
+    
+    resource->Release();
+}
+
+} // namespace

tests/Core/Asset/test_resource_cache.cpp

@@ -0,0 +1,147 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Core/Asset/ResourceCache.h>
+#include <XCEngine/Core/Asset/IResource.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+#include <XCEngine/Core/Asset/ResourceManager.h>
+#include <XCEngine/Core/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 { delete this; }
+};
+
+TEST(ResourceCache, AddAndFind) {
+    ResourceCache cache;
+    
+    TestResource* resource = new TestResource();
+    resource->Initialize({ "Test", "test.png", ResourceGUID(100), 1024 });
+    
+    ResourceGUID guid(100);
+    cache.Add(guid, resource);
+    
+    IResource* found = cache.Find(guid);
+    EXPECT_EQ(found, resource);
+    
+    cache.Remove(guid);
+    found = cache.Find(guid);
+    EXPECT_EQ(found, nullptr);
+}
+
+TEST(ResourceCache, GetSize) {
+    ResourceCache cache;
+    
+    EXPECT_EQ(cache.GetSize(), 0u);
+    
+    TestResource* resource1 = new TestResource();
+    resource1->Initialize({ "Test1", "test1.png", ResourceGUID(1), 100 });
+    cache.Add(ResourceGUID(1), resource1);
+    EXPECT_EQ(cache.GetSize(), 1u);
+    
+    TestResource* resource2 = new TestResource();
+    resource2->Initialize({ "Test2", "test2.png", ResourceGUID(2), 200 });
+    cache.Add(ResourceGUID(2), resource2);
+    EXPECT_EQ(cache.GetSize(), 2u);
+}
+
+TEST(ResourceCache, GetMemoryUsage) {
+    ResourceCache cache;
+    
+    EXPECT_EQ(cache.GetMemoryUsage(), 0u);
+    
+    TestResource* resource1 = new TestResource();
+    resource1->Initialize({ "Test1", "test1.png", ResourceGUID(1), 100 });
+    cache.Add(ResourceGUID(1), resource1);
+    EXPECT_EQ(cache.GetMemoryUsage(), 100u);
+    
+    TestResource* resource2 = new TestResource();
+    resource2->Initialize({ "Test2", "test2.png", ResourceGUID(2), 200 });
+    cache.Add(ResourceGUID(2), resource2);
+    EXPECT_EQ(cache.GetMemoryUsage(), 300u);
+}
+
+TEST(ResourceCache, SetMemoryBudget) {
+    ResourceCache cache;
+    
+    EXPECT_EQ(cache.GetMemoryBudget(), 512 * 1024 * 1024u);
+    
+    cache.SetMemoryBudget(1024);
+    EXPECT_EQ(cache.GetMemoryBudget(), 1024u);
+}
+
+TEST(ResourceCache, Touch) {
+    ResourceCache cache;
+    
+    TestResource* resource = new TestResource();
+    resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
+    
+    ResourceGUID guid(100);
+    cache.Add(guid, resource);
+    cache.Touch(guid);
+    
+    IResource* found = cache.Find(guid);
+    EXPECT_EQ(found, resource);
+}
+
+TEST(ResourceCache, Clear) {
+    ResourceCache cache;
+    
+    TestResource* resource1 = new TestResource();
+    resource1->Initialize({ "Test1", "test1.png", ResourceGUID(1), 100 });
+    cache.Add(ResourceGUID(1), resource1);
+    
+    TestResource* resource2 = new TestResource();
+    resource2->Initialize({ "Test2", "test2.png", ResourceGUID(2), 200 });
+    cache.Add(ResourceGUID(2), resource2);
+    
+    EXPECT_EQ(cache.GetSize(), 2u);
+    
+    cache.Clear();
+    EXPECT_EQ(cache.GetSize(), 0u);
+    EXPECT_EQ(cache.GetMemoryUsage(), 0u);
+}
+
+TEST(ResourceCache, OnMemoryPressure) {
+    ResourceCache cache;
+    cache.SetMemoryBudget(150);
+    
+    TestResource* resource1 = new TestResource();
+    resource1->Initialize({ "Test1", "test1.png", ResourceGUID(1), 100 });
+    cache.Add(ResourceGUID(1), resource1);
+    EXPECT_EQ(cache.GetMemoryUsage(), 100u);
+    
+    TestResource* resource2 = new TestResource();
+    resource2->Initialize({ "Test2", "test2.png", ResourceGUID(2), 100 });
+    cache.Add(ResourceGUID(2), resource2);
+    EXPECT_EQ(cache.GetMemoryUsage(), 200u);
+    
+    cache.OnMemoryPressure(50);
+    EXPECT_LE(cache.GetMemoryUsage(), 150u);
+}
+
+TEST(ResourceCache, GetLRUList) {
+    ResourceCache cache;
+    
+    TestResource* resource1 = new TestResource();
+    resource1->Initialize({ "Test1", "test1.png", ResourceGUID(1), 100 });
+    cache.Add(ResourceGUID(1), resource1);
+    
+    TestResource* resource2 = new TestResource();
+    resource2->Initialize({ "Test2", "test2.png", ResourceGUID(2), 200 });
+    cache.Add(ResourceGUID(2), resource2);
+    
+    auto lruList = cache.GetLRUList(2);
+    EXPECT_GE(lruList.Size(), 0u);
+}
+
+} // namespace

tests/Core/Asset/test_resource_dependency.cpp

@@ -0,0 +1,131 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Core/Asset/ResourceDependencyGraph.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+
+using namespace XCEngine::Resources;
+using namespace XCEngine::Containers;
+
+namespace {
+
+TEST(ResourceDependencyGraph, DefaultConstructor) {
+    ResourceDependencyGraph graph;
+}
+
+TEST(ResourceDependencyGraph, AddNode) {
+    ResourceDependencyGraph graph;
+    graph.AddNode(ResourceGUID(1), ResourceType::Texture);
+    EXPECT_TRUE(graph.HasNode(ResourceGUID(1)));
+}
+
+TEST(ResourceDependencyGraph, AddMultipleNodes) {
+    ResourceDependencyGraph graph;
+    graph.AddNode(ResourceGUID(1), ResourceType::Texture);
+    graph.AddNode(ResourceGUID(2), ResourceType::Mesh);
+    graph.AddNode(ResourceGUID(3), ResourceType::Material);
+    
+    EXPECT_TRUE(graph.HasNode(ResourceGUID(1)));
+    EXPECT_TRUE(graph.HasNode(ResourceGUID(2)));
+    EXPECT_TRUE(graph.HasNode(ResourceGUID(3)));
+}
+
+TEST(ResourceDependencyGraph, RemoveNode) {
+    ResourceDependencyGraph graph;
+    graph.AddNode(ResourceGUID(1), ResourceType::Texture);
+    EXPECT_TRUE(graph.HasNode(ResourceGUID(1)));
+    
+    graph.RemoveNode(ResourceGUID(1));
+    EXPECT_FALSE(graph.HasNode(ResourceGUID(1)));
+}
+
+TEST(ResourceDependencyGraph, AddDependency) {
+    ResourceDependencyGraph graph;
+    graph.AddNode(ResourceGUID(1), ResourceType::Material);
+    graph.AddNode(ResourceGUID(2), ResourceType::Texture);
+    
+    graph.AddDependency(ResourceGUID(1), ResourceGUID(2));
+    
+    auto deps = graph.GetDependencies(ResourceGUID(1));
+    EXPECT_EQ(deps.Size(), 1u);
+    EXPECT_EQ(deps[0], ResourceGUID(2));
+}
+
+TEST(ResourceDependencyGraph, GetDependents) {
+    ResourceDependencyGraph graph;
+    graph.AddNode(ResourceGUID(1), ResourceType::Material);
+    graph.AddNode(ResourceGUID(2), ResourceType::Texture);
+    
+    graph.AddDependency(ResourceGUID(1), ResourceGUID(2));
+    
+    auto dependents = graph.GetDependents(ResourceGUID(2));
+    EXPECT_EQ(dependents.Size(), 1u);
+    EXPECT_EQ(dependents[0], ResourceGUID(1));
+}
+
+TEST(ResourceDependencyGraph, GetAllDependencies) {
+    ResourceDependencyGraph graph;
+    graph.AddNode(ResourceGUID(1), ResourceType::Material);
+    graph.AddNode(ResourceGUID(2), ResourceType::Texture);
+    graph.AddNode(ResourceGUID(3), ResourceType::Shader);
+    
+    graph.AddDependency(ResourceGUID(1), ResourceGUID(2));
+    graph.AddDependency(ResourceGUID(1), ResourceGUID(3));
+    
+    auto allDeps = graph.GetAllDependencies(ResourceGUID(1));
+    EXPECT_EQ(allDeps.Size(), 2u);
+}
+
+TEST(ResourceDependencyGraph, RefCount) {
+    ResourceDependencyGraph graph;
+    graph.AddNode(ResourceGUID(1), ResourceType::Texture);
+    
+    EXPECT_EQ(graph.GetRefCount(ResourceGUID(1)), 0u);
+    
+    graph.IncrementRefCount(ResourceGUID(1));
+    EXPECT_EQ(graph.GetRefCount(ResourceGUID(1)), 1u);
+    
+    graph.IncrementRefCount(ResourceGUID(1));
+    EXPECT_EQ(graph.GetRefCount(ResourceGUID(1)), 2u);
+    
+    graph.DecrementRefCount(ResourceGUID(1));
+    EXPECT_EQ(graph.GetRefCount(ResourceGUID(1)), 1u);
+}
+
+TEST(ResourceDependencyGraph, Unload) {
+    ResourceDependencyGraph graph;
+    graph.AddNode(ResourceGUID(1), ResourceType::Texture);
+    
+    EXPECT_TRUE(graph.Unload(ResourceGUID(1)));
+    
+    graph.IncrementRefCount(ResourceGUID(1));
+    EXPECT_FALSE(graph.Unload(ResourceGUID(1)));
+}
+
+TEST(ResourceDependencyGraph, Clear) {
+    ResourceDependencyGraph graph;
+    graph.AddNode(ResourceGUID(1), ResourceType::Texture);
+    graph.AddNode(ResourceGUID(2), ResourceType::Mesh);
+    
+    EXPECT_TRUE(graph.HasNode(ResourceGUID(1)));
+    EXPECT_TRUE(graph.HasNode(ResourceGUID(2)));
+    
+    graph.Clear();
+    
+    EXPECT_FALSE(graph.HasNode(ResourceGUID(1)));
+    EXPECT_FALSE(graph.HasNode(ResourceGUID(2)));
+}
+
+TEST(ResourceDependencyGraph, RemoveDependency) {
+    ResourceDependencyGraph graph;
+    graph.AddNode(ResourceGUID(1), ResourceType::Material);
+    graph.AddNode(ResourceGUID(2), ResourceType::Texture);
+    
+    graph.AddDependency(ResourceGUID(1), ResourceGUID(2));
+    auto deps = graph.GetDependencies(ResourceGUID(1));
+    EXPECT_EQ(deps.Size(), 1u);
+    
+    graph.RemoveDependency(ResourceGUID(1), ResourceGUID(2));
+    deps = graph.GetDependencies(ResourceGUID(1));
+    EXPECT_EQ(deps.Size(), 0u);
+}
+
+} // namespace

tests/Core/Asset/test_resource_guid.cpp

@@ -0,0 +1,64 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+#include <XCEngine/Core/Containers/String.h>
+
+using namespace XCEngine::Resources;
+using namespace XCEngine::Containers;
+
+namespace {
+
+TEST(Resources_GUID, DefaultConstructor) {
+    ResourceGUID guid;
+    EXPECT_FALSE(guid.IsValid());
+    EXPECT_EQ(guid.value, 0);
+}
+
+TEST(Resources_GUID, ValueConstructor) {
+    ResourceGUID guid(12345);
+    EXPECT_TRUE(guid.IsValid());
+    EXPECT_EQ(guid.value, 12345);
+}
+
+TEST(Resources_GUID, Generate_FromCString) {
+    ResourceGUID guid1 = ResourceGUID::Generate("textures/player.png");
+    ResourceGUID guid2 = ResourceGUID::Generate("textures/player.png");
+    
+    EXPECT_EQ(guid1, guid2);
+    EXPECT_TRUE(guid1.IsValid());
+}
+
+TEST(Resources_GUID, Generate_FromString) {
+    String path = "models/player.fbx";
+    ResourceGUID guid = ResourceGUID::Generate(path);
+    EXPECT_TRUE(guid.IsValid());
+}
+
+TEST(Resources_GUID, Generate_DifferentPaths) {
+    ResourceGUID guid1 = ResourceGUID::Generate("textures/a.png");
+    ResourceGUID guid2 = ResourceGUID::Generate("textures/b.png");
+    
+    EXPECT_NE(guid1, guid2);
+}
+
+TEST(Resources_GUID, ToString) {
+    ResourceGUID guid(0x1234567890ABCDEF);
+    String str = guid.ToString();
+    
+    EXPECT_EQ(str.Length(), 16u);
+}
+
+TEST(Resources_GUID, MakeResourceGUID_Helper) {
+    ResourceGUID guid = MakeResourceGUID("test/path");
+    EXPECT_TRUE(guid.IsValid());
+}
+
+TEST(Resources_GUID, EqualityOperators) {
+    ResourceGUID guid1(100);
+    ResourceGUID guid2(100);
+    ResourceGUID guid3(200);
+    
+    EXPECT_TRUE(guid1 == guid2);
+    EXPECT_TRUE(guid1 != guid3);
+}
+
+} // namespace

tests/Core/Asset/test_resource_handle.cpp

@@ -0,0 +1,194 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Core/Asset/ResourceHandle.h>
+#include <XCEngine/Core/Asset/IResource.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+#include <XCEngine/Core/Asset/ResourceManager.h>
+#include <XCEngine/Core/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

tests/Core/Asset/test_resource_types.cpp

@@ -0,0 +1,35 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+#include <XCEngine/Core/Types.h>
+
+using namespace XCEngine::Resources;
+
+namespace {
+
+TEST(Resources_Types, ResourceType_EnumValues) {
+    EXPECT_EQ(static_cast<uint8_t>(ResourceType::Unknown), 0);
+    EXPECT_EQ(static_cast<uint8_t>(ResourceType::Texture), 1);
+    EXPECT_EQ(static_cast<uint8_t>(ResourceType::Mesh), 2);
+    EXPECT_EQ(static_cast<uint8_t>(ResourceType::Material), 3);
+    EXPECT_EQ(static_cast<uint8_t>(ResourceType::Shader), 4);
+    EXPECT_EQ(static_cast<uint8_t>(ResourceType::AudioClip), 5);
+    EXPECT_EQ(static_cast<uint8_t>(ResourceType::Binary), 6);
+}
+
+TEST(Resources_Types, GetResourceTypeName) {
+    EXPECT_STREQ(GetResourceTypeName(ResourceType::Texture), "Texture");
+    EXPECT_STREQ(GetResourceTypeName(ResourceType::Mesh), "Mesh");
+    EXPECT_STREQ(GetResourceTypeName(ResourceType::Material), "Material");
+    EXPECT_STREQ(GetResourceTypeName(ResourceType::Unknown), "Unknown");
+}
+
+TEST(Resources_Types, GetResourceType_TemplateSpecializations) {
+    EXPECT_EQ(GetResourceType<Texture>(), ResourceType::Texture);
+    EXPECT_EQ(GetResourceType<Mesh>(), ResourceType::Mesh);
+    EXPECT_EQ(GetResourceType<Material>(), ResourceType::Material);
+    EXPECT_EQ(GetResourceType<Shader>(), ResourceType::Shader);
+    EXPECT_EQ(GetResourceType<AudioClip>(), ResourceType::AudioClip);
+    EXPECT_EQ(GetResourceType<BinaryResource>(), ResourceType::Binary);
+}
+
+} // namespace