| // 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 ( expected != actual ) |
| { |
| result.addFailure( file, line, expr ); |
| result << "Expected: " << 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(); \ |
| } \ |
| *result_ |
| |
| /// \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 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 |