munit.h File Reference

#include <stdarg.h>
#include <stdlib.h>
#include <stdint.h>
#include <inttypes.h>
#include <string.h>

Include dependency graph for munit.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	MunitParameterEnum
struct	MunitParameter
struct	MunitTest
struct	MunitSuite_
struct	MunitArgument_

Macros
#define	MUNIT_VERSION(major, minor, revision)
#define	MUNIT_CURRENT_VERSION   MUNIT_VERSION(0, 4, 1)
#define	munit_int8_t   int8_t
#define	munit_uint8_t   uint8_t
#define	munit_int16_t   int16_t
#define	munit_uint16_t   uint16_t
#define	munit_int32_t   int32_t
#define	munit_uint32_t   uint32_t
#define	munit_int64_t   int64_t
#define	munit_uint64_t   uint64_t
#define	munit_bool   int
#define	MUNIT_LIKELY(expr)
#define	MUNIT_UNLIKELY(expr)
#define	MUNIT_UNUSED
#define	MUNIT_ARRAY_PARAM(name)
#define	MUNIT_SIZE_MODIFIER   "z"
#define	MUNIT_CHAR_MODIFIER   "hh"
#define	MUNIT_SHORT_MODIFIER   "h"
#define	MUNIT_NO_RETURN
#define	MUNIT_PUSH_DISABLE_MSVC_C4127_
#define	MUNIT_POP_DISABLE_MSVC_C4127_
#define	MUNIT_PRINTF(string_index, first_to_check)
#define	munit_logf(level, format, ...)
#define	munit_log(level, msg)
#define	munit_errorf(format, ...)
#define	munit_error(msg)
#define	munit_assert(expr)
#define	munit_assert_true(expr)
#define	munit_assert_false(expr)
#define	munit_assert_type_full(prefix, suffix, T, fmt, a, op, b)
#define	munit_assert_type(T, fmt, a, op, b)
#define	munit_assert_char(a, op, b)
#define	munit_assert_uchar(a, op, b)
#define	munit_assert_short(a, op, b)
#define	munit_assert_ushort(a, op, b)
#define	munit_assert_int(a, op, b)
#define	munit_assert_uint(a, op, b)
#define	munit_assert_long(a, op, b)
#define	munit_assert_ulong(a, op, b)
#define	munit_assert_llong(a, op, b)
#define	munit_assert_ullong(a, op, b)
#define	munit_assert_size(a, op, b)
#define	munit_assert_float(a, op, b)
#define	munit_assert_double(a, op, b)
#define	munit_assert_ptr(a, op, b)
#define	munit_assert_int8(a, op, b)
#define	munit_assert_uint8(a, op, b)
#define	munit_assert_int16(a, op, b)
#define	munit_assert_uint16(a, op, b)
#define	munit_assert_int32(a, op, b)
#define	munit_assert_uint32(a, op, b)
#define	munit_assert_int64(a, op, b)
#define	munit_assert_uint64(a, op, b)
#define	munit_assert_double_equal(a, b, precision)
#define	munit_assert_string_equal(a, b)
#define	munit_assert_string_not_equal(a, b)
#define	munit_assert_memory_equal(size, a, b)
#define	munit_assert_memory_not_equal(size, a, b)
#define	munit_assert_ptr_equal(a, b)
#define	munit_assert_ptr_not_equal(a, b)
#define	munit_assert_null(ptr)
#define	munit_assert_not_null(ptr)
#define	munit_assert_ptr_null(ptr)
#define	munit_assert_ptr_not_null(ptr)
#define	munit_malloc(size)
#define	munit_new(type)
#define	munit_calloc(nmemb, size)
#define	munit_newa(type, nmemb)

Typedefs
typedef MunitResult(*	MunitTestFunc) (const MunitParameter params[], void *user_data_or_fixture)
typedef void *(*	MunitTestSetup) (const MunitParameter params[], void *user_data)
typedef void(*	MunitTestTearDown) (void *fixture)
typedef struct MunitSuite_	MunitSuite
typedef struct MunitArgument_	MunitArgument

