This header file provides interfaces of the RTEMS Test Framework. More...

#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>

Data Structures
struct	T_fixture

struct	T_fixture_node

struct	T_remark

struct	T_case_context

struct	T_check_context

struct	T_check_context_msg

struct	T_config

struct	T_interrupt_test_config

struct	T_thread_switch_event

struct	T_thread_switch_header

struct	T_thread_switch_log

struct	T_thread_switch_log_2

struct	T_thread_switch_log_4

struct	T_thread_switch_log_10

struct	T_destructor

struct	T_measure_runtime_config

struct	T_measure_runtime_request

Macros
#define	T_ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))

#define	T_FILE_NAME __FILE__

#define	T_ZERO_LENGTH_ARRAY 1

#define	T_NO_RETURN _Noreturn

#define	T_CHECK_STOP 1U

#define	T_CHECK_QUIET 2U

#define	T_CHECK_FMT 4U

#define	T_CHECK_STEP_FLAG 8U

#define	T_CHECK_STEP_TO_FLAGS(step) ((unsigned int)(step) << 8)

#define	T_CHECK_STEP_FROM_FLAGS(flags) ((flags) >> 8)

#define	T_CHECK_STEP(step) (T_CHECK_STEP_TO_FLAGS(step) \| T_CHECK_STEP_FLAG)

#define	T_VA_ARGS_FIRST(...) T_VA_ARGS_FIRST_SELECT(__VA_ARGS__, throw_away)

#define	T_VA_ARGS_FIRST_SELECT(first, ...) first

#define	T_VA_ARGS_MORE(...) T_VA_ARGS_XEXPAND(T_VA_ARGS_KIND(__VA_ARGS__), __VA_ARGS__)

#define	T_VA_ARGS_XEXPAND(kind, ...) T_VA_ARGS_EXPAND(kind, __VA_ARGS__)

#define	T_VA_ARGS_EXPAND(kind, ...) T_VA_ARGS_EXPAND_##kind(__VA_ARGS__)

#define	T_VA_ARGS_EXPAND_0U(first)

#define	T_VA_ARGS_EXPAND_4U(first, ...) , __VA_ARGS__

#define	T_VA_ARGS_KIND(...)

#define	T_VA_ARGS_SELECT(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, ...) a10

#define	T_flags_true(flags, ...)

#define	T_flags_eq(flags, a, ...)

#define	T_flags_ne(flags, a, ...)

#define	T_flags_eq_ptr(a, e, flags, sa, se)

#define	T_flags_ne_ptr(a, e, flags, sa, se)

#define	T_flags_null(a, flags, sa)

#define	T_flags_not_null(a, flags, sa)

#define	T_flags_eq_mem(a, e, n, flags, sa, se, sn)

#define	T_flags_ne_mem(a, e, n, flags, sa, se, sn)

#define	T_flags_eq_str(a, e, flags)

#define	T_flags_ne_str(a, e, flags)

#define	T_flags_eq_nstr(a, e, n, flags)

#define	T_flags_ne_nstr(a, e, n, flags)

#define	T_flags_eq_char(a, e, flags)

#define	T_flags_ne_char(a, e, flags)

#define	T_flags_eq_int(a, e, flags)

#define	T_flags_ne_int(a, e, flags)

#define	T_flags_ge_int(a, e, flags)

#define	T_flags_gt_int(a, e, flags)

#define	T_flags_le_int(a, e, flags)

#define	T_flags_lt_int(a, e, flags)

#define	T_flags_eq_uint(a, e, flags)

#define	T_flags_ne_uint(a, e, flags)

#define	T_flags_ge_uint(a, e, flags)

#define	T_flags_gt_uint(a, e, flags)

#define	T_flags_le_uint(a, e, flags)

#define	T_flags_lt_uint(a, e, flags)

#define	T_flags_eq_long(a, e, flags)

#define	T_flags_ne_long(a, e, flags)

#define	T_flags_ge_long(a, e, flags)

#define	T_flags_gt_long(a, e, flags)

#define	T_flags_le_long(a, e, flags)

#define	T_flags_lt_long(a, e, flags)

#define	T_flags_eq_ulong(a, e, flags)

#define	T_flags_ne_ulong(a, e, flags)

#define	T_flags_ge_ulong(a, e, flags)

#define	T_flags_gt_ulong(a, e, flags)

#define	T_flags_le_ulong(a, e, flags)

#define	T_flags_lt_ulong(a, e, flags)

#define	T_flags_eq_ll(a, e, flags)

#define	T_flags_ne_ll(a, e, flags)

#define	T_flags_ge_ll(a, e, flags)

#define	T_flags_gt_ll(a, e, flags)

#define	T_flags_le_ll(a, e, flags)

#define	T_flags_lt_ll(a, e, flags)

#define	T_flags_eq_ull(a, e, flags)

#define	T_flags_ne_ull(a, e, flags)

#define	T_flags_ge_ull(a, e, flags)

#define	T_flags_gt_ull(a, e, flags)

#define	T_flags_le_ull(a, e, flags)

#define	T_flags_lt_ull(a, e, flags)

#define	T_flags_eno(a, e, flags)

#define	T_flags_eno_success(a, flags)

#define	T_flags_psx_error(a, eno, flags)

#define	T_flags_psx_success(a, flags)

#define	T_true(...) T_flags_true(0, __VA_ARGS__)

#define	T_assert_true(...) T_flags_true(T_CHECK_STOP, __VA_ARGS__)

#define	T_quiet_true(...) T_flags_true(T_CHECK_QUIET, __VA_ARGS__)

#define	T_step_true(s, ...) T_flags_true(T_CHECK_STEP(s), __VA_ARGS__)

#define	T_step_assert_true(s, ...) T_flags_true(T_CHECK_STEP(s) \| T_CHECK_STOP, __VA_ARGS__)

#define	T_false(...)

#define	T_assert_false(...)

#define	T_quiet_false(...)

#define	T_step_false(s, ...)

#define	T_step_assert_false(s, ...)

#define	T_eq(a, ...) T_flags_eq(0, a, __VA_ARGS__)

#define	T_assert_eq(a, ...) T_flags_eq(T_CHECK_STOP, a, __VA_ARGS__)

#define	T_quiet_eq(a, ...) T_flags_eq(T_CHECK_QUIET, a, __VA_ARGS__)

#define	T_step_eq(s, a, ...) T_flags_eq(T_CHECK_STEP(s), a, __VA_ARGS__)

#define	T_step_assert_eq(s, a, ...) T_flags_eq(T_CHECK_STEP(s) \| T_CHECK_STOP, a, __VA_ARGS__)

#define	T_ne(a, ...) T_flags_ne(0, a, __VA_ARGS__)

#define	T_assert_ne(a, ...) T_flags_ne(T_CHECK_STOP, a, __VA_ARGS__)

#define	T_quiet_ne(a, ...) T_flags_ne(T_CHECK_QUIET, a, __VA_ARGS__)

#define	T_step_ne(s, a, ...) T_flags_ne(T_CHECK_STEP(s), a, __VA_ARGS__)

#define	T_step_assert_ne(s, a, ...) T_flags_ne(T_CHECK_STEP(s) \| T_CHECK_STOP, a, __VA_ARGS__)

#define	T_eq_ptr(a, e) T_flags_eq_ptr(a, e, 0, #a, #e)

#define	T_assert_eq_ptr(a, e) T_flags_eq_ptr(a, e, T_CHECK_STOP, #a, #e)

#define	T_quiet_eq_ptr(a, e) T_flags_eq_ptr(a, e, T_CHECK_QUIET, #a, #e)

#define	T_step_eq_ptr(s, a, e) T_flags_eq_ptr(a, e, T_CHECK_STEP(s), #a, #e)

#define	T_step_assert_eq_ptr(s, a, e) T_flags_eq_ptr(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP, #a, #e)

#define	T_ne_ptr(a, e) T_flags_ne_ptr(a, e, 0, #a, #e)

#define	T_assert_ne_ptr(a, e) T_flags_ne_ptr(a, e, T_CHECK_STOP, #a, #e)

#define	T_quiet_ne_ptr(a, e) T_flags_ne_ptr(a, e, T_CHECK_QUIET, #a, #e)

#define	T_step_ne_ptr(s, a, e) T_flags_ne_ptr(a, e, T_CHECK_STEP(s), #a, #e)

#define	T_step_assert_ne_ptr(s, a, e) T_flags_ne_ptr(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP, #a, #e)

#define	T_null(a) T_flags_null(a, 0, #a)

#define	T_assert_null(a) T_flags_null(a, T_CHECK_STOP, #a)

#define	T_quiet_null(a) T_flags_null(a, T_CHECK_QUIET, #a)

#define	T_quiet_assert_null(a) T_flags_null(a, T_CHECK_QUIET \| T_CHECK_STOP, #a)

#define	T_step_null(s, a) T_flags_null(a, T_CHECK_STEP(s), #a)

#define	T_step_assert_null(s, a) T_flags_null(a, T_CHECK_STEP(s) \| T_CHECK_STOP, #a)

#define	T_not_null(a) T_flags_not_null(a, 0, #a)

#define	T_assert_not_null(a) T_flags_not_null(a, T_CHECK_STOP, #a)

#define	T_quiet_not_null(a) T_flags_not_null(a, T_CHECK_QUIET, #a)

#define	T_quiet_assert_not_null(a) T_flags_not_null(a, T_CHECK_QUIET \| T_CHECK_STOP, #a)

#define	T_step_not_null(s, a) T_flags_not_null(a, T_CHECK_STEP(s), #a)

#define	T_step_assert_not_null(s, a) T_flags_not_null(a, T_CHECK_STEP(s) \| T_CHECK_STOP, #a)

#define	T_eq_mem(a, e, n) T_flags_eq_mem(a, e, n, 0, #a, #e, #n)

#define	T_assert_eq_mem(a, e, n) T_flags_eq_mem(a, e, n, T_CHECK_STOP, #a, #e, #n)

#define	T_quiet_eq_mem(a, e, n) T_flags_eq_mem(a, e, n, T_CHECK_QUIET, #a, #e, #n)

