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

refactor(tests): reorganize tests directory to match engine structure

Browse Source 
- 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
This commit is contained in:
ssdfasd
2026-03-24 15:44:13 +08:00
parent 0345ce50cf
commit 0b3423966d
25 changed files with 999 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
tests/Resources/AudioClip/CMakeLists.txt Normal file
View File

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

20
tests/Resources/AudioClip/test_audio_clip.cpp Normal file
View File

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

118
tests/Resources/AudioClip/test_audio_loader.cpp Normal file
View File

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

55
tests/Resources/CMakeLists.txt
View File

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

31
tests/Resources/Material/CMakeLists.txt Normal file
View File

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

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

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

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

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

32
tests/Resources/Mesh/CMakeLists.txt Normal file
View File

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

33
tests/Resources/Mesh/test_mesh.cpp Normal file
View File

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

104
tests/Resources/Mesh/test_mesh_import_settings.cpp Normal file
View File

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

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

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

31
tests/Resources/Shader/CMakeLists.txt Normal file
View File

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

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

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

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

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

32
tests/Resources/Texture/CMakeLists.txt Normal file
View File

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

37
tests/Resources/Texture/test_texture.cpp Normal file
View File

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

119
tests/Resources/Texture/test_texture_import_settings.cpp Normal file
View File

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

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

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

69
tests/Resources/test_iresource.cpp
View File

@@ -1,69 +0,0 @@
#include <gtest/gtest.h>
#include <XCEngine/Core/Asset/IResource.h>
#include <XCEngine/Core/Asset/ResourceTypes.h>
#include <XCEngine/Core/Containers/String.h>
using namespace XCEngine::Resources;
using namespace XCEngine::Containers;
namespace {
class TestResource : public IResource {
public:
ResourceType GetType() const override { return ResourceType::Texture; }
const String& GetName() const override { return m_name; }
const String& GetPath() const override { return m_path; }
ResourceGUID GetGUID() const override { return m_guid; }
bool IsValid() const override { return m_isValid; }
size_t GetMemorySize() const override { return m_memorySize; }
void Release() override { delete this; }
};
TEST(IResource, Initialize) {
TestResource* resource = new TestResource();
IResource::ConstructParams params;
params.name = "TestTexture";
params.path = "textures/test.png";
params.guid = ResourceGUID(12345);
params.memorySize = 1024;
resource->Initialize(params);
EXPECT_EQ(resource->GetName(), "TestTexture");
EXPECT_EQ(resource->GetPath(), "textures/test.png");
EXPECT_EQ(resource->GetGUID().value, 12345u);
EXPECT_EQ(resource->GetMemorySize(), 1024u);
EXPECT_TRUE(resource->IsValid());
resource->Release();
}
TEST(IResource, SetInvalid) {
TestResource* resource = new TestResource();
IResource::ConstructParams params;
params.name = "Test";
params.path = "test.png";
params.guid = ResourceGUID(1);
params.memorySize = 100;
resource->Initialize(params);
EXPECT_TRUE(resource->IsValid());
resource->SetInvalid();
EXPECT_FALSE(resource->IsValid());
resource->Release();
}
TEST(IResource, DefaultValues) {
TestResource* resource = new TestResource();
EXPECT_EQ(resource->GetMemorySize(), 0u);
EXPECT_FALSE(resource->IsValid());
resource->Release();
}
} // namespace

147
tests/Resources/test_resource_cache.cpp
View File

