Add runtime exception handling, formatter improvements

Author: toroidal-code

examples/sample/example_spec.cpp

@@ -4,10 +4,11 @@
 #include <list>
 #include "cppspec.hpp"
 
+// clang-format off
 describe bool_spec("Some Tests", $ {
   context("true is", _ {
     it("true", _ {
-      expect(static_cast<bool>(1)).to_equal(true);
+      expect(1).to_equal(true);
     });
 
     it("true", _ {
@@ -27,6 +28,10 @@ describe bool_spec("Some Tests", $ {
     it("plus 1 equals 5", _ {
       expect(i+1).to_equal(5);
     });
+
+    it("equals 6", _ {
+      expect(i).to_equal(6);
+    });
   });
 
   explain("0 is", _ {

include/argparse.hpp

@@ -24,7 +24,9 @@ inline std::string file_name(std::string_view path) {
 }
 
 inline Runner parse(int argc, char** const argv) {
-  argparse::ArgumentParser program{file_name(argv[0])};
+  std::filesystem::path executable_path = argv[0];
+  std::string executable_name = executable_path.filename().string();
+  argparse::ArgumentParser program{executable_name};
 
   program.add_argument("-f", "--format")
       .default_value(std::string{"p"})

include/expectations/expectation.hpp

@@ -2,6 +2,7 @@
 
 #include <exception>
 #include <regex>
+#include <source_location>
 #include <string>
 #include <vector>
 
@@ -50,10 +51,11 @@ class Expectation {
  protected:
   bool is_positive_ = true;
   // Have we been negated?
-  bool ignore_failure_ = false;
+  bool ignore_ = false;
 
  public:
   Expectation() = default;
+  explicit Expectation(std::source_location location) : location(location) {}
 
   /**
    * @brief Create an Expectation using a value.
@@ -68,12 +70,12 @@ class Expectation {
   // virtual const A &get_target() const & { return target; }
   virtual A& get_target() & = 0;
 
-  ItBase* get_it() const { return it; }
-  std::source_location get_location() const { return location; }
+  [[nodiscard]] ItBase* get_it() const { return it; }
+  [[nodiscard]] std::source_location get_location() const { return location; }
 
   /** @brief Get whether the expectation is normal or negated. */
-  [[nodiscard]] constexpr bool sign() const { return is_positive_; }
-  [[nodiscard]] constexpr bool ignore_failure() const { return ignore_failure_; }
+  [[nodiscard]] constexpr bool positive() const { return is_positive_; }
+  [[nodiscard]] constexpr bool ignored() const { return ignore_; }
 
   /********* Modifiers *********/
 
@@ -404,6 +406,8 @@ class ExpectationValue : public Expectation<A> {
    * @return The constructed ExpectationValue.
    */
   ExpectationValue(ItBase& it, A value, std::source_location location) : Expectation<A>(it, location), value(value) {}
+  explicit ExpectationValue(A value, std::source_location location = std::source_location::current())
+      : Expectation<A>(location), value(value) {}
 
   /**
    * @brief Create an Expectation using an initializer list.
@@ -425,7 +429,7 @@ class ExpectationValue : public Expectation<A> {
   }
 
   ExpectationValue& ignore() override {
-    this->ignore_failure_ = true;
+    this->ignore_ = true;
     return *this;
   }
 };
@@ -484,7 +488,7 @@ class ExpectationFunc : public Expectation<decltype(std::declval<F>()())> {
   }
 
   ExpectationFunc& ignore() override {
-    this->ignore_failure_ = true;
+    this->ignore_ = true;
     return *this;
   }
 

include/expectations/handler.hpp

@@ -9,6 +9,7 @@
 
 #pragma once
 
+#include <exception>
 #include <string>
 
 #include "result.hpp"
@@ -39,9 +40,17 @@ struct NegativeExpectationHandler {
  */
 template <class Matcher>
 Result PositiveExpectationHandler::handle_matcher(Matcher& matcher) {
-  // TODO: handle expectation failure here
-  return !matcher.match() ? Result::failure_with(matcher.get_location(), matcher.failure_message())
-                          : Result::success(matcher.get_location());
+  bool matched = false;
+  try {
+    matched = matcher.match();
+  } catch (std::exception& e) {
+    return Result::error_with(matcher.get_location(), e.what());
+  } catch (...) {
+    return Result::error_with(matcher.get_location(), "Unknown exception thrown during matcher execution.");
+  }
+
+  return !matched ? Result::failure_with(matcher.get_location(), matcher.failure_message())
+                  : Result::success(matcher.get_location());
 }
 
 /**
@@ -54,9 +63,16 @@ Result PositiveExpectationHandler::handle_matcher(Matcher& matcher) {
  */
 template <class Matcher>
 Result NegativeExpectationHandler::handle_matcher(Matcher& matcher) {
-  // TODO: handle expectation failure here
-  return !matcher.negated_match() ? Result::failure_with(matcher.get_location(), matcher.failure_message_when_negated())
-                                  : Result::success(matcher.get_location());
+  bool matched = false;
+  try {
+    matched = matcher.negated_match();
+  } catch (std::exception& e) {
+    return Result::error_with(matcher.get_location(), e.what());
+  } catch (...) {
+    return Result::error_with(matcher.get_location(), "Unhandled exception thrown during matcher execution.");
+  }
+  return !matched ? Result::failure_with(matcher.get_location(), matcher.failure_message_when_negated())
+                  : Result::success(matcher.get_location());
 }
 
 }  // namespace CppSpec

include/formatters/formatters_base.hpp

@@ -7,6 +7,7 @@
 #include "description.hpp"
 #include "it_base.hpp"
 #include "runnable.hpp"
+#include "term_colors.hpp"
 
 extern "C" {
 #ifdef _WIN32
@@ -69,6 +70,31 @@ class BaseFormatter {
 
   int get_and_increment_test_counter() { return test_counter++; }
   void reset_test_counter() { test_counter = 1; }
+
+  const char* set_color(const char* color) {
+    if (!color_output) {
+      return "";  // No color output
+    }
+    return color;
+  }
+
+  const char* status_color(Result::Status status) {
+    if (!color_output) {
+      return "";  // No color output
+    }
+    switch (status) {
+      case Result::Status::Success:
+        return GREEN;
+      case Result::Status::Failure:
+        return RED;
+      case Result::Status::Error:
+        return MAGENTA;
+      case Result::Status::Skipped:
+        return YELLOW;
+    }
+  }
+
+  const char* reset_color() { return color_output ? RESET : ""; }
 };
 
 inline BaseFormatter& BaseFormatter::set_color_output(bool value) {

include/formatters/progress.hpp

@@ -13,7 +13,6 @@ namespace CppSpec::Formatters {
 // The TAP format makes things a little tricky
 class Progress : public BaseFormatter {
   std::list<std::string> baked_failure_messages;
-  std::list<std::string> raw_failure_messages;
 
   std::string prep_failure_helper(const ItBase& it);
 
@@ -25,6 +24,20 @@ class Progress : public BaseFormatter {
 
   void format_failure_messages();
   void prep_failure(const ItBase& it);
+
+  static char status_char(Result::Status status) {
+    switch (status) {
+      case Result::Status::Success:
+        return '.';
+      case Result::Status::Failure:
+        return 'F';
+      case Result::Status::Error:
+        return 'E';
+      case Result::Status::Skipped:
+        return 'S';
+    }
+    return '.';  // Default to success if status is unknown
+  }
 };
 
 /** @brief An assistant function for prep_failure to reduce complexity */
@@ -63,43 +76,33 @@ inline std::string Progress::prep_failure_helper(const ItBase& it) {
 }
 
 inline void Progress::prep_failure(const ItBase& it) {
-  std::ostringstream string_builder;  // oss is used as the local string builder
-  if (color_output) {
-    string_builder << RED;  // if we're doing color, make it red
-  }
+  std::list<std::string> raw_failure_messages;  // raw failure messages
+  std::ranges::transform(it.get_results(), std::back_inserter(raw_failure_messages),
+                         [](const Result& result) { return result.get_message(); });
+
+  std::ostringstream string_builder;                               // oss is used as the local string builder
+  string_builder << set_color(RED);                                // if we're doing color, make it red
   string_builder << "Test number " << test_counter << " failed:";  // Tell us what test # failed
-  if (color_output) {
-    string_builder << RESET;  // if we're doing color, reset the terminal
-  }
+  string_builder << reset_color();                                 // reset the color
   string_builder << prep_failure_helper(it);
-  if (color_output) {
-    string_builder << RED;
-  }
-  string_builder << Util::join(raw_failure_messages, "\n");
-  if (color_output) {
-    string_builder << RESET;
-  }
+  string_builder << set_color(RED);
+  string_builder << Util::join_endl(raw_failure_messages);
+  string_builder << reset_color();  // reset the color
+  string_builder << std::endl;
+
   raw_failure_messages.clear();
   baked_failure_messages.push_back(string_builder.str());
 }
 
 inline void Progress::format(const ItBase& it) {
-  if (it.get_result().status()) {
-    if (color_output) {
-      out_stream << GREEN;
-    }
-    out_stream << ".";
-  } else {
-    if (color_output) {
-      out_stream << RED;
-    }
-    out_stream << "F";
+  out_stream << status_color(it.get_result().status());
+  out_stream << status_char(it.get_result().status());
+  out_stream << reset_color();
+  out_stream << std::flush;
+
+  if (it.get_result().status() == Result::Status::Failure) {
     prep_failure(it);
   }
-  if (color_output) {
-    out_stream << RESET;
-  }
-  out_stream << std::flush;
   get_and_increment_test_counter();
 }
 

include/formatters/tap.hpp

@@ -25,9 +25,23 @@ inline std::string TAP::result_to_yaml(const Result& result) {
     return {};
   }
 
+  auto message = result.get_message();
+
   std::ostringstream oss;
   oss << "  " << "---" << std::endl;
-  oss << "  " << "message: " << "'" << result.get_message() << "'" << std::endl;
+  if (message.contains("\n")) {
+    oss << "  " << "message: |" << std::endl;
+    std::string indented_message = message;  // split on newlines and indent
+    std::string::size_type pos = 0;
+    while ((pos = indented_message.find('\n', pos)) != std::string::npos) {
+      indented_message.replace(pos, 1, "\n    ");
+      pos += 2;  // Skip over the newline and the space we just added
+    }
+    oss << "  " << "  " << indented_message << std::endl;
+  } else {
+    oss << "  " << "message: " << '"' << result.get_message() << '"' << std::endl;
+  }
+
   oss << "  " << "severity: failure" << std::endl;
   oss << "  " << "at:" << std::endl;
   oss << "  " << "  " << "file: " << result.get_location().file_name() << std::endl;
@@ -88,13 +102,9 @@ inline void TAP::format(const ItBase& it) {
 
   std::string description = Util::join(descriptions, " ");
 
-  if (color_output) {
-    buffer << (it.get_result().status() ? GREEN : RED);
-  }
-  buffer << (it.get_result().status() ? "ok" : "not ok");
-  if (color_output) {
-    buffer << RESET;
-  }
+  buffer << status_color(it.get_result().status());
+  buffer << (it.get_result().is_success() ? "ok" : "not ok");
+  buffer << reset_color();
   buffer << " " << get_and_increment_test_counter() << " - " << description << std::endl;
   buffer << result_to_yaml(it.get_result());
 }

include/formatters/term_colors.hpp

@@ -1,6 +1,8 @@
 /** @file */
 #pragma once
 
+namespace CppSpec {
+
 // the following are Unix/BASH ONLY terminal color codes.
 constexpr auto RESET("\033[0m");
 constexpr auto BLACK("\033[30m");              /* Black */
@@ -19,3 +21,5 @@ constexpr auto BOLDBLUE("\033[1m\033[34m");    /* Bold Blue */
 constexpr auto BOLDMAGENTA("\033[1m\033[35m"); /* Bold Magenta */
 constexpr auto BOLDCYAN("\033[1m\033[36m");    /* Bold Cyan */
 constexpr auto BOLDWHITE("\033[1m\033[37m");   /* Bold White */
+
+}  // namespace CppSpec

include/formatters/verbose.hpp

@@ -31,26 +31,18 @@ inline void Verbose::format(const Description& description) {
 }
 
 inline void Verbose::format(const ItBase& it) {
-  if (color_output) {
-    out_stream << (it.get_result().status() ? GREEN : RED);
-  }
+  out_stream << status_color(it.get_result().status());
   out_stream << it.padding() << it.get_description() << std::endl;
-  if (color_output) {
-    out_stream << RESET;
-  }
+  out_stream << reset_color();
 
   // Print any failures if we've got them
   // 'it' having a bad status necessarily
   // implies that there are failure messages
   for (const Result& result : it.get_results()) {
     if (result.is_failure()) {
-      if (color_output) {
-        out_stream << RED;  // make them red
-      }
+      out_stream << set_color(RED);
       out_stream << result.get_message() << std::endl;
-      if (color_output) {
-        out_stream << RESET;
-      }
+      out_stream << reset_color();
     }
   }