test: Added a buch of tests, also fixes :)

ArenaPointer now contains a reference to the original arena and an
offset instad of a raw address. Change was made to avoid invalidating
addresses and keeping a more consise system. arena_unwrap_pointer was
also included as a helper function.

include/arena.h

@@ -26,7 +26,10 @@ typedef struct {
     bool is_valid;
     union {
         ArenaErr err;
-        uint8_t *address;
+        struct {
+            Arena *arena;
+            size_t offset;
+        };
     };
 } ArenaPointer;
 
@@ -52,15 +55,13 @@ void arena_destroy(Arena *arena);
 ArenaPointer arena_alloc(Arena *arena, size_t size, size_t alignment);
 ArenaPointer arena_push(Arena *arena, void *data, size_t size, size_t alignment);
 ArenaErr arena_realloc(Arena *arena, size_t new_capacity);
+void *arena_unwrap_pointer(ArenaPointer p);
 
-SizeResult get_arena_align_padding(Arena *arena, size_t alignment);
+SizeResult arena_get_align_padding(Arena *arena, size_t alignment);
 ArenaErr arena_ensure_capacity(Arena *arena, size_t size, size_t alignment);
 // Should be moved to something like general utilities,
 // i should make one for all my c projects
 bool mul_size_t_safe(size_t a, size_t b, size_t *out);
 
 
-
-
-
 #endif // !ARENA_H

src/arena.c

@@ -5,6 +5,8 @@
 #include <stdlib.h>
 #include <string.h>
 
