Fix TAP and Verbose formatters and be_within_spec test

Author: toroidal-code

include/formatters/tap.hpp

@@ -12,9 +12,12 @@ struct TAP final : public BaseFormatter {
   bool first = true;
   std::ostringstream buffer;
 
+  ~TAP() { flush(); }
+
   std::string result_to_yaml(const Result& result);
   void format(Description& description) override;
   void format(ItBase& it) override;
+  void flush();
 };
 
 inline std::string TAP::result_to_yaml(const Result& result) {
@@ -36,14 +39,14 @@ inline std::string TAP::result_to_yaml(const Result& result) {
   return oss.str();
 }
 
-inline void TAP::format(Description& description) {
-  if (!first && !description.has_parent()) {
-    std::string str = buffer.str();
-    std::ostringstream oss;
-    if (str[0] == '\n') {
-      oss << str[0];
-    }
+inline void TAP::flush() {
+  std::string str = buffer.str();
+  std::ostringstream oss;
+  if (str[0] == '\n') {
+    oss << str[0];
+  }
 
+  if (test_counter != 1) {
     if (color_output) {
       oss << GREEN;
     }
@@ -52,13 +55,19 @@ inline void TAP::format(Description& description) {
       oss << RESET;
     }
     oss << std::endl;
+  }
 
-    oss << ((str[0] == '\n') ? str.substr(1) : str);
+  oss << ((str[0] == '\n') ? str.substr(1) : str);
 
-    std::cout << oss.str() << std::flush;
-    first = false;
-    test_counter = 1;
-    buffer = std::ostringstream();
+  std::cout << oss.str() << std::flush;
+  first = false;
+  reset_test_counter();
+  buffer = std::ostringstream();
+}
+
+inline void TAP::format(Description& description) {
+  if (!first && !description.has_parent()) {
+    flush();
   }
 
   if (first) {

include/formatters/verbose.hpp

@@ -12,7 +12,6 @@ namespace CppSpec::Formatters {
 
 class Verbose : public BaseFormatter {
   bool first = true;
-  std::list<std::string> failure_messages{};
 
  public:
   Verbose() = default;
@@ -51,8 +50,7 @@ inline void Verbose::format(ItBase& it) {
       if (color_output) {
         out_stream << RED;  // make them red
       }
-      out_stream << Util::join(failure_messages,
-                               "\n");  // separated by a blank line
+      out_stream << result.get_message() << std::endl;
       if (color_output) {
         out_stream << RESET;
       }

include/matchers/errors/fail.hpp

@@ -7,10 +7,10 @@ namespace CppSpec::Matchers {
 template <typename A>
 class Fail : public MatcherBase<A, void*> {
  public:
-  static_assert(is_result_v<A>, ".fail must() be matched against a Result.");
+  static_assert(is_result_v<A>, ".fail must() be matched against a Matcher.");
   explicit Fail(Expectation<A>& expectation) : MatcherBase<A, void*>(expectation, nullptr) {}
-
-  bool match() { return !this->actual().status(); }
+  std::string verb() override { return "fail"; }
+  bool match() override { return this->actual().is_failure(); }
 };
 
 template <typename A>
@@ -19,7 +19,13 @@ class FailWith : public MatcherBase<A, std::string> {
   static_assert(is_result_v<A>, ".fail_with() must be matched against a Result.");
   FailWith(Expectation<A>& expectation, std::string expected) : MatcherBase<A, std::string>(expectation, expected) {}
 
-  bool match() { return (!this->actual().status()) && this->actual().get_message() == this->expected(); }
+  std::string verb() override { return "fail with"; }
+  std::string description() override { return std::format(R"(fail with "{}")", this->expected()); }
+
+  bool match() override {
+    auto message = this->actual().get_message();
+    return this->actual().is_failure() && message == this->expected();
+  }
 };
 
 }  // namespace CppSpec::Matchers

include/matchers/matcher_base.hpp

@@ -169,18 +169,14 @@ Result MatcherBase<A, E>::run() {
 
   // If our items didn't match, we obviously failed.
   // Only report the failure if we aren't actively ignoring it.
-  if (result.is_failure()) {
-    if (expectation_.ignore_failure()) {
-      result = Result::success(result.get_location());
-    } else if (result.get_message().empty()) {
-      result.set_message(
-          "Failure message is empty. Does your matcher define the "
-          "appropriate failure_message[_when_negated] method to "
-          "return a string?");
-    }
+  if (result.is_failure() && result.get_message().empty()) {
+    result.set_message(
+        "Failure message is empty. Does your matcher define the "
+        "appropriate failure_message[_when_negated] method to "
+        "return a string?");
   }
 
-  if (parent) {
+  if (parent && !expectation_.ignore_failure()) {
     parent->add_result(result);
   }
   return result;

include/runnable.hpp

@@ -145,6 +145,7 @@ class Runnable {
  * @brief Generate padding (indentation) fore the current object.
  * @return A string of spaces for use in pretty-printing.
  */
+// TODO: Refactor this into Runnable::depth
 inline std::string Runnable::padding() const noexcept {
   return this->has_parent() ? this->get_parent()->padding() + "  " : "";
 }

spec/matchers/be_within_spec.cpp

@@ -75,7 +75,7 @@ describe be_within_spec("expect(actual).to_be_within(delta).of(expected)", $  {
 
     it("fails when actual is outside the given percent variance", _ {
       auto base_formatter = Formatters::BaseFormatter();
-      auto ex = ExpectationValue(self, 20.1, std::source_location::current());
+      auto ex = ExpectationValue(self, 20.1, std::source_location::current()).ignore();
       auto matcher = Matchers::BeWithinHelper(ex, 10).percent_of(10.0);
       expect(matcher.run()).to_fail_with("expected 20.1 to be within 10% of 10");
     });