Mercurial > libunicode
changeset 18:9b2038be6af4
tests: switch to rexo
author | David Demelier <markand@malikania.fr> |
---|---|
date | Mon, 11 Oct 2021 20:57:47 +0200 |
parents | 6fa530cc1188 |
children | 91879958b74d |
files | Makefile extern/LICENSE.libgreatest.txt extern/LICENSE.librexo.txt extern/VERSION.libgreatest.txt extern/VERSION.librexo.txt extern/libgreatest/greatest.h extern/librexo/rexo.h test/unicode.c unicode.c |
diffstat | 9 files changed, 6833 insertions(+), 1488 deletions(-) [+] |
line wrap: on
line diff
--- a/Makefile Mon Oct 11 20:57:32 2021 +0200 +++ b/Makefile Mon Oct 11 20:57:47 2021 +0200 @@ -21,7 +21,7 @@ CC= cc CFLAGS= -O3 -DNDEBUG -INCS= -Iextern/libgreatest -I. +INCS= -Iextern/librexo -I. .SUFFIXES: .SUFFIXES: .c
--- a/extern/LICENSE.libgreatest.txt Mon Oct 11 20:57:32 2021 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,13 +0,0 @@ -Copyright (c) 2011-2018 Scott Vokes <vokes.s@gmail.com> - -Permission to use, copy, modify, and/or distribute this software for any -purpose with or without fee is hereby granted, provided that the above -copyright notice and this permission notice appear in all copies. - -THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES -WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF -MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR -ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES -WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN -ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF -OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/extern/LICENSE.librexo.txt Mon Oct 11 20:57:47 2021 +0200 @@ -0,0 +1,24 @@ +This is free and unencumbered software released into the public domain. + +Anyone is free to copy, modify, publish, use, compile, sell, or +distribute this software, either in source code form or as a compiled +binary, for any purpose, commercial or non-commercial, and by any +means. + +In jurisdictions that recognize copyright laws, the author or authors +of this software dedicate any and all copyright interest in the +software to the public domain. We make this dedication for the benefit +of the public at large and to the detriment of our heirs and +successors. We intend this dedication to be an overt act of +relinquishment in perpetuity of all present and future rights to this +software under copyright law. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +For more information, please refer to <https://unlicense.org>
--- a/extern/VERSION.libgreatest.txt Mon Oct 11 20:57:32 2021 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1 +0,0 @@ -1.4.2
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/extern/VERSION.librexo.txt Mon Oct 11 20:57:47 2021 +0200 @@ -0,0 +1,1 @@ +0.2.2
--- a/extern/libgreatest/greatest.h Mon Oct 11 20:57:32 2021 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1225 +0,0 @@ -/* - * Copyright (c) 2011-2019 Scott Vokes <vokes.s@gmail.com> - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#ifndef GREATEST_H -#define GREATEST_H - -#if defined(__cplusplus) && !defined(GREATEST_NO_EXTERN_CPLUSPLUS) -extern "C" { -#endif - -/* 1.4.2 */ -#define GREATEST_VERSION_MAJOR 1 -#define GREATEST_VERSION_MINOR 4 -#define GREATEST_VERSION_PATCH 2 - -/* A unit testing system for C, contained in 1 file. - * It doesn't use dynamic allocation or depend on anything - * beyond ANSI C89. - * - * An up-to-date version can be found at: - * https://github.com/silentbicycle/greatest/ - */ - - -/********************************************************************* - * Minimal test runner template - *********************************************************************/ -#if 0 - -#include "greatest.h" - -TEST foo_should_foo(void) { - PASS(); -} - -static void setup_cb(void *data) { - printf("setup callback for each test case\n"); -} - -static void teardown_cb(void *data) { - printf("teardown callback for each test case\n"); -} - -SUITE(suite) { - /* Optional setup/teardown callbacks which will be run before/after - * every test case. If using a test suite, they will be cleared when - * the suite finishes. */ - SET_SETUP(setup_cb, voidp_to_callback_data); - SET_TEARDOWN(teardown_cb, voidp_to_callback_data); - - RUN_TEST(foo_should_foo); -} - -/* Add definitions that need to be in the test runner's main file. */ -GREATEST_MAIN_DEFS(); - -/* Set up, run suite(s) of tests, report pass/fail/skip stats. */ -int run_tests(void) { - GREATEST_INIT(); /* init. greatest internals */ - /* List of suites to run (if any). */ - RUN_SUITE(suite); - - /* Tests can also be run directly, without using test suites. */ - RUN_TEST(foo_should_foo); - - GREATEST_PRINT_REPORT(); /* display results */ - return greatest_all_passed(); -} - -/* main(), for a standalone command-line test runner. - * This replaces run_tests above, and adds command line option - * handling and exiting with a pass/fail status. */ -int main(int argc, char **argv) { - GREATEST_MAIN_BEGIN(); /* init & parse command-line args */ - RUN_SUITE(suite); - GREATEST_MAIN_END(); /* display results */ -} - -#endif -/*********************************************************************/ - - -#include <stdlib.h> -#include <stdio.h> -#include <string.h> -#include <ctype.h> - -/*********** - * Options * - ***********/ - -/* Default column width for non-verbose output. */ -#ifndef GREATEST_DEFAULT_WIDTH -#define GREATEST_DEFAULT_WIDTH 72 -#endif - -/* FILE *, for test logging. */ -#ifndef GREATEST_STDOUT -#define GREATEST_STDOUT stdout -#endif - -/* Remove GREATEST_ prefix from most commonly used symbols? */ -#ifndef GREATEST_USE_ABBREVS -#define GREATEST_USE_ABBREVS 1 -#endif - -/* Set to 0 to disable all use of setjmp/longjmp. */ -#ifndef GREATEST_USE_LONGJMP -#define GREATEST_USE_LONGJMP 1 -#endif - -/* Make it possible to replace fprintf with another - * function with the same interface. */ -#ifndef GREATEST_FPRINTF -#define GREATEST_FPRINTF fprintf -#endif - -#if GREATEST_USE_LONGJMP -#include <setjmp.h> -#endif - -/* Set to 0 to disable all use of time.h / clock(). */ -#ifndef GREATEST_USE_TIME -#define GREATEST_USE_TIME 1 -#endif - -#if GREATEST_USE_TIME -#include <time.h> -#endif - -/* Floating point type, for ASSERT_IN_RANGE. */ -#ifndef GREATEST_FLOAT -#define GREATEST_FLOAT double -#define GREATEST_FLOAT_FMT "%g" -#endif - -/* Size of buffer for test name + optional '_' separator and suffix */ -#ifndef GREATEST_TESTNAME_BUF_SIZE -#define GREATEST_TESTNAME_BUF_SIZE 128 -#endif - - -/********* - * Types * - *********/ - -/* Info for the current running suite. */ -typedef struct greatest_suite_info { - unsigned int tests_run; - unsigned int passed; - unsigned int failed; - unsigned int skipped; - -#if GREATEST_USE_TIME - /* timers, pre/post running suite and individual tests */ - clock_t pre_suite; - clock_t post_suite; - clock_t pre_test; - clock_t post_test; -#endif -} greatest_suite_info; - -/* Type for a suite function. */ -typedef void greatest_suite_cb(void); - -/* Types for setup/teardown callbacks. If non-NULL, these will be run - * and passed the pointer to their additional data. */ -typedef void greatest_setup_cb(void *udata); -typedef void greatest_teardown_cb(void *udata); - -/* Type for an equality comparison between two pointers of the same type. - * Should return non-0 if equal, otherwise 0. - * UDATA is a closure value, passed through from ASSERT_EQUAL_T[m]. */ -typedef int greatest_equal_cb(const void *expd, const void *got, void *udata); - -/* Type for a callback that prints a value pointed to by T. - * Return value has the same meaning as printf's. - * UDATA is a closure value, passed through from ASSERT_EQUAL_T[m]. */ -typedef int greatest_printf_cb(const void *t, void *udata); - -/* Callbacks for an arbitrary type; needed for type-specific - * comparisons via GREATEST_ASSERT_EQUAL_T[m].*/ -typedef struct greatest_type_info { - greatest_equal_cb *equal; - greatest_printf_cb *print; -} greatest_type_info; - -typedef struct greatest_memory_cmp_env { - const unsigned char *exp; - const unsigned char *got; - size_t size; -} greatest_memory_cmp_env; - -/* Callbacks for string and raw memory types. */ -extern greatest_type_info greatest_type_info_string; -extern greatest_type_info greatest_type_info_memory; - -typedef enum { - GREATEST_FLAG_FIRST_FAIL = 0x01, - GREATEST_FLAG_LIST_ONLY = 0x02, - GREATEST_FLAG_ABORT_ON_FAIL = 0x04 -} greatest_flag_t; - -/* Internal state for a PRNG, used to shuffle test order. */ -struct greatest_prng { - unsigned char random_order; /* use random ordering? */ - unsigned char initialized; /* is random ordering initialized? */ - unsigned char pad_0[6]; - unsigned long state; /* PRNG state */ - unsigned long count; /* how many tests, this pass */ - unsigned long count_ceil; /* total number of tests */ - unsigned long count_run; /* total tests run */ - unsigned long a; /* LCG multiplier */ - unsigned long c; /* LCG increment */ - unsigned long m; /* LCG modulus, based on count_ceil */ -}; - -/* Struct containing all test runner state. */ -typedef struct greatest_run_info { - unsigned char flags; - unsigned char verbosity; - unsigned char pad_0[2]; - - unsigned int tests_run; /* total test count */ - - /* currently running test suite */ - greatest_suite_info suite; - - /* overall pass/fail/skip counts */ - unsigned int passed; - unsigned int failed; - unsigned int skipped; - unsigned int assertions; - - /* info to print about the most recent failure */ - unsigned int fail_line; - unsigned int pad_1; - const char *fail_file; - const char *msg; - - /* current setup/teardown hooks and userdata */ - greatest_setup_cb *setup; - void *setup_udata; - greatest_teardown_cb *teardown; - void *teardown_udata; - - /* formatting info for ".....s...F"-style output */ - unsigned int col; - unsigned int width; - - /* only run a specific suite or test */ - const char *suite_filter; - const char *test_filter; - const char *test_exclude; - const char *name_suffix; /* print suffix with test name */ - char name_buf[GREATEST_TESTNAME_BUF_SIZE]; - - struct greatest_prng prng[2]; /* 0: suites, 1: tests */ - -#if GREATEST_USE_TIME - /* overall timers */ - clock_t begin; - clock_t end; -#endif - -#if GREATEST_USE_LONGJMP - int pad_jmp_buf; - unsigned char pad_2[4]; - jmp_buf jump_dest; -#endif -} greatest_run_info; - -struct greatest_report_t { - /* overall pass/fail/skip counts */ - unsigned int passed; - unsigned int failed; - unsigned int skipped; - unsigned int assertions; -}; - -/* Global var for the current testing context. - * Initialized by GREATEST_MAIN_DEFS(). */ -extern greatest_run_info greatest_info; - -/* Type for ASSERT_ENUM_EQ's ENUM_STR argument. */ -typedef const char *greatest_enum_str_fun(int value); - - -/********************** - * Exported functions * - **********************/ - -/* These are used internally by greatest macros. */ -int greatest_test_pre(const char *name); -void greatest_test_post(int res); -int greatest_do_assert_equal_t(const void *expd, const void *got, - greatest_type_info *type_info, void *udata); -void greatest_prng_init_first_pass(int id); -int greatest_prng_init_second_pass(int id, unsigned long seed); -void greatest_prng_step(int id); - -/* These are part of the public greatest API. */ -void GREATEST_SET_SETUP_CB(greatest_setup_cb *cb, void *udata); -void GREATEST_SET_TEARDOWN_CB(greatest_teardown_cb *cb, void *udata); -void GREATEST_INIT(void); -void GREATEST_PRINT_REPORT(void); -int greatest_all_passed(void); -void greatest_set_suite_filter(const char *filter); -void greatest_set_test_filter(const char *filter); -void greatest_set_test_exclude(const char *filter); -void greatest_stop_at_first_fail(void); -void greatest_abort_on_fail(void); -void greatest_list_only(void); -void greatest_get_report(struct greatest_report_t *report); -unsigned int greatest_get_verbosity(void); -void greatest_set_verbosity(unsigned int verbosity); -void greatest_set_flag(greatest_flag_t flag); -void greatest_set_test_suffix(const char *suffix); - - -/******************** -* Language Support * -********************/ - -/* If __VA_ARGS__ (C99) is supported, allow parametric testing -* without needing to manually manage the argument struct. */ -#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 19901L) || \ - (defined(_MSC_VER) && _MSC_VER >= 1800) -#define GREATEST_VA_ARGS -#endif - - -/********** - * Macros * - **********/ - -/* Define a suite. (The duplication is intentional -- it eliminates - * a warning from -Wmissing-declarations.) */ -#define GREATEST_SUITE(NAME) void NAME(void); void NAME(void) - -/* Declare a suite, provided by another compilation unit. */ -#define GREATEST_SUITE_EXTERN(NAME) void NAME(void) - -/* Start defining a test function. - * The arguments are not included, to allow parametric testing. */ -#define GREATEST_TEST static enum greatest_test_res - -/* PASS/FAIL/SKIP result from a test. Used internally. */ -typedef enum greatest_test_res { - GREATEST_TEST_RES_PASS = 0, - GREATEST_TEST_RES_FAIL = -1, - GREATEST_TEST_RES_SKIP = 1 -} greatest_test_res; - -/* Run a suite. */ -#define GREATEST_RUN_SUITE(S_NAME) greatest_run_suite(S_NAME, #S_NAME) - -/* Run a test in the current suite. */ -#define GREATEST_RUN_TEST(TEST) \ - do { \ - if (greatest_test_pre(#TEST) == 1) { \ - enum greatest_test_res res = GREATEST_SAVE_CONTEXT(); \ - if (res == GREATEST_TEST_RES_PASS) { \ - res = TEST(); \ - } \ - greatest_test_post(res); \ - } \ - } while (0) - -/* Ignore a test, don't warn about it being unused. */ -#define GREATEST_IGNORE_TEST(TEST) (void)TEST - -/* Run a test in the current suite with one void * argument, - * which can be a pointer to a struct with multiple arguments. */ -#define GREATEST_RUN_TEST1(TEST, ENV) \ - do { \ - if (greatest_test_pre(#TEST) == 1) { \ - enum greatest_test_res res = GREATEST_SAVE_CONTEXT(); \ - if (res == GREATEST_TEST_RES_PASS) { \ - res = TEST(ENV); \ - } \ - greatest_test_post(res); \ - } \ - } while (0) - -#ifdef GREATEST_VA_ARGS -#define GREATEST_RUN_TESTp(TEST, ...) \ - do { \ - if (greatest_test_pre(#TEST) == 1) { \ - enum greatest_test_res res = GREATEST_SAVE_CONTEXT(); \ - if (res == GREATEST_TEST_RES_PASS) { \ - res = TEST(__VA_ARGS__); \ - } \ - greatest_test_post(res); \ - } \ - } while (0) -#endif - - -/* Check if the test runner is in verbose mode. */ -#define GREATEST_IS_VERBOSE() ((greatest_info.verbosity) > 0) -#define GREATEST_LIST_ONLY() \ - (greatest_info.flags & GREATEST_FLAG_LIST_ONLY) -#define GREATEST_FIRST_FAIL() \ - (greatest_info.flags & GREATEST_FLAG_FIRST_FAIL) -#define GREATEST_ABORT_ON_FAIL() \ - (greatest_info.flags & GREATEST_FLAG_ABORT_ON_FAIL) -#define GREATEST_FAILURE_ABORT() \ - (GREATEST_FIRST_FAIL() && \ - (greatest_info.suite.failed > 0 || greatest_info.failed > 0)) - -/* Message-less forms of tests defined below. */ -#define GREATEST_PASS() GREATEST_PASSm(NULL) -#define GREATEST_FAIL() GREATEST_FAILm(NULL) -#define GREATEST_SKIP() GREATEST_SKIPm(NULL) -#define GREATEST_ASSERT(COND) \ - GREATEST_ASSERTm(#COND, COND) -#define GREATEST_ASSERT_OR_LONGJMP(COND) \ - GREATEST_ASSERT_OR_LONGJMPm(#COND, COND) -#define GREATEST_ASSERT_FALSE(COND) \ - GREATEST_ASSERT_FALSEm(#COND, COND) -#define GREATEST_ASSERT_EQ(EXP, GOT) \ - GREATEST_ASSERT_EQm(#EXP " != " #GOT, EXP, GOT) -#define GREATEST_ASSERT_EQ_FMT(EXP, GOT, FMT) \ - GREATEST_ASSERT_EQ_FMTm(#EXP " != " #GOT, EXP, GOT, FMT) -#define GREATEST_ASSERT_IN_RANGE(EXP, GOT, TOL) \ - GREATEST_ASSERT_IN_RANGEm(#EXP " != " #GOT " +/- " #TOL, EXP, GOT, TOL) -#define GREATEST_ASSERT_EQUAL_T(EXP, GOT, TYPE_INFO, UDATA) \ - GREATEST_ASSERT_EQUAL_Tm(#EXP " != " #GOT, EXP, GOT, TYPE_INFO, UDATA) -#define GREATEST_ASSERT_STR_EQ(EXP, GOT) \ - GREATEST_ASSERT_STR_EQm(#EXP " != " #GOT, EXP, GOT) -#define GREATEST_ASSERT_STRN_EQ(EXP, GOT, SIZE) \ - GREATEST_ASSERT_STRN_EQm(#EXP " != " #GOT, EXP, GOT, SIZE) -#define GREATEST_ASSERT_MEM_EQ(EXP, GOT, SIZE) \ - GREATEST_ASSERT_MEM_EQm(#EXP " != " #GOT, EXP, GOT, SIZE) -#define GREATEST_ASSERT_ENUM_EQ(EXP, GOT, ENUM_STR) \ - GREATEST_ASSERT_ENUM_EQm(#EXP " != " #GOT, EXP, GOT, ENUM_STR) - -/* The following forms take an additional message argument first, - * to be displayed by the test runner. */ - -/* Fail if a condition is not true, with message. */ -#define GREATEST_ASSERTm(MSG, COND) \ - do { \ - greatest_info.assertions++; \ - if (!(COND)) { GREATEST_FAILm(MSG); } \ - } while (0) - -/* Fail if a condition is not true, longjmping out of test. */ -#define GREATEST_ASSERT_OR_LONGJMPm(MSG, COND) \ - do { \ - greatest_info.assertions++; \ - if (!(COND)) { GREATEST_FAIL_WITH_LONGJMPm(MSG); } \ - } while (0) - -/* Fail if a condition is not false, with message. */ -#define GREATEST_ASSERT_FALSEm(MSG, COND) \ - do { \ - greatest_info.assertions++; \ - if ((COND)) { GREATEST_FAILm(MSG); } \ - } while (0) - -/* Fail if EXP != GOT (equality comparison by ==). */ -#define GREATEST_ASSERT_EQm(MSG, EXP, GOT) \ - do { \ - greatest_info.assertions++; \ - if ((EXP) != (GOT)) { GREATEST_FAILm(MSG); } \ - } while (0) - -/* Fail if EXP != GOT (equality comparison by ==). - * Warning: FMT, EXP, and GOT will be evaluated more - * than once on failure. */ -#define GREATEST_ASSERT_EQ_FMTm(MSG, EXP, GOT, FMT) \ - do { \ - greatest_info.assertions++; \ - if ((EXP) != (GOT)) { \ - GREATEST_FPRINTF(GREATEST_STDOUT, "\nExpected: "); \ - GREATEST_FPRINTF(GREATEST_STDOUT, FMT, EXP); \ - GREATEST_FPRINTF(GREATEST_STDOUT, "\n Got: "); \ - GREATEST_FPRINTF(GREATEST_STDOUT, FMT, GOT); \ - GREATEST_FPRINTF(GREATEST_STDOUT, "\n"); \ - GREATEST_FAILm(MSG); \ - } \ - } while (0) - -/* Fail if EXP is not equal to GOT, printing enum IDs. */ -#define GREATEST_ASSERT_ENUM_EQm(MSG, EXP, GOT, ENUM_STR) \ - do { \ - int greatest_EXP = (int)(EXP); \ - int greatest_GOT = (int)(GOT); \ - greatest_enum_str_fun *greatest_ENUM_STR = ENUM_STR; \ - if (greatest_EXP != greatest_GOT) { \ - GREATEST_FPRINTF(GREATEST_STDOUT, "\nExpected: %s", \ - greatest_ENUM_STR(greatest_EXP)); \ - GREATEST_FPRINTF(GREATEST_STDOUT, "\n Got: %s\n", \ - greatest_ENUM_STR(greatest_GOT)); \ - GREATEST_FAILm(MSG); \ - } \ - } while (0) \ - -/* Fail if GOT not in range of EXP +|- TOL. */ -#define GREATEST_ASSERT_IN_RANGEm(MSG, EXP, GOT, TOL) \ - do { \ - GREATEST_FLOAT greatest_EXP = (EXP); \ - GREATEST_FLOAT greatest_GOT = (GOT); \ - GREATEST_FLOAT greatest_TOL = (TOL); \ - greatest_info.assertions++; \ - if ((greatest_EXP > greatest_GOT && \ - greatest_EXP - greatest_GOT > greatest_TOL) || \ - (greatest_EXP < greatest_GOT && \ - greatest_GOT - greatest_EXP > greatest_TOL)) { \ - GREATEST_FPRINTF(GREATEST_STDOUT, \ - "\nExpected: " GREATEST_FLOAT_FMT \ - " +/- " GREATEST_FLOAT_FMT \ - "\n Got: " GREATEST_FLOAT_FMT \ - "\n", \ - greatest_EXP, greatest_TOL, greatest_GOT); \ - GREATEST_FAILm(MSG); \ - } \ - } while (0) - -/* Fail if EXP is not equal to GOT, according to strcmp. */ -#define GREATEST_ASSERT_STR_EQm(MSG, EXP, GOT) \ - do { \ - GREATEST_ASSERT_EQUAL_Tm(MSG, EXP, GOT, \ - &greatest_type_info_string, NULL); \ - } while (0) \ - -/* Fail if EXP is not equal to GOT, according to strncmp. */ -#define GREATEST_ASSERT_STRN_EQm(MSG, EXP, GOT, SIZE) \ - do { \ - size_t size = SIZE; \ - GREATEST_ASSERT_EQUAL_Tm(MSG, EXP, GOT, \ - &greatest_type_info_string, &size); \ - } while (0) \ - -/* Fail if EXP is not equal to GOT, according to memcmp. */ -#define GREATEST_ASSERT_MEM_EQm(MSG, EXP, GOT, SIZE) \ - do { \ - greatest_memory_cmp_env env; \ - env.exp = (const unsigned char *)EXP; \ - env.got = (const unsigned char *)GOT; \ - env.size = SIZE; \ - GREATEST_ASSERT_EQUAL_Tm(MSG, env.exp, env.got, \ - &greatest_type_info_memory, &env); \ - } while (0) \ - -/* Fail if EXP is not equal to GOT, according to a comparison - * callback in TYPE_INFO. If they are not equal, optionally use a - * print callback in TYPE_INFO to print them. */ -#define GREATEST_ASSERT_EQUAL_Tm(MSG, EXP, GOT, TYPE_INFO, UDATA) \ - do { \ - greatest_type_info *type_info = (TYPE_INFO); \ - greatest_info.assertions++; \ - if (!greatest_do_assert_equal_t(EXP, GOT, \ - type_info, UDATA)) { \ - if (type_info == NULL || type_info->equal == NULL) { \ - GREATEST_FAILm("type_info->equal callback missing!"); \ - } else { \ - GREATEST_FAILm(MSG); \ - } \ - } \ - } while (0) \ - -/* Pass. */ -#define GREATEST_PASSm(MSG) \ - do { \ - greatest_info.msg = MSG; \ - return GREATEST_TEST_RES_PASS; \ - } while (0) - -/* Fail. */ -#define GREATEST_FAILm(MSG) \ - do { \ - greatest_info.fail_file = __FILE__; \ - greatest_info.fail_line = __LINE__; \ - greatest_info.msg = MSG; \ - if (GREATEST_ABORT_ON_FAIL()) { abort(); } \ - return GREATEST_TEST_RES_FAIL; \ - } while (0) - -/* Optional GREATEST_FAILm variant that longjmps. */ -#if GREATEST_USE_LONGJMP -#define GREATEST_FAIL_WITH_LONGJMP() GREATEST_FAIL_WITH_LONGJMPm(NULL) -#define GREATEST_FAIL_WITH_LONGJMPm(MSG) \ - do { \ - greatest_info.fail_file = __FILE__; \ - greatest_info.fail_line = __LINE__; \ - greatest_info.msg = MSG; \ - longjmp(greatest_info.jump_dest, GREATEST_TEST_RES_FAIL); \ - } while (0) -#endif - -/* Skip the current test. */ -#define GREATEST_SKIPm(MSG) \ - do { \ - greatest_info.msg = MSG; \ - return GREATEST_TEST_RES_SKIP; \ - } while (0) - -/* Check the result of a subfunction using ASSERT, etc. */ -#define GREATEST_CHECK_CALL(RES) \ - do { \ - enum greatest_test_res greatest_RES = RES; \ - if (greatest_RES != GREATEST_TEST_RES_PASS) { \ - return greatest_RES; \ - } \ - } while (0) \ - -#if GREATEST_USE_TIME -#define GREATEST_SET_TIME(NAME) \ - NAME = clock(); \ - if (NAME == (clock_t) -1) { \ - GREATEST_FPRINTF(GREATEST_STDOUT, \ - "clock error: %s\n", #NAME); \ - exit(EXIT_FAILURE); \ - } - -#define GREATEST_CLOCK_DIFF(C1, C2) \ - GREATEST_FPRINTF(GREATEST_STDOUT, " (%lu ticks, %.3f sec)", \ - (long unsigned int) (C2) - (long unsigned int)(C1), \ - (double)((C2) - (C1)) / (1.0 * (double)CLOCKS_PER_SEC)) -#else -#define GREATEST_SET_TIME(UNUSED) -#define GREATEST_CLOCK_DIFF(UNUSED1, UNUSED2) -#endif - -#if GREATEST_USE_LONGJMP -#define GREATEST_SAVE_CONTEXT() \ - /* setjmp returns 0 (GREATEST_TEST_RES_PASS) on first call * \ - * so the test runs, then RES_FAIL from FAIL_WITH_LONGJMP. */ \ - ((enum greatest_test_res)(setjmp(greatest_info.jump_dest))) -#else -#define GREATEST_SAVE_CONTEXT() \ - /*a no-op, since setjmp/longjmp aren't being used */ \ - GREATEST_TEST_RES_PASS -#endif - -/* Run every suite / test function run within BODY in pseudo-random - * order, seeded by SEED. (The top 3 bits of the seed are ignored.) - * - * This should be called like: - * GREATEST_SHUFFLE_TESTS(seed, { - * GREATEST_RUN_TEST(some_test); - * GREATEST_RUN_TEST(some_other_test); - * GREATEST_RUN_TEST(yet_another_test); - * }); - * - * Note that the body of the second argument will be evaluated - * multiple times. */ -#define GREATEST_SHUFFLE_SUITES(SD, BODY) GREATEST_SHUFFLE(0, SD, BODY) -#define GREATEST_SHUFFLE_TESTS(SD, BODY) GREATEST_SHUFFLE(1, SD, BODY) -#define GREATEST_SHUFFLE(ID, SD, BODY) \ - do { \ - struct greatest_prng *prng = &greatest_info.prng[ID]; \ - greatest_prng_init_first_pass(ID); \ - do { \ - prng->count = 0; \ - if (prng->initialized) { greatest_prng_step(ID); } \ - BODY; \ - if (!prng->initialized) { \ - if (!greatest_prng_init_second_pass(ID, SD)) { break; } \ - } else if (prng->count_run == prng->count_ceil) { \ - break; \ - } \ - } while (!GREATEST_FAILURE_ABORT()); \ - prng->count_run = prng->random_order = prng->initialized = 0; \ - } while(0) - -/* Include several function definitions in the main test file. */ -#define GREATEST_MAIN_DEFS() \ - \ -/* Is FILTER a subset of NAME? */ \ -static int greatest_name_match(const char *name, const char *filter, \ - int res_if_none) { \ - size_t offset = 0; \ - size_t filter_len = filter ? strlen(filter) : 0; \ - if (filter_len == 0) { return res_if_none; } /* no filter */ \ - while (name[offset] != '\0') { \ - if (name[offset] == filter[0]) { \ - if (0 == strncmp(&name[offset], filter, filter_len)) { \ - return 1; \ - } \ - } \ - offset++; \ - } \ - \ - return 0; \ -} \ - \ -static void greatest_buffer_test_name(const char *name) { \ - struct greatest_run_info *g = &greatest_info; \ - size_t len = strlen(name), size = sizeof(g->name_buf); \ - memset(g->name_buf, 0x00, size); \ - (void)strncat(g->name_buf, name, size - 1); \ - if (g->name_suffix && (len + 1 < size)) { \ - g->name_buf[len] = '_'; \ - strncat(&g->name_buf[len+1], g->name_suffix, size-(len+2)); \ - } \ -} \ - \ -/* Before running a test, check the name filtering and \ - * test shuffling state, if applicable, and then call setup hooks. */ \ -int greatest_test_pre(const char *name) { \ - struct greatest_run_info *g = &greatest_info; \ - int match; \ - greatest_buffer_test_name(name); \ - match = greatest_name_match(g->name_buf, g->test_filter, 1) && \ - !greatest_name_match(g->name_buf, g->test_exclude, 0); \ - if (GREATEST_LIST_ONLY()) { /* just listing test names */ \ - if (match) { \ - GREATEST_FPRINTF(GREATEST_STDOUT, " %s\n", g->name_buf); \ - } \ - goto clear; \ - } \ - if (match && (!GREATEST_FIRST_FAIL() || g->suite.failed == 0)) { \ - struct greatest_prng *p = &g->prng[1]; \ - if (p->random_order) { \ - p->count++; \ - if (!p->initialized || ((p->count - 1) != p->state)) { \ - goto clear; /* don't run this test yet */ \ - } \ - } \ - GREATEST_SET_TIME(g->suite.pre_test); \ - if (g->setup) { g->setup(g->setup_udata); } \ - p->count_run++; \ - return 1; /* test should be run */ \ - } else { \ - goto clear; /* skipped */ \ - } \ -clear: \ - g->name_suffix = NULL; \ - return 0; \ -} \ - \ -static void greatest_do_pass(void) { \ - struct greatest_run_info *g = &greatest_info; \ - if (GREATEST_IS_VERBOSE()) { \ - GREATEST_FPRINTF(GREATEST_STDOUT, "PASS %s: %s", \ - g->name_buf, g->msg ? g->msg : ""); \ - } else { \ - GREATEST_FPRINTF(GREATEST_STDOUT, "."); \ - } \ - g->suite.passed++; \ -} \ - \ -static void greatest_do_fail(void) { \ - struct greatest_run_info *g = &greatest_info; \ - if (GREATEST_IS_VERBOSE()) { \ - GREATEST_FPRINTF(GREATEST_STDOUT, \ - "FAIL %s: %s (%s:%u)", g->name_buf, \ - g->msg ? g->msg : "", g->fail_file, g->fail_line); \ - } else { \ - GREATEST_FPRINTF(GREATEST_STDOUT, "F"); \ - g->col++; /* add linebreak if in line of '.'s */ \ - if (g->col != 0) { \ - GREATEST_FPRINTF(GREATEST_STDOUT, "\n"); \ - g->col = 0; \ - } \ - GREATEST_FPRINTF(GREATEST_STDOUT, "FAIL %s: %s (%s:%u)\n", \ - g->name_buf, g->msg ? g->msg : "", \ - g->fail_file, g->fail_line); \ - } \ - g->suite.failed++; \ -} \ - \ -static void greatest_do_skip(void) { \ - struct greatest_run_info *g = &greatest_info; \ - if (GREATEST_IS_VERBOSE()) { \ - GREATEST_FPRINTF(GREATEST_STDOUT, "SKIP %s: %s", \ - g->name_buf, g->msg ? g->msg : ""); \ - } else { \ - GREATEST_FPRINTF(GREATEST_STDOUT, "s"); \ - } \ - g->suite.skipped++; \ -} \ - \ -void greatest_test_post(int res) { \ - GREATEST_SET_TIME(greatest_info.suite.post_test); \ - if (greatest_info.teardown) { \ - void *udata = greatest_info.teardown_udata; \ - greatest_info.teardown(udata); \ - } \ - \ - if (res <= GREATEST_TEST_RES_FAIL) { \ - greatest_do_fail(); \ - } else if (res >= GREATEST_TEST_RES_SKIP) { \ - greatest_do_skip(); \ - } else if (res == GREATEST_TEST_RES_PASS) { \ - greatest_do_pass(); \ - } \ - greatest_info.name_suffix = NULL; \ - greatest_info.suite.tests_run++; \ - greatest_info.col++; \ - if (GREATEST_IS_VERBOSE()) { \ - GREATEST_CLOCK_DIFF(greatest_info.suite.pre_test, \ - greatest_info.suite.post_test); \ - GREATEST_FPRINTF(GREATEST_STDOUT, "\n"); \ - } else if (greatest_info.col % greatest_info.width == 0) { \ - GREATEST_FPRINTF(GREATEST_STDOUT, "\n"); \ - greatest_info.col = 0; \ - } \ - fflush(GREATEST_STDOUT); \ -} \ - \ -static void report_suite(void) { \ - if (greatest_info.suite.tests_run > 0) { \ - GREATEST_FPRINTF(GREATEST_STDOUT, \ - "\n%u test%s - %u passed, %u failed, %u skipped", \ - greatest_info.suite.tests_run, \ - greatest_info.suite.tests_run == 1 ? "" : "s", \ - greatest_info.suite.passed, \ - greatest_info.suite.failed, \ - greatest_info.suite.skipped); \ - GREATEST_CLOCK_DIFF(greatest_info.suite.pre_suite, \ - greatest_info.suite.post_suite); \ - GREATEST_FPRINTF(GREATEST_STDOUT, "\n"); \ - } \ -} \ - \ -static void update_counts_and_reset_suite(void) { \ - greatest_info.setup = NULL; \ - greatest_info.setup_udata = NULL; \ - greatest_info.teardown = NULL; \ - greatest_info.teardown_udata = NULL; \ - greatest_info.passed += greatest_info.suite.passed; \ - greatest_info.failed += greatest_info.suite.failed; \ - greatest_info.skipped += greatest_info.suite.skipped; \ - greatest_info.tests_run += greatest_info.suite.tests_run; \ - memset(&greatest_info.suite, 0, sizeof(greatest_info.suite)); \ - greatest_info.col = 0; \ -} \ - \ -static int greatest_suite_pre(const char *suite_name) { \ - struct greatest_prng *p = &greatest_info.prng[0]; \ - if (!greatest_name_match(suite_name, greatest_info.suite_filter, 1) \ - || (GREATEST_FAILURE_ABORT())) { return 0; } \ - if (p->random_order) { \ - p->count++; \ - if (!p->initialized || ((p->count - 1) != p->state)) { \ - return 0; /* don't run this suite yet */ \ - } \ - } \ - p->count_run++; \ - update_counts_and_reset_suite(); \ - GREATEST_FPRINTF(GREATEST_STDOUT, "\n* Suite %s:\n", suite_name); \ - GREATEST_SET_TIME(greatest_info.suite.pre_suite); \ - return 1; \ -} \ - \ -static void greatest_suite_post(void) { \ - GREATEST_SET_TIME(greatest_info.suite.post_suite); \ - report_suite(); \ -} \ - \ -static void greatest_run_suite(greatest_suite_cb *suite_cb, \ - const char *suite_name) { \ - if (greatest_suite_pre(suite_name)) { \ - suite_cb(); \ - greatest_suite_post(); \ - } \ -} \ - \ -int greatest_do_assert_equal_t(const void *expd, const void *got, \ - greatest_type_info *type_info, void *udata) { \ - int eq = 0; \ - if (type_info == NULL || type_info->equal == NULL) { \ - return 0; \ - } \ - eq = type_info->equal(expd, got, udata); \ - if (!eq) { \ - if (type_info->print != NULL) { \ - GREATEST_FPRINTF(GREATEST_STDOUT, "\nExpected: "); \ - (void)type_info->print(expd, udata); \ - GREATEST_FPRINTF(GREATEST_STDOUT, "\n Got: "); \ - (void)type_info->print(got, udata); \ - GREATEST_FPRINTF(GREATEST_STDOUT, "\n"); \ - } \ - } \ - return eq; \ -} \ - \ -static void greatest_usage(const char *name) { \ - GREATEST_FPRINTF(GREATEST_STDOUT, \ - "Usage: %s [-hlfav] [-s SUITE] [-t TEST] [-x EXCLUDE]\n" \ - " -h, --help print this Help\n" \ - " -l List suites and tests, then exit (dry run)\n" \ - " -f Stop runner after first failure\n" \ - " -a Abort on first failure (implies -f)\n" \ - " -v Verbose output\n" \ - " -s SUITE only run suites containing substring SUITE\n" \ - " -t TEST only run tests containing substring TEST\n" \ - " -x EXCLUDE exclude tests containing substring EXCLUDE\n", \ - name); \ -} \ - \ -static void greatest_parse_options(int argc, char **argv) { \ - int i = 0; \ - for (i = 1; i < argc; i++) { \ - if (argv[i][0] == '-') { \ - char f = argv[i][1]; \ - if ((f == 's' || f == 't' || f == 'x') && argc <= i + 1) { \ - greatest_usage(argv[0]); exit(EXIT_FAILURE); \ - } \ - switch (f) { \ - case 's': /* suite name filter */ \ - greatest_set_suite_filter(argv[i + 1]); i++; break; \ - case 't': /* test name filter */ \ - greatest_set_test_filter(argv[i + 1]); i++; break; \ - case 'x': /* test name exclusion */ \ - greatest_set_test_exclude(argv[i + 1]); i++; break; \ - case 'f': /* first fail flag */ \ - greatest_stop_at_first_fail(); break; \ - case 'a': /* abort() on fail flag */ \ - greatest_abort_on_fail(); break; \ - case 'l': /* list only (dry run) */ \ - greatest_list_only(); break; \ - case 'v': /* first fail flag */ \ - greatest_info.verbosity++; break; \ - case 'h': /* help */ \ - greatest_usage(argv[0]); exit(EXIT_SUCCESS); \ - case '-': \ - if (0 == strncmp("--help", argv[i], 6)) { \ - greatest_usage(argv[0]); exit(EXIT_SUCCESS); \ - } else if (0 == strncmp("--", argv[i], 2)) { \ - return; /* ignore following arguments */ \ - } /* fall through */ \ - default: \ - GREATEST_FPRINTF(GREATEST_STDOUT, \ - "Unknown argument '%s'\n", argv[i]); \ - greatest_usage(argv[0]); \ - exit(EXIT_FAILURE); \ - } \ - } \ - } \ -} \ - \ -int greatest_all_passed(void) { return (greatest_info.failed == 0); } \ - \ -void greatest_set_test_filter(const char *filter) { \ - greatest_info.test_filter = filter; \ -} \ - \ -void greatest_set_test_exclude(const char *filter) { \ - greatest_info.test_exclude = filter; \ -} \ - \ -void greatest_set_suite_filter(const char *filter) { \ - greatest_info.suite_filter = filter; \ -} \ - \ -void greatest_stop_at_first_fail(void) { \ - greatest_set_flag(GREATEST_FLAG_FIRST_FAIL); \ -} \ - \ -void greatest_abort_on_fail(void) { \ - greatest_set_flag(GREATEST_FLAG_ABORT_ON_FAIL); \ -} \ - \ -void greatest_list_only(void) { \ - greatest_set_flag(GREATEST_FLAG_LIST_ONLY); \ -} \ - \ -void greatest_get_report(struct greatest_report_t *report) { \ - if (report) { \ - report->passed = greatest_info.passed; \ - report->failed = greatest_info.failed; \ - report->skipped = greatest_info.skipped; \ - report->assertions = greatest_info.assertions; \ - } \ -} \ - \ -unsigned int greatest_get_verbosity(void) { \ - return greatest_info.verbosity; \ -} \ - \ -void greatest_set_verbosity(unsigned int verbosity) { \ - greatest_info.verbosity = (unsigned char)verbosity; \ -} \ - \ -void greatest_set_flag(greatest_flag_t flag) { \ - greatest_info.flags = (unsigned char)(greatest_info.flags | flag); \ -} \ - \ -void greatest_set_test_suffix(const char *suffix) { \ - greatest_info.name_suffix = suffix; \ -} \ - \ -void GREATEST_SET_SETUP_CB(greatest_setup_cb *cb, void *udata) { \ - greatest_info.setup = cb; \ - greatest_info.setup_udata = udata; \ -} \ - \ -void GREATEST_SET_TEARDOWN_CB(greatest_teardown_cb *cb, \ - void *udata) { \ - greatest_info.teardown = cb; \ - greatest_info.teardown_udata = udata; \ -} \ - \ -static int greatest_string_equal_cb(const void *expd, const void *got, \ - void *udata) { \ - size_t *size = (size_t *)udata; \ - return (size != NULL \ - ? (0 == strncmp((const char *)expd, (const char *)got, *size)) \ - : (0 == strcmp((const char *)expd, (const char *)got))); \ -} \ - \ -static int greatest_string_printf_cb(const void *t, void *udata) { \ - (void)udata; /* note: does not check \0 termination. */ \ - return GREATEST_FPRINTF(GREATEST_STDOUT, "%s", (const char *)t); \ -} \ - \ -greatest_type_info greatest_type_info_string = { \ - greatest_string_equal_cb, \ - greatest_string_printf_cb, \ -}; \ - \ -static int greatest_memory_equal_cb(const void *expd, const void *got, \ - void *udata) { \ - greatest_memory_cmp_env *env = (greatest_memory_cmp_env *)udata; \ - return (0 == memcmp(expd, got, env->size)); \ -} \ - \ -/* Hexdump raw memory, with differences highlighted */ \ -static int greatest_memory_printf_cb(const void *t, void *udata) { \ - greatest_memory_cmp_env *env = (greatest_memory_cmp_env *)udata; \ - const unsigned char *buf = (const unsigned char *)t; \ - unsigned char diff_mark = ' '; \ - FILE *out = GREATEST_STDOUT; \ - size_t i, line_i, line_len = 0; \ - int len = 0; /* format hexdump with differences highlighted */ \ - for (i = 0; i < env->size; i+= line_len) { \ - diff_mark = ' '; \ - line_len = env->size - i; \ - if (line_len > 16) { line_len = 16; } \ - for (line_i = i; line_i < i + line_len; line_i++) { \ - if (env->exp[line_i] != env->got[line_i]) diff_mark = 'X'; \ - } \ - len += GREATEST_FPRINTF(out, "\n%04x %c ", \ - (unsigned int)i, diff_mark); \ - for (line_i = i; line_i < i + line_len; line_i++) { \ - int m = env->exp[line_i] == env->got[line_i]; /* match? */ \ - len += GREATEST_FPRINTF(out, "%02x%c", \ - buf[line_i], m ? ' ' : '<'); \ - } \ - for (line_i = 0; line_i < 16 - line_len; line_i++) { \ - len += GREATEST_FPRINTF(out, " "); \ - } \ - GREATEST_FPRINTF(out, " "); \ - for (line_i = i; line_i < i + line_len; line_i++) { \ - unsigned char c = buf[line_i]; \ - len += GREATEST_FPRINTF(out, "%c", isprint(c) ? c : '.'); \ - } \ - } \ - len += GREATEST_FPRINTF(out, "\n"); \ - return len; \ -} \ - \ -void greatest_prng_init_first_pass(int id) { \ - greatest_info.prng[id].random_order = 1; \ - greatest_info.prng[id].count_run = 0; \ -} \ - \ -int greatest_prng_init_second_pass(int id, unsigned long seed) { \ - struct greatest_prng *p = &greatest_info.prng[id]; \ - if (p->count == 0) { return 0; } \ - p->count_ceil = p->count; \ - for (p->m = 1; p->m < p->count; p->m <<= 1) {} \ - p->state = seed & 0x1fffffff; /* only use lower 29 bits */ \ - p->a = 4LU * p->state; /* to avoid overflow when */ \ - p->a = (p->a ? p->a : 4) | 1; /* multiplied by 4 */ \ - p->c = 2147483647; /* and so p->c ((2 ** 31) - 1) is */ \ - p->initialized = 1; /* always relatively prime to p->a. */ \ - fprintf(stderr, "init_second_pass: a %lu, c %lu, state %lu\n", \ - p->a, p->c, p->state); \ - return 1; \ -} \ - \ -/* Step the pseudorandom number generator until its state reaches \ - * another test ID between 0 and the test count. \ - * This use a linear congruential pseudorandom number generator, \ - * with the power-of-two ceiling of the test count as the modulus, the \ - * masked seed as the multiplier, and a prime as the increment. For \ - * each generated value < the test count, run the corresponding test. \ - * This will visit all IDs 0 <= X < mod once before repeating, \ - * with a starting position chosen based on the initial seed. \ - * For details, see: Knuth, The Art of Computer Programming \ - * Volume. 2, section 3.2.1. */ \ -void greatest_prng_step(int id) { \ - struct greatest_prng *p = &greatest_info.prng[id]; \ - do { \ - p->state = ((p->a * p->state) + p->c) & (p->m - 1); \ - } while (p->state >= p->count_ceil); \ -} \ - \ -void GREATEST_INIT(void) { \ - /* Suppress unused function warning if features aren't used */ \ - (void)greatest_run_suite; \ - (void)greatest_parse_options; \ - (void)greatest_prng_step; \ - (void)greatest_prng_init_first_pass; \ - (void)greatest_prng_init_second_pass; \ - (void)greatest_set_test_suffix; \ - \ - memset(&greatest_info, 0, sizeof(greatest_info)); \ - greatest_info.width = GREATEST_DEFAULT_WIDTH; \ - GREATEST_SET_TIME(greatest_info.begin); \ -} \ - \ -/* Report passes, failures, skipped tests, the number of \ - * assertions, and the overall run time. */ \ -void GREATEST_PRINT_REPORT(void) { \ - if (!GREATEST_LIST_ONLY()) { \ - update_counts_and_reset_suite(); \ - GREATEST_SET_TIME(greatest_info.end); \ - GREATEST_FPRINTF(GREATEST_STDOUT, \ - "\nTotal: %u test%s", \ - greatest_info.tests_run, \ - greatest_info.tests_run == 1 ? "" : "s"); \ - GREATEST_CLOCK_DIFF(greatest_info.begin, \ - greatest_info.end); \ - GREATEST_FPRINTF(GREATEST_STDOUT, ", %u assertion%s\n", \ - greatest_info.assertions, \ - greatest_info.assertions == 1 ? "" : "s"); \ - GREATEST_FPRINTF(GREATEST_STDOUT, \ - "Pass: %u, fail: %u, skip: %u.\n", \ - greatest_info.passed, \ - greatest_info.failed, greatest_info.skipped); \ - } \ -} \ - \ -greatest_type_info greatest_type_info_memory = { \ - greatest_memory_equal_cb, \ - greatest_memory_printf_cb, \ -}; \ - \ -greatest_run_info greatest_info - -/* Handle command-line arguments, etc. */ -#define GREATEST_MAIN_BEGIN() \ - do { \ - GREATEST_INIT(); \ - greatest_parse_options(argc, argv); \ - } while (0) - -/* Report results, exit with exit status based on results. */ -#define GREATEST_MAIN_END() \ - do { \ - GREATEST_PRINT_REPORT(); \ - return (greatest_all_passed() ? EXIT_SUCCESS : EXIT_FAILURE); \ - } while (0) - -/* Make abbreviations without the GREATEST_ prefix for the - * most commonly used symbols. */ -#if GREATEST_USE_ABBREVS -#define TEST GREATEST_TEST -#define SUITE GREATEST_SUITE -#define SUITE_EXTERN GREATEST_SUITE_EXTERN -#define RUN_TEST GREATEST_RUN_TEST -#define RUN_TEST1 GREATEST_RUN_TEST1 -#define RUN_SUITE GREATEST_RUN_SUITE -#define IGNORE_TEST GREATEST_IGNORE_TEST -#define ASSERT GREATEST_ASSERT -#define ASSERTm GREATEST_ASSERTm -#define ASSERT_FALSE GREATEST_ASSERT_FALSE -#define ASSERT_EQ GREATEST_ASSERT_EQ -#define ASSERT_EQ_FMT GREATEST_ASSERT_EQ_FMT -#define ASSERT_IN_RANGE GREATEST_ASSERT_IN_RANGE -#define ASSERT_EQUAL_T GREATEST_ASSERT_EQUAL_T -#define ASSERT_STR_EQ GREATEST_ASSERT_STR_EQ -#define ASSERT_STRN_EQ GREATEST_ASSERT_STRN_EQ -#define ASSERT_MEM_EQ GREATEST_ASSERT_MEM_EQ -#define ASSERT_ENUM_EQ GREATEST_ASSERT_ENUM_EQ -#define ASSERT_FALSEm GREATEST_ASSERT_FALSEm -#define ASSERT_EQm GREATEST_ASSERT_EQm -#define ASSERT_EQ_FMTm GREATEST_ASSERT_EQ_FMTm -#define ASSERT_IN_RANGEm GREATEST_ASSERT_IN_RANGEm -#define ASSERT_EQUAL_Tm GREATEST_ASSERT_EQUAL_Tm -#define ASSERT_STR_EQm GREATEST_ASSERT_STR_EQm -#define ASSERT_STRN_EQm GREATEST_ASSERT_STRN_EQm -#define ASSERT_MEM_EQm GREATEST_ASSERT_MEM_EQm -#define ASSERT_ENUM_EQm GREATEST_ASSERT_ENUM_EQm -#define PASS GREATEST_PASS -#define FAIL GREATEST_FAIL -#define SKIP GREATEST_SKIP -#define PASSm GREATEST_PASSm -#define FAILm GREATEST_FAILm -#define SKIPm GREATEST_SKIPm -#define SET_SETUP GREATEST_SET_SETUP_CB -#define SET_TEARDOWN GREATEST_SET_TEARDOWN_CB -#define CHECK_CALL GREATEST_CHECK_CALL -#define SHUFFLE_TESTS GREATEST_SHUFFLE_TESTS -#define SHUFFLE_SUITES GREATEST_SHUFFLE_SUITES - -#ifdef GREATEST_VA_ARGS -#define RUN_TESTp GREATEST_RUN_TESTp -#endif - -#if GREATEST_USE_LONGJMP -#define ASSERT_OR_LONGJMP GREATEST_ASSERT_OR_LONGJMP -#define ASSERT_OR_LONGJMPm GREATEST_ASSERT_OR_LONGJMPm -#define FAIL_WITH_LONGJMP GREATEST_FAIL_WITH_LONGJMP -#define FAIL_WITH_LONGJMPm GREATEST_FAIL_WITH_LONGJMPm -#endif - -#endif /* USE_ABBREVS */ - -#if defined(__cplusplus) && !defined(GREATEST_NO_EXTERN_CPLUSPLUS) -} -#endif - -#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/extern/librexo/rexo.h Mon Oct 11 20:57:47 2021 +0200 @@ -0,0 +1,6697 @@ +/* + This is free and unencumbered software released into the public domain. + + Anyone is free to copy, modify, publish, use, compile, sell, or + distribute this software, either in source code form or as a compiled + binary, for any purpose, commercial or non-commercial, and by any + means. + + In jurisdictions that recognize copyright laws, the author or authors + of this software dedicate any and all copyright interest in the + software to the public domain. We make this dedication for the benefit + of the public at large and to the detriment of our heirs and + successors. We intend this dedication to be an overt act of + relinquishment in perpetuity of all present and future rights to this + software under copyright law. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR + OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + OTHER DEALINGS IN THE SOFTWARE. + + For more information, please refer to <https://unlicense.org> +*/ + +#ifndef REXO_REXO_H +#define REXO_REXO_H + +#define RX_MAJOR_VERSION 0 +#define RX_MINOR_VERSION 2 +#define RX_PATCH_VERSION 2 + +#define RX_VERSION \ + ((RX_MAJOR_VERSION << 20) | (RX_MINOR_VERSION << 10) | (RX_PATCH_VERSION)) + +/* + The environment macro represents whether the code is to be generated for a + 32-bit or 64-bit target platform. Some CPUs, such as the x86-64 processors, + allow running code in 32-bit mode if compiled using the -m32 or -mx32 + compiler switches, in which case `RX__ENVIRONMENT` is set to 32. +*/ +#if (!(defined(__x86_64__) || defined(_M_X64)) || defined(__ILP32__)) \ + && !(defined(__itanium__) || defined(_M_IA64)) \ + && !(defined(__powerpc64__) || defined(__ppc64__)) \ + && !defined(__aarch64__) + #define RX__ENVIRONMENT 32 +#else + #define RX__ENVIRONMENT 64 +#endif + +/* + The common data models, that is ILP32 (most recent 32-bit systems), + LP64 (Unix-like systems), and LLP64 (Windows), all have the `int` type set to + 32 bits, and the `long long` type to 64 bits. +*/ +#if defined(RX_UINT32_TYPE) + typedef RX_UINT32_TYPE rx_uint32; +#else + typedef unsigned int rx_uint32; +#endif +typedef char rx__invalid_uint32_type[sizeof(rx_uint32) == 4 ? 1 : -1]; + +#if defined(RX_UINT64_TYPE) + typedef RX_UINT64_TYPE rx_uint64; +#else + #if defined(__GNUC__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wlong-long" + #endif + /* + Even though the `long long` type is not part of the C89 and C++98 + standards, assume that it's defined by current compilers. + */ + typedef unsigned long long rx_uint64; + #if defined(__GNUC__) + #pragma GCC diagnostic pop + #endif +#endif +typedef char rx__invalid_uint64_type[sizeof(rx_uint64) == 8 ? 1 : -1]; + +/* + The C standard provides no guarantees about the size of the type `size_t`, + and some exotic platforms will in fact provide original values, but this + should cover most of the use cases. +*/ +#if defined(RX_SIZE_TYPE) + typedef RX_SIZE_TYPE rx_size; +#elif RX__ENVIRONMENT == 32 + typedef rx_uint32 rx_size; +#else + typedef rx_uint64 rx_size; +#endif + +#if defined(RX_ENABLE_EXTERNAL_LINKING) + #define RX__STORAGE extern +#else + #define RX__STORAGE static +#endif + +#if defined(__GNUC__) + #define RX__MAYBE_UNUSED __attribute__((unused)) +#else + #define RX__MAYBE_UNUSED +#endif + +#if defined(_MSC_VER) + #define RX__DEFINE_PARAMS(type) \ + _Pragma("warning(push)") \ + _Pragma("warning(disable : 4100)") \ + struct rx_context *RX_PARAM_CONTEXT RX__MAYBE_UNUSED, \ + type *RX_PARAM_DATA RX__MAYBE_UNUSED \ + _Pragma("warning(pop)") +#else + #define RX__DEFINE_PARAMS(type) \ + struct rx_context *RX_PARAM_CONTEXT RX__MAYBE_UNUSED, \ + type *RX_PARAM_DATA RX__MAYBE_UNUSED +#endif + +/* + Support compilers that checks printf-style functions. +*/ +#if defined(__GNUC__) + #define RX__PRINTF_CHECK(fmt, args) \ + __attribute__((format (printf, (fmt), (args)))) +#else + #define RX__PRINTF_CHECK(fmt, args) +#endif + +/* Public Interface O-(''Q) + -------------------------------------------------------------------------- */ + +#define RX_PARAM_CONTEXT rx__context +#define RX_PARAM_DATA rx__data + +#define RX_DATA RX_PARAM_DATA + +enum rx_status { + RX_SUCCESS = 0, + RX_ERROR = -1, + RX_ERROR_ABORTED = -2, + RX_ERROR_ALLOCATION = -3, + RX_ERROR_MAX_SIZE_EXCEEDED = -4 +}; + +enum rx_severity { RX_NONFATAL = 0, RX_FATAL = 1 }; + +enum rx_log_level { + RX_LOG_LEVEL_NONE = 0, + RX_LOG_LEVEL_FATAL = 1, + RX_LOG_LEVEL_ERROR = 3, + RX_LOG_LEVEL_WARNING = 4, + RX_LOG_LEVEL_INFO = 5, + RX_LOG_LEVEL_DEBUG = 6, + RX_LOG_LEVEL_ALL = RX_LOG_LEVEL_DEBUG +}; + +struct rx_context; + +typedef enum rx_status (*rx_set_up_fn)(RX__DEFINE_PARAMS(void)); +typedef void (*rx_tear_down_fn)(RX__DEFINE_PARAMS(void)); +typedef void (*rx_run_fn)(RX__DEFINE_PARAMS(void)); + +struct rx_fixture_config { + rx_set_up_fn set_up; + rx_tear_down_fn tear_down; +}; + +struct rx_fixture { + rx_size size; + struct rx_fixture_config config; +}; + +struct rx_test_case_config { + int skip; + struct rx_fixture fixture; +}; + +struct rx_test_case { + const char *suite_name; + const char *name; + rx_run_fn run; + struct rx_test_case_config config; +}; + +struct rx_failure { + const char *file; + int line; + enum rx_severity severity; + const char *msg; + const char *diagnostic_msg; +}; + +struct rx_summary { + const struct rx_test_case *test_case; + int skipped; + const char *error; + rx_size assessed_count; + rx_size failure_count; + struct rx_failure *failures; + rx_uint64 elapsed; +}; + +struct rx_summary_group { + rx_size count; + const struct rx_summary *array; +}; + +#if defined(__cplusplus) +extern "C" { +#endif + +RX__STORAGE void +rx_abort(struct rx_context *context); + +RX__STORAGE enum rx_status +rx_handle_test_result(struct rx_context *context, + int result, + const char *file, + int line, + enum rx_severity severity, + const char *failure_msg, + const char *diagnostic_msg); + +RX__STORAGE enum rx_status +rx_summary_initialize(struct rx_summary *summary, + const struct rx_test_case *test_case); + +RX__STORAGE void +rx_summary_terminate(struct rx_summary *summary); + +RX__STORAGE void +rx_summary_print(const struct rx_summary *summary); + +RX__STORAGE void +rx_sort_summaries_by_test_suite(struct rx_summary *summaries, + rx_size summary_count); + +RX__STORAGE void +rx_group_summaries_by_test_suite(rx_size *summary_group_count, + struct rx_summary_group *summary_groups, + rx_size summary_count, + const struct rx_summary *summaries); + +RX__STORAGE enum rx_status +rx_test_case_run(struct rx_summary *summary, + const struct rx_test_case *test_case); + +RX__STORAGE void +rx_enumerate_test_cases(rx_size *test_case_count, + struct rx_test_case *test_cases); + +RX__STORAGE enum rx_status +rx_run(rx_size test_case_count, const struct rx_test_case *test_cases); + +RX__STORAGE enum rx_status +rx_main(rx_size test_case_count, + const struct rx_test_case *test_cases, + int argc, + const char **argv); + +#if defined(__cplusplus) +} +#endif + +/* Helpers O-(''Q) + -------------------------------------------------------------------------- */ + +#define RX__LANG_C 0 +#define RX__LANG_CPP 1 + +#if defined(__cplusplus) + #define RX__LANG RX__LANG_CPP + #define RX__LANG_VERSION __cplusplus +#else + #define RX__LANG RX__LANG_C + #if defined(__STDC_VERSION__) + #define RX__LANG_VERSION __STDC_VERSION__ + #else + #define RX__LANG_VERSION 0L + #endif +#endif + +#if defined(RX_DISABLE_NPRINTF) \ + || (!defined(RX_ENABLE_NPRINTF) \ + && !defined(_MSC_VER) \ + && ((RX__LANG == RX__LANG_C && RX__LANG_VERSION < 199901L) \ + || (RX__LANG == RX__LANG_CPP && RX__LANG_VERSION < 201103L))) + #define RX__HAS_NPRINTF 0 +#else + #define RX__HAS_NPRINTF 1 +#endif + +#if defined(RX_DISABLE_VARIADIC_MACROS) \ + || (!defined(RX_ENABLE_VARIADIC_MACROS) \ + && !defined(_MSC_VER) \ + && ((RX__LANG == RX__LANG_C && RX__LANG_VERSION < 199901L) \ + || (RX__LANG == RX__LANG_CPP && RX__LANG_VERSION < 201103L))) + #define RX__HAS_VARIADIC_MACROS 0 +#else + #define RX__HAS_VARIADIC_MACROS 1 +#endif + +#define RX__FALSE ((int)0) +#define RX__TRUE ((int)1) + +/* Automatic Registration Framework O-(''Q) + -------------------------------------------------------------------------- */ + +#define RX_SET_UP(id) \ + static enum rx_status \ + id(RX__DEFINE_PARAMS(void)) + +#define RX_TEAR_DOWN(id) \ + static void \ + id(RX__DEFINE_PARAMS(void)) + +#if RX__HAS_VARIADIC_MACROS + #define RX_FIXTURE(...) \ + RX__EXPAND( \ + RX__CONCAT( \ + RX__FIXTURE_DISPATCH_, \ + RX__HAS_AT_LEAST_3_ARGS(__VA_ARGS__) \ + )(__VA_ARGS__)) \ + RX__REQUIRE_SEMICOLON + + #define RX__FIXTURE_DISPATCH_0(id, type) \ + RX__FIXTURE_0(id, sizeof(type)) + + #define RX__FIXTURE_DISPATCH_1(id, type, ...) \ + RX__FIXTURE_1(id, \ + sizeof(type), \ + RX__COUNT_ARGS(__VA_ARGS__), \ + (__VA_ARGS__)) +#else + #define RX_FIXTURE(id, type) \ + RX__FIXTURE_0(id, sizeof(type)) \ + RX__REQUIRE_SEMICOLON + + #define RX_FIXTURE_1(id, type, _0) \ + RX__FIXTURE_1(id, sizeof(type), 1, (_0)) \ + RX__REQUIRE_SEMICOLON + + #define RX_FIXTURE_2(id, type, _0, _1) \ + RX__FIXTURE_1(id, sizeof(type), 2, (_0, _1)) \ + RX__REQUIRE_SEMICOLON +#endif + +#if RX__HAS_VARIADIC_MACROS + #define RX_VOID_FIXTURE(...) \ + RX__EXPAND( \ + RX__CONCAT( \ + RX__VOID_FIXTURE_DISPATCH_, \ + RX__HAS_AT_LEAST_2_ARGS(__VA_ARGS__) \ + )(__VA_ARGS__)) \ + RX__REQUIRE_SEMICOLON + + #define RX__VOID_FIXTURE_DISPATCH_0(id) \ + RX__FIXTURE_0(id, 0) + + #define RX__VOID_FIXTURE_DISPATCH_1(id, ...) \ + RX__FIXTURE_1(id, \ + 0, \ + RX__COUNT_ARGS(__VA_ARGS__), \ + (__VA_ARGS__)) +#else + #define RX_VOID_FIXTURE(id) \ + RX__FIXTURE_0(id, 0) \ + RX__REQUIRE_SEMICOLON + + #define RX_VOID_FIXTURE_1(id, _0) \ + RX__FIXTURE_1(id, 0, 1, (_0)) \ + RX__REQUIRE_SEMICOLON + + #define RX_VOID_FIXTURE_2(id, _0, _1) \ + RX__FIXTURE_1(id, 0, 2, (_0, _1)) \ + RX__REQUIRE_SEMICOLON +#endif + +#if RX__HAS_VARIADIC_MACROS + #define RX_TEST_SUITE(...) \ + RX__EXPAND( \ + RX__CONCAT( \ + RX__TEST_SUITE_DISPATCH_, \ + RX__HAS_AT_LEAST_2_ARGS(__VA_ARGS__) \ + )(__VA_ARGS__)) \ + RX__REQUIRE_SEMICOLON + + #define RX__TEST_SUITE_DISPATCH_0(id) \ + RX__TEST_SUITE_0(id) + + #define RX__TEST_SUITE_DISPATCH_1(id, ...) \ + RX__TEST_SUITE_1(id, \ + RX__COUNT_ARGS(__VA_ARGS__), \ + (__VA_ARGS__)) +#else + #define RX_TEST_SUITE(id) \ + RX__TEST_SUITE_0(id) \ + RX__REQUIRE_SEMICOLON + + #define RX_TEST_SUITE_1(id, _0) \ + RX__TEST_SUITE_1(id, 1, (_0)) \ + RX__REQUIRE_SEMICOLON + + #define RX_TEST_SUITE_2(id, _0, _1) \ + RX__TEST_SUITE_1(id, 2, (_0, _1)) \ + RX__REQUIRE_SEMICOLON +#endif + +#if RX__HAS_VARIADIC_MACROS + #define RX_TEST_CASE(...) \ + RX__EXPAND( \ + RX__CONCAT( \ + RX__TEST_CASE_DISPATCH_, \ + RX__HAS_AT_LEAST_3_ARGS(__VA_ARGS__) \ + )(__VA_ARGS__)) + + #define RX__TEST_CASE_DISPATCH_0(suite_id, id) \ + RX__TEST_CASE_0(suite_id, id) + + #define RX__TEST_CASE_DISPATCH_1(suite_id, id, ...) \ + RX__TEST_CASE_1(suite_id, \ + id, \ + RX__COUNT_ARGS(__VA_ARGS__), \ + (__VA_ARGS__)) +#else + #define RX_TEST_CASE(suite_id, id) \ + RX__TEST_CASE_0(suite_id, id) + + #define RX_TEST_CASE_1(suite_id, id, _0) \ + RX__TEST_CASE_1(suite_id, id, 1, (_0)) + + #define RX_TEST_CASE_2(suite_id, id, _0, _1) \ + RX__TEST_CASE_1(suite_id, id, 2, (_0, _1)) +#endif + +/* Generic Assertions O-(''Q) + -------------------------------------------------------------------------- */ + +#if RX__HAS_VARIADIC_MACROS + #define RX__DEFINE_TEST(severity, expected, condition, ...) \ + rx__assess_value(RX_PARAM_CONTEXT, \ + !!(condition), \ + expected, \ + #condition, \ + __FILE__, \ + __LINE__, \ + severity, \ + __VA_ARGS__) +#else + #define RX__DEFINE_TEST(severity, expected, condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + rx__assess_value(RX_PARAM_CONTEXT, \ + !!(condition), \ + expected, \ + #condition, \ + __FILE__, \ + __LINE__, \ + severity, \ + msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) +#endif + +#define RX_REQUIRE(condition) \ + RX_REQUIRE_MSG(condition, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_REQUIRE_MSG(condition, ...) \ + RX__DEFINE_TEST(RX_FATAL, RX__TRUE, condition, __VA_ARGS__) +#else + #define RX_REQUIRE_MSG(condition, msg) \ + RX__DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_REQUIRE_MSG_1(condition, msg, \ + _0) \ + RX__DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REQUIRE_MSG_2(condition, msg, \ + _0, _1) \ + RX__DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REQUIRE_MSG_3(condition, msg, \ + _0, _1, _2) \ + RX__DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_REQUIRE_MSG_4(condition, msg, \ + _0, _1, _2, _3) \ + RX__DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_REQUIRE_MSG_5(condition, msg, \ + _0, _1, _2, _3, _4) \ + RX__DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_REQUIRE_MSG_6(condition, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_REQUIRE_MSG_7(condition, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_REQUIRE_MSG_8(condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_CHECK(condition) \ + RX_CHECK_MSG(condition, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_CHECK_MSG(condition, ...) \ + RX__DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, __VA_ARGS__) +#else + #define RX_CHECK_MSG(condition, msg) \ + RX__DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_CHECK_MSG_1(condition, msg, \ + _0) \ + RX__DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_CHECK_MSG_2(condition, msg, \ + _0, _1) \ + RX__DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_CHECK_MSG_3(condition, msg, \ + _0, _1, _2) \ + RX__DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_CHECK_MSG_4(condition, msg, \ + _0, _1, _2, _3) \ + RX__DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_CHECK_MSG_5(condition, msg, \ + _0, _1, _2, _3, _4) \ + RX__DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_CHECK_MSG_6(condition, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_CHECK_MSG_7(condition, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_CHECK_MSG_8(condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + + +/* Boolean Assertions O-(''Q) + -------------------------------------------------------------------------- */ + +#if RX__HAS_VARIADIC_MACROS + #define RX__BOOL_DEFINE_TEST(severity, expected, condition, ...) \ + rx__bool_assess_value(RX_PARAM_CONTEXT, \ + !!(condition), \ + expected, \ + #condition, \ + __FILE__, \ + __LINE__, \ + severity, \ + __VA_ARGS__) +#else + #define RX__BOOL_DEFINE_TEST(severity, expected, condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + rx__bool_assess_value(RX_PARAM_CONTEXT, \ + !!(condition), \ + expected, \ + #condition, \ + __FILE__, \ + __LINE__, \ + severity, \ + msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) +#endif + +#define RX_BOOL_REQUIRE_TRUE(condition) \ + RX_BOOL_REQUIRE_TRUE_MSG(condition, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_BOOL_REQUIRE_TRUE_MSG(condition, ...) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__TRUE, condition, __VA_ARGS__) +#else + #define RX_BOOL_REQUIRE_TRUE_MSG(condition, msg) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_BOOL_REQUIRE_TRUE_MSG_1(condition, msg, \ + _0) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_BOOL_REQUIRE_TRUE_MSG_2(condition, msg, \ + _0, _1) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_BOOL_REQUIRE_TRUE_MSG_3(condition, msg, \ + _0, _1, _2) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_BOOL_REQUIRE_TRUE_MSG_4(condition, msg, \ + _0, _1, _2, _3) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_BOOL_REQUIRE_TRUE_MSG_5(condition, msg, \ + _0, _1, _2, _3, _4) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_BOOL_REQUIRE_TRUE_MSG_6(condition, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_BOOL_REQUIRE_TRUE_MSG_7(condition, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_BOOL_REQUIRE_TRUE_MSG_8(condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_BOOL_CHECK_TRUE(condition) \ + RX_BOOL_CHECK_TRUE_MSG(condition, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_BOOL_CHECK_TRUE_MSG(condition, ...) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, __VA_ARGS__) +#else + #define RX_BOOL_CHECK_TRUE_MSG(condition, msg) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_BOOL_CHECK_TRUE_MSG_1(condition, msg, \ + _0) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_BOOL_CHECK_TRUE_MSG_2(condition, msg, \ + _0, _1) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_BOOL_CHECK_TRUE_MSG_3(condition, msg, \ + _0, _1, _2) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_BOOL_CHECK_TRUE_MSG_4(condition, msg, \ + _0, _1, _2, _3) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_BOOL_CHECK_TRUE_MSG_5(condition, msg, \ + _0, _1, _2, _3, _4) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_BOOL_CHECK_TRUE_MSG_6(condition, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_BOOL_CHECK_TRUE_MSG_7(condition, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_BOOL_CHECK_TRUE_MSG_8(condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__TRUE, condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_BOOL_REQUIRE_FALSE(condition) \ + RX_BOOL_REQUIRE_FALSE_MSG(condition, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_BOOL_REQUIRE_FALSE_MSG(condition, ...) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__FALSE, condition, __VA_ARGS__) +#else + #define RX_BOOL_REQUIRE_FALSE_MSG(condition, msg) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__FALSE, condition, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_BOOL_REQUIRE_FALSE_MSG_1(condition, msg, \ + _0) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__FALSE, condition, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_BOOL_REQUIRE_FALSE_MSG_2(condition, msg, \ + _0, _1) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__FALSE, condition, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_BOOL_REQUIRE_FALSE_MSG_3(condition, msg, \ + _0, _1, _2) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__FALSE, condition, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_BOOL_REQUIRE_FALSE_MSG_4(condition, msg, \ + _0, _1, _2, _3) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__FALSE, condition, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_BOOL_REQUIRE_FALSE_MSG_5(condition, msg, \ + _0, _1, _2, _3, _4) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__FALSE, condition, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_BOOL_REQUIRE_FALSE_MSG_6(condition, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__FALSE, condition, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_BOOL_REQUIRE_FALSE_MSG_7(condition, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__FALSE, condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_BOOL_REQUIRE_FALSE_MSG_8(condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__BOOL_DEFINE_TEST(RX_FATAL, RX__FALSE, condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_BOOL_CHECK_FALSE(condition) \ + RX_BOOL_CHECK_FALSE_MSG(condition, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_BOOL_CHECK_FALSE_MSG(condition, ...) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__FALSE, condition, __VA_ARGS__) +#else + #define RX_BOOL_CHECK_FALSE_MSG(condition, msg) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__FALSE, condition, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_BOOL_CHECK_FALSE_MSG_1(condition, msg, \ + _0) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__FALSE, condition, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_BOOL_CHECK_FALSE_MSG_2(condition, msg, \ + _0, _1) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__FALSE, condition, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_BOOL_CHECK_FALSE_MSG_3(condition, msg, \ + _0, _1, _2) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__FALSE, condition, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_BOOL_CHECK_FALSE_MSG_4(condition, msg, \ + _0, _1, _2, _3) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__FALSE, condition, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_BOOL_CHECK_FALSE_MSG_5(condition, msg, \ + _0, _1, _2, _3, _4) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__FALSE, condition, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_BOOL_CHECK_FALSE_MSG_6(condition, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__FALSE, condition, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_BOOL_CHECK_FALSE_MSG_7(condition, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__FALSE, condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_BOOL_CHECK_FALSE_MSG_8(condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__BOOL_DEFINE_TEST(RX_NONFATAL, RX__FALSE, condition, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +/* Integer Assertions O-(''Q) + -------------------------------------------------------------------------- */ + +#if RX__HAS_VARIADIC_MACROS + #define RX__INT_DEFINE_TEST(severity, op, x1, x2, ...) \ + rx__int_assess_comparison(RX_PARAM_CONTEXT, \ + (x1), \ + (x2), \ + op, \ + #x1, \ + #x2, \ + __FILE__, \ + __LINE__, \ + severity, \ + __VA_ARGS__) +#else + #define RX__INT_DEFINE_TEST(severity, op, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + rx__int_assess_comparison(RX_PARAM_CONTEXT, \ + (x1), \ + (x2), \ + op, \ + #x1, \ + #x2, \ + __FILE__, \ + __LINE__, \ + severity, \ + msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) +#endif + +#define RX_INT_REQUIRE_EQUAL(x1, x2) \ + RX_INT_REQUIRE_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_INT_REQUIRE_EQUAL_MSG(x1, x2, ...) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, __VA_ARGS__) +#else + #define RX_INT_REQUIRE_EQUAL_MSG(x1, x2, msg) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_INT_REQUIRE_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_INT_REQUIRE_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_INT_REQUIRE_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_INT_CHECK_EQUAL(x1, x2) \ + RX_INT_CHECK_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_INT_CHECK_EQUAL_MSG(x1, x2, ...) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, __VA_ARGS__) +#else + #define RX_INT_CHECK_EQUAL_MSG(x1, x2, msg) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_INT_CHECK_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_INT_CHECK_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_INT_CHECK_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_INT_CHECK_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_INT_REQUIRE_NOT_EQUAL(x1, x2) \ + RX_INT_REQUIRE_NOT_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_INT_REQUIRE_NOT_EQUAL_MSG(x1, x2, ...) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, __VA_ARGS__) +#else + #define RX_INT_REQUIRE_NOT_EQUAL_MSG(x1, x2, msg) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_INT_REQUIRE_NOT_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_NOT_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_NOT_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_NOT_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_NOT_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_NOT_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_INT_REQUIRE_NOT_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_INT_REQUIRE_NOT_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_INT_CHECK_NOT_EQUAL(x1, x2) \ + RX_INT_CHECK_NOT_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_INT_CHECK_NOT_EQUAL_MSG(x1, x2, ...) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, __VA_ARGS__) +#else + #define RX_INT_CHECK_NOT_EQUAL_MSG(x1, x2, msg) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_INT_CHECK_NOT_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_NOT_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_NOT_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_NOT_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_NOT_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_INT_CHECK_NOT_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_INT_CHECK_NOT_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_INT_CHECK_NOT_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_INT_REQUIRE_GREATER(x1, x2) \ + RX_INT_REQUIRE_GREATER_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_INT_REQUIRE_GREATER_MSG(x1, x2, ...) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, __VA_ARGS__) +#else + #define RX_INT_REQUIRE_GREATER_MSG(x1, x2, msg) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_INT_REQUIRE_GREATER_MSG_1(x1, x2, msg, \ + _0) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_GREATER_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_GREATER_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_GREATER_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_GREATER_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_GREATER_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_INT_REQUIRE_GREATER_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_INT_REQUIRE_GREATER_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_INT_CHECK_GREATER(x1, x2) \ + RX_INT_CHECK_GREATER_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_INT_CHECK_GREATER_MSG(x1, x2, ...) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, __VA_ARGS__) +#else + #define RX_INT_CHECK_GREATER_MSG(x1, x2, msg) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_INT_CHECK_GREATER_MSG_1(x1, x2, msg, \ + _0) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_GREATER_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_GREATER_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_GREATER_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_GREATER_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_INT_CHECK_GREATER_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_INT_CHECK_GREATER_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_INT_CHECK_GREATER_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_INT_REQUIRE_LESSER(x1, x2) \ + RX_INT_REQUIRE_LESSER_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_INT_REQUIRE_LESSER_MSG(x1, x2, ...) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, __VA_ARGS__) +#else + #define RX_INT_REQUIRE_LESSER_MSG(x1, x2, msg) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_INT_REQUIRE_LESSER_MSG_1(x1, x2, msg, \ + _0) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_LESSER_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_LESSER_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_LESSER_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_LESSER_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_LESSER_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_INT_REQUIRE_LESSER_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_INT_REQUIRE_LESSER_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_INT_CHECK_LESSER(x1, x2) \ + RX_INT_CHECK_LESSER_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_INT_CHECK_LESSER_MSG(x1, x2, ...) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, __VA_ARGS__) +#else + #define RX_INT_CHECK_LESSER_MSG(x1, x2, msg) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_INT_CHECK_LESSER_MSG_1(x1, x2, msg, \ + _0) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_LESSER_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_LESSER_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_LESSER_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_LESSER_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_INT_CHECK_LESSER_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_INT_CHECK_LESSER_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_INT_CHECK_LESSER_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_INT_REQUIRE_GREATER_OR_EQUAL(x1, x2) \ + RX_INT_REQUIRE_GREATER_OR_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_INT_REQUIRE_GREATER_OR_EQUAL_MSG(x1, x2, ...) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, \ + __VA_ARGS__) +#else + #define RX_INT_REQUIRE_GREATER_OR_EQUAL_MSG(x1, x2, msg) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_INT_REQUIRE_GREATER_OR_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_GREATER_OR_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_GREATER_OR_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_GREATER_OR_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_GREATER_OR_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_GREATER_OR_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_INT_REQUIRE_GREATER_OR_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_INT_REQUIRE_GREATER_OR_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_INT_CHECK_GREATER_OR_EQUAL(x1, x2) \ + RX_INT_CHECK_GREATER_OR_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_INT_CHECK_GREATER_OR_EQUAL_MSG(x1, x2, ...) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, \ + __VA_ARGS__) +#else + #define RX_INT_CHECK_GREATER_OR_EQUAL_MSG(x1, x2, msg) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_INT_CHECK_GREATER_OR_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_GREATER_OR_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_GREATER_OR_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_GREATER_OR_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_GREATER_OR_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_INT_CHECK_GREATER_OR_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_INT_CHECK_GREATER_OR_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_INT_CHECK_GREATER_OR_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_INT_REQUIRE_LESSER_OR_EQUAL(x1, x2) \ + RX_INT_REQUIRE_LESSER_OR_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_INT_REQUIRE_LESSER_OR_EQUAL_MSG(x1, x2, ...) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, \ + __VA_ARGS__) +#else + #define RX_INT_REQUIRE_LESSER_OR_EQUAL_MSG(x1, x2, msg) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_INT_REQUIRE_LESSER_OR_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_LESSER_OR_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_LESSER_OR_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_LESSER_OR_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_LESSER_OR_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_INT_REQUIRE_LESSER_OR_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_INT_REQUIRE_LESSER_OR_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_INT_REQUIRE_LESSER_OR_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__INT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_INT_CHECK_LESSER_OR_EQUAL(x1, x2) \ + RX_INT_CHECK_LESSER_OR_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_INT_CHECK_LESSER_OR_EQUAL_MSG(x1, x2, ...) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, \ + __VA_ARGS__) +#else + #define RX_INT_CHECK_LESSER_OR_EQUAL_MSG(x1, x2, msg) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_INT_CHECK_LESSER_OR_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_LESSER_OR_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_LESSER_OR_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_LESSER_OR_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_INT_CHECK_LESSER_OR_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_INT_CHECK_LESSER_OR_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_INT_CHECK_LESSER_OR_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_INT_CHECK_LESSER_OR_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__INT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +/* Unsigned Integer Assertions O-(''Q) + -------------------------------------------------------------------------- */ + +#if RX__HAS_VARIADIC_MACROS + #define RX__UINT_DEFINE_TEST(severity, op, x1, x2, ...) \ + rx__uint_assess_comparison(RX_PARAM_CONTEXT, \ + (x1), \ + (x2), \ + op, \ + #x1, \ + #x2, \ + __FILE__, \ + __LINE__, \ + severity, \ + __VA_ARGS__) +#else + #define RX__UINT_DEFINE_TEST(severity, op, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + rx__uint_assess_comparison(RX_PARAM_CONTEXT, \ + (x1), \ + (x2), \ + op, \ + #x1, \ + #x2, \ + __FILE__, \ + __LINE__, \ + severity, \ + msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) +#endif + +#define RX_UINT_REQUIRE_EQUAL(x1, x2) \ + RX_UINT_REQUIRE_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_UINT_REQUIRE_EQUAL_MSG(x1, x2, ...) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, __VA_ARGS__) +#else + #define RX_UINT_REQUIRE_EQUAL_MSG(x1, x2, msg) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_UINT_REQUIRE_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_UINT_REQUIRE_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_UINT_REQUIRE_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_UINT_CHECK_EQUAL(x1, x2) \ + RX_UINT_CHECK_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_UINT_CHECK_EQUAL_MSG(x1, x2, ...) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, __VA_ARGS__) +#else + #define RX_UINT_CHECK_EQUAL_MSG(x1, x2, msg) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_UINT_CHECK_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_UINT_CHECK_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_UINT_CHECK_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_UINT_CHECK_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_UINT_REQUIRE_NOT_EQUAL(x1, x2) \ + RX_UINT_REQUIRE_NOT_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_UINT_REQUIRE_NOT_EQUAL_MSG(x1, x2, ...) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, __VA_ARGS__) +#else + #define RX_UINT_REQUIRE_NOT_EQUAL_MSG(x1, x2, msg) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_UINT_REQUIRE_NOT_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_NOT_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_NOT_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_NOT_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_NOT_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_NOT_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_UINT_REQUIRE_NOT_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_UINT_REQUIRE_NOT_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_UINT_CHECK_NOT_EQUAL(x1, x2) \ + RX_UINT_CHECK_NOT_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_UINT_CHECK_NOT_EQUAL_MSG(x1, x2, ...) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, __VA_ARGS__) +#else + #define RX_UINT_CHECK_NOT_EQUAL_MSG(x1, x2, msg) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_UINT_CHECK_NOT_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_NOT_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_NOT_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_NOT_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_NOT_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_UINT_CHECK_NOT_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_UINT_CHECK_NOT_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_UINT_CHECK_NOT_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_UINT_REQUIRE_GREATER(x1, x2) \ + RX_UINT_REQUIRE_GREATER_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_UINT_REQUIRE_GREATER_MSG(x1, x2, ...) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, __VA_ARGS__) +#else + #define RX_UINT_REQUIRE_GREATER_MSG(x1, x2, msg) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_UINT_REQUIRE_GREATER_MSG_1(x1, x2, msg, \ + _0) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_GREATER_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_GREATER_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_GREATER_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_GREATER_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_GREATER_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_UINT_REQUIRE_GREATER_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_UINT_REQUIRE_GREATER_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_UINT_CHECK_GREATER(x1, x2) \ + RX_UINT_CHECK_GREATER_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_UINT_CHECK_GREATER_MSG(x1, x2, ...) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, __VA_ARGS__) +#else + #define RX_UINT_CHECK_GREATER_MSG(x1, x2, msg) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_UINT_CHECK_GREATER_MSG_1(x1, x2, msg, \ + _0) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_GREATER_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_GREATER_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_GREATER_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_GREATER_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_UINT_CHECK_GREATER_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_UINT_CHECK_GREATER_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_UINT_CHECK_GREATER_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_UINT_REQUIRE_LESSER(x1, x2) \ + RX_UINT_REQUIRE_LESSER_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_UINT_REQUIRE_LESSER_MSG(x1, x2, ...) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, __VA_ARGS__) +#else + #define RX_UINT_REQUIRE_LESSER_MSG(x1, x2, msg) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_UINT_REQUIRE_LESSER_MSG_1(x1, x2, msg, \ + _0) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_LESSER_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_LESSER_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_LESSER_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_LESSER_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_LESSER_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_UINT_REQUIRE_LESSER_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_UINT_REQUIRE_LESSER_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_UINT_CHECK_LESSER(x1, x2) \ + RX_UINT_CHECK_LESSER_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_UINT_CHECK_LESSER_MSG(x1, x2, ...) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, __VA_ARGS__) +#else + #define RX_UINT_CHECK_LESSER_MSG(x1, x2, msg) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_UINT_CHECK_LESSER_MSG_1(x1, x2, msg, \ + _0) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_LESSER_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_LESSER_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_LESSER_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_LESSER_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_UINT_CHECK_LESSER_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_UINT_CHECK_LESSER_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_UINT_CHECK_LESSER_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_UINT_REQUIRE_GREATER_OR_EQUAL(x1, x2) \ + RX_UINT_REQUIRE_GREATER_OR_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_UINT_REQUIRE_GREATER_OR_EQUAL_MSG(x1, x2, ...) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, \ + __VA_ARGS__) +#else + #define RX_UINT_REQUIRE_GREATER_OR_EQUAL_MSG(x1, x2, msg) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_UINT_REQUIRE_GREATER_OR_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_GREATER_OR_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_GREATER_OR_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_GREATER_OR_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_GREATER_OR_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_GREATER_OR_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_UINT_REQUIRE_GREATER_OR_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_UINT_REQUIRE_GREATER_OR_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_UINT_CHECK_GREATER_OR_EQUAL(x1, x2) \ + RX_UINT_CHECK_GREATER_OR_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_UINT_CHECK_GREATER_OR_EQUAL_MSG(x1, x2, ...) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, \ + __VA_ARGS__) +#else + #define RX_UINT_CHECK_GREATER_OR_EQUAL_MSG(x1, x2, msg) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg,\ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_UINT_CHECK_GREATER_OR_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_GREATER_OR_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_GREATER_OR_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_GREATER_OR_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_GREATER_OR_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_UINT_CHECK_GREATER_OR_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_UINT_CHECK_GREATER_OR_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_UINT_CHECK_GREATER_OR_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_UINT_REQUIRE_LESSER_OR_EQUAL(x1, x2) \ + RX_UINT_REQUIRE_LESSER_OR_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_UINT_REQUIRE_LESSER_OR_EQUAL_MSG(x1, x2, ...) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, \ + __VA_ARGS__) +#else + #define RX_UINT_REQUIRE_LESSER_OR_EQUAL_MSG(x1, x2, msg) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_UINT_REQUIRE_LESSER_OR_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_LESSER_OR_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_LESSER_OR_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_LESSER_OR_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_LESSER_OR_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_UINT_REQUIRE_LESSER_OR_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_UINT_REQUIRE_LESSER_OR_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_UINT_REQUIRE_LESSER_OR_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__UINT_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_UINT_CHECK_LESSER_OR_EQUAL(x1, x2) \ + RX_UINT_CHECK_LESSER_OR_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_UINT_CHECK_LESSER_OR_EQUAL_MSG(x1, x2, ...) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, \ + __VA_ARGS__) +#else + #define RX_UINT_CHECK_LESSER_OR_EQUAL_MSG(x1, x2, msg) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_UINT_CHECK_LESSER_OR_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_LESSER_OR_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_LESSER_OR_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_LESSER_OR_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_UINT_CHECK_LESSER_OR_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_UINT_CHECK_LESSER_OR_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_UINT_CHECK_LESSER_OR_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_UINT_CHECK_LESSER_OR_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__UINT_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +/* Floating-Point Assertions O-(''Q) + -------------------------------------------------------------------------- */ + +#if RX__HAS_VARIADIC_MACROS + #define RX__REAL_DEFINE_TEST(severity, op, x1, x2, ...) \ + rx__real_assess_comparison(RX_PARAM_CONTEXT, \ + (x1), \ + (x2), \ + op, \ + #x1, \ + #x2, \ + __FILE__, \ + __LINE__, \ + severity, \ + __VA_ARGS__) +#else + #define RX__REAL_DEFINE_TEST(severity, op, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + rx__real_assess_comparison(RX_PARAM_CONTEXT, \ + (x1), \ + (x2), \ + op, \ + #x1, \ + #x2, \ + __FILE__, \ + __LINE__, \ + severity, \ + msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) +#endif + +#define RX_REAL_REQUIRE_EQUAL(x1, x2) \ + RX_REAL_REQUIRE_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_REAL_REQUIRE_EQUAL_MSG(x1, x2, ...) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, __VA_ARGS__) +#else + #define RX_REAL_REQUIRE_EQUAL_MSG(x1, x2, msg) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_REAL_REQUIRE_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_REAL_REQUIRE_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_REAL_REQUIRE_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_REAL_CHECK_EQUAL(x1, x2) \ + RX_REAL_CHECK_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_REAL_CHECK_EQUAL_MSG(x1, x2, ...) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, __VA_ARGS__) +#else + #define RX_REAL_CHECK_EQUAL_MSG(x1, x2, msg) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_REAL_CHECK_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_REAL_CHECK_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_REAL_CHECK_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_REAL_CHECK_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_REAL_REQUIRE_NOT_EQUAL(x1, x2) \ + RX_REAL_REQUIRE_NOT_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_REAL_REQUIRE_NOT_EQUAL_MSG(x1, x2, ...) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, __VA_ARGS__) +#else + #define RX_REAL_REQUIRE_NOT_EQUAL_MSG(x1, x2, msg) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_REAL_REQUIRE_NOT_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_NOT_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_NOT_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_NOT_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_NOT_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_NOT_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_REAL_REQUIRE_NOT_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_REAL_REQUIRE_NOT_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_REAL_CHECK_NOT_EQUAL(x1, x2) \ + RX_REAL_CHECK_NOT_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_REAL_CHECK_NOT_EQUAL_MSG(x1, x2, ...) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, __VA_ARGS__) +#else + #define RX_REAL_CHECK_NOT_EQUAL_MSG(x1, x2, msg) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_REAL_CHECK_NOT_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_NOT_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_NOT_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_NOT_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_NOT_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_REAL_CHECK_NOT_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_REAL_CHECK_NOT_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_REAL_CHECK_NOT_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_REAL_REQUIRE_GREATER(x1, x2) \ + RX_REAL_REQUIRE_GREATER_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_REAL_REQUIRE_GREATER_MSG(x1, x2, ...) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, __VA_ARGS__) +#else + #define RX_REAL_REQUIRE_GREATER_MSG(x1, x2, msg) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_REAL_REQUIRE_GREATER_MSG_1(x1, x2, msg, \ + _0) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_GREATER_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_GREATER_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_GREATER_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_GREATER_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_GREATER_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_REAL_REQUIRE_GREATER_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_REAL_REQUIRE_GREATER_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_REAL_CHECK_GREATER(x1, x2) \ + RX_REAL_CHECK_GREATER_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_REAL_CHECK_GREATER_MSG(x1, x2, ...) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, __VA_ARGS__) +#else + #define RX_REAL_CHECK_GREATER_MSG(x1, x2, msg) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_REAL_CHECK_GREATER_MSG_1(x1, x2, msg, \ + _0) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_GREATER_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_GREATER_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_GREATER_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_GREATER_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_REAL_CHECK_GREATER_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_REAL_CHECK_GREATER_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_REAL_CHECK_GREATER_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_REAL_REQUIRE_LESSER(x1, x2) \ + RX_REAL_REQUIRE_LESSER_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_REAL_REQUIRE_LESSER_MSG(x1, x2, ...) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, __VA_ARGS__) +#else + #define RX_REAL_REQUIRE_LESSER_MSG(x1, x2, msg) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_REAL_REQUIRE_LESSER_MSG_1(x1, x2, msg, \ + _0) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_LESSER_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_LESSER_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_LESSER_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_LESSER_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_LESSER_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_REAL_REQUIRE_LESSER_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_REAL_REQUIRE_LESSER_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_REAL_CHECK_LESSER(x1, x2) \ + RX_REAL_CHECK_LESSER_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_REAL_CHECK_LESSER_MSG(x1, x2, ...) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, __VA_ARGS__) +#else + #define RX_REAL_CHECK_LESSER_MSG(x1, x2, msg) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_REAL_CHECK_LESSER_MSG_1(x1, x2, msg, \ + _0) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_LESSER_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_LESSER_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_LESSER_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_LESSER_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_REAL_CHECK_LESSER_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_REAL_CHECK_LESSER_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_REAL_CHECK_LESSER_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_REAL_REQUIRE_GREATER_OR_EQUAL(x1, x2) \ + RX_REAL_REQUIRE_GREATER_OR_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_REAL_REQUIRE_GREATER_OR_EQUAL_MSG(x1, x2, ...) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, \ + __VA_ARGS__) +#else + #define RX_REAL_REQUIRE_GREATER_OR_EQUAL_MSG(x1, x2, msg) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_REAL_REQUIRE_GREATER_OR_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_GREATER_OR_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_GREATER_OR_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_GREATER_OR_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_GREATER_OR_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_GREATER_OR_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_REAL_REQUIRE_GREATER_OR_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_REAL_REQUIRE_GREATER_OR_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_REAL_CHECK_GREATER_OR_EQUAL(x1, x2) \ + RX_REAL_CHECK_GREATER_OR_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_REAL_CHECK_GREATER_OR_EQUAL_MSG(x1, x2, ...) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, \ + __VA_ARGS__) +#else + #define RX_REAL_CHECK_GREATER_OR_EQUAL_MSG(x1, x2, msg) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg,\ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_REAL_CHECK_GREATER_OR_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_GREATER_OR_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_GREATER_OR_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_GREATER_OR_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_GREATER_OR_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_REAL_CHECK_GREATER_OR_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_REAL_CHECK_GREATER_OR_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_REAL_CHECK_GREATER_OR_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_GREATER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_REAL_REQUIRE_LESSER_OR_EQUAL(x1, x2) \ + RX_REAL_REQUIRE_LESSER_OR_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_REAL_REQUIRE_LESSER_OR_EQUAL_MSG(x1, x2, ...) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, \ + __VA_ARGS__) +#else + #define RX_REAL_REQUIRE_LESSER_OR_EQUAL_MSG(x1, x2, msg) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_REAL_REQUIRE_LESSER_OR_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_LESSER_OR_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_LESSER_OR_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_LESSER_OR_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_LESSER_OR_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_LESSER_OR_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_REAL_REQUIRE_LESSER_OR_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_REAL_REQUIRE_LESSER_OR_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__REAL_DEFINE_TEST(RX_FATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_REAL_CHECK_LESSER_OR_EQUAL(x1, x2) \ + RX_REAL_CHECK_LESSER_OR_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_REAL_CHECK_LESSER_OR_EQUAL_MSG(x1, x2, ...) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, \ + __VA_ARGS__) +#else + #define RX_REAL_CHECK_LESSER_OR_EQUAL_MSG(x1, x2, msg) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_REAL_CHECK_LESSER_OR_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_LESSER_OR_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_LESSER_OR_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_LESSER_OR_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_LESSER_OR_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_REAL_CHECK_LESSER_OR_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_REAL_CHECK_LESSER_OR_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_REAL_CHECK_LESSER_OR_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__REAL_DEFINE_TEST(RX_NONFATAL, RX__OP_LESSER_OR_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#if RX__HAS_VARIADIC_MACROS + #define RX__REAL_DEFINE_FUZZY_TEST(severity, op, x1, x2, tol, ...) \ + rx__real_assess_fuzzy_comparison(RX_PARAM_CONTEXT, \ + (x1), \ + (x2), \ + (tol), \ + op, \ + #x1, \ + #x2, \ + __FILE__, \ + __LINE__, \ + severity, \ + __VA_ARGS__) +#else + #define RX__REAL_DEFINE_FUZZY_TEST(severity, op, x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + rx__real_assess_fuzzy_comparison(RX_PARAM_CONTEXT, \ + (x1), \ + (x2), \ + (tol), \ + op, \ + #x1, \ + #x2, \ + __FILE__, \ + __LINE__, \ + severity, \ + msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) +#endif + +#define RX_REAL_REQUIRE_FUZZY_EQUAL(x1, x2, tol) \ + RX_REAL_REQUIRE_FUZZY_EQUAL_MSG(x1, x2, tol, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_REAL_REQUIRE_FUZZY_EQUAL_MSG(x1, x2, tol, ...) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, tol, \ + __VA_ARGS__) +#else + #define RX_REAL_REQUIRE_FUZZY_EQUAL_MSG(x1, x2, tol, msg) \ + RX__REAL_DEFINE_FUZZY_TEST( \ + RX_FATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_REAL_REQUIRE_FUZZY_EQUAL_MSG_1(x1, x2, tol, msg, \ + _0) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_FUZZY_EQUAL_MSG_2(x1, x2, tol, msg, \ + _0, _1) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_FUZZY_EQUAL_MSG_3(x1, x2, tol, msg, \ + _0, _1, _2) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_FUZZY_EQUAL_MSG_4(x1, x2, tol, msg, \ + _0, _1, _2, _3) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_FUZZY_EQUAL_MSG_5(x1, x2, tol, msg, \ + _0, _1, _2, _3, _4) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_FUZZY_EQUAL_MSG_6(x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_REAL_REQUIRE_FUZZY_EQUAL_MSG_7(x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_REAL_REQUIRE_FUZZY_EQUAL_MSG_8(x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_REAL_CHECK_FUZZY_EQUAL(x1, x2, tol) \ + RX_REAL_CHECK_FUZZY_EQUAL_MSG(x1, x2, tol, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_REAL_CHECK_FUZZY_EQUAL_MSG(x1, x2, tol, ...) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, tol, \ + __VA_ARGS__) +#else + #define RX_REAL_CHECK_FUZZY_EQUAL_MSG(x1, x2, tol, msg) \ + RX__REAL_DEFINE_FUZZY_TEST( \ + RX_NONFATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_REAL_CHECK_FUZZY_EQUAL_MSG_1(x1, x2, tol, msg, \ + _0) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_FUZZY_EQUAL_MSG_2(x1, x2, tol, msg, \ + _0, _1) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_FUZZY_EQUAL_MSG_3(x1, x2, tol, msg, \ + _0, _1, _2) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_FUZZY_EQUAL_MSG_4(x1, x2, tol, msg, \ + _0, _1, _2, _3) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_FUZZY_EQUAL_MSG_5(x1, x2, tol, msg, \ + _0, _1, _2, _3, _4) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_REAL_CHECK_FUZZY_EQUAL_MSG_6(x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_REAL_CHECK_FUZZY_EQUAL_MSG_7(x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_REAL_CHECK_FUZZY_EQUAL_MSG_8(x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_REAL_REQUIRE_FUZZY_NOT_EQUAL(x1, x2, tol) \ + RX_REAL_REQUIRE_FUZZY_NOT_EQUAL_MSG(x1, x2, tol, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_REAL_REQUIRE_FUZZY_NOT_EQUAL_MSG(x1, x2, tol, ...) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, tol, \ + __VA_ARGS__) +#else + #define RX_REAL_REQUIRE_FUZZY_NOT_EQUAL_MSG(x1, x2, tol, msg) \ + RX__REAL_DEFINE_FUZZY_TEST( \ + RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_REAL_REQUIRE_FUZZY_NOT_EQUAL_MSG_1(x1, x2, tol, msg, \ + _0) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_FUZZY_NOT_EQUAL_MSG_2(x1, x2, tol, msg, \ + _0, _1) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_FUZZY_NOT_EQUAL_MSG_3(x1, x2, tol, msg, \ + _0, _1, _2) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_FUZZY_NOT_EQUAL_MSG_4(x1, x2, tol, msg, \ + _0, _1, _2, _3) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_FUZZY_NOT_EQUAL_MSG_5(x1, x2, tol, msg, \ + _0, _1, _2, _3, _4) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_REAL_REQUIRE_FUZZY_NOT_EQUAL_MSG_6(x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_REAL_REQUIRE_FUZZY_NOT_EQUAL_MSG_7(x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_REAL_REQUIRE_FUZZY_NOT_EQUAL_MSG_8(x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_REAL_CHECK_FUZZY_NOT_EQUAL(x1, x2, tol) \ + RX_REAL_CHECK_FUZZY_NOT_EQUAL_MSG(x1, x2, tol, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_REAL_CHECK_FUZZY_NOT_EQUAL_MSG(x1, x2, tol, ...) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, tol, \ + __VA_ARGS__) +#else + #define RX_REAL_CHECK_FUZZY_NOT_EQUAL_MSG(x1, x2, tol, msg) \ + RX__REAL_DEFINE_FUZZY_TEST( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_REAL_CHECK_FUZZY_NOT_EQUAL_MSG_1(x1, x2, tol, msg, \ + _0) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg,\ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_FUZZY_NOT_EQUAL_MSG_2(x1, x2, tol, msg, \ + _0, _1) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg,\ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_FUZZY_NOT_EQUAL_MSG_3(x1, x2, tol, msg, \ + _0, _1, _2) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg,\ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_FUZZY_NOT_EQUAL_MSG_4(x1, x2, tol, msg, \ + _0, _1, _2, _3) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg,\ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_REAL_CHECK_FUZZY_NOT_EQUAL_MSG_5(x1, x2, tol, msg, \ + _0, _1, _2, _3, _4) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg,\ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_REAL_CHECK_FUZZY_NOT_EQUAL_MSG_6(x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg,\ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_REAL_CHECK_FUZZY_NOT_EQUAL_MSG_7(x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg,\ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_REAL_CHECK_FUZZY_NOT_EQUAL_MSG_8(x1, x2, tol, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__REAL_DEFINE_FUZZY_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, tol, msg,\ + _0, _1, _2, _3, _4, _5, _6, _7) + +/* String Assertions O-(''Q) + -------------------------------------------------------------------------- */ + +#if RX__HAS_VARIADIC_MACROS + #define RX__STR_TEST_DEFINE(severity, op, str_case, s1, s2, ...) \ + rx__str_assess_comparison(RX_PARAM_CONTEXT, \ + (s1), \ + (s2), \ + str_case, \ + op, \ + #s1, \ + #s2, \ + __FILE__, \ + __LINE__, \ + severity, \ + __VA_ARGS__) +#else + #define RX__STR_TEST_DEFINE(severity, op, str_case, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + rx__str_assess_comparison(RX_PARAM_CONTEXT, \ + (s1), \ + (s2), \ + str_case, \ + op, \ + #s1, \ + #s2, \ + __FILE__, \ + __LINE__, \ + severity, \ + msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) +#endif + +#define RX_STR_REQUIRE_EQUAL(s1, s2) \ + RX_STR_REQUIRE_EQUAL_MSG(s1, s2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_STR_REQUIRE_EQUAL_MSG(s1, s2, ...) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, __VA_ARGS__) +#else + #define RX_STR_REQUIRE_EQUAL_MSG(s1, s2, msg) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_STR_REQUIRE_EQUAL_MSG_1(s1, s2, msg, \ + _0) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_EQUAL_MSG_2(s1, s2, msg, \ + _0, _1) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_EQUAL_MSG_3(s1, s2, msg, \ + _0, _1, _2) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_EQUAL_MSG_4(s1, s2, msg, \ + _0, _1, _2, _3) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_EQUAL_MSG_5(s1, s2, msg, \ + _0, _1, _2, _3, _4) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_EQUAL_MSG_6(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_STR_REQUIRE_EQUAL_MSG_7(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_STR_REQUIRE_EQUAL_MSG_8(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_STR_CHECK_EQUAL(s1, s2) \ + RX_STR_CHECK_EQUAL_MSG(s1, s2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_STR_CHECK_EQUAL_MSG(s1, s2, ...) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, __VA_ARGS__) +#else + #define RX_STR_CHECK_EQUAL_MSG(s1, s2, msg) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_STR_CHECK_EQUAL_MSG_1(s1, s2, msg, \ + _0) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_CHECK_EQUAL_MSG_2(s1, s2, msg, \ + _0, _1) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_CHECK_EQUAL_MSG_3(s1, s2, msg, \ + _0, _1, _2) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_CHECK_EQUAL_MSG_4(s1, s2, msg, \ + _0, _1, _2, _3) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_STR_CHECK_EQUAL_MSG_5(s1, s2, msg, \ + _0, _1, _2, _3, _4) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_STR_CHECK_EQUAL_MSG_6(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_STR_CHECK_EQUAL_MSG_7(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_STR_CHECK_EQUAL_MSG_8(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_STR_REQUIRE_NOT_EQUAL(s1, s2) \ + RX_STR_REQUIRE_NOT_EQUAL_MSG(s1, s2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_STR_REQUIRE_NOT_EQUAL_MSG(s1, s2, ...) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, \ + __VA_ARGS__) +#else + #define RX_STR_REQUIRE_NOT_EQUAL_MSG(s1, s2, msg) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_STR_REQUIRE_NOT_EQUAL_MSG_1(s1, s2, msg, \ + _0) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_NOT_EQUAL_MSG_2(s1, s2, msg, \ + _0, _1) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_NOT_EQUAL_MSG_3(s1, s2, msg, \ + _0, _1, _2) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_NOT_EQUAL_MSG_4(s1, s2, msg, \ + _0, _1, _2, _3) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_NOT_EQUAL_MSG_5(s1, s2, msg, \ + _0, _1, _2, _3, _4) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_NOT_EQUAL_MSG_6(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_STR_REQUIRE_NOT_EQUAL_MSG_7(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_STR_REQUIRE_NOT_EQUAL_MSG_8(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_STR_CHECK_NOT_EQUAL(s1, s2) \ + RX_STR_CHECK_NOT_EQUAL_MSG(s1, s2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_STR_CHECK_NOT_EQUAL_MSG(s1, s2, ...) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, \ + __VA_ARGS__) +#else + #define RX_STR_CHECK_NOT_EQUAL_MSG(s1, s2, msg) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_STR_CHECK_NOT_EQUAL_MSG_1(s1, s2, msg, \ + _0) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_CHECK_NOT_EQUAL_MSG_2(s1, s2, msg, \ + _0, _1) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_CHECK_NOT_EQUAL_MSG_3(s1, s2, msg, \ + _0, _1, _2) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_CHECK_NOT_EQUAL_MSG_4(s1, s2, msg, \ + _0, _1, _2, _3) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_STR_CHECK_NOT_EQUAL_MSG_5(s1, s2, msg, \ + _0, _1, _2, _3, _4) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_STR_CHECK_NOT_EQUAL_MSG_6(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_STR_CHECK_NOT_EQUAL_MSG_7(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_STR_CHECK_NOT_EQUAL_MSG_8(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_OBEY, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_STR_REQUIRE_EQUAL_NO_CASE(s1, s2) \ + RX_STR_REQUIRE_EQUAL_NO_CASE_MSG(s1, s2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_STR_REQUIRE_EQUAL_NO_CASE_MSG(s1, s2, ...) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, __VA_ARGS__) +#else + #define RX_STR_REQUIRE_EQUAL_NO_CASE_MSG(s1, s2, msg) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_STR_REQUIRE_EQUAL_NO_CASE_MSG_1(s1, s2, msg, \ + _0) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_EQUAL_NO_CASE_MSG_2(s1, s2, msg, \ + _0, _1) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_EQUAL_NO_CASE_MSG_3(s1, s2, msg, \ + _0, _1, _2) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_EQUAL_NO_CASE_MSG_4(s1, s2, msg, \ + _0, _1, _2, _3) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_EQUAL_NO_CASE_MSG_5(s1, s2, msg, \ + _0, _1, _2, _3, _4) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_EQUAL_NO_CASE_MSG_6(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_STR_REQUIRE_EQUAL_NO_CASE_MSG_7(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_STR_REQUIRE_EQUAL_NO_CASE_MSG_8(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_STR_CHECK_EQUAL_NO_CASE(s1, s2) \ + RX_STR_CHECK_EQUAL_NO_CASE_MSG(s1, s2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_STR_CHECK_EQUAL_NO_CASE_MSG(s1, s2, ...) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, __VA_ARGS__) +#else + #define RX_STR_CHECK_EQUAL_NO_CASE_MSG(s1, s2, msg) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_STR_CHECK_EQUAL_NO_CASE_MSG_1(s1, s2, msg, \ + _0) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_CHECK_EQUAL_NO_CASE_MSG_2(s1, s2, msg, \ + _0, _1) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_CHECK_EQUAL_NO_CASE_MSG_3(s1, s2, msg, \ + _0, _1, _2) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_CHECK_EQUAL_NO_CASE_MSG_4(s1, s2, msg, \ + _0, _1, _2, _3) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_STR_CHECK_EQUAL_NO_CASE_MSG_5(s1, s2, msg, \ + _0, _1, _2, _3, _4) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_STR_CHECK_EQUAL_NO_CASE_MSG_6(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_STR_CHECK_EQUAL_NO_CASE_MSG_7(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_STR_CHECK_EQUAL_NO_CASE_MSG_8(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_STR_REQUIRE_NOT_EQUAL_NO_CASE(s1, s2) \ + RX_STR_REQUIRE_NOT_EQUAL_NO_CASE_MSG(s1, s2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_STR_REQUIRE_NOT_EQUAL_NO_CASE_MSG(s1, s2, ...) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, \ + __VA_ARGS__) +#else + #define RX_STR_REQUIRE_NOT_EQUAL_NO_CASE_MSG(s1, s2, msg) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_STR_REQUIRE_NOT_EQUAL_NO_CASE_MSG_1(s1, s2, msg, \ + _0) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_NOT_EQUAL_NO_CASE_MSG_2(s1, s2, msg, \ + _0, _1) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_NOT_EQUAL_NO_CASE_MSG_3(s1, s2, msg, \ + _0, _1, _2) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_NOT_EQUAL_NO_CASE_MSG_4(s1, s2, msg, \ + _0, _1, _2, _3) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_NOT_EQUAL_NO_CASE_MSG_5(s1, s2, msg, \ + _0, _1, _2, _3, _4) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_STR_REQUIRE_NOT_EQUAL_NO_CASE_MSG_6(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_STR_REQUIRE_NOT_EQUAL_NO_CASE_MSG_7(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_STR_REQUIRE_NOT_EQUAL_NO_CASE_MSG_8(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__STR_TEST_DEFINE( \ + RX_FATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_STR_CHECK_NOT_EQUAL_NO_CASE(s1, s2) \ + RX_STR_CHECK_NOT_EQUAL_NO_CASE_MSG(s1, s2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_STR_CHECK_NOT_EQUAL_NO_CASE_MSG(s1, s2, ...) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, \ + __VA_ARGS__) +#else + #define RX_STR_CHECK_NOT_EQUAL_NO_CASE_MSG(s1, s2, msg) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_STR_CHECK_NOT_EQUAL_NO_CASE_MSG_1(s1, s2, msg, \ + _0) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_CHECK_NOT_EQUAL_NO_CASE_MSG_2(s1, s2, msg, \ + _0, _1) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_CHECK_NOT_EQUAL_NO_CASE_MSG_3(s1, s2, msg, \ + _0, _1, _2) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_STR_CHECK_NOT_EQUAL_NO_CASE_MSG_4(s1, s2, msg, \ + _0, _1, _2, _3) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_STR_CHECK_NOT_EQUAL_NO_CASE_MSG_5(s1, s2, msg, \ + _0, _1, _2, _3, _4) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_STR_CHECK_NOT_EQUAL_NO_CASE_MSG_6(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_STR_CHECK_NOT_EQUAL_NO_CASE_MSG_7(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_STR_CHECK_NOT_EQUAL_NO_CASE_MSG_8(s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__STR_TEST_DEFINE( \ + RX_NONFATAL, RX__OP_NOT_EQUAL, RX__STR_CASE_IGNORE, s1, s2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +/* Pointer Assertions O-(''Q) + -------------------------------------------------------------------------- */ + +#if RX__HAS_VARIADIC_MACROS + #define RX__PTR_DEFINE_TEST(severity, op, x1, x2, ...) \ + rx__ptr_assess_comparison(RX_PARAM_CONTEXT, \ + (x1), \ + (x2), \ + op, \ + #x1, \ + #x2, \ + __FILE__, \ + __LINE__, \ + severity, \ + __VA_ARGS__) +#else + #define RX__PTR_DEFINE_TEST(severity, op, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + rx__ptr_assess_comparison(RX_PARAM_CONTEXT, \ + (x1), \ + (x2), \ + op, \ + #x1, \ + #x2, \ + __FILE__, \ + __LINE__, \ + severity, \ + msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) +#endif + +#define RX_PTR_REQUIRE_EQUAL(x1, x2) \ + RX_PTR_REQUIRE_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_PTR_REQUIRE_EQUAL_MSG(x1, x2, ...) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, __VA_ARGS__) +#else + #define RX_PTR_REQUIRE_EQUAL_MSG(x1, x2, msg) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_PTR_REQUIRE_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_REQUIRE_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_REQUIRE_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_REQUIRE_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_PTR_REQUIRE_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_PTR_REQUIRE_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_PTR_REQUIRE_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_PTR_REQUIRE_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_PTR_CHECK_EQUAL(x1, x2) \ + RX_PTR_CHECK_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_PTR_CHECK_EQUAL_MSG(x1, x2, ...) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, __VA_ARGS__) +#else + #define RX_PTR_CHECK_EQUAL_MSG(x1, x2, msg) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_PTR_CHECK_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_CHECK_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_CHECK_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_CHECK_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_PTR_CHECK_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_PTR_CHECK_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_PTR_CHECK_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_PTR_CHECK_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_PTR_REQUIRE_NOT_EQUAL(x1, x2) \ + RX_PTR_REQUIRE_NOT_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_PTR_REQUIRE_NOT_EQUAL_MSG(x1, x2, ...) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, __VA_ARGS__) +#else + #define RX_PTR_REQUIRE_NOT_EQUAL_MSG(x1, x2, msg) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_PTR_REQUIRE_NOT_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_REQUIRE_NOT_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_REQUIRE_NOT_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_REQUIRE_NOT_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_PTR_REQUIRE_NOT_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_PTR_REQUIRE_NOT_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_PTR_REQUIRE_NOT_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_PTR_REQUIRE_NOT_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__PTR_DEFINE_TEST(RX_FATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_PTR_CHECK_NOT_EQUAL(x1, x2) \ + RX_PTR_CHECK_NOT_EQUAL_MSG(x1, x2, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_PTR_CHECK_NOT_EQUAL_MSG(x1, x2, ...) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, __VA_ARGS__) +#else + #define RX_PTR_CHECK_NOT_EQUAL_MSG(x1, x2, msg) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_PTR_CHECK_NOT_EQUAL_MSG_1(x1, x2, msg, \ + _0) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_CHECK_NOT_EQUAL_MSG_2(x1, x2, msg, \ + _0, _1) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_CHECK_NOT_EQUAL_MSG_3(x1, x2, msg, \ + _0, _1, _2) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_CHECK_NOT_EQUAL_MSG_4(x1, x2, msg, \ + _0, _1, _2, _3) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_PTR_CHECK_NOT_EQUAL_MSG_5(x1, x2, msg, \ + _0, _1, _2, _3, _4) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_PTR_CHECK_NOT_EQUAL_MSG_6(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_PTR_CHECK_NOT_EQUAL_MSG_7(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_PTR_CHECK_NOT_EQUAL_MSG_8(x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__PTR_DEFINE_TEST(RX_NONFATAL, RX__OP_NOT_EQUAL, x1, x2, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#if RX__HAS_VARIADIC_MACROS + #define RX__PTR_DEFINE_ALIGNMENT_TEST(severity, x, alignment, ...) \ + rx__ptr_assess_alignment(RX_PARAM_CONTEXT, \ + (x), \ + (alignment), \ + #x, \ + __FILE__, \ + __LINE__, \ + severity, \ + __VA_ARGS__) +#else + #define RX__PTR_DEFINE_ALIGNMENT_TEST(severity, x, alignment, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + rx__ptr_assess_alignment(RX_PARAM_CONTEXT, \ + (x), \ + (alignment), \ + #x, \ + __FILE__, \ + __LINE__, \ + severity, \ + msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) +#endif + +#define RX_PTR_REQUIRE_ALIGNED(x, alignment) \ + RX_PTR_REQUIRE_ALIGNED_MSG(x, alignment, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_PTR_REQUIRE_ALIGNED_MSG(x, alignment, ...) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_FATAL, x, alignment, __VA_ARGS__) +#else + #define RX_PTR_REQUIRE_ALIGNED_MSG(x, alignment, msg) \ + RX__PTR_DEFINE_ALIGNMENT_TEST( \ + RX_FATAL, x, alignment, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_PTR_REQUIRE_ALIGNED_MSG_1(x, alignment, msg, \ + _0) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_FATAL, x, alignment, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_REQUIRE_ALIGNED_MSG_2(x, alignment, msg, \ + _0, _1) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_FATAL, x, alignment, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_REQUIRE_ALIGNED_MSG_3(x, alignment, msg, \ + _0, _1, _2) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_FATAL, x, alignment, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_REQUIRE_ALIGNED_MSG_4(x, alignment, msg, \ + _0, _1, _2, _3) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_FATAL, x, alignment, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_PTR_REQUIRE_ALIGNED_MSG_5(x, alignment, msg, \ + _0, _1, _2, _3, _4) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_FATAL, x, alignment, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_PTR_REQUIRE_ALIGNED_MSG_6(x, alignment, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_FATAL, x, alignment, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_PTR_REQUIRE_ALIGNED_MSG_7(x, alignment, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_FATAL, x, alignment, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_PTR_REQUIRE_ALIGNED_MSG_8(x, alignment, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_FATAL, x, alignment, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +#define RX_PTR_CHECK_ALIGNED(x, alignment) \ + RX_PTR_CHECK_ALIGNED_MSG(x, alignment, NULL) + +#if RX__HAS_VARIADIC_MACROS + #define RX_PTR_CHECK_ALIGNED_MSG(x, alignment, ...) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_NONFATAL, x, alignment, __VA_ARGS__) +#else + #define RX_PTR_CHECK_ALIGNED_MSG(x, alignment, msg) \ + RX__PTR_DEFINE_ALIGNMENT_TEST( \ + RX_NONFATAL, x, alignment, msg, \ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) +#endif + +#define RX_PTR_CHECK_ALIGNED_MSG_1(x, alignment, msg, \ + _0) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_NONFATAL, x, alignment, msg, \ + _0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_CHECK_ALIGNED_MSG_2(x, alignment, msg, \ + _0, _1) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_NONFATAL, x, alignment, msg, \ + _0, _1, NULL, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_CHECK_ALIGNED_MSG_3(x, alignment, msg, \ + _0, _1, _2) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_NONFATAL, x, alignment, msg, \ + _0, _1, _2, NULL, NULL, NULL, NULL, NULL) + +#define RX_PTR_CHECK_ALIGNED_MSG_4(x, alignment, msg, \ + _0, _1, _2, _3) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_NONFATAL, x, alignment, msg, \ + _0, _1, _2, _3, NULL, NULL, NULL, NULL) + +#define RX_PTR_CHECK_ALIGNED_MSG_5(x, alignment, msg, \ + _0, _1, _2, _3, _4) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_NONFATAL, x, alignment, msg, \ + _0, _1, _2, _3, _4, NULL, NULL, NULL) + +#define RX_PTR_CHECK_ALIGNED_MSG_6(x, alignment, msg, \ + _0, _1, _2, _3, _4, _5) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_NONFATAL, x, alignment, msg, \ + _0, _1, _2, _3, _4, _5, NULL, NULL) + +#define RX_PTR_CHECK_ALIGNED_MSG_7(x, alignment, msg, \ + _0, _1, _2, _3, _4, _5, _6) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_NONFATAL, x, alignment, msg, \ + _0, _1, _2, _3, _4, _5, _6, NULL) + +#define RX_PTR_CHECK_ALIGNED_MSG_8(x, alignment, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) \ + RX__PTR_DEFINE_ALIGNMENT_TEST(RX_NONFATAL, x, alignment, msg, \ + _0, _1, _2, _3, _4, _5, _6, _7) + +/* Implementation: Helpers O-(''Q) + -------------------------------------------------------------------------- */ + +#if defined(RX_ENABLE_DEBUGGING) \ + || (!defined(RX_DISABLE_DEBUGGING) && (defined(DEBUG) || !defined(NDEBUG))) + #define RX__DEBUGGING 1 +#else + #define RX__DEBUGGING 0 +#endif + +#if defined(_WIN32) + #define RX__PLATFORM_WINDOWS +#elif defined(__unix__) || defined(__APPLE__) + #define RX__PLATFORM_UNIX + #if defined(__APPLE__) + #define RX__PLATFORM_DARWIN + #elif defined(__linux__) + #define RX__PLATFORM_LINUX + #endif +#endif + +#include <ctype.h> +#include <setjmp.h> +#include <stdarg.h> +#include <stddef.h> +#include <stdio.h> +#include <stdint.h> +#include <string.h> + +#ifndef RX_ASSERT + #include <assert.h> + #define RX_ASSERT assert +#endif + +#ifndef RX_MALLOC + #include <stdlib.h> + #define RX_MALLOC malloc +#endif + +#ifndef RX_REALLOC + #include <stdlib.h> + #define RX_REALLOC realloc +#endif + +#ifndef RX_FREE + #include <stdlib.h> + #define RX_FREE free +#endif + +#if defined(RX__PLATFORM_WINDOWS) + #include <io.h> + #define RX__ISATTY _isatty + #define RX__FILENO _fileno +#else + #include <unistd.h> + #define RX__ISATTY isatty + #define RX__FILENO fileno +#endif + +typedef char rx__invalid_size_type[sizeof(rx_size) == sizeof(size_t) ? 1 : -1]; + +#define RX__UNUSED(x) (void)(x) + +#define RX__REQUIRE_SEMICOLON void rx__dummy(void) + +#define RX__STRINGIFY(x) #x + +#define RX__EXPAND(x) x + +#define RX__CONCAT_(a, b) a##b +#define RX__CONCAT(a, b) RX__CONCAT_(a, b) + +#define RX__STRUCT_SET_MEMBER(x) (*obj) x; + +#define RX__STRUCT_UPDATE_0() + +#define RX__STRUCT_UPDATE_1(_0) \ + RX__STRUCT_SET_MEMBER(_0) + +#define RX__STRUCT_UPDATE_2(_0, _1) \ + RX__STRUCT_SET_MEMBER(_0) \ + RX__STRUCT_UPDATE_1(_1) + +#define RX__STRUCT_UPDATE_3(_0, _1, _2) \ + RX__STRUCT_SET_MEMBER(_0) \ + RX__STRUCT_UPDATE_2(_1, _2) + +#define RX__STRUCT_UPDATE_4(_0, _1, _2, _3) \ + RX__STRUCT_SET_MEMBER(_0) \ + RX__STRUCT_UPDATE_3(_1, _2, _3) + +#define RX__STRUCT_UPDATE_5(_0, _1, _2, _3, _4) \ + RX__STRUCT_SET_MEMBER(_0) \ + RX__STRUCT_UPDATE_4(_1, _2, _3, _4) + +#define RX__STRUCT_UPDATE_6(_0, _1, _2, _3, _4, _5) \ + RX__STRUCT_SET_MEMBER(_0) \ + RX__STRUCT_UPDATE_5(_1, _2, _3, _4, _5) + +#define RX__STRUCT_UPDATE_7(_0, _1, _2, _3, _4, _5, _6) \ + RX__STRUCT_SET_MEMBER(_0) \ + RX__STRUCT_UPDATE_6(_1, _2, _3, _4, _5, _6) + +#define RX__STRUCT_UPDATE_8(_0, _1, _2, _3, _4, _5, _6, _7) \ + RX__STRUCT_SET_MEMBER(_0) \ + RX__STRUCT_UPDATE_7(_1, _2, _3, _4, _5, _6, _7) + +#define RX__STRUCT_DEFINE_UPDATE_FN(id, type, arg_count, args) \ + static void \ + id(type *obj) \ + { \ + RX__UNUSED(obj); \ + RX__EXPAND(RX__CONCAT(RX__STRUCT_UPDATE_, arg_count) args) \ + } + +#if RX__HAS_VARIADIC_MACROS + #define RX__ARG( \ + _0, _1, _2, _3, _4, _5, _6, _7, \ + _8, ...) _8 + + #define RX__HAS_AT_LEAST_2_ARGS(...) \ + RX__EXPAND(RX__ARG( \ + __VA_ARGS__, \ + 1, 1, 1, 1, 1, 1, 1, 0,)) + + #define RX__HAS_AT_LEAST_3_ARGS(...) \ + RX__EXPAND(RX__ARG( \ + __VA_ARGS__, \ + 1, 1, 1, 1, 1, 1, 0, 0,)) + + #define RX__COUNT_ARGS(...) \ + RX__EXPAND(RX__ARG( \ + __VA_ARGS__, \ + 8, 7, 6, 5, 4, 3, 2, 1, \ + 0,)) +#endif + +#define RX__FIXTURE_DESC_GET_ID(id) \ + rx__fixture_desc_##id +#define RX__FIXTURE_GET_UPDATE_FN_ID(id) \ + rx__fixture_update_fn_##id + +#define RX__TEST_SUITE_DESC_GET_ID(id) \ + rx__test_suite_desc_##id +#define RX__TEST_SUITE_DESC_PTR_GET_ID(id) \ + rx__test_suite_desc_ptr_##id + +#define RX__TEST_CASE_DESC_GET_ID(suite_id, id) \ + rx__test_case_desc_##suite_id##_##id +#define RX__TEST_CASE_DESC_PTR_GET_ID(suite_id, id) \ + rx__test_case_desc_ptr_##suite_id##_##id + +#define RX__TEST_CASE_CONFIG_DESC_GET_ID(id) \ + rx__test_case_config_desc_##id +#define RX__TEST_CASE_CONFIG_BLUEPRINT_GET_UPDATE_FN_ID(id) \ + rx__test_case_config_blueprint_update_fn_##id + +typedef intmax_t rx__int; +typedef uintmax_t rx__uint; +typedef long double rx__real; + +struct rx_context { + jmp_buf env; + struct rx_summary *summary; +}; + +/* Implementation: Logger O-(''Q) + -------------------------------------------------------------------------- */ + +#if !defined(RX_DISABLE_LOG_STYLING) \ + && defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 1 + #define RX__LOG_STYLING 1 +#else + #define RX__LOG_STYLING 0 +#endif + +#if defined(RX_SET_LOGGING_LEVEL_ALL) + #define RX__LOGGING_LEVEL RX_LOG_LEVEL_ALL +#elif defined(RX_SET_LOGGING_LEVEL_DEBUG) + #define RX__LOGGING_LEVEL RX_LOG_LEVEL_DEBUG +#elif defined(RX_SET_LOGGING_LEVEL_INFO) + #define RX__LOGGING_LEVEL RX_LOG_LEVEL_INFO +#elif defined(RX_SET_LOGGING_LEVEL_WARNING) + #define RX__LOGGING_LEVEL RX_LOG_LEVEL_WARNING +#elif defined(RX_SET_LOGGING_LEVEL_ERROR) + #define RX__LOGGING_LEVEL RX_LOG_LEVEL_ERROR +#elif defined(RX_SET_LOGGING_LEVEL_FATAL) + #define RX__LOGGING_LEVEL RX_LOG_LEVEL_FATAL +#elif defined(RX_SET_LOGGING_LEVEL_NONDE) + #define RX__LOGGING_LEVEL RX_LOG_LEVEL_NONE +#elif RX__DEBUGGING + #define RX__LOGGING_LEVEL RX_LOG_LEVEL_DEBUG +#else + #define RX__LOGGING_LEVEL RX_LOG_LEVEL_WARNING +#endif + +#if defined(RX_DISABLE_LOGGING) + #define RX__LOGGING 0 +#else + #define RX__LOGGING 1 +#endif + +#ifndef RX_LOG + #define RX_LOG rx__log +#endif + +#if defined(_MSC_VER) + #define RX__LOG(level, args) \ + do { \ + _Pragma("warning(push)") \ + _Pragma("warning(disable : 4127)") \ + if (RX__LOGGING && (level) <= RX__LOGGING_LEVEL) { \ + RX_LOG args; \ + } \ + _Pragma("warning(pop)") \ + } while (0) +#elif defined(__GNUC__) + #define RX__LOG(level, args) \ + do { \ + _Pragma("GCC diagnostic push") \ + _Pragma("GCC diagnostic ignored \"-Wtautological-compare\"") \ + if (RX__LOGGING && (level) <= RX__LOGGING_LEVEL) { \ + RX_LOG args; \ + } \ + _Pragma("GCC diagnostic pop") \ + } while (0) +#else + #define RX__LOG(level, args) \ + do { \ + if (RX__LOGGING && (level) <= RX__LOGGING_LEVEL) { \ + RX_LOG args; \ + } \ + } while (0) +#endif + +#define RX__LOG_DEBUG(msg) \ + RX__LOG(RX_LOG_LEVEL_DEBUG, \ + (RX_LOG_LEVEL_DEBUG, __FILE__, __LINE__, msg)) +#define RX__LOG_DEBUG_1(fmt, _0) \ + RX__LOG(RX_LOG_LEVEL_DEBUG, \ + (RX_LOG_LEVEL_DEBUG, __FILE__, __LINE__, fmt, _0)) +#define RX__LOG_DEBUG_2(fmt, _0, _1) \ + RX__LOG(RX_LOG_LEVEL_DEBUG, \ + (RX_LOG_LEVEL_DEBUG, __FILE__, __LINE__, fmt, _0, _1)) + +#define RX__LOG_INFO(msg) \ + RX__LOG(RX_LOG_LEVEL_INFO, \ + (RX_LOG_LEVEL_INFO, __FILE__, __LINE__, msg)) +#define RX__LOG_INFO_1(fmt, _0) \ + RX__LOG(RX_LOG_LEVEL_INFO, \ + (RX_LOG_LEVEL_INFO, __FILE__, __LINE__, fmt, _0)) +#define RX__LOG_INFO_2(fmt, _0, _1) \ + RX__LOG(RX_LOG_LEVEL_INFO, \ + (RX_LOG_LEVEL_INFO, __FILE__, __LINE__, fmt, _0, _1)) + +#define RX__LOG_WARNING(msg) \ + RX__LOG(RX_LOG_LEVEL_WARNING, \ + (RX_LOG_LEVEL_WARNING, __FILE__, __LINE__, msg)) +#define RX__LOG_WARNING_1(fmt, _0) \ + RX__LOG(RX_LOG_LEVEL_WARNING, \ + (RX_LOG_LEVEL_WARNING, __FILE__, __LINE__, fmt, _0)) +#define RX__LOG_WARNING_2(fmt, _0, _1) \ + RX__LOG(RX_LOG_LEVEL_WARNING, \ + (RX_LOG_LEVEL_WARNING, __FILE__, __LINE__, fmt, _0, _1)) + +#define RX__LOG_ERROR(msg) \ + RX__LOG(RX_LOG_LEVEL_ERROR, \ + (RX_LOG_LEVEL_ERROR, __FILE__, __LINE__, msg)) +#define RX__LOG_ERROR_1(fmt, _0) \ + RX__LOG(RX_LOG_LEVEL_ERROR, \ + (RX_LOG_LEVEL_ERROR, __FILE__, __LINE__, fmt, _0)) +#define RX__LOG_ERROR_2(fmt, _0, _1) \ + RX__LOG(RX_LOG_LEVEL_ERROR, \ + (RX_LOG_LEVEL_ERROR, __FILE__, __LINE__, fmt, _0, _1)) + +#define RX__LOG_FATAL(msg) \ + RX__LOG(RX_LOG_LEVEL_FATAL, \ + (RX_LOG_LEVEL_FATAL, __FILE__, __LINE__, msg)) +#define RX__LOG_FATAL_1(fmt, _0) \ + RX__LOG(RX_LOG_LEVEL_FATAL, \ + (RX_LOG_LEVEL_FATAL, __FILE__, __LINE__, fmt, _0)) +#define RX__LOG_FATAL_2(fmt, _0, _1) \ + RX__LOG(RX_LOG_LEVEL_FATAL, \ + (RX_LOG_LEVEL_FATAL, __FILE__, __LINE__, fmt, _0, _1)) + +#if RX__LOG_STYLING +enum rx__log_style { + RX__LOG_STYLE_RESET = 0, + RX__LOG_STYLE_BLACK = 1, + RX__LOG_STYLE_RED = 2, + RX__LOG_STYLE_GREEN = 3, + RX__LOG_STYLE_YELLOW = 4, + RX__LOG_STYLE_BLUE = 5, + RX__LOG_STYLE_MAGENTA = 6, + RX__LOG_STYLE_CYAN = 7, + RX__LOG_STYLE_BRIGHT_BLACK = 8, + RX__LOG_STYLE_BRIGHT_RED = 9, + RX__LOG_STYLE_BRIGHT_GREEN = 10, + RX__LOG_STYLE_BRIGHT_YELLOW = 11, + RX__LOG_STYLE_BRIGHT_BLUE = 12, + RX__LOG_STYLE_BRIGHT_MAGENTA = 13, + RX__LOG_STYLE_BRIGHT_CYAN = 14 +}; +#endif + +static void +rx__log_level_get_name(const char **name, enum rx_log_level level) +{ + RX_ASSERT(name != NULL); + + switch (level) { + case RX_LOG_LEVEL_FATAL: + *name = "fatal"; + return; + case RX_LOG_LEVEL_ERROR: + *name = "error"; + return; + case RX_LOG_LEVEL_WARNING: + *name = "warning"; + return; + case RX_LOG_LEVEL_INFO: + *name = "info"; + return; + case RX_LOG_LEVEL_DEBUG: + *name = "debug"; + return; + default: + RX_ASSERT(0); + } +} + +#if RX__LOG_STYLING +static void +rx__log_level_get_style(enum rx__log_style *style, enum rx_log_level level) +{ + RX_ASSERT(style != NULL); + + switch (level) { + case RX_LOG_LEVEL_FATAL: + *style = RX__LOG_STYLE_BRIGHT_MAGENTA; + return; + case RX_LOG_LEVEL_ERROR: + *style = RX__LOG_STYLE_BRIGHT_RED; + return; + case RX_LOG_LEVEL_WARNING: + *style = RX__LOG_STYLE_BRIGHT_YELLOW; + return; + case RX_LOG_LEVEL_INFO: + *style = RX__LOG_STYLE_BRIGHT_GREEN; + return; + case RX_LOG_LEVEL_DEBUG: + *style = RX__LOG_STYLE_BRIGHT_CYAN; + return; + default: + RX_ASSERT(0); + }; +} + +static void +rx__log_style_get_ansi_code(const char **code, enum rx__log_style style) +{ + RX_ASSERT(code != NULL); + + switch (style) { + case RX__LOG_STYLE_RESET: + *code = "\x1b[0m"; + return; + case RX__LOG_STYLE_BLACK: + *code = "\x1b[30m"; + return; + case RX__LOG_STYLE_RED: + *code = "\x1b[31m"; + return; + case RX__LOG_STYLE_GREEN: + *code = "\x1b[32m"; + return; + case RX__LOG_STYLE_YELLOW: + *code = "\x1b[33m"; + return; + case RX__LOG_STYLE_BLUE: + *code = "\x1b[34m"; + return; + case RX__LOG_STYLE_MAGENTA: + *code = "\x1b[35m"; + return; + case RX__LOG_STYLE_CYAN: + *code = "\x1b[36m"; + return; + case RX__LOG_STYLE_BRIGHT_BLACK: + *code = "\x1b[1;30m"; + return; + case RX__LOG_STYLE_BRIGHT_RED: + *code = "\x1b[1;31m"; + return; + case RX__LOG_STYLE_BRIGHT_GREEN: + *code = "\x1b[1;32m"; + return; + case RX__LOG_STYLE_BRIGHT_YELLOW: + *code = "\x1b[1;33m"; + return; + case RX__LOG_STYLE_BRIGHT_BLUE: + *code = "\x1b[1;34m"; + return; + case RX__LOG_STYLE_BRIGHT_MAGENTA: + *code = "\x1b[1;35m"; + return; + case RX__LOG_STYLE_BRIGHT_CYAN: + *code = "\x1b[1;36m"; + return; + default: + RX_ASSERT(0); + } +} +#endif /* RX__LOG_STYLING */ + +RX__PRINTF_CHECK(4, 5) +static void +rx__log(enum rx_log_level level, + const char *file, + int line, + const char *fmt, + ...) +{ + const char *level_name; + const char *level_style_begin; + const char *level_style_end; + va_list args; + + RX_ASSERT(file != NULL); + RX_ASSERT(fmt != NULL); + + rx__log_level_get_name(&level_name, level); + +#if RX__LOG_STYLING + if (RX__ISATTY(RX__FILENO(stderr))) { + enum rx__log_style level_style; + + rx__log_level_get_style(&level_style, level); + rx__log_style_get_ansi_code(&level_style_begin, level_style); + rx__log_style_get_ansi_code(&level_style_end, RX__LOG_STYLE_RESET); + } else { + level_style_begin = level_style_end = ""; + } +#else + level_style_begin = level_style_end = ""; +#endif + + va_start(args, fmt); + fprintf(stderr, + "%s:%d: %s%s%s: ", + file, + line, + level_style_begin, + level_name, + level_style_end); + vfprintf(stderr, fmt, args); + va_end(args); +} + +/* Implementation: Timer O-(''Q) + -------------------------------------------------------------------------- */ + +#define RX__TICKS_PER_SECOND 1000000000ul +#define RX__TICKS_PER_MICROSECOND 1000ul + +#if defined(RX__PLATFORM_WINDOWS) + #define WIN32_LEAN_AND_MEAN + #include <windows.h> +#elif defined(RX__PLATFORM_DARWIN) + #include <mach/mach_time.h> + #include <sys/resource.h> +#elif defined(RX__PLATFORM_UNIX) + #include <sys/resource.h> + #if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309L + #include <time.h> + #define RX__USE_CLOCK_GETTIME + #if defined(CLOCK_MONOTONIC_RAW) + #define RX__CLOCK_ID CLOCK_MONOTONIC_RAW + #elif defined(CLOCK_MONOTONIC) + #define RX__CLOCK_ID CLOCK_MONOTONIC + #else + #define RX__CLOCK_ID CLOCK_REALTIME + #endif + #else + #include <sys/time.h> + #endif +#else + typedef char rx__unsupported_platform[-1]; +#endif + +static enum rx_status +rx__get_real_time(uint64_t *time) +{ + RX_ASSERT(time != NULL); + +#if defined(RX__PLATFORM_WINDOWS) + { + static double time_to_nano; + LARGE_INTEGER counter; + + if (time_to_nano == 0.0) { + LARGE_INTEGER frequency; + + if (!QueryPerformanceFrequency(&frequency)) { + RX__LOG_DEBUG("failed to retrieve the timer's frequency\n"); + return RX_ERROR; + } + + time_to_nano = (double)RX__TICKS_PER_SECOND / frequency.QuadPart; + } + + if (!QueryPerformanceCounter(&counter)) { + RX__LOG_DEBUG("failed to retrieve the current time\n"); + return RX_ERROR; + } + + *time = (uint64_t)(counter.QuadPart * time_to_nano); + return RX_SUCCESS; + } +#elif defined(RX__PLATFORM_DARWIN) + /* + Since Darwin 5.2, `clock_gettime()` can return high resolution times + with the `CLOCK_UPTIME_RAW` clock but it internally only calls + `mach_absolute_time()` with the overhead of converting the result into + the `timespec` format. + */ + { + static uint64_t time_to_nano; + + if (time_to_nano == 0) { + mach_timebase_info_data_t info; + + if (mach_timebase_info(&info) != KERN_SUCCESS) { + RX__LOG_DEBUG("failed to retrieve the current time\n"); + return RX_ERROR; + } + + time_to_nano = info.numer / info.denom; + } + + *time = mach_absolute_time() * time_to_nano; + return RX_SUCCESS; + } +#elif defined(RX__PLATFORM_UNIX) + #if defined(RX__USE_CLOCK_GETTIME) + { + struct timespec t; + + if (clock_gettime(RX__CLOCK_ID, &t) != 0) { + RX__LOG_DEBUG("failed to retrieve the current time\n"); + return RX_ERROR; + } + + *time = (uint64_t)t.tv_sec * RX__TICKS_PER_SECOND + (uint64_t)t.tv_nsec; + return RX_SUCCESS; + } + #else + { + struct timeval t; + + if (gettimeofday(&t, NULL) != 0) { + RX__LOG_DEBUG("failed to retrieve the current time\n"); + return RX_ERROR; + } + + *time = (uint64_t)t.tv_sec * RX__TICKS_PER_SECOND + + (uint64_t)t.tv_usec * RX__TICKS_PER_MICROSECOND; + return RX_SUCCESS; + } + #endif +#else + RX__LOG_DEBUG("platform not supported\n"); + return RX_ERROR; +#endif +} + +/* Implementation: Test Failure Array O-(''Q) + -------------------------------------------------------------------------- */ + +/* + Simple implementation for dynamic arrays that can grow and stretch at + runtime. The object returned to the user is a standard pointer to a C array + but the implementation also allocates a header to keep track of the size + and the capacity. + + The memory layout is better represented by the diagram below. + + block user pointer + / / + +--------+--------+ + | header | buffer | + +--------+--------+ + + The block points to the whole memory being allocated while the buffer + represents the actual array exposed to the user. +*/ + +#define RX__DYN_ARRAY_GET_BLOCK(buf) \ + ((void *)&((struct rx__dyn_array_header *)(buf))[-1]) +#define RX__DYN_ARRAY_GET_HEADER(block) \ + ((struct rx__dyn_array_header *)(block)) +#define RX__DYN_ARRAY_GET_BUFFER(block) \ + ((void *)&((struct rx__dyn_array_header *)(block))[1]) +#define RX__DYN_ARRAY_GET_CONST_BLOCK(buf) \ + ((const void *)&((const struct rx__dyn_array_header *)(buf))[-1]) +#define RX__DYN_ARRAY_GET_CONST_HEADER(block) \ + ((const struct rx__dyn_array_header *)(block)) + +struct rx__dyn_array_header { + size_t size; + size_t capacity; +}; + +static const size_t rx__test_failure_array_max_capacity + = (((size_t)-1 - sizeof(struct rx__dyn_array_header)) + / sizeof(struct rx_failure)); + +static void +rx__dyn_array_get_new_capacity(size_t *capacity, + size_t current, + size_t requested, + size_t max) +{ + *capacity = current + current / 2 + 1; + if (*capacity < current) { + *capacity = max; + return; + } + + if (*capacity < requested) { + *capacity = requested; + } +} + +static enum rx_status +rx__dyn_array_ensure_has_enough_capacity(void **block, + size_t current_capacity, + size_t requested_capacity, + size_t max_capacity, + size_t element_size) +{ + void *buf; + size_t new_capacity; + + RX_ASSERT(block != NULL); + RX_ASSERT(element_size > 0); + + if (requested_capacity > max_capacity) { + RX__LOG_DEBUG("the requested capacity is too large\n"); + return RX_ERROR_MAX_SIZE_EXCEEDED; + } + + if (*block != NULL && current_capacity >= requested_capacity) { + return RX_SUCCESS; + } + + rx__dyn_array_get_new_capacity( + &new_capacity, current_capacity, requested_capacity, max_capacity); + RX_ASSERT(new_capacity >= requested_capacity); + RX_ASSERT(new_capacity <= max_capacity); + + buf = RX_REALLOC( + *block, + sizeof(struct rx__dyn_array_header) + element_size * new_capacity); + if (buf == NULL) { + RX__LOG_DEBUG("failed to reallocate the block\n"); + return RX_ERROR_ALLOCATION; + } + + RX__DYN_ARRAY_GET_HEADER(buf)->capacity = new_capacity; + *block = buf; + return RX_SUCCESS; +} + +static enum rx_status +rx__test_failure_array_create(struct rx_failure **array, size_t size) +{ + void *block; + size_t capacity; + + RX_ASSERT(array != NULL); + + rx__dyn_array_get_new_capacity( + &capacity, 0, size, rx__test_failure_array_max_capacity); + RX_ASSERT(capacity >= size); + RX_ASSERT(capacity <= rx__test_failure_array_max_capacity); + + block = RX_MALLOC(sizeof(struct rx__dyn_array_header) + + sizeof(struct rx_failure) * capacity); + if (block == NULL) { + RX__LOG_DEBUG_1("failed to reserve a large enough capacity for " + "the test failure array (requested capacity: %lu)\n", + (unsigned long)size); + return RX_ERROR_ALLOCATION; + } + + RX__DYN_ARRAY_GET_HEADER(block)->size = size; + RX__DYN_ARRAY_GET_HEADER(block)->capacity = capacity; + *array = (struct rx_failure *)RX__DYN_ARRAY_GET_BUFFER(block); + return RX_SUCCESS; +} + +static void +rx__test_failure_array_destroy(struct rx_failure *array) +{ + RX_FREE(RX__DYN_ARRAY_GET_BLOCK(array)); +} + +static void +rx__test_failure_array_get_size(size_t *size, const struct rx_failure *array) +{ + RX_ASSERT(array != NULL); + + *size = RX__DYN_ARRAY_GET_CONST_HEADER(RX__DYN_ARRAY_GET_CONST_BLOCK(array)) + ->size; +} + +static enum rx_status +rx__test_failure_array_extend_back(struct rx_failure **slice, + struct rx_failure **array, + size_t size) +{ + enum rx_status status; + void *block; + size_t pos; + + RX_ASSERT(array != NULL); + RX_ASSERT(*array != NULL); + + block = RX__DYN_ARRAY_GET_BLOCK(*array); + status = rx__dyn_array_ensure_has_enough_capacity( + &block, + RX__DYN_ARRAY_GET_HEADER(block)->capacity, + RX__DYN_ARRAY_GET_HEADER(block)->size + size, + rx__test_failure_array_max_capacity, + sizeof(struct rx_failure)); + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_1( + "failed to reserve a large enough capacity for " + "the test failure array (requested capacity: %lu)\n", + (unsigned long)RX__DYN_ARRAY_GET_HEADER(block)->size + size); + return status; + } + + RX_ASSERT(block != NULL); + + *array = (struct rx_failure *)RX__DYN_ARRAY_GET_BUFFER(block); + + pos = RX__DYN_ARRAY_GET_HEADER(block)->size; + memmove(&(*array)[pos + size], + &(*array)[pos], + sizeof(struct rx_failure) + * (RX__DYN_ARRAY_GET_HEADER(block)->size - pos)); + + if (slice != NULL) { + *slice = &(*array)[pos]; + } + + RX__DYN_ARRAY_GET_HEADER(block)->size += size; + return RX_SUCCESS; +} + +/* Implementation: Memory Sections O-(''Q) + -------------------------------------------------------------------------- */ + +/* + Compiler-specific code that allows grouping objects into specific + data sections, thus enabling automatic discovery by iterating over + anything registered in these sections. +*/ + +#if defined(_MSC_VER) + __pragma(section("rxsuite$a", read)) + __pragma(section("rxsuite$b", read)) + __pragma(section("rxsuite$c", read)) + + __declspec(allocate("rxsuite$a")) + const struct rx__test_suite_desc * const rx__test_suite_section_begin + = NULL; + + __declspec(allocate("rxsuite$c")) + const struct rx__test_suite_desc * const rx__test_suite_section_end + = NULL; + + #define RX__TEST_SUITE_REGISTER(name) \ + __declspec(allocate("rxsuite$b")) \ + const struct rx__test_suite_desc * const \ + RX__TEST_SUITE_DESC_PTR_GET_ID(name) \ + = &RX__TEST_SUITE_DESC_GET_ID(name) + + #define RX__TEST_SUITE_SECTION_BEGIN (&rx__test_suite_section_begin + 1) + #define RX__TEST_SUITE_SECTION_END (&rx__test_suite_section_end) +#else + #if defined(RX__PLATFORM_DARWIN) + extern const struct rx__test_suite_desc * const __start_rxsuite \ + __asm("section$start$__DATA$rxsuite"); + extern const struct rx__test_suite_desc * const __stop_rxsuite \ + __asm("section$end$__DATA$rxsuite"); + + #define RX__TEST_SUITE_SECTION \ + __attribute__((used,section("__DATA,rxsuite"))) + #else + extern const struct rx__test_suite_desc * const __start_rxsuite; + extern const struct rx__test_suite_desc * const __stop_rxsuite; + + #define RX__TEST_SUITE_SECTION \ + __attribute__((used,section("rxsuite"))) + #endif + + RX__TEST_SUITE_SECTION + static const struct rx__test_suite_desc * const rx__dummy_suite = NULL; + + #define RX__TEST_SUITE_REGISTER(name) \ + RX__TEST_SUITE_SECTION \ + const struct rx__test_suite_desc * const \ + RX__TEST_SUITE_DESC_PTR_GET_ID(name) \ + = &RX__TEST_SUITE_DESC_GET_ID(name) + + #define RX__TEST_SUITE_SECTION_BEGIN (&__start_rxsuite) + #define RX__TEST_SUITE_SECTION_END (&__stop_rxsuite) +#endif + +#if defined(_MSC_VER) + __pragma(section("rxcase$a", read)) + __pragma(section("rxcase$b", read)) + __pragma(section("rxcase$c", read)) + + __declspec(allocate("rxcase$a")) + const struct rx__test_case_desc * const rx__test_case_section_begin + = NULL; + + __declspec(allocate("rxcase$c")) + const struct rx__test_case_desc * const rx__test_case_section_end + = NULL; + + #define RX__TEST_CASE_REGISTER(suite_name, name) \ + __declspec(allocate("rxcase$b")) \ + const struct rx__test_case_desc * const \ + RX__TEST_CASE_DESC_PTR_GET_ID(suite_name, name) \ + = &RX__TEST_CASE_DESC_GET_ID(suite_name, name) + + #define RX__TEST_CASE_SECTION_BEGIN (&rx__test_case_section_begin + 1) + #define RX__TEST_CASE_SECTION_END (&rx__test_case_section_end) +#else + #if defined(RX__PLATFORM_DARWIN) + extern const struct rx__test_case_desc * const __start_rxcase \ + __asm("section$start$__DATA$rxcase"); + extern const struct rx__test_case_desc * const __stop_rxcase \ + __asm("section$end$__DATA$rxcase"); + + #define RX__TEST_CASE_SECTION \ + __attribute__((used,section("__DATA,rxcase"))) + #else + extern const struct rx__test_case_desc * const __start_rxcase; + extern const struct rx__test_case_desc * const __stop_rxcase; + + #define RX__TEST_CASE_SECTION \ + __attribute__((used,section("rxcase"))) + #endif + + RX__TEST_CASE_SECTION + static const struct rx__test_case_desc * const rx__dummy_case = NULL; + + #define RX__TEST_CASE_REGISTER(suite_name, name) \ + RX__TEST_CASE_SECTION \ + const struct rx__test_case_desc * const \ + RX__TEST_CASE_DESC_PTR_GET_ID(suite_name, name) \ + = &RX__TEST_CASE_DESC_GET_ID(suite_name, name) + + #define RX__TEST_CASE_SECTION_BEGIN (&__start_rxcase) + #define RX__TEST_CASE_SECTION_END (&__stop_rxcase) +#endif + +/* Implementation: Fixture O-(''Q) + -------------------------------------------------------------------------- */ + +typedef void (*rx__fixture_config_update_fn)( + struct rx_fixture_config *); + +struct rx__fixture_desc { + rx_size size; + const rx__fixture_config_update_fn update; +}; + +#define RX__FIXTURE_(id, size, update_fn) \ + static const struct rx__fixture_desc \ + RX__FIXTURE_DESC_GET_ID(id) \ + = {size, update_fn}; \ + \ + static const struct rx__fixture_desc \ + *id = &RX__FIXTURE_DESC_GET_ID(id); + +#define RX__FIXTURE_0(id, size) \ + RX__FIXTURE_(id, size, NULL) + +#define RX__FIXTURE_1(id, size, arg_count, args) \ + RX__STRUCT_DEFINE_UPDATE_FN( \ + RX__FIXTURE_GET_UPDATE_FN_ID(id), \ + struct rx_fixture_config, \ + arg_count, \ + args) \ + \ + RX__FIXTURE_(id, size, &RX__FIXTURE_GET_UPDATE_FN_ID(id)) + +/* Implementation: Test Case Config O-(''Q) + -------------------------------------------------------------------------- */ + +struct rx__test_case_config_blueprint { + int skip; + const struct rx__fixture_desc *fixture; +}; + +typedef void (*rx__test_case_config_blueprint_update_fn)( + struct rx__test_case_config_blueprint *); + +struct rx__test_case_config_desc { + const rx__test_case_config_blueprint_update_fn update; +}; + +#define RX__TEST_CASE_CONFIG(id, arg_count, args) \ + RX__STRUCT_DEFINE_UPDATE_FN( \ + RX__TEST_CASE_CONFIG_BLUEPRINT_GET_UPDATE_FN_ID(id), \ + struct rx__test_case_config_blueprint, \ + arg_count, \ + args) \ + \ + static const struct rx__test_case_config_desc \ + RX__TEST_CASE_CONFIG_DESC_GET_ID(id) \ + = {RX__TEST_CASE_CONFIG_BLUEPRINT_GET_UPDATE_FN_ID(id)}; + +/* Implementation: Test Suite O-(''Q) + -------------------------------------------------------------------------- */ + +struct rx__test_suite_desc { + const char *name; + const struct rx__test_case_config_desc *config_desc; +}; + +#define RX__TEST_SUITE_(id, config_desc) \ + static const struct rx__test_suite_desc \ + RX__TEST_SUITE_DESC_GET_ID(id) \ + = {#id, config_desc}; \ + \ + RX__TEST_SUITE_REGISTER(id) + +#define RX__TEST_SUITE_0(id) \ + RX__TEST_SUITE_(id, NULL); + +#define RX__TEST_SUITE_1(id, arg_count, args) \ + RX__TEST_CASE_CONFIG(id, arg_count, args) \ + RX__TEST_SUITE_(id, &RX__TEST_CASE_CONFIG_DESC_GET_ID(id)); + +/* Implementation: Test Case O-(''Q) + -------------------------------------------------------------------------- */ + +struct rx__test_case_desc { + const char *suite_name; + const char *name; + rx_run_fn run; + const struct rx__test_case_config_desc *config_desc; +}; + +#define RX__TEST_CASE_(suite_id, id, config_desc) \ + static void \ + suite_id##_##id(RX__DEFINE_PARAMS(void)); \ + \ + static const struct rx__test_case_desc \ + RX__TEST_CASE_DESC_GET_ID(suite_id, id) \ + = {#suite_id, \ + #id, \ + suite_id##_##id, \ + config_desc}; \ + \ + RX__TEST_CASE_REGISTER(suite_id, id); \ + \ + static void \ + suite_id##_##id(RX__DEFINE_PARAMS(void)) + +#define RX__TEST_CASE_0(suite_id, id) \ + RX__TEST_CASE_(suite_id, \ + id, \ + NULL) + +#define RX__TEST_CASE_1(suite_id, id, arg_count, args) \ + RX__TEST_CASE_CONFIG(suite_id##_##id, arg_count, args) \ + RX__TEST_CASE_(suite_id, \ + id, \ + &RX__TEST_CASE_CONFIG_DESC_GET_ID(suite_id##_##id)) + +/* Implementation: Operators O-(''Q) + -------------------------------------------------------------------------- */ + +enum rx__op { + RX__OP_EQUAL = 0, + RX__OP_NOT_EQUAL = 1, + RX__OP_GREATER = 2, + RX__OP_LESSER = 3, + RX__OP_GREATER_OR_EQUAL = 4, + RX__OP_LESSER_OR_EQUAL = 5 +}; + +static void +rx__op_get_symbol(const char **symbol, enum rx__op op) +{ + RX_ASSERT(symbol != NULL); + + switch (op) { + case RX__OP_EQUAL: + *symbol = "=="; + return; + case RX__OP_NOT_EQUAL: + *symbol = "!="; + return; + case RX__OP_GREATER: + *symbol = ">"; + return; + case RX__OP_LESSER: + *symbol = "<"; + return; + case RX__OP_GREATER_OR_EQUAL: + *symbol = ">="; + return; + case RX__OP_LESSER_OR_EQUAL: + *symbol = "<="; + return; + default: + RX_ASSERT(0); + } +} + +static void +rx__op_get_name(const char **name, enum rx__op op) +{ + RX_ASSERT(name != NULL); + + switch (op) { + case RX__OP_EQUAL: + *name = "equal to"; + return; + case RX__OP_NOT_EQUAL: + *name = "not equal to"; + return; + case RX__OP_GREATER: + *name = "greater than"; + return; + case RX__OP_LESSER: + *name = "less than"; + return; + case RX__OP_GREATER_OR_EQUAL: + *name = "greater than or equal to"; + return; + case RX__OP_LESSER_OR_EQUAL: + *name = "less than or equal to"; + return; + default: + RX_ASSERT(0); + } +} + +/* Implementation: String O-(''Q) + -------------------------------------------------------------------------- */ + +#define RX__STR_LENGTH_ID rx__length + +#define RX__STR_CREATE_VA_LIST(status, s, fmt) \ + do { \ + va_list args; \ + size_t RX__STR_LENGTH_ID; \ + \ + (s) = NULL; \ + \ + va_start(args, fmt); \ + (status) \ + = rx__str_initialize_va_list(&RX__STR_LENGTH_ID, s, fmt, args); \ + va_end(args); \ + \ + if ((status) == RX_SUCCESS) { \ + (s) = (char *)RX_MALLOC(sizeof *(s) * RX__STR_LENGTH_ID); \ + if ((s) == NULL) { \ + RX__LOG_DEBUG_1( \ + "failed to allocate the string (%lu bytes)\n", \ + (unsigned long)sizeof *(s) * RX__STR_LENGTH_ID); \ + (status) = RX_ERROR_ALLOCATION; \ + } else { \ + va_start(args, fmt); \ + (status) = rx__str_initialize_va_list( \ + &RX__STR_LENGTH_ID, s, fmt, args); \ + va_end(args); \ + if ((status) != RX_SUCCESS) { \ + RX_FREE(s); \ + } \ + } \ + } \ + } while (0) + +#define RX__STR_CREATE_(status, s, args) \ + do { \ + size_t RX__STR_LENGTH_ID; \ + \ + (s) = NULL; \ + (status) = rx__str_initialize args; \ + if ((status) == RX_SUCCESS) { \ + (s) = (char *)RX_MALLOC(sizeof *(s) * RX__STR_LENGTH_ID); \ + if ((s) == NULL) { \ + RX__LOG_DEBUG_1( \ + "failed to allocate the string (%lu bytes)\n", \ + (unsigned long)sizeof *(s) * RX__STR_LENGTH_ID); \ + (status) = RX_ERROR_ALLOCATION; \ + } else { \ + (status) = rx__str_initialize args; \ + if ((status) != RX_SUCCESS) { \ + RX_FREE(s); \ + } \ + } \ + } \ + } while (0) + +#define RX__STR_CREATE(status, s, msg) \ + RX__STR_CREATE_(status, s, (&RX__STR_LENGTH_ID, s, msg)) + +#define RX__STR_CREATE_1(status, s, fmt, _0) \ + RX__STR_CREATE_(status, s, (&RX__STR_LENGTH_ID, s, fmt, _0)) + +#define RX__STR_CREATE_2(status, s, fmt, _0, _1) \ + RX__STR_CREATE_(status, s, (&RX__STR_LENGTH_ID, s, fmt, _0, _1)) + +#define RX__STR_CREATE_3(status, s, fmt, _0, _1, _2) \ + RX__STR_CREATE_(status, s, (&RX__STR_LENGTH_ID, s, fmt, _0, _1, _2)) + +#define RX__STR_CREATE_4(status, s, fmt, _0, _1, _2, _3) \ + RX__STR_CREATE_(status, s, (&RX__STR_LENGTH_ID, s, fmt, _0, _1, _2, _3)) + +enum rx__str_case { RX__STR_CASE_OBEY = 0, RX__STR_CASE_IGNORE = 1 }; + +static void +rx__str_case_get_type(const char **type, enum rx__str_case str_case) +{ + RX_ASSERT(type != NULL); + + switch (str_case) { + case RX__STR_CASE_OBEY: + *type = "obey"; + return; + case RX__STR_CASE_IGNORE: + *type = "ignore"; + return; + default: + RX_ASSERT(0); + } +} + +RX__PRINTF_CHECK(3, 0) +static enum rx_status +rx__str_initialize_va_list(size_t *count, + char *s, + const char *fmt, + va_list args) +{ + int size; + + RX_ASSERT(count != NULL); + + if (s == NULL) { +#if defined(RX__PLATFORM_WINDOWS) + size = _vscprintf(fmt, args); +#elif RX__HAS_NPRINTF + size = vsnprintf(NULL, 0, fmt, args); +#else + { + FILE *file; + + file = fopen("/dev/null", "w"); + if (file == NULL) { + RX__LOG_DEBUG("could not open `/dev/null`\n"); + return RX_ERROR; + } + + size = vfprintf(file, fmt, args); + fclose(file); + } +#endif + + if (size < 0) { + RX__LOG_DEBUG("invalid string formatting\n"); + return RX_ERROR; + } + + *count = (size_t)size + 1; + return RX_SUCCESS; + } + +#if defined(_MSC_VER) + #pragma warning(push) + #pragma warning(disable : 4996) +#endif + size = vsprintf(s, fmt, args); +#if defined(_MSC_VER) + #pragma warning(pop) +#endif + if (size < 0) { + RX__LOG_DEBUG("unexpected string formatting error\n"); + return RX_ERROR; + } + + *count = (size_t)size + 1; + return RX_SUCCESS; +} + +RX__PRINTF_CHECK(3, 4) +static enum rx_status +rx__str_initialize(size_t *count, char *s, const char *fmt, ...) +{ + enum rx_status out; + va_list args; + + RX_ASSERT(count != NULL); + + va_start(args, fmt); + out = rx__str_initialize_va_list(count, s, fmt, args); + va_end(args); + + return out; +} + +static enum rx_status +rx__str_copy(char **s, const char *original) +{ + size_t size; + + size = strlen(original) + 1; + + *s = (char *)RX_MALLOC(sizeof **s * size); + if (*s == NULL) { + RX__LOG_DEBUG_1("failed to allocate the string (%lu bytes)\n", + (unsigned long)sizeof **s * size); + return RX_ERROR_ALLOCATION; + } + + memcpy(*s, original, size); + return RX_SUCCESS; +} + +/* Implementation: Helpers O-(''Q) + -------------------------------------------------------------------------- */ + +static int +rx__compare_test_cases(const void *a, const void *b) +{ + int out; + const struct rx_test_case *aa; + const struct rx_test_case *bb; + + aa = (const struct rx_test_case *)a; + bb = (const struct rx_test_case *)b; + + out = strcmp(aa->suite_name, bb->suite_name); + if (out != 0) { + return out; + } + + return strcmp(aa->name, bb->name); +} + +static int +rx__compare_summaries_by_test_suite(const void *a, const void *b) +{ + const struct rx_summary *aa; + const struct rx_summary *bb; + + aa = (const struct rx_summary *)a; + bb = (const struct rx_summary *)b; + return strcmp(aa->test_case->suite_name, bb->test_case->suite_name); +} + +static void +rx__real_are_equal_fuzzy(int *result, rx__real a, rx__real b, rx__real tol) +{ + rx__real diff; + rx__real abs_a; + rx__real abs_b; + + diff = a > b ? a - b : b - a; + if (diff <= tol) { + *result = 1; + return; + } + + abs_a = a < 0 ? -a : a; + abs_b = b < 0 ? -b : b; + *result = diff <= (abs_a > abs_b ? abs_a : abs_b) * tol; +} + +static void +rx__str_are_equal(int *result, const char *a, const char *b) +{ + while (*a != '\0') { + if (*a != *b) { + *result = 0; + return; + } + + ++a; + ++b; + } + + *result = *a == *b; +} + +static void +rx__str_are_equal_no_case(int *result, const char *a, const char *b) +{ + while (*a != '\0') { + if (tolower(*a) != tolower(*b)) { + *result = 0; + return; + } + + ++a; + ++b; + } + + *result = tolower(*a) == tolower(*b); +} + +RX__MAYBE_UNUSED static enum rx_status +rx__run_test_cases(size_t test_case_count, + const struct rx_test_case *test_cases) +{ + size_t i; + enum rx_status status; + struct rx_summary *summaries; + + if (test_case_count == 0) { + RX__LOG_INFO("nothing to run\n"); + return RX_SUCCESS; + } + + RX_ASSERT(test_cases != NULL); + + summaries = (struct rx_summary *)RX_MALLOC(sizeof *summaries + * test_case_count); + if (summaries == NULL) { + RX__LOG_DEBUG("failed to allocate the summaries\n"); + return RX_ERROR_ALLOCATION; + } + + status = RX_SUCCESS; + + for (i = 0; i < test_case_count;) { + const struct rx_test_case *test_case; + struct rx_summary *summary; + + test_case = &test_cases[i]; + summary = &summaries[i]; + + RX_ASSERT(test_case->suite_name != NULL); + RX_ASSERT(test_case->name != NULL); + + status = rx_summary_initialize(summary, test_case); + if (status != RX_SUCCESS) { + RX__LOG_ERROR_2("failed to initialize the summary " + "(suite: \"%s\", case: \"%s\")\n", + test_case->suite_name, + test_case->name); + goto summaries_cleanup; + } + + ++i; + + status = rx_test_case_run(summary, test_case); + if (status != RX_SUCCESS) { + RX__LOG_ERROR_2("failed to run a test case " + "(suite: \"%s\", case: \"%s\")\n", + test_case->suite_name, + test_case->name); + goto summaries_cleanup; + } + + rx_summary_print(summary); + } + + if (status == RX_SUCCESS) { + size_t j; + + for (j = 0; j < test_case_count; ++j) { + size_t k; + struct rx_summary *summary; + + summary = &summaries[j]; + + for (k = 0; k < summary->failure_count; ++k) { + const struct rx_failure *failure; + + failure = &summary->failures[k]; + if (failure->severity == RX_FATAL) { + status = RX_ERROR_ABORTED; + goto summaries_cleanup; + } + } + } + } + +summaries_cleanup: + while (i-- > 0) { + rx_summary_terminate(&summaries[i]); + } + + RX_FREE(summaries); + + return status; +} + +RX__MAYBE_UNUSED static enum rx_status +rx__run_registered_test_cases(void) +{ + enum rx_status out; + rx_size test_case_count; + struct rx_test_case *test_cases; + + rx_enumerate_test_cases(&test_case_count, NULL); + if (test_case_count == 0) { + return rx__run_test_cases(0, NULL); + } + + test_cases = (struct rx_test_case *)RX_MALLOC(sizeof *test_cases + * test_case_count); + if (test_cases == NULL) { + RX__LOG_ERROR("failed to allocate the test cases\n"); + return RX_ERROR_ALLOCATION; + } + + rx_enumerate_test_cases(&test_case_count, test_cases); + out = rx__run_test_cases(test_case_count, test_cases); + RX_FREE(test_cases); + return out; +} + +/* Implementation: Test Assessments O-(''Q) + -------------------------------------------------------------------------- */ + +RX__PRINTF_CHECK(8, 0) +RX__MAYBE_UNUSED static void +rx__assess_value(struct rx_context *context, + int x, + int expected, + const char *expr, + const char *file, + int line, + enum rx_severity severity, + const char *failure_fmt, + ...) +{ + int result; + char *failure_msg; + char *diagnostic_msg; + + RX_ASSERT(context != NULL); + RX_ASSERT(file != NULL); + + result = ((x && expected) || (!x && !expected)); + + if (result) { + failure_msg = NULL; + diagnostic_msg = NULL; + } else { + enum rx_status status; + + if (failure_fmt == NULL) { + RX__STR_CREATE_1(status, + failure_msg, + "`%s` is expected to evaluate to true", + expr); + } else { + RX__STR_CREATE_VA_LIST(status, failure_msg, failure_fmt); + } + + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the failure message for " + "the test located at %s:%d\n", + file, + line); + failure_msg = NULL; + } + + RX__STR_CREATE_1(status, diagnostic_msg, "%d", x); + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the diagnostic message for " + "the test located at %s:%d\n", + file, + line); + diagnostic_msg = NULL; + } + } + + if (rx_handle_test_result( + context, result, file, line, severity, failure_msg, diagnostic_msg) + != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to handle the test result for the test " + "located at %s:%d\n", + file, + line); + } + + RX_FREE(failure_msg); + RX_FREE(diagnostic_msg); + + if (!result && severity == RX_FATAL) { + rx_abort(context); + } +} + +RX__PRINTF_CHECK(8, 0) +RX__MAYBE_UNUSED static void +rx__bool_assess_value(struct rx_context *context, + int x, + int expected, + const char *expr, + const char *file, + int line, + enum rx_severity severity, + const char *failure_fmt, + ...) +{ + int result; + char *failure_msg; + char *diagnostic_msg; + + RX_ASSERT(context != NULL); + RX_ASSERT(expr != NULL); + RX_ASSERT(file != NULL); + + result = ((x && expected) || (!x && !expected)); + + if (result) { + failure_msg = NULL; + diagnostic_msg = NULL; + } else { + enum rx_status status; + + if (failure_fmt == NULL) { + RX__STR_CREATE_2(status, + failure_msg, + "`%s` is expected to be %s", + expr, + expected ? "true" : "false"); + } else { + RX__STR_CREATE_VA_LIST(status, failure_msg, failure_fmt); + } + + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the failure message for " + "the boolean test located at %s:%d\n", + file, + line); + failure_msg = NULL; + } + + RX__STR_CREATE_2(status, diagnostic_msg, "%d == %d", x, expected); + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the diagnostic message for " + "the boolean test located at %s:%d\n", + file, + line); + diagnostic_msg = NULL; + } + } + + if (rx_handle_test_result( + context, result, file, line, severity, failure_msg, diagnostic_msg) + != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to handle the test result for the boolean test " + "located at %s:%d\n", + file, + line); + } + + RX_FREE(failure_msg); + RX_FREE(diagnostic_msg); + + if (!result && severity == RX_FATAL) { + rx_abort(context); + } +} + +RX__PRINTF_CHECK(10, 0) +RX__MAYBE_UNUSED static void +rx__int_assess_comparison(struct rx_context *context, + rx__int x1, + rx__int x2, + enum rx__op op, + const char *expr1, + const char *expr2, + const char *file, + int line, + enum rx_severity severity, + const char *failure_fmt, + ...) +{ + int result; + char *failure_msg; + char *diagnostic_msg; + + RX_ASSERT(context != NULL); + RX_ASSERT(expr1 != NULL); + RX_ASSERT(expr2 != NULL); + RX_ASSERT(file != NULL); + + switch (op) { + case RX__OP_EQUAL: + result = x1 == x2; + break; + case RX__OP_NOT_EQUAL: + result = x1 != x2; + break; + case RX__OP_GREATER: + result = x1 > x2; + break; + case RX__OP_LESSER: + result = x1 < x2; + break; + case RX__OP_GREATER_OR_EQUAL: + result = x1 >= x2; + break; + case RX__OP_LESSER_OR_EQUAL: + result = x1 <= x2; + break; + default: + RX_ASSERT(0); + result = 0; + break; + } + + if (result) { + failure_msg = NULL; + diagnostic_msg = NULL; + } else { + enum rx_status status; + const char *op_symbol; + + if (failure_fmt == NULL) { + const char *op_name; + + rx__op_get_name(&op_name, op); + RX__STR_CREATE_3(status, + failure_msg, + "`%s` is expected to be %s `%s`", + expr1, + op_name, + expr2); + } else { + RX__STR_CREATE_VA_LIST(status, failure_msg, failure_fmt); + } + + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the failure message for " + "the integer comparison test located at %s:%d\n", + file, + line); + failure_msg = NULL; + } + + rx__op_get_symbol(&op_symbol, op); + RX__STR_CREATE_3(status, + diagnostic_msg, + "%ld %s %ld", + (long)x1, + op_symbol, + (long)x2); + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the diagnostic message for " + "the integer comparison test located at %s:%d\n", + file, + line); + diagnostic_msg = NULL; + } + } + + if (rx_handle_test_result( + context, result, file, line, severity, failure_msg, diagnostic_msg) + != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to handle the test result for the integer " + "comparison test located at %s:%d\n", + file, + line); + } + + RX_FREE(failure_msg); + RX_FREE(diagnostic_msg); + + if (!result && severity == RX_FATAL) { + rx_abort(context); + } +} + +RX__PRINTF_CHECK(10, 0) +RX__MAYBE_UNUSED static void +rx__uint_assess_comparison(struct rx_context *context, + rx__uint x1, + rx__uint x2, + enum rx__op op, + const char *expr1, + const char *expr2, + const char *file, + int line, + enum rx_severity severity, + const char *failure_fmt, + ...) +{ + int result; + char *failure_msg; + char *diagnostic_msg; + + RX_ASSERT(context != NULL); + RX_ASSERT(expr1 != NULL); + RX_ASSERT(expr2 != NULL); + RX_ASSERT(file != NULL); + + switch (op) { + case RX__OP_EQUAL: + result = x1 == x2; + break; + case RX__OP_NOT_EQUAL: + result = x1 != x2; + break; + case RX__OP_GREATER: + result = x1 > x2; + break; + case RX__OP_LESSER: + result = x1 < x2; + break; + case RX__OP_GREATER_OR_EQUAL: + result = x1 >= x2; + break; + case RX__OP_LESSER_OR_EQUAL: + result = x1 <= x2; + break; + default: + RX_ASSERT(0); + result = 0; + break; + } + + if (result) { + failure_msg = NULL; + diagnostic_msg = NULL; + } else { + enum rx_status status; + const char *op_symbol; + + if (failure_fmt == NULL) { + const char *op_name; + + rx__op_get_name(&op_name, op); + RX__STR_CREATE_3(status, + failure_msg, + "`%s` is expected to be %s `%s`", + expr1, + op_name, + expr2); + } else { + RX__STR_CREATE_VA_LIST(status, failure_msg, failure_fmt); + } + + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the failure message for " + "the unsigned integer comparison test located at " + "%s:%d\n", + file, + line); + failure_msg = NULL; + } + + rx__op_get_symbol(&op_symbol, op); + RX__STR_CREATE_3(status, + diagnostic_msg, + "%lu %s %lu", + (unsigned long)x1, + op_symbol, + (unsigned long)x2); + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the diagnostic message for " + "the unsigned integer comparison test located at " + "%s:%d\n", + file, + line); + diagnostic_msg = NULL; + } + } + + if (rx_handle_test_result( + context, result, file, line, severity, failure_msg, diagnostic_msg) + != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to handle the test result for the unsigned " + "integer comparison test located at %s:%d\n", + file, + line); + } + + RX_FREE(failure_msg); + RX_FREE(diagnostic_msg); + + if (!result && severity == RX_FATAL) { + rx_abort(context); + } +} + +RX__PRINTF_CHECK(10, 0) +RX__MAYBE_UNUSED static void +rx__real_assess_comparison(struct rx_context *context, + rx__real x1, + rx__real x2, + enum rx__op op, + const char *expr1, + const char *expr2, + const char *file, + int line, + enum rx_severity severity, + const char *failure_fmt, + ...) +{ + int result; + char *failure_msg; + char *diagnostic_msg; + + RX_ASSERT(context != NULL); + RX_ASSERT(expr1 != NULL); + RX_ASSERT(expr2 != NULL); + RX_ASSERT(file != NULL); + + switch (op) { +#if defined(__GNUC__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wfloat-equal" +#endif + case RX__OP_EQUAL: + result = x1 == x2; + break; + case RX__OP_NOT_EQUAL: + result = x1 != x2; + break; +#if defined(__GNUC__) + #pragma GCC diagnostic pop +#endif + case RX__OP_GREATER: + result = x1 > x2; + break; + case RX__OP_LESSER: + result = x1 < x2; + break; + case RX__OP_GREATER_OR_EQUAL: + result = x1 >= x2; + break; + case RX__OP_LESSER_OR_EQUAL: + result = x1 <= x2; + break; + default: + RX_ASSERT(0); + result = 0; + break; + } + + if (result) { + failure_msg = NULL; + diagnostic_msg = NULL; + } else { + enum rx_status status; + const char *op_symbol; + + if (failure_fmt == NULL) { + const char *op_name; + + rx__op_get_name(&op_name, op); + RX__STR_CREATE_3(status, + failure_msg, + "`%s` is expected to be %s `%s`", + expr1, + op_name, + expr2); + } else { + RX__STR_CREATE_VA_LIST(status, failure_msg, failure_fmt); + } + + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the failure message for " + "the real comparison test located at %s:%d\n", + file, + line); + failure_msg = NULL; + } + + rx__op_get_symbol(&op_symbol, op); + RX__STR_CREATE_3( + status, diagnostic_msg, "%Lf %s %Lf", x1, op_symbol, x2); + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the diagnostic message for " + "the real comparison test located at %s:%d\n", + file, + line); + diagnostic_msg = NULL; + } + } + + if (rx_handle_test_result( + context, result, file, line, severity, failure_msg, diagnostic_msg) + != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to handle the test result for the real " + "comparison test located at %s:%d\n", + file, + line); + } + + RX_FREE(failure_msg); + RX_FREE(diagnostic_msg); + + if (!result && severity == RX_FATAL) { + rx_abort(context); + } +} + +RX__PRINTF_CHECK(11, 0) +RX__MAYBE_UNUSED static void +rx__real_assess_fuzzy_comparison(struct rx_context *context, + rx__real x1, + rx__real x2, + rx__real tol, + enum rx__op op, + const char *expr1, + const char *expr2, + const char *file, + int line, + enum rx_severity severity, + const char *failure_fmt, + ...) +{ + int result; + char *failure_msg; + char *diagnostic_msg; + + RX_ASSERT(context != NULL); + RX_ASSERT(expr1 != NULL); + RX_ASSERT(expr2 != NULL); + RX_ASSERT(file != NULL); + + switch (op) { + case RX__OP_EQUAL: + rx__real_are_equal_fuzzy(&result, x1, x2, tol); + break; + case RX__OP_NOT_EQUAL: + rx__real_are_equal_fuzzy(&result, x1, x2, tol); + result = !result; + break; + default: + RX_ASSERT(0); + result = 0; + break; + } + + if (result) { + failure_msg = NULL; + diagnostic_msg = NULL; + } else { + enum rx_status status; + const char *op_symbol; + + if (failure_fmt == NULL) { + const char *op_name; + + rx__op_get_name(&op_name, op); + RX__STR_CREATE_4(status, + failure_msg, + "`%s` is expected to be almost %s `%s` " + "(tolerance: %Lf)", + expr1, + op_name, + expr2, + tol); + } else { + RX__STR_CREATE_VA_LIST(status, failure_msg, failure_fmt); + } + + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the failure message for " + "the real almost equal test located at %s:%d\n", + file, + line); + failure_msg = NULL; + } + + rx__op_get_symbol(&op_symbol, op); + RX__STR_CREATE_3( + status, diagnostic_msg, "%Lf %s %Lf", x1, op_symbol, x2); + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the diagnostic message for " + "the real almost equal test located at %s:%d\n", + file, + line); + diagnostic_msg = NULL; + } + } + + if (rx_handle_test_result( + context, result, file, line, severity, failure_msg, diagnostic_msg) + != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to handle the test result for the real " + "almost equal test located at %s:%d\n", + file, + line); + } + + RX_FREE(failure_msg); + RX_FREE(diagnostic_msg); + + if (!result && severity == RX_FATAL) { + rx_abort(context); + } +} + +RX__PRINTF_CHECK(11, 0) +RX__MAYBE_UNUSED static void +rx__str_assess_comparison(struct rx_context *context, + const char *s1, + const char *s2, + enum rx__str_case str_case, + enum rx__op op, + const char *expr1, + const char *expr2, + const char *file, + int line, + enum rx_severity severity, + const char *failure_fmt, + ...) +{ + int result; + char *failure_msg; + char *diagnostic_msg; + + RX_ASSERT(context != NULL); + RX_ASSERT(s1 != NULL); + RX_ASSERT(s2 != NULL); + RX_ASSERT(expr1 != NULL); + RX_ASSERT(expr2 != NULL); + RX_ASSERT(file != NULL); + + switch (op) { + case RX__OP_EQUAL: + str_case == RX__STR_CASE_OBEY + ? rx__str_are_equal(&result, s1, s2) + : rx__str_are_equal_no_case(&result, s1, s2); + break; + case RX__OP_NOT_EQUAL: + str_case == RX__STR_CASE_OBEY + ? rx__str_are_equal(&result, s1, s2) + : rx__str_are_equal_no_case(&result, s1, s2); + result = !result; + break; + default: + RX_ASSERT(0); + result = 0; + break; + } + + if (result) { + failure_msg = NULL; + diagnostic_msg = NULL; + } else { + enum rx_status status; + const char *op_symbol; + + if (failure_fmt == NULL) { + const char *str_case_type; + const char *op_name; + + rx__str_case_get_type(&str_case_type, str_case); + rx__op_get_name(&op_name, op); + RX__STR_CREATE_4(status, + failure_msg, + "`%s` is expected to be %s `%s` (case: %s)", + expr1, + op_name, + expr2, + str_case_type); + } else { + RX__STR_CREATE_VA_LIST(status, failure_msg, failure_fmt); + } + + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the failure message for " + "the string comparison test located at %s:%d\n", + file, + line); + failure_msg = NULL; + } + + rx__op_get_symbol(&op_symbol, op); + RX__STR_CREATE_3( + status, diagnostic_msg, "\"%s\" %s \"%s\"", s1, op_symbol, s2); + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the diagnostic message for " + "the string comparison test located at %s:%d\n", + file, + line); + diagnostic_msg = NULL; + } + } + + if (rx_handle_test_result( + context, result, file, line, severity, failure_msg, diagnostic_msg) + != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to handle the test result for the string " + "comparison test located at %s:%d\n", + file, + line); + } + + RX_FREE(failure_msg); + RX_FREE(diagnostic_msg); + + if (!result && severity == RX_FATAL) { + rx_abort(context); + } +} + +RX__PRINTF_CHECK(10, 0) +RX__MAYBE_UNUSED static void +rx__ptr_assess_comparison(struct rx_context *context, + void *x1, + void *x2, + enum rx__op op, + const char *expr1, + const char *expr2, + const char *file, + int line, + enum rx_severity severity, + const char *failure_fmt, + ...) +{ + int result; + char *failure_msg; + char *diagnostic_msg; + + RX_ASSERT(context != NULL); + RX_ASSERT(expr1 != NULL); + RX_ASSERT(expr2 != NULL); + RX_ASSERT(file != NULL); + + switch (op) { + case RX__OP_EQUAL: + result = x1 == x2; + break; + case RX__OP_NOT_EQUAL: + result = x1 != x2; + break; + default: + RX_ASSERT(0); + result = 0; + break; + } + + if (result) { + failure_msg = NULL; + diagnostic_msg = NULL; + } else { + enum rx_status status; + const char *op_symbol; + + if (failure_fmt == NULL) { + const char *op_name; + + rx__op_get_name(&op_name, op); + RX__STR_CREATE_3(status, + failure_msg, + "`%s` is expected to be %s `%s`", + expr1, + op_name, + expr2); + } else { + RX__STR_CREATE_VA_LIST(status, failure_msg, failure_fmt); + } + + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the failure message for " + "the pointer comparison test located at " + "%s:%d\n", + file, + line); + failure_msg = NULL; + } + + rx__op_get_symbol(&op_symbol, op); + RX__STR_CREATE_3(status, + diagnostic_msg, + "0x%08lx %s 0x%08lx", + (uintptr_t)x1, + op_symbol, + (uintptr_t)x2); + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the diagnostic message for " + "the pointer comparison test located at " + "%s:%d\n", + file, + line); + diagnostic_msg = NULL; + } + } + + if (rx_handle_test_result( + context, result, file, line, severity, failure_msg, diagnostic_msg) + != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to handle the test result for the pointer " + "comparison test located at %s:%d\n", + file, + line); + } + + RX_FREE(failure_msg); + RX_FREE(diagnostic_msg); + + if (!result && severity == RX_FATAL) { + rx_abort(context); + } +} + +RX__PRINTF_CHECK(8, 0) +RX__MAYBE_UNUSED static void +rx__ptr_assess_alignment(struct rx_context *context, + void *x, + size_t alignment, + const char *expr, + const char *file, + int line, + enum rx_severity severity, + const char *failure_fmt, + ...) +{ + int result; + char *failure_msg; + char *diagnostic_msg; + + RX_ASSERT(context != NULL); + RX_ASSERT(expr != NULL); + RX_ASSERT(file != NULL); + + result = (uintptr_t)x % alignment == 0; + + if (result) { + failure_msg = NULL; + diagnostic_msg = NULL; + } else { + enum rx_status status; + + if (failure_fmt == NULL) { + RX__STR_CREATE_2(status, + failure_msg, + "`%s` is expected to have an %lu-byte alignment", + expr, + (unsigned long)alignment); + } else { + RX__STR_CREATE_VA_LIST(status, failure_msg, failure_fmt); + } + + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the failure message for " + "the pointer alignment test located at " + "%s:%d\n", + file, + line); + failure_msg = NULL; + } + + RX__STR_CREATE_2(status, + diagnostic_msg, + "0x%08lx %% %lu != 0", + (uintptr_t)x, + (unsigned long)alignment); + if (status != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to create the diagnostic message for " + "the pointer alignment test located at " + "%s:%d\n", + file, + line); + diagnostic_msg = NULL; + } + } + + if (rx_handle_test_result( + context, result, file, line, severity, failure_msg, diagnostic_msg) + != RX_SUCCESS) { + RX__LOG_DEBUG_2("failed to handle the test result for the pointer " + "alignment test located at %s:%d\n", + file, + line); + } + + RX_FREE(failure_msg); + RX_FREE(diagnostic_msg); + + if (!result && severity == RX_FATAL) { + rx_abort(context); + } +} + +/* Implementation: Public API O-(''Q) + -------------------------------------------------------------------------- */ + +RX__MAYBE_UNUSED RX__STORAGE void +rx_abort(struct rx_context *context) +{ + longjmp(context->env, 1); +} + +RX__MAYBE_UNUSED RX__STORAGE enum rx_status +rx_handle_test_result(struct rx_context *context, + int result, + const char *file, + int line, + enum rx_severity severity, + const char *failure_msg, + const char *diagnostic_msg) +{ + enum rx_status status; + struct rx_summary *summary; + struct rx_failure *failure; + size_t failure_count; + + RX_ASSERT(context != NULL); + RX_ASSERT(context->summary != NULL); + RX_ASSERT(context->summary->failures != NULL); + RX_ASSERT(file != NULL); + + summary = context->summary; + + ++summary->assessed_count; + + if (result) { + return RX_SUCCESS; + } + + status + = rx__test_failure_array_extend_back(&failure, &summary->failures, 1); + if (status != RX_SUCCESS) { + summary->error = "failed to extend the test failure array\0"; + RX__LOG_ERROR_2("failed to extend the test failure array for the test " + "located at %s:%d\n", + file, + line); + return status; + } + + rx__test_failure_array_get_size(&failure_count, summary->failures); + summary->failure_count = failure_count; + + { + char *buf; + + status = rx__str_copy(&buf, file); + if (status != RX_SUCCESS) { + RX__LOG_ERROR_2("failed to allocate the file name for the test " + "located at %s:%d\n", + file, + line); + failure->file = NULL; + } else { + failure->file = buf; + } + } + + failure->line = line; + failure->severity = severity; + + if (failure_msg == NULL) { + failure->msg = NULL; + } else { + char *buf; + + status = rx__str_copy(&buf, failure_msg); + if (status != RX_SUCCESS) { + RX__LOG_ERROR_2("failed to allocate the failure message for " + "the test located at %s:%d\n", + file, + line); + failure->msg = NULL; + } else { + failure->msg = buf; + } + } + + if (diagnostic_msg == NULL) { + failure->diagnostic_msg = NULL; + } else { + char *buf; + + status = rx__str_copy(&buf, diagnostic_msg); + if (status != RX_SUCCESS) { + RX__LOG_ERROR_2("failed to allocate the diagnostic message for " + "the test located at %s:%d\n", + file, + line); + failure->diagnostic_msg = NULL; + } else { + failure->diagnostic_msg = buf; + } + } + + return RX_SUCCESS; +} + +RX__MAYBE_UNUSED RX__STORAGE enum rx_status +rx_summary_initialize(struct rx_summary *summary, + const struct rx_test_case *test_case) +{ + enum rx_status status; + + RX_ASSERT(summary != NULL); + RX_ASSERT(test_case != NULL); + + memset(summary, 0, sizeof *summary); + + status = rx__test_failure_array_create(&summary->failures, 0); + if (status != RX_SUCCESS) { + RX__LOG_ERROR_2("failed to create the test failure array " + "(suite: \"%s\", case: \"%s\")\n", + test_case->suite_name, + test_case->name); + return status; + } + + summary->test_case = test_case; + return RX_SUCCESS; +} + +RX__MAYBE_UNUSED RX__STORAGE void +rx_summary_terminate(struct rx_summary *summary) +{ + size_t i; + + RX_ASSERT(summary != NULL); + RX_ASSERT(summary->failures != NULL); + + for (i = 0; i < summary->failure_count; ++i) { + const struct rx_failure *failure; + + failure = &summary->failures[i]; + + RX_FREE((void *)(uintptr_t)failure->file); + RX_FREE((void *)(uintptr_t)failure->msg); + RX_FREE((void *)(uintptr_t)failure->diagnostic_msg); + } + + rx__test_failure_array_destroy(summary->failures); +} + +RX__MAYBE_UNUSED RX__STORAGE void +rx_summary_print(const struct rx_summary *summary) +{ + size_t i; + int passed; + const char *style_begin; + const char *style_end; + + RX_ASSERT(summary != NULL); + RX_ASSERT(summary->test_case != NULL); + RX_ASSERT(summary->test_case->suite_name != NULL); + RX_ASSERT(summary->test_case->name != NULL); + RX_ASSERT(summary->failures != NULL); + + passed = summary->failure_count == 0; + +#if RX__LOG_STYLING + if (RX__ISATTY(RX__FILENO(stderr))) { + rx__log_style_get_ansi_code( + &style_begin, + passed ? RX__LOG_STYLE_BRIGHT_GREEN : RX__LOG_STYLE_BRIGHT_RED); + rx__log_style_get_ansi_code(&style_end, RX__LOG_STYLE_RESET); + } else { + style_begin = style_end = ""; + } +#else + style_begin = style_end = ""; +#endif + + fprintf(stderr, + "[%s%s%s] \"%s\" / \"%s\" (%f ms)\n", + style_begin, + passed ? "PASSED" : "FAILED", + style_end, + summary->test_case->suite_name, + summary->test_case->name, + (double)summary->elapsed * (1000.0 / RX__TICKS_PER_SECOND)); + + for (i = 0; i < summary->failure_count; ++i) { + const struct rx_failure *failure; + const char *failure_msg; + + failure = &summary->failures[i]; + failure_msg = failure->msg == NULL ? "" : failure->msg; + + if (failure->diagnostic_msg != NULL) { + fprintf(stderr, + "%s:%d: %s test failure: %s\n%s\n", + failure->file, + failure->line, + failure->severity == RX_FATAL ? "fatal" : "nonfatal", + failure_msg, + failure->diagnostic_msg); + } else { + fprintf(stderr, + "%s:%d: %s test failure: %s\n", + failure->file, + failure->line, + failure->severity == RX_FATAL ? "fatal" : "nonfatal", + failure_msg); + } + } +} + +RX__MAYBE_UNUSED RX__STORAGE void +rx_sort_summaries_by_test_suite(struct rx_summary *summaries, + rx_size summary_count) +{ + qsort(summaries, + summary_count, + sizeof *summaries, + rx__compare_summaries_by_test_suite); +} + +RX__MAYBE_UNUSED RX__STORAGE void +rx_group_summaries_by_test_suite(rx_size *summary_group_count, + struct rx_summary_group *summary_groups, + rx_size summary_count, + const struct rx_summary *summaries) +{ + size_t i; + struct rx_summary_group *it; + + RX_ASSERT(summary_group_count != NULL); + + if (summary_count == 0) { + *summary_group_count = 0; + return; + } + + RX_ASSERT(summaries != NULL); + + if (summary_groups == NULL) { + *summary_group_count = 1; + for (i = 0; i < summary_count - 1; ++i) { + *summary_group_count += (rx_size)( + rx__compare_summaries_by_test_suite(&summaries[i], + &summaries[i + 1]) + != 0); + } + + return; + } + + it = summary_groups; + it->count = 0; + it->array = summaries; + for (i = 0; i < summary_count - 1; ++i) { + ++it->count; + + if (rx__compare_summaries_by_test_suite(&summaries[i], + &summaries[i + 1]) + != 0) { + ++it; + it->count = 0; + it->array = &summaries[i + 1]; + } + } + + ++it->count; +} + +RX__MAYBE_UNUSED RX__STORAGE enum rx_status +rx_test_case_run(struct rx_summary *summary, + const struct rx_test_case *test_case) +{ + enum rx_status status; + struct rx_context context; + void *data; + uint64_t time_begin; + uint64_t time_end; + + RX_ASSERT(summary != NULL); + RX_ASSERT(test_case != NULL); + RX_ASSERT(test_case->suite_name != NULL); + RX_ASSERT(test_case->name != NULL); + RX_ASSERT(test_case->run != NULL); + + if (test_case->config.skip) { + summary->skipped = 1; + return RX_SUCCESS; + } + + status = RX_SUCCESS; + context.summary = summary; + + if (test_case->config.fixture.size > 0) { + data = RX_MALLOC(test_case->config.fixture.size); + if (data == NULL) { + summary->error = "failed to allocate the data\0"; + RX__LOG_ERROR_2("failed to allocate the data" + "(suite: \"%s\", case: \"%s\")\n", + test_case->suite_name, + test_case->name); + return RX_ERROR_ALLOCATION; + } + } else { + data = NULL; + } + + if (test_case->config.fixture.config.set_up != NULL) { + status = test_case->config.fixture.config.set_up(&context, data); + if (status != RX_SUCCESS) { + summary->error = "failed to set-up the fixture\0"; + RX__LOG_ERROR_2("failed to set-up the fixture " + "(suite: \"%s\", case: \"%s\")\n", + test_case->suite_name, + test_case->name); + goto data_cleanup; + } + } + + if (rx__get_real_time(&time_begin) != RX_SUCCESS) { + time_begin = (uint64_t)-1; + } + + if (setjmp(context.env) == 0) { + test_case->run(&context, data); + } + + if (time_begin == (uint64_t)-1 + || rx__get_real_time(&time_end) != RX_SUCCESS) { + RX__LOG_ERROR_2("failed to measure the time elapsed " + "(suite: \"%s\", case: \"%s\")\n", + test_case->suite_name, + test_case->name); + summary->elapsed = 0; + } else { + RX_ASSERT(time_end >= time_begin); + summary->elapsed = (rx_uint64)(time_end - time_begin); + } + + if (test_case->config.fixture.config.tear_down != NULL) { + test_case->config.fixture.config.tear_down(&context, data); + } + +data_cleanup: + RX_FREE(data); + return status; +} + +RX__MAYBE_UNUSED RX__STORAGE void +rx_enumerate_test_cases(rx_size *test_case_count, + struct rx_test_case *test_cases) +{ + size_t i; + const struct rx__test_case_desc * const *c_it; + + RX_ASSERT(test_case_count != NULL); + + if (test_cases == NULL) { + *test_case_count = 0; + for (c_it = RX__TEST_CASE_SECTION_BEGIN; + c_it != RX__TEST_CASE_SECTION_END; + ++c_it) { + *test_case_count += (rx_size)(*c_it != NULL); + } + + return; + } + + i = 0; + for (c_it = RX__TEST_CASE_SECTION_BEGIN; + c_it != RX__TEST_CASE_SECTION_END; + ++c_it) { + const struct rx__test_suite_desc * const *s_it; + struct rx__test_case_config_blueprint config_blueprint; + struct rx_test_case *test_case; + + if (*c_it == NULL) { + continue; + } + + /* Find the corresponding test suite description, if any. */ + for (s_it = RX__TEST_SUITE_SECTION_BEGIN; + s_it != RX__TEST_SUITE_SECTION_END; + ++s_it) { + if (*s_it == NULL) { + continue; + } + + if (strcmp((*s_it)->name, (*c_it)->suite_name) == 0) { + break; + } + } + + memset(&config_blueprint, 0, sizeof config_blueprint); + + if (s_it != RX__TEST_SUITE_SECTION_END + && (*s_it)->config_desc != NULL) { + /* Inherit the config from the test suite's description. */ + (*s_it)->config_desc->update(&config_blueprint); + } + + if ((*c_it)->config_desc != NULL) { + /* Inherit the config from the test case's description. */ + (*c_it)->config_desc->update(&config_blueprint); + } + + test_case = &test_cases[i]; + + test_case->suite_name = (*c_it)->suite_name; + test_case->name = (*c_it)->name; + test_case->run = (*c_it)->run; + + test_case->config.skip = config_blueprint.skip; + + memset(&test_case->config.fixture, 0, sizeof test_case->config.fixture); + + if (config_blueprint.fixture != NULL) { + test_case->config.fixture.size = config_blueprint.fixture->size; + + if (config_blueprint.fixture->update != NULL) { + config_blueprint.fixture->update( + &test_case->config.fixture.config); + } + } + + ++i; + } + + RX_ASSERT(i == *test_case_count); + + /* Objects that are defined in a custom memory section can only be retrieved + in an undefined order, so these need to be manually sorted afterwards + in a sensible way. */ + qsort(test_cases, + *test_case_count, + sizeof *test_cases, + rx__compare_test_cases); +} + +RX__MAYBE_UNUSED RX__STORAGE enum rx_status +rx_run(rx_size test_case_count, const struct rx_test_case *test_cases) +{ + if (test_cases != NULL) { + return rx__run_test_cases(test_case_count, test_cases); + } + + /* If no test cases are explicitly passed, fallback to discovering the + ones defined through the automatic registration framework. */ + return rx__run_registered_test_cases(); +} + +RX__MAYBE_UNUSED RX__STORAGE enum rx_status +rx_main(rx_size test_case_count, + const struct rx_test_case *test_cases, + int argc, + const char **argv) +{ + RX__UNUSED(argc); + RX__UNUSED(argv); + + return rx_run(test_case_count, test_cases); +} + +#endif /* REXO_REXO_H */
--- a/test/unicode.c Mon Oct 11 20:57:32 2021 +0200 +++ b/test/unicode.c Mon Oct 11 20:57:47 2021 +0200 @@ -1,5 +1,5 @@ /* - * unicode.c -- main test file for unicode (C version) + * unicode.c -- main test file for unicode * * Copyright (c) 2013-2021 David Demelier <markand@malikania.fr> * @@ -18,8 +18,7 @@ #include <errno.h> -#define GREATEST_USE_ABBREVS 0 -#include <greatest.h> +#include <rexo.h> #include "unicode.h" @@ -47,8 +46,7 @@ return l1 == l2 && memcmp(s1, s2, l1) == 0; } -GREATEST_TEST -test_uni8_encode_basic(void) +RX_TEST_CASE(uni8_encode, simple) { size_t r; @@ -57,8 +55,8 @@ uint8_t buffer[5] = { 0 }; r = uni8_encode(buffer, sizeof (buffer), U'a'); - GREATEST_ASSERT_EQ(r, 1); - GREATEST_ASSERT_STR_EQ(buffer, u8"a"); + RX_INT_REQUIRE_EQUAL(r, 1); + RX_STR_REQUIRE_EQUAL((const char *)buffer, (const char *)u8"a"); } /* é -> 2 bytes. */ @@ -66,46 +64,32 @@ uint8_t buffer[5] = { 0 }; r = uni8_encode(buffer, sizeof (buffer), U'é'); - GREATEST_ASSERT_EQ(r, 2); - GREATEST_ASSERT_STR_EQ(buffer, u8"é"); + RX_INT_REQUIRE_EQUAL(r, 2); + RX_STR_REQUIRE_EQUAL((const char *)buffer, (const char *)u8"é"); } - - GREATEST_PASS(); } -GREATEST_TEST -test_uni8_encode_invalid(void) +RX_TEST_CASE(uni8_encode, invalid) { size_t r; uint8_t buffer[5] = { 0 }; r = uni8_encode(buffer, sizeof (buffer), 0xffffffff); - GREATEST_ASSERT_EQ(r, (size_t)-1); - GREATEST_ASSERT_EQ(errno, EILSEQ); - GREATEST_PASS(); + RX_UINT_REQUIRE_EQUAL(r, (size_t)-1); + RX_INT_REQUIRE_EQUAL(errno, EILSEQ); } -GREATEST_TEST -test_uni8_encode_toosmall(void) +RX_TEST_CASE(uni8_encode, toosmall) { size_t r; uint8_t buffer[1] = { 0 }; r = uni8_encode(buffer, sizeof (buffer), U'é'); - GREATEST_ASSERT_EQ(r, (size_t)-1); - GREATEST_ASSERT_EQ(errno, ERANGE); - GREATEST_PASS(); + RX_UINT_REQUIRE_EQUAL(r, (size_t)-1); + RX_INT_REQUIRE_EQUAL(errno, ERANGE); } -GREATEST_SUITE(suite_uni8_encode) -{ - GREATEST_RUN_TEST(test_uni8_encode_basic); - GREATEST_RUN_TEST(test_uni8_encode_invalid); - GREATEST_RUN_TEST(test_uni8_encode_toosmall); -} - -GREATEST_TEST -test_uni8_decode_basic(void) +RX_TEST_CASE(unit8_decode, simple) { size_t r; @@ -113,25 +97,22 @@ { uint32_t code = -1; - r = uni8_decode(u8"a", &code); - GREATEST_ASSERT_EQ(r, 1); - GREATEST_ASSERT_EQ(code, 'a'); + r = uni8_decode((const uint8_t *)u8"a", &code); + RX_UINT_REQUIRE_EQUAL(r, 1U); + RX_INT_REQUIRE_EQUAL(code, 'a'); } /* é -> 2 bytes. */ { uint32_t code = -1; - r = uni8_decode(u8"é", &code); - GREATEST_ASSERT_EQ(r, 2); - GREATEST_ASSERT_EQ(code, U'é'); + r = uni8_decode((const uint8_t *)u8"é", &code); + RX_UINT_REQUIRE_EQUAL(r, 2U); + RX_INT_REQUIRE_EQUAL(code, U'é'); } - - GREATEST_PASS(); } -GREATEST_TEST -test_uni8_decode_invalid(void) +RX_TEST_CASE(uni8_decode, invalid) { size_t r; @@ -139,10 +120,10 @@ { uint32_t code = -1; - r = uni8_decode(u8"\xff""a", &code); - GREATEST_ASSERT_EQ(r, (size_t)-1); - GREATEST_ASSERT_EQ(code, (uint32_t)-1); - GREATEST_ASSERT_EQ(errno, EILSEQ); + r = uni8_decode((const uint8_t *)u8"\xff""a", &code); + RX_UINT_REQUIRE_EQUAL(r, (size_t)-1); + RX_UINT_REQUIRE_EQUAL(code, (uint32_t)-1); + RX_INT_REQUIRE_EQUAL(errno, EILSEQ); } /* Valid "€" but unfinished sequence. */ @@ -150,68 +131,39 @@ uint32_t code = -1; r = uni8_decode((const uint8_t []){ -30, 0 }, &code); - GREATEST_ASSERT_EQ(r, (size_t)-1); - GREATEST_ASSERT_EQ(code, (uint32_t)-1); - GREATEST_ASSERT_EQ(errno, EILSEQ); + RX_UINT_REQUIRE_EQUAL(r, (size_t)-1); + RX_UINT_REQUIRE_EQUAL(code, (uint32_t)-1); + RX_INT_REQUIRE_EQUAL(errno, EILSEQ); } - - GREATEST_PASS(); } -GREATEST_SUITE(suite_uni8_decode) +RX_TEST_CASE(uni8_sizeof, simple) { - GREATEST_RUN_TEST(test_uni8_decode_basic); - GREATEST_RUN_TEST(test_uni8_decode_invalid); -} - -GREATEST_TEST -test_uni8_sizeof_basic(void) -{ - GREATEST_ASSERT_EQ(1, uni8_sizeof(u8"a"[0])); - GREATEST_ASSERT_EQ(2, uni8_sizeof(u8"é"[0])); - GREATEST_ASSERT_EQ(3, uni8_sizeof(u8"€"[0])); - GREATEST_ASSERT_EQ(4, uni8_sizeof(u8"𐍈"[0])); - GREATEST_PASS(); + RX_INT_REQUIRE_EQUAL(uni8_sizeof(u8"a"[0]), 1U); + RX_INT_REQUIRE_EQUAL(uni8_sizeof(u8"é"[0]), 2U); + RX_INT_REQUIRE_EQUAL(uni8_sizeof(u8"€"[0]), 3U); + RX_INT_REQUIRE_EQUAL(uni8_sizeof(u8"𐍈"[0]), 4U); } -GREATEST_TEST -test_uni8_sizeof_invalid(void) +RX_TEST_CASE(uni8_sizeof, invalid) { - GREATEST_ASSERT_EQ((size_t)-1, uni8_sizeof(u8"\xff"[0])); - GREATEST_ASSERT_EQ(errno, EILSEQ); - GREATEST_PASS(); -} - -GREATEST_SUITE(suite_uni8_sizeof) -{ - GREATEST_RUN_TEST(test_uni8_sizeof_basic); - GREATEST_RUN_TEST(test_uni8_sizeof_invalid); + RX_UINT_REQUIRE_EQUAL((size_t)-1, uni8_sizeof(u8"\xff"[0])); + RX_INT_REQUIRE_EQUAL(errno, EILSEQ); } -GREATEST_TEST -test_uni8_length_basic(void) +RX_TEST_CASE(uni8_length, simple) { - GREATEST_ASSERT_EQ(3, uni8_length("abc")); - GREATEST_ASSERT_EQ(4, uni8_length("5€")); - GREATEST_PASS(); + RX_UINT_REQUIRE_EQUAL(uni8_length((const uint8_t *)"abc"), 3U); + RX_UINT_REQUIRE_EQUAL(uni8_length((const uint8_t *)"5€"), 2U); } -GREATEST_TEST -test_uni8_length_invalid(void) +RX_TEST_CASE(uni8_length, invalid) { - GREATEST_ASSERT_EQ((size_t)-1, uni8_length("a""\xff""b")); - GREATEST_ASSERT_EQ(errno, EILSEQ); - GREATEST_PASS(); + RX_UINT_REQUIRE_EQUAL((size_t)-1, uni8_length((const uint8_t *)"a""\xff""b")); + RX_INT_REQUIRE_EQUAL(errno, EILSEQ); } -GREATEST_SUITE(suite_uni8_length) -{ - GREATEST_RUN_TEST(test_uni8_length_basic); - GREATEST_RUN_TEST(test_uni8_length_invalid); -} - -GREATEST_TEST -test_uni8_to32_basic(void) +RX_TEST_CASE(uni8_to32, simple) { size_t r; @@ -219,121 +171,79 @@ uint32_t buffer[10] = { 0 }; uint32_t expected[] = { U'a', U'b', U'c', 0 }; - r = uni8_to32("abc", buffer, 10); - GREATEST_ASSERT_EQ(r, 3); - GREATEST_ASSERT(u32cmp(buffer, expected)); + r = uni8_to32((const uint8_t *)"abc", buffer, 10); + RX_UINT_REQUIRE_EQUAL(r, 3U); + RX_REQUIRE(u32cmp(buffer, expected)); } { uint32_t buffer[10] = { 0 }; uint32_t expected[] = { U'a', U'é', U'c', 0 }; - r = uni8_to32("aéc", buffer, 10); - GREATEST_ASSERT_EQ(r, 3); - GREATEST_ASSERT(u32cmp(buffer, expected)); + r = uni8_to32((const uint8_t *)"aéc", buffer, 10); + RX_UINT_REQUIRE_EQUAL(r, 3); + RX_REQUIRE(u32cmp(buffer, expected)); } - - GREATEST_PASS(); } -GREATEST_TEST -test_uni8_to32_invalid(void) +RX_TEST_CASE(uni8_to32, invalid) { size_t r; uint32_t buffer[10] = { 0 }; /* Invalid UTF-8 sequence. */ - r = uni8_to32(u8"\xff""a", buffer, 10); - GREATEST_ASSERT_EQ(r, (size_t)-1); - GREATEST_ASSERT_EQ(errno, EILSEQ); + r = uni8_to32((const uint8_t *)u8"\xff""a", buffer, 10); + RX_UINT_REQUIRE_EQUAL(r, (size_t)-1); + RX_INT_REQUIRE_EQUAL(errno, EILSEQ); /* Valid "€" but unfinished sequence. */ r = uni8_to32((const uint8_t []){ -30, 0 }, buffer, 10); - GREATEST_ASSERT_EQ(r, (size_t)-1); - GREATEST_ASSERT_EQ(errno, EILSEQ); - - GREATEST_PASS(); + RX_UINT_REQUIRE_EQUAL(r, (size_t)-1); + RX_INT_REQUIRE_EQUAL(errno, EILSEQ); } -GREATEST_TEST -test_uni8_to32_toosmall(void) +RX_TEST_CASE(uni8_to32, toosmall) { size_t r; uint32_t buffer[4] = { 0 }; - r = uni8_to32(u8"bonjour à tous", buffer, 1); - GREATEST_ASSERT_EQ(r, (size_t)-1); - GREATEST_ASSERT_EQ(errno, ERANGE); - GREATEST_PASS(); -} - -GREATEST_SUITE(suite_uni8_to32) -{ - GREATEST_RUN_TEST(test_uni8_to32_basic); - GREATEST_RUN_TEST(test_uni8_to32_invalid); - GREATEST_RUN_TEST(test_uni8_to32_toosmall); + r = uni8_to32((const uint8_t *)u8"bonjour à tous", buffer, 1); + RX_UINT_REQUIRE_EQUAL(r, (size_t)-1); + RX_INT_REQUIRE_EQUAL(errno, ERANGE); } -GREATEST_TEST -test_uni32_sizeof_basic(void) +RX_TEST_CASE(uni32_sizeof, simple) { - GREATEST_ASSERT_EQ(1, uni32_sizeof(U'a')); - GREATEST_ASSERT_EQ(2, uni32_sizeof(U'é')); - GREATEST_ASSERT_EQ(3, uni32_sizeof(U'€')); - GREATEST_ASSERT_EQ(4, uni32_sizeof(U'𐍈')); - GREATEST_PASS(); + RX_UINT_REQUIRE_EQUAL(uni32_sizeof(U'a'), 1); + RX_UINT_REQUIRE_EQUAL(uni32_sizeof(U'é'), 2); + RX_UINT_REQUIRE_EQUAL(uni32_sizeof(U'€'), 3); + RX_UINT_REQUIRE_EQUAL(uni32_sizeof(U'𐍈'), 4); } -GREATEST_TEST -test_uni32_sizeof_invalid(void) +RX_TEST_CASE(uni32_sizeof, invalid) { - GREATEST_ASSERT_EQ((size_t)-1, uni32_sizeof(0xffffffff)); - GREATEST_ASSERT_EQ(errno, EILSEQ); - GREATEST_PASS(); -} - -GREATEST_SUITE(suite_uni32_sizeof) -{ - GREATEST_RUN_TEST(test_uni32_sizeof_basic); - GREATEST_RUN_TEST(test_uni32_sizeof_invalid); + RX_UINT_REQUIRE_EQUAL((size_t)-1, uni32_sizeof(0xffffffff)); + RX_INT_REQUIRE_EQUAL(errno, EILSEQ); } -GREATEST_TEST -test_uni32_length(void) +RX_TEST_CASE(uni32_length, simple) { - GREATEST_ASSERT_EQ(3, uni32_length((const uint32_t []){ U'a', U'é', U'c', 0 })); - GREATEST_PASS(); -} - -GREATEST_SUITE(suite_uni32_length) -{ - GREATEST_RUN_TEST(test_uni32_length); + RX_UINT_REQUIRE_EQUAL(uni32_length((const uint32_t []){ U'a', U'é', U'c', 0 }), 3U); } -GREATEST_TEST -test_uni32_requires_basic(void) +RX_TEST_CASE(uni32_requires, simple) { - GREATEST_ASSERT_EQ(3, uni32_requires(U"abc")); - GREATEST_ASSERT_EQ(9, uni32_requires(U"é€𐍈")); - GREATEST_PASS(); + RX_UINT_REQUIRE_EQUAL(uni32_requires(U"abc"), 3U); + RX_UINT_REQUIRE_EQUAL(uni32_requires(U"é€𐍈"), 9U); } -GREATEST_TEST -test_uni32_requires_invalid(void) +RX_TEST_CASE(uni32_requires, invalid) { - GREATEST_ASSERT_EQ((size_t)-1, uni32_requires(U"\xffffffff")); - GREATEST_ASSERT_EQ(errno, EILSEQ); - GREATEST_PASS(); + RX_UINT_REQUIRE_EQUAL((size_t)-1, uni32_requires(U"\xffffffff")); + RX_INT_REQUIRE_EQUAL(errno, EILSEQ); } -GREATEST_SUITE(suite_uni32_requires) -{ - GREATEST_RUN_TEST(test_uni32_requires_basic); - GREATEST_RUN_TEST(test_uni32_requires_invalid); -} - -GREATEST_TEST -test_uni32_to8_basic(void) +RX_TEST_CASE(uni32_to8, simple) { size_t r; @@ -341,127 +251,79 @@ uint8_t buffer[10] = { 0 }; r = uni32_to8(U"abc", buffer, sizeof (buffer)); - GREATEST_ASSERT_EQ(r, 3); - GREATEST_ASSERT_STR_EQ(buffer, u8"abc"); + RX_UINT_REQUIRE_EQUAL(r, 3U); + RX_STR_REQUIRE_EQUAL((const char *)buffer, (const char *)u8"abc"); } { uint8_t buffer[20] = { 0 }; r = uni32_to8(U"ça va, 5€ ?", buffer, sizeof (buffer)); - GREATEST_ASSERT_EQ(r, 14); - GREATEST_ASSERT_STR_EQ(buffer, u8"ça va, 5€ ?"); + RX_UINT_REQUIRE_EQUAL(r, 14U); + RX_STR_REQUIRE_EQUAL((const char *)buffer, (const char *)u8"ça va, 5€ ?"); } - - GREATEST_PASS(); } -GREATEST_TEST -test_uni32_to8_invalid(void) +RX_TEST_CASE(uni32_to8, invalid) { uint8_t buffer[10] = { 0 }; - GREATEST_ASSERT_EQ(uni32_to8(U"\xffffffff", buffer, sizeof (buffer)), (size_t)-1); - GREATEST_ASSERT_EQ(errno, EILSEQ); - GREATEST_PASS(); + RX_INT_REQUIRE_EQUAL(uni32_to8(U"\xffffffff", buffer, sizeof (buffer)), (size_t)-1); + RX_UINT_REQUIRE_EQUAL(errno, EILSEQ); } -GREATEST_TEST -test_uni32_to8_toosmall(void) +RX_TEST_CASE(uni32_to8, toosmall) { size_t r; uint8_t buffer[3] = { 0 }; r = uni32_to8(U"ça va ?", buffer, sizeof (buffer)); - GREATEST_ASSERT_EQ(r, (size_t)-1); - GREATEST_ASSERT_EQ(errno, ERANGE); - GREATEST_PASS(); -} - -GREATEST_SUITE(suite_uni32_to8) -{ - GREATEST_RUN_TEST(test_uni32_to8_basic); - GREATEST_RUN_TEST(test_uni32_to8_invalid); - GREATEST_RUN_TEST(test_uni32_to8_toosmall); + RX_UINT_REQUIRE_EQUAL(r, (size_t)-1); + RX_INT_REQUIRE_EQUAL(errno, ERANGE); } -GREATEST_TEST -test_misc_isalpha(void) +RX_TEST_CASE(misc, isalpha) { - GREATEST_ASSERT(uni_isalpha(U'é')); - GREATEST_ASSERT(!uni_isalpha(U'€')); - GREATEST_PASS(); + RX_REQUIRE(uni_isalpha(U'é')); + RX_REQUIRE(!uni_isalpha(U'€')); } -GREATEST_TEST -test_misc_isdigit(void) +RX_TEST_CASE(misc, isdigit) { - GREATEST_ASSERT(uni_isdigit(U'۱')); - GREATEST_ASSERT(!uni_isdigit(U'€')); - GREATEST_PASS(); -} - -GREATEST_TEST -test_misc_islower(void) -{ - GREATEST_ASSERT(uni_islower(U'a')); - GREATEST_ASSERT(uni_islower(U'é')); - GREATEST_ASSERT(!uni_islower(U'A')); - GREATEST_ASSERT(!uni_islower(U'É')); - GREATEST_PASS(); + RX_REQUIRE(uni_isdigit(U'۱')); + RX_REQUIRE(!uni_isdigit(U'€')); } -GREATEST_TEST -test_misc_isspace(void) +RX_TEST_CASE(misc, islower) { - GREATEST_ASSERT(uni_isspace(U' ')); - GREATEST_ASSERT(!uni_isspace(U'é')); - GREATEST_PASS(); + RX_REQUIRE(uni_islower(U'a')); + RX_REQUIRE(uni_islower(U'é')); + RX_REQUIRE(!uni_islower(U'A')); + RX_REQUIRE(!uni_islower(U'É')); } -GREATEST_TEST -test_misc_istitle(void) +RX_TEST_CASE(misc, isspace) { - GREATEST_ASSERT(uni_istitle(U'Dž')); - GREATEST_ASSERT(!uni_istitle(U'€')); - GREATEST_PASS(); + RX_REQUIRE(uni_isspace(U' ')); + RX_REQUIRE(!uni_isspace(U'é')); } -GREATEST_TEST -test_misc_isupper(void) +RX_TEST_CASE(misc, istitle) { - GREATEST_ASSERT(!uni_isupper('a')); - GREATEST_ASSERT(!uni_isupper(U'é')); - GREATEST_ASSERT(uni_isupper('A')); - GREATEST_ASSERT(uni_isupper(U'É')); - GREATEST_PASS(); + RX_REQUIRE(uni_istitle(U'Dž')); + RX_REQUIRE(!uni_istitle(U'€')); } -GREATEST_SUITE(suite_misc) +RX_TEST_CASE(misc, isupper) { - GREATEST_RUN_TEST(test_misc_isalpha); - GREATEST_RUN_TEST(test_misc_isdigit); - GREATEST_RUN_TEST(test_misc_islower); - GREATEST_RUN_TEST(test_misc_isspace); - GREATEST_RUN_TEST(test_misc_istitle); - GREATEST_RUN_TEST(test_misc_isupper); + RX_REQUIRE(!uni_isupper('a')); + RX_REQUIRE(!uni_isupper(U'é')); + RX_REQUIRE(uni_isupper('A')); + RX_REQUIRE(uni_isupper(U'É')); } -GREATEST_MAIN_DEFS(); - int main(int argc, char **argv) { - GREATEST_MAIN_BEGIN(); - GREATEST_RUN_SUITE(suite_uni8_encode); - GREATEST_RUN_SUITE(suite_uni8_decode); - GREATEST_RUN_SUITE(suite_uni8_sizeof); - GREATEST_RUN_SUITE(suite_uni8_length); - GREATEST_RUN_SUITE(suite_uni8_to32); - GREATEST_RUN_SUITE(suite_uni32_sizeof); - GREATEST_RUN_SUITE(suite_uni32_length); - GREATEST_RUN_SUITE(suite_uni32_requires); - GREATEST_RUN_SUITE(suite_uni32_to8); - GREATEST_RUN_SUITE(suite_misc); - GREATEST_MAIN_END(); + return rx_main(0, NULL, argc, (const char **)argv) == RX_SUCCESS ? 0 : 1; }