munit.c File Reference

#include <limits.h>
#include <time.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <setjmp.h>
#include <locale.h>
#include <langinfo.h>
#include <strings.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include "munit.h"
#include <assert.h>

Include dependency graph for munit.c:

Go to the source code of this file.

Data Structures
struct	PsnipClockTimespec
struct	MunitReport
struct	MunitTestRunner

Macros
#define	MUNIT_OUTPUT_FILE   stdout
#define	MUNIT_TEST_TIME_FORMAT   "0.8f"
#define	MUNIT_TEST_NAME_LEN   60
#define	MUNIT_ENABLE_TIMING
#define	_POSIX_C_SOURCE   200809L
#define	MUNIT_NL_LANGINFO
#define	MUNIT_STRINGIFY(x)
#define	MUNIT_XSTRINGIFY(x)
#define	MUNIT_STRERROR_LEN   80
#define	psnip_uint64_t   munit_uint64_t
#define	psnip_uint32_t   munit_uint32_t
#define	PSNIP_CLOCK_H
#define	PSNIP_CLOCK__COMPILER_ATTRIBUTES
#define	PSNIP_CLOCK__FUNCTION   PSNIP_CLOCK__COMPILER_ATTRIBUTES static
#define	PSNIP_CLOCK_METHOD_CLOCK_GETTIME   1
#define	PSNIP_CLOCK_METHOD_TIME   2
#define	PSNIP_CLOCK_METHOD_GETTIMEOFDAY   3
#define	PSNIP_CLOCK_METHOD_QUERYPERFORMANCECOUNTER   4
#define	PSNIP_CLOCK_METHOD_MACH_ABSOLUTE_TIME   5
#define	PSNIP_CLOCK_METHOD_CLOCK   6
#define	PSNIP_CLOCK_METHOD_GETPROCESSTIMES   7
#define	PSNIP_CLOCK_METHOD_GETRUSAGE   8
#define	PSNIP_CLOCK_METHOD_GETSYSTEMTIMEPRECISEASFILETIME   9
#define	PSNIP_CLOCK_METHOD_GETTICKCOUNT64   10
#define	PSNIP_CLOCK_UNREACHABLE()
#define	PSNIP_CLOCK_WALL_METHOD   PSNIP_CLOCK_METHOD_TIME
#define	PSNIP_CLOCK_CPU_METHOD   PSNIP_CLOCK_METHOD_CLOCK
#define	PSNIP_CLOCK_NSEC_PER_SEC   ((psnip_uint32_t) (1000000000ULL))
#define	ATOMIC_UINT32_T   volatile uint32_t
#define	ATOMIC_UINT32_INIT(x)
#define	munit_atomic_store(dest, value)
#define	munit_atomic_load(src)
#define	MUNIT_PRNG_MULTIPLIER   (747796405U)
#define	MUNIT_PRNG_INCREMENT   (1729U)
#define	MUNIT_RESULT_STRING_OK   "OK "
#define	MUNIT_RESULT_STRING_SKIP   "SKIP "
#define	MUNIT_RESULT_STRING_FAIL   "FAIL "
#define	MUNIT_RESULT_STRING_ERROR   "ERROR"
#define	MUNIT_RESULT_STRING_TODO   "TODO "

Enumerations
enum	PsnipClockType { PSNIP_CLOCK_TYPE_WALL = 1 , PSNIP_CLOCK_TYPE_CPU = 2 , PSNIP_CLOCK_TYPE_MONOTONIC = 3 }

Functions
void	munit_logf_ex (MunitLogLevel level, const char *filename, int line, const char *format,...)
void	munit_errorf_ex (const char *filename, int line, const char *format,...)
void *	munit_malloc_ex (const char *filename, int line, size_t size)
PSNIP_CLOCK__FUNCTION psnip_uint32_t	psnip_clock_wall_get_precision (void)
PSNIP_CLOCK__FUNCTION int	psnip_clock_wall_get_time (struct PsnipClockTimespec *res)
PSNIP_CLOCK__FUNCTION psnip_uint32_t	psnip_clock_cpu_get_precision (void)
PSNIP_CLOCK__FUNCTION int	psnip_clock_cpu_get_time (struct PsnipClockTimespec *res)
PSNIP_CLOCK__FUNCTION psnip_uint32_t	psnip_clock_monotonic_get_precision (void)
PSNIP_CLOCK__FUNCTION int	psnip_clock_monotonic_get_time (struct PsnipClockTimespec *res)
PSNIP_CLOCK__FUNCTION psnip_uint32_t	psnip_clock_get_precision (enum PsnipClockType clock_type)
PSNIP_CLOCK__FUNCTION int	psnip_clock_get_time (enum PsnipClockType clock_type, struct PsnipClockTimespec *res)
void	munit_rand_seed (munit_uint32_t seed)
munit_uint32_t	munit_rand_uint32 (void)
void	munit_rand_memory (size_t size, munit_uint8_t data[MUNIT_ARRAY_PARAM(size)])
int	munit_rand_int_range (int min, int max)
double	munit_rand_double (void)
const char *	munit_parameters_get (const MunitParameter params[], const char *key)
int	munit_suite_main_custom (const MunitSuite *suite, void *user_data, int argc, char *const argv[MUNIT_ARRAY_PARAM(argc+1)], const MunitArgument arguments[])
int	munit_suite_main (const MunitSuite *suite, void *user_data, int argc, char *const argv[MUNIT_ARRAY_PARAM(argc+1)])

