Merge commit '7eef3bf1545663791252b2a3cad437ec9fcfc9cc' as 'deps/ox/deps/jsoncpp'

deps/ox/deps/jsoncpp/src/test_lib_json/CMakeLists.txt

@@ -0,0 +1,39 @@
+# vim: et ts=4 sts=4 sw=4 tw=0
+
+add_executable(jsoncpp_test
+    jsontest.cpp
+    jsontest.h
+    fuzz.cpp
+    fuzz.h
+    main.cpp
+)
+
+
+if(BUILD_SHARED_LIBS)
+    if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12.0)
+        add_compile_definitions( JSON_DLL )
+    else()
+        add_definitions( -DJSON_DLL )
+    endif()
+    target_link_libraries(jsoncpp_test jsoncpp_lib)
+else()
+    target_link_libraries(jsoncpp_test jsoncpp_static)
+endif()
+
+# another way to solve issue #90
+#set_target_properties(jsoncpp_test PROPERTIES COMPILE_FLAGS -ffloat-store)
+
+## Create tests for dashboard submission, allows easy review of CI results https://my.cdash.org/index.php?project=jsoncpp
+add_test(NAME jsoncpp_test
+    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:jsoncpp_test>
+)
+set_target_properties(jsoncpp_test PROPERTIES OUTPUT_NAME jsoncpp_test)
+
+# Run unit tests in post-build
+# (default cmake workflow hides away the test result into a file, resulting in poor dev workflow?!?)
+if(JSONCPP_WITH_POST_BUILD_UNITTEST)
+    add_custom_command(TARGET jsoncpp_test
+        POST_BUILD
+        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:jsoncpp_test>
+    )
+endif()

deps/ox/deps/jsoncpp/src/test_lib_json/fuzz.cpp

@@ -0,0 +1,54 @@
+// Copyright 2007-2019 The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#include "fuzz.h"
+
+#include <cstdint>
+#include <json/config.h>
+#include <json/json.h>
+#include <memory>
+#include <string>
+
+namespace Json {
+class Exception;
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  Json::CharReaderBuilder builder;
+
+  if (size < sizeof(uint32_t)) {
+    return 0;
+  }
+
+  const uint32_t hash_settings = static_cast<uint32_t>(data[0]) |
+                                 (static_cast<uint32_t>(data[1]) << 8) |
+                                 (static_cast<uint32_t>(data[2]) << 16) |
+                                 (static_cast<uint32_t>(data[3]) << 24);
+  data += sizeof(uint32_t);
+  size -= sizeof(uint32_t);
+
+  builder.settings_["failIfExtra"] = hash_settings & (1 << 0);
+  builder.settings_["allowComments_"] = hash_settings & (1 << 1);
+  builder.settings_["strictRoot_"] = hash_settings & (1 << 2);
+  builder.settings_["allowDroppedNullPlaceholders_"] = hash_settings & (1 << 3);
+  builder.settings_["allowNumericKeys_"] = hash_settings & (1 << 4);
+  builder.settings_["allowSingleQuotes_"] = hash_settings & (1 << 5);
+  builder.settings_["failIfExtra_"] = hash_settings & (1 << 6);
+  builder.settings_["rejectDupKeys_"] = hash_settings & (1 << 7);
+  builder.settings_["allowSpecialFloats_"] = hash_settings & (1 << 8);
+  builder.settings_["collectComments"] = hash_settings & (1 << 9);
+  builder.settings_["allowTrailingCommas_"] = hash_settings & (1 << 10);
+
+  std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
+
+  Json::Value root;
+  const auto data_str = reinterpret_cast<const char*>(data);
+  try {
+    reader->parse(data_str, data_str + size, &root, nullptr);
+  } catch (Json::Exception const&) {
+  }
+  // Whether it succeeded or not doesn't matter.
+  return 0;
+}

deps/ox/deps/jsoncpp/src/test_lib_json/fuzz.dict

