From 0b3423966da3618db9f50a65ede51587ccb7c73b Mon Sep 17 00:00:00 2001 From: ssdfasd <2156608475@qq.com> Date: Tue, 24 Mar 2026 15:44:13 +0800 Subject: [PATCH] refactor(tests): reorganize tests directory to match engine structure - Created tests/Core/Asset/ with tests for IResource, ResourceTypes, ResourceHandle, ResourceCache, ResourceDependencyGraph, ResourceGUID - Created tests/Core/IO/ with tests for IResourceLoader, ResourcePath, ResourceFileSystem, FileArchive, ResourcePackage - Reorganized tests/Resources/ into subdirectories: Texture/, Mesh/, Material/, Shader/, AudioClip/ - Added CMakeLists.txt for each new test subdirectory - Fixed Material.h missing ResourceManager.h include (lost during engine refactor) - tests/Core/CMakeLists.txt updated to include Asset/ and IO/ subdirectories --- .../XCEngine/Resources/Material/Material.h | 20 +-- .../Asset}/test_iresource.cpp | 0 .../Asset}/test_resource_cache.cpp | 0 .../Asset}/test_resource_dependency.cpp | 0 .../Asset}/test_resource_guid.cpp | 0 .../Asset}/test_resource_handle.cpp | 0 .../Asset}/test_resource_types.cpp | 0 tests/Resources/AudioClip/CMakeLists.txt | 31 ++++ tests/Resources/AudioClip/test_audio_clip.cpp | 20 +++ .../Resources/AudioClip/test_audio_loader.cpp | 118 ++++++++++++++ tests/Resources/CMakeLists.txt | 55 +------ tests/Resources/Material/CMakeLists.txt | 31 ++++ tests/Resources/Material/test_material.cpp | 144 ++++++++++++++++++ .../Material/test_material_loader.cpp | 36 +++++ tests/Resources/Mesh/CMakeLists.txt | 32 ++++ tests/Resources/Mesh/test_mesh.cpp | 33 ++++ .../Mesh/test_mesh_import_settings.cpp | 104 +++++++++++++ tests/Resources/Mesh/test_mesh_loader.cpp | 37 +++++ tests/Resources/Shader/CMakeLists.txt | 31 ++++ tests/Resources/Shader/test_shader.cpp | 103 +++++++++++++ tests/Resources/Shader/test_shader_loader.cpp | 38 +++++ tests/Resources/Texture/CMakeLists.txt | 32 ++++ tests/Resources/Texture/test_texture.cpp | 37 +++++ .../Texture/test_texture_import_settings.cpp | 119 +++++++++++++++ .../Resources/Texture/test_texture_loader.cpp | 37 +++++ 25 files changed, 999 insertions(+), 59 deletions(-) rename tests/{Resources => Core/Asset}/test_iresource.cpp (100%) rename tests/{Resources => Core/Asset}/test_resource_cache.cpp (100%) rename tests/{Resources => Core/Asset}/test_resource_dependency.cpp (100%) rename tests/{Resources => Core/Asset}/test_resource_guid.cpp (100%) rename tests/{Resources => Core/Asset}/test_resource_handle.cpp (100%) rename tests/{Resources => Core/Asset}/test_resource_types.cpp (100%) create mode 100644 tests/Resources/AudioClip/CMakeLists.txt create mode 100644 tests/Resources/AudioClip/test_audio_clip.cpp create mode 100644 tests/Resources/AudioClip/test_audio_loader.cpp create mode 100644 tests/Resources/Material/CMakeLists.txt create mode 100644 tests/Resources/Material/test_material.cpp create mode 100644 tests/Resources/Material/test_material_loader.cpp create mode 100644 tests/Resources/Mesh/CMakeLists.txt create mode 100644 tests/Resources/Mesh/test_mesh.cpp create mode 100644 tests/Resources/Mesh/test_mesh_import_settings.cpp create mode 100644 tests/Resources/Mesh/test_mesh_loader.cpp create mode 100644 tests/Resources/Shader/CMakeLists.txt create mode 100644 tests/Resources/Shader/test_shader.cpp create mode 100644 tests/Resources/Shader/test_shader_loader.cpp create mode 100644 tests/Resources/Texture/CMakeLists.txt create mode 100644 tests/Resources/Texture/test_texture.cpp create mode 100644 tests/Resources/Texture/test_texture_import_settings.cpp create mode 100644 tests/Resources/Texture/test_texture_loader.cpp diff --git a/engine/include/XCEngine/Resources/Material/Material.h b/engine/include/XCEngine/Resources/Material/Material.h index 56d7f428..bbff7503 100644 --- a/engine/include/XCEngine/Resources/Material/Material.h +++ b/engine/include/XCEngine/Resources/Material/Material.h @@ -1,14 +1,14 @@ #pragma once -#include "IResource.h" -#include "ResourceHandle.h" -#include "ResourceManager.h" -#include "Texture.h" -#include "Shader.h" -#include "../Containers/HashMap.h" -#include "../Core/Types.h" -#include "../Math/Vector2.h" -#include "../Math/Vector3.h" -#include "../Math/Vector4.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include namespace XCEngine { diff --git a/tests/Resources/test_iresource.cpp b/tests/Core/Asset/test_iresource.cpp similarity index 100% rename from tests/Resources/test_iresource.cpp rename to tests/Core/Asset/test_iresource.cpp diff --git a/tests/Resources/test_resource_cache.cpp b/tests/Core/Asset/test_resource_cache.cpp similarity index 100% rename from tests/Resources/test_resource_cache.cpp rename to tests/Core/Asset/test_resource_cache.cpp diff --git a/tests/Resources/test_resource_dependency.cpp b/tests/Core/Asset/test_resource_dependency.cpp similarity index 100% rename from tests/Resources/test_resource_dependency.cpp rename to tests/Core/Asset/test_resource_dependency.cpp diff --git a/tests/Resources/test_resource_guid.cpp b/tests/Core/Asset/test_resource_guid.cpp similarity index 100% rename from tests/Resources/test_resource_guid.cpp rename to tests/Core/Asset/test_resource_guid.cpp diff --git a/tests/Resources/test_resource_handle.cpp b/tests/Core/Asset/test_resource_handle.cpp similarity index 100% rename from tests/Resources/test_resource_handle.cpp rename to tests/Core/Asset/test_resource_handle.cpp diff --git a/tests/Resources/test_resource_types.cpp b/tests/Core/Asset/test_resource_types.cpp similarity index 100% rename from tests/Resources/test_resource_types.cpp rename to tests/Core/Asset/test_resource_types.cpp diff --git a/tests/Resources/AudioClip/CMakeLists.txt b/tests/Resources/AudioClip/CMakeLists.txt new file mode 100644 index 00000000..83bc9f77 --- /dev/null +++ b/tests/Resources/AudioClip/CMakeLists.txt @@ -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) diff --git a/tests/Resources/AudioClip/test_audio_clip.cpp b/tests/Resources/AudioClip/test_audio_clip.cpp new file mode 100644 index 00000000..ce20a02c --- /dev/null +++ b/tests/Resources/AudioClip/test_audio_clip.cpp @@ -0,0 +1,20 @@ +#include +#include +#include +#include + +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 diff --git a/tests/Resources/AudioClip/test_audio_loader.cpp b/tests/Resources/AudioClip/test_audio_loader.cpp new file mode 100644 index 00000000..dff9a8f0 --- /dev/null +++ b/tests/Resources/AudioClip/test_audio_loader.cpp @@ -0,0 +1,118 @@ +#include +#include +#include +#include +#include +#include +#include + +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 wavData(sizeof(WAVFileHeader) + header.dataSize, 0); + std::memcpy(wavData.data(), &header, sizeof(WAVFileHeader)); + + std::ofstream file(filepath, std::ios::binary); + file.write(reinterpret_cast(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(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(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 diff --git a/tests/Resources/CMakeLists.txt b/tests/Resources/CMakeLists.txt index 1c985c7f..f3e8671a 100644 --- a/tests/Resources/CMakeLists.txt +++ b/tests/Resources/CMakeLists.txt @@ -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) diff --git a/tests/Resources/Material/CMakeLists.txt b/tests/Resources/Material/CMakeLists.txt new file mode 100644 index 00000000..72a95ddc --- /dev/null +++ b/tests/Resources/Material/CMakeLists.txt @@ -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) diff --git a/tests/Resources/Material/test_material.cpp b/tests/Resources/Material/test_material.cpp new file mode 100644 index 00000000..9b6d59e5 --- /dev/null +++ b/tests/Resources/Material/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/Material/test_material_loader.cpp b/tests/Resources/Material/test_material_loader.cpp new file mode 100644 index 00000000..47dff409 --- /dev/null +++ b/tests/Resources/Material/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/Mesh/CMakeLists.txt b/tests/Resources/Mesh/CMakeLists.txt new file mode 100644 index 00000000..da35022f --- /dev/null +++ b/tests/Resources/Mesh/CMakeLists.txt @@ -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) diff --git a/tests/Resources/Mesh/test_mesh.cpp b/tests/Resources/Mesh/test_mesh.cpp new file mode 100644 index 00000000..9b852c1d --- /dev/null +++ b/tests/Resources/Mesh/test_mesh.cpp @@ -0,0 +1,33 @@ +#include +#include +#include +#include + +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 diff --git a/tests/Resources/Mesh/test_mesh_import_settings.cpp b/tests/Resources/Mesh/test_mesh_import_settings.cpp new file mode 100644 index 00000000..058df083 --- /dev/null +++ b/tests/Resources/Mesh/test_mesh_import_settings.cpp @@ -0,0 +1,104 @@ +#include +#include +#include +#include + +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(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 diff --git a/tests/Resources/Mesh/test_mesh_loader.cpp b/tests/Resources/Mesh/test_mesh_loader.cpp new file mode 100644 index 00000000..72819983 --- /dev/null +++ b/tests/Resources/Mesh/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/Shader/CMakeLists.txt b/tests/Resources/Shader/CMakeLists.txt new file mode 100644 index 00000000..98faf604 --- /dev/null +++ b/tests/Resources/Shader/CMakeLists.txt @@ -0,0 +1,31 @@ +# ============================================================ +# Shader Tests +# ============================================================ + +set(SHADER_TEST_SOURCES + test_shader.cpp + test_shader_loader.cpp +) + +add_executable(shader_tests ${SHADER_TEST_SOURCES}) + +if(MSVC) + set_target_properties(shader_tests PROPERTIES + LINK_FLAGS "/NODEFAULTLIB:libcpmt.lib /NODEFAULTLIB:libcmt.lib" + ) +endif() + +target_link_libraries(shader_tests + PRIVATE + XCEngine + GTest::gtest + GTest::gtest_main +) + +target_include_directories(shader_tests PRIVATE + ${CMAKE_SOURCE_DIR}/engine/include + ${CMAKE_SOURCE_DIR}/tests/fixtures +) + +include(GoogleTest) +gtest_discover_tests(shader_tests) diff --git a/tests/Resources/Shader/test_shader.cpp b/tests/Resources/Shader/test_shader.cpp new file mode 100644 index 00000000..4caf44dd --- /dev/null +++ b/tests/Resources/Shader/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/Shader/test_shader_loader.cpp b/tests/Resources/Shader/test_shader_loader.cpp new file mode 100644 index 00000000..c43abe5e --- /dev/null +++ b/tests/Resources/Shader/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/Texture/CMakeLists.txt b/tests/Resources/Texture/CMakeLists.txt new file mode 100644 index 00000000..02f673a8 --- /dev/null +++ b/tests/Resources/Texture/CMakeLists.txt @@ -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) diff --git a/tests/Resources/Texture/test_texture.cpp b/tests/Resources/Texture/test_texture.cpp new file mode 100644 index 00000000..78f91290 --- /dev/null +++ b/tests/Resources/Texture/test_texture.cpp @@ -0,0 +1,37 @@ +#include +#include +#include +#include + +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 diff --git a/tests/Resources/Texture/test_texture_import_settings.cpp b/tests/Resources/Texture/test_texture_import_settings.cpp new file mode 100644 index 00000000..0455017f --- /dev/null +++ b/tests/Resources/Texture/test_texture_import_settings.cpp @@ -0,0 +1,119 @@ +#include +#include +#include + +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(cloned.get()); + EXPECT_EQ(clonedSettings->GetTextureType(), TextureType::TextureCube); + EXPECT_TRUE(clonedSettings->GetSRGB()); + EXPECT_EQ(clonedSettings->GetMaxAnisotropy(), 8u); +} + +} // namespace diff --git a/tests/Resources/Texture/test_texture_loader.cpp b/tests/Resources/Texture/test_texture_loader.cpp new file mode 100644 index 00000000..bcfb994e --- /dev/null +++ b/tests/Resources/Texture/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