fix reported failure location

Author: Tsche

example/always_passes.cpp

@@ -3,7 +3,8 @@
 
 namespace demo {
 auto zoinks() {
-  ASSERT(false, "oh no");
+  bool x = true;
+  ASSERT(x == false);
 }
 
 [[= rsl::test]] void always_passes() {

include/rsl/testing/annotations.hpp

@@ -30,32 +30,33 @@ struct Skip {
   bool (*value)() = &_testing_impl::constant_predicate<true>;
 };
 
-
-namespace _impl { 
-template <typename T, bool T::*condition>
+namespace _impl {
+template <typename T, bool T::* condition>
 bool wrap_cli_nsdm() {
   return T::get().*condition;
 }
-}
+}  // namespace _impl
 
 struct SkipIf {
   static consteval Skip operator()(bool condition) {
     return {extract<bool (*)()>(
-      substitute(^^_testing_impl::constant_predicate, {std::meta::reflect_constant(condition)}))};
+        substitute(^^_testing_impl::constant_predicate, {std::meta::reflect_constant(condition)}))};
+  }
+
+  static consteval Skip operator()(bool (*condition)()) { return {condition}; }
+
+  template <typename T>
+    requires requires {
+      { T::get() } -> std::same_as<T&>;
     }
-    
-    static consteval Skip operator()(bool (*condition)()) { return {condition}; }
-    
-    template <typename T>
-    requires requires { T::get(); }
-    static consteval Skip operator()(bool T::* condition)  {
-      return {extract<bool (*)()>(
+  static consteval Skip operator()(bool T::* condition) {
+    return {extract<bool (*)()>(
         substitute(^^_impl::wrap_cli_nsdm, {^^T, std::meta::reflect_constant(condition)}))};
-      }
-    };
-    
-    struct Rename {
-      rsl::string_view value;
+  }
+};
+
+struct Rename {
+  rsl::string_view value;
 
   static consteval Rename operator()(std::string_view new_name) {
     return Rename(define_static_string(new_name));

include/rsl/testing/assert.hpp

@@ -1,9 +1,22 @@
 #pragma once
 #include <cstddef>
+#include <exception>
 #include <vector>
 #include <string_view>
 
+#include <rsl/source_location>
+
 namespace rsl::testing {
+
+struct assertion_failure : std::exception {
+  std::string message;
+  rsl::source_location sloc;
+
+  assertion_failure(std::string_view message, rsl::source_location sloc)
+      : message(std::string(message))
+      , sloc(sloc) {}
+};
+  
 struct AssertionInfo {
   std::string_view raw;
   std::string_view expanded;

include/rsl/testing/test.hpp

@@ -17,11 +17,9 @@
 
 #include <rsl/testing/assert.hpp>
 
-namespace rsl::testing {
-struct assertion_failure : std::runtime_error {
-  using std::runtime_error::runtime_error;
-};
 
+namespace rsl::testing {
+ 
 class Test {
   using runner_type = std::vector<TestCase> (Test::*)() const;
   runner_type get_tests_impl;
@@ -30,6 +28,7 @@ class Test {
   std::vector<TestCase> expand_test() const {
     return _testing_impl::Expand<R, Ann>{this}.runs;
   }
+
 public:
   std::source_location sloc;
   std::string_view name;                   // raw name

include/rsl/testing/test_case.hpp

@@ -18,7 +18,7 @@ struct TestResult {
   TestOutcome outcome;
   double duration_ms;
 
-  std::string failure;
+  std::optional<assertion_failure> failure;
   std::string exception;
   std::string stdout;
   std::string stderr;

src/main/reporters/catch2xml.cpp

@@ -202,7 +202,11 @@ class[[= rename("xml")]] Catch2XmlReporter : public Reporter::Registrar<Catch2Xm
       using enum TestOutcome;
       case PASS: ++section->results.successes; break;
       case FAIL:
-        section->failure = {.value = result.failure};
+        if (result.failure.has_value()) {
+          section->failure = Failure{.filename = std::string(result.failure->sloc.file),
+                                     .line     = result.failure->sloc.line,
+                                     .value    = result.failure->message};
+        }
         ++section->results.failures;
         break;
       case SKIP:

src/main/reporters/terminal.cpp

@@ -26,7 +26,7 @@ class [[=rename("plain")]] ConsoleReporter : public Reporter::Registrar<ConsoleR
                  reset,
                  result.name,
                  result.duration_ms);
-      std::print("{}ERROR{}: {}\n", color[1], reset, result.failure);
+      std::print("{}ERROR{}: {}\n", color[1], reset, result.failure->message);
       std::print("==== {}stdout{} ====\n{}\n", color[1], reset, result.stdout);
       std::print("==== {}stderr{} ====\n{}\n", color[1], reset, result.stderr);
     }

src/main/reporters/xml.cpp

@@ -23,7 +23,7 @@ class [[=rename("junit")]] JUnitXmlReporter : public Reporter::Registrar<JUnitXm
   void after_test(TestResult const& result) override {
     auto node = testcase{.name=std::string(result.name), .time=result.duration_ms / 1000.};
     if (result.outcome == TestOutcome::FAIL) {
-      node.failure = result.failure + "\n";
+      node.failure = result.failure->message + "\n";
     }
     suite.tests.push_back(node);
   }

src/test.cpp

@@ -3,6 +3,7 @@
 #include <print>
 #include <chrono>
 
+#include <rsl/source_location>
 #include <rsl/testing/assert.hpp>
 #include <rsl/testing/test.hpp>
 #include <rsl/testing/output.hpp>
@@ -43,7 +44,7 @@ void failure_handler(libassert::assertion_info const& info) {
   auto trace = info.get_stacktrace();
   cleanup_frames(trace, rsl::testing::_testing_impl::assertion_counter().test_name);
   message += trace.to_string(Colorize);
-  throw rsl::testing::assertion_failure(message);
+  throw rsl::testing::assertion_failure(message, rsl::source_location(info.file_name, info.function, info.line));
 }
 
 namespace rsl::testing {
@@ -101,7 +102,7 @@ bool TestNamespace::run(Reporter* reporter) {
       reporter->before_test(TestCase{&test, +[]{}, std::string(test.name)});
 
       // TODO stringify skipped tests properly
-      auto result = TestResult{&test, std::string(test.name) + "(...)", TestOutcome::PASS};
+      auto result = TestResult{&test, std::string(test.name) + "(...)", TestOutcome::SKIP};
       reporter->after_test(result);
       results.push_back(result);
     }
@@ -128,15 +129,15 @@ TestResult TestCase::run() const {
     ret.duration_ms = std::chrono::duration<double, std::milli>(t1 - t0).count();
     return ret;
   } catch (assertion_failure const& failure) {
-    ret.failure += failure.what();
+    ret.failure = failure;
   } catch (std::exception const& exc) {  //
     ret.exception += exc.what();
   } catch (std::string const& msg) {  //
-    ret.failure += msg;
+    ret.exception += msg;
   } catch (std::string_view msg) {  //
-    ret.failure += msg;
+    ret.exception += msg;
   } catch (char const* msg) {  //
-    ret.failure += msg;
+    ret.exception += msg;
   } catch (...) { ret.exception += "unknown exception thrown"; }
 
   ret.outcome = TestOutcome(test->expect_failure);