diff --git a/.gitignore b/.gitignore
index 0bd57ed..d1a83ec 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,6 +7,12 @@ out/
 out/Debug/
 out/Release/
 
+# xmake
+xmake/
+xmake/*
+.xmake
+.xmake/*
+
 # Cmake files
 CMakeCache.txt
 CMakeFiles/
diff --git a/CMakeLists.txt b/CMakeLists.txt
deleted file mode 100644
index 03891fd..0000000
--- a/CMakeLists.txt
+++ /dev/null
@@ -1,98 +0,0 @@
-cmake_minimum_required(VERSION 3.20)
-project(
-  arraylist
-  VERSION 1.0
-  LANGUAGES C)
-
-# ------------------------------------------------
-# Estandard C
-# ------------------------------------------------
-set(CMAKE_C_STANDARD 11)
-set(CMAKE_C_STANDARD_REQUIRED ON)
-set(CMAKE_C_EXTENSIONS OFF)
-
-# Exportar compile_commands.json (clangd / IDEs)
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-
-# ------------------------------------------------
-# Is Top project?
-# ------------------------------------------------
-if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-  set(ARRAYLIST_IS_TOP_LEVEL ON)
-else()
-  set(ARRAYLIST_IS_TOP_LEVEL OFF)
-endif()
-
-# ------------------------------------------------
-# Opciones
-# ------------------------------------------------
-option(ARRAYLIST_BUILD_TESTS "Build tests" ${ARRAYLIST_IS_TOP_LEVEL})
-option(ARRAYLIST_BUILD_EXAMPLE "Build example" ${ARRAYLIST_IS_TOP_LEVEL})
-option(ARRAYLIST_ENABLE_INSTALL "Enable install" ${ARRAYLIST_IS_TOP_LEVEL})
-option(ARRAYLIST_ENABLE_SANITIZERS "Enable Sanitizers for test" ON)
-
-# ------------------------------------------------
-# Warning Flags (GCC/Clang vs MSVC)
-# ------------------------------------------------
-if(MSVC)
-  set(ARRAYLIST_WARNING_FLAGS /W4)
-else()
-  set(ARRAYLIST_WARNING_FLAGS -Wall -Wextra -Wpedantic)
-endif()
-
-# ------------------------------------------------
-# Main Library
-# ------------------------------------------------
-add_library(arraylist src/arraylist.c)
-
-# Alias con namespace → los consumidores via CPM/FetchContent pueden escribir
-# target_link_libraries(mi_app arraylist::arraylist)
-add_library(arraylist::arraylist ALIAS arraylist)
-
-target_include_directories(
-  arraylist PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-                   $<INSTALL_INTERFACE:include>)
-
-# Flagas only for compile lib
-target_compile_options(arraylist PRIVATE ${ARRAYLIST_WARNING_FLAGS})
-
-# Propagates c11 as requirement
-target_compile_features(arraylist PUBLIC c_std_11)
-
-# ------------------------------------------------
-# Example only built when is main proyect
-# ------------------------------------------------
-if(ARRAYLIST_BUILD_EXAMPLE)
-  add_executable(arraylist_example src/main.c)
-  target_link_libraries(arraylist_example PRIVATE arraylist)
-endif()
-
-# ------------------------------------------------
-# Tests
-# ------------------------------------------------
-if(ARRAYLIST_BUILD_TESTS)
-  enable_testing()
-  add_subdirectory(test)
-endif()
-
-# ------------------------------------------------
-# Installation rules
-# ------------------------------------------------
-if(ARRAYLIST_ENABLE_INSTALL)
-  include(GNUInstallDirs)
-
-  install(
-    TARGETS arraylist
-    EXPORT arraylistTargets
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-
-  install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-
-  install(
-    EXPORT arraylistTargets
-    FILE arraylistTargets.cmake
-    NAMESPACE arraylist::
-    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/arraylist)
-endif()
diff --git a/include/arraylist.h b/include/lae_arraylist.h
similarity index 72%
rename from include/arraylist.h
rename to include/lae_arraylist.h
index 78149a6..a836467 100644
--- a/include/arraylist.h
+++ b/include/lae_arraylist.h
@@ -1,9 +1,10 @@
-#ifndef ARRAYLIST_H
-#define ARRAYLIST_H
+#ifndef LAE_ARRAYLIST_H
+#define LAE_ARRAYLIST_H
 
+#include "lae_allocator.h"
 #include <inttypes.h>
-#include <stddef.h>
 #include <stdbool.h>
+#include <stddef.h>
 
 typedef struct ArrayList ArrayList;
 
@@ -25,7 +26,11 @@ typedef enum {
     ARRLIST_BORROW_UNDERFLOW,
 } ArrayListErr;
 
-ArrayListErr arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size);
+ArrayListErr arraylist_init(
+    ArrayList **arr,
+    Allocator allocator,
+    size_t capacity,
+    size_t elem_size);
 ArrayListErr arraylist_destroy(ArrayList **arr);
 ArrayListErr arraylist_clear(ArrayList *arr);
 ArrayList *arraylist_clone(const ArrayList *arr);
@@ -35,8 +40,8 @@ size_t arraylist_capacity(const ArrayList *arr);
 bool arraylist_is_empty(const ArrayList *arr);
 
 ArrayListErr arraylist_push_back(ArrayList *arr, void *data);
-ArrayListErr arraylist_insert(ArrayList*arr, size_t index, void *data);
-ArrayListErr arraylist_push_front(ArrayList* arr, void *data);
+ArrayListErr arraylist_insert(ArrayList *arr, size_t index, void *data);
+ArrayListErr arraylist_push_front(ArrayList *arr, void *data);
 
 // Here out can be null for not having anything writen
 ArrayListErr arraylist_pop_back(ArrayList *arr, void *out);
@@ -49,9 +54,21 @@ ArrayListErr arraylist_set(ArrayList *arr, size_t index, void *data);
 ArrayListErr arraylist_resize(ArrayList *arr, size_t new_capacity);
 ArrayListErr arraylist_reserve(ArrayList *arr, size_t size_to_reserve);
 
-//Slice stuff
-ArrayListErr arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, size_t len);
-ArrayListErr arraylist_slice_unsafe(ArraySlice **slice, ArrayList *arr, size_t start, size_t len);
+// Slice stuff
+ArrayListErr arraylist_slice(
+    ArraySlice **slice,
+    Allocator allocator,
+    ArrayList *arr,
+    size_t start,
+    size_t len);
+
+ArrayListErr arraylist_slice_unsafe(
+    ArraySlice **slice,
+    Allocator allocator,
+    ArrayList *arr,
+    size_t start,
+    size_t len);
+
 ArrayListErr arrayslice_destroy(ArraySlice **slice);
 
 bool arrayslice_is_valid(const ArraySlice *slice);
@@ -65,6 +82,9 @@ ArrayListErr arrayslice_next(ArraySlice *slice, void *out);
 ArrayListErr arrayslice_reset(ArraySlice *slice);
 ArrayListErr arrayslice_advance(ArraySlice *slice, size_t n);
 
-ArrayListErr arrayslice_to_arraylist(ArrayList **arr, const ArraySlice *slice);
+ArrayListErr arrayslice_to_arraylist(
+    ArrayList **arr,
+    Allocator allocator,
+    const ArraySlice *slice);
 
 #endif
diff --git a/src/arraylist.c b/src/lae_arraylist.c
similarity index 83%
rename from src/arraylist.c
rename to src/lae_arraylist.c
index b401d0f..47e8bb5 100644
--- a/src/arraylist.c
+++ b/src/lae_arraylist.c
@@ -1,15 +1,19 @@
-#include "arraylist.h"
+#include "lae_arraylist.h"
+#include "lae_allocator.h"
+#include <stdalign.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
-struct ArrayList{
+struct ArrayList {
     uint8_t *buffer;
     size_t capacity;
     size_t len;
     size_t elem_size;
     size_t borrows;
+
+    Allocator allocator;
 };
 
 struct ArraySlice {
@@ -18,6 +22,8 @@ struct ArraySlice {
     size_t end;
     size_t current;
     bool is_safe;
+
+    Allocator allocator;
 };
 
 // Grow and shrink factor is 2, 1.5 might give different results i guess
@@ -26,11 +32,15 @@ struct ArraySlice {
 static ArrayListErr arraylist_grow(ArrayList *arr);
 static ArrayListErr arraylist_shrink(ArrayList *arr);
 
-ArrayListErr arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size) {
+ArrayListErr arraylist_init(
+    ArrayList **arr,
+    Allocator allocator,
+    size_t capacity,
+    size_t elem_size) {
     if (arr == NULL) {
         return ARRLIST_NULL_ARG;
     }
-    
+
     *arr = NULL;
 
     if (capacity == 0) {
@@ -45,7 +55,8 @@ ArrayListErr arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size)
         return ARRLIST_INVALID_CAPACITY;
     }
 
-    ArrayList *new_arr = malloc(sizeof(ArrayList));
+    ArrayList *new_arr =
+        allocator.alloc(allocator.ctx, sizeof(ArrayList), alignof(ArrayList));
     if (new_arr == NULL) {
         return ARRLIST_BAD_ALLOC;
     }
@@ -54,9 +65,14 @@ ArrayListErr arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size)
     new_arr->elem_size = elem_size;
     new_arr->len = 0;
     new_arr->borrows = 0;
-    new_arr->buffer = malloc(capacity * elem_size);
+    new_arr->buffer = allocator.alloc(allocator.ctx, capacity * elem_size, 0);
+    new_arr->allocator = allocator;
     if (new_arr->buffer == NULL) {
-        free(new_arr);
+        allocator.free(
+            allocator.ctx,
+            new_arr,
+            sizeof(ArrayList),
+            alignof(ArrayList));
         return ARRLIST_BAD_ALLOC;
     }
 
@@ -73,9 +89,12 @@ ArrayListErr arraylist_destroy(ArrayList **arr) {
         return ARRLIST_IS_BORROWED;
     }
 
+    ArrayList *tmp = *arr;
+
     // No problem on using free on NULL :)
-    free((*arr)->buffer);
-    free(*arr);
+    tmp->allocator.free(tmp->allocator.ctx, tmp->buffer, tmp->capacity, 0);
+    tmp->allocator
+        .free(tmp->allocator.ctx, tmp, sizeof(ArrayList), alignof(ArrayList));
     *arr = NULL;
 
     return ARRLIST_OK;
@@ -122,7 +141,7 @@ static ArrayListErr arraylist_grow(ArrayList *arr) {
     size_t new_capacity = arr->capacity * 2;
 
     if (new_capacity > SIZE_MAX / arr->elem_size) {
-        return  ARRLIST_ALLOC_OVERFLOW;
+        return ARRLIST_ALLOC_OVERFLOW;
     }
 
     void *tmp = realloc(arr->buffer, new_capacity * arr->elem_size);
@@ -139,10 +158,10 @@ static ArrayListErr arraylist_shrink(ArrayList *arr) {
     size_t new_capacity = arr->capacity / 2;
 
     if (new_capacity > SIZE_MAX / arr->elem_size) {
-        return  ARRLIST_ALLOC_OVERFLOW;
+        return ARRLIST_ALLOC_OVERFLOW;
     }
-    
-    void *tmp = realloc(arr->buffer, new_capacity *arr->elem_size);
+
+    void *tmp = realloc(arr->buffer, new_capacity * arr->elem_size);
     if (tmp == NULL) {
         return ARRLIST_BAD_ALLOC;
     }
@@ -195,13 +214,9 @@ ArrayListErr arraylist_push_front(ArrayList *arr, void *data) {
     memmove(
         arr->buffer + arr->elem_size,
         arr->buffer,
-        (arr->len) * arr->elem_size
-    );
+        (arr->len) * arr->elem_size);
 
-    memcpy(
-        arr->buffer,
-        data,
-        arr->elem_size);
+    memcpy(arr->buffer, data, arr->elem_size);
 
     arr->len++;
 
@@ -233,9 +248,7 @@ ArrayListErr arraylist_insert(ArrayList *arr, size_t index, void *data) {
         arr->buffer + (index * arr->elem_size),
         (arr->len - index) * arr->elem_size);
 
-    memcpy(arr->buffer + (index * arr->elem_size),
-           data,
-           arr->elem_size);
+    memcpy(arr->buffer + (index * arr->elem_size), data, arr->elem_size);
 
     arr->len++;
 
@@ -295,11 +308,7 @@ ArrayListErr arraylist_pop_front(ArrayList *arr, void *out) {
     }
 
     if (out != NULL) {
-        memcpy(
-            out,
-            arr->buffer,
-            arr->elem_size
-        );
+        memcpy(out, arr->buffer, arr->elem_size);
     }
 
     memmove(
@@ -330,11 +339,7 @@ ArrayListErr arraylist_remove_at(ArrayList *arr, size_t index, void *out) {
     }
 
     if (out != NULL) {
-        memcpy(
-            out,
-            arr->buffer + (index * arr->elem_size),
-            arr->elem_size
-        );
+        memcpy(out, arr->buffer + (index * arr->elem_size), arr->elem_size);
     }
 
     memmove(
@@ -356,10 +361,7 @@ ArrayListErr arraylist_get(const ArrayList *arr, size_t index, void *out) {
         return ARRLIST_OUT_OF_BOUNDS;
     }
 
-    memcpy(
-        out,
-        arr->buffer + (index * arr->elem_size),
-        arr->elem_size);
+    memcpy(out, arr->buffer + (index * arr->elem_size), arr->elem_size);
 
     return ARRLIST_OK;
 }
@@ -373,10 +375,7 @@ ArrayListErr arraylist_set(ArrayList *arr, size_t index, void *data) {
         return ARRLIST_OUT_OF_BOUNDS;
     }
 
-    memcpy(
-        arr->buffer + (index * arr->elem_size),
-        data,
-        arr->elem_size);
+    memcpy(arr->buffer + (index * arr->elem_size), data, arr->elem_size);
 
     return ARRLIST_OK;
 }
@@ -395,7 +394,7 @@ ArrayListErr arraylist_resize(ArrayList *arr, size_t new_capacity) {
     }
 
     if (new_capacity > SIZE_MAX / arr->elem_size) {
-        return  ARRLIST_ALLOC_OVERFLOW;
+        return ARRLIST_ALLOC_OVERFLOW;
     }
 
     uint8_t *tmp = realloc(arr->buffer, new_capacity * arr->elem_size);
@@ -420,7 +419,7 @@ ArrayListErr arraylist_reserve(ArrayList *arr, size_t size_to_reserve) {
     if (arr->capacity + size_to_reserve > SIZE_MAX / arr->elem_size ||
         size_to_reserve > SIZE_MAX / arr->elem_size) {
 
-        return  ARRLIST_ALLOC_OVERFLOW;
+        return ARRLIST_ALLOC_OVERFLOW;
     }
 
     uint8_t *tmp = realloc(
@@ -436,7 +435,12 @@ ArrayListErr arraylist_reserve(ArrayList *arr, size_t size_to_reserve) {
     return ARRLIST_OK;
 }
 
-ArrayListErr arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, size_t len) {
+ArrayListErr arraylist_slice(
+    ArraySlice **slice,
+    Allocator allocator,
+    ArrayList *arr,
+    size_t start,
+    size_t len) {
     if (arr == NULL || slice == NULL) {
         return ARRLIST_NULL_ARG;
     }
@@ -453,7 +457,8 @@ ArrayListErr arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, s
         return ARRLIST_INVALID_START;
     }
 
-    ArraySlice *new_slice = malloc(sizeof(ArraySlice));
+    ArraySlice *new_slice =
+        allocator.alloc(allocator.ctx, sizeof(ArraySlice), alignof(ArraySlice));
     if (new_slice == NULL) {
         return ARRLIST_BAD_ALLOC;
     }
@@ -463,13 +468,19 @@ ArrayListErr arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, s
     new_slice->end = start + len;
     new_slice->current = start;
     new_slice->is_safe = true;
+    new_slice->allocator = allocator;
 
     arr->borrows++;
     *slice = new_slice;
     return ARRLIST_OK;
 }
 
-ArrayListErr arraylist_slice_unsafe(ArraySlice **slice, ArrayList *arr, size_t start, size_t len) {
+ArrayListErr arraylist_slice_unsafe(
+    ArraySlice **slice,
+    Allocator allocator,
+    ArrayList *arr,
+    size_t start,
+    size_t len) {
     if (arr == NULL || slice == NULL) {
         return ARRLIST_NULL_ARG;
     }
@@ -486,7 +497,8 @@ ArrayListErr arraylist_slice_unsafe(ArraySlice **slice, ArrayList *arr, size_t s
         return ARRLIST_INVALID_START;
     }
 
-    ArraySlice *new_slice = malloc(sizeof(ArraySlice));
+    ArraySlice *new_slice =
+        allocator.alloc(allocator.ctx, sizeof(ArraySlice), alignof(ArraySlice));
     if (new_slice == NULL) {
         return ARRLIST_BAD_ALLOC;
     }
@@ -496,6 +508,7 @@ ArrayListErr arraylist_slice_unsafe(ArraySlice **slice, ArrayList *arr, size_t s
     new_slice->end = start + len;
     new_slice->current = start;
     new_slice->is_safe = false;
+    new_slice->allocator = allocator;
 
     *slice = new_slice;
     return ARRLIST_OK;
@@ -510,7 +523,11 @@ ArrayListErr arrayslice_destroy(ArraySlice **slice) {
         (*slice)->arr->borrows--;
     }
 
-    free(*slice);
+    (*slice)->allocator.free(
+        (*slice)->allocator.ctx,
+        *slice,
+        sizeof(ArraySlice),
+        alignof(ArraySlice));
     *slice = NULL;
 
     return ARRLIST_OK;
@@ -581,13 +598,16 @@ ArrayListErr arrayslice_advance(ArraySlice *slice, size_t n) {
     if (n > SIZE_MAX - slice->current || slice->current + n > slice->end) {
         return ARRLIST_OUT_OF_BOUNDS;
     }
-    
+
     slice->current += n;
 
     return ARRLIST_OK;
 }
 
-ArrayListErr arrayslice_to_arraylist(ArrayList **arr, const ArraySlice *slice) {
+ArrayListErr arrayslice_to_arraylist(
+    ArrayList **arr,
+    Allocator allocator,
+    const ArraySlice *slice) {
     if (slice == NULL || slice->arr == NULL) {
         return ARRLIST_NULL_ARG;
     }
@@ -605,9 +625,9 @@ ArrayListErr arrayslice_to_arraylist(ArrayList **arr, const ArraySlice *slice) {
     ArrayList *new_arr;
     ArrayListErr init_err = arraylist_init(
         &new_arr,
+        allocator,
         arraylist_capacity(slice->arr),
-        slice->arr->elem_size
-    );
+        slice->arr->elem_size);
 
     if (init_err != ARRLIST_OK) {
         return init_err;
@@ -616,8 +636,7 @@ ArrayListErr arrayslice_to_arraylist(ArrayList **arr, const ArraySlice *slice) {
     memcpy(
         new_arr->buffer,
         slice->arr->buffer + (slice->start * slice->arr->elem_size),
-        slice->arr->elem_size * len
-    );
+        slice->arr->elem_size * len);
 
     new_arr->len = len;
 
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
deleted file mode 100644
index 99e14c4..0000000
--- a/test/CMakeLists.txt
+++ /dev/null
@@ -1,121 +0,0 @@
-# ---------------------------------------------------------------
-# First search cmocka and automatically download if necessary
-# ---------------------------------------------------------------
-find_package(cmocka QUIET)
-
-if(NOT cmocka_FOUND)
-  message(
-    STATUS
-      "[arraylist] cmocka was not fount in the system — downloading with FetchContent..."
-  )
-
-  include(FetchContent)
-  FetchContent_Declare(
-    cmocka
-    GIT_REPOSITORY https://git.cryptomilk.org/projects/cmocka.git
-    GIT_TAG cmocka-1.1.7
-    GIT_SHALLOW TRUE)
-
-  set(WITH_STATIC_LIB
-      ON
-      CACHE BOOL "" FORCE)
-  set(WITH_SHARED_LIB
-      OFF
-      CACHE BOOL "" FORCE)
-  set(WITH_CMOCKERY_SUPPORT
-      OFF
-      CACHE BOOL "" FORCE)
-  set(WITH_EXAMPLES
-      OFF
-      CACHE BOOL "" FORCE)
-  set(UNIT_TESTING
-      OFF
-      CACHE BOOL "" FORCE)
-  set(PICKY_DEVELOPER
-      OFF
-      CACHE BOOL "" FORCE)
-
-  FetchContent_MakeAvailable(cmocka)
-
-  # cmocka can export its target as "cmocka" or "cmocka-static" create alias if
-  # it doesnt exist
-  if(NOT TARGET cmocka::cmocka)
-    if(TARGET cmocka-static)
-      add_library(cmocka::cmocka ALIAS cmocka-static)
-    elseif(TARGET cmocka)
-      add_library(cmocka::cmocka ALIAS cmocka)
-    else()
-      message(
-        WARNING
-          "[arraylist] cmocka::cmocka target could not be tested — skipping tests"
-      )
-      return()
-    endif()
-  endif()
-endif()
-
-# ---------------------------------------------------------------
-# Verifiy ASAN support
-# ---------------------------------------------------------------
-set(ARRAYLIST_USE_ASAN OFF)
-
-if(ARRAYLIST_ENABLE_SANITIZERS)
-  if(MSVC)
-    if(MSVC_VERSION GREATER_EQUAL 1928)
-      set(ARRAYLIST_USE_ASAN ON)
-    else()
-      message(
-        STATUS
-          "[arraylist] MSVC < 16.9 doesnt support ASAN — sanitizers deactivated."
-      )
-    endif()
-  elseif(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang" AND NOT WIN32)
-    include(CheckCCompilerFlag)
-    check_c_compiler_flag(-fsanitize=address ARRAYLIST_COMPILER_HAS_ASAN)
-    if(ARRAYLIST_COMPILER_HAS_ASAN)
-      set(ARRAYLIST_USE_ASAN ON)
-    else()
-      message(
-        STATUS
-          "[arraylist] Compiler doesnt support -fsanitize=address — sanitizers deactivated."
-      )
-    endif()
-  else()
-    message(
-      STATUS
-        "[arraylist] Platform/compiler doesnt support ASAN — sanitizers deactivated."
-    )
-  endif()
-
-  if(ARRAYLIST_USE_ASAN)
-    message(STATUS "[arraylist] ASAN Enabled for tests")
-  endif()
-endif()
-
-# ---------------------------------------------------------------
-# Test execuatable
-# ---------------------------------------------------------------
-add_executable(test_arraylist test_arraylist.c)
-
-target_link_libraries(test_arraylist PRIVATE arraylist cmocka::cmocka)
-
-# Same as lib
-target_compile_features(test_arraylist PRIVATE c_std_11)
-
-# Apply asan
-if(ARRAYLIST_USE_ASAN)
-  if(MSVC)
-    target_compile_options(test_arraylist PRIVATE /fsanitize=address)
-  else()
-    target_compile_options(test_arraylist PRIVATE -fsanitize=address
-                                                  -fno-omit-frame-pointer)
-    target_link_options(test_arraylist PRIVATE -fsanitize=address)
-  endif()
-endif()
-
-# ---------------------------------------------------------------
-# Register with CTests
-# ---------------------------------------------------------------
-add_test(NAME arraylist_tests COMMAND test_arraylist)
-
-set_tests_properties(arraylist_tests PROPERTIES TIMEOUT 30)
diff --git a/test/test_arraylist.c b/test/test_arraylist.c
index 9a190f5..0ac85a2 100644
--- a/test/test_arraylist.c
+++ b/test/test_arraylist.c
@@ -7,2034 +7,2398 @@
 #include <stdint.h>
 #include <string.h>
 
-#include "arraylist.h"
+#include "lae_allocator.h"
+#include "lae_arraylist.h"
 
 // INIT
 
 static void test_init_valid_parameters(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
-  arraylist_destroy(&arr);
+    ArrayList *arr;
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
+    arraylist_destroy(&arr);
 }
 
 static void test_init_zero_capacity(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_uint_equal(arraylist_init(&arr, 0, sizeof(int)),
-                    ARRLIST_INVALID_CAPACITY);
-  arraylist_destroy(&arr);
+    ArrayList *arr;
+    assert_uint_equal(
+        arraylist_init(&arr, allocator_default(), 0, sizeof(int)),
+        ARRLIST_INVALID_CAPACITY);
+    arraylist_destroy(&arr);
 }
 
 static void test_init_zero_elem_size(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_uint_equal(arraylist_init(&arr, 64, 0), ARRLIST_INVALID_ELEM_SIZE);
-  arraylist_destroy(&arr);
+    ArrayList *arr;
+    assert_uint_equal(
+        arraylist_init(&arr, allocator_default(), 64, 0),
+        ARRLIST_INVALID_ELEM_SIZE);
+    arraylist_destroy(&arr);
 }
 
 static void test_init_large_capacity(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_uint_equal(arraylist_init(&arr, SIZE_MAX, sizeof(int)),
-                    ARRLIST_INVALID_CAPACITY);
-  arraylist_destroy(&arr);
+    ArrayList *arr;
+    assert_uint_equal(
+        arraylist_init(&arr, allocator_default(), SIZE_MAX, sizeof(int)),
+        ARRLIST_INVALID_CAPACITY);
+    arraylist_destroy(&arr);
 }
 
 // DESTROY
 
 static void test_destroy_valid_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
-  arraylist_destroy(&arr);
-  assert_null(arr);
+    ArrayList *arr;
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
+    arraylist_destroy(&arr);
+    assert_null(arr);
 }
 
 static void test_destroy_null_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr = NULL;
-  ArrayListErr err = arraylist_destroy(&arr);
+    ArrayList *arr = NULL;
+    ArrayListErr err = arraylist_destroy(&arr);
 
-  assert_null(arr);
-  assert_uint_equal(err, ARRLIST_NULL_ARG);
+    assert_null(arr);
+    assert_uint_equal(err, ARRLIST_NULL_ARG);
 }
 
 static void test_destroy_double(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
-  ArrayListErr err = arraylist_destroy(&arr);
-  assert_uint_equal(err, ARRLIST_OK);
-  assert_null(arr);
+    ArrayListErr err = arraylist_destroy(&arr);
+    assert_uint_equal(err, ARRLIST_OK);
+    assert_null(arr);
 
-  err = arraylist_destroy(&arr);
-  assert_uint_equal(err, ARRLIST_NULL_ARG);
-  assert_null(arr);
+    err = arraylist_destroy(&arr);
+    assert_uint_equal(err, ARRLIST_NULL_ARG);
+    assert_null(arr);
 }
 
 static void test_destroy_while_borrowed(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  assert_uint_equal(arraylist_destroy(&arr), ARRLIST_IS_BORROWED);
+    assert_uint_equal(arraylist_destroy(&arr), ARRLIST_IS_BORROWED);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 // State
 static void test_capacity_after_init(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
-  assert_uint_equal(arraylist_capacity(arr), 64);
+    assert_uint_equal(arraylist_capacity(arr), 64);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_is_empty_after_init(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
-  assert_true(arraylist_is_empty(arr));
+    assert_true(arraylist_is_empty(arr));
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_is_empty_after_push(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
+    int n = 8;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
 
-  assert_false(arraylist_is_empty(arr));
+    assert_false(arraylist_is_empty(arr));
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_size_after_many_push(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  assert_uint_equal(arraylist_size(arr), 1);
+    int n = 8;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 1);
 
-  assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
-  assert_uint_equal(arraylist_size(arr), 2);
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 2);
 
-  assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
-  assert_uint_equal(arraylist_size(arr), 3);
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 3);
 
-  assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
-  assert_uint_equal(arraylist_size(arr), 4);
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 4);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_capacity_growth_on_push(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 2, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  assert_uint_equal(arraylist_capacity(arr), 2);
+    int n = 8;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_capacity(arr), 2);
 
-  assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
-  assert_uint_equal(arraylist_capacity(arr), 2);
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_capacity(arr), 2);
 
-  assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
-  assert_uint_equal(arraylist_capacity(arr), 4);
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_capacity(arr), 4);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_capacity_shrink_on_pop(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 8, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_OK);
-  assert_uint_equal(arraylist_capacity(arr), 4);
+    int n = 8;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_capacity(arr), 4);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 // push_back
 static void test_push_back_single_element(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  assert_uint_equal(arraylist_size(arr), 1);
+    int n = 8;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 1);
 
-  int b;
-  assert_uint_equal(arraylist_get(arr, 0, &b), ARRLIST_OK);
-  assert_int_equal(b, 8);
+    int b;
+    assert_uint_equal(arraylist_get(arr, 0, &b), ARRLIST_OK);
+    assert_int_equal(b, 8);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_push_back_multiple_elements(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  assert_uint_equal(arraylist_size(arr), 1);
+    int n = 8;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 1);
 
-  n = 9;
-  assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
-  assert_uint_equal(arraylist_size(arr), 2);
+    n = 9;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 2);
 
-  n = 10;
-  assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
-  assert_uint_equal(arraylist_size(arr), 3);
+    n = 10;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 3);
 
-  n = 11;
-  assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
-  assert_uint_equal(arraylist_size(arr), 4);
+    n = 11;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 4);
 
-  n = 12;
-  assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
-  assert_uint_equal(arraylist_size(arr), 5);
+    n = 12;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 5);
 
-  int b;
-  assert_uint_equal(arraylist_get(arr, 0, &b), ARRLIST_OK);
-  assert_int_equal(b, 8);
+    int b;
+    assert_uint_equal(arraylist_get(arr, 0, &b), ARRLIST_OK);
+    assert_int_equal(b, 8);
 
-  assert_uint_equal(arraylist_get(arr, 1, &b), ARRLIST_OK);
-  assert_int_equal(b, 9);
+    assert_uint_equal(arraylist_get(arr, 1, &b), ARRLIST_OK);
+    assert_int_equal(b, 9);
 
-  assert_uint_equal(arraylist_get(arr, 2, &b), ARRLIST_OK);
-  assert_int_equal(b, 10);
+    assert_uint_equal(arraylist_get(arr, 2, &b), ARRLIST_OK);
+    assert_int_equal(b, 10);
 
-  assert_uint_equal(arraylist_get(arr, 3, &b), ARRLIST_OK);
-  assert_int_equal(b, 11);
+    assert_uint_equal(arraylist_get(arr, 3, &b), ARRLIST_OK);
+    assert_int_equal(b, 11);
 
-  assert_uint_equal(arraylist_get(arr, 4, &b), ARRLIST_OK);
-  assert_int_equal(b, 12);
+    assert_uint_equal(arraylist_get(arr, 4, &b), ARRLIST_OK);
+    assert_int_equal(b, 12);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_push_back_null_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr = NULL;
+    ArrayList *arr = NULL;
 
-  int n = 8;
-  assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_NULL_ARG);
+    int n = 8;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_NULL_ARG);
 }
 
 static void test_push_back_null_data(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  arraylist_init(&arr, 64, sizeof(int));
+    ArrayList *arr;
+    arraylist_init(&arr, allocator_default(), 64, sizeof(int));
 
-  assert_uint_equal(arraylist_push_back(arr, NULL), ARRLIST_NULL_ARG);
+    assert_uint_equal(arraylist_push_back(arr, NULL), ARRLIST_NULL_ARG);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_push_back_while_borrowed(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  int n = 8;
-  assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_IS_BORROWED);
+    int n = 8;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_IS_BORROWED);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 // Push front
 static void test_push_front_single_element(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
-  int n = 8;
-  int m;
-  assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_OK);
-  assert_uint_equal(arraylist_size(arr), 1);
-  assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK);
-  assert_uint_equal(m, 8);
+    int n = 8;
+    int m;
+    assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 1);
+    assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK);
+    assert_uint_equal(m, 8);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_push_front_multiple_elements(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
-  int n = 8;
-  int m;
+    int n = 8;
+    int m;
 
-  for (size_t i = 0; i < 10; i++) {
-    assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_OK);
-    assert_uint_equal(arraylist_size(arr), i + 1);
-    assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK);
-    assert_uint_equal(m, n);
-    n++;
-  }
+    for (size_t i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_OK);
+        assert_uint_equal(arraylist_size(arr), i + 1);
+        assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK);
+        assert_uint_equal(m, n);
+        n++;
+    }
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_push_front_null_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr = NULL;
+    ArrayList *arr = NULL;
 
-  int n = 8;
-  assert_int_equal(arraylist_push_front(arr, &n), ARRLIST_NULL_ARG);
+    int n = 8;
+    assert_int_equal(arraylist_push_front(arr, &n), ARRLIST_NULL_ARG);
 }
 
 static void test_push_front_null_data(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
-  assert_int_equal(arraylist_push_front(arr, NULL), ARRLIST_NULL_ARG);
+    assert_int_equal(arraylist_push_front(arr, NULL), ARRLIST_NULL_ARG);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_push_front_while_borrowed(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  int n = 8;
-  assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_IS_BORROWED);
+    int n = 8;
+    assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_IS_BORROWED);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 // Insert
 static void test_insert_at_beginning(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int n = 8;
-  int m;
-  assert_uint_equal(arraylist_size(arr), 10);
-  assert_uint_equal(arraylist_insert(arr, 0, &n), ARRLIST_OK);
-  assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK);
-  assert_uint_equal(arraylist_size(arr), 11);
-  assert_uint_equal(n, m);
+    int n = 8;
+    int m;
+    assert_uint_equal(arraylist_size(arr), 10);
+    assert_uint_equal(arraylist_insert(arr, 0, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 11);
+    assert_uint_equal(n, m);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_insert_at_middle(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int n = 8;
-  int m;
-  assert_uint_equal(arraylist_size(arr), 10);
-  assert_uint_equal(arraylist_insert(arr, 5, &n), ARRLIST_OK);
-  assert_uint_equal(arraylist_get(arr, 5, &m), ARRLIST_OK);
-  assert_uint_equal(arraylist_size(arr), 11);
-  assert_uint_equal(n, m);
+    int n = 8;
+    int m;
+    assert_uint_equal(arraylist_size(arr), 10);
+    assert_uint_equal(arraylist_insert(arr, 5, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_get(arr, 5, &m), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 11);
+    assert_uint_equal(n, m);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_insert_at_end(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int n = 8;
-  int m;
-  assert_uint_equal(arraylist_size(arr), 10);
-  assert_uint_equal(arraylist_insert(arr, 10, &n), ARRLIST_OK);
-  assert_uint_equal(arraylist_get(arr, 10, &m), ARRLIST_OK);
-  assert_uint_equal(arraylist_size(arr), 11);
-  assert_uint_equal(n, m);
+    int n = 8;
+    int m;
+    assert_uint_equal(arraylist_size(arr), 10);
+    assert_uint_equal(arraylist_insert(arr, 10, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_get(arr, 10, &m), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 11);
+    assert_uint_equal(n, m);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_insert_at_invalid_index(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
+    int n = 8;
+    assert_uint_equal(arraylist_insert(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_insert_null_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr = NULL;
+    ArrayList *arr = NULL;
 
-  int n = 8;
-  assert_uint_equal(arraylist_insert(arr, 0, &n), ARRLIST_NULL_ARG);
+    int n = 8;
+    assert_uint_equal(arraylist_insert(arr, 0, &n), ARRLIST_NULL_ARG);
 }
 
 static void test_insert_null_data(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
-  assert_uint_equal(arraylist_insert(arr, 0, NULL), ARRLIST_NULL_ARG);
+    assert_uint_equal(arraylist_insert(arr, 0, NULL), ARRLIST_NULL_ARG);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_insert_while_borrowed(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  int n = 8;
-  assert_uint_equal(arraylist_insert(arr, 2, &n), ARRLIST_IS_BORROWED);
+    int n = 8;
+    assert_uint_equal(arraylist_insert(arr, 2, &n), ARRLIST_IS_BORROWED);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 // Pop back
 static void test_pop_back_single_element(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int m;
-  assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_OK);
-  assert_uint_equal(m, 9);
+    int m;
+    assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_OK);
+    assert_uint_equal(m, 9);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_pop_back_multiple_elements(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int m;
-  for (int i = 9; i >= 5; i--) {
-    assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_OK);
-    assert_uint_equal(arraylist_size(arr), i);
-    assert_uint_equal(m, i);
-  }
+    int m;
+    for (int i = 9; i >= 5; i--) {
+        assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_OK);
+        assert_uint_equal(arraylist_size(arr), i);
+        assert_uint_equal(m, i);
+    }
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_pop_back_until_empty(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int m;
-  for (int i = 9; i >= 0; i--) {
-    assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_OK);
-    assert_uint_equal(arraylist_size(arr), i);
-    assert_uint_equal(m, i);
-  }
+    int m;
+    for (int i = 9; i >= 0; i--) {
+        assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_OK);
+        assert_uint_equal(arraylist_size(arr), i);
+        assert_uint_equal(m, i);
+    }
 
-  assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_EMPTY);
+    assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_EMPTY);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_pop_back_empty_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
+    int n;
+    assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_EMPTY);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_pop_back_null_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr = NULL;
+    ArrayList *arr = NULL;
 
-  int n;
-  assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_NULL_ARG);
+    int n;
+    assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_NULL_ARG);
 }
 
 static void test_pop_back_null_out(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
+    int n = 8;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
 
-  assert_uint_equal(arraylist_pop_back(arr, NULL), ARRLIST_OK);
+    assert_uint_equal(arraylist_pop_back(arr, NULL), ARRLIST_OK);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_pop_back_while_borrowed(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  int n = 8;
-  assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_IS_BORROWED);
+    int n = 8;
+    assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_IS_BORROWED);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 // Pop front
 static void test_pop_front_single_element(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int m;
-  assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_OK);
-  assert_uint_equal(m, 0);
+    int m;
+    assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_OK);
+    assert_uint_equal(m, 0);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_pop_front_multiple_elements(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int m;
-  size_t size = arraylist_size(arr);
-  for (int i = 0; i < 6; i++) {
-    assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_OK);
-    assert_uint_equal(arraylist_size(arr), size - (i + 1));
-    assert_uint_equal(m, i);
-  }
+    int m;
+    size_t size = arraylist_size(arr);
+    for (int i = 0; i < 6; i++) {
+        assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_OK);
+        assert_uint_equal(arraylist_size(arr), size - (i + 1));
+        assert_uint_equal(m, i);
+    }
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_pop_front_until_empty(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int m;
-  size_t size = arraylist_size(arr);
-  for (int i = 0; i < 10; i++) {
-    assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_OK);
-    assert_uint_equal(arraylist_size(arr), size - (i + 1));
-    assert_uint_equal(m, i);
-  }
+    int m;
+    size_t size = arraylist_size(arr);
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_OK);
+        assert_uint_equal(arraylist_size(arr), size - (i + 1));
+        assert_uint_equal(m, i);
+    }
 
-  assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_EMPTY);
+    assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_EMPTY);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_pop_front_empty_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
+    int n;
+    assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_EMPTY);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_pop_front_null_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr = NULL;
+    ArrayList *arr = NULL;
 
-  int n;
-  assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_NULL_ARG);
+    int n;
+    assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_NULL_ARG);
 }
 
 static void test_pop_front_null_out(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
+    int n = 8;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
 
-  assert_uint_equal(arraylist_pop_front(arr, NULL), ARRLIST_OK);
+    assert_uint_equal(arraylist_pop_front(arr, NULL), ARRLIST_OK);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_pop_front_while_borrowed(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
-  assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
+    assert_non_null(slice);
 
-  int n = 8;
-  assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_IS_BORROWED);
+    int n = 8;
+    assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_IS_BORROWED);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 // Remove at
 static void test_remove_at_beginning(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int m;
-  assert_uint_equal(arraylist_size(arr), 10);
-  assert_uint_equal(arraylist_remove_at(arr, 0, &m), ARRLIST_OK);
-  assert_uint_equal(arraylist_size(arr), 9);
-  assert_uint_equal(m, 0);
+    int m;
+    assert_uint_equal(arraylist_size(arr), 10);
+    assert_uint_equal(arraylist_remove_at(arr, 0, &m), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 9);
+    assert_uint_equal(m, 0);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_remove_at_middle(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int m;
-  assert_uint_equal(arraylist_size(arr), 10);
-  assert_uint_equal(arraylist_remove_at(arr, 5, &m), ARRLIST_OK);
-  assert_uint_equal(arraylist_size(arr), 9);
-  assert_uint_equal(m, 5);
+    int m;
+    assert_uint_equal(arraylist_size(arr), 10);
+    assert_uint_equal(arraylist_remove_at(arr, 5, &m), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 9);
+    assert_uint_equal(m, 5);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_remove_at_end(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int m;
-  assert_uint_equal(arraylist_size(arr), 10);
-  assert_uint_equal(arraylist_remove_at(arr, 9, &m), ARRLIST_OK);
-  assert_uint_equal(arraylist_size(arr), 9);
-  assert_uint_equal(m, 9);
+    int m;
+    assert_uint_equal(arraylist_size(arr), 10);
+    assert_uint_equal(arraylist_remove_at(arr, 9, &m), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 9);
+    assert_uint_equal(m, 9);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_remove_at_invalid_index(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
+    int n = 8;
+    assert_uint_equal(arraylist_remove_at(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_remove_at_null_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr = NULL;
+    ArrayList *arr = NULL;
 
-  int n = 8;
-  assert_uint_equal(arraylist_remove_at(arr, 0, &n), ARRLIST_NULL_ARG);
+    int n = 8;
+    assert_uint_equal(arraylist_remove_at(arr, 0, &n), ARRLIST_NULL_ARG);
 }
 
 static void test_remove_at_null_data(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
+    int n = 8;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
 
-  assert_uint_equal(arraylist_remove_at(arr, 0, NULL), ARRLIST_OK);
+    assert_uint_equal(arraylist_remove_at(arr, 0, NULL), ARRLIST_OK);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_remove_at_while_borrowed(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  int n = 8;
-  assert_uint_equal(arraylist_remove_at(arr, 5, &n), ARRLIST_IS_BORROWED);
+    int n = 8;
+    assert_uint_equal(arraylist_remove_at(arr, 5, &n), ARRLIST_IS_BORROWED);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 // Get
 static void test_get_valid_index(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int m;
-  assert_uint_equal(arraylist_get(arr, 6, &m), ARRLIST_OK);
-  assert_uint_equal(m, 6);
+    int m;
+    assert_uint_equal(arraylist_get(arr, 6, &m), ARRLIST_OK);
+    assert_uint_equal(m, 6);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_get_first_element(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int m;
-  assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK);
-  assert_uint_equal(m, 0);
+    int m;
+    assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK);
+    assert_uint_equal(m, 0);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_get_last_element(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int m;
-  assert_uint_equal(arraylist_get(arr, 9, &m), ARRLIST_OK);
-  assert_uint_equal(m, 9);
+    int m;
+    assert_uint_equal(arraylist_get(arr, 9, &m), ARRLIST_OK);
+    assert_uint_equal(m, 9);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_get_invalid_index(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int m;
-  assert_uint_equal(arraylist_get(arr, 80, &m), ARRLIST_OUT_OF_BOUNDS);
+    int m;
+    assert_uint_equal(arraylist_get(arr, 80, &m), ARRLIST_OUT_OF_BOUNDS);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_get_null_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr = NULL;
+    ArrayList *arr = NULL;
 
-  int m;
-  assert_uint_equal(arraylist_get(arr, 80, &m), ARRLIST_NULL_ARG);
+    int m;
+    assert_uint_equal(arraylist_get(arr, 80, &m), ARRLIST_NULL_ARG);
 }
 
 static void test_get_null_out(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  assert_uint_equal(arraylist_get(arr, 8, NULL), ARRLIST_NULL_ARG);
+    assert_uint_equal(arraylist_get(arr, 8, NULL), ARRLIST_NULL_ARG);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_get_while_borrowed(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  int n = 8;
-  assert_uint_equal(arraylist_get(arr, 5, &n), ARRLIST_OK);
+    int n = 8;
+    assert_uint_equal(arraylist_get(arr, 5, &n), ARRLIST_OK);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 // Set
 static void test_set_valid_index(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int n = 8;
-  int m;
-  assert_uint_equal(arraylist_set(arr, 6, &n), ARRLIST_OK);
-  assert_uint_equal(arraylist_get(arr, 6, &m), ARRLIST_OK);
-  assert_uint_equal(m, n);
+    int n = 8;
+    int m;
+    assert_uint_equal(arraylist_set(arr, 6, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_get(arr, 6, &m), ARRLIST_OK);
+    assert_uint_equal(m, n);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_set_first_element(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int n = 8;
-  int m;
-  assert_uint_equal(arraylist_set(arr, 0, &n), ARRLIST_OK);
-  assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK);
-  assert_uint_equal(m, n);
+    int n = 8;
+    int m;
+    assert_uint_equal(arraylist_set(arr, 0, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK);
+    assert_uint_equal(m, n);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_set_last_element(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int n = 8;
-  int m;
-  assert_uint_equal(arraylist_set(arr, 9, &n), ARRLIST_OK);
-  assert_uint_equal(arraylist_get(arr, 9, &m), ARRLIST_OK);
-  assert_uint_equal(m, n);
+    int n = 8;
+    int m;
+    assert_uint_equal(arraylist_set(arr, 9, &n), ARRLIST_OK);
+    assert_uint_equal(arraylist_get(arr, 9, &m), ARRLIST_OK);
+    assert_uint_equal(m, n);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_set_invalid_index(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  int n = 8;
-  assert_uint_equal(arraylist_set(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS);
+    int n = 8;
+    assert_uint_equal(arraylist_set(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_set_null_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr = NULL;
+    ArrayList *arr = NULL;
 
-  int n = 8;
-  assert_uint_equal(arraylist_set(arr, 80, &n), ARRLIST_NULL_ARG);
+    int n = 8;
+    assert_uint_equal(arraylist_set(arr, 80, &n), ARRLIST_NULL_ARG);
 }
 
 static void test_set_null_data(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
-  assert_uint_equal(arraylist_set(arr, 8, NULL), ARRLIST_NULL_ARG);
+    assert_uint_equal(arraylist_set(arr, 8, NULL), ARRLIST_NULL_ARG);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_set_while_borrowed(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  int n = 8;
-  assert_uint_equal(arraylist_set(arr, 5, &n), ARRLIST_OK);
+    int n = 8;
+    assert_uint_equal(arraylist_set(arr, 5, &n), ARRLIST_OK);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 // Clear
 static void test_clear_non_empty_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (size_t i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  assert_uint_equal(arraylist_clear(arr), ARRLIST_OK);
-  assert_uint_equal(arraylist_size(arr), 0);
-  assert_uint_equal(arraylist_capacity(arr), 64);
+    assert_uint_equal(arraylist_clear(arr), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 0);
+    assert_uint_equal(arraylist_capacity(arr), 64);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_clear_already_empty_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    assert_int_equal(
+        arraylist_init(&arr, allocator_default(), 64, sizeof(int)),
+        ARRLIST_OK);
 
-  assert_uint_equal(arraylist_clear(arr), ARRLIST_OK);
+    assert_uint_equal(arraylist_clear(arr), ARRLIST_OK);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_clear_null_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr = NULL;
+    ArrayList *arr = NULL;
 
-  assert_uint_equal(arraylist_clear(arr), ARRLIST_NULL_ARG);
+    assert_uint_equal(arraylist_clear(arr), ARRLIST_NULL_ARG);
 }
 
 static void test_clear_while_borrowed(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  assert_uint_equal(arraylist_clear(arr), ARRLIST_IS_BORROWED);
+    assert_uint_equal(arraylist_clear(arr), ARRLIST_IS_BORROWED);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 // Resize
 static void test_resize_increase_capacity(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
+    assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_OK);
+    assert_uint_equal(arraylist_capacity(arr), 128);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_resize_decrease_capacity(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
+    assert_uint_equal(arraylist_resize(arr, 32), ARRLIST_OK);
+    assert_uint_equal(arraylist_capacity(arr), 32);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_resize_to_zero(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
+    assert_uint_equal(arraylist_resize(arr, 0), ARRLIST_INVALID_CAPACITY);
+    assert_uint_equal(arraylist_capacity(arr), 64);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_resize_to_size_max(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
+    assert_uint_equal(arraylist_resize(arr, SIZE_MAX), ARRLIST_ALLOC_OVERFLOW);
+    assert_uint_equal(arraylist_capacity(arr), 64);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_resize_null_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr = NULL;
+    ArrayList *arr = NULL;
 
-  assert_uint_equal(arraylist_resize(arr, 65), ARRLIST_NULL_ARG);
+    assert_uint_equal(arraylist_resize(arr, 65), ARRLIST_NULL_ARG);
 }
 
 static void test_resize_while_borrowed(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_IS_BORROWED);
+    assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_IS_BORROWED);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 // Reserve
 static void test_reserve_normal_capacity(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
+    assert_uint_equal(arraylist_reserve(arr, 32), ARRLIST_OK);
+    assert_uint_equal(arraylist_capacity(arr), 96);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_reserve_size_max(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
+    assert_uint_equal(arraylist_reserve(arr, SIZE_MAX), ARRLIST_ALLOC_OVERFLOW);
+    assert_uint_equal(arraylist_capacity(arr), 64);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_reserve_size_0(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
+    assert_uint_equal(arraylist_reserve(arr, 0), ARRLIST_OK);
+    assert_uint_equal(arraylist_capacity(arr), 64);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_reserve_while_borrowed(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  assert_uint_equal(arraylist_reserve(arr, 128), ARRLIST_IS_BORROWED);
+    assert_uint_equal(arraylist_reserve(arr, 128), ARRLIST_IS_BORROWED);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 // Slice creation
 static void test_slice_valid_init(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(&slice, allocator_default(), arr, 0, 10),
+        ARRLIST_OK);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_invalid_index(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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, 32, 10),
-                    ARRLIST_INVALID_START);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(&slice, allocator_default(), arr, 32, 10),
+        ARRLIST_INVALID_START);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_invalid_len(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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, 300),
-                    ARRLIST_INVALID_START);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(&slice, allocator_default(), arr, 0, 300),
+        ARRLIST_INVALID_START);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_len_zero(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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, 0), ARRLIST_INVALID_START);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(&slice, allocator_default(), arr, 0, 0),
+        ARRLIST_INVALID_START);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_empty_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(&slice, allocator_default(), arr, 0, 10),
+        ARRLIST_INVALID_ARR);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_null_arr(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr = NULL;
+    ArrayList *arr = NULL;
 
-  ArraySlice *slice;
-  assert_uint_equal(arraylist_slice(&slice, arr, 0, 10), ARRLIST_NULL_ARG);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(&slice, allocator_default(), arr, 0, 10),
+        ARRLIST_NULL_ARG);
 }
 
 // Slice Unsafe
 static void test_slice_unsafe_valid_init(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice_unsafe(&slice, allocator_default(), arr, 0, 10),
+        ARRLIST_OK);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_unsafe_invalid_index(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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, 32, 10),
-                    ARRLIST_INVALID_START);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice_unsafe(&slice, allocator_default(), arr, 32, 10),
+        ARRLIST_INVALID_START);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_unsafe_invalid_len(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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, 300),
-                    ARRLIST_INVALID_START);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice_unsafe(&slice, allocator_default(), arr, 0, 300),
+        ARRLIST_INVALID_START);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_unsafe_len_zero(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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, 0),
-                    ARRLIST_INVALID_START);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice_unsafe(&slice, allocator_default(), arr, 0, 0),
+        ARRLIST_INVALID_START);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_unsafe_empty_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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),
-                    ARRLIST_INVALID_ARR);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice_unsafe(&slice, allocator_default(), arr, 0, 10),
+        ARRLIST_INVALID_ARR);
 
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_unsafe_null_arr(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr = NULL;
+    ArrayList *arr = NULL;
 
-  ArraySlice *slice;
-  assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 10),
-                    ARRLIST_NULL_ARG);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice_unsafe(&slice, allocator_default(), arr, 0, 10),
+        ARRLIST_NULL_ARG);
 }
 
 // Slice Destroy
 static void test_slice_destroy_valid(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_OK);
-  arraylist_destroy(&arr);
+    assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_OK);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_destroy_null_slice(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
 
-  ArraySlice *slice = NULL;
+    ArraySlice *slice = NULL;
 
-  assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_NULL_ARG);
-  arraylist_destroy(&arr);
+    assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_NULL_ARG);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_double_destroy(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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)),
-                    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,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_OK);
-  assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_NULL_ARG);
-  arraylist_destroy(&arr);
+    assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_OK);
+    assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_NULL_ARG);
+    arraylist_destroy(&arr);
 }
 
 // Slice peek
 static void test_slice_peek_valid_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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)),
-                    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,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  int m;
-  assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_OK);
-  assert_int_equal(m, 0);
+    int m;
+    assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_OK);
+    assert_int_equal(m, 0);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_peek_invalid_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK);
+    assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK);
 
-  int m;
-  assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_INVALID_SLICE);
+    int m;
+    assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_INVALID_SLICE);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_peek_null_out(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  assert_uint_equal(arrayslice_peek(slice, NULL), ARRLIST_NULL_ARG);
+    assert_uint_equal(arrayslice_peek(slice, NULL), ARRLIST_NULL_ARG);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_peek_null_slice(void **state) {
-  (void)state;
+    (void)state;
 
-  ArraySlice *slice = NULL;
+    ArraySlice *slice = NULL;
 
-  int m;
-  assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_NULL_ARG);
+    int m;
+    assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_NULL_ARG);
 }
 
 // Slice next
 static void test_slice_next_valid_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  int m;
-  assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
-  assert_int_equal(m, 0);
+    int m;
+    assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
+    assert_int_equal(m, 0);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_next_invalid_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK);
+    assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK);
 
-  int m;
-  assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_INVALID_SLICE);
+    int m;
+    assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_INVALID_SLICE);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_next_null_out(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  assert_uint_equal(arrayslice_next(slice, NULL), ARRLIST_OK);
+    assert_uint_equal(arrayslice_next(slice, NULL), ARRLIST_OK);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_next_null_slice(void **state) {
-  (void)state;
+    (void)state;
 
-  ArraySlice *slice = NULL;
+    ArraySlice *slice = NULL;
 
-  int m;
-  assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_NULL_ARG);
+    int m;
+    assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_NULL_ARG);
 }
 
 static void test_slice_next_until_invalid(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  int m;
-  for (int i = 0; i < 10; i++) {
-    assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
-    assert_uint_equal(m, i);
-  }
-  assert_false(arrayslice_is_valid(slice));
+    int m;
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
+        assert_uint_equal(m, i);
+    }
+    assert_false(arrayslice_is_valid(slice));
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 // Slice reset
 static void test_slice_reset_valid_slice(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  int m;
-  for (int i = 0; i < 10; i++) {
-    assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
-    assert_uint_equal(m, i);
-  }
+    int m;
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
+        assert_uint_equal(m, i);
+    }
 
-  assert_uint_equal(arrayslice_reset(slice), ARRLIST_OK);
+    assert_uint_equal(arrayslice_reset(slice), ARRLIST_OK);
 
-  for (int i = 0; i < 10; i++) {
-    assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
-    assert_uint_equal(m, i);
-  }
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
+        assert_uint_equal(m, i);
+    }
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_reset_null_slice(void **state) {
-  (void)state;
+    (void)state;
 
-  ArraySlice *slice = NULL;
+    ArraySlice *slice = NULL;
 
-  assert_uint_equal(arrayslice_reset(slice), ARRLIST_NULL_ARG);
+    assert_uint_equal(arrayslice_reset(slice), ARRLIST_NULL_ARG);
 }
 
 // Slice advance
 // out ou bounds
 // null
 static void test_slice_advance_valid_slice(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  int m;
-  for (int i = 0; i < 5; i++) {
-    assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
-    assert_uint_equal(m, i);
-  }
+    int m;
+    for (int i = 0; i < 5; i++) {
+        assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
+        assert_uint_equal(m, i);
+    }
 
-  assert_uint_equal(arrayslice_advance(slice, 5), ARRLIST_OK);
+    assert_uint_equal(arrayslice_advance(slice, 5), ARRLIST_OK);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_advance_out_of_bounds(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  int m;
-  for (int i = 0; i < 5; i++) {
-    assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
-    assert_uint_equal(m, i);
-  }
+    int m;
+    for (int i = 0; i < 5; i++) {
+        assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
+        assert_uint_equal(m, i);
+    }
 
-  assert_uint_equal(arrayslice_advance(slice, 40), ARRLIST_OUT_OF_BOUNDS);
+    assert_uint_equal(arrayslice_advance(slice, 40), ARRLIST_OUT_OF_BOUNDS);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_advance_size_max(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        arraylist_slice(
+            &slice,
+            allocator_default(),
+            arr,
+            0,
+            arraylist_size(arr)),
+        ARRLIST_OK);
 
-  int m;
-  for (int i = 0; i < 5; i++) {
-    assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
-    assert_uint_equal(m, i);
-  }
+    int m;
+    for (int i = 0; i < 5; i++) {
+        assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
+        assert_uint_equal(m, i);
+    }
 
-  assert_uint_equal(arrayslice_advance(slice, SIZE_MAX), ARRLIST_OUT_OF_BOUNDS);
+    assert_uint_equal(
+        arrayslice_advance(slice, SIZE_MAX),
+        ARRLIST_OUT_OF_BOUNDS);
 
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_advance_null_array(void **state) {
-  (void)state;
+    (void)state;
 
-  ArraySlice *slice = NULL;
+    ArraySlice *slice = NULL;
 
-  assert_uint_equal(arrayslice_advance(slice, 56), ARRLIST_NULL_ARG);
+    assert_uint_equal(arrayslice_advance(slice, 56), ARRLIST_NULL_ARG);
 }
 
 // Slice to Array
 static void test_slice_to_array_valid(void **state) {
-  (void)state;
+    (void)state;
 
-  ArrayList *arr;
-  assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    ArrayList *arr;
+    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);
-  }
+    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)),
-                    ARRLIST_OK);
+    ArraySlice *slice;
+    assert_uint_equal(
+        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(arraylist_capacity(arr2), 64);
-  assert_uint_equal(arraylist_size(arr2), 10);
+    ArrayList *arr2;
+    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);
 
-  arraylist_destroy(&arr2);
-  arrayslice_destroy(&slice);
-  arraylist_destroy(&arr);
+    arraylist_destroy(&arr2);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
 }
 
 static void test_slice_to_array_null_slice(void **state) {
-  (void)state;
+    (void)state;
 
-  ArraySlice *slice = NULL;
-  ArrayList *arr = NULL;
+    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) {
-  const struct CMUnitTest init[] = {
-      cmocka_unit_test(test_init_valid_parameters),
-      cmocka_unit_test(test_init_zero_capacity),
-      cmocka_unit_test(test_init_zero_elem_size),
-      cmocka_unit_test(test_init_large_capacity),
-  };
+    const struct CMUnitTest init[] = {
+        cmocka_unit_test(test_init_valid_parameters),
+        cmocka_unit_test(test_init_zero_capacity),
+        cmocka_unit_test(test_init_zero_elem_size),
+        cmocka_unit_test(test_init_large_capacity),
+    };
 
-  const struct CMUnitTest destroy[] = {
-      cmocka_unit_test(test_destroy_valid_array),
-      cmocka_unit_test(test_destroy_null_array),
-      cmocka_unit_test(test_destroy_double),
-      cmocka_unit_test(test_destroy_while_borrowed),
-  };
+    const struct CMUnitTest destroy[] = {
+        cmocka_unit_test(test_destroy_valid_array),
+        cmocka_unit_test(test_destroy_null_array),
+        cmocka_unit_test(test_destroy_double),
+        cmocka_unit_test(test_destroy_while_borrowed),
+    };
 
-  const struct CMUnitTest state[] = {
-      cmocka_unit_test(test_capacity_after_init),
-      cmocka_unit_test(test_is_empty_after_init),
-      cmocka_unit_test(test_is_empty_after_push),
-      cmocka_unit_test(test_size_after_many_push),
-      cmocka_unit_test(test_capacity_growth_on_push),
-      cmocka_unit_test(test_capacity_shrink_on_pop),
-  };
+    const struct CMUnitTest state[] = {
+        cmocka_unit_test(test_capacity_after_init),
+        cmocka_unit_test(test_is_empty_after_init),
+        cmocka_unit_test(test_is_empty_after_push),
+        cmocka_unit_test(test_size_after_many_push),
+        cmocka_unit_test(test_capacity_growth_on_push),
+        cmocka_unit_test(test_capacity_shrink_on_pop),
+    };
 
-  const struct CMUnitTest push_back[] = {
-      cmocka_unit_test(test_push_back_single_element),
-      cmocka_unit_test(test_push_back_multiple_elements),
-      cmocka_unit_test(test_push_back_null_array),
-      cmocka_unit_test(test_push_back_null_data),
-      cmocka_unit_test(test_push_back_while_borrowed),
-  };
+    const struct CMUnitTest push_back[] = {
+        cmocka_unit_test(test_push_back_single_element),
+        cmocka_unit_test(test_push_back_multiple_elements),
+        cmocka_unit_test(test_push_back_null_array),
+        cmocka_unit_test(test_push_back_null_data),
+        cmocka_unit_test(test_push_back_while_borrowed),
+    };
 
-  const struct CMUnitTest push_front[] = {
-      cmocka_unit_test(test_push_front_single_element),
-      cmocka_unit_test(test_push_front_multiple_elements),
-      cmocka_unit_test(test_push_front_null_array),
-      cmocka_unit_test(test_push_front_null_data),
-      cmocka_unit_test(test_push_front_while_borrowed),
-  };
+    const struct CMUnitTest push_front[] = {
+        cmocka_unit_test(test_push_front_single_element),
+        cmocka_unit_test(test_push_front_multiple_elements),
+        cmocka_unit_test(test_push_front_null_array),
+        cmocka_unit_test(test_push_front_null_data),
+        cmocka_unit_test(test_push_front_while_borrowed),
+    };
 
-  const struct CMUnitTest insert[] = {
-      cmocka_unit_test(test_insert_at_beginning),
-      cmocka_unit_test(test_insert_at_middle),
-      cmocka_unit_test(test_insert_at_end),
-      cmocka_unit_test(test_insert_at_invalid_index),
-      cmocka_unit_test(test_insert_null_array),
-      cmocka_unit_test(test_insert_null_data),
-      cmocka_unit_test(test_insert_while_borrowed),
-  };
+    const struct CMUnitTest insert[] = {
+        cmocka_unit_test(test_insert_at_beginning),
+        cmocka_unit_test(test_insert_at_middle),
+        cmocka_unit_test(test_insert_at_end),
+        cmocka_unit_test(test_insert_at_invalid_index),
+        cmocka_unit_test(test_insert_null_array),
+        cmocka_unit_test(test_insert_null_data),
+        cmocka_unit_test(test_insert_while_borrowed),
+    };
 
-  const struct CMUnitTest pop_back[] = {
-      cmocka_unit_test(test_pop_back_single_element),
-      cmocka_unit_test(test_pop_back_multiple_elements),
-      cmocka_unit_test(test_pop_back_until_empty),
-      cmocka_unit_test(test_pop_back_empty_array),
-      cmocka_unit_test(test_pop_back_null_array),
-      cmocka_unit_test(test_pop_back_null_out),
-      cmocka_unit_test(test_pop_back_while_borrowed),
-  };
+    const struct CMUnitTest pop_back[] = {
+        cmocka_unit_test(test_pop_back_single_element),
+        cmocka_unit_test(test_pop_back_multiple_elements),
+        cmocka_unit_test(test_pop_back_until_empty),
+        cmocka_unit_test(test_pop_back_empty_array),
+        cmocka_unit_test(test_pop_back_null_array),
+        cmocka_unit_test(test_pop_back_null_out),
+        cmocka_unit_test(test_pop_back_while_borrowed),
+    };
 
-  const struct CMUnitTest pop_front[] = {
-      cmocka_unit_test(test_pop_front_single_element),
-      cmocka_unit_test(test_pop_front_multiple_elements),
-      cmocka_unit_test(test_pop_front_until_empty),
-      cmocka_unit_test(test_pop_front_empty_array),
-      cmocka_unit_test(test_pop_front_null_array),
-      cmocka_unit_test(test_pop_front_null_out),
-      cmocka_unit_test(test_pop_front_while_borrowed),
-  };
+    const struct CMUnitTest pop_front[] = {
+        cmocka_unit_test(test_pop_front_single_element),
+        cmocka_unit_test(test_pop_front_multiple_elements),
+        cmocka_unit_test(test_pop_front_until_empty),
+        cmocka_unit_test(test_pop_front_empty_array),
+        cmocka_unit_test(test_pop_front_null_array),
+        cmocka_unit_test(test_pop_front_null_out),
+        cmocka_unit_test(test_pop_front_while_borrowed),
+    };
 
-  const struct CMUnitTest remove_at[] = {
-      cmocka_unit_test(test_remove_at_beginning),
-      cmocka_unit_test(test_remove_at_middle),
-      cmocka_unit_test(test_remove_at_end),
-      cmocka_unit_test(test_remove_at_invalid_index),
-      cmocka_unit_test(test_remove_at_null_array),
-      cmocka_unit_test(test_remove_at_null_data),
-      cmocka_unit_test(test_remove_at_while_borrowed),
-  };
+    const struct CMUnitTest remove_at[] = {
+        cmocka_unit_test(test_remove_at_beginning),
+        cmocka_unit_test(test_remove_at_middle),
+        cmocka_unit_test(test_remove_at_end),
+        cmocka_unit_test(test_remove_at_invalid_index),
+        cmocka_unit_test(test_remove_at_null_array),
+        cmocka_unit_test(test_remove_at_null_data),
+        cmocka_unit_test(test_remove_at_while_borrowed),
+    };
 
-  const struct CMUnitTest get[] = {
-      cmocka_unit_test(test_get_valid_index),
-      cmocka_unit_test(test_get_first_element),
-      cmocka_unit_test(test_get_last_element),
-      cmocka_unit_test(test_get_invalid_index),
-      cmocka_unit_test(test_get_null_array),
-      cmocka_unit_test(test_get_null_out),
-      cmocka_unit_test(test_get_while_borrowed),
-  };
+    const struct CMUnitTest get[] = {
+        cmocka_unit_test(test_get_valid_index),
+        cmocka_unit_test(test_get_first_element),
+        cmocka_unit_test(test_get_last_element),
+        cmocka_unit_test(test_get_invalid_index),
+        cmocka_unit_test(test_get_null_array),
+        cmocka_unit_test(test_get_null_out),
+        cmocka_unit_test(test_get_while_borrowed),
+    };
 
-  const struct CMUnitTest set[] = {
-      cmocka_unit_test(test_set_valid_index),
-      cmocka_unit_test(test_set_first_element),
-      cmocka_unit_test(test_set_last_element),
-      cmocka_unit_test(test_set_invalid_index),
-      cmocka_unit_test(test_set_null_array),
-      cmocka_unit_test(test_set_null_data),
-      cmocka_unit_test(test_set_while_borrowed),
-  };
+    const struct CMUnitTest set[] = {
+        cmocka_unit_test(test_set_valid_index),
+        cmocka_unit_test(test_set_first_element),
+        cmocka_unit_test(test_set_last_element),
+        cmocka_unit_test(test_set_invalid_index),
+        cmocka_unit_test(test_set_null_array),
+        cmocka_unit_test(test_set_null_data),
+        cmocka_unit_test(test_set_while_borrowed),
+    };
 
-  const struct CMUnitTest clear[] = {
-      cmocka_unit_test(test_clear_non_empty_array),
-      cmocka_unit_test(test_clear_already_empty_array),
-      cmocka_unit_test(test_clear_null_array),
-      cmocka_unit_test(test_clear_while_borrowed),
-  };
+    const struct CMUnitTest clear[] = {
+        cmocka_unit_test(test_clear_non_empty_array),
+        cmocka_unit_test(test_clear_already_empty_array),
+        cmocka_unit_test(test_clear_null_array),
+        cmocka_unit_test(test_clear_while_borrowed),
+    };
 
-  const struct CMUnitTest resize[] = {
-      cmocka_unit_test(test_resize_increase_capacity),
-      cmocka_unit_test(test_resize_decrease_capacity),
-      cmocka_unit_test(test_resize_to_zero),
-      cmocka_unit_test(test_resize_to_size_max),
-      cmocka_unit_test(test_resize_null_array),
-      cmocka_unit_test(test_resize_while_borrowed),
-  };
+    const struct CMUnitTest resize[] = {
+        cmocka_unit_test(test_resize_increase_capacity),
+        cmocka_unit_test(test_resize_decrease_capacity),
+        cmocka_unit_test(test_resize_to_zero),
+        cmocka_unit_test(test_resize_to_size_max),
+        cmocka_unit_test(test_resize_null_array),
+        cmocka_unit_test(test_resize_while_borrowed),
+    };
 
-  const struct CMUnitTest reserve[] = {
-      cmocka_unit_test(test_reserve_normal_capacity),
-      cmocka_unit_test(test_reserve_size_0),
-      cmocka_unit_test(test_reserve_size_max),
-      cmocka_unit_test(test_reserve_while_borrowed),
-  };
+    const struct CMUnitTest reserve[] = {
+        cmocka_unit_test(test_reserve_normal_capacity),
+        cmocka_unit_test(test_reserve_size_0),
+        cmocka_unit_test(test_reserve_size_max),
+        cmocka_unit_test(test_reserve_while_borrowed),
+    };
 
-  const struct CMUnitTest slice_array[] = {
-      cmocka_unit_test(test_slice_valid_init),
-      cmocka_unit_test(test_slice_invalid_index),
-      cmocka_unit_test(test_slice_invalid_len),
-      cmocka_unit_test(test_slice_len_zero),
-      cmocka_unit_test(test_slice_empty_array),
-      cmocka_unit_test(test_slice_null_arr),
-  };
+    const struct CMUnitTest slice_array[] = {
+        cmocka_unit_test(test_slice_valid_init),
+        cmocka_unit_test(test_slice_invalid_index),
+        cmocka_unit_test(test_slice_invalid_len),
+        cmocka_unit_test(test_slice_len_zero),
+        cmocka_unit_test(test_slice_empty_array),
+        cmocka_unit_test(test_slice_null_arr),
+    };
 
-  const struct CMUnitTest slice_array_unsafe[] = {
-      cmocka_unit_test(test_slice_unsafe_valid_init),
-      cmocka_unit_test(test_slice_unsafe_invalid_index),
-      cmocka_unit_test(test_slice_unsafe_invalid_len),
-      cmocka_unit_test(test_slice_unsafe_len_zero),
-      cmocka_unit_test(test_slice_unsafe_empty_array),
-      cmocka_unit_test(test_slice_unsafe_null_arr),
-  };
+    const struct CMUnitTest slice_array_unsafe[] = {
+        cmocka_unit_test(test_slice_unsafe_valid_init),
+        cmocka_unit_test(test_slice_unsafe_invalid_index),
+        cmocka_unit_test(test_slice_unsafe_invalid_len),
+        cmocka_unit_test(test_slice_unsafe_len_zero),
+        cmocka_unit_test(test_slice_unsafe_empty_array),
+        cmocka_unit_test(test_slice_unsafe_null_arr),
+    };
 
-  const struct CMUnitTest slice_destroy[] = {
-      cmocka_unit_test(test_slice_destroy_valid),
-      cmocka_unit_test(test_slice_destroy_null_slice),
-      cmocka_unit_test(test_slice_double_destroy),
-  };
+    const struct CMUnitTest slice_destroy[] = {
+        cmocka_unit_test(test_slice_destroy_valid),
+        cmocka_unit_test(test_slice_destroy_null_slice),
+        cmocka_unit_test(test_slice_double_destroy),
+    };
 
-  const struct CMUnitTest slice_peek[] = {
-      cmocka_unit_test(test_slice_peek_valid_array),
-      cmocka_unit_test(test_slice_peek_invalid_array),
-      cmocka_unit_test(test_slice_peek_null_slice),
-      cmocka_unit_test(test_slice_peek_null_out),
-  };
+    const struct CMUnitTest slice_peek[] = {
+        cmocka_unit_test(test_slice_peek_valid_array),
+        cmocka_unit_test(test_slice_peek_invalid_array),
+        cmocka_unit_test(test_slice_peek_null_slice),
+        cmocka_unit_test(test_slice_peek_null_out),
+    };
 
-  const struct CMUnitTest slice_next[] = {
-      cmocka_unit_test(test_slice_next_valid_array),
-      cmocka_unit_test(test_slice_next_invalid_array),
-      cmocka_unit_test(test_slice_next_null_slice),
-      cmocka_unit_test(test_slice_next_null_out),
-      cmocka_unit_test(test_slice_next_until_invalid),
-  };
+    const struct CMUnitTest slice_next[] = {
+        cmocka_unit_test(test_slice_next_valid_array),
+        cmocka_unit_test(test_slice_next_invalid_array),
+        cmocka_unit_test(test_slice_next_null_slice),
+        cmocka_unit_test(test_slice_next_null_out),
+        cmocka_unit_test(test_slice_next_until_invalid),
+    };
 
-  const struct CMUnitTest slice_reset[] = {
-      cmocka_unit_test(test_slice_reset_valid_slice),
-      cmocka_unit_test(test_slice_reset_null_slice),
-  };
+    const struct CMUnitTest slice_reset[] = {
+        cmocka_unit_test(test_slice_reset_valid_slice),
+        cmocka_unit_test(test_slice_reset_null_slice),
+    };
 
-  const struct CMUnitTest slice_advance[] = {
-      cmocka_unit_test(test_slice_advance_valid_slice),
-      cmocka_unit_test(test_slice_advance_out_of_bounds),
-      cmocka_unit_test(test_slice_advance_null_array),
-      cmocka_unit_test(test_slice_advance_size_max),
-  };
+    const struct CMUnitTest slice_advance[] = {
+        cmocka_unit_test(test_slice_advance_valid_slice),
+        cmocka_unit_test(test_slice_advance_out_of_bounds),
+        cmocka_unit_test(test_slice_advance_null_array),
+        cmocka_unit_test(test_slice_advance_size_max),
+    };
 
-  const struct CMUnitTest slice_to_array[] = {
-      cmocka_unit_test(test_slice_to_array_valid),
-      cmocka_unit_test(test_slice_to_array_null_slice),
-  };
+    const struct CMUnitTest slice_to_array[] = {
+        cmocka_unit_test(test_slice_to_array_valid),
+        cmocka_unit_test(test_slice_to_array_null_slice),
+    };
 
-  int rc = 0;
+    int rc = 0;
 
-  rc += cmocka_run_group_tests(init, NULL, NULL);
-  rc += cmocka_run_group_tests(destroy, NULL, NULL);
-  rc += cmocka_run_group_tests(state, NULL, NULL);
-  rc += cmocka_run_group_tests(push_back, NULL, NULL);
-  rc += cmocka_run_group_tests(push_front, NULL, NULL);
-  rc += cmocka_run_group_tests(insert, NULL, NULL);
-  rc += cmocka_run_group_tests(pop_back, NULL, NULL);
-  rc += cmocka_run_group_tests(pop_front, NULL, NULL);
-  rc += cmocka_run_group_tests(remove_at, NULL, NULL);
-  rc += cmocka_run_group_tests(get, NULL, NULL);
-  rc += cmocka_run_group_tests(set, NULL, NULL);
-  rc += cmocka_run_group_tests(clear, NULL, NULL);
-  rc += cmocka_run_group_tests(resize, NULL, NULL);
-  rc += cmocka_run_group_tests(reserve, NULL, NULL);
+    rc += cmocka_run_group_tests(init, NULL, NULL);
+    rc += cmocka_run_group_tests(destroy, NULL, NULL);
+    rc += cmocka_run_group_tests(state, NULL, NULL);
+    rc += cmocka_run_group_tests(push_back, NULL, NULL);
+    rc += cmocka_run_group_tests(push_front, NULL, NULL);
+    rc += cmocka_run_group_tests(insert, NULL, NULL);
+    rc += cmocka_run_group_tests(pop_back, NULL, NULL);
+    rc += cmocka_run_group_tests(pop_front, NULL, NULL);
+    rc += cmocka_run_group_tests(remove_at, NULL, NULL);
+    rc += cmocka_run_group_tests(get, NULL, NULL);
+    rc += cmocka_run_group_tests(set, NULL, NULL);
+    rc += cmocka_run_group_tests(clear, NULL, NULL);
+    rc += cmocka_run_group_tests(resize, NULL, NULL);
+    rc += cmocka_run_group_tests(reserve, NULL, NULL);
 
-  rc += cmocka_run_group_tests(slice_array, NULL, NULL);
-  rc += cmocka_run_group_tests(slice_array_unsafe, NULL, NULL);
-  rc += cmocka_run_group_tests(slice_destroy, NULL, NULL);
-  rc += cmocka_run_group_tests(slice_peek, NULL, NULL);
-  rc += cmocka_run_group_tests(slice_next, NULL, NULL);
-  rc += cmocka_run_group_tests(slice_reset, NULL, NULL);
-  rc += cmocka_run_group_tests(slice_advance, NULL, NULL);
-  rc += cmocka_run_group_tests(slice_to_array, NULL, NULL);
+    rc += cmocka_run_group_tests(slice_array, NULL, NULL);
+    rc += cmocka_run_group_tests(slice_array_unsafe, NULL, NULL);
+    rc += cmocka_run_group_tests(slice_destroy, NULL, NULL);
+    rc += cmocka_run_group_tests(slice_peek, NULL, NULL);
+    rc += cmocka_run_group_tests(slice_next, NULL, NULL);
+    rc += cmocka_run_group_tests(slice_reset, NULL, NULL);
+    rc += cmocka_run_group_tests(slice_advance, NULL, NULL);
+    rc += cmocka_run_group_tests(slice_to_array, NULL, NULL);
 
-  return rc;
+    return rc;
 }
diff --git a/xmake.lua b/xmake.lua
new file mode 100644
index 0000000..d8c8452
--- /dev/null
+++ b/xmake.lua
@@ -0,0 +1,94 @@
+set_project("lae_arraylist")
+set_version("1.0.0")
+
+set_languages("c11")
+
+add_rules("mode.debug", "mode.release")
+
+-- clang compile commands
+add_rules("plugin.compile_commands.autoupdate")
+
+-- =========================================================
+-- Options
+-- =========================================================
+
+option("tests")
+set_default(false)
+set_showmenu(true)
+option_end()
+
+option("example")
+set_default(false)
+set_showmenu(true)
+option_end()
+
+option("asan")
+set_default(false)
+set_showmenu(true)
+option_end()
+
+-- =========================================================
+-- Packages
+-- =========================================================
+
+-- Run xmake repo --add lae-repo https://laentropia-homelab.tail7368da.ts.net/laentropia/xmake-repo.git
+-- to add my repo :)
+
+add_requires("cmocka", { optional = true }) -- For tests
+add_requires("lae_allocator")
+
+-- =========================================================
+-- Library
+-- =========================================================
+
+target("lae_arraylist")
+set_kind("static")
+
+add_packages("lae_allocator", { public = true })
+
+add_files("src/lae_arraylist.c")
+
+add_headerfiles("include/*.h")
+
+add_includedirs("include", { public = true })
+
+if is_mode("debug") then
+	add_cflags("-Wall", "-Wextra", "-Wpedantic")
+end
+
+-- =========================================================
+-- Example executable
+-- =========================================================
+
+if has_config("example") then
+	target("example")
+	set_kind("binary")
+
+	add_deps("lae_arraylist")
+	add_packages("lae_allocator")
+
+	add_files("src/main.c")
+end
+
+-- =========================================================
+-- Tests
+-- =========================================================
+
+if has_config("tests") then
+	target("test_arraylist")
+	set_kind("binary")
+
+	add_files("test/test_arraylist.c")
+
+	add_deps("lae_arraylist")
+
+	add_packages("cmocka")
+
+	add_tests("default")
+
+	if has_config("asan") then
+		add_cflags("-fsanitize=address", "-fno-omit-frame-pointer", { force = true })
+
+		add_ldflags("-fsanitize=address", { force = true })
+	end
+end