ThreadPool now working with no memory leaks

test/Engine/EngineTest.h

@@ -1,5 +1,5 @@
 #pragma once
-#include <vld.h>
+//#include <vld.h>
 #include "ThreadPool.h"
 
 namespace Seele
@@ -8,10 +8,11 @@ namespace Seele
     {
         GlobalFixture()
         {
-            _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
+            //_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
         }
         ~GlobalFixture()
         {
+            getGlobalThreadPool().cleanup();
         }
         void setup()
         {

test/Engine/ThreadPool.cpp

@@ -4,51 +4,107 @@
 
 BOOST_AUTO_TEST_SUITE(ThreadPool)
 
-uint64 basicJobState = 0;
+uint64 basicAwaitState = 0;
+
+Job basicAwaitFirst()
+{
+    BOOST_REQUIRE_EQUAL(basicAwaitState, 5);
+    basicAwaitState = 10;
+    co_return;
+}
+Job basicAwaitSecond()
+{
+    BOOST_REQUIRE_EQUAL(basicAwaitState, 15);
+    basicAwaitState = 20;
+    co_return;
+}
+Job basicAwaitThird()
+{
+    BOOST_REQUIRE_EQUAL(basicAwaitState, 25);
+    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);
+}
+
+BOOST_AUTO_TEST_CASE(basic_coawait)
+{
+    basicAwaitBase();
+}
+
+uint64 basicThenState = 5;
 
 Job basicThenFirst()
 {
-    basicJobState = 10;
+    BOOST_REQUIRE_EQUAL(basicThenState, 5);
+    basicThenState = 10;
     co_return;
 }
 Job basicThenSecond()
 {
-    BOOST_REQUIRE_EQUAL(basicJobState, 10);
-    basicJobState = 20;
+    BOOST_REQUIRE_EQUAL(basicThenState, 15);
+    basicThenState = 20;
     co_return;
 }
 Job basicThenThird()
 {
-    BOOST_REQUIRE_EQUAL(basicJobState, 20);
+    BOOST_REQUIRE_EQUAL(basicThenState, 25);
+    basicThenState = 30;
     co_return;
 }
 
-Job basicThenBase()
+BOOST_AUTO_TEST_CASE(basic_thenchain)
 {
-    co_await basicThenFirst();
-    co_await basicThenSecond();
-    co_await basicThenThird();
+    basicThenFirst()
+        .then([]() -> Job
+        {
+            BOOST_REQUIRE_EQUAL(basicThenState, 10);
+            basicThenState = 15;
+            co_return;
+        })
+        .then(basicThenSecond())
+        .then([]() -> Job
+        {
+            BOOST_REQUIRE_EQUAL(basicThenState, 20);
+            basicThenState = 25;
+            co_return;
+        })
+        .then(basicThenThird())
+        .then([]() -> Job
+        {
+            BOOST_REQUIRE_EQUAL(basicThenState, 30);
+            co_return;
+        });
 }
 
-BOOST_AUTO_TEST_CASE(basic_then)
-{
-    basicThenBase();
-}
-/*
 uint64 basicAllState1 = 0;
 uint64 basicAllState2 = 0;
 Job basicAllFirst()
 {
     basicAllState1 = 10;
+    std::cout << "AllFirst" << std::endl;
     co_return;
 }
 Job basicAllSecond()
 {
     basicAllState2 = 10;
+    std::cout << "AllSecond" << std::endl;
     co_return;
 }
 Job basicAllThen()
 {
+    std::cout << "AllThen" << std::endl;
     BOOST_REQUIRE_EQUAL(basicAllState1, 10);
     BOOST_REQUIRE_EQUAL(basicAllState2, 10);
     co_return;
@@ -70,10 +126,12 @@ Job basicCallableFunc()
 BOOST_AUTO_TEST_CASE(basic_callable)
 {
     basicCallableFunc()
-        .then([=]() -> Job{
+        .then([=]() -> Job
+        {
             BOOST_REQUIRE_EQUAL(basicCallable, 10);
+            std::cout << "callable" << std::endl;
             co_return;
         });
-}*/
+}
 
 BOOST_AUTO_TEST_SUITE_END()