Macro Definition Documentation

_POSIX_C_SOURCE

#define _POSIX_C_SOURCE   200809L

Definition at line 61 of file munit.c.

ATOMIC_UINT32_INIT

#define ATOMIC_UINT32_INIT

(

x

)

Value:

(x)

Definition at line 826 of file munit.c.

ATOMIC_UINT32_T

#define ATOMIC_UINT32_T   volatile uint32_t

Definition at line 825 of file munit.c.

munit_atomic_load

#define munit_atomic_load

(

src

)

Value:

(*(src))

Definition at line 885 of file munit.c.

Referenced by munit_rand_double(), munit_rand_memory(), and munit_rand_uint32().

munit_atomic_store

#define munit_atomic_store	(		dest,
			value )

Value:

do { *(dest) = (value); } while (0)

Definition at line 884 of file munit.c.

Referenced by munit_rand_seed().

MUNIT_ENABLE_TIMING

#define MUNIT_ENABLE_TIMING

Definition at line 52 of file munit.c.

MUNIT_NL_LANGINFO

#define MUNIT_NL_LANGINFO

Definition at line 102 of file munit.c.

MUNIT_OUTPUT_FILE

#define MUNIT_OUTPUT_FILE   stdout

Definition at line 32 of file munit.c.

Referenced by munit_suite_main_custom().

MUNIT_PRNG_INCREMENT

#define MUNIT_PRNG_INCREMENT   (1729U)

Definition at line 898 of file munit.c.

Referenced by munit_rand_seed().

MUNIT_PRNG_MULTIPLIER

#define MUNIT_PRNG_MULTIPLIER   (747796405U)

Definition at line 897 of file munit.c.

MUNIT_RESULT_STRING_ERROR

#define MUNIT_RESULT_STRING_ERROR   "ERROR"

Definition at line 1261 of file munit.c.

MUNIT_RESULT_STRING_FAIL

#define MUNIT_RESULT_STRING_FAIL   "FAIL "

Definition at line 1260 of file munit.c.

MUNIT_RESULT_STRING_OK

#define MUNIT_RESULT_STRING_OK   "OK "

Definition at line 1258 of file munit.c.

MUNIT_RESULT_STRING_SKIP

#define MUNIT_RESULT_STRING_SKIP   "SKIP "

Definition at line 1259 of file munit.c.

MUNIT_RESULT_STRING_TODO

#define MUNIT_RESULT_STRING_TODO   "TODO "

Definition at line 1262 of file munit.c.

MUNIT_STRERROR_LEN

#define MUNIT_STRERROR_LEN   80

Definition at line 257 of file munit.c.

MUNIT_STRINGIFY

#define MUNIT_STRINGIFY

(

x

)

Value:

#x

Definition at line 127 of file munit.c.

MUNIT_TEST_NAME_LEN

#define MUNIT_TEST_NAME_LEN   60

Definition at line 46 of file munit.c.

MUNIT_TEST_TIME_FORMAT

#define MUNIT_TEST_TIME_FORMAT   "0.8f"

Definition at line 40 of file munit.c.

MUNIT_XSTRINGIFY

#define MUNIT_XSTRINGIFY

(

x

)

Value:

MUNIT_STRINGIFY(x)

Definition at line 128 of file munit.c.

PSNIP_CLOCK__COMPILER_ATTRIBUTES

#define PSNIP_CLOCK__COMPILER_ATTRIBUTES

Definition at line 328 of file munit.c.

PSNIP_CLOCK__FUNCTION

#define PSNIP_CLOCK__FUNCTION   PSNIP_CLOCK__COMPILER_ATTRIBUTES static

Definition at line 331 of file munit.c.

PSNIP_CLOCK_CPU_METHOD

#define PSNIP_CLOCK_CPU_METHOD   PSNIP_CLOCK_METHOD_CLOCK

Definition at line 466 of file munit.c.

PSNIP_CLOCK_H

#define PSNIP_CLOCK_H

Definition at line 318 of file munit.c.

PSNIP_CLOCK_METHOD_CLOCK

#define PSNIP_CLOCK_METHOD_CLOCK   6

Definition at line 362 of file munit.c.

PSNIP_CLOCK_METHOD_CLOCK_GETTIME

#define PSNIP_CLOCK_METHOD_CLOCK_GETTIME   1

Definition at line 357 of file munit.c.

PSNIP_CLOCK_METHOD_GETPROCESSTIMES

#define PSNIP_CLOCK_METHOD_GETPROCESSTIMES   7

Definition at line 363 of file munit.c.

PSNIP_CLOCK_METHOD_GETRUSAGE

#define PSNIP_CLOCK_METHOD_GETRUSAGE   8

Definition at line 364 of file munit.c.

PSNIP_CLOCK_METHOD_GETSYSTEMTIMEPRECISEASFILETIME

#define PSNIP_CLOCK_METHOD_GETSYSTEMTIMEPRECISEASFILETIME   9

Definition at line 365 of file munit.c.

PSNIP_CLOCK_METHOD_GETTICKCOUNT64

#define PSNIP_CLOCK_METHOD_GETTICKCOUNT64   10

Definition at line 366 of file munit.c.

PSNIP_CLOCK_METHOD_GETTIMEOFDAY

#define PSNIP_CLOCK_METHOD_GETTIMEOFDAY   3

Definition at line 359 of file munit.c.