#define	T_step_eq_mem(s, a, e, n) T_flags_eq_mem(a, e, n, T_CHECK_STEP(s), #a, #e, #n)

#define	T_step_assert_eq_mem(s, a, e, n) T_flags_eq_mem(a, e, n, T_CHECK_STEP(s) \| T_CHECK_STOP, #a, #e, #n)

#define	T_ne_mem(a, e, n) T_flags_ne_mem(a, e, n, 0, #a, #e, #n)

#define	T_assert_ne_mem(a, e, n) T_flags_ne_mem(a, e, n, T_CHECK_STOP, #a, #e, #n)

#define	T_quiet_ne_mem(a, e, n) T_flags_ne_mem(a, e, n, T_CHECK_QUIET, #a, #e, #n)

#define	T_step_ne_mem(s, a, e, n) T_flags_ne_mem(a, e, n, T_CHECK_STEP(s), #a, #e, #n)

#define	T_step_assert_ne_mem(s, a, e, n) T_flags_ne_mem(a, e, n, T_CHECK_STEP(s) \| T_CHECK_STOP, #a, #e, #n)

#define	T_eq_str(a, e) T_flags_eq_str(a, e, 0)

#define	T_assert_eq_str(a, e) T_flags_eq_str(a, e, T_CHECK_STOP)

#define	T_quiet_eq_str(a, e) T_flags_eq_str(a, e, T_CHECK_QUIET)

#define	T_step_eq_str(s, a, e) T_flags_eq_str(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_str(s, a, e) T_flags_eq_str(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_str(a, e) T_flags_ne_str(a, e, 0)

#define	T_assert_ne_str(a, e) T_flags_ne_str(a, e, T_CHECK_STOP)

#define	T_quiet_ne_str(a, e) T_flags_ne_str(a, e, T_CHECK_QUIET)

#define	T_step_ne_str(s, a, e) T_flags_ne_str(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_str(s, a, e) T_flags_ne_str(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_nstr(a, e, n) T_flags_eq_nstr(a, e, n, 0)

#define	T_assert_eq_nstr(a, e, n) T_flags_eq_nstr(a, e, n, T_CHECK_STOP)

#define	T_quiet_eq_nstr(a, e, n) T_flags_eq_nstr(a, e, n, T_CHECK_QUIET)

#define	T_step_eq_nstr(s, a, e, n) T_flags_eq_nstr(a, e, n, T_CHECK_STEP(s))

#define	T_step_assert_eq_nstr(s, a, e, n) T_flags_eq_nstr(a, e, n, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_nstr(a, e, n) T_flags_ne_nstr(a, e, n, 0)

#define	T_assert_ne_nstr(a, e, n) T_flags_ne_nstr(a, e, n, T_CHECK_STOP)

#define	T_quiet_ne_nstr(a, e, n) T_flags_ne_nstr(a, e, n, T_CHECK_QUIET)

#define	T_step_ne_nstr(s, a, e, n) T_flags_ne_nstr(a, e, n, T_CHECK_STEP(s))

#define	T_step_assert_ne_nstr(s, a, e, n) T_flags_ne_nstr(a, e, n, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_char(a, e) T_flags_eq_char(a, e, 0)

#define	T_assert_eq_char(a, e) T_flags_eq_char(a, e, T_CHECK_STOP)

#define	T_quiet_eq_char(a, e) T_flags_eq_char(a, e, T_CHECK_QUIET)

#define	T_step_eq_char(s, a, e) T_flags_eq_char(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_char(s, a, e) T_flags_eq_char(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_char(a, e) T_flags_ne_char(a, e, 0)

#define	T_assert_ne_char(a, e) T_flags_ne_char(a, e, T_CHECK_STOP)

#define	T_quiet_ne_char(a, e) T_flags_ne_char(a, e, T_CHECK_QUIET)

#define	T_step_ne_char(s, a, e) T_flags_ne_char(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_char(s, a, e) T_flags_ne_char(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_schar(a, e) T_flags_eq_int(a, e, 0)

#define	T_assert_eq_schar(a, e) T_flags_eq_int(a, e, T_CHECK_STOP)

#define	T_quiet_eq_schar(a, e) T_flags_eq_int(a, e, T_CHECK_QUIET)

#define	T_step_eq_schar(s, a, e) T_flags_eq_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_schar(s, a, e) T_flags_eq_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_schar(a, e) T_flags_ne_int(a, e, 0)

#define	T_assert_ne_schar(a, e) T_flags_ne_int(a, e, T_CHECK_STOP)

#define	T_quiet_ne_schar(a, e) T_flags_ne_int(a, e, T_CHECK_QUIET)

#define	T_step_ne_schar(s, a, e) T_flags_ne_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_schar(s, a, e) T_flags_ne_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_schar(a, e) T_flags_ge_int(a, e, 0)

#define	T_assert_ge_schar(a, e) T_flags_ge_int(a, e, T_CHECK_STOP)

#define	T_quiet_ge_schar(a, e) T_flags_ge_int(a, e, T_CHECK_QUIET)

#define	T_step_ge_schar(s, a, e) T_flags_ge_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_schar(s, a, e) T_flags_ge_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_schar(a, e) T_flags_gt_int(a, e, 0)

#define	T_assert_gt_schar(a, e) T_flags_gt_int(a, e, T_CHECK_STOP)

#define	T_quiet_gt_schar(a, e) T_flags_gt_int(a, e, T_CHECK_QUIET)

#define	T_step_gt_schar(s, a, e) T_flags_gt_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_schar(s, a, e) T_flags_gt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_schar(a, e) T_flags_le_int(a, e, 0)

#define	T_assert_le_schar(a, e) T_flags_le_int(a, e, T_CHECK_STOP)

#define	T_quiet_le_schar(a, e) T_flags_le_int(a, e, T_CHECK_QUIET)

#define	T_step_le_schar(s, a, e) T_flags_le_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_schar(s, a, e) T_flags_le_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_schar(a, e) T_flags_lt_int(a, e, 0)

#define	T_assert_lt_schar(a, e) T_flags_lt_int(a, e, T_CHECK_STOP)

#define	T_quiet_lt_schar(a, e) T_flags_lt_int(a, e, T_CHECK_QUIET)

#define	T_step_lt_schar(s, a, e) T_flags_lt_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_schar(s, a, e) T_flags_lt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_uchar(a, e) T_flags_eq_uint(a, e, 0)

#define	T_assert_eq_uchar(a, e) T_flags_eq_uint(a, e, T_CHECK_STOP)

#define	T_quiet_eq_uchar(a, e) T_flags_eq_uint(a, e, T_CHECK_QUIET)

#define	T_step_eq_uchar(s, a, e) T_flags_eq_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_uchar(s, a, e) T_flags_eq_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_uchar(a, e) T_flags_ne_uint(a, e, 0)

#define	T_assert_ne_uchar(a, e) T_flags_ne_uint(a, e, T_CHECK_STOP)

#define	T_quiet_ne_uchar(a, e) T_flags_ne_uint(a, e, T_CHECK_QUIET)

#define	T_step_ne_uchar(s, a, e) T_flags_ne_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_uchar(s, a, e) T_flags_ne_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_uchar(a, e) T_flags_ge_uint(a, e, 0)

#define	T_assert_ge_uchar(a, e) T_flags_ge_uint(a, e, T_CHECK_STOP)

#define	T_quiet_ge_uchar(a, e) T_flags_ge_uint(a, e, T_CHECK_QUIET)

#define	T_step_ge_uchar(s, a, e) T_flags_ge_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_uchar(s, a, e) T_flags_ge_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_uchar(a, e) T_flags_gt_uint(a, e, 0)

#define	T_assert_gt_uchar(a, e) T_flags_gt_uint(a, e, T_CHECK_STOP)

#define	T_quiet_gt_uchar(a, e) T_flags_gt_uint(a, e, T_CHECK_QUIET)

#define	T_step_gt_uchar(s, a, e) T_flags_gt_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_uchar(s, a, e) T_flags_gt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_uchar(a, e) T_flags_le_uint(a, e, 0)

#define	T_assert_le_uchar(a, e) T_flags_le_uint(a, e, T_CHECK_STOP)

#define	T_quiet_le_uchar(a, e) T_flags_le_uint(a, e, T_CHECK_QUIET)

#define	T_step_le_uchar(s, a, e) T_flags_le_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_uchar(s, a, e) T_flags_le_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_uchar(a, e) T_flags_lt_uint(a, e, 0)

#define	T_assert_lt_uchar(a, e) T_flags_lt_uint(a, e, T_CHECK_STOP)

#define	T_quiet_lt_uchar(a, e) T_flags_lt_uint(a, e, T_CHECK_QUIET)

#define	T_step_lt_uchar(s, a, e) T_flags_lt_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_uchar(s, a, e) T_flags_lt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_short(a, e) T_flags_eq_int(a, e, 0)

#define	T_assert_eq_short(a, e) T_flags_eq_int(a, e, T_CHECK_STOP)

#define	T_quiet_eq_short(a, e) T_flags_eq_int(a, e, T_CHECK_QUIET)

#define	T_step_eq_short(s, a, e) T_flags_eq_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_short(s, a, e) T_flags_eq_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_short(a, e) T_flags_ne_int(a, e, 0)

#define	T_assert_ne_short(a, e) T_flags_ne_int(a, e, T_CHECK_STOP)

#define	T_quiet_ne_short(a, e) T_flags_ne_int(a, e, T_CHECK_QUIET)

#define	T_step_ne_short(s, a, e) T_flags_ne_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_short(s, a, e) T_flags_ne_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_short(a, e) T_flags_ge_int(a, e, 0)

#define	T_assert_ge_short(a, e) T_flags_ge_int(a, e, T_CHECK_STOP)

#define	T_quiet_ge_short(a, e) T_flags_ge_int(a, e, T_CHECK_QUIET)

#define	T_step_ge_short(s, a, e) T_flags_ge_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_short(s, a, e) T_flags_ge_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_short(a, e) T_flags_gt_int(a, e, 0)

