UnitTest.mpp

module;

#include <cstdio>

export module CppUtils.UnitTest;

import std;
import CppUtils.Chrono.Concept;
import CppUtils.ChronoLogger;
import CppUtils.Container;
import CppUtils.Logger;
import CppUtils.Log.Exception;
import CppUtils.Log.Config.UnitTests;
import CppUtils.String;
import CppUtils.Terminal;
import CppUtils.Thread.Poll;
import CppUtils.System.Main;

export import CppUtils.UnitTest.LifetimeChecker;

namespace CppUtils::UnitTest
{
	export struct TestSettings final
	{
		bool verbose = true;
		bool detail = true;
		bool chrono = false;
		bool fastAbort = false;
	};

	struct Test final
	{
		std::string name;
		std::function<void(std::stop_token)> function;
		std::chrono::seconds timeout = std::chrono::seconds{10};
	};

	// Workaround on Windows (MSVC ABI)
	// https://github.com/llvm/llvm-project/issues/221609
#if defined(_WIN32)
	export class TestException: public std::exception
	{
	public:
		explicit inline TestException(std::string message):
			m_message{std::move(message)}
		{}

		[[nodiscard]] inline auto what() const noexcept -> const char* override
		{
			return m_message.c_str();
		}

	private:
		std::string m_message;
	};

	class TestSkipped final: public std::exception
	{
	public:
		explicit inline TestSkipped(std::string message, std::source_location location = std::source_location::current()):
			m_message{std::format("{} (at {}:{})", message, location.file_name(), location.line())}
		{}

		[[nodiscard]] inline auto what() const noexcept -> const char* override
		{
			return m_message.c_str();
		}

	private:
		std::string m_message;
	};
#else
	export class TestException: public std::runtime_error
	{
	public:
		inline TestException(std::string message):
			std::runtime_error{std::move(message)}
		{}
	};

	class TestSkipped final: public std::runtime_error
	{
	public:
		explicit inline TestSkipped(std::string message, std::source_location location = std::source_location::current()):
			std::runtime_error{std::format("{} (at {}:{})", message, location.file_name(), location.line())}
		{}
	};
#endif

	struct SkippedTest final
	{
		std::string name;
		std::string message;
	};

	enum class TestStatus
	{
		Success,
		Failure,
		Skipped
	};

	class TestRunner final
	{
		using Logger = Logger<"UnitTests">;

	public:
		inline auto addTestSuite(const std::string& name, std::vector<Test> tests) -> void
		{
			for (auto& test : tests)
				test.name = std::format("{}/{}", name, test.name);
			m_testSuites.insert(name, std::move(tests));
		}

		inline auto addTestSuite(const std::string& name, std::vector<std::string> prerequisites, std::vector<Test> tests) -> void
		{
			addTestSuite(name, tests);
			for (const auto& prerequisite : prerequisites)
				m_testSuites.addDependency(name, prerequisite);
		}

