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
TEST(CheckSucceedsOnTrue)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
TEST(CheckFailsOnFalse)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
TEST(FailureReportsCorrectTestName)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
TEST(CheckFailureIncludesCheckContents)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
TEST(CheckEqualSucceedsOnEqual)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
TEST(CheckEqualFailsOnNotEqual)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
TEST(CheckEqualFailureContainsCorrectDetails)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;
FunctionWithSideEffects()112 int FunctionWithSideEffects()
113 {
114 ++g_sideEffect;
115 return 1;
116 }
117
TEST(CheckEqualDoesNotHaveSideEffectsWhenPassing)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
TEST(CheckEqualDoesNotHaveSideEffectsWhenFailing)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
TEST(CheckCloseSucceedsOnEqual)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
TEST(CheckCloseFailsOnNotEqual)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
TEST(CheckCloseFailureContainsCorrectDetails)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
TEST(CheckCloseDoesNotHaveSideEffectsWhenPassing)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
TEST(CheckCloseDoesNotHaveSideEffectsWhenFailing)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
TEST(CheckArrayCloseSucceedsOnEqual)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
TEST(CheckArrayCloseFailsOnNotEqual)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
TEST(CheckArrayCloseFailureIncludesCheckExpectedAndActual)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
TEST(CheckArrayCloseFailureContainsCorrectDetails)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
TEST(CheckArrayCloseFailureIncludesTolerance)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
TEST(CheckArrayEqualSuceedsOnEqual)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
TEST(CheckArrayEqualFailsOnNotEqual)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
TEST(CheckArrayEqualFailureIncludesCheckExpectedAndActual)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
TEST(CheckArrayEqualFailureContainsCorrectInfo)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
FunctionWithSideEffects2()362 float const* FunctionWithSideEffects2()
363 {
364 ++g_sideEffect;
365 static float const data[] = {1,2,3,4};
366 return data;
367 }
368
TEST(CheckArrayCloseDoesNotHaveSideEffectsWhenPassing)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
TEST(CheckArrayCloseDoesNotHaveSideEffectsWhenFailing)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
TEST(CheckArray2DCloseSucceedsOnEqual)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
TEST(CheckArray2DCloseFailsOnNotEqual)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
TEST(CheckArray2DCloseFailureIncludesCheckExpectedAndActual)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
TEST(CheckArray2DCloseFailureContainsCorrectDetails)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
TEST(CheckArray2DCloseFailureIncludesTolerance)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
FunctionWithSideEffects3()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
TEST(CheckArray2DCloseDoesNotHaveSideEffectsWhenPassing)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
TEST(CheckArray2DCloseDoesNotHaveSideEffectsWhenFailing)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