inc/CppUnitTest/TestCase.h


#ifndef CPPUNIT_TESTCASE_H
#define CPPUNIT_TESTCASE_H

#include <string>
#include <vector>
//#include <typeinfo>

#include "Guards.h"

#include "Test.h"

#include "CppUnitException.h"

#include "CppUnitTest/CppUnitTestNamespace.h"
BEGIN_NAMESPACE_CPPUNITTEST

class TestResult;

/*
 * A test case defines the fixture to run multiple tests. To define a test case
 * 1) implement a subclass of TestCase
 * 2) define instance variables that store the state of the fixture
 * 3) initialize the fixture state by overriding setUp
 * 4) clean-up after a test by overriding tearDown.
 *
 * Each test runs in its own fixture so there
 * can be no side effects among test runs.
 * Here is an example:
 * 
 * class MathTest : public TestCase {
 *     protected: int m_value1;
 *     protected: int m_value2;
 *
 *     public: MathTest (std::string name)
 *                 : TestCase (name) {
 *     }
 *
 *     protected: void setUp () {
 *         m_value1 = 2;
 *         m_value2 = 3;
 *     }
 * }
 * 
 *
 * For each test implement a method which interacts
 * with the fixture. Verify the expected results with assertions specified
 * by calling assert on the expression you want to test:
 * 
 *    protected: void testAdd () {
 *        int result = value1 + value2;
 *        assert (result == 5);
 *    }
 * 
 * Once the methods are defined you can run them. To do this, use
 * a TestCaller.
 *
 * Test *test = new TestCaller<MathTest>("testAdd", MathTest::testAdd);
 * test->run ();
 *
 *
 * The tests to be run can be collected into a TestSuite. CppUnit provides
 * different test runners which can run a test suite and collect the results.
 * The test runners expect a static method suite as the entry
 * point to get a test to run.
 * 
 * public: static MathTest::suite () {
 *      TestSuite *suiteOfTests = new TestSuite;
 *      suiteOfTests->addTest(new TestCaller<MathTest>("testAdd", testAdd));
 *      suiteOfTests->addTest(new TestCaller<MathTest>("testDivideByZero", testDivideByZero));
 *      return suiteOfTests;
 *  }
 * 
 * Note that the caller of suite assumes lifetime control
 * for the returned suite.
 *
 * see TestResult, TestSuite and TestCaller
 *
 */


class TestCase : public Test 
{
   REFERENCEOBJECT (TestCase)

      public:
   TestCase         (std::string Name);
   ~TestCase        ();

   virtual void        run              (TestResult *result);
   virtual TestResult  *run             ();
   virtual int         countTestCases   ();
   std::string         toString         ();

   virtual void        setUp            ();
   virtual void        tearDown         ();

   void setCheckErrors(const std::vector<std::string>& checkErrors);

   const std::vector<std::string>& getCheckErrors();


 protected:
   virtual void        runTest          ();

   TestResult          *defaultResult   ();
   void                checkImplementation 
      (bool         condition, 
       std::string  conditionExpression = "",
       long         lineNumber = CPPUNIT_UNKNOWNLINENUMBER,
       std::string  fileName = CPPUNIT_UNKNOWNFILENAME);

   void                assertImplementation 
      (bool         condition, 
       std::string  conditionExpression = "",
       long         lineNumber = CPPUNIT_UNKNOWNLINENUMBER,
       std::string  fileName = CPPUNIT_UNKNOWNFILENAME);

   void                assertEquals     (long         expected, 
                                         long         actual,
                                         long         lineNumber = CPPUNIT_UNKNOWNLINENUMBER,
                                         std::string  fileName = CPPUNIT_UNKNOWNFILENAME);

   void                assertEquals     (double       expected, 
                                         double       actual, 
                                         double       delta, 
                                         long         lineNumber = CPPUNIT_UNKNOWNLINENUMBER,
                                         std::string  fileName = CPPUNIT_UNKNOWNFILENAME);

   std::string         notEqualsMessage (long         expected, 
                                         long         actual);

   std::string         notEqualsMessage (double       expected, 
                                         double       actual);

    
 private:

   std::vector<std::string> m_errorLog;

};