PSNIP_CLOCK_METHOD_MACH_ABSOLUTE_TIME

#define PSNIP_CLOCK_METHOD_MACH_ABSOLUTE_TIME   5

Definition at line 361 of file munit.c.

PSNIP_CLOCK_METHOD_QUERYPERFORMANCECOUNTER

#define PSNIP_CLOCK_METHOD_QUERYPERFORMANCECOUNTER   4

Definition at line 360 of file munit.c.

PSNIP_CLOCK_METHOD_TIME

#define PSNIP_CLOCK_METHOD_TIME   2

Definition at line 358 of file munit.c.

PSNIP_CLOCK_NSEC_PER_SEC

#define PSNIP_CLOCK_NSEC_PER_SEC   ((psnip_uint32_t) (1000000000ULL))

Definition at line 527 of file munit.c.

Referenced by psnip_clock_cpu_get_precision(), psnip_clock_cpu_get_time(), psnip_clock_monotonic_get_precision(), and psnip_clock_monotonic_get_time().

PSNIP_CLOCK_UNREACHABLE

#define PSNIP_CLOCK_UNREACHABLE

(

)

Value:

assert(0)

Definition at line 373 of file munit.c.

Referenced by psnip_clock_get_precision().

PSNIP_CLOCK_WALL_METHOD

#define PSNIP_CLOCK_WALL_METHOD   PSNIP_CLOCK_METHOD_TIME

Definition at line 462 of file munit.c.

psnip_uint32_t

#define psnip_uint32_t   munit_uint32_t

Definition at line 300 of file munit.c.

Referenced by psnip_clock_monotonic_get_precision().

psnip_uint64_t

#define psnip_uint64_t   munit_uint64_t

Definition at line 299 of file munit.c.

Referenced by psnip_clock_monotonic_get_time().

Enumeration Type Documentation

PsnipClockType

enum PsnipClockType

Enumerator
PSNIP_CLOCK_TYPE_WALL
PSNIP_CLOCK_TYPE_CPU
PSNIP_CLOCK_TYPE_MONOTONIC

Definition at line 334 of file munit.c.

                    {
    /* This clock provides the current time, in units since 1970-01-01
     * 00:00:00 UTC not including leap seconds.  In other words, UNIX
     * time.  Keep in mind that this clock doesn't account for leap
     * seconds, and can go backwards (think NTP adjustments). */
    PSNIP_CLOCK_TYPE_WALL = 1,
    /* The CPU time is a clock which increases only when the current
     * process is active (i.e., it doesn't increment while blocking on
     * I/O). */
    PSNIP_CLOCK_TYPE_CPU = 2,
    /* Monotonic time is always running (unlike CPU time), but it only
       ever moves forward unless you reboot the system.  Things like NTP
       adjustments have no effect on this clock. */
    PSNIP_CLOCK_TYPE_MONOTONIC = 3
};

Function Documentation

munit_errorf_ex()

void munit_errorf_ex	(	const char *	filename,
		int	line,
		const char *	format,
			... )

Definition at line 238 of file munit.c.

                                                                         {
    va_list ap;
 
    va_start(ap, format);
    munit_logf_exv(MUNIT_LOG_ERROR, stderr, filename, line, format, ap);
    va_end(ap);
 
#if defined(MUNIT_THREAD_LOCAL)
    if (munit_error_jmp_buf_valid)
        longjmp(munit_error_jmp_buf, 1);
#endif
    abort();
}

References MUNIT_LOG_ERROR.

munit_logf_ex()

void munit_logf_ex	(	MunitLogLevel	level,
		const char *	filename,
		int	line,
		const char *	format,
			... )

Definition at line 221 of file munit.c.

                                                                                            {
    va_list ap;
 
    va_start(ap, format);
    munit_logf_exv(level, stderr, filename, line, format, ap);
    va_end(ap);
 
    if (level >= munit_log_level_fatal) {
#if defined(MUNIT_THREAD_LOCAL)
        if (munit_error_jmp_buf_valid)
            longjmp(munit_error_jmp_buf, 1);
#endif
        abort();
    }
}

Referenced by munit_malloc_ex().

Here is the caller graph for this function:

munit_malloc_ex()

void * munit_malloc_ex	(	const char *	filename,
		int	line,
		size_t	size )

Definition at line 281 of file munit.c.

                                                             {
    void *ptr;
 
    if (size == 0)
        return NULL;
 
    ptr = calloc(1, size);
    if (MUNIT_UNLIKELY(ptr == NULL)) {
        munit_logf_ex(MUNIT_LOG_ERROR, filename, line, "Failed to allocate %" MUNIT_SIZE_MODIFIER "u bytes.", size);
    }
 
    return ptr;
}

References MUNIT_LOG_ERROR, munit_logf_ex(), MUNIT_SIZE_MODIFIER, and MUNIT_UNLIKELY.

Here is the call graph for this function:

munit_parameters_get()

const char * munit_parameters_get	(	const MunitParameter	params[],
		const char *	key )

Definition at line 1075 of file munit.c.

                                                                     {
    const MunitParameter *param;
 
    for (param = params; param != NULL && param->name != NULL; param++)
        if (strcmp(param->name, key) == 0)
            return param->value;
    return NULL;
}

References MunitParameter::name, and MunitParameter::value.

munit_rand_double()

double munit_rand_double

(

void

)

