testrun.c

CUNIT

    /* Clear results from the previous run */
    clear_previous_results(&f_run_summary, &f_failure_list);

    pSuite = pRegistry->pSuite;
    while (pSuite && (!result || (CU_get_error_action() == CUEA_IGNORE))) {
      /* if the suite has tests, run it */
      if (pSuite->uiNumberOfTests) {
        result2 = run_single_suite(pSuite, &f_run_summary);
        result = (CUE_SUCCESS == result) ? result2 : result;  /* result = 1st error encountered */
      }
      pSuite = pSuite->pNext;
    }

    /* test run is complete - clear flag */
    f_bTestIsRunning = FALSE;

    if (f_pAllTestsCompleteMessageHandler)
     (*f_pAllTestsCompleteMessageHandler)(f_failure_list);
  }

  return result;
}

/*------------------------------------------------------------------------*/
/** Run all tests in a specified suite.
 * The suite need not be registered in the test registry to be run.
 * Any initialization function for the suite is first called,
 * then the suite is run using run_single_suite(), and any
 * suite cleanup function is called.  Note that the
 * run statistics (counts of tests, successes, failures)
 * are initialized each time this function is called.
 * If an error condition occurs during the run, the action
 * depends on the current error action (see CU_set_error_action()).
 * @param pSuite The suite containing the test (non-NULL)
 * @return A CU_ErrorCode indicating the first error condition
 *         encountered while running the suite.  CU_run_suite()
 *         sets and returns CUE_NOSUITE if pSuite is NULL.  Other
 *         error codes can be set during suite initialization or
 *         cleanup or during test runs.
 * @see CU_run_all_tests() to run all suites.
 * @see CU_run_test() to run a single test in a specific suite.
 */
CU_ErrorCode CU_run_suite(CU_pSuite pSuite)
{
  CU_ErrorCode result;

  CU_set_error(result = CUE_SUCCESS);
  if (!pSuite) {
    CU_set_error(result = CUE_NOSUITE);
  }
  else {
    /* test run is starting - set flag */
    f_bTestIsRunning = TRUE;

    /* Clear results from the previous run */
    clear_previous_results(&f_run_summary, &f_failure_list);

    if (pSuite->uiNumberOfTests)
      result = run_single_suite(pSuite, &f_run_summary);

    /* test run is complete - clear flag */
    f_bTestIsRunning = FALSE;

    if (f_pAllTestsCompleteMessageHandler)
      (*f_pAllTestsCompleteMessageHandler)(f_failure_list);
  }

  return result;
}

/*------------------------------------------------------------------------*/
/** Run a specific test in a specified suite.
 * The suite need not be registered in the test registry to be run,
 * although the test must be registered in the specified suite.
 * Any initialization function for the suite is first
 * called, then the test is run using run_single_test(), and
 * any suite cleanup function is called.  Note that the
 * run statistics (counts of tests, successes, failures)
 * are initialized each time this function is called.
 * @param pSuite The suite containing the test (non-NULL)
 * @param pTest  The test to run (non-NULL)
 * @return A CU_ErrorCode indicating the first error condition
 *         encountered while running the suite.  CU_run_test()
 *         sets and returns CUE_NOSUITE if pSuite is NULL,
 *         CUE_NOTEST if pTest is NULL, and CUE_TEST_NOT_IN_SUITE
 *         if pTest is not registered in pSuite.  Other
 *         error codes can be set during suite initialization or
 *         cleanup or during the test run.
 * @see CU_run_all_tests() to run all tests/suites.
 * @see CU_run_suite() to run all tests in a specific suite.
 */