@@ -1,147 +0,0 @@
#include <gtest/gtest.h>
#include <XCEngine/Core/Asset/ResourceCache.h>
#include <XCEngine/Core/Asset/IResource.h>
#include <XCEngine/Core/Asset/ResourceTypes.h>
#include <XCEngine/Core/Asset/ResourceManager.h>
#include <XCEngine/Core/Containers/String.h>
using namespace XCEngine::Resources;
using namespace XCEngine::Containers;
namespace {
class TestResource : public IResource {
public:
ResourceType GetType() const override { return ResourceType::Texture; }
const String& GetName() const override { return m_name; }
const String& GetPath() const override { return m_path; }
ResourceGUID GetGUID() const override { return m_guid; }
bool IsValid() const override { return m_isValid; }
size_t GetMemorySize() const override { return m_memorySize; }
void Release() override { delete this; }
};
TEST(ResourceCache, AddAndFind) {
ResourceCache cache;
TestResource* resource = new TestResource();
resource->Initialize({ "Test", "test.png", ResourceGUID(100), 1024 });
ResourceGUID guid(100);
cache.Add(guid, resource);
IResource* found = cache.Find(guid);
EXPECT_EQ(found, resource);
cache.Remove(guid);
found = cache.Find(guid);
EXPECT_EQ(found, nullptr);
}
TEST(ResourceCache, GetSize) {
ResourceCache cache;
EXPECT_EQ(cache.GetSize(), 0u);
TestResource* resource1 = new TestResource();
resource1->Initialize({ "Test1", "test1.png", ResourceGUID(1), 100 });
cache.Add(ResourceGUID(1), resource1);
EXPECT_EQ(cache.GetSize(), 1u);
TestResource* resource2 = new TestResource();
resource2->Initialize({ "Test2", "test2.png", ResourceGUID(2), 200 });
cache.Add(ResourceGUID(2), resource2);
EXPECT_EQ(cache.GetSize(), 2u);
}
TEST(ResourceCache, GetMemoryUsage) {
ResourceCache cache;
EXPECT_EQ(cache.GetMemoryUsage(), 0u);
TestResource* resource1 = new TestResource();
resource1->Initialize({ "Test1", "test1.png", ResourceGUID(1), 100 });
cache.Add(ResourceGUID(1), resource1);
EXPECT_EQ(cache.GetMemoryUsage(), 100u);
TestResource* resource2 = new TestResource();
resource2->Initialize({ "Test2", "test2.png", ResourceGUID(2), 200 });
cache.Add(ResourceGUID(2), resource2);
EXPECT_EQ(cache.GetMemoryUsage(), 300u);
}
TEST(ResourceCache, SetMemoryBudget) {
ResourceCache cache;
EXPECT_EQ(cache.GetMemoryBudget(), 512 * 1024 * 1024u);
cache.SetMemoryBudget(1024);
EXPECT_EQ(cache.GetMemoryBudget(), 1024u);
}
TEST(ResourceCache, Touch) {
ResourceCache cache;
TestResource* resource = new TestResource();
resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
ResourceGUID guid(100);
cache.Add(guid, resource);
cache.Touch(guid);
IResource* found = cache.Find(guid);
EXPECT_EQ(found, resource);
}
TEST(ResourceCache, Clear) {
ResourceCache cache;
TestResource* resource1 = new TestResource();
resource1->Initialize({ "Test1", "test1.png", ResourceGUID(1), 100 });
cache.Add(ResourceGUID(1), resource1);
TestResource* resource2 = new TestResource();
resource2->Initialize({ "Test2", "test2.png", ResourceGUID(2), 200 });
cache.Add(ResourceGUID(2), resource2);
EXPECT_EQ(cache.GetSize(), 2u);
cache.Clear();
EXPECT_EQ(cache.GetSize(), 0u);
EXPECT_EQ(cache.GetMemoryUsage(), 0u);
}
TEST(ResourceCache, OnMemoryPressure) {
ResourceCache cache;
cache.SetMemoryBudget(150);
TestResource* resource1 = new TestResource();
resource1->Initialize({ "Test1", "test1.png", ResourceGUID(1), 100 });
cache.Add(ResourceGUID(1), resource1);
EXPECT_EQ(cache.GetMemoryUsage(), 100u);
TestResource* resource2 = new TestResource();
resource2->Initialize({ "Test2", "test2.png", ResourceGUID(2), 100 });
cache.Add(ResourceGUID(2), resource2);
EXPECT_EQ(cache.GetMemoryUsage(), 200u);
cache.OnMemoryPressure(50);
EXPECT_LE(cache.GetMemoryUsage(), 150u);
}
TEST(ResourceCache, GetLRUList) {
ResourceCache cache;
TestResource* resource1 = new TestResource();
resource1->Initialize({ "Test1", "test1.png", ResourceGUID(1), 100 });
cache.Add(ResourceGUID(1), resource1);
TestResource* resource2 = new TestResource();
resource2->Initialize({ "Test2", "test2.png", ResourceGUID(2), 200 });
cache.Add(ResourceGUID(2), resource2);
auto lruList = cache.GetLRUList(2);
EXPECT_GE(lruList.Size(), 0u);
}
} // namespace

