refactor: tests work, all fine

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)
 
 # ------------------------

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);

src/arraylist.c

@@ -27,10 +27,12 @@ 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;
     }
 

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);
 }
 
@@ -89,8 +89,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(arraylist_destroy(&arr), ARRLIST_IS_BORROWED);
@@ -284,8 +284,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);
 
     int n = 8;
     assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_IS_BORROWED);
@@ -361,8 +361,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);
 
     int n = 8;
     assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_IS_BORROWED);
@@ -479,8 +479,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);
 
     int n = 8;
     assert_uint_equal(arraylist_insert(arr, 2, &n), ARRLIST_IS_BORROWED);
@@ -594,8 +594,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);
 
     int n = 8;
     assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_IS_BORROWED);
@@ -711,7 +711,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));
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
     assert_non_null(slice);
 
     int n = 8;
@@ -825,8 +826,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);
 
     int n = 8;
     assert_uint_equal(arraylist_remove_at(arr, 5, &n), ARRLIST_IS_BORROWED);
@@ -938,8 +939,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);
 
     int n = 8;
     assert_uint_equal(arraylist_get(arr, 5, &n), ARRLIST_OK);
@@ -1053,8 +1054,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);
 
     int n = 8;
     assert_uint_equal(arraylist_set(arr, 5, &n), ARRLIST_OK);
@@ -1110,8 +1111,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(arraylist_clear(arr), ARRLIST_IS_BORROWED);
 
@@ -1186,8 +1187,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(arraylist_resize(arr, 128), ARRLIST_IS_BORROWED);
 
@@ -1242,8 +1243,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(arraylist_reserve(arr, 128), ARRLIST_IS_BORROWED);
 
@@ -1262,8 +1263,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, 10);
-    assert_non_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, 10), ARRLIST_OK);
 
     arrayslice_destroy(&slice);
     arraylist_destroy(&arr);
@@ -1279,8 +1280,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, 32, 10);
-    assert_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 32, 10), ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
 }
@@ -1295,8 +1296,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, 300);
-    assert_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, 300), ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
 }
@@ -1311,8 +1312,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, 0);
-    assert_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice(&slice, arr, 0, 0), ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
 }
@@ -1324,8 +1325,8 @@ static void test_slice_empty_array(void **state) {
     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
@@ -1350,8 +1351,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, 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);
@@ -1367,8 +1368,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, 32, 10);
-    assert_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 32, 10), ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
 }
@@ -1383,8 +1384,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, 300);
-    assert_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 300), ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
 }
@@ -1399,8 +1400,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, 0);
-    assert_null(slice);
+    ArraySlice *slice;
+    assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 0), ARRLIST_INVALID_START);
 
     arraylist_destroy(&arr);
 }
@@ -1412,8 +1413,8 @@ static void test_slice_unsafe_empty_array(void **state) {
     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);
@@ -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);
@@ -1489,9 +1489,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);
 
     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);
 
@@ -1534,8 +1533,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_peek(slice, NULL), ARRLIST_NULL_ARG);
 
@@ -1564,8 +1563,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);
 
     int m;
     assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
@@ -1585,8 +1584,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);
 
@@ -1608,8 +1607,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_next(slice, NULL), ARRLIST_OK);
 
@@ -1637,8 +1636,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);
 
     int m;
     for (int i = 0; i < 10; i++) {
@@ -1662,8 +1661,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);
 
     int m;
     for (int i = 0; i < 10; i++) {
@@ -1703,8 +1702,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);
 
     int m;
     for (int i = 0; i < 5; i++) {
@@ -1728,8 +1727,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);
 
     int m;
     for (int i = 0; i < 5; i++) {
@@ -1753,8 +1752,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);
 
     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) {