CU_ErrorCode CU_run_test(CU_pSuite pSuite, CU_pTest pTest)
{
  CU_ErrorCode result;
  CU_ErrorCode result2;

  CU_set_error(result = CUE_SUCCESS);
  if (!pSuite) {
    CU_set_error(result = CUE_NOSUITE);
  }
  else if (!pTest) {
    CU_set_error(result = CUE_NOTEST);
  }
  else if (NULL == CU_get_test_by_name(pTest->pName, pSuite)) {
    CU_set_error(result = CUE_TEST_NOT_IN_SUITE);
  }
  else {
    /* test run is starting - set flag */
    f_bTestIsRunning = TRUE;

    /* Clear results from the previous run */
    clear_previous_results(&f_run_summary, &f_failure_list);

    f_pCurTest = NULL;
    f_pCurSuite = pSuite;

    if ((pSuite->pInitializeFunc) && (*pSuite->pInitializeFunc)()) {
      if (f_pSuiteInitFailureMessageHandler) {
        (*f_pSuiteInitFailureMessageHandler)(pSuite);
      }
      f_run_summary.nSuitesFailed++;
      add_failure(&f_failure_list, &f_run_summary,
                  0, "Suite Initialization failed - Test Skipped", "CUnit System", pSuite, pTest);
      CU_set_error(result = CUE_SINIT_FAILED);
      /* test run is complete - clear flag */
      f_bTestIsRunning = FALSE;
    }
    /* reach here if no suite initialization, or if it succeeded */
    else {
      result2 = run_single_test(pTest, &f_run_summary);
      result = (CUE_SUCCESS == result) ? result2 : result;

      if ((pSuite->pCleanupFunc) && (*pSuite->pCleanupFunc)()) {
        f_run_summary.nSuitesFailed++;
        add_failure(&f_failure_list, &f_run_summary,
                    0, "Suite cleanup failed.", "CUnit System", pSuite, pTest);
        result = (CUE_SUCCESS == result) ? CUE_SCLEAN_FAILED : result;
        CU_set_error(CUE_SCLEAN_FAILED);
      }

      /* test run is complete - clear flag */
      f_bTestIsRunning = FALSE;

      if (f_pAllTestsCompleteMessageHandler)
        (*f_pAllTestsCompleteMessageHandler)(f_failure_list);

      f_pCurSuite = NULL;
    }
  }

  return result;
}

/*------------------------------------------------------------------------*/
/** Initialize the run summary information stored from
 * the previous test run.  Resets the run counts to zero,
 * and frees any memory associated with failure records.
 * Calling this function multiple times, while inefficient,
 * will not cause an error condition.
 * @see clear_previous_results()
 */
void CU_clear_previous_results(void)
{
  clear_previous_results(&f_run_summary, &f_failure_list);
}

/*------------------------------------------------------------------------*/
/** Retrieve a pointer to the currently-running suite (NULL if none).
 */
CU_pSuite CU_get_current_suite(void)
{
  return f_pCurSuite;
}

/*------------------------------------------------------------------------*/
/** Retrieve a pointer to the currently-running test (NULL if none).
 */
CU_pTest CU_get_current_test(void)
{
  return f_pCurTest;
}

/*------------------------------------------------------------------------*/
/** Returns <CODE>TRUE</CODE> if a test run is in progress,
 * <CODE>TRUE</CODE> otherwise.
 */
BOOL CU_is_test_running(void)
{
  return f_bTestIsRunning;
}

/*------------------------------------------------------------------------*/
/** Record a failed test.
 * This function is called whenever a test fails to record the
 * details of the failure.  This includes user assertion failures
 * and system errors such as failure to initialize a suite.
 * @param ppFailure    Pointer to head of linked list of failure
 *                     records to append with new failure record.
 *                     If NULL, it will be set to point to the new
 *                     failure record.
 * @param pRunSummary  Pointer to CU_RunSummary keeping track of failure records
 *                     (ignored if NULL).
 * @param uiLineNumber Line number of the failure, if applicable.
 * @param szCondition  Description of failure condition
 * @param szFileName   Name of file, if applicable
 * @param pSuite       The suite being run at time of failure
 * @param pTest        The test being run at time of failure
 */
