Fancy runner

Author: toroidal-code

Doxyfile

@@ -805,7 +805,7 @@ EXCLUDE_SYMLINKS       = NO
 # Note that the wildcards are matched against the file with absolute path, so to
 # exclude all test directories for example use the pattern */test/*
 
-EXCLUDE_PATTERNS       = */test/* */cxx-prettyprint/*
+EXCLUDE_PATTERNS       = */test/* */cxx-prettyprint/* */optional/*
 
 # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
 # (namespaces, classes, functions, etc.) that should be excluded from the

examples/sample/example_spec.cpp

@@ -53,7 +53,7 @@ describe bool_spec("Some Tests", $ {
       expect({1,2,3}).to_include({1});
     });
     it("includes [1,2,3]", _ {
-      expect({1,2,3}).to_include({1,2,3});
+      expect({1,2,3}).to_include({1,2,8});
     });
     it("does not include 4", _ {
       expect({1,2,3}).not_().to_include({4});
@@ -109,7 +109,7 @@ describe abs_spec("abs", $ {
   });
 
   before_all([]{ std::srand(std::time(0)); });
-  
+
   int n = 0;
   before_each([&]{ n = std::rand(); });
 
@@ -189,13 +189,12 @@ describe list_spec("A list spec", $ {
 
 /* Here is the declaration of fabs description defined in an other file (fabs_spec.c in this sample)*/
 int main(){
-  bool r = true;
-  auto printer = CppSpec::Printer::verbose;
-  r &= bool_spec.run(printer);
-  r &= abs_spec.run(printer);
-  r &= strcmp_spec.run(printer);
-  r &= vector_spec.run(printer);
-  r &= let_spec.run(printer);
-  r &= list_spec.run(printer);
-  return r ? EXIT_SUCCESS : EXIT_FAILURE;
+  return CppSpec::Runner()
+             .add_spec(bool_spec)
+             .add_spec(abs_spec)
+             .add_spec(strcmp_spec)
+             .add_spec(vector_spec)
+             .add_spec(let_spec)
+             .add_spec(list_spec)
+             .exec() ? EXIT_SUCCESS : EXIT_FAILURE;
 }

include/child.hpp

