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

docs: update TEST_SPEC.md and README.md to reflect new directory structure

Browse Source 
- TEST_SPEC.md: Updated test directory structure to reflect Core/Asset,
  Core/IO, and Resources/<Type> subdirectories
- TEST_SPEC.md: Updated module names and test counts (852 total)
- TEST_SPEC.md: Updated build commands for new Resources subdirectories
- README.md: Updated engine structure with Core/Asset/ and Core/IO/
- README.md: Updated Resources section with layered architecture
- README.md: Updated test coverage table with accurate counts
This commit is contained in:
ssdfasd
2026-03-24 16:14:05 +08:00
parent 0b3423966d
commit d575532966
153 changed files with 13975 additions and 6085 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
tests/Resources/test_audio_clip.cpp
View File

@@ -1,20 +0,0 @@
#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/test_audio_loader.cpp
View File

@@ -1,118 +0,0 @@
#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

51
tests/Resources/test_file_archive.cpp
View File

@@ -1,51 +0,0 @@
#include <gtest/gtest.h>
#include <XCEngine/Core/IO/FileArchive.h>
#include <XCEngine/Core/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

39
tests/Resources/test_iresource_loader.cpp
View File

@@ -1,39 +0,0 @@
#include <gtest/gtest.h>
#include <XCEngine/Core/IO/IResourceLoader.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 {
TEST(LoadResult, DefaultConstructor) {
LoadResult result;
EXPECT_FALSE(result.success);
EXPECT_EQ(result.resource, nullptr);
EXPECT_FALSE(result);
}
TEST(LoadResult, FromBool) {
LoadResult result(true);
EXPECT_TRUE(result.success);
}
TEST(LoadResult, FromErrorString) {
XCEngine::Containers::String errorMsg = "Error loading file";
LoadResult result(errorMsg);
EXPECT_FALSE(result.success);
EXPECT_STREQ(result.errorMessage.CStr(), "Error loading file");
}
TEST(LoadResult, BoolOperator) {
LoadResult emptyResult;
EXPECT_FALSE(emptyResult);
LoadResult errorResult("error");
EXPECT_FALSE(errorResult);
}
} // namespace

144
tests/Resources/test_material.cpp
View File

@@ -1,144 +0,0 @@
#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/test_material_loader.cpp
View File

@@ -1,36 +0,0 @@
#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

33
tests/Resources/test_mesh.cpp
View File

@@ -1,33 +0,0 @@
#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/test_mesh_import_settings.cpp
View File

@@ -1,104 +0,0 @@
#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/test_mesh_loader.cpp
View File

@@ -1,37 +0,0 @@
#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

41
tests/Resources/test_resource_filesystem.cpp
View File

@@ -1,41 +0,0 @@
#include <gtest/gtest.h>
#include <XCEngine/Core/IO/ResourceFileSystem.h>
#include <XCEngine/Core/Containers/String.h>
using namespace XCEngine::Resources;
using namespace XCEngine::Containers;
namespace {
TEST(ResourceFileSystem, GetSingleton) {
ResourceFileSystem& fs = ResourceFileSystem::Get();
EXPECT_EQ(&fs, &ResourceFileSystem::Get());
}
TEST(ResourceFileSystem, Initialize) {
ResourceFileSystem fs;
fs.Initialize("test/path");
fs.Shutdown();
}
TEST(ResourceFileSystem, AddDirectory) {
ResourceFileSystem fs;
fs.Initialize("test/path");
bool result = fs.AddDirectory("textures");
EXPECT_TRUE(result);
fs.Shutdown();
}
TEST(ResourceFileSystem, Exists) {
ResourceFileSystem fs;
fs.Initialize("test/path");
bool exists = fs.Exists("test.txt");
EXPECT_TRUE(exists);
fs.Shutdown();
}
} // namespace

75
tests/Resources/test_resource_package.cpp
View File

@@ -1,75 +0,0 @@
#include <gtest/gtest.h>
#include <XCEngine/Core/IO/ResourcePackage.h>
#include <XCEngine/Core/Containers/Array.h>
#include <XCEngine/Core/Types.h>
using namespace XCEngine::Resources;
using namespace XCEngine::Containers;
using namespace XCEngine::Core;
namespace {
TEST(ResourcePackageBuilder, DefaultConstructor) {
ResourcePackageBuilder builder;
EXPECT_TRUE(builder.GetOutputPath().Empty());
EXPECT_EQ(builder.GetProgress(), 0.0f);
}
TEST(ResourcePackageBuilder, SetOutputPath) {
ResourcePackageBuilder builder;
builder.SetOutputPath("test.pkg");
EXPECT_EQ(builder.GetOutputPath(), "test.pkg");
}
TEST(ResourcePackageBuilder, AddFile) {
ResourcePackageBuilder builder;
builder.SetOutputPath("test.pkg");
bool result = builder.AddFile("nonexistent.txt", "test.txt");
EXPECT_FALSE(result);
}
TEST(ResourcePackageBuilder, BuildWithoutFiles) {
ResourcePackageBuilder builder;
builder.SetOutputPath("test.pkg");
bool result = builder.Build();
EXPECT_FALSE(result);
}
TEST(ResourcePackage, DefaultConstructor) {
ResourcePackage pkg;
EXPECT_FALSE(pkg.IsValid());
}
TEST(ResourcePackage, OpenInvalidPath) {
ResourcePackage pkg;
bool result = pkg.Open("invalid/path/package.pkg");
EXPECT_FALSE(result);
EXPECT_FALSE(pkg.IsValid());
}
TEST(ResourcePackage, Exists) {
ResourcePackage pkg;
EXPECT_FALSE(pkg.Exists("test.txt"));
}
TEST(ResourcePackage, GetSize) {
ResourcePackage pkg;
EXPECT_EQ(pkg.GetSize("test.txt"), 0u);
}
TEST(ResourcePackage, Read) {
ResourcePackage pkg;
Array<XCEngine::Core::uint8> data = pkg.Read("test.txt");
EXPECT_EQ(data.Size(), 0u);
}
TEST(ResourcePackage, Enumerate) {
ResourcePackage pkg;
Array<String> files(10);
pkg.Enumerate("*.txt", files);
EXPECT_EQ(files.Size(), 0u);
}
} // namespace

