epicsUnitTest.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "epicsThread.h"
#include "epicsMutex.h"
#include "epicsUnitTest.h"
#include "epicsExit.h"
#include "epicsTime.h"
#include "ellLib.h"
#include "errlog.h"
#include "cantProceed.h"
#include "epicsStackTrace.h"

Include dependency graph for epicsUnitTest.c:

Go to the source code of this file.

Classes
struct	testFailure

Functions
void	testPlan (int plan)
	Declare the test plan, required. More...
int	testOkV (int pass, const char *fmt, va_list pvar)
	Test result with var-args description. More...
int	testOk (int pass, const char *fmt,...)
void	testPass (const char *fmt,...)
void	testFail (const char *fmt,...)
void	testSkip (int skip, const char *why)
	Place-holders for tests that can't be run. More...
void	testTodoBegin (const char *why)
	Mark the start of a group of tests that are expected to fail. More...
void	testTodoEnd (void)
	Mark the end of a failing test group. More...
int	testDiag (const char *fmt,...)
void	testAbort (const char *fmt,...)
int	testDone (void)
	Mark the end of testing. More...
int	testImpreciseTiming (void)
	Return non-zero in shared/oversubscribed testing envrionments. More...
void	testHarnessExit (void *dummy)
void	testHarness (void)
	Initialize test harness. More...
void	runTestFunc (const char *name, TESTFUNC func)

Variables
epicsTimeStamp	started
ELLLIST	faults
const char *	testing = NULL

Function Documentation

void runTestFunc	(	const char *	name,
		TESTFUNC	func
	)

Definition at line 310 of file epicsUnitTest.c.

                                                  {
    printf("\n***** %s *****\n", name);
    testing = name;
    func();     /* May not return */
    epicsThreadSleep(1.0);
}

void testAbort	(	const char *	fmt,
			...
	)

Definition at line 194 of file epicsUnitTest.c.

                                     {
    va_list pvar;
    va_start(pvar, fmt);
    printf("Bail out! ");
    vprintf(fmt, pvar);
    putchar('\n');
    fflush(stdout);
    va_end(pvar);
    abort();
}

int testDiag	(	const char *	fmt,
			...
	)

Definition at line 181 of file epicsUnitTest.c.

                                   {
    va_list pvar;
    va_start(pvar, fmt);
    epicsMutexMustLock(testLock);
    printf("# ");
    vprintf(fmt, pvar);
    putchar('\n');
    fflush(stdout);
    epicsMutexUnlock(testLock);
    va_end(pvar);
    return 0;
}

int testDone

(

void

)

Mark the end of testing.

Definition at line 209 of file epicsUnitTest.c.

                   {
    int status = 0;

    epicsMutexMustLock(testLock);
    if (perlHarness) {
        if (!planned) printf("1..%d\n", tested);
    } else {
        if (planned && tested > planned) {
            printf("\nRan %d tests but only planned for %d!\n", tested, planned);
            status = 2;
        } else if (planned && tested < planned) {
            printf("\nPlanned %d tests but only ran %d\n", planned, tested);
            status = 2;
        }
        printf("\n    Results\n    =======\n       Tests: %-3d\n", tested);
        if (tested) {
            testResult("Passed", passed);
            if (bonus) testResult("Todo Passes", bonus);
            if (failed) {
                testResult("Failed", failed);
                status = 1;
            }
            if (skipped) testResult("Skipped", skipped);
        }
    }
    if (Harness) {
        if (failed) {
            testFailure *fault = callocMustSucceed(1, sizeof(testFailure),
                "testDone calloc");
            fault->name     = testing;
            fault->tests    = tested;
            fault->failures = failed;
            fault->skips    = skipped;
            ellAdd(&faults, &fault->node);
        }
        Programs++;
        Tests += tested;
    }
    epicsMutexUnlock(testLock);
    return (status);
}

void testFail	(	const char *	fmt,
			...
	)

Definition at line 152 of file epicsUnitTest.c.

                                    {
    va_list pvar;
    va_start(pvar, fmt);
    testOkV(0, fmt, pvar);
    va_end(pvar);
}

void testHarness

(

void

)

Initialize test harness.

Definition at line 300 of file epicsUnitTest.c.

                       {
    epicsThreadOnce(&onceFlag, testOnce, NULL);
    epicsAtExit(testHarnessExit, NULL);
    Harness = 1;
    Programs = 0;
    Tests = 0;
    ellInit(&faults);
    epicsTimeGetCurrent(&started);
}

void testHarnessExit

(

void *

dummy

)