#define	T_assert_gt_short(a, e) T_flags_gt_int(a, e, T_CHECK_STOP)

#define	T_quiet_gt_short(a, e) T_flags_gt_int(a, e, T_CHECK_QUIET)

#define	T_step_gt_short(s, a, e) T_flags_gt_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_short(s, a, e) T_flags_gt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_short(a, e) T_flags_le_int(a, e, 0)

#define	T_assert_le_short(a, e) T_flags_le_int(a, e, T_CHECK_STOP)

#define	T_quiet_le_short(a, e) T_flags_le_int(a, e, T_CHECK_QUIET)

#define	T_step_le_short(s, a, e) T_flags_le_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_short(s, a, e) T_flags_le_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_short(a, e) T_flags_lt_int(a, e, 0)

#define	T_assert_lt_short(a, e) T_flags_lt_int(a, e, T_CHECK_STOP)

#define	T_quiet_lt_short(a, e) T_flags_lt_int(a, e, T_CHECK_QUIET)

#define	T_step_lt_short(s, a, e) T_flags_lt_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_short(s, a, e) T_flags_lt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_ushort(a, e) T_flags_eq_uint(a, e, 0)

#define	T_assert_eq_ushort(a, e) T_flags_eq_uint(a, e, T_CHECK_STOP)

#define	T_quiet_eq_ushort(a, e) T_flags_eq_uint(a, e, T_CHECK_QUIET)

#define	T_step_eq_ushort(s, a, e) T_flags_eq_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_ushort(s, a, e) T_flags_eq_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_ushort(a, e) T_flags_ne_uint(a, e, 0)

#define	T_assert_ne_ushort(a, e) T_flags_ne_uint(a, e, T_CHECK_STOP)

#define	T_quiet_ne_ushort(a, e) T_flags_ne_uint(a, e, T_CHECK_QUIET)

#define	T_step_ne_ushort(s, a, e) T_flags_ne_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_ushort(s, a, e) T_flags_ne_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_ushort(a, e) T_flags_ge_uint(a, e, 0)

#define	T_assert_ge_ushort(a, e) T_flags_ge_uint(a, e, T_CHECK_STOP)

#define	T_quiet_ge_ushort(a, e) T_flags_ge_uint(a, e, T_CHECK_QUIET)

#define	T_step_ge_ushort(s, a, e) T_flags_ge_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_ushort(s, a, e) T_flags_ge_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_ushort(a, e) T_flags_gt_uint(a, e, 0)

#define	T_assert_gt_ushort(a, e) T_flags_gt_uint(a, e, T_CHECK_STOP)

#define	T_quiet_gt_ushort(a, e) T_flags_gt_uint(a, e, T_CHECK_QUIET)

#define	T_step_gt_ushort(s, a, e) T_flags_gt_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_ushort(s, a, e) T_flags_gt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_ushort(a, e) T_flags_le_uint(a, e, 0)

#define	T_assert_le_ushort(a, e) T_flags_le_uint(a, e, T_CHECK_STOP)

#define	T_quiet_le_ushort(a, e) T_flags_le_uint(a, e, T_CHECK_QUIET)

#define	T_step_le_ushort(s, a, e) T_flags_le_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_ushort(s, a, e) T_flags_le_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_ushort(a, e) T_flags_lt_uint(a, e, 0)

#define	T_assert_lt_ushort(a, e) T_flags_lt_uint(a, e, T_CHECK_STOP)

#define	T_quiet_lt_ushort(a, e) T_flags_lt_uint(a, e, T_CHECK_QUIET)

#define	T_step_lt_ushort(s, a, e) T_flags_lt_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_ushort(s, a, e) T_flags_lt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_int(a, e) T_flags_eq_int(a, e, 0)

#define	T_assert_eq_int(a, e) T_flags_eq_int(a, e, T_CHECK_STOP)

#define	T_quiet_eq_int(a, e) T_flags_eq_int(a, e, T_CHECK_QUIET)

#define	T_step_eq_int(s, a, e) T_flags_eq_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_int(s, a, e) T_flags_eq_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_int(a, e) T_flags_ne_int(a, e, 0)

#define	T_assert_ne_int(a, e) T_flags_ne_int(a, e, T_CHECK_STOP)

#define	T_quiet_ne_int(a, e) T_flags_ne_int(a, e, T_CHECK_QUIET)

#define	T_step_ne_int(s, a, e) T_flags_ne_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_int(s, a, e) T_flags_ne_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_int(a, e) T_flags_ge_int(a, e, 0)

#define	T_assert_ge_int(a, e) T_flags_ge_int(a, e, T_CHECK_STOP)

#define	T_quiet_ge_int(a, e) T_flags_ge_int(a, e, T_CHECK_QUIET)

#define	T_step_ge_int(s, a, e) T_flags_ge_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_int(s, a, e) T_flags_ge_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_int(a, e) T_flags_gt_int(a, e, 0)

#define	T_assert_gt_int(a, e) T_flags_gt_int(a, e, T_CHECK_STOP)

#define	T_quiet_gt_int(a, e) T_flags_gt_int(a, e, T_CHECK_QUIET)

#define	T_step_gt_int(s, a, e) T_flags_gt_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_int(s, a, e) T_flags_gt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_int(a, e) T_flags_le_int(a, e, 0)

#define	T_assert_le_int(a, e) T_flags_le_int(a, e, T_CHECK_STOP)

#define	T_quiet_le_int(a, e) T_flags_le_int(a, e, T_CHECK_QUIET)

#define	T_step_le_int(s, a, e) T_flags_le_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_int(s, a, e) T_flags_le_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_int(a, e) T_flags_lt_int(a, e, 0)

#define	T_assert_lt_int(a, e) T_flags_lt_int(a, e, T_CHECK_STOP)

#define	T_quiet_lt_int(a, e) T_flags_lt_int(a, e, T_CHECK_QUIET)

#define	T_step_lt_int(s, a, e) T_flags_lt_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_int(s, a, e) T_flags_lt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_uint(a, e) T_flags_eq_uint(a, e, 0)

#define	T_assert_eq_uint(a, e) T_flags_eq_uint(a, e, T_CHECK_STOP)

#define	T_quiet_eq_uint(a, e) T_flags_eq_uint(a, e, T_CHECK_QUIET)

#define	T_step_eq_uint(s, a, e) T_flags_eq_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_uint(s, a, e) T_flags_eq_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_uint(a, e) T_flags_ne_uint(a, e, 0)

#define	T_assert_ne_uint(a, e) T_flags_ne_uint(a, e, T_CHECK_STOP)

#define	T_quiet_ne_uint(a, e) T_flags_ne_uint(a, e, T_CHECK_QUIET)

#define	T_step_ne_uint(s, a, e) T_flags_ne_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_uint(s, a, e) T_flags_ne_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_uint(a, e) T_flags_ge_uint(a, e, 0)

#define	T_assert_ge_uint(a, e) T_flags_ge_uint(a, e, T_CHECK_STOP)

#define	T_quiet_ge_uint(a, e) T_flags_ge_uint(a, e, T_CHECK_QUIET)

#define	T_step_ge_uint(s, a, e) T_flags_ge_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_uint(s, a, e) T_flags_ge_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_uint(a, e) T_flags_gt_uint(a, e, 0)

#define	T_assert_gt_uint(a, e) T_flags_gt_uint(a, e, T_CHECK_STOP)

#define	T_quiet_gt_uint(a, e) T_flags_gt_uint(a, e, T_CHECK_QUIET)

#define	T_step_gt_uint(s, a, e) T_flags_gt_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_uint(s, a, e) T_flags_gt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_uint(a, e) T_flags_le_uint(a, e, 0)

#define	T_assert_le_uint(a, e) T_flags_le_uint(a, e, T_CHECK_STOP)

#define	T_quiet_le_uint(a, e) T_flags_le_uint(a, e, T_CHECK_QUIET)

#define	T_step_le_uint(s, a, e) T_flags_le_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_uint(s, a, e) T_flags_le_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_uint(a, e) T_flags_lt_uint(a, e, 0)

#define	T_assert_lt_uint(a, e) T_flags_lt_uint(a, e, T_CHECK_STOP)

#define	T_quiet_lt_uint(a, e) T_flags_lt_uint(a, e, T_CHECK_QUIET)

#define	T_step_lt_uint(s, a, e) T_flags_lt_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_uint(s, a, e) T_flags_lt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_long(a, e) T_flags_eq_long(a, e, 0)

#define	T_assert_eq_long(a, e) T_flags_eq_long(a, e, T_CHECK_STOP)

#define	T_quiet_eq_long(a, e) T_flags_eq_long(a, e, T_CHECK_QUIET)

#define	T_step_eq_long(s, a, e) T_flags_eq_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_long(s, a, e) T_flags_eq_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_long(a, e) T_flags_ne_long(a, e, 0)

#define	T_assert_ne_long(a, e) T_flags_ne_long(a, e, T_CHECK_STOP)

#define	T_quiet_ne_long(a, e) T_flags_ne_long(a, e, T_CHECK_QUIET)

#define	T_step_ne_long(s, a, e) T_flags_ne_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_long(s, a, e) T_flags_ne_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_long(a, e) T_flags_ge_long(a, e, 0)

#define	T_assert_ge_long(a, e) T_flags_ge_long(a, e, T_CHECK_STOP)

#define	T_quiet_ge_long(a, e) T_flags_ge_long(a, e, T_CHECK_QUIET)

#define	T_step_ge_long(s, a, e) T_flags_ge_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_long(s, a, e) T_flags_ge_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_long(a, e) T_flags_gt_long(a, e, 0)

#define	T_assert_gt_long(a, e) T_flags_gt_long(a, e, T_CHECK_STOP)

#define	T_quiet_gt_long(a, e) T_flags_gt_long(a, e, T_CHECK_QUIET)

#define	T_step_gt_long(s, a, e) T_flags_gt_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_long(s, a, e) T_flags_gt_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_long(a, e) T_flags_le_long(a, e, 0)

#define	T_assert_le_long(a, e) T_flags_le_long(a, e, T_CHECK_STOP)