+
+
 ArenaResult arena_init(size_t capacity) {
     if (capacity < 1) {
         return (ArenaResult) {.is_valid = false, .err = ARENA_INVALID_SIZE};
@@ -36,13 +38,20 @@ ArenaPointer arena_alloc(Arena *arena, size_t size, size_t alignment) {
         return (ArenaPointer) {.is_valid = false, .err = ARENA_NULL_ARG};
     }
 
-    SizeResult padding = get_arena_align_padding(arena, alignment);
+    if (size < 1) {
+        return (ArenaPointer) {.is_valid = false, .err = ARENA_INVALID_SIZE};
+    }
+
+    if (alignment < 1) {
+        return (ArenaPointer) {.is_valid = false, .err = ARENA_INVALID_ALIGN};
+    }
+
+    SizeResult padding = arena_get_align_padding(arena, alignment);
     if (!padding.is_valid) {
         return (ArenaPointer) {.is_valid = false, .err = padding.err};
     }
 
-
+    if (arena->offset + padding.val + size > arena->capacity) {
-    if (arena->offset + padding.val >= arena->capacity) {
         return (ArenaPointer) {.is_valid = false, .err = ARENA_OUT_OF_SPACE};
     }
 
@@ -53,7 +62,7 @@ ArenaPointer arena_alloc(Arena *arena, size_t size, size_t alignment) {
     size_t aligned_offset = arena->offset + padding.val;
 
     arena->offset = aligned_offset + size;
-    return (ArenaPointer) {.is_valid = true, .address = arena->buffer + aligned_offset};
+    return (ArenaPointer) {.is_valid = true, .offset = aligned_offset, .arena = arena};
 }
 
 ArenaErr arena_ensure_capacity(Arena *arena, size_t size, size_t alignment) {
@@ -61,7 +70,15 @@ ArenaErr arena_ensure_capacity(Arena *arena, size_t size, size_t alignment) {
         return ARENA_NULL_ARG;
     }
 
-    SizeResult padding = get_arena_align_padding(arena, alignment);
+    if (size < 1) {
+        return ARENA_INVALID_SIZE;
+    }
+
+    if (alignment < 1) {
+        return ARENA_INVALID_ALIGN;
+    }
+    
+    SizeResult padding = arena_get_align_padding(arena, alignment);
     if (!padding.is_valid) {
         return padding.err;
     }
@@ -93,6 +110,14 @@ ArenaPointer arena_push(Arena *arena, void *data, size_t size, size_t alignment)
         return (ArenaPointer) {.is_valid = false, .err = ARENA_NULL_ARG};
     }
 
+    if (size < 1) {
+        return (ArenaPointer) {.is_valid = false, .err = ARENA_INVALID_SIZE};
+    }
+
+    if (size < 1) {
+        return (ArenaPointer) {.is_valid = false, .err = ARENA_INVALID_ALIGN};
+    }
+
     ArenaErr err = arena_ensure_capacity(arena, size, alignment);
     if (err != ARENA_OK) {
         return (ArenaPointer) {.is_valid = false, .err = err};
@@ -104,7 +129,7 @@ ArenaPointer arena_push(Arena *arena, void *data, size_t size, size_t alignment)
     }
     
     memcpy(
-        pointer.address,
+        arena_unwrap_pointer(pointer),
         data,
         size);
 
@@ -116,6 +141,10 @@ ArenaErr arena_realloc(Arena *arena, size_t new_capacity) {
         return ARENA_NULL_ARG;
     }
 
+    if (new_capacity < 1) {
+        return ARENA_INVALID_SIZE;
+    }
+
     uint8_t *tmp = realloc(arena->buffer, new_capacity);
     if (tmp == NULL) {
         return ARENA_BAD_ALLOC;
@@ -126,7 +155,9 @@ ArenaErr arena_realloc(Arena *arena, size_t new_capacity) {
     return ARENA_OK;
 }
 
-SizeResult get_arena_align_padding(Arena *arena, size_t alignment) {
+
+
+SizeResult arena_get_align_padding(Arena *arena, size_t alignment) {
     if (arena == NULL) {
         return (SizeResult) {.is_valid = false, .err = ARENA_NULL_ARG};
     }
@@ -141,6 +172,13 @@ SizeResult get_arena_align_padding(Arena *arena, size_t alignment) {
     return (SizeResult) {.is_valid = true, .err = aligned - current_address};
 }
 
+void *arena_unwrap_pointer(ArenaPointer p) {
+    if (!p.is_valid) {
+        return NULL;
+    }
+    return p.arena->buffer + p.offset;
+}
+
 bool mul_size_t_safe(size_t a, size_t b, size_t *out) {
     if (out == NULL) {
         return true;

test/test_arena.c

@@ -7,6 +7,7 @@
 #include <setjmp.h>
 #include <cmocka.h>
 #include <string.h>
+#include <limits.h>
 
 #include "arena.h"
 
@@ -20,17 +21,18 @@ static void test_push_3_ints(void **state) {
     int int_to_push = 20;
     ArenaPointer result = arena_push(&arena, &int_to_push, sizeof(int), alignof(int));
     assert_true(result.is_valid);
-    assert_int_equal(20, *(int*)result.address);
+    assert_int_equal(20, *(int*)arena_unwrap_pointer(result));
+    assert_int_equal(20, *(int*)arena_unwrap_pointer(result));
 
     int_to_push = 30;
     result = arena_push(&arena, &int_to_push, sizeof(int), alignof(int));
     assert_true(result.is_valid);
-    assert_int_equal(30, *(int*) result.address);
+    assert_int_equal(30, *(int*)arena_unwrap_pointer(result));
 
     int_to_push = 40;
     result = arena_push(&arena, &int_to_push, sizeof(int), alignof(int));
     assert_true(result.is_valid);
-    assert_int_equal(40, *(int*) result.address);
+    assert_int_equal(40, *(int*)arena_unwrap_pointer(result));
 
     arena_destroy(&arena);
 }
@@ -45,36 +47,89 @@ static void test_push_3_ints_2_doubles(void **state) {
     int int_to_push = 20;
     ArenaPointer result = arena_push(&arena, &int_to_push, sizeof(int), alignof(int));
     assert_true(result.is_valid);
-    assert_int_equal(20, *(int*)result.address);
+    assert_int_equal(20, *(int*)arena_unwrap_pointer(result));
 
     double double_to_push = 4.57;
     result = arena_push(&arena, &double_to_push, sizeof(double), alignof(double));
     assert_true(result.is_valid);
-    assert_double_equal(4.57, *(double*)result.address, 1e-6);
+    assert_double_equal(4.57, *(double*)arena_unwrap_pointer(result), 1e-6);
 
     int_to_push = 30;
     result = arena_push(&arena, &int_to_push, sizeof(int), alignof(int));
     assert_true(result.is_valid);
-    assert_int_equal(30, *(int*)result.address);
+    assert_int_equal(30, *(int*)arena_unwrap_pointer(result));
 
     int_to_push = 40;
     result = arena_push(&arena, &int_to_push, sizeof(int), alignof(int));
     assert_true(result.is_valid);
-    assert_int_equal(40, *(int*) result.address);
+    assert_int_equal(40, *(int*)arena_unwrap_pointer(result));
 
     double_to_push = 267.33;
     result = arena_push(&arena, &double_to_push, sizeof(double), alignof(double));
     assert_true(result.is_valid);
-    assert_double_equal(267.33, *(double*) result.address, 1e-6);
+    assert_double_equal(267.33, *(double*)arena_unwrap_pointer(result), 1e-6);
 
     arena_destroy(&arena);
 }
 
+static void test_init_arena_0_cap(void **state) {
+    (void) state;
+
+    ArenaResult arena = arena_init(0);
+    assert_false(arena.is_valid);
+    assert_int_equal(arena.err, ARENA_INVALID_SIZE);
+}
+
+static void test_arena_alloc_size_0(void **state) {
+    (void) state;
+
+    ArenaResult value = arena_init(64);
+    assert_true(value.is_valid);
+    Arena arena = value.arena;
+
+    ArenaPointer pointer = arena_alloc(&arena, 0, alignof(int));
+    assert_false(pointer.is_valid);
+    assert_int_equal(pointer.err, ARENA_INVALID_SIZE);
+
+    arena_destroy(&arena);
+}
+
+static void test_arena_alloc_size_max(void **state) {
+    (void) state;
+
+    ArenaResult value = arena_init(64);
+    assert_true(value.is_valid);
+    Arena arena = value.arena;
+
+    ArenaPointer pointer = arena_alloc(&arena, SIZE_MAX, alignof(int));
+    assert_false(pointer.is_valid);
+    assert_int_equal(pointer.err, ARENA_OUT_OF_SPACE);
+
+    arena_destroy(&arena);
+}
+
+static void test_arena_align_size_0(void **state) {
+    (void) state;
+
+    ArenaResult value = arena_init(64);
+    assert_true(value.is_valid);
+    Arena arena = value.arena;
+
+    ArenaPointer pointer = arena_alloc(&arena, sizeof(int), 0);
+    assert_false(pointer.is_valid);
+    assert_int_equal(pointer.err, ARENA_INVALID_ALIGN);
+
+    arena_destroy(&arena);
+}
 
 int main(void) {
     const struct CMUnitTest tests[] = {
         cmocka_unit_test(test_push_3_ints),
         cmocka_unit_test(test_push_3_ints_2_doubles),
+        cmocka_unit_test(test_init_arena_0_cap),
+        cmocka_unit_test(test_arena_alloc_size_0),
+        cmocka_unit_test(test_arena_alloc_size_max),
+        cmocka_unit_test(test_arena_align_size_0),
     };