summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/jsoncpp/src/test_lib_json/jsontest.h
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/jsoncpp/src/test_lib_json/jsontest.h')
-rw-r--r--3rdparty/jsoncpp/src/test_lib_json/jsontest.h280
1 files changed, 280 insertions, 0 deletions
diff --git a/3rdparty/jsoncpp/src/test_lib_json/jsontest.h b/3rdparty/jsoncpp/src/test_lib_json/jsontest.h
new file mode 100644
index 00000000000..5c56a40b0ff
--- /dev/null
+++ b/3rdparty/jsoncpp/src/test_lib_json/jsontest.h
@@ -0,0 +1,280 @@
+// Copyright 2007-2010 Baptiste Lepilleur
+// 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 <json/config.h>
+#include <json/value.h>
+#include <json/writer.h>
+#include <stdio.h>
+#include <deque>
+#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_;
+ std::string expr_;
+ std::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 {
+ typedef unsigned int Id;
+ 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_;
+
+ /// \internal Implementation detail for predicate macros
+ PredicateContext* predicateStackTail_;
+
+ void setTestName(const std::string& name);
+
+ /// Adds an assertion failure.
+ TestResult&
+ addFailure(const char* file, unsigned int line, const char* expr = 0);
+
+ /// 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) {
+ std::ostringstream oss;
+ oss.precision(16);
+ oss.setf(std::ios_base::floatfield);
+ oss << 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 std::string& message);
+ unsigned int getAssertionNestingLevel() const;
+ /// Adds a failure or a predicate context
+ void addFailureInfo(const char* file,
+ unsigned int line,
+ const char* expr,
+ unsigned int nestingLevel);
+ static std::string indentText(const std::string& text,
+ const std::string& indent);
+
+ typedef std::deque<Failure> Failures;
+ Failures failures_;
+ std::string name_;
+ PredicateContext rootPredicateNode_;
+ PredicateContext::Id lastUsedPredicateId_;
+ /// Failure which is the target of the messages added using operator <<
+ Failure* messageTarget_;
+};
+
+class TestCase {
+public:
+ TestCase();
+
+ virtual ~TestCase();
+
+ void run(TestResult& result);
+
+ virtual const char* testName() const = 0;
+
+protected:
+ TestResult* result_;
+
+private:
+ virtual void runTestCase() = 0;
+};
+
+/// Function pointer type for TestCase factory
+typedef TestCase* (*TestCaseFactory)();
+
+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
+ unsigned int testCount() const;
+
+ /// Returns the name of the test case at the specified index
+ std::string testNameAt(unsigned int index) const;
+
+ /// Runs the test case at the specified index using the specified TestResult
+ void runTestAt(unsigned int index, TestResult& result) const;
+
+ static void printUsage(const char* appName);
+
+private: // prevents copy construction and assignment
+ Runner(const Runner& other);
+ Runner& operator=(const Runner& other);
+
+private:
+ void listTests() const;
+ bool testIndex(const std::string& testName, unsigned int& index) const;
+ static void preventDialogOnCrash();
+
+private:
+ typedef std::deque<TestCaseFactory> Factories;
+ Factories tests_;
+};
+
+template <typename T, typename U>
+TestResult& checkEqual(TestResult& result,
+ const T& expected,
+ const 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;
+}
+
+TestResult& checkStringEqual(TestResult& result,
+ const std::string& expected,
+ const std::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) \
+ { \
+ JsonTest::PredicateContext _minitest_Context = { \
+ result_->predicateId_, __FILE__, __LINE__, #expr \
+ }; \
+ result_->predicateStackTail_->next_ = &_minitest_Context; \
+ result_->predicateId_ += 1; \
+ result_->predicateStackTail_ = &_minitest_Context; \
+ (expr); \
+ result_->popPredicateContext(); \
+ }
+
+/// \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_, \
+ std::string(expected), \
+ std::string(actual), \
+ __FILE__, \
+ __LINE__, \
+ #expected " == " #actual)
+
+/// \brief Asserts that a given expression throws an exception
+#define JSONTEST_ASSERT_THROWS(expr) \
+ { \
+ bool _threw = false; \
+ try { \
+ expr; \
+ } \
+ catch (...) { \
+ _threw = true; \
+ } \
+ if (!_threw) \
+ result_->addFailure( \
+ __FILE__, __LINE__, "expected exception thrown: " #expr); \
+ }
+
+/// \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: /* overidden from TestCase */ \
+ virtual const char* testName() const { return #FixtureType "/" #name; } \
+ virtual void runTestCase(); \
+ }; \
+ \
+ 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))
+
+#endif // ifndef JSONTEST_H_INCLUDED