		inline auto executeTest(const Test& test, const TestSettings& settings) const -> std::pair<TestStatus, std::string>
		{
			using namespace std::chrono_literals;
			if (settings.verbose)
			{
				Logger::emit<"separator">();
				Logger::print<"detail">("{}:", test.name);
				Logger::waitUntilFinished(10s);
			}

			// Workaround on Windows (MSVC ABI)
			// https://github.com/llvm/llvm-project/issues/221609
#if defined(_WIN32)
			struct ExecutionResult final
			{
				TestStatus status = TestStatus::Success;
				std::string message;
			};

			auto chronoLogger = Log::ChronoLogger{[](std::string_view duration) {
				Logger::print<"detail">("Test duration: {}", duration);
			}, settings.verbose and settings.chrono};

			auto promise = std::promise<ExecutionResult>{};
			auto future = promise.get_future();

			auto worker = std::jthread{[promise = std::move(promise), function = test.function, testName = test.name](std::stop_token stopToken) mutable {
				try
				{
					function(stopToken);
					promise.set_value({TestStatus::Success, ""});
				}
				catch (const TestSkipped& skipped)
				{
					promise.set_value({TestStatus::Skipped, skipped.what()});
				}
				catch (const TestException& exception)
				{
					promise.set_value({TestStatus::Failure, std::format("The following test didn't pass:\n{}\n  {}", testName, exception.what())});
				}
				catch (const std::exception& exception)
				{
					promise.set_value({TestStatus::Failure, std::format("An exception occurred during the test:\n{}\n  {}", testName, exception.what())});
				}
				catch (...)
				{
					promise.set_value({TestStatus::Failure, std::format("An unknown exception occurred during the test: {}", testName)});
				}
			}};

			if (future.wait_for(test.timeout) == std::future_status::timeout)
			{
				worker.request_stop();
				worker.detach();
				Logger::print<"error">("The following test timed out after {}s:\n{}", test.timeout.count(), test.name);
				return {TestStatus::Failure, ""};
			}

			const auto [status, message] = future.get();
			if (status == TestStatus::Skipped)
			{
				if (settings.verbose)
					Logger::print<"warning">("Skipped: {}", message);
				return {TestStatus::Skipped, message};
			}
			if (status == TestStatus::Failure)
			{
				Logger::print<"error">("{}", message);
				return {TestStatus::Failure, ""};
			}
#else
			try
			{
				try
				{
					auto chronoLogger = Log::ChronoLogger{[](std::string_view duration) {
						Logger::print<"detail">("Test duration: {}", duration);
					}, settings.verbose and settings.chrono};

					auto promise = std::promise<void>{};
					auto future = promise.get_future();

					auto worker = std::jthread{[promise = std::move(promise), function = test.function](std::stop_token stopToken) mutable {
						try
						{
							function(stopToken);
							promise.set_value();
						}
						catch (...)
						{
							promise.set_exception(std::current_exception());
						}
					}};

					if (future.wait_for(test.timeout) == std::future_status::timeout)
					{
						worker.request_stop();
						worker.detach();
						throw TestException{std::format("Test timed out after {}s", test.timeout.count())};
					}

					future.get();
				}
				catch (const TestSkipped& skipped)
				{
					if (settings.verbose)
						Logger::print<"warning">("Skipped: {}", skipped.what());
					return {TestStatus::Skipped, skipped.what()};
				}
				catch ([[maybe_unused]] const TestException& exception)
				{
					std::throw_with_nested(std::runtime_error{std::format("The following test didn't pass:\n{}", test.name)});
				}
				catch (const std::exception& exception)
				{
					std::throw_with_nested(std::runtime_error{std::format("An exception occurred during the test:\n{}\n{}", test.name, exception.what())});
				}
			}
			catch (const std::exception& exception)
			{
				logException<Logger>(exception);
				return {TestStatus::Failure, ""};
			}
#endif
			if (settings.verbose)
				Logger::print<"success">("Passed");
			Logger::waitUntilFinished(10s);
			return {TestStatus::Success, ""};
		}

		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(
				std::views::values(m_testSuites.nodes) | std::views::transform([](auto&& node) { return std::ranges::size(node.value); }),
				0uz,
				std::plus{});
			Logger::print<"info">("{} tests found. Execution:", nbTests);

			auto failedTestSuites = std::vector<std::string>{};
			auto implicitlySkippedTestSuites = std::vector<std::string>{};
			auto explicitlySkippedTests = std::vector<SkippedTest>{};

			auto nbSuccess = 0uz;
			auto nbFail = 0uz;
			auto nbSkip = 0uz;

			if (auto result = m_testSuites.forEach([&](const auto& name, const auto& tests, const auto& dependencies) -> bool {
				if (std::ranges::empty(tests))
				{
					Logger::print<"warning">("No tests found in test suite {}", name);
					testSuiteIsSuccess[name] = true;
					return not settings.fastAbort;
				}

				for (const auto& dependency : dependencies)
					if (not testSuiteIsSuccess[dependency])
					{
						Logger::print<"warning">("Skipping test suite {} due to failed prerequisites in test suite {}", name, dependency);
						testSuiteIsSuccess[name] = false;
						implicitlySkippedTestSuites.push_back(name);
						nbSkip += std::ranges::size(tests);
						return not settings.fastAbort;
					}

				auto allTestsPassed = true;
				for (const auto& test : tests)
				{
					const auto [status, skipMessage] = executeTest(test, settings);
					if (status == TestStatus::Success)
						++nbSuccess;
					else if (status == TestStatus::Skipped)
					{
						++nbSkip;
						explicitlySkippedTests.push_back({test.name, skipMessage});
					}
					else
					{
						++nbFail;
						allTestsPassed = false;
						if (settings.fastAbort)
							break;
					}
				}

				testSuiteIsSuccess[name] = allTestsPassed;
				if (not allTestsPassed)
					failedTestSuites.push_back(name);

				return allTestsPassed or not settings.fastAbort;
			});
				not result)
				Logger::print<"error">("The tests cannot be run: {}", result.error());

			Logger::emit<"separator">();
			Logger::print<"detail">("Test results");
			if (nbFail == 0 and nbSkip == 0)
			{
				Logger::print<"success">("All tests passed successfully");
				return exitSuccess;
			}
			if (nbFail > 0)
				Logger::emit<"color">(Terminal::TextColor::TextColorEnum::Red, "The tests failed:");
			else
				Logger::emit<"color">(Terminal::TextColor::TextColorEnum::Yellow, "Some tests were skipped:");