#define	T_quiet_le_long(a, e) T_flags_le_long(a, e, T_CHECK_QUIET)

#define	T_step_le_long(s, a, e) T_flags_le_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_long(s, a, e) T_flags_le_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_long(a, e) T_flags_lt_long(a, e, 0)

#define	T_assert_lt_long(a, e) T_flags_lt_long(a, e, T_CHECK_STOP)

#define	T_quiet_lt_long(a, e) T_flags_lt_long(a, e, T_CHECK_QUIET)

#define	T_step_lt_long(s, a, e) T_flags_lt_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_long(s, a, e) T_flags_lt_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_ulong(a, e) T_flags_eq_ulong(a, e, 0)

#define	T_assert_eq_ulong(a, e) T_flags_eq_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_eq_ulong(a, e) T_flags_eq_ulong(a, e, T_CHECK_QUIET)

#define	T_step_eq_ulong(s, a, e) T_flags_eq_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_ulong(s, a, e) T_flags_eq_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_ulong(a, e) T_flags_ne_ulong(a, e, 0)

#define	T_assert_ne_ulong(a, e) T_flags_ne_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_ne_ulong(a, e) T_flags_ne_ulong(a, e, T_CHECK_QUIET)

#define	T_step_ne_ulong(s, a, e) T_flags_ne_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_ulong(s, a, e) T_flags_ne_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_ulong(a, e) T_flags_ge_ulong(a, e, 0)

#define	T_assert_ge_ulong(a, e) T_flags_ge_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_ge_ulong(a, e) T_flags_ge_ulong(a, e, T_CHECK_QUIET)

#define	T_step_ge_ulong(s, a, e) T_flags_ge_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_ulong(s, a, e) T_flags_ge_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_ulong(a, e) T_flags_gt_ulong(a, e, 0)

#define	T_assert_gt_ulong(a, e) T_flags_gt_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_gt_ulong(a, e) T_flags_gt_ulong(a, e, T_CHECK_QUIET)

#define	T_step_gt_ulong(s, a, e) T_flags_gt_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_ulong(s, a, e) T_flags_gt_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_ulong(a, e) T_flags_le_ulong(a, e, 0)

#define	T_assert_le_ulong(a, e) T_flags_le_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_le_ulong(a, e) T_flags_le_ulong(a, e, T_CHECK_QUIET)

#define	T_step_le_ulong(s, a, e) T_flags_le_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_ulong(s, a, e) T_flags_le_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_ulong(a, e) T_flags_lt_ulong(a, e, 0)

#define	T_assert_lt_ulong(a, e) T_flags_lt_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_lt_ulong(a, e) T_flags_lt_ulong(a, e, T_CHECK_QUIET)

#define	T_step_lt_ulong(s, a, e) T_flags_lt_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_ulong(s, a, e) T_flags_lt_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_ll(a, e) T_flags_eq_ll(a, e, 0)

#define	T_assert_eq_ll(a, e) T_flags_eq_ll(a, e, T_CHECK_STOP)

#define	T_quiet_eq_ll(a, e) T_flags_eq_ll(a, e, T_CHECK_QUIET)

#define	T_step_eq_ll(s, a, e) T_flags_eq_ll(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_ll(s, a, e) T_flags_eq_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_ll(a, e) T_flags_ne_ll(a, e, 0)

#define	T_assert_ne_ll(a, e) T_flags_ne_ll(a, e, T_CHECK_STOP)

#define	T_quiet_ne_ll(a, e) T_flags_ne_ll(a, e, T_CHECK_QUIET)

#define	T_step_ne_ll(s, a, e) T_flags_ne_ll(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_ll(s, a, e) T_flags_ne_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_ll(a, e) T_flags_ge_ll(a, e, 0)

#define	T_assert_ge_ll(a, e) T_flags_ge_ll(a, e, T_CHECK_STOP)

#define	T_quiet_ge_ll(a, e) T_flags_ge_ll(a, e, T_CHECK_QUIET)

#define	T_step_ge_ll(s, a, e) T_flags_ge_ll(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_ll(s, a, e) T_flags_ge_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_ll(a, e) T_flags_gt_ll(a, e, 0)

#define	T_assert_gt_ll(a, e) T_flags_gt_ll(a, e, T_CHECK_STOP)

#define	T_quiet_gt_ll(a, e) T_flags_gt_ll(a, e, T_CHECK_QUIET)

#define	T_step_gt_ll(s, a, e) T_flags_gt_ll(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_ll(s, a, e) T_flags_gt_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_ll(a, e) T_flags_le_ll(a, e, 0)

#define	T_assert_le_ll(a, e) T_flags_le_ll(a, e, T_CHECK_STOP)

#define	T_quiet_le_ll(a, e) T_flags_le_ll(a, e, T_CHECK_QUIET)

#define	T_step_le_ll(s, a, e) T_flags_le_ll(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_ll(s, a, e) T_flags_le_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_ll(a, e) T_flags_lt_ll(a, e, 0)

#define	T_assert_lt_ll(a, e) T_flags_lt_ll(a, e, T_CHECK_STOP)

#define	T_quiet_lt_ll(a, e) T_flags_lt_ll(a, e, T_CHECK_QUIET)

#define	T_step_lt_ll(s, a, e) T_flags_lt_ll(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_ll(s, a, e) T_flags_lt_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_ull(a, e) T_flags_eq_ull(a, e, 0)

#define	T_assert_eq_ull(a, e) T_flags_eq_ull(a, e, T_CHECK_STOP)

#define	T_quiet_eq_ull(a, e) T_flags_eq_ull(a, e, T_CHECK_QUIET)

#define	T_step_eq_ull(s, a, e) T_flags_eq_ull(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_ull(s, a, e) T_flags_eq_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_ull(a, e) T_flags_ne_ull(a, e, 0)

#define	T_assert_ne_ull(a, e) T_flags_ne_ull(a, e, T_CHECK_STOP)

#define	T_quiet_ne_ull(a, e) T_flags_ne_ull(a, e, T_CHECK_QUIET)

#define	T_step_ne_ull(s, a, e) T_flags_ne_ull(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_ull(s, a, e) T_flags_ne_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_ull(a, e) T_flags_ge_ull(a, e, 0)

#define	T_assert_ge_ull(a, e) T_flags_ge_ull(a, e, T_CHECK_STOP)

#define	T_quiet_ge_ull(a, e) T_flags_ge_ull(a, e, T_CHECK_QUIET)

#define	T_step_ge_ull(s, a, e) T_flags_ge_ull(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_ull(s, a, e) T_flags_ge_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_ull(a, e) T_flags_gt_ull(a, e, 0)

#define	T_assert_gt_ull(a, e) T_flags_gt_ull(a, e, T_CHECK_STOP)

#define	T_quiet_gt_ull(a, e) T_flags_gt_ull(a, e, T_CHECK_QUIET)

#define	T_step_gt_ull(s, a, e) T_flags_gt_ull(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_ull(s, a, e) T_flags_gt_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_ull(a, e) T_flags_le_ull(a, e, 0)

#define	T_assert_le_ull(a, e) T_flags_le_ull(a, e, T_CHECK_STOP)

#define	T_quiet_le_ull(a, e) T_flags_le_ull(a, e, T_CHECK_QUIET)

#define	T_step_le_ull(s, a, e) T_flags_le_ull(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_ull(s, a, e) T_flags_le_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_ull(a, e) T_flags_lt_ull(a, e, 0)

#define	T_assert_lt_ull(a, e) T_flags_lt_ull(a, e, T_CHECK_STOP)

#define	T_quiet_lt_ull(a, e) T_flags_lt_ull(a, e, T_CHECK_QUIET)

#define	T_step_lt_ull(s, a, e) T_flags_lt_ull(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_ull(s, a, e) T_flags_lt_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_i8(a, e) T_flags_eq_int(a, e, 0)

#define	T_assert_eq_i8(a, e) T_flags_eq_int(a, e, T_CHECK_STOP)

#define	T_quiet_eq_i8(a, e) T_flags_eq_int(a, e, T_CHECK_QUIET)

#define	T_step_eq_i8(s, a, e) T_flags_eq_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_i8(s, a, e) T_flags_eq_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_i8(a, e) T_flags_ne_int(a, e, 0)

#define	T_assert_ne_i8(a, e) T_flags_ne_int(a, e, T_CHECK_STOP)

#define	T_quiet_ne_i8(a, e) T_flags_ne_int(a, e, T_CHECK_QUIET)

#define	T_step_ne_i8(s, a, e) T_flags_ne_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_i8(s, a, e) T_flags_ne_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_i8(a, e) T_flags_ge_int(a, e, 0)

#define	T_assert_ge_i8(a, e) T_flags_ge_int(a, e, T_CHECK_STOP)

#define	T_quiet_ge_i8(a, e) T_flags_ge_int(a, e, T_CHECK_QUIET)

#define	T_step_ge_i8(s, a, e) T_flags_ge_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_i8(s, a, e) T_flags_ge_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_i8(a, e) T_flags_gt_int(a, e, 0)

#define	T_assert_gt_i8(a, e) T_flags_gt_int(a, e, T_CHECK_STOP)

#define	T_quiet_gt_i8(a, e) T_flags_gt_int(a, e, T_CHECK_QUIET)

#define	T_step_gt_i8(s, a, e) T_flags_gt_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_i8(s, a, e) T_flags_gt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_i8(a, e) T_flags_le_int(a, e, 0)

#define	T_assert_le_i8(a, e) T_flags_le_int(a, e, T_CHECK_STOP)

#define	T_quiet_le_i8(a, e) T_flags_le_int(a, e, T_CHECK_QUIET)

#define	T_step_le_i8(s, a, e) T_flags_le_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_i8(s, a, e) T_flags_le_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_i8(a, e) T_flags_lt_int(a, e, 0)

#define	T_assert_lt_i8(a, e) T_flags_lt_int(a, e, T_CHECK_STOP)

#define	T_quiet_lt_i8(a, e) T_flags_lt_int(a, e, T_CHECK_QUIET)

