diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9c72d54..ab30810 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,7 +8,7 @@ set(CMAKE_C_STANDARD_REQUIRED ON)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 # Opciones
-option(ARRAYLIST_BUILD_TESTS "Build arraylist tests" OFF)
+option(ARRAYLIST_BUILD_TESTS "Build arraylist tests" ON)
 option(ARRAYLIST_ENABLE_SANITIZERS "Enable sanitizers for tests" ON)
 
 # ------------------------
diff --git a/include/arraylist.h b/include/arraylist.h
index a5943b6..78149a6 100644
--- a/include/arraylist.h
+++ b/include/arraylist.h
@@ -22,6 +22,7 @@ typedef enum {
     ARRLIST_INVALID_SLICE,
     ARRLIST_INVALID_ARR,
     ARRLIST_INVALID_START,
+    ARRLIST_BORROW_UNDERFLOW,
 } ArrayListErr;
 
 ArrayListErr arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size);
diff --git a/src/arraylist.c b/src/arraylist.c
index 6000bd8..b401d0f 100644
--- a/src/arraylist.c
+++ b/src/arraylist.c
@@ -27,9 +27,11 @@ static ArrayListErr arraylist_grow(ArrayList *arr);
 static ArrayListErr arraylist_shrink(ArrayList *arr);
 
 ArrayListErr arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size) {
-    if (arr == NULL || *arr == NULL) {
+    if (arr == NULL) {
         return ARRLIST_NULL_ARG;
     }
+    
+    *arr = NULL;
 
     if (capacity == 0) {
         return ARRLIST_INVALID_CAPACITY;
@@ -44,7 +46,7 @@ ArrayListErr arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size)
     }
 
     ArrayList *new_arr = malloc(sizeof(ArrayList));
-    if (arr == NULL) {
+    if (new_arr == NULL) {
         return ARRLIST_BAD_ALLOC;
     }
 
@@ -54,8 +56,8 @@ ArrayListErr arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size)
     new_arr->borrows = 0;
     new_arr->buffer = malloc(capacity * elem_size);
     if (new_arr->buffer == NULL) {
-        free(arr);
-        return NULL;
+        free(new_arr);
+        return ARRLIST_BAD_ALLOC;
     }
 
     *arr = new_arr;
@@ -435,19 +437,19 @@ ArrayListErr arraylist_reserve(ArrayList *arr, size_t size_to_reserve) {
 }
 
 ArrayListErr arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, size_t len) {
-    if (arr == NULL) {
+    if (arr == NULL || slice == NULL) {
         return ARRLIST_NULL_ARG;
     }
 
-    if (arr->len == 0 || len == 0) {
+    if (arr->len == 0) {
         return ARRLIST_INVALID_ARR;
     }
 
-    if (start > SIZE_MAX / arr->elem_size || len > SIZE_MAX / arr->elem_size) {
+    if (start > SIZE_MAX - len) {
         return ARRLIST_INVALID_CAPACITY;
     }
 
-    if (start + len > arr->len) {
+    if (start + len > arr->len || len == 0) {
         return ARRLIST_INVALID_START;
     }
 
@@ -460,26 +462,27 @@ ArrayListErr arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, s
     new_slice->start = start;
     new_slice->end = start + len;
     new_slice->current = start;
-    new_slice->is_safe = false;
+    new_slice->is_safe = true;
 
+    arr->borrows++;
     *slice = new_slice;
     return ARRLIST_OK;
 }
 
 ArrayListErr arraylist_slice_unsafe(ArraySlice **slice, ArrayList *arr, size_t start, size_t len) {
-    if (arr == NULL) {
+    if (arr == NULL || slice == NULL) {
         return ARRLIST_NULL_ARG;
     }
 
-    if (arr->len == 0 || len == 0) {
+    if (arr->len == 0) {
         return ARRLIST_INVALID_ARR;
     }
 
-    if (start > SIZE_MAX / arr->elem_size || len > SIZE_MAX / arr->elem_size) {
+    if (start > SIZE_MAX - len) {
         return ARRLIST_INVALID_CAPACITY;
     }
 
-    if (start + len > arr->len) {
+    if (start + len > arr->len || len == 0) {
         return ARRLIST_INVALID_START;
     }
 
@@ -589,7 +592,7 @@ ArrayListErr arrayslice_to_arraylist(ArrayList **arr, const ArraySlice *slice) {
         return ARRLIST_NULL_ARG;
     }
 
-    if (arr == NULL || *arr == NULL) {
+    if (arr == NULL) {
         return ARRLIST_NULL_ARG;
     }
 
diff --git a/test/test_arraylist.c b/test/test_arraylist.c
index 44af3e6..bf233bc 100644
--- a/test/test_arraylist.c
+++ b/test/test_arraylist.c
@@ -31,7 +31,7 @@ static void test_init_zero_elem_size(void **state) {
     (void) state;
 
     ArrayList *arr;
-    assert_uint_equal(arraylist_init(&arr, 0, sizeof(int)), ARRLIST_INVALID_ELEM_SIZE);
+    assert_uint_equal(arraylist_init(&arr, 64, 0), ARRLIST_INVALID_ELEM_SIZE);
     arraylist_destroy(&arr);
 }
 
@@ -68,7 +68,7 @@ static void test_destroy_double(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     ArrayListErr err = arraylist_destroy(&arr);
     assert_uint_equal(err, ARRLIST_OK);
@@ -83,14 +83,14 @@ static void test_destroy_while_borrowed(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
 
     assert_uint_equal(arraylist_destroy(&arr), ARRLIST_IS_BORROWED);
@@ -104,7 +104,7 @@ static void test_capacity_after_init(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     assert_uint_equal(arraylist_capacity(arr), 64);
 
@@ -115,7 +115,7 @@ static void test_is_empty_after_init(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     assert_true(arraylist_is_empty(arr));
 
@@ -126,7 +126,7 @@ static void test_is_empty_after_push(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -140,7 +140,7 @@ static void test_size_after_many_push(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -162,7 +162,7 @@ static void test_capacity_growth_on_push(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 2, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 2, sizeof(int)), ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -181,7 +181,7 @@ static void test_capacity_shrink_on_pop(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 8, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 8, sizeof(int)), ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -196,7 +196,7 @@ static void test_push_back_single_element(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -213,7 +213,7 @@ static void test_push_back_multiple_elements(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -278,14 +278,14 @@ static void test_push_back_while_borrowed(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_IS_BORROWED);
@@ -299,7 +299,7 @@ static void test_push_front_single_element(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     int n = 8;
     int m;
@@ -315,7 +315,7 @@ static void test_push_front_multiple_elements(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     int n = 8;
     int m;
@@ -344,7 +344,7 @@ static void test_push_front_null_data(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     assert_int_equal(arraylist_push_front(arr, NULL), ARRLIST_NULL_ARG);
 
@@ -355,14 +355,14 @@ static void test_push_front_while_borrowed(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice,arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_IS_BORROWED);
@@ -376,7 +376,7 @@ static void test_insert_at_beginning(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -397,7 +397,7 @@ static void test_insert_at_middle(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -418,7 +418,7 @@ static void test_insert_at_end(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -439,7 +439,7 @@ static void test_insert_at_invalid_index(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
 
     int n = 8;
@@ -461,7 +461,7 @@ static void test_insert_null_data(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
 
     assert_uint_equal(arraylist_insert(arr, 0, NULL), ARRLIST_NULL_ARG);
@@ -473,14 +473,14 @@ static void test_insert_while_borrowed(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_insert(arr, 2, &n), ARRLIST_IS_BORROWED);
@@ -494,7 +494,7 @@ static void test_pop_back_single_element(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -511,7 +511,7 @@ static void test_pop_back_multiple_elements(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -531,7 +531,7 @@ static void test_pop_back_until_empty(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -553,7 +553,7 @@ static void test_pop_back_empty_array(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     int n;
     assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_EMPTY);
@@ -574,7 +574,7 @@ static void test_pop_back_null_out(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -588,14 +588,14 @@ static void test_pop_back_while_borrowed(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_IS_BORROWED);
@@ -609,7 +609,7 @@ static void test_pop_front_single_element(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -626,7 +626,7 @@ static void test_pop_front_multiple_elements(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -647,7 +647,7 @@ static void test_pop_front_until_empty(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -670,7 +670,7 @@ static void test_pop_front_empty_array(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     int n;
     assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_EMPTY);
@@ -691,7 +691,7 @@ static void test_pop_front_null_out(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -705,13 +705,14 @@ static void test_pop_front_while_borrowed(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
     assert_non_null(slice);
 
     int n = 8;
@@ -726,7 +727,7 @@ static void test_remove_at_beginning(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -745,7 +746,7 @@ static void test_remove_at_middle(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -764,7 +765,7 @@ static void test_remove_at_end(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -783,7 +784,7 @@ static void test_remove_at_invalid_index(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
 
     int n = 8;
@@ -805,7 +806,7 @@ static void test_remove_at_null_data(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
@@ -819,14 +820,14 @@ static void test_remove_at_while_borrowed(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_remove_at(arr, 5, &n), ARRLIST_IS_BORROWED);
@@ -840,7 +841,7 @@ static void test_get_valid_index(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -857,7 +858,7 @@ static void test_get_first_element(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -874,7 +875,7 @@ static void test_get_last_element(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -891,7 +892,7 @@ static void test_get_invalid_index(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -917,7 +918,7 @@ static void test_get_null_out(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -932,14 +933,14 @@ static void test_get_while_borrowed(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_get(arr, 5, &n), ARRLIST_OK);
@@ -953,7 +954,7 @@ static void test_set_valid_index(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -972,7 +973,7 @@ static void test_set_first_element(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -991,7 +992,7 @@ static void test_set_last_element(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1010,7 +1011,7 @@ static void test_set_invalid_index(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1036,7 +1037,7 @@ static void test_set_null_data(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     assert_uint_equal(arraylist_set(arr, 8, NULL), ARRLIST_NULL_ARG);
 
@@ -1047,14 +1048,14 @@ static void test_set_while_borrowed(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     int n = 8;
     assert_uint_equal(arraylist_set(arr, 5, &n), ARRLIST_OK);
@@ -1068,7 +1069,7 @@ static void test_clear_non_empty_array(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1085,7 +1086,7 @@ static void test_clear_already_empty_array(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     assert_uint_equal(arraylist_clear(arr), ARRLIST_OK);
 
@@ -1104,14 +1105,14 @@ static void test_clear_while_borrowed(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     assert_uint_equal(arraylist_clear(arr), ARRLIST_IS_BORROWED);
 
@@ -1124,7 +1125,7 @@ static void test_resize_increase_capacity(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_OK);
     assert_uint_equal(arraylist_capacity(arr), 128);
@@ -1136,7 +1137,7 @@ static void test_resize_decrease_capacity(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     assert_uint_equal(arraylist_resize(arr, 32), ARRLIST_OK);
     assert_uint_equal(arraylist_capacity(arr), 32);
@@ -1148,7 +1149,7 @@ static void test_resize_to_zero(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     assert_uint_equal(arraylist_resize(arr, 0), ARRLIST_INVALID_CAPACITY);
     assert_uint_equal(arraylist_capacity(arr), 64);
@@ -1160,7 +1161,7 @@ static void test_resize_to_size_max(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     assert_uint_equal(arraylist_resize(arr, SIZE_MAX), ARRLIST_ALLOC_OVERFLOW);
     assert_uint_equal(arraylist_capacity(arr), 64);
@@ -1180,14 +1181,14 @@ static void test_resize_while_borrowed(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_IS_BORROWED);
 
@@ -1200,7 +1201,7 @@ static void test_reserve_normal_capacity(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     assert_uint_equal(arraylist_reserve(arr, 32), ARRLIST_OK);
     assert_uint_equal(arraylist_capacity(arr), 96);
@@ -1212,7 +1213,7 @@ static void test_reserve_size_max(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     assert_uint_equal(arraylist_reserve(arr, SIZE_MAX), ARRLIST_ALLOC_OVERFLOW);
     assert_uint_equal(arraylist_capacity(arr), 64);
@@ -1224,7 +1225,7 @@ static void test_reserve_size_0(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     assert_uint_equal(arraylist_reserve(arr, 0), ARRLIST_OK);
     assert_uint_equal(arraylist_capacity(arr), 64);
@@ -1236,14 +1237,14 @@ static void test_reserve_while_borrowed(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     assert_uint_equal(arraylist_reserve(arr, 128), ARRLIST_IS_BORROWED);
 
@@ -1256,14 +1257,14 @@ static void test_slice_valid_init(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, 10);
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, 10), ARRLIST_OK);
 
     arrayslice_destroy(&slice);
     arraylist_destroy(&arr);
@@ -1273,14 +1274,14 @@ static void test_slice_invalid_index(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 32, 10);
-    assert_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 32, 10), ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
 }
@@ -1289,14 +1290,14 @@ static void test_slice_invalid_len(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, 300);
-    assert_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, 300), ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
 }
@@ -1305,14 +1306,14 @@ static void test_slice_len_zero(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, 0);
-    assert_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, 0), ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
 }
@@ -1321,11 +1322,11 @@ static void test_slice_empty_array(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
 
-    ArraySlice *slice = arraylist_slice(arr, 0, 10);
-    assert_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, 10), ARRLIST_INVALID_ARR);
 
     arraylist_destroy(&arr);
 }
@@ -1335,8 +1336,8 @@ static void test_slice_null_arr(void **state) {
 
     ArrayList *arr = NULL;
 
-    ArraySlice *slice = arraylist_slice(arr, 0, 10);
-    assert_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, 10), ARRLIST_NULL_ARG);
 }
 
 // Slice Unsafe
@@ -1344,14 +1345,14 @@ static void test_slice_unsafe_valid_init(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, 10);
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 10), ARRLIST_OK);
 
     arrayslice_destroy(&slice);
     arraylist_destroy(&arr);
@@ -1361,14 +1362,14 @@ static void test_slice_unsafe_invalid_index(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 32, 10);
-    assert_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 32, 10), ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
 }
@@ -1377,14 +1378,14 @@ static void test_slice_unsafe_invalid_len(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, 300);
-    assert_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 300), ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
 }
@@ -1393,14 +1394,14 @@ static void test_slice_unsafe_len_zero(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (size_t i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, 0);
-    assert_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 0), ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
 }
@@ -1409,11 +1410,11 @@ static void test_slice_unsafe_empty_array(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
 
-    ArraySlice *slice = arraylist_slice(arr, 0, 10);
-    assert_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 10), ARRLIST_INVALID_ARR);
 
     arraylist_destroy(&arr);
 }
@@ -1423,8 +1424,8 @@ static void test_slice_unsafe_null_arr(void **state) {
 
     ArrayList *arr = NULL;
 
-    ArraySlice *slice = arraylist_slice(arr, 0, 10);
-    assert_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 10), ARRLIST_NULL_ARG);
 }
 
 // Slice Destroy
@@ -1438,8 +1439,8 @@ assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_OK);
     arraylist_destroy(&arr);
@@ -1449,7 +1450,7 @@ static void test_slice_destroy_null_slice(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
@@ -1470,9 +1471,8 @@ assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
-
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_OK);
     assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_NULL_ARG);
@@ -1484,14 +1484,13 @@ static void test_slice_peek_valid_array(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
-
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     int m;
     assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_OK);
@@ -1511,8 +1510,8 @@ assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK);
 
@@ -1528,14 +1527,14 @@ static void test_slice_peek_null_out(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     assert_uint_equal(arrayslice_peek(slice, NULL), ARRLIST_NULL_ARG);
 
@@ -1558,14 +1557,14 @@ static void test_slice_next_valid_array(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     int m;
     assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
@@ -1579,14 +1578,14 @@ static void test_slice_next_invalid_array(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK);
 
@@ -1602,14 +1601,14 @@ static void test_slice_next_null_out(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     assert_uint_equal(arrayslice_next(slice, NULL), ARRLIST_OK);
 
@@ -1631,14 +1630,14 @@ static void test_slice_next_until_invalid(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     int m;
     for (int i = 0; i < 10; i++) {
@@ -1656,14 +1655,14 @@ static void test_slice_reset_valid_slice(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     int m;
     for (int i = 0; i < 10; i++) {
@@ -1697,14 +1696,14 @@ static void test_slice_advance_valid_slice(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     int m;
     for (int i = 0; i < 5; i++) {
@@ -1722,14 +1721,14 @@ static void test_slice_advance_out_of_bounds(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     int m;
     for (int i = 0; i < 5; i++) {
@@ -1747,14 +1746,14 @@ static void test_slice_advance_size_max(void **state) {
     (void) state;
 
     ArrayList *arr;
-assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
+    assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
     for (int i = 0; i < 10; i++) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
     int m;
     for (int i = 0; i < 5; i++) {
@@ -1787,11 +1786,11 @@ static void test_slice_to_array_valid(void **state) {
         assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
     }
 
-    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
 
-    ArrayList *arr2 = arrayslice_to_arraylist(slice);
-    assert_non_null(arr2);
+    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);
 
@@ -1804,8 +1803,9 @@ static void test_slice_to_array_null_slice(void **state) {
     (void) state;
 
     ArraySlice *slice = NULL;
+    ArrayList *arr = NULL;
 
-    assert_null(arrayslice_to_arraylist(slice));
+    assert_uint_equal(arrayslice_to_arraylist(&arr, slice), ARRLIST_NULL_ARG);
 }
 
 int main(void) {