summaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/array.c427
-rw-r--r--tests/array.h2
-rw-r--r--tests/array_typed.c223
-rw-r--r--tests/array_typed.h2
-rw-r--r--tests/common.h12
-rw-r--r--tests/lib.c132
-rw-r--r--tests/main.c27
-rw-r--r--tests/ring_buffer.c177
-rw-r--r--tests/str.c358
-rw-r--r--tests/str.h2
10 files changed, 802 insertions, 560 deletions
diff --git a/tests/array.c b/tests/array.c
index 08d29eb..6cc88c6 100644
--- a/tests/array.c
+++ b/tests/array.c
@@ -3,23 +3,22 @@
#include <al/random.h>
#include "array.h"
-
-struct test_t {
- u32 i;
-};
+#include "common.h"
static bool array_test_init(void)
{
AL_TEST_START("array_init");
- array(u32) arr;
- al_array_init(arr);
+ array(u32) ints;
+ al_array_init(ints);
- AL_TEST_EQ((void *)arr.data, NULL, ptr);
- AL_TEST_EQ(arr.alloc, 0, u32);
- AL_TEST_EQ(arr.size, 0, u32);
+ AL_TEST_EQ(ints.count, 0, u32);
+ AL_TEST_EQ(ints.alloc, 0, u32);
+ AL_TEST_EQ(ints.data, NULL, ptr);
- al_array_free(arr);
+ al_array_free(ints);
+ // Not a double-free.
+ al_array_free(ints);
AL_TEST_END();
}
@@ -28,25 +27,22 @@ static bool array_test_reserve(void)
{
AL_TEST_START("array_reserve");
- array(u32) arr;
- al_array_init(arr);
-
- al_array_reserve(arr, 64);
-
- AL_TEST_NEQ((void *)arr.data, NULL, ptr);
- AL_TEST_EQ(arr.alloc, 64, u32);
+ array(u32) ints;
+ al_array_init(ints);
- al_array_reserve(arr, 128);
+ al_array_reserve(ints, 64);
+ AL_TEST_EQ(ints.alloc, 256, u32);
+ AL_TEST_NEQ(ints.data, NULL, ptr);
- AL_TEST_NEQ((void *)arr.data, NULL, ptr);
- AL_TEST_EQ(arr.alloc, 128, u32);
+ al_array_reserve(ints, 128);
+ AL_TEST_EQ(ints.alloc, 512, u32);
+ AL_TEST_NEQ(ints.data, NULL, ptr);
- al_array_reserve(arr, 129);
+ al_array_reserve(ints, 129);
+ AL_TEST_EQ(ints.alloc, 1024, u32);
+ AL_TEST_NEQ(ints.data, NULL, ptr);
- AL_TEST_NEQ((void *)arr.data, NULL, ptr);
- AL_TEST_EQ(arr.alloc, 256, u32);
-
- al_array_free(arr);
+ al_array_free(ints);
AL_TEST_END();
}
@@ -55,15 +51,19 @@ static bool array_test_at(void)
{
AL_TEST_START("array_at");
- array(u32) arr;
- al_array_init(arr);
+ array(u32) ints;
+ al_array_init(ints);
u32 x = 5;
- al_array_push(arr, x);
+ al_array_push(ints, x);
+ al_array_push(ints, (u32)4);
- AL_TEST_EQ(al_array_at(arr, 0), 5, u32);
+ AL_TEST_EQ(al_array_at(ints, 0), 5, u32);
+ AL_TEST_EQ(al_array_at(ints, 1), 4, u32);
+ AL_TEST_EQ(ints.count, 2, u32);
+ AL_TEST_EQ(ints.alloc, 8, u32);
- al_array_free(arr);
+ al_array_free(ints);
AL_TEST_END();
}
@@ -72,39 +72,69 @@ static bool array_test_last(void)
{
AL_TEST_START("array_last");
- array(u32) arr;
- al_array_init(arr);
+ array(u32) ints;
+ al_array_init(ints);
u32 x = 1, y = 2, z = 3;
+ al_array_push(ints, x);
+ al_array_push(ints, y);
+ al_array_push(ints, z);
- al_array_push(arr, x);
- al_array_push(arr, y);
- al_array_push(arr, z);
-
- AL_TEST_EQ(al_array_last(arr), 3, u32);
+ AL_TEST_EQ(al_array_last(ints), z, u32);
+ AL_TEST_EQ(ints.count, 3, u32);
+ AL_TEST_EQ(ints.alloc, 16, u32);
- al_array_free(arr);
+ al_array_free(ints);
AL_TEST_END();
}
+AL_UNUSED_FUNCTION_PUSH
+
+static s32 uint8_compare(const void *a, const void *b)
+{
+ if (*(u8 *)a < *(u8 *)b) return 1;
+ else if (*(u8 *)b < *(u8 *)a) return -1;
+ return 0;
+}
+
+AL_UNUSED_FUNCTION_POP
+
static bool array_test_push(void)
{
AL_TEST_START("array_push");
- array(u32) arr;
- al_array_init(arr);
+ array(u8) bytes;
+ al_array_init(bytes);
- u32 x = 4, y = 5;
+ u8 increment = 0;
+ for (u32 i = 0; i < MAX_ALLOC_32; i++) {
+ al_array_push(bytes, (increment = (u8)al_add_wrap(increment, 2, UINT8_MAX)));
+ }
+ AL_TEST_EQ(bytes.count, MAX_ALLOC_32, u32);
+ AL_TEST_EQ(bytes.alloc, MAX_ALLOC_32, u32);
+
+ AL_TEST_EQ(&al_array_at(bytes, MAX_ALLOC_32 - 1), &al_array_last(bytes), ptr);
- al_array_push(arr, x);
- al_array_push(arr, y);
+ AL_TEST_EQ(al_array_at(bytes, 3535), 187, u8);
+ AL_TEST_EQ(al_array_at(bytes, 2348151), 224, u8);
+ AL_TEST_EQ(al_array_at(bytes, 75134), 75, u8);
+ AL_TEST_EQ(al_array_at(bytes, 1735095), 152, u8);
+ AL_TEST_EQ(al_array_at(bytes, 191236099), 250, u8);
+ if (MAX_ALLOC_32 > INT32_MAX) {
+ AL_TEST_EQ(al_array_at(bytes, 3116282697), 236, u8);
+ AL_TEST_EQ(al_array_at(bytes, 2923789681), 199, u8);
+ }
- AL_TEST_EQ(arr.size, 2, u32);
- AL_TEST_EQ(al_array_at(arr, 0), x, u32);
- AL_TEST_EQ(al_array_at(arr, 1), y, u32);
+#if 0 // This is very slow.
+ al_array_sort(bytes, u8, uint8_compare);
+ AL_TEST_LTE(al_array_at(bytes, MAX_ALLOC_32 - 1), al_array_at(bytes, MAX_ALLOC_32 - 26000000), u8);
+ AL_TEST_LTE(al_array_at(bytes, MAX_ALLOC_32 - 27000000), al_array_at(bytes, MAX_ALLOC_32 - 52000000), u8);
+ AL_TEST_LTE(al_array_at(bytes, MAX_ALLOC_32 - 53000000), al_array_at(bytes, MAX_ALLOC_32 - 78000000), u8);
+ AL_TEST_LTE(al_array_at(bytes, MAX_ALLOC_32 - 79000000), al_array_at(bytes, MAX_ALLOC_32 - 104000000), u8);
+#endif
- al_array_free(arr);
+ al_array_free(bytes);
AL_TEST_END();
}
@@ -113,27 +143,23 @@ static bool array_test_pop(void)
{
AL_TEST_START("array_pop");
- array(u32) arr;
- al_array_init(arr);
+ array(u32) ints;
+ al_array_init(ints);
u32 x = 4, y = 5;
+ al_array_push(ints, x);
+ al_array_push(ints, y);
- al_array_push(arr, x);
- al_array_push(arr, y);
-
- u32 rx, ry;
-
- ry = al_array_pop(arr);
+ u32 ry = al_array_pop(ints);
+ AL_TEST_EQ(ints.count, 1, u32);
- AL_TEST_EQ(arr.size, 1, u32);
+ u32 rx = al_array_pop(ints);
+ AL_TEST_EQ(ints.count, 0, u32);
- rx = al_array_pop(arr);
-
- AL_TEST_EQ(arr.size, 0, u32);
AL_TEST_EQ(rx, x, u32);
AL_TEST_EQ(ry, y, u32);
- al_array_free(arr);
+ al_array_free(ints);
AL_TEST_END();
}
@@ -142,28 +168,28 @@ static bool array_test_remove_at(void)
{
AL_TEST_START("array_remove_at");
- array(u32) arr;
- al_array_init(arr);
- al_array_reserve(arr, 12);
+ array(u32) ints;
+ al_array_init(ints);
+ al_array_reserve(ints, 12);
u32 array_before[] = { 1, 2, 3, 4, 5, 6 };
u32 array_after[] = { 2, 3, 4 };
- for (u32 i = 0; i < sizeof(array_before) / sizeof(u32); i++) {
- al_array_push(arr, array_before[i]);
+ for (u32 i = 0; i < ARRAY_SIZE(array_before); i++) {
+ al_array_push(ints, array_before[i]);
}
- al_array_remove_at(arr, 0);
- al_array_remove_at(arr, 3);
- al_array_remove_at(arr, 3);
+ al_array_remove_at(ints, 0);
+ al_array_remove_at(ints, 3);
+ al_array_remove_at(ints, 3);
- AL_TEST_EQ(arr.size, (u32)(sizeof(array_after) / sizeof(u32)), u32);
+ AL_TEST_EQ(ints.count, ARRAY_SIZE(array_after), u32);
- for (u32 i = 0; i < sizeof(array_after) / sizeof(u32); i++) {
- AL_TEST_EQ(al_array_at(arr, i), array_after[i], u32);
+ for (u32 i = 0; i < ARRAY_SIZE(array_after); i++) {
+ AL_TEST_EQ(al_array_at(ints, i), array_after[i], u32);
}
- al_array_free(arr);
+ al_array_free(ints);
AL_TEST_END();
}
@@ -172,31 +198,33 @@ static bool array_test_remove_range(void)
{
AL_TEST_START("array_remove_range");
- array(u32) arr;
- al_array_init(arr);
- al_array_reserve(arr, 12);
+ array(u32) ints;
+ al_array_init(ints);
+ al_array_reserve(ints, 12);
u32 array_before[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
u32 array_after[] = { 1, 3, 4, 7, 8, 11 };
- for (u32 i = 0; i < sizeof(array_before) / sizeof(u32); i++) {
- al_array_push(arr, array_before[i]);
+ for (u32 i = 0; i < ARRAY_SIZE(array_before); i++) {
+ al_array_push(ints, array_before[i]);
}
- al_array_remove_range(arr, 1, 2);
- al_array_remove_range(arr, 3, 5);
- AL_TEST_EQ(arr.size, 9, u32);
- al_array_remove_range(arr, 5, 7);
- AL_TEST_EQ(arr.size, 7, u32);
- al_array_remove_range(arr, 6, 7);
+ al_array_remove_range(ints, 1, 2);
+ al_array_remove_range(ints, 3, 5);
+ AL_TEST_EQ(ints.count, 9, u32);
+
+ al_array_remove_range(ints, 5, 7);
+ AL_TEST_EQ(ints.count, 7, u32);
+
+ al_array_remove_range(ints, 6, 7);
- AL_TEST_EQ(arr.size, (u32)(sizeof(array_after) / sizeof(u32)), u32);
+ AL_TEST_EQ(ints.count, ARRAY_SIZE(array_after), u32);
- for (u32 i = 0; i < sizeof(array_after) / sizeof(u32); i++) {
- AL_TEST_EQ(al_array_at(arr, i), array_after[i], u32);
+ for (u32 i = 0; i < ARRAY_SIZE(array_after); i++) {
+ AL_TEST_EQ(al_array_at(ints, i), array_after[i], u32);
}
- al_array_free(arr);
+ al_array_free(ints);
AL_TEST_END();
}
@@ -205,33 +233,32 @@ static bool array_test_pop_at(void)
{
AL_TEST_START("array_pop_at");
- array(u32) arr;
- al_array_init(arr);
+ array(u32) ints;
+ al_array_init(ints);
u32 array_before[] = { 1, 2, 3, 4, 5, 6 };
u32 array_after[] = { 2, 3, 4 };
- for (u32 i = 0; i < sizeof(array_before) / sizeof(u32); i++) {
- al_array_push(arr, array_before[i]);
+ for (u32 i = 0; i < ARRAY_SIZE(array_before); i++) {
+ al_array_push(ints, array_before[i]);
}
u32 x, y, z;
-
- al_array_pop_at(arr, 0, x);
- al_array_pop_at(arr, 3, y);
- al_array_pop_at(arr, 3, z);
+ al_array_pop_at(ints, 0, x);
+ al_array_pop_at(ints, 3, y);
+ al_array_pop_at(ints, 3, z);
AL_TEST_EQ(x, array_before[0], u32);
AL_TEST_EQ(y, array_before[4], u32);
AL_TEST_EQ(z, array_before[5], u32);
- AL_TEST_EQ(arr.size, (u32)(sizeof(array_after) / sizeof(u32)), u32);
+ AL_TEST_EQ(ints.count, ARRAY_SIZE(array_after), u32);
- for (u32 i = 0; i < sizeof(array_after) / sizeof(u32); i++) {
- AL_TEST_EQ(al_array_at(arr, i), array_after[i], u32);
+ for (u32 i = 0; i < ARRAY_SIZE(array_after); i++) {
+ AL_TEST_EQ(al_array_at(ints, i), array_after[i], u32);
}
- al_array_free(arr);
+ al_array_free(ints);
AL_TEST_END();
}
@@ -240,39 +267,36 @@ static bool array_test_insert(void)
{
AL_TEST_START("array_insert");
- array(struct test_t) arr;
- al_array_init(arr);
-
- struct test_t x = {
- .i = 5
- };
+ array(struct test_t) objects;
+ al_array_init(objects);
- struct test_t y = {
- .i = 5
- };
+ struct test_t x = { .d = 5 };
+ struct test_t y = { .d = 2 };
+ struct test_t z = { .d = 6 };
- struct test_t z = {
- .i = 5
- };
+ al_array_push(objects, (struct test_t){ .d = 7 });
+ al_array_push(objects, (struct test_t){ .d = 9 });
+ al_array_push(objects, (struct test_t){ .d = 444 });
- al_array_insert(arr, 1, x);
- al_array_insert(arr, 0, y);
- al_array_insert(arr, 1, z);
+ al_array_insert(objects, 1, x);
+ al_array_insert(objects, 0, y);
+ al_array_insert(objects, 1, z);
- AL_TEST_EQ(al_array_at(arr, 3).i, x.i, u32);
- AL_TEST_EQ(al_array_at(arr, 0).i, y.i, u32);
- AL_TEST_EQ(al_array_at(arr, 1).i, z.i, u32);
+ AL_TEST_EQ(al_array_at(objects, 3).d, x.d, u32);
+ AL_TEST_EQ(al_array_at(objects, 0).d, y.d, u32);
+ AL_TEST_EQ(al_array_at(objects, 1).d, z.d, u32);
- AL_TEST_EQ(arr.size, 4, u32);
+ AL_TEST_EQ(objects.count, 6, u32);
- al_array_remove_at(arr, 3);
+ al_array_remove_at(objects, 3);
- AL_TEST_EQ(arr.size, 3, u32);
+ AL_TEST_EQ(objects.count, 5, u32);
- AL_TEST_EQ(al_array_at(arr, 0).i, y.i, u32);
- AL_TEST_EQ(al_array_at(arr, 1).i, z.i, u32);
+ AL_TEST_NEQ(al_array_at(objects, 3).d, x.d, u32);
+ AL_TEST_EQ(al_array_at(objects, 0).d, y.d, u32);
+ AL_TEST_EQ(al_array_at(objects, 1).d, z.d, u32);
- al_array_free(arr);
+ al_array_free(objects);
AL_TEST_END();
}
@@ -281,75 +305,75 @@ static bool array_test_foreach(void)
{
AL_TEST_START("array_foreach");
- array(u32) arr;
- al_array_init(arr);
+ array(u32) ints;
+ al_array_init(ints);
- al_array_push(arr, 0);
- al_array_push(arr, 1);
- al_array_push(arr, 2);
- al_array_push(arr, 3);
- al_array_push(arr, 4);
- al_array_push(arr, 5);
+ al_array_push(ints, (u32)0);
+ al_array_push(ints, (u32)1);
+ al_array_push(ints, (u32)2);
+ al_array_push(ints, (u32)3);
+ al_array_push(ints, (u32)4);
+ al_array_push(ints, (u32)5);
u32 iter0;
- al_array_foreach(arr, i, iter0) {
+ al_array_foreach(ints, i, iter0) {
AL_TEST_EQ(iter0, i, u32);
}
u32 iter1;
- al_array_foreach_rev(arr, i, iter1) {
+ al_array_foreach_rev(ints, i, iter1) {
AL_TEST_EQ(iter1, i, u32);
}
u32 *ptr0;
- al_array_foreach_ptr(arr, i, ptr0) {
+ al_array_foreach_ptr(ints, i, ptr0) {
AL_TEST_EQ(*ptr0, i, u32);
}
u32 iter2;
- al_array_foreach_rev(arr, i, iter2) {
+ al_array_foreach_rev(ints, i, iter2) {
AL_TEST_EQ(iter2, i, u32);
- al_array_remove_at(arr, i);
+ al_array_remove_at(ints, i);
}
- AL_TEST_EQ(arr.size, 0, u32);
+ AL_TEST_EQ(ints.count, 0, u32);
- al_array_push(arr, 0);
- al_array_push(arr, 1);
- al_array_push(arr, 2);
- al_array_push(arr, 3);
- al_array_push(arr, 4);
- al_array_push(arr, 5);
- al_array_push(arr, 6);
- al_array_push(arr, 7);
- al_array_push(arr, 8);
- al_array_push(arr, 9);
+ al_array_push(ints, (u32)0);
+ al_array_push(ints, (u32)1);
+ al_array_push(ints, (u32)2);
+ al_array_push(ints, (u32)3);
+ al_array_push(ints, (u32)4);
+ al_array_push(ints, (u32)5);
+ al_array_push(ints, (u32)6);
+ al_array_push(ints, (u32)7);
+ al_array_push(ints, (u32)8);
+ al_array_push(ints, (u32)9);
- u32 iter3, count0 = 0;
- al_array_foreach(arr, i, iter3) {
- AL_TEST_EQ(iter3, count0, u32);
- count0++;
- al_array_remove_at_iter(arr, i);
+ u32 iter3, count = 0;
+ al_array_foreach(ints, i, iter3) {
+ AL_TEST_EQ(iter3, count, u32);
+ count++;
+ al_array_remove_at_iter(ints, i);
}
- al_array_push(arr, 0);
- al_array_push(arr, 1);
- al_array_push(arr, 2);
- al_array_push(arr, 3);
- al_array_push(arr, 4);
- al_array_push(arr, 5);
- al_array_push(arr, 6);
- al_array_push(arr, 7);
- al_array_push(arr, 8);
- al_array_push(arr, 9);
+ al_array_push(ints, (u32)0);
+ al_array_push(ints, (u32)1);
+ al_array_push(ints, (u32)2);
+ al_array_push(ints, (u32)3);
+ al_array_push(ints, (u32)4);
+ al_array_push(ints, (u32)5);
+ al_array_push(ints, (u32)6);
+ al_array_push(ints, (u32)7);
+ al_array_push(ints, (u32)8);
+ al_array_push(ints, (u32)9);
u32 iter4;
- al_array_foreach(arr, i, iter4) {
+ al_array_foreach(ints, i, iter4) {
AL_TEST_EQ(iter4, i + i, u32);
- al_array_remove_at(arr, i);
+ al_array_remove_at(ints, i);
}
- al_array_free(arr);
+ al_array_free(ints);
AL_TEST_END();
}
@@ -361,28 +385,81 @@ static s32 int32_compare(const void *a, const void *b)
return 0;
}
+static s32 int32_compare_reverse(const void *a, const void *b)
+{
+ if (*(s32 *)a < *(s32 *)b) return -1;
+ else if (*(s32 *)b < *(s32 *)a) return 1;
+ return 0;
+}
+
+static inline s64 sum_of_array(s32 *data, u32 count)
+{
+ s64 sum = 0;
+ while (count-- > 0) {
+ sum += *data++;
+ }
+ return sum;
+}
+
static bool array_test_sort(void)
{
AL_TEST_START("array_sort");
- array(s32) arr;
- al_array_init(arr);
+ array(s32) ints;
+ al_array_init(ints);
+
+ al_array_push(ints, 0);
+ al_array_push(ints, 1);
+ al_array_push(ints, 2);
+ al_array_push(ints, 3);
+ al_array_push(ints, 4);
+ al_array_push(ints, 0);
+ al_array_push(ints, 99);
+ AL_TEST_EQ(sum_of_array(ints.data, ints.count), 109, s64);
+
+ s32 end = al_rand() % 4000;
+ for (s32 i = 0; i < end; i++) {
+ al_array_push(ints, (al_rand() % 9001) - 9000);
+ }
+
+ s64 before_sort_sum = sum_of_array(ints.data, ints.count);
+ al_array_sort(ints, s32, int32_compare);
+ AL_TEST_EQ(sum_of_array(ints.data, ints.count), before_sort_sum, s64);
+
+ for (u32 i = 1; i < ints.count; i++) {
+ AL_TEST_GTE(al_array_at(ints, i - 1), al_array_at(ints, i), s32);
+ }
- s32 end = al_rand() % 2000;
+ end = al_rand() % 4000;
for (s32 i = 0; i < end; i++) {
- al_array_push(arr, al_rand());
+ al_array_push(ints, (al_rand() % 90001) - 90000);
}
- al_array_sort(arr, s32, int32_compare);
+ before_sort_sum = sum_of_array(ints.data, ints.count);
+ al_array_sort(ints, s32, int32_compare_reverse);
+ AL_TEST_EQ(sum_of_array(ints.data, ints.count), before_sort_sum, s64);
- for (u32 i = 1; i < arr.size; i++) {
- AL_TEST_GTE(al_array_at(arr, i - 1), al_array_at(arr, i), s32);
+ for (u32 i = 1; i < ints.count; i++) {
+ AL_TEST_LTE(al_array_at(ints, i - 1), al_array_at(ints, i), s32);
+ }
+
+ end = al_rand() % 4000;
+ for (s32 i = 0; i < end; i++) {
+ al_array_push(ints, (al_rand() % 900001) - 900000);
+ }
+
+ before_sort_sum = sum_of_array(ints.data, ints.count);
+ al_array_sort(ints, s32, int32_compare);
+ AL_TEST_EQ(sum_of_array(ints.data, ints.count), before_sort_sum, s64);
+
+ for (u32 i = 1; i < ints.count; i++) {
+ AL_TEST_GTE(al_array_at(ints, i - 1), al_array_at(ints, i), s32);
}
AL_TEST_END();
}
-bool array_tests_run(void)
+bool array_tests_run(u32 skip_mask)
{
AL_TEST_START_GROUP("array");
@@ -390,7 +467,9 @@ bool array_tests_run(void)
AL_TEST_RUN(array_test_reserve);
AL_TEST_RUN(array_test_at);
AL_TEST_RUN(array_test_last);
- AL_TEST_RUN(array_test_push);
+ if (skip_mask & AL_TESTS_RUN_LIMITS) {
+ AL_TEST_RUN(array_test_push);
+ }
AL_TEST_RUN(array_test_pop);
AL_TEST_RUN(array_test_remove_at);
AL_TEST_RUN(array_test_remove_range);
diff --git a/tests/array.h b/tests/array.h
index 881f936..8416bf2 100644
--- a/tests/array.h
+++ b/tests/array.h
@@ -3,6 +3,6 @@
#include <al/types.h>
-bool array_tests_run(void);
+bool array_tests_run(u32 skip_mask);
#endif // _AL_ARRAY_TESTS_H
diff --git a/tests/array_typed.c b/tests/array_typed.c
index edaa52b..f61634d 100644
--- a/tests/array_typed.c
+++ b/tests/array_typed.c
@@ -2,28 +2,32 @@
#include <al/array_typed.h>
#include "array_typed.h"
+#include "common.h"
-struct test_t {
- u32 i;
-};
+AL_UNUSED_FUNCTION_PUSH
AL_ARRAY_INLINE_STORAGE_DEFINE(u32, u32, 64)
AL_ARRAY_DEFINE(u32, u32)
+AL_ARRAY_DEFINE(u8, u8)
AL_ARRAY_INLINE_STORAGE_DEFINE(test_t, struct test_t, 16)
+AL_UNUSED_FUNCTION_POP
+
static bool array_test_init(void)
{
AL_TEST_START("array_init");
- array(u32, 64) arr;
- al_array_init(u32, 64)(&arr);
+ array(u32, 64) ints;
+ al_array_init(u32, 64)(&ints);
- AL_TEST_EQ((void *)arr.data, NULL, ptr);
- AL_TEST_EQ(arr.alloc, 64, u32);
- AL_TEST_EQ(arr.size, 0, u32);
- AL_TEST_EQ(sizeof(arr.inline_data), 64 * sizeof(u32), size_t);
+ AL_TEST_EQ(ints.count, 0, u32);
+ AL_TEST_EQ(ints.alloc, 256, u32);
+ AL_TEST_EQ(ints.data, NULL, ptr);
+ AL_TEST_EQ(sizeof(ints.inline_data), 64 * sizeof(u32), size_t);
- al_array_free(u32, 64)(&arr);
+ al_array_free(u32, 64)(&ints);
+ // Not a double-free.
+ al_array_free(u32, 64)(&ints);
AL_TEST_END();
}
@@ -32,25 +36,22 @@ static bool array_test_reserve(void)
{
AL_TEST_START("array_reserve");
- array(u32, 64) arr;
- al_array_init(u32, 64)(&arr);
-
- al_array_reserve(u32, 64)(&arr, 64);
-
- AL_TEST_EQ((void *)arr.data, NULL, ptr);
- AL_TEST_EQ(arr.alloc, 64, u32);
-
- al_array_reserve(u32, 64)(&arr, 128);
+ array(u32, 64) ints;
+ al_array_init(u32, 64)(&ints);
- AL_TEST_NEQ((void *)arr.data, NULL, ptr);
- AL_TEST_EQ(arr.alloc, 128, u32);
+ al_array_reserve(u32, 64)(&ints, 64);
+ AL_TEST_EQ(ints.alloc, 256, u32);
+ AL_TEST_EQ(ints.data, NULL, ptr);
- al_array_reserve(u32, 64)(&arr, 129);
+ al_array_reserve(u32, 64)(&ints, 128);
+ AL_TEST_EQ(ints.alloc, 512, u32);
+ AL_TEST_NEQ(ints.data, NULL, ptr);
- AL_TEST_NEQ((void *)arr.data, NULL, ptr);
- AL_TEST_EQ(arr.alloc, 256, u32);
+ al_array_reserve(u32, 64)(&ints, 129);
+ AL_TEST_EQ(ints.alloc, 1024, u32);
+ AL_TEST_NEQ(ints.data, NULL, ptr);
- al_array_free(u32, 64)(&arr);
+ al_array_free(u32, 64)(&ints);
AL_TEST_END();
}
@@ -59,15 +60,19 @@ static bool array_test_at(void)
{
AL_TEST_START("array_at");
- array(u32, 64) arr;
- al_array_init(u32, 64)(&arr);
+ array(u32, 64) ints;
+ al_array_init(u32, 64)(&ints);
u32 x = 5;
- al_array_push(u32, 64)(&arr, &x);
+ al_array_push(u32, 64)(&ints, x);
+ al_array_push(u32, 64)(&ints, (u32)4);
- AL_TEST_EQ(*al_array_at(u32, 64)(&arr, 0), 5, u32);
+ AL_TEST_EQ(*al_array_at(u32, 64)(&ints, 0), 5, u32);
+ AL_TEST_EQ(*al_array_at(u32, 64)(&ints, 1), 4, u32);
+ AL_TEST_EQ(ints.count, 2, u32);
+ AL_TEST_EQ(ints.alloc, 256, u32);
- al_array_free(u32, 64)(&arr);
+ al_array_free(u32, 64)(&ints);
AL_TEST_END();
}
@@ -76,18 +81,19 @@ static bool array_test_last(void)
{
AL_TEST_START("array_last");
- array(u32, 64) arr;
- al_array_init(u32, 64)(&arr);
+ array(u32, 64) ints;
+ al_array_init(u32, 64)(&ints);
u32 x = 1, y = 2, z = 3;
+ al_array_push(u32, 64)(&ints, x);
+ al_array_push(u32, 64)(&ints, y);
+ al_array_push(u32, 64)(&ints, z);
- al_array_push(u32, 64)(&arr, &x);
- al_array_push(u32, 64)(&arr, &y);
- al_array_push(u32, 64)(&arr, &z);
+ AL_TEST_EQ(*al_array_last(u32, 64)(&ints), 3, u32);
+ AL_TEST_EQ(ints.count, 3, u32);
+ AL_TEST_EQ(ints.alloc, 256, u32);
- AL_TEST_EQ(*al_array_last(u32, 64)(&arr), 3, u32);
-
- al_array_free(u32, 64)(&arr);
+ al_array_free(u32, 64)(&ints);
AL_TEST_END();
}
@@ -96,19 +102,21 @@ static bool array_test_push(void)
{
AL_TEST_START("array_push");
- array(u32, 64) arr;
- al_array_init(u32, 64)(&arr);
-
- u32 x = 4, y = 5;
+ array(u8) bytes;
+ al_array_init(u8)(&bytes);
- al_array_push(u32, 64)(&arr, &x);
- al_array_push(u32, 64)(&arr, &y);
+ for (u32 i = 0; i < MAX_ALLOC_32; i++) {
+ al_array_push(u8)(&bytes, (u8)1);
+ }
+ AL_TEST_EQ(bytes.count, MAX_ALLOC_32, u32);
+ AL_TEST_EQ(bytes.alloc, MAX_ALLOC_32, u32);
- AL_TEST_EQ(arr.size, 2, u32);
- AL_TEST_EQ(*al_array_at(u32, 64)(&arr, 0), x, u32);
- AL_TEST_EQ(*al_array_at(u32, 64)(&arr, 1), y, u32);
+ AL_TEST_EQ(al_array_at(u8)(&bytes, MAX_ALLOC_32 - 1), al_array_last(u8)(&bytes), ptr);
+ AL_TEST_EQ(*al_array_at(u8)(&bytes, MAX_ALLOC_32 - 2), 1, u8);
+ AL_TEST_EQ(*al_array_at(u8)(&bytes, MAX_ALLOC_32 - 3), 1, u8);
+ AL_TEST_EQ(*al_array_at(u8)(&bytes, MAX_ALLOC_32 - 4), 1, u8);
- al_array_free(u32, 64)(&arr);
+ al_array_free(u8)(&bytes);
AL_TEST_END();
}
@@ -117,27 +125,25 @@ static bool array_test_pop(void)
{
AL_TEST_START("array_pop");
- array(u32, 64) arr;
- al_array_init(u32, 64)(&arr);
+ array(u32, 64) ints;
+ al_array_init(u32, 64)(&ints);
u32 x = 4, y = 5;
-
- al_array_push(u32, 64)(&arr, &x);
- al_array_push(u32, 64)(&arr, &y);
+ al_array_push(u32, 64)(&ints, x);
+ al_array_push(u32, 64)(&ints, y);
u32 rx, ry;
- al_array_pop(u32, 64)(&arr, &ry);
-
- AL_TEST_EQ(arr.size, 1, u32);
+ al_array_pop(u32, 64)(&ints, &ry);
+ AL_TEST_EQ(ints.count, 1, u32);
- al_array_pop(u32, 64)(&arr, &rx);
+ al_array_pop(u32, 64)(&ints, &rx);
+ AL_TEST_EQ(ints.count, 0, u32);
- AL_TEST_EQ(arr.size, 0, u32);
AL_TEST_EQ(rx, x, u32);
AL_TEST_EQ(ry, y, u32);
- al_array_free(u32, 64)(&arr);
+ al_array_free(u32, 64)(&ints);
AL_TEST_END();
}
@@ -146,28 +152,28 @@ static bool array_test_remove_at(void)
{
AL_TEST_START("array_remove_at");
- array(u32) arr;
- al_array_init(u32)(&arr);
- al_array_reserve(u32)(&arr, 12);
+ array(u32) ints;
+ al_array_init(u32)(&ints);
+ al_array_reserve(u32)(&ints, 12);
u32 array_before[] = { 1, 2, 3, 4, 5, 6 };
u32 array_after[] = { 2, 3, 4 };
- for (u32 i = 0; i < sizeof(array_before) / sizeof(u32); i++) {
- al_array_push(u32)(&arr, &array_before[i]);
+ for (u32 i = 0; i < ARRAY_SIZE(array_before); i++) {
+ al_array_push(u32)(&ints, array_before[i]);
}
- al_array_remove_at(u32)(&arr, 0);
- al_array_remove_at(u32)(&arr, 3);
- al_array_remove_at(u32)(&arr, 3);
+ al_array_remove_at(u32)(&ints, 0);
+ al_array_remove_at(u32)(&ints, 3);
+ al_array_remove_at(u32)(&ints, 3);
- AL_TEST_EQ(arr.size, (u32)(sizeof(array_after) / sizeof(u32)), u32);
+ AL_TEST_EQ(ints.count, ARRAY_SIZE(array_after), u32);
- for (u32 i = 0; i < sizeof(array_after) / sizeof(u32); i++) {
- AL_TEST_EQ(*al_array_at(u32)(&arr, i), array_after[i], u32);
+ for (u32 i = 0; i < ARRAY_SIZE(array_after); i++) {
+ AL_TEST_EQ(*al_array_at(u32)(&ints, i), array_after[i], u32);
}
- al_array_free(u32)(&arr);
+ al_array_free(u32)(&ints);
AL_TEST_END();
}
@@ -176,33 +182,31 @@ static bool array_test_pop_at(void)
{
AL_TEST_START("array_pop_at");
- array(u32, 64) arr;
- al_array_init(u32, 64)(&arr);
+ array(u32, 64) ints;
+ al_array_init(u32, 64)(&ints);
u32 array_before[] = { 1, 2, 3, 4, 5, 6 };
u32 array_after[] = { 2, 3, 4 };
- for (u32 i = 0; i < sizeof(array_before) / sizeof(u32); i++) {
- al_array_push(u32, 64)(&arr, &array_before[i]);
+ for (u32 i = 0; i < ARRAY_SIZE(array_before); i++) {
+ al_array_push(u32, 64)(&ints, array_before[i]);
}
- u32 x, y, z;
-
- al_array_pop_at(u32, 64)(&arr, 0, &x);
- al_array_pop_at(u32, 64)(&arr, 3, &y);
- al_array_pop_at(u32, 64)(&arr, 3, &z);
+ u32 x = al_array_pop_at(u32, 64)(&ints, 0);
+ u32 y = al_array_pop_at(u32, 64)(&ints, 3);
+ u32 z = al_array_pop_at(u32, 64)(&ints, 3);
AL_TEST_EQ(x, array_before[0], u32);
AL_TEST_EQ(y, array_before[4], u32);
AL_TEST_EQ(z, array_before[5], u32);
- AL_TEST_EQ(arr.size, (u32)(sizeof(array_after) / sizeof(u32)), u32);
+ AL_TEST_EQ(ints.count, ARRAY_SIZE(array_after), u32);
- for (u32 i = 0; i < sizeof(array_after) / sizeof(u32); i++) {
- AL_TEST_EQ(*al_array_at(u32, 64)(&arr, i), array_after[i], u32);
+ for (u32 i = 0; i < ARRAY_SIZE(array_after); i++) {
+ AL_TEST_EQ(*al_array_at(u32, 64)(&ints, i), array_after[i], u32);
}
- al_array_free(u32, 64)(&arr);
+ al_array_free(u32, 64)(&ints);
AL_TEST_END();
}
@@ -211,44 +215,41 @@ static bool array_test_insert(void)
{
AL_TEST_START("array_insert");
- array(test_t, 16) arr;
- al_array_init(test_t, 16)(&arr);
-
- struct test_t x = {
- .i = 5
- };
+ array(test_t, 16) objects;
+ al_array_init(test_t, 16)(&objects);
- struct test_t y = {
- .i = 5
- };
+ struct test_t x = { .d = 5 };
+ struct test_t y = { .d = 2 };
+ struct test_t z = { .d = 6 };
- struct test_t z = {
- .i = 5
- };
+ al_array_push(test_t, 16)(&objects, (struct test_t){ .d = 7 });
+ al_array_push(test_t, 16)(&objects, (struct test_t){ .d = 9 });
+ al_array_push(test_t, 16)(&objects, (struct test_t){ .d = 444 });
- al_array_insert(test_t, 16)(&arr, 1, &x);
- al_array_insert(test_t, 16)(&arr, 0, &y);
- al_array_insert(test_t, 16)(&arr, 1, &z);
+ al_array_insert(test_t, 16)(&objects, 1, x);
+ al_array_insert(test_t, 16)(&objects, 0, y);
+ al_array_insert(test_t, 16)(&objects, 1, z);
- AL_TEST_EQ(al_array_at(test_t, 16)(&arr, 3)->i, x.i, u32);
- AL_TEST_EQ(al_array_at(test_t, 16)(&arr, 0)->i, y.i, u32);
- AL_TEST_EQ(al_array_at(test_t, 16)(&arr, 1)->i, z.i, u32);
+ AL_TEST_EQ(al_array_at(test_t, 16)(&objects, 3)->d, x.d, u32);
+ AL_TEST_EQ(al_array_at(test_t, 16)(&objects, 0)->d, y.d, u32);
+ AL_TEST_EQ(al_array_at(test_t, 16)(&objects, 1)->d, z.d, u32);
- AL_TEST_EQ(arr.size, 4, u32);
+ AL_TEST_EQ(objects.count, 6, u32);
- al_array_remove_at(test_t, 16)(&arr, 3);
+ al_array_remove_at(test_t, 16)(&objects, 3);
- AL_TEST_EQ(arr.size, 3, u32);
+ AL_TEST_EQ(objects.count, 5, u32);
- AL_TEST_EQ(al_array_at(test_t, 16)(&arr, 0)->i, y.i, u32);
- AL_TEST_EQ(al_array_at(test_t, 16)(&arr, 1)->i, z.i, u32);
+ AL_TEST_NEQ(al_array_at(test_t, 16)(&objects, 0)->d, x.d, u32);
+ AL_TEST_EQ(al_array_at(test_t, 16)(&objects, 0)->d, y.d, u32);
+ AL_TEST_EQ(al_array_at(test_t, 16)(&objects, 1)->d, z.d, u32);
- al_array_free(test_t, 16)(&arr);
+ al_array_free(test_t, 16)(&objects);
AL_TEST_END();
}
-bool array_typed_tests_run(void)
+bool array_typed_tests_run(u32 skip_mask)
{
AL_TEST_START_GROUP("array_typed");
@@ -256,7 +257,9 @@ bool array_typed_tests_run(void)
AL_TEST_RUN(array_test_reserve);
AL_TEST_RUN(array_test_at);
AL_TEST_RUN(array_test_last);
- AL_TEST_RUN(array_test_push);
+ if (skip_mask & AL_TESTS_RUN_LIMITS) {
+ AL_TEST_RUN(array_test_push);
+ }
AL_TEST_RUN(array_test_pop);
AL_TEST_RUN(array_test_remove_at);
AL_TEST_RUN(array_test_pop_at);
diff --git a/tests/array_typed.h b/tests/array_typed.h
index 644cce6..2241ede 100644
--- a/tests/array_typed.h
+++ b/tests/array_typed.h
@@ -3,6 +3,6 @@
#include <al/types.h>
-bool array_typed_tests_run(void);
+bool array_typed_tests_run(u32 skip_mask);
#endif // _AL_ARRAY_TYPED_TESTS_H
diff --git a/tests/common.h b/tests/common.h
new file mode 100644
index 0000000..cd8e6ab
--- /dev/null
+++ b/tests/common.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <al/types.h>
+
+enum {
+ AL_TESTS_RUN_LIMITS = 1
+};
+
+struct test_t {
+ u32 d;
+ u32 j;
+};
diff --git a/tests/lib.c b/tests/lib.c
index 0923cf1..48b6c02 100644
--- a/tests/lib.c
+++ b/tests/lib.c
@@ -1,37 +1,62 @@
-#include <al/array.h>
#include <al/test.h>
+#include <al/array.h>
#include <al/lib.h>
-#include <al/random.h>
-struct test_t {
- u32 d;
-};
+#include "lib.h"
+#include "common.h"
static bool lib_test_add_wrap(void)
{
AL_TEST_START("lib_add_wrap");
- u32 x = UINT32_MAX - 5;
- x = al_u32_add_wrap(x, 15);
- AL_TEST_EQ(x, 10, u32);
+ // u32
+ u32 counter32 = UINT32_MAX - 5;
+ counter32 = al_u32_add_wrap(counter32, 15);
+ AL_TEST_EQ(counter32, 10, u32);
+
+ counter32 = UINT32_MAX;
+ counter32 = al_u32_add_wrap(counter32, 1);
+ AL_TEST_EQ(counter32, 1, u32);
+
+ counter32 = UINT32_MAX - 25;
+ counter32 = al_u32_add_wrap(counter32, 20);
+ AL_TEST_EQ(counter32, UINT32_MAX - 5, u32);
+ counter32 = al_u32_add_wrap(counter32, 6);
+ AL_TEST_EQ(counter32, 1, u32);
- x = UINT32_MAX;
- x = al_u32_add_wrap(x, 1);
- AL_TEST_EQ(x, 1, u32);
+ // u16
+ u16 counter16 = UINT16_MAX - 5;
+ counter16 = al_u16_add_wrap(counter16, 15);
+ AL_TEST_EQ(counter16, 10, u16);
- x = UINT32_MAX - 25;
- x = al_u32_add_wrap(x, 20);
- AL_TEST_EQ(x, UINT32_MAX - 5, u32);
- x = al_u32_add_wrap(x, 6);
- AL_TEST_EQ(x, 1, u32);
+ counter16 = UINT16_MAX;
+ counter16 = al_u16_add_wrap(counter16, 1);
+ AL_TEST_EQ(counter16, 1, u16);
- u16 y = UINT16_MAX - 5;
- y = al_u16_add_wrap(y, 15);
- AL_TEST_EQ(y, 10, u16);
+ counter16 = UINT16_MAX - 25;
+ counter16 = al_u16_add_wrap(counter16, 20);
+ AL_TEST_EQ(counter16, UINT16_MAX - 5, u16);
+ counter16 = al_u16_add_wrap(counter16, 6);
+ AL_TEST_EQ(counter16, 1, u16);
- y = UINT16_MAX;
- y = al_u16_add_wrap(y, 1);
- AL_TEST_EQ(y, 1, u16);
+ // inc_wrap
+ counter16 = UINT16_MAX - 4;
+ AL_TEST_EQ((counter16 = al_u16_inc_wrap(counter16)), UINT16_MAX - 3, u16);
+ AL_TEST_EQ((counter16 = al_u16_inc_wrap(counter16)), UINT16_MAX - 2, u16);
+ AL_TEST_EQ((counter16 = al_u16_inc_wrap(counter16)), UINT16_MAX - 1, u16);
+ AL_TEST_EQ((counter16 = al_u16_inc_wrap(counter16)), UINT16_MAX, u16);
+ AL_TEST_EQ((counter16 = al_u16_inc_wrap(counter16)), 0, u16);
+ AL_TEST_EQ((counter16 = al_u16_inc_wrap(counter16)), 1, u16);
+ AL_TEST_EQ((counter16 = al_u16_inc_wrap(counter16)), 2, u16);
+ AL_TEST_EQ((counter16 = al_u16_inc_wrap(counter16)), 3, u16);
+
+ // From 3 to UINT16_MAX.
+ for (u16 i = 0; i < UINT16_MAX - 3; i++) {
+ AL_TEST_EQ((counter16 = al_u16_inc_wrap(counter16)), i + 4, u16);
+ }
+
+ // Wrap to 0.
+ AL_TEST_EQ((counter16 = al_u16_inc_wrap(counter16)), 0, u16);
AL_TEST_END();
}
@@ -40,62 +65,53 @@ static bool lib_test_offset_vs_at_and_ref(void)
{
AL_TEST_START("lib_offset_vs_at_and_ref");
- array(struct test_t *) ar;
- al_array_init(ar);
+ // Test that &al_array_at and al_array_offset are equivalent and that we can
+ // have NULL entires in an array of pointers.
+
+ array(struct test_t *) objects;
+ al_array_init(objects);
for (u32 i = 0; i < 10; i++) {
if (i == 4) {
- al_array_push(ar, NULL);
+ al_array_push(objects, (struct test_t *)NULL);
} else {
- al_array_push(ar, al_alloc_object(struct test_t));
+ al_array_push(objects, al_alloc_object(struct test_t));
}
}
- AL_TEST_EQ(&al_array_at(ar, 2), al_array_offset(ar, 2), ptr);
- AL_TEST_EQ(&al_array_at(ar, 3), al_array_offset(ar, 3), ptr);
- AL_TEST_NEQ(*&al_array_at(ar, 3), NULL, ptr);
- AL_TEST_EQ(&al_array_at(ar, 4), al_array_offset(ar, 4), ptr);
- AL_TEST_EQ(*&al_array_at(ar, 4), *al_array_offset(ar, 4), ptr);
- AL_TEST_NEQ(*&al_array_at(ar, 4), *al_array_offset(ar, 2), ptr);
- AL_TEST_EQ(*&al_array_at(ar, 4), NULL, ptr);
- AL_TEST_EQ(&al_array_at(ar, 5), al_array_offset(ar, 5), ptr);
+ AL_TEST_EQ(&al_array_at(objects, 2), al_array_offset(objects, 2), ptr);
+ AL_TEST_EQ(&al_array_at(objects, 3), al_array_offset(objects, 3), ptr);
+ AL_TEST_NEQ(*&al_array_at(objects, 3), NULL, ptr);
+
+ AL_TEST_EQ(&al_array_at(objects, 4), al_array_offset(objects, 4), ptr);
+ AL_TEST_EQ(*&al_array_at(objects, 4), *al_array_offset(objects, 4), ptr);
+
+ AL_TEST_NEQ(*&al_array_at(objects, 4), *al_array_offset(objects, 2), ptr);
+
+ AL_TEST_EQ(*&al_array_at(objects, 4), NULL, ptr);
+ AL_TEST_EQ(&al_array_at(objects, 5), al_array_offset(objects, 5), ptr);
for (u32 i = 0; i < 10; i++) {
if (i != 4) {
- al_free(al_array_at(ar, i));
+ al_free(al_array_at(objects, i));
}
}
AL_TEST_END();
}
-/*
-static bool lib_test_add_wrap_atomic(void)
+static bool lib_test_min_max(void)
{
- AL_TEST_START("lib_add_wrap_atomic");
-
- for (u32 i = 0; i < UINT16_MAX - 3; i++) {
- al_inc_u16();
- }
-
- AL_TEST_EQ(al_inc_u16(), UINT16_MAX - 3, u16);
- AL_TEST_EQ(al_inc_u16(), UINT16_MAX - 2, u16);
- AL_TEST_EQ(al_inc_u16(), UINT16_MAX - 1, u16);
- AL_TEST_EQ(al_inc_u16(), UINT16_MAX, u16);
- AL_TEST_EQ(al_inc_u16(), 0, u16);
- AL_TEST_EQ(al_inc_u16(), 1, u16);
- AL_TEST_EQ(al_inc_u16(), 2, u16);
- AL_TEST_EQ(al_inc_u16(), 3, u16);
-
- for (u32 i = 0; i < UINT16_MAX - 3; i++) {
- AL_TEST_EQ(al_inc_u16(), i + 4, u16);
- }
+ AL_TEST_START("lib_min_max");
- AL_TEST_EQ(al_inc_u16(), 0, u16);
+ AL_TEST_EQ(MAX((u32)4, (u32)3), 4, u32);
+ AL_TEST_EQ(MIN((u32)4, (u32)3), 3, u32);
+ // Compiler warnings.
+ //AL_TEST_EQ(MAX(4, (u32)3), 4, u32);
+ //AL_TEST_EQ(MIN(4, (u32)3), 3, u32);
AL_TEST_END();
}
-*/
bool lib_tests_run(void)
{
@@ -103,7 +119,7 @@ bool lib_tests_run(void)
AL_TEST_RUN(lib_test_add_wrap);
AL_TEST_RUN(lib_test_offset_vs_at_and_ref);
- //AL_TEST_RUN(lib_test_add_wrap_atomic);
+ AL_TEST_RUN(lib_test_min_max);
AL_TEST_END_GROUP();
}
diff --git a/tests/main.c b/tests/main.c
index 5964a04..672511a 100644
--- a/tests/main.c
+++ b/tests/main.c
@@ -1,5 +1,7 @@
#include <al/lib.h>
+#include <al/str.h>
#include <al/random.h>
+#include <time.h>
#include "lib.h"
#include "array.h"
@@ -8,18 +10,31 @@
#endif
#include "str.h"
#include "ring_buffer.h"
+#include "common.h"
-s32 main(void)
+s32 main(s32 argc, char *argv[])
{
- al_rand_init();
+ al_rand_init((u32)time(NULL));
- if (!lib_tests_run()) goto fail;
- if (!array_tests_run()) goto fail;
+ u32 skip_mask = 0;
+ if (argc > 1) {
+ for (s32 i = 1; i < argc; i++) {
+ if (al_str_eq(&al_str_cr(argv[i]), &al_str_c("run_limits"))) {
+ skip_mask |= AL_TESTS_RUN_LIMITS;
+ al_printf("MAX_ALLOC_32: %u, INT32_MAX: %u, UINT32_MAX: %u.\n",
+ MAX_ALLOC_32, INT32_MAX, UINT32_MAX);
+ }
+ }
+ }
+
+
+ if (!array_tests_run(skip_mask)) goto fail;
#ifdef AL_HAVE_GNU_EXTENSIONS
- if (!array_typed_tests_run()) goto fail;
+ if (!array_typed_tests_run(skip_mask)) goto fail;
#endif
- if (!str_tests_run()) goto fail;
+ if (!str_tests_run(skip_mask)) goto fail;
if (!ring_buffer_tests_run()) goto fail;
+ if (!lib_tests_run()) goto fail;
return EXIT_SUCCESS;
diff --git a/tests/ring_buffer.c b/tests/ring_buffer.c
index 30b583e..97286a3 100644
--- a/tests/ring_buffer.c
+++ b/tests/ring_buffer.c
@@ -2,22 +2,24 @@
#include <al/ring_buffer.h>
#include <al/atomic.h>
-#define TEST_BUFFER_SIZE 32
+#include "ring_buffer.h"
-static u8 buffer[TEST_BUFFER_SIZE];
-static u8 buffer_ret[TEST_BUFFER_SIZE];
-static u8 buffer_half[TEST_BUFFER_SIZE / 2] = {0};
-static u8 buffer_over[TEST_BUFFER_SIZE + 16] = {0};
+#define BUFFER_SIZE 32
+
+static u8 buffer[BUFFER_SIZE];
+static u8 output[BUFFER_SIZE];
+static u8 half_buffer[BUFFER_SIZE / 2] = { 0 };
+static u8 bigger_buffer[BUFFER_SIZE + 16] = { 0 };
static bool ring_buffer_test_init(void)
{
AL_TEST_START("ring_buffer_init");
struct al_ring_buffer buf;
- al_ring_buffer_init(&buf, buffer, TEST_BUFFER_SIZE);
+ al_ring_buffer_init(&buf, buffer, BUFFER_SIZE);
AL_TEST_EQ(buf.start, buffer, ptr);
- AL_TEST_EQ(buf.end, buffer + TEST_BUFFER_SIZE, ptr);
+ AL_TEST_EQ(buf.end, buffer + BUFFER_SIZE, ptr);
AL_TEST_EQ(al_atomic_load(void)(&buf.read, AL_ATOMIC_RELAXED), buffer, ptr);
AL_TEST_EQ(al_atomic_load(void)(&buf.write, AL_ATOMIC_RELAXED), buffer, ptr);
@@ -29,9 +31,9 @@ static bool ring_buffer_test_space(void)
AL_TEST_START("ring_buffer_space");
struct al_ring_buffer buf;
- al_ring_buffer_init(&buf, buffer, TEST_BUFFER_SIZE);
+ al_ring_buffer_init(&buf, buffer, BUFFER_SIZE);
- AL_TEST_EQ(al_ring_buffer_space(&buf), TEST_BUFFER_SIZE - 1, size_t);
+ AL_TEST_EQ(al_ring_buffer_space(&buf), BUFFER_SIZE - 1, ptrdiff_t);
AL_TEST_END();
}
@@ -41,9 +43,9 @@ static bool ring_buffer_test_occupied(void)
AL_TEST_START("ring_buffer_occupied");
struct al_ring_buffer buf;
- al_ring_buffer_init(&buf, buffer, TEST_BUFFER_SIZE);
+ al_ring_buffer_init(&buf, buffer, BUFFER_SIZE);
- AL_TEST_EQ(al_ring_buffer_occupied(&buf), 0, size_t);
+ AL_TEST_EQ(al_ring_buffer_occupied(&buf), 0, ptrdiff_t);
AL_TEST_END();
}
@@ -53,29 +55,28 @@ static bool ring_buffer_test_read_and_write_chunk(void)
AL_TEST_START("ring_buffer_read_and_write_chunk");
struct al_ring_buffer buf;
- al_ring_buffer_init(&buf, buffer, TEST_BUFFER_SIZE);
+ al_ring_buffer_init(&buf, buffer, BUFFER_SIZE);
char *data = "TestTEST";
- size_t data_size = al_strlen(data) + 1;
+ ptrdiff_t data_size = (ptrdiff_t)(al_strlen(data) + 1);
- size_t size;
+ ptrdiff_t size;
u8 *ptr = al_ring_buffer_write_chunk(&buf, &size);
+ AL_TEST_EQ(size, BUFFER_SIZE - 1, ptrdiff_t);
- AL_TEST_EQ(size, TEST_BUFFER_SIZE - 1, size_t);
+ al_memcpy(ptr, data, (size_t)data_size);
- al_memcpy(ptr, data, data_size);
al_ring_buffer_append(&buf, ptr, data_size);
-
- AL_TEST_EQ(al_ring_buffer_occupied(&buf), data_size, size_t);
- AL_TEST_EQ(al_ring_buffer_space(&buf), (TEST_BUFFER_SIZE - 1) - data_size, size_t);
+ AL_TEST_EQ(al_ring_buffer_occupied(&buf), data_size, ptrdiff_t);
+ AL_TEST_EQ(al_ring_buffer_space(&buf), (BUFFER_SIZE - 1) - data_size, ptrdiff_t);
ptr = al_ring_buffer_read_chunk(&buf, &size);
- AL_TEST_EQ(size, data_size, size_t);
- AL_TEST_TRUE((strcmp((char *)ptr, data) == 0));
- al_ring_buffer_consume(&buf, ptr, size);
+ AL_TEST_EQ(size, data_size, ptrdiff_t);
+ AL_TEST_TRUE(strcmp((char *)ptr, data) == 0);
- AL_TEST_EQ(al_ring_buffer_occupied(&buf), 0, size_t);
- AL_TEST_EQ(al_ring_buffer_space(&buf), TEST_BUFFER_SIZE - 1, size_t);
+ al_ring_buffer_consume(&buf, ptr, size);
+ AL_TEST_EQ(al_ring_buffer_occupied(&buf), 0, ptrdiff_t);
+ AL_TEST_EQ(al_ring_buffer_space(&buf), BUFFER_SIZE - 1, ptrdiff_t);
AL_TEST_END();
}
@@ -85,40 +86,45 @@ static bool ring_buffer_test_read_and_write(void)
AL_TEST_START("ring_buffer_read_and_write");
struct al_ring_buffer buf;
- al_ring_buffer_init(&buf, buffer, TEST_BUFFER_SIZE);
+ al_ring_buffer_init(&buf, buffer, BUFFER_SIZE);
char *data = "TestTEST";
- size_t data_size = al_strlen(data) + 1;
+ ptrdiff_t data_size = (ptrdiff_t)(al_strlen(data) + 1);
al_ring_buffer_write(&buf, (u8 *)data, data_size);
+ AL_TEST_EQ(al_ring_buffer_occupied(&buf), data_size, ptrdiff_t);
+ AL_TEST_EQ(al_ring_buffer_space(&buf), (BUFFER_SIZE - 1) - data_size, ptrdiff_t);
- AL_TEST_EQ(al_ring_buffer_occupied(&buf), data_size, size_t);
- AL_TEST_EQ(al_ring_buffer_space(&buf), (TEST_BUFFER_SIZE - 1) - data_size, size_t);
-
- al_ring_buffer_read(&buf, (u8 *)buffer_ret, data_size);
- AL_TEST_TRUE((strcmp((char *)buffer_ret, data) == 0));
+ al_ring_buffer_read(&buf, (u8 *)output, data_size);
+ AL_TEST_TRUE(strcmp((char *)output, data) == 0);
+ AL_TEST_EQ(al_ring_buffer_occupied(&buf), 0, ptrdiff_t);
+ AL_TEST_EQ(al_ring_buffer_space(&buf), BUFFER_SIZE - 1, ptrdiff_t);
- AL_TEST_EQ(al_ring_buffer_occupied(&buf), 0, size_t);
- AL_TEST_EQ(al_ring_buffer_space(&buf), TEST_BUFFER_SIZE - 1, size_t);
+ al_memset(half_buffer, 'd', sizeof(half_buffer));
+ AL_TEST_EQ(al_ring_buffer_write(&buf, half_buffer, sizeof(half_buffer)), sizeof(half_buffer), ptrdiff_t);
+ AL_TEST_EQ(al_ring_buffer_occupied(&buf), sizeof(half_buffer), ptrdiff_t);
+ AL_TEST_EQ(al_ring_buffer_space(&buf), (BUFFER_SIZE - 1) - sizeof(half_buffer), ptrdiff_t);
- al_memset(buffer_half, 'd', sizeof(buffer_half));
+ // Arbitrarily read data_size from what was written above.
+ AL_TEST_EQ(al_ring_buffer_read(&buf, (u8 *)output, data_size), data_size, ptrdiff_t);
+ AL_TEST_TRUE(al_memcmp(output, "ddddddddd", (size_t)data_size) == 0);
- AL_TEST_EQ(al_ring_buffer_write(&buf, buffer_half, sizeof(buffer_half)), sizeof(buffer_half), size_t);
- AL_TEST_EQ(al_ring_buffer_occupied(&buf), sizeof(buffer_half), size_t);
- AL_TEST_EQ(al_ring_buffer_space(&buf), (TEST_BUFFER_SIZE - 1) - sizeof(buffer_half), size_t);
-
- AL_TEST_EQ(al_ring_buffer_read(&buf, (u8 *)buffer_ret, data_size), data_size, size_t);
- AL_TEST_TRUE(al_memcmp(buffer_ret, "ddddddddd", data_size) == 0);
-
- AL_TEST_EQ(al_ring_buffer_write(&buf, buffer_half, sizeof(buffer_half)), sizeof(buffer_half), size_t);
- AL_TEST_EQ(al_ring_buffer_occupied(&buf), TEST_BUFFER_SIZE - data_size, size_t);
+ AL_TEST_EQ(al_ring_buffer_write(&buf, half_buffer, sizeof(half_buffer)), sizeof(half_buffer), ptrdiff_t);
+ AL_TEST_EQ(al_ring_buffer_occupied(&buf), BUFFER_SIZE - data_size, ptrdiff_t);
+ // Test that we wrapped.
AL_TEST_LT(al_atomic_load(void)(&buf.write, AL_ATOMIC_RELAXED), al_atomic_load(void)(&buf.read, AL_ATOMIC_RELAXED), ptr);
- size_t space = al_ring_buffer_space(&buf);
- AL_TEST_EQ(space, data_size - 1, size_t);
- AL_TEST_EQ(al_ring_buffer_write(&buf, buffer_over, sizeof(buffer_over)), space, size_t);
+ ptrdiff_t space = al_ring_buffer_space(&buf);
+ // Maximum space is BUFFER_SIZE - 1.
+ AL_TEST_EQ(space, data_size - 1, ptrdiff_t);
+ al_memset(bigger_buffer, 'r', sizeof(bigger_buffer));
+ // Test impartial write because we're out of space.
+ AL_TEST_EQ(al_ring_buffer_write(&buf, bigger_buffer, sizeof(bigger_buffer)), space, ptrdiff_t);
- AL_TEST_EQ(al_ring_buffer_read(&buf, buffer_ret, sizeof(buffer_over)), TEST_BUFFER_SIZE - 1, size_t);
+ // Test we can read everything.
+ AL_TEST_EQ(al_ring_buffer_read(&buf, output, sizeof(bigger_buffer)), BUFFER_SIZE - 1, ptrdiff_t);
+ AL_TEST_TRUE(al_memcmp(output, half_buffer, sizeof(half_buffer)) == 0);
+ AL_TEST_TRUE(al_memcmp(output + ((BUFFER_SIZE - 1) - space), bigger_buffer, (size_t)space) == 0);
AL_TEST_END();
}
@@ -128,58 +134,63 @@ static bool ring_buffer_test_peek(void)
AL_TEST_START("ring_buffer_peek");
struct al_ring_buffer buf;
- al_ring_buffer_init(&buf, buffer, TEST_BUFFER_SIZE);
+ al_ring_buffer_init(&buf, buffer, BUFFER_SIZE);
- char *data = "abcabcabcabcabcabcabcabcabcabca";
- size_t data_size = al_strlen(data);
- AL_TEST_EQ(data_size, TEST_BUFFER_SIZE - 1, size_t);
+ char *data = "aBcDeFgHiJkLmNoPqRsTuVwXyZ12345";
+ ptrdiff_t data_size = (ptrdiff_t)al_strlen(data);
+ AL_TEST_EQ(data_size, BUFFER_SIZE - 1, ptrdiff_t);
al_ring_buffer_write(&buf, (u8 *)data, data_size);
- al_ring_buffer_peek(&buf, buffer_ret, 0, data_size);
- AL_TEST_TRUE(al_memcmp(buffer_ret, data, data_size) == 0);
+ // Peek everything.
+ al_ring_buffer_peek(&buf, output, 0, data_size);
+ AL_TEST_TRUE(al_memcmp(output, data, (size_t)data_size) == 0);
- al_ring_buffer_peek(&buf, buffer_ret, 3, data_size);
- AL_TEST_TRUE(al_memcmp(buffer_ret, data + 3, data_size - 3) == 0);
+ // Peek from an offset of 3.
+ al_ring_buffer_peek(&buf, output, 3, data_size);
+ AL_TEST_TRUE(al_memcmp(output, data + 3, (size_t)(data_size - 3)) == 0);
- al_ring_buffer_read(&buf, buffer_ret, 3);
- AL_TEST_TRUE(al_memcmp(buffer_ret, data, 3) == 0);
+ // Read 3 bytes and peek the remaining
+ al_ring_buffer_read(&buf, output, 3);
+ AL_TEST_TRUE(al_memcmp(output, data, 3) == 0);
al_ring_buffer_write(&buf, (u8 *)data, data_size);
- al_ring_buffer_peek(&buf, buffer_ret, 3, data_size);
- AL_TEST_TRUE(al_memcmp(buffer_ret, data + 6, data_size - 6) == 0);
-
- al_ring_buffer_peek(&buf, buffer_ret, 0, data_size);
- AL_TEST_TRUE(al_memcmp(buffer_ret, "abcabcabcabcabcabcabcabcabcaabc", data_size) == 0);
-
- al_ring_buffer_read(&buf, buffer_ret, (TEST_BUFFER_SIZE - 1) - 4);
-
- al_ring_buffer_peek(&buf, buffer_ret, 0, data_size);
- AL_TEST_TRUE(al_memcmp(buffer_ret, "aab", 3) == 0);
+ ptrdiff_t occupied = al_ring_buffer_occupied(&buf);
+ AL_TEST_EQ(al_ring_buffer_peek(&buf, output, 3, data_size), occupied - 3, ptrdiff_t);
+ AL_TEST_TRUE(al_memcmp(output, data + 6, (size_t)(data_size - 6)) == 0);
- AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 10, data_size), 0, size_t);
- AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 3, data_size), 1, size_t);
- AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 4, data_size), 0, size_t);
+ // Peek everything again.
+ al_ring_buffer_peek(&buf, output, 0, data_size);
+ AL_TEST_TRUE(al_memcmp(output, "DeFgHiJkLmNoPqRsTuVwXyZ12345aBc", (size_t)data_size) == 0);
- al_ring_buffer_peek(&buf, buffer_ret, 1, data_size);
- AL_TEST_TRUE(al_memcmp(buffer_ret, "abc", 3) == 0);
+ // Read up to the last 4 bytes.
+ al_ring_buffer_read(&buf, output, (BUFFER_SIZE - 1) - 4);
+ al_ring_buffer_peek(&buf, output, 0, data_size);
+ AL_TEST_TRUE(al_memcmp(output, "5aBc", 4) == 0);
- AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 2, data_size), 2, size_t);
- AL_TEST_TRUE(al_memcmp(buffer_ret, "bc", 2) == 0);
+ // Test peek truncating the offset.
+ AL_TEST_EQ(al_ring_buffer_peek(&buf, output, 10, data_size), 0, ptrdiff_t);
+ AL_TEST_EQ(al_ring_buffer_peek(&buf, output, 3, data_size), 1, ptrdiff_t);
+ AL_TEST_EQ(al_ring_buffer_peek(&buf, output, 4, data_size), 0, ptrdiff_t);
- al_ring_buffer_read(&buf, buffer_ret, 1);
+ // Incrementally read the rest of the buffer.
+ al_ring_buffer_peek(&buf, output, 1, data_size);
+ AL_TEST_TRUE(al_memcmp(output, "aBc", 3) == 0);
- AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 0, data_size), 3, size_t);
- AL_TEST_TRUE(al_memcmp(buffer_ret, "abc", 3) == 0);
+ AL_TEST_EQ(al_ring_buffer_peek(&buf, output, 2, data_size), 2, ptrdiff_t);
+ AL_TEST_TRUE(al_memcmp(output, "Bc", 2) == 0);
- AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 3, data_size), 0, size_t);
- AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 4, data_size), 0, size_t);
+ al_ring_buffer_read(&buf, output, 1);
+ AL_TEST_EQ(al_ring_buffer_peek(&buf, output, 0, data_size), 3, ptrdiff_t);
+ AL_TEST_TRUE(al_memcmp(output, "aBc", 3) == 0);
- AL_TEST_EQ(al_ring_buffer_read(&buf, buffer_ret, 4), 3, size_t);
+ AL_TEST_EQ(al_ring_buffer_peek(&buf, output, 3, data_size), 0, ptrdiff_t);
+ AL_TEST_EQ(al_ring_buffer_peek(&buf, output, 4, data_size), 0, ptrdiff_t);
- AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 0, data_size), 0, size_t);
- AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 1, data_size), 0, size_t);
- AL_TEST_EQ(al_ring_buffer_peek(&buf, buffer_ret, 2, data_size), 0, size_t);
+ AL_TEST_EQ(al_ring_buffer_read(&buf, output, 4), 3, ptrdiff_t);
+ AL_TEST_EQ(al_ring_buffer_peek(&buf, output, 0, data_size), 0, ptrdiff_t);
+ AL_TEST_EQ(al_ring_buffer_peek(&buf, output, 1, data_size), 0, ptrdiff_t);
+ AL_TEST_EQ(al_ring_buffer_peek(&buf, output, 999, data_size), 0, ptrdiff_t);
AL_TEST_END();
}
diff --git a/tests/str.c b/tests/str.c
index 72ed81f..51b0bf1 100644
--- a/tests/str.c
+++ b/tests/str.c
@@ -2,30 +2,41 @@
#include <al/str.h>
#include <al/wstr.h>
+#include "str.h"
+#include "common.h"
+
static bool str_test_cmp(void)
{
AL_TEST_START("str_cmp");
- str *s0 = al_str_c("testtestasdf");
- str *s1 = al_str_c("testtestasdf");
- str *s2 = al_str_c("testtedfdfstasdf");
- str *s3 = al_str_c("dtesttedfdfstasdf");
+ str string0 = al_str_c("The Snake");
+ str string1 = al_str_c("The Rat");
+ str string2 = al_str_c("The Cat");
+ str string3 = al_str_c("The Dog");
+ str string4 = al_str_c("The Snake");
+
+ AL_TEST_FALSE(al_str_eq(&string0, &string1));
+ AL_TEST_FALSE(al_str_eq(&string0, &string2));
+ AL_TEST_FALSE(al_str_eq(&string0, &string3));
+ AL_TEST_FALSE(al_str_eq(&string2, &string3));
+ AL_TEST_TRUE(al_str_eq(&string3, &string3));
+ AL_TEST_TRUE(al_str_eq(&string4, &string0));
- AL_TEST_TRUE(al_str_eq(s0, s1));
- AL_TEST_FALSE(al_str_eq(s0, s2));
- AL_TEST_FALSE(al_str_eq(s0, s3));
- AL_TEST_FALSE(al_str_eq(s2, s3));
+ AL_TEST_EQ(al_str_cmp(&string0, &al_str_c("The "), 0, 4), 0, s32);
+ AL_TEST_EQ(al_str_cmp(&string0, &al_str_c(" S"), 3, 2), 0, s32);
+ // Sn[a]ke
+ AL_TEST_LT(al_str_cmp(&string0, &al_str_c("b"), 6, 1), 0, s32);
+ AL_TEST_GT(al_str_cmp(&string0, &al_str_cs(((char[]){ 'a' - 1 })), 6, 1), 0, s32);
- AL_TEST_EQ(al_str_cmp(s0, al_str_c("test"), 0, 4), 0, u32);
- AL_TEST_EQ(al_str_cmp(s0, al_str_c("tt"), 3, 2), 0, u32);
- AL_TEST_GT(al_str_cmp(s0, al_str_c("r"), 6, 1), 0, u32);
- AL_TEST_EQ(al_str_cmp(s0, al_str_c("ee"), 15, 2), -1, u32);
+ AL_TEST_EQ(al_str_cmp(&string0, &al_str_c("XX"), 15, 2), -1, s32);
+ AL_TEST_EQ(al_str_cmp(&al_str_c("YY"), &string2, string2.length, 1), -1, s32);
+ AL_TEST_EQ(al_str_cmp(&string2, &al_str_c("ZZ"), 0, string2.length), 1, s32);
- str *s4 = al_str_c("page");
- str *s5 = al_str_c("page.json");
+ str string5 = al_str_c("the_database");
+ str string6 = al_str_c("the_database.json");
- AL_TEST_FALSE(al_str_eq(s5, s4));
- AL_TEST_FALSE(al_str_eq(s4, s5));
+ AL_TEST_FALSE(al_str_eq(&string6, &string5));
+ AL_TEST_FALSE(al_str_eq(&string5, &string6));
AL_TEST_END();
}
@@ -34,18 +45,18 @@ static bool str_test_cat(void)
{
AL_TEST_START("str_cat");
- str *result = al_str_c("testtestasdf");
+ str result = al_str_c("hygshiylitf");
- str s0;
- al_str_from(&s0, "");
+ str string0;
+ al_str_from(&string0, "hyg");
- AL_TEST_EQ(s0.len, 0, u32);
+ AL_TEST_EQ(string0.length, 3, u32);
- al_str_cat(&s0, al_str_c("testtestasdf"));
+ al_str_cat(&string0, &al_str_c("shiylitf"));
- AL_TEST_TRUE(al_str_eq(result, &s0));
+ AL_TEST_TRUE(al_str_eq(&result, &string0));
- al_str_free(&s0);
+ al_str_free(&string0);
AL_TEST_END();
}
@@ -54,20 +65,18 @@ static bool str_test_insert(void)
{
AL_TEST_START("str_insert");
- str *insert_result = al_str_c("testtest[insert]asdf");
- str *prepend_result = al_str_c("[prepend]testtestasdf");
+ str insert_result = al_str_c("^_-^-^--__-^[insert]_-^--^___");
+ str prepend_result = al_str_c("[prepend]-^_^_^---^^-__");
str insert_str;
- str prepend_str;
-
- al_str_from(&insert_str, "testtestasdf");
- al_str_from(&prepend_str, "testtestasdf");
+ al_str_from(&insert_str, "^_-^-^--__-^_-^--^___");
+ al_str_insert(&insert_str, 12, &al_str_c("[insert]"));
+ AL_TEST_TRUE(al_str_eq(&insert_result, &insert_str));
- al_str_insert(&insert_str, 8, al_str_c("[insert]"));
- al_str_prepend(&prepend_str, al_str_c("[prepend]"));
-
- AL_TEST_TRUE(al_str_eq(insert_result, &insert_str));
- AL_TEST_TRUE(al_str_eq(prepend_result, &prepend_str));
+ str prepend_str;
+ al_str_from(&prepend_str, "-^_^_^---^^-__");
+ al_str_prepend(&prepend_str, &al_str_c("[prepend]"));
+ AL_TEST_TRUE(al_str_eq(&prepend_result, &prepend_str));
al_str_free(&insert_str);
al_str_free(&prepend_str);
@@ -79,12 +88,14 @@ static bool str_test_find_rfind(void)
{
AL_TEST_START("str_find_rfind");
- str *s0 = al_str_c("testtes\\ta\\sdf");
+ str string0 = al_str_c("wowowow\\$$\\wow");
- AL_TEST_EQ(al_str_find(s0, '\\'), 7, s32);
- AL_TEST_EQ(al_str_rfind(s0, '\\'), 10, s32);
+ AL_TEST_EQ(al_str_find(&string0, '\\'), 7, u32);
+ AL_TEST_EQ(al_str_rfind(&string0, '\\'), 10, u32);
+ AL_TEST_EQ(al_str_find(&string0, 'P'), al_str_npos, u32);
- AL_TEST_EQ(al_str_find_str(s0, al_str_c("tes\\")), 4, s32);
+ AL_TEST_EQ(al_str_find_str(&string0, &al_str_c("wow\\")), 4, u32);
+ AL_TEST_EQ(al_str_find_str(&string0, &al_str_c("John\\")), al_str_npos, u32);
AL_TEST_END();
}
@@ -93,25 +104,25 @@ static bool str_test_substr(void)
{
AL_TEST_START("str_substr");
- str *result0 = al_str_c("[cutout0]");
- str *result1 = al_str_c("[cutout1]");
+ str result0 = al_str_c("[cutout0]");
+ str result1 = al_str_c("[cutout1]");
str s;
- al_str_from(&s, "dfkdljfd[cutout0]dfd[cutout1]fd");
+ al_str_from(&s, "88888888[cutout0]999[cutout1]10");
- s32 start = al_str_find(&s, '[');
- s32 end = al_str_find(&s, ']') + 1;
+ u32 start = al_str_find(&s, '[');
+ u32 end = al_str_find(&s, ']') + 1;
- str *cutout0 = al_str_substr(&s, start, end);
- str *sub = al_str_substr(&s, end, s.len);
+ str cutout0 = al_str_substr(&s, start, end);
+ str sub = al_str_substr(&s, end, s.length);
- start = al_str_find(sub, '[');
- end = al_str_find(sub, ']') + 1;
+ start = al_str_find(&sub, '[');
+ end = al_str_find(&sub, ']') + 1;
- str *cutout1 = al_str_substr(sub, start, end);
+ str cutout1 = al_str_substr(&sub, start, end);
- AL_TEST_TRUE(al_str_eq(result0, cutout0));
- AL_TEST_TRUE(al_str_eq(result1, cutout1));
+ AL_TEST_TRUE(al_str_eq(&result0, &cutout0));
+ AL_TEST_TRUE(al_str_eq(&result1, &cutout1));
al_str_free(&s);
@@ -122,47 +133,38 @@ static bool str_test_get_line(void)
{
AL_TEST_START("str_get_line");
- str *lines0 = al_str_c("test\nasdf\ntest2\na\n ");
- str *lines_array0[] = { al_str_c("test"), al_str_c("asdf"), al_str_c("test2"), al_str_c("a"), al_str_c(" ") };
+ str string0 = al_str_c("Yellow\nmellow\nhello,\nhello\n,\n");
+ str array0[] = { al_str_c("Yellow"), al_str_c("mellow"), al_str_c("hello,"), al_str_c("hello"), al_str_c(",") };
- str *lines1 = al_str_c("test\nasdf\ntest2\na\n");
- str *lines_array1[] = { al_str_c("test"), al_str_c("asdf"), al_str_c("test2"), al_str_c("a") };
+ str string1 = al_str_c("Yellow\nmellow\nhello,\nhello\n,\n ");
+ str array1[] = { al_str_c("Yellow"), al_str_c("mellow"), al_str_c("hello,"), al_str_c("hello"), al_str_c(","), al_str_c(" ") };
- str *lines;
- str **lines_array;
- u32 lines_array_size;
+ str strings[] = { string0, string1 };
+ str *arrays[] = { array0, array1 };
+ u32 sizes[] = { ARRAY_SIZE(array0), ARRAY_SIZE(array1) };
- for (u32 i = 0; i < 2; i++) {
- if (i == 0) {
- lines = lines0;
- lines_array = lines_array0;
- lines_array_size = (u32)ARRAY_SIZE(lines_array0);
- } else if (i == 1) {
- lines = lines1;
- lines_array = lines_array1;
- lines_array_size = (u32)ARRAY_SIZE(lines_array1);
+ for (u32 i = 0; i < ARRAY_SIZE(strings); i++) {
+ u32 counter = 0;
+ str line = al_str_null();
+ for (; al_str_get_line(&strings[i], '\n', &line); ) {
+ AL_TEST_LT(counter, sizes[i], u32);
+ AL_TEST_TRUE(al_str_eq(&line, &arrays[i][counter++]));
}
- str line = al_str_zero();
- u32 c = 0;
+ AL_TEST_EQ(counter, sizes[i], u32);
- for (; al_str_get_line(lines, '\n', &line); ) {
- AL_TEST_LT(c, lines_array_size, u32);
- AL_TEST_TRUE(al_str_eq(&line, lines_array[c++]));
+ counter = 0;
+ line = al_str_null();
+ // One empty line.
+ for (; al_str_get_line(&al_str_c("\n"), '\n', &line); ) {
+ AL_TEST_LT(counter, 1, u32);
+ AL_TEST_EQ(line.length, 0, u32);
+ counter++;
}
- AL_TEST_EQ(c, lines_array_size, u32);
-
- lines = al_str_c("");
-
- al_memset(&line, 0, sizeof(str));
- c = 0;
-
- for (; al_str_get_line(lines, '\n', &line); ) {
- AL_TEST_LT(c, 1, u32);
- AL_TEST_EQ(line.len, 0, u32);
- c++;
- }
+ // No lines.
+ line = al_str_null();
+ AL_TEST_FALSE(al_str_get_line(&al_str_c(""), '\n', &line));
}
AL_TEST_END();
@@ -172,54 +174,155 @@ static bool str_test_to_long(void)
{
AL_TEST_START("str_to_long");
- str *s0 = al_str_c("10353");
- str *s1 = al_str_c("-3563");
- str *s2 = al_str_c("-2147483647"); // 1 away
- // This fails on MSVC for some reason.
- str *s2_1 = al_str_c("-2147483648"); // min
- str *s2_2 = al_str_c("-2147483649"); // underflow
- str *s3 = al_str_c("0xfff");
- str *s4 = al_str_c("0b01010");
- str *s5 = al_str_c("01010");
- str *s6 = al_str_c("99999999999999999999");
- str *s7 = al_str_c(" -99999999999999999999");
- str *s8 = al_str_c("---99999999999999999999");
- str *s9 = al_str_c("'p[afd'dfdfs[f");
- str *s10 = al_str_c("\n\t 01010");
- str *s11 = al_str_c("-9223372036854775809");
- str *s12 = al_str_c("6519749124957310923");
- str *s13 = al_str_c("-3519311901742109472");
+ str string0 = al_str_c("1738");
+ str string1 = al_str_c("-3563");
+ str string2 = al_str_c("-2147483647"); // 1 away (32 bit)
+ str string2_1 = al_str_c("-2147483648"); // min (32 bit)
+ str string2_2 = al_str_c("-2147483649"); // underflow (32 bit)
+ str string2_3 = al_str_c("9223372036854775807"); // int64_max
+ str string2_4 = al_str_c("9223372036854775806");
+ str string2_5 = al_str_c("9223372036854775808"); // overflow
+ str string2_6 = al_str_c("0x7fffffffffffffff"); // int64_max
+ str string2_7 = al_str_c("0x8000000000000000"); // overflow
+ str string2_8 = al_str_c("-0x8000000000000000"); // int64_min
+ str string2_9 = al_str_c("0b111111111111111111111111111111111111111111111111111111111111111"); // int64_max
+ str string2_10 = al_str_c("0b1000000000000000000000000000000000000000000000000000000000000000"); // overflow
+ str string2_11 = al_str_c("-0b1000000000000000000000000000000000000000000000000000000000000000"); // int64_min
+ str string3 = al_str_c("0xfff");
+ str string4 = al_str_c("0b01010");
+ str string5 = al_str_c("01010");
+ str string6 = al_str_c("9999999999999999999999999999999999");
+ str string7 = al_str_c(" -99999999999999999999");
+ str string8 = al_str_c("---99999999999999999999");
+ str string9 = al_str_c("'p[afd'dfdfs[f");
+ str string10 = al_str_c("\n\t 01010");
+ str string11 = al_str_c("-9223372036854775809");
+ str string12 = al_str_c("6519749124957310923");
+ str string13 = al_str_c("-3519311901742109472");
+ str string14 = al_str_c("18446744073709551614");
+ str string15 = al_str_c("-18446744073709551616");
+
+ bool error;
+
+ AL_TEST_EQ(al_str_to_long(&string0, 10, &error), 1738LL, s64);
+ AL_TEST_FALSE(error);
+
+ AL_TEST_EQ(al_str_to_long(&string1, 10, &error), -3563LL, s64);
+ AL_TEST_FALSE(error);
+
+ AL_TEST_EQ(al_str_to_long(&string2, 10, &error), -2147483647LL, s64);
+ AL_TEST_FALSE(error);
+
+ AL_TEST_EQ(al_str_to_long(&string2_1, 10, &error), -2147483648LL, s64);
+ AL_TEST_FALSE(error);
+
+ AL_TEST_EQ(al_str_to_long(&string2_2, 10, &error), -2147483649LL, s64);
+ AL_TEST_FALSE(error);
+
+ AL_TEST_EQ(al_str_to_long(&string2_3, 10, &error), INT64_MAX, s64);
+ AL_TEST_FALSE(error);
+
+ AL_TEST_EQ(al_str_to_long(&string2_4, 10, &error), INT64_MAX - 1, s64);
+ AL_TEST_FALSE(error);
+
+ al_str_to_long(&string2_5, 10, &error);
+ AL_TEST_TRUE(error);
+
+ AL_TEST_EQ(al_str_to_long(&string2_6, 16, &error), INT64_MAX, s64);
+ AL_TEST_FALSE(error);
+
+ al_str_to_long(&string2_7, 16, &error);
+ AL_TEST_TRUE(error);
+
+ AL_TEST_EQ(al_str_to_long(&string2_8, 16, &error), INT64_MIN, s64);
+ AL_TEST_FALSE(error);
+
+ AL_TEST_EQ(al_str_to_long(&string2_9, 2, &error), INT64_MAX, s64);
+ AL_TEST_FALSE(error);
+
+ al_str_to_long(&string2_10, 2, &error);
+ AL_TEST_TRUE(error);
+
+ AL_TEST_EQ(al_str_to_long(&string2_11, 2, &error), INT64_MIN, s64);
+ AL_TEST_FALSE(error);
- AL_TEST_EQ(al_str_to_long(s0, 10), 10353L, s64);
- AL_TEST_EQ(al_str_to_long(s1, 10), -3563L, s64);
- AL_TEST_EQ(al_str_to_long(s2, 10), -2147483647L, s64);
- AL_TEST_EQ(al_str_to_long(s2_1, 10), -2147483648L, s64);
- AL_TEST_EQ(al_str_to_long(s2_2, 10), -2147483649L, s64);
- AL_TEST_EQ(al_str_to_long(s3, 16), 0xfff, s64);
- AL_TEST_EQ(al_str_to_long(s4, 2), 0b01010, s64);
- AL_TEST_EQ(al_str_to_long(s5, 2), 0b01010, s64);
- AL_TEST_EQ(al_str_to_long(s6, 10), INT64_MAX, s64);
- AL_TEST_EQ(al_str_to_long(s7, 10), INT64_MIN, s64);
- AL_TEST_EQ(al_str_to_long(s8, 10), INT64_MIN, s64);
- AL_TEST_EQ(al_str_to_long(s9, 10), INT64_MAX, s64);
- AL_TEST_EQ(al_str_to_long(s10, 2), 0b01010, s64);
- AL_TEST_EQ(al_str_to_long(s11, 10), INT64_MIN, s64);
- AL_TEST_EQ(al_str_to_long(s12, 10), 6519749124957310923L, s64);
- AL_TEST_EQ(al_str_to_long(s13, 10), -3519311901742109472, s64);
+ AL_TEST_EQ(al_str_to_long(&string3, 16, &error), 0xfff, s64);
+ AL_TEST_FALSE(error);
+
+ AL_TEST_EQ(al_str_to_long(&string4, 2, &error), 0b01010, s64);
+ AL_TEST_FALSE(error);
+
+ AL_TEST_EQ(al_str_to_long(&string5, 2, &error), 0b01010, s64);
+ AL_TEST_FALSE(error);
+
+ al_str_to_long(&string6, 10, &error);
+ AL_TEST_TRUE(error);
+
+ al_str_to_long(&string7, 10, &error);
+ AL_TEST_TRUE(error);
+
+ al_str_to_long(&string8, 10, &error);
+ AL_TEST_TRUE(error);
+
+ al_str_to_long(&string9, 10, &error);
+ AL_TEST_TRUE(error);
+
+ AL_TEST_EQ(al_str_to_long(&string10, 2, &error), 0b01010, s64);
+ AL_TEST_FALSE(error);
+
+ al_str_to_long(&string11, 10, &error);
+ AL_TEST_TRUE(error);
+
+ AL_TEST_EQ(al_str_to_long(&string12, 10, &error), 6519749124957310923LL, s64);
+ AL_TEST_FALSE(error);
+
+ AL_TEST_EQ(al_str_to_long(&string13, 10, &error), -3519311901742109472, s64);
+ AL_TEST_FALSE(error);
+
+ al_str_to_long(&string14, 10, &error);
+ AL_TEST_TRUE(error);
+
+ al_str_to_long(&string15, 10, &error);
+ AL_TEST_TRUE(error);
AL_TEST_END();
}
-static str *global __attribute__((unused)) = al_str_c("yeeee");
+// Very non-exhaustive.
+static bool str_test_limits(void)
+{
+ AL_TEST_START("str_limits");
+
+ str s = al_str_null();
+
+ for (u32 i = 0; i < MAX_ALLOC_32 - 1; i++) {
+ al_str_cat(&s, &al_str_c("y"));
+ }
+ al_str_cat(&s, &al_str_c("x"));
+
+ AL_TEST_TRUE(al_str_atr(&s, 1) == 'x');
+ AL_TEST_TRUE(al_str_at(&s, MAX_ALLOC_32 - 1) == 'x');
+ AL_TEST_TRUE(al_str_atr(&s, 2) == 'y');
+
+ AL_TEST_END();
+}
+
+#ifndef _MSC_VER
+static str global_string = al_str_c("yeeee");
+#endif
static bool str_test_error_prone_str_c(void)
{
AL_TEST_START("str_error_prone_str_c");
- str *n = al_str_c("yoyoyoyoyo");
- AL_TEST_EQ(n->len, al_strlen("yoyoyoyoyo"), u32);
- AL_TEST_EQ(n->alloc, 0, u32);
- AL_TEST_EQ(al_memcmp(n->data, "yoyoyoyoyo", al_strlen("yoyoyoyoyo") + 1), 0, u32);
+ str n = al_str_c("yoyoyoyoyo");
+ AL_TEST_EQ(n.length, al_strlen("yoyoyoyoyo"), u32);
+ AL_TEST_EQ(n.alloc, 0, u32);
+ AL_TEST_EQ(al_memcmp(n.data, "yoyoyoyoyo", al_strlen("yoyoyoyoyo") + 1), 0, s32);
+
+#ifndef _MSC_VER
+ AL_TEST_TRUE(al_str_eq(&global_string, &al_str_c("yeeee")));
+#endif
// This is expected to cause a compile error.
#if 0
@@ -229,8 +332,8 @@ static bool str_test_error_prone_str_c(void)
str ds = *al_str_c(d);
str ss = *al_str_cr(d);
- AL_TEST_EQ(ds.len, (u32)(sizeof(char *) - 1), u32);
- AL_TEST_EQ(ss.len, (u32)al_strlen(s), u32);
+ AL_TEST_EQ(ds.length, (u32)(sizeof(char *) - 1), u32);
+ AL_TEST_EQ(ss.length, (u32)al_strlen(s), u32);
al_free(d);
@@ -240,8 +343,8 @@ static bool str_test_error_prone_str_c(void)
wstr wds = *al_wstr_c(wd);
wstr wss = *al_wstr_cr(wd);
- AL_TEST_EQ(wds.len, (u32)((sizeof(wchar_t *) / sizeof(wchar_t)) - 1), u32);
- AL_TEST_EQ(wss.len, (u32)wcslen(ws), u32);
+ AL_TEST_EQ(wds.length, (u32)((sizeof(wchar_t *) / sizeof(wchar_t)) - 1), u32);
+ AL_TEST_EQ(wss.length, (u32)wcslen(ws), u32);
al_free(wd);
#endif
@@ -249,7 +352,7 @@ static bool str_test_error_prone_str_c(void)
AL_TEST_END();
}
-bool str_tests_run(void)
+bool str_tests_run(u32 skip_mask)
{
AL_TEST_START_GROUP("str");
@@ -260,6 +363,9 @@ bool str_tests_run(void)
AL_TEST_RUN(str_test_substr);
AL_TEST_RUN(str_test_get_line);
AL_TEST_RUN(str_test_to_long);
+ if (skip_mask & AL_TESTS_RUN_LIMITS) {
+ AL_TEST_RUN(str_test_limits);
+ }
AL_TEST_RUN(str_test_error_prone_str_c);
AL_TEST_END_GROUP();
diff --git a/tests/str.h b/tests/str.h
index 64eb0fa..044f8f6 100644
--- a/tests/str.h
+++ b/tests/str.h
@@ -3,6 +3,6 @@
#include <al/types.h>
-bool str_tests_run(void);
+bool str_tests_run(u32 skip_mask);
#endif // _AL_STR_TESTS_H
generated by cgit v1.2.3-101-g0448 (git 2.54.0) at 2026-07-25 21:10:41 +0000