exit normally in aborts predicate

When testing that a closure calls `abort`, exit normally in the child
process if the test closure returns successfully. Previously, the child
process would call `_Exit` in order to terminate without flushing to
stdout. However, this also prevents gcov from writing coverage metrics
of the child process as this routine is registered with `atexit`.

This commit updates the abort predicate to send a flush command to the
printer before calling fork. The child process silences the printer
before invoking the test closure and exits normally if needed.

Change-Id: I0164e5752b4967ecad87c7fb7eee6622b847ab4b

.github/coverage.yml

@@ -0,0 +1,18 @@
+coverage:
+  status:
+    project:
+      default:
+        # basic
+        target: auto
+        threshold: 0%
+        base: auto 
+        flags: 
+          - unit
+        paths: 
+          - "src"
+       # advanced settings
+        branches: 
+          - master
+        if_ci_failed: error #success, failure, error, ignore
+        informational: false
+        only_pulls: false

src/aborts.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "src/cfg.hpp"
+
 #include <cstdlib>
 #include <cstring>
 #include <optional>
@@ -10,7 +12,8 @@
 
 namespace skytest {
 
-inline constexpr struct
+namespace detail {
+struct aborts_fn
 {
   struct return_type
   {
@@ -38,23 +41,40 @@ inline constexpr struct
     }
   };
 
-  template <class F>
+  struct do_flush
+  {
+    friend auto& operator<<(std::ostream& os, do_flush)
+    {
+      os.flush();
+      return os;
+    }
+  };
+
+  template <class F, class Override = override>
   constexpr auto operator()(F&& f) const -> return_type
   {
+    cfg<Override>.printer_ << do_flush{};
+
     const auto pid = ::fork();
     if (pid == -1) {
       return {};
     }
 
     if (pid == 0) {
+      cfg<Override>.silence();
+
       std::forward<F>(f)();
-      std::_Exit(EXIT_SUCCESS);
+
+      // NOLINTNEXTLINE(concurrency-mt-unsafe)
+      std::exit(EXIT_SUCCESS);
     }
 
     auto status = int{};
     ::wait(&status);
     return {status};
   }
-} aborts{};
+};
+}  // namespace detail
+inline constexpr auto aborts = detail::aborts_fn{};
 
 }  // namespace skytest

src/runner.hpp

@@ -7,12 +7,20 @@
 #include <type_traits>
 
 namespace skytest {
+namespace detail {
+struct aborts_fn;
+}
 
 template <class Printer>
 class runner
 {
   mutable Printer printer_;
   mutable summary summary_{};
+  mutable bool silent_ = false;
+
+  friend struct ::skytest::detail::aborts_fn;
+
+  auto silence() const { silent_ = true; }
 
 public:
   template <
@@ -25,6 +33,10 @@ class runner
 
   ~runner()
   {
+    if (silent_) {
+      return;
+    }
+
     printer_ << summary_;
 
     // NOLINTNEXTLINE(concurrency-mt-unsafe)