1 /*
2 * BCUnit - A Unit testing framework library for C.
3 * Copyright (C) 2001 Anil Kumar
4 * Copyright (C) 2004-2006 Anil Kumar, Jerry St.Clair
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Library General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Library General Public License for more details.
15 *
16 * You should have received a copy of the GNU Library General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 /*
22 * Implementation of Test Run Interface.
23 *
24 * Aug 2001 Initial implementaion (AK)
25 *
26 * 19/Aug/2001 Added initial registry/Suite/test framework implementation. (AK)
27 *
28 * 24/Aug/2001 Changed Data structure from SLL to DLL for all linked lists. (AK)
29 *
30 * 25/Nov/2001 Added notification for Suite Initialization failure condition. (AK)
31 *
32 * 5-Aug-2004 New interface, doxygen comments, moved add_failure on suite
33 * initialization so called even if a callback is not registered,
34 * moved CU_assertImplementation into TestRun.c, consolidated
35 * all run summary info out of CU_TestRegistry into TestRun.c,
36 * revised counting and reporting of run stats to cleanly
37 * differentiate suite, test, and assertion failures. (JDS)
38 *
39 * 1-Sep-2004 Modified CU_assertImplementation() and run_single_test() for
40 * setjmp/longjmp mechanism of aborting test runs, add asserts in
41 * CU_assertImplementation() to trap use outside a registered
42 * test function during an active test run. (JDS)
43 *
44 * 22-Sep-2004 Initial implementation of internal unit tests, added nFailureRecords
45 * to CU_Run_Summary, added CU_get_n_failure_records(), removed
46 * requirement for registry to be initialized in order to run
47 * CU_run_suite() and CU_run_test(). (JDS)
48 *
49 * 30-Apr-2005 Added callback for suite cleanup function failure,
50 * updated unit tests. (JDS)
51 *
52 * 23-Apr-2006 Added testing for suite/test deactivation, changing functions.
53 * Moved doxygen comments for public functions into header.
54 * Added type marker to CU_FailureRecord.
55 * Added support for tracking inactive suites/tests. (JDS)
56 *
57 * 02-May-2006 Added internationalization hooks. (JDS)
58 *
59 * 02-Jun-2006 Added support for elapsed time. Added handlers for suite
60 * start and complete events. Reworked test run routines to
61 * better support these features, suite/test activation. (JDS)
62 *
63 * 16-Avr-2007 Added setup and teardown functions. (CJN)
64 *
65 */
66
67 /** @file
68 * Test run management functions (implementation).
69 */
70 /** @addtogroup Framework
71 @{
72 */
73
74 #include <stdlib.h>
75 #include <string.h>
76 #include <assert.h>
77 #include <stdio.h>
78 #include <setjmp.h>
79 #include <time.h>
80
81 #include "BCUnit.h"
82 #include "MyMem.h"
83 #include "TestDB.h"
84 #include "TestRun.h"
85 #include "Util.h"
86 #include "BCUnit_intl.h"
87
88 #ifdef _WIN32
89 extern void OutputDebugStringPrintf(FILE *file, const char *fmt, ...);
90 #define fprintf(file, fmt, ...) OutputDebugStringPrintf(file, fmt, ##__VA_ARGS__)
91 #elif defined(__ANDROID__)
92 extern void AndroidPrintf(FILE *file, const char *fmt, ...);
93 #define fprintf(file, fmt, ...) AndroidPrintf(file, fmt, ##__VA_ARGS__)
94 #else
95 extern void otherPrintf(FILE *file, const char *fmt, ...);
96 #define fprintf(file, fmt, ...) otherPrintf(file, fmt, ##__VA_ARGS__)
97 #endif
98
99 /*=================================================================
100 * Global/Static Definitions
101 *=================================================================*/
102 static CU_BOOL f_bTestIsRunning = CU_FALSE; /**< Flag for whether a test run is in progress */
103 static CU_pSuite f_pCurSuite = NULL; /**< Pointer to the suite currently being run. */
104 static CU_pTest f_pCurTest = NULL; /**< Pointer to the test currently being run. */
105
106 /** CU_RunSummary to hold results of each test run. */
107 static CU_RunSummary f_run_summary = {"", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
108
109 /** CU_pFailureRecord to hold head of failure record list of each test run. */
110 static CU_pFailureRecord f_failure_list = NULL;
111
112 /** CU_pFailureRecord to hold head of failure record list of each test run. */
113 static CU_pFailureRecord f_last_failure = NULL;
114
115 /** Flag for whether inactive suites/tests are treated as failures. */
116 static CU_BOOL f_failure_on_inactive = CU_TRUE;
117
118 /** Variable for storage of start time for test run. */
119 static time_t f_start_time;
120
121
122 /** Pointer to the function to be called before running a suite. */
123 static CU_SuiteStartMessageHandler f_pSuiteStartMessageHandler = NULL;
124
125 /** Pointer to the function to be called before running a test. */
126 static CU_TestStartMessageHandler f_pTestStartMessageHandler = NULL;
127
128 /** Pointer to the function to be called after running a test. */
129 static CU_TestCompleteMessageHandler f_pTestCompleteMessageHandler = NULL;
130
131 /** Pointer to the function to be called after running a suite. */
132 static CU_SuiteCompleteMessageHandler f_pSuiteCompleteMessageHandler = NULL;
133
134 /** Pointer to the function to be called when all tests have been run. */
135 static CU_AllTestsCompleteMessageHandler f_pAllTestsCompleteMessageHandler = NULL;
136
137 /** Pointer to the function to be called if a suite initialization function returns an error. */
138 static CU_SuiteInitFailureMessageHandler f_pSuiteInitFailureMessageHandler = NULL;
139
140 /** Pointer to the function to be called if a suite cleanup function returns an error. */
141 static CU_SuiteCleanupFailureMessageHandler f_pSuiteCleanupFailureMessageHandler = NULL;
142
143 /*=================================================================
144 * Private function forward declarations
145 *=================================================================*/
146 static void clear_previous_results(CU_pRunSummary pRunSummary, CU_pFailureRecord* ppFailure);
147 static void cleanup_failure_list(CU_pFailureRecord* ppFailure);
148 static CU_ErrorCode run_single_suite(CU_pSuite pSuite, CU_pRunSummary pRunSummary);
149 static CU_ErrorCode run_single_test(CU_pTest pTest, CU_pRunSummary pRunSummary);
150 static void add_failure(CU_pFailureRecord* ppFailure,
151 CU_pRunSummary pRunSummary,
152 CU_FailureType type,
153 unsigned int uiLineNumber,
154 const char *szCondition,
155 const char *szFileName,
156 CU_pSuite pSuite,
157 CU_pTest pTest);
158
159 /*=================================================================
160 * Public Interface functions
161 *=================================================================*/
CU_assertImplementation(CU_BOOL bValue,unsigned int uiLine,const char * strCondition,const char * strFile,const char * strFunction,CU_BOOL bFatal)162 CU_BOOL CU_assertImplementation(CU_BOOL bValue,
163 unsigned int uiLine,
164 const char *strCondition,
165 const char *strFile,
166 const char *strFunction,
167 CU_BOOL bFatal)
168 {
169 /* not used in current implementation - stop compiler warning */
170 CU_UNREFERENCED_PARAMETER(strFunction);
171
172 /* these should always be non-NULL (i.e. a test run is in progress) */
173 assert(NULL != f_pCurSuite);
174 assert(NULL != f_pCurTest);
175
176 ++f_run_summary.nAsserts;
177 if (CU_FALSE == bValue) {
178 ++f_run_summary.nAssertsFailed;
179 add_failure(&f_failure_list, &f_run_summary, CUF_AssertFailed,
180 uiLine, strCondition, strFile, f_pCurSuite, f_pCurTest);
181
182 if ((CU_TRUE == bFatal) && (NULL != f_pCurTest->pJumpBuf)) {
183 longjmp(*(f_pCurTest->pJumpBuf), 1);
184 }
185 }
186
187 return bValue;
188 }
189
190 /*------------------------------------------------------------------------*/
CU_set_suite_start_handler(CU_SuiteStartMessageHandler pSuiteStartHandler)191 void CU_set_suite_start_handler(CU_SuiteStartMessageHandler pSuiteStartHandler)
192 {
193 f_pSuiteStartMessageHandler = pSuiteStartHandler;
194 }
195
196 /*------------------------------------------------------------------------*/
CU_set_test_start_handler(CU_TestStartMessageHandler pTestStartHandler)197 void CU_set_test_start_handler(CU_TestStartMessageHandler pTestStartHandler)
198 {
199 f_pTestStartMessageHandler = pTestStartHandler;
200 }
201
202 /*------------------------------------------------------------------------*/
CU_set_test_complete_handler(CU_TestCompleteMessageHandler pTestCompleteHandler)203 void CU_set_test_complete_handler(CU_TestCompleteMessageHandler pTestCompleteHandler)
204 {
205 f_pTestCompleteMessageHandler = pTestCompleteHandler;
206 }
207
208 /*------------------------------------------------------------------------*/
CU_set_suite_complete_handler(CU_SuiteCompleteMessageHandler pSuiteCompleteHandler)209 void CU_set_suite_complete_handler(CU_SuiteCompleteMessageHandler pSuiteCompleteHandler)
210 {
211 f_pSuiteCompleteMessageHandler = pSuiteCompleteHandler;
212 }
213
214 /*------------------------------------------------------------------------*/
CU_set_all_test_complete_handler(CU_AllTestsCompleteMessageHandler pAllTestsCompleteHandler)215 void CU_set_all_test_complete_handler(CU_AllTestsCompleteMessageHandler pAllTestsCompleteHandler)
216 {
217 f_pAllTestsCompleteMessageHandler = pAllTestsCompleteHandler;
218 }
219
220 /*------------------------------------------------------------------------*/
CU_set_suite_init_failure_handler(CU_SuiteInitFailureMessageHandler pSuiteInitFailureHandler)221 void CU_set_suite_init_failure_handler(CU_SuiteInitFailureMessageHandler pSuiteInitFailureHandler)
222 {
223 f_pSuiteInitFailureMessageHandler = pSuiteInitFailureHandler;
224 }
225
226 /*------------------------------------------------------------------------*/
CU_set_suite_cleanup_failure_handler(CU_SuiteCleanupFailureMessageHandler pSuiteCleanupFailureHandler)227 void CU_set_suite_cleanup_failure_handler(CU_SuiteCleanupFailureMessageHandler pSuiteCleanupFailureHandler)
228 {
229 f_pSuiteCleanupFailureMessageHandler = pSuiteCleanupFailureHandler;
230 }
231
232 /*------------------------------------------------------------------------*/
CU_get_suite_start_handler(void)233 CU_SuiteStartMessageHandler CU_get_suite_start_handler(void)
234 {
235 return f_pSuiteStartMessageHandler;
236 }
237
238 /*------------------------------------------------------------------------*/
CU_get_test_start_handler(void)239 CU_TestStartMessageHandler CU_get_test_start_handler(void)
240 {
241 return f_pTestStartMessageHandler;
242 }
243
244 /*------------------------------------------------------------------------*/
CU_get_test_complete_handler(void)245 CU_TestCompleteMessageHandler CU_get_test_complete_handler(void)
246 {
247 return f_pTestCompleteMessageHandler;
248 }
249
250 /*------------------------------------------------------------------------*/
CU_get_suite_complete_handler(void)251 CU_SuiteCompleteMessageHandler CU_get_suite_complete_handler(void)
252 {
253 return f_pSuiteCompleteMessageHandler;
254 }
255
256 /*------------------------------------------------------------------------*/
CU_get_all_test_complete_handler(void)257 CU_AllTestsCompleteMessageHandler CU_get_all_test_complete_handler(void)
258 {
259 return f_pAllTestsCompleteMessageHandler;
260 }
261
262 /*------------------------------------------------------------------------*/
CU_get_suite_init_failure_handler(void)263 CU_SuiteInitFailureMessageHandler CU_get_suite_init_failure_handler(void)
264 {
265 return f_pSuiteInitFailureMessageHandler;
266 }
267
268 /*------------------------------------------------------------------------*/
CU_get_suite_cleanup_failure_handler(void)269 CU_SuiteCleanupFailureMessageHandler CU_get_suite_cleanup_failure_handler(void)
270 {
271 return f_pSuiteCleanupFailureMessageHandler;
272 }
273
274 /*------------------------------------------------------------------------*/
CU_get_number_of_suites_run(void)275 unsigned int CU_get_number_of_suites_run(void)
276 {
277 return f_run_summary.nSuitesRun;
278 }
279
280 /*------------------------------------------------------------------------*/
CU_get_number_of_suites_failed(void)281 unsigned int CU_get_number_of_suites_failed(void)
282 {
283 return f_run_summary.nSuitesFailed;
284 }
285
286 /*------------------------------------------------------------------------*/
CU_get_number_of_suites_inactive(void)287 unsigned int CU_get_number_of_suites_inactive(void)
288 {
289 return f_run_summary.nSuitesInactive;
290 }
291
292 /*------------------------------------------------------------------------*/
CU_get_number_of_tests_run(void)293 unsigned int CU_get_number_of_tests_run(void)
294 {
295 return f_run_summary.nTestsRun;
296 }
297
298 /*------------------------------------------------------------------------*/
CU_get_number_of_tests_failed(void)299 unsigned int CU_get_number_of_tests_failed(void)
300 {
301 return f_run_summary.nTestsFailed;
302 }
303
304 /*------------------------------------------------------------------------*/
CU_get_number_of_tests_inactive(void)305 unsigned int CU_get_number_of_tests_inactive(void)
306 {
307 return f_run_summary.nTestsInactive;
308 }
309
310 /*------------------------------------------------------------------------*/
CU_get_number_of_asserts(void)311 unsigned int CU_get_number_of_asserts(void)
312 {
313 return f_run_summary.nAsserts;
314 }
315
316 /*------------------------------------------------------------------------*/
CU_get_number_of_successes(void)317 unsigned int CU_get_number_of_successes(void)
318 {
319 return (f_run_summary.nAsserts - f_run_summary.nAssertsFailed);
320 }
321
322 /*------------------------------------------------------------------------*/
CU_get_number_of_failures(void)323 unsigned int CU_get_number_of_failures(void)
324 {
325 return f_run_summary.nAssertsFailed;
326 }
327
328 /*------------------------------------------------------------------------*/
CU_get_number_of_failure_records(void)329 unsigned int CU_get_number_of_failure_records(void)
330 {
331 return f_run_summary.nFailureRecords;
332 }
333
334 /*------------------------------------------------------------------------*/
CU_get_elapsed_time(void)335 double CU_get_elapsed_time(void)
336 {
337 if (CU_TRUE == f_bTestIsRunning) {
338 return ((double)time(0) - (double)f_start_time);
339 }
340 else {
341 return f_run_summary.ElapsedTime;
342 }
343 }
344
345 /*------------------------------------------------------------------------*/
CU_get_failure_list(void)346 CU_pFailureRecord CU_get_failure_list(void)
347 {
348 return f_failure_list;
349 }
350
351 /*------------------------------------------------------------------------*/
CU_get_run_summary(void)352 CU_pRunSummary CU_get_run_summary(void)
353 {
354 return &f_run_summary;
355 }
356
357 /*------------------------------------------------------------------------*/
CU_run_all_tests(void)358 CU_ErrorCode CU_run_all_tests(void)
359 {
360 CU_pTestRegistry pRegistry = CU_get_registry();
361 CU_pSuite pSuite = NULL;
362 CU_ErrorCode result = CUE_SUCCESS;
363 CU_ErrorCode result2;
364
365 /* Clear results from the previous run */
366 clear_previous_results(&f_run_summary, &f_failure_list);
367
368 if (NULL == pRegistry) {
369 result = CUE_NOREGISTRY;
370 }
371 else {
372 /* test run is starting - set flag */
373 f_bTestIsRunning = CU_TRUE;
374 f_start_time = time(0);
375
376 pSuite = pRegistry->pSuite;
377 while ((NULL != pSuite) && ((CUE_SUCCESS == result) || (CU_get_error_action() == CUEA_IGNORE))) {
378 result2 = run_single_suite(pSuite, &f_run_summary);
379 result = (CUE_SUCCESS == result) ? result2 : result; /* result = 1st error encountered */
380 pSuite = pSuite->pNext;
381 }
382
383 /* test run is complete - clear flag */
384 f_bTestIsRunning = CU_FALSE;
385 f_run_summary.ElapsedTime = ((double)time(0) - (double)f_start_time);
386
387 if (NULL != f_pAllTestsCompleteMessageHandler) {
388 (*f_pAllTestsCompleteMessageHandler)(f_failure_list);
389 }
390 }
391
392 CU_set_error(result);
393 return result;
394 }
395
396 /*------------------------------------------------------------------------*/
CU_run_suite(CU_pSuite pSuite)397 CU_ErrorCode CU_run_suite(CU_pSuite pSuite)
398 {
399 CU_ErrorCode result = CUE_SUCCESS;
400
401 /* Clear results from the previous run */
402 clear_previous_results(&f_run_summary, &f_failure_list);
403
404 if (NULL == pSuite) {
405 result = CUE_NOSUITE;
406 }
407 else {
408 /* test run is starting - set flag */
409 f_bTestIsRunning = CU_TRUE;
410 f_start_time = time(0);
411
412 result = run_single_suite(pSuite, &f_run_summary);
413
414 /* test run is complete - clear flag */
415 f_bTestIsRunning = CU_FALSE;
416 f_run_summary.ElapsedTime = ((double)time(0) - (double)f_start_time);
417
418 /* run handler for overall completion, if any */
419 if (NULL != f_pAllTestsCompleteMessageHandler) {
420 (*f_pAllTestsCompleteMessageHandler)(f_failure_list);
421 }
422 }
423
424 CU_set_error(result);
425 return result;
426 }
427
428 /*------------------------------------------------------------------------*/
CU_run_test(CU_pSuite pSuite,CU_pTest pTest)429 CU_ErrorCode CU_run_test(CU_pSuite pSuite, CU_pTest pTest)
430 {
431 CU_ErrorCode result = CUE_SUCCESS;
432 CU_ErrorCode result2;
433
434 /* Clear results from the previous run */
435 clear_previous_results(&f_run_summary, &f_failure_list);
436
437 if (NULL == pSuite) {
438 result = CUE_NOSUITE;
439 }
440 else if (NULL == pTest) {
441 result = CUE_NOTEST;
442 }
443 else if (CU_FALSE == pSuite->fActive) {
444 f_run_summary.nSuitesInactive++;
445 if (CU_FALSE != f_failure_on_inactive) {
446 add_failure(&f_failure_list, &f_run_summary, CUF_SuiteInactive,
447 0, _("Suite inactive"), _("BCUnit System"), pSuite, NULL);
448 }
449 result = CUE_SUITE_INACTIVE;
450 }
451 else if ((NULL == pTest->pName) || (NULL == CU_get_test_by_name(pTest->pName, pSuite))) {
452 result = CUE_TEST_NOT_IN_SUITE;
453 }
454 else {
455 /* test run is starting - set flag */
456 f_bTestIsRunning = CU_TRUE;
457 f_start_time = time(0);
458
459 f_pCurTest = NULL;
460 f_pCurSuite = pSuite;
461
462 pSuite->uiNumberOfTestsFailed = 0;
463 pSuite->uiNumberOfTestsSuccess = 0;
464
465 /* run handler for suite start, if any */
466 if (NULL != f_pSuiteStartMessageHandler) {
467 (*f_pSuiteStartMessageHandler)(pSuite);
468 }
469
470 /* run the suite initialization function, if any */
471 if ((NULL != pSuite->pInitializeFunc) && (0 != (*pSuite->pInitializeFunc)())) {
472 /* init function had an error - call handler, if any */
473 if (NULL != f_pSuiteInitFailureMessageHandler) {
474 (*f_pSuiteInitFailureMessageHandler)(pSuite);
475 }
476 f_run_summary.nSuitesFailed++;
477 add_failure(&f_failure_list, &f_run_summary, CUF_SuiteInitFailed, 0,
478 _("Suite Initialization failed - Suite Skipped"),
479 _("BCUnit System"), pSuite, NULL);
480 result = CUE_SINIT_FAILED;
481 }
482 /* reach here if no suite initialization, or if it succeeded */
483 else {
484 result2 = run_single_test(pTest, &f_run_summary);
485 result = (CUE_SUCCESS == result) ? result2 : result;
486
487 /* run the suite cleanup function, if any */
488 if ((NULL != pSuite->pCleanupFunc) && (0 != (*pSuite->pCleanupFunc)())) {
489 /* cleanup function had an error - call handler, if any */
490 if (NULL != f_pSuiteCleanupFailureMessageHandler) {
491 (*f_pSuiteCleanupFailureMessageHandler)(pSuite);
492 }
493 f_run_summary.nSuitesFailed++;
494 add_failure(&f_failure_list, &f_run_summary, CUF_SuiteCleanupFailed,
495 0, _("Suite cleanup failed."), _("BCUnit System"), pSuite, NULL);
496 result = (CUE_SUCCESS == result) ? CUE_SCLEAN_FAILED : result;
497 }
498 }
499
500 /* run handler for suite completion, if any */
501 if (NULL != f_pSuiteCompleteMessageHandler) {
502 (*f_pSuiteCompleteMessageHandler)(pSuite, NULL);
503 }
504
505 /* test run is complete - clear flag */
506 f_bTestIsRunning = CU_FALSE;
507 f_run_summary.ElapsedTime = ((double)time(0) - (double)f_start_time);
508
509 /* run handler for overall completion, if any */
510 if (NULL != f_pAllTestsCompleteMessageHandler) {
511 (*f_pAllTestsCompleteMessageHandler)(f_failure_list);
512 }
513
514 f_pCurSuite = NULL;
515 }
516
517 CU_set_error(result);
518 return result;
519 }
520
521 /*------------------------------------------------------------------------*/
CU_clear_previous_results(void)522 void CU_clear_previous_results(void)
523 {
524 clear_previous_results(&f_run_summary, &f_failure_list);
525 }
526
527 /*------------------------------------------------------------------------*/
CU_get_current_suite(void)528 CU_pSuite CU_get_current_suite(void)
529 {
530 return f_pCurSuite;
531 }
532
533 /*------------------------------------------------------------------------*/
CU_get_current_test(void)534 CU_pTest CU_get_current_test(void)
535 {
536 return f_pCurTest;
537 }
538
539 /*------------------------------------------------------------------------*/
CU_is_test_running(void)540 CU_BOOL CU_is_test_running(void)
541 {
542 return f_bTestIsRunning;
543 }
544
545 /*------------------------------------------------------------------------*/
CU_set_fail_on_inactive(CU_BOOL new_inactive)546 CU_EXPORT void CU_set_fail_on_inactive(CU_BOOL new_inactive)
547 {
548 f_failure_on_inactive = new_inactive;
549 }
550
551 /*------------------------------------------------------------------------*/
CU_get_fail_on_inactive(void)552 CU_EXPORT CU_BOOL CU_get_fail_on_inactive(void)
553 {
554 return f_failure_on_inactive;
555 }
556
557 /*------------------------------------------------------------------------*/
CU_print_run_results(FILE * file)558 CU_EXPORT void CU_print_run_results(FILE *file)
559 {
560 char *summary_string;
561
562 assert(NULL != file);
563 summary_string = CU_get_run_results_string();
564 if (NULL != summary_string) {
565 fprintf(file, "%s", summary_string);
566 CU_FREE(summary_string);
567 }
568 else {
569 fprintf(file, _("An error occurred printing the run results."));
570 }
571 }
572
573 /*------------------------------------------------------------------------*/
CU_get_run_results_string(void)574 CU_EXPORT char * CU_get_run_results_string(void)
575
576 {
577 CU_pRunSummary pRunSummary = &f_run_summary;
578 CU_pTestRegistry pRegistry = CU_get_registry();
579 int width[9];
580 size_t len;
581 char *result;
582
583 assert(NULL != pRunSummary);
584 assert(NULL != pRegistry);
585
586 width[0] = strlen(_("Run Summary:"));
587 width[1] = CU_MAX(6,
588 CU_MAX(strlen(_("Type")),
589 CU_MAX(strlen(_("suites")),
590 CU_MAX(strlen(_("tests")),
591 strlen(_("asserts")))))) + 1;
592 width[2] = CU_MAX(6,
593 CU_MAX(strlen(_("Total")),
594 CU_MAX(CU_number_width(pRegistry->uiNumberOfSuites),
595 CU_MAX(CU_number_width(pRegistry->uiNumberOfTests),
596 CU_number_width(pRunSummary->nAsserts))))) + 1;
597 width[3] = CU_MAX(6,
598 CU_MAX(strlen(_("Ran")),
599 CU_MAX(CU_number_width(pRunSummary->nSuitesRun),
600 CU_MAX(CU_number_width(pRunSummary->nTestsRun),
601 CU_number_width(pRunSummary->nAsserts))))) + 1;
602 width[4] = CU_MAX(6,
603 CU_MAX(strlen(_("Passed")),
604 CU_MAX(strlen(_("n/a")),
605 CU_MAX(CU_number_width(pRunSummary->nTestsRun - pRunSummary->nTestsFailed),
606 CU_number_width(pRunSummary->nAsserts - pRunSummary->nAssertsFailed))))) + 1;
607 width[5] = CU_MAX(6,
608 CU_MAX(strlen(_("Failed")),
609 CU_MAX(CU_number_width(pRunSummary->nSuitesFailed),
610 CU_MAX(CU_number_width(pRunSummary->nTestsFailed),
611 CU_number_width(pRunSummary->nAssertsFailed))))) + 1;
612 width[6] = CU_MAX(6,
613 CU_MAX(strlen(_("Inactive")),
614 CU_MAX(CU_number_width(pRunSummary->nSuitesInactive),
615 CU_MAX(CU_number_width(pRunSummary->nTestsInactive),
616 strlen(_("n/a")))))) + 1;
617
618 width[7] = strlen(_("Elapsed time = "));
619 width[8] = strlen(_(" seconds"));
620
621 len = 13 + 4*(width[0] + width[1] + width[2] + width[3] + width[4] + width[5] + width[6]) + width[7] + width[8] + 1;
622 result = (char *)CU_MALLOC(len);
623
624 if (NULL != result) {
625 snprintf(result, len, "%*s%*s%*s%*s%*s%*s%*s\n" /* if you change this, be sure */
626 "%*s%*s%*u%*u%*s%*u%*u\n" /* to change the calculation of */
627 "%*s%*s%*u%*u%*u%*u%*u\n" /* len above! */
628 "%*s%*s%*u%*u%*u%*u%*s\n\n"
629 "%*s%d%*s",
630 (int)width[0], _("Run Summary:"),
631 (int)width[1], _("Type"),
632 (int)width[2], _("Total"),
633 (int)width[3], _("Ran"),
634 (int)width[4], _("Passed"),
635 (int)width[5], _("Failed"),
636 (int)width[6], _("Inactive"),
637 (int)width[0], " ",
638 (int)width[1], _("suites"),
639 (int)width[2], pRegistry->uiNumberOfSuites,
640 (int)width[3], pRunSummary->nSuitesRun,
641 (int)width[4], _("n/a"),
642 (int)width[5], pRunSummary->nSuitesFailed,
643 (int)width[6], pRunSummary->nSuitesInactive,
644 (int)width[0], " ",
645 (int)width[1], _("tests"),
646 (int)width[2], pRegistry->uiNumberOfTests,
647 (int)width[3], pRunSummary->nTestsRun,
648 (int)width[4], pRunSummary->nTestsRun - pRunSummary->nTestsFailed,
649 (int)width[5], pRunSummary->nTestsFailed,
650 (int)width[6], pRunSummary->nTestsInactive,
651 (int)width[0], " ",
652 (int)width[1], _("asserts"),
653 (int)width[2], pRunSummary->nAsserts,
654 (int)width[3], pRunSummary->nAsserts,
655 (int)width[4], pRunSummary->nAsserts - pRunSummary->nAssertsFailed,
656 (int)width[5], pRunSummary->nAssertsFailed,
657 (int)width[6], _("n/a"),
658 (int)width[7], _("Elapsed time = "), (int)CU_get_elapsed_time(), /* makes sure time is updated */
659 (int)width[8], _(" seconds")
660 );
661 result[len-1] = '\0';
662 }
663 return result;
664 }
665
666 /*=================================================================
667 * Static Function Definitions
668 *=================================================================*/
669 /**
670 * Records a runtime failure.
671 * This function is called whenever a runtime failure occurs.
672 * This includes user assertion failures, suite initialization and
673 * cleanup failures, and inactive suites/tests when set as failures.
674 * This function records the details of the failure in a new
675 * failure record in the linked list of runtime failures.
676 *
677 * @param ppFailure Pointer to head of linked list of failure
678 * records to append with new failure record.
679 * If it points to a NULL pointer, it will be set
680 * to point to the new failure record.
681 * @param pRunSummary Pointer to CU_RunSummary keeping track of failure records
682 * (ignored if NULL).
683 * @param type Type of failure.
684 * @param uiLineNumber Line number of the failure, if applicable.
685 * @param szCondition Description of failure condition
686 * @param szFileName Name of file, if applicable
687 * @param pSuite The suite being run at time of failure
688 * @param pTest The test being run at time of failure
689 */
add_failure(CU_pFailureRecord * ppFailure,CU_pRunSummary pRunSummary,CU_FailureType type,unsigned int uiLineNumber,const char * szCondition,const char * szFileName,CU_pSuite pSuite,CU_pTest pTest)690 static void add_failure(CU_pFailureRecord* ppFailure,
691 CU_pRunSummary pRunSummary,
692 CU_FailureType type,
693 unsigned int uiLineNumber,
694 const char *szCondition,
695 const char *szFileName,
696 CU_pSuite pSuite,
697 CU_pTest pTest)
698 {
699 CU_pFailureRecord pFailureNew = NULL;
700 CU_pFailureRecord pTemp = NULL;
701
702 assert(NULL != ppFailure);
703
704 pFailureNew = (CU_pFailureRecord)CU_MALLOC(sizeof(CU_FailureRecord));
705
706 if (NULL == pFailureNew) {
707 return;
708 }
709
710 pFailureNew->strFileName = NULL;
711 pFailureNew->strCondition = NULL;
712 if (NULL != szFileName) {
713 pFailureNew->strFileName = (char*)CU_MALLOC(strlen(szFileName) + 1);
714 if(NULL == pFailureNew->strFileName) {
715 CU_FREE(pFailureNew);
716 return;
717 }
718 strcpy(pFailureNew->strFileName, szFileName);
719 }
720
721 if (NULL != szCondition) {
722 pFailureNew->strCondition = (char*)CU_MALLOC(strlen(szCondition) + 1);
723 if (NULL == pFailureNew->strCondition) {
724 if(NULL != pFailureNew->strFileName) {
725 CU_FREE(pFailureNew->strFileName);
726 }
727 CU_FREE(pFailureNew);
728 return;
729 }
730 strcpy(pFailureNew->strCondition, szCondition);
731 }
732
733 pFailureNew->type = type;
734 pFailureNew->uiLineNumber = uiLineNumber;
735 pFailureNew->pTest = pTest;
736 pFailureNew->pSuite = pSuite;
737 pFailureNew->pNext = NULL;
738 pFailureNew->pPrev = NULL;
739
740 pTemp = *ppFailure;
741 if (NULL != pTemp) {
742 while (NULL != pTemp->pNext) {
743 pTemp = pTemp->pNext;
744 }
745 pTemp->pNext = pFailureNew;
746 pFailureNew->pPrev = pTemp;
747 }
748 else {
749 *ppFailure = pFailureNew;
750 }
751
752 if (NULL != pRunSummary) {
753 ++(pRunSummary->nFailureRecords);
754 }
755 f_last_failure = pFailureNew;
756 }
757
758 /*
759 * Local function for result set initialization/cleanup.
760 */
761 /*------------------------------------------------------------------------*/
762 /**
763 * Initializes the run summary information in the specified structure.
764 * Resets the run counts to zero, and calls cleanup_failure_list() if
765 * failures were recorded by the last test run. Calling this function
766 * multiple times, while inefficient, will not cause an error condition.
767 *
768 * @param pRunSummary CU_RunSummary to initialize (non-NULL).
769 * @param ppFailure The failure record to clean (non-NULL).
770 * @see CU_clear_previous_results()
771 */
clear_previous_results(CU_pRunSummary pRunSummary,CU_pFailureRecord * ppFailure)772 static void clear_previous_results(CU_pRunSummary pRunSummary, CU_pFailureRecord* ppFailure)
773 {
774 assert(NULL != pRunSummary);
775 assert(NULL != ppFailure);
776
777 pRunSummary->nSuitesRun = 0;
778 pRunSummary->nSuitesFailed = 0;
779 pRunSummary->nSuitesInactive = 0;
780 pRunSummary->nTestsRun = 0;
781 pRunSummary->nTestsFailed = 0;
782 pRunSummary->nTestsInactive = 0;
783 pRunSummary->nAsserts = 0;
784 pRunSummary->nAssertsFailed = 0;
785 pRunSummary->nFailureRecords = 0;
786 pRunSummary->ElapsedTime = 0.0;
787
788 if (NULL != *ppFailure) {
789 cleanup_failure_list(ppFailure);
790 }
791
792 f_last_failure = NULL;
793 }
794
795 /*------------------------------------------------------------------------*/
796 /**
797 * Frees all memory allocated for the linked list of test failure
798 * records. pFailure is reset to NULL after its list is cleaned up.
799 *
800 * @param ppFailure Pointer to head of linked list of
801 * CU_pFailureRecords to clean.
802 * @see CU_clear_previous_results()
803 */
cleanup_failure_list(CU_pFailureRecord * ppFailure)804 static void cleanup_failure_list(CU_pFailureRecord* ppFailure)
805 {
806 CU_pFailureRecord pCurFailure = NULL;
807 CU_pFailureRecord pNextFailure = NULL;
808
809 pCurFailure = *ppFailure;
810
811 while (NULL != pCurFailure) {
812
813 if (NULL != pCurFailure->strCondition) {
814 CU_FREE(pCurFailure->strCondition);
815 }
816
817 if (NULL != pCurFailure->strFileName) {
818 CU_FREE(pCurFailure->strFileName);
819 }
820
821 pNextFailure = pCurFailure->pNext;
822 CU_FREE(pCurFailure);
823 pCurFailure = pNextFailure;
824 }
825
826 *ppFailure = NULL;
827 }
828
829 /*------------------------------------------------------------------------*/
830 /**
831 * Runs all tests in a specified suite.
832 * Internal function to run all tests in a suite. The suite need
833 * not be registered in the test registry to be run. Only
834 * suites having their fActive flags set CU_TRUE will actually be
835 * run. If the BCUnit framework is in an error condition after
836 * running a test, no additional tests are run.
837 *
838 * @param pSuite The suite containing the test (non-NULL).
839 * @param pRunSummary The CU_RunSummary to receive the results (non-NULL).
840 * @return A CU_ErrorCode indicating the status of the run.
841 * @see CU_run_suite() for public interface function.
842 * @see CU_run_all_tests() for running all suites.
843 */
run_single_suite(CU_pSuite pSuite,CU_pRunSummary pRunSummary)844 static CU_ErrorCode run_single_suite(CU_pSuite pSuite, CU_pRunSummary pRunSummary)
845 {
846 CU_pTest pTest = NULL;
847 unsigned int nStartFailures;
848 /* keep track of the last failure BEFORE running the test */
849 CU_pFailureRecord pLastFailure = f_last_failure;
850 CU_ErrorCode result = CUE_SUCCESS;
851 CU_ErrorCode result2;
852
853 assert(NULL != pSuite);
854 assert(NULL != pRunSummary);
855
856 nStartFailures = pRunSummary->nFailureRecords;
857
858 f_pCurTest = NULL;
859 f_pCurSuite = pSuite;
860
861 pSuite->uiNumberOfTestsFailed = 0;
862 pSuite->uiNumberOfTestsSuccess = 0;
863
864 /* run handler for suite start, if any */
865 if (NULL != f_pSuiteStartMessageHandler) {
866 (*f_pSuiteStartMessageHandler)(pSuite);
867 }
868
869 /* run suite if it's active */
870 if (CU_FALSE != pSuite->fActive) {
871
872 /* run the suite initialization function, if any */
873 if ((NULL != pSuite->pInitializeFunc) && (0 != (*pSuite->pInitializeFunc)())) {
874 /* init function had an error - call handler, if any */
875 if (NULL != f_pSuiteInitFailureMessageHandler) {
876 (*f_pSuiteInitFailureMessageHandler)(pSuite);
877 }
878 pRunSummary->nSuitesFailed++;
879 add_failure(&f_failure_list, &f_run_summary, CUF_SuiteInitFailed, 0,
880 _("Suite Initialization failed - Suite Skipped"),
881 _("BCUnit System"), pSuite, NULL);
882 result = CUE_SINIT_FAILED;
883 }
884
885 /* reach here if no suite initialization, or if it succeeded */
886 else {
887 pTest = pSuite->pTest;
888 while ((NULL != pTest) && ((CUE_SUCCESS == result) || (CU_get_error_action() == CUEA_IGNORE))) {
889 if (CU_FALSE != pTest->fActive) {
890 result2 = run_single_test(pTest, pRunSummary);
891 result = (CUE_SUCCESS == result) ? result2 : result;
892 }
893 else {
894 f_run_summary.nTestsInactive++;
895 if (CU_FALSE != f_failure_on_inactive) {
896 add_failure(&f_failure_list, &f_run_summary, CUF_TestInactive,
897 0, _("Test inactive"), _("BCUnit System"), pSuite, pTest);
898 result = CUE_TEST_INACTIVE;
899 }
900 }
901 pTest = pTest->pNext;
902
903 if (CUE_SUCCESS == result) {
904 pSuite->uiNumberOfTestsFailed++;
905 }
906 else {
907 pSuite->uiNumberOfTestsSuccess++;
908 }
909 }
910 pRunSummary->nSuitesRun++;
911
912 /* call the suite cleanup function, if any */
913 if ((NULL != pSuite->pCleanupFunc) && (0 != (*pSuite->pCleanupFunc)())) {
914 if (NULL != f_pSuiteCleanupFailureMessageHandler) {
915 (*f_pSuiteCleanupFailureMessageHandler)(pSuite);
916 }
917 pRunSummary->nSuitesFailed++;
918 add_failure(&f_failure_list, &f_run_summary, CUF_SuiteCleanupFailed,
919 0, _("Suite cleanup failed."), _("BCUnit System"), pSuite, NULL);
920 result = (CUE_SUCCESS == result) ? CUE_SCLEAN_FAILED : result;
921 }
922 }
923 }
924
925 /* otherwise record inactive suite and failure if appropriate */
926 else {
927 f_run_summary.nSuitesInactive++;
928 if (CU_FALSE != f_failure_on_inactive) {
929 add_failure(&f_failure_list, &f_run_summary, CUF_SuiteInactive,
930 0, _("Suite inactive"), _("BCUnit System"), pSuite, NULL);
931 result = CUE_SUITE_INACTIVE;
932 }
933 }
934
935 /* if additional failures have occurred... */
936 if (pRunSummary->nFailureRecords > nStartFailures) {
937 if (NULL != pLastFailure) {
938 pLastFailure = pLastFailure->pNext; /* was a previous failure, so go to next one */
939 }
940 else {
941 pLastFailure = f_failure_list; /* no previous failure - go to 1st one */
942 }
943 }
944 else {
945 pLastFailure = NULL; /* no additional failure - set to NULL */
946 }
947
948 /* run handler for suite completion, if any */
949 if (NULL != f_pSuiteCompleteMessageHandler) {
950 (*f_pSuiteCompleteMessageHandler)(pSuite, pLastFailure);
951 }
952
953 f_pCurSuite = NULL;
954 return result;
955 }
956
957 /*------------------------------------------------------------------------*/
958 /**
959 * Runs a specific test.
960 * Internal function to run a test case. This includes calling
961 * any handler to be run before executing the test, running the
962 * test's function (if any), and calling any handler to be run
963 * after executing a test. Suite initialization and cleanup functions
964 * are not called by this function. A current suite must be set and
965 * active (checked by assertion).
966 *
967 * @param pTest The test to be run (non-NULL).
968 * @param pRunSummary The CU_RunSummary to receive the results (non-NULL).
969 * @return A CU_ErrorCode indicating the status of the run.
970 * @see CU_run_test() for public interface function.
971 * @see CU_run_all_tests() for running all suites.
972 */
run_single_test(CU_pTest pTest,CU_pRunSummary pRunSummary)973 static CU_ErrorCode run_single_test(CU_pTest pTest, CU_pRunSummary pRunSummary)
974 {
975 volatile unsigned int nStartFailures;
976 /* keep track of the last failure BEFORE running the test */
977 volatile CU_pFailureRecord pLastFailure = f_last_failure;
978 jmp_buf buf;
979 CU_ErrorCode result = CUE_SUCCESS;
980
981 assert(NULL != f_pCurSuite);
982 assert(CU_FALSE != f_pCurSuite->fActive);
983 assert(NULL != pTest);
984 assert(NULL != pRunSummary);
985
986 nStartFailures = pRunSummary->nFailureRecords;
987
988 f_pCurTest = pTest;
989
990 if (NULL != f_pTestStartMessageHandler) {
991 (*f_pTestStartMessageHandler)(f_pCurTest, f_pCurSuite);
992 }
993
994 /* run test if it is active */
995 if (CU_FALSE != pTest->fActive) {
996
997 if (NULL != f_pCurSuite->pSetUpFunc) {
998 (*f_pCurSuite->pSetUpFunc)();
999 }
1000
1001 /* set jmp_buf and run test */
1002 pTest->pJumpBuf = &buf;
1003 if (0 == setjmp(buf)) {
1004 if (NULL != pTest->pTestFunc) {
1005 (*pTest->pTestFunc)();
1006 }
1007 }
1008
1009 if (NULL != f_pCurSuite->pTearDownFunc) {
1010 (*f_pCurSuite->pTearDownFunc)();
1011 }
1012
1013 pRunSummary->nTestsRun++;
1014 }
1015 else {
1016 f_run_summary.nTestsInactive++;
1017 if (CU_FALSE != f_failure_on_inactive) {
1018 add_failure(&f_failure_list, &f_run_summary, CUF_TestInactive,
1019 0, _("Test inactive"), _("BCUnit System"), f_pCurSuite, f_pCurTest);
1020 }
1021 result = CUE_TEST_INACTIVE;
1022 }
1023
1024 /* if additional failures have occurred... */
1025 if (pRunSummary->nFailureRecords > nStartFailures) {
1026 pRunSummary->nTestsFailed++;
1027 if (NULL != pLastFailure) {
1028 pLastFailure = pLastFailure->pNext; /* was a previous failure, so go to next one */
1029 }
1030 else {
1031 pLastFailure = f_failure_list; /* no previous failure - go to 1st one */
1032 }
1033 }
1034 else {
1035 pLastFailure = NULL; /* no additional failure - set to NULL */
1036 }
1037
1038 if (NULL != f_pTestCompleteMessageHandler) {
1039 (*f_pTestCompleteMessageHandler)(f_pCurTest, f_pCurSuite, pLastFailure);
1040 }
1041
1042 pTest->pJumpBuf = NULL;
1043 f_pCurTest = NULL;
1044
1045 return result;
1046 }
1047
1048 /** @} */
1049
1050 #ifdef BCUNIT_BUILD_TESTS
1051 #include "test_bcunit.h"
1052
1053 /** Types of framework events tracked by test system. */
1054 typedef enum TET {
1055 SUITE_START = 1,
1056 TEST_START,
1057 TEST_COMPLETE,
1058 SUITE_COMPLETE,
1059 ALL_TESTS_COMPLETE,
1060 SUITE_INIT_FAILED,
1061 SUITE_CLEANUP_FAILED
1062 } TestEventType;
1063
1064 /** Test event structure for recording details of a framework event. */
1065 typedef struct TE {
1066 TestEventType type;
1067 CU_pSuite pSuite;
1068 CU_pTest pTest;
1069 CU_pFailureRecord pFailure;
1070 struct TE * pNext;
1071 } TestEvent, * pTestEvent;
1072
1073 static int f_nTestEvents = 0;
1074 static pTestEvent f_pFirstEvent = NULL;
1075
1076 /** Creates & stores a test event record having the specified details. */
add_test_event(TestEventType type,CU_pSuite psuite,CU_pTest ptest,CU_pFailureRecord pfailure)1077 static void add_test_event(TestEventType type, CU_pSuite psuite,
1078 CU_pTest ptest, CU_pFailureRecord pfailure)
1079 {
1080 pTestEvent pNewEvent = (pTestEvent)malloc(sizeof(TestEvent));
1081 pTestEvent pNextEvent = f_pFirstEvent;
1082
1083 if (NULL == pNewEvent) {
1084 fprintf(stderr, "Memory allocation failed in add_test_event().");
1085 exit(1);
1086 }
1087
1088 pNewEvent->type = type;
1089 pNewEvent->pSuite = psuite;
1090 pNewEvent->pTest = ptest;
1091 pNewEvent->pFailure = pfailure;
1092 pNewEvent->pNext = NULL;
1093
1094 if (pNextEvent) {
1095 while (pNextEvent->pNext) {
1096 pNextEvent = pNextEvent->pNext;
1097 }
1098 pNextEvent->pNext = pNewEvent;
1099 }
1100 else {
1101 f_pFirstEvent = pNewEvent;
1102 }
1103 ++f_nTestEvents;
1104 }
1105
1106 /** Deallocates all test event data. */
clear_test_events(void)1107 static void clear_test_events(void)
1108 {
1109 pTestEvent pCurrentEvent = f_pFirstEvent;
1110 pTestEvent pNextEvent = NULL;
1111
1112 while (pCurrentEvent) {
1113 pNextEvent = pCurrentEvent->pNext;
1114 free(pCurrentEvent);
1115 pCurrentEvent = pNextEvent;
1116 }
1117
1118 f_pFirstEvent = NULL;
1119 f_nTestEvents = 0;
1120 }
1121
suite_start_handler(const CU_pSuite pSuite)1122 static void suite_start_handler(const CU_pSuite pSuite)
1123 {
1124 TEST(CU_is_test_running());
1125 TEST(pSuite == CU_get_current_suite());
1126 TEST(NULL == CU_get_current_test());
1127
1128 add_test_event(SUITE_START, pSuite, NULL, NULL);
1129 }
1130
test_start_handler(const CU_pTest pTest,const CU_pSuite pSuite)1131 static void test_start_handler(const CU_pTest pTest, const CU_pSuite pSuite)
1132 {
1133 TEST(CU_is_test_running());
1134 TEST(pSuite == CU_get_current_suite());
1135 TEST(pTest == CU_get_current_test());
1136
1137 add_test_event(TEST_START, pSuite, pTest, NULL);
1138 }
1139
test_complete_handler(const CU_pTest pTest,const CU_pSuite pSuite,const CU_pFailureRecord pFailure)1140 static void test_complete_handler(const CU_pTest pTest, const CU_pSuite pSuite,
1141 const CU_pFailureRecord pFailure)
1142 {
1143 TEST(CU_is_test_running());
1144 TEST(pSuite == CU_get_current_suite());
1145 TEST(pTest == CU_get_current_test());
1146
1147 add_test_event(TEST_COMPLETE, pSuite, pTest, pFailure);
1148 }
1149
suite_complete_handler(const CU_pSuite pSuite,const CU_pFailureRecord pFailure)1150 static void suite_complete_handler(const CU_pSuite pSuite,
1151 const CU_pFailureRecord pFailure)
1152 {
1153 TEST(CU_is_test_running());
1154 TEST(pSuite == CU_get_current_suite());
1155 TEST(NULL == CU_get_current_test());
1156
1157 add_test_event(SUITE_COMPLETE, pSuite, NULL, pFailure);
1158 }
1159
test_all_complete_handler(const CU_pFailureRecord pFailure)1160 static void test_all_complete_handler(const CU_pFailureRecord pFailure)
1161 {
1162 TEST(!CU_is_test_running());
1163
1164 add_test_event(ALL_TESTS_COMPLETE, NULL, NULL, pFailure);
1165 }
1166
suite_init_failure_handler(const CU_pSuite pSuite)1167 static void suite_init_failure_handler(const CU_pSuite pSuite)
1168 {
1169 TEST(CU_is_test_running());
1170 TEST(pSuite == CU_get_current_suite());
1171
1172 add_test_event(SUITE_INIT_FAILED, pSuite, NULL, NULL);
1173 }
1174
suite_cleanup_failure_handler(const CU_pSuite pSuite)1175 static void suite_cleanup_failure_handler(const CU_pSuite pSuite)
1176 {
1177 TEST(CU_is_test_running());
1178 TEST(pSuite == CU_get_current_suite());
1179
1180 add_test_event(SUITE_CLEANUP_FAILED, pSuite, NULL, NULL);
1181 }
1182
1183 /**
1184 * Centralize test result testing - we're going to do it a lot!
1185 * This is messy since we want to report the calling location upon failure.
1186 *
1187 * Via calling test functions tests:
1188 * CU_get_number_of_suites_run()
1189 * CU_get_number_of_suites_failed()
1190 * CU_get_number_of_tests_run()
1191 * CU_get_number_of_tests_failed()
1192 * CU_get_number_of_asserts()
1193 * CU_get_number_of_successes()
1194 * CU_get_number_of_failures()
1195 * CU_get_number_of_failure_records()
1196 * CU_get_run_summary()
1197 */
do_test_results(unsigned int nSuitesRun,unsigned int nSuitesFailed,unsigned int nSuitesInactive,unsigned int nTestsRun,unsigned int nTestsFailed,unsigned int nTestsInactive,unsigned int nAsserts,unsigned int nSuccesses,unsigned int nFailures,unsigned int nFailureRecords,const char * file,unsigned int line)1198 static void do_test_results(unsigned int nSuitesRun,
1199 unsigned int nSuitesFailed,
1200 unsigned int nSuitesInactive,
1201 unsigned int nTestsRun,
1202 unsigned int nTestsFailed,
1203 unsigned int nTestsInactive,
1204 unsigned int nAsserts,
1205 unsigned int nSuccesses,
1206 unsigned int nFailures,
1207 unsigned int nFailureRecords,
1208 const char *file,
1209 unsigned int line)
1210 {
1211 char msg[500];
1212 CU_pRunSummary pRunSummary = NULL;
1213
1214 if (nSuitesRun == CU_get_number_of_suites_run()) {
1215 PASS();
1216 } else {
1217 snprintf(msg, 499, "%u == CU_get_number_of_suites_run() (called from %s:%u)",
1218 nSuitesRun, file, line);
1219 msg[499] = '\0';
1220 FAIL(msg);
1221 }
1222
1223 if (nSuitesInactive == CU_get_number_of_suites_inactive()) {
1224 PASS();
1225 } else {
1226 snprintf(msg, 499, "%u == CU_get_number_of_suites_inactive() (called from %s:%u)",
1227 nSuitesInactive, file, line);
1228 msg[499] = '\0';
1229 FAIL(msg);
1230 }
1231
1232 if (nSuitesFailed == CU_get_number_of_suites_failed()) {
1233 PASS();
1234 } else {
1235 snprintf(msg, 499, "%u == CU_get_number_of_suites_failed() (called from %s:%u)",
1236 nSuitesFailed, file, line);
1237 msg[499] = '\0';
1238 FAIL(msg);
1239 }
1240
1241 if (nTestsRun == CU_get_number_of_tests_run()) {
1242 PASS();
1243 } else {
1244 snprintf(msg, 499, "%u == CU_get_number_of_tests_run() (called from %s:%u)",
1245 nTestsRun, file, line);
1246 msg[499] = '\0';
1247 FAIL(msg);
1248 }
1249
1250 if (nTestsFailed == CU_get_number_of_tests_failed()) {
1251 PASS();
1252 } else {
1253 snprintf(msg, 499, "%u == CU_get_number_of_tests_failed() (called from %s:%u)",
1254 nTestsFailed, file, line);
1255 msg[499] = '\0';
1256 FAIL(msg);
1257 }
1258
1259 if (nTestsInactive == CU_get_number_of_tests_inactive()) {
1260 PASS();
1261 } else {
1262 snprintf(msg, 499, "%u == CU_get_number_of_tests_inactive() (called from %s:%u)",
1263 nTestsInactive, file, line);
1264 msg[499] = '\0';
1265 FAIL(msg);
1266 }
1267
1268 if (nAsserts == CU_get_number_of_asserts()) {
1269 PASS();
1270 } else {
1271 snprintf(msg, 499, "%u == CU_get_number_of_asserts() (called from %s:%u)",
1272 nAsserts, file, line);
1273 msg[499] = '\0';
1274 FAIL(msg);
1275 }
1276
1277 if (nSuccesses == CU_get_number_of_successes()) {
1278 PASS();
1279 } else {
1280 snprintf(msg, 499, "%u == CU_get_number_of_successes() (called from %s:%u)",
1281 nSuccesses, file, line);
1282 msg[499] = '\0';
1283 FAIL(msg);
1284 }
1285
1286 if (nFailures == CU_get_number_of_failures()) {
1287 PASS();
1288 } else {
1289 snprintf(msg, 499, "%u == CU_get_number_of_failures() (called from %s:%u)",
1290 nFailures, file, line);
1291 msg[499] = '\0';
1292 FAIL(msg);
1293 }
1294
1295 if (nFailureRecords == CU_get_number_of_failure_records()) {
1296 PASS();
1297 } else {
1298 snprintf(msg, 499, "%u == CU_get_number_of_failure_records() (called from %s:%u)",
1299 nFailureRecords, file, line);
1300 msg[499] = '\0';
1301 FAIL(msg);
1302 }
1303
1304 pRunSummary = CU_get_run_summary();
1305
1306 if (pRunSummary->nSuitesRun == CU_get_number_of_suites_run()) {
1307 PASS();
1308 } else {
1309 snprintf(msg, 499, "%u == CU_get_number_of_suites_run() (called from %s:%u)",
1310 pRunSummary->nSuitesRun, file, line);
1311 msg[499] = '\0';
1312 FAIL(msg);
1313 }
1314
1315 if (pRunSummary->nSuitesFailed == CU_get_number_of_suites_failed()) {
1316 PASS();
1317 } else {
1318 snprintf(msg, 499, "%u == CU_get_number_of_suites_failed() (called from %s:%u)",
1319 pRunSummary->nSuitesFailed, file, line);
1320 msg[499] = '\0';
1321 FAIL(msg);
1322 }
1323
1324 if (pRunSummary->nTestsRun == CU_get_number_of_tests_run()) {
1325 PASS();
1326 } else {
1327 snprintf(msg, 499, "%u == CU_get_number_of_tests_run() (called from %s:%u)",
1328 pRunSummary->nTestsRun, file, line);
1329 msg[499] = '\0';
1330 FAIL(msg);
1331 }
1332
1333 if (pRunSummary->nTestsFailed == CU_get_number_of_tests_failed()) {
1334 PASS();
1335 } else {
1336 snprintf(msg, 499, "%u == CU_get_number_of_tests_failed() (called from %s:%u)",
1337 pRunSummary->nTestsFailed, file, line);
1338 msg[499] = '\0';
1339 FAIL(msg);
1340 }
1341
1342 if (pRunSummary->nAsserts == CU_get_number_of_asserts()) {
1343 PASS();
1344 } else {
1345 snprintf(msg, 499, "%u == CU_get_number_of_asserts() (called from %s:%u)",
1346 pRunSummary->nAsserts, file, line);
1347 msg[499] = '\0';
1348 FAIL(msg);
1349 }
1350
1351 if (pRunSummary->nAssertsFailed == CU_get_number_of_failures()) {
1352 PASS();
1353 } else {
1354 snprintf(msg, 499, "%u == CU_get_number_of_failures() (called from %s:%u)",
1355 pRunSummary->nAssertsFailed, file, line);
1356 msg[499] = '\0';
1357 FAIL(msg);
1358 }
1359
1360 if (pRunSummary->nFailureRecords == CU_get_number_of_failure_records()) {
1361 PASS();
1362 } else {
1363 snprintf(msg, 499, "%u == CU_get_number_of_failure_records() (called from %s:%u)",
1364 pRunSummary->nFailureRecords, file, line);
1365 msg[499] = '\0';
1366 FAIL(msg);
1367 }
1368 }
1369
1370 #define test_results(nSuitesRun, nSuitesFailed, nSuitesInactive, nTestsRun, nTestsFailed, \
1371 nTestsInactive, nAsserts, nSuccesses, nFailures, nFailureRecords) \
1372 do_test_results(nSuitesRun, nSuitesFailed, nSuitesInactive, nTestsRun, nTestsFailed, \
1373 nTestsInactive, nAsserts, nSuccesses, nFailures, nFailureRecords, \
1374 __FILE__, __LINE__)
1375
test_succeed(void)1376 static void test_succeed(void) { CU_TEST(CU_TRUE); }
test_fail(void)1377 static void test_fail(void) { CU_TEST(CU_FALSE); }
suite_succeed(void)1378 static int suite_succeed(void) { return 0; }
suite_fail(void)1379 static int suite_fail(void) { return 1; }
1380
1381 static CU_BOOL SetUp_Passed;
1382
test_succeed_if_setup(void)1383 static void test_succeed_if_setup(void) { CU_TEST(SetUp_Passed); }
test_fail_if_not_setup(void)1384 static void test_fail_if_not_setup(void) { CU_TEST(SetUp_Passed); }
1385
suite_setup(void)1386 static void suite_setup(void) { SetUp_Passed = CU_TRUE; }
suite_teardown(void)1387 static void suite_teardown(void) { SetUp_Passed = CU_FALSE; }
1388
1389
1390 /*-------------------------------------------------*/
1391 /* tests:
1392 * CU_set_suite_start_handler()
1393 * CU_set_test_start_handler()
1394 * CU_set_test_complete_handler()
1395 * CU_set_suite_complete_handler()
1396 * CU_set_all_test_complete_handler()
1397 * CU_set_suite_init_failure_handler()
1398 * CU_set_suite_cleanup_failure_handler()
1399 * CU_get_suite_start_handler()
1400 * CU_get_test_start_handler()
1401 * CU_get_test_complete_handler()
1402 * CU_get_suite_complete_handler()
1403 * CU_get_all_test_complete_handler()
1404 * CU_get_suite_init_failure_handler()
1405 * CU_get_suite_cleanup_failure_handler()
1406 * CU_is_test_running()
1407 * via handlers tests:
1408 * CU_get_current_suite()
1409 * CU_get_current_test()
1410 */
test_message_handlers(void)1411 static void test_message_handlers(void)
1412 {
1413 CU_pSuite pSuite1 = NULL;
1414 CU_pSuite pSuite2 = NULL;
1415 CU_pSuite pSuite3 = NULL;
1416 CU_pTest pTest1 = NULL;
1417 CU_pTest pTest2 = NULL;
1418 CU_pTest pTest3 = NULL;
1419 CU_pTest pTest4 = NULL;
1420 CU_pTest pTest5 = NULL;
1421 pTestEvent pEvent = NULL;
1422
1423 TEST(!CU_is_test_running());
1424
1425 /* handlers should be NULL on startup */
1426 TEST(NULL == CU_get_suite_start_handler());
1427 TEST(NULL == CU_get_test_start_handler());
1428 TEST(NULL == CU_get_test_complete_handler());
1429 TEST(NULL == CU_get_suite_complete_handler());
1430 TEST(NULL == CU_get_all_test_complete_handler());
1431 TEST(NULL == CU_get_suite_init_failure_handler());
1432 TEST(NULL == CU_get_suite_cleanup_failure_handler());
1433
1434 /* register some suites and tests */
1435 CU_initialize_registry();
1436 pSuite1 = CU_add_suite("suite1", NULL, NULL);
1437 pTest1 = CU_add_test(pSuite1, "test1", test_succeed);
1438 pTest2 = CU_add_test(pSuite1, "test2", test_fail);
1439 pTest3 = CU_add_test(pSuite1, "test3", test_succeed);
1440 pSuite2 = CU_add_suite("suite2", suite_fail, NULL);
1441 pTest4 = CU_add_test(pSuite2, "test4", test_succeed);
1442 pSuite3 = CU_add_suite("suite3", suite_succeed, suite_fail);
1443 pTest5 = CU_add_test(pSuite3, "test5", test_fail);
1444
1445 TEST_FATAL(CUE_SUCCESS == CU_get_error());
1446
1447 /* first run tests without handlers set */
1448 clear_test_events();
1449 CU_run_all_tests();
1450
1451 TEST(0 == f_nTestEvents);
1452 TEST(NULL == f_pFirstEvent);
1453 test_results(2,2,0,4,2,0,4,2,2,4);
1454
1455 /* set handlers to local functions */
1456 CU_set_suite_start_handler(&suite_start_handler);
1457 CU_set_test_start_handler(&test_start_handler);
1458 CU_set_test_complete_handler(&test_complete_handler);
1459 CU_set_suite_complete_handler(&suite_complete_handler);
1460 CU_set_all_test_complete_handler(&test_all_complete_handler);
1461 CU_set_suite_init_failure_handler(&suite_init_failure_handler);
1462 CU_set_suite_cleanup_failure_handler(&suite_cleanup_failure_handler);
1463
1464 /* confirm handlers set properly */
1465 TEST(suite_start_handler == CU_get_suite_start_handler());
1466 TEST(test_start_handler == CU_get_test_start_handler());
1467 TEST(test_complete_handler == CU_get_test_complete_handler());
1468 TEST(suite_complete_handler == CU_get_suite_complete_handler());
1469 TEST(test_all_complete_handler == CU_get_all_test_complete_handler());
1470 TEST(suite_init_failure_handler == CU_get_suite_init_failure_handler());
1471 TEST(suite_cleanup_failure_handler == CU_get_suite_cleanup_failure_handler());
1472
1473 /* run tests again with handlers set */
1474 clear_test_events();
1475 CU_run_all_tests();
1476
1477 TEST(17 == f_nTestEvents);
1478 if (17 == f_nTestEvents) {
1479 pEvent = f_pFirstEvent;
1480 TEST(SUITE_START == pEvent->type);
1481 TEST(pSuite1 == pEvent->pSuite);
1482 TEST(NULL == pEvent->pTest);
1483 TEST(NULL == pEvent->pFailure);
1484
1485 pEvent = pEvent->pNext;
1486 TEST(TEST_START == pEvent->type);
1487 TEST(pSuite1 == pEvent->pSuite);
1488 TEST(pTest1 == pEvent->pTest);
1489 TEST(NULL == pEvent->pFailure);
1490
1491 pEvent = pEvent->pNext;
1492 TEST(TEST_COMPLETE == pEvent->type);
1493 TEST(pSuite1 == pEvent->pSuite);
1494 TEST(pTest1 == pEvent->pTest);
1495 TEST(NULL == pEvent->pFailure);
1496
1497 pEvent = pEvent->pNext;
1498 TEST(TEST_START == pEvent->type);
1499 TEST(pSuite1 == pEvent->pSuite);
1500 TEST(pTest2 == pEvent->pTest);
1501 TEST(NULL == pEvent->pFailure);
1502
1503 pEvent = pEvent->pNext;
1504 TEST(TEST_COMPLETE == pEvent->type);
1505 TEST(pSuite1 == pEvent->pSuite);
1506 TEST(pTest2 == pEvent->pTest);
1507 TEST(NULL != pEvent->pFailure);
1508
1509 pEvent = pEvent->pNext;
1510 TEST(TEST_START == pEvent->type);
1511 TEST(pSuite1 == pEvent->pSuite);
1512 TEST(pTest3 == pEvent->pTest);
1513 TEST(NULL == pEvent->pFailure);
1514
1515 pEvent = pEvent->pNext;
1516 TEST(TEST_COMPLETE == pEvent->type);
1517 TEST(pSuite1 == pEvent->pSuite);
1518 TEST(pTest3 == pEvent->pTest);
1519 TEST(NULL == pEvent->pFailure);
1520
1521 pEvent = pEvent->pNext;
1522 TEST(SUITE_COMPLETE == pEvent->type);
1523 TEST(pSuite1 == pEvent->pSuite);
1524 TEST(NULL == pEvent->pTest);
1525 TEST(NULL != pEvent->pFailure);
1526
1527 pEvent = pEvent->pNext;
1528 TEST(SUITE_START == pEvent->type);
1529 TEST(pSuite2 == pEvent->pSuite);
1530 TEST(NULL == pEvent->pTest);
1531 TEST(NULL == pEvent->pFailure);
1532
1533 pEvent = pEvent->pNext;
1534 TEST(SUITE_INIT_FAILED == pEvent->type);
1535 TEST(pSuite2 == pEvent->pSuite);
1536 TEST(NULL == pEvent->pTest);
1537 TEST(NULL == pEvent->pFailure);
1538
1539 pEvent = pEvent->pNext;
1540 TEST(SUITE_COMPLETE == pEvent->type);
1541 TEST(pSuite2 == pEvent->pSuite);
1542 TEST(NULL == pEvent->pTest);
1543 TEST(NULL != pEvent->pFailure);
1544
1545 pEvent = pEvent->pNext;
1546 TEST(SUITE_START == pEvent->type);
1547 TEST(pSuite3 == pEvent->pSuite);
1548 TEST(NULL == pEvent->pTest);
1549 TEST(NULL == pEvent->pFailure);
1550
1551 pEvent = pEvent->pNext;
1552 TEST(TEST_START == pEvent->type);
1553 TEST(pSuite3 == pEvent->pSuite);
1554 TEST(pTest5 == pEvent->pTest);
1555 TEST(NULL == pEvent->pFailure);
1556
1557 pEvent = pEvent->pNext;
1558 TEST(TEST_COMPLETE == pEvent->type);
1559 TEST(pSuite3 == pEvent->pSuite);
1560 TEST(pTest5 == pEvent->pTest);
1561 TEST(NULL != pEvent->pFailure);
1562
1563 pEvent = pEvent->pNext;
1564 TEST(SUITE_CLEANUP_FAILED == pEvent->type);
1565 TEST(pSuite3 == pEvent->pSuite);
1566 TEST(NULL == pEvent->pTest);
1567 TEST(NULL == pEvent->pFailure);
1568
1569 pEvent = pEvent->pNext;
1570 TEST(SUITE_COMPLETE == pEvent->type);
1571 TEST(pSuite3 == pEvent->pSuite);
1572 TEST(NULL == pEvent->pTest);
1573 TEST(NULL != pEvent->pFailure);
1574
1575 pEvent = pEvent->pNext;
1576 TEST(ALL_TESTS_COMPLETE == pEvent->type);
1577 TEST(NULL == pEvent->pSuite);
1578 TEST(NULL == pEvent->pTest);
1579 TEST(NULL != pEvent->pFailure);
1580 if (4 == CU_get_number_of_failure_records()) {
1581 TEST(NULL != pEvent->pFailure->pNext);
1582 TEST(NULL != pEvent->pFailure->pNext->pNext);
1583 TEST(NULL != pEvent->pFailure->pNext->pNext->pNext);
1584 TEST(NULL == pEvent->pFailure->pNext->pNext->pNext->pNext);
1585 }
1586 TEST(pEvent->pFailure == CU_get_failure_list());
1587 }
1588
1589 test_results(2,2,0,4,2,0,4,2,2,4);
1590
1591 /* clear handlers and run again */
1592 CU_set_suite_start_handler(NULL);
1593 CU_set_test_start_handler(NULL);
1594 CU_set_test_complete_handler(NULL);
1595 CU_set_suite_complete_handler(NULL);
1596 CU_set_all_test_complete_handler(NULL);
1597 CU_set_suite_init_failure_handler(NULL);
1598 CU_set_suite_cleanup_failure_handler(NULL);
1599
1600 TEST(NULL == CU_get_suite_start_handler());
1601 TEST(NULL == CU_get_test_start_handler());
1602 TEST(NULL == CU_get_test_complete_handler());
1603 TEST(NULL == CU_get_suite_complete_handler());
1604 TEST(NULL == CU_get_all_test_complete_handler());
1605 TEST(NULL == CU_get_suite_init_failure_handler());
1606 TEST(NULL == CU_get_suite_cleanup_failure_handler());
1607
1608 clear_test_events();
1609 CU_run_all_tests();
1610
1611 TEST(0 == f_nTestEvents);
1612 TEST(NULL == f_pFirstEvent);
1613 test_results(2,2,0,4,2,0,4,2,2,4);
1614
1615 CU_cleanup_registry();
1616 clear_test_events();
1617 }
1618
1619 static CU_BOOL f_exit_called = CU_FALSE;
1620
1621 /* intercept exit for testing of CUEA_ABORT action */
test_exit(int status)1622 void test_exit(int status)
1623 {
1624 CU_UNREFERENCED_PARAMETER(status); /* not used */
1625 f_exit_called = CU_TRUE;
1626 }
1627
1628
1629 /*-------------------------------------------------*/
test_CU_fail_on_inactive(void)1630 static void test_CU_fail_on_inactive(void)
1631 {
1632 CU_pSuite pSuite1 = NULL;
1633 CU_pSuite pSuite2 = NULL;
1634 CU_pTest pTest1 = NULL;
1635 CU_pTest pTest2 = NULL;
1636 CU_pTest pTest3 = NULL;
1637 CU_pTest pTest4 = NULL;
1638
1639 CU_set_error_action(CUEA_IGNORE);
1640 CU_initialize_registry();
1641
1642 /* register some suites and tests */
1643 CU_initialize_registry();
1644 pSuite1 = CU_add_suite("suite1", NULL, NULL);
1645 pTest1 = CU_add_test(pSuite1, "test1", test_succeed);
1646 pTest2 = CU_add_test(pSuite1, "test2", test_fail);
1647 pSuite2 = CU_add_suite("suite2", suite_fail, NULL);
1648 pTest3 = CU_add_test(pSuite2, "test3", test_succeed);
1649 pTest4 = CU_add_test(pSuite2, "test4", test_succeed);
1650
1651 /* test initial conditions */
1652 TEST(CU_TRUE == CU_get_fail_on_inactive());
1653 TEST(CU_TRUE == pSuite1->fActive);
1654 TEST(CU_TRUE == pSuite2->fActive);
1655 TEST(CU_TRUE == pTest1->fActive);
1656 TEST(CU_TRUE == pTest2->fActive);
1657 TEST(CU_TRUE == pTest3->fActive);
1658 TEST(CU_TRUE == pTest4->fActive);
1659
1660 CU_set_fail_on_inactive(CU_TRUE);
1661 TEST(CU_TRUE == CU_get_fail_on_inactive());
1662 TEST(CUE_SINIT_FAILED == CU_run_all_tests()); /* all suites/tests active */
1663 test_results(1,1,0,2,1,0,2,1,1,2);
1664 CU_set_fail_on_inactive(CU_FALSE);
1665 TEST(CU_FALSE == CU_get_fail_on_inactive());
1666 TEST(CUE_SINIT_FAILED == CU_run_all_tests());
1667 test_results(1,1,0,2,1,0,2,1,1,2);
1668
1669 CU_set_suite_active(pSuite1, CU_FALSE);
1670 CU_set_suite_active(pSuite2, CU_FALSE);
1671 CU_set_fail_on_inactive(CU_TRUE);
1672 TEST(CUE_SUITE_INACTIVE == CU_run_all_tests()); /* all suites inactive */
1673 test_results(0,0,2,0,0,0,0,0,0,2);
1674 CU_set_fail_on_inactive(CU_FALSE);
1675 TEST(CUE_SUCCESS == CU_run_all_tests());
1676 test_results(0,0,2,0,0,0,0,0,0,0);
1677 CU_set_suite_active(pSuite1, CU_TRUE);
1678 CU_set_suite_active(pSuite2, CU_TRUE);
1679
1680 CU_set_suite_active(pSuite2, CU_FALSE);
1681 CU_set_fail_on_inactive(CU_TRUE);
1682 TEST(CUE_SUITE_INACTIVE == CU_run_all_tests()); /* some suites inactive */
1683 test_results(1,0,1,2,1,0,2,1,1,2);
1684 CU_set_fail_on_inactive(CU_FALSE);
1685 TEST(CUE_SUCCESS == CU_run_all_tests());
1686 test_results(1,0,1,2,1,0,2,1,1,1);
1687 CU_set_suite_active(pSuite2, CU_TRUE);
1688
1689 CU_set_test_active(pTest1, CU_FALSE);
1690 CU_set_test_active(pTest2, CU_FALSE);
1691 CU_set_test_active(pTest3, CU_FALSE);
1692 CU_set_test_active(pTest4, CU_FALSE);
1693 CU_set_fail_on_inactive(CU_TRUE);
1694 TEST(CUE_TEST_INACTIVE == CU_run_all_tests()); /* all tests inactive */
1695 test_results(1,1,0,0,0,2,0,0,0,3);
1696 CU_set_fail_on_inactive(CU_FALSE);
1697 TEST(CUE_SINIT_FAILED == CU_run_all_tests());
1698 test_results(1,1,0,0,0,2,0,0,0,1);
1699 CU_set_test_active(pTest1, CU_TRUE);
1700 CU_set_test_active(pTest2, CU_TRUE);
1701 CU_set_test_active(pTest3, CU_TRUE);
1702 CU_set_test_active(pTest4, CU_TRUE);
1703
1704 CU_set_test_active(pTest2, CU_FALSE);
1705 CU_set_test_active(pTest4, CU_FALSE);
1706 CU_set_fail_on_inactive(CU_TRUE);
1707 TEST(CUE_TEST_INACTIVE == CU_run_all_tests()); /* some tests inactive */
1708 test_results(1,1,0,1,0,1,1,1,0,2);
1709 CU_set_fail_on_inactive(CU_FALSE);
1710 TEST(CUE_SINIT_FAILED == CU_run_all_tests());
1711 test_results(1,1,0,1,0,1,1,1,0,1);
1712 CU_set_test_active(pTest2, CU_TRUE);
1713 CU_set_test_active(pTest4, CU_TRUE);
1714
1715 CU_set_suite_active(pSuite2, CU_FALSE);
1716 CU_set_test_active(pTest1, CU_FALSE);
1717 CU_set_fail_on_inactive(CU_TRUE);
1718 TEST(CUE_TEST_INACTIVE == CU_run_all_tests()); /* some suites & tests inactive */
1719 test_results(1,0,1,1,1,1,1,0,1,3);
1720 CU_set_fail_on_inactive(CU_FALSE);
1721 TEST(CUE_SUCCESS == CU_run_all_tests());
1722 test_results(1,0,1,1,1,1,1,0,1,1);
1723 CU_set_suite_active(pSuite2, CU_TRUE);
1724 CU_set_test_active(pTest1, CU_TRUE);
1725
1726 /* clean up */
1727 CU_cleanup_registry();
1728 }
1729
1730 /*-------------------------------------------------*/
test_CU_run_all_tests(void)1731 static void test_CU_run_all_tests(void)
1732 {
1733 CU_pSuite pSuite1 = NULL;
1734 CU_pSuite pSuite2 = NULL;
1735 CU_pSuite pSuite3 = NULL;
1736 CU_pSuite pSuite4 = NULL;
1737 CU_pTest pTest1 = NULL;
1738 CU_pTest pTest2 = NULL;
1739 CU_pTest pTest3 = NULL;
1740 CU_pTest pTest4 = NULL;
1741 CU_pTest pTest5 = NULL;
1742 CU_pTest pTest6 = NULL;
1743 CU_pTest pTest7 = NULL;
1744 CU_pTest pTest8 = NULL;
1745 CU_pTest pTest9 = NULL;
1746 CU_pTest pTest10 = NULL;
1747
1748 /* error - uninitialized registry (CUEA_IGNORE) */
1749 CU_cleanup_registry();
1750 CU_set_error_action(CUEA_IGNORE);
1751
1752 TEST(CUE_NOREGISTRY == CU_run_all_tests());
1753 TEST(CUE_NOREGISTRY == CU_get_error());
1754
1755 /* error - uninitialized registry (CUEA_FAIL) */
1756 CU_cleanup_registry();
1757 CU_set_error_action(CUEA_FAIL);
1758
1759 TEST(CUE_NOREGISTRY == CU_run_all_tests());
1760 TEST(CUE_NOREGISTRY == CU_get_error());
1761
1762 /* error - uninitialized registry (CUEA_ABORT) */
1763 CU_cleanup_registry();
1764 CU_set_error_action(CUEA_ABORT);
1765
1766 f_exit_called = CU_FALSE;
1767 CU_run_all_tests();
1768 TEST(CU_TRUE == f_exit_called);
1769 f_exit_called = CU_FALSE;
1770
1771 /* run with no suites or tests registered */
1772 CU_initialize_registry();
1773
1774 CU_set_error_action(CUEA_IGNORE);
1775 TEST(CUE_SUCCESS == CU_run_all_tests());
1776 test_results(0,0,0,0,0,0,0,0,0,0);
1777
1778 /* register some suites and tests */
1779 CU_initialize_registry();
1780 pSuite1 = CU_add_suite("suite1", NULL, NULL);
1781 pTest1 = CU_add_test(pSuite1, "test1", test_succeed);
1782 pTest2 = CU_add_test(pSuite1, "test2", test_fail);
1783 pTest3 = CU_add_test(pSuite1, "test1", test_succeed); /* duplicate test name OK */
1784 pTest4 = CU_add_test(pSuite1, "test4", test_fail);
1785 pTest5 = CU_add_test(pSuite1, "test1", test_succeed); /* duplicate test name OK */
1786 pSuite2 = CU_add_suite("suite2", suite_fail, NULL);
1787 pTest6 = CU_add_test(pSuite2, "test6", test_succeed);
1788 pTest7 = CU_add_test(pSuite2, "test7", test_succeed);
1789 pSuite3 = CU_add_suite("suite1", NULL, NULL); /* duplicate suite name OK */
1790 pTest8 = CU_add_test(pSuite3, "test8", test_fail);
1791 pTest9 = CU_add_test(pSuite3, "test9", test_succeed);
1792 pSuite4 = CU_add_suite("suite4", NULL, suite_fail);
1793 pTest10 = CU_add_test(pSuite4, "test10", test_succeed);
1794
1795 TEST_FATAL(4 == CU_get_registry()->uiNumberOfSuites);
1796 TEST_FATAL(10 == CU_get_registry()->uiNumberOfTests);
1797
1798 /* run all tests (CUEA_IGNORE) */
1799 CU_set_error_action(CUEA_IGNORE);
1800 TEST(CUE_SINIT_FAILED == CU_run_all_tests()); /* all suites/tests active */
1801 test_results(3,2,0,8,3,0,8,5,3,5);
1802
1803 CU_set_suite_active(pSuite1, CU_FALSE);
1804 CU_set_suite_active(pSuite2, CU_FALSE);
1805 CU_set_suite_active(pSuite3, CU_FALSE);
1806 CU_set_suite_active(pSuite4, CU_FALSE);
1807 CU_set_fail_on_inactive(CU_FALSE);
1808 TEST(CUE_SUCCESS == CU_run_all_tests()); /* suites inactive */
1809 test_results(0,0,4,0,0,0,0,0,0,0);
1810 CU_set_fail_on_inactive(CU_TRUE);
1811 TEST(CUE_SUITE_INACTIVE == CU_run_all_tests());
1812 test_results(0,0,4,0,0,0,0,0,0,4);
1813
1814 CU_set_suite_active(pSuite1, CU_FALSE);
1815 CU_set_suite_active(pSuite2, CU_TRUE);
1816 CU_set_suite_active(pSuite3, CU_TRUE);
1817 CU_set_suite_active(pSuite4, CU_FALSE);
1818 CU_set_fail_on_inactive(CU_FALSE);
1819 TEST(CUE_SINIT_FAILED == CU_run_all_tests()); /* some suites inactive */
1820 test_results(1,1,2,2,1,0,2,1,1,2);
1821 CU_set_fail_on_inactive(CU_TRUE);
1822 TEST(CUE_SUITE_INACTIVE == CU_run_all_tests());
1823 test_results(1,1,2,2,1,0,2,1,1,4);
1824
1825 CU_set_suite_active(pSuite1, CU_TRUE);
1826 CU_set_suite_active(pSuite2, CU_TRUE);
1827 CU_set_suite_active(pSuite3, CU_TRUE);
1828 CU_set_suite_active(pSuite4, CU_TRUE);
1829
1830 CU_set_test_active(pTest1, CU_FALSE);
1831 CU_set_test_active(pTest2, CU_FALSE);
1832 CU_set_test_active(pTest3, CU_FALSE);
1833 CU_set_test_active(pTest4, CU_FALSE);
1834 CU_set_test_active(pTest5, CU_FALSE);
1835 CU_set_test_active(pTest6, CU_FALSE);
1836 CU_set_test_active(pTest7, CU_FALSE);
1837 CU_set_test_active(pTest8, CU_FALSE);
1838 CU_set_test_active(pTest9, CU_FALSE);
1839 CU_set_test_active(pTest10, CU_FALSE);
1840 CU_set_fail_on_inactive(CU_FALSE);
1841 TEST(CUE_SINIT_FAILED == CU_run_all_tests()); /* no tests active */
1842 test_results(3,2,0,0,0,8,0,0,0,2);
1843 CU_set_fail_on_inactive(CU_TRUE);
1844 TEST(CUE_TEST_INACTIVE == CU_run_all_tests());
1845 test_results(3,2,0,0,0,8,0,0,0,10);
1846
1847 CU_set_test_active(pTest1, CU_TRUE);
1848 CU_set_test_active(pTest2, CU_FALSE);
1849 CU_set_test_active(pTest3, CU_TRUE);
1850 CU_set_test_active(pTest4, CU_FALSE);
1851 CU_set_test_active(pTest5, CU_TRUE);
1852 CU_set_test_active(pTest6, CU_FALSE);
1853 CU_set_test_active(pTest7, CU_TRUE);
1854 CU_set_test_active(pTest8, CU_FALSE);
1855 CU_set_test_active(pTest9, CU_TRUE);
1856 CU_set_test_active(pTest10, CU_FALSE);
1857 CU_set_fail_on_inactive(CU_FALSE);
1858 TEST(CUE_SINIT_FAILED == CU_run_all_tests()); /* some tests active */
1859 test_results(3,2,0,4,0,4,4,4,0,2);
1860 CU_set_fail_on_inactive(CU_TRUE);
1861 TEST(CUE_TEST_INACTIVE == CU_run_all_tests());
1862 test_results(3,2,0,4,0,4,4,4,0,6);
1863
1864 CU_set_test_active(pTest1, CU_TRUE);
1865 CU_set_test_active(pTest2, CU_TRUE);
1866 CU_set_test_active(pTest3, CU_TRUE);
1867 CU_set_test_active(pTest4, CU_TRUE);
1868 CU_set_test_active(pTest5, CU_TRUE);
1869 CU_set_test_active(pTest6, CU_TRUE);
1870 CU_set_test_active(pTest7, CU_TRUE);
1871 CU_set_test_active(pTest8, CU_TRUE);
1872 CU_set_test_active(pTest9, CU_TRUE);
1873 CU_set_test_active(pTest10, CU_TRUE);
1874
1875 CU_set_suite_initfunc(pSuite1, &suite_fail);
1876 TEST(CUE_SINIT_FAILED == CU_run_all_tests()); /* change a suite init function */
1877 CU_set_suite_initfunc(pSuite1, NULL);
1878 test_results(2,3,0,3,1,0,3,2,1,4);
1879
1880 CU_set_suite_cleanupfunc(pSuite4, NULL);
1881 TEST(CUE_SINIT_FAILED == CU_run_all_tests()); /* change a suite cleanup function */
1882 CU_set_suite_cleanupfunc(pSuite4, &suite_fail);
1883 test_results(3,1,0,8,3,0,8,5,3,4);
1884
1885 CU_set_test_func(pTest2, &test_succeed);
1886 CU_set_test_func(pTest4, &test_succeed);
1887 CU_set_test_func(pTest8, &test_succeed);
1888 TEST(CUE_SINIT_FAILED == CU_run_all_tests()); /* change a test function */
1889 CU_set_test_func(pTest2, &test_fail);
1890 CU_set_test_func(pTest4, &test_fail);
1891 CU_set_test_func(pTest8, &test_fail);
1892 test_results(3,2,0,8,0,0,8,8,0,2);
1893
1894 /* run all tests (CUEA_FAIL) */
1895 CU_set_error_action(CUEA_FAIL);
1896 TEST(CUE_SINIT_FAILED == CU_run_all_tests()); /* all suites active */
1897 test_results(1,1,0,5,2,0,5,3,2,3);
1898
1899 CU_set_suite_active(pSuite1, CU_TRUE);
1900 CU_set_suite_active(pSuite2, CU_FALSE);
1901 CU_set_suite_active(pSuite3, CU_FALSE);
1902 CU_set_suite_active(pSuite4, CU_TRUE);
1903 CU_set_fail_on_inactive(CU_FALSE);
1904 TEST(CUE_SCLEAN_FAILED == CU_run_all_tests()); /* some suites inactive */
1905 test_results(2,1,2,6,2,0,6,4,2,3);
1906 CU_set_fail_on_inactive(CU_TRUE);
1907 TEST(CUE_SUITE_INACTIVE == CU_run_all_tests());
1908 test_results(1,0,1,5,2,0,5,3,2,3);
1909
1910 CU_set_suite_active(pSuite1, CU_TRUE);
1911 CU_set_suite_active(pSuite2, CU_TRUE);
1912 CU_set_suite_active(pSuite3, CU_TRUE);
1913 CU_set_suite_active(pSuite4, CU_TRUE);
1914
1915 CU_set_test_active(pTest1, CU_FALSE);
1916 CU_set_test_active(pTest2, CU_FALSE);
1917 CU_set_test_active(pTest3, CU_FALSE);
1918 CU_set_test_active(pTest4, CU_FALSE);
1919 CU_set_test_active(pTest5, CU_FALSE);
1920 CU_set_test_active(pTest6, CU_FALSE);
1921 CU_set_test_active(pTest7, CU_FALSE);
1922 CU_set_test_active(pTest8, CU_FALSE);
1923 CU_set_test_active(pTest9, CU_FALSE);
1924 CU_set_test_active(pTest10, CU_FALSE);
1925 CU_set_fail_on_inactive(CU_FALSE);
1926 TEST(CUE_SINIT_FAILED == CU_run_all_tests()); /* no tests active */
1927 test_results(1,1,0,0,0,5,0,0,0,1);
1928 CU_set_fail_on_inactive(CU_TRUE);
1929 TEST(CUE_TEST_INACTIVE == CU_run_all_tests());
1930 test_results(1,0,0,0,0,1,0,0,0,1);
1931
1932 CU_set_test_active(pTest1, CU_FALSE);
1933 CU_set_test_active(pTest2, CU_TRUE);
1934 CU_set_test_active(pTest3, CU_FALSE);
1935 CU_set_test_active(pTest4, CU_TRUE);
1936 CU_set_test_active(pTest5, CU_FALSE);
1937 CU_set_test_active(pTest6, CU_TRUE);
1938 CU_set_test_active(pTest7, CU_FALSE);
1939 CU_set_test_active(pTest8, CU_TRUE);
1940 CU_set_test_active(pTest9, CU_FALSE);
1941 CU_set_test_active(pTest10, CU_TRUE);
1942 CU_set_fail_on_inactive(CU_FALSE);
1943 TEST(CUE_SINIT_FAILED == CU_run_all_tests()); /* some tests active */
1944 test_results(1,1,0,2,2,3,2,0,2,3);
1945 CU_set_fail_on_inactive(CU_TRUE);
1946 TEST(CUE_TEST_INACTIVE == CU_run_all_tests());
1947 test_results(1,0,0,0,0,1,0,0,0,1);
1948
1949 CU_set_test_active(pTest1, CU_TRUE);
1950 CU_set_test_active(pTest2, CU_TRUE);
1951 CU_set_test_active(pTest3, CU_TRUE);
1952 CU_set_test_active(pTest4, CU_TRUE);
1953 CU_set_test_active(pTest5, CU_TRUE);
1954 CU_set_test_active(pTest6, CU_TRUE);
1955 CU_set_test_active(pTest7, CU_TRUE);
1956 CU_set_test_active(pTest8, CU_TRUE);
1957 CU_set_test_active(pTest9, CU_TRUE);
1958 CU_set_test_active(pTest10, CU_TRUE);
1959
1960 CU_set_suite_initfunc(pSuite2, NULL);
1961 TEST(CUE_SCLEAN_FAILED == CU_run_all_tests()); /* change a suite init function */
1962 CU_set_suite_initfunc(pSuite2, &suite_fail);
1963 test_results(4,1,0,10,3,0,10,7,3,4);
1964
1965 CU_set_suite_cleanupfunc(pSuite1, &suite_fail);
1966 TEST(CUE_SCLEAN_FAILED == CU_run_all_tests()); /* change a suite cleanup function */
1967 CU_set_suite_cleanupfunc(pSuite1, NULL);
1968 test_results(1,1,0,5,2,0,5,3,2,3);
1969
1970 CU_set_test_func(pTest1, &test_fail);
1971 CU_set_test_func(pTest3, &test_fail);
1972 CU_set_test_func(pTest5, &test_fail);
1973 CU_set_test_func(pTest9, &test_fail);
1974 CU_set_test_func(pTest10, &test_fail);
1975 TEST(CUE_SINIT_FAILED == CU_run_all_tests()); /* change a test function */
1976 CU_set_test_func(pTest1, &test_succeed);
1977 CU_set_test_func(pTest3, &test_succeed);
1978 CU_set_test_func(pTest5, &test_succeed);
1979 CU_set_test_func(pTest9, &test_succeed);
1980 CU_set_test_func(pTest10, &test_succeed);
1981 test_results(1,1,0,5,5,0,5,0,5,6);
1982
1983 /* run all tests (CUEA_ABORT) */
1984 f_exit_called = CU_FALSE;
1985 CU_set_error_action(CUEA_ABORT);
1986 CU_set_suite_active(pSuite1, CU_TRUE);
1987 CU_set_suite_active(pSuite2, CU_TRUE);
1988 CU_set_suite_active(pSuite3, CU_TRUE);
1989 CU_set_suite_active(pSuite4, CU_TRUE);
1990 TEST(CUE_SINIT_FAILED == CU_run_all_tests()); /* all suites active */
1991 TEST(CU_TRUE == f_exit_called);
1992 test_results(1,1,0,5,2,0,5,3,2,3);
1993
1994 CU_set_suite_active(pSuite1, CU_FALSE);
1995 CU_set_suite_active(pSuite2, CU_FALSE);
1996 CU_set_suite_active(pSuite3, CU_FALSE);
1997 CU_set_suite_active(pSuite4, CU_FALSE);
1998 f_exit_called = CU_FALSE;
1999 CU_set_fail_on_inactive(CU_FALSE);
2000 TEST(CUE_SUCCESS == CU_run_all_tests()); /* no suites active, so no abort() */
2001 TEST(CU_FALSE == f_exit_called);
2002 test_results(0,0,4,0,0,0,0,0,0,0);
2003 f_exit_called = CU_FALSE;
2004 CU_set_fail_on_inactive(CU_TRUE);
2005 TEST(CUE_SUITE_INACTIVE == CU_run_all_tests());
2006 TEST(CU_TRUE == f_exit_called);
2007 test_results(0,0,1,0,0,0,0,0,0,1);
2008
2009 CU_set_suite_active(pSuite1, CU_TRUE);
2010 CU_set_suite_active(pSuite2, CU_FALSE);
2011 CU_set_suite_active(pSuite3, CU_TRUE);
2012 CU_set_suite_active(pSuite4, CU_TRUE);
2013 f_exit_called = CU_FALSE;
2014 CU_set_fail_on_inactive(CU_FALSE);
2015 TEST(CUE_SCLEAN_FAILED == CU_run_all_tests()); /* some suites active */
2016 TEST(CU_TRUE == f_exit_called);
2017 test_results(3,1,1,8,3,0,8,5,3,4);
2018 f_exit_called = CU_FALSE;
2019 CU_set_fail_on_inactive(CU_TRUE);
2020 TEST(CUE_SUITE_INACTIVE == CU_run_all_tests());
2021 TEST(CU_TRUE == f_exit_called);
2022 test_results(1,0,1,5,2,0,5,3,2,3);
2023
2024 CU_set_suite_active(pSuite1, CU_TRUE);
2025 CU_set_suite_active(pSuite2, CU_TRUE);
2026 CU_set_suite_active(pSuite3, CU_TRUE);
2027 CU_set_suite_active(pSuite4, CU_TRUE);
2028
2029 CU_set_test_active(pTest1, CU_FALSE);
2030 CU_set_test_active(pTest2, CU_FALSE);
2031 CU_set_test_active(pTest3, CU_FALSE);
2032 CU_set_test_active(pTest4, CU_FALSE);
2033 CU_set_test_active(pTest5, CU_FALSE);
2034 CU_set_test_active(pTest6, CU_FALSE);
2035 CU_set_test_active(pTest7, CU_FALSE);
2036 CU_set_test_active(pTest8, CU_FALSE);
2037 CU_set_test_active(pTest9, CU_FALSE);
2038 CU_set_test_active(pTest10, CU_FALSE);
2039 f_exit_called = CU_FALSE;
2040 CU_set_fail_on_inactive(CU_FALSE);
2041 TEST(CUE_SINIT_FAILED == CU_run_all_tests()); /* no tests active */
2042 TEST(CU_TRUE == f_exit_called);
2043 test_results(1,1,0,0,0,5,0,0,0,1);
2044 f_exit_called = CU_FALSE;
2045 CU_set_fail_on_inactive(CU_TRUE);
2046 TEST(CUE_TEST_INACTIVE == CU_run_all_tests());
2047 TEST(CU_TRUE == f_exit_called);
2048 test_results(1,0,0,0,0,1,0,0,0,1);
2049
2050 CU_set_test_active(pTest1, CU_FALSE);
2051 CU_set_test_active(pTest2, CU_TRUE);
2052 CU_set_test_active(pTest3, CU_FALSE);
2053 CU_set_test_active(pTest4, CU_TRUE);
2054 CU_set_test_active(pTest5, CU_FALSE);
2055 CU_set_test_active(pTest6, CU_TRUE);
2056 CU_set_test_active(pTest7, CU_FALSE);
2057 CU_set_test_active(pTest8, CU_TRUE);
2058 CU_set_test_active(pTest9, CU_FALSE);
2059 CU_set_test_active(pTest10, CU_TRUE);
2060 f_exit_called = CU_FALSE;
2061 CU_set_fail_on_inactive(CU_FALSE);
2062 TEST(CUE_SINIT_FAILED == CU_run_all_tests()); /* some tests active */
2063 TEST(CU_TRUE == f_exit_called);
2064 test_results(1,1,0,2,2,3,2,0,2,3);
2065 f_exit_called = CU_FALSE;
2066 CU_set_fail_on_inactive(CU_TRUE);
2067 TEST(CUE_TEST_INACTIVE == CU_run_all_tests());
2068 TEST(CU_TRUE == f_exit_called);
2069 test_results(1,0,0,0,0,1,0,0,0,1);
2070
2071 CU_set_test_active(pTest1, CU_TRUE);
2072 CU_set_test_active(pTest2, CU_TRUE);
2073 CU_set_test_active(pTest3, CU_TRUE);
2074 CU_set_test_active(pTest4, CU_TRUE);
2075 CU_set_test_active(pTest5, CU_TRUE);
2076 CU_set_test_active(pTest6, CU_TRUE);
2077 CU_set_test_active(pTest7, CU_TRUE);
2078 CU_set_test_active(pTest8, CU_TRUE);
2079 CU_set_test_active(pTest9, CU_TRUE);
2080 CU_set_test_active(pTest10, CU_TRUE);
2081
2082 f_exit_called = CU_FALSE;
2083 CU_set_suite_initfunc(pSuite1, &suite_fail);
2084 TEST(CUE_SINIT_FAILED == CU_run_all_tests()); /* change a suite init function */
2085 CU_set_suite_initfunc(pSuite1, NULL);
2086 TEST(CU_TRUE == f_exit_called);
2087 test_results(0,1,0,0,0,0,0,0,0,1);
2088
2089 f_exit_called = CU_FALSE;
2090 CU_set_suite_cleanupfunc(pSuite1, &suite_fail);
2091 TEST(CUE_SCLEAN_FAILED == CU_run_all_tests()); /* change a suite cleanup function */
2092 CU_set_suite_cleanupfunc(pSuite1, NULL);
2093 TEST(CU_TRUE == f_exit_called);
2094 test_results(1,1,0,5,2,0,5,3,2,3);
2095
2096 f_exit_called = CU_FALSE;
2097 CU_set_test_func(pTest1, &test_fail);
2098 CU_set_test_func(pTest3, &test_fail);
2099 CU_set_test_func(pTest5, &test_fail);
2100 CU_set_test_func(pTest9, &test_fail);
2101 CU_set_test_func(pTest10, &test_fail);
2102 TEST(CUE_SINIT_FAILED == CU_run_all_tests()); /* change a test function */
2103 CU_set_test_func(pTest1, &test_succeed);
2104 CU_set_test_func(pTest3, &test_succeed);
2105 CU_set_test_func(pTest5, &test_succeed);
2106 CU_set_test_func(pTest9, &test_succeed);
2107 CU_set_test_func(pTest10, &test_succeed);
2108 TEST(CU_TRUE == f_exit_called);
2109 test_results(1,1,0,5,5,0,5,0,5,6);
2110
2111 /* clean up after testing */
2112 CU_set_error_action(CUEA_IGNORE);
2113 CU_cleanup_registry();
2114 }
2115
2116
2117 /*-------------------------------------------------*/
test_CU_run_suite(void)2118 static void test_CU_run_suite(void)
2119 {
2120 CU_pSuite pSuite1 = NULL;
2121 CU_pSuite pSuite2 = NULL;
2122 CU_pSuite pSuite3 = NULL;
2123 CU_pSuite pSuite4 = NULL;
2124 CU_pSuite pSuite5 = NULL;
2125 CU_pSuite pSuite6 = NULL;
2126 CU_pTest pTest1 = NULL;
2127 CU_pTest pTest2 = NULL;
2128 CU_pTest pTest3 = NULL;
2129 CU_pTest pTest4 = NULL;
2130 CU_pTest pTest5 = NULL;
2131 CU_pTest pTest6 = NULL;
2132 CU_pTest pTest7 = NULL;
2133 CU_pTest pTest8 = NULL;
2134 CU_pTest pTest9 = NULL;
2135 CU_pTest pTest10 = NULL;
2136 CU_pTest pTest11 = NULL;
2137
2138 /* error - NULL suite (CUEA_IGNORE) */
2139 CU_set_error_action(CUEA_IGNORE);
2140
2141 TEST(CUE_NOSUITE == CU_run_suite(NULL));
2142 TEST(CUE_NOSUITE == CU_get_error());
2143
2144 /* error - NULL suite (CUEA_FAIL) */
2145 CU_set_error_action(CUEA_FAIL);
2146
2147 TEST(CUE_NOSUITE == CU_run_suite(NULL));
2148 TEST(CUE_NOSUITE == CU_get_error());
2149
2150 /* error - NULL suite (CUEA_ABORT) */
2151 CU_set_error_action(CUEA_ABORT);
2152
2153 f_exit_called = CU_FALSE;
2154 CU_run_suite(NULL);
2155 TEST(CU_TRUE == f_exit_called);
2156 f_exit_called = CU_FALSE;
2157
2158 /* register some suites and tests */
2159 CU_initialize_registry();
2160 pSuite1 = CU_add_suite("suite1", NULL, NULL);
2161 pTest1 = CU_add_test(pSuite1, "test1", test_succeed);
2162 pTest2 = CU_add_test(pSuite1, "test2", test_fail);
2163 pTest3 = CU_add_test(pSuite1, "test3", test_succeed);
2164 pTest4 = CU_add_test(pSuite1, "test4", test_fail);
2165 pTest5 = CU_add_test(pSuite1, "test5", test_succeed);
2166 pSuite2 = CU_add_suite("suite1", suite_fail, NULL); /* duplicate suite name OK */
2167 pTest6 = CU_add_test(pSuite2, "test6", test_succeed);
2168 pTest7 = CU_add_test(pSuite2, "test7", test_succeed);
2169 pSuite3 = CU_add_suite("suite3", NULL, suite_fail);
2170 pTest8 = CU_add_test(pSuite3, "test8", test_fail);
2171 pTest9 = CU_add_test(pSuite3, "test8", test_succeed); /* duplicate test name OK */
2172 pSuite4 = CU_add_suite("suite4", NULL, NULL);
2173 pSuite5 = CU_add_suite_with_setup_and_teardown("suite5", NULL, NULL, suite_setup, suite_teardown);
2174 pTest10 = CU_add_test(pSuite5, "test10", test_succeed_if_setup);
2175 pSuite6 = CU_add_suite("suite6", NULL, NULL);
2176 pTest11 = CU_add_test(pSuite6, "test11", test_fail_if_not_setup);
2177
2178 TEST_FATAL(6 == CU_get_registry()->uiNumberOfSuites);
2179 TEST_FATAL(11 == CU_get_registry()->uiNumberOfTests);
2180
2181 /* run each suite (CUEA_IGNORE) */
2182 CU_set_error_action(CUEA_IGNORE);
2183
2184 TEST(CUE_SUCCESS == CU_run_suite(pSuite1)); /* suites/tests active */
2185 test_results(1,0,0,5,2,0,5,3,2,2);
2186
2187 TEST(CUE_SINIT_FAILED == CU_run_suite(pSuite2));
2188 test_results(0,1,0,0,0,0,0,0,0,1);
2189
2190 TEST(CUE_SCLEAN_FAILED == CU_run_suite(pSuite3));
2191 test_results(1,1,0,2,1,0,2,1,1,2);
2192
2193 TEST(CUE_SUCCESS == CU_run_suite(pSuite4));
2194 test_results(1,0,0,0,0,0,0,0,0,0);
2195
2196 TEST(CUE_SUCCESS == CU_run_suite(pSuite5));
2197 test_results(1,0,0,1,0,0,1,1,0,0);
2198
2199 TEST(CUE_SUCCESS == CU_run_suite(pSuite6));
2200 test_results(1,0,0,1,1,0,1,0,1,1);
2201
2202 CU_set_suite_active(pSuite3, CU_FALSE);
2203 CU_set_fail_on_inactive(CU_FALSE);
2204 TEST(CUE_SUCCESS == CU_run_suite(pSuite3)); /* suite inactive */
2205 test_results(0,0,1,0,0,0,0,0,0,0);
2206 CU_set_fail_on_inactive(CU_TRUE);
2207 TEST(CUE_SUITE_INACTIVE == CU_run_suite(pSuite3));
2208 test_results(0,0,1,0,0,0,0,0,0,1);
2209 CU_set_suite_active(pSuite3, CU_TRUE);
2210
2211 CU_set_test_active(pTest1, CU_FALSE);
2212 CU_set_test_active(pTest2, CU_FALSE);
2213 CU_set_test_active(pTest3, CU_FALSE);
2214 CU_set_test_active(pTest4, CU_FALSE);
2215 CU_set_test_active(pTest5, CU_FALSE);
2216 CU_set_fail_on_inactive(CU_FALSE);
2217 TEST(CUE_SUCCESS == CU_run_suite(pSuite1)); /* all tests inactive */
2218 test_results(1,0,0,0,0,5,0,0,0,0);
2219 CU_set_fail_on_inactive(CU_TRUE);
2220 TEST(CUE_TEST_INACTIVE == CU_run_suite(pSuite1));
2221 test_results(1,0,0,0,0,5,0,0,0,5);
2222
2223 CU_set_test_active(pTest1, CU_TRUE);
2224 CU_set_test_active(pTest2, CU_FALSE);
2225 CU_set_test_active(pTest3, CU_TRUE);
2226 CU_set_test_active(pTest4, CU_FALSE);
2227 CU_set_test_active(pTest5, CU_TRUE);
2228 CU_set_fail_on_inactive(CU_FALSE);
2229 TEST(CUE_SUCCESS == CU_run_suite(pSuite1)); /* some tests inactive */
2230 test_results(1,0,0,3,0,2,3,3,0,0);
2231 CU_set_fail_on_inactive(CU_TRUE);
2232 TEST(CUE_TEST_INACTIVE == CU_run_suite(pSuite1));
2233 test_results(1,0,0,3,0,2,3,3,0,2);
2234 CU_set_test_active(pTest2, CU_TRUE);
2235 CU_set_test_active(pTest4, CU_TRUE);
2236
2237 CU_set_suite_initfunc(pSuite1, &suite_fail);
2238 TEST(CUE_SINIT_FAILED == CU_run_suite(pSuite1)); /* change a suite init function */
2239 CU_set_suite_initfunc(pSuite1, NULL);
2240 test_results(0,1,0,0,0,0,0,0,0,1);
2241
2242 CU_set_suite_cleanupfunc(pSuite1, &suite_fail);
2243 TEST(CUE_SCLEAN_FAILED == CU_run_suite(pSuite1)); /* change a suite cleanup function */
2244 CU_set_suite_cleanupfunc(pSuite1, NULL);
2245 test_results(1,1,0,5,2,0,5,3,2,3);
2246
2247 CU_set_test_func(pTest1, &test_fail);
2248 CU_set_test_func(pTest3, &test_fail);
2249 CU_set_test_func(pTest5, &test_fail);
2250 TEST(CUE_SUCCESS == CU_run_suite(pSuite1)); /* change a test function */
2251 CU_set_test_func(pTest1, &test_succeed);
2252 CU_set_test_func(pTest3, &test_succeed);
2253 CU_set_test_func(pTest5, &test_succeed);
2254 test_results(1,0,0,5,5,0,5,0,5,5);
2255
2256 /* run each suite (CUEA_FAIL) */
2257 CU_set_error_action(CUEA_FAIL);
2258
2259 TEST(CUE_SUCCESS == CU_run_suite(pSuite1)); /* suite active */
2260 test_results(1,0,0,5,2,0,5,3,2,2);
2261
2262 TEST(CUE_SINIT_FAILED == CU_run_suite(pSuite2));
2263 test_results(0,1,0,0,0,0,0,0,0,1);
2264
2265 TEST(CUE_SCLEAN_FAILED == CU_run_suite(pSuite3));
2266 test_results(1,1,0,2,1,0,2,1,1,2);
2267
2268 TEST(CUE_SUCCESS == CU_run_suite(pSuite4));
2269 test_results(1,0,0,0,0,0,0,0,0,0);
2270
2271 CU_set_suite_active(pSuite1, CU_FALSE);
2272 CU_set_fail_on_inactive(CU_FALSE);
2273 TEST(CUE_SUCCESS == CU_run_suite(pSuite1)); /* suite inactive */
2274 test_results(0,0,1,0,0,0,0,0,0,0);
2275 CU_set_fail_on_inactive(CU_TRUE);
2276 TEST(CUE_SUITE_INACTIVE == CU_run_suite(pSuite1));
2277 test_results(0,0,1,0,0,0,0,0,0,1);
2278 CU_set_suite_active(pSuite1, CU_TRUE);
2279
2280 CU_set_test_active(pTest8, CU_FALSE);
2281 CU_set_test_active(pTest9, CU_FALSE);
2282 CU_set_fail_on_inactive(CU_FALSE);
2283 TEST(CUE_SCLEAN_FAILED == CU_run_suite(pSuite3)); /* all tests inactive */
2284 test_results(1,1,0,0,0,2,0,0,0,1);
2285 CU_set_fail_on_inactive(CU_TRUE);
2286 TEST(CUE_TEST_INACTIVE == CU_run_suite(pSuite3));
2287 test_results(1,1,0,0,0,1,0,0,0,2);
2288
2289 CU_set_test_active(pTest8, CU_TRUE);
2290 CU_set_test_active(pTest9, CU_FALSE);
2291 CU_set_fail_on_inactive(CU_FALSE);
2292 TEST(CUE_SCLEAN_FAILED == CU_run_suite(pSuite3)); /* some tests inactive */
2293 test_results(1,1,0,1,1,1,1,0,1,2);
2294 CU_set_fail_on_inactive(CU_TRUE);
2295 TEST(CUE_TEST_INACTIVE == CU_run_suite(pSuite3));
2296 test_results(1,1,0,1,1,1,1,0,1,3);
2297 CU_set_test_active(pTest9, CU_TRUE);
2298
2299 CU_set_suite_initfunc(pSuite2, NULL);
2300 TEST(CUE_SUCCESS == CU_run_suite(pSuite2)); /* change a suite init function */
2301 CU_set_suite_initfunc(pSuite2, &suite_fail);
2302 test_results(1,0,0,2,0,0,2,2,0,0);
2303
2304 CU_set_suite_cleanupfunc(pSuite1, &suite_fail);
2305 TEST(CUE_SCLEAN_FAILED == CU_run_suite(pSuite1)); /* change a suite cleanup function */
2306 CU_set_suite_cleanupfunc(pSuite1, NULL);
2307 test_results(1,1,0,5,2,0,5,3,2,3);
2308
2309 CU_set_test_func(pTest2, &test_succeed);
2310 CU_set_test_func(pTest4, &test_succeed);
2311 TEST(CUE_SUCCESS == CU_run_suite(pSuite1)); /* change a test function */
2312 CU_set_test_func(pTest2, &test_fail);
2313 CU_set_test_func(pTest4, &test_fail);
2314 test_results(1,0,0,5,0,0,5,5,0,0);
2315
2316 /* run each suite (CUEA_ABORT) */
2317 CU_set_error_action(CUEA_ABORT);
2318
2319 f_exit_called = CU_FALSE;
2320 TEST(CUE_SUCCESS == CU_run_suite(pSuite1)); /* suite active */
2321 TEST(CU_FALSE == f_exit_called);
2322 test_results(1,0,0,5,2,0,5,3,2,2);
2323
2324 f_exit_called = CU_FALSE;
2325 TEST(CUE_SINIT_FAILED == CU_run_suite(pSuite2));
2326 TEST(CU_TRUE == f_exit_called);
2327 f_exit_called = CU_FALSE;
2328 test_results(0,1,0,0,0,0,0,0,0,1);
2329
2330 f_exit_called = CU_FALSE;
2331 TEST(CUE_SCLEAN_FAILED == CU_run_suite(pSuite3));
2332 TEST(CU_TRUE == f_exit_called);
2333 test_results(1,1,0,2,1,0,2,1,1,2);
2334
2335 f_exit_called = CU_FALSE;
2336 TEST(CUE_SUCCESS == CU_run_suite(pSuite4));
2337 TEST(CU_FALSE == f_exit_called);
2338 test_results(1,0,0,0,0,0,0,0,0,0);
2339
2340 CU_set_suite_active(pSuite2, CU_FALSE);
2341 f_exit_called = CU_FALSE;
2342 CU_set_fail_on_inactive(CU_FALSE);
2343 TEST(CUE_SUCCESS == CU_run_suite(pSuite2)); /* suite inactive, but not a failure */
2344 TEST(CU_FALSE == f_exit_called);
2345 test_results(0,0,1,0,0,0,0,0,0,0);
2346 f_exit_called = CU_FALSE;
2347 CU_set_fail_on_inactive(CU_TRUE);
2348 TEST(CUE_SUITE_INACTIVE == CU_run_suite(pSuite2));
2349 TEST(CU_TRUE == f_exit_called);
2350 test_results(0,0,1,0,0,0,0,0,0,1);
2351 CU_set_suite_active(pSuite2, CU_TRUE);
2352
2353 CU_set_test_active(pTest8, CU_FALSE);
2354 CU_set_test_active(pTest9, CU_FALSE);
2355 f_exit_called = CU_FALSE;
2356 CU_set_fail_on_inactive(CU_FALSE);
2357 TEST(CUE_SCLEAN_FAILED == CU_run_suite(pSuite3)); /* all tests inactive */
2358 TEST(CU_TRUE == f_exit_called);
2359 test_results(1,1,0,0,0,2,0,0,0,1);
2360 f_exit_called = CU_FALSE;
2361 CU_set_fail_on_inactive(CU_TRUE);
2362 TEST(CUE_TEST_INACTIVE == CU_run_suite(pSuite3));
2363 TEST(CU_TRUE == f_exit_called);
2364 test_results(1,1,0,0,0,1,0,0,0,2);
2365
2366 CU_set_test_active(pTest8, CU_FALSE);
2367 CU_set_test_active(pTest9, CU_TRUE);
2368 f_exit_called = CU_FALSE;
2369 CU_set_fail_on_inactive(CU_FALSE);
2370 TEST(CUE_SCLEAN_FAILED == CU_run_suite(pSuite3)); /* some tests inactive */
2371 TEST(CU_TRUE == f_exit_called);
2372 test_results(1,1,0,1,0,1,1,1,0,1);
2373 f_exit_called = CU_FALSE;
2374 CU_set_fail_on_inactive(CU_TRUE);
2375 TEST(CUE_TEST_INACTIVE == CU_run_suite(pSuite3));
2376 TEST(CU_TRUE == f_exit_called);
2377 test_results(1,1,0,0,0,1,0,0,0,2);
2378 CU_set_test_active(pTest8, CU_TRUE);
2379
2380 f_exit_called = CU_FALSE;
2381 CU_set_suite_initfunc(pSuite1, &suite_fail);
2382 TEST(CUE_SINIT_FAILED == CU_run_suite(pSuite1)); /* change a suite init function */
2383 CU_set_suite_initfunc(pSuite1, NULL);
2384 TEST(CU_TRUE == f_exit_called);
2385 test_results(0,1,0,0,0,0,0,0,0,1);
2386
2387 f_exit_called = CU_FALSE;
2388 CU_set_suite_cleanupfunc(pSuite1, &suite_fail);
2389 TEST(CUE_SCLEAN_FAILED == CU_run_suite(pSuite1)); /* change a suite cleanup function */
2390 CU_set_suite_cleanupfunc(pSuite1, NULL);
2391 TEST(CU_TRUE == f_exit_called);
2392 test_results(1,1,0,5,2,0,5,3,2,3);
2393
2394 f_exit_called = CU_FALSE;
2395 CU_set_test_func(pTest8, &test_succeed);
2396 CU_set_test_func(pTest9, &test_fail);
2397 TEST(CUE_SCLEAN_FAILED == CU_run_suite(pSuite3)); /* change a test function */
2398 CU_set_test_func(pTest8, &test_fail);
2399 CU_set_test_func(pTest9, &test_succeed);
2400 TEST(CU_TRUE == f_exit_called);
2401 test_results(1,1,0,2,1,0,2,1,1,2);
2402
2403 /* clean up after testing */
2404 CU_set_error_action(CUEA_IGNORE);
2405 CU_cleanup_registry();
2406 }
2407
2408 /*-------------------------------------------------*/
test_CU_run_test(void)2409 static void test_CU_run_test(void)
2410 {
2411 CU_pSuite pSuite1 = NULL;
2412 CU_pSuite pSuite2 = NULL;
2413 CU_pSuite pSuite3 = NULL;
2414 CU_pTest pTest1 = NULL;
2415 CU_pTest pTest2 = NULL;
2416 CU_pTest pTest3 = NULL;
2417 CU_pTest pTest4 = NULL;
2418 CU_pTest pTest5 = NULL;
2419 CU_pTest pTest6 = NULL;
2420 CU_pTest pTest7 = NULL;
2421 CU_pTest pTest8 = NULL;
2422 CU_pTest pTest9 = NULL;
2423
2424 /* register some suites and tests */
2425 CU_initialize_registry();
2426 pSuite1 = CU_add_suite("suite1", NULL, NULL);
2427 pTest1 = CU_add_test(pSuite1, "test1", test_succeed);
2428 pTest2 = CU_add_test(pSuite1, "test2", test_fail);
2429 pTest3 = CU_add_test(pSuite1, "test3", test_succeed);
2430 pTest4 = CU_add_test(pSuite1, "test4", test_fail);
2431 pTest5 = CU_add_test(pSuite1, "test5", test_succeed);
2432 pSuite2 = CU_add_suite("suite2", suite_fail, NULL);
2433 pTest6 = CU_add_test(pSuite2, "test6", test_succeed);
2434 pTest7 = CU_add_test(pSuite2, "test7", test_succeed);
2435 pSuite3 = CU_add_suite("suite2", NULL, suite_fail); /* duplicate suite name OK */
2436 pTest8 = CU_add_test(pSuite3, "test8", test_fail);
2437 pTest9 = CU_add_test(pSuite3, "test8", test_succeed); /* duplicate test name OK */
2438
2439 TEST_FATAL(3 == CU_get_registry()->uiNumberOfSuites);
2440 TEST_FATAL(9 == CU_get_registry()->uiNumberOfTests);
2441
2442 /* error - NULL suite (CUEA_IGNORE) */
2443 CU_set_error_action(CUEA_IGNORE);
2444
2445 TEST(CUE_NOSUITE == CU_run_test(NULL, pTest1));
2446 TEST(CUE_NOSUITE == CU_get_error());
2447
2448 /* error - NULL suite (CUEA_FAIL) */
2449 CU_set_error_action(CUEA_FAIL);
2450
2451 TEST(CUE_NOSUITE == CU_run_test(NULL, pTest1));
2452 TEST(CUE_NOSUITE == CU_get_error());
2453
2454 /* error - NULL test (CUEA_ABORT) */
2455 CU_set_error_action(CUEA_ABORT);
2456
2457 f_exit_called = CU_FALSE;
2458 CU_run_test(NULL, pTest1);
2459 TEST(CU_TRUE == f_exit_called);
2460 f_exit_called = CU_FALSE;
2461
2462 /* error - NULL test (CUEA_IGNORE) */
2463 CU_set_error_action(CUEA_IGNORE);
2464
2465 TEST(CUE_NOTEST == CU_run_test(pSuite1, NULL));
2466 TEST(CUE_NOTEST == CU_get_error());
2467
2468 /* error - NULL test (CUEA_FAIL) */
2469 CU_set_error_action(CUEA_FAIL);
2470
2471 TEST(CUE_NOTEST == CU_run_test(pSuite1, NULL));
2472 TEST(CUE_NOTEST == CU_get_error());
2473
2474 /* error - NULL test (CUEA_ABORT) */
2475 CU_set_error_action(CUEA_ABORT);
2476
2477 f_exit_called = CU_FALSE;
2478 CU_run_test(pSuite1, NULL);
2479 TEST(CU_TRUE == f_exit_called);
2480 f_exit_called = CU_FALSE;
2481
2482 /* error - test not in suite (CUEA_IGNORE) */
2483 CU_set_error_action(CUEA_IGNORE);
2484
2485 TEST(CUE_TEST_NOT_IN_SUITE == CU_run_test(pSuite3, pTest1));
2486 TEST(CUE_TEST_NOT_IN_SUITE == CU_get_error());
2487
2488 /* error - NULL test (CUEA_FAIL) */
2489 CU_set_error_action(CUEA_FAIL);
2490
2491 TEST(CUE_TEST_NOT_IN_SUITE == CU_run_test(pSuite3, pTest1));
2492 TEST(CUE_TEST_NOT_IN_SUITE == CU_get_error());
2493
2494 /* error - NULL test (CUEA_ABORT) */
2495 CU_set_error_action(CUEA_ABORT);
2496
2497 f_exit_called = CU_FALSE;
2498 CU_run_test(pSuite3, pTest1);
2499 TEST(CU_TRUE == f_exit_called);
2500 f_exit_called = CU_FALSE;
2501
2502 /* run each test (CUEA_IGNORE) */
2503 CU_set_error_action(CUEA_IGNORE);
2504
2505 TEST(CUE_SUCCESS == CU_run_test(pSuite1, pTest1)); /* all suite/tests active */
2506 test_results(0,0,0,1,0,0,1,1,0,0);
2507
2508 TEST(CUE_SUCCESS == CU_run_test(pSuite1, pTest2));
2509 test_results(0,0,0,1,1,0,1,0,1,1);
2510
2511 TEST(CUE_SUCCESS == CU_run_test(pSuite1, pTest3));
2512 test_results(0,0,0,1,0,0,1,1,0,0);
2513
2514 TEST(CUE_SUCCESS == CU_run_test(pSuite1, pTest4));
2515 test_results(0,0,0,1,1,0,1,0,1,1);
2516
2517 TEST(CUE_SUCCESS == CU_run_test(pSuite1, pTest5));
2518 test_results(0,0,0,1,0,0,1,1,0,0);
2519
2520 TEST(CUE_SINIT_FAILED == CU_run_test(pSuite2, pTest6));
2521 test_results(0,1,0,0,0,0,0,0,0,1);
2522
2523 TEST(CUE_SINIT_FAILED == CU_run_test(pSuite2, pTest7));
2524 test_results(0,1,0,0,0,0,0,0,0,1);
2525
2526 TEST(CUE_SCLEAN_FAILED == CU_run_test(pSuite3, pTest8));
2527 test_results(0,1,0,1,1,0,1,0,1,2);
2528
2529 TEST(CUE_SCLEAN_FAILED == CU_run_test(pSuite3, pTest9));
2530 test_results(0,1,0,1,0,0,1,1,0,1);
2531
2532 CU_set_suite_active(pSuite1, CU_FALSE);
2533 CU_set_fail_on_inactive(CU_FALSE);
2534 TEST(CUE_SUITE_INACTIVE == CU_run_test(pSuite1, pTest1)); /* suite inactive */
2535 test_results(0,0,1,0,0,0,0,0,0,0);
2536 CU_set_fail_on_inactive(CU_TRUE);
2537 TEST(CUE_SUITE_INACTIVE == CU_run_test(pSuite1, pTest1));
2538 test_results(0,0,1,0,0,0,0,0,0,1);
2539 CU_set_suite_active(pSuite1, CU_TRUE);
2540
2541 CU_set_test_active(pTest1, CU_FALSE);
2542 CU_set_fail_on_inactive(CU_FALSE);
2543 TEST(CUE_TEST_INACTIVE == CU_run_test(pSuite1, pTest1)); /* test inactive */
2544 test_results(0,0,0,0,0,1,0,0,0,0);
2545 CU_set_fail_on_inactive(CU_TRUE);
2546 TEST(CUE_TEST_INACTIVE == CU_run_test(pSuite1, pTest1));
2547 test_results(0,0,0,0,1,1,0,0,0,1);
2548 CU_set_test_active(pTest1, CU_TRUE);
2549
2550 CU_set_suite_initfunc(pSuite1, &suite_fail);
2551 TEST(CUE_SINIT_FAILED == CU_run_test(pSuite1, pTest1)); /* change a suite init function */
2552 CU_set_suite_initfunc(pSuite1, NULL);
2553 test_results(0,1,0,0,0,0,0,0,0,1);
2554
2555 CU_set_suite_cleanupfunc(pSuite1, &suite_fail);
2556 TEST(CUE_SCLEAN_FAILED == CU_run_test(pSuite1, pTest1)); /* change a suite cleanup function */
2557 CU_set_suite_cleanupfunc(pSuite1, NULL);
2558 test_results(0,1,0,1,0,0,1,1,0,1);
2559
2560 CU_set_test_func(pTest8, &test_succeed);
2561 TEST(CUE_SCLEAN_FAILED == CU_run_test(pSuite3, pTest8)); /* change a test function */
2562 CU_set_test_func(pTest8, &test_fail);
2563 test_results(0,1,0,1,0,0,1,1,0,1);
2564
2565 /* run each test (CUEA_FAIL) */
2566 CU_set_error_action(CUEA_FAIL);
2567
2568 TEST(CUE_SUCCESS == CU_run_test(pSuite1, pTest1)); /* suite/test active */
2569 test_results(0,0,0,1,0,0,1,1,0,0);
2570
2571 TEST(CUE_SUCCESS == CU_run_test(pSuite1, pTest2));
2572 test_results(0,0,0,1,1,0,1,0,1,1);
2573
2574 TEST(CUE_SUCCESS == CU_run_test(pSuite1, pTest3));
2575 test_results(0,0,0,1,0,0,1,1,0,0);
2576
2577 TEST(CUE_SUCCESS == CU_run_test(pSuite1, pTest4));
2578 test_results(0,0,0,1,1,0,1,0,1,1);
2579
2580 TEST(CUE_SUCCESS == CU_run_test(pSuite1, pTest5));
2581 test_results(0,0,0,1,0,0,1,1,0,0);
2582
2583 TEST(CUE_SINIT_FAILED == CU_run_test(pSuite2, pTest6));
2584 test_results(0,1,0,0,0,0,0,0,0,1);
2585
2586 TEST(CUE_SINIT_FAILED == CU_run_test(pSuite2, pTest7));
2587 test_results(0,1,0,0,0,0,0,0,0,1);
2588
2589 TEST(CUE_SCLEAN_FAILED == CU_run_test(pSuite3, pTest8));
2590 test_results(0,1,0,1,1,0,1,0,1,2);
2591
2592 TEST(CUE_SCLEAN_FAILED == CU_run_test(pSuite3, pTest9));
2593 test_results(0,1,0,1,0,0,1,1,0,1);
2594
2595 CU_set_suite_active(pSuite2, CU_FALSE);
2596 CU_set_fail_on_inactive(CU_FALSE);
2597 TEST(CUE_SUITE_INACTIVE == CU_run_test(pSuite2, pTest7)); /* suite inactive */
2598 test_results(0,0,1,0,0,0,0,0,0,0);
2599 CU_set_fail_on_inactive(CU_TRUE);
2600 TEST(CUE_SUITE_INACTIVE == CU_run_test(pSuite2, pTest7));
2601 test_results(0,0,1,0,0,0,0,0,0,1);
2602 CU_set_suite_active(pSuite2, CU_TRUE);
2603
2604 CU_set_test_active(pTest7, CU_FALSE);
2605 CU_set_fail_on_inactive(CU_FALSE);
2606 TEST(CUE_SINIT_FAILED == CU_run_test(pSuite2, pTest7)); /* test inactive */
2607 test_results(0,1,0,0,0,0,0,0,0,1);
2608 CU_set_fail_on_inactive(CU_TRUE);
2609 TEST(CUE_SINIT_FAILED == CU_run_test(pSuite2, pTest7));
2610 test_results(0,1,0,0,0,0,0,0,0,1);
2611 CU_set_test_active(pTest7, CU_TRUE);
2612
2613 CU_set_suite_initfunc(pSuite2, NULL);
2614 TEST(CUE_SUCCESS == CU_run_test(pSuite2, pTest6)); /* change a suite init function */
2615 CU_set_suite_initfunc(pSuite2, &suite_fail);
2616 test_results(0,0,0,1,0,0,1,1,0,0);
2617
2618 CU_set_suite_cleanupfunc(pSuite3, NULL);
2619 TEST(CUE_SUCCESS == CU_run_test(pSuite3, pTest8)); /* change a suite cleanup function */
2620 CU_set_suite_cleanupfunc(pSuite3, &suite_fail);
2621 test_results(0,0,0,1,1,0,1,0,1,1);
2622
2623 CU_set_test_func(pTest8, &test_succeed);
2624 TEST(CUE_SCLEAN_FAILED == CU_run_test(pSuite3, pTest8)); /* change a test function */
2625 CU_set_test_func(pTest8, &test_fail);
2626 test_results(0,1,0,1,0,0,1,1,0,1);
2627
2628 /* run each test (CUEA_ABORT) */
2629 CU_set_error_action(CUEA_ABORT);
2630
2631 f_exit_called = CU_FALSE;
2632 TEST(CUE_SUCCESS == CU_run_test(pSuite1, pTest1));
2633 TEST(CU_FALSE == f_exit_called);
2634 test_results(0,0,0,1,0,0,1,1,0,0);
2635
2636 f_exit_called = CU_FALSE;
2637 TEST(CUE_SUCCESS == CU_run_test(pSuite1, pTest2));
2638 TEST(CU_FALSE == f_exit_called);
2639 test_results(0,0,0,1,1,0,1,0,1,1);
2640
2641 f_exit_called = CU_FALSE;
2642 TEST(CUE_SUCCESS == CU_run_test(pSuite1, pTest3));
2643 TEST(CU_FALSE == f_exit_called);
2644 test_results(0,0,0,1,0,0,1,1,0,0);
2645
2646 f_exit_called = CU_FALSE;
2647 TEST(CUE_SUCCESS == CU_run_test(pSuite1, pTest4));
2648 TEST(CU_FALSE == f_exit_called);
2649 test_results(0,0,0,1,1,0,1,0,1,1);
2650
2651 f_exit_called = CU_FALSE;
2652 TEST(CUE_SUCCESS == CU_run_test(pSuite1, pTest5));
2653 TEST(CU_FALSE == f_exit_called);
2654 test_results(0,0,0,1,0,0,1,1,0,0);
2655
2656 f_exit_called = CU_FALSE;
2657 TEST(CUE_SINIT_FAILED == CU_run_test(pSuite2, pTest6));
2658 TEST(CU_TRUE == f_exit_called);
2659 test_results(0,1,0,0,0,0,0,0,0,1);
2660
2661 f_exit_called = CU_FALSE;
2662 TEST(CUE_SINIT_FAILED == CU_run_test(pSuite2, pTest7));
2663 TEST(CU_TRUE == f_exit_called);
2664 test_results(0,1,0,0,0,0,0,0,0,1);
2665
2666 f_exit_called = CU_FALSE;
2667 TEST(CUE_SCLEAN_FAILED == CU_run_test(pSuite3, pTest8));
2668 TEST(CU_TRUE == f_exit_called);
2669 test_results(0,1,0,1,1,0,1,0,1,2);
2670
2671 f_exit_called = CU_FALSE;
2672 TEST(CUE_SCLEAN_FAILED == CU_run_test(pSuite3, pTest9));
2673 TEST(CU_TRUE == f_exit_called);
2674 test_results(0,1,0,1,0,0,1,1,0,1);
2675
2676 CU_set_suite_active(pSuite2, CU_FALSE);
2677 CU_set_fail_on_inactive(CU_FALSE);
2678 f_exit_called = CU_FALSE;
2679 TEST(CUE_SUITE_INACTIVE == CU_run_test(pSuite2, pTest6)); /* suite inactive */
2680 TEST(CU_TRUE == f_exit_called);
2681 test_results(0,0,1,0,0,0,0,0,0,0);
2682 CU_set_fail_on_inactive(CU_TRUE);
2683 f_exit_called = CU_FALSE;
2684 TEST(CUE_SUITE_INACTIVE == CU_run_test(pSuite2, pTest6));
2685 TEST(CU_TRUE == f_exit_called);
2686 test_results(0,0,1,0,0,0,0,0,0,1);
2687 CU_set_suite_active(pSuite2, CU_TRUE);
2688
2689 CU_set_test_active(pTest6, CU_FALSE);
2690 CU_set_fail_on_inactive(CU_FALSE);
2691 f_exit_called = CU_FALSE;
2692 TEST(CUE_SINIT_FAILED == CU_run_test(pSuite2, pTest6)); /* test inactive */
2693 TEST(CU_TRUE == f_exit_called);
2694 test_results(0,1,0,0,0,0,0,0,0,1);
2695 CU_set_fail_on_inactive(CU_TRUE);
2696 f_exit_called = CU_FALSE;
2697 TEST(CUE_SINIT_FAILED == CU_run_test(pSuite2, pTest6));
2698 TEST(CU_TRUE == f_exit_called);
2699 test_results(0,1,0,0,0,0,0,0,0,1);
2700 CU_set_test_active(pTest6, CU_TRUE);
2701
2702 f_exit_called = CU_FALSE;
2703 CU_set_suite_initfunc(pSuite2, NULL);
2704 TEST(CUE_SUCCESS == CU_run_test(pSuite2, pTest6)); /* change a suite init function */
2705 CU_set_suite_initfunc(pSuite2, &suite_fail);
2706 TEST(CU_FALSE == f_exit_called);
2707 test_results(0,0,0,1,0,0,1,1,0,0);
2708
2709 f_exit_called = CU_FALSE;
2710 CU_set_suite_cleanupfunc(pSuite1, &suite_fail);
2711 TEST(CUE_SCLEAN_FAILED == CU_run_test(pSuite1, pTest1)); /* change a suite cleanup function */
2712 CU_set_suite_cleanupfunc(pSuite1, NULL);
2713 TEST(CU_TRUE == f_exit_called);
2714 test_results(0,1,0,1,0,0,1,1,0,1);
2715
2716 f_exit_called = CU_FALSE;
2717 CU_set_test_func(pTest8, &test_succeed);
2718 TEST(CUE_SCLEAN_FAILED == CU_run_test(pSuite3, pTest8)); /* change a test function */
2719 CU_set_test_func(pTest8, &test_fail);
2720 TEST(CU_TRUE == f_exit_called);
2721 test_results(0,1,0,1,0,0,1,1,0,1);
2722
2723 /* clean up after testing */
2724 CU_set_error_action(CUEA_IGNORE);
2725 CU_cleanup_registry();
2726 }
2727
2728 /*-------------------------------------------------*/
2729 /* tests CU_assertImplementation()
2730 * CU_get_failure_list()
2731 * CU_clear_previous_results()
2732 */
test_CU_assertImplementation(void)2733 static void test_CU_assertImplementation(void)
2734 {
2735 CU_Test dummy_test;
2736 CU_Suite dummy_suite;
2737 CU_pFailureRecord pFailure1 = NULL;
2738 CU_pFailureRecord pFailure2 = NULL;
2739 CU_pFailureRecord pFailure3 = NULL;
2740 CU_pFailureRecord pFailure4 = NULL;
2741 CU_pFailureRecord pFailure5 = NULL;
2742 CU_pFailureRecord pFailure6 = NULL;
2743
2744 CU_clear_previous_results();
2745
2746 TEST(NULL == CU_get_failure_list());
2747 TEST(0 == CU_get_number_of_asserts());
2748 TEST(0 == CU_get_number_of_failures());
2749 TEST(0 == CU_get_number_of_failure_records());
2750
2751 /* fool CU_assertImplementation into thinking test run is in progress */
2752 f_pCurTest = &dummy_test;
2753 f_pCurSuite = &dummy_suite;
2754
2755 /* asserted value is CU_TRUE*/
2756 TEST(CU_TRUE == CU_assertImplementation(CU_TRUE, 100, "Nothing happened 0.", "dummy0.c", "dummy_func0", CU_FALSE));
2757
2758 TEST(NULL == CU_get_failure_list());
2759 TEST(1 == CU_get_number_of_asserts());
2760 TEST(0 == CU_get_number_of_failures());
2761 TEST(0 == CU_get_number_of_failure_records());
2762
2763 TEST(CU_TRUE == CU_assertImplementation(CU_TRUE, 101, "Nothing happened 1.", "dummy1.c", "dummy_func1", CU_FALSE));
2764
2765 TEST(NULL == CU_get_failure_list());
2766 TEST(2 == CU_get_number_of_asserts());
2767 TEST(0 == CU_get_number_of_failures());
2768 TEST(0 == CU_get_number_of_failure_records());
2769
2770 /* asserted value is CU_FALSE */
2771 TEST(CU_FALSE == CU_assertImplementation(CU_FALSE, 102, "Something happened 2.", "dummy2.c", "dummy_func2", CU_FALSE));
2772
2773 TEST(NULL != CU_get_failure_list());
2774 TEST(3 == CU_get_number_of_asserts());
2775 TEST(1 == CU_get_number_of_failures());
2776 TEST(1 == CU_get_number_of_failure_records());
2777
2778 TEST(CU_FALSE == CU_assertImplementation(CU_FALSE, 103, "Something happened 3.", "dummy3.c", "dummy_func3", CU_FALSE));
2779
2780 TEST(NULL != CU_get_failure_list());
2781 TEST(4 == CU_get_number_of_asserts());
2782 TEST(2 == CU_get_number_of_failures());
2783 TEST(2 == CU_get_number_of_failure_records());
2784
2785 TEST(CU_FALSE == CU_assertImplementation(CU_FALSE, 104, "Something happened 4.", "dummy4.c", "dummy_func4", CU_FALSE));
2786
2787 TEST(NULL != CU_get_failure_list());
2788 TEST(5 == CU_get_number_of_asserts());
2789 TEST(3 == CU_get_number_of_failures());
2790 TEST(3 == CU_get_number_of_failure_records());
2791
2792 if (3 == CU_get_number_of_failure_records()) {
2793 pFailure1 = CU_get_failure_list();
2794 TEST(102 == pFailure1->uiLineNumber);
2795 TEST(!strcmp("dummy2.c", pFailure1->strFileName));
2796 TEST(!strcmp("Something happened 2.", pFailure1->strCondition));
2797 TEST(&dummy_test == pFailure1->pTest);
2798 TEST(&dummy_suite == pFailure1->pSuite);
2799 TEST(NULL != pFailure1->pNext);
2800 TEST(NULL == pFailure1->pPrev);
2801
2802 pFailure2 = pFailure1->pNext;
2803 TEST(103 == pFailure2->uiLineNumber);
2804 TEST(!strcmp("dummy3.c", pFailure2->strFileName));
2805 TEST(!strcmp("Something happened 3.", pFailure2->strCondition));
2806 TEST(&dummy_test == pFailure2->pTest);
2807 TEST(&dummy_suite == pFailure2->pSuite);
2808 TEST(NULL != pFailure2->pNext);
2809 TEST(pFailure1 == pFailure2->pPrev);
2810
2811 pFailure3 = pFailure2->pNext;
2812 TEST(104 == pFailure3->uiLineNumber);
2813 TEST(!strcmp("dummy4.c", pFailure3->strFileName));
2814 TEST(!strcmp("Something happened 4.", pFailure3->strCondition));
2815 TEST(&dummy_test == pFailure3->pTest);
2816 TEST(&dummy_suite == pFailure3->pSuite);
2817 TEST(NULL == pFailure3->pNext);
2818 TEST(pFailure2 == pFailure3->pPrev);
2819 }
2820 else
2821 FAIL("Unexpected number of failure records.");
2822
2823 /* confirm destruction of failure records */
2824 pFailure4 = pFailure1;
2825 pFailure5 = pFailure2;
2826 pFailure6 = pFailure3;
2827 TEST(0 != test_bcunit_get_n_memevents(pFailure4));
2828 TEST(test_bcunit_get_n_allocations(pFailure4) != test_bcunit_get_n_deallocations(pFailure4));
2829 TEST(0 != test_bcunit_get_n_memevents(pFailure5));
2830 TEST(test_bcunit_get_n_allocations(pFailure5) != test_bcunit_get_n_deallocations(pFailure5));
2831 TEST(0 != test_bcunit_get_n_memevents(pFailure6));
2832 TEST(test_bcunit_get_n_allocations(pFailure6) != test_bcunit_get_n_deallocations(pFailure6));
2833
2834 CU_clear_previous_results();
2835 TEST(0 != test_bcunit_get_n_memevents(pFailure4));
2836 TEST(test_bcunit_get_n_allocations(pFailure4) == test_bcunit_get_n_deallocations(pFailure4));
2837 TEST(0 != test_bcunit_get_n_memevents(pFailure5));
2838 TEST(test_bcunit_get_n_allocations(pFailure5) == test_bcunit_get_n_deallocations(pFailure5));
2839 TEST(0 != test_bcunit_get_n_memevents(pFailure6));
2840 TEST(test_bcunit_get_n_allocations(pFailure6) == test_bcunit_get_n_deallocations(pFailure6));
2841 TEST(0 == CU_get_number_of_asserts());
2842 TEST(0 == CU_get_number_of_successes());
2843 TEST(0 == CU_get_number_of_failures());
2844 TEST(0 == CU_get_number_of_failure_records());
2845
2846 f_pCurTest = NULL;
2847 f_pCurSuite = NULL;
2848 }
2849
2850 /*-------------------------------------------------*/
test_add_failure(void)2851 static void test_add_failure(void)
2852 {
2853 CU_Test test1;
2854 CU_Suite suite1;
2855 CU_pFailureRecord pFailure1 = NULL;
2856 CU_pFailureRecord pFailure2 = NULL;
2857 CU_pFailureRecord pFailure3 = NULL;
2858 CU_pFailureRecord pFailure4 = NULL;
2859 CU_RunSummary run_summary = {"", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
2860
2861 /* test under memory exhaustion */
2862 test_bcunit_deactivate_malloc();
2863 add_failure(&pFailure1, &run_summary, CUF_AssertFailed, 100, "condition 0", "file0.c", &suite1, &test1);
2864 TEST(NULL == pFailure1);
2865 TEST(0 == run_summary.nFailureRecords);
2866 test_bcunit_activate_malloc();
2867
2868 /* normal operation */
2869 add_failure(&pFailure1, &run_summary, CUF_AssertFailed, 101, "condition 1", "file1.c", &suite1, &test1);
2870 TEST(1 == run_summary.nFailureRecords);
2871 if (TEST(NULL != pFailure1)) {
2872 TEST(101 == pFailure1->uiLineNumber);
2873 TEST(!strcmp("condition 1", pFailure1->strCondition));
2874 TEST(!strcmp("file1.c", pFailure1->strFileName));
2875 TEST(&test1 == pFailure1->pTest);
2876 TEST(&suite1 == pFailure1->pSuite);
2877 TEST(NULL == pFailure1->pNext);
2878 TEST(NULL == pFailure1->pPrev);
2879 TEST(pFailure1 == f_last_failure);
2880 TEST(0 != test_bcunit_get_n_memevents(pFailure1));
2881 TEST(test_bcunit_get_n_allocations(pFailure1) != test_bcunit_get_n_deallocations(pFailure1));
2882 }
2883
2884 add_failure(&pFailure1, &run_summary, CUF_AssertFailed, 102, "condition 2", "file2.c", NULL, &test1);
2885 TEST(2 == run_summary.nFailureRecords);
2886 if (TEST(NULL != pFailure1)) {
2887 TEST(101 == pFailure1->uiLineNumber);
2888 TEST(!strcmp("condition 1", pFailure1->strCondition));
2889 TEST(!strcmp("file1.c", pFailure1->strFileName));
2890 TEST(&test1 == pFailure1->pTest);
2891 TEST(&suite1 == pFailure1->pSuite);
2892 TEST(NULL != pFailure1->pNext);
2893 TEST(NULL == pFailure1->pPrev);
2894 TEST(pFailure1 != f_last_failure);
2895 TEST(0 != test_bcunit_get_n_memevents(pFailure1));
2896 TEST(test_bcunit_get_n_allocations(pFailure1) != test_bcunit_get_n_deallocations(pFailure1));
2897
2898 if (TEST(NULL != (pFailure2 = pFailure1->pNext))) {
2899 TEST(102 == pFailure2->uiLineNumber);
2900 TEST(!strcmp("condition 2", pFailure2->strCondition));
2901 TEST(!strcmp("file2.c", pFailure2->strFileName));
2902 TEST(&test1 == pFailure2->pTest);
2903 TEST(NULL == pFailure2->pSuite);
2904 TEST(NULL == pFailure2->pNext);
2905 TEST(pFailure1 == pFailure2->pPrev);
2906 TEST(pFailure2 == f_last_failure);
2907 TEST(0 != test_bcunit_get_n_memevents(pFailure2));
2908 TEST(test_bcunit_get_n_allocations(pFailure2) != test_bcunit_get_n_deallocations(pFailure2));
2909 }
2910 }
2911
2912 pFailure3 = pFailure1;
2913 pFailure4 = pFailure2;
2914 clear_previous_results(&run_summary, &pFailure1);
2915
2916 TEST(0 == run_summary.nFailureRecords);
2917 TEST(0 != test_bcunit_get_n_memevents(pFailure3));
2918 TEST(test_bcunit_get_n_allocations(pFailure3) == test_bcunit_get_n_deallocations(pFailure3));
2919 TEST(0 != test_bcunit_get_n_memevents(pFailure4));
2920 TEST(test_bcunit_get_n_allocations(pFailure4) == test_bcunit_get_n_deallocations(pFailure4));
2921 }
2922
2923 /*-------------------------------------------------*/
test_bcunit_TestRun(void)2924 void test_bcunit_TestRun(void)
2925 {
2926 test_bcunit_start_tests("TestRun.c");
2927
2928 test_message_handlers();
2929 test_CU_fail_on_inactive();
2930 test_CU_run_all_tests();
2931 test_CU_run_suite();
2932 test_CU_run_test();
2933 test_CU_assertImplementation();
2934 test_add_failure();
2935
2936 test_bcunit_end_tests();
2937 }
2938
2939 #endif /* BCUNIT_BUILD_TESTS */
2940