#define	T_step_lt_i8(s, a, e) T_flags_lt_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_i8(s, a, e) T_flags_lt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_u8(a, e) T_flags_eq_uint(a, e, 0)

#define	T_assert_eq_u8(a, e) T_flags_eq_uint(a, e, T_CHECK_STOP)

#define	T_quiet_eq_u8(a, e) T_flags_eq_uint(a, e, T_CHECK_QUIET)

#define	T_step_eq_u8(s, a, e) T_flags_eq_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_u8(s, a, e) T_flags_eq_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_u8(a, e) T_flags_ne_uint(a, e, 0)

#define	T_assert_ne_u8(a, e) T_flags_ne_uint(a, e, T_CHECK_STOP)

#define	T_quiet_ne_u8(a, e) T_flags_ne_uint(a, e, T_CHECK_QUIET)

#define	T_step_ne_u8(s, a, e) T_flags_ne_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_u8(s, a, e) T_flags_ne_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_u8(a, e) T_flags_ge_uint(a, e, 0)

#define	T_assert_ge_u8(a, e) T_flags_ge_uint(a, e, T_CHECK_STOP)

#define	T_quiet_ge_u8(a, e) T_flags_ge_uint(a, e, T_CHECK_QUIET)

#define	T_step_ge_u8(s, a, e) T_flags_ge_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_u8(s, a, e) T_flags_ge_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_u8(a, e) T_flags_gt_uint(a, e, 0)

#define	T_assert_gt_u8(a, e) T_flags_gt_uint(a, e, T_CHECK_STOP)

#define	T_quiet_gt_u8(a, e) T_flags_gt_uint(a, e, T_CHECK_QUIET)

#define	T_step_gt_u8(s, a, e) T_flags_gt_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_u8(s, a, e) T_flags_gt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_u8(a, e) T_flags_le_uint(a, e, 0)

#define	T_assert_le_u8(a, e) T_flags_le_uint(a, e, T_CHECK_STOP)

#define	T_quiet_le_u8(a, e) T_flags_le_uint(a, e, T_CHECK_QUIET)

#define	T_step_le_u8(s, a, e) T_flags_le_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_u8(s, a, e) T_flags_le_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_u8(a, e) T_flags_lt_uint(a, e, 0)

#define	T_assert_lt_u8(a, e) T_flags_lt_uint(a, e, T_CHECK_STOP)

#define	T_quiet_lt_u8(a, e) T_flags_lt_uint(a, e, T_CHECK_QUIET)

#define	T_step_lt_u8(s, a, e) T_flags_lt_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_u8(s, a, e) T_flags_lt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_i16(a, e) T_flags_eq_int(a, e, 0)

#define	T_assert_eq_i16(a, e) T_flags_eq_int(a, e, T_CHECK_STOP)

#define	T_quiet_eq_i16(a, e) T_flags_eq_int(a, e, T_CHECK_QUIET)

#define	T_step_eq_i16(s, a, e) T_flags_eq_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_i16(s, a, e) T_flags_eq_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_i16(a, e) T_flags_ne_int(a, e, 0)

#define	T_assert_ne_i16(a, e) T_flags_ne_int(a, e, T_CHECK_STOP)

#define	T_quiet_ne_i16(a, e) T_flags_ne_int(a, e, T_CHECK_QUIET)

#define	T_step_ne_i16(s, a, e) T_flags_ne_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_i16(s, a, e) T_flags_ne_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_i16(a, e) T_flags_ge_int(a, e, 0)

#define	T_assert_ge_i16(a, e) T_flags_ge_int(a, e, T_CHECK_STOP)

#define	T_quiet_ge_i16(a, e) T_flags_ge_int(a, e, T_CHECK_QUIET)

#define	T_step_ge_i16(s, a, e) T_flags_ge_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_i16(s, a, e) T_flags_ge_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_i16(a, e) T_flags_gt_int(a, e, 0)

#define	T_assert_gt_i16(a, e) T_flags_gt_int(a, e, T_CHECK_STOP)

#define	T_quiet_gt_i16(a, e) T_flags_gt_int(a, e, T_CHECK_QUIET)

#define	T_step_gt_i16(s, a, e) T_flags_gt_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_i16(s, a, e) T_flags_gt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_i16(a, e) T_flags_le_int(a, e, 0)

#define	T_assert_le_i16(a, e) T_flags_le_int(a, e, T_CHECK_STOP)

#define	T_quiet_le_i16(a, e) T_flags_le_int(a, e, T_CHECK_QUIET)

#define	T_step_le_i16(s, a, e) T_flags_le_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_i16(s, a, e) T_flags_le_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_i16(a, e) T_flags_lt_int(a, e, 0)

#define	T_assert_lt_i16(a, e) T_flags_lt_int(a, e, T_CHECK_STOP)

#define	T_quiet_lt_i16(a, e) T_flags_lt_int(a, e, T_CHECK_QUIET)

#define	T_step_lt_i16(s, a, e) T_flags_lt_int(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_i16(s, a, e) T_flags_lt_int(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_u16(a, e) T_flags_eq_uint(a, e, 0)

#define	T_assert_eq_u16(a, e) T_flags_eq_uint(a, e, T_CHECK_STOP)

#define	T_quiet_eq_u16(a, e) T_flags_eq_uint(a, e, T_CHECK_QUIET)

#define	T_step_eq_u16(s, a, e) T_flags_eq_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_u16(s, a, e) T_flags_eq_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_u16(a, e) T_flags_ne_uint(a, e, 0)

#define	T_assert_ne_u16(a, e) T_flags_ne_uint(a, e, T_CHECK_STOP)

#define	T_quiet_ne_u16(a, e) T_flags_ne_uint(a, e, T_CHECK_QUIET)

#define	T_step_ne_u16(s, a, e) T_flags_ne_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_u16(s, a, e) T_flags_ne_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_u16(a, e) T_flags_ge_uint(a, e, 0)

#define	T_assert_ge_u16(a, e) T_flags_ge_uint(a, e, T_CHECK_STOP)

#define	T_quiet_ge_u16(a, e) T_flags_ge_uint(a, e, T_CHECK_QUIET)

#define	T_step_ge_u16(s, a, e) T_flags_ge_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_u16(s, a, e) T_flags_ge_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_u16(a, e) T_flags_gt_uint(a, e, 0)

#define	T_assert_gt_u16(a, e) T_flags_gt_uint(a, e, T_CHECK_STOP)

#define	T_quiet_gt_u16(a, e) T_flags_gt_uint(a, e, T_CHECK_QUIET)

#define	T_step_gt_u16(s, a, e) T_flags_gt_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_u16(s, a, e) T_flags_gt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_u16(a, e) T_flags_le_uint(a, e, 0)

#define	T_assert_le_u16(a, e) T_flags_le_uint(a, e, T_CHECK_STOP)

#define	T_quiet_le_u16(a, e) T_flags_le_uint(a, e, T_CHECK_QUIET)

#define	T_step_le_u16(s, a, e) T_flags_le_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_u16(s, a, e) T_flags_le_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_u16(a, e) T_flags_lt_uint(a, e, 0)

#define	T_assert_lt_u16(a, e) T_flags_lt_uint(a, e, T_CHECK_STOP)

#define	T_quiet_lt_u16(a, e) T_flags_lt_uint(a, e, T_CHECK_QUIET)

#define	T_step_lt_u16(s, a, e) T_flags_lt_uint(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_u16(s, a, e) T_flags_lt_uint(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_i32(a, e) T_flags_eq_long(a, e, 0)

#define	T_assert_eq_i32(a, e) T_flags_eq_long(a, e, T_CHECK_STOP)

#define	T_quiet_eq_i32(a, e) T_flags_eq_long(a, e, T_CHECK_QUIET)

#define	T_step_eq_i32(s, a, e) T_flags_eq_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_i32(s, a, e) T_flags_eq_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_i32(a, e) T_flags_ne_long(a, e, 0)

#define	T_assert_ne_i32(a, e) T_flags_ne_long(a, e, T_CHECK_STOP)

#define	T_quiet_ne_i32(a, e) T_flags_ne_long(a, e, T_CHECK_QUIET)

#define	T_step_ne_i32(s, a, e) T_flags_ne_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_i32(s, a, e) T_flags_ne_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_i32(a, e) T_flags_ge_long(a, e, 0)

#define	T_assert_ge_i32(a, e) T_flags_ge_long(a, e, T_CHECK_STOP)

#define	T_quiet_ge_i32(a, e) T_flags_ge_long(a, e, T_CHECK_QUIET)

#define	T_step_ge_i32(s, a, e) T_flags_ge_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_i32(s, a, e) T_flags_ge_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_i32(a, e) T_flags_gt_long(a, e, 0)

#define	T_assert_gt_i32(a, e) T_flags_gt_long(a, e, T_CHECK_STOP)

#define	T_quiet_gt_i32(a, e) T_flags_gt_long(a, e, T_CHECK_QUIET)

#define	T_step_gt_i32(s, a, e) T_flags_gt_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_i32(s, a, e) T_flags_gt_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_i32(a, e) T_flags_le_long(a, e, 0)

#define	T_assert_le_i32(a, e) T_flags_le_long(a, e, T_CHECK_STOP)

#define	T_quiet_le_i32(a, e) T_flags_le_long(a, e, T_CHECK_QUIET)

#define	T_step_le_i32(s, a, e) T_flags_le_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_i32(s, a, e) T_flags_le_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_i32(a, e) T_flags_lt_long(a, e, 0)

#define	T_assert_lt_i32(a, e) T_flags_lt_long(a, e, T_CHECK_STOP)

#define	T_quiet_lt_i32(a, e) T_flags_lt_long(a, e, T_CHECK_QUIET)

#define	T_step_lt_i32(s, a, e) T_flags_lt_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_i32(s, a, e) T_flags_lt_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_u32(a, e) T_flags_eq_ulong(a, e, 0)

#define	T_assert_eq_u32(a, e) T_flags_eq_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_eq_u32(a, e) T_flags_eq_ulong(a, e, T_CHECK_QUIET)