Definition at line 1028 of file munit.c.

                        {
    munit_uint32_t old, state;
    double retval = 0.0;
 
    do {
        state = old = munit_atomic_load(&munit_rand_state);
 
        /* See http://mumble.net/~campbell/tmp/random_real.c for how to do
         * this right.  Patches welcome if you feel that this is too
         * biased. */
        retval = munit_rand_state_uint32(&state) / ((~((munit_uint32_t) 0U)) + 1.0);
    } while (!munit_atomic_cas(&munit_rand_state, &old, state));
 
    return retval;
}

References munit_atomic_load, and munit_uint32_t.

munit_rand_int_range()

int munit_rand_int_range	(	int	min,
		int	max )

Definition at line 1015 of file munit.c.

                                       {
    munit_uint64_t range = (munit_uint64_t) max - (munit_uint64_t) min;
 
    if (min > max)
        return munit_rand_int_range(max, min);
 
    if (range > (~((munit_uint32_t) 0U)))
        range = (~((munit_uint32_t) 0U));
 
    return min + munit_rand_at_most(0, (munit_uint32_t) range);
}

References munit_rand_int_range(), munit_uint32_t, and munit_uint64_t.

Referenced by munit_rand_int_range().

Here is the call graph for this function:

Here is the caller graph for this function:

munit_rand_memory()

void munit_rand_memory	(	size_t	size,
		munit_uint8_t	data[MUNIT_ARRAY_PARAM(size)] )

Definition at line 971 of file munit.c.

                                                                            {
    munit_uint32_t old, state;
 
    do {
        state = old = munit_atomic_load(&munit_rand_state);
        munit_rand_state_memory(&state, size, data);
    } while (!munit_atomic_cas(&munit_rand_state, &old, state));
}

References munit_atomic_load, munit_uint32_t, and munit_uint8_t.

munit_rand_seed()

void munit_rand_seed

(

munit_uint32_t

seed

)

Definition at line 913 of file munit.c.

                                     {
    munit_uint32_t state = munit_rand_next_state(seed + MUNIT_PRNG_INCREMENT);
    munit_atomic_store(&munit_rand_state, state);
}

References munit_atomic_store, MUNIT_PRNG_INCREMENT, and munit_uint32_t.

munit_rand_uint32()

munit_uint32_t munit_rand_uint32

(

void

)

Definition at line 942 of file munit.c.

                        {
    munit_uint32_t old, state;
 
    do {
        old = munit_atomic_load(&munit_rand_state);
        state = munit_rand_next_state(old);
    } while (!munit_atomic_cas(&munit_rand_state, &old, state));
 
    return munit_rand_from_state(old);
}

References munit_atomic_load, and munit_uint32_t.

munit_suite_main()

int munit_suite_main	(	const MunitSuite *	suite,
		void *	user_data,
		int	argc,
		char *const	argv[MUNIT_ARRAY_PARAM(argc+1)] )

Definition at line 2094 of file munit.c.

                                                                          {
    return munit_suite_main_custom(suite, user_data, argc, argv, NULL);
}

References munit_suite_main_custom().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

munit_suite_main_custom()

int munit_suite_main_custom	(	const MunitSuite *	suite,
		void *	user_data,
		int	argc,
		char *const	argv[MUNIT_ARRAY_PARAM(argc+1)],
		const MunitArgument	arguments[] )