Enumerations
enum	MunitLogLevel { MUNIT_LOG_DEBUG , MUNIT_LOG_INFO , MUNIT_LOG_WARNING , MUNIT_LOG_ERROR }
enum	MunitResult { MUNIT_OK , MUNIT_FAIL , MUNIT_SKIP , MUNIT_ERROR }
enum	MunitTestOptions { MUNIT_TEST_OPTION_NONE = 0 , MUNIT_TEST_OPTION_SINGLE_ITERATION = 1 << 0 , MUNIT_TEST_OPTION_TODO = 1 << 1 }
enum	MunitSuiteOptions { MUNIT_SUITE_OPTION_NONE = 0 }

Functions
void	munit_logf_ex (MunitLogLevel level, const char *filename, int line, const char *format,...)
MUNIT_NO_RETURN void	munit_errorf_ex (const char *filename, int line, const char *format,...)
void *	munit_malloc_ex (const char *filename, int line, size_t size)
void	munit_rand_seed (munit_uint32_t seed)
munit_uint32_t	munit_rand_uint32 (void)
int	munit_rand_int_range (int min, int max)
double	munit_rand_double (void)
void	munit_rand_memory (size_t size, munit_uint8_t buffer[MUNIT_ARRAY_PARAM(size)])
const char *	munit_parameters_get (const MunitParameter params[], const char *key)
int	munit_suite_main (const MunitSuite *suite, void *user_data, int argc, char *const argv[MUNIT_ARRAY_PARAM(argc+1)])
int	munit_suite_main_custom (const MunitSuite *suite, void *user_data, int argc, char *const argv[MUNIT_ARRAY_PARAM(argc+1)], const MunitArgument arguments[])

Macro Definition Documentation

MUNIT_ARRAY_PARAM

#define MUNIT_ARRAY_PARAM

(

name

)

Definition at line 142 of file munit.h.

munit_assert

#define munit_assert

(

expr

)