#define	T_step_eq_u32(s, a, e) T_flags_eq_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_u32(s, a, e) T_flags_eq_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_u32(a, e) T_flags_ne_ulong(a, e, 0)

#define	T_assert_ne_u32(a, e) T_flags_ne_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_ne_u32(a, e) T_flags_ne_ulong(a, e, T_CHECK_QUIET)

#define	T_step_ne_u32(s, a, e) T_flags_ne_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_u32(s, a, e) T_flags_ne_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_u32(a, e) T_flags_ge_ulong(a, e, 0)

#define	T_assert_ge_u32(a, e) T_flags_ge_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_ge_u32(a, e) T_flags_ge_ulong(a, e, T_CHECK_QUIET)

#define	T_step_ge_u32(s, a, e) T_flags_ge_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_u32(s, a, e) T_flags_ge_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_u32(a, e) T_flags_gt_ulong(a, e, 0)

#define	T_assert_gt_u32(a, e) T_flags_gt_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_gt_u32(a, e) T_flags_gt_ulong(a, e, T_CHECK_QUIET)

#define	T_step_gt_u32(s, a, e) T_flags_gt_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_u32(s, a, e) T_flags_gt_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_u32(a, e) T_flags_le_ulong(a, e, 0)

#define	T_assert_le_u32(a, e) T_flags_le_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_le_u32(a, e) T_flags_le_ulong(a, e, T_CHECK_QUIET)

#define	T_step_le_u32(s, a, e) T_flags_le_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_u32(s, a, e) T_flags_le_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_u32(a, e) T_flags_lt_ulong(a, e, 0)

#define	T_assert_lt_u32(a, e) T_flags_lt_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_lt_u32(a, e) T_flags_lt_ulong(a, e, T_CHECK_QUIET)

#define	T_step_lt_u32(s, a, e) T_flags_lt_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_u32(s, a, e) T_flags_lt_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_i64(a, e) T_flags_eq_ll(a, e, 0)

#define	T_assert_eq_i64(a, e) T_flags_eq_ll(a, e, T_CHECK_STOP)

#define	T_quiet_eq_i64(a, e) T_flags_eq_ll(a, e, T_CHECK_QUIET)

#define	T_step_eq_i64(s, a, e) T_flags_eq_ll(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_i64(s, a, e) T_flags_eq_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_i64(a, e) T_flags_ne_ll(a, e, 0)

#define	T_assert_ne_i64(a, e) T_flags_ne_ll(a, e, T_CHECK_STOP)

#define	T_quiet_ne_i64(a, e) T_flags_ne_ll(a, e, T_CHECK_QUIET)

#define	T_step_ne_i64(s, a, e) T_flags_ne_ll(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_i64(s, a, e) T_flags_ne_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_i64(a, e) T_flags_ge_ll(a, e, 0)

#define	T_assert_ge_i64(a, e) T_flags_ge_ll(a, e, T_CHECK_STOP)

#define	T_quiet_ge_i64(a, e) T_flags_ge_ll(a, e, T_CHECK_QUIET)

#define	T_step_ge_i64(s, a, e) T_flags_ge_ll(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_i64(s, a, e) T_flags_ge_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_i64(a, e) T_flags_gt_ll(a, e, 0)

#define	T_assert_gt_i64(a, e) T_flags_gt_ll(a, e, T_CHECK_STOP)

#define	T_quiet_gt_i64(a, e) T_flags_gt_ll(a, e, T_CHECK_QUIET)

#define	T_step_gt_i64(s, a, e) T_flags_gt_ll(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_i64(s, a, e) T_flags_gt_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_i64(a, e) T_flags_le_ll(a, e, 0)

#define	T_assert_le_i64(a, e) T_flags_le_ll(a, e, T_CHECK_STOP)

#define	T_quiet_le_i64(a, e) T_flags_le_ll(a, e, T_CHECK_QUIET)

#define	T_step_le_i64(s, a, e) T_flags_le_ll(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_i64(s, a, e) T_flags_le_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_i64(a, e) T_flags_lt_ll(a, e, 0)

#define	T_assert_lt_i64(a, e) T_flags_lt_ll(a, e, T_CHECK_STOP)

#define	T_quiet_lt_i64(a, e) T_flags_lt_ll(a, e, T_CHECK_QUIET)

#define	T_step_lt_i64(s, a, e) T_flags_lt_ll(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_i64(s, a, e) T_flags_lt_ll(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_u64(a, e) T_flags_eq_ull(a, e, 0)

#define	T_assert_eq_u64(a, e) T_flags_eq_ull(a, e, T_CHECK_STOP)

#define	T_quiet_eq_u64(a, e) T_flags_eq_ull(a, e, T_CHECK_QUIET)

#define	T_step_eq_u64(s, a, e) T_flags_eq_ull(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_u64(s, a, e) T_flags_eq_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_u64(a, e) T_flags_ne_ull(a, e, 0)

#define	T_assert_ne_u64(a, e) T_flags_ne_ull(a, e, T_CHECK_STOP)

#define	T_quiet_ne_u64(a, e) T_flags_ne_ull(a, e, T_CHECK_QUIET)

#define	T_step_ne_u64(s, a, e) T_flags_ne_ull(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_u64(s, a, e) T_flags_ne_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_u64(a, e) T_flags_ge_ull(a, e, 0)

#define	T_assert_ge_u64(a, e) T_flags_ge_ull(a, e, T_CHECK_STOP)

#define	T_quiet_ge_u64(a, e) T_flags_ge_ull(a, e, T_CHECK_QUIET)

#define	T_step_ge_u64(s, a, e) T_flags_ge_ull(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_u64(s, a, e) T_flags_ge_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_u64(a, e) T_flags_gt_ull(a, e, 0)

#define	T_assert_gt_u64(a, e) T_flags_gt_ull(a, e, T_CHECK_STOP)

#define	T_quiet_gt_u64(a, e) T_flags_gt_ull(a, e, T_CHECK_QUIET)

#define	T_step_gt_u64(s, a, e) T_flags_gt_ull(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_u64(s, a, e) T_flags_gt_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_u64(a, e) T_flags_le_ull(a, e, 0)

#define	T_assert_le_u64(a, e) T_flags_le_ull(a, e, T_CHECK_STOP)

#define	T_quiet_le_u64(a, e) T_flags_le_ull(a, e, T_CHECK_QUIET)

#define	T_step_le_u64(s, a, e) T_flags_le_ull(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_u64(s, a, e) T_flags_le_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_u64(a, e) T_flags_lt_ull(a, e, 0)

#define	T_assert_lt_u64(a, e) T_flags_lt_ull(a, e, T_CHECK_STOP)

#define	T_quiet_lt_u64(a, e) T_flags_lt_ull(a, e, T_CHECK_QUIET)

#define	T_step_lt_u64(s, a, e) T_flags_lt_ull(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_u64(s, a, e) T_flags_lt_ull(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_iptr(a, e) T_flags_eq_long(a, e, 0)

#define	T_assert_eq_iptr(a, e) T_flags_eq_long(a, e, T_CHECK_STOP)

#define	T_quiet_eq_iptr(a, e) T_flags_eq_long(a, e, T_CHECK_QUIET)

#define	T_step_eq_iptr(s, a, e) T_flags_eq_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_iptr(s, a, e) T_flags_eq_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_iptr(a, e) T_flags_ne_long(a, e, 0)

#define	T_assert_ne_iptr(a, e) T_flags_ne_long(a, e, T_CHECK_STOP)

#define	T_quiet_ne_iptr(a, e) T_flags_ne_long(a, e, T_CHECK_QUIET)

#define	T_step_ne_iptr(s, a, e) T_flags_ne_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_iptr(s, a, e) T_flags_ne_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_iptr(a, e) T_flags_ge_long(a, e, 0)

#define	T_assert_ge_iptr(a, e) T_flags_ge_long(a, e, T_CHECK_STOP)

#define	T_quiet_ge_iptr(a, e) T_flags_ge_long(a, e, T_CHECK_QUIET)

#define	T_step_ge_iptr(s, a, e) T_flags_ge_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_iptr(s, a, e) T_flags_ge_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_iptr(a, e) T_flags_gt_long(a, e, 0)

#define	T_assert_gt_iptr(a, e) T_flags_gt_long(a, e, T_CHECK_STOP)

#define	T_quiet_gt_iptr(a, e) T_flags_gt_long(a, e, T_CHECK_QUIET)

#define	T_step_gt_iptr(s, a, e) T_flags_gt_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_iptr(s, a, e) T_flags_gt_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_iptr(a, e) T_flags_le_long(a, e, 0)

#define	T_assert_le_iptr(a, e) T_flags_le_long(a, e, T_CHECK_STOP)

#define	T_quiet_le_iptr(a, e) T_flags_le_long(a, e, T_CHECK_QUIET)

#define	T_step_le_iptr(s, a, e) T_flags_le_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_iptr(s, a, e) T_flags_le_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_iptr(a, e) T_flags_lt_long(a, e, 0)

#define	T_assert_lt_iptr(a, e) T_flags_lt_long(a, e, T_CHECK_STOP)

#define	T_quiet_lt_iptr(a, e) T_flags_lt_long(a, e, T_CHECK_QUIET)

#define	T_step_lt_iptr(s, a, e) T_flags_lt_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_iptr(s, a, e) T_flags_lt_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_uptr(a, e) T_flags_eq_ulong(a, e, 0)

#define	T_assert_eq_uptr(a, e) T_flags_eq_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_eq_uptr(a, e) T_flags_eq_ulong(a, e, T_CHECK_QUIET)

#define	T_step_eq_uptr(s, a, e) T_flags_eq_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_uptr(s, a, e) T_flags_eq_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_uptr(a, e) T_flags_ne_ulong(a, e, 0)

#define	T_assert_ne_uptr(a, e) T_flags_ne_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_ne_uptr(a, e) T_flags_ne_ulong(a, e, T_CHECK_QUIET)

#define	T_step_ne_uptr(s, a, e) T_flags_ne_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_uptr(s, a, e) T_flags_ne_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_uptr(a, e) T_flags_ge_ulong(a, e, 0)

