refactor

Author: Tsche

include/rsl/testing/_testing_impl/expand.hpp

@@ -9,7 +9,7 @@
 #include <rsl/repr>
 #include <rsl/testing/assert.hpp>
 
-#include <rsl/testing/test_case.hpp>
+#include <rsl/testing/result.hpp>
 
 #include "fixture.hpp"
 #include "annotations.hpp"
@@ -29,7 +29,7 @@ struct FuzzRunner {
   }
 };
 
-template <std::meta::info Def, std::meta::info Target>
+template <typename TC, std::meta::info Def, std::meta::info Target>
 struct TestRunner {
   template <typename T>
   static void run_one(T const& tuple) {
@@ -72,14 +72,14 @@ struct TestRunner {
   }
 
   template <typename... Ts>
-  static TestCase bind(Test const* group, std::tuple<Ts...> args) {
+  static TC bind(Test const* group, std::tuple<Ts...> args) {
     return {group, std::bind_front(run_one<std::tuple<Ts...>>, args), get_name(args)};
   }
 };
 
-template <std::meta::info R, _testing_impl::Annotations A>
+template <typename TC, std::meta::info R, _testing_impl::Annotations A>
 struct Expand {
-  std::vector<TestCase> runs;
+  std::vector<TC> runs;
   Test const* group;
 
   template <typename Runner, annotations::Params Generator>
@@ -103,7 +103,7 @@ struct Expand {
 
   template <std::meta::info Target>
   void expand_params() {
-    using runner = TestRunner<R, Target>;
+    using runner = TestRunner<TC, R, Target>;
 
     if constexpr (A.params.size() == 0) {
       // expand fixtures

include/rsl/testing/test_case.hpp include/rsl/testing/result.hppinclude/rsl/testing/test_case.hpp renamed to include/rsl/testing/result.hpp

@@ -26,18 +26,12 @@ struct TestResult {
   std::vector<AssertionInfo> assertions;
 };
 
-struct TestCase {
-  class Test const* test;
-  std::function<void()> fnc;
-  std::string name;
+struct ResultNamespace {
+  std::string_view name;
+  std::vector<TestResult> tests;
+  std::vector<ResultNamespace> children;
 
-  [[nodiscard]] TestResult run() const;
-};
-
-struct FuzzTarget {
-  // stringifying name is pointless here, perhaps do it after failure
-  class Test const* test;
-  int (*run)(uint8_t const*, size_t);
-  size_t (*mutate)(uint8_t*, size_t, size_t, unsigned int);
+  void insert(TestResult const& test, size_t i = 0);
+  [[nodiscard]] std::size_t count() const;
 };
 }  // namespace rsl::testing

include/rsl/testing/test.hpp

@@ -8,7 +8,7 @@
 #include <set>
 #include <algorithm>
 
-#include "test_case.hpp"
+#include "result.hpp"
 
 #include "_testing_impl/util.hpp"
 #include "_testing_impl/expand.hpp"
@@ -19,14 +19,28 @@
 
 
 namespace rsl::testing {
- 
+struct TestCase {
+  class Test const* test;
+  std::function<void()> fnc;
+  std::string name;
+
+  [[nodiscard]] TestResult run() const;
+};
+
+struct FuzzTarget {
+  // stringifying name is pointless here, perhaps do it after failure
+  class Test const* test;
+  int (*run)(uint8_t const*, size_t);
+  size_t (*mutate)(uint8_t*, size_t, size_t, unsigned int);
+};
+
 class Test {
   using runner_type = std::vector<TestCase> (Test::*)() const;
   runner_type get_tests_impl;
 
   template <std::meta::info R, _testing_impl::Annotations Ann>
   std::vector<TestCase> expand_test() const {
-    return _testing_impl::Expand<R, Ann>{this}.runs;
+    return _testing_impl::Expand<TestCase, R, Ann>{this}.runs;
   }
 
 public:

src/test.cpp

@@ -6,12 +6,12 @@
 #include <rsl/source_location>
 #include <rsl/testing/assert.hpp>
 #include <rsl/testing/test.hpp>
+#include <rsl/testing/result.hpp>
 #include <rsl/testing/output.hpp>
 #include <rsl/testing/util.hpp>
 #include <rsl/testing/_testing_impl/discovery.hpp>
 
 #include "capture.hpp"
-#include "rsl/testing/test_case.hpp"
 
 #include <cpptrace/basic.hpp>
 #include <cpptrace/utils.hpp>
@@ -184,6 +184,33 @@ bool TestNamespace::iterator::operator==(iterator const& other) const {
   return elements == other.elements;
 }
 
+// TODO get rid of duplicated code
+void ResultNamespace::insert(TestResult const& test, std::size_t i) {
+  if (i == test.test->full_name.size() - 1) {
+    tests.push_back(test);
+    return;
+  }
+
+  auto it = std::ranges::find_if(children, [&](const ResultNamespace& ns) {
+    return ns.name == test.test->full_name[i];
+  });
+
+  if (it == children.end()) {
+    children.emplace_back(test.test->full_name[i]);
+    it = std::prev(children.end());
+  }
+
+  it->insert(test, i + 1);
+}
+
+std::size_t ResultNamespace::count() const {
+  std::size_t total = tests.size();
+  for (auto const& ns : children) {
+    total += ns.count();
+  }
+  return total;
+}
+
 void TestNamespace::insert(Test const& test, std::size_t i) {
   if (i == test.full_name.size() - 1) {
     tests.push_back(test);