chore: sync workspace state

tests/core/Containers/CMakeLists.txt

@@ -0,0 +1,32 @@
+# ============================================================
+# Containers Library Tests
+# ============================================================
+
+set(CONTAINERS_TEST_SOURCES
+    test_string.cpp
+    test_array.cpp
+    test_hashmap.cpp
+)
+
+add_executable(containers_tests ${CONTAINERS_TEST_SOURCES})
+
+if(MSVC)
+    set_target_properties(containers_tests PROPERTIES
+        LINK_FLAGS "/NODEFAULTLIB:libcpmt.lib /NODEFAULTLIB:libcmt.lib"
+    )
+endif()
+
+target_link_libraries(containers_tests
+    PRIVATE
+    XCEngine
+    GTest::gtest
+    GTest::gtest_main
+)
+
+target_include_directories(containers_tests PRIVATE
+    ${CMAKE_SOURCE_DIR}/engine/include
+    ${CMAKE_SOURCE_DIR}/tests/Fixtures
+)
+
+include(GoogleTest)
+gtest_discover_tests(containers_tests)

tests/core/Containers/test_array.cpp

@@ -0,0 +1,162 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Core/Containers/Array.h>
+
+using namespace XCEngine::Containers;
+
+namespace {
+
+TEST(Containers_Array, DefaultConstructor) {
+    Array<int> arr;
+    EXPECT_EQ(arr.Size(), 0u);
+    EXPECT_EQ(arr.Capacity(), 0u);
+    EXPECT_TRUE(arr.Empty());
+}
+
+TEST(Containers_Array, CapacityConstructor) {
+    Array<int> arr(10);
+    EXPECT_EQ(arr.Size(), 0u);
+    EXPECT_GE(arr.Capacity(), 10u);
+}
+
+TEST(Containers_Array, CountValueConstructor) {
+    Array<int> arr(5, 42);
+    EXPECT_EQ(arr.Size(), 5u);
+    for (size_t i = 0; i < 5; ++i) {
+        EXPECT_EQ(arr[i], 42);
+    }
+}
+
+TEST(Containers_Array, InitializerListConstructor) {
+    Array<int> arr = {1, 2, 3, 4, 5};
+    EXPECT_EQ(arr.Size(), 5u);
+    EXPECT_EQ(arr[0], 1);
+    EXPECT_EQ(arr[4], 5);
+}
+
+TEST(Containers_Array, CopyConstructor) {
+    Array<int> arr1 = {1, 2, 3};
+    Array<int> arr2(arr1);
+    EXPECT_EQ(arr2.Size(), 3u);
+    EXPECT_EQ(arr2[0], 1);
+    EXPECT_EQ(arr2[2], 3);
+}
+
+TEST(Containers_Array, MoveConstructor) {
+    Array<int> arr1 = {1, 2, 3};
+    Array<int> arr2(std::move(arr1));
+    EXPECT_EQ(arr2.Size(), 3u);
+    EXPECT_EQ(arr2[0], 1);
+}
+
+TEST(Containers_Array, CopyAssignment) {
+    Array<int> arr1 = {1, 2, 3};
+    Array<int> arr2;
+    arr2 = arr1;
+    EXPECT_EQ(arr2.Size(), 3u);
+    EXPECT_EQ(arr2[0], 1);
+}
+
+TEST(Containers_Array, MoveAssignment) {
+    Array<int> arr1 = {1, 2, 3};
+    Array<int> arr2;
+    arr2 = std::move(arr1);
+    EXPECT_EQ(arr2.Size(), 3u);
+    EXPECT_EQ(arr2[0], 1);
+}
+
+TEST(Containers_Array, OperatorSquareBrackets) {
+    Array<int> arr = {10, 20, 30};
+    EXPECT_EQ(arr[0], 10);
+    EXPECT_EQ(arr[1], 20);
+    EXPECT_EQ(arr[2], 30);
+    
+    arr[1] = 25;
+    EXPECT_EQ(arr[1], 25);
+}
+
+TEST(Containers_Array, PushBack) {
+    Array<int> arr;
+    arr.PushBack(1);
+    arr.PushBack(2);
+    arr.PushBack(3);
+    EXPECT_EQ(arr.Size(), 3u);
+    EXPECT_EQ(arr[2], 3);
+}
+
+TEST(Containers_Array, EmplaceBack) {
+    Array<int> arr;
+    arr.EmplaceBack(1);
+    arr.EmplaceBack(2);
+    arr.EmplaceBack(3);
+    EXPECT_EQ(arr.Size(), 3u);
+}
+
+TEST(Containers_Array, PopBack) {
+    Array<int> arr = {1, 2, 3};
+    arr.PopBack();
+    EXPECT_EQ(arr.Size(), 2u);
+    EXPECT_EQ(arr[1], 2);
+}
+
+TEST(Containers_Array, Clear) {
+    Array<int> arr = {1, 2, 3};
+    arr.Clear();
+    EXPECT_EQ(arr.Size(), 0u);
+    EXPECT_TRUE(arr.Empty());
+}
+
+TEST(Containers_Array, Reserve) {
+    Array<int> arr;
+    arr.Reserve(100);
+    EXPECT_GE(arr.Capacity(), 100u);
+}
+
+TEST(Containers_Array, Resize) {
+    Array<int> arr;
+    arr.Resize(5);
+    EXPECT_EQ(arr.Size(), 5u);
+    EXPECT_EQ(arr[0], 0);
+    EXPECT_EQ(arr[4], 0);
+    
+    arr.Resize(8, 42);
+    EXPECT_EQ(arr.Size(), 8u);
+    EXPECT_EQ(arr[0], 0);
+    EXPECT_EQ(arr[5], 42);
+    EXPECT_EQ(arr[7], 42);
+}
+
+TEST(Containers_Array, Front) {
+    Array<int> arr = {10, 20, 30};
+    EXPECT_EQ(arr.Front(), 10);
+}
+
+TEST(Containers_Array, Back) {
+    Array<int> arr = {10, 20, 30};
+    EXPECT_EQ(arr.Back(), 30);
+}
+
+TEST(Containers_Array, Data) {
+    Array<int> arr = {10, 20, 30};
+    EXPECT_EQ(arr.Data()[0], 10);
+    EXPECT_EQ(arr.Data()[1], 20);
+}
+
+TEST(Containers_Array, Iterator) {
+    Array<int> arr = {1, 2, 3, 4, 5};
+    int sum = 0;
+    for (auto it = arr.begin(); it != arr.end(); ++it) {
+        sum += *it;
+    }
+    EXPECT_EQ(sum, 15);
+}
+
+TEST(Containers_Array, RangeBasedFor) {
+    Array<int> arr = {1, 2, 3, 4, 5};
+    int sum = 0;
+    for (int v : arr) {
+        sum += v;
+    }
+    EXPECT_EQ(sum, 15);
+}
+
+} // namespace

