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

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)

tests/Resources/Texture/test_texture.cpp

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

tests/Resources/Texture/test_texture_import_settings.cpp

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

tests/Resources/Texture/test_texture_loader.cpp

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