1 #include "UnitTest++/UnitTestPP.h"
2 #include "UnitTest++/CurrentTest.h"
3 #include "RecordingReporter.h"
4 #include "ScopedCurrentTest.h"
5 
6 using namespace std;
7 
8 namespace {
9 
10 TEST(CheckSucceedsOnTrue)
11 {
12     bool failure = true;
13     {
14         RecordingReporter reporter;
15         UnitTest::TestResults testResults(&reporter);
16 
17 		ScopedCurrentTest scopedResults(testResults);
18 		CHECK(true);
19 
20 		failure = (testResults.GetFailureCount() > 0);
21     }
22 
23     CHECK(!failure);
24 }
25 
26 TEST(CheckFailsOnFalse)
27 {
28     bool failure = false;
29     {
30         RecordingReporter reporter;
31         UnitTest::TestResults testResults(&reporter);
32 		ScopedCurrentTest scopedResults(testResults);
33         CHECK(false);
34         failure = (testResults.GetFailureCount() > 0);
35     }
36 
37     CHECK(failure);
38 }
39 
40 TEST(FailureReportsCorrectTestName)
41 {
42     RecordingReporter reporter;
43     {
44         UnitTest::TestResults testResults(&reporter);
45 		ScopedCurrentTest scopedResults(testResults);
46         CHECK(false);
47     }
48 
49     CHECK_EQUAL(m_details.testName, reporter.lastFailedTest);
50 }
51 
52 TEST(CheckFailureIncludesCheckContents)
53 {
54     RecordingReporter reporter;
55     {
56         UnitTest::TestResults testResults(&reporter);
57 		ScopedCurrentTest scopedResults(testResults);
58         const bool yaddayadda = false;
59         CHECK(yaddayadda);
60     }
61 
62     CHECK(strstr(reporter.lastFailedMessage, "yaddayadda"));
63 }
64 
65 TEST(CheckEqualSucceedsOnEqual)
66 {
67     bool failure = true;
68     {
69         RecordingReporter reporter;
70         UnitTest::TestResults testResults(&reporter);
71 		ScopedCurrentTest scopedResults(testResults);
72         CHECK_EQUAL(1, 1);
73         failure = (testResults.GetFailureCount() > 0);
74     }
75 
76     CHECK(!failure);
77 }
78 
79 TEST(CheckEqualFailsOnNotEqual)
80 {
81     bool failure = false;
82     {
83         RecordingReporter reporter;
84         UnitTest::TestResults testResults(&reporter);
85 		ScopedCurrentTest scopedResults(testResults);
86         CHECK_EQUAL(1, 2);
87         failure = (testResults.GetFailureCount() > 0);
88     }
89 
90     CHECK(failure);
91 }
92 
93 TEST(CheckEqualFailureContainsCorrectDetails)
94 {
95     int line = 0;
96     RecordingReporter reporter;
97     {
98         UnitTest::TestResults testResults(&reporter);
99 		UnitTest::TestDetails const testDetails("testName", "suiteName", "filename", -1);
100 		ScopedCurrentTest scopedResults(testResults, &testDetails);
101 
102 		CHECK_EQUAL(1, 123);    line = __LINE__;
103     }
104 
105     CHECK_EQUAL("testName", reporter.lastFailedTest);
106     CHECK_EQUAL("suiteName", reporter.lastFailedSuite);
107     CHECK_EQUAL("filename", reporter.lastFailedFile);
108     CHECK_EQUAL(line, reporter.lastFailedLine);
109 }
110 
111 int g_sideEffect = 0;
112 int FunctionWithSideEffects()
113 {
114     ++g_sideEffect;
115     return 1;
116 }
117 
118 TEST(CheckEqualDoesNotHaveSideEffectsWhenPassing)
119 {
120     g_sideEffect = 0;
121     {
122         UnitTest::TestResults testResults;
123 		ScopedCurrentTest scopedResults(testResults);
124         CHECK_EQUAL(1, FunctionWithSideEffects());
125     }
126     CHECK_EQUAL(1, g_sideEffect);
127 }
128 
129 TEST(CheckEqualDoesNotHaveSideEffectsWhenFailing)
130 {
131     g_sideEffect = 0;
132     {
133         UnitTest::TestResults testResults;
134 		ScopedCurrentTest scopedResults(testResults);
135         CHECK_EQUAL(2, FunctionWithSideEffects());
136     }
137     CHECK_EQUAL(1, g_sideEffect);
138 }
139 
140 
141 TEST(CheckCloseSucceedsOnEqual)
142 {
143     bool failure = true;
144     {
145         RecordingReporter reporter;
146         UnitTest::TestResults testResults(&reporter);
147 		ScopedCurrentTest scopedResults(testResults);
148         CHECK_CLOSE (1.0f, 1.001f, 0.01f);
149         failure = (testResults.GetFailureCount() > 0);
150     }
151 
152     CHECK(!failure);
153 }
154 
155 TEST(CheckCloseFailsOnNotEqual)
156 {
157     bool failure = false;
158     {
159         RecordingReporter reporter;
160         UnitTest::TestResults testResults(&reporter);
161 		ScopedCurrentTest scopedResults(testResults);
162         CHECK_CLOSE (1.0f, 1.1f, 0.01f);
163         failure = (testResults.GetFailureCount() > 0);
164     }
165 
166     CHECK(failure);
167 }
168 
169 TEST(CheckCloseFailureContainsCorrectDetails)
170 {
171     int line = 0;
172     RecordingReporter reporter;
173     {
174         UnitTest::TestResults testResults(&reporter);
175 		UnitTest::TestDetails testDetails("test", "suite", "filename", -1);
176 		ScopedCurrentTest scopedResults(testResults, &testDetails);
177 
178 		CHECK_CLOSE (1.0f, 1.1f, 0.01f);    line = __LINE__;
179     }
180 
181     CHECK_EQUAL("test", reporter.lastFailedTest);
182     CHECK_EQUAL("suite", reporter.lastFailedSuite);
183     CHECK_EQUAL("filename", reporter.lastFailedFile);
184     CHECK_EQUAL(line, reporter.lastFailedLine);
185 }
186 
187 TEST(CheckCloseDoesNotHaveSideEffectsWhenPassing)
188 {
189     g_sideEffect = 0;
190     {
191         UnitTest::TestResults testResults;
192 		ScopedCurrentTest scopedResults(testResults);
193         CHECK_CLOSE (1, FunctionWithSideEffects(), 0.1f);
194     }
195     CHECK_EQUAL(1, g_sideEffect);
196 }
197 
198 TEST(CheckCloseDoesNotHaveSideEffectsWhenFailing)
199 {
200     g_sideEffect = 0;
201     {
202         UnitTest::TestResults testResults;
203 		ScopedCurrentTest scopedResults(testResults);
204         CHECK_CLOSE (2, FunctionWithSideEffects(), 0.1f);
205     }
206     CHECK_EQUAL(1, g_sideEffect);
207 }
208 
209 TEST(CheckArrayCloseSucceedsOnEqual)
210 {
211     bool failure = true;
212     {
213         RecordingReporter reporter;
214         UnitTest::TestResults testResults(&reporter);
215 		ScopedCurrentTest scopedResults(testResults);
216         const float data[4] = { 0, 1, 2, 3 };
217         CHECK_ARRAY_CLOSE (data, data, 4, 0.01f);
218         failure = (testResults.GetFailureCount() > 0);
219     }
220 
221     CHECK(!failure);
222 }
223 
224 TEST(CheckArrayCloseFailsOnNotEqual)
225 {
226     bool failure = false;
227     {
228         RecordingReporter reporter;
229         UnitTest::TestResults testResults(&reporter);
230 		ScopedCurrentTest scopedResults(testResults);
231 
232 		int const data1[4] = { 0, 1, 2, 3 };
233         int const data2[4] = { 0, 1, 3, 3 };
234 		CHECK_ARRAY_CLOSE (data1, data2, 4, 0.01f);
235 
236 		failure = (testResults.GetFailureCount() > 0);
237     }
238 
239     CHECK(failure);
240 }
241 
242 TEST(CheckArrayCloseFailureIncludesCheckExpectedAndActual)
243 {
244     RecordingReporter reporter;
245     {
246         UnitTest::TestResults testResults(&reporter);
247 		ScopedCurrentTest scopedResults(testResults);
248 
249 		int const data1[4] = { 0, 1, 2, 3 };
250         int const data2[4] = { 0, 1, 3, 3 };
251         CHECK_ARRAY_CLOSE (data1, data2, 4, 0.01f);
252     }
253 
254     CHECK(strstr(reporter.lastFailedMessage, "xpected [ 0 1 2 3 ]"));
255     CHECK(strstr(reporter.lastFailedMessage, "was [ 0 1 3 3 ]"));
256 }
257 
258 TEST(CheckArrayCloseFailureContainsCorrectDetails)
259 {
260     int line = 0;
261     RecordingReporter reporter;
262     {
263         UnitTest::TestResults testResults(&reporter);
264 		UnitTest::TestDetails testDetails("arrayCloseTest", "arrayCloseSuite", "filename", -1);
265 		ScopedCurrentTest scopedResults(testResults, &testDetails);
266 
267 		int const data1[4] = { 0, 1, 2, 3 };
268         int const data2[4] = { 0, 1, 3, 3 };
269         CHECK_ARRAY_CLOSE (data1, data2, 4, 0.01f);     line = __LINE__;
270     }
271 
272     CHECK_EQUAL("arrayCloseTest", reporter.lastFailedTest);
273     CHECK_EQUAL("arrayCloseSuite", reporter.lastFailedSuite);
274     CHECK_EQUAL("filename", reporter.lastFailedFile);
275     CHECK_EQUAL(line, reporter.lastFailedLine);
276 }
277 
278 TEST(CheckArrayCloseFailureIncludesTolerance)
279 {
280     RecordingReporter reporter;
281     {
282         UnitTest::TestResults testResults(&reporter);
283 		ScopedCurrentTest scopedResults(testResults);
284 
285 		float const data1[4] = { 0, 1, 2, 3 };
286         float const data2[4] = { 0, 1, 3, 3 };
287         CHECK_ARRAY_CLOSE (data1, data2, 4, 0.01f);
288     }
289 
290     CHECK(strstr(reporter.lastFailedMessage, "0.01"));
291 }
292 
293 TEST(CheckArrayEqualSuceedsOnEqual)
294 {
295     bool failure = true;
296     {
297         RecordingReporter reporter;
298         UnitTest::TestResults testResults(&reporter);
299 		ScopedCurrentTest scopedResults(testResults);
300 
301 		const float data[4] = { 0, 1, 2, 3 };
302         CHECK_ARRAY_EQUAL (data, data, 4);
303 
304 		failure = (testResults.GetFailureCount() > 0);
305     }
306 
307     CHECK(!failure);
308 }
309 
310 TEST(CheckArrayEqualFailsOnNotEqual)
311 {
312     bool failure = false;
313     {
314         RecordingReporter reporter;
315         UnitTest::TestResults testResults(&reporter);
316 		ScopedCurrentTest scopedResults(testResults);
317 
318 		int const data1[4] = { 0, 1, 2, 3 };
319         int const data2[4] = { 0, 1, 3, 3 };
320         CHECK_ARRAY_EQUAL (data1, data2, 4);
321 
322 		failure = (testResults.GetFailureCount() > 0);
323     }
324 
325     CHECK(failure);
326 }
327 
328 TEST(CheckArrayEqualFailureIncludesCheckExpectedAndActual)
329 {
330     RecordingReporter reporter;
331     {
332         UnitTest::TestResults testResults(&reporter);
333 		ScopedCurrentTest scopedResults(testResults);
334 
335 		int const data1[4] = { 0, 1, 2, 3 };
336         int const data2[4] = { 0, 1, 3, 3 };
337         CHECK_ARRAY_EQUAL (data1, data2, 4);
338     }
339 
340     CHECK(strstr(reporter.lastFailedMessage, "xpected [ 0 1 2 3 ]"));
341     CHECK(strstr(reporter.lastFailedMessage, "was [ 0 1 3 3 ]"));
342 }
343 
344 TEST(CheckArrayEqualFailureContainsCorrectInfo)
345 {
346     int line = 0;
347     RecordingReporter reporter;
348     {
349         UnitTest::TestResults testResults(&reporter);
350 		ScopedCurrentTest scopedResults(testResults);
351 
352 		int const data1[4] = { 0, 1, 2, 3 };
353         int const data2[4] = { 0, 1, 3, 3 };
354         CHECK_ARRAY_EQUAL (data1, data2, 4);     line = __LINE__;
355     }
356 
357     CHECK_EQUAL("CheckArrayEqualFailureContainsCorrectInfo", reporter.lastFailedTest);
358     CHECK_EQUAL(__FILE__, reporter.lastFailedFile);
359     CHECK_EQUAL(line, reporter.lastFailedLine);
360 }
361 
362 float const* FunctionWithSideEffects2()
363 {
364     ++g_sideEffect;
365     static float const data[] = {1,2,3,4};
366     return data;
367 }
368 
369 TEST(CheckArrayCloseDoesNotHaveSideEffectsWhenPassing)
370 {
371     g_sideEffect = 0;
372     {
373         UnitTest::TestResults testResults;
374 		ScopedCurrentTest scopedResults(testResults);
375 
376 		const float data[] = { 0, 1, 2, 3 };
377         CHECK_ARRAY_CLOSE (data, FunctionWithSideEffects2(), 4, 0.01f);
378     }
379     CHECK_EQUAL(1, g_sideEffect);
380 }
381 
382 TEST(CheckArrayCloseDoesNotHaveSideEffectsWhenFailing)
383 {
384     g_sideEffect = 0;
385     {
386         UnitTest::TestResults testResults;
387 		ScopedCurrentTest scopedResults(testResults);
388 
389 		const float data[] = { 0, 1, 3, 3 };
390         CHECK_ARRAY_CLOSE (data, FunctionWithSideEffects2(), 4, 0.01f);
391     }
392 
393 	CHECK_EQUAL(1, g_sideEffect);
394 }
395 
396 TEST(CheckArray2DCloseSucceedsOnEqual)
397 {
398     bool failure = true;
399     {
400         RecordingReporter reporter;
401         UnitTest::TestResults testResults(&reporter);
402 		ScopedCurrentTest scopedResults(testResults);
403 
404 		const float data[2][2] = { {0, 1}, {2, 3} };
405         CHECK_ARRAY2D_CLOSE (data, data, 2, 2, 0.01f);
406 
407 		failure = (testResults.GetFailureCount() > 0);
408     }
409 
410     CHECK(!failure);
411 }
412 
413 TEST(CheckArray2DCloseFailsOnNotEqual)
414 {
415     bool failure = false;
416     {
417         RecordingReporter reporter;
418         UnitTest::TestResults testResults(&reporter);
419 		ScopedCurrentTest scopedResults(testResults);
420 
421 		int const data1[2][2] = { {0, 1}, {2, 3} };
422         int const data2[2][2] = { {0, 1}, {3, 3} };
423         CHECK_ARRAY2D_CLOSE (data1, data2, 2, 2, 0.01f);
424 
425 		failure = (testResults.GetFailureCount() > 0);
426     }
427 
428     CHECK(failure);
429 }
430 
431 TEST(CheckArray2DCloseFailureIncludesCheckExpectedAndActual)
432 {
433     RecordingReporter reporter;
434     {
435         UnitTest::TestResults testResults(&reporter);
436 		ScopedCurrentTest scopedResults(testResults);
437 
438 		int const data1[2][2] = { {0, 1}, {2, 3} };
439         int const data2[2][2] = { {0, 1}, {3, 3} };
440 
441 		CHECK_ARRAY2D_CLOSE (data1, data2, 2, 2, 0.01f);
442     }
443 
444     CHECK(strstr(reporter.lastFailedMessage, "xpected [ [ 0 1 ] [ 2 3 ] ]"));
445     CHECK(strstr(reporter.lastFailedMessage, "was [ [ 0 1 ] [ 3 3 ] ]"));
446 }
447 
448 TEST(CheckArray2DCloseFailureContainsCorrectDetails)
449 {
450     int line = 0;
451     RecordingReporter reporter;
452     {
453         UnitTest::TestResults testResults(&reporter);
454 		UnitTest::TestDetails testDetails("array2DCloseTest", "array2DCloseSuite", "filename", -1);
455 		ScopedCurrentTest scopedResults(testResults, &testDetails);
456 
457 		int const data1[2][2] = { {0, 1}, {2, 3} };
458         int const data2[2][2] = { {0, 1}, {3, 3} };
459 		CHECK_ARRAY2D_CLOSE (data1, data2, 2, 2, 0.01f);     line = __LINE__;
460     }
461 
462     CHECK_EQUAL("array2DCloseTest", reporter.lastFailedTest);
463     CHECK_EQUAL("array2DCloseSuite", reporter.lastFailedSuite);
464     CHECK_EQUAL("filename", reporter.lastFailedFile);
465     CHECK_EQUAL(line, reporter.lastFailedLine);
466 }
467 
468 TEST(CheckArray2DCloseFailureIncludesTolerance)
469 {
470     RecordingReporter reporter;
471     {
472         UnitTest::TestResults testResults(&reporter);
473 		ScopedCurrentTest scopedResults(testResults);
474 
475 		float const data1[2][2] = { {0, 1}, {2, 3} };
476         float const data2[2][2] = { {0, 1}, {3, 3} };
477         CHECK_ARRAY2D_CLOSE (data1, data2, 2, 2, 0.01f);
478     }
479 
480     CHECK(strstr(reporter.lastFailedMessage, "0.01"));
481 }
482 
483 float const* const* FunctionWithSideEffects3()
484 {
485     ++g_sideEffect;
486     static float const data1[] = {0,1};
487     static float const data2[] = {2,3};
488     static const float* const data[] = {data1, data2};
489     return data;
490 }
491 
492 TEST(CheckArray2DCloseDoesNotHaveSideEffectsWhenPassing)
493 {
494     g_sideEffect = 0;
495     {
496         UnitTest::TestResults testResults;
497 		ScopedCurrentTest scopedResults(testResults);
498 
499 		const float data[2][2] = { {0, 1}, {2, 3} };
500         CHECK_ARRAY2D_CLOSE (data, FunctionWithSideEffects3(), 2, 2, 0.01f);
501     }
502     CHECK_EQUAL(1, g_sideEffect);
503 }
504 
505 TEST(CheckArray2DCloseDoesNotHaveSideEffectsWhenFailing)
506 {
507     g_sideEffect = 0;
508     {
509         UnitTest::TestResults testResults;
510 		ScopedCurrentTest scopedResults(testResults);
511 
512 		const float data[2][2] = { {0, 1}, {3, 3} };
513         CHECK_ARRAY2D_CLOSE (data, FunctionWithSideEffects3(), 2, 2, 0.01f);
514     }
515     CHECK_EQUAL(1, g_sideEffect);
516 }
517 
518 }
519