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/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