tests/core/Containers/test_hashmap.cpp

@@ -0,0 +1,139 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Core/Containers/HashMap.h>
+#include <XCEngine/Core/Containers/String.h>
+
+using namespace XCEngine::Containers;
+
+namespace {
+
+TEST(Containers_HashMap, DefaultConstructor) {
+    HashMap<int, int> map;
+    EXPECT_EQ(map.Size(), 0u);
+    EXPECT_TRUE(map.Empty());
+}
+
+TEST(Containers_HashMap, Insert) {
+    HashMap<int, String> map;
+    map.Insert(1, String("one"));
+    EXPECT_EQ(map.Size(), 1u);
+}
+
+TEST(Containers_HashMap, InsertDuplicate) {
+    HashMap<int, int> map;
+    map.Insert(1, 10);
+    map.Insert(1, 20);
+    EXPECT_EQ(map.Size(), 1u);
+    
+    auto* val = map.Find(1);
+    EXPECT_EQ(*val, 20);
+}
+
+TEST(Containers_HashMap, Find) {
+    HashMap<int, int> map;
+    map.Insert(1, 100);
+    map.Insert(2, 200);
+    
+    auto* val = map.Find(1);
+    ASSERT_NE(val, nullptr);
+    EXPECT_EQ(*val, 100);
+    
+    val = map.Find(2);
+    ASSERT_NE(val, nullptr);
+    EXPECT_EQ(*val, 200);
+    
+    val = map.Find(3);
+    EXPECT_EQ(val, nullptr);
+}
+
+TEST(Containers_HashMap, Find_NotFound) {
+    HashMap<int, int> map;
+    map.Insert(1, 100);
+    EXPECT_EQ(map.Find(999), nullptr);
+}
+
+TEST(Containers_HashMap, OperatorBracket) {
+    HashMap<int, int> map;
+    map[1] = 100;
+    map[2] = 200;
+    
+    EXPECT_EQ(map[1], 100);
+    EXPECT_EQ(map[2], 200);
+}
+
+TEST(Containers_HashMap, OperatorBracket_NewKey) {
+    HashMap<int, int> map;
+    map[1] = 100;
+    EXPECT_EQ(map.Size(), 1u);
+    EXPECT_EQ(map[1], 100);
+}
+
+TEST(Containers_HashMap, Contains) {
+    HashMap<int, int> map;
+    map.Insert(1, 100);
+    map.Insert(2, 200);
+    
+    EXPECT_TRUE(map.Contains(1));
+    EXPECT_TRUE(map.Contains(2));
+    EXPECT_FALSE(map.Contains(3));
+}
+
+TEST(Containers_HashMap, Erase) {
+    HashMap<int, int> map;
+    map.Insert(1, 100);
+    map.Insert(2, 200);
+    EXPECT_EQ(map.Size(), 2u);
+    
+    bool erased = map.Erase(1);
+    EXPECT_TRUE(erased);
+    EXPECT_EQ(map.Size(), 1u);
+    EXPECT_FALSE(map.Contains(1));
+    EXPECT_TRUE(map.Contains(2));
+}
+
+TEST(Containers_HashMap, Erase_NotFound) {
+    HashMap<int, int> map;
+    map.Insert(1, 100);
+    
+    bool erased = map.Erase(999);
+    EXPECT_FALSE(erased);
+    EXPECT_EQ(map.Size(), 1u);
+}
+
+TEST(Containers_HashMap, Clear) {
+    HashMap<int, int> map;
+    map.Insert(1, 100);
+    map.Insert(2, 200);
+    map.Insert(3, 300);
+    
+    map.Clear();
+    EXPECT_EQ(map.Size(), 0u);
+    EXPECT_TRUE(map.Empty());
+}
+
+TEST(Containers_HashMap, MultipleInsertions) {
+    HashMap<int, int> map;
+    for (int i = 0; i < 100; ++i) {
+        map.Insert(i, i * 10);
+    }
+    EXPECT_EQ(map.Size(), 100u);
+    
+    for (int i = 0; i < 100; ++i) {
+        auto* val = map.Find(i);
+        ASSERT_NE(val, nullptr);
+        EXPECT_EQ(*val, i * 10);
+    }
+}
+
+TEST(Containers_HashMap, StringKey) {
+    HashMap<String, int> map;
+    map.Insert(String("apple"), 1);
+    map.Insert(String("banana"), 2);
+    map.Insert(String("cherry"), 3);
+    
+    EXPECT_EQ(map.Size(), 3u);
+    EXPECT_EQ(map[String("apple")], 1);
+    EXPECT_EQ(map[String("banana")], 2);
+    EXPECT_EQ(map[String("cherry")], 3);
+}
+
+} // namespace

