Add junit output support

Author: toroidal-code

.clang-tidy

@@ -36,10 +36,9 @@ Checks: >
   -readability-identifier-length,
   -readability-magic-numbers
 WarningsAsErrors: false # should be true once we get there
-#HeaderFileExtensions:         ['h','hh','hpp','hxx'] # enable iff clang-tidy v17+
-#ImplementationFileExtensions: ['c','cc','cpp','cxx'] # enable iff clang-tidy v17+ (stops from touching .S assembly files)
+HeaderFileExtensions:         ['h','hh','hpp','hxx'] # enable iff clang-tidy v17+
+ImplementationFileExtensions: ['c','cc','cpp','cxx'] # enable iff clang-tidy v17+ (stops from touching .S assembly files)
 HeaderFilterRegex: ".*"
-AnalyzeTemporaryDtors: false
 ExtraArgs: ['-Wno-unknown-argument', '-Wno-unknown-warning-option', '-W']
 FormatStyle: file
 CheckOptions:

include/argparse.hpp

@@ -1,6 +1,8 @@
 #pragma once
 
 #include <argparse/argparse.hpp>
+#include <fstream>
+#include <string>
 #include <string_view>
 
 #include "formatters/junit_xml.hpp"
@@ -21,11 +23,6 @@ inline std::string file_name(std::string_view path) {
   return std::string{file};
 }
 
