ArrayList/test/test_arraylist.c

#include <stdalign.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <setjmp.h>
#include <cmocka.h>
#include <string.h>

#include "arraylist.h"

// INIT

static void test_init_valid_parameters(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);
    arraylist_destroy(&arr);
}

static void test_init_zero_capacity(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(0, sizeof(int));
    assert_null(arr);
    arraylist_destroy(&arr);
}

static void test_init_zero_elem_size(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, 0);
    assert_null(arr);
    arraylist_destroy(&arr);
}

static void test_init_large_capacity(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(SIZE_MAX, sizeof(int));
    assert_null(arr);
    arraylist_destroy(&arr);
}

// DESTROY
 
static void test_destroy_valid_array(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    arraylist_destroy(&arr);
    assert_null(arr);
}

static void test_destroy_null_array(void **state) {
    (void) state;

    ArrayList *arr = NULL;
    ArrayListErr err = arraylist_destroy(&arr);

    assert_null(arr);
    assert_uint_equal(err, ARRLIST_NULL_ARG);
}

static void test_destroy_double(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_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);
}

static void test_destroy_while_borrowed(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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


    assert_uint_equal(arraylist_destroy(&arr), ARRLIST_IS_BORROWED);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

// State
static void test_capacity_after_init(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    assert_uint_equal(arraylist_capacity(arr), 64);

    arraylist_destroy(&arr);
}

static void test_is_empty_after_init(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    assert_true(arraylist_is_empty(arr));

    arraylist_destroy(&arr);
}

static void test_is_empty_after_push(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    int n = 8;
    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
    
    assert_false(arraylist_is_empty(arr));

    arraylist_destroy(&arr);
}

static void test_size_after_many_push(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
    assert_uint_equal(arraylist_size(arr), 4);

    arraylist_destroy(&arr);
}

static void test_capacity_growth_on_push(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(2, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_capacity_shrink_on_pop(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(8, sizeof(int));
    assert_non_null(arr);

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

// push_back
static void test_push_back_single_element(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_push_back_multiple_elements(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    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, 3, &b), ARRLIST_OK);
    assert_int_equal(b, 11);

    assert_uint_equal(arraylist_get(arr, 4, &b), ARRLIST_OK);
    assert_int_equal(b, 12);

    arraylist_destroy(&arr);
}

static void test_push_back_null_array(void **state) {
    (void) state;

    ArrayList *arr = NULL;

    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;

    ArrayList *arr = arraylist_init(64, sizeof(int));

    assert_uint_equal(arraylist_push_back(arr, NULL), ARRLIST_NULL_ARG);

    arraylist_destroy(&arr);
}

static void test_push_back_while_borrowed(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    int n = 8;
    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_IS_BORROWED);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

// Push front
static void test_push_front_single_element(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

static void test_push_front_multiple_elements(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    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++;
    }

    arraylist_destroy(&arr);
}

static void test_push_front_null_array(void **state) {
    (void) state;

    ArrayList *arr = NULL;

    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;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    assert_int_equal(arraylist_push_front(arr, NULL), ARRLIST_NULL_ARG);

    arraylist_destroy(&arr);
}

static void test_push_front_while_borrowed(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    int n = 8;
    assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_IS_BORROWED);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

// Insert
static void test_insert_at_beginning(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_insert_at_middle(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_insert_at_end(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_insert_at_invalid_index(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);


    int n = 8;
    assert_uint_equal(arraylist_insert(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS);

    arraylist_destroy(&arr);
}

static void test_insert_null_array(void **state) {
    (void) state;

    ArrayList *arr = NULL;

    int n = 8;
    assert_uint_equal(arraylist_insert(arr, 0, &n), ARRLIST_NULL_ARG);
}

static void test_insert_null_data(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);


    assert_uint_equal(arraylist_insert(arr, 0, NULL), ARRLIST_NULL_ARG);

    arraylist_destroy(&arr);
}

static void test_insert_while_borrowed(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    int n = 8;
    assert_uint_equal(arraylist_insert(arr, 2, &n), ARRLIST_IS_BORROWED);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

// Pop back
static void test_pop_back_single_element(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_pop_back_multiple_elements(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_pop_back_until_empty(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_EMPTY);

    arraylist_destroy(&arr);
}

static void test_pop_back_empty_array(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    int n;
    assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_EMPTY);

    arraylist_destroy(&arr);
}

static void test_pop_back_null_array(void **state) {
    (void) state;

    ArrayList *arr = NULL;

    int n;
    assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_NULL_ARG);
}

static void test_pop_back_null_out(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    int n = 8;
    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);

    assert_uint_equal(arraylist_pop_back(arr, NULL), ARRLIST_OK);

    arraylist_destroy(&arr);
}

static void test_pop_back_while_borrowed(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    int n = 8;
    assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_IS_BORROWED);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

// Pop front
static void test_pop_front_single_element(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_pop_front_multiple_elements(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_pop_front_until_empty(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_EMPTY);

    arraylist_destroy(&arr);
}

static void test_pop_front_empty_array(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    int n;
    assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_EMPTY);

    arraylist_destroy(&arr);
}

static void test_pop_front_null_array(void **state) {
    (void) state;

    ArrayList *arr = NULL;

    int n;
    assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_NULL_ARG);
}

static void test_pop_front_null_out(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    int n = 8;
    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);

    assert_uint_equal(arraylist_pop_front(arr, NULL), ARRLIST_OK);

    arraylist_destroy(&arr);
}

static void test_pop_front_while_borrowed(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    int n = 8;
    assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_IS_BORROWED);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

// Remove at
static void test_remove_at_beginning(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_remove_at_middle(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_remove_at_end(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_remove_at_invalid_index(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);


    int n = 8;
    assert_uint_equal(arraylist_remove_at(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS);

    arraylist_destroy(&arr);
}

static void test_remove_at_null_array(void **state) {
    (void) state;

    ArrayList *arr = NULL;

    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;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    int n = 8;
    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);

    assert_uint_equal(arraylist_remove_at(arr, 0, NULL), ARRLIST_OK);

    arraylist_destroy(&arr);
}

static void test_remove_at_while_borrowed(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    int n = 8;
    assert_uint_equal(arraylist_remove_at(arr, 5, &n), ARRLIST_IS_BORROWED);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

// Get
static void test_get_valid_index(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_get_first_element(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_get_last_element(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_get_invalid_index(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_get_null_array(void **state) {
    (void) state;

    ArrayList *arr = NULL;


    int m;
    assert_uint_equal(arraylist_get(arr, 80, &m), ARRLIST_NULL_ARG);
}

static void test_get_null_out(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_get_while_borrowed(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    int n = 8;
    assert_uint_equal(arraylist_get(arr, 5, &n), ARRLIST_OK);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

// Set
static void test_set_valid_index(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_set_first_element(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_set_last_element(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_set_invalid_index(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_set_null_array(void **state) {
    (void) state;

    ArrayList *arr = NULL;

    int n = 8;
    assert_uint_equal(arraylist_set(arr, 80, &n), ARRLIST_NULL_ARG);

}

static void test_set_null_data(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    assert_uint_equal(arraylist_set(arr, 8, NULL), ARRLIST_NULL_ARG);

    arraylist_destroy(&arr);
}

static void test_set_while_borrowed(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    int n = 8;
    assert_uint_equal(arraylist_set(arr, 5, &n), ARRLIST_OK);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

//Clear
static void test_clear_non_empty_array(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_clear_already_empty_array(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    assert_uint_equal(arraylist_clear(arr), ARRLIST_OK);

    arraylist_destroy(&arr);
}

static void test_clear_null_array(void **state) {
    (void) state;

    ArrayList *arr = NULL;

    assert_uint_equal(arraylist_clear(arr), ARRLIST_NULL_ARG);
}

static void test_clear_while_borrowed(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    assert_uint_equal(arraylist_clear(arr), ARRLIST_IS_BORROWED);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

//Resize
static void test_resize_increase_capacity(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_OK);
    assert_uint_equal(arraylist_capacity(arr), 128);
    
    arraylist_destroy(&arr);
}

static void test_resize_decrease_capacity(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    assert_uint_equal(arraylist_resize(arr, 32), ARRLIST_OK);
    assert_uint_equal(arraylist_capacity(arr), 32);

    arraylist_destroy(&arr);
}

static void test_resize_to_zero(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    assert_uint_equal(arraylist_resize(arr, 0), ARRLIST_INVALID_CAPACITY);
    assert_uint_equal(arraylist_capacity(arr), 64);

    arraylist_destroy(&arr);
}

static void test_resize_to_size_max(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    assert_uint_equal(arraylist_resize(arr, SIZE_MAX), ARRLIST_ALLOC_OVERFLOW);
    assert_uint_equal(arraylist_capacity(arr), 64);

    arraylist_destroy(&arr);
}

static void test_resize_null_array(void **state) {
    (void) state;

    ArrayList *arr = NULL;

    assert_uint_equal(arraylist_resize(arr, 65), ARRLIST_NULL_ARG);
}

static void test_resize_while_borrowed(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_IS_BORROWED);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

// Reserve
static void test_reserve_normal_capacity(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    assert_uint_equal(arraylist_reserve(arr, 32), ARRLIST_OK);
    assert_uint_equal(arraylist_capacity(arr), 96);

    arraylist_destroy(&arr);
}

static void test_reserve_size_max(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    assert_uint_equal(arraylist_reserve(arr, SIZE_MAX), ARRLIST_ALLOC_OVERFLOW);
    assert_uint_equal(arraylist_capacity(arr), 64);

    arraylist_destroy(&arr);
}

static void test_reserve_size_0(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    assert_uint_equal(arraylist_reserve(arr, 0), ARRLIST_OK);
    assert_uint_equal(arraylist_capacity(arr), 64);

    arraylist_destroy(&arr);
}

static void test_reserve_while_borrowed(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    assert_uint_equal(arraylist_reserve(arr, 128), ARRLIST_IS_BORROWED);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

// Slice creation
static void test_slice_valid_init(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    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_destroy(&slice);
    arraylist_destroy(&arr);
}

static void test_slice_invalid_index(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_slice_invalid_len(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_slice_len_zero(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_slice_empty_array(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);


    ArraySlice *slice = arraylist_slice(arr, 0, 10);
    assert_null(slice);

    arraylist_destroy(&arr);
}

static void test_slice_null_arr(void **state) {
    (void) state;

    ArrayList *arr = NULL;

    ArraySlice *slice = arraylist_slice(arr, 0, 10);
    assert_null(slice);
}

// Slice Unsafe
static void test_slice_unsafe_valid_init(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    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_destroy(&slice);
    arraylist_destroy(&arr);
}

static void test_slice_unsafe_invalid_index(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_slice_unsafe_invalid_len(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_slice_unsafe_len_zero(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    arraylist_destroy(&arr);
}

static void test_slice_unsafe_empty_array(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);


    ArraySlice *slice = arraylist_slice(arr, 0, 10);
    assert_null(slice);

    arraylist_destroy(&arr);
}

static void test_slice_unsafe_null_arr(void **state) {
    (void) state;

    ArrayList *arr = NULL;

    ArraySlice *slice = arraylist_slice(arr, 0, 10);
    assert_null(slice);
}

// Slice Destroy
static void test_slice_destroy_valid(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_OK);
    arraylist_destroy(&arr);
}

static void test_slice_destroy_null_slice(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

    for (int i = 0; i < 10; i++) {
        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
    }

    ArraySlice *slice = NULL;

    assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_NULL_ARG);
    arraylist_destroy(&arr);
}

static void test_slice_double_destroy(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    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;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    int m;
    assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_OK);
    assert_int_equal(m, 0);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

static void test_slice_peek_invalid_array(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK);

    int m;
    assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_INVALID_SLICE);
    assert_int_equal(m, 0);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

static void test_slice_peek_null_out(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    assert_uint_equal(arrayslice_peek(slice, NULL), ARRLIST_NULL_ARG);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

static void test_slice_peek_null_slice(void **state) {
    (void) state;

    ArraySlice *slice = NULL;

    int m;
    assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_NULL_ARG);
    assert_int_equal(m, 0);
}

// Slice next
static void test_slice_next_valid_array(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    int m;
    assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
    assert_int_equal(m, 0);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

static void test_slice_next_invalid_array(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK);

    int m;
    assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_INVALID_SLICE);
    assert_int_equal(m, 0);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

static void test_slice_next_null_out(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

    assert_uint_equal(arrayslice_next(slice, NULL), ARRLIST_OK);

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

static void test_slice_next_null_slice(void **state) {
    (void) state;

    ArraySlice *slice = NULL;

    int m;
    assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_NULL_ARG);
    assert_int_equal(m, 0);
}

static void test_slice_next_until_invalid(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

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

//Slice reset
static void test_slice_reset_valid_slice(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

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

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

static void test_slice_reset_null_slice(void **state) {
    (void) state;

    ArraySlice *slice = NULL;

    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;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

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

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

static void test_slice_advance_out_of_bounds(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

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

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

static void test_slice_advance_size_max(void **state) {
    (void) state;

    ArrayList *arr = arraylist_init(64, sizeof(int));
    assert_non_null(arr);

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

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

    arrayslice_destroy(&slice);
    arraylist_destroy(&arr);
}

static void test_slice_advance_null_array(void **state) {
    (void) state;

    ArraySlice *slice = NULL;

    assert_uint_equal(arrayslice_advance(slice, 56), 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 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 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 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_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 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 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 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_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_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_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),
    };

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

    return rc;
}