tests/core/Containers/test_string.cpp

@@ -0,0 +1,133 @@
+#include <gtest/gtest.h>
+#include <XCEngine/Core/Containers/String.h>
+
+using namespace XCEngine::Containers;
+
+namespace {
+
+TEST(Containers_String, DefaultConstructor_EmptyString) {
+    String s;
+    EXPECT_EQ(s.Length(), 0u);
+    EXPECT_STREQ(s.CStr(), "");
+    EXPECT_TRUE(s.Empty());
+}
+
+TEST(Containers_String, ConstructorFromCString) {
+    String s("Hello");
+    EXPECT_EQ(s.Length(), 5u);
+    EXPECT_STREQ(s.CStr(), "Hello");
+}
+
+TEST(Containers_String, CopyConstructor) {
+    String s1("Hello");
+    String s2(s1);
+    EXPECT_EQ(s2.Length(), 5u);
+    EXPECT_STREQ(s2.CStr(), "Hello");
+}
+
+TEST(Containers_String, MoveConstructor) {
+    String s1("Hello");
+    String s2(std::move(s1));
+    EXPECT_EQ(s2.Length(), 5u);
+    EXPECT_STREQ(s2.CStr(), "Hello");
+}
+
+TEST(Containers_String, CopyAssignment) {
+    String s1("Hello");
+    String s2;
+    s2 = s1;
+    EXPECT_EQ(s2.Length(), 5u);
+    EXPECT_STREQ(s2.CStr(), "Hello");
+}
+
+TEST(Containers_String, MoveAssignment) {
+    String s1("Hello");
+    String s2;
+    s2 = std::move(s1);
+    EXPECT_EQ(s2.Length(), 5u);
+    EXPECT_STREQ(s2.CStr(), "Hello");
+}
+
+TEST(Containers_String, OperatorPlusEqual_String) {
+    String s("Hello");
+    s += String(" World");
+    EXPECT_EQ(s.Length(), 11u);
+    EXPECT_STREQ(s.CStr(), "Hello World");
+}
+
+TEST(Containers_String, OperatorPlusEqual_CString) {
+    String s("Hello");
+    s += " World";
+    EXPECT_EQ(s.Length(), 11u);
+    EXPECT_STREQ(s.CStr(), "Hello World");
+}
+
+TEST(Containers_String, Substring) {
+    String s("Hello World");
+    String sub = s.Substring(0, 5);
+    EXPECT_STREQ(sub.CStr(), "Hello");
+    
+    String sub2 = s.Substring(6);
+    EXPECT_STREQ(sub2.CStr(), "World");
+    
+    String sub3 = s.Substring(6, 3);
+    EXPECT_STREQ(sub3.CStr(), "Wor");
+}
+
+TEST(Containers_String, Trim) {
+    String s("  Hello  ");
+    String trimmed = s.Trim();
+    EXPECT_STREQ(trimmed.CStr(), "Hello");
+}
+
+TEST(Containers_String, ToLower) {
+    String s("HELLO");
+    String lower = s.ToLower();
+    EXPECT_STREQ(lower.CStr(), "hello");
+}
+
+TEST(Containers_String, ToUpper) {
+    String s("hello");
+    String upper = s.ToUpper();
+    EXPECT_STREQ(upper.CStr(), "HELLO");
+}
+
+TEST(Containers_String, Find_Found) {
+    String s("Hello World");
+    EXPECT_EQ(s.Find("World"), 6u);
+    EXPECT_EQ(s.Find("Hello"), 0u);
+}
+
+TEST(Containers_String, Find_NotFound) {
+    String s("Hello");
+    EXPECT_EQ(s.Find("World"), String::npos);
+}
+
+TEST(Containers_String, StartsWith) {
+    String s("Hello World");
+    EXPECT_TRUE(s.StartsWith("Hello"));
+    EXPECT_TRUE(s.StartsWith(String("Hello")));
+    EXPECT_FALSE(s.StartsWith("World"));
+}
+
+TEST(Containers_String, EndsWith) {
+    String s("Hello World");
+    EXPECT_TRUE(s.EndsWith("World"));
+    EXPECT_TRUE(s.EndsWith(String("World")));
+    EXPECT_FALSE(s.EndsWith("Hello"));
+}
+
+TEST(Containers_String, Clear) {
+    String s("Hello");
+    s.Clear();
+    EXPECT_EQ(s.Length(), 0u);
+    EXPECT_TRUE(s.Empty());
+}
+
+TEST(Containers_String, Reserve) {
+    String s("Hi");
+    s.Reserve(100);
+    EXPECT_GE(s.Capacity(), 100u);
+}
+
+} // namespace