-struct RuntimeOpts {
-  bool verbose = false;
-  std::shared_ptr<Formatters::BaseFormatter> formatter = nullptr;
-};
-
 inline Runner parse(int argc, char** const argv) {
   argparse::ArgumentParser program{file_name(argv[0])};
 
@@ -35,7 +32,8 @@ inline Runner parse(int argc, char** const argv) {
       .required()
       .help("set the output format");
 
-  program.add_argument("--verbose").help("increase output verbosity").default_value(false).implicit_value(true);
+  program.add_argument("--output-junit").help("output JUnit XML to the specified file").default_value(std::string{});
+  program.add_argument("--verbose").help("increase output verbosity").flag();
 
   try {
     program.parse_args(argc, argv);
@@ -45,22 +43,28 @@ inline Runner parse(int argc, char** const argv) {
     std::exit(1);
   }
 
-  RuntimeOpts opts;
-
   auto format_string = program.get<std::string>("--format");
+  std::shared_ptr<Formatters::BaseFormatter> formatter;
   if (format_string == "d" || format_string == "detail" || program["--verbose"] == true) {
-    opts.formatter = std::make_unique<Formatters::Verbose>();
+    formatter = std::make_shared<Formatters::Verbose>();
   } else if (format_string == "p" || format_string == "progress") {
-    opts.formatter = std::make_unique<Formatters::Progress>();
+    formatter = std::make_shared<Formatters::Progress>();
   } else if (format_string == "t" || format_string == "tap") {
-    opts.formatter = std::make_unique<Formatters::TAP>();
+    formatter = std::make_shared<Formatters::TAP>();
   } else if (format_string == "j" || format_string == "junit") {
-    opts.formatter = std::make_unique<Formatters::JUnitXML>();
+    formatter = std::make_shared<Formatters::JUnitXML>();
   } else {
     std::cerr << "Unrecognized format type" << std::endl;
     std::exit(-1);
   }
 
-  return Runner{opts.formatter};
+  auto junit_output_filepath = program.get<std::string>("--output-junit");
+  if (!junit_output_filepath.empty()) {
+    auto* file_stream = new std::ofstream(junit_output_filepath);
+    auto junit_output = std::make_shared<Formatters::JUnitXML>(*file_stream, false);
+    return Runner{formatter, junit_output};
+  }
+
+  return Runner{formatter};
 }
 }  // namespace CppSpec

include/formatters/formatters_base.hpp

@@ -33,54 +33,44 @@ class BaseFormatter {
  protected:
   std::ostream& out_stream;
   int test_counter = 1;
-  bool multiple = false;
   bool color_output;
 
  public:
   explicit BaseFormatter(std::ostream& out_stream = std::cout, bool color = is_terminal())
       : out_stream(out_stream), color_output(color) {}
   BaseFormatter(const BaseFormatter&) = default;
   BaseFormatter(const BaseFormatter& copy, std::ostream& out_stream)
-      : out_stream(out_stream),
-        test_counter(copy.test_counter),
-        multiple(copy.multiple),
-        color_output(copy.color_output) {}
+      : out_stream(out_stream), test_counter(copy.test_counter), color_output(copy.color_output) {}
 
   virtual ~BaseFormatter() = default;
 
   void format(Runnable& runnable) {
-    if (Description* description = dynamic_cast<Description*>(&runnable)) {
+    if (auto* description = dynamic_cast<Description*>(&runnable)) {
       format(*description);
-    } else if (ItBase* it = dynamic_cast<ItBase*>(&runnable)) {
+    } else if (auto* it = dynamic_cast<ItBase*>(&runnable)) {
       format(*it);
     }
     format_children(runnable);
   }
 
   void format_children(Runnable& runnable) {
     for (auto& child : runnable.get_children()) {
-      if (Runnable* runnable = dynamic_cast<Runnable*>(child.get())) {
+      if (auto* runnable = dynamic_cast<Runnable*>(child.get())) {
         this->format(*runnable);
       }
     }
   }
 
-  virtual void format(Description& description) {}
-  virtual void format(ItBase& it) {}
+  virtual void format(Description& /* description */) {}
+  virtual void format(ItBase& /* it */) {}
   virtual void cleanup() {}
 
-  BaseFormatter& set_multiple(bool value);
   BaseFormatter& set_color_output(bool value);
 
   int get_and_increment_test_counter() { return test_counter++; }
   void reset_test_counter() { test_counter = 1; }
 };
 
-inline BaseFormatter& BaseFormatter::set_multiple(bool multiple) {
-  this->multiple = multiple;
-  return *this;
-}
-
 inline BaseFormatter& BaseFormatter::set_color_output(bool value) {
   this->color_output = value;
   return *this;

include/formatters/junit_xml.hpp

@@ -2,16 +2,16 @@
 #include <algorithm>
 #include <atomic>
 #include <chrono>
+#include <filesystem>
 #include <numeric>
 #include <string>
-#include <string_view>
 
 #include "formatters_base.hpp"
 #include "it_base.hpp"
 
 namespace CppSpec::Formatters {
 // JUnit XML header
-constexpr static std::string_view junit_xml_header = R"(<?xml version="1.0" encoding="UTF-8"?>)";
+constexpr static auto junit_xml_header = R"(<?xml version="1.0" encoding="UTF-8"?>)";
 
 struct XMLSerializable {
   virtual ~XMLSerializable() = default;
@@ -26,8 +26,8 @@ struct Result {
   std::string type;
   std::string text;
 
-  Result(const std::string& message, const std::string& type, const std::string& text, Status status = Status::Failure)
-      : status(status), message(message), type(type), text(text) {}
+  Result(std::string message, std::string type, std::string text, Status status = Status::Failure)
+      : status(status), message(std::move(message)), type(std::move(type)), text(std::move(text)) {}
 
   [[nodiscard]] std::string status_string() const {
     switch (status) {
@@ -91,7 +91,7 @@ struct TestSuite {
             size_t tests,
             size_t failures,
             std::chrono::time_point<std::chrono::system_clock> timestamp)
-      : id(get_next_id()), name(name), time(time), timestamp(timestamp), tests(tests), failures(failures) {}
+      : id(get_next_id()), name(std::move(name)), time(time), timestamp(timestamp), tests(tests), failures(failures) {}
 
   [[nodiscard]] std::string to_xml() const {
     auto timestamp_str =
@@ -119,7 +119,7 @@ struct TestSuites {
   std::string name;
   size_t tests = 0;
   size_t failures = 0;
-  std::chrono::duration<double> time;
+  std::chrono::duration<double> time{};
   std::chrono::time_point<std::chrono::system_clock> timestamp;
 
   std::list<TestSuite> suites;
@@ -165,6 +165,10 @@ class JUnitXML : public BaseFormatter {
   }
 
   void format(Description& description) override {
+    if (test_suites.name.empty()) {
+      std::filesystem::path file_path = description.get_location().file_name();
+      test_suites.name = file_path.stem().string();
+    }
     if (description.has_parent()) {
       return;
     }
@@ -177,7 +181,7 @@ class JUnitXML : public BaseFormatter {
     std::forward_list<std::string> descriptions;
 
     descriptions.push_front(it.get_description());
-    for (auto parent = it.get_parent_as<Description>(); parent->has_parent();
+    for (auto* parent = it.get_parent_as<Description>(); parent->has_parent();
          parent = parent->get_parent_as<Description>()) {
       descriptions.push_front(parent->get_description());
     }
@@ -198,8 +202,8 @@ class JUnitXML : public BaseFormatter {
       if (result.is_success()) {
         continue;
       }
-      std::string junit_message = result.get_location_string() + ": " + result.get_message();
-      test_case.results.emplace_back("Match failure.", result.get_type(), result.get_message());
+      test_case.results.emplace_back(result.get_location_string() + ": Match failure.", result.get_type(),
+                                     result.get_message());
     }
 
     test_suites.suites.back().cases.push_back(test_case);

include/formatters/verbose.hpp

@@ -1,9 +1,6 @@
 /** @file */
 #pragma once
 
-#include <list>
-#include <string>
-
 #include "formatters_base.hpp"
 #include "it_base.hpp"
 #include "term_colors.hpp"
@@ -20,7 +17,7 @@ class Verbose : public BaseFormatter {
   explicit Verbose(const BaseFormatter& base) : BaseFormatter(base) {}
 
   void format(Description& description) override;
-  void format(ItBase& description) override;
+  void format(ItBase& it) override;
 };
 
 inline void Verbose::format(Description& description) {

include/runner.hpp

@@ -1,7 +1,5 @@
 /** @file */
 #pragma once
-#include <initializer_list>
-#pragma once
 
 #include <list>
 #include <utility>
@@ -16,13 +14,15 @@ namespace CppSpec {
  * @brief A collection of Descriptions that are run in sequence
  */
 class Runner {
-  std::list<Description*> specs{};
-  std::shared_ptr<Formatters::BaseFormatter> formatter;
+  std::list<Description*> specs;
+  std::list<std::shared_ptr<Formatters::BaseFormatter>> formatters;
 
  public:
-  explicit Runner(std::shared_ptr<Formatters::BaseFormatter> formatter) : formatter{std::move(formatter)} {};
+  template <typename... Formatters>
+  explicit Runner(Formatters&&... formatters) : formatters{std::forward<Formatters>(formatters)...} {}
 
-  ~Runner() = default;
+  explicit Runner(std::list<std::shared_ptr<Formatters::BaseFormatter>>&& formatters)
+      : formatters{std::move(formatters)} {}
 
   /**
    * @brief Add a Description object
@@ -45,19 +45,17 @@ class Runner {
     bool success = true;
     for (Description* spec : specs) {
       spec->timed_run();
-      formatter->format(static_cast<Runnable&>(*spec));
       success &= spec->get_result().status();
     }
+    for (auto& formatter : formatters) {
+      for (Description* spec : specs) {
+        formatter->format(static_cast<Runnable&>(*spec));
+      }
+    }
     return success ? Result::success(location) : Result::failure(location);
   }
 
-  Result exec() {
-    if (specs.size() > 1) {
-      formatter->set_multiple(true);
-    }
-    Result result = run();
-    return result;
-  }
+  Result exec() { return run(); }
 };
 
 }  // namespace CppSpec