commit 3f0ef4538e7d1617b39e09a4cbd78312a9fcdc2e
parent 8d8421b7e5e5d15f840f02f05ea70f779935653e
Author: vaplv <vaplv@free.fr>
Date: Wed, 22 Nov 2017 10:13:26 +0100
Add the CHK macro and make deprecated [N]CHECK
Replace the [N]CHECK macros by CHK.
Diffstat:
29 files changed, 1261 insertions(+), 1262 deletions(-)
diff --git a/src/rsys.h b/src/rsys.h
@@ -190,6 +190,17 @@
#define ATOMIC_GET(A) ATOMIC_ADD(A, 0)
/*******************************************************************************
+ * Function deprecation
+ ******************************************************************************/
+#ifdef COMPILER_CL
+ #define DEPRECATED __declspec(deprecated)
+#elif defined COMPILER_GCC
+ #define DEPRECATED __attribute__((deprecated))
+#else
+ #define DEPRECATED
+#endif
+
+/*******************************************************************************
* Code checking
******************************************************************************/
#ifdef NDEBUG
@@ -216,17 +227,16 @@
abort(); \
} (void)0
-#define CHECK(A, B) \
+#define CHK(Cond) \
{ \
- if((A) != (B)) \
- FATAL("error:" STR( __FILE__ ) ":" STR( __LINE__ )"\n"); \
+ if(!(Cond)) \
+ FATAL("error:" STR(__FILE__) ":" STR(__LINE__)"\n"); \
} (void)0
-#define NCHECK(A, B) \
- { \
- if((A) == (B)) \
- FATAL("error:" STR( __FILE__ ) ":" STR( __LINE__ )"\n"); \
- } (void)0
+static INLINE DEPRECATED void deprecated_CHECK(void) { (void)0; }
+static INLINE DEPRECATED void deprecated_NCHECK(void) { (void)0; }
+#define CHECK(A, B) { deprecated_CHECK(); CHK((A) == (B)); } (void)0
+#define NCHECK(A, B) { deprecated_NCHECK(); CHK((A) != (B)); } (void)0
/*******************************************************************************
* Branch prediction information
@@ -376,14 +386,6 @@ typedef int res_T;
? (uintptr_t)(B) < ((uintptr_t)(A) + (SzA)) \
: (uintptr_t)(A) < ((uintptr_t)(B) + (SzB)))
-#ifdef COMPILER_CL
- #define DEPRECATED __declspec(deprecated)
-#elif defined COMPILER_GCC
- #define DEPRECATED __attribute__((deprecated))
-#else
- #define DEPRECATED
-#endif
-
#ifdef __cplusplus
#define BEGIN_DECLS extern "C" {
#define END_DECLS }
diff --git a/src/test_algorithm.c b/src/test_algorithm.c
@@ -18,16 +18,16 @@
static int
cmp_int(const void* a, const void* b)
{
- NCHECK(a, NULL);
- NCHECK(b, NULL);
+ CHK(a != NULL);
+ CHK(b != NULL);
return *(const int*)a - *(const int*)b;
}
static int
cmp_dbl(const void* a, const void* b)
{
- NCHECK(a, NULL);
- NCHECK(b, NULL);
+ CHK(a != NULL);
+ CHK(b != NULL);
return *(const double*)a < *(const double*) b
? -1 : (*(const double*)a > *(const double*)b ? 1 : 0);
}
@@ -48,36 +48,36 @@ main(int argc, char** argv)
(void)argc, (void)argv;
i = 3, pi = search_lower_bound(&i, array_int, nints, sizeof(int), cmp_int);
- CHECK(*pi, 4);
- CHECK(pi[3], 6);
+ CHK(*pi == 4);
+ CHK(pi[3] == 6);
i = 4, pi = search_lower_bound(&i, array_int, nints, sizeof(int), cmp_int);
- CHECK(*pi, 4);
- CHECK(pi[3], 6);
+ CHK(*pi == 4);
+ CHK(pi[3] == 6);
i = 5, pi = search_lower_bound(&i, array_int, nints, sizeof(int), cmp_int);
- CHECK(*pi, 6);
+ CHK(*pi == 6);
i = 13, pi = search_lower_bound(&i, array_int, nints, sizeof(int), cmp_int);
- CHECK(*pi, 13);
+ CHK(*pi == 13);
i = -1, pi = search_lower_bound(&i, array_int, nints, sizeof(int), cmp_int);
- CHECK(*pi, 0);
+ CHK(*pi == 0);
i = 19, pi = search_lower_bound(&i, array_int, nints, sizeof(int), cmp_int);
- CHECK(pi, NULL);
+ CHK(pi == NULL);
d = 2.1, pd = search_lower_bound(&d, array_dbl, ndbls, sizeof(double), cmp_dbl);
- CHECK(*pd, 2.3);
+ CHK(*pd == 2.3);
d = 2.3, pd = search_lower_bound(&d, array_dbl, ndbls, sizeof(double), cmp_dbl);
- CHECK(*pd, 2.3);
- CHECK(pd[3], 4);
+ CHK(*pd == 2.3);
+ CHK(pd[3] == 4);
d = -1.0, pd = search_lower_bound(&d, array_dbl, ndbls, sizeof(double), cmp_dbl);
- CHECK(*pd, 2.3);
+ CHK(*pd == 2.3);
d = 6.001, pd = search_lower_bound(&d, array_dbl, ndbls, sizeof(double), cmp_dbl);
- CHECK(*pd, 9.1);
+ CHK(*pd == 9.1);
d = 19.0, pd = search_lower_bound(&d, array_dbl, ndbls, sizeof(double), cmp_dbl);
- CHECK(*pd, 19.123);
+ CHK(*pd == 19.123);
d = 20.0, pd = search_lower_bound(&d, array_dbl, ndbls, sizeof(double), cmp_dbl);
- CHECK(pd, NULL);
+ CHK(pd == NULL);
i = -1, pi = search_lower_bound(&i, array_int, 1, sizeof(int), cmp_int);
- CHECK(*pi, 0);
+ CHK(*pi == 0);
return 0;
}
diff --git a/src/test_atomic.c b/src/test_atomic.c
@@ -23,29 +23,29 @@ main(int argc, char** argv)
(void)argc, (void)argv;
tmp = ATOMIC_INCR(&atom);
- CHECK(atom, 1);
- CHECK(tmp, 1);
+ CHK(atom == 1);
+ CHK(tmp == 1);
tmp = ATOMIC_ADD(&atom, 5);
- CHECK(atom, 6);
- CHECK(tmp, 6);
+ CHK(atom == 6);
+ CHK(tmp == 6);
tmp = ATOMIC_DECR(&atom);
- CHECK(atom, 5);
- CHECK(tmp, 5);
+ CHK(atom == 5);
+ CHK(tmp == 5);
tmp = ATOMIC_SUB(&atom, 7);
- CHECK(atom, -2);
- CHECK(tmp, -2);
+ CHK(atom == -2);
+ CHK(tmp == -2);
tmp = ATOMIC_CAS(&atom, 0, -1);
- CHECK(atom, -2);
- CHECK(tmp, -2);
+ CHK(atom == -2);
+ CHK(tmp == -2);
tmp = ATOMIC_CAS(&atom, 0, -2);
- CHECK(atom, 0);
- CHECK(tmp, -2);
+ CHK(atom == 0);
+ CHK(tmp == -2);
tmp = ATOMIC_SET(&atom, 9);
- CHECK(atom, 9);
- CHECK(tmp, 0);
+ CHK(atom == 9);
+ CHK(tmp == 0);
tmp = ATOMIC_GET(&atom);
- CHECK(tmp, 9);
+ CHK(tmp == 9);
return 0;
}
diff --git a/src/test_binary_heap.c b/src/test_binary_heap.c
@@ -31,69 +31,69 @@ test_primitive_type(void)
mem_init_proxy_allocator(&allocator_proxy, &mem_default_allocator);
bheap_u64_init(&allocator_proxy, &heap);
- CHECK(bheap_u64_is_empty(&heap), 1);
+ CHK(bheap_u64_is_empty(&heap) == 1);
bheap_u64_clear(&heap);
- CHECK(bheap_u64_is_empty(&heap), 1);
-
- CHECK(bheap_u64_is_empty(&heap), 1);
- CHECK(bheap_u64_top(&heap, &i), 0);
- CHECK(bheap_u64_pop(&heap, &i), 0);
- i = 48; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
- i = 51; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
- i = 1; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
- i = 7; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
- i = 78; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
- i = 4; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
- i = 61; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
- i = 72; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
- CHECK(bheap_u64_is_empty(&heap), 0);
-
- NCHECK(bheap_u64_top(&heap, &i), 0);
- CHECK(i, 1);
- NCHECK(bheap_u64_top(&heap, &i), 0);
- CHECK(i, 1);
- NCHECK(bheap_u64_pop(&heap, &i), 0);
- CHECK(i, 1);
- NCHECK(bheap_u64_pop(&heap, &i), 0);
- CHECK(i, 4);
- NCHECK(bheap_u64_pop(&heap, &i), 0);
- CHECK(i, 7);
- NCHECK(bheap_u64_pop(&heap, &i), 0);
- CHECK(i, 48);
-
- i = 5; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
- i = 50; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
- i = 51; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
- NCHECK(bheap_u64_top(&heap, &i), 0);
- CHECK(i, 5);
- NCHECK(bheap_u64_pop(&heap, &i), 0);
- CHECK(i, 5);
- NCHECK(bheap_u64_pop(&heap, &i), 0);
- CHECK(i, 50);
- NCHECK(bheap_u64_pop(&heap, &i), 0);
- CHECK(i, 51);
- NCHECK(bheap_u64_pop(&heap, &i), 0);
- CHECK(i, 51);
- NCHECK(bheap_u64_pop(&heap, &i), 0);
- CHECK(i, 61);
- NCHECK(bheap_u64_pop(&heap, &i), 0);
- CHECK(i, 72);
- NCHECK(bheap_u64_pop(&heap, &i), 0);
- CHECK(i, 78);
- CHECK(bheap_u64_pop(&heap, &i), 0);
-
- CHECK(bheap_u64_is_empty(&heap), 1);
+ CHK(bheap_u64_is_empty(&heap) == 1);
+
+ CHK(bheap_u64_is_empty(&heap) == 1);
+ CHK(bheap_u64_top(&heap, &i) == 0);
+ CHK(bheap_u64_pop(&heap, &i) == 0);
+ i = 48; CHK(bheap_u64_insert(&heap, &i) == RES_OK);
+ i = 51; CHK(bheap_u64_insert(&heap, &i) == RES_OK);
+ i = 1; CHK(bheap_u64_insert(&heap, &i) == RES_OK);
+ i = 7; CHK(bheap_u64_insert(&heap, &i) == RES_OK);
+ i = 78; CHK(bheap_u64_insert(&heap, &i) == RES_OK);
+ i = 4; CHK(bheap_u64_insert(&heap, &i) == RES_OK);
+ i = 61; CHK(bheap_u64_insert(&heap, &i) == RES_OK);
+ i = 72; CHK(bheap_u64_insert(&heap, &i) == RES_OK);
+ CHK(bheap_u64_is_empty(&heap) == 0);
+
+ CHK(bheap_u64_top(&heap, &i) != 0);
+ CHK(i == 1);
+ CHK(bheap_u64_top(&heap, &i) != 0);
+ CHK(i == 1);
+ CHK(bheap_u64_pop(&heap, &i) != 0);
+ CHK(i == 1);
+ CHK(bheap_u64_pop(&heap, &i) != 0);
+ CHK(i == 4);
+ CHK(bheap_u64_pop(&heap, &i) != 0);
+ CHK(i == 7);
+ CHK(bheap_u64_pop(&heap, &i) != 0);
+ CHK(i == 48);
+
+ i = 5; CHK(bheap_u64_insert(&heap, &i) == RES_OK);
+ i = 50; CHK(bheap_u64_insert(&heap, &i) == RES_OK);
+ i = 51; CHK(bheap_u64_insert(&heap, &i) == RES_OK);
+ CHK(bheap_u64_top(&heap, &i) != 0);
+ CHK(i == 5);
+ CHK(bheap_u64_pop(&heap, &i) != 0);
+ CHK(i == 5);
+ CHK(bheap_u64_pop(&heap, &i) != 0);
+ CHK(i == 50);
+ CHK(bheap_u64_pop(&heap, &i) != 0);
+ CHK(i == 51);
+ CHK(bheap_u64_pop(&heap, &i) != 0);
+ CHK(i == 51);
+ CHK(bheap_u64_pop(&heap, &i) != 0);
+ CHK(i == 61);
+ CHK(bheap_u64_pop(&heap, &i) != 0);
+ CHK(i == 72);
+ CHK(bheap_u64_pop(&heap, &i) != 0);
+ CHK(i == 78);
+ CHK(bheap_u64_pop(&heap, &i) == 0);
+
+ CHK(bheap_u64_is_empty(&heap) == 1);
FOR_EACH(i, 0, 17689) {
const uint64_t j = (uint64_t)rand();
- CHECK(bheap_u64_insert(&heap, &j), RES_OK);
+ CHK(bheap_u64_insert(&heap, &j) == RES_OK);
}
- CHECK(bheap_u64_is_empty(&heap), 0);
- NCHECK(bheap_u64_pop(&heap, &i), 0);
+ CHK(bheap_u64_is_empty(&heap) == 0);
+ CHK(bheap_u64_pop(&heap, &i) != 0);
while(bheap_u64_is_empty(&heap)) {
uint64_t j = 0;
- NCHECK(bheap_u64_pop(&heap, &j), 0);
- CHECK(j >= i, 1);
+ CHK(bheap_u64_pop(&heap, &j) != 0);
+ CHK(j >= i);
i = j;
}
@@ -156,12 +156,12 @@ test_struct(void)
bheap_str_insert(&heap, &str);
}
- NCHECK(bheap_str_pop(&heap, &str), 0);
+ CHK(bheap_str_pop(&heap, &str) != 0);
while(bheap_str_is_empty(&heap)) {
struct str str2;
str_init(&allocator_proxy, &str2);
- NCHECK(bheap_str_pop(&heap, &str2), 0);
- CHECK(strcmp(str_cget(&str), str_cget(&str2)), -1);
+ CHK(bheap_str_pop(&heap, &str2) != 0);
+ CHK(strcmp(str_cget(&str), str_cget(&str2)) == -1);
str_set(&str, str_cget(&str2));
str_release(&str2);
}
@@ -179,7 +179,7 @@ main(int argc, char** argv)
(void)argc, (void)argv;
test_primitive_type();
test_struct();
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_condition.c b/src/test_condition.c
@@ -108,7 +108,7 @@ read(struct stream* stream)
buff_node = list_head(&stream->list_flush);
buff = CONTAINER_OF(buff_node, struct buff, node);
- CHECK(strcmp(buff->scratch, src_str[i]), 0);
+ CHK(strcmp(buff->scratch, src_str[i]) == 0);
printf("\n%s\n", buff->scratch);
mutex_lock(stream->mutex);
@@ -159,11 +159,11 @@ main(int argc, char** argv)
list_init(&stream.list_fill);
list_init(&stream.list_flush);
stream.mutex = mutex_create();
- NCHECK(stream.mutex, NULL);
+ CHK(stream.mutex != NULL);
stream.cond_flush = cond_create();
- NCHECK(stream.cond_flush, NULL);
+ CHK(stream.cond_flush != NULL);
stream.cond_fill = cond_create();
- NCHECK(stream.cond_fill, NULL);
+ CHK(stream.cond_fill != NULL);
list_init(&buff[0].node);
list_init(&buff[1].node);
diff --git a/src/test_cstr.c b/src/test_cstr.c
@@ -20,61 +20,61 @@ static void
test_double(void)
{
double d;
- CHECK(cstr_to_double(NULL, &d), RES_BAD_ARG);
- CHECK(cstr_to_double("a", &d), RES_BAD_ARG);
- CHECK(cstr_to_double(STR(PI), &d), RES_OK);
- CHECK(d, PI);
- CHECK(cstr_to_double(" 1.e-3", &d), RES_OK);
- CHECK(d, 1.e-3);
- CHECK(cstr_to_double("+1.E+3 ", &d), RES_OK);
- CHECK(d, 1.e3);
- CHECK(cstr_to_double("INF", &d), RES_OK);
- CHECK(d, INF);
- CHECK(cstr_to_double("INFINITY", &d), RES_OK);
- CHECK(d, INF);
- CHECK(cstr_to_double("", &d), RES_BAD_ARG);
+ CHK(cstr_to_double(NULL, &d) == RES_BAD_ARG);
+ CHK(cstr_to_double("a", &d) == RES_BAD_ARG);
+ CHK(cstr_to_double(STR(PI), &d) == RES_OK);
+ CHK(d == PI);
+ CHK(cstr_to_double(" 1.e-3", &d) == RES_OK);
+ CHK(d == 1.e-3);
+ CHK(cstr_to_double("+1.E+3 ", &d) == RES_OK);
+ CHK(d == 1.e3);
+ CHK(cstr_to_double("INF", &d) == RES_OK);
+ CHK(d == INF);
+ CHK(cstr_to_double("INFINITY", &d) == RES_OK);
+ CHK(d == INF);
+ CHK(cstr_to_double("", &d) == RES_BAD_ARG);
}
static void
test_float(void)
{
float f;
- CHECK(cstr_to_float(NULL, &f), RES_BAD_ARG);
- CHECK(cstr_to_float("a", &f), RES_BAD_ARG);
- CHECK(cstr_to_float(STR(PI), &f), RES_OK);
- CHECK(f, (float)PI);
- CHECK(cstr_to_float("1.e-1", &f), RES_OK);
- CHECK(f, 1.e-1f);
- CHECK(cstr_to_float("+1.E+3", &f), RES_OK);
- CHECK(f, 1.e3f);
- CHECK(cstr_to_float("INF", &f), RES_OK);
- CHECK(f, (float)INF);
- CHECK(cstr_to_float("INFINITY", &f), RES_OK);
- CHECK(f, (float)INF);
- CHECK(cstr_to_float(STR(DBL_MAX), &f), RES_BAD_ARG);
- CHECK(cstr_to_float(STR(DBL_MIN), &f), RES_BAD_ARG);
- CHECK(cstr_to_float("0.0", &f), RES_OK);
- CHECK(f, 0.f);
- CHECK(cstr_to_float("-0.0", &f), RES_OK);
- CHECK(f, 0.f);
+ CHK(cstr_to_float(NULL, &f) == RES_BAD_ARG);
+ CHK(cstr_to_float("a", &f) == RES_BAD_ARG);
+ CHK(cstr_to_float(STR(PI), &f) == RES_OK);
+ CHK(f == (float)PI);
+ CHK(cstr_to_float("1.e-1", &f) == RES_OK);
+ CHK(f == 1.e-1f);
+ CHK(cstr_to_float("+1.E+3", &f) == RES_OK);
+ CHK(f == 1.e3f);
+ CHK(cstr_to_float("INF", &f) == RES_OK);
+ CHK(f == (float)INF);
+ CHK(cstr_to_float("INFINITY", &f) == RES_OK);
+ CHK(f == (float)INF);
+ CHK(cstr_to_float(STR(DBL_MAX), &f) == RES_BAD_ARG);
+ CHK(cstr_to_float(STR(DBL_MIN), &f) == RES_BAD_ARG);
+ CHK(cstr_to_float("0.0", &f) == RES_OK);
+ CHK(f == 0.f);
+ CHK(cstr_to_float("-0.0", &f) == RES_OK);
+ CHK(f == 0.f);
}
static void
test_long(void)
{
long l;
- CHECK(cstr_to_long(NULL, &l), RES_BAD_ARG);
- CHECK(cstr_to_long("a", &l), RES_BAD_ARG);
- CHECK(cstr_to_long("1.e-3", &l), RES_BAD_ARG);
- CHECK(cstr_to_long("1", &l), RES_OK);
- CHECK(l, 1);
- CHECK(cstr_to_long("-1", &l), RES_OK);
- CHECK(l, -1);
- CHECK(cstr_to_long("+1234567890", &l), RES_OK);
- CHECK(l, 1234567890);
- CHECK(cstr_to_long(" \t+1234567890 \t ", &l), RES_OK);
- CHECK(l, 1234567890);
- CHECK(cstr_to_long(" \t+1234567890 \t a", &l), RES_BAD_ARG);
+ CHK(cstr_to_long(NULL, &l) == RES_BAD_ARG);
+ CHK(cstr_to_long("a", &l) == RES_BAD_ARG);
+ CHK(cstr_to_long("1.e-3", &l) == RES_BAD_ARG);
+ CHK(cstr_to_long("1", &l) == RES_OK);
+ CHK(l == 1);
+ CHK(cstr_to_long("-1", &l) == RES_OK);
+ CHK(l == -1);
+ CHK(cstr_to_long("+1234567890", &l) == RES_OK);
+ CHK(l == 1234567890);
+ CHK(cstr_to_long(" \t+1234567890 \t ", &l) == RES_OK);
+ CHK(l == 1234567890);
+ CHK(cstr_to_long(" \t+1234567890 \t a", &l) == RES_BAD_ARG);
}
static void
@@ -83,25 +83,25 @@ test_int(void)
char buf[128];
int i;
- CHECK(cstr_to_int(NULL, &i), RES_BAD_ARG);
- CHECK(cstr_to_int("a", &i), RES_BAD_ARG);
- CHECK(cstr_to_int("1.e-1", &i), RES_BAD_ARG);
- CHECK(cstr_to_int("1", &i), RES_OK);
- CHECK(i, 1);
- CHECK(cstr_to_int("-2", &i), RES_OK);
- CHECK(i, -2);
- CHECK(cstr_to_int("\t-2 ", &i), RES_OK);
- CHECK(i, -2);
+ CHK(cstr_to_int(NULL, &i) == RES_BAD_ARG);
+ CHK(cstr_to_int("a", &i) == RES_BAD_ARG);
+ CHK(cstr_to_int("1.e-1", &i) == RES_BAD_ARG);
+ CHK(cstr_to_int("1", &i) == RES_OK);
+ CHK(i == 1);
+ CHK(cstr_to_int("-2", &i) == RES_OK);
+ CHK(i == -2);
+ CHK(cstr_to_int("\t-2 ", &i) == RES_OK);
+ CHK(i == -2);
sprintf(buf, "%d", INT_MAX);
- CHECK(cstr_to_int(buf, &i), RES_OK);
- CHECK(i, INT_MAX);
+ CHK(cstr_to_int(buf, &i) == RES_OK);
+ CHK(i == INT_MAX);
sprintf(buf, "%d", INT_MIN);
- CHECK(cstr_to_int(buf, &i), RES_OK);
- CHECK(i, INT_MIN);
+ CHK(cstr_to_int(buf, &i) == RES_OK);
+ CHK(i == INT_MIN);
sprintf(buf, "%lld", (long long)INT_MAX+1);
- CHECK(cstr_to_int(buf, &i), RES_BAD_ARG);
+ CHK(cstr_to_int(buf, &i) == RES_BAD_ARG);
sprintf(buf, "%lld", (long long)INT_MIN-1);
- CHECK(cstr_to_int(buf, &i), RES_BAD_ARG);
+ CHK(cstr_to_int(buf, &i) == RES_BAD_ARG);
}
static void
@@ -110,22 +110,22 @@ test_uint(void)
char buf[128];
unsigned u;
- CHECK(cstr_to_uint(NULL, &u), RES_BAD_ARG);
- CHECK(cstr_to_uint("a", &u), RES_BAD_ARG);
- CHECK(cstr_to_uint("-1", &u), RES_OK);
- CHECK(u, UINT_MAX);
- CHECK(cstr_to_uint("0.", &u), RES_BAD_ARG);
- CHECK(cstr_to_uint("0", &u), RES_OK);
- CHECK(u, 0);
- CHECK(cstr_to_uint("+2", &u), RES_OK);
- CHECK(u, 2);
- CHECK(cstr_to_uint(" \t+123 \t ", &u), RES_OK);
- CHECK(u, 123);
+ CHK(cstr_to_uint(NULL, &u) == RES_BAD_ARG);
+ CHK(cstr_to_uint("a", &u) == RES_BAD_ARG);
+ CHK(cstr_to_uint("-1", &u) == RES_OK);
+ CHK(u == UINT_MAX);
+ CHK(cstr_to_uint("0.", &u) == RES_BAD_ARG);
+ CHK(cstr_to_uint("0", &u) == RES_OK);
+ CHK(u == 0);
+ CHK(cstr_to_uint("+2", &u) == RES_OK);
+ CHK(u == 2);
+ CHK(cstr_to_uint(" \t+123 \t ", &u) == RES_OK);
+ CHK(u == 123);
sprintf(buf, "%u", UINT_MAX);
- CHECK(cstr_to_uint(buf, &u), RES_OK);
- CHECK(u, UINT_MAX);
+ CHK(cstr_to_uint(buf, &u) == RES_OK);
+ CHK(u == UINT_MAX);
sprintf(buf, "%llu", (unsigned long long)UINT_MAX+1);
- CHECK(cstr_to_uint(buf, &u), RES_BAD_ARG);
+ CHK(cstr_to_uint(buf, &u) == RES_BAD_ARG);
}
static void
@@ -134,22 +134,22 @@ test_ulong(void)
char buf[128];
unsigned long ul;
- CHECK(cstr_to_ulong(NULL, &ul), RES_BAD_ARG);
- CHECK(cstr_to_ulong("a", &ul), RES_BAD_ARG);
- CHECK(cstr_to_ulong("-1", &ul), RES_OK);
- CHECK(ul, ULONG_MAX);
- CHECK(cstr_to_ulong("0.", &ul), RES_BAD_ARG);
- CHECK(cstr_to_ulong("0", &ul), RES_OK);
- CHECK(ul, 0);
- CHECK(cstr_to_ulong("+2", &ul), RES_OK);
- CHECK(ul, 2);
- CHECK(cstr_to_ulong(" \t+123 \t ", &ul), RES_OK);
- CHECK(ul, 123);
+ CHK(cstr_to_ulong(NULL, &ul) == RES_BAD_ARG);
+ CHK(cstr_to_ulong("a", &ul) == RES_BAD_ARG);
+ CHK(cstr_to_ulong("-1", &ul) == RES_OK);
+ CHK(ul == ULONG_MAX);
+ CHK(cstr_to_ulong("0.", &ul) == RES_BAD_ARG);
+ CHK(cstr_to_ulong("0", &ul) == RES_OK);
+ CHK(ul == 0);
+ CHK(cstr_to_ulong("+2", &ul) == RES_OK);
+ CHK(ul == 2);
+ CHK(cstr_to_ulong(" \t+123 \t ", &ul) == RES_OK);
+ CHK(ul == 123);
sprintf(buf, "%lu", ULONG_MAX);
- CHECK(cstr_to_ulong(buf, &ul), RES_OK);
- CHECK(ul, ULONG_MAX);
+ CHK(cstr_to_ulong(buf, &ul) == RES_OK);
+ CHK(ul == ULONG_MAX);
sprintf(buf, "%lu%c", ULONG_MAX, '0');
- CHECK(cstr_to_ulong(buf, &ul), RES_BAD_ARG);
+ CHK(cstr_to_ulong(buf, &ul) == RES_BAD_ARG);
}
static void
@@ -158,43 +158,43 @@ test_list_double(void)
double dlist[4];
size_t len;
- CHECK(cstr_to_list_double(NULL, ':', dlist, NULL, 3), RES_BAD_ARG);
- CHECK(cstr_to_list_double("a", ':', dlist, NULL, 3), RES_BAD_ARG);
- CHECK(cstr_to_list_double("1.e-3:2.0:"STR(PI), ':', dlist, NULL, 3), RES_OK);
- CHECK(dlist[0], 1.e-3);
- CHECK(dlist[1], 2.0);
- CHECK(dlist[2], PI);
- CHECK(cstr_to_list_double("1.e-3:2.0:", ':', dlist, &len, 3), RES_OK);
- CHECK(len, 2);
- CHECK(dlist[0], 1.e-3);
- CHECK(dlist[1], 2.0);
- CHECK(cstr_to_list_double("-1.0:0.5:1.2:4.3", ':', dlist, &len, 2), RES_BAD_ARG);
- CHECK(cstr_to_list_double("-1.0:0.5:1.2:4.3a", ':', NULL, &len, 0), RES_BAD_ARG);
- CHECK(cstr_to_list_double("-1.0:0.5:1.2:4.3", ':', NULL, &len, 0), RES_OK);
- CHECK(len, 4);
- CHECK(cstr_to_list_double("-1.0:0.5:1.2:4.3", ':', dlist, NULL, len), RES_OK);
- CHECK(dlist[0], -1.0);
- CHECK(dlist[1], 0.5);
- CHECK(dlist[2], 1.2);
- CHECK(dlist[3], 4.3);
- CHECK(cstr_to_list_double(" \t -1.0,0.5,1.2,INF \t", ':', dlist, NULL, 4), RES_BAD_ARG);
- CHECK(cstr_to_list_double(" \t -1.0,0.5,1.2,INF \t", ',', dlist, NULL, 4), RES_OK);
- CHECK(dlist[0], -1.0);
- CHECK(dlist[1], 0.5);
- CHECK(dlist[2], 1.2);
- CHECK(dlist[3], INF);
- CHECK(cstr_to_list_double("-1.0.2.3", '.', dlist, NULL, 4), RES_OK);
- CHECK(dlist[0], -1);
- CHECK(dlist[1], 0);
- CHECK(dlist[2], 2);
- CHECK(dlist[3], 3);
- CHECK(cstr_to_list_double(" \t -1.0:0.5:1.2:4.3 \ta", ':', dlist, NULL, 4), RES_BAD_ARG);
+ CHK(cstr_to_list_double(NULL, ':', dlist, NULL, 3) == RES_BAD_ARG);
+ CHK(cstr_to_list_double("a", ':', dlist, NULL, 3) == RES_BAD_ARG);
+ CHK(cstr_to_list_double("1.e-3:2.0:"STR(PI), ':', dlist, NULL, 3) == RES_OK);
+ CHK(dlist[0] == 1.e-3);
+ CHK(dlist[1] == 2.0);
+ CHK(dlist[2] == PI);
+ CHK(cstr_to_list_double("1.e-3:2.0:", ':', dlist, &len, 3) == RES_OK);
+ CHK(len == 2);
+ CHK(dlist[0] == 1.e-3);
+ CHK(dlist[1] == 2.0);
+ CHK(cstr_to_list_double("-1.0:0.5:1.2:4.3", ':', dlist, &len, 2) == RES_BAD_ARG);
+ CHK(cstr_to_list_double("-1.0:0.5:1.2:4.3a", ':', NULL, &len, 0) == RES_BAD_ARG);
+ CHK(cstr_to_list_double("-1.0:0.5:1.2:4.3", ':', NULL, &len, 0) == RES_OK);
+ CHK(len == 4);
+ CHK(cstr_to_list_double("-1.0:0.5:1.2:4.3", ':', dlist, NULL, len) == RES_OK);
+ CHK(dlist[0] == -1.0);
+ CHK(dlist[1] == 0.5);
+ CHK(dlist[2] == 1.2);
+ CHK(dlist[3] == 4.3);
+ CHK(cstr_to_list_double(" \t -1.0,0.5,1.2,INF \t", ':', dlist, NULL, 4) == RES_BAD_ARG);
+ CHK(cstr_to_list_double(" \t -1.0,0.5,1.2,INF \t", ',', dlist, NULL, 4) == RES_OK);
+ CHK(dlist[0] == -1.0);
+ CHK(dlist[1] == 0.5);
+ CHK(dlist[2] == 1.2);
+ CHK(dlist[3] == INF);
+ CHK(cstr_to_list_double("-1.0.2.3", '.', dlist, NULL, 4) == RES_OK);
+ CHK(dlist[0] == -1);
+ CHK(dlist[1] == 0);
+ CHK(dlist[2] == 2);
+ CHK(dlist[3] == 3);
+ CHK(cstr_to_list_double(" \t -1.0:0.5:1.2:4.3 \ta", ':', dlist, NULL, 4) == RES_BAD_ARG);
dlist[1] = dlist[2] = dlist[3] = -1.0;
- CHECK(cstr_to_list_double("1.0", ':', dlist, NULL, 1), RES_OK);
- CHECK(dlist[0], 1.0);
- CHECK(dlist[1], -1.0);
- CHECK(dlist[2], -1.0);
- CHECK(dlist[3], -1.0);
+ CHK(cstr_to_list_double("1.0", ':', dlist, NULL, 1) == RES_OK);
+ CHK(dlist[0] == 1.0);
+ CHK(dlist[1] == -1.0);
+ CHK(dlist[2] == -1.0);
+ CHK(dlist[3] == -1.0);
}
static void
@@ -203,31 +203,31 @@ test_list_float(void)
float flist[4];
size_t len;
- CHECK(cstr_to_list_float(NULL, ':', flist, NULL, 3), RES_BAD_ARG);
- CHECK(cstr_to_list_float("a", ':', flist, NULL, 3), RES_BAD_ARG);
- CHECK(cstr_to_list_float("1.e-3:2.0:"STR(PI), ':', flist, NULL, 3), RES_OK);
- CHECK(flist[0], 1.e-3f);
- CHECK(flist[1], 2.0f);
- CHECK(flist[2], (float)PI);
- CHECK(cstr_to_list_float("1.e-3:2.0:", ':', flist, &len, 3), RES_OK);
- CHECK(len, 2);
- CHECK(flist[0], 1.e-3f);
- CHECK(flist[1], 2.0f);
- CHECK(cstr_to_list_float("-1.0:0.5:1.2:4.3", ':', flist, &len, 2), RES_BAD_ARG);
- CHECK(cstr_to_list_float("-1.0:0.5:1.2:4.3a", ':', NULL, &len, 0), RES_BAD_ARG);
- CHECK(cstr_to_list_float("-1.0:0.5:1.2:4.3", ':', NULL, &len, 0), RES_OK);
- CHECK(len, 4);
- CHECK(cstr_to_list_float("-1.0:0.5:1.2:4.3", ':', flist, NULL, len), RES_OK);
- CHECK(flist[0], -1.0f);
- CHECK(flist[1], 0.5f);
- CHECK(flist[2], 1.2f);
- CHECK(flist[3], 4.3f);
- CHECK(cstr_to_list_float(" \t -1.0,0.5,1.2,INF \t", ':', flist, NULL, 4), RES_BAD_ARG);
- CHECK(cstr_to_list_float(" \t -1.0,0.5,1.2,INF \t", ',', flist, NULL, 4), RES_OK);
- CHECK(flist[0], -1.0f);
- CHECK(flist[1], 0.5f);
- CHECK(flist[2], 1.2f);
- CHECK(flist[3], (float)INF);
+ CHK(cstr_to_list_float(NULL, ':', flist, NULL, 3) == RES_BAD_ARG);
+ CHK(cstr_to_list_float("a", ':', flist, NULL, 3) == RES_BAD_ARG);
+ CHK(cstr_to_list_float("1.e-3:2.0:"STR(PI), ':', flist, NULL, 3) == RES_OK);
+ CHK(flist[0] == 1.e-3f);
+ CHK(flist[1] == 2.0f);
+ CHK(flist[2] == (float)PI);
+ CHK(cstr_to_list_float("1.e-3:2.0:", ':', flist, &len, 3) == RES_OK);
+ CHK(len == 2);
+ CHK(flist[0] == 1.e-3f);
+ CHK(flist[1] == 2.0f);
+ CHK(cstr_to_list_float("-1.0:0.5:1.2:4.3", ':', flist, &len, 2) == RES_BAD_ARG);
+ CHK(cstr_to_list_float("-1.0:0.5:1.2:4.3a", ':', NULL, &len, 0) == RES_BAD_ARG);
+ CHK(cstr_to_list_float("-1.0:0.5:1.2:4.3", ':', NULL, &len, 0) == RES_OK);
+ CHK(len == 4);
+ CHK(cstr_to_list_float("-1.0:0.5:1.2:4.3", ':', flist, NULL, len) == RES_OK);
+ CHK(flist[0] == -1.0f);
+ CHK(flist[1] == 0.5f);
+ CHK(flist[2] == 1.2f);
+ CHK(flist[3] == 4.3f);
+ CHK(cstr_to_list_float(" \t -1.0,0.5,1.2,INF \t", ':', flist, NULL, 4) == RES_BAD_ARG);
+ CHK(cstr_to_list_float(" \t -1.0,0.5,1.2,INF \t", ',', flist, NULL, 4) == RES_OK);
+ CHK(flist[0] == -1.0f);
+ CHK(flist[1] == 0.5f);
+ CHK(flist[2] == 1.2f);
+ CHK(flist[3] == (float)INF);
}
static void
@@ -236,26 +236,26 @@ test_list_uint(void)
unsigned ulist[4];
size_t len;
- CHECK(cstr_to_list_uint(NULL, ':', ulist, NULL, 3), RES_BAD_ARG);
- CHECK(cstr_to_list_uint("a", ':', ulist, NULL, 3), RES_BAD_ARG);
- CHECK(cstr_to_list_uint("1:4:-1", ':', ulist, NULL, 3), RES_OK);
- CHECK(ulist[0], 1);
- CHECK(ulist[1], 4);
- CHECK(ulist[2], (unsigned)-1);
- CHECK(cstr_to_list_uint("1:2::", ':', ulist, &len, 3), RES_OK);
- CHECK(len, 2);
- CHECK(ulist[0], 1);
- CHECK(ulist[1], 2);
- CHECK(cstr_to_list_uint("1:5:2:4", ':', ulist, &len, 2), RES_BAD_ARG);
- CHECK(cstr_to_list_uint("1:5:2:4.2", ':', NULL, &len, 0), RES_BAD_ARG);
- CHECK(cstr_to_list_uint("1:5:2:4", ':', NULL, &len, 0), RES_OK);
- CHECK(len, 4);
- CHECK(cstr_to_list_uint("-1.5.2.3", ':', ulist, NULL, len), RES_BAD_ARG);
- CHECK(cstr_to_list_uint("-1.5.2.3", '.', ulist, NULL, len), RES_OK);
- CHECK(ulist[0], (unsigned)-1);
- CHECK(ulist[1], 5);
- CHECK(ulist[2], 2);
- CHECK(ulist[3], 3);
+ CHK(cstr_to_list_uint(NULL, ':', ulist, NULL, 3) == RES_BAD_ARG);
+ CHK(cstr_to_list_uint("a", ':', ulist, NULL, 3) == RES_BAD_ARG);
+ CHK(cstr_to_list_uint("1:4:-1", ':', ulist, NULL, 3) == RES_OK);
+ CHK(ulist[0] == 1);
+ CHK(ulist[1] == 4);
+ CHK(ulist[2] == (unsigned)-1);
+ CHK(cstr_to_list_uint("1:2::", ':', ulist, &len, 3) == RES_OK);
+ CHK(len == 2);
+ CHK(ulist[0] == 1);
+ CHK(ulist[1] == 2);
+ CHK(cstr_to_list_uint("1:5:2:4", ':', ulist, &len, 2) == RES_BAD_ARG);
+ CHK(cstr_to_list_uint("1:5:2:4.2", ':', NULL, &len, 0) == RES_BAD_ARG);
+ CHK(cstr_to_list_uint("1:5:2:4", ':', NULL, &len, 0) == RES_OK);
+ CHK(len == 4);
+ CHK(cstr_to_list_uint("-1.5.2.3", ':', ulist, NULL, len) == RES_BAD_ARG);
+ CHK(cstr_to_list_uint("-1.5.2.3", '.', ulist, NULL, len) == RES_OK);
+ CHK(ulist[0] == (unsigned)-1);
+ CHK(ulist[1] == 5);
+ CHK(ulist[2] == 2);
+ CHK(ulist[3] == 3);
}
int
diff --git a/src/test_dynamic_array.c b/src/test_dynamic_array.c
@@ -56,16 +56,16 @@ test_cstr(struct mem_allocator* allocator)
size_t i = 0;
darray_str_init(NULL, &darray);
- CHECK(darray_str_size_get(&darray), 0);
+ CHK(darray_str_size_get(&darray) == 0);
darray_str_clear(&darray);
- CHECK(darray_str_size_get(&darray), 0);
+ CHK(darray_str_size_get(&darray) == 0);
FOR_EACH(i, 0, 4) {
darray_str_push_back(&darray, strs + i);
}
- CHECK(darray_str_size_get(&darray), 4);
+ CHK(darray_str_size_get(&darray) == 4);
darray_str_clear(&darray);
- CHECK(darray_str_size_get(&darray), 0);
+ CHK(darray_str_size_get(&darray) == 0);
darray_str_release(&darray);
darray_str_init(allocator, &darray);
@@ -73,20 +73,20 @@ test_cstr(struct mem_allocator* allocator)
darray_str_push_back(&darray, strs + i);
}
FOR_EACH(i, 0, nstrs) {
- CHECK(strcmp(darray_str_cdata_get(&darray)[i], strs[i]), 0);
+ CHK(strcmp(darray_str_cdata_get(&darray)[i], strs[i]) == 0);
}
darray_str_purge(&darray);
- CHECK(darray_str_size_get(&darray), 0);
+ CHK(darray_str_size_get(&darray) == 0);
darray_str_release(&darray);
darray_str_init(allocator, &darray);
- CHECK(darray_str_size_get(&darray), 0);
+ CHK(darray_str_size_get(&darray) == 0);
darray_str_resize(&darray, 8);
- CHECK(darray_str_size_get(&darray), 8);
+ CHK(darray_str_size_get(&darray) == 8);
darray_str_resize(&darray, 0);
- CHECK(darray_str_size_get(&darray), 0);
+ CHK(darray_str_size_get(&darray) == 0);
darray_str_resize(&darray, 33);
- CHECK(darray_str_size_get(&darray), 33);
+ CHK(darray_str_size_get(&darray) == 33);
darray_str_release(&darray);
}
@@ -110,21 +110,21 @@ test_string
darray_string_init(allocator0, &darray);
darray_string_init(allocator1, &darray2);
- CHECK(darray_string_size_get(&darray), 0);
- CHECK(darray_string_size_get(&darray2), 0);
+ CHK(darray_string_size_get(&darray) == 0);
+ CHK(darray_string_size_get(&darray2) == 0);
darray_string_resize(&darray, nstrs);
FOR_EACH(i, 0, nstrs) {
str_set(darray_string_data_get(&darray) + i, strs[i]);
}
- CHECK(darray_string_size_get(&darray), nstrs);
+ CHK(darray_string_size_get(&darray) == nstrs);
FOR_EACH(i, 0, nstrs) {
const struct str* str = darray_string_cdata_get(&darray) + i;
- CHECK(strcmp(str_cget(str), strs[i]), 0);
+ CHK(strcmp(str_cget(str), strs[i]) == 0);
}
darray_string_copy(&darray, &darray2);
- CHECK(darray_string_size_get(&darray), 0);
+ CHK(darray_string_size_get(&darray) == 0);
FOR_EACH(i, 0, nstrs) {
struct str str;
str_init(allocator1, &str);
@@ -133,38 +133,38 @@ test_string
str_release(&str);
}
- CHECK(darray_string_size_get(&darray), nstrs);
+ CHK(darray_string_size_get(&darray) == nstrs);
FOR_EACH(i, 0, nstrs) {
const struct str* str = darray_string_cdata_get(&darray) + i;
- CHECK(strcmp(str_cget(str), strs[i]), 0);
+ CHK(strcmp(str_cget(str), strs[i]) == 0);
}
darray_string_copy(&darray2, &darray);
- CHECK(darray_string_size_get(&darray2), nstrs);
+ CHK(darray_string_size_get(&darray2) == nstrs);
FOR_EACH(i, 0, nstrs) {
const struct str* str = darray_string_cdata_get(&darray) + i;
const struct str* str2 = darray_string_cdata_get(&darray2) + i;
- CHECK(strcmp(str_cget(str), strs[i]), 0);
- CHECK(strcmp(str_cget(str2), strs[i]), 0);
+ CHK(strcmp(str_cget(str), strs[i]) == 0);
+ CHK(strcmp(str_cget(str2), strs[i]) == 0);
}
darray_string_clear(&darray2);
i = MEM_ALLOCATED_SIZE(allocator1);
darray_string_purge(&darray2);
- CHECK(MEM_ALLOCATED_SIZE(allocator1) < i, 1);
- CHECK(darray_string_size_get(&darray2), 0);
+ CHK(MEM_ALLOCATED_SIZE(allocator1) < i);
+ CHK(darray_string_size_get(&darray2) == 0);
darray_string_copy_and_clear(&darray2, &darray);
- CHECK(darray_string_size_get(&darray2), nstrs);
- CHECK(darray_string_size_get(&darray), 0);
+ CHK(darray_string_size_get(&darray2) == nstrs);
+ CHK(darray_string_size_get(&darray) == 0);
FOR_EACH(i, 0, nstrs) {
const struct str* str = darray_string_cdata_get(&darray2) + i;
- CHECK(strcmp(str_cget(str), strs[i]), 0);
+ CHK(strcmp(str_cget(str), strs[i]) == 0);
}
darray_string_copy_and_release(&darray, &darray2);
FOR_EACH(i, 0, nstrs) {
const struct str* str = darray_string_cdata_get(&darray) + i;
- CHECK(strcmp(str_cget(str), strs[i]), 0);
+ CHK(strcmp(str_cget(str), strs[i]) == 0);
}
darray_string_release(&darray);
@@ -185,7 +185,7 @@ test_swap_int
#define PUSH_BACK(V, E) { \
const int i__ = (E); \
- CHECK(darray_int_push_back(&(V), &i__), RES_OK); \
+ CHK(darray_int_push_back(&(V), &i__) == RES_OK); \
} (void)0
darray_int_init(allocator0, &a);
@@ -197,15 +197,15 @@ test_swap_int
PUSH_BACK(b,-1);
PUSH_BACK(b,-2);
- CHECK(darray_int_swap(&a, &b), RES_OK);
- CHECK(darray_int_size_get(&a), 2);
- CHECK(darray_int_size_get(&b), 3);
+ CHK(darray_int_swap(&a, &b) == RES_OK);
+ CHK(darray_int_size_get(&a) == 2);
+ CHK(darray_int_size_get(&b) == 3);
- CHECK(darray_int_cdata_get(&a)[0],-1);
- CHECK(darray_int_cdata_get(&a)[1],-2);
- CHECK(darray_int_cdata_get(&b)[0], 1);
- CHECK(darray_int_cdata_get(&b)[1], 2);
- CHECK(darray_int_cdata_get(&b)[2], 3);
+ CHK(darray_int_cdata_get(&a)[0] == -1);
+ CHK(darray_int_cdata_get(&a)[1] == -2);
+ CHK(darray_int_cdata_get(&b)[0] == 1);
+ CHK(darray_int_cdata_get(&b)[1] == 2);
+ CHK(darray_int_cdata_get(&b)[2] == 3);
darray_int_clear(&a);
darray_int_clear(&b);
@@ -213,23 +213,23 @@ test_swap_int
FOR_EACH(i, 0, 128) PUSH_BACK(a, i);
FOR_EACH(i, 0, 112) PUSH_BACK(b,-i);
- CHECK(darray_int_swap(&a, &b), RES_OK);
- CHECK(darray_int_size_get(&a), 112);
- CHECK(darray_int_size_get(&b), 128);
- FOR_EACH(i, 0, 112) CHECK(darray_int_cdata_get(&a)[i],-i);
- FOR_EACH(i, 0, 128) CHECK(darray_int_cdata_get(&b)[i], i);
+ CHK(darray_int_swap(&a, &b) == RES_OK);
+ CHK(darray_int_size_get(&a) == 112);
+ CHK(darray_int_size_get(&b) == 128);
+ FOR_EACH(i, 0, 112) CHK(darray_int_cdata_get(&a)[i] == -i);
+ FOR_EACH(i, 0, 128) CHK(darray_int_cdata_get(&b)[i] == i);
darray_int_release(&b);
darray_int_init(allocator1, &b);
PUSH_BACK(b, -1);
PUSH_BACK(b, -314);
- CHECK(darray_int_swap(&a, &b), RES_OK);
- CHECK(darray_int_size_get(&a), 2);
- CHECK(darray_int_size_get(&b), 112);
- FOR_EACH(i, 0, 112) CHECK(darray_int_cdata_get(&b)[i],-i);
- CHECK(darray_int_cdata_get(&a)[0],-1);
- CHECK(darray_int_cdata_get(&a)[1],-314);
+ CHK(darray_int_swap(&a, &b) == RES_OK);
+ CHK(darray_int_size_get(&a) == 2);
+ CHK(darray_int_size_get(&b) == 112);
+ FOR_EACH(i, 0, 112) CHK(darray_int_cdata_get(&b)[i] == -i);
+ CHK(darray_int_cdata_get(&a)[0] == -1);
+ CHK(darray_int_cdata_get(&a)[1] == -314);
darray_int_release(&a);
darray_int_release(&b);
@@ -250,30 +250,30 @@ test_swap_string
#define PUSH_BACK(V, CStr) { \
struct str str__; \
str_init(allocator1, &str__); \
- CHECK(str_set(&str__, CStr), RES_OK); \
- CHECK(darray_string_push_back(&(V), &str__), RES_OK); \
+ CHK(str_set(&str__, CStr) == RES_OK); \
+ CHK(darray_string_push_back(&(V), &str__) == RES_OK); \
str_release(&str__); \
} (void)0
darray_string_init(allocator0, &a);
darray_string_init(allocator1, &b);
- CHECK(nstrs >= 3, 1);
+ CHK(nstrs >= 3);
PUSH_BACK(a, strs[0]);
PUSH_BACK(a, strs[1]);
PUSH_BACK(a, strs[2]);
PUSH_BACK(b, strs[3]);
PUSH_BACK(b, strs[4]);
- CHECK(darray_string_swap(&a, &b), RES_OK);
- CHECK(darray_string_size_get(&a), 2);
- CHECK(darray_string_size_get(&b), 3);
+ CHK(darray_string_swap(&a, &b) == RES_OK);
+ CHK(darray_string_size_get(&a) == 2);
+ CHK(darray_string_size_get(&b) == 3);
- CHECK(strcmp(str_cget(darray_string_cdata_get(&a)+0), strs[3]), 0);
- CHECK(strcmp(str_cget(darray_string_cdata_get(&a)+1), strs[4]), 0);
- CHECK(strcmp(str_cget(darray_string_cdata_get(&b)+0), strs[0]), 0);
- CHECK(strcmp(str_cget(darray_string_cdata_get(&b)+1), strs[1]), 0);
- CHECK(strcmp(str_cget(darray_string_cdata_get(&b)+2), strs[2]), 0);
+ CHK(strcmp(str_cget(darray_string_cdata_get(&a)+0), strs[3]) == 0);
+ CHK(strcmp(str_cget(darray_string_cdata_get(&a)+1), strs[4]) == 0);
+ CHK(strcmp(str_cget(darray_string_cdata_get(&b)+0), strs[0]) == 0);
+ CHK(strcmp(str_cget(darray_string_cdata_get(&b)+1), strs[1]) == 0);
+ CHK(strcmp(str_cget(darray_string_cdata_get(&b)+2), strs[2]) == 0);
darray_string_clear(&a);
darray_string_clear(&b);
@@ -281,15 +281,15 @@ test_swap_string
FOR_EACH(i, 0, nstrs/2) PUSH_BACK(a, strs[i]);
FOR_EACH(i, nstrs/2, nstrs) PUSH_BACK(b, strs[i]);
- CHECK(darray_string_swap(&a, &b), RES_OK);
- CHECK(darray_string_size_get(&a), nstrs/2);
- CHECK(darray_string_size_get(&b), nstrs - nstrs/2);
+ CHK(darray_string_swap(&a, &b) == RES_OK);
+ CHK(darray_string_size_get(&a) == nstrs/2);
+ CHK(darray_string_size_get(&b) == nstrs - nstrs/2);
FOR_EACH(i, 0, nstrs/2) {
- CHECK(strcmp(str_cget(darray_string_cdata_get(&b)+i), strs[i]), 0);
+ CHK(strcmp(str_cget(darray_string_cdata_get(&b)+i), strs[i]) == 0);
}
FOR_EACH(i, 0, nstrs - nstrs/2) {
- CHECK(strcmp(str_cget(darray_string_cdata_get(&a)+i), strs[i+nstrs/2]), 0);
+ CHK(strcmp(str_cget(darray_string_cdata_get(&a)+i), strs[i+nstrs/2]) == 0);
}
darray_string_release(&b);
@@ -297,15 +297,15 @@ test_swap_string
PUSH_BACK(b, strs[0]);
PUSH_BACK(b, strs[1]);
- CHECK(darray_string_swap(&a, &b), RES_OK);
- CHECK(darray_string_size_get(&a), 2);
- CHECK(darray_string_size_get(&b), nstrs - nstrs/2);
+ CHK(darray_string_swap(&a, &b) == RES_OK);
+ CHK(darray_string_size_get(&a) == 2);
+ CHK(darray_string_size_get(&b) == nstrs - nstrs/2);
FOR_EACH(i, 0, nstrs - nstrs/2) {
- CHECK(strcmp(str_cget(darray_string_cdata_get(&b)+i), strs[i+nstrs/2]), 0);
+ CHK(strcmp(str_cget(darray_string_cdata_get(&b)+i), strs[i+nstrs/2]) == 0);
}
- CHECK(strcmp(str_cget(darray_string_cdata_get(&a)+0), strs[0]), 0);
- CHECK(strcmp(str_cget(darray_string_cdata_get(&a)+1), strs[1]), 0);
+ CHK(strcmp(str_cget(darray_string_cdata_get(&a)+0), strs[0]) == 0);
+ CHK(strcmp(str_cget(darray_string_cdata_get(&a)+1), strs[1]) == 0);
darray_string_release(&a);
darray_string_release(&b);
@@ -334,27 +334,27 @@ test_alignment(struct mem_allocator* allocator)
struct darray_byte64 bytes64;
struct darray_byte1K bytes1K;
- NCHECK(allocator, NULL);
+ CHK(allocator != NULL);
darray_byte_init(allocator, &bytes);
- CHECK(darray_byte_resize(&bytes, 2), RES_OK);
- CHECK(IS_ALIGNED(darray_byte_cdata_get(&bytes), ALIGNOF(char)), 1);
- CHECK(darray_byte_resize(&bytes, 314159), RES_OK);
- CHECK(IS_ALIGNED(darray_byte_cdata_get(&bytes), ALIGNOF(char)), 1);
+ CHK(darray_byte_resize(&bytes, 2) == RES_OK);
+ CHK(IS_ALIGNED(darray_byte_cdata_get(&bytes), ALIGNOF(char)) == 1);
+ CHK(darray_byte_resize(&bytes, 314159) == RES_OK);
+ CHK(IS_ALIGNED(darray_byte_cdata_get(&bytes), ALIGNOF(char)) == 1);
darray_byte_release(&bytes);
darray_byte64_init(allocator, &bytes64);
- CHECK(darray_byte64_resize(&bytes64, 2), RES_OK);
- CHECK(IS_ALIGNED(darray_byte64_cdata_get(&bytes64), 64), 1);
- CHECK(darray_byte64_resize(&bytes64, 314159), RES_OK);
- CHECK(IS_ALIGNED(darray_byte64_cdata_get(&bytes64), 64), 1);
+ CHK(darray_byte64_resize(&bytes64, 2) == RES_OK);
+ CHK(IS_ALIGNED(darray_byte64_cdata_get(&bytes64), 64) == 1);
+ CHK(darray_byte64_resize(&bytes64, 314159) == RES_OK);
+ CHK(IS_ALIGNED(darray_byte64_cdata_get(&bytes64), 64) == 1);
darray_byte64_release(&bytes64);
darray_byte1K_init(allocator, &bytes1K);
- CHECK(darray_byte1K_resize(&bytes1K, 2), RES_OK);
- CHECK(IS_ALIGNED(darray_byte1K_cdata_get(&bytes1K), 1024), 1);
- CHECK(darray_byte1K_resize(&bytes1K, 314159), RES_OK);
- CHECK(IS_ALIGNED(darray_byte1K_cdata_get(&bytes1K), 1024), 1);
+ CHK(darray_byte1K_resize(&bytes1K, 2) == RES_OK);
+ CHK(IS_ALIGNED(darray_byte1K_cdata_get(&bytes1K), 1024) == 1);
+ CHK(darray_byte1K_resize(&bytes1K, 314159) == RES_OK);
+ CHK(IS_ALIGNED(darray_byte1K_cdata_get(&bytes1K), 1024) == 1);
darray_byte1K_release(&bytes1K);
}
@@ -381,7 +381,7 @@ main(int argc, char** argv)
check_memory_allocator(&allocator_proxy);
mem_shutdown_proxy_allocator(&allocator_proxy);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_free_list.c b/src/test_free_list.c
@@ -41,46 +41,46 @@ main(int argc, char** argv)
}
flist_object_init(NULL, &list);
- CHECK(flist_object_is_empty(&list), 1);
- CHECK(flist_object_hold(&list, id[0]), 0);
- CHECK(flist_object_get(&list, id[0]), NULL);
+ CHK(flist_object_is_empty(&list));
+ CHK(flist_object_hold(&list, id[0]) == 0);
+ CHK(flist_object_get(&list, id[0]) == NULL);
id[0] = flist_object_add(&list);
- CHECK(id[0].index, 0);
- CHECK(flist_object_is_empty(&list), 0);
+ CHK(id[0].index == 0);
+ CHK(flist_object_is_empty(&list) == 0);
flist_object_clear(&list);
id[0] = flist_object_add(&list);
id[1] = flist_object_add(&list);
- CHECK(id[0].index, 0);
- CHECK(id[1].index, 1);
+ CHK(id[0].index == 0);
+ CHK(id[1].index == 1);
flist_object_del(&list, id[0]);
- CHECK(id[1].index, 1);
+ CHK(id[1].index == 1);
id[0] = flist_object_add(&list);
- CHECK(id[0].index, 0);
- CHECK(id[1].index, 1);
+ CHK(id[0].index == 0);
+ CHK(id[1].index == 1);
flist_object_del(&list, id[0]);
flist_object_del(&list, id[1]);
id[0] = flist_object_add(&list);
id[1] = flist_object_add(&list);
flist_object_clear(&list);
- CHECK(id[0].index != id[1].index, 1);
- CHECK(id[0].index <= 1, 1);
- CHECK(id[1].index <= 1, 1);
- CHECK(flist_object_is_empty(&list), 1);
+ CHK(id[0].index != id[1].index);
+ CHK(id[0].index <= 1);
+ CHK(id[1].index <= 1);
+ CHK(flist_object_is_empty(&list) == 1);
FOR_EACH(i, 0, NB_OBJ / 2) {
struct fid tmp_id;
id[i] = flist_object_add(&list);
- CHECK(flist_object_hold(&list, id[i]), 1);
+ CHK(flist_object_hold(&list, id[i]) == 1);
obj = flist_object_get(&list, id[i]);
tmp_id = object_id_get(obj);
- CHECK(id[i].index, (unsigned)i);
- CHECK(FID_EQ(tmp_id, id[i]), 1);
- NCHECK(obj, NULL);
+ CHK(id[i].index == (unsigned)i);
+ CHK(FID_EQ(tmp_id, id[i]) == 1);
+ CHK(obj != NULL);
obj->i = 0xDECAF000 + (unsigned)i;
}
- CHECK(flist_object_is_empty(&list), 0);
+ CHK(flist_object_is_empty(&list) == 0);
FOR_EACH(i, 0, NB_OBJ * 2 / 3) {
const float rand_f /* in [0, 1] */ = (float)rand() / (float)RAND_MAX;
@@ -91,20 +91,20 @@ main(int argc, char** argv)
FOR_EACH(i, NB_OBJ / 2, NB_OBJ) {
id[i] = flist_object_add(&list);
- CHECK(flist_object_hold(&list, id[i]), 1);
+ CHK(flist_object_hold(&list, id[i]) == 1);
obj = flist_object_get(&list, id[i]);
- NCHECK(obj, NULL);
+ CHK(obj != NULL);
obj->i = 0xDECAF000 + (unsigned)i;
}
FOR_EACH(i, 0, NB_OBJ) {
if(IS_FID_NULL(id[i])) {
- CHECK(flist_object_hold(&list, id[i]), 0);
- CHECK(flist_object_get(&list, id[i]), NULL);
+ CHK(flist_object_hold(&list, id[i]) == 0);
+ CHK(flist_object_get(&list, id[i]) == NULL);
} else {
- CHECK(flist_object_hold(&list, id[i]), 1);
+ CHK(flist_object_hold(&list, id[i]) == 1);
obj = flist_object_get(&list, id[i]);
- CHECK(obj->i, 0xDECAF000 + (unsigned)i);
+ CHK(obj->i == 0xDECAF000 + (unsigned)i);
}
}
@@ -120,11 +120,11 @@ main(int argc, char** argv)
nitems = 0;
memset(find, 0, NB_OBJ * sizeof(char));
FLIST_FOR_EACH(obj, &list) {
- CHECK(find[obj->i], 0);
+ CHK(find[obj->i] == 0);
find[obj->i] = 1;
++nitems;
}
- CHECK(nitems, NB_OBJ);
+ CHK(nitems == NB_OBJ);
FOR_EACH(i, 0, NB_OBJ / 2)
flist_object_del(&list, id[i*2]);
@@ -132,32 +132,32 @@ main(int argc, char** argv)
nitems = 0;
memset(find, 0, NB_OBJ * sizeof(char));
FLIST_FOR_EACH(obj, &list) {
- CHECK(find[obj->i], 0);
+ CHK(find[obj->i] == 0);
find[obj->i] = 1;
++nitems;
}
- CHECK(nitems, NB_OBJ/2);
+ CHK(nitems == NB_OBJ/2);
FOR_EACH(i, 0, NB_OBJ) {
if(i%2) {
- CHECK(flist_object_hold(&list, id[i]), 1);
- CHECK(find[i], 1);
+ CHK(flist_object_hold(&list, id[i]) == 1);
+ CHK(find[i] == 1);
} else {
- CHECK(flist_object_hold(&list, id[i]), 0);
- CHECK(find[i], 0);
- CHECK(IS_FID_NULL(object_id_get(list.items + id[i].index)), 1);
+ CHK(flist_object_hold(&list, id[i]) == 0);
+ CHK(find[i] == 0);
+ CHK(IS_FID_NULL(object_id_get(list.items + id[i].index)) == 1);
}
}
- CHECK(flist_object_is_empty(&list), 0);
+ CHK(flist_object_is_empty(&list) == 0);
flist_object_clear(&list);
- CHECK(flist_object_is_empty(&list), 1);
+ CHK(flist_object_is_empty(&list) == 1);
nitems = 0;
FLIST_FOR_EACH(obj, &list)
++nitems;
- CHECK(nitems, 0);
+ CHK(nitems == 0);
FOR_EACH(i, 0, NB_OBJ)
- CHECK(flist_object_hold(&list, id[i]), 0);
+ CHK(flist_object_hold(&list, id[i]) == 0);
FOR_EACH(i, 0, NB_OBJ/4) {
id[i] = flist_object_add(&list);
@@ -168,18 +168,18 @@ main(int argc, char** argv)
nitems = 0;
memset(find, 0, NB_OBJ * sizeof(char));
FLIST_FOR_EACH(obj, &list) {
- CHECK(obj->i % 2, 0);
+ CHK(obj->i % 2 == 0);
find[obj->i/2] = 1;
++nitems;
}
- CHECK(nitems, NB_OBJ / 4);
+ CHK(nitems == NB_OBJ / 4);
FOR_EACH(i, 0, NB_OBJ/4) {
- CHECK(find[i], 1);
- CHECK(flist_object_hold(&list, id[i]), 1);
- CHECK(flist_object_get(&list, id[i])->i, (unsigned)i * 2);
+ CHK(find[i] == 1);
+ CHK(flist_object_hold(&list, id[i]) == 1);
+ CHK(flist_object_get(&list, id[i])->i == (unsigned)i * 2);
}
flist_object_release(&list);
- CHECK(MEM_ALLOCATED_SIZE(&mem_default_allocator), 0);
+ CHK(MEM_ALLOCATED_SIZE(&mem_default_allocator) == 0);
return 0;
}
diff --git a/src/test_func_name.c b/src/test_func_name.c
@@ -16,19 +16,19 @@
#include "rsys.h"
#include <string.h>
-static void foo(void) { CHECK(strcmp(FUNC_NAME, "foo"), 0); }
-static void bar(void) { CHECK(strcmp(FUNC_NAME, "bar"), 0); }
+static void foo(void) { CHK(strcmp(FUNC_NAME, "foo") == 0); }
+static void bar(void) { CHK(strcmp(FUNC_NAME, "bar") == 0); }
static void foo_bar(int i)
{
(void)i;
- CHECK(strcmp(FUNC_NAME, "foo_bar"), 0);
+ CHK(strcmp(FUNC_NAME, "foo_bar") == 0);
}
int
main(int argc, char** argv)
{
(void)argc, (void)argv;
- CHECK(strcmp(FUNC_NAME, "main"), 0);
+ CHK(strcmp(FUNC_NAME, "main") == 0);
foo();
bar();
foo_bar(0);
diff --git a/src/test_hash_table.c b/src/test_hash_table.c
@@ -39,31 +39,31 @@ test_htbl_int_float(void)
mem_init_proxy_allocator(&allocator_proxy, &mem_default_allocator);
htable_int_float_init(&allocator_proxy, &htbl);
- CHECK(htable_int_float_reserve(&htbl, 30), RES_OK);
+ CHK(htable_int_float_reserve(&htbl, 30) == RES_OK);
FOR_EACH(i, 0, n) {
float f = (float)i;
- CHECK(htable_int_float_set(&htbl, &i, &f), RES_OK);
+ CHK(htable_int_float_set(&htbl, &i, &f) == RES_OK);
}
FOR_EACH(i, 0, n) {
float* p = htable_int_float_find(&htbl, &i);
- NCHECK(p, NULL);
- CHECK(*p, (float) i);
+ CHK(p != NULL);
+ CHK(*p == (float) i);
}
- CHECK(htable_int_float_size_get(&htbl), (size_t)n);
+ CHK(htable_int_float_size_get(&htbl) == (size_t)n);
FOR_EACH(i, 0, n / 2) {
- CHECK(htable_int_float_erase(&htbl, &i), 1);
+ CHK(htable_int_float_erase(&htbl, &i) == 1);
}
- CHECK(htable_int_float_size_get(&htbl), (size_t)(n/2));
+ CHK(htable_int_float_size_get(&htbl) == (size_t)(n/2));
FOR_EACH(i, 0, n/2) {
float* p = htable_int_float_find(&htbl, &i);
- CHECK(p, NULL);
+ CHK(p == NULL);
}
FOR_EACH(i, n/2, n) {
float* p = htable_int_float_find(&htbl, &i);
- NCHECK(p, NULL);
- CHECK(*p, (float) i);
+ CHK(p != NULL);
+ CHK(*p == (float) i);
}
htable_int_float_release(&htbl);
@@ -153,43 +153,43 @@ test_htbl_str_int(void)
str_init(&allocator_proxy, &tmp);
htable_str_int_init(&allocator_proxy, &htbl);
- CHECK(htable_str_int_is_empty(&htbl), 1);
+ CHK(htable_str_int_is_empty(&htbl) == 1);
str_set(&tmp, "empty");
- CHECK(htable_str_int_find(&htbl, &tmp), NULL);
- CHECK(htable_str_int_size_get(&htbl), 0);
+ CHK(htable_str_int_find(&htbl, &tmp) == NULL);
+ CHK(htable_str_int_size_get(&htbl) == 0);
i = 0;
str_set(&tmp, str[i]);
- CHECK(htable_str_int_set(&htbl, &tmp, &i), RES_OK);
- CHECK(htable_str_int_is_empty(&htbl), 0);
- CHECK(htable_str_int_size_get(&htbl), 1);
+ CHK(htable_str_int_set(&htbl, &tmp, &i) == RES_OK);
+ CHK(htable_str_int_is_empty(&htbl) == 0);
+ CHK(htable_str_int_size_get(&htbl) == 1);
FOR_EACH(i, 1, str_size) {
str_set(&tmp, str[i]);
- CHECK(htable_str_int_set(&htbl, &tmp, &i), RES_OK);
+ CHK(htable_str_int_set(&htbl, &tmp, &i) == RES_OK);
}
- CHECK(htable_str_int_size_get(&htbl), (size_t)str_size);
+ CHK(htable_str_int_size_get(&htbl) == (size_t)str_size);
str_set(&tmp, "Terra icognita");
- CHECK(htable_str_int_find(&htbl, &tmp), NULL);
+ CHK(htable_str_int_find(&htbl, &tmp) == NULL);
FOR_EACH(i, 0, 64) {
int j = rand() % str_size;
str_set(&tmp, str[j]);
data = htable_str_int_find(&htbl, &tmp);
- NCHECK(data, NULL);
- CHECK(*data, (int)j);
+ CHK(data != NULL);
+ CHK(*data == (int)j);
}
str_set(&tmp, "Terra icognita");
- CHECK(htable_str_int_erase(&htbl, &tmp), 0);
+ CHK(htable_str_int_erase(&htbl, &tmp) == 0);
FOR_EACH(i, 0, array_size) {
str_set(&tmp, str[array[i]]);
- CHECK(htable_str_int_erase(&htbl, &tmp), 1);
+ CHK(htable_str_int_erase(&htbl, &tmp) == 1);
}
FOR_EACH(i, 0, array_size) {
str_set(&tmp, str[array[i]]);
- CHECK(htable_str_int_find(&htbl, &tmp), 0);
+ CHK(htable_str_int_find(&htbl, &tmp) == 0);
}
- CHECK(htable_str_int_size_get(&htbl), (size_t)(str_size - array_size));
+ CHK(htable_str_int_size_get(&htbl) == (size_t)(str_size - array_size));
FOR_EACH(i, 0, str_size) {
int j = 0;
FOR_EACH(j, 0, array_size) {
@@ -199,72 +199,71 @@ test_htbl_str_int(void)
if(j >= array_size) {
str_set(&tmp, str[i]);
data = htable_str_int_find(&htbl, &tmp);
- NCHECK(data, NULL);
- CHECK(*data, (int)i);
+ CHK(data != NULL);
+ CHK(*data == (int)i);
}
}
FOR_EACH(i, 0, array_size) {
str_set(&tmp, str[array[i]]);
- CHECK(htable_str_int_set(&htbl, &tmp, array + i), RES_OK);
+ CHK(htable_str_int_set(&htbl, &tmp, array + i) == RES_OK);
}
- CHECK(htable_str_int_size_get(&htbl), (size_t)str_size);
- CHECK(htable_str_int_is_empty(&htbl), 0);
+ CHK(htable_str_int_size_get(&htbl) == (size_t)str_size);
+ CHK(htable_str_int_is_empty(&htbl) == 0);
htable_str_int_begin(&htbl, &it0);
htable_str_int_end(&htbl, &it1);
- CHECK(htable_str_int_iterator_eq(&it0, &it0), 1);
- CHECK(htable_str_int_iterator_eq(&it0, &it1), 0);
+ CHK(htable_str_int_iterator_eq(&it0, &it0) == 1);
+ CHK(htable_str_int_iterator_eq(&it0, &it1) == 0);
memset(str_found, 0, sizeof(str_found));
while(!htable_str_int_iterator_eq(&it0, &it1) ) {
data = htable_str_int_iterator_data_get(&it0);
- CHECK
- (*htable_str_int_find(&htbl, htable_str_int_iterator_key_get(&it0) ),
- *data);
- CHECK(str_found[*data], 0);
+ CHK(*htable_str_int_find(&htbl, htable_str_int_iterator_key_get(&it0))
+ == *data);
+ CHK(str_found[*data] == 0);
str_found[*data] = 1;
htable_str_int_iterator_next(&it0);
}
FOR_EACH(i, 0, str_size) {
- CHECK(str_found[i], 1);
+ CHK(str_found[i] == 1);
}
htable_str_int_purge(&htbl);
htable_str_int_begin(&htbl, &it0);
htable_str_int_end(&htbl, &it1);
- CHECK(htable_str_int_iterator_eq(&it0, &it1), 1);
+ CHK(htable_str_int_iterator_eq(&it0, &it1) == 1);
- CHECK(htable_str_int_is_empty(&htbl), 1);
- CHECK(htable_str_int_size_get(&htbl), 0);
+ CHK(htable_str_int_is_empty(&htbl) == 1);
+ CHK(htable_str_int_size_get(&htbl) == 0);
htable_str_int_release(&htbl);
htable_str_int_init(&allocator_proxy, &htbl);
htable_str_int_reserve(&htbl, 3);
str_set(&tmp, "Zero"), i = 0;
- CHECK(htable_str_int_set(&htbl, &tmp, &i), RES_OK);
+ CHK(htable_str_int_set(&htbl, &tmp, &i) == RES_OK);
str_set(&tmp, "One"), i = 1;
- CHECK(htable_str_int_set(&htbl, &tmp, &i), RES_OK);
+ CHK(htable_str_int_set(&htbl, &tmp, &i) == RES_OK);
str_set(&tmp, "Two"), i = 2;
- CHECK(htable_str_int_set(&htbl, &tmp, &i), RES_OK);
+ CHK(htable_str_int_set(&htbl, &tmp, &i) == RES_OK);
str_set(&tmp, "Three"), i = 3;
- CHECK(htable_str_int_set(&htbl, &tmp, &i), RES_OK);
+ CHK(htable_str_int_set(&htbl, &tmp, &i) == RES_OK);
str_set(&tmp, "Four"), i = 4;
- CHECK(htable_str_int_set(&htbl, &tmp, &i), RES_OK);
- CHECK(htable_str_int_size_get(&htbl), 5);
+ CHK(htable_str_int_set(&htbl, &tmp, &i) == RES_OK);
+ CHK(htable_str_int_size_get(&htbl) == 5);
str_set(&tmp, "Zero"), i = 'a';
- CHECK(htable_str_int_set(&htbl, &tmp, &i), RES_OK);
- CHECK(htable_str_int_size_get(&htbl), 5);
+ CHK(htable_str_int_set(&htbl, &tmp, &i) == RES_OK);
+ CHK(htable_str_int_size_get(&htbl) == 5);
data = htable_str_int_find(&htbl, &tmp);
- NCHECK(data, NULL);
- CHECK(*data, 'a');
+ CHK(data != NULL);
+ CHK(*data == 'a');
htable_str_int_clear(&htbl);
htable_str_int_begin(&htbl, &it0);
htable_str_int_end(&htbl, &it1);
- CHECK(htable_str_int_iterator_eq(&it0, &it1), 1);
- CHECK(htable_str_int_is_empty(&htbl), 1);
- CHECK(htable_str_int_size_get(&htbl), 0);
+ CHK(htable_str_int_iterator_eq(&it0, &it1) == 1);
+ CHK(htable_str_int_is_empty(&htbl) == 1);
+ CHK(htable_str_int_size_get(&htbl) == 0);
htable_str_int_release(&htbl);
@@ -371,55 +370,55 @@ ANGVBA BS QRZBAF EHA NZBX VA BHE PVGVRF.",
FOR_EACH(i, 0, nstrs) {
darray_char_clear(&darray);
FOR_EACH(j, 0, strlen(str[i]) + 1) {
- CHECK(darray_char_push_back(&darray, str[i] + j), RES_OK);
+ CHK(darray_char_push_back(&darray, str[i] + j) == RES_OK);
}
str_set(&tmp, str[i]);
- CHECK(htable_str_darray_set(&htbl, &tmp, &darray), RES_OK);
+ CHK(htable_str_darray_set(&htbl, &tmp, &darray) == RES_OK);
}
- CHECK(htable_str_darray_size_get(&htbl), nstrs);
- CHECK(htable_str_darray_size_get(&htbl2), 0);
- CHECK(htable_str_darray_size_get(&htbl3), 0);
+ CHK(htable_str_darray_size_get(&htbl) == nstrs);
+ CHK(htable_str_darray_size_get(&htbl2) == 0);
+ CHK(htable_str_darray_size_get(&htbl3) == 0);
- CHECK(htable_str_darray_copy(&htbl3, &htbl), RES_OK);
- CHECK(htable_str_darray_copy(&htbl, &htbl2), RES_OK);
+ CHK(htable_str_darray_copy(&htbl3, &htbl) == RES_OK);
+ CHK(htable_str_darray_copy(&htbl, &htbl2) == RES_OK);
- CHECK(htable_str_darray_size_get(&htbl), 0);
- CHECK(htable_str_darray_size_get(&htbl2), 0);
- CHECK(htable_str_darray_size_get(&htbl3), nstrs);
+ CHK(htable_str_darray_size_get(&htbl) == 0);
+ CHK(htable_str_darray_size_get(&htbl2) == 0);
+ CHK(htable_str_darray_size_get(&htbl3) == nstrs);
- CHECK(htable_str_darray_copy(&htbl, &htbl3), RES_OK);
- CHECK(htable_str_darray_copy_and_clear(&htbl2, &htbl3), RES_OK);
+ CHK(htable_str_darray_copy(&htbl, &htbl3) == RES_OK);
+ CHK(htable_str_darray_copy_and_clear(&htbl2, &htbl3) == RES_OK);
- CHECK(htable_str_darray_size_get(&htbl), nstrs);
- CHECK(htable_str_darray_size_get(&htbl2), nstrs);
- CHECK(htable_str_darray_size_get(&htbl3), 0);
+ CHK(htable_str_darray_size_get(&htbl) == nstrs);
+ CHK(htable_str_darray_size_get(&htbl2) == nstrs);
+ CHK(htable_str_darray_size_get(&htbl3) == 0);
FOR_EACH(i, 0, nstrs) {
darray_char_clear(&darray);
FOR_EACH(j, 0, strlen(str[i]) + 1) {
- CHECK(darray_char_push_back(&darray, str[i] + j), RES_OK);
+ CHK(darray_char_push_back(&darray, str[i] + j) == RES_OK);
}
str_set(&tmp, str[i]);
- CHECK(htable_str_darray_set(&htbl3, &tmp, &darray), RES_OK);
+ CHK(htable_str_darray_set(&htbl3, &tmp, &darray) == RES_OK);
}
- CHECK(htable_str_darray_size_get(&htbl3), nstrs);
+ CHK(htable_str_darray_size_get(&htbl3) == nstrs);
FOR_EACH(i, 0, nstrs) {
str_set(&tmp, str[i]);
data = htable_str_darray_find(&htbl, &tmp);
- NCHECK(data, NULL);
- CHECK(strcmp(darray_char_cdata_get(data), str[i]), 0);
+ CHK(data != NULL);
+ CHK(strcmp(darray_char_cdata_get(data), str[i]) == 0);
data = htable_str_darray_find(&htbl2, &tmp);
- NCHECK(data, NULL);
- CHECK(strcmp(darray_char_cdata_get(data), str[i]), 0);
+ CHK(data != NULL);
+ CHK(strcmp(darray_char_cdata_get(data), str[i]) == 0);
data = htable_str_darray_find(&htbl3, &tmp);
- NCHECK(data, NULL);
- CHECK(strcmp(darray_char_cdata_get(data), str[i]), 0);
+ CHK(data != NULL);
+ CHK(strcmp(darray_char_cdata_get(data), str[i]) == 0);
}
FOR_EACH(j, 0, nerase) {
@@ -434,26 +433,26 @@ ANGVBA BS QRZBAF EHA NZBX VA BHE PVGVRF.",
str_set(&tmp, str[i]);
data = htable_str_darray_find(&htbl, &tmp);
- NCHECK(data, NULL);
- CHECK(strcmp(darray_char_cdata_get(data), str_cget(&tmp)), 0);
- CHECK(htable_str_darray_erase(&htbl, &tmp), 1);
- CHECK(htable_str_darray_erase(&htbl, &tmp), 0);
+ CHK(data != NULL);
+ CHK(strcmp(darray_char_cdata_get(data), str_cget(&tmp)) == 0);
+ CHK(htable_str_darray_erase(&htbl, &tmp) == 1);
+ CHK(htable_str_darray_erase(&htbl, &tmp) == 0);
}
- CHECK(htable_str_darray_size_get(&htbl), nstrs - nerase);
+ CHK(htable_str_darray_size_get(&htbl) == nstrs - nerase);
FOR_EACH(j, 0, nerase) {
str_set(&tmp, str[buf[j]]);
data = htable_str_darray_find(&htbl, &tmp);
- CHECK(data, NULL);
+ CHK(data == NULL);
data = htable_str_darray_find(&htbl2, &tmp);
- NCHECK(data, NULL);
- CHECK(strcmp(darray_char_cdata_get(data), str[buf[j]]), 0);
+ CHK(data != NULL);
+ CHK(strcmp(darray_char_cdata_get(data), str[buf[j]]) == 0);
data = htable_str_darray_find(&htbl3, &tmp);
- NCHECK(data, NULL);
- CHECK(strcmp(darray_char_cdata_get(data), str[buf[j]]), 0);
+ CHK(data != NULL);
+ CHK(strcmp(darray_char_cdata_get(data), str[buf[j]]) == 0);
}
@@ -462,11 +461,11 @@ ANGVBA BS QRZBAF EHA NZBX VA BHE PVGVRF.",
while(!htable_str_darray_iterator_eq(&it0, &it1)) {
key = htable_str_darray_iterator_key_get(&it0);
data = htable_str_darray_iterator_data_get(&it0);
- CHECK(strcmp(str_cget(key), darray_char_cdata_get(data)), 0);
+ CHK(strcmp(str_cget(key), darray_char_cdata_get(data)) == 0);
htable_str_darray_iterator_next(&it0);
}
- CHECK(htable_str_darray_reserve(&htbl, 2891), RES_OK);
+ CHK(htable_str_darray_reserve(&htbl, 2891) == RES_OK);
FOR_EACH(j, 0, 5) {
for(;;) {
@@ -477,8 +476,8 @@ ANGVBA BS QRZBAF EHA NZBX VA BHE PVGVRF.",
}
str_set(&tmp, str[i]);
data = htable_str_darray_find(&htbl, &tmp);
- NCHECK(data, NULL);
- CHECK(strcmp(darray_char_cdata_get(data), str_cget(&tmp)), 0);
+ CHK(data != NULL);
+ CHK(strcmp(darray_char_cdata_get(data), str_cget(&tmp)) == 0);
}
htable_str_darray_copy_and_release(&htbl, &htbl3);
@@ -486,12 +485,12 @@ ANGVBA BS QRZBAF EHA NZBX VA BHE PVGVRF.",
str_set(&tmp, str[i]);
data = htable_str_darray_find(&htbl, &tmp);
- NCHECK(data, NULL);
- CHECK(strcmp(darray_char_cdata_get(data), str[i]), 0);
+ CHK(data != NULL);
+ CHK(strcmp(darray_char_cdata_get(data), str[i]) == 0);
data = htable_str_darray_find(&htbl2, &tmp);
- NCHECK(data, NULL);
- CHECK(strcmp(darray_char_cdata_get(data), str[i]), 0);
+ CHK(data != NULL);
+ CHK(strcmp(darray_char_cdata_get(data), str[i]) == 0);
}
str_release(&tmp);
diff --git a/src/test_image.c b/src/test_image.c
@@ -31,10 +31,10 @@ check_image_eq
size_t x, y;
size_t i;
- CHECK(img->format, ref_fmt);
- CHECK(img->height, ref_height);
- CHECK(img->width, ref_width);
- CHECK(img->pitch >= img->width, 1);
+ CHK(img->format == ref_fmt);
+ CHK(img->height == ref_height);
+ CHK(img->width == ref_width);
+ CHK(img->pitch >= img->width);
i = 0;
FOR_EACH(y, 0, img->height) {
@@ -43,14 +43,14 @@ check_image_eq
const char* pixel = row + (size_t)x*sizeof_image_format(img->format);
switch(img->format) {
case IMAGE_RGB8:
- CHECK(((uint8_t*)pixel)[0], ((uint8_t*)ref_pixels)[i]), ++i;
- CHECK(((uint8_t*)pixel)[1], ((uint8_t*)ref_pixels)[i]), ++i;
- CHECK(((uint8_t*)pixel)[2], ((uint8_t*)ref_pixels)[i]), ++i;
+ CHK(((uint8_t*)pixel)[0] == ((uint8_t*)ref_pixels)[i]), ++i;
+ CHK(((uint8_t*)pixel)[1] == ((uint8_t*)ref_pixels)[i]), ++i;
+ CHK(((uint8_t*)pixel)[2] == ((uint8_t*)ref_pixels)[i]), ++i;
break;
case IMAGE_RGB16:
- CHECK(((uint16_t*)pixel)[0], ((uint16_t*)ref_pixels)[i]), ++i;
- CHECK(((uint16_t*)pixel)[1], ((uint16_t*)ref_pixels)[i]), ++i;
- CHECK(((uint16_t*)pixel)[2], ((uint16_t*)ref_pixels)[i]), ++i;
+ CHK(((uint16_t*)pixel)[0] == ((uint16_t*)ref_pixels)[i]), ++i;
+ CHK(((uint16_t*)pixel)[1] == ((uint16_t*)ref_pixels)[i]), ++i;
+ CHK(((uint16_t*)pixel)[2] == ((uint16_t*)ref_pixels)[i]), ++i;
break;
default: FATAL("Unreachable code.\n"); break;
}
@@ -71,15 +71,15 @@ check_image_read
int is_bin;
char id[2];
- CHECK(image_init(allocator, &img), RES_OK);
+ CHK(image_init(allocator, &img) == RES_OK);
- CHECK(fseek(fp, 0, SEEK_SET), 0);
- CHECK(image_read_ppm_stream(&img, fp), RES_OK);
+ CHK(fseek(fp, 0, SEEK_SET) == 0);
+ CHK(image_read_ppm_stream(&img, fp) == RES_OK);
- CHECK(fseek(fp, 0, SEEK_SET), 0);
- CHECK(fread(id, 1, 2, fp), 2);
- CHECK(id[0], 'P');
- CHECK(id[1] == '3' || id[1] == '6', 1);
+ CHK(fseek(fp, 0, SEEK_SET) == 0);
+ CHK(fread(id, 1, 2, fp) == 2);
+ CHK(id[0] == 'P');
+ CHK(id[1] == '3' || id[1] == '6');
is_bin = id[1] == '6';
switch(fmt) {
@@ -88,40 +88,40 @@ check_image_read
default: FATAL("Unreachable code.\n"); break;
}
- CHECK(fseek(fp, 3, SEEK_SET), 0);
+ CHK(fseek(fp, 3, SEEK_SET) == 0);
fprintf(fp, "%lu %lu\n", (unsigned long)width+1, (unsigned long)height);
- CHECK(fseek(fp, 0, SEEK_SET), 0);
- CHECK(image_read_ppm_stream(&img, fp), RES_BAD_ARG);
- CHECK(fseek(fp, 3, SEEK_SET), 0);
+ CHK(fseek(fp, 0, SEEK_SET) == 0);
+ CHK(image_read_ppm_stream(&img, fp) == RES_BAD_ARG);
+ CHK(fseek(fp, 3, SEEK_SET) == 0);
fprintf(fp, "%lu %lu\n", (unsigned long)width, (unsigned long)height+1);
- CHECK(fseek(fp, 0, SEEK_SET), 0);
- CHECK(image_read_ppm_stream(&img, fp), RES_BAD_ARG);
- CHECK(fseek(fp, 3, SEEK_SET), 0);
+ CHK(fseek(fp, 0, SEEK_SET) == 0);
+ CHK(image_read_ppm_stream(&img, fp) == RES_BAD_ARG);
+ CHK(fseek(fp, 3, SEEK_SET) == 0);
fprintf(fp, "%lu %lu\n", (unsigned long)width, (unsigned long)height);
fprintf(fp, "%lu\n", (unsigned long)max_val+1);
- CHECK(fseek(fp, 0, SEEK_SET), 0);
+ CHK(fseek(fp, 0, SEEK_SET) == 0);
if(is_bin) {
- CHECK(image_read_ppm_stream(&img, fp), RES_BAD_ARG);
+ CHK(image_read_ppm_stream(&img, fp) == RES_BAD_ARG);
} else {
switch(fmt) {
case IMAGE_RGB8:
- CHECK(image_read_ppm_stream(&img, fp), RES_OK);
+ CHK(image_read_ppm_stream(&img, fp) == RES_OK);
break;
case IMAGE_RGB16:
- CHECK(image_read_ppm_stream(&img, fp), RES_BAD_ARG);
+ CHK(image_read_ppm_stream(&img, fp) == RES_BAD_ARG);
break;
default: FATAL("Unreachable code.\n"); break;
}
}
- CHECK(fseek(fp, 3, SEEK_SET), 0);
+ CHK(fseek(fp, 3, SEEK_SET) == 0);
fprintf(fp, "%lu %lu\n", (unsigned long)width, (unsigned long)height);
fprintf(fp, "%lu\n", (unsigned long)max_val);
- CHECK(fseek(fp, 0, SEEK_SET), 0);
- CHECK(image_read_ppm_stream(&img, fp), RES_OK);
+ CHK(fseek(fp, 0, SEEK_SET) == 0);
+ CHK(image_read_ppm_stream(&img, fp) == RES_OK);
- CHECK(image_release(&img), RES_OK);
+ CHK(image_release(&img) == RES_OK);
}
static void
@@ -136,104 +136,104 @@ check_image
size_t pitch;
FILE* fp;
- CHECK(image_init(NULL, NULL), RES_BAD_ARG);
- CHECK(image_init(allocator, NULL), RES_BAD_ARG);
- CHECK(image_init(NULL, &img), RES_OK);
- CHECK(image_release(NULL), RES_BAD_ARG);
- CHECK(image_release(&img), RES_OK);
- CHECK(image_init(allocator, &img), RES_OK);
+ CHK(image_init(NULL, NULL) == RES_BAD_ARG);
+ CHK(image_init(allocator, NULL) == RES_BAD_ARG);
+ CHK(image_init(NULL, &img) == RES_OK);
+ CHK(image_release(NULL) == RES_BAD_ARG);
+ CHK(image_release(&img) == RES_OK);
+ CHK(image_init(allocator, &img) == RES_OK);
pitch = width * sizeof_image_format(fmt);
- CHECK(image_setup(NULL, 0, 0, 0, fmt, NULL), RES_BAD_ARG);
- CHECK(image_setup(&img, 0, 0, 0, fmt, NULL), RES_BAD_ARG);
- CHECK(image_setup(NULL, width, 0, 0, fmt, NULL), RES_BAD_ARG);
- CHECK(image_setup(&img, width, 0, 0, fmt, NULL), RES_BAD_ARG);
- CHECK(image_setup(NULL, 0, height, 0, fmt, NULL), RES_BAD_ARG);
- CHECK(image_setup(&img, 0, height, 0, fmt, NULL), RES_BAD_ARG);
- CHECK(image_setup(NULL, width, height, 0, fmt, NULL), RES_BAD_ARG);
- CHECK(image_setup(&img, width, height, 0, fmt, NULL), RES_BAD_ARG);
- CHECK(image_setup(NULL, 0, 0, pitch, fmt, NULL), RES_BAD_ARG);
- CHECK(image_setup(&img, 0, 0, pitch, fmt, NULL), RES_BAD_ARG);
- CHECK(image_setup(NULL, width, 0, pitch, fmt, NULL), RES_BAD_ARG);
- CHECK(image_setup(&img, width, 0, pitch, fmt, NULL), RES_BAD_ARG);
- CHECK(image_setup(NULL, 0, height, pitch, fmt, NULL), RES_BAD_ARG);
- CHECK(image_setup(&img, 0, height, pitch, fmt, NULL), RES_BAD_ARG);
- CHECK(image_setup(NULL, width, height, pitch, fmt, NULL), RES_BAD_ARG);
- CHECK(image_setup(&img, width, height, pitch, fmt, NULL), RES_OK);
- CHECK(image_setup(NULL, 0, 0, 0, fmt, pixels), RES_BAD_ARG);
- CHECK(image_setup(&img, 0, 0, 0, fmt, pixels), RES_BAD_ARG);
- CHECK(image_setup(NULL, width, 0, 0, fmt, pixels), RES_BAD_ARG);
- CHECK(image_setup(&img, width, 0, 0, fmt, pixels), RES_BAD_ARG);
- CHECK(image_setup(NULL, 0, height, 0, fmt, pixels), RES_BAD_ARG);
- CHECK(image_setup(&img, 0, height, 0, fmt, pixels), RES_BAD_ARG);
- CHECK(image_setup(NULL, width, height, 0, fmt, pixels), RES_BAD_ARG);
- CHECK(image_setup(&img, width, height, 0, fmt, pixels), RES_BAD_ARG);
- CHECK(image_setup(NULL, 0, 0, pitch, fmt, pixels), RES_BAD_ARG);
- CHECK(image_setup(&img, 0, 0, pitch, fmt, pixels), RES_BAD_ARG);
- CHECK(image_setup(NULL, width, 0, pitch, fmt, pixels), RES_BAD_ARG);
- CHECK(image_setup(&img, width, 0, pitch, fmt, pixels), RES_BAD_ARG);
- CHECK(image_setup(NULL, 0, height, pitch, fmt, pixels), RES_BAD_ARG);
- CHECK(image_setup(&img, 0, height, pitch, fmt, pixels), RES_BAD_ARG);
- CHECK(image_setup(NULL, width, height, pitch, fmt, pixels), RES_BAD_ARG);
- CHECK(image_setup(&img, width, height, pitch, fmt, pixels), RES_OK);
+ CHK(image_setup(NULL, 0, 0, 0, fmt, NULL) == RES_BAD_ARG);
+ CHK(image_setup(&img, 0, 0, 0, fmt, NULL) == RES_BAD_ARG);
+ CHK(image_setup(NULL, width, 0, 0, fmt, NULL) == RES_BAD_ARG);
+ CHK(image_setup(&img, width, 0, 0, fmt, NULL) == RES_BAD_ARG);
+ CHK(image_setup(NULL, 0, height, 0, fmt, NULL) == RES_BAD_ARG);
+ CHK(image_setup(&img, 0, height, 0, fmt, NULL) == RES_BAD_ARG);
+ CHK(image_setup(NULL, width, height, 0, fmt, NULL) == RES_BAD_ARG);
+ CHK(image_setup(&img, width, height, 0, fmt, NULL) == RES_BAD_ARG);
+ CHK(image_setup(NULL, 0, 0, pitch, fmt, NULL) == RES_BAD_ARG);
+ CHK(image_setup(&img, 0, 0, pitch, fmt, NULL) == RES_BAD_ARG);
+ CHK(image_setup(NULL, width, 0, pitch, fmt, NULL) == RES_BAD_ARG);
+ CHK(image_setup(&img, width, 0, pitch, fmt, NULL) == RES_BAD_ARG);
+ CHK(image_setup(NULL, 0, height, pitch, fmt, NULL) == RES_BAD_ARG);
+ CHK(image_setup(&img, 0, height, pitch, fmt, NULL) == RES_BAD_ARG);
+ CHK(image_setup(NULL, width, height, pitch, fmt, NULL) == RES_BAD_ARG);
+ CHK(image_setup(&img, width, height, pitch, fmt, NULL) == RES_OK);
+ CHK(image_setup(NULL, 0, 0, 0, fmt, pixels) == RES_BAD_ARG);
+ CHK(image_setup(&img, 0, 0, 0, fmt, pixels) == RES_BAD_ARG);
+ CHK(image_setup(NULL, width, 0, 0, fmt, pixels) == RES_BAD_ARG);
+ CHK(image_setup(&img, width, 0, 0, fmt, pixels) == RES_BAD_ARG);
+ CHK(image_setup(NULL, 0, height, 0, fmt, pixels) == RES_BAD_ARG);
+ CHK(image_setup(&img, 0, height, 0, fmt, pixels) == RES_BAD_ARG);
+ CHK(image_setup(NULL, width, height, 0, fmt, pixels) == RES_BAD_ARG);
+ CHK(image_setup(&img, width, height, 0, fmt, pixels) == RES_BAD_ARG);
+ CHK(image_setup(NULL, 0, 0, pitch, fmt, pixels) == RES_BAD_ARG);
+ CHK(image_setup(&img, 0, 0, pitch, fmt, pixels) == RES_BAD_ARG);
+ CHK(image_setup(NULL, width, 0, pitch, fmt, pixels) == RES_BAD_ARG);
+ CHK(image_setup(&img, width, 0, pitch, fmt, pixels) == RES_BAD_ARG);
+ CHK(image_setup(NULL, 0, height, pitch, fmt, pixels) == RES_BAD_ARG);
+ CHK(image_setup(&img, 0, height, pitch, fmt, pixels) == RES_BAD_ARG);
+ CHK(image_setup(NULL, width, height, pitch, fmt, pixels) == RES_BAD_ARG);
+ CHK(image_setup(&img, width, height, pitch, fmt, pixels) == RES_OK);
fp = tmpfile();
- NCHECK(fp, NULL);
+ CHK(fp != NULL);
- CHECK(image_write_ppm_stream(NULL, 0, NULL), RES_BAD_ARG);
- CHECK(image_write_ppm_stream(&img, 0, NULL), RES_BAD_ARG);
- CHECK(image_write_ppm_stream(NULL, 0, fp), RES_BAD_ARG);
- CHECK(image_write_ppm_stream(&img, 0, fp), RES_OK);
+ CHK(image_write_ppm_stream(NULL, 0, NULL) == RES_BAD_ARG);
+ CHK(image_write_ppm_stream(&img, 0, NULL) == RES_BAD_ARG);
+ CHK(image_write_ppm_stream(NULL, 0, fp) == RES_BAD_ARG);
+ CHK(image_write_ppm_stream(&img, 0, fp) == RES_OK);
- CHECK(image_read_ppm_stream(NULL, NULL), RES_BAD_ARG);
- CHECK(image_read_ppm_stream(&img, NULL), RES_BAD_ARG);
- CHECK(image_read_ppm_stream(NULL, fp), RES_BAD_ARG);
- CHECK(image_read_ppm_stream(&img, fp), RES_BAD_ARG);
+ CHK(image_read_ppm_stream(NULL, NULL) == RES_BAD_ARG);
+ CHK(image_read_ppm_stream(&img, NULL) == RES_BAD_ARG);
+ CHK(image_read_ppm_stream(NULL, fp) == RES_BAD_ARG);
+ CHK(image_read_ppm_stream(&img, fp) == RES_BAD_ARG);
rewind(fp);
- CHECK(image_read_ppm_stream(&img, fp), RES_OK);
+ CHK(image_read_ppm_stream(&img, fp) == RES_OK);
check_image_eq(&img, pixels, width, height, fmt);
rewind(fp);
- CHECK(image_write_ppm_stream(&img, 1, fp), RES_OK);
+ CHK(image_write_ppm_stream(&img, 1, fp) == RES_OK);
rewind(fp);
- CHECK(image_read_ppm_stream(&img, fp), RES_OK);
+ CHK(image_read_ppm_stream(&img, fp) == RES_OK);
check_image_eq(&img, pixels, width, height, fmt);
- CHECK(image_write_ppm(NULL, 0, NULL), RES_BAD_ARG);
- CHECK(image_write_ppm(&img, 0, NULL), RES_BAD_ARG);
- CHECK(image_write_ppm(NULL, 0, "test.ppm"), RES_BAD_ARG);
- CHECK(image_write_ppm(&img, 0, "test.ppm"), RES_OK);
+ CHK(image_write_ppm(NULL, 0, NULL) == RES_BAD_ARG);
+ CHK(image_write_ppm(&img, 0, NULL) == RES_BAD_ARG);
+ CHK(image_write_ppm(NULL, 0, "test.ppm") == RES_BAD_ARG);
+ CHK(image_write_ppm(&img, 0, "test.ppm") == RES_OK);
- CHECK(image_read_ppm(NULL, NULL), RES_BAD_ARG);
- CHECK(image_read_ppm(&img, NULL), RES_BAD_ARG);
- CHECK(image_read_ppm(NULL, "test_bad.ppm"), RES_BAD_ARG);
- CHECK(image_read_ppm(&img, "test_bad.ppm"), RES_IO_ERR);
- CHECK(image_read_ppm(&img, "test.ppm"), RES_OK);
+ CHK(image_read_ppm(NULL, NULL) == RES_BAD_ARG);
+ CHK(image_read_ppm(&img, NULL) == RES_BAD_ARG);
+ CHK(image_read_ppm(NULL, "test_bad.ppm") == RES_BAD_ARG);
+ CHK(image_read_ppm(&img, "test_bad.ppm") == RES_IO_ERR);
+ CHK(image_read_ppm(&img, "test.ppm") == RES_OK);
check_image_eq(&img, pixels, width, height, fmt);
- CHECK(image_write_ppm(&img, 1, "test.ppm"), RES_OK);
- CHECK(image_read_ppm(&img, "test.ppm"), RES_OK);
+ CHK(image_write_ppm(&img, 1, "test.ppm") == RES_OK);
+ CHK(image_read_ppm(&img, "test.ppm") == RES_OK);
check_image_eq(&img, pixels, width, height, fmt);
- CHECK(image_write_ppm_stream(&img, 1, stdout), RES_OK);
+ CHK(image_write_ppm_stream(&img, 1, stdout) == RES_OK);
fclose(fp);
fp = tmpfile();
- NCHECK(fp, NULL);
- CHECK(image_write_ppm_stream(&img, 0, fp), RES_OK);
+ CHK(fp != NULL);
+ CHK(image_write_ppm_stream(&img, 0, fp) == RES_OK);
check_image_read(fp, width, height, fmt, allocator);
fclose(fp);
fp = tmpfile();
- NCHECK(fp, NULL);
- CHECK(image_write_ppm_stream(&img, 1, fp), RES_OK);
+ CHK(fp != NULL);
+ CHK(image_write_ppm_stream(&img, 1, fp) == RES_OK);
check_image_read(fp, width, height, fmt, allocator);
fclose(fp);
- CHECK(image_release(&img), RES_OK);
+ CHK(image_release(&img) == RES_OK);
}
int
@@ -260,10 +260,10 @@ main(int argc, char** argv)
int x, y, i = 0;
(void)argc, (void)argv;
- CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
+ CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
pixels = MEM_ALLOC(&allocator, WIDTH*sizeof_image_format(IMAGE_RGB8)*HEIGHT);
- NCHECK(pixels, NULL);
+ CHK(pixels != NULL);
i = 0;
FOR_EACH(y, 0, HEIGHT) {
@@ -279,7 +279,7 @@ main(int argc, char** argv)
MEM_RM(&allocator, pixels);
pixels = MEM_ALLOC(&allocator, WIDTH*sizeof_image_format(IMAGE_RGB16)*HEIGHT);
- NCHECK(pixels, NULL);
+ CHK(pixels != NULL);
i = 0;
FOR_EACH(y, 0, HEIGHT) {
@@ -295,6 +295,6 @@ main(int argc, char** argv)
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_library.c b/src/test_library.c
@@ -36,18 +36,18 @@ main(int argc, char** argv)
void* lib = NULL;
(void)argc, (void)argv;
- CHECK(library_open(NULL), NULL);
- CHECK(library_open("none"), NULL);
+ CHK(library_open(NULL) == NULL);
+ CHK(library_open("none") == NULL);
lib = library_open("./" SHARED_LIBRARY_NAME("test_lib"));
- NCHECK(lib, NULL);
+ CHK(lib != NULL);
- CHECK(library_get_symbol(lib, "exported_func_BAD"), NULL);
- NCHECK(library_get_symbol(lib, "exported_func"), NULL);
+ CHK(library_get_symbol(lib, "exported_func_BAD") == NULL);
+ CHK(library_get_symbol(lib, "exported_func") != NULL);
- CHECK(library_close(NULL), RES_BAD_ARG);
- CHECK(library_close(lib), RES_OK);
+ CHK(library_close(NULL) == RES_BAD_ARG);
+ CHK(library_close(lib) == RES_OK);
- CHECK(MEM_ALLOCATED_SIZE(&mem_default_allocator), 0);
+ CHK(MEM_ALLOCATED_SIZE(&mem_default_allocator) == 0);
return 0;
}
diff --git a/src/test_list.c b/src/test_list.c
@@ -38,132 +38,132 @@ main(int argc, char** argv)
list_init(&elmt1.node);
list_init(&elmt2.node);
- CHECK(is_list_empty(&list), 1);
+ CHK(is_list_empty(&list) == 1);
elmt0.c = 'a';
list_add(&list, &elmt0.node);
- CHECK(is_list_empty(&list), 0);
- CHECK(list_head(&list), &elmt0.node);
+ CHK(is_list_empty(&list) == 0);
+ CHK(list_head(&list) == &elmt0.node);
elmt1.c = 'b';
list_add(&list, &elmt1.node);
- CHECK(is_list_empty(&list), 0);
- CHECK(elmt1.node.next, &elmt0.node);
- CHECK(elmt1.node.prev, &list);
- CHECK(elmt1.node.next->prev, &elmt1.node);
- CHECK(list_head(&list), &elmt1.node);
+ CHK(is_list_empty(&list) == 0);
+ CHK(elmt1.node.next == &elmt0.node);
+ CHK(elmt1.node.prev == &list);
+ CHK(elmt1.node.next->prev == &elmt1.node);
+ CHK(list_head(&list) == &elmt1.node);
elmt2.c = 'c';
list_add_tail(&list, &elmt2.node);
- CHECK(is_list_empty(&list), 0);
- CHECK(elmt2.node.next, &list);
- CHECK(elmt2.node.prev, &elmt0.node);
- CHECK(elmt2.node.prev->prev, &elmt1.node);
- CHECK(elmt1.node.next->next, &elmt2.node);
- CHECK(elmt0.node.next, &elmt2.node);
- CHECK(list_head(&list), &elmt1.node);
- CHECK(list_tail(&list), &elmt2.node);
+ CHK(is_list_empty(&list) == 0);
+ CHK(elmt2.node.next == &list);
+ CHK(elmt2.node.prev == &elmt0.node);
+ CHK(elmt2.node.prev->prev == &elmt1.node);
+ CHK(elmt1.node.next->next == &elmt2.node);
+ CHK(elmt0.node.next == &elmt2.node);
+ CHK(list_head(&list) == &elmt1.node);
+ CHK(list_tail(&list) == &elmt2.node);
list_del(&elmt0.node);
- CHECK(is_list_empty(&list), 0);
- CHECK(elmt2.node.next, &list);
- CHECK(elmt2.node.prev, &elmt1.node);
- CHECK(elmt1.node.next, &elmt2.node);
- CHECK(elmt1.node.prev, &list);
- CHECK(list_head(&list), &elmt1.node);
- CHECK(list_tail(&list), &elmt2.node);
+ CHK(is_list_empty(&list) == 0);
+ CHK(elmt2.node.next == &list);
+ CHK(elmt2.node.prev == &elmt1.node);
+ CHK(elmt1.node.next == &elmt2.node);
+ CHK(elmt1.node.prev == &list);
+ CHK(list_head(&list) == &elmt1.node);
+ CHK(list_tail(&list) == &elmt2.node);
list_del(&elmt2.node);
- CHECK(is_list_empty(&list), 0);
- CHECK(elmt1.node.next, &list);
- CHECK(elmt1.node.prev, &list);
- CHECK(list_head(&list), &elmt1.node);
- CHECK(list_tail(&list), &elmt1.node);
+ CHK(is_list_empty(&list) == 0);
+ CHK(elmt1.node.next == &list);
+ CHK(elmt1.node.prev == &list);
+ CHK(list_head(&list) == &elmt1.node);
+ CHK(list_tail(&list) == &elmt1.node);
list_del(&elmt1.node);
- CHECK(is_list_empty(&list), 1);
+ CHK(is_list_empty(&list) == 1);
list_add(&list, &elmt2.node);
list_add(&list, &elmt1.node);
list_add(&list, &elmt0.node);
- CHECK(is_list_empty(&list), 0);
- CHECK(elmt2.node.next, &list);
- CHECK(elmt2.node.prev, &elmt1.node);
- CHECK(elmt1.node.next, &elmt2.node);
- CHECK(elmt1.node.prev, &elmt0.node);
- CHECK(elmt0.node.next, &elmt1.node);
- CHECK(elmt0.node.prev, &list);
- CHECK(list_head(&list), &elmt0.node);
- CHECK(list_tail(&list), &elmt2.node);
-
- CHECK(is_list_empty(&list1), 1);
+ CHK(is_list_empty(&list) == 0);
+ CHK(elmt2.node.next == &list);
+ CHK(elmt2.node.prev == &elmt1.node);
+ CHK(elmt1.node.next == &elmt2.node);
+ CHK(elmt1.node.prev == &elmt0.node);
+ CHK(elmt0.node.next == &elmt1.node);
+ CHK(elmt0.node.prev == &list);
+ CHK(list_head(&list) == &elmt0.node);
+ CHK(list_tail(&list) == &elmt2.node);
+
+ CHK(is_list_empty(&list1) == 1);
list_move(&elmt1.node, &list1);
- CHECK(is_list_empty(&list), 0);
- CHECK(is_list_empty(&list1), 0);
- CHECK(elmt2.node.next, &list);
- CHECK(elmt2.node.prev, &elmt0.node);
- CHECK(elmt1.node.next, &list1);
- CHECK(elmt1.node.prev, &list1);
- CHECK(elmt0.node.next, &elmt2.node);
- CHECK(elmt0.node.prev, &list);
- CHECK(list_head(&list), &elmt0.node);
- CHECK(list_tail(&list), &elmt2.node);
- CHECK(list_head(&list1), &elmt1.node);
- CHECK(list_tail(&list1), &elmt1.node);
+ CHK(is_list_empty(&list) == 0);
+ CHK(is_list_empty(&list1) == 0);
+ CHK(elmt2.node.next == &list);
+ CHK(elmt2.node.prev == &elmt0.node);
+ CHK(elmt1.node.next == &list1);
+ CHK(elmt1.node.prev == &list1);
+ CHK(elmt0.node.next == &elmt2.node);
+ CHK(elmt0.node.prev == &list);
+ CHK(list_head(&list) == &elmt0.node);
+ CHK(list_tail(&list) == &elmt2.node);
+ CHK(list_head(&list1) == &elmt1.node);
+ CHK(list_tail(&list1) == &elmt1.node);
list_move_tail(&elmt2.node, &list1);
- CHECK(is_list_empty(&list), 0);
- CHECK(is_list_empty(&list1), 0);
- CHECK(elmt2.node.next, &list1);
- CHECK(elmt2.node.prev, &elmt1.node);
- CHECK(elmt1.node.next, &elmt2.node);
- CHECK(elmt1.node.prev, &list1);
- CHECK(elmt0.node.next, &list);
- CHECK(elmt0.node.prev, &list);
- CHECK(list_head(&list), &elmt0.node);
- CHECK(list_tail(&list), &elmt0.node);
- CHECK(list_head(&list1), &elmt1.node);
- CHECK(list_tail(&list1), &elmt2.node);
+ CHK(is_list_empty(&list) == 0);
+ CHK(is_list_empty(&list1) == 0);
+ CHK(elmt2.node.next == &list1);
+ CHK(elmt2.node.prev == &elmt1.node);
+ CHK(elmt1.node.next == &elmt2.node);
+ CHK(elmt1.node.prev == &list1);
+ CHK(elmt0.node.next == &list);
+ CHK(elmt0.node.prev == &list);
+ CHK(list_head(&list) == &elmt0.node);
+ CHK(list_tail(&list) == &elmt0.node);
+ CHK(list_head(&list1) == &elmt1.node);
+ CHK(list_tail(&list1) == &elmt2.node);
list_move(&elmt0.node, &list1);
- CHECK(is_list_empty(&list), 1);
- CHECK(is_list_empty(&list1), 0);
- CHECK(elmt2.node.next, &list1);
- CHECK(elmt2.node.prev, &elmt1.node);
- CHECK(elmt1.node.next, &elmt2.node);
- CHECK(elmt1.node.prev, &elmt0.node);
- CHECK(elmt0.node.next, &elmt1.node);
- CHECK(elmt0.node.prev, &list1);
- CHECK(list_head(&list1), &elmt0.node);
- CHECK(list_tail(&list1), &elmt2.node);
+ CHK(is_list_empty(&list) == 1);
+ CHK(is_list_empty(&list1) == 0);
+ CHK(elmt2.node.next == &list1);
+ CHK(elmt2.node.prev == &elmt1.node);
+ CHK(elmt1.node.next == &elmt2.node);
+ CHK(elmt1.node.prev == &elmt0.node);
+ CHK(elmt0.node.next == &elmt1.node);
+ CHK(elmt0.node.prev == &list1);
+ CHK(list_head(&list1) == &elmt0.node);
+ CHK(list_tail(&list1) == &elmt2.node);
i = 0;
LIST_FOR_EACH(n, &list1) {
struct elmt* e = CONTAINER_OF(n, struct elmt, node);
- CHECK(e->c, 'a' + i);
+ CHK(e->c == 'a' + i);
++i;
}
- CHECK(i, 3);
+ CHK(i == 3);
i = 3;
LIST_FOR_EACH_REVERSE(n, &list1) {
struct elmt* e = CONTAINER_OF(n, struct elmt, node);
--i;
- CHECK(e->c, 'a' + i);
+ CHK(e->c == 'a' + i);
}
- CHECK(i, 0);
+ CHK(i == 0);
i = 0;
LIST_FOR_EACH_SAFE(n, tmp, &list1) {
struct elmt* e = NULL;
list_move_tail(n, &list);
e = CONTAINER_OF(n, struct elmt, node);
- CHECK(e->c, 'a' + i);
+ CHK(e->c == 'a' + i);
++i;
}
- CHECK(i, 3);
- CHECK(is_list_empty(&list1), 1);
- CHECK(is_list_empty(&list), 0);
+ CHK(i == 3);
+ CHK(is_list_empty(&list1) == 1);
+ CHK(is_list_empty(&list) == 0);
i = 3;
LIST_FOR_EACH_REVERSE_SAFE(n, tmp, &list) {
@@ -171,41 +171,41 @@ main(int argc, char** argv)
list_move(n, &list1);
e = CONTAINER_OF(n, struct elmt, node);
--i;
- CHECK(e->c, 'a' + i);
+ CHK(e->c == 'a' + i);
}
- CHECK(i, 0);
- CHECK(is_list_empty(&list1), 0);
- CHECK(is_list_empty(&list), 1);
+ CHK(i == 0);
+ CHK(is_list_empty(&list1) == 0);
+ CHK(is_list_empty(&list) == 1);
i = 0;
LIST_FOR_EACH(n, &list1) {
struct elmt* e = CONTAINER_OF(n, struct elmt, node);
- CHECK(e->c, 'a' + i);
+ CHK(e->c == 'a' + i);
++i;
}
- CHECK(i, 3);
+ CHK(i == 3);
list_move(&elmt1.node, &list1);
- CHECK(elmt2.node.next, &list1);
- CHECK(elmt2.node.prev, &elmt0.node);
- CHECK(elmt1.node.next, &elmt0.node);
- CHECK(elmt1.node.prev, &list1);
- CHECK(elmt0.node.next, &elmt2.node);
- CHECK(elmt0.node.prev, &elmt1.node);
- CHECK(list_head(&list1), &elmt1.node);
- CHECK(list_tail(&list1), &elmt2.node);
+ CHK(elmt2.node.next == &list1);
+ CHK(elmt2.node.prev == &elmt0.node);
+ CHK(elmt1.node.next == &elmt0.node);
+ CHK(elmt1.node.prev == &list1);
+ CHK(elmt0.node.next == &elmt2.node);
+ CHK(elmt0.node.prev == &elmt1.node);
+ CHK(list_head(&list1) == &elmt1.node);
+ CHK(list_tail(&list1) == &elmt2.node);
list_move_tail(&elmt0.node, &list1);
- CHECK(elmt2.node.next, &elmt0.node);
- CHECK(elmt2.node.prev, &elmt1.node);
- CHECK(elmt1.node.next, &elmt2.node);
- CHECK(elmt1.node.prev, &list1);
- CHECK(elmt0.node.next, &list1);
- CHECK(elmt0.node.prev, &elmt2.node);
- CHECK(list_head(&list1), &elmt1.node);
- CHECK(list_tail(&list1), &elmt0.node);
-
- CHECK(MEM_ALLOCATED_SIZE(&mem_default_allocator), 0);
+ CHK(elmt2.node.next == &elmt0.node);
+ CHK(elmt2.node.prev == &elmt1.node);
+ CHK(elmt1.node.next == &elmt2.node);
+ CHK(elmt1.node.prev == &list1);
+ CHK(elmt0.node.next == &list1);
+ CHK(elmt0.node.prev == &elmt2.node);
+ CHK(list_head(&list1) == &elmt1.node);
+ CHK(list_tail(&list1) == &elmt0.node);
+
+ CHK(MEM_ALLOCATED_SIZE(&mem_default_allocator) == 0);
return 0;
}
diff --git a/src/test_logger.c b/src/test_logger.c
@@ -20,7 +20,7 @@ static void
func_stream_out(const char* fmt, void* data)
{
*(int*)data += 1;
- CHECK(strcmp(fmt, "output"), 0);
+ CHK(strcmp(fmt, "output") == 0);
}
static void
@@ -34,22 +34,22 @@ static void
func_stream_err(const char* fmt, void* data)
{
*(int*)data += 1;
- CHECK(strcmp(fmt, "error"), 0);
+ CHK(strcmp(fmt, "error") == 0);
}
static void
func_stream_warn(const char* fmt, void* data)
{
*(int*)data += 1;
- CHECK(strcmp( fmt, "warning" ), 0);
+ CHK(strcmp( fmt, "warning" ) == 0);
}
static void
test_vprint(struct logger* logger, const char* fmt, ...)
{
va_list vargs_list;
- NCHECK(logger, NULL);
- NCHECK(fmt, NULL);
+ CHK(logger != NULL);
+ CHK(fmt != NULL);
va_start(vargs_list, fmt);
logger_vprint(logger, LOG_OUTPUT, fmt, vargs_list);
@@ -77,124 +77,124 @@ main(int argc, char** argv)
logger_init(&allocator_proxy, &logger);
logger_print(&logger, LOG_OUTPUT, "out%s", "put");
- CHECK(istream_out, 0);
- CHECK(istream_err, 0);
- CHECK(istream_warn, 0);
+ CHK(istream_out == 0);
+ CHK(istream_err == 0);
+ CHK(istream_warn == 0);
- CHECK(logger_has_stream(&logger, LOG_OUTPUT), 0);
- CHECK(logger_has_stream(&logger, LOG_ERROR), 0);
- CHECK(logger_has_stream(&logger, LOG_WARNING), 0);
+ CHK(logger_has_stream(&logger, LOG_OUTPUT) == 0);
+ CHK(logger_has_stream(&logger, LOG_ERROR) == 0);
+ CHK(logger_has_stream(&logger, LOG_WARNING) == 0);
logger_set_stream(&logger, LOG_OUTPUT, func_stream_out, &istream_out);
- CHECK(logger_has_stream(&logger, LOG_OUTPUT), 1);
+ CHK(logger_has_stream(&logger, LOG_OUTPUT) == 1);
logger_print(&logger, LOG_OUTPUT, "output");
- CHECK(istream_out, 1);
- CHECK(istream_err, 0);
- CHECK(istream_warn, 0);
+ CHK(istream_out == 1);
+ CHK(istream_err == 0);
+ CHK(istream_warn == 0);
logger_set_stream(&logger, LOG_ERROR, func_stream_err, &istream_err);
logger_set_stream(&logger, LOG_WARNING, func_stream_warn, &istream_warn);
- CHECK(logger_has_stream(&logger, LOG_OUTPUT), 1);
- CHECK(logger_has_stream(&logger, LOG_ERROR), 1);
- CHECK(logger_has_stream(&logger, LOG_WARNING), 1);
+ CHK(logger_has_stream(&logger, LOG_OUTPUT) == 1);
+ CHK(logger_has_stream(&logger, LOG_ERROR) == 1);
+ CHK(logger_has_stream(&logger, LOG_WARNING) == 1);
logger_print(&logger, LOG_OUTPUT, "output");
- CHECK(istream_out, 2);
- CHECK(istream_err, 0);
- CHECK(istream_warn, 0);
+ CHK(istream_out == 2);
+ CHK(istream_err == 0);
+ CHK(istream_warn == 0);
logger_print(&logger, LOG_ERROR, "error");
- CHECK(istream_out, 2);
- CHECK(istream_err, 1);
- CHECK(istream_warn, 0);
+ CHK(istream_out == 2);
+ CHK(istream_err == 1);
+ CHK(istream_warn == 0);
logger_print(&logger, LOG_WARNING, "war%c%s", 'n', "ing");
- CHECK(istream_out, 2);
- CHECK(istream_err, 1);
- CHECK(istream_warn, 1);
+ CHK(istream_out == 2);
+ CHK(istream_err == 1);
+ CHK(istream_warn == 1);
logger_set_stream(&logger, LOG_OUTPUT, func_stream_out, &istream_out);
logger_print(&logger, LOG_OUTPUT, "output");
- CHECK(istream_out, 3);
- CHECK(istream_err, 1);
- CHECK(istream_warn, 1);
+ CHK(istream_out == 3);
+ CHK(istream_err == 1);
+ CHK(istream_warn == 1);
logger_print
( &logger, LOG_OUTPUT, "%c%c%c%c%c%c", 'o', 'u' ,'t', 'p', 'u', 't' );
- CHECK(istream_out, 4);
- CHECK(istream_err, 1);
- CHECK(istream_warn, 1);
+ CHK(istream_out == 4);
+ CHK(istream_err == 1);
+ CHK(istream_warn == 1);
logger_print(&logger, LOG_ERROR, "error");
- CHECK(istream_out, 4);
- CHECK(istream_err, 2);
- CHECK(istream_warn, 1);
+ CHK(istream_out == 4);
+ CHK(istream_err == 2);
+ CHK(istream_warn == 1);
logger_print(&logger, LOG_WARNING, "warning");
- CHECK(istream_out, 4);
- CHECK(istream_err, 2);
- CHECK(istream_warn, 2);
+ CHK(istream_out == 4);
+ CHK(istream_err == 2);
+ CHK(istream_warn == 2);
logger_set_stream(&logger, LOG_ERROR, NULL, NULL);
logger_print(&logger, LOG_ERROR, "error");
- CHECK(istream_out, 4);
- CHECK(istream_err, 2);
- CHECK(istream_warn, 2);
+ CHK(istream_out == 4);
+ CHK(istream_err == 2);
+ CHK(istream_warn == 2);
logger_clear(&logger);
- CHECK(logger_has_stream(&logger, LOG_OUTPUT), 0);
- CHECK(logger_has_stream(&logger, LOG_ERROR), 0);
- CHECK(logger_has_stream(&logger, LOG_WARNING), 0);
+ CHK(logger_has_stream(&logger, LOG_OUTPUT) == 0);
+ CHK(logger_has_stream(&logger, LOG_ERROR) == 0);
+ CHK(logger_has_stream(&logger, LOG_WARNING) == 0);
istream_out = istream_err = istream_warn = 0;
logger_set_stream(&logger, LOG_OUTPUT, func_stream_out, &istream_out);
logger_set_stream(&logger, LOG_ERROR, func_stream_out, &istream_out);
logger_set_stream(&logger, LOG_WARNING, func_stream_out, &istream_out);
logger_print(&logger, LOG_OUTPUT, "output");
- CHECK(istream_out, 1);
- CHECK(istream_err, 0);
- CHECK(istream_warn, 0);
+ CHK(istream_out == 1);
+ CHK(istream_err == 0);
+ CHK(istream_warn == 0);
logger_print(&logger, LOG_ERROR, "output");
- CHECK(istream_out, 2);
- CHECK(istream_err, 0);
- CHECK(istream_warn, 0);
+ CHK(istream_out == 2);
+ CHK(istream_err == 0);
+ CHK(istream_warn == 0);
logger_print(&logger, LOG_WARNING, "output");
- CHECK(istream_out, 3);
- CHECK(istream_err, 0);
- CHECK(istream_warn, 0);
+ CHK(istream_out == 3);
+ CHK(istream_err == 0);
+ CHK(istream_warn == 0);
logger_set_stream(&logger, LOG_WARNING, NULL, NULL);
logger_print(&logger, LOG_WARNING, "output");
- CHECK(istream_out, 3);
- CHECK(istream_err, 0);
- CHECK(istream_warn, 0);
+ CHK(istream_out == 3);
+ CHK(istream_err == 0);
+ CHK(istream_warn == 0);
logger_print(&logger, LOG_ERROR, "output");
logger_print(&logger, LOG_OUTPUT, "output");
- CHECK(istream_out, 5);
- CHECK(istream_err, 0);
- CHECK(istream_warn, 0);
+ CHK(istream_out == 5);
+ CHK(istream_err == 0);
+ CHK(istream_warn == 0);
logger_set_stream(&logger, LOG_OUTPUT, NULL, NULL);
logger_set_stream(&logger, LOG_OUTPUT, NULL, NULL);
logger_print(&logger, LOG_WARNING, "output");
logger_print(&logger, LOG_OUTPUT, "output");
- CHECK(istream_out, 5);
- CHECK(istream_err, 0);
- CHECK(istream_warn, 0);
+ CHK(istream_out == 5);
+ CHK(istream_err == 0);
+ CHK(istream_warn == 0);
logger_print(&logger, LOG_ERROR, "output");
- CHECK(istream_out, 6);
- CHECK(istream_err, 0);
- CHECK(istream_warn, 0);
+ CHK(istream_out == 6);
+ CHK(istream_err == 0);
+ CHK(istream_warn == 0);
logger_set_stream(&logger, LOG_OUTPUT, func_stream_out, &istream_out);
logger_set_stream(&logger, LOG_WARNING, func_stream_out, &istream_out);
logger_print(&logger, LOG_OUTPUT, "output");
logger_print(&logger, LOG_ERROR, "output");
logger_print(&logger, LOG_WARNING, "output");
- CHECK(istream_out, 9);
- CHECK(istream_err, 0);
- CHECK(istream_warn, 0);
+ CHK(istream_out == 9);
+ CHK(istream_err == 0);
+ CHK(istream_warn == 0);
logger_clear(&logger);
logger_print(&logger, LOG_OUTPUT, "output");
logger_print(&logger, LOG_ERROR, "output");
logger_print(&logger, LOG_WARNING, "output");
- CHECK(istream_out, 9);
- CHECK(istream_err, 0);
- CHECK(istream_warn, 0);
+ CHK(istream_out == 9);
+ CHK(istream_err == 0);
+ CHK(istream_warn == 0);
logger_set_stream(&logger, LOG_OUTPUT, func_stream_out_std, NULL);
logger_print
@@ -224,7 +224,7 @@ ENCCRY QBJA GB GUR FHESNPR BS URYY.\n\n",
check_memory_allocator(&allocator_proxy);
mem_shutdown_proxy_allocator(&allocator_proxy);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_math.c b/src/test_math.c
@@ -28,90 +28,90 @@ main(int argc, char** argv)
int i;
(void)argc, (void)argv;
- f = -3.14159f; CHECK(absf(f),-f);
- f = 3.14159f; CHECK(absf(f), f);
+ f = -3.14159f; CHK(absf(f) == -f);
+ f = 3.14159f; CHK(absf(f) == f);
f = -3.14159f; g = 2.71828f;
- CHECK(MMAX(f, g), g);
- CHECK(MMIN(f, g), f);
- CHECK(MMAX(-10, 0), 0);
- CHECK(MMAX(10, 0), 10);
- CHECK(MMIN(-10, 0), -10);
- CHECK(MMIN(10, 0), 0);
-
- CHECK(CLAMP(0.1f, 0.f, 1.f), 0.1f);
- CHECK(CLAMP(-0.1f, 0.f, 1.f), 0.f);
- CHECK(CLAMP(1.2f, 0.f, 1.f), 1.f);
- CHECK(CLAMP(1.f, 0.f, 1.f), 1.f);
- CHECK(CLAMP(0, -127, 127), 0);
- CHECK(CLAMP(255, -127, 127), 127);
- CHECK(CLAMP(-255, -127, 127), -127);
-
- CHECK(eq_epsf((float)PI, 3.14159265358979323846f, 1.e-6f), 1);
- CHECK(eq_epsf((float)RCP_PI, 1.f / (float)PI, 1.e-6f), 1);
- CHECK(eq_eps(PI, 3.14159265358979323846, 1.e-8), 1);
- CHECK(eq_eps(RCP_PI, 1.0/PI, 1.e-8), 1);
-
- CHECK(1.f/0.f, (float)INF);
- CHECK(-1.f/0.f, (float)-INF);
- NCHECK(1.0/0.0, -INF);
- CHECK(1.0/0.0, INF);
- NCHECK(-1.0/0.0, INF);
- CHECK(-1.0/0.0, -INF);
- NCHECK(IS_INF(PI/0.0), 0);
- NCHECK(IS_INF(-PI/0.0), 0);
- CHECK(IS_INF(PI), 0);
+ CHK(MMAX(f, g) == g);
+ CHK(MMIN(f, g) == f);
+ CHK(MMAX(-10, 0) == 0);
+ CHK(MMAX(10, 0) == 10);
+ CHK(MMIN(-10, 0) == -10);
+ CHK(MMIN(10, 0) == 0);
+
+ CHK(CLAMP(0.1f, 0.f, 1.f) == 0.1f);
+ CHK(CLAMP(-0.1f, 0.f, 1.f) == 0.f);
+ CHK(CLAMP(1.2f, 0.f, 1.f) == 1.f);
+ CHK(CLAMP(1.f, 0.f, 1.f) == 1.f);
+ CHK(CLAMP(0, -127, 127) == 0);
+ CHK(CLAMP(255, -127, 127) == 127);
+ CHK(CLAMP(-255, -127, 127) == -127);
+
+ CHK(eq_epsf((float)PI, 3.14159265358979323846f, 1.e-6f) == 1);
+ CHK(eq_epsf((float)RCP_PI, 1.f / (float)PI, 1.e-6f) == 1);
+ CHK(eq_eps(PI, 3.14159265358979323846, 1.e-8) == 1);
+ CHK(eq_eps(RCP_PI, 1.0/PI, 1.e-8) == 1);
+
+ CHK(1.f/0.f == (float)INF);
+ CHK(-1.f/0.f == (float)-INF);
+ CHK(1.0/0.0 != -INF);
+ CHK(1.0/0.0 == INF);
+ CHK(-1.0/0.0 != INF);
+ CHK(-1.0/0.0 == -INF);
+ CHK(IS_INF(PI/0.0) != 0);
+ CHK(IS_INF(-PI/0.0) != 0);
+ CHK(IS_INF(PI) == 0);
d = NaN;
- CHECK(d==d, 0);
- CHECK(IS_NaN(d), 1);
+ CHK(d != d);
+ CHK(IS_NaN(d) == 1);
d = -NaN;
- CHECK(d==d, 0);
- CHECK(IS_NaN(d), 1);
+ CHK(d!=d);
+ CHK(IS_NaN(d) == 1);
d = sqrt(-1);
- CHECK(IS_NaN(d), 1);
+ CHK(IS_NaN(d) == 1);
f = (float)NaN;
- CHECK(f==f, 0);
- CHECK(IS_NaN(f), 1);
+ CHK(f!=f);
+ CHK(IS_NaN(f) == 1);
f = (float)sqrt(-1);
- CHECK(f==f, 0);
- CHECK(IS_NaN(f), 1);
- CHECK(IS_NaN(NaN), 1);
- CHECK(IS_NaN(-NaN), 1);
- CHECK(IS_NaN(INF), 0);
- CHECK(IS_NaN(-INF), 0);
- CHECK(IS_NaN(1.0/3.0), 0);
-
- CHECK(IS_POW2(0), 0);
- CHECK(IS_POW2(1), 1);
- CHECK(IS_POW2(2), 1);
- CHECK(IS_POW2(3), 0);
- CHECK(IS_POW2(31), 0);
- CHECK(IS_POW2(64), 1);
- CHECK(IS_POW2(1 << 16), 1);
-
- CHECK(log2i(3), 1);
- CHECK(log2i(4), 2);
- CHECK(log2i(5), 2);
- CHECK(log2i(7), 2);
- CHECK(log2i(8), 3);
- CHECK(log2i(12), 3);
- CHECK(log2i(511), 8);
- CHECK(log2i(512), 9);
-
- CHECK(round_up_pow2(0), 1);
- CHECK(round_up_pow2(3), 4);
- CHECK(round_up_pow2(4), 4);
- CHECK(round_up_pow2(100), 128);
-
- CHECK(absf(-1.f), 1.f);
- CHECK(absf(10.f), 10.f);
- CHECK(absf(-3.14159f), (float)3.14159f);
-
- CHECK(eq_eps(MDEG2RAD(90.0), PI*0.5, 1.e-8), 1);
- CHECK(eq_eps(MDEG2RAD(45.0), PI*0.25, 1.e-8), 1);
- CHECK(eq_eps(MRAD2DEG(PI), 180.0, 1.e-8), 1);
- CHECK(eq_eps(MRAD2DEG(PI*0.75), 135.0, 1.e-8), 1);
- CHECK(eq_eps(MRAD2DEG(MDEG2RAD(70.0)), 70.0, 1.e-8), 1);
+ CHK(f!=f);
+ CHK(IS_NaN(f) == 1);
+ CHK(IS_NaN(NaN) == 1);
+ CHK(IS_NaN(-NaN) == 1);
+ CHK(IS_NaN(INF) == 0);
+ CHK(IS_NaN(-INF) == 0);
+ CHK(IS_NaN(1.0/3.0) == 0);
+
+ CHK(IS_POW2(0) == 0);
+ CHK(IS_POW2(1) == 1);
+ CHK(IS_POW2(2) == 1);
+ CHK(IS_POW2(3) == 0);
+ CHK(IS_POW2(31) == 0);
+ CHK(IS_POW2(64) == 1);
+ CHK(IS_POW2(1 << 16) == 1);
+
+ CHK(log2i(3) == 1);
+ CHK(log2i(4) == 2);
+ CHK(log2i(5) == 2);
+ CHK(log2i(7) == 2);
+ CHK(log2i(8) == 3);
+ CHK(log2i(12) == 3);
+ CHK(log2i(511) == 8);
+ CHK(log2i(512) == 9);
+
+ CHK(round_up_pow2(0) == 1);
+ CHK(round_up_pow2(3) == 4);
+ CHK(round_up_pow2(4) == 4);
+ CHK(round_up_pow2(100) == 128);
+
+ CHK(absf(-1.f) == 1.f);
+ CHK(absf(10.f) == 10.f);
+ CHK(absf(-3.14159f) == (float)3.14159f);
+
+ CHK(eq_eps(MDEG2RAD(90.0), PI*0.5, 1.e-8) == 1);
+ CHK(eq_eps(MDEG2RAD(45.0), PI*0.25, 1.e-8) == 1);
+ CHK(eq_eps(MRAD2DEG(PI), 180.0, 1.e-8) == 1);
+ CHK(eq_eps(MRAD2DEG(PI*0.75), 135.0, 1.e-8) == 1);
+ CHK(eq_eps(MRAD2DEG(MDEG2RAD(70.0)), 70.0, 1.e-8) == 1);
FOR_EACH(i, 0, 16) {
double c, s, tmp;
@@ -119,17 +119,17 @@ main(int argc, char** argv)
c = cos(d);
s = sin(d);
tmp = cos2sin(c);
- CHECK(eq_eps(s, tmp, 1.0e-8) || eq_eps(s, -tmp, 1.0e-8), 1);
+ CHK(eq_eps(s, tmp, 1.0e-8) || eq_eps(s, -tmp, 1.0e-8) == 1);
tmp = sin2cos(s);
- CHECK(eq_eps(c, tmp, 1.0e-8) || eq_eps(c, -tmp, 1.0e-8), 1);
+ CHK(eq_eps(c, tmp, 1.0e-8) || eq_eps(c, -tmp, 1.0e-8) == 1);
}
- CHECK(signf(-3.14159f), -1.f);
- CHECK(signf(1.23f), 1.f);
- CHECK(signf(0.f), 1.f);
- CHECK(sign(-3.14159), -1.0);
- CHECK(sign(1.23), 1.0);
- CHECK(sign(0.0), 1.0);
+ CHK(signf(-3.14159f) == -1.f);
+ CHK(signf(1.23f) == 1.f);
+ CHK(signf(0.f) == 1.f);
+ CHK(sign(-3.14159) == -1.0);
+ CHK(sign(1.23) == 1.0);
+ CHK(sign(0.0) == 1.0);
return 0;
}
diff --git a/src/test_mem_allocator.c b/src/test_mem_allocator.c
@@ -27,22 +27,22 @@ test_regular(void)
size_t i = 0;
p = mem_alloc_aligned(1024, ALIGNOF(char));
- NCHECK(p, NULL);
- CHECK(IS_ALIGNED((uintptr_t)p, ALIGNOF(char)), 1);
+ CHK(p != NULL);
+ CHK(IS_ALIGNED((uintptr_t)p, ALIGNOF(char)) == 1);
mem_rm( p );
q[0] = mem_alloc_aligned(10, 64);
q[1] = mem_alloc(58);
q[2] = mem_alloc(78);
- NCHECK(q[0], NULL);
- NCHECK(q[1], NULL);
- NCHECK(q[2], NULL);
- CHECK(IS_ALIGNED((uintptr_t )q[0], 64 ), 1);
+ CHK(q[0] != NULL);
+ CHK(q[1] != NULL);
+ CHK(q[2] != NULL);
+ CHK(IS_ALIGNED((uintptr_t )q[0], 64 ) == 1);
p = mem_calloc(1, 4);
- NCHECK(p, NULL);
+ CHK(p != NULL);
FOR_EACH(i, 0, 4) {
- CHECK(((char*)p)[i], 0);
+ CHK(((char*)p)[i] == 0);
}
FOR_EACH(i, 0, 4) {
((char*)p)[i] = (char)i;
@@ -52,7 +52,7 @@ test_regular(void)
p = mem_realloc(p, 8);
FOR_EACH(i, 0, 4) {
- CHECK(((char*)p)[i], (char)i);
+ CHK(((char*)p)[i] == (char)i);
}
FOR_EACH(i, 4, 8) {
((char*)p)[i] = (char)i;
@@ -62,20 +62,20 @@ test_regular(void)
p = mem_realloc(p, 5);
FOR_EACH(i, 0, 5) {
- CHECK(((char*)p )[i], (char)i);
+ CHK(((char*)p )[i] == (char)i);
}
mem_rm(p);
p = NULL;
p = mem_realloc(NULL, 16);
- NCHECK(p, NULL);
+ CHK(p != NULL);
p = mem_realloc(p, 0);
mem_rm(q[0]);
- CHECK(mem_alloc_aligned(1024, 0 ), NULL);
- CHECK(mem_alloc_aligned(1024, 3 ), NULL);
+ CHK(mem_alloc_aligned(1024, 0 ) == NULL);
+ CHK(mem_alloc_aligned(1024, 3 ) == NULL);
}
static void
@@ -87,22 +87,22 @@ test_allocator(struct mem_allocator* allocator)
size_t i = 0;
p = MEM_ALLOC_ALIGNED(allocator, 1024, ALIGNOF(char));
- NCHECK(p, NULL);
- CHECK(IS_ALIGNED((uintptr_t)p, ALIGNOF(char)), 1);
+ CHK(p != NULL);
+ CHK(IS_ALIGNED((uintptr_t)p, ALIGNOF(char)) == 1);
MEM_RM(allocator, p);
q[0] = MEM_ALLOC_ALIGNED(allocator, 10, 8);
q[1] = MEM_CALLOC(allocator, 1, 58);
q[2] = MEM_ALLOC(allocator, 78);
- NCHECK(q[0], NULL);
- NCHECK(q[1], NULL);
- NCHECK(q[2], NULL);
- CHECK(IS_ALIGNED((uintptr_t)q[0], 8), 1);
+ CHK(q[0] != NULL);
+ CHK(q[1] != NULL);
+ CHK(q[2] != NULL);
+ CHK(IS_ALIGNED((uintptr_t)q[0], 8) == 1);
p = MEM_CALLOC(allocator, 2, 2);
- NCHECK(p, NULL);
+ CHK(p != NULL);
for(i = 0; i < 4; ++i)
- CHECK(((char*)p)[i], 0);
+ CHK(((char*)p)[i] == 0);
for(i = 0; i < 4; ++i)
((char*)p)[i] = (char)i;
@@ -116,7 +116,7 @@ test_allocator(struct mem_allocator* allocator)
p = MEM_REALLOC(allocator, p, 8);
for(i = 0; i < 4; ++i)
- CHECK(((char*)p)[i], (char)i);
+ CHK(((char*)p)[i] == (char)i);
for(i = 4; i < 8; ++i)
((char*)p)[i] = (char)i;
@@ -124,20 +124,20 @@ test_allocator(struct mem_allocator* allocator)
p = MEM_REALLOC(allocator, p, 5);
for(i = 0; i < 5; ++i)
- CHECK(((char*)p)[i], (char)i);
+ CHK(((char*)p)[i] == (char)i);
MEM_RM(allocator, p);
p = NULL;
p = MEM_REALLOC(allocator, NULL, 16);
- NCHECK(p, NULL);
+ CHK(p != NULL);
p = MEM_REALLOC(allocator, p, 0);
MEM_RM(allocator, q[0]);
- CHECK(MEM_ALLOC_ALIGNED(allocator, 1024, 0), NULL);
- CHECK(MEM_ALLOC_ALIGNED(allocator, 1024, 3), NULL);
- CHECK(MEM_ALLOCATED_SIZE(allocator), 0);
+ CHK(MEM_ALLOC_ALIGNED(allocator, 1024, 0) == NULL);
+ CHK(MEM_ALLOC_ALIGNED(allocator, 1024, 3) == NULL);
+ CHK(MEM_ALLOCATED_SIZE(allocator) == 0);
}
int
@@ -157,42 +157,41 @@ main(int argc, char** argv)
test_allocator(&mem_default_allocator);
printf("\n-- Regular allocator\n");
- CHECK(mem_init_regular_allocator(NULL), RES_BAD_ARG);
- CHECK(mem_init_regular_allocator(&allocator), RES_OK);
+ CHK(mem_init_regular_allocator(NULL) == RES_BAD_ARG);
+ CHK(mem_init_regular_allocator(&allocator) == RES_OK);
test_allocator(&allocator);
mem_shutdown_regular_allocator(&allocator);
printf("\n-- Proxy allocator of default allocator\n");
- CHECK(mem_init_proxy_allocator(NULL, NULL), RES_BAD_ARG);
- CHECK(mem_init_proxy_allocator(&allocator, NULL), RES_BAD_ARG);
- CHECK(mem_init_proxy_allocator(NULL, &mem_default_allocator), RES_BAD_ARG);
- CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
+ CHK(mem_init_proxy_allocator(NULL, NULL) == RES_BAD_ARG);
+ CHK(mem_init_proxy_allocator(&allocator, NULL) == RES_BAD_ARG);
+ CHK(mem_init_proxy_allocator(NULL, &mem_default_allocator) == RES_BAD_ARG);
+ CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
test_allocator(&allocator);
printf("\n-- Proxy allocator of proxy allocator\n");
- CHECK(mem_init_proxy_allocator(&allocator2, &allocator), RES_OK);
+ CHK(mem_init_proxy_allocator(&allocator2, &allocator) == RES_OK);
test_allocator(&allocator2);
mem_shutdown_proxy_allocator(&allocator2);
mem_shutdown_proxy_allocator(&allocator);
printf("\n-- LIFO allocator\n");
- CHECK(mem_init_lifo_allocator(NULL, NULL, 4096), RES_BAD_ARG);
- CHECK(mem_init_lifo_allocator(&allocator, NULL, 4096), RES_BAD_ARG);
- CHECK(mem_init_lifo_allocator(NULL, &mem_default_allocator, 4096), RES_BAD_ARG);
- CHECK(mem_init_lifo_allocator
- (&allocator, &mem_default_allocator, 4096), RES_OK);
- CHECK(MEM_ALLOC(&allocator, 4097), NULL);
+ CHK(mem_init_lifo_allocator(NULL, NULL, 4096) == RES_BAD_ARG);
+ CHK(mem_init_lifo_allocator(&allocator, NULL, 4096) == RES_BAD_ARG);
+ CHK(mem_init_lifo_allocator(NULL, &mem_default_allocator, 4096) == RES_BAD_ARG);
+ CHK(mem_init_lifo_allocator(&allocator, &mem_default_allocator, 4096) == RES_OK);
+ CHK(MEM_ALLOC(&allocator, 4097) == NULL);
test_allocator(&allocator);
mem_shutdown_lifo_allocator(&allocator);
- CHECK(MEM_AREA_OVERLAP(mem, sizeof(int[2]), mem + 2, sizeof(int[6])), 0);
- CHECK(MEM_AREA_OVERLAP(mem + 4, sizeof(int[4]), mem, sizeof(int[4])), 0);
- CHECK(MEM_AREA_OVERLAP(mem, sizeof(int[2]), mem + 1, sizeof(int[7])), 1);
- CHECK(MEM_AREA_OVERLAP(mem + 7, sizeof(int[1]), mem, sizeof(int[8])), 1);
+ CHK(MEM_AREA_OVERLAP(mem, sizeof(int[2]), mem + 2, sizeof(int[6])) == 0);
+ CHK(MEM_AREA_OVERLAP(mem + 4, sizeof(int[4]), mem, sizeof(int[4])) == 0);
+ CHK(MEM_AREA_OVERLAP(mem, sizeof(int[2]), mem + 1, sizeof(int[7])) == 1);
+ CHK(MEM_AREA_OVERLAP(mem + 7, sizeof(int[1]), mem, sizeof(int[8])) == 1);
- CHECK(MEM_ALLOCATED_SIZE(&mem_default_allocator), 0);
- CHECK(mem_allocated_size(), 0);
+ CHK(MEM_ALLOCATED_SIZE(&mem_default_allocator) == 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_mutex.c b/src/test_mutex.c
@@ -201,8 +201,7 @@ test_mutex(void)
string.str[0] = '\0';
string.i = 0;
- string.mutex = mutex_create();
- NCHECK(string.mutex, NULL);
+ CHK(string.mutex = mutex_create());
time_current(&time_start);
@@ -227,8 +226,8 @@ test_mutex(void)
sizeof(dump)/sizeof(char));
printf("%s\n", dump);
- CHECK(string.i, sizeof(src_str)/sizeof(char) + 1);
- CHECK(strcmp(string.str, src_str), 0);
+ CHK(string.i == sizeof(src_str)/sizeof(char) + 1);
+ CHK(strcmp(string.str, src_str) == 0);
mutex_destroy(string.mutex);
}
diff --git a/src/test_quaternion.c b/src/test_quaternion.c
@@ -22,57 +22,57 @@ main(int argc, char** argv)
float q0[4], q1[4], q2[4];
(void)argc, (void)argv;
- CHECK(quat_identity(q0), q0);
- CHECK(q0[0], 0.f);
- CHECK(q0[1], 0.f);
- CHECK(q0[2], 0.f);
- CHECK(q0[3], 1.f);
+ CHK(quat_identity(q0) == q0);
+ CHK(q0[0] == 0.f);
+ CHK(q0[1] == 0.f);
+ CHK(q0[2] == 0.f);
+ CHK(q0[3] == 1.f);
f3(v3, 2.f, 5.f, 1.f);
- CHECK(quat_set_axis_angle(q0, v3, (float)PI*0.3f), q0);
- CHECK(eq_eps(q0[0], 0.907981f, 1.e-6f), 1);
- CHECK(eq_eps(q0[1], 2.269953f, 1.e-6f), 1);
- CHECK(eq_eps(q0[2], 0.453991f, 1.e-6f), 1);
- CHECK(eq_eps(q0[3], 0.891007f, 1.e-6f), 1);
+ CHK(quat_set_axis_angle(q0, v3, (float)PI*0.3f) == q0);
+ CHK(eq_eps(q0[0], 0.907981f, 1.e-6f) == 1);
+ CHK(eq_eps(q0[1], 2.269953f, 1.e-6f) == 1);
+ CHK(eq_eps(q0[2], 0.453991f, 1.e-6f) == 1);
+ CHK(eq_eps(q0[3], 0.891007f, 1.e-6f) == 1);
f4(q0, 1.f, 2.f, 3.f, 4.f);
f4(q1, 5.f, 6.f, 7.f, 8.f);
- CHECK(quat_mul(q2, q0, q1), q2);
- CHECK(q2[0], 24.f);
- CHECK(q2[1], 48.f);
- CHECK(q2[2], 48.f);
- CHECK(q2[3], -6.f);
+ CHK(quat_mul(q2, q0, q1) == q2);
+ CHK(q2[0] == 24.f);
+ CHK(q2[1] == 48.f);
+ CHK(q2[2] == 48.f);
+ CHK(q2[3] == -6.f);
- CHECK(quat_conj(q2, q0), q2);
- CHECK(q2[0], -1.f);
- CHECK(q2[1], -2.f);
- CHECK(q2[2], -3.f);
- CHECK(q2[3], 4.f);
+ CHK(quat_conj(q2, q0) == q2);
+ CHK(q2[0] == -1.f);
+ CHK(q2[1] == -2.f);
+ CHK(q2[2] == -3.f);
+ CHK(q2[3] == 4.f);
f4_normalize(q0, f4(q0, 1.f, 2.f, 5.f, 0.5f));
f3_set(q1, q0);
q1[3] = quat_calca(q1);
- CHECK(eq_eps(q1[3], q0[3], 1.e-6f), 1);
+ CHK(eq_eps(q1[3], q0[3], 1.e-6f) == 1);
f4(q0, 1.f, 2.F, 3.f, 5.f);
f4(q1, 2.f, 6.f, 7.f, 6.f);
- CHECK(quat_slerp(q2, q0, q1, 0.3f), q2);
- CHECK(eq_eps(q2[0], 1.3f, 1.e-6f), 1);
- CHECK(eq_eps(q2[1], 3.2f, 1.e-6f), 1);
- CHECK(eq_eps(q2[2], 4.2f, 1.e-6f), 1);
- CHECK(eq_eps(q2[3], 5.3f, 1.e-6f), 1);
+ CHK(quat_slerp(q2, q0, q1, 0.3f) == q2);
+ CHK(eq_eps(q2[0], 1.3f, 1.e-6f) == 1);
+ CHK(eq_eps(q2[1], 3.2f, 1.e-6f) == 1);
+ CHK(eq_eps(q2[2], 4.2f, 1.e-6f) == 1);
+ CHK(eq_eps(q2[3], 5.3f, 1.e-6f) == 1);
f4(q0, 2.f, 5.f, 17.f, 9.f);
- CHECK(quat_to_f33(m33, q0), m33);
- CHECK(f3_eq_eps(m33 + 0, f3(v3, -627.f, 326.f, -22.f), 1.e-6f), 1);
- CHECK(f3_eq_eps(m33 + 3, f3(v3, -286.f, -585.f, 206.f), 1.e-6f), 1);
- CHECK(f3_eq_eps(m33 + 6, f3(v3, 158.f, 134.f, -57.f), 1.e-6f), 1);
+ CHK(quat_to_f33(m33, q0) == m33);
+ CHK(f3_eq_eps(m33 + 0, f3(v3, -627.f, 326.f, -22.f), 1.e-6f) == 1);
+ CHK(f3_eq_eps(m33 + 3, f3(v3, -286.f, -585.f, 206.f), 1.e-6f) == 1);
+ CHK(f3_eq_eps(m33 + 6, f3(v3, 158.f, 134.f, -57.f), 1.e-6f) == 1);
f4_normalize(q0, q0);
- CHECK(quat_to_f33(m33, q0), m33);
- CHECK(f3_eq_eps(m33 + 0, f3(v3,-0.573935f, 0.817043f,-0.055138f), 1.e-6f), 1);
- CHECK(f3_eq_eps(m33 + 3, f3(v3,-0.716792f,-0.468672f, 0.516291f), 1.e-6f), 1);
- CHECK(f3_eq_eps(m33 + 6, f3(v3, 0.395990f, 0.335840f, 0.854637f), 1.e-6f), 1);
+ CHK(quat_to_f33(m33, q0) == m33);
+ CHK(f3_eq_eps(m33 + 0, f3(v3,-0.573935f, 0.817043f,-0.055138f), 1.e-6f) == 1);
+ CHK(f3_eq_eps(m33 + 3, f3(v3,-0.716792f,-0.468672f, 0.516291f), 1.e-6f) == 1);
+ CHK(f3_eq_eps(m33 + 6, f3(v3, 0.395990f, 0.335840f, 0.854637f), 1.e-6f) == 1);
return 0;
}
diff --git a/src/test_real2.h b/src/test_real2.h
@@ -25,8 +25,8 @@
{ \
REAL* a__ = (a); \
REAL* b__ = (b); \
- CHECK((a__)[0], (b__)[0]); \
- CHECK((a__)[1], (b__)[1]); \
+ CHK((a__)[0] == (b__)[0]); \
+ CHK((a__)[1] == (b__)[1]); \
} (void) 0
int
@@ -38,14 +38,14 @@ main(int argc, char** argv)
REALX_FUNC__(set)(a, REALX_FUNC__(splat)(c, -1.0));
CHECK_REAL2(a, c);
- CHECK(a[0], -1.0);
- CHECK(a[1], -1.0);
+ CHK(a[0] == -1.0);
+ CHK(a[1] == -1.0);
REALX_FUNC__(set)(a, REALX_CTOR__(c, 0.0, 1.0));
- CHECK(a[0], 0.0);
- CHECK(a[1], 1.0);
+ CHK(a[0] == 0.0);
+ CHK(a[1] == 1.0);
REALX_FUNC__(splat)(a, -2.0);
- CHECK(a[0], -2.0);
- CHECK(a[1], -2.0);
+ CHK(a[0] == -2.0);
+ CHK(a[1] == -2.0);
REALX_FUNC__(set)(a, REALX_CTOR__(c, -1.0, 2.0));
CHECK_REAL2(REALX_FUNC__(minus)(b, a), REALX_CTOR__(c, 1.0, -2.0));
@@ -77,32 +77,32 @@ main(int argc, char** argv)
REALX_FUNC__(set)(b, REALX_CTOR__(c, 1.0, 2.0));
CHECK_REAL2(REALX_FUNC__(lerp)(dst, a, b, 0.5), REALX_CTOR__(c, 0.5, 1.5));
CHECK_REAL2(dst, REALX_CTOR__(c, 0.5, 1.5));
- CHECK(REALX_FUNC__(sum)(b), 3.0);
- CHECK(REALX_FUNC__(dot)(a, b), 2.0);
- CHECK(eq_eps(REALX_FUNC__(len)(a), sqrt(1.0), REAL_EPSILON__), 1);
+ CHK(REALX_FUNC__(sum)(b) == 3.0);
+ CHK(REALX_FUNC__(dot)(a, b) == 2.0);
+ CHK(eq_eps(REALX_FUNC__(len)(a), sqrt(1.0), REAL_EPSILON__) == 1);
- CHECK(REALX_FUNC__(is_normalized)(b), 0);
+ CHK(REALX_FUNC__(is_normalized)(b) == 0);
f = REALX_FUNC__(normalize)(dst, b);
- CHECK(REALX_FUNC__(is_normalized)(b), 0);
- NCHECK(REALX_FUNC__(is_normalized)(dst), 0);
- CHECK(eq_eps(f, sqrt(5.0), REAL_EPSILON__), 1);
- CHECK(eq_eps(dst[0], b[0] / f, REAL_EPSILON__), 1);
- CHECK(eq_eps(dst[1], b[1] / f, REAL_EPSILON__), 1);
+ CHK(REALX_FUNC__(is_normalized)(b) == 0);
+ CHK(REALX_FUNC__(is_normalized)(dst) != 0);
+ CHK(eq_eps(f, sqrt(5.0), REAL_EPSILON__) == 1);
+ CHK(eq_eps(dst[0], b[0] / f, REAL_EPSILON__) == 1);
+ CHK(eq_eps(dst[1], b[1] / f, REAL_EPSILON__) == 1);
- CHECK(REALX_FUNC__(eq)(a, a), 1);
- CHECK(REALX_FUNC__(eq)(a, b), 0);
- CHECK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, b[0], a[1])), 0);
- CHECK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, a[0], b[1])), 0);
+ CHK(REALX_FUNC__(eq)(a, a) == 1);
+ CHK(REALX_FUNC__(eq)(a, b) == 0);
+ CHK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, b[0], a[1])) == 0);
+ CHK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, a[0], b[1])) == 0);
REALX_FUNC__(set)(b, a);
REALX_FUNC__(add)(b, b, REALX_FUNC__(splat)(c, (REAL)(REAL_EPSILON__ * 0.5)));
- CHECK(REALX_FUNC__(eq)(a, b), 0);
- CHECK(REALX_FUNC__(eq_eps)(a, b, REAL_EPSILON__), 1);
- CHECK(REALX_FUNC__(eq_eps)(a, b, (REAL)(REAL_EPSILON__ * 0.25)), 0);
+ CHK(REALX_FUNC__(eq)(a, b) == 0);
+ CHK(REALX_FUNC__(eq_eps)(a, b, REAL_EPSILON__) == 1);
+ CHK(REALX_FUNC__(eq_eps)(a, b, (REAL)(REAL_EPSILON__ * 0.25)) == 0);
REALX_FUNC__(set)(a, REALX_CTOR__(c, 1.0, -2.0));
REALX_FUNC__(set)(b, REALX_CTOR__(c, 3.0, 1.0));
- CHECK(REALX_FUNC__(cross)(a, b), 7.0);
+ CHK(REALX_FUNC__(cross)(a, b) == 7.0);
REALX_FUNC__(set)(a, REALX_CTOR__(c, 1.0, -2.0));
REALX_FUNC__(set)(b, REALX_CTOR__(c, -3.0, 1.0));
diff --git a/src/test_real22.h b/src/test_real22.h
@@ -30,7 +30,7 @@
const REAL* b__ = (B); \
int i__; \
FOR_EACH(i__, 0, 2) \
- CHECK(a__[i__], b__[i__]); \
+ CHK(a__[i__] == b__[i__]); \
} (void)0
#define CHECK_REAL22(A, B) \
{ \
@@ -38,7 +38,7 @@
const REAL* b__ = (B); \
int i__; \
FOR_EACH(i__, 0, 4) \
- CHECK(a__[i__], b__[i__]); \
+ CHK(a__[i__] == b__[i__]); \
} (void)0
int
@@ -51,23 +51,23 @@ main(int argc, char** argv)
REALXY_FUNC__(set)(c, REALXY_FUNC__(splat)(a, -1.0));
FOR_EACH(i, 0, 4) {
- CHECK(a[i], -1.0);
- CHECK(c[i], -1.0);
+ CHK(a[i] == -1.0);
+ CHK(c[i] == -1.0);
}
REALXY_FUNC__(set)(a, REALXY_CTOR__(c, 0.0, 1.0, 2.0, 3.0));
FOR_EACH(i, 0, 4) {
- CHECK(a[i], (REAL)i);
+ CHK(a[i] == (REAL)i);
}
CHECK_REAL22(REALXY_FUNC__(set_identity)(a),
REALXY_CTOR__(c, 1.0, 0.0, 0.0, 1.0));
CHECK_REAL22(a, REALXY_CTOR__(c, 1.0, 0.0, 0.0, 1.0));
- CHECK(REALXY_FUNC__(is_identity)(a), 1);
+ CHK(REALXY_FUNC__(is_identity)(a) == 1);
REALXY_FUNC__(set)(c, a);
FOR_EACH(i, 0, REALX_DIMENSION__*REALY_DIMENSION__) {
REAL_TYPE__ r = c[i];
c[i] = c[i] + REAL_EPSILON__;
- CHECK(REALXY_FUNC__(is_identity)(c), 0);
+ CHK(REALXY_FUNC__(is_identity)(c) == 0);
c[i] = r;
}
@@ -148,17 +148,17 @@ main(int argc, char** argv)
CHECK_REAL22(a, REALXY_CTOR__(c, -1.0, -2.0, -3.0, -4.0));
REALXY_FUNC__(set)(a, b);
- CHECK(REALXY_FUNC__(eq)(a, b), 1);
+ CHK(REALXY_FUNC__(eq)(a, b) == 1);
REALXY_FUNC__(add)(a, a, REALXY_FUNC__(splat)(c, REAL_EPSILON__));
- CHECK(REALXY_FUNC__(eq)(a, b), 0);
- CHECK(REALXY_FUNC__(eq_eps)(a, b, REAL_EPSILON__), 1);
- CHECK(REALXY_FUNC__(eq_eps)(a, b, REAL_EPSILON__ * (REAL)0.9), 0);
+ CHK(REALXY_FUNC__(eq)(a, b) == 0);
+ CHK(REALXY_FUNC__(eq_eps)(a, b, REAL_EPSILON__) == 1);
+ CHK(REALXY_FUNC__(eq_eps)(a, b, REAL_EPSILON__ * (REAL)0.9) == 0);
REALXY_FUNC__(set)(a, REALXY_CTOR__(c, 1, 3, 2, 4));
- CHECK(REALXY_FUNC__(det)(a), -2.0);
- CHECK(REALXY_FUNC__(inverse)(b, a), -2.0);
+ CHK(REALXY_FUNC__(det)(a) == -2.0);
+ CHK(REALXY_FUNC__(inverse)(b, a) == -2.0);
CHECK_REAL22(b, REALXY_CTOR__(c, -2.0, 1.5, 1.0, -0.5));
- CHECK(REALXY_FUNC__(invtrans)(a, a), -2.0);
+ CHK(REALXY_FUNC__(invtrans)(a, a) == -2.0);
CHECK_REAL22(a, REALXY_CTOR__(c, -2.0, 1.0, 1.5, -0.5));
return 0;
diff --git a/src/test_real3.h b/src/test_real3.h
@@ -25,9 +25,9 @@
{ \
REAL* a__ = (a); \
REAL* b__ = (b); \
- CHECK((a__)[0], (b__)[0]); \
- CHECK((a__)[1], (b__)[1]); \
- CHECK((a__)[2], (b__)[2]); \
+ CHK((a__)[0] == (b__)[0]); \
+ CHK((a__)[1] == (b__)[1]); \
+ CHK((a__)[2] == (b__)[2]); \
} (void)0
int
@@ -38,17 +38,17 @@ main(int argc, char** argv)
(void)argc, (void)argv;
REALX_FUNC__(set)(a, REALX_FUNC__(splat)(c, -1.0));
- CHECK(a[0], -1.0);
- CHECK(a[1], -1.0);
- CHECK(a[2], -1.0);
+ CHK(a[0] == -1.0);
+ CHK(a[1] == -1.0);
+ CHK(a[2] == -1.0);
REALX_FUNC__(set)(a, REALX_CTOR__(c, 0.0, 1.0, 2.0));
- CHECK(a[0], 0.0);
- CHECK(a[1], 1.0);
- CHECK(a[2], 2.0);
+ CHK(a[0] == 0.0);
+ CHK(a[1] == 1.0);
+ CHK(a[2] == 2.0);
REALX_FUNC__(splat)(a, -2.0);
- CHECK(a[0], -2.0);
- CHECK(a[1], -2.0);
- CHECK(a[2], -2.0);
+ CHK(a[0] == -2.0);
+ CHK(a[1] == -2.0);
+ CHK(a[2] == -2.0);
REALX_FUNC__(set)(a, REALX_CTOR__(c, -1.0, 2.0, -3.0));
CHECK_REAL3(REALX_FUNC__(minus)(b, a), REALX_CTOR__(c, 1.0, -2.0, 3.0));
@@ -84,30 +84,30 @@ main(int argc, char** argv)
REALX_FUNC__(set)(b, REALX_CTOR__(c, 1.0, 2.0, -1.0));
CHECK_REAL3(REALX_FUNC__(lerp)(dst, a, b, 0.5), REALX_CTOR__(c, 0.5, 1.5, 0.5));
CHECK_REAL3(dst, REALX_CTOR__(c, 0.5, 1.5, 0.5));
- CHECK(REALX_FUNC__(sum)(b), 2.0);
- CHECK(REALX_FUNC__(dot)(a, b), 0.0);
- CHECK(eq_eps(REALX_FUNC__(len)(a), sqrt(5.0), REAL_EPSILON__), 1);
+ CHK(REALX_FUNC__(sum)(b) == 2.0);
+ CHK(REALX_FUNC__(dot)(a, b) == 0.0);
+ CHK(eq_eps(REALX_FUNC__(len)(a), sqrt(5.0), REAL_EPSILON__) == 1);
- CHECK(REALX_FUNC__(is_normalized)(a), 0);
+ CHK(REALX_FUNC__(is_normalized)(a) == 0);
f = REALX_FUNC__(normalize)(dst, a);
- CHECK(REALX_FUNC__(is_normalized)(a), 0);
- NCHECK(REALX_FUNC__(is_normalized)(dst), 0);
- CHECK(eq_eps(f, sqrt(5.0), REAL_EPSILON__), 1);
- CHECK(eq_eps(dst[0], a[0] / f, REAL_EPSILON__), 1);
- CHECK(eq_eps(dst[1], a[1] / f, REAL_EPSILON__), 1);
- CHECK(eq_eps(dst[2], a[2] / f, REAL_EPSILON__), 1);
+ CHK(REALX_FUNC__(is_normalized)(a) == 0);
+ CHK(REALX_FUNC__(is_normalized)(dst) != 0);
+ CHK(eq_eps(f, sqrt(5.0), REAL_EPSILON__) == 1);
+ CHK(eq_eps(dst[0], a[0] / f, REAL_EPSILON__) == 1);
+ CHK(eq_eps(dst[1], a[1] / f, REAL_EPSILON__) == 1);
+ CHK(eq_eps(dst[2], a[2] / f, REAL_EPSILON__) == 1);
- CHECK(REALX_FUNC__(eq)(a, a), 1);
- CHECK(REALX_FUNC__(eq)(a, b), 0);
- CHECK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, b[0], a[1], a[2])), 0);
- CHECK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, a[0], b[1], a[2])), 0);
- CHECK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, a[0], a[1], b[2])), 0);
+ CHK(REALX_FUNC__(eq)(a, a) == 1);
+ CHK(REALX_FUNC__(eq)(a, b) == 0);
+ CHK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, b[0], a[1], a[2])) == 0);
+ CHK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, a[0], b[1], a[2])) == 0);
+ CHK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, a[0], a[1], b[2])) == 0);
REALX_FUNC__(set)(b, a);
REALX_FUNC__(add)(b, b, REALX_FUNC__(splat)(c, (REAL)(REAL_EPSILON__ * 0.5)));
- CHECK(REALX_FUNC__(eq)(a, b), 0);
- CHECK(REALX_FUNC__(eq_eps)(a, b, REAL_EPSILON__), 1);
- CHECK(REALX_FUNC__(eq_eps)(a, b, (REAL)(REAL_EPSILON__ * 0.25)), 0);
+ CHK(REALX_FUNC__(eq)(a, b) == 0);
+ CHK(REALX_FUNC__(eq_eps)(a, b, REAL_EPSILON__) == 1);
+ CHK(REALX_FUNC__(eq_eps)(a, b, (REAL)(REAL_EPSILON__ * 0.25)) == 0);
REALX_FUNC__(set)(a, REALX_CTOR__(c, 1.0, -2.0, 2.0));
REALX_FUNC__(set)(b, REALX_CTOR__(c, 3.0, 1.0, -1.5));
CHECK_REAL3(REALX_FUNC__(cross)(dst, a, b), REALX_CTOR__(c, 1.0, 7.5, 7.0));
diff --git a/src/test_real33.h b/src/test_real33.h
@@ -30,7 +30,7 @@
const REAL* b__ = (B); \
int i__; \
FOR_EACH(i__, 0, 3) \
- CHECK(a__[i__], b__[i__]); \
+ CHK(a__[i__] == b__[i__]); \
} (void)0
#define CHECK_REAL33(A, B) \
{ \
@@ -38,7 +38,7 @@
const REAL* b__ = (B); \
int i__; \
FOR_EACH(i__, 0, 9) \
- CHECK(a__[i__], b__[i__]); \
+ CHK(a__[i__] == b__[i__]); \
} (void)0
int
@@ -51,24 +51,24 @@ main(int argc, char** argv)
REALXY_FUNC__(set)(a, REALXY_FUNC__(splat)(c, -1.0));
FOR_EACH(i, 0, 9) {
- CHECK(a[i], -1.0);
- CHECK(c[i], -1.0);
+ CHK(a[i] == -1.0);
+ CHK(c[i] == -1.0);
}
REALXY_CTOR__(a, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
FOR_EACH(i, 0, 9) {
- CHECK(a[i], (REAL)i);
+ CHK(a[i] == (REAL)i);
}
CHECK_REAL33
(REALXY_FUNC__(set_identity)(a),
REALXY_CTOR__(c, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0));
CHECK_REAL33(a, REALXY_CTOR__(c, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0));
- CHECK(REALXY_FUNC__(is_identity)(a), 1);
+ CHK(REALXY_FUNC__(is_identity)(a) == 1);
REALXY_FUNC__(set)(c, a);
FOR_EACH(i, 0, REALX_DIMENSION__*REALY_DIMENSION__) {
REAL_TYPE__ r = c[i];
c[i] = c[i] + REAL_EPSILON__;
- CHECK(REALXY_FUNC__(is_identity)(c), 0);
+ CHK(REALXY_FUNC__(is_identity)(c) == 0);
c[i] = r;
}
@@ -203,28 +203,28 @@ main(int argc, char** argv)
REALXY_CTOR__(c, -1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0, -9.0));
REALXY_FUNC__(set)(a, b);
- CHECK(REALXY_FUNC__(eq)(a, b), 1);
+ CHK(REALXY_FUNC__(eq)(a, b) == 1);
REALXY_FUNC__(add)(a, a, REALXY_FUNC__(splat)(c, FLT_EPSILON));
- CHECK(REALXY_FUNC__(eq)(a, b), 0);
- CHECK(REALXY_FUNC__(eq_eps)(a, b, FLT_EPSILON), 1);
- CHECK(REALXY_FUNC__(eq_eps)(a, b, FLT_EPSILON * (REAL)0.9), 0);
+ CHK(REALXY_FUNC__(eq)(a, b) == 0);
+ CHK(REALXY_FUNC__(eq_eps)(a, b, FLT_EPSILON) == 1);
+ CHK(REALXY_FUNC__(eq_eps)(a, b, FLT_EPSILON * (REAL)0.9) == 0);
REALXY_CTOR__(a, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 3.0, -4.0, 9.0);
- CHECK(REALXY_FUNC__(det)(a), -60.0);
- CHECK(REALXY_FUNC__(inverse)(b, a), -60.0);
+ CHK(REALXY_FUNC__(det)(a) == -60.0);
+ CHK(REALXY_FUNC__(inverse)(b, a) == -60.0);
REALXY_REALXY_FUNC__(mul)(dst, a, b);
- CHECK(REALXY_FUNC__(eq_eps)(dst,
- REALXY_CTOR__(c, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0), 1.e-6f), 1);
- CHECK(REALXY_FUNC__(invtrans)(a, a), -60.0);
+ CHK(REALXY_FUNC__(eq_eps)(dst,
+ REALXY_CTOR__(c, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0), 1.e-6f));
+ CHK(REALXY_FUNC__(invtrans)(a, a) == -60.0);
CHECK_REAL33
(a, REALXY_CTOR__(c, b[0], b[3], b[6], b[1], b[4], b[7], b[2], b[5], b[8]));
REALX_CTOR__(c, (REAL)0.66666667, (REAL)0.33333333, (REAL)0.66666667);
REALXY_FUNC__(rotation_axis_angle)(a, c, (REAL)0.349066);
- CHECK(REALXY_FUNC__(eq_eps)(a, REALXY_CTOR__(c,
+ CHK(REALXY_FUNC__(eq_eps)(a, REALXY_CTOR__(c,
(REAL)0.966496, (REAL)0.241415, (REAL)-0.0872034,
(REAL)-0.214612, (REAL)0.946393, (REAL)0.241415,
- (REAL)0.14081, (REAL)-0.214612, (REAL)0.966496), (REAL)1.e-6), 1);
+ (REAL)0.14081, (REAL)-0.214612, (REAL)0.966496), (REAL)1.e-6));
return 0;
}
diff --git a/src/test_real4.h b/src/test_real4.h
@@ -25,10 +25,10 @@
{ \
REAL* a__ = (a); \
REAL* b__ = (b); \
- CHECK((a__)[0], (b__)[0]); \
- CHECK((a__)[1], (b__)[1]); \
- CHECK((a__)[2], (b__)[2]); \
- CHECK((a__)[3], (b__)[3]); \
+ CHK((a__)[0] == (b__)[0]); \
+ CHK((a__)[1] == (b__)[1]); \
+ CHK((a__)[2] == (b__)[2]); \
+ CHK((a__)[3] == (b__)[3]); \
} (void) 0
int
@@ -39,20 +39,20 @@ main(int argc, char** argv)
(void)argc, (void)argv;
REALX_FUNC__(set)(a, REALX_FUNC__(splat)(c, -1.0));
- CHECK(a[0], -1.0);
- CHECK(a[1], -1.0);
- CHECK(a[2], -1.0);
- CHECK(a[3], -1.0);
+ CHK(a[0] == -1.0);
+ CHK(a[1] == -1.0);
+ CHK(a[2] == -1.0);
+ CHK(a[3] == -1.0);
REALX_FUNC__(set)(a, REALX_CTOR__(c, 0.0, 1.0, 2.0, 3.0));
- CHECK(a[0], 0.0);
- CHECK(a[1], 1.0);
- CHECK(a[2], 2.0);
- CHECK(a[3], 3.0);
+ CHK(a[0] == 0.0);
+ CHK(a[1] == 1.0);
+ CHK(a[2] == 2.0);
+ CHK(a[3] == 3.0);
REALX_FUNC__(splat)(a, -2.0);
- CHECK(a[0], -2.0);
- CHECK(a[1], -2.0);
- CHECK(a[2], -2.0);
- CHECK(a[3], -2.0);
+ CHK(a[0] == -2.0);
+ CHK(a[1] == -2.0);
+ CHK(a[2] == -2.0);
+ CHK(a[3] == -2.0);
REALX_FUNC__(set)(a, REALX_CTOR__(c, -1.0, 2.0, -3.0, 4.0));
CHECK_REAL4(REALX_FUNC__(minus)(b, a), REALX_CTOR__(c, 1.0, -2.0, 3.0, -4.0));
@@ -91,33 +91,33 @@ main(int argc, char** argv)
REALX_FUNC__(set)(b, REALX_CTOR__(c, 1.0, 2.0, -1.0, 1.0));
CHECK_REAL4(REALX_FUNC__(lerp)(dst, a, b, 0.5), REALX_CTOR__(c, 0.5, 1.5, 0.5, 2.5));
CHECK_REAL4(dst, REALX_CTOR__(c, 0.5, 1.5, 0.5, 2.5));
- CHECK(REALX_FUNC__(sum)(b), 3.0);
- CHECK(REALX_FUNC__(dot)(a, b), 4.0);
- CHECK(eq_eps(REALX_FUNC__(len)(a), sqrt(21.0), REAL_EPSILON__), 1);
+ CHK(REALX_FUNC__(sum)(b) == 3.0);
+ CHK(REALX_FUNC__(dot)(a, b) == 4.0);
+ CHK(eq_eps(REALX_FUNC__(len)(a), sqrt(21.0), REAL_EPSILON__) == 1);
REALX_FUNC__(set)(a, REALX_CTOR__(c, 0.0, 4.0, 2.0, 3.0));
- CHECK(REALX_FUNC__(is_normalized)(a), 0);
+ CHK(REALX_FUNC__(is_normalized)(a) == 0);
f = REALX_FUNC__(normalize)(dst, a);
- CHECK(REALX_FUNC__(is_normalized)(a), 0);
- NCHECK(REALX_FUNC__(is_normalized)(dst), 0);
- CHECK(eq_eps(f, sqrt(29.0), REAL_EPSILON__), 1);
- CHECK(eq_eps(dst[0], a[0] / f, REAL_EPSILON__), 1);
- CHECK(eq_eps(dst[1], a[1] / f, REAL_EPSILON__), 1);
- CHECK(eq_eps(dst[2], a[2] / f, REAL_EPSILON__), 1);
- CHECK(eq_eps(dst[3], a[3] / f, REAL_EPSILON__), 1);
+ CHK(REALX_FUNC__(is_normalized)(a) == 0);
+ CHK(REALX_FUNC__(is_normalized)(dst) != 0);
+ CHK(eq_eps(f, sqrt(29.0), REAL_EPSILON__) == 1);
+ CHK(eq_eps(dst[0], a[0] / f, REAL_EPSILON__) == 1);
+ CHK(eq_eps(dst[1], a[1] / f, REAL_EPSILON__) == 1);
+ CHK(eq_eps(dst[2], a[2] / f, REAL_EPSILON__) == 1);
+ CHK(eq_eps(dst[3], a[3] / f, REAL_EPSILON__) == 1);
- CHECK(REALX_FUNC__(eq)(a, a), 1);
- CHECK(REALX_FUNC__(eq)(a, b), 0);
- CHECK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, b[0], a[1], a[2], a[3])), 0);
- CHECK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, a[0], b[1], a[2], a[3])), 0);
- CHECK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, a[0], a[1], b[2], a[3])), 0);
- CHECK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, a[0], a[1], a[2], b[3])), 0);
+ CHK(REALX_FUNC__(eq)(a, a) == 1);
+ CHK(REALX_FUNC__(eq)(a, b) == 0);
+ CHK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, b[0], a[1], a[2], a[3])) == 0);
+ CHK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, a[0], b[1], a[2], a[3])) == 0);
+ CHK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, a[0], a[1], b[2], a[3])) == 0);
+ CHK(REALX_FUNC__(eq)(a, REALX_CTOR__(c, a[0], a[1], a[2], b[3])) == 0);
REALX_FUNC__(set)(b, a);
REALX_FUNC__(add)(b, b, REALX_FUNC__(splat)(c, (REAL)(REAL_EPSILON__ * 0.5)));
- CHECK(REALX_FUNC__(eq)(a, b), 0);
- CHECK(REALX_FUNC__(eq_eps)(a, b, REAL_EPSILON__), 1);
- CHECK(REALX_FUNC__(eq_eps)(a, b, (REAL)(REAL_EPSILON__ * 0.25)), 0);
+ CHK(REALX_FUNC__(eq)(a, b) == 0);
+ CHK(REALX_FUNC__(eq_eps)(a, b, REAL_EPSILON__) == 1);
+ CHK(REALX_FUNC__(eq_eps)(a, b, (REAL)(REAL_EPSILON__ * 0.25)) == 0);
REALX_FUNC__(set)(a, REALX_CTOR__(c, 1.0, 3.0, -2.0, (REAL)0.1));
REALX_FUNC__(set)(b, REALX_CTOR__(c, -1.0, (REAL)3.1, (REAL)-2.1, 1.0));
diff --git a/src/test_real44.h b/src/test_real44.h
@@ -29,7 +29,7 @@
const REAL* b__ = (B); \
int i__; \
FOR_EACH(i__, 0, 4) \
- CHECK(a__[i__], b__[i__]); \
+ CHK(a__[i__] == b__[i__]); \
} (void)0
#define CHECK_REAL44(A, B) \
{ \
@@ -37,7 +37,7 @@
const REAL* b__ = (B); \
int i__; \
FOR_EACH(i__, 0, 16) \
- CHECK(a__[i__], b__[i__]); \
+ CHK(a__[i__] == b__[i__]); \
} (void)0
int
@@ -50,8 +50,8 @@ main(int argc, char** argv)
REALXY_FUNC__(set)(a, REALXY_FUNC__(splat)(c, -1.0));
FOR_EACH(i, 0, 16) {
- CHECK(a[i], -1.0);
- CHECK(c[i], -1.0);
+ CHK(a[i] == -1.0);
+ CHK(c[i] == -1.0);
}
REALXY_CTOR__
(a,
@@ -60,7 +60,7 @@ main(int argc, char** argv)
8.0, 9.0, 10.0, 11.0,
12.0, 13.0, 14.0, 15.0);
FOR_EACH(i, 0, 16) {
- CHECK(a[i], (REAL)i);
+ CHK(a[i] == (REAL)i);
}
CHECK_REAL44
(REALXY_FUNC__(set_identity)(a),REALXY_CTOR__(c,
@@ -74,12 +74,12 @@ main(int argc, char** argv)
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0));
- CHECK(REALXY_FUNC__(is_identity)(a), 1);
+ CHK(REALXY_FUNC__(is_identity)(a) == 1);
REALXY_FUNC__(set)(c, a);
FOR_EACH(i, 0, REALX_DIMENSION__*REALY_DIMENSION__) {
REAL_TYPE__ r = c[i];
c[i] = c[i] + REAL_EPSILON__;
- CHECK(REALXY_FUNC__(is_identity)(c), 0);
+ CHK(REALXY_FUNC__(is_identity)(c) == 0);
c[i] = r;
}
@@ -404,10 +404,10 @@ main(int argc, char** argv)
-3.0, -2.0, -1.0, 0.0));
REALXY_FUNC__(set)(a, b);
- CHECK(REALXY_FUNC__(eq)(a, b), 1);
+ CHK(REALXY_FUNC__(eq)(a, b) == 1);
REALXY_FUNC__(add)(a, a, REALXY_FUNC__(splat)(c, FLT_EPSILON));
- CHECK(REALXY_FUNC__(eq_eps)(a, b, FLT_EPSILON), 1);
- CHECK(REALXY_FUNC__(eq_eps)(a, b, FLT_EPSILON * (REAL)0.9), 0);
+ CHK(REALXY_FUNC__(eq_eps)(a, b, FLT_EPSILON) == 1);
+ CHK(REALXY_FUNC__(eq_eps)(a, b, FLT_EPSILON * (REAL)0.9) == 0);
REALXY_FUNC__(set)
(a, REALXY_CTOR__(c,
@@ -415,17 +415,17 @@ main(int argc, char** argv)
1.0, -2.0, 2.0, 1.0,
1.0, -8.0, -4.0, 2.0,
1.0, 3.0, 4.0, 2.0));
- CHECK(REALXY_FUNC__(det)(a), 78.0);
- CHECK(REALXY_FUNC__(inverse)(b, a), 78.0);
+ CHK(REALXY_FUNC__(det)(a) == 78.0);
+ CHK(REALXY_FUNC__(inverse)(b, a) == 78.0);
REALXY_REALXY_FUNC__(mul)(dst, a, b);
- CHECK(REALXY_FUNC__(eq_eps)
+ CHK(REALXY_FUNC__(eq_eps)
(dst, REALXY_CTOR__(c,
1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0),
- 1.e-6f), 1);
- CHECK(REALXY_FUNC__(invtrans)(a, a), 78.0);
+ 1.e-6f));
+ CHK(REALXY_FUNC__(invtrans)(a, a) == 78.0);
REALXY_FUNC__(transpose)(a, a);
CHECK_REAL44(a, b);
diff --git a/src/test_ref.c b/src/test_ref.c
@@ -24,7 +24,7 @@ static void
release(ref_T* ref)
{
ASSERT(NULL != ref);
- CHECK(CONTAINER_OF(ref, struct test, ref)->val, (int)0xDEADBEEF);
+ CHK(CONTAINER_OF(ref, struct test, ref)->val == (int)0xDEADBEEF);
}
int
@@ -40,9 +40,9 @@ main(int argc, char** argv)
ref_get(&test.ref);
ref_get(&test.ref);
- CHECK(ref_put(&test.ref, release), 0);
- CHECK(ref_put(&test.ref, release), 0);
- CHECK(ref_put(&test.ref, release), 0);
- CHECK(ref_put(&test.ref, release), 1);
+ CHK(ref_put(&test.ref, release) == 0);
+ CHK(ref_put(&test.ref, release) == 0);
+ CHK(ref_put(&test.ref, release) == 0);
+ CHK(ref_put(&test.ref, release) == 1);
return 0;
}
diff --git a/src/test_signal.c b/src/test_signal.c
@@ -33,38 +33,38 @@ enum test_signal {
static void
sig0_func1(struct ctxt* ctxt, void* data)
{
- CHECK(data, NULL);
+ CHK(data == NULL);
ctxt->sig0_func1_invoked = 1;
}
static void
sig0_func2(struct ctxt* ctxt, void* data)
{
- NCHECK(data, NULL);
+ CHK(data != NULL);
ctxt->sig0_func2_sum += *((int*)data);
}
static void
sig1_func(struct ctxt* ctxt, void* data)
{
- NCHECK(data, NULL);
+ CHK(data != NULL);
ctxt->sig1_func_sum += *(int*)data;
}
static void
sig2_func( void* data )
{
- NCHECK(data, NULL);
+ CHK(data != NULL);
*(uint32_t*)data = 0xDECAFBAD;
}
static void
sig3_func(int i, float f, char c, void* data)
{
- NCHECK(data, NULL);
- CHECK(i, 3);
- CHECK(f, 4.0f);
- CHECK(c, 'a');
+ CHK(data != NULL);
+ CHK(i == 3);
+ CHK(f == 4.0f);
+ CHK(c == 'a');
*(uint32_t*)data = 0xDECAFBAD;
}
@@ -110,55 +110,55 @@ main(int argc, char** argv)
ctxt.sig1_func_sum = 0;
SIG_BROADCAST(&signals[SIG0], clbk_T, ARG1(&ctxt));
- CHECK(ctxt.sig0_func1_invoked, 0);
- CHECK(ctxt.sig0_func2_sum, 0);
- CHECK(ctxt.sig1_func_sum, 0);
+ CHK(ctxt.sig0_func1_invoked == 0);
+ CHK(ctxt.sig0_func2_sum == 0);
+ CHK(ctxt.sig1_func_sum == 0);
SIG_BROADCAST(&signals[SIG1], clbk_T, ARG1(&ctxt));
- CHECK(ctxt.sig0_func1_invoked, 0);
- CHECK(ctxt.sig0_func2_sum, 0);
- CHECK(ctxt.sig1_func_sum, 0);
+ CHK(ctxt.sig0_func1_invoked == 0);
+ CHK(ctxt.sig0_func2_sum == 0);
+ CHK(ctxt.sig1_func_sum == 0);
SIG_CONNECT_CLBK(&signals[SIG0], &clbk0_a);
SIG_CONNECT_CLBK(&signals[SIG0], &clbk0_b);
SIG_CONNECT_CLBK(&signals[SIG0], &clbk0_c);
SIG_BROADCAST(&signals[SIG0], clbk_T, ARG1(&ctxt));
- CHECK(ctxt.sig0_func1_invoked, 1);
- CHECK(ctxt.sig0_func2_sum, 11);
- CHECK(ctxt.sig1_func_sum, 0);
+ CHK(ctxt.sig0_func1_invoked == 1);
+ CHK(ctxt.sig0_func2_sum == 11);
+ CHK(ctxt.sig1_func_sum == 0);
CLBK_DISCONNECT(&clbk0_c);
ctxt.sig0_func1_invoked = 0;
ctxt.sig0_func2_sum = 0;
ctxt.sig1_func_sum = 0;
SIG_BROADCAST(&signals[SIG0], clbk_T, ARG1(&ctxt));
- CHECK(ctxt.sig0_func1_invoked, 1);
- CHECK(ctxt.sig0_func2_sum, 12);
- CHECK(ctxt.sig1_func_sum, 0);
+ CHK(ctxt.sig0_func1_invoked == 1);
+ CHK(ctxt.sig0_func2_sum == 12);
+ CHK(ctxt.sig1_func_sum == 0);
SIG_CONNECT_CLBK(&signals[SIG1], &clbk1_a);
SIG_BROADCAST(&signals[SIG0], clbk_T, ARG1(&ctxt));
- CHECK(ctxt.sig0_func1_invoked, 1);
- CHECK(ctxt.sig0_func2_sum, 24);
- CHECK(ctxt.sig1_func_sum, 0);
+ CHK(ctxt.sig0_func1_invoked == 1);
+ CHK(ctxt.sig0_func2_sum == 24);
+ CHK(ctxt.sig1_func_sum == 0);
SIG_BROADCAST(&signals[SIG1], clbk_T, ARG1(&ctxt));
- CHECK(ctxt.sig0_func1_invoked, 1);
- CHECK(ctxt.sig0_func2_sum, 24);
- CHECK(ctxt.sig1_func_sum, 2);
+ CHK(ctxt.sig0_func1_invoked == 1);
+ CHK(ctxt.sig0_func2_sum == 24);
+ CHK(ctxt.sig1_func_sum == 2);
SIG_CONNECT_CLBK(&signals[SIG1], &clbk1_b);
SIG_BROADCAST(&signals[SIG1], clbk_T, ARG1(&ctxt));
- CHECK(ctxt.sig0_func1_invoked, 1);
- CHECK(ctxt.sig0_func2_sum, 24);
- CHECK(ctxt.sig1_func_sum, 5);
+ CHK(ctxt.sig0_func1_invoked == 1);
+ CHK(ctxt.sig0_func2_sum == 24);
+ CHK(ctxt.sig1_func_sum == 5);
CLBK_INIT(&clbk2);
CLBK_SETUP(&clbk2, sig2_func, &clbk_data);
SIG_CONNECT_CLBK(&signals[SIG2], &clbk2);
- CHECK(clbk_data, 0);
+ CHK(clbk_data == 0);
SIG_BROADCAST(&signals[SIG2], clbk2_T, ARG0());
- CHECK(clbk_data, 0xDECAFBAD);
+ CHK(clbk_data == 0xDECAFBAD);
CLBK_DISCONNECT(&clbk2);
CLBK_INIT(&clbk3);
@@ -166,9 +166,9 @@ main(int argc, char** argv)
SIG_CONNECT_CLBK(&signals[SIG3], &clbk3);
clbk_data = 0;
SIG_BROADCAST(&signals[SIG3], clbk3_T, ARG3(3, 4.0f, 'a'));
- CHECK(clbk_data, 0xDECAFBAD);
+ CHK(clbk_data == 0xDECAFBAD);
- CHECK(MEM_ALLOCATED_SIZE(&mem_default_allocator), 0);
+ CHK(MEM_ALLOCATED_SIZE(&mem_default_allocator) == 0);
return 0;
}
diff --git a/src/test_str.c b/src/test_str.c
@@ -27,119 +27,119 @@ main(int argc, char** argv)
mem_init_proxy_allocator(&allocator_proxy, &mem_default_allocator);
str_init(&allocator_proxy, &str);
- CHECK(strcmp(str_get(&str), ""), 0);
- CHECK(str_len(&str), 0);
- CHECK(str_is_empty(&str), 1);
+ CHK(strcmp(str_get(&str), "") == 0);
+ CHK(str_len(&str) == 0);
+ CHK(str_is_empty(&str) == 1);
- CHECK(str_set(&str, "Foo"), RES_OK);
- CHECK(strcmp(str_get(&str), "Foo"), 0);
- CHECK(str_len(&str), strlen("Foo"));
- CHECK(str_is_empty(&str), 0);
+ CHK(str_set(&str, "Foo") == RES_OK);
+ CHK(strcmp(str_get(&str), "Foo") == 0);
+ CHK(str_len(&str) == strlen("Foo"));
+ CHK(str_is_empty(&str) == 0);
str_clear(&str);
- CHECK(strcmp(str_get(&str), ""), 0);
- CHECK(str_len(&str), 0);
+ CHK(strcmp(str_get(&str), "") == 0);
+ CHK(str_len(&str) == 0);
- CHECK(str_set(&str, __FILE__), RES_OK);
- CHECK(strcmp(str_get(&str), __FILE__), 0);
+ CHK(str_set(&str, __FILE__) == RES_OK);
+ CHK(strcmp(str_get(&str), __FILE__) == 0);
str_release(&str);
str_init(&allocator_proxy, &str);
- CHECK(strcmp(str_get(&str), ""), 0);
- CHECK(str_len(&str), 0);
-
- CHECK(str_set(&str, "Hello world!"), RES_OK);
- CHECK(strcmp(str_get(&str), "Hello world!"), 0);
- NCHECK(str_insert(&str, 13, " insert"), RES_OK);
- CHECK(str_insert(&str, 12, " insert"), RES_OK);
- CHECK(strcmp(str_get(&str), "Hello world! insert"), 0);
-
- CHECK(str_insert(&str, 6, "abcdefgh "), RES_OK);
- CHECK(strcmp(str_get(&str), "Hello abcdefgh world! insert"), 0);
- CHECK(str_insert(&str, 0, "ABC "), RES_OK);
- CHECK(strcmp(str_get(&str), "ABC Hello abcdefgh world! insert"), 0);
- CHECK(str_insert(&str, 11, "0123456789ABCDEF"), RES_OK);
- CHECK(strcmp(str_get(&str),
- "ABC Hello a0123456789ABCDEFbcdefgh world! insert"), 0);
- CHECK(str_len(&str),
+ CHK(strcmp(str_get(&str), "") == 0);
+ CHK(str_len(&str) == 0);
+
+ CHK(str_set(&str, "Hello world!") == RES_OK);
+ CHK(strcmp(str_get(&str), "Hello world!") == 0);
+ CHK(str_insert(&str, 13, " insert") != RES_OK);
+ CHK(str_insert(&str, 12, " insert") == RES_OK);
+ CHK(strcmp(str_get(&str), "Hello world! insert") == 0);
+
+ CHK(str_insert(&str, 6, "abcdefgh ") == RES_OK);
+ CHK(strcmp(str_get(&str), "Hello abcdefgh world! insert") == 0);
+ CHK(str_insert(&str, 0, "ABC ") == RES_OK);
+ CHK(strcmp(str_get(&str), "ABC Hello abcdefgh world! insert") == 0);
+ CHK(str_insert(&str, 11, "0123456789ABCDEF") == RES_OK);
+ CHK(strcmp(str_get(&str),
+ "ABC Hello a0123456789ABCDEFbcdefgh world! insert") == 0);
+ CHK(str_len(&str) ==
strlen("ABC Hello a0123456789ABCDEFbcdefgh world! insert"));
- CHECK(str_set(&str, "Hello world!"), RES_OK);
- CHECK(str_append(&str, " Append"), RES_OK);
- CHECK(strcmp(str_get(&str), "Hello world! Append"), 0);
- CHECK(str_append(&str, "!"), RES_OK);
- CHECK(strcmp(str_get(&str), "Hello world! Append!"), 0);
-
- NCHECK(str_insert_char(&str, 21, 'a'), RES_OK);
- CHECK(strcmp(str_get(&str), "Hello world! Append!"), 0);
- CHECK(str_insert_char(&str, 20, 'a'), RES_OK);
- CHECK(strcmp(str_get(&str), "Hello world! Append!a"), 0);
- CHECK(str_insert_char(&str, 0, '0'), RES_OK);
- CHECK(strcmp(str_get(&str), "0Hello world! Append!a"), 0);
- CHECK(str_insert_char(&str, 13, 'A'), RES_OK);
- CHECK(strcmp(str_get(&str), "0Hello world!A Append!a"), 0);
-
- CHECK(str_append_char(&str, 'z'), RES_OK);
- CHECK(strcmp(str_get(&str), "0Hello world!A Append!az"), 0);
-
- CHECK(str_reserve(&str, 128), RES_OK);
- CHECK(str_reserve(&str, 0), RES_OK);
- CHECK(strcmp(str_get(&str), "0Hello world!A Append!az"), 0);
-
- CHECK(str_insert_char(&str, 13, '\0'), RES_OK);
- CHECK(strcmp(str_get(&str), "0Hello world!"), 0);
- CHECK(str_len(&str), strlen("0Hello world!"));
- CHECK(str_append_char(&str, '\0'), RES_OK);
- CHECK(strcmp(str_get(&str), "0Hello world!"), 0);
- CHECK(str_len(&str), strlen("0Hello world!"));
+ CHK(str_set(&str, "Hello world!") == RES_OK);
+ CHK(str_append(&str, " Append") == RES_OK);
+ CHK(strcmp(str_get(&str), "Hello world! Append") == 0);
+ CHK(str_append(&str, "!") == RES_OK);
+ CHK(strcmp(str_get(&str), "Hello world! Append!") == 0);
+
+ CHK(str_insert_char(&str, 21, 'a') != RES_OK);
+ CHK(strcmp(str_get(&str), "Hello world! Append!") == 0);
+ CHK(str_insert_char(&str, 20, 'a') == RES_OK);
+ CHK(strcmp(str_get(&str), "Hello world! Append!a") == 0);
+ CHK(str_insert_char(&str, 0, '0') == RES_OK);
+ CHK(strcmp(str_get(&str), "0Hello world! Append!a") == 0);
+ CHK(str_insert_char(&str, 13, 'A') == RES_OK);
+ CHK(strcmp(str_get(&str), "0Hello world!A Append!a") == 0);
+
+ CHK(str_append_char(&str, 'z') == RES_OK);
+ CHK(strcmp(str_get(&str), "0Hello world!A Append!az") == 0);
+
+ CHK(str_reserve(&str, 128) == RES_OK);
+ CHK(str_reserve(&str, 0) == RES_OK);
+ CHK(strcmp(str_get(&str), "0Hello world!A Append!az") == 0);
+
+ CHK(str_insert_char(&str, 13, '\0') == RES_OK);
+ CHK(strcmp(str_get(&str), "0Hello world!") == 0);
+ CHK(str_len(&str) == strlen("0Hello world!"));
+ CHK(str_append_char(&str, '\0') == RES_OK);
+ CHK(strcmp(str_get(&str), "0Hello world!") == 0);
+ CHK(str_len(&str) == strlen("0Hello world!"));
str_init(&allocator_proxy, &str2);
str_copy(&str2, &str);
- CHECK(strcmp(str_cget(&str2), "0Hello world!"), 0);
- CHECK(strcmp(str_cget(&str), "0Hello world!"), 0);
+ CHK(strcmp(str_cget(&str2), "0Hello world!") == 0);
+ CHK(strcmp(str_cget(&str), "0Hello world!") == 0);
- CHECK(str_eq(&str, &str2), 1);
+ CHK(str_eq(&str, &str2) == 1);
- CHECK(str_hash(&str), str_hash(&str2));
+ CHK(str_hash(&str) == str_hash(&str2));
str_clear(&str2);
- NCHECK(str_hash(&str), str_hash(&str2));
+ CHK(str_hash(&str) != str_hash(&str2));
str_copy_and_clear(&str2, &str);
- CHECK(strcmp(str_cget(&str2), "0Hello world!"), 0);
- CHECK(str_len(&str2), strlen(str_cget(&str2)));
- CHECK(str_len(&str), 0);
+ CHK(strcmp(str_cget(&str2), "0Hello world!") == 0);
+ CHK(str_len(&str2) == strlen(str_cget(&str2)));
+ CHK(str_len(&str) == 0);
str_copy_and_release(&str, &str2);
- CHECK(strcmp(str_cget(&str), "0Hello world!"), 0);
+ CHK(strcmp(str_cget(&str), "0Hello world!") == 0);
str_init(&allocator_proxy, &str2);
str_set(&str2, "ABC Hello a0123456789ABCDEFbcdefgh world! insert");
- CHECK(str_eq(&str, &str2), 0);
- CHECK(str_cmp(&str, &str2), strcmp(str_cget(&str), str_cget(&str2)));
+ CHK(str_eq(&str, &str2) == 0);
+ CHK(str_cmp(&str, &str2) == strcmp(str_cget(&str), str_cget(&str2)));
- NCHECK(str_hash(&str), str_hash(&str2));
+ CHK(str_hash(&str) != str_hash(&str2));
str_copy_and_clear(&str, &str2);
- CHECK(0, strcmp
+ CHK(!strcmp
(str_cget(&str), "ABC Hello a0123456789ABCDEFbcdefgh world! insert"));
- CHECK(str_len(&str), strlen(str_cget(&str)));
+ CHK(str_len(&str) == strlen(str_cget(&str)));
str_set(&str2, "Hello world!");
- CHECK(strcmp(str_cget(&str2), "Hello world!"), 0);
+ CHK(strcmp(str_cget(&str2), "Hello world!") == 0);
str_clear(&str2);
str_copy_and_clear(&str, &str2);
- CHECK(str_len(&str), 0);
- CHECK(str_len(&str2), 0);
- CHECK(strlen(str_cget(&str)), 0);
+ CHK(str_len(&str) == 0);
+ CHK(str_len(&str2) == 0);
+ CHK(strlen(str_cget(&str)) == 0);
str_copy_and_release(&str2, &str2);
str_set(&str, "Hello World!");
str_copy_and_clear(&str, &str);
- CHECK(str_len(&str), 0);
+ CHK(str_len(&str) == 0);
str_release(&str);
check_memory_allocator(&allocator_proxy);
mem_shutdown_proxy_allocator(&allocator_proxy);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_stretchy_array.c b/src/test_stretchy_array.c
@@ -21,33 +21,33 @@ test_double(void)
{
double* array = NULL;
- CHECK(sa_size(array), 0);
+ CHK(sa_size(array) == 0);
sa_clear(array);
- CHECK(sa_add(array, 4), array);
- CHECK(sa_size(array), 4);
+ CHK(sa_add(array, 4) == array);
+ CHK(sa_size(array) == 4);
array[0] = PI;
array[1] = PI;
array[2] = PI;
array[3] = PI;
- CHECK(sa_last(array), PI);
+ CHK(sa_last(array) == PI);
sa_push(array, 1.2345);
- CHECK(sa_last(array), 1.2345);
+ CHK(sa_last(array) == 1.2345);
sa_push(array, 6.7890);
- CHECK(sa_last(array), 6.7890);
+ CHK(sa_last(array) == 6.7890);
- CHECK(array[0], PI);
- CHECK(array[1], PI);
- CHECK(array[2], PI);
- CHECK(array[3], PI);
- CHECK(array[4], 1.2345);
- CHECK(array[5], 6.7890);
- CHECK(sa_size(array), 6);
+ CHK(array[0] == PI);
+ CHK(array[1] == PI);
+ CHK(array[2] == PI);
+ CHK(array[3] == PI);
+ CHK(array[4] == 1.2345);
+ CHK(array[5] == 6.7890);
+ CHK(sa_size(array) == 6);
sa_clear(array);
- CHECK(sa_size(array), 0);
+ CHK(sa_size(array) == 0);
sa_release(array);
}
@@ -59,38 +59,38 @@ test_int(void)
int* p;
size_t i;
- CHECK(sa_size(array), 0);
+ CHK(sa_size(array) == 0);
FOR_EACH(i, 0, 1024)
sa_push(array, (int)i);
- CHECK(sa_size(array), 1024);
+ CHK(sa_size(array) == 1024);
FOR_EACH(i, 0, 1024)
- CHECK(array[i], (int)i);
+ CHK(array[i] == (int)i);
- CHECK(sa_last(array), 1023);
+ CHK(sa_last(array) == 1023);
p = sa_add(array, 32);
- CHECK(sa_size(array), 1056);
+ CHK(sa_size(array) == 1056);
FOR_EACH(i, 0, 32)
p[i] = (int)i;
- CHECK(sa_last(array), 31);
+ CHK(sa_last(array) == 31);
FOR_EACH(i, 0, 32)
array[1024 + i] = (int)i;
sa_clear(array);
- CHECK(sa_size(array), 0);
+ CHK(sa_size(array) == 0);
p = sa_add(array, 16);
- CHECK(p, array);
- CHECK(sa_size(array), 16);
+ CHK(p == array);
+ CHK(sa_size(array) == 16);
FOR_EACH(i, 0, 16)
p[i] = -(int)i;
FOR_EACH(i, 0, 16)
- CHECK(array[i], -(int)i);
+ CHK(array[i] == -(int)i);
sa_release(array);
}
@@ -101,6 +101,6 @@ main(int argc, char** argv)
(void)argc, (void)argv;
test_int();
test_double();
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_time.c b/src/test_time.c
@@ -26,16 +26,16 @@ main(int argc, char** argv)
int64_t i = 0;
(void)argc, (void)argv;
- CHECK(time_current(&start), &start);
+ CHK(time_current(&start) == &start);
FOR_EACH(i, 0, INT32_MAX / 64); /* Active wait */
- CHECK(time_current(&end), &end);
+ CHK(time_current(&end) == &end);
- CHECK(time_sub(&res, &end, &start), &res);
+ CHK(time_sub(&res, &end, &start) == &res);
time = time_val(&res, TIME_NSEC);
- CHECK(time >= 0, 1 );
- CHECK(time_val(&res, TIME_USEC), time / 1000);
- CHECK(time_val(&res, TIME_MSEC), time / 1000000);
- CHECK(time_val(&res, TIME_SEC), time / 1000000000);
+ CHK(time >= 0);
+ CHK(time_val(&res, TIME_USEC) == time / 1000);
+ CHK(time_val(&res, TIME_MSEC) == time / 1000000);
+ CHK(time_val(&res, TIME_SEC) == time / 1000000000);
time_dump
(&res, TIME_SEC|TIME_MSEC|TIME_USEC, NULL, dump, sizeof(dump));
@@ -43,23 +43,23 @@ main(int argc, char** argv)
time_dump(&res, TIME_ALL, NULL, dump, sizeof(dump));
printf(">>> %s.\n", dump);
- CHECK(time_add(&res, &res, &res), &res);
- CHECK(time_val(&res, TIME_NSEC), 2*time);
+ CHK(time_add(&res, &res, &res) == &res);
+ CHK(time_val(&res, TIME_NSEC) == 2*time);
time_dump(&res, TIME_ALL, NULL, dump, sizeof(dump));
printf(">>> %s.\n", dump);
time = time_val(&res, TIME_NSEC);
- CHECK(time_zero(&start), &start);
- CHECK(time_val(&start, TIME_NSEC), 0);
- CHECK(time_add(&res, &res, &start), &res);
- CHECK(time_val(&res, TIME_NSEC), time);
- CHECK(time_add(&start, &res, &start), &start);
- CHECK(time_val(&start, TIME_NSEC), time);
- CHECK(time_sub(&res, time_zero(&start), &res), &res);
- CHECK(time_val(&res, TIME_NSEC), -time);
+ CHK(time_zero(&start) == &start);
+ CHK(time_val(&start, TIME_NSEC) == 0);
+ CHK(time_add(&res, &res, &start) == &res);
+ CHK(time_val(&res, TIME_NSEC) == time);
+ CHK(time_add(&start, &res, &start) == &start);
+ CHK(time_val(&start, TIME_NSEC) == time);
+ CHK(time_sub(&res, time_zero(&start), &res) == &res);
+ CHK(time_val(&res, TIME_NSEC) == -time);
- CHECK(time_sub(&res, &end, &end), &res);
- CHECK(time_val(&res, TIME_NSEC), 0);
+ CHK(time_sub(&res, &end, &end) == &res);
+ CHK(time_val(&res, TIME_NSEC) == 0);
time_dump(&res, TIME_ALL, NULL, dump, sizeof(dump));
printf(">>> %s.\n", dump);
time_dump(&res, 0, NULL, dump, sizeof(dump));