@@ -0,0 +1,54 @@
+#
+# AFL dictionary for JSON
+# -----------------------
+#
+# Just the very basics.
+#
+# Inspired by a dictionary by Jakub Wilk <jwilk@jwilk.net>
+#
+# https://github.com/rc0r/afl-fuzz/blob/master/dictionaries/json.dict
+#
+
+"0"
+",0"
+":0"
+"0:"
+"-1.2e+3"
+
+"true"
+"false"
+"null"
+
+"\"\""
+",\"\""
+":\"\""
+"\"\":"
+
+"{}"
+",{}"
+":{}"
+"{\"\":0}"
+"{{}}"
+
+"[]"
+",[]"
+":[]"
+"[0]"
+"[[]]"
+
+"''"
+"\\"
+"\\b"
+"\\f"
+"\\n"
+"\\r"
+"\\t"
+"\\u0000"
+"\\x00"
+"\\0"
+"\\uD800\\uDC00"
+"\\uDBFF\\uDFFF"
+
+"\"\":0"
+"//"
+"/**/"

deps/ox/deps/jsoncpp/src/test_lib_json/fuzz.h

@@ -0,0 +1,14 @@
+// Copyright 2007-2010 The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef FUZZ_H_INCLUDED
+#define FUZZ_H_INCLUDED
+
+#include <cstddef>
+#include <stdint.h>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size);
+
+#endif // ifndef FUZZ_H_INCLUDED

deps/ox/deps/jsoncpp/src/test_lib_json/jsontest.cpp