131
tests/Resources/test_resource_dependency.cpp
View File

@@ -1,131 +0,0 @@
#include <gtest/gtest.h>
#include <XCEngine/Core/Asset/ResourceDependencyGraph.h>
#include <XCEngine/Core/Asset/ResourceTypes.h>
using namespace XCEngine::Resources;
using namespace XCEngine::Containers;
namespace {
TEST(ResourceDependencyGraph, DefaultConstructor) {
ResourceDependencyGraph graph;
}
TEST(ResourceDependencyGraph, AddNode) {
ResourceDependencyGraph graph;
graph.AddNode(ResourceGUID(1), ResourceType::Texture);
EXPECT_TRUE(graph.HasNode(ResourceGUID(1)));
}
TEST(ResourceDependencyGraph, AddMultipleNodes) {
ResourceDependencyGraph graph;
graph.AddNode(ResourceGUID(1), ResourceType::Texture);
graph.AddNode(ResourceGUID(2), ResourceType::Mesh);
graph.AddNode(ResourceGUID(3), ResourceType::Material);
EXPECT_TRUE(graph.HasNode(ResourceGUID(1)));
EXPECT_TRUE(graph.HasNode(ResourceGUID(2)));
EXPECT_TRUE(graph.HasNode(ResourceGUID(3)));
}
TEST(ResourceDependencyGraph, RemoveNode) {
ResourceDependencyGraph graph;
graph.AddNode(ResourceGUID(1), ResourceType::Texture);
EXPECT_TRUE(graph.HasNode(ResourceGUID(1)));
graph.RemoveNode(ResourceGUID(1));
EXPECT_FALSE(graph.HasNode(ResourceGUID(1)));
}
TEST(ResourceDependencyGraph, AddDependency) {
ResourceDependencyGraph graph;
graph.AddNode(ResourceGUID(1), ResourceType::Material);
graph.AddNode(ResourceGUID(2), ResourceType::Texture);
graph.AddDependency(ResourceGUID(1), ResourceGUID(2));
auto deps = graph.GetDependencies(ResourceGUID(1));
EXPECT_EQ(deps.Size(), 1u);
EXPECT_EQ(deps[0], ResourceGUID(2));
}
TEST(ResourceDependencyGraph, GetDependents) {
ResourceDependencyGraph graph;
graph.AddNode(ResourceGUID(1), ResourceType::Material);
graph.AddNode(ResourceGUID(2), ResourceType::Texture);
graph.AddDependency(ResourceGUID(1), ResourceGUID(2));
auto dependents = graph.GetDependents(ResourceGUID(2));
EXPECT_EQ(dependents.Size(), 1u);
EXPECT_EQ(dependents[0], ResourceGUID(1));
}
TEST(ResourceDependencyGraph, GetAllDependencies) {
ResourceDependencyGraph graph;
graph.AddNode(ResourceGUID(1), ResourceType::Material);
graph.AddNode(ResourceGUID(2), ResourceType::Texture);
graph.AddNode(ResourceGUID(3), ResourceType::Shader);
graph.AddDependency(ResourceGUID(1), ResourceGUID(2));
graph.AddDependency(ResourceGUID(1), ResourceGUID(3));
auto allDeps = graph.GetAllDependencies(ResourceGUID(1));
EXPECT_EQ(allDeps.Size(), 2u);
}
TEST(ResourceDependencyGraph, RefCount) {
ResourceDependencyGraph graph;
graph.AddNode(ResourceGUID(1), ResourceType::Texture);
EXPECT_EQ(graph.GetRefCount(ResourceGUID(1)), 0u);
graph.IncrementRefCount(ResourceGUID(1));
EXPECT_EQ(graph.GetRefCount(ResourceGUID(1)), 1u);
graph.IncrementRefCount(ResourceGUID(1));
EXPECT_EQ(graph.GetRefCount(ResourceGUID(1)), 2u);
graph.DecrementRefCount(ResourceGUID(1));
EXPECT_EQ(graph.GetRefCount(ResourceGUID(1)), 1u);
}
TEST(ResourceDependencyGraph, Unload) {
ResourceDependencyGraph graph;
graph.AddNode(ResourceGUID(1), ResourceType::Texture);
EXPECT_TRUE(graph.Unload(ResourceGUID(1)));
graph.IncrementRefCount(ResourceGUID(1));
EXPECT_FALSE(graph.Unload(ResourceGUID(1)));
}
TEST(ResourceDependencyGraph, Clear) {
ResourceDependencyGraph graph;
graph.AddNode(ResourceGUID(1), ResourceType::Texture);
graph.AddNode(ResourceGUID(2), ResourceType::Mesh);
EXPECT_TRUE(graph.HasNode(ResourceGUID(1)));
EXPECT_TRUE(graph.HasNode(ResourceGUID(2)));
graph.Clear();
EXPECT_FALSE(graph.HasNode(ResourceGUID(1)));
EXPECT_FALSE(graph.HasNode(ResourceGUID(2)));
}
TEST(ResourceDependencyGraph, RemoveDependency) {
ResourceDependencyGraph graph;
graph.AddNode(ResourceGUID(1), ResourceType::Material);
graph.AddNode(ResourceGUID(2), ResourceType::Texture);
graph.AddDependency(ResourceGUID(1), ResourceGUID(2));
auto deps = graph.GetDependencies(ResourceGUID(1));
EXPECT_EQ(deps.Size(), 1u);
graph.RemoveDependency(ResourceGUID(1), ResourceGUID(2));
deps = graph.GetDependencies(ResourceGUID(1));
EXPECT_EQ(deps.Size(), 0u);
}
} // namespace