Value:

  do { \
    if (!MUNIT_LIKELY(expr)) { \
      munit_error("assertion failed: " #expr); \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

Definition at line 209 of file munit.h.

#define munit_assert(expr) \
  do { \
    if (!MUNIT_LIKELY(expr)) { \
      munit_error("assertion failed: " #expr); \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

munit_assert_char

#define munit_assert_char	(		a,
			op,
			b )

Value:

  munit_assert_type_full("'\\x", "'", char, "02" MUNIT_CHAR_MODIFIER "x", a, op, b)

Definition at line 251 of file munit.h.

#define munit_assert_char(a, op, b) \
  munit_assert_type_full("'\\x", "'", char, "02" MUNIT_CHAR_MODIFIER "x", a, op, b)

munit_assert_double

#define munit_assert_double	(		a,
			op,
			b )

Value:

  munit_assert_type(double, "g", a, op, b)

Definition at line 277 of file munit.h.

#define munit_assert_double(a, op, b) \
  munit_assert_type(double, "g", a, op, b)

munit_assert_double_equal

#define munit_assert_double_equal	(		a,
			b,
			precision )

Value:

  do { \
    const double munit_tmp_a_ = (a); \
    const double munit_tmp_b_ = (b); \
    const double munit_tmp_diff_ = ((munit_tmp_a_ - munit_tmp_b_) < 0) ? \
      -(munit_tmp_a_ - munit_tmp_b_) : \
      (munit_tmp_a_ - munit_tmp_b_); \
    if (MUNIT_UNLIKELY(munit_tmp_diff_ > 1e-##precision)) { \
      munit_errorf("assertion failed: %s == %s (%0." #precision "g == %0." #precision "g)", \
           #a, #b, munit_tmp_a_, munit_tmp_b_); \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

Definition at line 299 of file munit.h.

#define munit_assert_double_equal(a, b, precision) \
  do { \
    const double munit_tmp_a_ = (a); \
    const double munit_tmp_b_ = (b); \
    const double munit_tmp_diff_ = ((munit_tmp_a_ - munit_tmp_b_) < 0) ? \
      -(munit_tmp_a_ - munit_tmp_b_) : \
      (munit_tmp_a_ - munit_tmp_b_); \
    if (MUNIT_UNLIKELY(munit_tmp_diff_ > 1e-##precision)) { \
      munit_errorf("assertion failed: %s == %s (%0." #precision "g == %0." #precision "g)", \
           #a, #b, munit_tmp_a_, munit_tmp_b_); \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

munit_assert_false

#define munit_assert_false

(

expr

)

Value:

  do { \
    if (!MUNIT_LIKELY(!(expr))) { \
      munit_error("assertion failed: " #expr " is not false"); \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

Definition at line 227 of file munit.h.

#define munit_assert_false(expr) \
  do { \
    if (!MUNIT_LIKELY(!(expr))) { \
      munit_error("assertion failed: " #expr " is not false"); \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

munit_assert_float

#define munit_assert_float	(		a,
			op,
			b )

Value:

  munit_assert_type(float, "f", a, op, b)

Definition at line 275 of file munit.h.

#define munit_assert_float(a, op, b) \
  munit_assert_type(float, "f", a, op, b)

munit_assert_int

#define munit_assert_int	(		a,
			op,
			b )

Value:

  munit_assert_type(int, "d", a, op, b)

Definition at line 259 of file munit.h.

#define munit_assert_int(a, op, b) \
  munit_assert_type(int, "d", a, op, b)

munit_assert_int16

#define munit_assert_int16	(		a,
			op,
			b )

Value:

  munit_assert_type(munit_int16_t, PRIi16, a, op, b)

Definition at line 286 of file munit.h.

#define munit_assert_int16(a, op, b) \
  munit_assert_type(munit_int16_t, PRIi16, a, op, b)

munit_assert_int32

#define munit_assert_int32	(		a,
			op,
			b )

Value:

  munit_assert_type(munit_int32_t, PRIi32, a, op, b)

Definition at line 290 of file munit.h.

#define munit_assert_int32(a, op, b) \
  munit_assert_type(munit_int32_t, PRIi32, a, op, b)

munit_assert_int64

#define munit_assert_int64	(		a,
			op,
			b )

Value:

  munit_assert_type(munit_int64_t, PRIi64, a, op, b)

Definition at line 294 of file munit.h.

#define munit_assert_int64(a, op, b) \
  munit_assert_type(munit_int64_t, PRIi64, a, op, b)

munit_assert_int8

#define munit_assert_int8	(		a,
			op,
			b )

Value:

  munit_assert_type(munit_int8_t, PRIi8, a, op, b)

Definition at line 282 of file munit.h.

#define munit_assert_int8(a, op, b)             \
  munit_assert_type(munit_int8_t, PRIi8, a, op, b)

munit_assert_llong

#define munit_assert_llong	(		a,
			op,
			b )

Value:

  munit_assert_type(long long int, "lld", a, op, b)

Definition at line 267 of file munit.h.

#define munit_assert_llong(a, op, b) \
  munit_assert_type(long long int, "lld", a, op, b)

munit_assert_long

#define munit_assert_long	(		a,
			op,
			b )

Value:

  munit_assert_type(long int, "ld", a, op, b)

Definition at line 263 of file munit.h.

#define munit_assert_long(a, op, b) \
  munit_assert_type(long int, "ld", a, op, b)

munit_assert_memory_equal

#define munit_assert_memory_equal	(		size,
			a,
			b )

Value:

  do { \
    const unsigned char* munit_tmp_a_ = (const unsigned char*) (a); \
    const unsigned char* munit_tmp_b_ = (const unsigned char*) (b); \
    const size_t munit_tmp_size_ = (size); \
    if (MUNIT_UNLIKELY(memcmp(munit_tmp_a_, munit_tmp_b_, munit_tmp_size_)) != 0) { \
      size_t munit_tmp_pos_; \
      for (munit_tmp_pos_ = 0 ; munit_tmp_pos_ < munit_tmp_size_ ; munit_tmp_pos_++) { \
        if (munit_tmp_a_[munit_tmp_pos_] != munit_tmp_b_[munit_tmp_pos_]) { \
          munit_errorf("assertion failed: memory %s == %s, at offset %" MUNIT_SIZE_MODIFIER "u", \
                       #a, #b, munit_tmp_pos_); \
          break; \
        } \
      } \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

Definition at line 340 of file munit.h.

#define munit_assert_memory_equal(size, a, b) \
  do { \
    const unsigned char* munit_tmp_a_ = (const unsigned char*) (a); \
    const unsigned char* munit_tmp_b_ = (const unsigned char*) (b); \
    const size_t munit_tmp_size_ = (size); \
    if (MUNIT_UNLIKELY(memcmp(munit_tmp_a_, munit_tmp_b_, munit_tmp_size_)) != 0) { \
      size_t munit_tmp_pos_; \
      for (munit_tmp_pos_ = 0 ; munit_tmp_pos_ < munit_tmp_size_ ; munit_tmp_pos_++) { \
        if (munit_tmp_a_[munit_tmp_pos_] != munit_tmp_b_[munit_tmp_pos_]) { \
          munit_errorf("assertion failed: memory %s == %s, at offset %" MUNIT_SIZE_MODIFIER "u", \
                       #a, #b, munit_tmp_pos_); \
          break; \
        } \
      } \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

munit_assert_memory_not_equal

#define munit_assert_memory_not_equal	(		size,
			a,
			b )

Value:

  do { \
    const unsigned char* munit_tmp_a_ = (const unsigned char*) (a); \
    const unsigned char* munit_tmp_b_ = (const unsigned char*) (b); \
    const size_t munit_tmp_size_ = (size); \
    if (MUNIT_UNLIKELY(memcmp(munit_tmp_a_, munit_tmp_b_, munit_tmp_size_)) == 0) { \
      munit_errorf("assertion failed: memory %s != %s (%zu bytes)", \
                   #a, #b, munit_tmp_size_); \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

Definition at line 359 of file munit.h.

#define munit_assert_memory_not_equal(size, a, b) \
  do { \
    const unsigned char* munit_tmp_a_ = (const unsigned char*) (a); \
    const unsigned char* munit_tmp_b_ = (const unsigned char*) (b); \
    const size_t munit_tmp_size_ = (size); \
    if (MUNIT_UNLIKELY(memcmp(munit_tmp_a_, munit_tmp_b_, munit_tmp_size_)) == 0) { \
      munit_errorf("assertion failed: memory %s != %s (%zu bytes)", \
                   #a, #b, munit_tmp_size_); \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

munit_assert_not_null

#define munit_assert_not_null

(

ptr

)

Value:

  munit_assert_ptr(ptr, !=, NULL)

Definition at line 378 of file munit.h.

#define munit_assert_not_null(ptr) \
  munit_assert_ptr(ptr, !=, NULL)

munit_assert_null

#define munit_assert_null

(

ptr

)

Value:

  munit_assert_ptr(ptr, ==, NULL)

Definition at line 376 of file munit.h.

#define munit_assert_null(ptr) \
  munit_assert_ptr(ptr, ==, NULL)

munit_assert_ptr

#define munit_assert_ptr	(		a,
			op,
			b )

Value:

  munit_assert_type(const void*, "p", a, op, b)

Definition at line 279 of file munit.h.

#define munit_assert_ptr(a, op, b) \
  munit_assert_type(const void*, "p", a, op, b)

munit_assert_ptr_equal

#define munit_assert_ptr_equal	(		a,
			b )

Value:

  munit_assert_ptr(a, ==, b)

Definition at line 372 of file munit.h.

#define munit_assert_ptr_equal(a, b) \
  munit_assert_ptr(a, ==, b)

munit_assert_ptr_not_equal

#define munit_assert_ptr_not_equal	(		a,
			b )

Value:

  munit_assert_ptr(a, !=, b)

Definition at line 374 of file munit.h.

#define munit_assert_ptr_not_equal(a, b) \
  munit_assert_ptr(a, !=, b)

munit_assert_ptr_not_null

#define munit_assert_ptr_not_null

(

ptr

)

Value:

  munit_assert_ptr(ptr, !=, NULL)

Definition at line 382 of file munit.h.

#define munit_assert_ptr_not_null(ptr) \
  munit_assert_ptr(ptr, !=, NULL)

munit_assert_ptr_null

#define munit_assert_ptr_null

(

ptr

)

Value:

  munit_assert_ptr(ptr, ==, NULL)

Definition at line 380 of file munit.h.

#define munit_assert_ptr_null(ptr) \
  munit_assert_ptr(ptr, ==, NULL)

munit_assert_short

#define munit_assert_short	(		a,
			op,
			b )

Value:

  munit_assert_type(short, MUNIT_SHORT_MODIFIER "d", a, op, b)

Definition at line 255 of file munit.h.

#define munit_assert_short(a, op, b) \
  munit_assert_type(short, MUNIT_SHORT_MODIFIER "d", a, op, b)

munit_assert_size

#define munit_assert_size	(		a,
			op,
			b )

Value:

  munit_assert_type(size_t, MUNIT_SIZE_MODIFIER "u", a, op, b)

Definition at line 272 of file munit.h.

#define munit_assert_size(a, op, b) \
  munit_assert_type(size_t, MUNIT_SIZE_MODIFIER "u", a, op, b)

munit_assert_string_equal

#define munit_assert_string_equal	(		a,
			b )

Value:

  do { \
    const char* munit_tmp_a_ = a; \
    const char* munit_tmp_b_ = b; \
    if (MUNIT_UNLIKELY(strcmp(munit_tmp_a_, munit_tmp_b_) != 0)) { \
      munit_errorf("assertion failed: string %s == %s (\"%s\" == \"%s\")", \
                   #a, #b, munit_tmp_a_, munit_tmp_b_); \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

Definition at line 316 of file munit.h.

#define munit_assert_string_equal(a, b) \
  do { \
    const char* munit_tmp_a_ = a; \
    const char* munit_tmp_b_ = b; \
    if (MUNIT_UNLIKELY(strcmp(munit_tmp_a_, munit_tmp_b_) != 0)) { \
      munit_errorf("assertion failed: string %s == %s (\"%s\" == \"%s\")", \
                   #a, #b, munit_tmp_a_, munit_tmp_b_); \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

munit_assert_string_not_equal

#define munit_assert_string_not_equal	(		a,
			b )

Value:

  do { \
    const char* munit_tmp_a_ = a; \
    const char* munit_tmp_b_ = b; \
    if (MUNIT_UNLIKELY(strcmp(munit_tmp_a_, munit_tmp_b_) == 0)) { \
      munit_errorf("assertion failed: string %s != %s (\"%s\" == \"%s\")", \
                   #a, #b, munit_tmp_a_, munit_tmp_b_); \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

Definition at line 328 of file munit.h.

#define munit_assert_string_not_equal(a, b) \
  do { \
    const char* munit_tmp_a_ = a; \
    const char* munit_tmp_b_ = b; \
    if (MUNIT_UNLIKELY(strcmp(munit_tmp_a_, munit_tmp_b_) == 0)) { \
      munit_errorf("assertion failed: string %s != %s (\"%s\" == \"%s\")", \
                   #a, #b, munit_tmp_a_, munit_tmp_b_); \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

munit_assert_true

#define munit_assert_true

(

expr

)

Value:

  do { \
    if (!MUNIT_LIKELY(expr)) { \
      munit_error("assertion failed: " #expr " is not true"); \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

Definition at line 218 of file munit.h.

#define munit_assert_true(expr) \
  do { \
    if (!MUNIT_LIKELY(expr)) { \
      munit_error("assertion failed: " #expr " is not true"); \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

munit_assert_type

#define munit_assert_type	(		T,
			fmt,
			a,
			op,
			b )

Value:

  munit_assert_type_full("", "", T, fmt, a, op, b)

Definition at line 248 of file munit.h.

#define munit_assert_type(T, fmt, a, op, b) \
  munit_assert_type_full("", "", T, fmt, a, op, b)

munit_assert_type_full

#define munit_assert_type_full	(		prefix,
			suffix,
			T,
			fmt,
			a,
			op,
			b )

Value:

  do { \
    T munit_tmp_a_ = (a); \
    T munit_tmp_b_ = (b); \
    if (!(munit_tmp_a_ op munit_tmp_b_)) {                               \
      munit_errorf("assertion failed: %s %s %s (" prefix "%" fmt suffix " %s " prefix "%" fmt suffix ")", \
                   #a, #op, #b, munit_tmp_a_, #op, munit_tmp_b_); \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

Definition at line 236 of file munit.h.

#define munit_assert_type_full(prefix, suffix, T, fmt, a, op, b)   \
  do { \
    T munit_tmp_a_ = (a); \
    T munit_tmp_b_ = (b); \
    if (!(munit_tmp_a_ op munit_tmp_b_)) {                               \
      munit_errorf("assertion failed: %s %s %s (" prefix "%" fmt suffix " %s " prefix "%" fmt suffix ")", \
                   #a, #op, #b, munit_tmp_a_, #op, munit_tmp_b_); \
    } \
    MUNIT_PUSH_DISABLE_MSVC_C4127_ \
  } while (0) \
  MUNIT_POP_DISABLE_MSVC_C4127_

munit_assert_uchar

#define munit_assert_uchar	(		a,
			op,
			b )

Value:

  munit_assert_type_full("'\\x", "'", unsigned char, "02" MUNIT_CHAR_MODIFIER "x", a, op, b)

Definition at line 253 of file munit.h.

#define munit_assert_uchar(a, op, b) \
  munit_assert_type_full("'\\x", "'", unsigned char, "02" MUNIT_CHAR_MODIFIER "x", a, op, b)

munit_assert_uint

#define munit_assert_uint	(		a,
			op,
			b )

Value:

  munit_assert_type(unsigned int, "u", a, op, b)

Definition at line 261 of file munit.h.

#define munit_assert_uint(a, op, b) \
  munit_assert_type(unsigned int, "u", a, op, b)

munit_assert_uint16

#define munit_assert_uint16	(		a,
			op,
			b )

Value:

  munit_assert_type(munit_uint16_t, PRIu16, a, op, b)

Definition at line 288 of file munit.h.

#define munit_assert_uint16(a, op, b) \
  munit_assert_type(munit_uint16_t, PRIu16, a, op, b)

munit_assert_uint32

#define munit_assert_uint32	(		a,
			op,
			b )

Value:

  munit_assert_type(munit_uint32_t, PRIu32, a, op, b)

Definition at line 292 of file munit.h.

#define munit_assert_uint32(a, op, b) \
  munit_assert_type(munit_uint32_t, PRIu32, a, op, b)

munit_assert_uint64

#define munit_assert_uint64	(		a,
			op,
			b )

Value:

  munit_assert_type(munit_uint64_t, PRIu64, a, op, b)

Definition at line 296 of file munit.h.

#define munit_assert_uint64(a, op, b) \
  munit_assert_type(munit_uint64_t, PRIu64, a, op, b)

munit_assert_uint8

#define munit_assert_uint8	(		a,
			op,
			b )

Value:

  munit_assert_type(munit_uint8_t, PRIu8, a, op, b)

Definition at line 284 of file munit.h.

#define munit_assert_uint8(a, op, b) \
  munit_assert_type(munit_uint8_t, PRIu8, a, op, b)

munit_assert_ullong

#define munit_assert_ullong	(		a,
			op,
			b )

Value:

  munit_assert_type(unsigned long long int, "llu", a, op, b)

Definition at line 269 of file munit.h.

#define munit_assert_ullong(a, op, b) \
  munit_assert_type(unsigned long long int, "llu", a, op, b)

munit_assert_ulong

#define munit_assert_ulong	(		a,
			op,
			b )

Value:

  munit_assert_type(unsigned long int, "lu", a, op, b)

Definition at line 265 of file munit.h.

#define munit_assert_ulong(a, op, b) \
  munit_assert_type(unsigned long int, "lu", a, op, b)

munit_assert_ushort

#define munit_assert_ushort	(		a,
			op,
			b )

Value:

  munit_assert_type(unsigned short, MUNIT_SHORT_MODIFIER "u", a, op, b)

Definition at line 257 of file munit.h.

#define munit_assert_ushort(a, op, b) \
  munit_assert_type(unsigned short, MUNIT_SHORT_MODIFIER "u", a, op, b)

munit_bool

#define munit_bool   int

Definition at line 121 of file munit.h.

munit_calloc

#define munit_calloc	(		nmemb,
			size )

Value:

  munit_malloc((nmemb) * (size))

Definition at line 395 of file munit.h.

#define munit_calloc(nmemb, size) \
  munit_malloc((nmemb) * (size))

MUNIT_CHAR_MODIFIER

#define MUNIT_CHAR_MODIFIER   "hh"

Definition at line 147 of file munit.h.

MUNIT_CURRENT_VERSION

#define MUNIT_CURRENT_VERSION   MUNIT_VERSION(0, 4, 1)

Definition at line 35 of file munit.h.

munit_error

#define munit_error

(

msg

)

Value:

  munit_errorf("%s", msg)

Definition at line 206 of file munit.h.

#define munit_error(msg) \
  munit_errorf("%s", msg)

munit_errorf

#define munit_errorf	(		format,
			... )

Value:

  munit_errorf_ex(__FILE__, __LINE__, format, __VA_ARGS__)

Definition at line 203 of file munit.h.

#define munit_errorf(format, ...) \
  munit_errorf_ex(__FILE__, __LINE__, format, __VA_ARGS__)

munit_int16_t

#define munit_int16_t   int16_t

Definition at line 52 of file munit.h.

munit_int32_t

#define munit_int32_t   int32_t

Definition at line 54 of file munit.h.

munit_int64_t

#define munit_int64_t   int64_t

Definition at line 56 of file munit.h.

munit_int8_t

#define munit_int8_t   int8_t

Definition at line 50 of file munit.h.

MUNIT_LIKELY

#define MUNIT_LIKELY

(

expr

)

Value:

(expr)

Definition at line 134 of file munit.h.

munit_log

#define munit_log	(		level,
			msg )

Value:

  munit_logf(level, "%s", msg)

Definition at line 196 of file munit.h.

#define munit_log(level, msg) \
  munit_logf(level, "%s", msg)

munit_logf

#define munit_logf	(		level,
			format,
			... )

Value:

  munit_logf_ex(level, __FILE__, __LINE__, format, __VA_ARGS__)

Definition at line 193 of file munit.h.

#define munit_logf(level, format, ...) \
  munit_logf_ex(level, __FILE__, __LINE__, format, __VA_ARGS__)

munit_malloc

#define munit_malloc

(

size

)

Value:

  munit_malloc_ex(__FILE__, __LINE__, (size))

Definition at line 389 of file munit.h.

#define munit_malloc(size) \
  munit_malloc_ex(__FILE__, __LINE__, (size))

munit_new

#define munit_new

(

type

)

Value:

  ((type*) munit_malloc(sizeof(type)))

Definition at line 392 of file munit.h.

#define munit_new(type) \
  ((type*) munit_malloc(sizeof(type)))

munit_newa

#define munit_newa	(		type,
			nmemb )

Value:

  ((type*) munit_calloc((nmemb), sizeof(type)))

Definition at line 398 of file munit.h.

#define munit_newa(type, nmemb) \
  ((type*) munit_calloc((nmemb), sizeof(type)))

MUNIT_NO_RETURN

#define MUNIT_NO_RETURN

Definition at line 166 of file munit.h.

MUNIT_POP_DISABLE_MSVC_C4127_

#define MUNIT_POP_DISABLE_MSVC_C4127_

Definition at line 174 of file munit.h.

MUNIT_PRINTF

#define MUNIT_PRINTF	(		string_index,
			first_to_check )

Definition at line 187 of file munit.h.

MUNIT_PUSH_DISABLE_MSVC_C4127_

#define MUNIT_PUSH_DISABLE_MSVC_C4127_

Definition at line 173 of file munit.h.

MUNIT_SHORT_MODIFIER

#define MUNIT_SHORT_MODIFIER   "h"

Definition at line 148 of file munit.h.

MUNIT_SIZE_MODIFIER

#define MUNIT_SIZE_MODIFIER   "z"

Definition at line 146 of file munit.h.

Referenced by munit_malloc_ex().

munit_uint16_t

#define munit_uint16_t   uint16_t

Definition at line 53 of file munit.h.

munit_uint32_t

#define munit_uint32_t   uint32_t

Definition at line 55 of file munit.h.

Referenced by munit_rand_double(), munit_rand_int_range(), munit_rand_memory(), munit_rand_seed(), munit_rand_uint32(), and munit_suite_main_custom().

munit_uint64_t

#define munit_uint64_t   uint64_t

Definition at line 57 of file munit.h.

Referenced by munit_rand_int_range().

munit_uint8_t

#define munit_uint8_t   uint8_t

Definition at line 51 of file munit.h.

Referenced by munit_rand_memory().

MUNIT_UNLIKELY

#define MUNIT_UNLIKELY

(

expr

)

Value:

(expr)

Definition at line 135 of file munit.h.

Referenced by munit_malloc_ex().

MUNIT_UNUSED

#define MUNIT_UNUSED

Definition at line 136 of file munit.h.

MUNIT_VERSION

#define MUNIT_VERSION	(		major,
			minor,
			revision )

Value:

  (((major) << 16) | ((minor) << 8) | (revision))

Definition at line 32 of file munit.h.

#define MUNIT_VERSION(major, minor, revision) \
  (((major) << 16) | ((minor) << 8) | (revision))

Typedef Documentation

MunitArgument

typedef struct MunitArgument_ MunitArgument

Definition at line 480 of file munit.h.

MunitSuite

typedef struct MunitSuite_ MunitSuite

Definition at line 465 of file munit.h.

MunitTestFunc

typedef MunitResult(* MunitTestFunc) (const MunitParameter params[], void *user_data_or_fixture)

Definition at line 446 of file munit.h.

MunitTestSetup

typedef void *(* MunitTestSetup) (const MunitParameter params[], void *user_data)

Definition at line 448 of file munit.h.

MunitTestTearDown

typedef void(* MunitTestTearDown) (void *fixture)

Definition at line 450 of file munit.h.

Enumeration Type Documentation

MunitLogLevel

enum MunitLogLevel

Enumerator
MUNIT_LOG_DEBUG
MUNIT_LOG_INFO
MUNIT_LOG_WARNING
MUNIT_LOG_ERROR

Definition at line 177 of file munit.h.

             {
    MUNIT_LOG_DEBUG,
    MUNIT_LOG_INFO,
    MUNIT_LOG_WARNING,
    MUNIT_LOG_ERROR
} MunitLogLevel;

MunitResult

enum MunitResult

Enumerator
MUNIT_OK
MUNIT_FAIL
MUNIT_SKIP
MUNIT_ERROR

Definition at line 415 of file munit.h.

             {
    /* Test successful */
    MUNIT_OK,
    /* Test failed */
    MUNIT_FAIL,
    /* Test was skipped */
    MUNIT_SKIP,
    /* Test failed due to circumstances not intended to be tested
     * (things like network errors, invalid parameter value, failure to
     * allocate memory in the test harness, etc.). */
    MUNIT_ERROR
} MunitResult;

MunitSuiteOptions

enum MunitSuiteOptions

Enumerator
MUNIT_SUITE_OPTION_NONE

Definition at line 461 of file munit.h.

             {
    MUNIT_SUITE_OPTION_NONE = 0
} MunitSuiteOptions;

MunitTestOptions

enum MunitTestOptions

Enumerator
MUNIT_TEST_OPTION_NONE
MUNIT_TEST_OPTION_SINGLE_ITERATION
MUNIT_TEST_OPTION_TODO

Definition at line 440 of file munit.h.

             {
    MUNIT_TEST_OPTION_NONE = 0,
    MUNIT_TEST_OPTION_SINGLE_ITERATION = 1 << 0,
    MUNIT_TEST_OPTION_TODO = 1 << 1
} MunitTestOptions;

Function Documentation

munit_errorf_ex()

MUNIT_NO_RETURN 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	buffer[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: