testsuite/json/jsontest.h

#ifndef JSONTEST_H_INCLUDED
#define JSONTEST_H_INCLUDED

#include <deque>
#include <stdio.h>
#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
{
  struct Failure
  {
    const char *file_;
    std::string expr_;
    std::string message_;
    unsigned int line_;
    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 size_t Id;
    Id id_;
    const char *file_;
    size_t 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;

    TestResult &operator << (bool value);
    TestResult &operator << (int value);
    TestResult &operator << (unsigned int value);
    TestResult &operator << (double value);
    TestResult &operator << (const char *value);
    TestResult &operator << (const std::string &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>
  TestResult &
  checkEqual (TestResult &result, const T &expected, const T &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 (condition)                                                           \
    {                                                                          \
    }                                                                          \
  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),        \
                              # 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 */
Revision:	1.1
Committed:	Sun Oct 17 08:15:15 2010 UTC (13 years, 9 months ago) by sf-pippijn
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	initial import
#	User	Rev	Content
1	sf-pippijn	1.1	#ifndef JSONTEST_H_INCLUDED
2			#define JSONTEST_H_INCLUDED
3
4			#include <deque>
5			#include <stdio.h>
6			#include <string>
7
8			/*
9			* //////////////////////////////////////////////////////////////////
10			* //////////////////////////////////////////////////////////////////
11			* Mini Unit Testing framework
12			* //////////////////////////////////////////////////////////////////
13			* //////////////////////////////////////////////////////////////////
14			*/
15
16
17
18			/** \brief Unit testing framework.
19			* \warning: all assertions are non-aborting, test case execution will continue
20			* even if an assertion namespace.
21			* This constraint is for portability: the framework needs to compile
22			* on Visual Studio 6 and must not require exception usage.
23			*/
24			namespace JsonTest
25			{
26			struct Failure
27			{
28			const char *file_;
29			std::string expr_;
30			std::string message_;
31			unsigned int line_;
32			unsigned int nestingLevel_;
33			};
34
35
36			/*
37			* / Context used to create the assertion callstack on failure.
38			* / Must be a POD to allow inline initialisation without stepping
39			* / into the debugger.
40			*/
41			struct PredicateContext
42			{
43			typedef size_t Id;
44			Id id_;
45			const char *file_;
46			size_t line_;
47			const char *expr_;
48			PredicateContext *next_;
49			/*
50			* / Related Failure, set when the PredicateContext is converted
51			* / into a Failure.
52			*/
53			Failure *failure_;
54			};
55
56			class TestResult
57			{
58			public:
59			TestResult ();
60
61			/*
62			* / \internal Implementation detail for assertion macros
63			* / Not encapsulated to prevent step into when debugging failed assertions
64			* / Incremented by one on assertion predicate entry, decreased by one
65			* / by addPredicateContext().
66			*/
67			PredicateContext::Id predicateId_;
68
69			/* / \internal Implementation detail for predicate macros */
70			PredicateContext *predicateStackTail_;
71
72			void setTestName (const std::string &name);
73
74			/* / Adds an assertion failure. */
75			TestResult &addFailure (const char file, unsigned int line, const char expr = 0);
76
77			/*
78			* / Removes the last PredicateContext added to the predicate stack
79			* / chained list.
80			* / Next messages will be targed at the PredicateContext that was removed.
81			*/
82			TestResult &popPredicateContext ();
83
84			bool failed () const;
85
86			void printFailure (bool printTestName) const;
87
88			TestResult &operator << (bool value);
89			TestResult &operator << (int value);
90			TestResult &operator << (unsigned int value);
91			TestResult &operator << (double value);
92			TestResult &operator << (const char *value);
93			TestResult &operator << (const std::string &value);
94
95			private:
96			TestResult &addToLastFailure (const std::string &message);
97			unsigned int getAssertionNestingLevel () const;
98			/* / Adds a failure or a predicate context */
99			void addFailureInfo (const char file, unsigned int line, const char expr, unsigned int nestingLevel);
100			static std::string indentText (const std::string &text, const std::string &indent);
101
102			typedef std::deque<Failure> Failures;
103			Failures failures_;
104			std::string name_;
105			PredicateContext rootPredicateNode_;
106			PredicateContext::Id lastUsedPredicateId_;
107			/* / Failure which is the target of the messages added using operator << */
108			Failure *messageTarget_;
109			};
110
111
112			class TestCase
113			{
114			public:
115			TestCase ();
116
117			virtual
118			~TestCase ();
119
120			void run (TestResult &result);
121
122			virtual const char *testName () const = 0;
123
124			protected:
125			TestResult *result_;
126
127			private:
128			virtual void runTestCase () = 0;
129			};
130
131			/* / Function pointer type for TestCase factory */
132			typedef TestCase (TestCaseFactory)();
133
134			class Runner
135			{
136			public:
137			Runner ();
138
139			/* / Adds a test to the suite */
140			Runner &add (TestCaseFactory factory);
141
142			/*
143			* / Runs test as specified on the command-line
144			* / If no command-line arguments are provided, run all tests.
145			* / If --list-tests is provided, then print the list of all test cases
146			* / If --test <testname> is provided, then run test testname.
147			*/
148			int runCommandLine (int argc, const char *argv[]) const;
149
150			/* / Runs all the test cases */
151			bool runAllTest (bool printSummary) const;
152
153			/* / Returns the number of test case in the suite */
154			unsigned int testCount () const;
155
156			/* / Returns the name of the test case at the specified index */
157			std::string testNameAt (unsigned int index) const;
158
159			/* / Runs the test case at the specified index using the specified TestResult */
160			void runTestAt (unsigned int index, TestResult &result) const;
161
162			static void printUsage (const char *appName);
163
164			private:
165			/* prevents copy construction and assignment */
166			Runner (const Runner &other);
167			Runner &operator = (const Runner &other);
168
169			private:
170			void listTests () const;
171			bool testIndex (const std::string &testName, unsigned int &index) const;
172			static void preventDialogOnCrash ();
173
174			private:
175			typedef std::deque<TestCaseFactory> Factories;
176			Factories tests_;
177			};
178
179			template<typename T>
180			TestResult &
181			checkEqual (TestResult &result, const T &expected, const T &actual, const char file, unsigned int line, const char expr)
182			{
183			if (expected != actual)
184			{
185			result.addFailure (file, line, expr);
186			result << "Expected: " << expected << "\n";
187			result << "Actual : " << actual;
188			}
189			return result;
190			}
191
192			TestResult &checkStringEqual (TestResult &result, const std::string &expected, const std::string &actual, const char file, unsigned int line, const char expr);
193			} /* namespace JsonTest */
194
195
196			/*
197			* / \brief Asserts that the given expression is true.
198			* / JSONTEST_ASSERT( x == y ) << "x=" << x << ", y=" << y;
199			* / JSONTEST_ASSERT( x == y );
200			*/
201			#define JSONTEST_ASSERT(expr) \
202			if (condition) \
203			{ \
204			} \
205			else \
206			result_->addFailure (__FILE__, __LINE__, # expr)
207
208			/*
209			* / \brief Asserts that the given predicate is true.
210			* / The predicate may do other assertions and be a member function of the fixture.
211			*/
212			#define JSONTEST_ASSERT_PRED(expr) \
213			{ \
214			JsonTest::PredicateContext _minitest_Context = { \
215			result_->predicateId_, __FILE__, __LINE__, # expr }; \
216			result_->predicateStackTail_->next_ = &_minitest_Context; \
217			result_->predicateId_ += 1; \
218			result_->predicateStackTail_ = &_minitest_Context; \
219			(expr); \
220			result_->popPredicateContext (); \
221			} \
222			*result_
223
224			/* / \brief Asserts that two values are equals. */
225			#define JSONTEST_ASSERT_EQUAL(expected, actual) \
226			JsonTest::checkEqual (*result_, expected, actual, \
227			__FILE__, __LINE__, \
228			# expected " == " # actual)
229
230			/* / \brief Asserts that two values are equals. */
231			#define JSONTEST_ASSERT_STRING_EQUAL(expected, actual) \
232			JsonTest::checkStringEqual (*result_, \
233			std::string (expected), std::string (actual), \
234			# expected " == " # actual)
235
236			/* / \brief Begin a fixture test case. */
237			#define JSONTEST_FIXTURE(FixtureType, name) \
238			class Test ## FixtureType ## name \
239			: public FixtureType \
240			{ \
241			public: \
242			static JsonTest::TestCase *factory () \
243			{ \
244			return new Test ## FixtureType ## name (); \
245			} \
246			public: \
247			/* overidden from TestCase */ \
248			virtual const char *testName () const \
249			{ \
250			return # FixtureType "/" # name; \
251			} \
252			virtual void runTestCase (); \
253			}; \
254			\
255			void Test ## FixtureType ## name::runTestCase ()
256
257			#define JSONTEST_FIXTURE_FACTORY(FixtureType, name) \
258			& Test ## FixtureType ## name::factory
259
260			#define JSONTEST_REGISTER_FIXTURE(runner, FixtureType, name) \
261			(runner).add (JSONTEST_FIXTURE_FACTORY (FixtureType, name))
262
263			#endif /* ifndef JSONTEST_H_INCLUDED */