@@ -0,0 +1,430 @@
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#define _CRT_SECURE_NO_WARNINGS 1 // Prevents deprecation warning with MSVC
+#include "jsontest.h"
+#include <cstdio>
+#include <string>
+
+#if defined(_MSC_VER)
+// Used to install a report hook that prevent dialog on assertion and error.
+#include <crtdbg.h>
+#endif // if defined(_MSC_VER)
+
+#if defined(_WIN32)
+// Used to prevent dialog on memory fault.
+// Limits headers included by Windows.h
+#define WIN32_LEAN_AND_MEAN
+#define NOSERVICE
+#define NOMCX
+#define NOIME
+#define NOSOUND
+#define NOCOMM
+#define NORPC
+#define NOGDI
+#define NOUSER
+#define NODRIVERS
+#define NOLOGERROR
+#define NOPROFILER
+#define NOMEMMGR
+#define NOLFILEIO
+#define NOOPENFILE
+#define NORESOURCE
+#define NOATOM
+#define NOLANGUAGE
+#define NOLSTRING
+#define NODBCS
+#define NOKEYBOARDINFO
+#define NOGDICAPMASKS
+#define NOCOLOR
+#define NOGDIOBJ
+#define NODRAWTEXT
+#define NOTEXTMETRIC
+#define NOSCALABLEFONT
+#define NOBITMAP
+#define NORASTEROPS
+#define NOMETAFILE
+#define NOSYSMETRICS
+#define NOSYSTEMPARAMSINFO
+#define NOMSG
+#define NOWINSTYLES
+#define NOWINOFFSETS
+#define NOSHOWWINDOW
+#define NODEFERWINDOWPOS
+#define NOVIRTUALKEYCODES
+#define NOKEYSTATES
+#define NOWH
+#define NOMENUS
+#define NOSCROLL
+#define NOCLIPBOARD
+#define NOICONS
+#define NOMB
+#define NOSYSCOMMANDS
+#define NOMDI
+#define NOCTLMGR
+#define NOWINMESSAGES
+#include <windows.h>
+#endif // if defined(_WIN32)
+
+namespace JsonTest {
+
+// class TestResult
+// //////////////////////////////////////////////////////////////////
+
+TestResult::TestResult() {
+  // The root predicate has id 0
+  rootPredicateNode_.id_ = 0;
+  rootPredicateNode_.next_ = nullptr;
+  predicateStackTail_ = &rootPredicateNode_;
+}
+
+void TestResult::setTestName(const Json::String& name) { name_ = name; }
+
+TestResult& TestResult::addFailure(const char* file, unsigned int line,
+                                   const char* expr) {
+  /// Walks the PredicateContext stack adding them to failures_ if not already
+  /// added.
+  unsigned int nestingLevel = 0;
+  PredicateContext* lastNode = rootPredicateNode_.next_;
+  for (; lastNode != nullptr; lastNode = lastNode->next_) {
+    if (lastNode->id_ > lastUsedPredicateId_) // new PredicateContext
+    {
+      lastUsedPredicateId_ = lastNode->id_;
+      addFailureInfo(lastNode->file_, lastNode->line_, lastNode->expr_,
+                     nestingLevel);
+      // Link the PredicateContext to the failure for message target when
+      // popping the PredicateContext.
+      lastNode->failure_ = &(failures_.back());
+    }
+    ++nestingLevel;
+  }
+
+  // Adds the failed assertion
+  addFailureInfo(file, line, expr, nestingLevel);
+  messageTarget_ = &(failures_.back());
+  return *this;
+}
+
+void TestResult::addFailureInfo(const char* file, unsigned int line,
+                                const char* expr, unsigned int nestingLevel) {
+  Failure failure;
+  failure.file_ = file;
+  failure.line_ = line;
+  if (expr) {
+    failure.expr_ = expr;
+  }
+  failure.nestingLevel_ = nestingLevel;
+  failures_.push_back(failure);
+}
+
+TestResult& TestResult::popPredicateContext() {
+  PredicateContext* lastNode = &rootPredicateNode_;
+  while (lastNode->next_ != nullptr && lastNode->next_->next_ != nullptr) {
+    lastNode = lastNode->next_;
+  }
+  // Set message target to popped failure
+  PredicateContext* tail = lastNode->next_;
+  if (tail != nullptr && tail->failure_ != nullptr) {
+    messageTarget_ = tail->failure_;
+  }
+  // Remove tail from list
+  predicateStackTail_ = lastNode;
+  lastNode->next_ = nullptr;
+  return *this;
+}
+
+bool TestResult::failed() const { return !failures_.empty(); }
+
+void TestResult::printFailure(bool printTestName) const {
+  if (failures_.empty()) {
+    return;
+  }
+
+  if (printTestName) {
+    printf("* Detail of %s test failure:\n", name_.c_str());
+  }
+
+  // Print in reverse to display the callstack in the right order
+  for (const auto& failure : failures_) {
+    Json::String indent(failure.nestingLevel_ * 2, ' ');
+    if (failure.file_) {
+      printf("%s%s(%u): ", indent.c_str(), failure.file_, failure.line_);
+    }
+    if (!failure.expr_.empty()) {
+      printf("%s\n", failure.expr_.c_str());
+    } else if (failure.file_) {
+      printf("\n");
+    }
+    if (!failure.message_.empty()) {
+      Json::String reindented = indentText(failure.message_, indent + "  ");
+      printf("%s\n", reindented.c_str());
+    }
+  }
+}
+
+Json::String TestResult::indentText(const Json::String& text,
+                                    const Json::String& indent) {
+  Json::String reindented;
+  Json::String::size_type lastIndex = 0;
+  while (lastIndex < text.size()) {
+    Json::String::size_type nextIndex = text.find('\n', lastIndex);
+    if (nextIndex == Json::String::npos) {
+      nextIndex = text.size() - 1;
+    }
+    reindented += indent;
+    reindented += text.substr(lastIndex, nextIndex - lastIndex + 1);
+    lastIndex = nextIndex + 1;
+  }
+  return reindented;
+}
+
+TestResult& TestResult::addToLastFailure(const Json::String& message) {
+  if (messageTarget_ != nullptr) {
+    messageTarget_->message_ += message;
+  }
+  return *this;
+}
+
+TestResult& TestResult::operator<<(Json::Int64 value) {
+  return addToLastFailure(Json::valueToString(value));
+}
+
+TestResult& TestResult::operator<<(Json::UInt64 value) {
+  return addToLastFailure(Json::valueToString(value));
+}
+
+TestResult& TestResult::operator<<(bool value) {
+  return addToLastFailure(value ? "true" : "false");
+}
+
+// class TestCase
+// //////////////////////////////////////////////////////////////////
+
+TestCase::TestCase() = default;
+
+TestCase::~TestCase() = default;
+
+void TestCase::run(TestResult& result) {
+  result_ = &result;
+  runTestCase();
+}
+
+// class Runner
+// //////////////////////////////////////////////////////////////////
+
+Runner::Runner() = default;
+
+Runner& Runner::add(TestCaseFactory factory) {
+  tests_.push_back(factory);
+  return *this;
+}
+
+size_t Runner::testCount() const { return tests_.size(); }
+
+Json::String Runner::testNameAt(size_t index) const {
+  TestCase* test = tests_[index]();
+  Json::String name = test->testName();
+  delete test;
+  return name;
+}
+
+void Runner::runTestAt(size_t index, TestResult& result) const {
+  TestCase* test = tests_[index]();
+  result.setTestName(test->testName());
+  printf("Testing %s: ", test->testName());
+  fflush(stdout);
+#if JSON_USE_EXCEPTION
+  try {
+#endif // if JSON_USE_EXCEPTION
+    test->run(result);
+#if JSON_USE_EXCEPTION
+  } catch (const std::exception& e) {
+    result.addFailure(__FILE__, __LINE__, "Unexpected exception caught:")
+        << e.what();
+  }
+#endif // if JSON_USE_EXCEPTION
+  delete test;
+  const char* status = result.failed() ? "FAILED" : "OK";
+  printf("%s\n", status);
+  fflush(stdout);
+}
+
+bool Runner::runAllTest(bool printSummary) const {
+  size_t const count = testCount();
+  std::deque<TestResult> failures;
+  for (size_t index = 0; index < count; ++index) {
+    TestResult result;
+    runTestAt(index, result);
+    if (result.failed()) {
+      failures.push_back(result);
+    }
+  }
+
+  if (failures.empty()) {
+    if (printSummary) {
+      printf("All %zu tests passed\n", count);
+    }
+    return true;
+  }
+  for (auto& result : failures) {
+    result.printFailure(count > 1);
+  }
+
+  if (printSummary) {
+    size_t const failedCount = failures.size();
+    size_t const passedCount = count - failedCount;
+    printf("%zu/%zu tests passed (%zu failure(s))\n", passedCount, count,
+           failedCount);
+  }
+  return false;
+}
+
+bool Runner::testIndex(const Json::String& testName, size_t& indexOut) const {
+  const size_t count = testCount();
+  for (size_t index = 0; index < count; ++index) {
+    if (testNameAt(index) == testName) {
+      indexOut = index;
+      return true;
+    }
+  }
+  return false;
+}
+
+void Runner::listTests() const {
+  const size_t count = testCount();
+  for (size_t index = 0; index < count; ++index) {
+    printf("%s\n", testNameAt(index).c_str());
+  }
+}
+
+int Runner::runCommandLine(int argc, const char* argv[]) const {
+  // typedef std::deque<String> TestNames;
+  Runner subrunner;
+  for (int index = 1; index < argc; ++index) {
+    Json::String opt = argv[index];
+    if (opt == "--list-tests") {
+      listTests();
+      return 0;
+    }
+    if (opt == "--test-auto") {
+      preventDialogOnCrash();
+    } else if (opt == "--test") {
+      ++index;
+      if (index < argc) {
+        size_t testNameIndex;
+        if (testIndex(argv[index], testNameIndex)) {
+          subrunner.add(tests_[testNameIndex]);
+        } else {
+          fprintf(stderr, "Test '%s' does not exist!\n", argv[index]);
+          return 2;
+        }
+      } else {
+        printUsage(argv[0]);
+        return 2;
+      }
+    } else {
+      printUsage(argv[0]);
+      return 2;
+    }
+  }
+  bool succeeded;
+  if (subrunner.testCount() > 0) {
+    succeeded = subrunner.runAllTest(subrunner.testCount() > 1);
+  } else {
+    succeeded = runAllTest(true);
+  }
+  return succeeded ? 0 : 1;
+}
+
+#if defined(_MSC_VER) && defined(_DEBUG)
+// Hook MSVCRT assertions to prevent dialog from appearing
+static int msvcrtSilentReportHook(int reportType, char* message,
+                                  int* /*returnValue*/) {
+  // The default CRT handling of error and assertion is to display
+  // an error dialog to the user.
+  // Instead, when an error or an assertion occurs, we force the
+  // application to terminate using abort() after display
+  // the message on stderr.
+  if (reportType == _CRT_ERROR || reportType == _CRT_ASSERT) {
+    // calling abort() cause the ReportHook to be called
+    // The following is used to detect this case and let's the
+    // error handler fallback on its default behaviour (
+    // display a warning message)
+    static volatile bool isAborting = false;
+    if (isAborting) {
+      return TRUE;
+    }
+    isAborting = true;
+
+    fprintf(stderr, "CRT Error/Assert:\n%s\n", message);
+    fflush(stderr);
+    abort();
+  }
+  // Let's other reportType (_CRT_WARNING) be handled as they would by default
+  return FALSE;
+}
+#endif // if defined(_MSC_VER)
+
+void Runner::preventDialogOnCrash() {
+#if defined(_MSC_VER) && defined(_DEBUG)
+  // Install a hook to prevent MSVCRT error and assertion from
+  // popping a dialog
+  // This function a NO-OP in release configuration
+  // (which cause warning since msvcrtSilentReportHook is not referenced)
+  _CrtSetReportHook(&msvcrtSilentReportHook);
+#endif // if defined(_MSC_VER)
+
+  // @todo investigate this handler (for buffer overflow)
+  // _set_security_error_handler
+
+#if defined(_WIN32)
+  // Prevents the system from popping a dialog for debugging if the
+  // application fails due to invalid memory access.
+  SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |
+               SEM_NOOPENFILEERRORBOX);
+#endif // if defined(_WIN32)
+}
+
+void Runner::printUsage(const char* appName) {
+  printf("Usage: %s [options]\n"
+         "\n"
+         "If --test is not specified, then all the test cases be run.\n"
+         "\n"
+         "Valid options:\n"
+         "--list-tests: print the name of all test cases on the standard\n"
+         "              output and exit.\n"
+         "--test TESTNAME: executes the test case with the specified name.\n"
+         "                 May be repeated.\n"
+         "--test-auto: prevent dialog prompting for debugging on crash.\n",
+         appName);
+}
+
+// Assertion functions
+// //////////////////////////////////////////////////////////////////
+
+Json::String ToJsonString(const char* toConvert) {
+  return Json::String(toConvert);
+}
+
+Json::String ToJsonString(Json::String in) { return in; }
+
+#if JSONCPP_USING_SECURE_MEMORY
+Json::String ToJsonString(std::string in) {
+  return Json::String(in.data(), in.data() + in.length());
+}
+#endif
+
+TestResult& checkStringEqual(TestResult& result, const Json::String& expected,
+                             const Json::String& actual, const char* file,
+                             unsigned int line, const char* expr) {
+  if (expected != actual) {
+    result.addFailure(file, line, expr);
+    result << "Expected: '" << expected << "'\n";
+    result << "Actual  : '" << actual << "'";
+  }
+  return result;
+}
+
+} // namespace JsonTest