64
tests/Resources/test_resource_guid.cpp
View File

@@ -1,64 +0,0 @@
#include <gtest/gtest.h>
#include <XCEngine/Core/Asset/ResourceTypes.h>
#include <XCEngine/Core/Containers/String.h>
using namespace XCEngine::Resources;
using namespace XCEngine::Containers;
namespace {
TEST(Resources_GUID, DefaultConstructor) {
ResourceGUID guid;
EXPECT_FALSE(guid.IsValid());
EXPECT_EQ(guid.value, 0);
}
TEST(Resources_GUID, ValueConstructor) {
ResourceGUID guid(12345);
EXPECT_TRUE(guid.IsValid());
EXPECT_EQ(guid.value, 12345);
}
TEST(Resources_GUID, Generate_FromCString) {
ResourceGUID guid1 = ResourceGUID::Generate("textures/player.png");
ResourceGUID guid2 = ResourceGUID::Generate("textures/player.png");
EXPECT_EQ(guid1, guid2);
EXPECT_TRUE(guid1.IsValid());
}
TEST(Resources_GUID, Generate_FromString) {
String path = "models/player.fbx";
ResourceGUID guid = ResourceGUID::Generate(path);
EXPECT_TRUE(guid.IsValid());
}
TEST(Resources_GUID, Generate_DifferentPaths) {
ResourceGUID guid1 = ResourceGUID::Generate("textures/a.png");
ResourceGUID guid2 = ResourceGUID::Generate("textures/b.png");
EXPECT_NE(guid1, guid2);
}
TEST(Resources_GUID, ToString) {
ResourceGUID guid(0x1234567890ABCDEF);
String str = guid.ToString();
EXPECT_EQ(str.Length(), 16u);
}
TEST(Resources_GUID, MakeResourceGUID_Helper) {
ResourceGUID guid = MakeResourceGUID("test/path");
EXPECT_TRUE(guid.IsValid());
}
TEST(Resources_GUID, EqualityOperators) {
ResourceGUID guid1(100);
ResourceGUID guid2(100);
ResourceGUID guid3(200);
EXPECT_TRUE(guid1 == guid2);
EXPECT_TRUE(guid1 != guid3);
}
} // namespace

