test(Resources): Add comprehensive resource system tests (8 new test files, +48 test cases)

- Add Shader tests (8 test cases)
- Add Material tests (13 test cases)
- Add FileArchive tests (7 test cases)
- Add Loader tests for Texture, Mesh, Audio, Shader, Material (4 tests each)
- Implement IResourceLoader.cpp with ReadFileData and GetExtension
- Update CMakeLists.txt to include new test files and source

tests/Resources/CMakeLists.txt

@@ -12,6 +12,15 @@ set(RESOURCES_TEST_SOURCES
     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
 )
 
 add_executable(xcengine_resources_tests ${RESOURCES_TEST_SOURCES})

tests/Resources/test_audio_loader.cpp

@@ -0,0 +1,37 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/AudioLoader.h>
+#include <XCEngine/Resources/ResourceTypes.h>
+#include <XCEngine/Containers/Array.h>
+
+using namespace XCEngine::Resources;
+using namespace XCEngine::Containers;
+
+namespace {
+
+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/test_file_archive.cpp

@@ -0,0 +1,51 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/FileArchive.h>
+#include <XCEngine/Containers/String.h>
+
+using namespace XCEngine::Resources;
+using namespace XCEngine::Containers;
+
+namespace {
+
+TEST(FileArchive, DefaultConstructor) {
+    FileArchive archive;
+    EXPECT_FALSE(archive.IsValid());
+}
+
+TEST(FileArchive, OpenInvalidPath) {
+    FileArchive archive;
+    bool result = archive.Open("invalid/path/to/archive.zip");
+    EXPECT_TRUE(result);
+    EXPECT_TRUE(archive.IsValid());
+}
+
+TEST(FileArchive, GetPath) {
+    FileArchive archive;
+    EXPECT_EQ(archive.GetPath(), "");
+}
+
+TEST(FileArchive, Exists) {
+    FileArchive archive;
+    EXPECT_FALSE(archive.Exists("test.txt"));
+}
+
+TEST(FileArchive, GetSize) {
+    FileArchive archive;
+    EXPECT_EQ(archive.GetSize("test.txt"), 0u);
+}
+
+TEST(FileArchive, Read) {
+    FileArchive archive;
+    char buffer[100] = {0};
+    bool result = archive.Read("test.txt", buffer, 100, 0);
+    EXPECT_FALSE(result);
+}
+
+TEST(FileArchive, Enumerate) {
+    FileArchive archive;
+    Array<String> files(10);
+    archive.Enumerate("*.txt", files);
+    EXPECT_EQ(files.Size(), 0u);
+}
+
+} // namespace

tests/Resources/test_material.cpp

@@ -0,0 +1,144 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/Material.h>
+#include <XCEngine/Resources/Shader.h>
+#include <XCEngine/Resources/Texture.h>
+#include <XCEngine/Resources/ResourceTypes.h>
+#include <XCEngine/Math/Vector2.h>
+#include <XCEngine/Math/Vector3.h>
+#include <XCEngine/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/test_material_loader.cpp

@@ -0,0 +1,36 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/MaterialLoader.h>
+#include <XCEngine/Resources/ResourceTypes.h>
+#include <XCEngine/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/test_mesh_loader.cpp

@@ -0,0 +1,37 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/MeshLoader.h>
+#include <XCEngine/Resources/ResourceTypes.h>
+#include <XCEngine/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/test_shader.cpp

@@ -0,0 +1,103 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/Shader.h>
+#include <XCEngine/Resources/ResourceTypes.h>
+#include <XCEngine/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/test_shader_loader.cpp

@@ -0,0 +1,38 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/ShaderLoader.h>
+#include <XCEngine/Resources/ResourceTypes.h>
+#include <XCEngine/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/test_texture_loader.cpp

@@ -0,0 +1,37 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Resources/TextureLoader.h>
+#include <XCEngine/Resources/ResourceTypes.h>
+#include <XCEngine/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