/* call the suite initialization function, if any */  if ((pSuite->pInitializeFunc) && (*pSuite->pInitializeFunc)()) {    if (f_pSuiteInitFailureMessageHandler) {      (*f_pSuiteInitFailureMessageHandler)(pSuite);    }    pRunSummary->nSuitesFailed++;    add_failure(&f_failure_list, &f_run_summary,                0, "Suite Initialization failed - Suite Skipped", "CUnit System", pSuite, NULL);    CU_set_error(result = CUE_SINIT_FAILED);  }  /* reach here if no suite initialization, or if it succeeded */  else {    pTest = pSuite->pTest;    while (pTest && (!result || (CU_get_error_action() == CUEA_IGNORE))) {      result2 = run_single_test(pTest, pRunSummary);      result = (CUE_SUCCESS == result) ? result2 : result;      pTest = pTest->pNext;    }    pRunSummary->nSuitesRun++;    /* call the suite cleanup function, if any */    if ((pSuite->pCleanupFunc) && (*pSuite->pCleanupFunc)()) {      pRunSummary->nSuitesFailed++;      add_failure(&f_failure_list, &f_run_summary,                  0, "Suite cleanup failed.", "CUnit System", pSuite, pTest);      CU_set_error(CUE_SCLEAN_FAILED);      result = (CUE_SUCCESS == result) ? CUE_SCLEAN_FAILED : result;    }  }  f_pCurSuite = NULL;  return result;}/*------------------------------------------------------------------------*//** Run a specific test. * Internal function to run a test case.  This includes * calling any handler to be run before executing the test, * running the test's function (if any), and calling any * handler to be run after executing a test. * @param pTest The test to be run (non-NULL). * @param pRunSummary The CU_RunSummary to receive the results (non-NULL). * @return A CU_ErrorCode indicating the status of the run. * @see CU_run_test() for public interface function. * @see CU_run_all_tests() for running all suites. */CU_ErrorCode run_single_test(CU_pTest pTest, CU_pRunSummary pRunSummary){  unsigned int nStartFailures;  /* keep track of the last failure BEFORE running the test */  CU_pFailureRecord pLastFailure = f_last_failure;  jmp_buf buf;  assert(pTest);  assert(pRunSummary);  nStartFailures = pRunSummary->nAssertsFailed;  CU_set_error(CUE_SUCCESS);  f_pCurTest = pTest;  if (f_pTestStartMessageHandler)    (*f_pTestStartMessageHandler)(f_pCurTest, f_pCurSuite);  /* set jmp_buf and run test */  pTest->pJumpBuf = &buf;  if (!setjmp(buf))    if (pTest->pTestFunc)      (*pTest->pTestFunc)();  pRunSummary->nTestsRun++;  /* if additional assertions have failed... */  if (pRunSummary->nAssertsFailed > nStartFailures) {    pRunSummary->nTestsFailed++;    if (pLastFailure)      pLastFailure = pLastFailure->pNext;  /* was a failure before - go to next one */    else      pLastFailure = f_failure_list;       /* no previous failure - go to 1st one */  }  else    pLastFailure = NULL;                   /* no additional failure - set to NULL */  if (f_pTestCompleteMessageHandler)    (*f_pTestCompleteMessageHandler)(f_pCurTest, f_pCurSuite, pLastFailure);  pTest->pJumpBuf = NULL;  f_pCurTest = NULL;  return CU_get_error();}/** @} */#ifdef CUNIT_BUILD_TESTS#include "test_cunit.h"typedef enum TET {  TEST_START = 1,  TEST_COMPLETE,  ALL_TESTS_COMPLETE,  SUITE_INIT_FAILED,} TestEventType;typedef struct TE {  TestEventType     type;  CU_pSuite         pSuite;  CU_pTest          pTest;  CU_pFailureRecord pFailure;  struct TE *       pNext;} TestEvent, * pTestEvent;static int f_nTestEvents = 0;static pTestEvent f_pFirstEvent = NULL;static void add_test_event(TestEventType type, CU_pSuite psuite,                           CU_pTest ptest, CU_pFailureRecord pfailure){  pTestEvent pNewEvent = (pTestEvent)malloc(sizeof(TestEvent));  pTestEvent pNextEvent = NULL;  pNewEvent->type = type;  pNewEvent->pSuite = psuite;  pNewEvent->pTest = ptest;  pNewEvent->pFailure = pfailure;  pNewEvent->pNext = NULL;  pNextEvent = f_pFirstEvent;  if (pNextEvent) {    while (pNextEvent->pNext) {      pNextEvent = pNextEvent->pNext;    }    pNextEvent->pNext = pNewEvent;  }  else {    f_pFirstEvent = pNewEvent;  }  ++f_nTestEvents;}static void clear_test_events(void){  pTestEvent pCurrentEvent = f_pFirstEvent;  pTestEvent pNextEvent = NULL;  while (pCurrentEvent) {    pNextEvent = pCurrentEvent->pNext;    free(pCurrentEvent);    pCurrentEvent = pNextEvent;  }  f_pFirstEvent = NULL;  f_nTestEvents = 0;}static void test_start_handler(const CU_pTest pTest, const CU_pSuite pSuite){  TEST(CU_is_test_running());  TEST(pSuite == CU_get_current_suite());  TEST(pTest == CU_get_current_test());  add_test_event(TEST_START, pSuite, pTest, NULL);}static void test_complete_handler(const CU_pTest pTest, const CU_pSuite pSuite,                                  const CU_pFailureRecord pFailure){  TEST(CU_is_test_running());  TEST(pSuite == CU_get_current_suite());  TEST(pTest == CU_get_current_test());  add_test_event(TEST_COMPLETE, pSuite, pTest, pFailure);}static void test_all_complete_handler(const CU_pFailureRecord pFailure){  TEST(!CU_is_test_running());  add_test_event(ALL_TESTS_COMPLETE, NULL, NULL, pFailure);}static void suite_init_failure_handler(const CU_pSuite pSuite){  TEST(CU_is_test_running());  TEST(pSuite == CU_get_current_suite());  add_test_event(SUITE_INIT_FAILED, pSuite, NULL, NULL);}void test_succeed(void) { CU_TEST(TRUE); }void test_fail(void) { CU_TEST(FALSE); }int suite_fail(void) { return 1; }/*-------------------------------------------------*//* tests: *    CU_set_test_start_handler() *    CU_set_test_complete_handler() *    CU_set_all_test_complete_handler() *    CU_set_suite_init_failure_handler() *    CU_get_test_start_handler() *    CU_get_test_complete_handler() *    CU_get_all_test_complete_handler() *    CU_get_suite_init_failure_handler() */static void test_message_handlers(void){  CU_pSuite pSuite1 = NULL;  CU_pSuite pSuite2 = NULL;  CU_pTest  pTest1 = NULL;  CU_pTest  pTest2 = NULL;  CU_pTest  pTest3 = NULL;  pTestEvent pEvent = NULL;  CU_pRunSummary pRunSummary = NULL;  TEST(!CU_is_test_running());  /* handlers should be NULL on startup */  TEST(NULL == CU_get_test_start_handler());  TEST(NULL == CU_get_test_complete_handler());  TEST(NULL == CU_get_all_test_complete_handler());  TEST(NULL == CU_get_suite_init_failure_handler());  /* register some suites and tests */  CU_initialize_registry();  pSuite1 = CU_add_suite("suite1", NULL, NULL);  pTest1 = CU_add_test(pSuite1, "test1", test_succeed);  pTest2 = CU_add_test(pSuite1, "test2", test_fail);  pTest3 = CU_add_test(pSuite1, "test3", test_succeed);  pSuite2 = CU_add_suite("suite2", suite_fail, NULL);  CU_add_test(pSuite2, "test4", test_succeed);  TEST_FATAL(CUE_SUCCESS == CU_get_error());  /* first run tests without handlers set */  clear_test_events();  CU_run_all_tests();  TEST(0 == f_nTestEvents);  TEST(NULL == f_pFirstEvent);  TEST(1 == CU_get_number_of_suites_run());  TEST(1 == CU_get_number_of_suites_failed());  TEST(3 == CU_get_number_of_tests_run());  TEST(1 == CU_get_number_of_tests_failed());  TEST(3 == CU_get_number_of_asserts());  TEST(2 == CU_get_number_of_successes());  TEST(1 == CU_get_number_of_failures());  TEST(2 == CU_get_number_of_failure_records());  pRunSummary = CU_get_run_summary();  TEST(pRunSummary->nSuitesRun      == CU_get_number_of_suites_run());  TEST(pRunSummary->nSuitesFailed   == CU_get_number_of_suites_failed());  TEST(pRunSummary->nTestsRun       == CU_get_number_of_tests_run());  TEST(pRunSummary->nTestsFailed    == CU_get_number_of_tests_failed());  TEST(pRunSummary->nAsserts        == CU_get_number_of_asserts());  TEST(pRunSummary->nAssertsFailed  == CU_get_number_of_failures());  TEST(pRunSummary->nFailureRecords == CU_get_number_of_failure_records());  /* set handlers to local functions */  CU_set_test_start_handler(test_start_handler);  CU_set_test_complete_handler(test_complete_handler);  CU_set_all_test_complete_handler(test_all_complete_handler);  CU_set_suite_init_failure_handler(suite_init_failure_handler);  /* confirm handlers set properly */  TEST(test_start_handler == CU_get_test_start_handler());  TEST(test_complete_handler == CU_get_test_complete_handler());  TEST(test_all_complete_handler == CU_get_all_test_complete_handler());  TEST(suite_init_failure_handler == CU_get_suite_init_failure_handler());  /* run tests again with handlers set */  clear_test_events();  CU_run_all_tests();  TEST(8 == f_nTestEvents);  if (8 == f_nTestEvents) {    pEvent = f_pFirstEvent;    TEST(TEST_START == pEvent->type);    TEST(pSuite1 == pEvent->pSuite);    TEST(pTest1 == pEvent->pTest);    TEST(NULL == pEvent->pFailure);    pEvent = pEvent->pNext;    TEST(TEST_COMPLETE == pEvent->type);    TEST(pSuite1 == pEvent->pSuite);    TEST(pTest1 == pEvent->pTest);    TEST(NULL == pEvent->pFailure);    pEvent = pEvent->pNext;    TEST(TEST_START == pEvent->type);    TEST(pSuite1 == pEvent->pSuite);    TEST(pTest2 == pEvent->pTest);    TEST(NULL == pEvent->pFailure);    pEvent = pEvent->pNext;    TEST(TEST_COMPLETE == pEvent->type);    TEST(pSuite1 == pEvent->pSuite);    TEST(pTest2 == pEvent->pTest);    TEST(NULL != pEvent->pFailure);    pEvent = pEvent->pNext;    TEST(TEST_START == pEvent->type);    TEST(pSuite1 == pEvent->pSuite);    TEST(pTest3 == pEvent->pTest);    TEST(NULL == pEvent->pFailure);    pEvent = pEvent->pNext;    TEST(TEST_COMPLETE == pEvent->type);    TEST(pSuite1 == pEvent->pSuite);    TEST(pTest3 == pEvent->pTest);    TEST(NULL == pEvent->pFailure);    pEvent = pEvent->pNext;    TEST(SUITE_INIT_FAILED == pEvent->type);    TEST(pSuite2 == pEvent->pSuite);    TEST(NULL == pEvent->pTest);    TEST(NULL == pEvent->pFailure);    pEvent = pEvent->pNext;    TEST(ALL_TESTS_COMPLETE == pEvent->type);    TEST(NULL == pEvent->pSuite);    TEST(NULL == pEvent->pTest);    TEST(NULL != pEvent->pFailure);    TEST(NULL != pEvent->pFailure->pNext);    TEST(NULL == pEvent->pFailure->pNext->pNext);    TEST(pEvent->pFailure == CU_get_failure_list());  }  TEST(1 == CU_get_number_of_suites_run());  TEST(1 == CU_get_number_of_suites_failed());  TEST(3 == CU_get_number_of_tests_run());  TEST(1 == CU_get_number_of_tests_failed());  TEST(3 == CU_get_number_of_asserts());  TEST(2 == CU_get_number_of_successes());  TEST(1 == CU_get_number_of_failures());  TEST(2 == CU_get_number_of_failure_records());  pRunSummary = CU_get_run_summary();  TEST(pRunSummary->nSuitesRun      == CU_get_number_of_suites_run());  TEST(pRunSummary->nSuitesFailed   == CU_get_number_of_suites_failed());  TEST(pRunSummary->nTestsRun       == CU_get_number_of_tests_run());  TEST(pRunSummary->nTestsFailed    == CU_get_number_of_tests_failed());  TEST(pRunSummary->nAsserts        == CU_get_number_of_asserts());  TEST(pRunSummary->nAssertsFailed  == CU_get_number_of_failures());  TEST(pRunSummary->nFailureRecords == CU_get_number_of_failure_records());  /* clear handlers and run again */  CU_set_test_start_handler(NULL);  CU_set_test_complete_handler(NULL);  CU_set_all_test_complete_handler(NULL);  CU_set_suite_init_failure_handler(NULL);  TEST(NULL == CU_get_test_start_handler());  TEST(NULL == CU_get_test_complete_handler());