Add support for semihosted platforms

Author: toroidal-code

include/argparse.hpp

@@ -1,10 +1,17 @@
 #pragma once
 
-#include <argparse/argparse.hpp>
-#include <fstream>
 #include <string>
 #include <string_view>
 
+#ifdef CPPSPEC_SEMIHOSTED
+#include <sys/stat.h>
+#include <cstring>
+#else
+#include <argparse/argparse.hpp>
+#include <filesystem>
+#include <fstream>
+#endif
+
 #include "formatters/junit_xml.hpp"
 #include "formatters/progress.hpp"
 #include "formatters/tap.hpp"
@@ -24,6 +31,31 @@ inline std::string file_name(std::string_view path) {
 }
 
 inline Runner parse(int argc, char** const argv) {
+#ifdef CPPSPEC_SEMIHOSTED
+  int i = 0;
+  for (; i < argc; ++i) {
+    if (strcmp(argv[i], "-f") == 0) {
+      break;
+    }
+  }
+  if (i == argc) {
+    return Runner{std::make_shared<Formatters::Progress>()};
+    std::exit(-1);
+  }
+  std::string format_string = argv[i + 1];
+  if (format_string == "d" || format_string == "detail") {
+    return Runner{std::make_shared<Formatters::Verbose>()};
+  } else if (format_string == "p" || format_string == "progress") {
+    return Runner{std::make_shared<Formatters::Progress>()};
+  } else if (format_string == "t" || format_string == "tap") {
+    return Runner{std::make_shared<Formatters::TAP>()};
+  } else if (format_string == "j" || format_string == "junit") {
+    return Runner{std::make_shared<Formatters::JUnitXML>()};
+  } else {
+    std::cerr << "Unrecognized format type" << std::endl;
+    std::exit(-1);
+  }
+#else
   std::filesystem::path executable_path = argv[0];
   std::string executable_name = executable_path.filename().string();
   argparse::ArgumentParser program{executable_name};
@@ -71,7 +103,7 @@ inline Runner parse(int argc, char** const argv) {
     auto junit_output = std::make_shared<Formatters::JUnitXML>(*file_stream, false);
     return Runner{formatter, junit_output};
   }
-
   return Runner{formatter};
+#endif
 }
 }  // namespace CppSpec

include/cppspec.hpp

@@ -33,11 +33,22 @@
 #define after_each self.after_each
 #define let(name, body) auto(name) = self.let(body);
 
+#ifdef CPPSPEC_SEMIHOSTED
 #define CPPSPEC_MAIN(spec)                                                                              \
   int main(int argc, char** const argv) {                                                               \
     return CppSpec::parse(argc, argv).add_spec(spec).exec().is_success() ? EXIT_SUCCESS : EXIT_FAILURE; \
+  }                                                                                                     \
+  extern "C" int _getentropy(void* buf, size_t buflen) {                                                \
+    return -1;                                                                                          \
   }
 
+#else
+#define CPPSPEC_MAIN(spec)                                                                              \
+  int main(int argc, char** const argv) {                                                               \
+    return CppSpec::parse(argc, argv).add_spec(spec).exec().is_success() ? EXIT_SUCCESS : EXIT_FAILURE; \
+  }
+#endif
+
 #define CPPSPEC_SPEC(spec_name)                                                                              \
   int spec_name##_spec(int argc, char** const argv) {                                                        \
     return CppSpec::parse(argc, argv).add_spec(spec_name).exec().is_success() ? EXIT_SUCCESS : EXIT_FAILURE; \

include/formatters/junit_xml.hpp

@@ -1,11 +1,13 @@
 #pragma once
 #include <algorithm>
-#include <atomic>
 #include <chrono>
-#include <filesystem>
 #include <numeric>
 #include <string>
 
+#ifndef CPPSPEC_SEMIHOSTED
+#include <filesystem>
+#endif
+
 #include "formatters_base.hpp"
 #include "it_base.hpp"
 
@@ -116,7 +118,7 @@ struct TestSuite {
 
   [[nodiscard]] std::string to_xml() const {
     std::string timestamp_str;
-#ifdef __APPLE__
+#if defined(__APPLE__) || defined(CPPSPEC_SEMIHOSTED)
     // Cludge because macOS doesn't have std::chrono::current_zone() or std::chrono::zoned_time()
     std::time_t time_t_timestamp = std::chrono::system_clock::to_time_t(timestamp);
     std::tm localtime = *std::localtime(&time_t_timestamp);
@@ -142,7 +144,7 @@ struct TestSuite {
   }
 
   static size_t get_next_id() {
-    static std::atomic_size_t id_counter = 0;
+    static std::size_t id_counter = 0;
     return id_counter++;
   }
 };
@@ -198,8 +200,25 @@ class JUnitXML : public BaseFormatter {
 
   void format(const Description& description) override {
     if (test_suites.name.empty()) {
+#ifdef CPPSPEC_SEMIHOSTED
+      std::string file_path = description.get_location().file_name();
+      // remove leading folders
+      auto pos = file_path.find_last_of("/");
+      if (pos != std::string::npos) {
+        file_path = file_path.substr(pos + 1);
+      }
+
+      // remove extension
+      pos = file_path.find_last_of('.');
+      if (pos != std::string::npos) {
+        file_path = file_path.substr(0, pos);
+      }
+
+      test_suites.name = file_path;
+#else
       std::filesystem::path file_path = description.get_location().file_name();
       test_suites.name = file_path.stem().string();
+#endif
     }
     if (description.has_parent()) {
       return;
@@ -213,7 +232,7 @@ class JUnitXML : public BaseFormatter {
     std::forward_list<std::string> descriptions;
 
     descriptions.push_front(it.get_description());
-    for (const Description* parent = it.get_parent_as<Description>(); parent->has_parent();
+    for (const auto* parent = it.get_parent_as<Description>(); parent->has_parent();
          parent = parent->get_parent_as<Description>()) {
       descriptions.push_front(parent->get_description());
     }

include/formatters/progress.hpp

@@ -107,13 +107,17 @@ inline void Progress::format(const ItBase& it) {
 }
 
 inline void Progress::format_failure_messages() {
-  if (!baked_failure_messages.empty()) {  // If we have any failures to format
-    for (const std::string& message : baked_failure_messages) {
-      out_stream << std::endl;
-      out_stream << message;  // separated by a blank line
-    }
-    baked_failure_messages.clear();  // Finally, clear the failures list.
+  if (baked_failure_messages.empty()) {
+    out_stream << std::endl;  // If we don't have any failures, just print a blank line.
+    return;
+  }
+
+  // If we have any failures to format
+  for (const std::string& message : baked_failure_messages) {
+    out_stream << std::endl;
+    out_stream << message;  // separated by a blank line
   }
+  baked_failure_messages.clear();  // Finally, clear the failures list.
 }
 
 static Progress progress;