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

engine/include/XCEngine/Resources/Material/Material.h

@@ -1,14 +1,14 @@
 #pragma once
-#include "IResource.h"
-#include "ResourceHandle.h"
-#include "ResourceManager.h"
-#include "Texture.h"
-#include "Shader.h"
-#include "../Containers/HashMap.h"
-#include "../Core/Types.h"
-#include "../Math/Vector2.h"
-#include "../Math/Vector3.h"
-#include "../Math/Vector4.h"
+#include <XCEngine/Core/Asset/IResource.h>
+#include <XCEngine/Core/Asset/ResourceHandle.h>
+#include <XCEngine/Core/Asset/ResourceManager.h>
+#include <XCEngine/Resources/Texture/Texture.h>
+#include <XCEngine/Resources/Shader/Shader.h>
+#include <XCEngine/Core/Containers/HashMap.h>
+#include <XCEngine/Core/Types.h>
+#include <XCEngine/Core/Math/Vector2.h>
+#include <XCEngine/Core/Math/Vector3.h>
+#include <XCEngine/Core/Math/Vector4.h>
 #include <cstring>
 
 namespace XCEngine {

tests/Resources/AudioClip/CMakeLists.txt

@@ -0,0 +1,31 @@
+# ============================================================
+# AudioClip Tests
+# ============================================================
+
+set(AUDIOCLIP_TEST_SOURCES
+    test_audio_clip.cpp
+    test_audio_loader.cpp
+)
+
+add_executable(audioclip_tests ${AUDIOCLIP_TEST_SOURCES})
+
+if(MSVC)
+    set_target_properties(audioclip_tests PROPERTIES
+        LINK_FLAGS "/NODEFAULTLIB:libcpmt.lib /NODEFAULTLIB:libcmt.lib"
+    )
+endif()
+
+target_link_libraries(audioclip_tests
+    PRIVATE
+    XCEngine
+    GTest::gtest
+    GTest::gtest_main
+)
+
+target_include_directories(audioclip_tests PRIVATE
+    ${CMAKE_SOURCE_DIR}/engine/include
+    ${CMAKE_SOURCE_DIR}/tests/fixtures
+)
+
+include(GoogleTest)
+gtest_discover_tests(audioclip_tests)

tests/Resources/AudioClip/test_audio_clip.cpp

@@ -0,0 +1,20 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/AudioClip/AudioClip.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+#include <XCEngine/Core/Asset/ResourceManager.h>
+
+using namespace XCEngine::Resources;
+
+namespace {
+
+TEST(AudioClip, GetType) {
+    AudioClip audio;
+    EXPECT_EQ(audio.GetType(), ResourceType::AudioClip);
+}
+
+TEST(AudioClip, GetMemorySize) {
+    AudioClip audio;
+    EXPECT_EQ(audio.GetMemorySize(), 0u);
+}
+
+} // namespace

tests/Resources/AudioClip/test_audio_loader.cpp

@@ -0,0 +1,118 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/AudioClip/AudioLoader.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+#include <XCEngine/Core/Containers/Array.h>
+#include <XCEngine/Core/Asset/ResourceManager.h>
+#include <fstream>
+#include <cstring>
+
+using namespace XCEngine::Resources;
+using namespace XCEngine::Containers;
+
+namespace {
+
+#pragma pack(push, 1)
+struct WAVFileHeader {
+    char riff[4];
+    uint32_t fileSize;
+    char wave[4];
+    char fmt[4];
+    uint32_t fmtSize;
+    uint16_t audioFormat;
+    uint16_t numChannels;
+    uint32_t sampleRate;
+    uint32_t byteRate;
+    uint16_t blockAlign;
+    uint16_t bitsPerSample;
+    char data[4];
+    uint32_t dataSize;
+};
+#pragma pack(pop)
+
+void CreateTestWAVFile(const char* filepath, uint16_t channels, uint32_t sampleRate, uint16_t bitsPerSample, uint32_t numSamples) {
+    WAVFileHeader header = {};
+    header.riff[0] = 'R'; header.riff[1] = 'I'; header.riff[2] = 'F'; header.riff[3] = 'F';
+    header.wave[0] = 'W'; header.wave[1] = 'A'; header.wave[2] = 'V'; header.wave[3] = 'E';
+    header.fmt[0] = 'f'; header.fmt[1] = 'm'; header.fmt[2] = 't'; header.fmt[3] = ' ';
+    header.fmtSize = 16;
+    header.audioFormat = 1;
+    header.numChannels = channels;
+    header.sampleRate = sampleRate;
+    header.bitsPerSample = bitsPerSample;
+    header.blockAlign = channels * bitsPerSample / 8;
+    header.byteRate = sampleRate * header.blockAlign;
+    header.data[0] = 'd'; header.data[1] = 'a'; header.data[2] = 't'; header.data[3] = 'a';
+    header.dataSize = numSamples * header.blockAlign;
+    header.fileSize = 36 + header.dataSize;
+
+    std::vector<uint8_t> wavData(sizeof(WAVFileHeader) + header.dataSize, 0);
+    std::memcpy(wavData.data(), &header, sizeof(WAVFileHeader));
+
+    std::ofstream file(filepath, std::ios::binary);
+    file.write(reinterpret_cast<const char*>(wavData.data()), wavData.size());
+}
+
+TEST(AudioLoader, ParseWAV_Mono44100_16bit) {
+    const char* testPath = "test_mono_44100.wav";
+    CreateTestWAVFile(testPath, 1, 44100, 16, 44100);
+
+    AudioLoader loader;
+    LoadResult result = loader.Load(testPath);
+
+    EXPECT_TRUE(result);
+    if (result) {
+        AudioClip* clip = static_cast<AudioClip*>(result.resource);
+        EXPECT_EQ(clip->GetSampleRate(), 44100u);
+        EXPECT_EQ(clip->GetChannels(), 1u);
+        EXPECT_EQ(clip->GetBitsPerSample(), 16u);
+        EXPECT_GT(clip->GetDuration(), 0.0f);
+    }
+
+    std::remove(testPath);
+}
+
+TEST(AudioLoader, ParseWAV_Stereo48000_16bit) {
+    const char* testPath = "test_stereo_48000.wav";
+    CreateTestWAVFile(testPath, 2, 48000, 16, 4800);
+
+    AudioLoader loader;
+    LoadResult result = loader.Load(testPath);
+
+    EXPECT_TRUE(result);
+    if (result) {
+        AudioClip* clip = static_cast<AudioClip*>(result.resource);
+        EXPECT_EQ(clip->GetSampleRate(), 48000u);
+        EXPECT_EQ(clip->GetChannels(), 2u);
+        EXPECT_EQ(clip->GetBitsPerSample(), 16u);
+    }
+
+    std::remove(testPath);
+}
+
+TEST(AudioLoader, GetResourceType) {
+    AudioLoader loader;
+    EXPECT_EQ(loader.GetResourceType(), ResourceType::AudioClip);
+}
+
+TEST(AudioLoader, GetSupportedExtensions) {
+    AudioLoader loader;
+    auto extensions = loader.GetSupportedExtensions();
+    EXPECT_GE(extensions.Size(), 1u);
+}
+
+TEST(AudioLoader, CanLoad) {
+    AudioLoader loader;
+    EXPECT_TRUE(loader.CanLoad("test.wav"));
+    EXPECT_TRUE(loader.CanLoad("test.mp3"));
+    EXPECT_TRUE(loader.CanLoad("test.ogg"));
+    EXPECT_FALSE(loader.CanLoad("test.txt"));
+    EXPECT_FALSE(loader.CanLoad("test.png"));
+}
+
+TEST(AudioLoader, LoadInvalidPath) {
+    AudioLoader loader;
+    LoadResult result = loader.Load("invalid/path/audio.wav");
+    EXPECT_FALSE(result);
+}
+
+} // namespace

tests/Resources/CMakeLists.txt

@@ -1,52 +1,9 @@
 # ============================================================
-# Resources Library Tests
+# Resources Tests - Container for subdirectories
 # ============================================================
 
-set(RESOURCES_TEST_SOURCES
-    test_resource_types.cpp
-    test_resource_guid.cpp
-    test_iresource.cpp
-    test_resource_handle.cpp
-    test_resource_cache.cpp
-    test_iresource_loader.cpp
-    test_texture.cpp
-    test_mesh.cpp
-    test_audio_clip.cpp
-    test_resource_filesystem.cpp
-    test_file_archive.cpp
-    test_shader.cpp
-    test_material.cpp
-    test_texture_loader.cpp
-    test_mesh_loader.cpp
-    test_audio_loader.cpp
-    test_shader_loader.cpp
-    test_material_loader.cpp
-    test_resource_package.cpp
-    test_resource_dependency.cpp
-    test_texture_import_settings.cpp
-    test_mesh_import_settings.cpp
-    test_resource_path.cpp
-)
-
-add_executable(resources_tests ${RESOURCES_TEST_SOURCES})
-
-if(MSVC)
-    set_target_properties(resources_tests PROPERTIES
-        LINK_FLAGS "/NODEFAULTLIB:libcpmt.lib /NODEFAULTLIB:libcmt.lib"
-    )
-endif()
-
-target_link_libraries(resources_tests
-    PRIVATE
-    XCEngine
-    GTest::gtest
-    GTest::gtest_main
-)
-
-target_include_directories(resources_tests PRIVATE
-    ${CMAKE_SOURCE_DIR}/engine/include
-    ${CMAKE_SOURCE_DIR}/tests/fixtures
-)
-
-include(GoogleTest)
-gtest_discover_tests(resources_tests)
+add_subdirectory(Texture)
+add_subdirectory(Mesh)
+add_subdirectory(Material)
+add_subdirectory(Shader)
+add_subdirectory(AudioClip)

tests/Resources/Material/CMakeLists.txt

@@ -0,0 +1,31 @@
+# ============================================================
+# Material Tests
+# ============================================================
+
+set(MATERIAL_TEST_SOURCES
+    test_material.cpp
+    test_material_loader.cpp
+)
+
+add_executable(material_tests ${MATERIAL_TEST_SOURCES})
+
+if(MSVC)
+    set_target_properties(material_tests PROPERTIES
+        LINK_FLAGS "/NODEFAULTLIB:libcpmt.lib /NODEFAULTLIB:libcmt.lib"
+    )
+endif()
+
+target_link_libraries(material_tests
+    PRIVATE
+    XCEngine
+    GTest::gtest
+    GTest::gtest_main
+)
+
+target_include_directories(material_tests PRIVATE
+    ${CMAKE_SOURCE_DIR}/engine/include
+    ${CMAKE_SOURCE_DIR}/tests/fixtures
+)
+
+include(GoogleTest)
+gtest_discover_tests(material_tests)

tests/Resources/Material/test_material.cpp

@@ -0,0 +1,144 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/Material/Material.h>
+#include <XCEngine/Resources/Shader/Shader.h>
+#include <XCEngine/Resources/Texture/Texture.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+#include <XCEngine/Core/Math/Vector2.h>
+#include <XCEngine/Core/Math/Vector3.h>
+#include <XCEngine/Core/Math/Vector4.h>
+
+using namespace XCEngine::Resources;
+using namespace XCEngine::Math;
+
+namespace {
+
+TEST(Material, DefaultConstructor) {
+    Material material;
+    EXPECT_EQ(material.GetType(), ResourceType::Material);
+    EXPECT_FALSE(material.IsValid());
+    EXPECT_EQ(material.GetMemorySize(), 0u);
+}
+
+TEST(Material, GetType) {
+    Material material;
+    EXPECT_EQ(material.GetType(), ResourceType::Material);
+}
+
+TEST(Material, SetGetShader) {
+    Material material;
+    Shader* shader = new Shader();
+    
+    ResourceHandle<Shader> handle(shader);
+    material.SetShader(handle);
+    
+    EXPECT_EQ(material.GetShader(), shader);
+}
+
+TEST(Material, SetGetFloat) {
+    Material material;
+    
+    material.SetFloat("uTime", 1.5f);
+    EXPECT_FLOAT_EQ(material.GetFloat("uTime"), 1.5f);
+}
+
+TEST(Material, SetGetFloat2) {
+    Material material;
+    
+    Vector2 value(1.0f, 2.0f);
+    material.SetFloat2("uUV", value);
+    
+    Vector2 result = material.GetFloat2("uUV");
+    EXPECT_FLOAT_EQ(result.x, 1.0f);
+    EXPECT_FLOAT_EQ(result.y, 2.0f);
+}
+
+TEST(Material, SetGetFloat3) {
+    Material material;
+    
+    Vector3 value(1.0f, 2.0f, 3.0f);
+    material.SetFloat3("uPosition", value);
+    
+    Vector3 result = material.GetFloat3("uPosition");
+    EXPECT_FLOAT_EQ(result.x, 1.0f);
+    EXPECT_FLOAT_EQ(result.y, 2.0f);
+    EXPECT_FLOAT_EQ(result.z, 3.0f);
+}
+
+TEST(Material, SetGetFloat4) {
+    Material material;
+    
+    Vector4 value(1.0f, 2.0f, 3.0f, 4.0f);
+    material.SetFloat4("uColor", value);
+    
+    Vector4 result = material.GetFloat4("uColor");
+    EXPECT_FLOAT_EQ(result.x, 1.0f);
+    EXPECT_FLOAT_EQ(result.y, 2.0f);
+    EXPECT_FLOAT_EQ(result.z, 3.0f);
+    EXPECT_FLOAT_EQ(result.w, 4.0f);
+}
+
+TEST(Material, SetGetInt) {
+    Material material;
+    
+    material.SetInt("uIndex", 42);
+    EXPECT_EQ(material.GetInt("uIndex"), 42);
+}
+
+TEST(Material, SetGetBool) {
+    Material material;
+    
+    material.SetBool("uEnabled", true);
+    EXPECT_TRUE(material.GetBool("uEnabled"));
+    
+    material.SetBool("uEnabled", false);
+    EXPECT_FALSE(material.GetBool("uEnabled"));
+}
+
+TEST(Material, SetGetTexture) {
+    Material material;
+    Texture* texture = new Texture();
+    
+    ResourceHandle<Texture> handle(texture);
+    material.SetTexture("uDiffuse", handle);
+    
+    EXPECT_EQ(material.GetTexture("uDiffuse").Get(), texture);
+}
+
+TEST(Material, HasProperty) {
+    Material material;
+    
+    EXPECT_FALSE(material.HasProperty("uTime"));
+    
+    material.SetFloat("uTime", 1.0f);
+    EXPECT_TRUE(material.HasProperty("uTime"));
+}
+
+TEST(Material, RemoveProperty) {
+    Material material;
+    
+    material.SetFloat("uTime", 1.0f);
+    EXPECT_TRUE(material.HasProperty("uTime"));
+    
+    material.RemoveProperty("uTime");
+    EXPECT_FALSE(material.HasProperty("uTime"));
+}
+
+TEST(Material, ClearAllProperties) {
+    Material material;
+    
+    material.SetFloat("uTime", 1.0f);
+    material.SetFloat3("uPosition", Vector3(1.0f, 2.0f, 3.0f));
+    material.SetInt("uIndex", 1);
+    
+    EXPECT_TRUE(material.HasProperty("uTime"));
+    EXPECT_TRUE(material.HasProperty("uPosition"));
+    EXPECT_TRUE(material.HasProperty("uIndex"));
+    
+    material.ClearAllProperties();
+    
+    EXPECT_FALSE(material.HasProperty("uTime"));
+    EXPECT_FALSE(material.HasProperty("uPosition"));
+    EXPECT_FALSE(material.HasProperty("uIndex"));
+}
+
+} // namespace

tests/Resources/Material/test_material_loader.cpp

@@ -0,0 +1,36 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/Material/MaterialLoader.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+#include <XCEngine/Core/Containers/Array.h>
+
+using namespace XCEngine::Resources;
+using namespace XCEngine::Containers;
+
+namespace {
+
+TEST(MaterialLoader, GetResourceType) {
+    MaterialLoader loader;
+    EXPECT_EQ(loader.GetResourceType(), ResourceType::Material);
+}
+
+TEST(MaterialLoader, GetSupportedExtensions) {
+    MaterialLoader loader;
+    auto extensions = loader.GetSupportedExtensions();
+    EXPECT_GE(extensions.Size(), 1u);
+}
+
+TEST(MaterialLoader, CanLoad) {
+    MaterialLoader loader;
+    EXPECT_TRUE(loader.CanLoad("test.mat"));
+    EXPECT_TRUE(loader.CanLoad("test.json"));
+    EXPECT_FALSE(loader.CanLoad("test.txt"));
+    EXPECT_FALSE(loader.CanLoad("test.png"));
+}
+
+TEST(MaterialLoader, LoadInvalidPath) {
+    MaterialLoader loader;
+    LoadResult result = loader.Load("invalid/path/material.mat");
+    EXPECT_FALSE(result);
+}
+
+} // namespace

tests/Resources/Mesh/CMakeLists.txt

@@ -0,0 +1,32 @@
+# ============================================================
+# Mesh Tests
+# ============================================================
+
+set(MESH_TEST_SOURCES
+    test_mesh.cpp
+    test_mesh_loader.cpp
+    test_mesh_import_settings.cpp
+)
+
+add_executable(mesh_tests ${MESH_TEST_SOURCES})
+
+if(MSVC)
+    set_target_properties(mesh_tests PROPERTIES
+        LINK_FLAGS "/NODEFAULTLIB:libcpmt.lib /NODEFAULTLIB:libcmt.lib"
+    )
+endif()
+
+target_link_libraries(mesh_tests
+    PRIVATE
+    XCEngine
+    GTest::gtest
+    GTest::gtest_main
+)
+
+target_include_directories(mesh_tests PRIVATE
+    ${CMAKE_SOURCE_DIR}/engine/include
+    ${CMAKE_SOURCE_DIR}/tests/fixtures
+)
+
+include(GoogleTest)
+gtest_discover_tests(mesh_tests)

tests/Resources/Mesh/test_mesh.cpp

@@ -0,0 +1,33 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/Mesh/Mesh.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+#include <XCEngine/Core/Asset/ResourceManager.h>
+
+using namespace XCEngine::Resources;
+
+namespace {
+
+TEST(Mesh, DefaultConstructor) {
+    Mesh mesh;
+    EXPECT_EQ(mesh.GetVertexCount(), 0u);
+    EXPECT_EQ(mesh.GetIndexCount(), 0u);
+    EXPECT_EQ(mesh.GetVertexStride(), 0u);
+    EXPECT_FALSE(mesh.IsUse32BitIndex());
+}
+
+TEST(Mesh, GetType) {
+    Mesh mesh;
+    EXPECT_EQ(mesh.GetType(), ResourceType::Mesh);
+}
+
+TEST(Mesh, GetMemorySize) {
+    Mesh mesh;
+    EXPECT_EQ(mesh.GetMemorySize(), 0u);
+}
+
+TEST(Mesh, GetSections) {
+    Mesh mesh;
+    EXPECT_EQ(mesh.GetSections().Size(), 0u);
+}
+
+} // namespace

tests/Resources/Mesh/test_mesh_import_settings.cpp

@@ -0,0 +1,104 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/Mesh/MeshImportSettings.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+#include <XCEngine/Core/Math/Vector3.h>
+
+using namespace XCEngine::Resources;
+using namespace XCEngine::Math;
+
+namespace {
+
+TEST(MeshImportSettings, DefaultConstructor) {
+    MeshImportSettings settings;
+    EXPECT_EQ(settings.GetImportFlags(), MeshImportFlags::None);
+    EXPECT_FLOAT_EQ(settings.GetScale(), 1.0f);
+    EXPECT_EQ(settings.GetOffset(), Vector3::Zero());
+    EXPECT_TRUE(settings.GetAxisConversion());
+    EXPECT_FALSE(settings.GetMergeMeshes());
+    EXPECT_FLOAT_EQ(settings.GetOptimizeThreshold(), 0.3f);
+    EXPECT_FLOAT_EQ(settings.GetImportScale(), 1.0f);
+    EXPECT_FLOAT_EQ(settings.GetThreshold(), 0.0f);
+}
+
+TEST(MeshImportSettings, SetImportFlags) {
+    MeshImportSettings settings;
+    settings.SetImportFlags(MeshImportFlags::FlipUVs | MeshImportFlags::GenerateNormals);
+    EXPECT_TRUE(settings.HasImportFlag(MeshImportFlags::FlipUVs));
+    EXPECT_TRUE(settings.HasImportFlag(MeshImportFlags::GenerateNormals));
+    EXPECT_FALSE(settings.HasImportFlag(MeshImportFlags::GenerateTangents));
+}
+
+TEST(MeshImportSettings, AddImportFlag) {
+    MeshImportSettings settings;
+    settings.AddImportFlag(MeshImportFlags::FlipUVs);
+    EXPECT_TRUE(settings.HasImportFlag(MeshImportFlags::FlipUVs));
+}
+
+TEST(MeshImportSettings, RemoveImportFlag) {
+    MeshImportSettings settings;
+    settings.SetImportFlags(MeshImportFlags::FlipUVs | MeshImportFlags::GenerateNormals);
+    settings.RemoveImportFlag(MeshImportFlags::FlipUVs);
+    EXPECT_FALSE(settings.HasImportFlag(MeshImportFlags::FlipUVs));
+    EXPECT_TRUE(settings.HasImportFlag(MeshImportFlags::GenerateNormals));
+}
+
+TEST(MeshImportSettings, SetScale) {
+    MeshImportSettings settings;
+    settings.SetScale(2.0f);
+    EXPECT_FLOAT_EQ(settings.GetScale(), 2.0f);
+}
+
+TEST(MeshImportSettings, SetOffset) {
+    MeshImportSettings settings;
+    Vector3 offset(1.0f, 2.0f, 3.0f);
+    settings.SetOffset(offset);
+    EXPECT_EQ(settings.GetOffset(), offset);
+}
+
+TEST(MeshImportSettings, SetAxisConversion) {
+    MeshImportSettings settings;
+    settings.SetAxisConversion(false);
+    EXPECT_FALSE(settings.GetAxisConversion());
+}
+
+TEST(MeshImportSettings, SetMergeMeshes) {
+    MeshImportSettings settings;
+    settings.SetMergeMeshes(true);
+    EXPECT_TRUE(settings.GetMergeMeshes());
+}
+
+TEST(MeshImportSettings, SetOptimizeThreshold) {
+    MeshImportSettings settings;
+    settings.SetOptimizeThreshold(0.5f);
+    EXPECT_FLOAT_EQ(settings.GetOptimizeThreshold(), 0.5f);
+}
+
+TEST(MeshImportSettings, SetImportScale) {
+    MeshImportSettings settings;
+    settings.SetImportScale(0.5f);
+    EXPECT_FLOAT_EQ(settings.GetImportScale(), 0.5f);
+}
+
+TEST(MeshImportSettings, SetThreshold) {
+    MeshImportSettings settings;
+    settings.SetThreshold(0.01f);
+    EXPECT_FLOAT_EQ(settings.GetThreshold(), 0.01f);
+}
+
+TEST(MeshImportSettings, Clone) {
+    MeshImportSettings settings;
+    settings.SetImportFlags(MeshImportFlags::FlipUVs | MeshImportFlags::GenerateNormals);
+    settings.SetScale(2.0f);
+    settings.SetMergeMeshes(true);
+
+    auto cloned = settings.Clone();
+    ASSERT_NE(cloned, nullptr);
+
+    MeshImportSettings* clonedSettings = static_cast<MeshImportSettings*>(cloned.get());
+    EXPECT_TRUE(clonedSettings->HasImportFlag(MeshImportFlags::FlipUVs));
+    EXPECT_TRUE(clonedSettings->HasImportFlag(MeshImportFlags::GenerateNormals));
+    EXPECT_FLOAT_EQ(clonedSettings->GetScale(), 2.0f);
+    EXPECT_TRUE(clonedSettings->GetMergeMeshes());
+}
+
+} // namespace

tests/Resources/Mesh/test_mesh_loader.cpp

@@ -0,0 +1,37 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/Mesh/MeshLoader.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+#include <XCEngine/Core/Containers/Array.h>
+
+using namespace XCEngine::Resources;
+using namespace XCEngine::Containers;
+
+namespace {
+
+TEST(MeshLoader, GetResourceType) {
+    MeshLoader loader;
+    EXPECT_EQ(loader.GetResourceType(), ResourceType::Mesh);
+}
+
+TEST(MeshLoader, GetSupportedExtensions) {
+    MeshLoader loader;
+    auto extensions = loader.GetSupportedExtensions();
+    EXPECT_GE(extensions.Size(), 1u);
+}
+
+TEST(MeshLoader, CanLoad) {
+    MeshLoader loader;
+    EXPECT_TRUE(loader.CanLoad("test.obj"));
+    EXPECT_TRUE(loader.CanLoad("test.fbx"));
+    EXPECT_TRUE(loader.CanLoad("test.gltf"));
+    EXPECT_FALSE(loader.CanLoad("test.txt"));
+    EXPECT_FALSE(loader.CanLoad("test.png"));
+}
+
+TEST(MeshLoader, LoadInvalidPath) {
+    MeshLoader loader;
+    LoadResult result = loader.Load("invalid/path/mesh.obj");
+    EXPECT_FALSE(result);
+}
+
+} // namespace

tests/Resources/Shader/CMakeLists.txt

@@ -0,0 +1,31 @@
+# ============================================================
+# Shader Tests
+# ============================================================
+
+set(SHADER_TEST_SOURCES
+    test_shader.cpp
+    test_shader_loader.cpp
+)
+
+add_executable(shader_tests ${SHADER_TEST_SOURCES})
+
+if(MSVC)
+    set_target_properties(shader_tests PROPERTIES
+        LINK_FLAGS "/NODEFAULTLIB:libcpmt.lib /NODEFAULTLIB:libcmt.lib"
+    )
+endif()
+
+target_link_libraries(shader_tests
+    PRIVATE
+    XCEngine
+    GTest::gtest
+    GTest::gtest_main
+)
+
+target_include_directories(shader_tests PRIVATE
+    ${CMAKE_SOURCE_DIR}/engine/include
+    ${CMAKE_SOURCE_DIR}/tests/fixtures
+)
+
+include(GoogleTest)
+gtest_discover_tests(shader_tests)

tests/Resources/Shader/test_shader.cpp

@@ -0,0 +1,103 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/Shader/Shader.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+#include <XCEngine/Core/Containers/Array.h>
+
+using namespace XCEngine::Resources;
+using namespace XCEngine::Containers;
+
+namespace {
+
+TEST(Shader, DefaultConstructor) {
+    Shader shader;
+    EXPECT_EQ(shader.GetShaderType(), ShaderType::Fragment);
+    EXPECT_EQ(shader.GetShaderLanguage(), ShaderLanguage::GLSL);
+    EXPECT_FALSE(shader.IsValid());
+    EXPECT_EQ(shader.GetMemorySize(), 0u);
+}
+
+TEST(Shader, GetType) {
+    Shader shader;
+    EXPECT_EQ(shader.GetType(), ResourceType::Shader);
+}
+
+TEST(Shader, SetGetShaderType) {
+    Shader shader;
+    
+    shader.SetShaderType(ShaderType::Vertex);
+    EXPECT_EQ(shader.GetShaderType(), ShaderType::Vertex);
+    
+    shader.SetShaderType(ShaderType::Fragment);
+    EXPECT_EQ(shader.GetShaderType(), ShaderType::Fragment);
+    
+    shader.SetShaderType(ShaderType::Geometry);
+    EXPECT_EQ(shader.GetShaderType(), ShaderType::Geometry);
+    
+    shader.SetShaderType(ShaderType::Compute);
+    EXPECT_EQ(shader.GetShaderType(), ShaderType::Compute);
+}
+
+TEST(Shader, SetGetShaderLanguage) {
+    Shader shader;
+    
+    shader.SetShaderLanguage(ShaderLanguage::GLSL);
+    EXPECT_EQ(shader.GetShaderLanguage(), ShaderLanguage::GLSL);
+    
+    shader.SetShaderLanguage(ShaderLanguage::HLSL);
+    EXPECT_EQ(shader.GetShaderLanguage(), ShaderLanguage::HLSL);
+    
+    shader.SetShaderLanguage(ShaderLanguage::SPIRV);
+    EXPECT_EQ(shader.GetShaderLanguage(), ShaderLanguage::SPIRV);
+}
+
+TEST(Shader, SetGetSourceCode) {
+    Shader shader;
+    const char* source = "#version 330 core\nvoid main() {}";
+    
+    shader.SetSourceCode(source);
+    EXPECT_EQ(shader.GetSourceCode(), source);
+}
+
+TEST(Shader, SetGetCompiledBinary) {
+    Shader shader;
+    XCEngine::Containers::Array<XCEngine::Core::uint8> binary = { 0x00, 0x01, 0x02, 0x03 };
+    
+    shader.SetCompiledBinary(binary);
+    EXPECT_EQ(shader.GetCompiledBinary().Size(), 4u);
+    EXPECT_EQ(shader.GetCompiledBinary()[0], 0x00);
+    EXPECT_EQ(shader.GetCompiledBinary()[3], 0x03);
+}
+
+TEST(Shader, AddGetUniforms) {
+    Shader shader;
+    
+    ShaderUniform uniform1;
+    uniform1.name = "uModelView";
+    uniform1.location = 0;
+    uniform1.size = 1;
+    uniform1.type = 4;
+    
+    shader.AddUniform(uniform1);
+    
+    const auto& uniforms = shader.GetUniforms();
+    EXPECT_EQ(uniforms.Size(), 1u);
+    EXPECT_EQ(uniforms[0].name, "uModelView");
+}
+
+TEST(Shader, AddGetAttributes) {
+    Shader shader;
+    
+    ShaderAttribute attr1;
+    attr1.name = "aPosition";
+    attr1.location = 0;
+    attr1.size = 1;
+    attr1.type = 3;
+    
+    shader.AddAttribute(attr1);
+    
+    const auto& attributes = shader.GetAttributes();
+    EXPECT_EQ(attributes.Size(), 1u);
+    EXPECT_EQ(attributes[0].name, "aPosition");
+}
+
+} // namespace

tests/Resources/Shader/test_shader_loader.cpp

@@ -0,0 +1,38 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/Shader/ShaderLoader.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+#include <XCEngine/Core/Containers/Array.h>
+
+using namespace XCEngine::Resources;
+using namespace XCEngine::Containers;
+
+namespace {
+
+TEST(ShaderLoader, GetResourceType) {
+    ShaderLoader loader;
+    EXPECT_EQ(loader.GetResourceType(), ResourceType::Shader);
+}
+
+TEST(ShaderLoader, GetSupportedExtensions) {
+    ShaderLoader loader;
+    auto extensions = loader.GetSupportedExtensions();
+    EXPECT_GE(extensions.Size(), 1u);
+}
+
+TEST(ShaderLoader, CanLoad) {
+    ShaderLoader loader;
+    EXPECT_TRUE(loader.CanLoad("test.vert"));
+    EXPECT_TRUE(loader.CanLoad("test.frag"));
+    EXPECT_TRUE(loader.CanLoad("test.glsl"));
+    EXPECT_TRUE(loader.CanLoad("test.hlsl"));
+    EXPECT_FALSE(loader.CanLoad("test.txt"));
+    EXPECT_FALSE(loader.CanLoad("test.png"));
+}
+
+TEST(ShaderLoader, LoadInvalidPath) {
+    ShaderLoader loader;
+    LoadResult result = loader.Load("invalid/path/shader.glsl");
+    EXPECT_FALSE(result);
+}
+
+} // namespace

tests/Resources/Texture/CMakeLists.txt

@@ -0,0 +1,32 @@
+# ============================================================
+# Texture Tests
+# ============================================================
+
+set(TEXTURE_TEST_SOURCES
+    test_texture.cpp
+    test_texture_loader.cpp
+    test_texture_import_settings.cpp
+)
+
+add_executable(texture_tests ${TEXTURE_TEST_SOURCES})
+
+if(MSVC)
+    set_target_properties(texture_tests PROPERTIES
+        LINK_FLAGS "/NODEFAULTLIB:libcpmt.lib /NODEFAULTLIB:libcmt.lib"
+    )
+endif()
+
+target_link_libraries(texture_tests
+    PRIVATE
+    XCEngine
+    GTest::gtest
+    GTest::gtest_main
+)
+
+target_include_directories(texture_tests PRIVATE
+    ${CMAKE_SOURCE_DIR}/engine/include
+    ${CMAKE_SOURCE_DIR}/tests/fixtures
+)
+
+include(GoogleTest)
+gtest_discover_tests(texture_tests)

tests/Resources/Texture/test_texture.cpp

@@ -0,0 +1,37 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/Texture/Texture.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+#include <XCEngine/Core/Asset/ResourceManager.h>
+
+using namespace XCEngine::Resources;
+
+namespace {
+
+TEST(Texture, DefaultConstructor) {
+    Texture texture;
+    EXPECT_EQ(texture.GetWidth(), 0u);
+    EXPECT_EQ(texture.GetHeight(), 0u);
+    EXPECT_EQ(texture.GetDepth(), 1u);
+    EXPECT_EQ(texture.GetMipLevels(), 1u);
+    EXPECT_EQ(texture.GetArraySize(), 1u);
+    EXPECT_EQ(texture.GetTextureType(), TextureType::Texture2D);
+    EXPECT_EQ(texture.GetFormat(), TextureFormat::RGBA8_UNORM);
+    EXPECT_EQ(texture.GetUsage(), TextureUsage::ShaderResource);
+}
+
+TEST(Texture, GetMemorySize) {
+    Texture texture;
+    EXPECT_EQ(texture.GetMemorySize(), 0u);
+}
+
+TEST(Texture, GetType) {
+    Texture texture;
+    EXPECT_EQ(texture.GetType(), ResourceType::Texture);
+}
+
+TEST(Texture, IsValid) {
+    Texture texture;
+    EXPECT_FALSE(texture.IsValid());
+}
+
+} // namespace

tests/Resources/Texture/test_texture_import_settings.cpp

@@ -0,0 +1,119 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/Texture/TextureImportSettings.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+
+using namespace XCEngine::Resources;
+
+namespace {
+
+TEST(TextureImportSettings, DefaultConstructor) {
+    TextureImportSettings settings;
+    EXPECT_EQ(settings.GetTextureType(), TextureType::Texture2D);
+    EXPECT_EQ(settings.GetTargetFormat(), TextureFormat::Unknown);
+    EXPECT_TRUE(settings.GetGenerateMipmaps());
+    EXPECT_EQ(settings.GetMipmapFilter(), MipmapFilter::Box);
+    EXPECT_EQ(settings.GetMaxAnisotropy(), 16u);
+    EXPECT_FALSE(settings.GetSRGB());
+    EXPECT_FALSE(settings.GetFlipVertical());
+    EXPECT_FALSE(settings.GetFlipHorizontal());
+    EXPECT_EQ(settings.GetCompressionQuality(), CompressionQuality::High);
+    EXPECT_TRUE(settings.GetUseHardwareCompression());
+    EXPECT_EQ(settings.GetMaxSize(), 0u);
+    EXPECT_FALSE(settings.GetGenerateNormalMap());
+    EXPECT_FLOAT_EQ(settings.GetNormalMapStrength(), 1.0f);
+}
+
+TEST(TextureImportSettings, SetTextureType) {
+    TextureImportSettings settings;
+    settings.SetTextureType(TextureType::TextureCube);
+    EXPECT_EQ(settings.GetTextureType(), TextureType::TextureCube);
+}
+
+TEST(TextureImportSettings, SetTargetFormat) {
+    TextureImportSettings settings;
+    settings.SetTargetFormat(TextureFormat::BC7_UNORM_SRGB);
+    EXPECT_EQ(settings.GetTargetFormat(), TextureFormat::BC7_UNORM_SRGB);
+}
+
+TEST(TextureImportSettings, SetGenerateMipmaps) {
+    TextureImportSettings settings;
+    settings.SetGenerateMipmaps(false);
+    EXPECT_FALSE(settings.GetGenerateMipmaps());
+}
+
+TEST(TextureImportSettings, SetMipmapFilter) {
+    TextureImportSettings settings;
+    settings.SetMipmapFilter(MipmapFilter::Kaiser);
+    EXPECT_EQ(settings.GetMipmapFilter(), MipmapFilter::Kaiser);
+}
+
+TEST(TextureImportSettings, SetMaxAnisotropy) {
+    TextureImportSettings settings;
+    settings.SetMaxAnisotropy(8);
+    EXPECT_EQ(settings.GetMaxAnisotropy(), 8u);
+}
+
+TEST(TextureImportSettings, SetSRGB) {
+    TextureImportSettings settings;
+    settings.SetSRGB(true);
+    EXPECT_TRUE(settings.GetSRGB());
+}
+
+TEST(TextureImportSettings, SetFlipVertical) {
+    TextureImportSettings settings;
+    settings.SetFlipVertical(true);
+    EXPECT_TRUE(settings.GetFlipVertical());
+}
+
+TEST(TextureImportSettings, SetFlipHorizontal) {
+    TextureImportSettings settings;
+    settings.SetFlipHorizontal(true);
+    EXPECT_TRUE(settings.GetFlipHorizontal());
+}
+
+TEST(TextureImportSettings, SetCompressionQuality) {
+    TextureImportSettings settings;
+    settings.SetCompressionQuality(CompressionQuality::Low);
+    EXPECT_EQ(settings.GetCompressionQuality(), CompressionQuality::Low);
+}
+
+TEST(TextureImportSettings, SetUseHardwareCompression) {
+    TextureImportSettings settings;
+    settings.SetUseHardwareCompression(false);
+    EXPECT_FALSE(settings.GetUseHardwareCompression());
+}
+
+TEST(TextureImportSettings, SetMaxSize) {
+    TextureImportSettings settings;
+    settings.SetMaxSize(2048);
+    EXPECT_EQ(settings.GetMaxSize(), 2048u);
+}
+
+TEST(TextureImportSettings, SetGenerateNormalMap) {
+    TextureImportSettings settings;
+    settings.SetGenerateNormalMap(true);
+    EXPECT_TRUE(settings.GetGenerateNormalMap());
+}
+
+TEST(TextureImportSettings, SetNormalMapStrength) {
+    TextureImportSettings settings;
+    settings.SetNormalMapStrength(2.0f);
+    EXPECT_FLOAT_EQ(settings.GetNormalMapStrength(), 2.0f);
+}
+
+TEST(TextureImportSettings, Clone) {
+    TextureImportSettings settings;
+    settings.SetTextureType(TextureType::TextureCube);
+    settings.SetSRGB(true);
+    settings.SetMaxAnisotropy(8);
+
+    auto cloned = settings.Clone();
+    ASSERT_NE(cloned, nullptr);
+    
+    TextureImportSettings* clonedSettings = static_cast<TextureImportSettings*>(cloned.get());
+    EXPECT_EQ(clonedSettings->GetTextureType(), TextureType::TextureCube);
+    EXPECT_TRUE(clonedSettings->GetSRGB());
+    EXPECT_EQ(clonedSettings->GetMaxAnisotropy(), 8u);
+}
+
+} // namespace

tests/Resources/Texture/test_texture_loader.cpp

@@ -0,0 +1,37 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/Texture/TextureLoader.h>
+#include <XCEngine/Core/Asset/ResourceTypes.h>
+#include <XCEngine/Core/Containers/Array.h>
+
+using namespace XCEngine::Resources;
+using namespace XCEngine::Containers;
+
+namespace {
+
+TEST(TextureLoader, GetResourceType) {
+    TextureLoader loader;
+    EXPECT_EQ(loader.GetResourceType(), ResourceType::Texture);
+}
+
+TEST(TextureLoader, GetSupportedExtensions) {
+    TextureLoader loader;
+    auto extensions = loader.GetSupportedExtensions();
+    EXPECT_GE(extensions.Size(), 1u);
+}
+
+TEST(TextureLoader, CanLoad) {
+    TextureLoader loader;
+    EXPECT_TRUE(loader.CanLoad("test.png"));
+    EXPECT_TRUE(loader.CanLoad("test.jpg"));
+    EXPECT_TRUE(loader.CanLoad("test.tga"));
+    EXPECT_FALSE(loader.CanLoad("test.txt"));
+    EXPECT_FALSE(loader.CanLoad("test.obj"));
+}
+
+TEST(TextureLoader, LoadInvalidPath) {
+    TextureLoader loader;
+    LoadResult result = loader.Load("invalid/path/texture.png");
+    EXPECT_FALSE(result);
+}
+
+} // namespace