added initializer list and some tests for arrayview

Author: jnyfah

ZEngine/ZEngine/Core/Containers/Array.h

@@ -2,8 +2,6 @@
 #include <Allocator.h>
 #include <type_traits>
 
-// using span ?
-
 using namespace ZEngine::Core::Memory;
 
 namespace ZEngine::Core::Containers

ZEngine/ZEngine/Core/Containers/InitializerList.h

@@ -0,0 +1,73 @@
+#pragma once
+#include <Allocator.h>
+
+using namespace ZEngine::Core::Memory;
+
+namespace ZEngine::Core::Containers
+{
+
+    template <typename T>
+    struct InitializerList
+    {
+        using value_type      = T;
+        using size_type       = size_t;
+        using reference       = T&;
+        using const_reference = const T&;
+        using iterator        = T*;
+        using const_iterator  = const T*;
+        using pointer         = T*;
+        using const_pointer   = const T*;
+
+        InitializerList(pointer data, size_type size) : m_data(data), m_size(size) {}
+
+        iterator begin()
+        {
+            return m_data;
+        }
+
+        const_iterator begin() const
+        {
+            return m_data;
+        }
+
+        iterator end()
+        {
+            return m_data + m_size;
+        }
+
+        const_iterator end() const
+        {
+            return m_data + m_size;
+        }
+
+        pointer data()
+        {
+            return m_data;
+        }
+
+        const_pointer data() const
+        {
+            return m_data;
+        }
+
+        bool empty() const
+        {
+            return m_size == 0;
+        }
+
+        size_type size() const
+        {
+            return m_size;
+        }
+
+        size_type m_size;
+        pointer   m_data;
+    };
+
+    template <typename T, size_t N>
+    InitializerList<T> make_initializer_list(T (&arr)[N])
+    {
+        return InitializerList<T>(arr, N);
+    }
+
+} // namespace ZEngine::Core::Containers

ZEngine/tests/CMakeLists.txt

@@ -9,6 +9,7 @@ set (TEST_SOURCES
     array_test.cpp
     string_test.cpp
     hashmap_test.cpp
+    initializerlist_test.cpp
 )
 
 add_executable(ZEngineTests ${TEST_SOURCES})

ZEngine/tests/array_test.cpp

@@ -130,4 +130,23 @@ TEST_F(ArrayTest, FrontAndBack)
 
     EXPECT_EQ(array.front(), 10);
     EXPECT_EQ(array.back(), 30);
+}
+
+TEST_F(ArrayTest, ArrayViewWrap)
+{
+    Array<int> array;
+    array.init(&allocator, 4);
+    array.push(10);
+    array.push(20);
+    array.push(30);
+
+    ArrayView<int> view(array);
+
+    EXPECT_EQ(view.size(), array.size());
+    EXPECT_EQ(view[0], 10);
+    EXPECT_EQ(view[1], 20);
+    EXPECT_EQ(view[2], 30);
+
+    view[1] = 99;
+    EXPECT_EQ(array[1], 99);
 }

ZEngine/tests/initializerlist_test.cpp

@@ -0,0 +1,84 @@
+#include <Core/Containers/Array.h>
+#include <Core/Containers/InitializerList.h>
+#include <Core/Containers/Strings.h>
+#include <gtest/gtest.h>
+
+using namespace ZEngine::Core::Containers;
+using namespace ZEngine::Core::Memory;
+
+class InitializerListTest : public ::testing::Test
+{
+protected:
+    void SetUp() override
+    {
+        arena.Initialize(512);
+    }
+
+    void TearDown() override
+    {
+        arena.Shutdown();
+    }
+
+    ArenaAllocator arena;
+};
+
+TEST_F(InitializerListTest, WithArray)
+{
+    Array<int> array;
+    array.init(&arena, 4);
+    array.push(1);
+    array.push(2);
+    array.push(3);
+    array.push(4);
+
+    InitializerList<int> list(array.data(), array.size());
+
+    EXPECT_EQ(list.size(), 4);
+    EXPECT_EQ(list.data()[0], 1);
+    EXPECT_EQ(*(list.begin() + 2), 3);
+
+    int total = 0;
+    for (int val : list)
+    {
+        total += val;
+    }
+
+    EXPECT_EQ(total, 10);
+}
+
+TEST_F(InitializerListTest, WithStrings)
+{
+    Array<String> str_array;
+    str_array.init(&arena, 3);
+    str_array.push(String());
+    str_array.push(String());
+    str_array.push(String());
+
+    str_array[0].init(&arena, "Alpha");
+    str_array[1].init(&arena, "Beta");
+    str_array[2].init(&arena, "Gamma");
+
+    InitializerList<String> list(str_array.data(), str_array.size());
+
+    EXPECT_EQ(list.size(), 3);
+    EXPECT_STREQ(list.data()[0].c_str(), "Alpha");
+    EXPECT_STREQ(list.data()[2].c_str(), "Gamma");
+
+    std::string result;
+    for (const auto& str : list)
+        result += str.c_str();
+
+    EXPECT_EQ(result, "AlphaBetaGamma");
+}
+
+TEST_F(InitializerListTest, EmptyFromArray)
+{
+    Array<int> empty_array;
+    empty_array.init(&arena, 0);
+
+    InitializerList<int> list(empty_array.data(), empty_array.size());
+
+    EXPECT_EQ(list.size(), 0);
+    EXPECT_TRUE(list.empty());
+    EXPECT_EQ(list.begin(), list.end());
+}