implement output capture

Author: Tsche

example/always_passes.cpp

@@ -1,10 +1,13 @@
 #include <rsl/test>
+#include <iostream>
 
 namespace demo {
 
 [[=rsl::test]] 
 void always_passes() {
-  // ASSERT(false, "testing");
+  std::cout << "foo\n";
+  std::cerr << "bar\n";
+  ASSERT(false, "testing");
 }
 
 [[=rsl::test, =rsl::expect_failure]]

include/rsl/testing/test_case.hpp

@@ -6,8 +6,12 @@ namespace rsl::testing {
 struct TestResult {
   class Test const* test;
   std::string name;
+
   bool passed;
   std::string error;
+
+  std::string stdout;
+  std::string stderr;
   double duration_ms;
 };
 

src/CMakeLists.txt

@@ -1,9 +1,9 @@
 target_sources(rsltest PUBLIC 
-    discovery.cpp
+    capture.cpp
     test.cpp
 )
 
-target_sources(rsltest_main PUBLIC main.cpp)
+target_sources(rsltest_main PRIVATE main.cpp)
 target_include_directories(rsltest PRIVATE .)
 target_include_directories(rsltest_main PRIVATE .)
 

src/capture.cpp

@@ -0,0 +1,85 @@
+#include "capture.hpp"
+
+#include <string>
+#include <string_view>
+
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <fcntl.h>
+#include <io.h>
+#include <windows.h>
+#else
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#endif
+
+
+namespace rsl::testing {
+
+RedirectedOutput::RedirectedOutput(FILE* redirected_stream, int original_fd)
+    : redirected(redirected_stream)
+    , underlying_fd(original_fd) {
+  underlying    = fdopen(original_fd, "w");
+  redirected_fd = fileno(redirected_stream);
+}
+
+Capture::Capture(FILE* stream, std::string& target, bool echo )
+    : target(&target)
+    , echo(echo) {
+  fflush(stream);
+  out = {stream, dup(fileno(stream))};
+#ifdef _WIN32
+  _pipe(pipe_fds_, 8192, _O_BINARY);
+#else
+  pipe(pipe_fds_);
+  fcntl(pipe_fds_[0], F_SETFL, O_NONBLOCK);
+#endif
+  dup2(pipe_fds_[1], out.redirected_fd);
+}
+
+Capture::~Capture() {
+  fflush(out.redirected);
+  dup2(out.underlying_fd, out.redirected_fd);
+  close(pipe_fds_[1]);
+
+  drain();  // Final flush
+
+  close(pipe_fds_[0]);
+  close(out.underlying_fd);
+}
+
+static int read_pipe(int fd, char* buffer, size_t size) {
+#ifdef _WIN32
+  HANDLE h        = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
+  DWORD available = 0;
+  if (PeekNamedPipe(h, nullptr, 0, nullptr, &available, nullptr) && available > 0)
+    return _read(fd, buffer, static_cast<unsigned>(size));
+  return 0;
+#else
+  ssize_t n = read(fd, buffer, size);
+  if (n > 0)
+    return static_cast<int>(n);
+  if (errno == EAGAIN || errno == EWOULDBLOCK)
+    return 0;
+  return -1;
+#endif
+}
+
+void Capture::drain() {
+  fflush(out.redirected);
+  char buffer[256];
+  while (true) {
+    int n = read_pipe(pipe_fds_[0], buffer, sizeof(buffer));
+    if (n > 0) {
+      *target += std::string_view(buffer, n);
+      if (echo) {
+        write(out.underlying_fd, buffer, n);
+      }
+    } else {
+      break;
+    }
+  }
+}
+
+}  // namespace rsl::testing

src/capture.hpp

@@ -0,0 +1,31 @@
+#pragma once
+#include <cstdio>
+#include <string>
+
+namespace rsl::testing {
+
+struct RedirectedOutput {
+  FILE* redirected = nullptr;
+  FILE* underlying = nullptr;
+
+  int redirected_fd = -1;
+  int underlying_fd = -1;
+
+  RedirectedOutput() = default;
+
+  RedirectedOutput(FILE* redirected_stream, int original_fd);
+};
+
+class Capture {
+  int pipe_fds_[2]{};
+  std::string* target;
+  bool echo;
+
+public:
+  RedirectedOutput out;
+
+  Capture(FILE* stream, std::string& target, bool echo = false);
+  ~Capture();
+  void drain();
+};
+}  // namespace rsl::testing

src/discovery.cpp

@@ -13,8 +13,8 @@
 
 #include <rsl/config>
 #include <rsl/testing/_testing_impl/factory.hpp>
-
 #include "output.hpp"
+
 namespace {
 template <std::ranges::range R>
 std::string join(R&& values, std::string_view delimiter) {

src/main.cpp

@@ -5,7 +5,6 @@
 
 #include <rsl/testing/output.hpp>
 #include <rsl/xml>
-#include "rsl/testing/annotations.hpp"
 
 namespace rsl::testing::_xml_impl {
 struct OverallResult {

src/reporters/catch2xml.cpp

@@ -27,6 +27,8 @@ class [[=rename("plain")]] ConsoleReporter : public Reporter::Registrar<ConsoleR
                  result.name,
                  result.duration_ms);
       std::print("{}ERROR{}: {}\n", color[1], reset, result.error);
+      std::print("==== {}stdout{} ====\n{}\n", color[1], reset, result.stdout);
+      std::print("==== {}stderr{} ====\n{}\n", color[1], reset, result.stderr);
     }
   }
   void after_run(std::span<TestResult> results) override {

src/reporters/terminal.cpp

@@ -4,11 +4,14 @@
 #include <libassert/assert.hpp>
 #include <rsl/testing/test.hpp>
 #include <rsl/testing/output.hpp>
+#include <rsl/testing/_testing_impl/discovery.hpp>
+
+#include "capture.hpp"
 
-template <bool Colorize>
 void failure_handler(libassert::assertion_info const& info) {
   // libassert::enable_virtual_terminal_processing_if_needed();  // for terminal colors on windows
-  auto width          = libassert::terminal_width(libassert::stderr_fileno);
+  constexpr bool Colorize = true;
+  auto width              = libassert::terminal_width(libassert::stderr_fileno);
   const auto& scheme  = Colorize ? libassert::get_color_scheme() : libassert::color_scheme::blank;
   std::string message = std::string(info.action()) + " at " + info.location() + ":";
   if (info.message) {
@@ -21,12 +24,57 @@ void failure_handler(libassert::assertion_info const& info) {
 }
 
 namespace rsl::testing {
-namespace _testing_impl {
-std::set<TestDef>& registry();
+std::set<TestDef>& _testing_impl::registry() {
+  static std::set<TestDef> data;
+  return data;
+}
+
+bool TestRoot::run(Reporter* reporter) {
+  libassert::set_failure_handler(failure_handler);
+  std::println("failure handler set");
+  reporter->before_run(*this);
+  bool status = TestNamespace::run(reporter);
+  libassert::set_failure_handler(libassert::default_failure_handler);
+  // TODO after_run
+  reporter->after_run({});
+  return status;
+}
+
+bool TestNamespace::run(Reporter* reporter) {
+  if (!name.empty()) {
+    reporter->enter_namespace(name);
+  }
+  bool status = true;
+  for (auto& ns : children) {
+    status &= ns.run(reporter);
+  }
+
+  for (auto& test : tests) {
+    auto runs = test.get_tests();
+    reporter->before_test_group(test);
+
+    std::vector<TestResult> results;
+    for (auto const& test_run : test.get_tests()) {
+      reporter->before_test(test_run);
+      auto result = test_run.run();
+      reporter->after_test(result);
+      results.push_back(result);
+    }
+
+    reporter->after_test_group(results);
+  }
+  if (!name.empty()) {
+    reporter->exit_namespace(name);
+  }
+  return status;
 }
+
 TestResult TestCase::run() const {
   auto ret = TestResult{.test = test, .name = name};
   try {
+    Capture _out(stdout, ret.stdout);
+    Capture _err(stderr, ret.stderr);
+
     auto t0 = std::chrono::steady_clock::now();
     fnc();
     auto t1 = std::chrono::steady_clock::now();
@@ -35,11 +83,16 @@ TestResult TestCase::run() const {
     ret.duration_ms = std::chrono::duration<double, std::milli>(t1 - t0).count();
     return ret;
   } catch (assertion_failure const& failure) {
-    ret.error = failure.what();
-  } catch (std::exception const& exc) {
-    ret.error = exc.what();
-  }  //
-  catch (...) {}
+    ret.error += failure.what();
+  } catch (std::exception const& exc) {  //
+    ret.error += exc.what();
+  } catch (std::string const& msg) {  //
+    ret.error += msg;
+  } catch (std::string_view msg) {  //
+    ret.error += msg;
+  } catch (char const* msg) {  //
+    ret.error += msg;
+  } catch (...) { ret.error += "unknown exception thrown"; }
 
   ret.passed = test->expect_failure;
   return ret;
@@ -111,45 +164,6 @@ std::size_t TestNamespace::count() const {
   return total;
 }
 
-bool TestNamespace::run(Reporter* reporter) {
-  if (!name.empty()) {
-    reporter->enter_namespace(name);
-  }
-  bool status = true;
-  for (auto& ns : children) {
-    status &= ns.run(reporter);
-  }
-
-  for (auto& test : tests) {
-    auto runs = test.get_tests();
-    reporter->before_test_group(test);
-
-    std::vector<TestResult> results;
-    for (auto const& test_run : test.get_tests()) {
-      reporter->before_test(test_run);
-      auto result = test_run.run();
-      reporter->after_test(result);
-      results.push_back(result);
-    }
-
-    reporter->after_test_group(results);
-  }
-  if (!name.empty()) {
-    reporter->exit_namespace(name);
-  }
-  return status;
-}
-
-bool TestRoot::run(Reporter* reporter) {
-  libassert::set_failure_handler(failure_handler<true>);
-  reporter->before_run(*this);
-  bool status = TestNamespace::run(reporter);
-  libassert::set_failure_handler(libassert::default_failure_handler);
-  // TODO after_run
-  reporter->after_run({});
-  return status;
-}
-
 TestRoot get_tests() {
   TestRoot root;
   for (auto test_def : rsl::testing::_testing_impl::registry()) {