UnitTest & ThreadLoop: Fix deadlock

Author: MorganCaron

modules/Execution/EventQueue.mpp

@@ -6,6 +6,7 @@ import CppUtils.Execution.EventDispatcher;
 import CppUtils.Execution.ScopeGuard;
 import CppUtils.Thread.ThreadLoop;
 import CppUtils.Thread.UniqueLocker;
+import CppUtils.Chrono.Concept;
 
 export namespace CppUtils::Execution
 {
@@ -51,10 +52,17 @@ export namespace CppUtils::Execution
 			m_dispatcher.subscribe<eventName>(std::forward<decltype(function)>(function));
 		}
 
-		inline auto waitUntilFinished() -> void
+		template<Chrono::Duration Duration = std::chrono::milliseconds>
+		inline auto waitUntilFinished(Duration timeout = Duration::zero()) -> bool
 		{
 			auto accessor = m_queue.access();
-			m_condition.wait(accessor.getLockGuard(), [this, &accessor] { return accessor.value().empty() and not m_isTaskRunning; });
+			auto predicate = [this, &accessor] { return std::empty(accessor.value()) and not m_isTaskRunning; };
+			if (timeout == Duration::zero())
+			{
+				m_condition.wait(accessor.getLockGuard(), predicate);
+				return true;
+			}
+			return m_condition.wait_for(accessor.getLockGuard(), timeout, predicate);
 		}
 
 	private:
@@ -73,10 +81,10 @@ export namespace CppUtils::Execution
 			{
 				auto accessor = m_queue.access();
 				m_condition.wait(accessor.getLockGuard(), [this, &accessor] {
-					return not accessor.value().empty() or m_worker.isStopRequested();
+					return not std::empty(accessor.value()) or m_worker.isStopRequested();
 				});
 
-				if (accessor.value().empty())
+				if (std::empty(accessor.value()))
 					return;
 
 				m_isTaskRunning = true;

modules/Log/Logger.mpp

@@ -11,6 +11,7 @@ import CppUtils.Pattern.Multiton;
 import CppUtils.Terminal.Size;
 import CppUtils.Terminal.TextColor;
 import CppUtils.Terminal.TextModifier;
+import CppUtils.Chrono.Concept;
 
 // Todo: log le datetime
 // Todo: log le stacktrace ( https://en.cppreference.com/w/cpp/utility/stacktrace_entry )
@@ -59,9 +60,10 @@ export namespace CppUtils
 			eventQueue().template subscribe<logType>(std::forward<decltype(function)>(function));
 		}
 
-		static inline auto waitUntilFinished() -> void
+		template<Chrono::Duration Duration = std::chrono::milliseconds>
+		static inline auto waitUntilFinished(Duration timeout = Duration::zero()) -> bool
 		{
-			eventQueue().waitUntilFinished();
+			return eventQueue().waitUntilFinished(timeout);
 		}
 	};
 

modules/Thread/ThreadLoop.mpp

@@ -75,6 +75,7 @@ export namespace CppUtils::Thread
 				return;
 
 			m_thread = std::jthread{[function = m_function, interruptFunction = m_interruptFunction, onError = m_onError](std::stop_token stopToken) mutable -> void {
+				using namespace std::chrono_literals;
 				while (not stopToken.stop_requested())
 				{
 					try
@@ -93,15 +94,18 @@ export namespace CppUtils::Thread
 							catch (const std::exception& exception)
 							{
 								std::println(stderr, "ThreadLoop: onError threw an exception: {}", exception.what());
+								std::this_thread::sleep_for(100ms);
 							}
 							catch (...)
 							{
 								std::println(stderr, "ThreadLoop: onError threw a non-std exception");
+								std::this_thread::sleep_for(100ms);
 							}
 						}
 						else
 						{
-							std::println(stderr, "ThreadLoop: Unhandled exception");
+							std::println(stderr, "ThreadLoop: Unhandled exception, cooling down...");
+							std::this_thread::sleep_for(100ms);
 						}
 					}
 				}

modules/UnitTest/UnitTest.mpp

@@ -63,6 +63,7 @@ namespace CppUtils::UnitTest
 
 		inline auto executeTest(const Test& test, const TestSettings& settings) const -> bool
 		{
+			using namespace std::chrono_literals;
 			if (settings.verbose)
 			{
 				Logger::emit<"separator">();
@@ -116,12 +117,13 @@ namespace CppUtils::UnitTest
 			}
 			if (settings.verbose)
 				Logger::print<"success">("Passed");
-			Logger::waitUntilFinished();
+			Logger::waitUntilFinished(10s);
 			return true;
 		}
 
 		inline auto executeTests(TestSettings settings) -> int
 		{
+			using namespace std::chrono_literals;
 			auto testSuiteIsSuccess = std::unordered_map<std::string, bool>{};
 
 			const auto nbTests = std::ranges::fold_left(
@@ -209,7 +211,7 @@ namespace CppUtils::UnitTest
 					Logger::emit<"color">(Terminal::TextColor::TextColorEnum::Yellow, std::format("  - {}", skippedTestSuite));
 			}
 
-			Logger::waitUntilFinished();
+			Logger::waitUntilFinished(10s);
 			return nbFail == 0 ? exitSuccess : exitFailure;
 		}