Transitioning unit tests to gtest

tests/CMakeLists.txt

@@ -0,0 +1,14 @@
+find_package(GTest CONFIG REQUIRED)
+
+add_executable(SeeleUnitTests "")
+
+add_subdirectory(Engine/)
+
+target_link_libraries(SeeleUnitTests PRIVATE Engine)
+target_link_libraries(SeeleUnitTests PRIVATE GTest::gtest_main)
+
+enable_testing()
+add_test(SeeleEngineTest SeeleUnitTests)
+
+include(GoogleTest)
+gtest_discover_tests(SeeleUnitTests)

tests/Engine/CMakeLists.txt

@@ -0,0 +1,10 @@
+target_sources(SeeleUnitTests
+	PRIVATE
+		EngineTest.h
+		ThreadPool.cpp)
+
+target_include_directories(SeeleUnitTests PUBLIC ./)
+add_subdirectory(Containers/)
+add_subdirectory(Graphics/)
+add_subdirectory(Math/)
+add_subdirectory(Serialization/)

tests/Engine/Containers/Array.cpp

@@ -0,0 +1,195 @@
+#include "EngineTest.h"
+#include "Containers/Array.h"
+#include "MinimalEngine.h"
+#include <algorithm>
+#include <time.h>
+#include <chrono>
+
+using namespace Seele;
+
+TEST(ArraySuite, empty_constructur)
+{
+    Array<uint8> array;
+    ASSERT_EQ(array.size(), 0);
+}
+
+TEST(ArraySuite, initialial_size)
+{
+    Array<uint8> array(3);
+    ASSERT_EQ(array.size(), 3);
+}
+
+TEST(ArraySuite, resize)
+{
+    Array<uint8> array;
+    array.add(2);
+    array.add(3);
+    ASSERT_EQ(array.size(), 2);
+    array.resize(5);
+    ASSERT_EQ(array.size(), 5);
+}
+TEST(ArraySuite, clear)
+{
+    Array<uint8> array;
+    array.add(3);
+    array.add(2);
+    array.add(6);
+    ASSERT_EQ(array.size(), 3);
+    array.clear();
+    ASSERT_EQ(array.size(), 0);
+    array.add(2);
+}
+TEST(ArraySuite, remove_keeporder)
+{
+    Array<uint8> array;
+    array.add(1);
+    array.add(2);
+    array.add(3);
+    array.add(4);
+    array.add(5);
+    array.remove(1);
+    ASSERT_EQ(array[1], 3);
+    ASSERT_EQ(array[2], 4);
+    ASSERT_EQ(array[3], 5);
+    ASSERT_EQ(array.size(), 4);
+}
+
+TEST(ArraySuite, find)
+{
+    Array<uint8> array;
+    for(uint8 i = 0; i < 100; ++i)
+    {
+        array.add(i);
+    }
+    auto it = array.find([](uint8 elem){ return elem / 9 == 9; });
+    ASSERT_EQ(*it, 81);
+}
+
+TEST(ArraySuite, remove_swap)
+{
+    Array<uint8> array;
+    array.add(1);
+    array.add(2);
+    array.add(3);
+    array.add(4);
+    array.add(5);
+    array.removeAt(1, false);
+    ASSERT_EQ(array[1], 5);
+    ASSERT_EQ(array[2], 3);
+    ASSERT_EQ(array[3], 4);
+    ASSERT_EQ(array.size(), 4);
+}
+
+TEST(ArraySuite, remove_iterator)
+{
+    Array<uint8> array;
+    array.add(1);
+    array.add(2);
+    array.add(3);
+    array.add(4);
+    array.add(5);
+    array.remove(array.find(1), false);
+    ASSERT_EQ(array[0], 5);
+    ASSERT_EQ(array[1], 2);
+    ASSERT_EQ(array[2], 3);
+    ASSERT_EQ(array[3], 4);
+    ASSERT_EQ(array.size(), 4);
+}
+
+TEST(ArraySuite, remove_iterator_keep_order)
+{
+    Array<uint8> array;
+    array.add(1);
+    array.add(2);
+    array.add(3);
+    array.add(4);
+    array.add(5);
+    array.remove(array.find(1));
+    ASSERT_EQ(array[0], 2);
+    ASSERT_EQ(array[1], 3);
+    ASSERT_EQ(array[2], 4);
+    ASSERT_EQ(array[3], 5);
+    ASSERT_EQ(array.size(), 4);
+}
+
+TEST(ArraySuite, random_access)
+{
+    Array<uint8> array;
+    array.add(4);
+    array.add(5);
+    array.add(6);
+    ASSERT_EQ(array[2], 6);
+    ASSERT_EQ(array[0], 4);
+}
+
+TEST(ArraySuite, copy)
+{
+    Array<uint8> array;
+    array.add(0);
+    array.add(1);
+    array.add(2);
+    array.add(3);
+    Array<uint8> copy = array;
+    ASSERT_EQ(array, copy);
+    Array<uint8> copy2(copy);
+    ASSERT_EQ(array, copy2);
+}
+
+class BaseElement
+{
+    uint64 test;
+};
+
+class BaseContainer
+{
+    Array<BaseElement> elements;
+};
+
+class DerivedContainer : public BaseContainer
+{
+    uint64 test;
+};
+
+TEST(ArraySuite, virtual_classes)
+{
+    Array<DerivedContainer> array(64);
+    for(uint32 i = 0; i < 100; ++i)
+    {
+        Array<DerivedContainer> copy = array;
+        ASSERT_EQ(array.size(), copy.size());
+    }
+}
+
+class TestStruct
+{
+public:
+    uint32 data;
+    ~TestStruct()
+    {
+        data = 1;
+    }
+};
+DECLARE_REF(TestStruct);
+
+TEST(StaticArraySuite, empty_constructur)
+{
+    StaticArray<uint8, 2> array;
+    ASSERT_EQ(array.size(), 2);
+}
+
+TEST(StaticArraySuite, initialial_size)
+{
+    StaticArray<uint8, 3> array(3);
+    ASSERT_EQ(array.size(), 3);
+    ASSERT_EQ(array[1], 3);
+}
+
+TEST(StaticArraySuite, random_access)
+{
+    StaticArray<uint8, 3> array;
+    array[0] = 4;
+    array[1] = 5;
+    array[2] = 6;
+    ASSERT_EQ(array[0], 4);
+    ASSERT_EQ(array[2], 6);
+}

