all: Consider types and numerical limits

 - Vastly improve tests.
 - Change array/str/wstr APIs.
 - Use ptrdiff_t instead of size_t in ring buffer.
 - Make random seed thread-local.
 - Log now uses a static thread-local buffer instead of a malloc'd buffer.

Signed-off-by: Andrew Opalach <andrew@akon.city>

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