// Constructs a test case
inline TestCase::TestCase (std::string name) : Test(name)  
{}


// Destructs a test case
inline TestCase::~TestCase ()
{}


// Returns a count of all the tests executed
inline int TestCase::countTestCases ()
{ return 1; }

// A hook for fixture set up
inline void TestCase::setUp ()
{}


// A hook for fixture tear down
inline void TestCase::tearDown ()
{}


// Returns the name of the test case instance
inline std::string TestCase::toString () {return name();}
//{ const std::type_info& thisClass = typeid (*this); return std::string (thisClass.name ()) + "." + name (); }


// A set of macros which allow us to get the line number
// and file name at the point of an error.
// Just goes to show that preprocessors do have some
// redeeming qualities.

#define CPPUNIT_SOURCEANNOTATION

#ifdef CPPUNIT_SOURCEANNOTATION

#undef assert
#define assert(condition)\
    (this->assertImplementation ((condition),(#condition),\
        __LINE__, __FILE__))

#undef CHECK
#define CHECK(condition)\
    (this->checkImplementation ((condition),(#condition),\
        __LINE__, __FILE__))

#else

#undef assert
#define assert(condition)\
    (this->assertImplementation ((condition),"",\
        __LINE__, __FILE__))

#undef CHECK
#define CHECK(condition)\
    (this->checkImplementation ((condition),"",\
        __LINE__, __FILE__))

#endif


// Macros for primitive value comparisons
#define assertDoublesEqual(expected,actual,delta)\
(this->assertEquals ((expected),\
        (actual),(delta),__LINE__,__FILE__))

#define assertLongsEqual(expected,actual)\
(this->assertEquals ((expected),\
        (actual),__LINE__,__FILE__))

END_NAMESPACE_CPPUNITTEST

#endif


1	jgs	82
2			#ifndef CPPUNIT_TESTCASE_H
3			#define CPPUNIT_TESTCASE_H
4
5			#include <string>
6			#include <vector>
7			//#include <typeinfo>
8
9			#include "Guards.h"
10
11			#include "Test.h"
12
13			#include "CppUnitException.h"
14
15			#include "CppUnitTest/CppUnitTestNamespace.h"
16			BEGIN_NAMESPACE_CPPUNITTEST
17
18			class TestResult;
19
20			/*
21			* A test case defines the fixture to run multiple tests. To define a test case
22			* 1) implement a subclass of TestCase
23			* 2) define instance variables that store the state of the fixture
24			* 3) initialize the fixture state by overriding setUp
25			* 4) clean-up after a test by overriding tearDown.
26			*
27			* Each test runs in its own fixture so there
28			* can be no side effects among test runs.
29			* Here is an example:
30			*
31			* class MathTest : public TestCase {
32			* protected: int m_value1;
33			* protected: int m_value2;
34			*
35			* public: MathTest (std::string name)
36			* : TestCase (name) {
37			* }
38			*
39			* protected: void setUp () {
40			* m_value1 = 2;
41			* m_value2 = 3;
42			* }
43			* }
44			*
45			*
46			* For each test implement a method which interacts
47			* with the fixture. Verify the expected results with assertions specified
48			* by calling assert on the expression you want to test:
49			*
50			* protected: void testAdd () {
51			* int result = value1 + value2;
52			* assert (result == 5);
53			* }
54			*
55			* Once the methods are defined you can run them. To do this, use
56			* a TestCaller.
57			*
58			* Test *test = new TestCaller<MathTest>("testAdd", MathTest::testAdd);
59			* test->run ();
60			*
61			*
62			* The tests to be run can be collected into a TestSuite. CppUnit provides
63			* different test runners which can run a test suite and collect the results.
64			* The test runners expect a static method suite as the entry
65			* point to get a test to run.
66			*
67			* public: static MathTest::suite () {
68			* TestSuite *suiteOfTests = new TestSuite;
69			* suiteOfTests->addTest(new TestCaller<MathTest>("testAdd", testAdd));
70			* suiteOfTests->addTest(new TestCaller<MathTest>("testDivideByZero", testDivideByZero));
71			* return suiteOfTests;
72			* }
73			*
74			* Note that the caller of suite assumes lifetime control
75			* for the returned suite.
76			*
77			* see TestResult, TestSuite and TestCaller
78			*
79			*/
80
81
82			class TestCase : public Test
83			{
84			REFERENCEOBJECT (TestCase)
85
86			public:
87			TestCase (std::string Name);
88			~TestCase ();
89
90			virtual void run (TestResult *result);
91			virtual TestResult *run ();
92			virtual int countTestCases ();
93			std::string toString ();
94
95			virtual void setUp ();
96			virtual void tearDown ();
97
98			void setCheckErrors(const std::vector<std::string>& checkErrors);
99
100			const std::vector<std::string>& getCheckErrors();
101
102
103			protected:
104			virtual void runTest ();
105
106			TestResult *defaultResult ();
107			void checkImplementation
108			(bool condition,
109			std::string conditionExpression = "",
110			long lineNumber = CPPUNIT_UNKNOWNLINENUMBER,
111			std::string fileName = CPPUNIT_UNKNOWNFILENAME);
112
113			void assertImplementation
114			(bool condition,
115			std::string conditionExpression = "",
116			long lineNumber = CPPUNIT_UNKNOWNLINENUMBER,
117			std::string fileName = CPPUNIT_UNKNOWNFILENAME);
118
119			void assertEquals (long expected,
120			long actual,
121			long lineNumber = CPPUNIT_UNKNOWNLINENUMBER,
122			std::string fileName = CPPUNIT_UNKNOWNFILENAME);
123
124			void assertEquals (double expected,
125			double actual,
126			double delta,
127			long lineNumber = CPPUNIT_UNKNOWNLINENUMBER,
128			std::string fileName = CPPUNIT_UNKNOWNFILENAME);
129
130			std::string notEqualsMessage (long expected,
131			long actual);
132
133			std::string notEqualsMessage (double expected,
134			double actual);
135
136
137			private:
138
139			std::vector<std::string> m_errorLog;
140
141			};
142
143
144			// Constructs a test case
145			inline TestCase::TestCase (std::string name) : Test(name)
146			{}
147
148
149			// Destructs a test case
150			inline TestCase::~TestCase ()
151			{}
152
153
154			// Returns a count of all the tests executed
155			inline int TestCase::countTestCases ()
156			{ return 1; }
157
158			// A hook for fixture set up
159			inline void TestCase::setUp ()
160			{}
161
162
163			// A hook for fixture tear down
164			inline void TestCase::tearDown ()
165			{}
166
167
168			// Returns the name of the test case instance
169			inline std::string TestCase::toString () {return name();}
170			//{ const std::type_info& thisClass = typeid (*this); return std::string (thisClass.name ()) + "." + name (); }
171
172
173
174			// A set of macros which allow us to get the line number
175			// and file name at the point of an error.
176			// Just goes to show that preprocessors do have some
177			// redeeming qualities.
178
179			#define CPPUNIT_SOURCEANNOTATION
180
181			#ifdef CPPUNIT_SOURCEANNOTATION
182
183			#undef assert
184			#define assert(condition)\
185			(this->assertImplementation ((condition),(#condition),\
186			__LINE__, __FILE__))
187
188			#undef CHECK
189			#define CHECK(condition)\
190			(this->checkImplementation ((condition),(#condition),\
191			__LINE__, __FILE__))
192
193			#else
194
195			#undef assert
196			#define assert(condition)\
197			(this->assertImplementation ((condition),"",\
198			__LINE__, __FILE__))
199
200			#undef CHECK
201			#define CHECK(condition)\
202			(this->checkImplementation ((condition),"",\
203			__LINE__, __FILE__))
204
205			#endif
206
207
208			// Macros for primitive value comparisons
209			#define assertDoublesEqual(expected,actual,delta)\
210			(this->assertEquals ((expected),\
211			(actual),(delta),__LINE__,__FILE__))
212
213			#define assertLongsEqual(expected,actual)\
214			(this->assertEquals ((expected),\
215			(actual),__LINE__,__FILE__))
216
217			END_NAMESPACE_CPPUNITTEST
218
219			#endif
220
221
222
223
224
225
226
227
228
229
230
231
232
Name	Value
svn:eol-style	native
svn:executable	*
svn:keywords	Author Date Id Revision