#define	T_assert_ge_uptr(a, e) T_flags_ge_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_ge_uptr(a, e) T_flags_ge_ulong(a, e, T_CHECK_QUIET)

#define	T_step_ge_uptr(s, a, e) T_flags_ge_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_uptr(s, a, e) T_flags_ge_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_uptr(a, e) T_flags_gt_ulong(a, e, 0)

#define	T_assert_gt_uptr(a, e) T_flags_gt_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_gt_uptr(a, e) T_flags_gt_ulong(a, e, T_CHECK_QUIET)

#define	T_step_gt_uptr(s, a, e) T_flags_gt_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_uptr(s, a, e) T_flags_gt_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_uptr(a, e) T_flags_le_ulong(a, e, 0)

#define	T_assert_le_uptr(a, e) T_flags_le_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_le_uptr(a, e) T_flags_le_ulong(a, e, T_CHECK_QUIET)

#define	T_step_le_uptr(s, a, e) T_flags_le_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_uptr(s, a, e) T_flags_le_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_uptr(a, e) T_flags_lt_ulong(a, e, 0)

#define	T_assert_lt_uptr(a, e) T_flags_lt_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_lt_uptr(a, e) T_flags_lt_ulong(a, e, T_CHECK_QUIET)

#define	T_step_lt_uptr(s, a, e) T_flags_lt_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_uptr(s, a, e) T_flags_lt_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_ssz(a, e) T_flags_eq_long(a, e, 0)

#define	T_assert_eq_ssz(a, e) T_flags_eq_long(a, e, T_CHECK_STOP)

#define	T_quiet_eq_ssz(a, e) T_flags_eq_long(a, e, T_CHECK_QUIET)

#define	T_step_eq_ssz(s, a, e) T_flags_eq_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_ssz(s, a, e) T_flags_eq_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_ssz(a, e) T_flags_ne_long(a, e, 0)

#define	T_assert_ne_ssz(a, e) T_flags_ne_long(a, e, T_CHECK_STOP)

#define	T_quiet_ne_ssz(a, e) T_flags_ne_long(a, e, T_CHECK_QUIET)

#define	T_step_ne_ssz(s, a, e) T_flags_ne_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_ssz(s, a, e) T_flags_ne_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_ssz(a, e) T_flags_ge_long(a, e, 0)

#define	T_assert_ge_ssz(a, e) T_flags_ge_long(a, e, T_CHECK_STOP)

#define	T_quiet_ge_ssz(a, e) T_flags_ge_long(a, e, T_CHECK_QUIET)

#define	T_step_ge_ssz(s, a, e) T_flags_ge_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_ssz(s, a, e) T_flags_ge_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_ssz(a, e) T_flags_gt_long(a, e, 0)

#define	T_assert_gt_ssz(a, e) T_flags_gt_long(a, e, T_CHECK_STOP)

#define	T_quiet_gt_ssz(a, e) T_flags_gt_long(a, e, T_CHECK_QUIET)

#define	T_step_gt_ssz(s, a, e) T_flags_gt_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_ssz(s, a, e) T_flags_gt_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_ssz(a, e) T_flags_le_long(a, e, 0)

#define	T_assert_le_ssz(a, e) T_flags_le_long(a, e, T_CHECK_STOP)

#define	T_quiet_le_ssz(a, e) T_flags_le_long(a, e, T_CHECK_QUIET)

#define	T_step_le_ssz(s, a, e) T_flags_le_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_ssz(s, a, e) T_flags_le_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_ssz(a, e) T_flags_lt_long(a, e, 0)

#define	T_assert_lt_ssz(a, e) T_flags_lt_long(a, e, T_CHECK_STOP)

#define	T_quiet_lt_ssz(a, e) T_flags_lt_long(a, e, T_CHECK_QUIET)

#define	T_step_lt_ssz(s, a, e) T_flags_lt_long(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_ssz(s, a, e) T_flags_lt_long(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eq_sz(a, e) T_flags_eq_ulong(a, e, 0)

#define	T_assert_eq_sz(a, e) T_flags_eq_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_eq_sz(a, e) T_flags_eq_ulong(a, e, T_CHECK_QUIET)

#define	T_step_eq_sz(s, a, e) T_flags_eq_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eq_sz(s, a, e) T_flags_eq_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ne_sz(a, e) T_flags_ne_ulong(a, e, 0)

#define	T_assert_ne_sz(a, e) T_flags_ne_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_ne_sz(a, e) T_flags_ne_ulong(a, e, T_CHECK_QUIET)

#define	T_step_ne_sz(s, a, e) T_flags_ne_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ne_sz(s, a, e) T_flags_ne_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_ge_sz(a, e) T_flags_ge_ulong(a, e, 0)

#define	T_assert_ge_sz(a, e) T_flags_ge_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_ge_sz(a, e) T_flags_ge_ulong(a, e, T_CHECK_QUIET)

#define	T_step_ge_sz(s, a, e) T_flags_ge_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_ge_sz(s, a, e) T_flags_ge_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_gt_sz(a, e) T_flags_gt_ulong(a, e, 0)

#define	T_assert_gt_sz(a, e) T_flags_gt_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_gt_sz(a, e) T_flags_gt_ulong(a, e, T_CHECK_QUIET)

#define	T_step_gt_sz(s, a, e) T_flags_gt_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_gt_sz(s, a, e) T_flags_gt_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_le_sz(a, e) T_flags_le_ulong(a, e, 0)

#define	T_assert_le_sz(a, e) T_flags_le_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_le_sz(a, e) T_flags_le_ulong(a, e, T_CHECK_QUIET)

#define	T_step_le_sz(s, a, e) T_flags_le_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_le_sz(s, a, e) T_flags_le_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_lt_sz(a, e) T_flags_lt_ulong(a, e, 0)

#define	T_assert_lt_sz(a, e) T_flags_lt_ulong(a, e, T_CHECK_STOP)

#define	T_quiet_lt_sz(a, e) T_flags_lt_ulong(a, e, T_CHECK_QUIET)

#define	T_step_lt_sz(s, a, e) T_flags_lt_ulong(a, e, T_CHECK_STEP(s))

#define	T_step_assert_lt_sz(s, a, e) T_flags_lt_ulong(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eno(a, e) T_flags_eno(a, e, 0)

#define	T_assert_eno(a, e) T_flags_eno(a, e, T_CHECK_STOP)

#define	T_quiet_eno(a, e) T_flags_eno(a, e, T_CHECK_QUIET)

#define	T_step_eno(s, a, e) T_flags_eno(a, e, T_CHECK_STEP(s))

#define	T_step_assert_eno(s, a, e) T_flags_eno(a, e, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_eno_success(a) T_flags_eno_success(a, 0)

#define	T_assert_eno_success(a) T_flags_eno_success(a, T_CHECK_STOP)

#define	T_quiet_eno_success(a) T_flags_eno_success(a, T_CHECK_QUIET)

#define	T_step_eno_success(s, a) T_flags_eno_success(a, T_CHECK_STEP(s))

#define	T_step_assert_eno_success(s, a) T_flags_eno_success(a, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_psx_error(a, eno) T_flags_psx_error(a, eno, 0)

#define	T_assert_psx_error(a, eno) T_flags_psx_error(a, eno, T_CHECK_STOP)

#define	T_quiet_psx_error(a, eno) T_flags_psx_error(a, eno, T_CHECK_QUIET)

#define	T_step_psx_error(s, a, eno) T_flags_psx_error(a, eno, T_CHECK_STEP(s))

#define	T_step_assert_psx_error(s, a, eno) T_flags_psx_error(a, eno, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_psx_success(a) T_flags_psx_success(a, 0)

#define	T_assert_psx_success(a) T_flags_psx_success(a, T_CHECK_STOP)

#define	T_quiet_psx_success(a) T_flags_psx_success(a, T_CHECK_QUIET)

#define	T_step_psx_success(s, a) T_flags_psx_success(a, T_CHECK_STEP(s))

#define	T_step_assert_psx_success(s, a) T_flags_psx_success(a, T_CHECK_STEP(s) \| T_CHECK_STOP)

#define	T_flags_step(a, flags)

#define	T_step(e) T_flags_step(e, 0)

#define	T_step_assert(e) T_flags_step(e, T_CHECK_STOP)

#define	T_unreachable() do { T_true(false, "Unreachable"); T_stop(); } while (0)

#define	T_TEST_CASE_FIXTURE(name, fixture)

#define	T_TEST_CASE(name) T_TEST_CASE_FIXTURE(name, NULL)

#define	T_MEASURE_RUNTIME_ALLOW_CLOCK_ISR 0x1

#define	T_MEASURE_RUNTIME_REPORT_SAMPLES 0x2

#define	T_MEASURE_RUNTIME_DISABLE_FULL_CACHE 0x10

#define	T_MEASURE_RUNTIME_DISABLE_HOT_CACHE 0x20

#define	T_MEASURE_RUNTIME_DISABLE_DIRTY_CACHE 0x40

#define	T_MEASURE_RUNTIME_DISABLE_MINOR_LOAD 0x80

#define	T_MEASURE_RUNTIME_DISABLE_MAX_LOAD 0x100

Typedefs
typedef struct T_fixture	T_fixture

typedef struct T_fixture_node	T_fixture_node

typedef struct T_remark	T_remark

typedef struct T_case_context	T_case_context

typedef unsigned long	T_ticks

typedef uint64_t	T_time

typedef char	T_time_string[24]

typedef void(*	T_action) (T_event, const char *)

typedef void(*	T_putchar) (int, void *)

typedef struct T_destructor	T_destructor

typedef struct T_measure_runtime_context	T_measure_runtime_context

Enumerations
enum	T_verbosity { T_QUIET , T_NORMAL , T_VERBOSE }

enum	T_event { T_EVENT_RUN_INITIALIZE_EARLY , T_EVENT_RUN_INITIALIZE_LATE , T_EVENT_CASE_EARLY , T_EVENT_CASE_BEGIN , T_EVENT_CASE_END , T_EVENT_CASE_LATE , T_EVENT_CASE_STOP , T_EVENT_RUN_FINALIZE_EARLY , T_EVENT_RUN_FINALIZE_LATE }