@@ -4,7 +4,7 @@
 
 namespace CppSpec {
 
-struct BasePrinter;
+struct BasePrinter;  // Forward declaration to allow reference
 
 /**
  * @brief Base class for all objects in the execution tree.

include/class_description.hpp

@@ -254,5 +254,5 @@ Result ItCd<T>::run(BasePrinter &printer) {
   return this->get_status() ? Result::success : Result::failure;
 }
 
-} // ::CppSpec
-#endif // CPPSPEC_CLASS_DESCRIPTION_HPP
+}  // ::CppSpec
+#endif  // CPPSPEC_CLASS_DESCRIPTION_HPP

include/cppspec.hpp

@@ -2,8 +2,9 @@
  * @file
  * @brief The core header file for Cppspec
  */
-
-#include "printer.hpp"
+#ifndef CPPSPEC_HPP
+#define CPPSPEC_HPP
+#include "runner.hpp"
 
 #define _ [=](auto &self) mutable
 #define $ [](auto &self)
@@ -18,11 +19,13 @@
 #define before_each self.before_each
 #define after_all self.after_all
 #define after_each self.after_each
-#define let(name, body)              \
+#define let(name, body)                   \
   auto name = self.make_let(#name, body); \
-  self.let(#name, name);
+  self.add_let(#name, name);
 
 typedef CppSpec::Description describe;
 
 template <class T>
 using describe_a = CppSpec::ClassDescription<T>;
+
+#endif  // CPPSPEC_HPP

include/description.hpp

@@ -70,7 +70,7 @@ class Description : public Runnable {
 
   template <typename T>
   auto make_let(std::string name, T body) -> Let<decltype(body())>;
-  void let(std::string name, Runnable &body);
+  void add_let(std::string name, Runnable &body);
   virtual Result run(BasePrinter &printer) override;
   void reset_lets();
   Runnable *find_let(std::string);
@@ -158,7 +158,7 @@ auto Description::make_let(std::string name, T body) -> Let<decltype(body())> {
   return Let<decltype(body())>(*this, name, body);
 }
 
-void Description::let(std::string name, Runnable &body) {
+void Description::add_let(std::string name, Runnable &body) {
   lets.insert({name, &body});
 }
 

include/printer.hpp

@@ -1,5 +1,5 @@
-#ifndef CPP_SPEC_PRINTER_HPP
-#define CPP_SPEC_PRINTER_HPP
+#ifndef CPPSPEC_PRINTER_HPP
+#define CPPSPEC_PRINTER_HPP
 // the following are UBUNTU/LINUX ONLY terminal color codes.
 #define RESET "\033[0m"
 #define BLACK "\033[30m"              /* Black */
@@ -26,6 +26,9 @@ namespace CppSpec {
 class PrettyPrinter : public BasePrinter {
   int test_counter = 1;
   std::stringstream buffer;
+  std::shared_ptr<std::list<std::string>> failures =
+      std::make_shared<std::list<std::string>>();  // empty list by default
+
   bool first = true;
 
  public:
@@ -34,9 +37,12 @@ class PrettyPrinter : public BasePrinter {
         test_counter(copy.test_counter),
         first(copy.first) {
     buffer << copy.buffer.str();
-  }
+  };
 
   PrettyPrinter(Mode mode) : BasePrinter(mode){};
+  PrettyPrinter(Mode mode, std::shared_ptr<std::list<std::string>> failures)
+      : BasePrinter(mode), failures(failures){};
+
   // template <class C>
   // void print(ClassDescription<C> &runnable);
   void print(Description &runnable) override;
@@ -99,24 +105,42 @@ void PrettyPrinter::print_failure(std::string message) {
   // Diff diff = differ.diff(actual, expected)
   // Throwing exceptions in Ruby is totally different from C++. Gonna just
   // stdout this thing.
+  std::ostringstream oss;
   switch (mode) {
     case Mode::verbose:
       std::cout << RED << message << RESET << std::endl;
+    // failures->push_back(message);
     case Mode::terse:
-      buffer << std::endl
-             << RED << "Test number " << test_counter << " failed:" << std::endl
-             << message << RESET;
+      // failure_buffer << std::endl << RED
+
+      oss << "Test number " << test_counter << " failed:" << std::endl
+          << message;
+      //<< RESET;
+      failures->push_back(oss.str());
     default:
       break;
   }
 }
 
+/**
+ * Gets called at the end of printing an entire spec (!this->has_parent())
+ */
 void PrettyPrinter::flush() {
   std::string str = buffer.str();
   std::stringstream ss;
   switch (mode) {
     case Mode::terse:
-      if (not str.empty()) std::cout << std::endl << str << std::endl;
+      if (failures.unique()) {   // this means that it's *our* list of failures
+                                 // not a runner's
+        std::cout << std::endl;  // If that's true; print a newline
+        if (not failures->empty()) {  // If we have any failures to print
+          std::cout << RED            // make them red
+                    << Util::join(*failures, "\n\n")  // print them
+                    << RESET << std::endl;            // and print a newline
+          failures->clear();  // finally, clear the failures list.
+        }
+        test_counter = 1;     // and reset the test counter
+      }
       break;
     case Mode::TAP:
       if (str[0] == '\n') {
@@ -126,12 +150,12 @@ void PrettyPrinter::flush() {
         ss << "1.." << test_counter - 1 << std::endl << str;
       }
       std::cout << ss.str() << std::flush;
-      buffer = std::stringstream();
       first = false;
     default:
       test_counter = 1;
       break;
   }
+  buffer = std::stringstream();
 }
 
 namespace Printer {
@@ -141,4 +165,4 @@ static PrettyPrinter TAP = PrettyPrinter(PrettyPrinter::Mode::TAP);
 }
 
 }  // ::CppSpec
-#endif  // CPP_SPEC_PRINTER_HPP
+#endif  // CPPSPEC_PRINTER_HPP

include/result.hpp

@@ -6,8 +6,9 @@ namespace CppSpec {
 
 class Result {
   const bool value;
-  std::string message = "";
-  Result(bool value) : value(value) { };
+  std::string message;
+  Result(bool value, std::string message = "")
+      : value(value), message(message){};
 
  public:
   // Default destructor
@@ -51,12 +52,12 @@ inline Result &Result::set_message(std::string message) {
 
 Result Result::success = Result(true);
 inline Result Result::success_with(std::string success_message) {
-  return success.set_message(success_message);
+  return Result(true, success_message);
 }
 
 Result Result::failure = Result(false);
 inline Result Result::failure_with(std::string failure_message) {
-  return failure.set_message(failure_message);
+  return Result(false, failure_message);
 }
 
 std::ostream &operator<<(std::ostream &os, const Result &res) {
@@ -70,5 +71,5 @@ std::ostream &operator<<(std::ostream &os, const Result &res) {
   return os << ss.str();
 }
 
-} //::CppSpec
+}  //::CppSpec
 #endif  // CPPSPEC_RESULT_HPP

include/runner.hpp

@@ -0,0 +1,55 @@
+#ifndef CPPSPEC_RUNNER_HPP
+#define CPPSPEC_RUNNER_HPP
+#include <list>
+#include "printer.hpp"
+
+namespace CppSpec {
+
+class Runner {
+  std::list<Description *> specs;
+  PrettyPrinter &printer = Printer::terse;
+
+ public:
+  Runner() = default;
+
+  Runner(PrettyPrinter &printer) : printer(printer){};
+
+  template <typename T>
+  Runner &add_spec(ClassDescription<T> &spec);
+  Runner &add_spec(Description &spec);
+  Result run(BasePrinter &printer);
+  Result exec();
+};
+
+template <typename T>
+Runner &Runner::add_spec(ClassDescription<T> &spec) {
+  specs.push_back(&spec);
+  return *this;
+}
+
+Runner &Runner::add_spec(Description &spec) {
+  specs.push_back(&spec);
+  return *this;
+}
+
+Result Runner::run(BasePrinter &printer) {
+  bool success = true;
+  for (auto spec : specs) {
+    success &= static_cast<bool>(spec->run(printer));
+  }
+  return success ? Result::success : Result::failure;
+}
+
+Result Runner::exec() {
+  if (this->printer.mode == BasePrinter::Mode::terse) {
+    auto failures = std::make_shared<std::list<std::string>>();
+    PrettyPrinter printer(this->printer.mode, failures);
+    Result result = this->run(printer);
+    std::cout << RED << std::endl << Util::join<std::list<std::string>>(*failures, "\n\n") << RESET << std::endl;
+    return result;
+  } else {
+    return this->run(printer);
+  }
+}
+}
+#endif  // CPPSPEC_RUNNER_HPP

include/util.hpp

@@ -235,6 +235,17 @@ std::string inspect_object<std::string>(std::string &o) {
   return ss.str();
 }
 
+template <typename Range>
+std::string join(Range &iterable, const std::string &sep) {
+  std::ostringstream oss;
+  typename Range::const_iterator it;
+  for (it = iterable.cbegin(); it != iterable.cend(); it++) {
+    oss << *it;
+    if (it != --iterable.cend()) oss << sep;
+  }
+  return oss.str();
+}
+
 }  // ::Util
 }  // ::CppSpec
-#endif // CPPSPEC_UTIL_HPP
+#endif  // CPPSPEC_UTIL_HPP