From 02ca59edf6a95f54ac236ef4ecb556a1aae11d1a Mon Sep 17 00:00:00 2001 From: ssdfasd <2156608475@qq.com> Date: Wed, 18 Mar 2026 00:09:06 +0800 Subject: [PATCH] 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 --- engine/CMakeLists.txt | 1 + engine/src/Resources/IResourceLoader.cpp | 42 +++++++ tests/Resources/CMakeLists.txt | 9 ++ tests/Resources/test_audio_loader.cpp | 37 ++++++ tests/Resources/test_file_archive.cpp | 51 ++++++++ tests/Resources/test_material.cpp | 144 +++++++++++++++++++++++ tests/Resources/test_material_loader.cpp | 36 ++++++ tests/Resources/test_mesh_loader.cpp | 37 ++++++ tests/Resources/test_shader.cpp | 103 ++++++++++++++++ tests/Resources/test_shader_loader.cpp | 38 ++++++ tests/Resources/test_texture_loader.cpp | 37 ++++++ 11 files changed, 535 insertions(+) create mode 100644 engine/src/Resources/IResourceLoader.cpp create mode 100644 tests/Resources/test_audio_loader.cpp create mode 100644 tests/Resources/test_file_archive.cpp create mode 100644 tests/Resources/test_material.cpp create mode 100644 tests/Resources/test_material_loader.cpp create mode 100644 tests/Resources/test_mesh_loader.cpp create mode 100644 tests/Resources/test_shader.cpp create mode 100644 tests/Resources/test_shader_loader.cpp create mode 100644 tests/Resources/test_texture_loader.cpp diff --git a/engine/CMakeLists.txt b/engine/CMakeLists.txt index e995233f..2bdcfc32 100644 --- a/engine/CMakeLists.txt +++ b/engine/CMakeLists.txt @@ -176,6 +176,7 @@ add_library(XCEngine STATIC ${CMAKE_CURRENT_SOURCE_DIR}/src/Resources/ResourceCache.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/Resources/AsyncLoader.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/Resources/ResourceTypes.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/src/Resources/IResourceLoader.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/Resources/Texture.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/Resources/Mesh.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/Resources/TextureLoader.cpp diff --git a/engine/src/Resources/IResourceLoader.cpp b/engine/src/Resources/IResourceLoader.cpp new file mode 100644 index 00000000..c57b5a22 --- /dev/null +++ b/engine/src/Resources/IResourceLoader.cpp @@ -0,0 +1,42 @@ +#include "XCEngine/Resources/IResourceLoader.h" +#include + +namespace XCEngine { +namespace Resources { + +Containers::Array IResourceLoader::ReadFileData(const Containers::String& path) { + Containers::Array data; + + std::ifstream file(path.CStr(), std::ios::binary | std::ios::ate); + if (!file.is_open()) { + return data; + } + + std::streamsize size = file.tellg(); + file.seekg(0, std::ios::beg); + + data.Resize(static_cast(size)); + if (!file.read(reinterpret_cast(data.Data()), size)) { + data.Clear(); + } + + return data; +} + +Containers::String IResourceLoader::GetExtension(const Containers::String& path) { + Containers::String ext; + size_t dotPos = Containers::String::npos; + for (size_t i = path.Length(); i > 0; --i) { + if (path[i - 1] == '.') { + dotPos = i - 1; + break; + } + } + if (dotPos != Containers::String::npos) { + ext = path.Substring(dotPos + 1); + } + return ext; +} + +} // namespace Resources +} // namespace XCEngine diff --git a/tests/Resources/CMakeLists.txt b/tests/Resources/CMakeLists.txt index f919d4db..5e58e6b9 100644 --- a/tests/Resources/CMakeLists.txt +++ b/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}) diff --git a/tests/Resources/test_audio_loader.cpp b/tests/Resources/test_audio_loader.cpp new file mode 100644 index 00000000..7d8dd17d --- /dev/null +++ b/tests/Resources/test_audio_loader.cpp @@ -0,0 +1,37 @@ +#include +#include +#include +#include + +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 diff --git a/tests/Resources/test_file_archive.cpp b/tests/Resources/test_file_archive.cpp new file mode 100644 index 00000000..e92532c5 --- /dev/null +++ b/tests/Resources/test_file_archive.cpp @@ -0,0 +1,51 @@ +#include +#include +#include + +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 files(10); + archive.Enumerate("*.txt", files); + EXPECT_EQ(files.Size(), 0u); +} + +} // namespace diff --git a/tests/Resources/test_material.cpp b/tests/Resources/test_material.cpp new file mode 100644 index 00000000..165a27a8 --- /dev/null +++ b/tests/Resources/test_material.cpp @@ -0,0 +1,144 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +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 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 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 diff --git a/tests/Resources/test_material_loader.cpp b/tests/Resources/test_material_loader.cpp new file mode 100644 index 00000000..dde118bf --- /dev/null +++ b/tests/Resources/test_material_loader.cpp @@ -0,0 +1,36 @@ +#include +#include +#include +#include + +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 diff --git a/tests/Resources/test_mesh_loader.cpp b/tests/Resources/test_mesh_loader.cpp new file mode 100644 index 00000000..7d5b570b --- /dev/null +++ b/tests/Resources/test_mesh_loader.cpp @@ -0,0 +1,37 @@ +#include +#include +#include +#include + +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 diff --git a/tests/Resources/test_shader.cpp b/tests/Resources/test_shader.cpp new file mode 100644 index 00000000..ebec54e9 --- /dev/null +++ b/tests/Resources/test_shader.cpp @@ -0,0 +1,103 @@ +#include +#include +#include +#include + +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 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 diff --git a/tests/Resources/test_shader_loader.cpp b/tests/Resources/test_shader_loader.cpp new file mode 100644 index 00000000..34d2d404 --- /dev/null +++ b/tests/Resources/test_shader_loader.cpp @@ -0,0 +1,38 @@ +#include +#include +#include +#include + +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 diff --git a/tests/Resources/test_texture_loader.cpp b/tests/Resources/test_texture_loader.cpp new file mode 100644 index 00000000..2d93b789 --- /dev/null +++ b/tests/Resources/test_texture_loader.cpp @@ -0,0 +1,37 @@ +#include +#include +#include +#include + +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