feat: 实现Containers、Memory、Threading核心模块及单元测试

- Containers: String, Array, HashMap 容器实现及测试
- Memory: Allocator, LinearAllocator, PoolAllocator, ProxyAllocator, MemoryManager 实现及测试
- Threading: Mutex, SpinLock, ReadWriteLock, Thread, Task, TaskSystem 实现及测试
- 修复Windows平台兼容性: _aligned_malloc, std::hash特化
- 修复构建错误和测试用例问题

tests/threading/CMakeLists.txt

@@ -0,0 +1,31 @@
+# ============================================================
+# Threading Library Tests
+# ============================================================
+
+set(THREADING_TEST_SOURCES
+    test_mutex.cpp
+    test_spinlock.cpp
+    test_task.cpp
+)
+
+add_executable(xcengine_threading_tests ${THREADING_TEST_SOURCES})
+
+if(MSVC)
+    set_target_properties(xcengine_threading_tests PROPERTIES
+        LINK_FLAGS "/NODEFAULTLIB:libcpmt.lib /NODEFAULTLIB:libcmt.lib"
+    )
+endif()
+
+target_link_libraries(xcengine_threading_tests
+    PRIVATE
+    XCEngine
+    GTest::gtest
+    GTest::gtest_main
+)
+
+target_include_directories(xcengine_threading_tests PRIVATE
+    ${CMAKE_SOURCE_DIR}/engine/include
+    ${CMAKE_SOURCE_DIR}/tests/fixtures
+)
+
+add_test(NAME ThreadingTests COMMAND xcengine_threading_tests)

tests/threading/test_mutex.cpp

@@ -0,0 +1,41 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Threading/Mutex.h>
+
+using namespace XCEngine::Threading;
+
+namespace {
+
+TEST(Threading_Mutex, LockUnlock) {
+    Mutex mutex;
+    
+    mutex.Lock();
+    mutex.Unlock();
+}
+
+TEST(Threading_Mutex, TryLock_Success) {
+    Mutex mutex;
+    
+    bool result = mutex.TryLock();
+    EXPECT_TRUE(result);
+    mutex.Unlock();
+}
+
+TEST(Threading_Mutex, TryLock_AlreadyLocked) {
+    Mutex mutex;
+    
+    mutex.Lock();
+    bool result = mutex.TryLock();
+    EXPECT_FALSE(result);
+    mutex.Unlock();
+}
+
+TEST(Threading_Mutex, MultipleLockUnlock) {
+    Mutex mutex;
+    
+    for (int i = 0; i < 10; ++i) {
+        mutex.Lock();
+        mutex.Unlock();
+    }
+}
+
+} // namespace

tests/threading/test_spinlock.cpp

@@ -0,0 +1,32 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Threading/SpinLock.h>
+
+using namespace XCEngine::Threading;
+
+namespace {
+
+TEST(Threading_SpinLock, LockUnlock) {
+    SpinLock spinlock;
+    
+    spinlock.Lock();
+    spinlock.Unlock();
+}
+
+TEST(Threading_SpinLock, TryLock_Success) {
+    SpinLock spinlock;
+    
+    bool result = spinlock.TryLock();
+    EXPECT_TRUE(result);
+    spinlock.Unlock();
+}
+
+TEST(Threading_SpinLock, TryLock_AlreadyLocked) {
+    SpinLock spinlock;
+    
+    spinlock.Lock();
+    bool result = spinlock.TryLock();
+    EXPECT_FALSE(result);
+    spinlock.Unlock();
+}
+
+} // namespace

tests/threading/test_task.cpp

@@ -0,0 +1,59 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Threading/Task.h>
+#include <XCEngine/Threading/LambdaTask.h>
+
+using namespace XCEngine::Threading;
+
+namespace {
+
+class TestTask : public ITask {
+public:
+    TestTask(bool* flag) : m_flag(flag) {}
+    
+    void Execute() override {
+        if (m_flag) *m_flag = true;
+    }
+    
+private:
+    bool* m_flag;
+};
+
+TEST(Threading_Task, DefaultPriority) {
+    TestTask task(nullptr);
+    EXPECT_EQ(task.GetPriority(), TaskPriority::Normal);
+}
+
+TEST(Threading_Task, SetPriority) {
+    TestTask task(nullptr);
+    task.SetPriority(TaskPriority::High);
+    EXPECT_EQ(task.GetPriority(), TaskPriority::High);
+}
+
+TEST(Threading_Task, Status) {
+    TestTask task(nullptr);
+    EXPECT_EQ(task.GetStatus(), TaskStatus::Pending);
+    
+    task.SetStatus(TaskStatus::Running);
+    EXPECT_EQ(task.GetStatus(), TaskStatus::Running);
+}
+
+TEST(Threading_Task, Execute) {
+    bool executed = false;
+    TestTask task(&executed);
+    task.Execute();
+    EXPECT_TRUE(executed);
+}
+
+TEST(Threading_LambdaTask, Execute) {
+    bool executed = false;
+    LambdaTask task([&executed]() { executed = true; });
+    task.Execute();
+    EXPECT_TRUE(executed);
+}
+
+TEST(Threading_LambdaTask, Priority) {
+    LambdaTask task([]() {}, TaskPriority::Low);
+    EXPECT_EQ(task.GetPriority(), TaskPriority::Low);
+}
+
+} // namespace