			if (nbSuccess > 0)
				Logger::print<"success">("- {} successful tests", nbSuccess);
			if (nbSuccess == 0)
				Logger::emit<"color">(Terminal::TextColor::TextColorEnum::Red, "- 0 successful tests");

			if (nbFail > 0)
			{
				Logger::emit<"color">(Terminal::TextColor::TextColorEnum::Red, std::format("- {} failed tests", nbFail));
				for (const auto& failedTestSuite : failedTestSuites)
					Logger::emit<"color">(Terminal::TextColor::TextColorEnum::Red, std::format("  - {}", failedTestSuite));
			}

			if (nbSkip > 0)
			{
				Logger::emit<"color">(Terminal::TextColor::TextColorEnum::Yellow, std::format("- {} skipped tests", nbSkip));
				for (const auto& skippedTest : explicitlySkippedTests)
					Logger::emit<"color">(Terminal::TextColor::TextColorEnum::Yellow, std::format("  - {}: {}", skippedTest.name, skippedTest.message));
				for (const auto& skippedTestSuite : implicitlySkippedTestSuites)
					Logger::emit<"color">(Terminal::TextColor::TextColorEnum::Yellow, std::format("  - {} (due to failed prerequisites)", skippedTestSuite));
			}

			Logger::waitUntilFinished(10s);
			return nbFail == 0 ? exitSuccess : exitFailure;
		}

	private:
		Container::DependencyGraph<std::string, std::vector<Test>> m_testSuites;
	};

	inline /* constinit */ auto testRunner = TestRunner{};

	export struct TestSuite final
	{
		using Logger = Logger<"UnitTests">;

		inline explicit TestSuite(const std::string& name, std::vector<std::string> prerequisites, std::function<void(TestSuite&)> function)
		{
			function(*this);
			testRunner.addTestSuite(name, prerequisites, std::move(tests));
		}

		inline explicit TestSuite(std::string name, std::function<void(TestSuite&)> function)
		{
			function(*this);
			testRunner.addTestSuite(name, std::move(tests));
		}

		inline auto addTest(std::string name, std::function<void(std::stop_token)> function, std::chrono::seconds timeout = std::chrono::seconds{10}) -> void
		{
			tests.emplace_back(std::move(name), std::move(function), timeout);
		}

		inline auto addTest(std::string name, std::function<void()> function, std::chrono::seconds timeout = std::chrono::seconds{10}) -> void
		{
			tests.emplace_back(std::move(name), [function = std::move(function)](std::stop_token) { function(); }, timeout);
		}

		[[noreturn]] inline auto skip(std::string message, std::source_location sourceLocation = std::source_location::current()) -> void
		{
			throw TestSkipped{std::move(message), sourceLocation};
		}

		inline auto skipIf(bool condition, std::string message, std::source_location sourceLocation = std::source_location::current()) -> void
		{
			if (condition)
				skip(std::move(message), sourceLocation);
		}

		// Todo C++23: std::stacktrace stacktrace = std::current_stacktrace()
		inline auto expect(const auto& condition, std::source_location sourceLocation = std::source_location::current()) -> void
		requires requires { static_cast<bool>(condition); }
		{
			if (not static_cast<bool>(condition)) [[unlikely]]
				throw TestException{std::format("In {}\nAt line {}, column {}\nIn expect(condition)",
					sourceLocation.file_name(),
					sourceLocation.line(),
					sourceLocation.column())};
		}

		template<Chrono::Duration TimeoutDuration = std::chrono::milliseconds, Chrono::Duration StepDuration = std::chrono::milliseconds>
		inline auto expectWait(
			auto&& predicate,
			TimeoutDuration timeout = std::chrono::milliseconds{1'000},
			StepDuration step = std::chrono::milliseconds{20},
			std::source_location sourceLocation = std::source_location::current()) -> void
		{
			if (not Thread::pollFor(std::forward<decltype(predicate)>(predicate), timeout, step)) [[unlikely]]
				throw TestException{std::format("In {}\nAt line {}, column {}\nIn expectWait(predicate)\nTimed out waiting for predicate to become true",
					sourceLocation.file_name(),
					sourceLocation.line(),
					sourceLocation.column())};
		}

		inline auto expectEqual(const auto& lhs, const auto& rhs, std::source_location sourceLocation = std::source_location::current()) -> void
		{
			if (lhs != rhs) [[unlikely]]
				throw TestException{std::format("In {}\nAt line {}, column {}\nIn expectEqual(lhs, rhs)\nwith lhs:\n{}\nand rhs:\n{}",
					sourceLocation.file_name(),
					sourceLocation.line(),
					sourceLocation.column(),
					String::formatValue(lhs),
					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::emit<"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())};
			}
		}

		std::vector<Test> tests;
	};

	export inline auto executeTests(TestSettings settings) -> int
	{
		return testRunner.executeTests(std::move(settings));
	}
}