tests/Engine/Containers/CMakeLists.txt

@@ -0,0 +1,5 @@
+target_sources(SeeleUnitTests
+	PRIVATE
+		Array.cpp
+		Map.cpp
+		List.cpp)

tests/Engine/Containers/List.cpp

@@ -0,0 +1,56 @@
+#include "EngineTest.h"
+#include "Containers/List.h"
+
+using namespace Seele;
+
+TEST(ListSuite, basic_add)
+{
+	List<int> list;
+	list.add(2);
+	ASSERT_EQ(list.size(), 1);
+	list.add(4);
+	ASSERT_EQ(list.size(), 2);
+	List<int>::Iterator it = list.find(2);
+	ASSERT_EQ(*it, 2);
+}
+
+TEST(ListSuite, basic_insert)
+{
+	List<int> list;
+	list.add(2);
+	list.add(3);
+	list.add(4);
+	List<int>::Iterator it = list.find(3);
+	it = list.insert(it, 1);
+	ASSERT_EQ(*it, 1);
+	ASSERT_EQ(list.size(), 4);
+}
+TEST(ListSuite, basic_remove)
+{
+	List<int> list;
+	list.add(2);
+	list.add(3);
+	list.add(4);
+	List<int>::Iterator it = list.find(3);
+	it = list.remove(it);
+	ASSERT_EQ(*it, 4);
+	ASSERT_EQ(list.size(), 2);
+}
+
+TEST(ListSuite, list_join)
+{
+	List<int> list1;
+	List<int> list2;
+	list1.add(2);
+	list1.add(1);
+	list1.add(3);
+	list1.add(4);
+	list2.add(5);
+	list2.add(7);
+	list2.add(8);
+	list2.add(6);
+	list2.add(9);
+	list1.moveElements(std::move(list2));
+	ASSERT_EQ(list1.size(), 9);
+	ASSERT_EQ(list2.size(), 0);
+}

tests/Engine/Containers/Map.cpp

