diff --git a/src/lae_arraylist.c b/src/lae_arraylist.c
index ae8efc0..47e8bb5 100644
--- a/src/lae_arraylist.c
+++ b/src/lae_arraylist.c
@@ -508,6 +508,7 @@ ArrayListErr arraylist_slice_unsafe(
     new_slice->end = start + len;
     new_slice->current = start;
     new_slice->is_safe = false;
+    new_slice->allocator = allocator;
 
     *slice = new_slice;
     return ARRLIST_OK;
diff --git a/test/test_arraylist.c b/test/test_arraylist.c
index bd14211..0ac85a2 100644
--- a/test/test_arraylist.c
+++ b/test/test_arraylist.c
@@ -7,6 +7,7 @@
 #include <stdint.h>
 #include <string.h>
 
+#include "lae_allocator.h"
 #include "lae_arraylist.h"
 
 // INIT
@@ -15,7 +16,9 @@ static void test_init_valid_parameters(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
     arraylist_destroy(&arr);
 }
 
@@ -24,7 +27,7 @@ static void test_init_zero_capacity(void **state) {
 
     ArrayList *arr;
     assert_uint_equal(
-        arraylist_init(&arr, 0, sizeof(int)),
+        arraylist_init(&arr, allocator_default(), 0, sizeof(int)),
         ARRLIST_INVALID_CAPACITY);
     arraylist_destroy(&arr);
 }
@@ -33,7 +36,9 @@ static void test_init_zero_elem_size(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_uint_equal(arraylist_init(&arr, 64, 0), ARRLIST_INVALID_ELEM_SIZE);
+    assert_uint_equal(
+        arraylist_init(&arr, allocator_default(), 64, 0),
+        ARRLIST_INVALID_ELEM_SIZE);
     arraylist_destroy(&arr);
 }
 
@@ -42,7 +47,7 @@ static void test_init_large_capacity(void **state) {
 
     ArrayList *arr;
     assert_uint_equal(
-        arraylist_init(&arr, SIZE_MAX, sizeof(int)),
+        arraylist_init(&arr, allocator_default(), SIZE_MAX, sizeof(int)),
         ARRLIST_INVALID_CAPACITY);
     arraylist_destroy(&arr);
 }
@@ -53,7 +58,9 @@ static void test_destroy_valid_array(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
     arraylist_destroy(&arr);
     assert_null(arr);
 }
@@ -72,7 +79,9 @@ static void test_destroy_double(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     ArrayListErr err = arraylist_destroy(&arr);
     assert_uint_equal(err, ARRLIST_OK);
@@ -87,7 +96,9 @@ static void test_destroy_while_borrowed(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -95,7 +106,12 @@ static void test_destroy_while_borrowed(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     assert_uint_equal(arraylist_destroy(&arr), ARRLIST_IS_BORROWED);
@@ -109,7 +125,9 @@ static void test_capacity_after_init(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     assert_uint_equal(arraylist_capacity(arr), 64);
 
@@ -120,7 +138,9 @@ static void test_is_empty_after_init(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     assert_true(arraylist_is_empty(arr));
 
@@ -131,7 +151,9 @@ static void test_is_empty_after_push(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -145,7 +167,9 @@ static void test_size_after_many_push(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -167,7 +191,9 @@ static void test_capacity_growth_on_push(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 2, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 2, sizeof(int)),
+        ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -186,7 +212,9 @@ static void test_capacity_shrink_on_pop(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 8, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 8, sizeof(int)),
+        ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -201,7 +229,9 @@ static void test_push_back_single_element(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -218,7 +248,9 @@ static void test_push_back_multiple_elements(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -272,7 +304,7 @@ static void test_push_back_null_data(void **state) {
     (void)state;
 
     ArrayList *arr;
-    arraylist_init(&arr, 64, sizeof(int));
+    arraylist_init(&arr, allocator_default(), 64, sizeof(int));
 
     assert_uint_equal(arraylist_push_back(arr, NULL), ARRLIST_NULL_ARG);
 
@@ -283,7 +315,9 @@ static void test_push_back_while_borrowed(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -291,7 +325,12 @@ static void test_push_back_while_borrowed(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     int n = 8;
@@ -306,7 +345,9 @@ static void test_push_front_single_element(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     int n = 8;
     int m;
@@ -322,7 +363,9 @@ static void test_push_front_multiple_elements(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     int n = 8;
     int m;
@@ -351,7 +394,9 @@ static void test_push_front_null_data(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     assert_int_equal(arraylist_push_front(arr, NULL), ARRLIST_NULL_ARG);
 
@@ -362,7 +407,9 @@ static void test_push_front_while_borrowed(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -370,7 +417,12 @@ static void test_push_front_while_borrowed(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     int n = 8;
@@ -385,7 +437,9 @@ static void test_insert_at_beginning(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -406,7 +460,9 @@ static void test_insert_at_middle(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -427,7 +483,9 @@ static void test_insert_at_end(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -448,7 +506,9 @@ static void test_insert_at_invalid_index(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_insert(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS);
@@ -469,7 +529,9 @@ static void test_insert_null_data(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     assert_uint_equal(arraylist_insert(arr, 0, NULL), ARRLIST_NULL_ARG);
 
@@ -480,7 +542,9 @@ static void test_insert_while_borrowed(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -488,7 +552,12 @@ static void test_insert_while_borrowed(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     int n = 8;
@@ -503,7 +572,9 @@ static void test_pop_back_single_element(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -520,7 +591,9 @@ static void test_pop_back_multiple_elements(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -540,7 +613,9 @@ static void test_pop_back_until_empty(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -562,7 +637,9 @@ static void test_pop_back_empty_array(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     int n;
     assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_EMPTY);
@@ -583,7 +660,9 @@ static void test_pop_back_null_out(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -597,7 +676,9 @@ static void test_pop_back_while_borrowed(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -605,7 +686,12 @@ static void test_pop_back_while_borrowed(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     int n = 8;
@@ -620,7 +706,9 @@ static void test_pop_front_single_element(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -637,7 +725,9 @@ static void test_pop_front_multiple_elements(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -658,7 +748,9 @@ static void test_pop_front_until_empty(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -681,7 +773,9 @@ static void test_pop_front_empty_array(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     int n;
     assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_EMPTY);
@@ -702,7 +796,9 @@ static void test_pop_front_null_out(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -716,7 +812,9 @@ static void test_pop_front_while_borrowed(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -724,7 +822,12 @@ static void test_pop_front_while_borrowed(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
     assert_non_null(slice);
 
@@ -740,7 +843,9 @@ static void test_remove_at_beginning(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -759,7 +864,9 @@ static void test_remove_at_middle(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -778,7 +885,9 @@ static void test_remove_at_end(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -797,7 +906,9 @@ static void test_remove_at_invalid_index(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_remove_at(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS);
@@ -818,7 +929,9 @@ static void test_remove_at_null_data(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -832,7 +945,9 @@ static void test_remove_at_while_borrowed(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -840,7 +955,12 @@ static void test_remove_at_while_borrowed(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     int n = 8;
@@ -855,7 +975,9 @@ static void test_get_valid_index(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -872,7 +994,9 @@ static void test_get_first_element(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -889,7 +1013,9 @@ static void test_get_last_element(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -906,7 +1032,9 @@ static void test_get_invalid_index(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -931,7 +1059,9 @@ static void test_get_null_out(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -946,7 +1076,9 @@ static void test_get_while_borrowed(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -954,7 +1086,12 @@ static void test_get_while_borrowed(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     int n = 8;
@@ -969,7 +1106,9 @@ static void test_set_valid_index(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -988,7 +1127,9 @@ static void test_set_first_element(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1007,7 +1148,9 @@ static void test_set_last_element(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1026,7 +1169,9 @@ static void test_set_invalid_index(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1051,7 +1196,9 @@ static void test_set_null_data(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     assert_uint_equal(arraylist_set(arr, 8, NULL), ARRLIST_NULL_ARG);
 
@@ -1062,7 +1209,9 @@ static void test_set_while_borrowed(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1070,7 +1219,12 @@ static void test_set_while_borrowed(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     int n = 8;
@@ -1085,7 +1239,9 @@ static void test_clear_non_empty_array(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1102,7 +1258,9 @@ static void test_clear_already_empty_array(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     assert_uint_equal(arraylist_clear(arr), ARRLIST_OK);
 
@@ -1121,7 +1279,9 @@ static void test_clear_while_borrowed(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1129,7 +1289,12 @@ static void test_clear_while_borrowed(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     assert_uint_equal(arraylist_clear(arr), ARRLIST_IS_BORROWED);
@@ -1143,7 +1308,9 @@ static void test_resize_increase_capacity(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_OK);
     assert_uint_equal(arraylist_capacity(arr), 128);
@@ -1155,7 +1322,9 @@ static void test_resize_decrease_capacity(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     assert_uint_equal(arraylist_resize(arr, 32), ARRLIST_OK);
     assert_uint_equal(arraylist_capacity(arr), 32);
@@ -1167,7 +1336,9 @@ static void test_resize_to_zero(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     assert_uint_equal(arraylist_resize(arr, 0), ARRLIST_INVALID_CAPACITY);
     assert_uint_equal(arraylist_capacity(arr), 64);
@@ -1179,7 +1350,9 @@ static void test_resize_to_size_max(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     assert_uint_equal(arraylist_resize(arr, SIZE_MAX), ARRLIST_ALLOC_OVERFLOW);
     assert_uint_equal(arraylist_capacity(arr), 64);
@@ -1199,7 +1372,9 @@ static void test_resize_while_borrowed(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1207,7 +1382,12 @@ static void test_resize_while_borrowed(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_IS_BORROWED);
@@ -1221,7 +1401,9 @@ static void test_reserve_normal_capacity(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     assert_uint_equal(arraylist_reserve(arr, 32), ARRLIST_OK);
     assert_uint_equal(arraylist_capacity(arr), 96);
@@ -1233,7 +1415,9 @@ static void test_reserve_size_max(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     assert_uint_equal(arraylist_reserve(arr, SIZE_MAX), ARRLIST_ALLOC_OVERFLOW);
     assert_uint_equal(arraylist_capacity(arr), 64);
@@ -1245,7 +1429,9 @@ static void test_reserve_size_0(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     assert_uint_equal(arraylist_reserve(arr, 0), ARRLIST_OK);
     assert_uint_equal(arraylist_capacity(arr), 64);
@@ -1257,7 +1443,9 @@ static void test_reserve_while_borrowed(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1265,7 +1453,12 @@ static void test_reserve_while_borrowed(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     assert_uint_equal(arraylist_reserve(arr, 128), ARRLIST_IS_BORROWED);
@@ -1279,14 +1472,18 @@ static void test_slice_valid_init(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
     ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, 10), ARRLIST_OK);
+    assert_uint_equal(
+        arraylist_slice(&slice, allocator_default(), arr, 0, 10),
+        ARRLIST_OK);
 
     arrayslice_destroy(&slice);
     arraylist_destroy(&arr);
@@ -1296,7 +1493,9 @@ static void test_slice_invalid_index(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1304,7 +1503,7 @@ static void test_slice_invalid_index(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 32, 10),
+        arraylist_slice(&slice, allocator_default(), arr, 32, 10),
         ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
@@ -1314,7 +1513,9 @@ static void test_slice_invalid_len(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1322,7 +1523,7 @@ static void test_slice_invalid_len(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, 300),
+        arraylist_slice(&slice, allocator_default(), arr, 0, 300),
         ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
@@ -1332,7 +1533,9 @@ static void test_slice_len_zero(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1340,7 +1543,7 @@ static void test_slice_len_zero(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, 0),
+        arraylist_slice(&slice, allocator_default(), arr, 0, 0),
         ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
@@ -1350,10 +1553,14 @@ static void test_slice_empty_array(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, 10), ARRLIST_INVALID_ARR);
+    assert_uint_equal(
+        arraylist_slice(&slice, allocator_default(), arr, 0, 10),
+        ARRLIST_INVALID_ARR);
 
     arraylist_destroy(&arr);
 }
@@ -1364,7 +1571,9 @@ static void test_slice_null_arr(void **state) {
     ArrayList *arr = NULL;
 
     ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, 10), ARRLIST_NULL_ARG);
+    assert_uint_equal(
+        arraylist_slice(&slice, allocator_default(), arr, 0, 10),
+        ARRLIST_NULL_ARG);
 }
 
 // Slice Unsafe
@@ -1372,14 +1581,18 @@ static void test_slice_unsafe_valid_init(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
     ArraySlice *slice;
-    assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 10), ARRLIST_OK);
+    assert_uint_equal(
+        arraylist_slice_unsafe(&slice, allocator_default(), arr, 0, 10),
+        ARRLIST_OK);
 
     arrayslice_destroy(&slice);
     arraylist_destroy(&arr);
@@ -1389,7 +1602,9 @@ static void test_slice_unsafe_invalid_index(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1397,7 +1612,7 @@ static void test_slice_unsafe_invalid_index(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice_unsafe(&slice, arr, 32, 10),
+        arraylist_slice_unsafe(&slice, allocator_default(), arr, 32, 10),
         ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
@@ -1407,7 +1622,9 @@ static void test_slice_unsafe_invalid_len(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1415,7 +1632,7 @@ static void test_slice_unsafe_invalid_len(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice_unsafe(&slice, arr, 0, 300),
+        arraylist_slice_unsafe(&slice, allocator_default(), arr, 0, 300),
         ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
@@ -1425,7 +1642,9 @@ static void test_slice_unsafe_len_zero(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1433,7 +1652,7 @@ static void test_slice_unsafe_len_zero(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice_unsafe(&slice, arr, 0, 0),
+        arraylist_slice_unsafe(&slice, allocator_default(), arr, 0, 0),
         ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
@@ -1443,11 +1662,13 @@ static void test_slice_unsafe_empty_array(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice_unsafe(&slice, arr, 0, 10),
+        arraylist_slice_unsafe(&slice, allocator_default(), arr, 0, 10),
         ARRLIST_INVALID_ARR);
 
     arraylist_destroy(&arr);
@@ -1460,7 +1681,7 @@ static void test_slice_unsafe_null_arr(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice_unsafe(&slice, arr, 0, 10),
+        arraylist_slice_unsafe(&slice, allocator_default(), arr, 0, 10),
         ARRLIST_NULL_ARG);
 }
 
@@ -1469,7 +1690,9 @@ static void test_slice_destroy_valid(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1477,7 +1700,12 @@ static void test_slice_destroy_valid(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_OK);
@@ -1488,7 +1716,9 @@ static void test_slice_destroy_null_slice(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1504,14 +1734,21 @@ static void test_slice_double_destroy(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_OK);
@@ -1524,14 +1761,21 @@ static void test_slice_peek_valid_array(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     int m;
@@ -1546,7 +1790,9 @@ static void test_slice_peek_invalid_array(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1554,7 +1800,12 @@ static void test_slice_peek_invalid_array(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK);
@@ -1570,7 +1821,9 @@ static void test_slice_peek_null_out(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1578,7 +1831,12 @@ static void test_slice_peek_null_out(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     assert_uint_equal(arrayslice_peek(slice, NULL), ARRLIST_NULL_ARG);
@@ -1601,7 +1859,9 @@ static void test_slice_next_valid_array(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1609,7 +1869,12 @@ static void test_slice_next_valid_array(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     int m;
@@ -1624,7 +1889,9 @@ static void test_slice_next_invalid_array(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1632,7 +1899,12 @@ static void test_slice_next_invalid_array(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK);
@@ -1648,7 +1920,9 @@ static void test_slice_next_null_out(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1656,7 +1930,12 @@ static void test_slice_next_null_out(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     assert_uint_equal(arrayslice_next(slice, NULL), ARRLIST_OK);
@@ -1678,7 +1957,9 @@ static void test_slice_next_until_invalid(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1686,7 +1967,12 @@ static void test_slice_next_until_invalid(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     int m;
@@ -1705,7 +1991,9 @@ static void test_slice_reset_valid_slice(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1713,7 +2001,12 @@ static void test_slice_reset_valid_slice(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     int m;
@@ -1748,7 +2041,9 @@ static void test_slice_advance_valid_slice(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1756,7 +2051,12 @@ static void test_slice_advance_valid_slice(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     int m;
@@ -1775,7 +2075,9 @@ static void test_slice_advance_out_of_bounds(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1783,7 +2085,12 @@ static void test_slice_advance_out_of_bounds(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     int m;
@@ -1802,7 +2109,9 @@ static void test_slice_advance_size_max(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1810,7 +2119,12 @@ static void test_slice_advance_size_max(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     int m;
@@ -1840,7 +2154,9 @@ static void test_slice_to_array_valid(void **state) {
     (void)state;
 
     ArrayList *arr;
-    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1848,11 +2164,18 @@ static void test_slice_to_array_valid(void **state) {
 
     ArraySlice *slice;
     assert_uint_equal(
-        arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
         ARRLIST_OK);
 
     ArrayList *arr2;
-    assert_uint_equal(arrayslice_to_arraylist(&arr2, slice), ARRLIST_OK);
+    assert_uint_equal(
+        arrayslice_to_arraylist(&arr2, allocator_default(), slice),
+        ARRLIST_OK);
     assert_uint_equal(arraylist_capacity(arr2), 64);
     assert_uint_equal(arraylist_size(arr2), 10);
 
@@ -1867,7 +2190,9 @@ static void test_slice_to_array_null_slice(void **state) {
     ArraySlice *slice = NULL;
     ArrayList *arr = NULL;
 
-    assert_uint_equal(arrayslice_to_arraylist(&arr, slice), ARRLIST_NULL_ARG);
+    assert_uint_equal(
+        arrayslice_to_arraylist(&arr, allocator_default(), slice),
+        ARRLIST_NULL_ARG);
 }
 
 int main(void) {
diff --git a/xmake.lua b/xmake.lua
index 7564556..d8c8452 100644
--- a/xmake.lua
+++ b/xmake.lua
@@ -75,7 +75,7 @@ end
 -- =========================================================
 
 if has_config("tests") then
-	target("test_arena")
+	target("test_arraylist")
 	set_kind("binary")
 
 	add_files("test/test_arraylist.c")