194
tests/Resources/test_resource_handle.cpp
View File

@@ -1,194 +0,0 @@
#include <gtest/gtest.h>
#include <XCEngine/Core/Asset/ResourceHandle.h>
#include <XCEngine/Core/Asset/IResource.h>
#include <XCEngine/Core/Asset/ResourceTypes.h>
#include <XCEngine/Core/Asset/ResourceManager.h>
#include <XCEngine/Core/Containers/String.h>
using namespace XCEngine::Resources;
using namespace XCEngine::Containers;
namespace {
class TestResource : public IResource {
public:
ResourceType GetType() const override { return ResourceType::Texture; }
const String& GetName() const override { return m_name; }
const String& GetPath() const override { return m_path; }
ResourceGUID GetGUID() const override { return m_guid; }
bool IsValid() const override { return m_isValid; }
size_t GetMemorySize() const override { return m_memorySize; }
void Release() override {
m_released = true;
}
bool m_released = false;
};
TEST(ResourceHandle, DefaultConstructor) {
ResourceHandle<TestResource> handle;
EXPECT_FALSE(handle.IsValid());
EXPECT_EQ(handle.Get(), nullptr);
}
TEST(ResourceHandle, PointerConstructor) {
TestResource* resource = new TestResource();
resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
ResourceHandle<TestResource> handle(resource);
EXPECT_TRUE(handle.IsValid());
EXPECT_EQ(handle.Get(), resource);
EXPECT_EQ(handle->GetName(), "Test");
handle.Reset();
EXPECT_FALSE(handle.IsValid());
}
TEST(ResourceHandle, CopyConstructor) {
TestResource* resource = new TestResource();
resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
ResourceHandle<TestResource> handle1(resource);
ResourceHandle<TestResource> handle2(handle1);
EXPECT_TRUE(handle1.IsValid());
EXPECT_TRUE(handle2.IsValid());
EXPECT_EQ(handle1.Get(), handle2.Get());
handle1.Reset();
EXPECT_TRUE(handle2.IsValid());
handle2.Reset();
EXPECT_FALSE(handle1.IsValid());
EXPECT_FALSE(handle2.IsValid());
}
TEST(ResourceHandle, MoveConstructor) {
TestResource* resource = new TestResource();
resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
ResourceHandle<TestResource> handle1(resource);
ResourceHandle<TestResource> handle2(std::move(handle1));
EXPECT_FALSE(handle1.IsValid());
EXPECT_TRUE(handle2.IsValid());
EXPECT_EQ(handle2.Get(), resource);
handle2.Reset();
}
TEST(ResourceHandle, AssignmentOperator) {
TestResource* resource = new TestResource();
resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
ResourceHandle<TestResource> handle1(resource);
EXPECT_TRUE(handle1.IsValid());
ResourceHandle<TestResource> handle2;
handle2 = handle1;
EXPECT_TRUE(handle2.IsValid());
EXPECT_EQ(handle1.Get(), handle2.Get());
handle1.Reset();
EXPECT_TRUE(handle2.IsValid());
handle2.Reset();
}
TEST(ResourceHandle, MoveAssignment) {
TestResource* resource = new TestResource();
resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
ResourceHandle<TestResource> handle1(resource);
ResourceHandle<TestResource> handle2;
handle2 = std::move(handle1);
EXPECT_FALSE(handle1.IsValid());
EXPECT_TRUE(handle2.IsValid());
handle2.Reset();
}
TEST(ResourceHandle, GetGUID) {
TestResource* resource = new TestResource();
resource->Initialize({ "Test", "test.png", ResourceGUID(12345), 100 });
ResourceHandle<TestResource> handle(resource);
EXPECT_EQ(handle.GetGUID().value, 12345u);
ResourceHandle<TestResource> emptyHandle;
EXPECT_EQ(emptyHandle.GetGUID().value, 0u);
handle.Reset();
}
TEST(ResourceHandle, GetResourceType) {
TestResource* resource = new TestResource();
resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
ResourceHandle<TestResource> handle(resource);
EXPECT_EQ(handle.GetResourceType(), ResourceType::Texture);
ResourceHandle<TestResource> emptyHandle;
EXPECT_EQ(emptyHandle.GetResourceType(), ResourceType::Unknown);
handle.Reset();
}
TEST(ResourceHandle, BoolOperator) {
TestResource* resource = new TestResource();
resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
ResourceHandle<TestResource> handle(resource);
if (handle) {
EXPECT_TRUE(true);
} else {
EXPECT_TRUE(false);
}
handle.Reset();
if (handle) {
EXPECT_TRUE(false);
} else {
EXPECT_TRUE(true);
}
}
TEST(ResourceHandle, Swap) {
TestResource* resource1 = new TestResource();
resource1->Initialize({ "Test1", "test1.png", ResourceGUID(100), 100 });
TestResource* resource2 = new TestResource();
resource2->Initialize({ "Test2", "test2.png", ResourceGUID(200), 200 });
ResourceHandle<TestResource> handle1(resource1);
ResourceHandle<TestResource> handle2(resource2);
handle1.Swap(handle2);
EXPECT_EQ(handle1.Get(), resource2);
EXPECT_EQ(handle2.Get(), resource1);
handle1.Reset();
handle2.Reset();
}
TEST(ResourceHandle, EqualityOperators) {
TestResource* resource = new TestResource();
resource->Initialize({ "Test", "test.png", ResourceGUID(100), 100 });
ResourceHandle<TestResource> handle1(resource);
ResourceHandle<TestResource> handle2(handle1);
EXPECT_TRUE(handle1 == handle2);
EXPECT_FALSE(handle1 != handle2);
ResourceHandle<TestResource> handle3;
EXPECT_FALSE(handle1 == handle3);
EXPECT_TRUE(handle1 != handle3);
handle1.Reset();
handle2.Reset();
}
} // namespace

