diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/simple-test.h | 1681 |
1 files changed, 423 insertions, 1258 deletions
diff --git a/src/simple-test.h b/src/simple-test.h index 6650720..b1dbfdf 100644 --- a/src/simple-test.h +++ b/src/simple-test.h @@ -1,1329 +1,494 @@ #ifndef SIMPLE_TEST_H #define SIMPLE_TEST_H -#define _XOPEN_SOURCE - -#include <inttypes.h> -#include <locale.h> -#include <stdlib.h> -#include <stdint.h> #include <stdio.h> +#include <stdlib.h> #include <stdbool.h> +#include <stdint.h> +#include <inttypes.h> +#include <stdarg.h> #include <string.h> -#include <wchar.h> /**************************** * INTERNAL FUNCTIONALITY * ****************************/ -typedef enum { + + +enum simple_test_type { SIMPLE_TEST_BOOL, SIMPLE_TEST_INT, - SIMPLE_TEST_UINT, - SIMPLE_TEST_FLOAT, - SIMPLE_TEST_PTR, + SIMPLE_TEST_UNSIGNED, SIMPLE_TEST_CHAR, - SIMPLE_TEST_STR, - SIMPLE_TEST_WCHAR, - SIMPLE_TEST_WSTR, - SIMPLE_TEST_DEFAULT, -} simple_test_type_t; + SIMPLE_TEST_STRING, + SIMPLE_TEST_POINTER, + SIMPLE_TEST_UNKNOWN, + SIMPLE_TEST_MISMATCH, +}; -typedef enum { +enum simple_test_cond { SIMPLE_TEST_TRUE, + SIMPLE_TEST_FALSE, SIMPLE_TEST_EQ, SIMPLE_TEST_NEQ, - SIMPLE_TEST_G, + SIMPLE_TEST_GT, + SIMPLE_TEST_LT, SIMPLE_TEST_GEQ, - SIMPLE_TEST_L, SIMPLE_TEST_LEQ -} simple_test_cond_t; +}; + +#define SIMPLE_TEST_TYPE(a) \ + _Generic((a), \ + bool: SIMPLE_TEST_BOOL, \ + char: SIMPLE_TEST_CHAR, \ + int8_t: SIMPLE_TEST_INT, \ + int16_t: SIMPLE_TEST_INT, \ + int32_t: SIMPLE_TEST_INT, \ + int64_t: SIMPLE_TEST_INT, \ + uint8_t: SIMPLE_TEST_UNSIGNED, \ + uint16_t: SIMPLE_TEST_UNSIGNED, \ + uint32_t: SIMPLE_TEST_UNSIGNED, \ + uint64_t: SIMPLE_TEST_UNSIGNED, \ + char *: SIMPLE_TEST_STRING, \ + void *: SIMPLE_TEST_POINTER, \ + default: SIMPLE_TEST_UNKNOWN) + +#define SIMPLE_TEST_PASTE_ACTUAL(a, b) \ + a##b + +#define SIMPLE_TEST_PASTE(a, b) \ + SIMPLE_TEST_PASTE_ACTUAL(a, b) + +#define SIMPLE_TEST_FAIL1(...) \ + do { \ + printf("\e[1m% *c :: at line %d, \e[m\e[1;31mfail: \e[m", \ + simple_test_pad_width, ' ', __LINE__); \ + printf(__VA_ARGS__); \ + printf("\n"); \ + } while (0) + +// #define SIMPLE_TEST_PRINT_VAL(a, type) \ +// do { \ +// printf("\e[1m% *c :: ", simple_test_pad_width, ' '); \ +// printf("`%s` \e[m== \e[1m", #a); \ +// switch (type) { \ +// case SIMPLE_TEST_BOOL: \ +// printf("%s", (a) ? "true" : "false"); \ +// break; \ +// case SIMPLE_TEST_CHAR: \ +// printf("%c", (a)); \ +// break; \ +// case SIMPLE_TEST_INT: \ +// printf("%" PRIdMAX, (a)); \ +// break; \ +// case SIMPLE_TEST_UNSIGNED: \ +// printf("%" PRIuMAX, (a)); \ +// break; \ +// case SIMPLE_TEST_STRING: \ +// printf(((a) ? "\"%s\"" : "%s"), (a)); \ +// break; \ +// case SIMPLE_TEST_POINTER: \ +// printf("%p", (a)); \ +// break; \ +// default: \ +// break; \ +// } \ +// printf("\e[m\n"); \ +// } while (0) + +#define SIMPLE_TEST_PRINT_VAL(w, s, t) \ + do { \ + printf("\e[1m% *c :: ", simple_test_pad_width, ' '); \ + printf("`%s` \e[m== \e[1m", s); \ + switch (t) { \ + case SIMPLE_TEST_BOOL: \ + printf("%s", (w ? simple_test_il : simple_test_ir) \ + ? "true" : "false"); \ + break; \ + case SIMPLE_TEST_CHAR: \ + printf("%c", w ? simple_test_il : simple_test_ir); \ + break; \ + case SIMPLE_TEST_INT: \ + printf("%" PRIdMAX, w ? simple_test_il : simple_test_ir); \ + break; \ + case SIMPLE_TEST_UNSIGNED: \ + printf("%" PRIuMAX, w ? simple_test_ul : simple_test_ur); \ + break; \ + case SIMPLE_TEST_STRING: \ + printf(((w ? simple_test_sl : simple_test_sr) \ + ? "\"%s\"" : "%s"), w \ + ? simple_test_sl : simple_test_sr); \ + break; \ + case SIMPLE_TEST_POINTER: \ + printf("%p", w ? simple_test_pl : simple_test_pr); \ + break; \ + default: \ + break; \ + } \ + printf("\e[m\n"); \ + } while (0) + +#define SIMPLE_TEST_FAIL2 \ + do { \ + simple_test_fail_count++; \ + goto simple_test_loop_end; \ + } while (0) + +#define SIMPLE_TEST_ERR(...) \ + do { \ + printf("\e[1m% *c :: at line %d, \e[m\e[1;31merr: \e[m", \ + simple_test_pad_width, ' ', __LINE__); \ + printf(__VA_ARGS__); \ + printf("\n"); \ + exit(1); \ + } while (0) -int simple_test_mbslen(char *arg) -{ - int blen = strlen(arg), clen = 0, i = 0; - wchar_t wc; - setlocale(LC_ALL, ""); - while(i < blen) { - i += mbtowc(&wc, arg + i, blen - i); - clen += wcwidth(wc); - } - return clen; -} +#define SIMPLE_TEST_PRINT_BUF_WIDTH 512 -void simple_test_get_escape(char c, char *buf) -{ - buf[0] = '\\'; - buf[2] = '\0'; - switch(c) { - case '\a': - buf[1] = 'a'; - break; - case '\b': - buf[1] = 'b'; - break; - case '\t': - buf[1] = 't'; - break; - case '\n': - buf[1] = 'n'; - break; - case '\v': - buf[1] = 'v'; - break; - case '\f': - buf[1] = 'f'; - break; - case '\r': - buf[1] = 'r'; - break; - default: - buf[0] = c; - buf[1] = '\0'; - } -} +/****************** + * BASIC MACROS * + ******************/ -void simple_test_get_escape_wide(wchar_t c, wchar_t *buf) -{ - buf[0] = L'\\'; - buf[2] = L'\0'; +#define REGISTER_TEARDOWN(f) \ + do { \ + if (simple_test_teardown != NULL) \ + SIMPLE_TEST_ERR("teardown function already defined"); \ + simple_test_teardown = _Generic((f), \ + void(*)(void): (f), default: NULL); \ + if (simple_test_teardown == NULL) { \ + SIMPLE_TEST_ERR( \ + "wrongly-typed function passed to REGISTER_TEARDOWN"); \ + } \ + } while (0) - switch(c) { - case L'\a': - buf[1] = L'a'; - break; - case L'\b': - buf[1] = L'b'; - break; - case L'\t': - buf[1] = L't'; - break; - case L'\n': - buf[1] = L'n'; - break; - case L'\v': - buf[1] = L'v'; - break; - case L'\f': - buf[1] = L'f'; - break; - case L'\r': - buf[1] = L'r'; - break; - default: - buf[0] = c; - buf[1] = L'\0'; - } -} -/* extra levels of abstraction are necessary - * to get __LINE__ to evaluate first */ -#define SIMPLE_TEST_STRINGIFY(x) SIMPLE_TEST_STRINGIFY_EVAL(x) +#define USE_TEARDOWN \ + do { \ + if (simple_test_teardown == NULL) \ + SIMPLE_TEST_ERR("teardown function undefined"); \ + simple_test_do_teardown = true; \ + } while (0) -#define SIMPLE_TEST_STRINGIFY_EVAL(x) \ -#x -#define SIMPLE_TEST_LEN_DIFF(arg1, arg2) \ - ( simple_test_mbslen(arg1) - simple_test_mbslen(arg2) ) -#define SIMPLE_TEST_FAIL_ONE(summary, file, line, fmt, sarg, arg) \ -do { \ - { \ - printf("\e[1m :: "); \ - printf("%s", file); \ - printf(":%i: \e[31;1mfail:\e[m ", line); \ - printf(summary); \ - printf("\e[m\n"); \ - printf("\e[1m :: "); \ - printf("%s == \e[m" fmt "\n", sarg, arg); \ - exit(1); \ - } \ -} while(0) -#define SIMPLE_TEST_FAIL(summary, file, line, fmt1, fmt2, sarg1, sarg2, arg1, arg2) \ -do { \ +/* must appear before all tests */ +#define BEGIN_TEST \ + int main(int argc, char **argv) \ { \ - int simple_test_i, simple_test_diff = SIMPLE_TEST_LEN_DIFF(sarg1, sarg2); \ - printf("\e[1m :: "); \ - printf("%s", file); \ - printf(":%i: \e[31;1mfail:\e[m ", line); \ - printf(summary); \ - printf("\e[m\n"); \ - printf("\e[1m :: "); \ - for(simple_test_i = 0; simple_test_i < -simple_test_diff; simple_test_i++) \ - printf(" "); \ - printf("%s == \e[m", sarg1); \ - printf(fmt1, arg1); \ - printf("\n\e[1m :: "); \ - for(simple_test_i = 0; simple_test_i < simple_test_diff; simple_test_i++) \ - printf(" "); \ - printf("%s == \e[m", sarg2); \ - printf(fmt2, arg2); \ - printf("\n"); \ - exit(1); \ - } \ -} while(0) + int simple_test_iterator; \ + int simple_test_pad_width = 0; \ + int simple_test_fail_count = 0; \ + char simple_test_print_buf[SIMPLE_TEST_PRINT_BUF_WIDTH]; \ + int simple_test_test_count = 0; \ + int simple_test_test_current = 1; \ + int simple_test_pass_number = 0; \ + bool simple_test_do_teardown = false; \ + void (*simple_test_teardown)(void) = NULL; \ + do { \ + if (simple_test_pass_number == 0) { \ + printf("\e[1mstarting tests in " __FILE__ "...\n"); \ + } else { \ + simple_test_pad_width = sprintf(simple_test_print_buf, \ + "%d", simple_test_test_count) + 1; \ + } \ + for (simple_test_iterator = 0; simple_test_pass_number == 0 && \ + simple_test_iterator < 1; simple_test_iterator++) { \ + (void)0; \ -#define SIMPLE_TEST_INTERN_ERR(file, line) \ -do { \ - printf("\e[1m :: "); \ - printf("%s:%i: \e[31;1merr:\e[m ", file, line); \ - printf("bad call to internal func\n"); \ - exit(1); \ -} while(0) -void simple_test_assert_bool(char *sarg1, char *sarg2, - bool arg1, bool arg2, - const char *file, const int line, simple_test_cond_t cond) -{ - switch(cond) { - case SIMPLE_TEST_TRUE: - if(!(arg2)) - SIMPLE_TEST_FAIL_ONE("unexpected false value", file, line, - "%s", sarg2, arg2 ? "true" : "false"); - break; - case SIMPLE_TEST_EQ: - if(arg1 != arg2) - SIMPLE_TEST_FAIL("bool values do not match", file, line, - "%s", "%s", sarg1, sarg2, - arg1 ? "true" : "false", arg2 ? "true" : "false"); - break; - case SIMPLE_TEST_NEQ: - if(arg1 == arg2) - SIMPLE_TEST_FAIL("bool values match", file, line, - "%s", "%s", sarg1, sarg2, - arg1 ? "true" : "false", arg2 ? "true" : "false"); - break; - default: - SIMPLE_TEST_INTERN_ERR(file, line); +#define TEST(description) \ + } \ + if (simple_test_do_teardown) { \ + simple_test_do_teardown = false; \ + simple_test_teardown(); \ + } \ + int SIMPLE_TEST_PASTE(simple_test_test_slot_, __LINE__); \ + if (simple_test_pass_number == 0) { \ + SIMPLE_TEST_PASTE(simple_test_test_slot_, __LINE__) \ + = ++simple_test_test_count; \ + } else if (simple_test_pass_number \ + == SIMPLE_TEST_PASTE(simple_test_test_slot_, __LINE__)) { \ + printf("\e[m% *d \e[1m:: \e[m\e[33m%s\e[m\n", simple_test_pad_width, \ + simple_test_test_current++, description); \ + +/* must appear after all tests */ +#define END_TEST \ + } \ + if (simple_test_do_teardown) { \ + simple_test_do_teardown = false; \ + simple_test_teardown(); \ + } \ + if (simple_test_test_count == 0) { \ + SIMPLE_TEST_ERR("no tests defined"); \ + } \ +simple_test_loop_end: \ + (void)0; \ + } while (simple_test_pass_number++ < simple_test_test_count); \ + if (simple_test_fail_count) { \ + printf("\e[1;31m%d of %d tests failed\e[m\n", \ + simple_test_fail_count, simple_test_test_count); \ + return 1; \ + } else { \ + printf("\e[1;32mall tests passed!\e[m\n"); \ + return 0; \ + } \ } -} -void simple_test_assert_int(char *sarg1, char *sarg2, - intmax_t arg1, intmax_t arg2, - const char *file, const int line, simple_test_cond_t cond) -{ - switch(cond) { - case SIMPLE_TEST_TRUE: - if(!(arg2)) - SIMPLE_TEST_FAIL_ONE("unexpected 0 value", file, line, - "%" PRIiMAX, sarg2, arg2); - break; - case SIMPLE_TEST_EQ: - if(arg1 != arg2) - SIMPLE_TEST_FAIL("int values do not match", file, line, - "%" PRIiMAX, "%" PRIiMAX, sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_NEQ: - if(arg1 == arg2) - SIMPLE_TEST_FAIL("int values match", file, line, - "%" PRIiMAX, "%" PRIiMAX, sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_G: - if(arg1 <= arg2) - SIMPLE_TEST_FAIL("arg1 <= arg2", file, line, - "%" PRIiMAX, "%" PRIiMAX, sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_GEQ: - if(arg1 < arg2) - SIMPLE_TEST_FAIL("arg1 < arg2", file, line, - "%" PRIiMAX, "%" PRIiMAX, sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_L: - if(arg1 >= arg2) - SIMPLE_TEST_FAIL("arg1 >= arg2", file, line, - "%" PRIiMAX, "%" PRIiMAX, sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_LEQ: - if(arg1 > arg2) - SIMPLE_TEST_FAIL("arg1 > arg2", file, line, - "%" PRIiMAX, "%" PRIiMAX, sarg1, sarg2, arg1, arg2); - break; - default: - SIMPLE_TEST_INTERN_ERR(file, line); - } -} +#define ECHO(...) \ + do { \ + printf("\e[1m% *c :: \e[m\e[34m", simple_test_pad_width, ' '); \ + printf(__VA_ARGS__); \ + printf("...\e[m\n"); \ + } while (0) -void simple_test_assert_uint(char *sarg1, char *sarg2, - uintmax_t arg1, uintmax_t arg2, - const char *file, const int line, simple_test_cond_t cond) -{ - switch(cond) { - case SIMPLE_TEST_TRUE: - if(!(arg2)) - SIMPLE_TEST_FAIL_ONE("unexpected 0 value", file, line, - "%" PRIuMAX, sarg2, arg2); - break; - case SIMPLE_TEST_EQ: - if(arg1 != arg2) - SIMPLE_TEST_FAIL("uint values do not match", file, line, - "%" PRIuMAX, "%" PRIuMAX, sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_NEQ: - if(arg1 == arg2) - SIMPLE_TEST_FAIL("uint values match", file, line, - "%" PRIuMAX, "%" PRIuMAX, sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_G: - if(arg1 <= arg2) - SIMPLE_TEST_FAIL("arg1 <= arg2", file, line, - "%" PRIuMAX, "%" PRIuMAX, sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_GEQ: - if(arg1 < arg2) - SIMPLE_TEST_FAIL("arg1 < arg2", file, line, - "%" PRIuMAX, "%" PRIuMAX, sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_L: - if(arg1 >= arg2) - SIMPLE_TEST_FAIL("arg1 >= arg2", file, line, - "%" PRIuMAX, "%" PRIuMAX, sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_LEQ: - if(arg1 > arg2) - SIMPLE_TEST_FAIL("arg1 > arg2", file, line, - "%" PRIuMAX, "%" PRIuMAX, sarg1, sarg2, arg1, arg2); - break; - default: - SIMPLE_TEST_INTERN_ERR(file, line); - } -} -void simple_test_assert_hex(char *sarg1, char *sarg2, - uintmax_t arg1, uintmax_t arg2, - const char *file, const int line, simple_test_cond_t cond) -{ - switch(cond) { - case SIMPLE_TEST_TRUE: - if(!(arg2)) - SIMPLE_TEST_FAIL_ONE("unexpected 0 value", file, line, - "%" PRIxMAX, sarg2, arg2); - break; - case SIMPLE_TEST_EQ: - if(arg1 != arg2) - SIMPLE_TEST_FAIL("uint values do not match", file, line, - "%" PRIxMAX, "%" PRIxMAX, sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_NEQ: - if(arg1 == arg2) - SIMPLE_TEST_FAIL("uint values match", file, line, - "%" PRIxMAX, "%" PRIxMAX, sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_G: - if(arg1 <= arg2) - SIMPLE_TEST_FAIL("arg1 <= arg2", file, line, - "%" PRIxMAX, "%" PRIxMAX, sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_GEQ: - if(arg1 < arg2) - SIMPLE_TEST_FAIL("arg1 < arg2", file, line, - "%" PRIxMAX, "%" PRIxMAX, sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_L: - if(arg1 >= arg2) - SIMPLE_TEST_FAIL("arg1 >= arg2", file, line, - "%" PRIxMAX, "%" PRIxMAX, sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_LEQ: - if(arg1 > arg2) - SIMPLE_TEST_FAIL("arg1 > arg2", file, line, - "%" PRIxMAX, "%" PRIxMAX, sarg1, sarg2, arg1, arg2); - break; - default: - SIMPLE_TEST_INTERN_ERR(file, line); - } -} +/********************** + * ASSERTION MACROS * + **********************/ -void simple_test_assert_float(char *sarg1, char *sarg2, - long double arg1, long double arg2, - const char *file, const int line, simple_test_cond_t cond) -{ - switch(cond) { - case SIMPLE_TEST_TRUE: - if(!(arg2)) - SIMPLE_TEST_FAIL_ONE("unexpected 0 value", file, line, - "%Lg", sarg2, arg2); - break; - case SIMPLE_TEST_EQ: - if(arg1 != arg2) - SIMPLE_TEST_FAIL("float values do not match", file, line, - "%Lg", "%Lg", sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_NEQ: - if(arg1 == arg2) - SIMPLE_TEST_FAIL("float values match", file, line, - "%Lg", "%Lg", sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_G: - if(arg1 <= arg2) - SIMPLE_TEST_FAIL("arg1 <= arg2", file, line, - "%Lg", "%Lg", sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_GEQ: - if(arg1 < arg2) - SIMPLE_TEST_FAIL("arg1 < arg2", file, line, - "%Lg", "%Lg", sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_L: - if(arg1 >= arg2) - SIMPLE_TEST_FAIL("arg1 >= arg2", file, line, - "%Lg", "%Lg", sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_LEQ: - if(arg1 > arg2) - SIMPLE_TEST_FAIL("arg1 > arg2", file, line, - "%Lg", "%Lg", sarg1, sarg2, arg1, arg2); - break; - default: - SIMPLE_TEST_INTERN_ERR(file, line); - } -} +static intmax_t simple_test_il, simple_test_ir; +static uintmax_t simple_test_ul, simple_test_ur; +static char simple_test_cl, simple_test_cr; +static char *simple_test_sl, *simple_test_sr; +static void *simple_test_pl, *simple_test_pr; -void simple_test_assert_ptr(char *sarg1, char *sarg2, - void *arg1, void *arg2, - const char *file, const int line, simple_test_cond_t cond) +static int simple_test_assert(enum simple_test_type t, + enum simple_test_cond c, ...) { - switch(cond) { + va_list ap; + bool two = !(c == SIMPLE_TEST_TRUE || c == SIMPLE_TEST_FALSE); + + int r; + + va_start(ap, c); + + switch (t) { + case SIMPLE_TEST_MISMATCH: + return -2; + case SIMPLE_TEST_BOOL: + case SIMPLE_TEST_INT: + case SIMPLE_TEST_CHAR: + simple_test_il = va_arg(ap, intmax_t); + if (two) simple_test_ir = va_arg(ap, intmax_t); + switch (c) { case SIMPLE_TEST_TRUE: - if(arg2 == NULL) - SIMPLE_TEST_FAIL_ONE("unexpected NULL value", file, line, - "%p", sarg2, arg2); - break; + r = simple_test_il; + goto end; + case SIMPLE_TEST_FALSE: + r = !simple_test_il; + goto end; case SIMPLE_TEST_EQ: - if(arg1 != arg2) - SIMPLE_TEST_FAIL("pointer values do not match", file, line, - "%p", "%p", sarg1, sarg2, arg1, arg2); - break; + r = simple_test_il == simple_test_ir; + goto end; case SIMPLE_TEST_NEQ: - if(arg1 == arg2) - SIMPLE_TEST_FAIL("pointer values match", file, line, - "%p", "%p", sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_G: - if(arg1 <= arg2) - SIMPLE_TEST_FAIL("arg1 <= arg2", file, line, - "%p", "%p", sarg1, sarg2, arg1, arg2); - break; + r = simple_test_il != simple_test_ir; + goto end; + case SIMPLE_TEST_GT: + r = simple_test_il > simple_test_ir; + goto end; + case SIMPLE_TEST_LT: + r = simple_test_il < simple_test_ir; + goto end; case SIMPLE_TEST_GEQ: - if(arg1 < arg2) - SIMPLE_TEST_FAIL("arg1 < arg2", file, line, - "%p", "%p", sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_L: - if(arg1 >= arg2) - SIMPLE_TEST_FAIL("arg1 >= arg2", file, line, - "%p", "%p", sarg1, sarg2, arg1, arg2); - break; + r = simple_test_il >= simple_test_ir; + goto end; case SIMPLE_TEST_LEQ: - if(arg1 > arg2) - SIMPLE_TEST_FAIL("arg1 > arg2", file, line, - "%p", "%p", sarg1, sarg2, arg1, arg2); - break; - default: - SIMPLE_TEST_INTERN_ERR(file, line); - } -} - -void simple_test_assert_char(char *sarg1, char *sarg2, - char arg1, char arg2, - const char *file, const int line, simple_test_cond_t cond) -{ - char buf1[3]; - char buf2[3]; - simple_test_get_escape(arg1, buf1); - simple_test_get_escape(arg2, buf2); - switch(cond) { + r = simple_test_il <= simple_test_ir; + goto end; + } + + case SIMPLE_TEST_UNSIGNED: + simple_test_ul = va_arg(ap, uintmax_t); + if (two) simple_test_ur = va_arg(ap, uintmax_t); + switch (c) { case SIMPLE_TEST_TRUE: - if(arg2 == '\0') - SIMPLE_TEST_FAIL_ONE("unexpected '\\0' value", file, line, - "‘%s’", sarg2, buf2); - break; + r = simple_test_ul; + goto end; + case SIMPLE_TEST_FALSE: + r = !simple_test_ul; + goto end; case SIMPLE_TEST_EQ: - if(arg1 != arg2) - SIMPLE_TEST_FAIL("char values do not match", file, line, - "‘%s’", "‘%s’", sarg1, sarg2, buf1, buf2); - break; + r = simple_test_ul == simple_test_ur; + goto end; case SIMPLE_TEST_NEQ: - if(arg1 == arg2) - SIMPLE_TEST_FAIL("char values match", file, line, - "‘%s’", "‘%s’", sarg1, sarg2, buf1, buf2); - break; - case SIMPLE_TEST_G: - if(arg1 <= arg2) - SIMPLE_TEST_FAIL("arg1 <= arg2", file, line, - "‘%s’", "‘%s’", sarg1, sarg2, buf1, buf2); - break; + r = simple_test_ul != simple_test_ur; + goto end; + case SIMPLE_TEST_GT: + r = simple_test_ul > simple_test_ur; + goto end; + case SIMPLE_TEST_LT: + r = simple_test_ul < simple_test_ur; + goto end; case SIMPLE_TEST_GEQ: - if(arg1 < arg2) - SIMPLE_TEST_FAIL("arg1 < arg2", file, line, - "‘%s’", "‘%s’", sarg1, sarg2, buf1, buf2); - break; - case SIMPLE_TEST_L: - if(arg1 >= arg2) - SIMPLE_TEST_FAIL("arg1 >= arg2", file, line, - "‘%s’", "‘%s’", sarg1, sarg2, buf1, buf2); - break; + r = simple_test_ul >= simple_test_ur; + goto end; case SIMPLE_TEST_LEQ: - if(arg1 > arg2) - SIMPLE_TEST_FAIL("arg1 > arg2", file, line, - "‘%s’", "‘%s’", sarg1, sarg2, buf1, buf2); - break; - default: - SIMPLE_TEST_INTERN_ERR(file, line); - } -} - -void simple_test_assert_str(char *sarg1, char *sarg2, - char *arg1, char *arg2, - const char *file, const int line, simple_test_cond_t cond) -{ - bool barg1 = (arg1 == NULL ? true : false); - bool barg2 = (arg2 == NULL ? true : false); - arg1 = (arg1 == NULL ? "(nil)" : arg1); - arg2 = (arg2 == NULL ? "(nil)" : arg2); - - switch(cond) { + r = simple_test_ul <= simple_test_ur; + goto end; + } + + case SIMPLE_TEST_STRING: + simple_test_sl = va_arg(ap, char *); + if (two) simple_test_sr = va_arg(ap, char *); + switch (c) { case SIMPLE_TEST_TRUE: - if(!strcmp(arg2, "(nil)")) - SIMPLE_TEST_FAIL_ONE("unexpected NULL string", file, line, - "%s", sarg2, arg2); - break; + r = simple_test_sl != NULL; + goto end; + case SIMPLE_TEST_FALSE: + r = simple_test_sl == NULL; + goto end; case SIMPLE_TEST_EQ: - if( strcmp(arg1, arg2) ) - SIMPLE_TEST_FAIL("strings do not match", file, line, - (barg1 ? "%s" : "‘%s’"), - (barg2 ? "%s" : "‘%s’"), - sarg1, sarg2, arg1, arg2); - break; + r = strcmp(simple_test_sl, simple_test_sr) ? 0 : 1; + goto end; case SIMPLE_TEST_NEQ: - if( !strcmp(arg1, arg2) ) - SIMPLE_TEST_FAIL("strings match", file, line, - (barg1 ? "%s" : "‘%s’"), - (barg2 ? "%s" : "‘%s’"), - sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_G: - if( strcmp(arg1, arg2) <= 0) - SIMPLE_TEST_FAIL("arg1 <= arg2", file, line, - (barg1 ? "%s" : "‘%s’"), - (barg2 ? "%s" : "‘%s’"), - sarg1, sarg2, arg1, arg2); - break; + r = strcmp(simple_test_sl, simple_test_sr) ? 1 : 0; + goto end; + case SIMPLE_TEST_GT: + r = strcmp(simple_test_sl, simple_test_sr) > 0 ? 1 : 0; + goto end; + case SIMPLE_TEST_LT: + r = strcmp(simple_test_sl, simple_test_sr) < 0 ? 1 : 0; + goto end; case SIMPLE_TEST_GEQ: - if( strcmp(arg1, arg2) < 0) - SIMPLE_TEST_FAIL("arg1 < arg2", file, line, - (barg1 ? "%s" : "‘%s’"), - (barg2 ? "%s" : "‘%s’"), - sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_L: - if( strcmp(arg1, arg2) >= 0) - SIMPLE_TEST_FAIL("arg1 >= arg2", file, line, - (barg1 ? "%s" : "‘%s’"), - (barg2 ? "%s" : "‘%s’"), - sarg1, sarg2, arg1, arg2); - break; + r = strcmp(simple_test_sl, simple_test_sr) >= 0 ? 1 : 0; + goto end; case SIMPLE_TEST_LEQ: - if( strcmp(arg1, arg2) > 0) - SIMPLE_TEST_FAIL("arg1 > arg2", file, line, - (barg1 ? "%s" : "‘%s’"), - (barg2 ? "%s" : "‘%s’"), - sarg1, sarg2, arg1, arg2); - break; - default: - SIMPLE_TEST_INTERN_ERR(file, line); - } -} - -void simple_test_assert_wchar(char *sarg1, char *sarg2, - wchar_t arg1, wchar_t arg2, - const char *file, const int line, simple_test_cond_t cond) -{ - wchar_t buf1[3]; - wchar_t buf2[3]; - simple_test_get_escape_wide(arg1, buf1); - simple_test_get_escape_wide(arg2, buf2); - switch(cond) { + r = strcmp(simple_test_sl, simple_test_sr) <= 0 ? 1 : 0; + goto end; + } + + case SIMPLE_TEST_POINTER: + simple_test_pl = va_arg(ap, void *); + if (two) simple_test_pr = va_arg(ap, void *); + switch (c) { case SIMPLE_TEST_TRUE: - if(arg2 == L'\0') - SIMPLE_TEST_FAIL_ONE("unexpected '\\0' value", file, line, - "‘%ls’", sarg2, buf2); - break; + r = simple_test_pl != NULL; + goto end; + case SIMPLE_TEST_FALSE: + r = simple_test_pl == NULL; + goto end; case SIMPLE_TEST_EQ: - if(arg1 != arg2) - SIMPLE_TEST_FAIL("char values do not match", file, line, - "‘%ls’", "‘%ls’", sarg1, sarg2, buf1, buf2); - break; + r = simple_test_pl == simple_test_pr; + goto end; case SIMPLE_TEST_NEQ: - if(arg1 == arg2) - SIMPLE_TEST_FAIL("char values match", file, line, - "‘%ls’", "‘%ls’", sarg1, sarg2, buf1, buf2); - break; - case SIMPLE_TEST_G: - if(arg1 <= arg2) - SIMPLE_TEST_FAIL("arg1 <= arg2", file, line, - "‘%ls’", "‘%ls’", sarg1, sarg2, buf1, buf2); - break; + r = simple_test_pl != simple_test_pr; + goto end; + case SIMPLE_TEST_GT: + r = simple_test_pl > simple_test_pr; + goto end; + case SIMPLE_TEST_LT: + r = simple_test_pl < simple_test_pr; + goto end; case SIMPLE_TEST_GEQ: - if(arg1 < arg2) - SIMPLE_TEST_FAIL("arg1 < arg2", file, line, - "‘%ls’", "‘%ls’", sarg1, sarg2, buf1, buf2); - break; - case SIMPLE_TEST_L: - if(arg1 >= arg2) - SIMPLE_TEST_FAIL("arg1 >= arg2", file, line, - "‘%ls’", "‘%ls’", sarg1, sarg2, buf1, buf2); - break; + r = simple_test_pl >= simple_test_pr; + goto end; case SIMPLE_TEST_LEQ: - if(arg1 > arg2) - SIMPLE_TEST_FAIL("arg1 > arg2", file, line, - "‘%ls’", "‘%ls’", sarg1, sarg2, buf1, buf2); - break; - default: - SIMPLE_TEST_INTERN_ERR(file, line); + r = simple_test_pl <= simple_test_pr; + goto end; + } + + default: + r = -1; } + +end: + va_end(ap); + return r; } -void simple_test_assert_wstr(char *sarg1, char *sarg2, - wchar_t *arg1, wchar_t *arg2, - const char *file, const int line, simple_test_cond_t cond) +static enum simple_test_type simple_test_type_resolve(enum simple_test_type t1, + enum simple_test_type t2) { - bool barg1 = (arg1 == NULL ? true : false); - bool barg2 = (arg2 == NULL ? true : false); - arg1 = (arg1 == NULL ? L"(nil)" : arg1); - arg2 = (arg2 == NULL ? L"(nil)" : arg2); - - switch(cond) { - case SIMPLE_TEST_TRUE: - if(!wcscmp(arg2, L"(nil)")) - SIMPLE_TEST_FAIL_ONE("unexpected NULL string", file, line, - "%ls", sarg2, arg2); - break; - case SIMPLE_TEST_EQ: - if( wcscmp(arg1, arg2) ) - SIMPLE_TEST_FAIL("strings do not match", file, line, - (barg1 ? "%ls" : "‘%ls’"), - (barg2 ? "%ls" : "‘%ls’"), - sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_NEQ: - if( !wcscmp(arg1, arg2) ) - SIMPLE_TEST_FAIL("strings match", file, line, - (barg1 ? "%ls" : "‘%ls’"), - (barg2 ? "%ls" : "‘%ls’"), - sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_G: - if( wcscmp(arg1, arg2) <= 0) - SIMPLE_TEST_FAIL("arg1 <= arg2", file, line, - (barg1 ? "%ls" : "‘%ls’"), - (barg2 ? "%ls" : "‘%ls’"), - sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_GEQ: - if( wcscmp(arg1, arg2) < 0) - SIMPLE_TEST_FAIL("arg1 < arg2", file, line, - (barg1 ? "%ls" : "‘%ls’"), - (barg2 ? "%ls" : "‘%ls’"), - sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_L: - if( wcscmp(arg1, arg2) >= 0) - SIMPLE_TEST_FAIL("arg1 >= arg2", file, line, - (barg1 ? "%ls" : "‘%ls’"), - (barg2 ? "%ls" : "‘%ls’"), - sarg1, sarg2, arg1, arg2); - break; - case SIMPLE_TEST_LEQ: - if( wcscmp(arg1, arg2) > 0) - SIMPLE_TEST_FAIL("arg1 > arg2", file, line, - (barg1 ? "%ls" : "‘%ls’"), - (barg2 ? "%ls" : "‘%ls’"), - sarg1, sarg2, arg1, arg2); - break; - default: - SIMPLE_TEST_INTERN_ERR(file, line); + if (t1 != t2) { + if (t1 == SIMPLE_TEST_INT && t2 == SIMPLE_TEST_UNSIGNED + || t1 == SIMPLE_TEST_UNSIGNED && t2 == SIMPLE_TEST_INT + || t1 == SIMPLE_TEST_BOOL && t2 == SIMPLE_TEST_UNSIGNED + || t1 == SIMPLE_TEST_UNSIGNED && t2 == SIMPLE_TEST_BOOL) { + return SIMPLE_TEST_UNSIGNED; + } else if (t1 == SIMPLE_TEST_BOOL && t2 == SIMPLE_TEST_INT + || t1 == SIMPLE_TEST_INT && t2 == SIMPLE_TEST_BOOL) { + return SIMPLE_TEST_INT; + } else if (t1 == SIMPLE_TEST_INT && t2 == SIMPLE_TEST_CHAR + || t1 == SIMPLE_TEST_CHAR && t2 == SIMPLE_TEST_INT) { + return SIMPLE_TEST_CHAR; + } else if (t1 == SIMPLE_TEST_CHAR && t2 == SIMPLE_TEST_UNSIGNED + || t1 == SIMPLE_TEST_UNSIGNED && t2 == SIMPLE_TEST_CHAR){ + return SIMPLE_TEST_UNSIGNED; + } else if (t1 == SIMPLE_TEST_POINTER && t2 == SIMPLE_TEST_STRING + || t1 == SIMPLE_TEST_STRING && t2 == SIMPLE_TEST_POINTER){ + return SIMPLE_TEST_POINTER; + } else { + return SIMPLE_TEST_MISMATCH; + } } -} - -/* reporting bool as SIMPLE_TEST_INT because that's how the compiler - * sees true / false constants */ -#define SIMPLE_TEST_TYPE_ENUM_VAL(arg) \ - _Generic((arg), \ - bool: SIMPLE_TEST_INT, \ - int8_t: SIMPLE_TEST_INT, int16_t: SIMPLE_TEST_INT, \ - int32_t: SIMPLE_TEST_INT, int64_t: SIMPLE_TEST_INT, \ - uint8_t: SIMPLE_TEST_UINT, uint16_t: SIMPLE_TEST_UINT, \ - uint32_t: SIMPLE_TEST_UINT, uint64_t: SIMPLE_TEST_UINT, \ - float: SIMPLE_TEST_FLOAT, double: SIMPLE_TEST_FLOAT, \ - long double: SIMPLE_TEST_FLOAT, \ - default: SIMPLE_TEST_DEFAULT \ - ) - -#define SIMPLE_TEST_TYPE_CHECK(arg1, arg2) \ -do { \ - if(SIMPLE_TEST_TYPE_ENUM_VAL(arg1) != SIMPLE_TEST_TYPE_ENUM_VAL(arg2)) { \ - printf("\e[1m :: "); \ - printf("%s:%i: \e[31;1merr:\e[m ", __FILE__, __LINE__); \ - printf("type mismatch\n"); \ - exit(1); \ - } \ -} while(0) - -#define SIMPLE_TEST_GENERIC_CAST(arg) \ - _Generic((arg), \ - int8_t: (intmax_t)(arg), int16_t: (intmax_t)(arg), int32_t: (intmax_t)(arg), \ - int64_t: (intmax_t)(arg), \ - uint8_t: (uintmax_t)(arg), uint16_t: (uintmax_t)(arg), uint32_t: (uintmax_t)(arg), \ - uint64_t: (uintmax_t)(arg), \ - float: (long double)(arg), double: (long double)(arg), \ - long double: (long double)(arg) \ - ) - -#define SIMPLE_TEST_GENERIC_NOT(arg) \ - _Generic((arg), \ - int8_t: 0, int16_t: 0, int32_t: 0, int64_t: 0, \ - uint8_t: 0, uint16_t: 0, uint32_t: 0, uint64_t: 0, \ - float: 0.0, double: 0.0, \ - long double: 0.0 \ - ) - -#define SIMPLE_TEST_GENERIC_NOT_STR(arg) \ - _Generic((arg), \ - int8_t: "0", int16_t: "0", int32_t: "0", int64_t: "0", \ - uint8_t: "0", uint16_t: "0", uint32_t: "0", uint64_t: "0", \ - float: "0.0", double: "0.0", \ - long double: "0.0" \ - ) - -#define SIMPLE_TEST_GENERIC_FUNCCALL(sarg1, sarg2, arg1, arg2, cond) \ - _Generic((arg2), \ - int8_t: simple_test_assert_int, int16_t: simple_test_assert_int, \ - int32_t: simple_test_assert_int, int64_t: simple_test_assert_int, \ - uint8_t: simple_test_assert_uint, uint16_t: simple_test_assert_uint, \ - uint32_t: simple_test_assert_uint, uint64_t: simple_test_assert_uint, \ - float: simple_test_assert_float, double: simple_test_assert_float, \ - long double: simple_test_assert_float \ - )(sarg1, sarg2, SIMPLE_TEST_GENERIC_CAST(arg1), \ - SIMPLE_TEST_GENERIC_CAST(arg2), __FILE__, __LINE__, cond) - - - -/********************** - * TOP-LEVEL MACROS * - **********************/ - -/* the whole thing is inside one - * big function. yay! */ -#define BEGIN_TEST \ -int simple_test_count_current=1; \ -int main(int argc, char *argv[]) \ -{ \ - printf("\e[1m" __FILE__ "\n"); -/* yaaaay! */ -#define END_TEST \ - printf("\e[1m :: \e[m\e[32msuccess!\e[m\n"); \ - return 0; \ + return t1; } -#define TEST(description) \ -printf("\e[1m%3i :: \e[m\e[33m%s\e[m\n", simple_test_count_current++, description); - -/* pretty printing for the current state within - * a test */ -#define ECHO(...) \ -do { \ - printf("\e[1m :: \e[m\e[34m"); \ - printf(__VA_ARGS__); \ - printf("...\e[m\n"); \ -} while(0) - - -/************************ - * TYPE-GENERIC TESTS * - ************************/ - -#define ASSERT(arg) \ -do { \ - SIMPLE_TEST_GENERIC_FUNCCALL(SIMPLE_TEST_GENERIC_NOT_STR(arg), #arg, \ - SIMPLE_TEST_GENERIC_NOT(arg), arg, SIMPLE_TEST_TRUE); \ -} while(0) - -#define ASSERT_EQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - SIMPLE_TEST_GENERIC_FUNCCALL(#arg1, #arg2, \ - arg1, arg2, SIMPLE_TEST_EQ); \ -} while(0) - -#define ASSERT_NEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - SIMPLE_TEST_GENERIC_FUNCCALL(#arg1, #arg2, \ - arg1, arg2, SIMPLE_TEST_NEQ); \ -} while(0) - -#define ASSERT_G(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - SIMPLE_TEST_GENERIC_FUNCCALL(#arg1, #arg2, \ - arg1, arg2, SIMPLE_TEST_G); \ -} while(0) - -#define ASSERT_GEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - SIMPLE_TEST_GENERIC_FUNCCALL(#arg1, #arg2, \ - arg1, arg2, SIMPLE_TEST_GEQ); \ -} while(0) - -#define ASSERT_L(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - SIMPLE_TEST_GENERIC_FUNCCALL(#arg1, #arg2, \ - arg1, arg2, SIMPLE_TEST_L); \ -} while(0) - -#define ASSERT_LEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - SIMPLE_TEST_GENERIC_FUNCCALL(#arg1, #arg2, \ - arg1, arg2, SIMPLE_TEST_LEQ); \ -} while(0) - -/************************* - * TYPE-SPECIFIC TESTS * - *************************/ - -#define ASSERT_BOOL(arg) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(false, arg); \ - simple_test_assert_bool("false", #arg, \ - false, (bool)(arg), \ - __FILE__, __LINE__, SIMPLE_TEST_TRUE); \ -} while(0) - -#define ASSERT_BOOL_EQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_bool(#arg1, #arg2, \ - (bool)(arg1), (bool)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_EQ); \ -} while(0) - -#define ASSERT_BOOL_NEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_bool(#arg1, #arg2, \ - (bool)(arg1), (bool)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_NEQ); \ -} while(0) - -#define ASSERT_INT(arg) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(0, arg); \ - simple_test_assert_int("0", #arg, \ - (intmax_t)0, (intmax_t)(arg), \ - __FILE__, __LINE__, SIMPLE_TEST_TRUE); \ -} while(0) - -#define ASSERT_INT_EQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_int(#arg1, #arg2, \ - (intmax_t)(arg1), (intmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_EQ); \ -} while(0) - -#define ASSERT_INT_NEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_int(#arg1, #arg2, \ - (intmax_t)(arg1), (intmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_NEQ); \ -} while(0) - -#define ASSERT_INT_G(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_int(#arg1, #arg2, \ - (intmax_t)(arg1), (intmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_G); \ -} while(0) - -#define ASSERT_INT_GEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_int(#arg1, #arg2, \ - (intmax_t)(arg1), (intmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_GEQ); \ -} while(0) - -#define ASSERT_INT_L(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_int(#arg1, #arg2, \ - (intmax_t)(arg1), (intmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_L); \ -} while(0) - -#define ASSERT_INT_LEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_int(#arg1, #arg2, \ - (intmax_t)(arg1), (intmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_LEQ); \ -} while(0) - -#define ASSERT_UINT(arg) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(0, arg); \ - simple_test_assert_uint("0", #arg, \ - (uintmax_t)0, (uintmax_t)(arg), \ - __FILE__, __LINE__, SIMPLE_TEST_TRUE); \ -} while(0) - -#define ASSERT_UINT_EQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_uint(#arg1, #arg2, \ - (uintmax_t)(arg1), (uintmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_EQ); \ -} while(0) - -#define ASSERT_UINT_NEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_uint(#arg1, #arg2, \ - (uintmax_t)(arg1), (uintmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_NEQ); \ -} while(0) - -#define ASSERT_UINT_G(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_uint(#arg1, #arg2, \ - (uintmax_t)(arg1), (uintmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_G); \ -} while(0) - -#define ASSERT_UINT_GEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_uint(#arg1, #arg2, \ - (uintmax_t)(arg1), (uintmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_GEQ); \ -} while(0) - -#define ASSERT_UINT_L(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_uint(#arg1, #arg2, \ - (uintmax_t)(arg1), (uintmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_L); \ -} while(0) - -#define ASSERT_UINT_LEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_uint(#arg1, #arg2, \ - (uintmax_t)(arg1), (uintmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_LEQ); \ -} while(0) - -#define ASSERT_HEX(arg) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(0, arg2); \ - simple_test_assert_uint("0", #arg, \ - (uintmax_t)0, (uintmax_t)(arg), \ - __FILE__, __LINE__, SIMPLE_TEST_TRUE); \ -} while(0) - -#define ASSERT_HEX_EQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_uint(#arg1, #arg2, \ - (uintmax_t)(arg1), (uintmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_EQ); \ -} while(0) - -#define ASSERT_HEX_NEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_hex(#arg1, #arg2, \ - (uintmax_t)(arg1), (uintmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_NEQ); \ -} while(0) - -#define ASSERT_HEX_G(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_hex(#arg1, #arg2, \ - (uintmax_t)(arg1), (uintmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_G); \ -} while(0) - -#define ASSERT_HEX_GEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_hex(#arg1, #arg2, \ - (uintmax_t)(arg1), (uintmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_GEQ); \ -} while(0) - -#define ASSERT_HEX_L(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_hex(#arg1, #arg2, \ - (uintmax_t)(arg1), (uintmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_L); \ -} while(0) - -#define ASSERT_HEX_LEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_hex(#arg1, #arg2, \ - (uintmax_t)(arg1), (uintmax_t)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_LEQ); \ -} while(0) - -#define ASSERT_FLOAT(arg) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(0.0, arg); \ - simple_test_assert_float("0", #arg, \ - (long double)0, (long double)(arg), \ - __FILE__, __LINE__, SIMPLE_TEST_TRUE); \ -} while(0) - -#define ASSERT_FLOAT_EQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_float(#arg1, #arg2, \ - (long double)(arg1), (long double)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_EQ); \ -} while(0) - -#define ASSERT_FLOAT_NEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_float(#arg1, #arg2, \ - (long double)(arg1), (long double)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_NEQ); \ -} while(0) - -#define ASSERT_FLOAT_G(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_float(#arg1, #arg2, \ - (long double)(arg1), (long double)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_G); \ -} while(0) - -#define ASSERT_FLOAT_GEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_float(#arg1, #arg2, \ - (long double)(arg1), (long double)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_GEQ); \ -} while(0) - -#define ASSERT_FLOAT_L(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_float(#arg1, #arg2, \ - (long double)(arg1), (long double)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_L); \ -} while(0) - -#define ASSERT_FLOAT_LEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_float(#arg1, #arg2, \ - (long double)(arg1), (long double)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_LEQ); \ -} while(0) - -#define ASSERT_PTR(arg) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(NULL, arg); \ - simple_test_assert_ptr("NULL", #arg, \ - NULL, (void *)(arg), \ - __FILE__, __LINE__, SIMPLE_TEST_TRUE); \ -} while(0) - -#define ASSERT_PTR_EQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_ptr(#arg1, #arg2, \ - (void *)(arg1), (void *)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_EQ); \ -} while(0) - -#define ASSERT_PTR_NEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_ptr(#arg1, #arg2, \ - (void *)(arg1), (void *)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_NEQ); \ -} while(0) - -#define ASSERT_PTR_G(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_ptr(#arg1, #arg2, \ - (void *)(arg1), (void *)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_G); \ -} while(0) - -#define ASSERT_PTR_GEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_ptr(#arg1, #arg2, \ - (void *)(arg1), (void *)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_GEQ); \ -} while(0) - -#define ASSERT_PTR_L(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_ptr(#arg1, #arg2, \ - (void *)(arg1), (void *)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_L); \ -} while(0) - -#define ASSERT_PTR_LEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_ptr(#arg1, #arg2, \ - (void *)(arg1), (void *)(arg2), \ - __FILE__, __LINE__, SIMPLE_TEST_LEQ); \ -} while(0) - -#define ASSERT_CHAR(arg) \ -do { \ - SIMPLE_TEST_TYPE_CHECK('\0', arg); \ - simple_test_assert_char("\\0", #arg, \ - '\0', arg, \ - __FILE__, __LINE__, SIMPLE_TEST_TRUE); \ -} while(0) - -#define ASSERT_CHAR_EQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_char(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_EQ); \ -} while(0) - -#define ASSERT_CHAR_NEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_char(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_NEQ); \ -} while(0) - -#define ASSERT_CHAR_G(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_char(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_G); \ -} while(0) - -#define ASSERT_CHAR_GEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_char(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_GEQ); \ -} while(0) - -#define ASSERT_CHAR_L(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_char(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_L); \ -} while(0) - -#define ASSERT_CHAR_LEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_char(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_LEQ); \ -} while(0) - -#define ASSERT_STR(arg) \ -do { \ - SIMPLE_TEST_TYPE_CHECK("0", arg); \ - simple_test_assert_str("0", #arg, \ - 0, (arg), \ - __FILE__, __LINE__, SIMPLE_TEST_TRUE); \ -} while(0) - -#define ASSERT_STR_EQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_str(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_EQ); \ -} while(0) - -#define ASSERT_STR_NEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_str(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_NEQ); \ -} while(0) - -#define ASSERT_STR_G(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_str(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_G); \ -} while(0) - -#define ASSERT_STR_GEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_str(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_GEQ); \ -} while(0) - -#define ASSERT_STR_L(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_str(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_L); \ -} while(0) - -#define ASSERT_STR_LEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_str(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_LEQ); \ -} while(0) - -#define ASSERT_WCHAR(arg) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(L'\0', arg2); \ - simple_test_assert_wchar("\\0", #arg, \ - L'\0', arg, \ - __FILE__, __LINE__, SIMPLE_TEST_TRUE); \ -} while(0) - -#define ASSERT_WCHAR_EQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_wchar(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_EQ); \ -} while(0) - -#define ASSERT_WCHAR_NEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_wchar(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_NEQ); \ -} while(0) - -#define ASSERT_WCHAR_G(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_wchar(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_G); \ -} while(0) - -#define ASSERT_WCHAR_GEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_wchar(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_GEQ); \ -} while(0) - -#define ASSERT_WCHAR_L(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_wchar(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_L); \ -} while(0) - -#define ASSERT_WCHAR_LEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_wchar(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_LEQ); \ -} while(0) - -#define ASSERT_WSTR(arg) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(L"0", arg); \ - simple_test_assert_wstr("0", #arg, \ - 0, (arg), \ - __FILE__, __LINE__, SIMPLE_TEST_TRUE); \ -} while(0) - -#define ASSERT_WSTR_EQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_wstr(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_EQ); \ -} while(0) - -#define ASSERT_WSTR_NEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_wstr(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_NEQ); \ -} while(0) - -#define ASSERT_WSTR_G(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_wstr(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_G); \ -} while(0) - -#define ASSERT_WSTR_GEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_wstr(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_GEQ); \ -} while(0) - -#define ASSERT_WSTR_L(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_wstr(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_L); \ -} while(0) - -#define ASSERT_WSTR_LEQ(arg1, arg2) \ -do { \ - SIMPLE_TEST_TYPE_CHECK(arg1, arg2); \ - simple_test_assert_wstr(#arg1, #arg2, \ - arg1, arg2, \ - __FILE__, __LINE__, SIMPLE_TEST_LEQ); \ -} while(0) +#define SIMPLE_TEST_ASSERT1(t, c, s, a) \ + do { \ + switch ( simple_test_assert(t, c, (a)) ) { \ + case 1: break; \ + case 0: \ + SIMPLE_TEST_FAIL1(s " failed"); \ + SIMPLE_TEST_PRINT_VAL(0, #a, t); \ + SIMPLE_TEST_FAIL2; \ + break; \ + default: \ + SIMPLE_TEST_ERR("unrecognised type in assertion"); \ + } \ + } while (0) + +#define SIMPLE_TEST_ASSERT2(t1, t2, c, s, a, b) \ + do { \ + switch ( simple_test_assert(simple_test_type_resolve(t1, t2), \ + c, (a), (b)) ) { \ + case 1: break; \ + case 0: \ + SIMPLE_TEST_FAIL1(s " failed"); \ + SIMPLE_TEST_PRINT_VAL(0, #a, simple_test_type_resolve(t1, t2)); \ + SIMPLE_TEST_PRINT_VAL(1, #b, simple_test_type_resolve(t1, t2)); \ + SIMPLE_TEST_FAIL2; \ + break; \ + case -2: \ + SIMPLE_TEST_ERR("type mismatch in assertion"); \ + default: \ + SIMPLE_TEST_ERR("unrecognised type in assertion"); \ + } \ + } while (0) + +#define ASSERT(a) \ + SIMPLE_TEST_ASSERT1(SIMPLE_TEST_TYPE((a)), SIMPLE_TEST_TRUE, "ASSERT", a) + +#define ASSERT_NOT(a) \ + SIMPLE_TEST_ASSERT1(SIMPLE_TEST_TYPE((a)), SIMPLE_TEST_FALSE, \ + "ASSERT_NOT", a) + +#define ASSERT_EQ(a, b) \ + SIMPLE_TEST_ASSERT2(SIMPLE_TEST_TYPE((a)), SIMPLE_TEST_TYPE((b)), \ + SIMPLE_TEST_EQ, "ASSERT_EQ", a, b) + +#define ASSERT_NEQ(a, b) \ + SIMPLE_TEST_ASSERT2(SIMPLE_TEST_TYPE((a)), SIMPLE_TEST_TYPE((b)), \ + SIMPLE_TEST_NEQ, "ASSERT_NEQ", a, b) + +#define ASSERT_GT(a, b) \ + SIMPLE_TEST_ASSERT2(SIMPLE_TEST_TYPE((a)), SIMPLE_TEST_TYPE((b)), \ + SIMPLE_TEST_GT, "ASSERT_GT", a, b) + +#define ASSERT_LT(a, b) \ + SIMPLE_TEST_ASSERT2(SIMPLE_TEST_TYPE((a)), SIMPLE_TEST_TYPE((b)), \ + SIMPLE_TEST_LT, "ASSERT_LT", a, b) + +#define ASSERT_GEQ(a, b) \ + SIMPLE_TEST_ASSERT2(SIMPLE_TEST_TYPE((a)), SIMPLE_TEST_TYPE((b)), \ + SIMPLE_TEST_GEQ, "ASSERT_GEQ", a, b) + +#define ASSERT_LEQ(a, b) \ + SIMPLE_TEST_ASSERT2(SIMPLE_TEST_TYPE((a)), SIMPLE_TEST_TYPE((b)), \ + SIMPLE_TEST_LEQ, "ASSERT_LEQ", a, b) #endif |