deps/ox/deps/jsoncpp/src/test_lib_json/jsontest.h

@@ -0,0 +1,288 @@
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSONTEST_H_INCLUDED
+#define JSONTEST_H_INCLUDED
+
+#include <cstdio>
+#include <deque>
+#include <iomanip>
+#include <json/config.h>
+#include <json/value.h>
+#include <json/writer.h>
+#include <sstream>
+#include <string>
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// Mini Unit Testing framework
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+/** \brief Unit testing framework.
+ * \warning: all assertions are non-aborting, test case execution will continue
+ *           even if an assertion namespace.
+ *           This constraint is for portability: the framework needs to compile
+ *           on Visual Studio 6 and must not require exception usage.
+ */
+namespace JsonTest {
+
+class Failure {
+public:
+  const char* file_;
+  unsigned int line_;
+  Json::String expr_;
+  Json::String message_;
+  unsigned int nestingLevel_;
+};
+
+/// Context used to create the assertion callstack on failure.
+/// Must be a POD to allow inline initialisation without stepping
+/// into the debugger.
+struct PredicateContext {
+  using Id = unsigned int;
+  Id id_;
+  const char* file_;
+  unsigned int line_;
+  const char* expr_;
+  PredicateContext* next_;
+  /// Related Failure, set when the PredicateContext is converted
+  /// into a Failure.
+  Failure* failure_;
+};
+
+class TestResult {
+public:
+  TestResult();
+
+  /// \internal Implementation detail for assertion macros
+  /// Not encapsulated to prevent step into when debugging failed assertions
+  /// Incremented by one on assertion predicate entry, decreased by one
+  /// by addPredicateContext().
+  PredicateContext::Id predicateId_{1};
+
+  /// \internal Implementation detail for predicate macros
+  PredicateContext* predicateStackTail_;
+
+  void setTestName(const Json::String& name);
+
+  /// Adds an assertion failure.
+  TestResult& addFailure(const char* file, unsigned int line,
+                         const char* expr = nullptr);
+
+  /// Removes the last PredicateContext added to the predicate stack
+  /// chained list.
+  /// Next messages will be targed at the PredicateContext that was removed.
+  TestResult& popPredicateContext();
+
+  bool failed() const;
+
+  void printFailure(bool printTestName) const;
+
+  // Generic operator that will work with anything ostream can deal with.
+  template <typename T> TestResult& operator<<(const T& value) {
+    Json::OStringStream oss;
+    oss << std::setprecision(16) << std::hexfloat << value;
+    return addToLastFailure(oss.str());
+  }
+
+  // Specialized versions.
+  TestResult& operator<<(bool value);
+  // std:ostream does not support 64bits integers on all STL implementation
+  TestResult& operator<<(Json::Int64 value);
+  TestResult& operator<<(Json::UInt64 value);
+
+private:
+  TestResult& addToLastFailure(const Json::String& message);
+  /// Adds a failure or a predicate context
+  void addFailureInfo(const char* file, unsigned int line, const char* expr,
+                      unsigned int nestingLevel);
+  static Json::String indentText(const Json::String& text,
+                                 const Json::String& indent);
+
+  using Failures = std::deque<Failure>;
+  Failures failures_;
+  Json::String name_;
+  PredicateContext rootPredicateNode_;
+  PredicateContext::Id lastUsedPredicateId_{0};
+  /// Failure which is the target of the messages added using operator <<
+  Failure* messageTarget_{nullptr};
+};
+
+class TestCase {
+public:
+  TestCase();
+
+  virtual ~TestCase();
+
+  void run(TestResult& result);
+
+  virtual const char* testName() const = 0;
+
+protected:
+  TestResult* result_{nullptr};
+
+private:
+  virtual void runTestCase() = 0;
+};
+
+/// Function pointer type for TestCase factory
+using TestCaseFactory = TestCase* (*)();
+
+class Runner {
+public:
+  Runner();
+
+  /// Adds a test to the suite
+  Runner& add(TestCaseFactory factory);
+
+  /// Runs test as specified on the command-line
+  /// If no command-line arguments are provided, run all tests.
+  /// If --list-tests is provided, then print the list of all test cases
+  /// If --test <testname> is provided, then run test testname.
+  int runCommandLine(int argc, const char* argv[]) const;
+
+  /// Runs all the test cases
+  bool runAllTest(bool printSummary) const;
+
+  /// Returns the number of test case in the suite
+  size_t testCount() const;
+
+  /// Returns the name of the test case at the specified index
+  Json::String testNameAt(size_t index) const;
+
+  /// Runs the test case at the specified index using the specified TestResult
+  void runTestAt(size_t index, TestResult& result) const;
+
+  static void printUsage(const char* appName);
+
+private: // prevents copy construction and assignment
+  Runner(const Runner& other) = delete;
+  Runner& operator=(const Runner& other) = delete;
+
+private:
+  void listTests() const;
+  bool testIndex(const Json::String& testName, size_t& indexOut) const;
+  static void preventDialogOnCrash();
+
+private:
+  using Factories = std::deque<TestCaseFactory>;
+  Factories tests_;
+};
+
+template <typename T, typename U>
+TestResult& checkEqual(TestResult& result, T expected, U actual,
+                       const char* file, unsigned int line, const char* expr) {
+  if (static_cast<U>(expected) != actual) {
+    result.addFailure(file, line, expr);
+    result << "Expected: " << static_cast<U>(expected) << "\n";
+    result << "Actual  : " << actual;
+  }
+  return result;
+}
+
+Json::String ToJsonString(const char* toConvert);
+Json::String ToJsonString(Json::String in);
+#if JSONCPP_USING_SECURE_MEMORY
+Json::String ToJsonString(std::string in);
+#endif
+
+TestResult& checkStringEqual(TestResult& result, const Json::String& expected,
+                             const Json::String& actual, const char* file,
+                             unsigned int line, const char* expr);
+
+} // namespace JsonTest
+
+/// \brief Asserts that the given expression is true.
+/// JSONTEST_ASSERT( x == y ) << "x=" << x << ", y=" << y;
+/// JSONTEST_ASSERT( x == y );
+#define JSONTEST_ASSERT(expr)                                                  \
+  if (expr) {                                                                  \
+  } else                                                                       \
+    result_->addFailure(__FILE__, __LINE__, #expr)
+
+/// \brief Asserts that the given predicate is true.
+/// The predicate may do other assertions and be a member function of the
+/// fixture.
+#define JSONTEST_ASSERT_PRED(expr)                                             \
+  do {                                                                         \
+    JsonTest::PredicateContext _minitest_Context = {                           \
+        result_->predicateId_, __FILE__, __LINE__, #expr, NULL, NULL};         \
+    result_->predicateStackTail_->next_ = &_minitest_Context;                  \
+    result_->predicateId_ += 1;                                                \
+    result_->predicateStackTail_ = &_minitest_Context;                         \
+    (expr);                                                                    \
+    result_->popPredicateContext();                                            \
+  } while (0)
+
+/// \brief Asserts that two values are equals.
+#define JSONTEST_ASSERT_EQUAL(expected, actual)                                \
+  JsonTest::checkEqual(*result_, expected, actual, __FILE__, __LINE__,         \
+                       #expected " == " #actual)
+
+/// \brief Asserts that two values are equals.
+#define JSONTEST_ASSERT_STRING_EQUAL(expected, actual)                         \
+  JsonTest::checkStringEqual(*result_, JsonTest::ToJsonString(expected),       \
+                             JsonTest::ToJsonString(actual), __FILE__,         \
+                             __LINE__, #expected " == " #actual)
+
+/// \brief Asserts that a given expression throws an exception
+#define JSONTEST_ASSERT_THROWS(expr)                                           \
+  do {                                                                         \
+    bool _threw = false;                                                       \
+    try {                                                                      \
+      expr;                                                                    \
+    } catch (...) {                                                            \
+      _threw = true;                                                           \
+    }                                                                          \
+    if (!_threw)                                                               \
+      result_->addFailure(__FILE__, __LINE__,                                  \
+                          "expected exception thrown: " #expr);                \
+  } while (0)
+
+/// \brief Begin a fixture test case.
+#define JSONTEST_FIXTURE(FixtureType, name)                                    \
+  class Test##FixtureType##name : public FixtureType {                         \
+  public:                                                                      \
+    static JsonTest::TestCase* factory() {                                     \
+      return new Test##FixtureType##name();                                    \
+    }                                                                          \
+                                                                               \
+  public: /* overridden from TestCase */                                       \
+    const char* testName() const override { return #FixtureType "/" #name; }   \
+    void runTestCase() override;                                               \
+  };                                                                           \
+                                                                               \
+  void Test##FixtureType##name::runTestCase()
+
+#define JSONTEST_FIXTURE_FACTORY(FixtureType, name)                            \
+  &Test##FixtureType##name::factory
+
+#define JSONTEST_REGISTER_FIXTURE(runner, FixtureType, name)                   \
+  (runner).add(JSONTEST_FIXTURE_FACTORY(FixtureType, name))
+
+/// \brief Begin a fixture test case.
+#define JSONTEST_FIXTURE_V2(FixtureType, name, collections)                    \
+  class Test##FixtureType##name : public FixtureType {                         \
+  public:                                                                      \
+    static JsonTest::TestCase* factory() {                                     \
+      return new Test##FixtureType##name();                                    \
+    }                                                                          \
+    static bool collect() {                                                    \
+      (collections).push_back(JSONTEST_FIXTURE_FACTORY(FixtureType, name));    \
+      return true;                                                             \
+    }                                                                          \
+                                                                               \
+  public: /* overridden from TestCase */                                       \
+    const char* testName() const override { return #FixtureType "/" #name; }   \
+    void runTestCase() override;                                               \
+  };                                                                           \
+                                                                               \
+  static bool test##FixtureType##name##collect =                               \
+      Test##FixtureType##name::collect();                                      \
+                                                                               \
+  void Test##FixtureType##name::runTestCase()
+
+#endif // ifndef JSONTEST_H_INCLUDED