UnitTest: expectThrow & expectNoThrow

Author: MorganCaron

modules/UnitTest/UnitTest.mpp

@@ -178,6 +178,8 @@ namespace CppUtils::UnitTest
 
 	export struct TestSuite final
 	{
+		using Logger = CppUtils::Logger<"CppUtils">;
+
 		inline explicit TestSuite(const std::string& name, std::vector<std::string> prerequisites, std::function<void(TestSuite&)> function)
 		{
 			function(*this);
@@ -216,6 +218,49 @@ namespace CppUtils::UnitTest
 					String::formatValue(rhs))};
 		}
 
+		template<class ExceptionType>
+		inline auto expectThrow(auto&& function, std::source_location sourceLocation = std::source_location::current()) -> void
+		{
+			try
+			{
+				function();
+				throw TestException{std::format("In {}\nAt line {}, column {}\nExpected throw of type {}, but no exception was thrown.",
+					sourceLocation.file_name(),
+					sourceLocation.line(),
+					sourceLocation.column(),
+					typeid(ExceptionType).name())};
+			}
+			catch (const ExceptionType&)
+			{
+				Logger::print<"success">("Expected exception caught.");
+			}
+			catch (const std::exception& exception)
+			{
+				throw TestException{std::format("In {}\nAt line {}, column {}\nExpected throw of type {}, but caught different exception: {}",
+					sourceLocation.file_name(),
+					sourceLocation.line(),
+					sourceLocation.column(),
+					typeid(ExceptionType).name(),
+					exception.what())};
+			}
+		}
+
+		inline auto expectNoThrow(auto&& function, std::source_location sourceLocation = std::source_location::current()) -> void
+		{
+			try
+			{
+				function();
+			}
+			catch (const std::exception& exception)
+			{
+				throw TestException{std::format("In {}\nAt line {}, column {}\nExpected no throw, but an exception was thrown: {}",
+					sourceLocation.file_name(),
+					sourceLocation.line(),
+					sourceLocation.column(),
+					exception.what())};
+			}
+		}
+
 		inline auto expectCall(ExpectedCall& expectedCall, const Chrono::Duration auto& timeout, std::source_location sourceLocation = std::source_location::current()) -> void
 		{
 			if (expectedCall.wait_for(timeout) != std::future_status::ready)

tests/System/Error.mpp

@@ -0,0 +1,55 @@
+export module CppUtils.UnitTests.System.Error;
+
+import std;
+import CppUtils;
+
+export namespace CppUtils::UnitTest::System::Error
+{
+	inline auto _ = TestSuite{"System/Error", {"UnitTest"}, [](auto& suite) {
+		suite.addTest("throwErrno", [&] {
+			suite.template expectThrow<std::runtime_error>([&] {
+				CppUtils::System::throwErrno(-1, "Test error");
+			});
+			suite.template expectNoThrow<>([&] {
+				CppUtils::System::throwErrno(0, "Test success");
+			});
+		});
+
+		suite.addTest("expectErrno", [&] {
+			{
+				auto result = CppUtils::System::expectErrno(-1, "Test error");
+				suite.expect(not result.has_value());
+			}
+			{
+				auto result = CppUtils::System::expectErrno(0, "Test success");
+				suite.expect(result.has_value());
+				suite.expectEqual(result.value(), 0);
+			}
+		});
+
+#if defined(OS_WINDOWS)
+		suite.addTest("throwLastError", [&] {
+			suite.template expectThrow<std::runtime_error>([&] {
+				CppUtils::System::throwLastError("Test last error");
+			});
+		});
+
+		suite.addTest("throwLastErrorIf", [&] {
+			suite.template expectThrow<std::runtime_error>([&] {
+				CppUtils::System::throwLastErrorIf(1, "Test last error if");
+			});
+			suite.template expectNoThrow<>([&] {
+				CppUtils::System::throwLastErrorIf(0, "Test last error if");
+			});
+		});
+
+		suite.addTest("expectNoError", [&] {
+			auto result = CppUtils::System::expectNoError(0, "Test no error");
+			suite.expect(result.has_value());
+			suite.expectEqual(result.value(), 0);
+			result = CppUtils::System::expectNoError(1, "Test no error");
+			suite.expect(not result.has_value());
+		});
+#endif
+	}};
+}

tests/UnitTests.mpp

@@ -28,6 +28,7 @@ export import CppUtils.UnitTests.Network;
 export import CppUtils.UnitTests.Random;
 export import CppUtils.UnitTests.Stl.Format;
 export import CppUtils.UnitTests.String.Utility;
+export import CppUtils.UnitTests.System.Error;
 export import CppUtils.UnitTests.Thread.SharedLocker;
 export import CppUtils.UnitTests.Thread.ThreadLoop;
 export import CppUtils.UnitTests.Thread.ThreadPool;