110
tests/Resources/test_resource_path.cpp
View File

@@ -1,110 +0,0 @@
#include <gtest/gtest.h>
#include <XCEngine/Core/IO/ResourcePath.h>
#include <XCEngine/Core/Asset/ResourceTypes.h>
#include <XCEngine/Core/Containers/String.h>
using namespace XCEngine::Resources;
using namespace XCEngine::Containers;
namespace {
TEST(ResourcePath, DefaultConstructor) {
ResourcePath path;
EXPECT_FALSE(path.IsValid());
}
TEST(ResourcePath, ConstructorWithCString) {
ResourcePath path("textures/player.png");
EXPECT_TRUE(path.IsValid());
EXPECT_EQ(path.GetPath(), "textures/player.png");
}
TEST(ResourcePath, ConstructorWithString) {
String str = "models/player.fbx";
ResourcePath path(str);
EXPECT_TRUE(path.IsValid());
EXPECT_EQ(path.GetPath(), str);
}
TEST(ResourcePath, GetExtension) {
ResourcePath path("textures/player.png");
EXPECT_EQ(path.GetExtension(), ".png");
}
TEST(ResourcePath, GetExtensionNoExtension) {
ResourcePath path("textures/player");
EXPECT_TRUE(path.GetExtension().Empty());
}
TEST(ResourcePath, GetStem) {
ResourcePath path("textures/player.png");
EXPECT_EQ(path.GetStem(), "player");
}
TEST(ResourcePath, GetStemNoExtension) {
ResourcePath path("textures/player");
EXPECT_EQ(path.GetStem(), "player");
}
TEST(ResourcePath, GetFileName) {
ResourcePath path("textures/player.png");
EXPECT_EQ(path.GetFileName(), "player.png");
}
TEST(ResourcePath, GetDirectory) {
ResourcePath path("textures/player.png");
EXPECT_EQ(path.GetDirectory(), "textures");
}
TEST(ResourcePath, GetDirectoryWithBackslash) {
ResourcePath path("textures\\player.png");
EXPECT_EQ(path.GetDirectory(), "textures");
}
TEST(ResourcePath, GetFullPath) {
ResourcePath path("textures/player.png");
EXPECT_EQ(path.GetFullPath(), "textures/player.png");
}
TEST(ResourcePath, HasExtension) {
ResourcePath path("textures/player.png");
EXPECT_TRUE(path.HasExtension(".png"));
EXPECT_FALSE(path.HasExtension(".jpg"));
}
TEST(ResourcePath, HasExtensionNoExtension) {
ResourcePath path("textures/player");
EXPECT_FALSE(path.HasExtension(".png"));
}
TEST(ResourcePath, HasAnyExtension) {
ResourcePath path("textures/player.png");
const char* extensions[] = { ".jpg", ".png", ".tga" };
EXPECT_TRUE(path.HasAnyExtension(extensions, 3));
}
TEST(ResourcePath, HasAnyExtensionNoMatch) {
ResourcePath path("textures/player.png");
const char* extensions[] = { ".jpg", ".tga", ".bmp" };
EXPECT_FALSE(path.HasAnyExtension(extensions, 3));
}
TEST(ResourcePath, ToGUID) {
ResourcePath path("textures/player.png");
ResourceGUID guid = path.ToGUID();
EXPECT_TRUE(guid.IsValid());
}
TEST(ResourcePath, SetPath) {
ResourcePath path;
path.SetPath("textures/player.png");
EXPECT_TRUE(path.IsValid());
EXPECT_EQ(path.GetPath(), "textures/player.png");
}
TEST(ResourcePath, GetRelativePath) {
ResourcePath path("textures/player.png");
EXPECT_EQ(path.GetRelativePath(), "textures/player.png");
}
} // namespace

103
tests/Resources/test_shader.cpp
View File

@@ -1,103 +0,0 @@
#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/test_shader_loader.cpp
View File

@@ -1,38 +0,0 @@
#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

37
tests/Resources/test_texture.cpp
View File

@@ -1,37 +0,0 @@
#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/test_texture_import_settings.cpp
View File

@@ -1,119 +0,0 @@
#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/test_texture_loader.cpp
View File

@@ -1,37 +0,0 @@
#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