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