Definition at line 265 of file epicsUnitTest.c.

                                  {
    epicsTimeStamp ended;
    int Faulty;

    if (!Harness) return;

    epicsTimeGetCurrent(&ended);

    printf("\n\n    EPICS Test Harness Results"
             "\n    ==========================\n\n");

    Faulty = ellCount(&faults);
    if (!Faulty)
        printf("All tests successful.\n");
    else {
        int Failures = 0;
        testFailure *f;

        printf("Failing Program           Tests  Faults\n"
               "---------------------------------------\n");
        while ((f = (testFailure *)ellGet(&faults))) {
            Failures += f->failures;
            printf("%-25s %5d   %5d\n", f->name, f->tests, f->failures);
            if (f->skips)
                printf("%d subtests skipped\n", f->skips);
            free(f);
        }
        printf("\nFailed %d/%d test programs. %d/%d subtests failed.\n",
               Faulty, Programs, Failures, Tests);
    }

    printf("Programs=%d, Tests=%d, %.0f wallclock secs\n\n",
           Programs, Tests, epicsTimeDiffInSeconds(&ended, &started));
}

int testImpreciseTiming

(

void

)

Return non-zero in shared/oversubscribed testing envrionments.

May be used to testSkip(), or select longer timeouts, for some cases when the test process may be preempted for arbitrarily long times. This is common in shared CI environments.

The environment variable $EPICS_TEST_IMPRECISE_TIMING=YES should be set in by such testing environments.

Definition at line 253 of file epicsUnitTest.c.

{
    if(impreciseTiming==0) {
        const char* env = getenv("EPICS_TEST_IMPRECISE_TIMING");

        impreciseTiming = (env && strcmp(env, "YES")==0) ? 1 : -1;
    }
    return impreciseTiming>0;
}

int testOk	(	int	pass,
		const char *	fmt,
			...
	)

Definition at line 137 of file epicsUnitTest.c.

                                           {
    va_list pvar;
    va_start(pvar, fmt);
    testOkV(pass, fmt, pvar);
    va_end(pvar);
    return pass;
}

int testOkV	(	int	pass,
		const char *	fmt,
		va_list	pvar
	)

Test result with var-args description.

Parameters

pass	True/False value indicating result.
fmt	A printf-style format string describing the test.
pvar	A var-args pointer to any parameters for the format string.

Returns

The value of pass.

Definition at line 112 of file epicsUnitTest.c.

                                                     {
    const char *result = "not ok";
    epicsMutexMustLock(testLock);
    tested++;
    if (pass) {
        result += 4;    /* skip "not " */
        passed++;
        if (todo)
            bonus++;
    } else {
        if (todo)
            passed++;
        else
            failed++;
    }
    printf("%s %2d - ", result, tested);
    vprintf(fmt, pvar);
    if (todo)
        printf(" # TODO %s", todo);
    putchar('\n');
    fflush(stdout);
    epicsMutexUnlock(testLock);
    return pass;
}

void testPass	(	const char *	fmt,
			...
	)

Definition at line 145 of file epicsUnitTest.c.

                                    {
    va_list pvar;
    va_start(pvar, fmt);
    testOkV(1, fmt, pvar);
    va_end(pvar);
}

void testPlan

(

int

tests

)

Declare the test plan, required.

Parameters

tests

Number of tests to be run. May be zero if not known but the test harness then can't tell if the program dies prematurely.

Definition at line 102 of file epicsUnitTest.c.

                        {
    epicsThreadOnce(&onceFlag, testOnce, NULL);
    epicsMutexMustLock(testLock);
    planned = plan;
    tested = passed = failed = skipped = bonus = 0;
    todo = NULL;
    if (plan) printf("1..%d\n", plan);
    epicsMutexUnlock(testLock);
}

void testSkip	(	int	skip,
		const char *	why
	)

Place-holders for tests that can't be run.

Parameters

skip	How many tests are being skipped.
why	Reason for skipping these tests.

Definition at line 159 of file epicsUnitTest.c.

                                         {
    epicsMutexMustLock(testLock);
    while (skip-- > 0) {
        tested++;
        passed++;
        skipped++;
        printf("ok %2d # SKIP %s\n", tested, why);
    }
    fflush(stdout);
    epicsMutexUnlock(testLock);
}

void testTodoBegin

(

const char *

why

)

Mark the start of a group of tests that are expected to fail.

Parameters

why	Reason for expected failures.

Definition at line 171 of file epicsUnitTest.c.

                                    {
    epicsMutexMustLock(testLock);
    todo = why;
    epicsMutexUnlock(testLock);
}

void testTodoEnd

(

void

)

Mark the end of a failing test group.

Definition at line 177 of file epicsUnitTest.c.

                       {
    testTodoBegin(NULL);
}

Variable Documentation

ELLLIST faults

Definition at line 57 of file epicsUnitTest.c.

epicsTimeStamp started

Definition at line 52 of file epicsUnitTest.c.

const char* testing = NULL

Definition at line 58 of file epicsUnitTest.c.