Definition at line 1867 of file munit.c.

                                                         {
    int result = EXIT_FAILURE;
    MunitTestRunner runner;
    size_t parameters_size = 0;
    size_t tests_size = 0;
    int arg;
 
    char *envptr;
    unsigned long ts;
    char *endptr;
    unsigned long long iterations;
    MunitLogLevel level;
    const MunitArgument *argument;
    const char **runner_tests;
    unsigned int tests_run;
    unsigned int tests_total;
 
    runner.prefix = NULL;
    runner.suite = NULL;
    runner.current_suite = NULL;
    runner.tests = NULL;
    runner.seed = 0;
    runner.iterations = 0;
    runner.parameters = NULL;
    runner.single_parameter_mode = 0;
    runner.user_data = NULL;
 
    runner.report.successful = 0;
    runner.report.skipped = 0;
    runner.report.failed = 0;
    runner.report.errored = 0;
#if defined(MUNIT_ENABLE_TIMING)
    runner.report.cpu_clock = 0;
    runner.report.wall_clock = 0;
#endif
 
    runner.colorize = 0;
#if !defined(_WIN32)
    runner.fork = 1;
#else
    runner.fork = 0;
#endif
    runner.show_stderr = 0;
    runner.fatal_failures = 0;
    runner.suite = suite;
    runner.user_data = user_data;
    runner.seed = munit_rand_generate_seed();
    runner.colorize = munit_stream_supports_ansi(MUNIT_OUTPUT_FILE);
 
    for (arg = 1; arg < argc; arg++) {
        if (strncmp("--", argv[arg], 2) == 0) {
            if (strcmp("seed", argv[arg] + 2) == 0) {
                if (arg + 1 >= argc) {
                    munit_logf_internal(MUNIT_LOG_ERROR, stderr, "%s requires an argument", argv[arg]);
                    goto cleanup;
                }
 
                envptr = argv[arg + 1];
                ts = strtoul(argv[arg + 1], &envptr, 0);
                if (*envptr != '\0' || ts > (~((munit_uint32_t) 0U))) {
                    munit_logf_internal(MUNIT_LOG_ERROR, stderr, "invalid value ('%s') passed to %s", argv[arg + 1],
                                        argv[arg]);
                    goto cleanup;
                }
                runner.seed = (munit_uint32_t) ts;
 
                arg++;
            } else if (strcmp("iterations", argv[arg] + 2) == 0) {
                if (arg + 1 >= argc) {
                    munit_logf_internal(MUNIT_LOG_ERROR, stderr, "%s requires an argument", argv[arg]);
                    goto cleanup;
                }
 
                endptr = argv[arg + 1];
                iterations = strtoul(argv[arg + 1], &endptr, 0);
                if (*endptr != '\0' || iterations > UINT_MAX) {
                    munit_logf_internal(MUNIT_LOG_ERROR, stderr, "invalid value ('%s') passed to %s", argv[arg + 1],
                                        argv[arg]);
                    goto cleanup;
                }
 
                runner.iterations = (unsigned int) iterations;
 
                arg++;
            } else if (strcmp("param", argv[arg] + 2) == 0) {
                if (arg + 2 >= argc) {
                    munit_logf_internal(MUNIT_LOG_ERROR, stderr, "%s requires two arguments", argv[arg]);
                    goto cleanup;
                }
 
                runner.parameters = realloc(runner.parameters, sizeof(MunitParameter) * (parameters_size + 2));
                if (runner.parameters == NULL) {
                    munit_log_internal(MUNIT_LOG_ERROR, stderr, "failed to allocate memory");
                    goto cleanup;
                }
                runner.parameters[parameters_size].name = (char *) argv[arg + 1];
                runner.parameters[parameters_size].value = (char *) argv[arg + 2];
                parameters_size++;
                runner.parameters[parameters_size].name = NULL;
                runner.parameters[parameters_size].value = NULL;
                arg += 2;
            } else if (strcmp("color", argv[arg] + 2) == 0) {
                if (arg + 1 >= argc) {
                    munit_logf_internal(MUNIT_LOG_ERROR, stderr, "%s requires an argument", argv[arg]);
                    goto cleanup;
                }
 
                if (strcmp(argv[arg + 1], "always") == 0)
                    runner.colorize = 1;
                else if (strcmp(argv[arg + 1], "never") == 0)
                    runner.colorize = 0;
                else if (strcmp(argv[arg + 1], "auto") == 0)
                    runner.colorize = munit_stream_supports_ansi(MUNIT_OUTPUT_FILE);
                else {
                    munit_logf_internal(MUNIT_LOG_ERROR, stderr, "invalid value ('%s') passed to %s", argv[arg + 1],
                                        argv[arg]);
                    goto cleanup;
                }
 
                arg++;
            } else if (strcmp("help", argv[arg] + 2) == 0) {
                munit_print_help(argc, argv, user_data, arguments);
                result = EXIT_SUCCESS;
                goto cleanup;
            } else if (strcmp("single", argv[arg] + 2) == 0) {
                runner.single_parameter_mode = 1;
            } else if (strcmp("show-stderr", argv[arg] + 2) == 0) {
                runner.show_stderr = 1;
#if !defined(_WIN32)
            } else if (strcmp("no-fork", argv[arg] + 2) == 0) {
                runner.fork = 0;
#endif
            } else if (strcmp("fatal-failures", argv[arg] + 2) == 0) {
                runner.fatal_failures = 1;
            } else if (strcmp("log-visible", argv[arg] + 2) == 0 ||
                       strcmp("log-fatal", argv[arg] + 2) == 0) {
                if (arg + 1 >= argc) {
                    munit_logf_internal(MUNIT_LOG_ERROR, stderr, "%s requires an argument", argv[arg]);
                    goto cleanup;
                }
 
                if (strcmp(argv[arg + 1], "debug") == 0)
                    level = MUNIT_LOG_DEBUG;
                else if (strcmp(argv[arg + 1], "info") == 0)
                    level = MUNIT_LOG_INFO;
                else if (strcmp(argv[arg + 1], "warning") == 0)
                    level = MUNIT_LOG_WARNING;
                else if (strcmp(argv[arg + 1], "error") == 0)
                    level = MUNIT_LOG_ERROR;
                else {
                    munit_logf_internal(MUNIT_LOG_ERROR, stderr, "invalid value ('%s') passed to %s", argv[arg + 1],
                                        argv[arg]);
                    goto cleanup;
                }
 
                if (strcmp("log-visible", argv[arg] + 2) == 0)
                    munit_log_level_visible = level;
                else
                    munit_log_level_fatal = level;
 
                arg++;
            } else if (strcmp("list", argv[arg] + 2) == 0) {
                munit_suite_list_tests(suite, 0, NULL);
                result = EXIT_SUCCESS;
                goto cleanup;
            } else if (strcmp("list-params", argv[arg] + 2) == 0) {
                munit_suite_list_tests(suite, 1, NULL);
                result = EXIT_SUCCESS;
                goto cleanup;
            } else {
                argument = munit_arguments_find(arguments, argv[arg] + 2);
                if (argument == NULL) {
                    munit_logf_internal(MUNIT_LOG_ERROR, stderr, "unknown argument ('%s')", argv[arg]);
                    goto cleanup;
                }
 
                if (!argument->parse_argument(suite, user_data, &arg, argc, argv))
                    goto cleanup;
            }
        } else {
            runner_tests = realloc((void *) runner.tests, sizeof(char *) * (tests_size + 2));
            if (runner_tests == NULL) {
                munit_log_internal(MUNIT_LOG_ERROR, stderr, "failed to allocate memory");
                goto cleanup;
            }
            runner.tests = runner_tests;
            runner.tests[tests_size++] = argv[arg];
            runner.tests[tests_size] = NULL;
        }
    }
 
    fflush(stderr);
    fprintf(MUNIT_OUTPUT_FILE, "Running test suite with seed 0x%08" PRIx32 "...\n", runner.seed);
 
    munit_test_runner_run(&runner);
 
    tests_run = runner.report.successful + runner.report.failed + runner.report.errored;
    tests_total = tests_run + runner.report.skipped;
    if (tests_run == 0) {
        fprintf(stderr, "No tests run, %d (100%%) skipped.\n", runner.report.skipped);
    } else {
        fprintf(MUNIT_OUTPUT_FILE, "%d of %d (%0.0f%%) tests successful, %d (%0.0f%%) test skipped.\n",
                runner.report.successful, tests_run,
                (((double) runner.report.successful) / ((double) tests_run)) * 100.0,
                runner.report.skipped,
                (((double) runner.report.skipped) / ((double) tests_total)) * 100.0);
    }
 
 
#if defined(MUNIT_FAIL_NO_TEST_RUN)
    if (runner.report.failed == 0 && runner.report.errored == 0 && tests_run > 0) {
#else
    if (runner.report.failed == 0 && runner.report_simple.errored == 0) {
#endif
        result = EXIT_SUCCESS;
    }
 
    cleanup:
    free(runner.parameters);
    free((void *) runner.tests);
 
    return result;
}

References MunitTestRunner::colorize, MunitReport::cpu_clock, MunitTestRunner::current_suite, MunitReport::errored, MunitReport::failed, MunitTestRunner::fatal_failures, MunitTestRunner::fork, MunitTestRunner::iterations, MUNIT_LOG_DEBUG, MUNIT_LOG_ERROR, MUNIT_LOG_INFO, MUNIT_LOG_WARNING, MUNIT_OUTPUT_FILE, munit_uint32_t, MunitParameter::name, MunitTestRunner::parameters, MunitArgument_::parse_argument, MunitTestRunner::prefix, MunitTestRunner::report, MunitTestRunner::seed, MunitTestRunner::show_stderr, MunitTestRunner::single_parameter_mode, MunitReport::skipped, MunitReport::successful, MunitTestRunner::suite, MunitTestRunner::tests, MunitTestRunner::user_data, MunitParameter::value, and MunitReport::wall_clock.

Referenced by munit_suite_main().

Here is the caller graph for this function:

psnip_clock_cpu_get_precision()

PSNIP_CLOCK__FUNCTION psnip_uint32_t psnip_clock_cpu_get_precision

(

void

)

Definition at line 603 of file munit.c.

                                    {
#if !defined(PSNIP_CLOCK_CPU_METHOD)
    return 0;
#elif defined(PSNIP_CLOCK_CPU_METHOD) && PSNIP_CLOCK_CPU_METHOD == PSNIP_CLOCK_METHOD_CLOCK_GETTIME
    return psnip_clock__clock_getres(PSNIP_CLOCK_CLOCK_GETTIME_CPU);
#elif defined(PSNIP_CLOCK_CPU_METHOD) && PSNIP_CLOCK_CPU_METHOD == PSNIP_CLOCK_METHOD_CLOCK
    return CLOCKS_PER_SEC;
#elif defined(PSNIP_CLOCK_CPU_METHOD) && PSNIP_CLOCK_CPU_METHOD == PSNIP_CLOCK_METHOD_GETPROCESSTIMES
  return PSNIP_CLOCK_NSEC_PER_SEC / 100;
#else
  return 0;
#endif
}

References PSNIP_CLOCK_NSEC_PER_SEC.

Referenced by psnip_clock_get_precision().

Here is the caller graph for this function:

psnip_clock_cpu_get_time()

PSNIP_CLOCK__FUNCTION int psnip_clock_cpu_get_time

(

struct PsnipClockTimespec *

res

)

Definition at line 618 of file munit.c.

                                                         {
#if !defined(PSNIP_CLOCK_CPU_METHOD)
    (void) res;
  return -2;
#elif defined(PSNIP_CLOCK_CPU_METHOD) && PSNIP_CLOCK_CPU_METHOD == PSNIP_CLOCK_METHOD_CLOCK_GETTIME
    return psnip_clock__clock_gettime(PSNIP_CLOCK_CLOCK_GETTIME_CPU, res);
#elif defined(PSNIP_CLOCK_CPU_METHOD) && PSNIP_CLOCK_CPU_METHOD == PSNIP_CLOCK_METHOD_CLOCK
    clock_t t = clock();
  if (t == ((clock_t) -1))
    return -5;
  res->seconds = t / CLOCKS_PER_SEC;
  res->nanoseconds = (t % CLOCKS_PER_SEC) * (PSNIP_CLOCK_NSEC_PER_SEC / CLOCKS_PER_SEC);
#elif defined(PSNIP_CLOCK_CPU_METHOD) && PSNIP_CLOCK_CPU_METHOD == PSNIP_CLOCK_METHOD_GETPROCESSTIMES
  FILETIME CreationTime, ExitTime, KernelTime, UserTime;
  LARGE_INTEGER date, adjust;
 
  if (!GetProcessTimes(GetCurrentProcess(), &CreationTime, &ExitTime, &KernelTime, &UserTime))
    return -7;
 
  /* http://www.frenk.com/2009/12/convert-filetime-to-unix-timestamp/ */
  date.HighPart = UserTime.dwHighDateTime;
  date.LowPart = UserTime.dwLowDateTime;
  adjust.QuadPart = 11644473600000 * 10000;
  date.QuadPart -= adjust.QuadPart;
 
  res->seconds = date.QuadPart / 10000000;
  res->nanoseconds = (date.QuadPart % 10000000) * (PSNIP_CLOCK_NSEC_PER_SEC / 100);
#elif PSNIP_CLOCK_CPU_METHOD == PSNIP_CLOCK_METHOD_GETRUSAGE
  struct rusage usage;
  if (getrusage(RUSAGE_SELF, &usage) != 0)
    return -8;
 
  res->seconds = usage.ru_utime.tv_sec;
  res->nanoseconds = tv.tv_usec * 1000;
#else
  (void) res;
  return -2;
#endif
 
    return 0;
}

References PsnipClockTimespec::nanoseconds, PSNIP_CLOCK_NSEC_PER_SEC, and PsnipClockTimespec::seconds.

Referenced by psnip_clock_get_time().

Here is the caller graph for this function:

psnip_clock_get_precision()

PSNIP_CLOCK__FUNCTION psnip_uint32_t psnip_clock_get_precision

(

enum PsnipClockType

clock_type

)

Definition at line 733 of file munit.c.

                                                          {
    switch (clock_type) {
        case PSNIP_CLOCK_TYPE_MONOTONIC:
            return psnip_clock_monotonic_get_precision();
        case PSNIP_CLOCK_TYPE_CPU:
            return psnip_clock_cpu_get_precision();
        case PSNIP_CLOCK_TYPE_WALL:
            return psnip_clock_wall_get_precision();
    }
 
    PSNIP_CLOCK_UNREACHABLE();
    return 0;
}

References psnip_clock_cpu_get_precision(), psnip_clock_monotonic_get_precision(), PSNIP_CLOCK_TYPE_CPU, PSNIP_CLOCK_TYPE_MONOTONIC, PSNIP_CLOCK_TYPE_WALL, PSNIP_CLOCK_UNREACHABLE, and psnip_clock_wall_get_precision().

Here is the call graph for this function:

psnip_clock_get_time()

PSNIP_CLOCK__FUNCTION int psnip_clock_get_time	(	enum PsnipClockType	clock_type,
		struct PsnipClockTimespec *	res )

Definition at line 750 of file munit.c.

                                                                                     {
    assert(res != NULL);
 
    switch (clock_type) {
        case PSNIP_CLOCK_TYPE_MONOTONIC:
            return psnip_clock_monotonic_get_time(res);
        case PSNIP_CLOCK_TYPE_CPU:
            return psnip_clock_cpu_get_time(res);
        case PSNIP_CLOCK_TYPE_WALL:
            return psnip_clock_wall_get_time(res);
    }
 
    return -1;
}

References assert(), psnip_clock_cpu_get_time(), psnip_clock_monotonic_get_time(), PSNIP_CLOCK_TYPE_CPU, PSNIP_CLOCK_TYPE_MONOTONIC, PSNIP_CLOCK_TYPE_WALL, and psnip_clock_wall_get_time().

Here is the call graph for this function:

psnip_clock_monotonic_get_precision()

PSNIP_CLOCK__FUNCTION psnip_uint32_t psnip_clock_monotonic_get_precision

(

void

)

Definition at line 661 of file munit.c.

                                          {
#if !defined(PSNIP_CLOCK_MONOTONIC_METHOD)
    return 0;
#elif defined(PSNIP_CLOCK_MONOTONIC_METHOD) && PSNIP_CLOCK_MONOTONIC_METHOD == PSNIP_CLOCK_METHOD_CLOCK_GETTIME
    return psnip_clock__clock_getres(PSNIP_CLOCK_CLOCK_GETTIME_MONOTONIC);
#elif defined(PSNIP_CLOCK_MONOTONIC_METHOD) && PSNIP_CLOCK_MONOTONIC_METHOD == PSNIP_CLOCK_METHOD_MACH_ABSOLUTE_TIME
    static mach_timebase_info_data_t tbi = { 0, };
  if (tbi.denom == 0)
    mach_timebase_info(&tbi);
  return (psnip_uint32_t) (tbi.numer / tbi.denom);
#elif defined(PSNIP_CLOCK_MONOTONIC_METHOD) && PSNIP_CLOCK_MONOTONIC_METHOD == PSNIP_CLOCK_METHOD_GETTICKCOUNT64
  return 1000;
#elif defined(PSNIP_CLOCK_MONOTONIC_METHOD) && PSNIP_CLOCK_MONOTONIC_METHOD == PSNIP_CLOCK_METHOD_QUERYPERFORMANCECOUNTER
  LARGE_INTEGER Frequency;
  QueryPerformanceFrequency(&Frequency);
  return (psnip_uint32_t) ((Frequency.QuadPart > PSNIP_CLOCK_NSEC_PER_SEC) ? PSNIP_CLOCK_NSEC_PER_SEC : Frequency.QuadPart);
#else
  return 0;
#endif
}

References PSNIP_CLOCK_NSEC_PER_SEC, and psnip_uint32_t.

Referenced by psnip_clock_get_precision().

Here is the caller graph for this function:

psnip_clock_monotonic_get_time()

PSNIP_CLOCK__FUNCTION int psnip_clock_monotonic_get_time

(

struct PsnipClockTimespec *

res

)

Definition at line 683 of file munit.c.

                                                               {
#if !defined(PSNIP_CLOCK_MONOTONIC_METHOD)
    (void) res;
  return -2;
#elif defined(PSNIP_CLOCK_MONOTONIC_METHOD) && PSNIP_CLOCK_MONOTONIC_METHOD == PSNIP_CLOCK_METHOD_CLOCK_GETTIME
    return psnip_clock__clock_gettime(PSNIP_CLOCK_CLOCK_GETTIME_MONOTONIC, res);
#elif defined(PSNIP_CLOCK_MONOTONIC_METHOD) && PSNIP_CLOCK_MONOTONIC_METHOD == PSNIP_CLOCK_METHOD_MACH_ABSOLUTE_TIME
    psnip_uint64_t nsec = mach_absolute_time();
  static mach_timebase_info_data_t tbi = { 0, };
  if (tbi.denom == 0)
    mach_timebase_info(&tbi);
  nsec *= ((psnip_uint64_t) tbi.numer) / ((psnip_uint64_t) tbi.denom);
  res->seconds = nsec / PSNIP_CLOCK_NSEC_PER_SEC;
  res->nanoseconds = nsec % PSNIP_CLOCK_NSEC_PER_SEC;
#elif defined(PSNIP_CLOCK_MONOTONIC_METHOD) && PSNIP_CLOCK_MONOTONIC_METHOD == PSNIP_CLOCK_METHOD_QUERYPERFORMANCECOUNTER
  LARGE_INTEGER t, f;
  if (QueryPerformanceCounter(&t) == 0)
    return -12;
 
  QueryPerformanceFrequency(&f);
  res->seconds = t.QuadPart / f.QuadPart;
  res->nanoseconds = t.QuadPart % f.QuadPart;
  if (f.QuadPart > PSNIP_CLOCK_NSEC_PER_SEC)
    res->nanoseconds /= f.QuadPart / PSNIP_CLOCK_NSEC_PER_SEC;
  else
    res->nanoseconds *= PSNIP_CLOCK_NSEC_PER_SEC / f.QuadPart;
#elif defined(PSNIP_CLOCK_MONOTONIC_METHOD) && PSNIP_CLOCK_MONOTONIC_METHOD == PSNIP_CLOCK_METHOD_GETTICKCOUNT64
  const ULONGLONG msec = GetTickCount64();
  res->seconds = msec / 1000;
  res->nanoseconds = sec % 1000;
#else
  return -2;
#endif
 
    return 0;
}

References PsnipClockTimespec::nanoseconds, PSNIP_CLOCK_NSEC_PER_SEC, psnip_uint64_t, and PsnipClockTimespec::seconds.

Referenced by psnip_clock_get_time().

Here is the caller graph for this function:

psnip_clock_wall_get_precision()

PSNIP_CLOCK__FUNCTION psnip_uint32_t psnip_clock_wall_get_precision

(

void

)

Definition at line 562 of file munit.c.

                                     {
#if !defined(PSNIP_CLOCK_WALL_METHOD)
    return 0;
#elif defined(PSNIP_CLOCK_WALL_METHOD) && PSNIP_CLOCK_WALL_METHOD == PSNIP_CLOCK_METHOD_CLOCK_GETTIME
    return psnip_clock__clock_getres(PSNIP_CLOCK_CLOCK_GETTIME_WALL);
#elif defined(PSNIP_CLOCK_WALL_METHOD) && PSNIP_CLOCK_WALL_METHOD == PSNIP_CLOCK_METHOD_GETTIMEOFDAY
    return 1000000;
#elif defined(PSNIP_CLOCK_WALL_METHOD) && PSNIP_CLOCK_WALL_METHOD == PSNIP_CLOCK_METHOD_TIME
  return 1;
#else
  return 0;
#endif
}

Referenced by psnip_clock_get_precision().

Here is the caller graph for this function:

psnip_clock_wall_get_time()

PSNIP_CLOCK__FUNCTION int psnip_clock_wall_get_time

(

struct PsnipClockTimespec *

res

)

Definition at line 577 of file munit.c.

                                                          {
    (void) res;
 
#if !defined(PSNIP_CLOCK_WALL_METHOD)
    return -2;
#elif defined(PSNIP_CLOCK_WALL_METHOD) && PSNIP_CLOCK_WALL_METHOD == PSNIP_CLOCK_METHOD_CLOCK_GETTIME
    return psnip_clock__clock_gettime(PSNIP_CLOCK_CLOCK_GETTIME_WALL, res);
#elif defined(PSNIP_CLOCK_WALL_METHOD) && PSNIP_CLOCK_WALL_METHOD == PSNIP_CLOCK_METHOD_TIME
    res->seconds = time(NULL);
  res->nanoseconds = 0;
#elif defined(PSNIP_CLOCK_WALL_METHOD) && PSNIP_CLOCK_WALL_METHOD == PSNIP_CLOCK_METHOD_GETTIMEOFDAY
  struct timeval tv;
 
  if (gettimeofday(&tv, NULL) != 0)
    return -6;
 
  res->seconds = tv.tv_sec;
  res->nanoseconds = tv.tv_usec * 1000;
#else
  return -2;
#endif
 
    return 0;
}

References PsnipClockTimespec::nanoseconds, and PsnipClockTimespec::seconds.

Referenced by psnip_clock_get_time().

Here is the caller graph for this function: