1 /*
2  * Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are met:
7  *     * Redistributions of source code must retain the above copyright
8  *       notice, this list of conditions and the following disclaimer.
9  *     * Redistributions in binary form must reproduce the above copyright
10  *       notice, this list of conditions and the following disclaimer in the
11  *       documentation and/or other materials provided with the distribution.
12  *     * Neither the name of the <organization> nor the
13  *       names of its contributors may be used to endorse or promote products
14  *       derived from this software without specific prior written permission.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ``AS IS'' AND ANY
17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19  * DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
20  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  */
27 
28 // This file contains the Test class along with the macros which make effective
29 // in the harness.
30 
31 #ifndef D_UTest_h
32 #define D_UTest_h
33 
34 #include "SimpleString.h"
35 
36 class TestResult;
37 class TestPlugin;
38 class TestFailure;
39 class TestFilter;
40 class TestTerminator;
41 
42 extern bool doubles_equal(double d1, double d2, double threshold);
43 
44 //////////////////// Utest
45 
46 class UtestShell;
47 
48 class Utest
49 {
50 public:
51     Utest();
52     virtual ~Utest();
53     virtual void run();
54 
55     virtual void setup();
56     virtual void teardown();
57     virtual void testBody();
58 };
59 
60 //////////////////// TestTerminator
61 
62 class TestTerminator
63 {
64 public:
65     virtual void exitCurrentTest() const=0;
66     virtual ~TestTerminator();
67 };
68 
69 class NormalTestTerminator : public TestTerminator
70 {
71 public:
72     virtual void exitCurrentTest() const _override;
73     virtual ~NormalTestTerminator() _destructor_override;
74 };
75 
76 class TestTerminatorWithoutExceptions  : public TestTerminator
77 {
78 public:
79     virtual void exitCurrentTest() const _override;
80     virtual ~TestTerminatorWithoutExceptions() _destructor_override;
81 };
82 
83 //////////////////// UtestShell
84 
85 class UtestShell
86 {
87 public:
88     static UtestShell *getCurrent();
89 
90 public:
91     UtestShell(const char* groupName, const char* testName, const char* fileName, size_t lineNumber);
92     virtual ~UtestShell();
93 
94     virtual UtestShell* addTest(UtestShell* test);
95     virtual UtestShell *getNext() const;
96     virtual size_t countTests();
97 
98     bool shouldRun(const TestFilter* groupFilters, const TestFilter* nameFilters) const;
99     const SimpleString getName() const;
100     const SimpleString getGroup() const;
101     virtual SimpleString getFormattedName() const;
102     const SimpleString getFile() const;
103     size_t getLineNumber() const;
104     virtual bool willRun() const;
105     virtual bool hasFailed() const;
106     void countCheck();
107 
108     virtual void assertTrue(bool condition, const char *checkString, const char *conditionString, const char* text, const char *fileName, size_t lineNumber, const TestTerminator& testTerminator = NormalTestTerminator());
109     virtual void assertCstrEqual(const char *expected, const char *actual, const char* text, const char *fileName, size_t lineNumber, const TestTerminator& testTerminator = NormalTestTerminator());
110     virtual void assertCstrNEqual(const char *expected, const char *actual, size_t length, const char* text, const char *fileName, size_t lineNumber, const TestTerminator& testTerminator = NormalTestTerminator());
111     virtual void assertCstrNoCaseEqual(const char *expected, const char *actual, const char* text, const char *fileName, size_t lineNumber);
112     virtual void assertCstrContains(const char *expected, const char *actual, const char* text, const char *fileName, size_t lineNumber);
113     virtual void assertCstrNoCaseContains(const char *expected, const char *actual, const char* text, const char *fileName, size_t lineNumber);
114     virtual void assertLongsEqual(long expected, long actual, const char* text, const char *fileName, size_t lineNumber, const TestTerminator& testTerminator = NormalTestTerminator());
115     virtual void assertUnsignedLongsEqual(unsigned long expected, unsigned long actual, const char* text, const char *fileName, size_t lineNumber, const TestTerminator& testTerminator = NormalTestTerminator());
116     virtual void assertLongLongsEqual(cpputest_longlong expected, cpputest_longlong actual, const char* text, const char *fileName, size_t lineNumber, const TestTerminator& testTerminator = NormalTestTerminator());
117     virtual void assertUnsignedLongLongsEqual(cpputest_ulonglong expected, cpputest_ulonglong actual, const char* text, const char *fileName, size_t lineNumber, const TestTerminator& testTerminator = NormalTestTerminator());
118     virtual void assertSignedBytesEqual(signed char expected, signed char actual, const char* text, const char *fileName, size_t lineNumber, const TestTerminator& testTerminator = NormalTestTerminator());
119     virtual void assertPointersEqual(const void *expected, const void *actual, const char* text, const char *fileName, size_t lineNumber, const TestTerminator& testTerminator = NormalTestTerminator());
120     virtual void assertFunctionPointersEqual(void (*expected)(), void (*actual)(), const char* text, const char* fileName, size_t lineNumber, const TestTerminator& testTerminator = NormalTestTerminator());
121     virtual void assertDoublesEqual(double expected, double actual, double threshold, const char* text, const char *fileName, size_t lineNumber, const TestTerminator& testTerminator = NormalTestTerminator());
122     virtual void assertEquals(bool failed, const char* expected, const char* actual, const char* text, const char* file, size_t lineNumber, const TestTerminator& testTerminator = NormalTestTerminator());
123     virtual void assertBinaryEqual(const void *expected, const void *actual, size_t length, const char* text, const char *fileName, size_t lineNumber, const TestTerminator& testTerminator = NormalTestTerminator());
124     virtual void assertBitsEqual(unsigned long expected, unsigned long actual, unsigned long mask, size_t byteCount, const char* text, const char *fileName, size_t lineNumber, const TestTerminator& testTerminator = NormalTestTerminator());
125     virtual void assertCompare(bool comparison, const char *checkString, const char *comparisonString, const char *text, const char *fileName, size_t lineNumber, const TestTerminator& testTerminator = NormalTestTerminator());
126     virtual void fail(const char *text, const char *fileName, size_t lineNumber, const TestTerminator& testTerminator = NormalTestTerminator());
127     virtual void exitTest(const TestTerminator& testTerminator = NormalTestTerminator());
128 
129     virtual void print(const char *text, const char *fileName, size_t lineNumber);
130     virtual void print(const SimpleString & text, const char *fileName, size_t lineNumber);
131     virtual void printVeryVerbose(const char* text);
132 
133     void setFileName(const char *fileName);
134     void setLineNumber(size_t lineNumber);
135     void setGroupName(const char *groupName);
136     void setTestName(const char *testName);
137 
138     static void crash();
139     static void setCrashMethod(void (*crashme)());
140     static void resetCrashMethod();
141 
142     virtual bool isRunInSeperateProcess() const;
143     virtual void setRunInSeperateProcess();
144 
145     virtual void setRunIgnored();
146 
147     virtual Utest* createTest();
148     virtual void destroyTest(Utest* test);
149 
150     virtual void runOneTest(TestPlugin* plugin, TestResult& result);
151     virtual void runOneTestInCurrentProcess(TestPlugin *plugin, TestResult & result);
152 
153     virtual void failWith(const TestFailure& failure);
154     virtual void failWith(const TestFailure& failure, const TestTerminator& terminator);
155 
156 protected:
157     UtestShell();
158     UtestShell(const char *groupName, const char *testName, const char *fileName, size_t lineNumber, UtestShell *nextTest);
159 
160     virtual SimpleString getMacroName() const;
161     TestResult *getTestResult();
162 private:
163     const char *group_;
164     const char *name_;
165     const char *file_;
166     size_t lineNumber_;
167     UtestShell *next_;
168     bool isRunAsSeperateProcess_;
169     bool hasFailed_;
170 
171     void setTestResult(TestResult* result);
172     void setCurrentTest(UtestShell* test);
173     bool match(const char* target, const TestFilter* filters) const;
174 
175     static UtestShell* currentTest_;
176     static TestResult* testResult_;
177 
178 };
179 
180 
181 
182 //////////////////// ExecFunctionTest
183 
184 class ExecFunctionTestShell;
185 
186 class ExecFunctionTest : public Utest
187 {
188 public:
189     ExecFunctionTest(ExecFunctionTestShell* shell);
190     void testBody() _override;
191     virtual void setup() _override;
192     virtual void teardown() _override;
193 private:
194     ExecFunctionTestShell* shell_;
195 };
196 
197 //////////////////// ExecFunction
198 
199 class ExecFunction
200 {
201 public:
202     ExecFunction();
203     virtual ~ExecFunction();
204 
205     virtual void exec()=0;
206 };
207 
208 class ExecFunctionWithoutParameters : public ExecFunction
209 {
210 public:
211     void (*testFunction_)();
212 
213     ExecFunctionWithoutParameters(void(*testFunction)());
214     virtual ~ExecFunctionWithoutParameters() _destructor_override;
215 
216     virtual void exec() _override;
217 };
218 
219 //////////////////// ExecFunctionTestShell
220 
221 class ExecFunctionTestShell : public UtestShell
222 {
223 public:
224     void (*setup_)();
225     void (*teardown_)();
226     ExecFunction* testFunction_;
227 
228     ExecFunctionTestShell(void(*set)() = NULLPTR, void(*tear)() = NULLPTR) :
229         UtestShell("ExecFunction", "ExecFunction", "ExecFunction", 1), setup_(set), teardown_(tear), testFunction_(NULLPTR)
230     {
231     }
232 
createTest()233     Utest* createTest() _override { return new ExecFunctionTest(this); }
234     virtual ~ExecFunctionTestShell() _destructor_override;
235 };
236 
237 //////////////////// CppUTestFailedException
238 
239 class CppUTestFailedException
240 {
241 public:
242     int dummy_;
243 };
244 
245 //////////////////// IgnoredTest
246 
247 class IgnoredUtestShell : public UtestShell
248 {
249 public:
250     IgnoredUtestShell();
251     virtual ~IgnoredUtestShell() _destructor_override;
252     explicit IgnoredUtestShell(const char* groupName, const char* testName,
253             const char* fileName, size_t lineNumber);
254     virtual bool willRun() const _override;
255     virtual void setRunIgnored() _override;
256 protected:
257     virtual SimpleString getMacroName() const _override;
258     virtual void runOneTest(TestPlugin* plugin, TestResult& result) _override;
259 private:
260 
261     IgnoredUtestShell(const IgnoredUtestShell&);
262     IgnoredUtestShell& operator=(const IgnoredUtestShell&);
263 
264     bool runIgnored_;
265 
266 };
267 
268 //////////////////// UtestShellPointerArray
269 
270 class UtestShellPointerArray
271 {
272 public:
273     UtestShellPointerArray(UtestShell* firstTest);
274     ~UtestShellPointerArray();
275 
276     void shuffle(size_t seed);
277     void reverse();
278     void relinkTestsInOrder();
279     UtestShell* getFirstTest() const;
280     UtestShell* get(size_t index) const;
281 
282 private:
283 
284     void swap(size_t index1, size_t index2);
285 
286     UtestShell** arrayOfTests_;
287     size_t count_;
288 };
289 
290 
291 //////////////////// TestInstaller
292 
293 class TestInstaller
294 {
295 public:
296     explicit TestInstaller(UtestShell& shell, const char* groupName, const char* testName,
297             const char* fileName, size_t lineNumber);
298     virtual ~TestInstaller();
299 
300     void unDo();
301 
302 private:
303 
304     TestInstaller(const TestInstaller&);
305     TestInstaller& operator=(const TestInstaller&);
306 
307 };
308 
309 #endif
310