Dynamitos/Seele
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Transitioning unit tests to gtest

Browse Source
This commit is contained in:
Dynamitos
2023-12-18 08:37:25 +01:00
parent 34e0d283e8
commit 617bb2828d
29 changed files with 416 additions and 820 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CMakeLists.txt
+1
View File
@@ -118,6 +118,7 @@ target_compile_options(Engine PUBLIC "$<$<CONFIG:DEBUG>:-DENABLE_VALIDATION>")
target_compile_options(Engine PUBLIC "$<$<CONFIG:DEBUG>:-DSEELE_DEBUG>")
add_subdirectory(src/)
add_subdirectory(tests/)
if(WIN32)
add_custom_target(dll_copy ALL
CMakeSettings.json
+13 -1
View File
@@ -11,7 +11,6 @@
"cmakeCommandArgs": "-DCMAKE_DEBUG_POSTFIX=\"\" -DCMAKE_PLATFORM=x64",
"buildRoot": "C:/Users/Dynamitos/Seele/bin/",
"installRoot": "C:/Program Files/Seele",
"addressSanitizerEnabled": true
},
{
"name": "Release",
@@ -36,6 +35,19 @@
"ctestCommandArgs": "",
"inheritEnvironments": [ "msvc_x64" ],
"intelliSenseMode": "windows-msvc-x64"
},
{
"name": "AddressSanitizer",
"buildCommandArgs": "",
"ctestCommandArgs": "",
"configurationType": "Debug",
"generator": "Visual Studio 17 2022 Win64",
"intelliSenseMode": "windows-msvc-x64",
"inheritEnvironments": [ "msvc_x64" ],
"cmakeCommandArgs": "-DCMAKE_DEBUG_POSTFIX=\"\" -DCMAKE_PLATFORM=x64",
"buildRoot": "C:/Users/Dynamitos/Seele/bin/",
"installRoot": "C:/Program Files/Seele",
"addressSanitizerEnabled": true
}
]
}
test/CMakeLists.txt
-35
View File
@@ -1,35 +0,0 @@
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ".")
find_package(Boost COMPONENTS unit_test_framework REQUIRED)
find_package(Vulkan REQUIRED)
add_subdirectory(Engine/)
target_include_directories(Seele_unit_tests PRIVATE ${ENGINE_ROOT})
target_link_libraries(Seele_unit_tests PRIVATE Engine)
target_link_libraries(Seele_unit_tests PRIVATE Boost::unit_test_framework)
if(UNIX)
target_compile_definitions(Seele_unit_tests PRIVATE -DBOOST_TEST_DYN_LINK)
endif()
target_precompile_headers(Seele_unit_tests
PRIVATE
<assert.h>
<memory>
<atomic>
<coroutine>
<thread>
<cstring>
<iostream>
<string>
<thread>
<functional>
<filesystem>
<fstream>
<mutex>
<condition_variable>)
enable_testing()
add_test(SeeleEngineTest Seele_unit_tests)
test/Engine/CMakeLists.txt
-12
View File
@@ -1,12 +0,0 @@
target_sources(Seele_unit_tests
PRIVATE
../../src/Engine/MinimalEngine.cpp
../../src/Engine/ThreadPool.cpp
EngineTest.h
EngineTest.cpp)
#ThreadPool.cpp)
target_include_directories(Seele_unit_tests PUBLIC ./)
add_subdirectory(Containers/)
add_subdirectory(Graphics/)
add_subdirectory(Math/)
add_subdirectory(Serialization/)
test/Engine/Containers/Array.cpp
-220
View File
@@ -1,220 +0,0 @@
#include "EngineTest.h"
#include "Containers/Array.h"
#include "MinimalEngine.h"
#include <algorithm>
#include <time.h>
#include <chrono>
#include <boost/test/unit_test.hpp>
using namespace Seele;
BOOST_AUTO_TEST_SUITE(Array_Suite)
BOOST_AUTO_TEST_CASE(empty_constructur)
{
Array<uint8> array;
BOOST_CHECK_EQUAL(array.size(), 0);
}
BOOST_AUTO_TEST_CASE(initialial_size)
{
Array<uint8> array(3);
BOOST_CHECK_EQUAL(array.size(), 3);
}
BOOST_AUTO_TEST_CASE(resize)
{
Array<uint8> array;
array.add(2);
array.add(3);
BOOST_CHECK_EQUAL(array.size(), 2);
array.resize(5);
BOOST_CHECK_EQUAL(array.size(), 5);
}
BOOST_AUTO_TEST_CASE(clear)
{
Array<uint8> array;
array.add(3);
array.add(2);
array.add(6);
BOOST_CHECK_EQUAL(array.size(), 3);
array.clear();
BOOST_CHECK_EQUAL(array.size(), 0);
array.add(2);
}
BOOST_AUTO_TEST_CASE(remove_keeporder)
{
Array<uint8> array;
array.add(1);
array.add(2);
array.add(3);
array.add(4);
array.add(5);
array.remove(1);
BOOST_CHECK_EQUAL(array[1], 3);
BOOST_CHECK_EQUAL(array[2], 4);
BOOST_CHECK_EQUAL(array[3], 5);
BOOST_CHECK_EQUAL(array.size(), 4);
}
BOOST_AUTO_TEST_CASE(find)
{
Array<uint8> array;
for(uint8 i = 0; i < 100; ++i)
{
array.add(i);
}
auto it = array.find([](uint8 elem){ return elem / 9 == 9; });
BOOST_CHECK_EQUAL(*it, 81);
}
BOOST_AUTO_TEST_CASE(remove_swap)
{
Array<uint8> array;
array.add(1);
array.add(2);
array.add(3);
array.add(4);
array.add(5);
array.removeAt(1, false);
BOOST_CHECK_EQUAL(array[1], 5);
BOOST_CHECK_EQUAL(array[2], 3);
BOOST_CHECK_EQUAL(array[3], 4);
BOOST_CHECK_EQUAL(array.size(), 4);
}
BOOST_AUTO_TEST_CASE(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);
BOOST_CHECK_EQUAL(array[0], 5);
BOOST_CHECK_EQUAL(array[1], 2);
BOOST_CHECK_EQUAL(array[2], 3);
BOOST_CHECK_EQUAL(array[3], 4);
BOOST_CHECK_EQUAL(array.size(), 4);
}
BOOST_AUTO_TEST_CASE(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));
BOOST_CHECK_EQUAL(array[0], 2);
BOOST_CHECK_EQUAL(array[1], 3);
BOOST_CHECK_EQUAL(array[2], 4);
BOOST_CHECK_EQUAL(array[3], 5);
BOOST_CHECK_EQUAL(array.size(), 4);
}
BOOST_AUTO_TEST_CASE(random_access)
{
Array<uint8> array;
array.add(4);
array.add(5);
array.add(6);
BOOST_CHECK_EQUAL(array[2], 6);
BOOST_CHECK_EQUAL(array[0], 4);
}
BOOST_AUTO_TEST_CASE(copy)
{
Array<uint8> array;
array.add(0);
array.add(1);
array.add(2);
array.add(3);
Array<uint8> copy = array;
BOOST_CHECK_EQUAL_COLLECTIONS(array.begin(), array.end(), copy.begin(), copy.end());
Array<uint8> copy2(copy);
BOOST_CHECK_EQUAL_COLLECTIONS(array.begin(), array.end(), copy2.begin(), copy2.end());
}
class BaseElement
{
uint64 test;
};
class BaseContainer
{
Array<BaseElement> elements;
};
class DerivedContainer : public BaseContainer
{
uint64 test;
};
BOOST_AUTO_TEST_CASE(virtual_classes)
{
Array<DerivedContainer> array(64);
for(uint32 i = 0; i < 100; ++i)
{
Array<DerivedContainer> copy = array;
BOOST_CHECK_EQUAL(array.size(), copy.size());
}
}
class TestStruct
{
public:
uint32 data;
~TestStruct()
{
data = 1;
}
};
DECLARE_REF(TestStruct);
BOOST_AUTO_TEST_CASE(refptr_interaction)
{
uint32* dataPtr;
{
PTestStruct test = new TestStruct();
test->data = 32123;
dataPtr = &test->data;
{
Array<PTestStruct> arr(1);
arr[0] = test;
}
BOOST_CHECK_EQUAL(test->data, 32123);
}
}
BOOST_AUTO_TEST_SUITE_END()
BOOST_AUTO_TEST_SUITE(StaticArray_Suite)
BOOST_AUTO_TEST_CASE(empty_constructur)
{
StaticArray<uint8, 2> array;
BOOST_CHECK_EQUAL(array.size(), 2);
}
BOOST_AUTO_TEST_CASE(initialial_size)
{
StaticArray<uint8, 3> array(3);
BOOST_CHECK_EQUAL(array.size(), 3);
BOOST_CHECK_EQUAL(array[1], 3);
}
BOOST_AUTO_TEST_CASE(random_access)
{
StaticArray<uint8, 3> array;
array[0] = 4;
array[1] = 5;
array[2] = 6;
BOOST_CHECK_EQUAL(array[0], 4);
BOOST_CHECK_EQUAL(array[2], 6);
}
BOOST_AUTO_TEST_SUITE_END()
test/Engine/Containers/Map.cpp
-95
View File
@@ -1,95 +0,0 @@
#include "EngineTest.h"
#include "Containers/Map.h"
#include <boost/test/unit_test.hpp>
using namespace Seele;
BOOST_AUTO_TEST_SUITE(CachedMap)
BOOST_AUTO_TEST_CASE(insert_find_basic)
{
Map<int, int> map;
map[2] = 3;
map[1] = 5;
map[6] = 4;
map[4] = 7;
BOOST_REQUIRE_EQUAL(map[2], 3);
BOOST_REQUIRE_EQUAL(map[1], 5);
BOOST_REQUIRE_EQUAL(map[6], 4);
BOOST_REQUIRE_EQUAL(map[4], 7);
map[2] = 5;
map[4] = 4;
BOOST_REQUIRE_EQUAL(map[2], 5);
BOOST_REQUIRE_EQUAL(map[4], 4);
BOOST_REQUIRE_EQUAL(map.find(2)->value, 5);
BOOST_REQUIRE_EQUAL(map.find(4)->value, 4);
//BOOST_REQUIRE_EQUAL(map.find(5), map.end());
}
BOOST_AUTO_TEST_CASE(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++;
}
BOOST_REQUIRE_EQUAL(count, 4);
}
BOOST_AUTO_TEST_CASE(remove_entry)
{
Map<int, int> map;
map[1] = 5;
map[4] = 1;
map[2] = 6;
map[3] = 4;
map.erase(2);
BOOST_REQUIRE_EQUAL(map.size(), 3);
BOOST_REQUIRE_EQUAL(map[1], 5);
BOOST_REQUIRE_EQUAL(map[4], 1);
BOOST_REQUIRE_EQUAL(map[3], 4);
}
BOOST_AUTO_TEST_CASE(key_exists)
{
Map<int, int> map;
map[2] = 3;
BOOST_REQUIRE_EQUAL(map.exists(2), true);
BOOST_REQUIRE_EQUAL(map.exists(4), false);
map.erase(2);
BOOST_REQUIRE_EQUAL(map.exists(2), false);
}
BOOST_AUTO_TEST_CASE(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;
BOOST_REQUIRE_EQUAL(map[Key{ 2 }], 3);
BOOST_REQUIRE_EQUAL(map[Key{ 3 }], 4);
}
BOOST_AUTO_TEST_CASE(string_key)
{
std::map<std::string, int> map;
map["Test"] = 2;
map["Test2"] = 3;
BOOST_REQUIRE_EQUAL(map["Test"], 2);
BOOST_REQUIRE_EQUAL(map["Test2"], 3);
}
BOOST_AUTO_TEST_SUITE_END()
test/Engine/EngineTest.cpp
-119
View File
@@ -1,119 +0,0 @@
#include "EngineTest.h"
#include "MinimalEngine.h"
#define BOOST_TEST_MODULE SeeleEngine
#include <boost/test/unit_test.hpp>
//#include <vld.h>
using namespace Seele;
Seele::GlobalFixture::~GlobalFixture()
{
//getGlobalThreadPool().waitIdle();
}
BOOST_TEST_GLOBAL_FIXTURE(GlobalFixture);
BOOST_AUTO_TEST_SUITE(RefPtr)
struct TestStruct
{
TestStruct()
: data(10)
{
}
virtual ~TestStruct()
{
data = 15;
}
uint32 data;
};
struct DeclStruct;
BOOST_AUTO_TEST_CASE(basic_refcount)
{
{
Seele::RefPtr<TestStruct> ptr = new TestStruct();
BOOST_REQUIRE_EQUAL(ptr->data, 10);
{
Seele::RefPtr<TestStruct> secondPtr = ptr;
BOOST_REQUIRE_EQUAL(secondPtr->data, 10);
BOOST_REQUIRE_EQUAL(ptr->data, 10);
}
BOOST_REQUIRE_EQUAL(ptr->data, 10);
}
}
struct DeclStruct
{
~DeclStruct()
{
data = 10;
}
uint32 data = 20;
};
struct DerivedStruct : public TestStruct
{
DerivedStruct()
:data2(20)
{
}
~DerivedStruct()
{
data2 = 30;
}
uint32 data2;
};
BOOST_AUTO_TEST_CASE(inheritance_cast)
{
Seele::RefPtr<DerivedStruct> backCast;
{
Seele::RefPtr<DerivedStruct> derived = new DerivedStruct();
Seele::RefPtr<TestStruct> base = derived;
BOOST_REQUIRE_EQUAL(base->data, 10);
backCast = base.cast<DerivedStruct>();
BOOST_REQUIRE_EQUAL(backCast->data, 10);
BOOST_REQUIRE_EQUAL(backCast->data2, 20);
}
BOOST_REQUIRE_EQUAL(backCast->data, 10);
BOOST_REQUIRE_EQUAL(backCast->data2, 20);
}
BOOST_AUTO_TEST_CASE(unique_ptr)
{
Seele::UniquePtr<TestStruct> uptr = new TestStruct();
Seele::UniquePtr<TestStruct> uptr2 = std::move(uptr);
BOOST_REQUIRE_EQUAL(uptr2->data, 10);
BOOST_REQUIRE_EQUAL(uptr.isValid(), false);
}
struct ThisReference
{
ThisReference()
{
}
~ThisReference()
{
data = 12;
}
Seele::RefPtr<ThisReference> getRef()
{
return this;
}
uint32 data = 1;
};
BOOST_AUTO_TEST_CASE(this_reference)
{
Seele::RefPtr<ThisReference> ptr2;
{
Seele::RefPtr<ThisReference> ptr = new ThisReference();
BOOST_REQUIRE_EQUAL(ptr->data, 1);
ptr2 = ptr->getRef();
BOOST_REQUIRE_EQUAL(ptr2->data, 1);
ptr2->data = 5;
BOOST_REQUIRE_EQUAL(ptr->data, 5);
}
BOOST_REQUIRE_EQUAL(ptr2->data, 5);
}
BOOST_AUTO_TEST_SUITE_END()
test/Engine/EngineTest.h
-20
View File
@@ -1,20 +0,0 @@
#pragma once
#include <vld.h>
namespace Seele
{
struct GlobalFixture
{
GlobalFixture()
{
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
}
~GlobalFixture();
void setup()
{
}
void teardown()
{
}
};
};
test/Engine/Graphics/GraphicsResources.cpp
-13
View File
@@ -1,13 +0,0 @@
#include "EngineTest.h"
#include "Graphics/Vulkan/VulkanGraphics.h"
#include <boost/test/unit_test.hpp>
using namespace Seele;
BOOST_AUTO_TEST_SUITE(Vulkan)
BOOST_AUTO_TEST_CASE(init)
{
}
BOOST_AUTO_TEST_SUITE_END()
test/Engine/Math/CMakeLists.txt
-4
View File
@@ -1,4 +0,0 @@
target_sources(Seele_unit_tests
PRIVATE
../../../src/Engine/Math/Vector.cpp
Vector.cpp)
test/Engine/Math/Vector.cpp
-46
View File
@@ -1,46 +0,0 @@
#include "EngineTest.h"
#include "Math/Vector.h"
#include <boost/test/unit_test.hpp>
using namespace Seele;
using namespace Seele::Math;
BOOST_AUTO_TEST_SUITE(VectorParse)
BOOST_AUTO_TEST_CASE(parse_vector_basic)
{
const char* str = "float3(0, 0, 0)";
Vector vec = parseVector(str);
BOOST_CHECK_EQUAL(vec.x, 0);
BOOST_CHECK_EQUAL(vec.y, 0);
BOOST_CHECK_EQUAL(vec.z, 0);
}
BOOST_AUTO_TEST_CASE(parse_vector_literal)
{
const char* str = "float3(0.0f, 0.0f, 0.0f)";
Vector vec = parseVector(str);
BOOST_CHECK_EQUAL(vec.x, 0);
BOOST_CHECK_EQUAL(vec.y, 0);
BOOST_CHECK_EQUAL(vec.z, 0);
}
BOOST_AUTO_TEST_CASE(parse_vector_no_literal)
{
const char* str = "float3(0.0, 0.0, 0.0)";
Vector vec = parseVector(str);
BOOST_CHECK_EQUAL(vec.x, 0);
BOOST_CHECK_EQUAL(vec.y, 0);
BOOST_CHECK_EQUAL(vec.z, 0);
}
BOOST_AUTO_TEST_CASE(parse_vector_float)
{
const char* str = "float3(0.01, 0.01f, 0.01f)";
Vector vec = parseVector(str);
BOOST_CHECK_EQUAL(vec.x, 0.01f);
BOOST_CHECK_EQUAL(vec.y, 0.01f);
BOOST_CHECK_EQUAL(vec.z, 0.01f);
}
BOOST_AUTO_TEST_SUITE_END()
test/Engine/Serialization/ArchiveBuffer.cpp
-10
View File
@@ -1,10 +0,0 @@
#include "EngineTest.h"
#include <boost/test/unit_test.hpp>
using namespace Seele;
BOOST_AUTO_TEST_SUITE(SaveLoadKtx)
BOOST_AUTO_TEST_CASE(empty_constructur)
{
}
test/Engine/Serialization/CMakeLists.txt
-3
View File
@@ -1,3 +0,0 @@
target_sources(Seele_unit_tests
PRIVATE
ArchiveBuffer.cpp)
test/Engine/ThreadPool.cpp
-220
View File
@@ -1,220 +0,0 @@
#include "EngineTest.h"
#include "ThreadPool.h"
#include <boost/test/unit_test.hpp>
#include <numeric>
using namespace std::chrono_literals;
BOOST_AUTO_TEST_SUITE(ThreadPool)
/*
uint64 basicAwaitState = 0;
Job basicAwaitFirst()
{
BOOST_REQUIRE_EQUAL(basicAwaitState, 5);
std::this_thread::sleep_for(500ms);
basicAwaitState = 10;
co_return;
}
Job basicAwaitSecond()
{
BOOST_REQUIRE_EQUAL(basicAwaitState, 15);
std::this_thread::sleep_for(500ms);
basicAwaitState = 20;
co_return;
}
Job basicAwaitThird()
{
BOOST_REQUIRE_EQUAL(basicAwaitState, 25);
std::this_thread::sleep_for(500ms);
basicAwaitState = 30;
co_return;
}
Job basicAwaitBase()
{
basicAwaitState = 5;
co_await basicAwaitFirst();
BOOST_REQUIRE_EQUAL(basicAwaitState, 10);
basicAwaitState = 15;
co_await basicAwaitSecond();
BOOST_REQUIRE_EQUAL(basicAwaitState, 20);
basicAwaitState = 25;
co_await basicAwaitThird();
BOOST_REQUIRE_EQUAL(basicAwaitState, 30);
co_return;
}
BOOST_AUTO_TEST_CASE(basic_coawait)
{
basicAwaitBase();
}
uint64 basicThenState = 5;
Job basicThenFirst()
{
BOOST_REQUIRE_EQUAL(basicThenState, 5);
std::this_thread::sleep_for(500ms);
basicThenState = 10;
co_return;
}
Job basicThenSecond()
{
BOOST_REQUIRE_EQUAL(basicThenState, 15);
std::this_thread::sleep_for(500ms);
basicThenState = 20;
co_return;
}
Job basicThenThird()
{
BOOST_REQUIRE_EQUAL(basicThenState, 25);
std::this_thread::sleep_for(500ms);
basicThenState = 30;
co_return;
}
BOOST_AUTO_TEST_CASE(basic_thenchain)
{
basicThenFirst()
.then([]() -> Job
{
BOOST_REQUIRE_EQUAL(basicThenState, 10);
std::this_thread::sleep_for(500ms);
basicThenState = 15;
co_return;
})
.then(basicThenSecond())
.then([]() -> Job
{
BOOST_REQUIRE_EQUAL(basicThenState, 20);
std::this_thread::sleep_for(500ms);
basicThenState = 25;
co_return;
})
.then(basicThenThird())
.then([]() -> Job
{
BOOST_REQUIRE_EQUAL(basicThenState, 30);
co_return;
});
}
*/
uint64 basicAllState1 = 0;
uint64 basicAllState2 = 0;
Job basicAllFirst()
{
std::this_thread::sleep_for(500ms);
basicAllState1 = 10;
co_return;
}
Job basicAllSecond()
{
std::this_thread::sleep_for(500ms);
basicAllState2 = 10;
co_return;
}
Job basicAllThen()
{
BOOST_REQUIRE_EQUAL(basicAllState1, 10);
BOOST_REQUIRE_EQUAL(basicAllState2, 10);
co_return;
}
BOOST_AUTO_TEST_CASE(basic_all)
{
Job allJob = Job::all(basicAllFirst(), basicAllSecond());
allJob.then(basicAllThen());
}
/*
uint64 allThenState = 0;
Job allThenInitial()
{
std::this_thread::sleep_for(500ms);
allThenState = 10;
co_return;
}
Job allThenIntermediate()
{
std::this_thread::sleep_for(500ms);
BOOST_REQUIRE_EQUAL(allThenState, 10);
allThenState = 20;
co_return;
}
Job allThenFinal()
{
BOOST_REQUIRE_EQUAL(allThenState, 20);
co_return;
}
BOOST_AUTO_TEST_CASE(all_then_interaction)
{
Job::all(allThenInitial())
.then(allThenIntermediate())
.then(Job::all(allThenFinal()));
}
uint64 basicCallable = 0;
Job basicCallableFunc()
{
std::this_thread::sleep_for(500ms);
basicCallable = 10;
co_return;
}
BOOST_AUTO_TEST_CASE(basic_callable)
{
basicCallableFunc()
.then([=]() -> Job
{
BOOST_REQUIRE_EQUAL(basicCallable, 10);
co_return;
});
}
struct Payload
{
StaticArray<uint64, 1000> data;
uint64 result = 0;
};
Job worker(Payload& payload)
{
for(uint32 i = 0; i < 100000; ++i)
{
payload.result = std::accumulate(payload.data.begin(), payload.data.end(), (uint64)1, std::multiplies<uint64>());
}
co_return;
}
Job launchStressTest()
{
Array<Payload> payloads(100);
Array<Job> jobs;
for(auto& payload : payloads)
{
for(uint64 i = 0; i < payload.data.size(); ++i)
{
payload.data[i] = i;
}
}
auto startTime = std::chrono::high_resolution_clock::now();
std::cout << "Starting up" << std::endl;
co_await Job::launchJobs(&worker, payloads);
std::cout << "Finished waiting" << std::endl;
auto endTime = std::chrono::high_resolution_clock::now();
float delta = std::chrono::duration_cast<std::chrono::seconds>(endTime - startTime).count();
std::cout << "Update took " << delta << " seconds";
}
BOOST_AUTO_TEST_CASE(stress_test)
{
launchStressTest();
}*/
BOOST_AUTO_TEST_SUITE_END()
tests/CMakeLists.txt
+14
View File
@@ -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
+10
View File
@@ -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
+195
View File
@@ -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);
}
test/Engine/Containers/CMakeLists.txt → tests/Engine/Containers/CMakeLists.txt
+1 -1
View File
@@ -1,4 +1,4 @@
target_sources(Seele_unit_tests
target_sources(SeeleUnitTests
PRIVATE
Array.cpp
Map.cpp
test/Engine/Containers/List.cpp → tests/Engine/Containers/List.cpp
+14 -19
View File
@@ -1,23 +1,20 @@
#include "EngineTest.h"
#include "Containers/List.h"
#include <boost/test/unit_test.hpp>
using namespace Seele;
BOOST_AUTO_TEST_SUITE(List_Suite)
BOOST_AUTO_TEST_CASE(basic_add)
TEST(ListSuite, basic_add)
{
List<int> list;
list.add(2);
BOOST_REQUIRE_EQUAL(list.size(), 1);
ASSERT_EQ(list.size(), 1);
list.add(4);
BOOST_REQUIRE_EQUAL(list.size(), 2);
ASSERT_EQ(list.size(), 2);
List<int>::Iterator it = list.find(2);
BOOST_REQUIRE_EQUAL(*it, 2);
ASSERT_EQ(*it, 2);
}
BOOST_AUTO_TEST_CASE(basic_insert)
TEST(ListSuite, basic_insert)
{
List<int> list;
list.add(2);
@@ -25,10 +22,10 @@ BOOST_AUTO_TEST_CASE(basic_insert)
list.add(4);
List<int>::Iterator it = list.find(3);
it = list.insert(it, 1);
BOOST_REQUIRE_EQUAL(*it, 1);
BOOST_REQUIRE_EQUAL(list.size(), 4);
ASSERT_EQ(*it, 1);
ASSERT_EQ(list.size(), 4);
}
BOOST_AUTO_TEST_CASE(basic_remove)
TEST(ListSuite, basic_remove)
{
List<int> list;
list.add(2);
@@ -36,11 +33,11 @@ BOOST_AUTO_TEST_CASE(basic_remove)
list.add(4);
List<int>::Iterator it = list.find(3);
it = list.remove(it);
BOOST_REQUIRE_EQUAL(*it, 4);
BOOST_REQUIRE_EQUAL(list.size(), 2);
ASSERT_EQ(*it, 4);
ASSERT_EQ(list.size(), 2);
}
BOOST_AUTO_TEST_CASE(list_join)
TEST(ListSuite, list_join)
{
List<int> list1;
List<int> list2;
@@ -53,9 +50,7 @@ BOOST_AUTO_TEST_CASE(list_join)
list2.add(8);
list2.add(6);
list2.add(9);
list1.moveElements(list2);
BOOST_REQUIRE_EQUAL(list1.size(), 9);
BOOST_REQUIRE_EQUAL(list2.size(), 0);
list1.moveElements(std::move(list2));
ASSERT_EQ(list1.size(), 9);
ASSERT_EQ(list2.size(), 0);
}
BOOST_AUTO_TEST_SUITE_END()
tests/Engine/Containers/Map.cpp
+91
View File
@@ -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
+5
View File
@@ -0,0 +1,5 @@
#pragma once
#include <gtest/gtest.h>
#include "MinimalEngine.h"
using namespace Seele;
test/Engine/Graphics/CMakeLists.txt → tests/Engine/Graphics/CMakeLists.txt
+1 -1
View File
@@ -1,4 +1,4 @@
target_sources(Seele_unit_tests
target_sources(SeeleUnitTests
PRIVATE
GraphicsResources.cpp)
tests/Engine/Graphics/GraphicsResources.cpp
+2
View File
@@ -0,0 +1,2 @@
#include "EngineTest.h"
#include "Graphics/Vulkan/Graphics.h"
tests/Engine/Math/CMakeLists.txt
+3
View File
@@ -0,0 +1,3 @@
target_sources(SeeleUnitTests
PRIVATE
Vector.cpp)
tests/Engine/Math/Vector.cpp
+38
View File
@@ -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
+1
View File
@@ -0,0 +1 @@
#include "EngineTest.h"
tests/Engine/Serialization/CMakeLists.txt
+3
View File
@@ -0,0 +1,3 @@
target_sources(SeeleUnitTests
PRIVATE
ArchiveBuffer.cpp)
tests/Engine/ThreadPool.cpp
+22
View File
@@ -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);
}
vcpkg.json
+2 -1
View File
@@ -9,6 +9,7 @@
"glm",
"ktx",
"nlohmann-json",
"shader-slang"
"shader-slang",
"gtest"
]
}