clean up annotations and test

Author: Tsche

include/rsl/testing/_testing_impl/annotations.hpp

@@ -11,9 +11,9 @@
 #endif
 
 #include <rsl/testing/test.hpp>
+#include <rsl/testing/annotations.hpp>
 
 #include "fixture.hpp"
-#include "annotations.hpp"
 #include "util.hpp"
 
 namespace rsl::testing::_testing_impl {

include/rsl/testing/_testing_impl/discovery.hpp

@@ -9,10 +9,10 @@
 #include <rsl/repr>
 #include <rsl/testing/assert.hpp>
 
+#include <rsl/testing/annotations.hpp>
 #include <rsl/testing/result.hpp>
 
 #include "fixture.hpp"
-#include "annotations.hpp"
 
 namespace rsl::testing::_testing_impl {
 template <std::meta::info R, std::meta::info Target>

include/rsl/testing/_testing_impl/expand.hpp

@@ -5,7 +5,7 @@
 #include <meta>
 #include <unordered_map>
 
-#include "annotations.hpp"
+#include <rsl/testing/annotations.hpp>
 
 namespace rsl::testing::_testing_impl {
 template <class Base, class... Args>

include/rsl/testing/_testing_impl/factory.hpp

@@ -2,6 +2,7 @@
 #include <cstdint>
 #include <string_view>
 #include <meta>
+#include <algorithm>
 
 namespace rsl::testing::_testing_impl {
 template <bool V>

include/rsl/testing/_testing_impl/util.hpp

@@ -12,7 +12,6 @@
 namespace rsl {
 using testing::fixture;
 using testing::fuzz;
-using testing::property_test;
 using testing::test;
 
 using testing::params;

include/rsl/testing/all.hpp

@@ -1,5 +1,4 @@
 #pragma once
-#include <type_traits>
 #include <vector>
 #include <initializer_list>
 #include <meta>
@@ -11,16 +10,15 @@
 #include "_testing_impl/util.hpp"
 #include "_testing_impl/paramset.hpp"
 
-namespace rsl::testing {
 
+namespace rsl::testing {
 using _testing_impl::ParamSet;
 
 namespace annotations {
 struct FixtureTag {};
 
 // test kinds
 struct TestTag {};
-struct PropertyTag : TestTag {};
 struct FuzzTag : TestTag {};
 
 // flags
@@ -98,7 +96,6 @@ struct Params {
 constexpr inline annotations::FixtureTag fixture;
 
 constexpr inline annotations::TestTag test;
-constexpr inline annotations::PropertyTag property_test;
 constexpr inline annotations::FuzzTag fuzz;
 
 constexpr inline annotations::ExpectFailureTag expect_failure;
@@ -108,4 +105,48 @@ constexpr inline annotations::Rename rename;
 
 using tparams = annotations::TParams;
 using params  = annotations::Params;
-}  // namespace rsl::testing
+
+namespace _testing_impl {
+struct Annotations {  // consteval-only
+  rsl::span<ParamSet const> targets;
+  rsl::span<annotations::Params const> params;
+
+  bool expect_failure = false;
+  bool (*skip)()      = nullptr;  // this is a function to support conditional skipping
+  rsl::string_view name;          // custom base name
+  bool is_fuzz_test = false;
+
+  consteval explicit Annotations(std::meta::info fnc) {
+    std::vector<ParamSet> tp_sets;
+    std::vector<annotations::Params> p;
+
+    for (auto annotation : annotations_of(fnc)) {
+      auto type = remove_cvref(type_of(annotation));
+      if (type == ^^annotations::TParams) {
+        tp_sets.append_range(extract<annotations::TParams>(constant_of(annotation)).value);
+      } else if (type == ^^annotations::Params) {
+        p.push_back(extract<annotations::Params>(constant_of(annotation)));
+      } else if (type == ^^annotations::ExpectFailureTag) {
+        constexpr_assert(!expect_failure, "Cannot annotate with expect_failure more than once.");
+        expect_failure = true;
+      } else if (type == ^^annotations::Skip) {
+        // constexpr_assert(skip == nullptr, "Cannot have more than one skip annotation.");
+        skip = extract<annotations::Skip>(constant_of(annotation)).value;
+      } else if (type == ^^annotations::Rename) {
+        constexpr_assert(name.empty(), "Cannot rename more than once.");
+        name = extract<annotations::Rename>(constant_of(annotation)).value;
+      } else if (type == ^^annotations::FuzzTag) {
+        is_fuzz_test = true;
+      }
+    }
+
+    targets = define_static_array(tp_sets);
+    params  = define_static_array(p);
+
+    if (skip == nullptr) {
+      skip = &constant_predicate<false>;
+    }
+  }
+};
+}  // namespace rsl::testing::_testing_impl
+}

include/rsl/testing/annotations.hpp

@@ -2,22 +2,17 @@
 #include <string>
 #include <functional>
 #include <meta>
-#include <ranges>
 #include <iterator>
 #include <deque>
-#include <set>
-#include <algorithm>
 
 #include "result.hpp"
 
 #include "_testing_impl/util.hpp"
 #include "_testing_impl/expand.hpp"
-#include "_testing_impl/fixture.hpp"
-#include "_testing_impl/annotations.hpp"
 
+#include <rsl/testing/annotations.hpp>
 #include <rsl/testing/assert.hpp>
 
-
 namespace rsl::testing {
 struct TestCase {
   class Test const* test;
@@ -49,22 +44,19 @@ class Test {
   std::string_view preferred_name;         // from annotations
   std::span<char const* const> full_name;  // fully qualified name
 
-  bool expect_failure;    // invert test checking
-  bool (*skip)();         // function to support conditional skipping
-  bool is_property_test;  // expand missing args as fixtures if false,
-                          // otherwise parameterize with domain
+  bool expect_failure;  // invert test checking
+  bool (*skip)();       // function to support conditional skipping
   bool is_fuzz_test;
 
   Test() = delete;
   consteval explicit Test(std::meta::info test, std::meta::info annotation_anchor)
       : sloc(source_location_of(test))
       , name(define_static_string(identifier_of(test))) {
-    auto ann         = _testing_impl::Annotations(annotation_anchor);
-    preferred_name   = ann.name;
-    expect_failure   = ann.expect_failure;
-    skip             = ann.skip;
-    is_property_test = ann.is_property_test;
-    is_fuzz_test     = ann.is_fuzz_test;
+    auto ann       = _testing_impl::Annotations(annotation_anchor);
+    preferred_name = ann.name;
+    expect_failure = ann.expect_failure;
+    skip           = ann.skip;
+    is_fuzz_test   = ann.is_fuzz_test;
 
     get_tests_impl = extract<runner_type>(
         substitute(^^expand_test, {reflect_constant(test), std::meta::reflect_constant(ann)}));