test/refactor: lock approach taken, best one

test/test_arena.c

@@ -209,6 +209,59 @@ static void test_arena_ensure_capacity_align_max(void **state) {
     arena_destroy(&arena);
 }
 
+static void test_arena_allocator_valid_allocation(void **state) {
+    (void)state;
+
+    Arena *arena;
+    assert_uint_equal(arena_init(&arena, allocator_default(), 64), ARENA_OK);
+
+    ArenaAllocator result = arena_get_allocator(arena);
+    assert_true(result.is_valid);
+
+    Allocator arena_allocator = result.allocator;
+
+    int *x =
+        arena_allocator.alloc(arena_allocator.ctx, sizeof(int), alignof(int));
+
+    assert_non_null(x);
+
+    *x = 34;
+    assert_int_equal(*x, 34);
+
+    arena_destroy(&arena);
+}
+
+static void test_arena_allocatro_many_allocations(void **state) {
+    (void)state;
+
+    Arena *arena;
+    assert_uint_equal(arena_init(&arena, allocator_default(), 64), ARENA_OK);
+
+    ArenaAllocator result = arena_get_allocator(arena);
+    assert_true(result.is_valid);
+
+    Allocator arena_allocator = result.allocator;
+    for (int i = 0; i < 10; i++) {
+        int *x = arena_allocator.alloc(
+            arena_allocator.ctx,
+            sizeof(int),
+            alignof(int));
+
+        assert_non_null(x);
+    }
+
+    arena_destroy(&arena);
+}
+
+static void test_arena_allocator_from_null_arena(void **state) {
+    (void)state;
+
+    Arena *arena = NULL;
+
+    ArenaAllocator result = arena_get_allocator(arena);
+    assert_false(result.is_valid);
+}
+
 int main(void) {
     const struct CMUnitTest tests[] = {
         cmocka_unit_test(test_push_3_ints),
@@ -223,6 +276,7 @@ int main(void) {
         cmocka_unit_test(test_arena_ensure_capacity_align_max),
         cmocka_unit_test(test_arena_ensure_capacity_size_0),
         cmocka_unit_test(test_arena_ensure_capacity_size_max),
+        cmocka_unit_test(test_arena_allocator_valid_allocation),
     };
 
     return cmocka_run_group_tests(tests, NULL, NULL);