35
tests/Resources/test_resource_types.cpp
View File

@@ -1,35 +0,0 @@
#include <gtest/gtest.h>
#include <XCEngine/Core/Asset/ResourceTypes.h>
#include <XCEngine/Core/Types.h>
using namespace XCEngine::Resources;
namespace {
TEST(Resources_Types, ResourceType_EnumValues) {
EXPECT_EQ(static_cast<uint8_t>(ResourceType::Unknown), 0);
EXPECT_EQ(static_cast<uint8_t>(ResourceType::Texture), 1);
EXPECT_EQ(static_cast<uint8_t>(ResourceType::Mesh), 2);
EXPECT_EQ(static_cast<uint8_t>(ResourceType::Material), 3);
EXPECT_EQ(static_cast<uint8_t>(ResourceType::Shader), 4);
EXPECT_EQ(static_cast<uint8_t>(ResourceType::AudioClip), 5);
EXPECT_EQ(static_cast<uint8_t>(ResourceType::Binary), 6);
}
TEST(Resources_Types, GetResourceTypeName) {
EXPECT_STREQ(GetResourceTypeName(ResourceType::Texture), "Texture");
EXPECT_STREQ(GetResourceTypeName(ResourceType::Mesh), "Mesh");
EXPECT_STREQ(GetResourceTypeName(ResourceType::Material), "Material");
EXPECT_STREQ(GetResourceTypeName(ResourceType::Unknown), "Unknown");
}
TEST(Resources_Types, GetResourceType_TemplateSpecializations) {
EXPECT_EQ(GetResourceType<Texture>(), ResourceType::Texture);
EXPECT_EQ(GetResourceType<Mesh>(), ResourceType::Mesh);
EXPECT_EQ(GetResourceType<Material>(), ResourceType::Material);
EXPECT_EQ(GetResourceType<Shader>(), ResourceType::Shader);
EXPECT_EQ(GetResourceType<AudioClip>(), ResourceType::AudioClip);
EXPECT_EQ(GetResourceType<BinaryResource>(), ResourceType::Binary);
}
} // namespace