@@ -0,0 +1,91 @@
+#include "EngineTest.h"
+#include "Containers/Map.h"
+
+using namespace Seele;
+
+TEST(CachedMap, insert_find_basic)
+{
+    Map<int, int> map;
+    map[2] = 3;
+    map[1] = 5;
+    map[6] = 4;
+    map[4] = 7;
+    ASSERT_EQ(map[2], 3);
+    ASSERT_EQ(map[1], 5);
+    ASSERT_EQ(map[6], 4);
+    ASSERT_EQ(map[4], 7);
+    map[2] = 5;
+    map[4] = 4;
+    ASSERT_EQ(map[2], 5);
+    ASSERT_EQ(map[4], 4);
+    ASSERT_EQ(map.find(2)->value, 5);
+    ASSERT_EQ(map.find(4)->value, 4);
+    //ASSERT_EQ(map.find(5), map.end());
+}
+
+TEST(CachedMap, for_each)
+{
+    Map<int, int> map;
+    map[2] = 3;
+    map[1] = 5;
+    map[6] = 4;
+    map[4] = 7;
+    int count = 0;
+    for(auto it : map)
+    {
+        count++;
+    }
+    ASSERT_EQ(count, 4);
+}
+
+TEST(CachedMap, remove_entry)
+{
+    Map<int, int> map;
+    map[1] = 5;
+    map[4] = 1;
+    map[2] = 6;
+    map[3] = 4;
+    map.erase(2);
+    ASSERT_EQ(map.size(), 3);
+    ASSERT_EQ(map[1], 5);
+    ASSERT_EQ(map[4], 1);
+    ASSERT_EQ(map[3], 4);
+}
+
+TEST(CachedMap, key_exists)
+{
+    Map<int, int> map;
+    map[2] = 3;
+    ASSERT_EQ(map.exists(2), true);
+    ASSERT_EQ(map.exists(4), false);
+    map.erase(2);
+    ASSERT_EQ(map.exists(2), false);
+}
+
+TEST(CachedMap, custom_key)
+{
+    struct Key
+    {
+        int id;
+        bool operator<(const Key& other) const
+        {
+            return id < other.id;
+        }
+    };
+    Map<Key, int> map;
+    map[Key{ 2 }] = 3;
+    map[Key{ 3 }] = 4;
+    ASSERT_EQ(map[Key{ 2 }], 3);
+    ASSERT_EQ(map[Key{ 3 }], 4);
+
+}
+
+TEST(CachedMap, string_key)
+{
+    std::map<std::string, int> map;
+    map["Test"] = 2;
+    map["Test2"] = 3;
+    ASSERT_EQ(map["Test"], 2);
+    ASSERT_EQ(map["Test2"], 3);
+}
+

tests/Engine/EngineTest.h

@@ -0,0 +1,5 @@
+#pragma once
+#include <gtest/gtest.h>
+#include "MinimalEngine.h"
+
+using namespace Seele;

tests/Engine/Graphics/CMakeLists.txt

@@ -0,0 +1,4 @@
+target_sources(SeeleUnitTests
+	PRIVATE
+		GraphicsResources.cpp)
+		

tests/Engine/Graphics/GraphicsResources.cpp

@@ -0,0 +1,2 @@
+#include "EngineTest.h"
+#include "Graphics/Vulkan/Graphics.h"

tests/Engine/Math/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(SeeleUnitTests
+    PRIVATE
+        Vector.cpp)

tests/Engine/Math/Vector.cpp

@@ -0,0 +1,38 @@
+#include "EngineTest.h"
+#include "Math/Vector.h"
+
+TEST(VectorParse, parse_vector_basic)
+{
+    const char* str = "float3(0, 0, 0)";
+    Vector vec = parseVector(str);
+    ASSERT_EQ(vec.x, 0);
+    ASSERT_EQ(vec.y, 0);
+    ASSERT_EQ(vec.z, 0);
+}
+
+TEST(VectorParse, parse_vector_literal)
+{
+    const char* str = "float3(0.0f, 0.0f, 0.0f)";
+    Vector vec = parseVector(str);
+    ASSERT_EQ(vec.x, 0);
+    ASSERT_EQ(vec.y, 0);
+    ASSERT_EQ(vec.z, 0);
+}
+
+TEST(VectorParse, parse_vector_no_literal)
+{
+    const char* str = "float3(0.0, 0.0, 0.0)";
+    Vector vec = parseVector(str);
+    ASSERT_EQ(vec.x, 0);
+    ASSERT_EQ(vec.y, 0);
+    ASSERT_EQ(vec.z, 0);
+}
+
+TEST(VectorParse, parse_vector_float)
+{
+    const char* str = "float3(0.01, 0.01f, 0.01f)";
+    Vector vec = parseVector(str);
+    ASSERT_EQ(vec.x, 0.01f);
+    ASSERT_EQ(vec.y, 0.01f);
+    ASSERT_EQ(vec.z, 0.01f);
+}

tests/Engine/Serialization/ArchiveBuffer.cpp

@@ -0,0 +1 @@
+#include "EngineTest.h"

tests/Engine/Serialization/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(SeeleUnitTests
+	PRIVATE
+		ArchiveBuffer.cpp)

tests/Engine/ThreadPool.cpp

@@ -0,0 +1,22 @@
+#include "EngineTest.h"
+#include "ThreadPool.h"
+#include <numeric>
+
+TEST(ThreadPool, RunBatch)
+{
+    ThreadPool t(10);
+    uint32 test = 20;
+    std::mutex m;
+    List<Task> work;
+    for (uint32 i = 0; i < 400; ++i)
+    {
+        work.add([&]() -> Task {
+            std::unique_lock l(m);
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+            test++;
+            co_return;
+        }());
+    }
+    t.runAndWait(std::move(work));
+    ASSERT_EQ(test, 420);
+}