Initial Release

test/tests.cpp

@@ -0,0 +1,161 @@
+#include "tests.hpp"
+
+#include <cstring>
+#include <thespian/backtrace.h>
+#include <thespian/context.hpp>
+#include <thespian/debug.hpp>
+#include <thespian/env.hpp>
+#include <thespian/instance.hpp>
+#include <thespian/timeout.hpp>
+#include <thespian/trace.hpp>
+
+#include <csignal>
+#include <cstdlib>
+#include <iostream>
+#include <map>
+#include <mutex>
+#include <string>
+#include <utility>
+#include <vector>
+
+using cbor::buffer;
+using std::cerr;
+using std::cout;
+using std::lock_guard;
+using std::map;
+using std::move;
+using std::mutex;
+using std::ostream;
+using std::string;
+using thespian::env_t;
+using thespian::handle;
+using thespian::ok;
+
+namespace {
+
+using namespace std::chrono_literals;
+
+auto operator<<(ostream &s, const cbor::buffer::value_accessor::unvisitable_type
+                                & /*unused*/) -> ostream & {
+  return s << "unvisitable_type";
+}
+
+struct logger {
+  thespian::timeout t{thespian::create_timeout(60s, cbor::array("timeout"))};
+  const char *name;
+  mutex &trace_m;
+  bool verbose;
+
+  explicit logger(const char *name, mutex &trace_m, bool verbose)
+      : name(name), trace_m(trace_m), verbose(verbose) {}
+
+  auto receive(const buffer &m) {
+    if (verbose) {
+      std::lock_guard<mutex> lock(trace_m);
+      cout << name << ": ";
+      auto dump = [&](auto val) { cout << val << " "; };
+      for (const auto val : m)
+        val.visit(dump);
+      cout << '\n';
+    }
+    return ok();
+  }
+
+  static auto start(thespian::context &ctx, const char *name, mutex &trace_m,
+                    bool verbose, env_t env) -> handle {
+    return ctx
+        .spawn(
+            [name, &trace_m, verbose]() {
+              thespian::receive(
+                  [p{make_shared<logger>(name, trace_m, verbose)}](
+                      auto, auto m) { return p->receive(move(m)); });
+              return ok();
+            },
+            string("logger_") + name, move(env))
+        .value();
+  }
+}; // namespace
+
+} // namespace
+
+extern "C" auto runtestcase(const char *name) -> int {
+  mutex trace_m;
+
+  if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) // NOLINT
+    abort();
+
+  auto gdb = getenv("JITDEBUG"); // NOLINT
+
+  if (gdb) {
+    if (strcmp(gdb, "on") != 0)
+      install_debugger();
+    else if (strcmp(gdb, "backtrace") != 0)
+      install_backtrace();
+  }
+
+  auto ctx = thespian::context::create();
+
+  map<string, testcase *> tests;
+  tests["cbor_match"] = cbor_match;
+  tests["debug"] = debug;
+  tests["endpoint_unx"] = endpoint_unx;
+  tests["endpoint_tcp"] = endpoint_tcp;
+  tests["hub_filter"] = hub_filter;
+  tests["ip_tcp_client_server"] = ip_tcp_client_server;
+  tests["ip_udp_echo"] = ip_udp_echo;
+  tests["metronome_test"] = metronome_test;
+  tests["perf_cbor"] = perf_cbor;
+  tests["perf_hub"] = perf_hub;
+  tests["perf_ring"] = perf_ring;
+  tests["perf_spawn"] = perf_spawn;
+  tests["spawn_exit"] = spawn_exit;
+  tests["timeout_test"] = timeout_test;
+
+  env_t env{};
+  env_t log_env{};
+  auto trace = [&](const buffer &buf) {
+    lock_guard<mutex> lock(trace_m);
+    cout << buf.to_json() << '\n';
+  };
+  log_env.on_trace(trace);
+  env.on_trace(trace);
+  if (getenv("TRACE")) { // NOLINT
+    thespian::debug::enable(*ctx);
+    env.enable_all_channels();
+    log_env.enable_all_channels();
+  }
+  if (getenv("TRACE_LIFETIME")) { // NOLINT
+    thespian::debug::enable(*ctx);
+    env.enable(thespian::channel::lifetime);
+    log_env.enable(thespian::channel::lifetime);
+  }
+  if (getenv("TRACE_EXECUTE")) { // NOLINT
+    env.enable(thespian::channel::execute);
+  }
+  if (getenv("TRACE_SEND")) { // NOLINT
+    env.enable(thespian::channel::send);
+  }
+  if (getenv("TRACE_RECEIVE")) { // NOLINT
+    env.enable(thespian::channel::receive);
+  }
+
+  bool long_run = getenv("LONGRUN"); // NOLINT
+  bool verbose = getenv("VERBOSE");  // NOLINT
+  env.is("long_run") = long_run;
+  env.is("verbose") = verbose;
+
+  if (verbose)
+    cout << '\n';
+
+  env.proc("log") = logger::start(*ctx, name, trace_m, verbose, move(log_env));
+
+  auto test = tests.find(name);
+  if (test == tests.end()) {
+    cerr << "invalid testcase: " << name << '\n';
+    return 1;
+  }
+  bool result{false};
+  test->second(*ctx, result, move(env));
+  ctx->run();
+  return result ? 0 : 1;
+}