aboutsummaryrefslogtreecommitdiffstats
path: root/src/simple-test.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/simple-test.h')
-rw-r--r--src/simple-test.h1681
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
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-19 16:22:03 +0000