xuanchi/XCEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
- 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
This commit is contained in:
ssdfasd
2026-03-18 00:09:06 +08:00
parent 640557cbb5
commit 02ca59edf6
11 changed files with 535 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
engine/CMakeLists.txt
View File

@@ -176,6 +176,7 @@ add_library(XCEngine STATIC
${CMAKE_CURRENT_SOURCE_DIR}/src/Resources/ResourceCache.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/Resources/ResourceCache.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Resources/AsyncLoader.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/Resources/AsyncLoader.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Resources/ResourceTypes.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/Texture.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Resources/Mesh.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/Resources/Mesh.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Resources/TextureLoader.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/Resources/TextureLoader.cpp

42
engine/src/Resources/IResourceLoader.cpp Normal file
View File

@@ -0,0 +1,42 @@
#include "XCEngine/Resources/IResourceLoader.h"
#include <fstream>
namespace XCEngine {
namespace Resources {
Containers::Array<Core::uint8> IResourceLoader::ReadFileData(const Containers::String& path) {
Containers::Array<Core::uint8> 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_t>(size));
if (!file.read(reinterpret_cast<char*>(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

9
tests/Resources/CMakeLists.txt
View File

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

37
tests/Resources/test_audio_loader.cpp Normal file
View File

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

51
tests/Resources/test_file_archive.cpp Normal file
View File

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

144
tests/Resources/test_material.cpp Normal file
View File

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

36
tests/Resources/test_material_loader.cpp Normal file
View File

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

37
tests/Resources/test_mesh_loader.cpp Normal file
View File

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

103
tests/Resources/test_shader.cpp Normal file
View File

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

38
tests/Resources/test_shader_loader.cpp Normal file
View File

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

37
tests/Resources/test_texture_loader.cpp Normal file
View File

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