From b4b64abc1ec6224ccf13bf7afcbf56a700be20ad Mon Sep 17 00:00:00 2001 From: sippeangelo Date: Tue, 1 Dec 2015 09:51:15 +0100 Subject: [PATCH 1/8] Made Rendering/Util visible to CMake project --- src/Engine/CMakeLists.txt | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/Engine/CMakeLists.txt b/src/Engine/CMakeLists.txt index 861573a3..7bc15041 100644 --- a/src/Engine/CMakeLists.txt +++ b/src/Engine/CMakeLists.txt @@ -48,7 +48,12 @@ file(GLOB SOURCE_FILES_Rendering "${INCLUDE_PATH}/Rendering/*.h" "Rendering/*.cpp" ) +file(GLOB SOURCE_FILES_Rendering_Util + "${INCLUDE_PATH}/Rendering/Util/*.h" + "Rendering/Util/*.cpp" +) source_group(Rendering FILES ${SOURCE_FILES_Rendering}) +source_group(Rendering\\Util FILES ${SOURCE_FILES_Rendering_Util}) file(GLOB SOURCE_FILES_GUI "${INCLUDE_PATH}/GUI/*.h" From cf349870dee05907d92c130463d9815558d93283 Mon Sep 17 00:00:00 2001 From: sippeangelo Date: Tue, 1 Dec 2015 10:40:33 +0100 Subject: [PATCH 2/8] Simplified CMake for Game --- src/Game/CMakeLists.txt | 20 +------------------- 1 file changed, 1 insertion(+), 19 deletions(-) diff --git a/src/Game/CMakeLists.txt b/src/Game/CMakeLists.txt index 2fceae1e..b513fa92 100644 --- a/src/Game/CMakeLists.txt +++ b/src/Game/CMakeLists.txt @@ -1,31 +1,13 @@ project(TacticalZ-Game) -find_package(OpenGL REQUIRED) -find_package(GLEW REQUIRED) -find_package(GLFW REQUIRED) find_package(Boost REQUIRED COMPONENTS system filesystem thread chrono) -find_package(assimp REQUIRED) -find_package(ZLIB REQUIRED) -find_package(PNG REQUIRED) -# Because FindOpenAL is retarded -#set(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} "${CMAKE_SOURCE_DIR}/deps/include/AL") -#find_package(OpenAL REQUIRED) -if(UNIX) - find_package(X11 REQUIRED) -endif() set(INCLUDE_PATH ${CMAKE_SOURCE_DIR}/include/Game) include_directories( ${CMAKE_SOURCE_DIR}/include/Engine + ${CMAKE_SOURCE_DIR}/deps/include ${INCLUDE_PATH} - ${OPENGL_INCLUDE_DIR} - ${GLEW_INCLUDE_DIRS} - ${GLFW_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS} - ${assimp_INCLUDE_DIRS} - ${PNG_INCLUDE_DIRS} - ${OPENAL_INCLUDE_DIR} - ${X11_INCLUDE_DIRS} ) file(GLOB SOURCE_FILES From ae759654c1cd1221d516018411dea70c7d5a26aa Mon Sep 17 00:00:00 2001 From: sippeangelo Date: Tue, 1 Dec 2015 11:21:33 +0100 Subject: [PATCH 3/8] Made deploy create a bin folder so it doesn't fail if it's missing --- tools/deploy.bat | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/deploy.bat b/tools/deploy.bat index b3f51c07..cdab1c20 100755 --- a/tools/deploy.bat +++ b/tools/deploy.bat @@ -1,6 +1,7 @@ @ECHO off SET DeployLocation=bin\ +MKDIR %DeployLocation% ECHO Deploying assets to %DeployLocation% :: Asset folders From f65b7d591cf39884cb558dd780f66a0bd22d0c7a Mon Sep 17 00:00:00 2001 From: sippeangelo Date: Wed, 2 Dec 2015 15:02:18 +0100 Subject: [PATCH 4/8] Fixed Tests running the game when it really shouldn't. --- src/Game/CMakeLists.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/Game/CMakeLists.txt b/src/Game/CMakeLists.txt index b513fa92..41cc30eb 100644 --- a/src/Game/CMakeLists.txt +++ b/src/Game/CMakeLists.txt @@ -12,12 +12,13 @@ include_directories( file(GLOB SOURCE_FILES "${INCLUDE_PATH}/*.h" - "*.cpp" + #"*.cpp" ) #source_group(Core FILES ${SOURCE_FILES}) set(SOURCE_FILES ${SOURCE_FILES} + "Game.cpp" ) set(LIBRARIES From fd99562c7a7f32301724d92eec105853884156fa Mon Sep 17 00:00:00 2001 From: verysecrethero Date: Wed, 2 Dec 2015 15:03:55 +0100 Subject: [PATCH 5/8] yrryr567yry567 --- include/Engine/Core/Collision.h | 3 +++ src/Engine/Core/Collision.cpp | 23 +++++++++++++++++++++++ src/Tests/CollisionTest.cpp | 18 ++++++++++++++++++ 3 files changed, 44 insertions(+) create mode 100644 src/Tests/CollisionTest.cpp diff --git a/include/Engine/Core/Collision.h b/include/Engine/Core/Collision.h index 113a4a39..f67a1c67 100644 --- a/include/Engine/Core/Collision.h +++ b/include/Engine/Core/Collision.h @@ -2,11 +2,13 @@ #define Collision_h__ #include "../GLM.h" +#include namespace Collision { struct Ray { +public: glm::vec3 Origin; glm::vec3 Direction; }; @@ -29,6 +31,7 @@ private: }; bool RayAABBIntr(const Ray& ray, const AABB& box); +bool RayVsAABB(const Ray& ray, const AABB& box); } #endif \ No newline at end of file diff --git a/src/Engine/Core/Collision.cpp b/src/Engine/Core/Collision.cpp index 4ccd1ccd..fd79b8bc 100644 --- a/src/Engine/Core/Collision.cpp +++ b/src/Engine/Core/Collision.cpp @@ -1,4 +1,5 @@ #include "Core\Collision.h" +#include namespace Collision { @@ -36,4 +37,26 @@ bool RayAABBIntr(const Ray& ray, const AABB& box) return !(abs(c.x*w.y - c.y*w.x) > half.x*v.y + half.y*v.x); } +bool RayVsAABB(const Ray& ray, const AABB& box) +{ + glm::vec3 invdir = 1.0f / ray.Direction; + glm::vec3 bMin = box.MinCorner(); + glm::vec3 bMax = box.MaxCorner(); + + float t1 = (bMin.x - ray.Origin.x)*invdir.x; + float t2 = (bMax.x - ray.Origin.x)*invdir.x; + float t3 = (bMin.y - ray.Origin.y)*invdir.y; + float t4 = (bMax.y - ray.Origin.y)*invdir.y; + float t5 = (bMin.z - ray.Origin.z)*invdir.z; + float t6 = (bMax.z - ray.Origin.z)*invdir.z; + + float tmin = std::max(std::max(std::min(t1, t2), std::min(t3, t4)), std::min(t5, t6)); + float tmax = std::min(std::min(std::max(t1, t2), std::max(t3, t4)), std::max(t5, t6)); + + if (tmax < 0 || tmin > tmax) + return false; + + return true; +} + } \ No newline at end of file diff --git a/src/Tests/CollisionTest.cpp b/src/Tests/CollisionTest.cpp new file mode 100644 index 00000000..ef02cb66 --- /dev/null +++ b/src/Tests/CollisionTest.cpp @@ -0,0 +1,18 @@ +#include +using boost::unit_test_framework::test_suite; +using boost::unit_test_framework::test_case; +#include + +BOOST_AUTO_TEST_SUITE(collisionTests) + +BOOST_AUTO_TEST_CASE(collisionTest) +{ + Collision::Ray ray; + ray.Origin = glm::vec3(0, 0, 0); + ray.Direction = glm::vec3(0, 0, 0); + auto someAABB = Collision::AABB(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0)); + bool z = Collision::RayVsAABB(ray, someAABB); +} + +BOOST_AUTO_TEST_SUITE_END() + From 91f8b4359b8ee108eb6767c47b8bc7ff79f5c2a8 Mon Sep 17 00:00:00 2001 From: sippeangelo Date: Wed, 2 Dec 2015 15:25:27 +0100 Subject: [PATCH 6/8] Fixed Tests not including dependencies properly --- src/Game/CMakeLists.txt | 2 +- src/Tests/.gitkeep | 0 src/Tests/CMakeLists.txt | 9 +++++---- 3 files changed, 6 insertions(+), 5 deletions(-) delete mode 100755 src/Tests/.gitkeep diff --git a/src/Game/CMakeLists.txt b/src/Game/CMakeLists.txt index 41cc30eb..c21aaa8a 100644 --- a/src/Game/CMakeLists.txt +++ b/src/Game/CMakeLists.txt @@ -4,8 +4,8 @@ find_package(Boost REQUIRED COMPONENTS system filesystem thread chrono) set(INCLUDE_PATH ${CMAKE_SOURCE_DIR}/include/Game) include_directories( - ${CMAKE_SOURCE_DIR}/include/Engine ${CMAKE_SOURCE_DIR}/deps/include + ${CMAKE_SOURCE_DIR}/include/Engine ${INCLUDE_PATH} ${Boost_INCLUDE_DIRS} ) diff --git a/src/Tests/.gitkeep b/src/Tests/.gitkeep deleted file mode 100755 index e69de29b..00000000 diff --git a/src/Tests/CMakeLists.txt b/src/Tests/CMakeLists.txt index 306d5fdd..697dea29 100644 --- a/src/Tests/CMakeLists.txt +++ b/src/Tests/CMakeLists.txt @@ -2,11 +2,12 @@ project(TacticalZ-Tests) find_package(Boost REQUIRED COMPONENTS chrono thread unit_test_framework) -set(INCLUDE_PATH ${CMAKE_SOURCE_DIR}/include) +set(INCLUDE_PATH ${CMAKE_SOURCE_DIR}/include/Tests) include_directories( - ${INCLUDE_PATH}/Engine - ${INCLUDE_PATH}/Game - ${INCLUDE_PATH}/Tests + ${CMAKE_SOURCE_DIR}/deps/include + ${CMAKE_SOURCE_DIR}/include/Engine + ${CMAKE_SOURCE_DIR}/include/Game + ${INCLUDE_PATH} ${Boost_INCLUDE_DIRS} ) From af294f78b7622ac5ec0ad21faa2ef571bb9fb5c3 Mon Sep 17 00:00:00 2001 From: verysecrethero Date: Wed, 2 Dec 2015 16:26:30 +0100 Subject: [PATCH 7/8] czdxvxdfvxvxvc --- src/Engine/Core/Collision.cpp | 16 ++++----- src/Tests/CollisionTest.cpp | 64 ++++++++++++++++++++++++++++++++--- 2 files changed, 67 insertions(+), 13 deletions(-) diff --git a/src/Engine/Core/Collision.cpp b/src/Engine/Core/Collision.cpp index fd79b8bc..ff38c8a2 100644 --- a/src/Engine/Core/Collision.cpp +++ b/src/Engine/Core/Collision.cpp @@ -40,15 +40,13 @@ bool RayAABBIntr(const Ray& ray, const AABB& box) bool RayVsAABB(const Ray& ray, const AABB& box) { glm::vec3 invdir = 1.0f / ray.Direction; - glm::vec3 bMin = box.MinCorner(); - glm::vec3 bMax = box.MaxCorner(); - - float t1 = (bMin.x - ray.Origin.x)*invdir.x; - float t2 = (bMax.x - ray.Origin.x)*invdir.x; - float t3 = (bMin.y - ray.Origin.y)*invdir.y; - float t4 = (bMax.y - ray.Origin.y)*invdir.y; - float t5 = (bMin.z - ray.Origin.z)*invdir.z; - float t6 = (bMax.z - ray.Origin.z)*invdir.z; + + float t1 = (box.MinCorner().x - ray.Origin.x)*invdir.x; + float t2 = (box.MaxCorner().x - ray.Origin.x)*invdir.x; + float t3 = (box.MinCorner().y - ray.Origin.y)*invdir.y; + float t4 = (box.MaxCorner().y - ray.Origin.y)*invdir.y; + float t5 = (box.MinCorner().z - ray.Origin.z)*invdir.z; + float t6 = (box.MaxCorner().z - ray.Origin.z)*invdir.z; float tmin = std::max(std::max(std::min(t1, t2), std::min(t3, t4)), std::min(t5, t6)); float tmax = std::min(std::min(std::max(t1, t2), std::max(t3, t4)), std::max(t5, t6)); diff --git a/src/Tests/CollisionTest.cpp b/src/Tests/CollisionTest.cpp index ef02cb66..426b9722 100644 --- a/src/Tests/CollisionTest.cpp +++ b/src/Tests/CollisionTest.cpp @@ -2,16 +2,72 @@ using boost::unit_test_framework::test_suite; using boost::unit_test_framework::test_case; #include +#include //srand BOOST_AUTO_TEST_SUITE(collisionTests) BOOST_AUTO_TEST_CASE(collisionTest) { + //fixed seed + srand(2); Collision::Ray ray; - ray.Origin = glm::vec3(0, 0, 0); - ray.Direction = glm::vec3(0, 0, 0); - auto someAABB = Collision::AABB(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0)); - bool z = Collision::RayVsAABB(ray, someAABB); + Collision::AABB someAABB; + glm::vec3 minPos; + glm::vec3 maxPos; + bool z; + int test = 0; + for (size_t i = 0; i < 1000000; i++) + { + ray.Origin.x = rand() % 100; + ray.Origin.y = rand() % 100; + ray.Origin.z = rand() % 100; + ray.Direction.x = rand() % 100; + ray.Direction.y = rand() % 100; + ray.Direction.z = rand() % 100; + minPos.x = rand() % 100; + minPos.y = rand() % 100; + minPos.z = rand() % 100; + maxPos.x = rand() % 100; + maxPos.y = rand() % 100; + maxPos.z = rand() % 100; + + someAABB = Collision::AABB(minPos, maxPos); + z = Collision::RayVsAABB(ray, someAABB); + if (z) ++test; + } + BOOST_CHECK(test >= 0); +} + +BOOST_AUTO_TEST_CASE(collisionTest2) +{ + //fixed seed + srand(2); + Collision::Ray ray; + Collision::AABB someAABB; + glm::vec3 minPos; + glm::vec3 maxPos; + bool z; + int test = 0; + for (size_t i = 0; i < 1000000; i++) + { + ray.Origin.x = rand() % 100; + ray.Origin.y = rand() % 100; + ray.Origin.z = rand() % 100; + ray.Direction.x = rand() % 100; + ray.Direction.y = rand() % 100; + ray.Direction.z = rand() % 100; + minPos.x = rand() % 100; + minPos.y = rand() % 100; + minPos.z = rand() % 100; + maxPos.x = rand() % 100; + maxPos.y = rand() % 100; + maxPos.z = rand() % 100; + + someAABB = Collision::AABB(minPos, maxPos); + z = Collision::RayAABBIntr(ray, someAABB); + if (z) ++test; + } + BOOST_CHECK(test >= 0); } BOOST_AUTO_TEST_SUITE_END() From 464650c370e78ef13baa01b38fc9c3ff6972f695 Mon Sep 17 00:00:00 2001 From: verysecrethero Date: Wed, 2 Dec 2015 16:31:39 +0100 Subject: [PATCH 8/8] more tests added --- src/Tests/ObjectPoolTest.cpp | 476 +++++++++++++++++++++++++++++++++++ 1 file changed, 476 insertions(+) create mode 100644 src/Tests/ObjectPoolTest.cpp diff --git a/src/Tests/ObjectPoolTest.cpp b/src/Tests/ObjectPoolTest.cpp new file mode 100644 index 00000000..adea33eb --- /dev/null +++ b/src/Tests/ObjectPoolTest.cpp @@ -0,0 +1,476 @@ +#include +using boost::unit_test_framework::test_suite; +using boost::unit_test_framework::test_case; +#include "../wmem/MemPrototype/ObjectPool.h" +#include + +struct S +{ + S() = default; + S(int i, float ff) : k(i), f(ff) { } + ~S() { } + int k; + float f; +}; + +//BOOST_GLOBAL_FIXTURE(S); +BOOST_AUTO_TEST_SUITE(memProtoTypeTestSuite) + +BOOST_AUTO_TEST_CASE(testPool) +{ + ObjectPool pool(32);//32 true/false values = 32 slots + BOOST_CHECK(pool.empty() == true); + + const size_t size = 12;//12 platser i structen addresses, som håller en int, en float vardera + S* addresses[size]; + addresses[0] = pool.New(7, 0.035f); + //"Not empty after allocating one element." + BOOST_CHECK(!pool.empty()); + + //"Element created correctly with k==7" + BOOST_CHECK(addresses[0]->k == 7); + //"Element created correctly with f==0.035f" + BOOST_CHECK_CLOSE_FRACTION(addresses[0]->f, 0.035f, 0.0001f); + addresses[0]->k = 5; + BOOST_CHECK(addresses[0]->k == 5); + + //"Empty after delete" + pool.Delete(addresses[0]); + BOOST_CHECK(pool.empty()); + + addresses[0] = pool.New(7, 0.035f); + addresses[1] = pool.New(5, 0.035f); + pool.Delete(addresses[1]); + BOOST_CHECK(!pool.empty()); + pool.Delete(addresses[0]); + BOOST_CHECK(pool.empty()); + + //INT32_MAX, FLT_MAX test + addresses[0] = pool.New(INT32_MAX, FLT_MAX); + BOOST_CHECK(!pool.empty()); + BOOST_CHECK(addresses[0]->k == INT32_MAX); + BOOST_CHECK_CLOSE_FRACTION(addresses[0]->f, FLT_MAX, 0.0001f); +} +/* +BOOST_AUTO_TEST_CASE(testPoolArray) +{ +ObjectPool pool(32); +S* addresses; + +//Add array size 5 to pool." +addresses = pool.NewArray(5);// <-> addresses = new S[5]; +addresses[0] = S(12, 0.030f); +addresses[1] = S(13, 0.031f); +addresses[2] = S(14, 0.032f); +addresses[3] = S(15, 0.033f); +addresses[4] = S(16, 0.034f); + +//"Not empty after allocating +BOOST_CHECK(!pool.empty()); +//"Element created correctly with k==12" +BOOST_CHECK(addresses->k == 12); +//"Element created correctly with f==0.030f" +BOOST_CHECK_CLOSE_FRACTION(addresses->f, 0.030f, 0.0001f); + +//add a few other structs so it becomes bigger than the original size (32), +//which means it must push back the rest of the values into a vector +S* test2, *test3, *test4, *test5; +test2 = pool.NewArray(5);// <-> test2 = new S[5]; +test3 = pool.NewArray(40);//+40 +test4 = pool.NewArray(40);//+40 +test5 = pool.NewArray(40);//+40=120 +BOOST_CHECK(pool.ExtraSize() == 120); +BOOST_CHECK(pool.PoolSize() == 10); +BOOST_CHECK(pool.size() == 120 + 10); + +//testar "perfekt delete", dvs bryr mig inte om att testa att deleta bara 38 om storleken egentligen är 40 osv +pool.DeleteArray(test2, 5);//callar destructorn på test2 också +pool.DeleteArray(test3, 40); + +pool.DeleteArray(addresses, 5); + +//add / del array +S* another = pool.NewArray(64); +for (int i = 0; i < 64; ++i) +another[i] = S(i, 0.1f*i); +pool.DeleteArray(another, 64); +} +*/ +BOOST_AUTO_TEST_CASE(testIterationNormal) +{ + //extra vector check + S* test4, *test5; + ObjectPool pool(4); + test4 = pool.New(); + test5 = pool.New(); + //Check so iterate over pool doesn't throw compile-time errors. + for (auto &o : pool) + o.k = 14; + for (size_t i = 0; i < 1; ++i) + BOOST_CHECK(test4[i].k == 14); + for (size_t i = 0; i < 1; ++i) + BOOST_CHECK(test5[i].k == 14); +} + +BOOST_AUTO_TEST_CASE(testOutOfScopeDelete) +{ + //extra vector check + S* test4, *test5; + { + ObjectPool pool(4); + test4 = pool.New(); + test5 = pool.New(); + //Check so iterate over pool doesn't throw compile-time errors. + for (auto &o : pool) + o.k = 14; + for (size_t i = 0; i < 1; ++i) + BOOST_CHECK(test4[i].k == 14); + for (size_t i = 0; i < 1; ++i) + BOOST_CHECK(test5[i].k == 14); + } + //pool goes out of scope here, and thus the test4 values become undefined (memory is killed at out of scope) + BOOST_CHECK(test4[0].k != 14); + BOOST_CHECK(test5[0].k != 15); +} + +BOOST_AUTO_TEST_CASE(testIterationOneExtra) +{ + //extra vector check + ObjectPool pool(1); + S* test4, *test5; + test4 = pool.New(); + test5 = pool.New(); + //Check so iterate over pool doesn't throw compile-time errors. + for (auto &o : pool) + o.k = 14; + for (size_t i = 0; i < 1; ++i) + BOOST_CHECK(test4[i].k == 14); + for (size_t i = 0; i < 1; ++i) + BOOST_CHECK(test5[i].k == 14); +} + +BOOST_AUTO_TEST_CASE(testIterationTwoExtra) +{ + //extra vector check + ObjectPool pool(1); + S* test4, *test5; + test4 = pool.New(); + test5 = pool.New(); + //Check so iterate over pool doesn't throw compile-time errors. + for (auto &o : pool) + o.k = 14; + for (size_t i = 0; i < 1; ++i) + BOOST_CHECK(test4[i].k == 14); + for (size_t i = 0; i < 1; ++i) + BOOST_CHECK(test5[i].k == 14); +} +/* +BOOST_AUTO_TEST_CASE(releaseModeTest_RandomAllocateDeallocate) +{ +//run this in releasemode +struct I +{ +I() = default; +I(size_t i, size_t ff) : k(i), f(ff) { } +~I() { } +size_t k; +size_t f; +}; +srand((unsigned int)time(nullptr)); + +const size_t SIZE = 128; +ObjectPool pool(SIZE); +I* addresses[SIZE]; +std::vector allocated(SIZE, false); +std::vector arrSizes(SIZE, 0); +size_t slotsAlloced = 0; +size_t superCount = 0; +size_t slot; +size_t i; + +while (superCount++ < 1000) { +if (rand() % 2 == 0) { +i = 0; +//ta slumpmässig slot som inte är allokerad +do { +slot = (size_t)((SIZE - 1) * ((float)rand() / RAND_MAX)); +} while (allocated[slot] && ++i < 512); + +if (i < 512) { +arrSizes[slot] = 1 + (size_t)((24 - 1) * ((float)rand() / RAND_MAX)); +addresses[slot] = pool.NewArray(arrSizes[slot]); +for (size_t a = 0; a < arrSizes[slot]; ++a) +addresses[slot][a] = I(slot, a); +allocated[slot] = true; +++slotsAlloced; +} +} +//Deallocate +else { +i = 0; +//ta slumpmässig slot som är allokerad +do { +slot = (size_t)((SIZE - 1) * ((float)rand() / RAND_MAX)); +} while (!allocated[slot] && ++i < 512); + +if (i < 512) { +pool.DeleteArray(addresses[slot], arrSizes[slot]); +arrSizes[slot] = 0; +allocated[slot] = false; +--slotsAlloced; +} +} +//Check content. +for (size_t a = 0; a < SIZE; ++a) { +if (allocated[a]) { +for (size_t e = 0; e < arrSizes[a]; ++e) { +BOOST_CHECK(!(addresses[a][e].k != a || addresses[a][e].f != e)); +} +} +} +} +} +*/ + +BOOST_AUTO_TEST_CASE(testConstructors) +{ + //http://stackoverflow.com/questions/357929/is-it-important-to-unit-test-a-constructor + //"If your constructor has, for example, an if (condition), you need to test both flows (true,false). + //If your constructor does some kind of job before setting. You should check the job is done" + + //testing the constructors with different T values and a small check so size is initialized to 0 + MemoryPool memPoolI; + BOOST_CHECK(memPoolI.empty()); + BOOST_CHECK(memPoolI.size() == 0); + MemoryPool memPoolF; + BOOST_CHECK(memPoolF.empty()); + BOOST_CHECK(memPoolF.size() == 0); + MemoryPool memPoolD; + BOOST_CHECK(memPoolD.empty()); + BOOST_CHECK(memPoolD.size() == 0); + MemoryPool memPoolS; + BOOST_CHECK(memPoolS.empty()); + BOOST_CHECK(memPoolS.size() == 0); + + ObjectPool objPoolI(64); + BOOST_CHECK(objPoolI.empty()); + BOOST_CHECK(objPoolI.size() == 0); + ObjectPool objPoolF(32); + BOOST_CHECK(objPoolF.empty()); + BOOST_CHECK(objPoolF.size() == 0); + ObjectPool objPoolD(16); + BOOST_CHECK(objPoolD.empty()); + BOOST_CHECK(objPoolD.size() == 0); + ObjectPool objPoolS(128); + BOOST_CHECK(objPoolS.empty()); + BOOST_CHECK(objPoolS.size() == 0); +} + +BOOST_AUTO_TEST_CASE(testOperators) +{ + ObjectPool pool(100); + // S* s[12] = pool.NewArray(12); + S* s[12]; + s[0] = pool.New(); + s[11] = pool.New(); + + s[0]->k = 2; + s[11]->k = 3; + //testing operators: ++i,!= + auto& iter = pool.begin(); + for (iter; iter != pool.end(); ++iter) { + //testing operators:*,== + auto dereferencedIterator = *iter; + if (iter == pool.begin()) { + BOOST_CHECK(dereferencedIterator.k == 2); + } + if (iter == pool.end()) { + BOOST_CHECK(dereferencedIterator.k == 3); + } + //testing operators:-> + iter->k += 2; + } + BOOST_CHECK(s[0]->k == 4); + BOOST_CHECK(s[11]->k == 5); + BOOST_CHECK(iter == pool.end()); + + //testing operators:i++ + s[0]->k = 2; + s[11]->k = 2; + for (auto& iter = pool.begin(); iter != pool.end(); iter++) + iter->k += 2; + BOOST_CHECK(s[0]->k == 4); + BOOST_CHECK(s[11]->k == 4); +} +/* +BOOST_AUTO_TEST_CASE(testBranchFree) +{ +//testing Free , which is the only untested +//via delete/deletearray + +//1. no extra memory delete +ObjectPool pool(32);//32 true/false values = 32 slots +S* addresses[12]; +addresses[0] = pool.New(7, 0.035f); +pool.Delete(addresses[0]); +BOOST_CHECK(pool.empty()); + +//1b. no extra memory deleteArray +ObjectPool pool1b(32);//32 true/false values = 32 slots +S* test1b; +test1b = pool1b.NewArray(5);// <-> test2 = new S[5]; +BOOST_CHECK(pool1b.size() == 5); +pool1b.DeleteArray(test1b, 5);//callar destructorn på test2 också +BOOST_CHECK(pool1b.empty()); + +//2. extra memory delete +ObjectPool pool2(2); +S* addresses2[12]; +addresses2[0] = pool2.New(7, 0.035f); +addresses2[1] = pool2.New(7, 0.035f); +addresses2[2] = pool2.New(7, 0.035f); +addresses2[3] = pool2.New(7, 0.035f); +addresses2[4] = pool2.New(7, 0.035f); +BOOST_CHECK(pool2.size() == 5); +pool2.Delete(addresses2[0]); +BOOST_CHECK(pool2.size() == 4); +pool2.Delete(addresses2[1]); +BOOST_CHECK(pool2.size() == 3); +pool2.Delete(addresses2[2]); +BOOST_CHECK(pool2.size() == 2); +pool2.Delete(addresses2[3]); +BOOST_CHECK(pool2.size() == 1); +pool2.Delete(addresses2[4]); +BOOST_CHECK(pool2.empty()); +//reverse delete +addresses2[0] = pool2.New(7, 0.035f); +addresses2[1] = pool2.New(7, 0.035f); +addresses2[2] = pool2.New(7, 0.035f); +addresses2[3] = pool2.New(7, 0.035f); +addresses2[4] = pool2.New(7, 0.035f); +BOOST_CHECK(pool2.size() == 5); +pool2.Delete(addresses2[4]); +BOOST_CHECK(pool2.size() == 4); +pool2.Delete(addresses2[3]); +BOOST_CHECK(pool2.size() == 3); +pool2.Delete(addresses2[2]); +BOOST_CHECK(pool2.size() == 2); +pool2.Delete(addresses2[1]); +BOOST_CHECK(pool2.size() == 1); +pool2.Delete(addresses2[0]); +BOOST_CHECK(pool2.empty()); + +//2b. extra memory deleteArray +ObjectPool pool2b(32);//32 true/false values = 32 slots +S* test2b,*test2bb; +test2b = pool2b.NewArray(5);// <-> test2 = new S[5]; +BOOST_CHECK(pool2b.size() == 5); +test2bb = pool2b.NewArray(40);// <-> test2 = new S[5]; +BOOST_CHECK(pool2b.size() == 45); +pool2b.DeleteArray(test2b, 5);//callar destructorn på test2 också +BOOST_CHECK(pool2b.size() == 40); +pool2b.DeleteArray(test2bb, 40);//callar destructorn på test2 också +BOOST_CHECK(pool2b.empty()); +} +*/ +BOOST_AUTO_TEST_CASE(testBranchAllocate) +{ + //1 slot else many slots + //see testBranchFree + + //out of mem vs not out of mem allocate + //see testBranchFree +} +BOOST_AUTO_TEST_CASE(testEdgeCase) +{ + //test with a very small pool + ObjectPool pool(1); + BOOST_CHECK(pool.empty()); + S* test4; + test4 = pool.New(7, 0.035f); + BOOST_CHECK(!pool.empty()); + BOOST_CHECK(test4->k == 7); + BOOST_CHECK_CLOSE_FRACTION(test4->f, 0.035f, 0.0001f); + + //test with a very small pool and array, iterating + ObjectPool poolA(1); + S* test5; + test5 = poolA.New(); + //Check so iterate over pool doesn't throw compile-time errors. + for (auto &o : poolA) + o.k = 14; + for (size_t i = 0; i < 1; ++i) + BOOST_CHECK(test5[i].k == 14); +} + +BOOST_AUTO_TEST_CASE(testBadlyAlignedData) +{ + //small test with non-aligned data 4+1bytes + struct S + { + S() = default; + S(float f, char c) : m_f(f), m_c(c) { } + ~S() { } + float m_f; + char m_c; + }; + MemoryPool memPoolS; + BOOST_CHECK(memPoolS.empty()); + BOOST_CHECK(memPoolS.size() == 0); + ObjectPool objPoolS(64); + BOOST_CHECK(objPoolS.empty()); + BOOST_CHECK(objPoolS.size() == 0); + S* test4; + test4 = objPoolS.New(); + //Check so iterate over pool doesn't throw compile-time errors. + for (auto &o : objPoolS) { + o.m_c = 'v'; + o.m_f = 0.15534543f; + } + for (size_t i = 0; i < 1; ++i) { + BOOST_CHECK(test4[i].m_c == 'v'); + BOOST_CHECK_CLOSE_FRACTION(test4[i].m_f, 0.15534543f, 0.0001f); + } +} +BOOST_AUTO_TEST_CASE(testBadlyAlignedData2) +{ + //small test with non-aligned data 1+1+1bytes + struct S + { + S() = default; + S(char c, char c2, char c3) : m_c(c), m_c2(c2), m_c3(c3) { } + ~S() { } + char m_c; + char m_c2; + char m_c3; + }; + MemoryPool memPoolS; + BOOST_CHECK(memPoolS.empty()); + BOOST_CHECK(memPoolS.size() == 0); + ObjectPool objPoolS(64); + BOOST_CHECK(objPoolS.empty()); + BOOST_CHECK(objPoolS.size() == 0); + S* test4; + test4 = objPoolS.New(); + //Check so iterate over pool doesn't throw compile-time errors. + for (auto &o : objPoolS) { + o.m_c = 'v'; + o.m_c2 = 'w'; + o.m_c3 = 'x'; + } + for (size_t i = 0; i < 1; ++i) { + BOOST_CHECK(test4[i].m_c == 'v'); + BOOST_CHECK(test4[i].m_c2 == 'w'); + BOOST_CHECK(test4[i].m_c3 == 'x'); + } +} + +BOOST_AUTO_TEST_CASE(testWrongData) +{ +} +BOOST_AUTO_TEST_CASE(testFillDeleteFillAgain) { + //already done in BOOST_AUTO_TEST_CASE(releaseModeTest_RandomAllocateDeallocate) + +} + +BOOST_AUTO_TEST_SUITE_END()