void add_failure(CU_pFailureRecord* ppFailure, CU_pRunSummary pRunSummary,
                 unsigned int uiLineNumber, char szCondition[],
                 char szFileName[], CU_pSuite pSuite, CU_pTest pTest)
{
  CU_pFailureRecord pFailureNew = NULL;
  CU_pFailureRecord pTemp = NULL;

  pFailureNew = (CU_pFailureRecord)CU_MALLOC(sizeof(CU_FailureRecord));

  if (!pFailureNew)
    return;

  pFailureNew->strFileName = NULL;
  pFailureNew->strCondition = NULL;
  if (szFileName) {
    pFailureNew->strFileName = (char*)CU_MALLOC(strlen(szFileName) + 1);
    if(!pFailureNew->strFileName) {
      CU_FREE(pFailureNew);
      return;
    }
    strcpy(pFailureNew->strFileName, szFileName);
  }

  if (szCondition) {
    pFailureNew->strCondition = (char*)CU_MALLOC(strlen(szCondition) + 1);
    if (!pFailureNew->strCondition) {
      if(pFailureNew->strFileName) {
        CU_FREE(pFailureNew->strFileName);
      }
      CU_FREE(pFailureNew);
      return;
    }
    strcpy(pFailureNew->strCondition, szCondition);
  }

  pFailureNew->uiLineNumber = uiLineNumber;
  pFailureNew->pTest = pTest;
  pFailureNew->pSuite = pSuite;
  pFailureNew->pNext = NULL;
  pFailureNew->pPrev = NULL;

  pTemp = *ppFailure;
  if (pTemp) {
    while (pTemp->pNext) {
      pTemp = pTemp->pNext;
    }
    pTemp->pNext = pFailureNew;
    pFailureNew->pPrev = pTemp;
  }
  else {
    *ppFailure = pFailureNew;
  }

  if (NULL != pRunSummary)
    ++(pRunSummary->nFailureRecords);
  f_last_failure = pFailureNew;
}

/*
 *  Local function for result set initialization/cleanup.
 */
/*------------------------------------------------------------------------*/
/** Initialize the run summary information in the
 * specified structure.  Resets the run counts to zero,
 * and calls cleanup_failure_list() if failures
 * were recorded by the last test run.
 * Calling this function multiple times, while inefficient,
 * will not cause an error condition.
 * @param pRunSummary CU_RunSummary to initialize.
 * @see CU_clear_previous_results()
 */
static void clear_previous_results(CU_pRunSummary pRunSummary, CU_pFailureRecord* ppFailure)
{
  pRunSummary->nSuitesRun = 0;
  pRunSummary->nSuitesFailed = 0;
  pRunSummary->nTestsRun = 0;
  pRunSummary->nTestsFailed = 0;
  pRunSummary->nAsserts = 0;
  pRunSummary->nAssertsFailed = 0;
  pRunSummary->nFailureRecords = 0;

  if (NULL != *ppFailure)
    cleanup_failure_list(ppFailure);

  f_last_failure = NULL;
}

/*------------------------------------------------------------------------*/
/** Free all memory allocated for the linked list of
 * test failure records.  pFailure is reset to NULL
 * after its list is cleaned up.
 * @param ppFailure Pointer to head of linked list of
 *                  CU_pFailureRecords to clean.
 * @see CU_clear_previous_results()
 */
static void cleanup_failure_list(CU_pFailureRecord* ppFailure)
{
  CU_pFailureRecord pCurFailure = NULL;
  CU_pFailureRecord pNextFailure = NULL;

  pCurFailure = *ppFailure;

  while (pCurFailure) {

    if (pCurFailure->strCondition)
      CU_FREE(pCurFailure->strCondition);

    if (pCurFailure->strFileName)
      CU_FREE(pCurFailure->strFileName);

    pNextFailure = pCurFailure->pNext;
    CU_FREE(pCurFailure);
    pCurFailure = pNextFailure;
  }

  *ppFailure = NULL;
}

/*------------------------------------------------------------------------*/
/** Run all tests in a specified suite.
 * Internal function to run all tests in a suite.  The suite
 * need not be registered in the test registry to be run.
 * If the CUnit system is in an error condition after running
 * a test, no additional tests are run.
 * @param pSuite The suite containing the test (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_suite() for public interface function.
 * @see CU_run_all_tests() for running all suites.
 */
static CU_ErrorCode run_single_suite(CU_pSuite pSuite, CU_pRunSummary pRunSummary)
{
  CU_pTest pTest = NULL;
  CU_ErrorCode result;
  CU_ErrorCode result2;

  assert(pSuite);
  assert(pRunSummary);

  f_pCurTest = NULL;
  f_pCurSuite = pSuite;

  CU_set_error(result = CUE_SUCCESS);