enum	T_interrupt_test_state { T_INTERRUPT_TEST_INITIAL , T_INTERRUPT_TEST_ACTION , T_INTERRUPT_TEST_BLOCKED , T_INTERRUPT_TEST_CONTINUE , T_INTERRUPT_TEST_DONE , T_INTERRUPT_TEST_EARLY , T_INTERRUPT_TEST_INTERRUPT , T_INTERRUPT_TEST_LATE , T_INTERRUPT_TEST_TIMEOUT }

Functions
void	T_case_register (T_case_context *)

void	T_check (const T_check_context *, bool,...)

void	T_check_eq_ptr (const T_check_context_msg *, uintptr_t, uintptr_t)

void	T_check_ne_ptr (const T_check_context_msg *, uintptr_t, uintptr_t)

void	T_check_null (const T_check_context_msg *, uintptr_t)

void	T_check_not_null (const T_check_context_msg *, uintptr_t)

void	T_check_eq_mem (const T_check_context_msg , const void , const void *, size_t)

void	T_check_ne_mem (const T_check_context_msg , const void , const void *, size_t)

void	T_check_eq_str (const T_check_context , const char , const char *)

void	T_check_ne_str (const T_check_context , const char , const char *)

void	T_check_eq_nstr (const T_check_context , const char , const char *, size_t)

void	T_check_ne_nstr (const T_check_context , const char , const char *, size_t)

void	T_check_eq_char (const T_check_context *, char, char)

void	T_check_ne_char (const T_check_context *, char, char)

void	T_check_eq_int (const T_check_context *, int, int)

void	T_check_ne_int (const T_check_context *, int, int)

void	T_check_ge_int (const T_check_context *, int, int)

void	T_check_gt_int (const T_check_context *, int, int)

void	T_check_le_int (const T_check_context *, int, int)

void	T_check_lt_int (const T_check_context *, int, int)

void	T_check_eq_uint (const T_check_context *, unsigned int, unsigned int)

void	T_check_ne_uint (const T_check_context *, unsigned int, unsigned int)

void	T_check_ge_uint (const T_check_context *, unsigned int, unsigned int)

void	T_check_gt_uint (const T_check_context *, unsigned int, unsigned int)

void	T_check_le_uint (const T_check_context *, unsigned int, unsigned int)

void	T_check_lt_uint (const T_check_context *, unsigned int, unsigned int)

void	T_check_eq_long (const T_check_context *, long, long)

void	T_check_ne_long (const T_check_context *, long, long)

void	T_check_ge_long (const T_check_context *, long, long)

void	T_check_gt_long (const T_check_context *, long, long)

void	T_check_le_long (const T_check_context *, long, long)

void	T_check_lt_long (const T_check_context *, long, long)

void	T_check_eq_ulong (const T_check_context *, unsigned long, unsigned long)

void	T_check_ne_ulong (const T_check_context *, unsigned long, unsigned long)

void	T_check_ge_ulong (const T_check_context *, unsigned long, unsigned long)

void	T_check_gt_ulong (const T_check_context *, unsigned long, unsigned long)

void	T_check_le_ulong (const T_check_context *, unsigned long, unsigned long)

void	T_check_lt_ulong (const T_check_context *, unsigned long, unsigned long)

void	T_check_eq_ll (const T_check_context *, long long, long long)

void	T_check_ne_ll (const T_check_context *, long long, long long)

void	T_check_ge_ll (const T_check_context *, long long, long long)

void	T_check_gt_ll (const T_check_context *, long long, long long)

void	T_check_le_ll (const T_check_context *, long long, long long)

void	T_check_lt_ll (const T_check_context *, long long, long long)

void	T_check_eq_ull (const T_check_context *, unsigned long long, unsigned long long)

void	T_check_ne_ull (const T_check_context *, unsigned long long, unsigned long long)

void	T_check_ge_ull (const T_check_context *, unsigned long long, unsigned long long)

void	T_check_gt_ull (const T_check_context *, unsigned long long, unsigned long long)

void	T_check_le_ull (const T_check_context *, unsigned long long, unsigned long long)

void	T_check_lt_ull (const T_check_context *, unsigned long long, unsigned long long)

void	T_check_eno (const T_check_context *, int, int)

void	T_check_eno_success (const T_check_context *, int)

void	T_check_psx_error (const T_check_context *, int, int)

void	T_check_psx_success (const T_check_context *, int)

int	T_printf (char const *,...)

int	T_vprintf (char const *, va_list)

int	T_puts (const char *, size_t)

int	T_snprintf (char , size_t, const char ,...)

void	T_log (T_verbosity, char const *,...)

const char *	T_case_name (void)

T_verbosity	T_set_verbosity (T_verbosity)

const char *	T_strerror (int)

void	T_plan (unsigned int)

void	T_push_plan (T_fixture_node *, unsigned int)

void	T_pop_plan (void)

void	T_check_step (const T_check_context *, unsigned int)

const char *	T_time_to_string_ns (T_time, T_time_string)

const char *	T_time_to_string_us (T_time, T_time_string)

const char *	T_time_to_string_ms (T_time, T_time_string)

const char *	T_time_to_string_s (T_time, T_time_string)

const char *	T_ticks_to_string_ns (T_ticks, T_time_string)

const char *	T_ticks_to_string_us (T_ticks, T_time_string)

const char *	T_ticks_to_string_ms (T_ticks, T_time_string)

const char *	T_ticks_to_string_s (T_ticks, T_time_string)

T_time	T_ticks_to_time (T_ticks)

T_ticks	T_time_to_ticks (T_time)

T_time	T_seconds_and_nanoseconds_to_time (uint32_t, uint32_t)

void	T_time_to_seconds_and_nanoseconds (T_time, uint32_t , uint32_t )

T_time	T_now (void)

T_ticks	T_tick (void)

T_time	T_now_clock (void)

T_time	T_now_dummy (void)

T_time	T_now_tick (void)

T_time	T_case_begin_time (void)

void *	T_malloc (size_t)

void *	T_calloc (size_t, size_t)

void *	T_zalloc (size_t, void()(void ))

void	T_free (void *)

void	T_register (void)

void	T_putchar_default (int, void *)

int	T_main (const T_config *)

void	T_make_runner (void)

bool	T_is_runner (void)

void	T_run_initialize (const T_config *)

void	T_run_all (void)

void	T_run_by_name (const char *)

void *	T_case_begin (const char , const T_fixture )

void	T_case_end (void)

bool	T_run_finalize (void)

void	T_set_putchar (T_putchar, void , T_putchar , void **)

void *	T_fixture_context (void)

void	T_set_fixture_context (void *)

void	T_add_remark (T_remark *)

void *	T_push_fixture (T_fixture_node , const T_fixture )

void	T_pop_fixture (void)

T_NO_RETURN void	T_stop (void)

size_t	T_get_scope (const char const const desc, char buf, size_t n, const size_t *second_indices)
	Gets the scope for nested fixtures.

size_t	T_str_copy (char , const char , size_t)

void	T_busy (uint_fast32_t)

uint_fast32_t	T_get_one_clock_tick_busy (void)

T_interrupt_test_state	T_interrupt_test_change_state (T_interrupt_test_state, T_interrupt_test_state)

T_interrupt_test_state	T_interrupt_test_get_state (void)

void	T_interrupt_test_busy_wait_for_interrupt (void)

T_interrupt_test_state	T_interrupt_test (const T_interrupt_test_config config, void arg)

T_thread_switch_log *	T_thread_switch_record (T_thread_switch_log *)

T_thread_switch_log *	T_thread_switch_record_2 (T_thread_switch_log_2 *)

T_thread_switch_log *	T_thread_switch_record_4 (T_thread_switch_log_4 *)

T_thread_switch_log *	T_thread_switch_record_10 (T_thread_switch_log_10 *)

void	T_report_hash_sha256 (T_event, const char *)

void	T_report_hash_sha256_update (char c)

void	T_check_heap (T_event, const char *)

void	T_add_destructor (T_destructor , void()(T_destructor *))

void	T_remove_destructor (T_destructor *)

T_measure_runtime_context *	T_measure_runtime_create (const T_measure_runtime_config *)

void	T_measure_runtime (T_measure_runtime_context , const T_measure_runtime_request )

Variables
const T_check_context	T_special

const T_fixture	T_empty_fixture

Detailed Description

This header file provides interfaces of the RTEMS Test Framework.

Macro Definition Documentation

◆ T_flags_step

#define T_flags_step	(	a,
		flags
	)

Value:

{                                   \
    static const T_check_context T_check_instance = {       \
        T_FILE_NAME, __LINE__, (flags) | T_CHECK_FMT };     \
    T_check_step(&T_check_instance, a);             \
}

◆ T_TEST_CASE_FIXTURE

#define T_TEST_CASE_FIXTURE	(	name,
		fixture
	)

Value:

void T_case_body_##name(void);                  \
T_case_context T_case_instance_##name = {           \
    #name,                          \
    T_case_body_##name,                     \
    fixture,                            \
    NULL                            \
};                              \
__attribute__((__constructor__)) static void            \
T_case_register_##name(void)                    \
{                               \
    T_case_register(&T_case_instance_##name);       \
}                               \
void T_case_body_##name(void)

Function Documentation

◆ T_get_scope()

size_t T_get_scope	(	const char const const *	desc,
		char *	buf,
		size_t	n,
		const size_t *	second_indices
	)

Gets the scope for nested fixtures.

This function should help implementing scope fixture methods. The parameter layout allows efficient code generation for this method.

Parameters

desc	is the description table. It shall be a NULL-terminated array which references arrays of descriptive strings.
buf	is the buffer for the scope string.
n	is the size of the scope buffer in characters.
second_indices	is an array of indices defining which descriptive string is used for each entry in the description table.

Returns: Returns the characters consumed from the buffer for the produced scope.

Data Structures

Macros

Typedefs

Enumerations