added test suite

test/common_helper/test_define_test.hpp

@@ -0,0 +1,89 @@
+//
+// Created by Patrick Maschek on 08/04/2024.
+//
+
+#ifndef CONST_CONTAINER_TEST_DEFINE_TEST_HPP_
+#define CONST_CONTAINER_TEST_DEFINE_TEST_HPP_
+
+#include <array>
+#include <concepts>
+#include <tuple>
+
+#include "test_ret_val.h"
+
+template<std::invocable Func>
+struct test_def_base {
+	using FuncType = Func;
+	
+	const char *name;
+	Func func;
+	
+	constexpr test_def_base(const char * name, Func func) : name(name), func(func) {}
+	
+	virtual constexpr std::invoke_result_t<Func> operator()() { return std::apply(func, std::make_tuple()); }
+};
+
+template<std::invocable Func, typename ...Args>
+struct test_definition : public test_def_base<Func> {
+	using base = test_def_base<Func>;
+	static constexpr std::size_t ARG_SIZE = sizeof...(Args);
+	
+	std::tuple<Args...> args;
+	
+	constexpr test_definition(const char *name, Func func, Args ...args) 
+		: test_def_base<Func>(name, func), args(std::make_tuple(args...)) {}
+	
+	constexpr std::invoke_result_t<Func, Args...> operator()() override { return std::apply(base::func, args); }
+};
+
+
+struct test_suite_base {
+	const char *name;
+};
+
+template<typename ...TestDefs>
+	requires (sizeof...(TestDefs) == 0 || (std::derived_from<TestDefs, test_def_base<typename TestDefs::FuncType>> && ...))
+struct test_suite : public test_suite_base {
+	
+	static constexpr std::size_t TEST_NR = sizeof...(TestDefs);
+	
+	std::tuple<TestDefs...> tests;
+	
+	constexpr test_suite(const char *name, std::tuple<TestDefs...> tests) : test_suite_base(name), tests(tests) {}
+	
+	constexpr ret_val<TEST_NR> run() {
+		
+		std::vector<ret_val_s> v;
+		std::apply([&v](auto&& ...args) { ((v.push_back(args())), ...); }, tests);
+		
+		ret_val<TEST_NR> ret = { name };
+		std::ranges::move(v, ret.vals.begin());
+		
+		return ret;
+	}
+};
+
+template<typename Suite>
+struct quick_test_def {
+	Suite current;
+	
+	template<std::invocable Func, typename ...Args>
+	constexpr auto operator()(const char *name, Func func, Args... args) {
+		auto test = test_definition(name, func, args...);
+		auto new_suite = test_suite(current.name, std::tuple_cat(current.tests, std::make_tuple(test)));
+		return quick_test_def<decltype(new_suite)> { new_suite };
+	}
+	
+	constexpr operator Suite() {
+		return current;
+	}
+};
+
+template<typename ...TestDefs>
+test_suite(quick_test_def<test_suite<TestDefs...>>) -> test_suite<TestDefs...>;
+
+constexpr auto define_tests(const char *name) {
+	return quick_test_def { test_suite<>{ name, std::make_tuple() } };
+}
+
+#endif //CONST_CONTAINER_TEST_DEFINE_TEST_HPP_

test/common_helper/test_ret_val.h

@@ -11,24 +11,6 @@
 
 enum ReturnCode { FAILED = -1, PASSED = 0 };
 
-/*struct test_ret_val {
-	struct ret_val_s : public cc::const_list_node<ret_val_s> {
-		ReturnCode val = FAILED;
-		const char *msg = "";
-	};
-	
-	cc::const_list<ret_val_s> list;
-	
-	constexpr test_ret_val() = default;
-	constexpr test_ret_val(const test_ret_val& other) = delete;
-	constexpr test_ret_val(test_ret_val&& other) = default;
-	
-	constexpr test_ret_val& operator=(const test_ret_val& other) = delete;
-	constexpr test_ret_val& operator=(test_ret_val&& other) = default;
-	
-	constexpr operator bool() const { return std::all_of(list.cbegin(), list.cend(), [](auto e){ return !static_cast<bool>(e.val); }); }
-};*/
-
 struct ret_val_s {
 	const char *test_name = "";
 	ReturnCode val = FAILED;
@@ -36,6 +18,14 @@ struct ret_val_s {
 };
 
 template<std::size_t Nr>
-using ret_val = std::array<ret_val_s, Nr>;
+struct ret_val {
+	const char * name;
+	std::array<ret_val_s, Nr> vals;
+	
+	[[nodiscard]] constexpr inline std::size_t size() const { return vals.size(); }
+	
+	constexpr inline ret_val_s& operator[](std::size_t i) { return vals[i]; }
+	constexpr inline const ret_val_s& operator[](std::size_t i) const { return vals[i]; }
+};
 
 #endif //CONST_CONTAINER_TEST_RETURN_VAL_H_

test/common_helper/test_util.hpp

@@ -21,18 +21,19 @@ struct TestStruct {
 	constexpr bool operator==(const TestStruct &other) const { return x == other.x && c == other.c && std::string_view(s) == other.s; }
 };
 
-template<std::invocable F>
-consteval auto consteval_caller(F &func) {
-	return func();
+template<typename F, typename ...Args>
+	requires (std::invocable<F, Args...>)
+consteval auto consteval_caller(F &func, Args... args) {
+	return func(args...);
 }
 
 template<std::invocable ...TestFuncs>
-constexpr auto run_tests(TestFuncs... tests) {
+constexpr auto run_tests(const char *name, TestFuncs... tests) {
 	constexpr std::size_t num_tests = sizeof...(tests);
 
 	std::array test_arr = { tests... };
 
-	ret_val<num_tests> ret;
+	ret_val<num_tests> ret { .name = name };
 	for (std::size_t i = 0; i < test_arr.size(); ++i) {
 		ret[i] = test_arr[i]();
 	}
@@ -42,7 +43,11 @@ constexpr auto run_tests(TestFuncs... tests) {
 
 template<std::size_t Nr>
 void report(const ret_val<Nr>& ret_val) {
-
+	
+	std::cout << "-----------------------------------------" << "\n";
+	std::cout << "Report for test: \"" << ret_val.name << "\"\n";
+	std::cout << "-----------------------------------------" << "\n";
+	
 	for (std::size_t i = 0; i < ret_val.size(); ++i) {
 		std::cout << "Result of Test \"" << ret_val[i].test_name << "\" (number: " << i << "): "
 				  << (ret_val[i].val == ReturnCode::PASSED ? "PASSED" : "FAILED") << "\n"

test/const_vector/const_vector_constructor.test.cpp

@@ -3,11 +3,20 @@
 
 #include <const_vector.hpp>
 
+#include "test_define_test.hpp"
+#include "test_util.hpp"
 #include "test_ret_val.h"
 
-constexpr auto test_func() {
+test_suite tests = define_tests("Tests")
+		("Test1", [](){
+
+			return TEST_PASS("Test1", "PASS");
+		});
+
+constexpr auto test_func(const char *name) {
 	
-	auto ret_val = run_tests([](){
+	auto ret_val = run_tests(name,
+	[](){
 
 		return TEST_PASS("Test1", "PASS");
 	});
@@ -17,11 +26,15 @@ constexpr auto test_func() {
 }
 
 int main() {
-	auto ret = test_func();
+	auto ret = test_func("Test 1");
 	
-	auto cret = consteval_caller();
+	auto cret = consteval_caller(test_func, "Consteval Test");
 	
 	report(ret);
+	report(cret);
+
+	auto sret = tests.run();
+	report(sret);
 	
 	return 0;
 }