From 5734af33db3af45374d2ec8b27cc9eb1bd654d4d Mon Sep 17 00:00:00 2001 From: laentropia Date: Wed, 20 May 2026 17:37:59 -0600 Subject: [PATCH] Test cfix --- test/test_arraylist.c | 2455 +++++++++++++++++++++-------------------- 1 file changed, 1239 insertions(+), 1216 deletions(-) diff --git a/test/test_arraylist.c b/test/test_arraylist.c index bf233bc..9a190f5 100644 --- a/test/test_arraylist.c +++ b/test/test_arraylist.c @@ -1,10 +1,10 @@ +#include +#include #include #include #include #include #include -#include -#include #include #include "arraylist.h" @@ -12,2006 +12,2029 @@ // INIT static void test_init_valid_parameters(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - arraylist_destroy(&arr); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + arraylist_destroy(&arr); } static void test_init_zero_capacity(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_uint_equal(arraylist_init(&arr, 0, sizeof(int)), ARRLIST_INVALID_CAPACITY); - arraylist_destroy(&arr); + ArrayList *arr; + assert_uint_equal(arraylist_init(&arr, 0, sizeof(int)), + ARRLIST_INVALID_CAPACITY); + arraylist_destroy(&arr); } static void test_init_zero_elem_size(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_uint_equal(arraylist_init(&arr, 64, 0), ARRLIST_INVALID_ELEM_SIZE); - arraylist_destroy(&arr); + ArrayList *arr; + assert_uint_equal(arraylist_init(&arr, 64, 0), ARRLIST_INVALID_ELEM_SIZE); + arraylist_destroy(&arr); } static void test_init_large_capacity(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_uint_equal(arraylist_init(&arr, SIZE_MAX, sizeof(int)), ARRLIST_INVALID_CAPACITY); - arraylist_destroy(&arr); + ArrayList *arr; + assert_uint_equal(arraylist_init(&arr, SIZE_MAX, sizeof(int)), + ARRLIST_INVALID_CAPACITY); + arraylist_destroy(&arr); } // DESTROY - -static void test_destroy_valid_array(void **state) { - (void) state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - arraylist_destroy(&arr); - assert_null(arr); +static void test_destroy_valid_array(void **state) { + (void)state; + + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + arraylist_destroy(&arr); + assert_null(arr); } static void test_destroy_null_array(void **state) { - (void) state; + (void)state; - ArrayList *arr = NULL; - ArrayListErr err = arraylist_destroy(&arr); + ArrayList *arr = NULL; + ArrayListErr err = arraylist_destroy(&arr); - assert_null(arr); - assert_uint_equal(err, ARRLIST_NULL_ARG); + assert_null(arr); + assert_uint_equal(err, ARRLIST_NULL_ARG); } static void test_destroy_double(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - ArrayListErr err = arraylist_destroy(&arr); - assert_uint_equal(err, ARRLIST_OK); - assert_null(arr); + ArrayListErr err = arraylist_destroy(&arr); + assert_uint_equal(err, ARRLIST_OK); + assert_null(arr); - err = arraylist_destroy(&arr); - assert_uint_equal(err, ARRLIST_NULL_ARG); - assert_null(arr); + err = arraylist_destroy(&arr); + assert_uint_equal(err, ARRLIST_NULL_ARG); + assert_null(arr); } static void test_destroy_while_borrowed(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); + assert_uint_equal(arraylist_destroy(&arr), ARRLIST_IS_BORROWED); - assert_uint_equal(arraylist_destroy(&arr), ARRLIST_IS_BORROWED); - - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } // State static void test_capacity_after_init(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - assert_uint_equal(arraylist_capacity(arr), 64); + assert_uint_equal(arraylist_capacity(arr), 64); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_is_empty_after_init(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - assert_true(arraylist_is_empty(arr)); + assert_true(arraylist_is_empty(arr)); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_is_empty_after_push(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - int n = 8; - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - - assert_false(arraylist_is_empty(arr)); + int n = 8; + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - arraylist_destroy(&arr); + assert_false(arraylist_is_empty(arr)); + + arraylist_destroy(&arr); } static void test_size_after_many_push(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - int n = 8; - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 1); + int n = 8; + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 1); - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 2); + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 2); - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 3); + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 3); - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 4); + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 4); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_capacity_growth_on_push(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 2, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 2, sizeof(int)), ARRLIST_OK); - int n = 8; - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_capacity(arr), 2); + int n = 8; + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); + assert_uint_equal(arraylist_capacity(arr), 2); - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_capacity(arr), 2); + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); + assert_uint_equal(arraylist_capacity(arr), 2); - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_capacity(arr), 4); + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); + assert_uint_equal(arraylist_capacity(arr), 4); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_capacity_shrink_on_pop(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 8, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 8, sizeof(int)), ARRLIST_OK); - int n = 8; - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_capacity(arr), 4); + int n = 8; + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); + assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_OK); + assert_uint_equal(arraylist_capacity(arr), 4); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } // push_back static void test_push_back_single_element(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - int n = 8; - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 1); + int n = 8; + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 1); - int b; - assert_uint_equal(arraylist_get(arr, 0, &b), ARRLIST_OK); - assert_int_equal(b, 8); + int b; + assert_uint_equal(arraylist_get(arr, 0, &b), ARRLIST_OK); + assert_int_equal(b, 8); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_push_back_multiple_elements(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - int n = 8; - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 1); + int n = 8; + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 1); - n = 9; - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 2); + n = 9; + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 2); - n = 10; - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 3); + n = 10; + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 3); - n = 11; - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 4); + n = 11; + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 4); - n = 12; - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 5); + n = 12; + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 5); - int b; - assert_uint_equal(arraylist_get(arr, 0, &b), ARRLIST_OK); - assert_int_equal(b, 8); + int b; + assert_uint_equal(arraylist_get(arr, 0, &b), ARRLIST_OK); + assert_int_equal(b, 8); - assert_uint_equal(arraylist_get(arr, 1, &b), ARRLIST_OK); - assert_int_equal(b, 9); + assert_uint_equal(arraylist_get(arr, 1, &b), ARRLIST_OK); + assert_int_equal(b, 9); - assert_uint_equal(arraylist_get(arr, 2, &b), ARRLIST_OK); - assert_int_equal(b, 10); - - assert_uint_equal(arraylist_get(arr, 3, &b), ARRLIST_OK); - assert_int_equal(b, 11); + assert_uint_equal(arraylist_get(arr, 2, &b), ARRLIST_OK); + assert_int_equal(b, 10); - assert_uint_equal(arraylist_get(arr, 4, &b), ARRLIST_OK); - assert_int_equal(b, 12); + assert_uint_equal(arraylist_get(arr, 3, &b), ARRLIST_OK); + assert_int_equal(b, 11); - arraylist_destroy(&arr); + 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; + (void)state; - ArrayList *arr = NULL; + ArrayList *arr = NULL; - int n = 8; - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_NULL_ARG); + int n = 8; + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_NULL_ARG); } static void test_push_back_null_data(void **state) { - (void) state; + (void)state; - ArrayList *arr; - arraylist_init(&arr, 64, sizeof(int)); + ArrayList *arr; + arraylist_init(&arr, 64, sizeof(int)); - assert_uint_equal(arraylist_push_back(arr, NULL), ARRLIST_NULL_ARG); + assert_uint_equal(arraylist_push_back(arr, NULL), ARRLIST_NULL_ARG); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_push_back_while_borrowed(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - int n = 8; - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_IS_BORROWED); + int n = 8; + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_IS_BORROWED); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } // Push front static void test_push_front_single_element(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - int n = 8; - int m; - assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 1); - assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK); - assert_uint_equal(m, 8); + int n = 8; + int m; + assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 1); + assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK); + assert_uint_equal(m, 8); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_push_front_multiple_elements(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - int n = 8; - int m; + int n = 8; + int m; - for (size_t i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), i + 1); - assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK); - assert_uint_equal(m, n); - n++; - } + for (size_t i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), i + 1); + assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK); + assert_uint_equal(m, n); + n++; + } - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_push_front_null_array(void **state) { - (void) state; + (void)state; - ArrayList *arr = NULL; + ArrayList *arr = NULL; - int n = 8; - assert_int_equal(arraylist_push_front(arr, &n), ARRLIST_NULL_ARG); + int n = 8; + assert_int_equal(arraylist_push_front(arr, &n), ARRLIST_NULL_ARG); } static void test_push_front_null_data(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - assert_int_equal(arraylist_push_front(arr, NULL), ARRLIST_NULL_ARG); + assert_int_equal(arraylist_push_front(arr, NULL), ARRLIST_NULL_ARG); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_push_front_while_borrowed(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice,arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - int n = 8; - assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_IS_BORROWED); + int n = 8; + assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_IS_BORROWED); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } // Insert static void test_insert_at_beginning(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int n = 8; - int m; - assert_uint_equal(arraylist_size(arr), 10); - assert_uint_equal(arraylist_insert(arr, 0, &n), ARRLIST_OK); - assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 11); - assert_uint_equal(n, m); + int n = 8; + int m; + assert_uint_equal(arraylist_size(arr), 10); + assert_uint_equal(arraylist_insert(arr, 0, &n), ARRLIST_OK); + assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 11); + assert_uint_equal(n, m); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_insert_at_middle(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int n = 8; - int m; - assert_uint_equal(arraylist_size(arr), 10); - assert_uint_equal(arraylist_insert(arr, 5, &n), ARRLIST_OK); - assert_uint_equal(arraylist_get(arr, 5, &m), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 11); - assert_uint_equal(n, m); + int n = 8; + int m; + assert_uint_equal(arraylist_size(arr), 10); + assert_uint_equal(arraylist_insert(arr, 5, &n), ARRLIST_OK); + assert_uint_equal(arraylist_get(arr, 5, &m), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 11); + assert_uint_equal(n, m); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_insert_at_end(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int n = 8; - int m; - assert_uint_equal(arraylist_size(arr), 10); - assert_uint_equal(arraylist_insert(arr, 10, &n), ARRLIST_OK); - assert_uint_equal(arraylist_get(arr, 10, &m), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 11); - assert_uint_equal(n, m); + int n = 8; + int m; + assert_uint_equal(arraylist_size(arr), 10); + assert_uint_equal(arraylist_insert(arr, 10, &n), ARRLIST_OK); + assert_uint_equal(arraylist_get(arr, 10, &m), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 11); + assert_uint_equal(n, m); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_insert_at_invalid_index(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + int n = 8; + assert_uint_equal(arraylist_insert(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS); - int n = 8; - assert_uint_equal(arraylist_insert(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS); - - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_insert_null_array(void **state) { - (void) state; + (void)state; - ArrayList *arr = NULL; + ArrayList *arr = NULL; - int n = 8; - assert_uint_equal(arraylist_insert(arr, 0, &n), ARRLIST_NULL_ARG); + int n = 8; + assert_uint_equal(arraylist_insert(arr, 0, &n), ARRLIST_NULL_ARG); } static void test_insert_null_data(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_uint_equal(arraylist_insert(arr, 0, NULL), ARRLIST_NULL_ARG); - assert_uint_equal(arraylist_insert(arr, 0, NULL), ARRLIST_NULL_ARG); - - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_insert_while_borrowed(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - int n = 8; - assert_uint_equal(arraylist_insert(arr, 2, &n), ARRLIST_IS_BORROWED); + int n = 8; + assert_uint_equal(arraylist_insert(arr, 2, &n), ARRLIST_IS_BORROWED); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } // Pop back static void test_pop_back_single_element(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int m; - assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_OK); - assert_uint_equal(m, 9); + int m; + assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_OK); + assert_uint_equal(m, 9); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_pop_back_multiple_elements(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int m; - for (int i = 9; i >= 5; i--) { - assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), i); - assert_uint_equal(m, i); - } + int m; + for (int i = 9; i >= 5; i--) { + assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), i); + assert_uint_equal(m, i); + } - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_pop_back_until_empty(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int m; - for (int i = 9; i >= 0; i--) { - assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), i); - assert_uint_equal(m, i); - } + int m; + for (int i = 9; i >= 0; i--) { + assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), i); + assert_uint_equal(m, i); + } - assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_EMPTY); + assert_uint_equal(arraylist_pop_back(arr, &m), ARRLIST_EMPTY); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_pop_back_empty_array(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - int n; - assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_EMPTY); + int n; + assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_EMPTY); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_pop_back_null_array(void **state) { - (void) state; + (void)state; - ArrayList *arr = NULL; + ArrayList *arr = NULL; - int n; - assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_NULL_ARG); + int n; + assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_NULL_ARG); } static void test_pop_back_null_out(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - int n = 8; - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); + int n = 8; + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_pop_back(arr, NULL), ARRLIST_OK); + assert_uint_equal(arraylist_pop_back(arr, NULL), ARRLIST_OK); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_pop_back_while_borrowed(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - int n = 8; - assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_IS_BORROWED); + int n = 8; + assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_IS_BORROWED); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } // Pop front static void test_pop_front_single_element(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int m; - assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_OK); - assert_uint_equal(m, 0); + int m; + assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_OK); + assert_uint_equal(m, 0); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_pop_front_multiple_elements(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int m; - size_t size = arraylist_size(arr); - for (int i = 0; i < 6; i++) { - assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), size - (i + 1)); - assert_uint_equal(m, i); - } + int m; + size_t size = arraylist_size(arr); + for (int i = 0; i < 6; i++) { + assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), size - (i + 1)); + assert_uint_equal(m, i); + } - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_pop_front_until_empty(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int m; - size_t size = arraylist_size(arr); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), size - (i + 1)); - assert_uint_equal(m, i); - } + int m; + size_t size = arraylist_size(arr); + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), size - (i + 1)); + assert_uint_equal(m, i); + } - assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_EMPTY); + assert_uint_equal(arraylist_pop_front(arr, &m), ARRLIST_EMPTY); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_pop_front_empty_array(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - int n; - assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_EMPTY); + int n; + assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_EMPTY); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_pop_front_null_array(void **state) { - (void) state; + (void)state; - ArrayList *arr = NULL; + ArrayList *arr = NULL; - int n; - assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_NULL_ARG); + int n; + assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_NULL_ARG); } static void test_pop_front_null_out(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - int n = 8; - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); + int n = 8; + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_pop_front(arr, NULL), ARRLIST_OK); + assert_uint_equal(arraylist_pop_front(arr, NULL), ARRLIST_OK); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_pop_front_while_borrowed(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); - assert_non_null(slice); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); + assert_non_null(slice); - int n = 8; - assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_IS_BORROWED); + int n = 8; + assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_IS_BORROWED); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } // Remove at static void test_remove_at_beginning(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int m; - assert_uint_equal(arraylist_size(arr), 10); - assert_uint_equal(arraylist_remove_at(arr, 0, &m), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 9); - assert_uint_equal(m, 0); + int m; + assert_uint_equal(arraylist_size(arr), 10); + assert_uint_equal(arraylist_remove_at(arr, 0, &m), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 9); + assert_uint_equal(m, 0); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_remove_at_middle(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int m; - assert_uint_equal(arraylist_size(arr), 10); - assert_uint_equal(arraylist_remove_at(arr, 5, &m), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 9); - assert_uint_equal(m, 5); + int m; + assert_uint_equal(arraylist_size(arr), 10); + assert_uint_equal(arraylist_remove_at(arr, 5, &m), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 9); + assert_uint_equal(m, 5); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_remove_at_end(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int m; - assert_uint_equal(arraylist_size(arr), 10); - assert_uint_equal(arraylist_remove_at(arr, 9, &m), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 9); - assert_uint_equal(m, 9); + int m; + assert_uint_equal(arraylist_size(arr), 10); + assert_uint_equal(arraylist_remove_at(arr, 9, &m), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 9); + assert_uint_equal(m, 9); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_remove_at_invalid_index(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + int n = 8; + assert_uint_equal(arraylist_remove_at(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS); - int n = 8; - assert_uint_equal(arraylist_remove_at(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS); - - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_remove_at_null_array(void **state) { - (void) state; + (void)state; - ArrayList *arr = NULL; + ArrayList *arr = NULL; - int n = 8; - assert_uint_equal(arraylist_remove_at(arr, 0, &n), ARRLIST_NULL_ARG); + int n = 8; + assert_uint_equal(arraylist_remove_at(arr, 0, &n), ARRLIST_NULL_ARG); } static void test_remove_at_null_data(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - int n = 8; - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); + int n = 8; + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_uint_equal(arraylist_remove_at(arr, 0, NULL), ARRLIST_OK); + assert_uint_equal(arraylist_remove_at(arr, 0, NULL), ARRLIST_OK); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_remove_at_while_borrowed(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - int n = 8; - assert_uint_equal(arraylist_remove_at(arr, 5, &n), ARRLIST_IS_BORROWED); + int n = 8; + assert_uint_equal(arraylist_remove_at(arr, 5, &n), ARRLIST_IS_BORROWED); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } // Get static void test_get_valid_index(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int m; - assert_uint_equal(arraylist_get(arr, 6, &m), ARRLIST_OK); - assert_uint_equal(m, 6); + int m; + assert_uint_equal(arraylist_get(arr, 6, &m), ARRLIST_OK); + assert_uint_equal(m, 6); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_get_first_element(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int m; - assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK); - assert_uint_equal(m, 0); + int m; + assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK); + assert_uint_equal(m, 0); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_get_last_element(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int m; - assert_uint_equal(arraylist_get(arr, 9, &m), ARRLIST_OK); - assert_uint_equal(m, 9); + int m; + assert_uint_equal(arraylist_get(arr, 9, &m), ARRLIST_OK); + assert_uint_equal(m, 9); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_get_invalid_index(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int m; - assert_uint_equal(arraylist_get(arr, 80, &m), ARRLIST_OUT_OF_BOUNDS); + int m; + assert_uint_equal(arraylist_get(arr, 80, &m), ARRLIST_OUT_OF_BOUNDS); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_get_null_array(void **state) { - (void) state; + (void)state; - ArrayList *arr = NULL; + ArrayList *arr = NULL; - - int m; - assert_uint_equal(arraylist_get(arr, 80, &m), ARRLIST_NULL_ARG); + int m; + assert_uint_equal(arraylist_get(arr, 80, &m), ARRLIST_NULL_ARG); } static void test_get_null_out(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - assert_uint_equal(arraylist_get(arr, 8, NULL), ARRLIST_NULL_ARG); + assert_uint_equal(arraylist_get(arr, 8, NULL), ARRLIST_NULL_ARG); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_get_while_borrowed(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - int n = 8; - assert_uint_equal(arraylist_get(arr, 5, &n), ARRLIST_OK); + int n = 8; + assert_uint_equal(arraylist_get(arr, 5, &n), ARRLIST_OK); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } // Set static void test_set_valid_index(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int n = 8; - int m; - assert_uint_equal(arraylist_set(arr, 6, &n), ARRLIST_OK); - assert_uint_equal(arraylist_get(arr, 6, &m), ARRLIST_OK); - assert_uint_equal(m, n); + int n = 8; + int m; + assert_uint_equal(arraylist_set(arr, 6, &n), ARRLIST_OK); + assert_uint_equal(arraylist_get(arr, 6, &m), ARRLIST_OK); + assert_uint_equal(m, n); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_set_first_element(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int n = 8; - int m; - assert_uint_equal(arraylist_set(arr, 0, &n), ARRLIST_OK); - assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK); - assert_uint_equal(m, n); + int n = 8; + int m; + assert_uint_equal(arraylist_set(arr, 0, &n), ARRLIST_OK); + assert_uint_equal(arraylist_get(arr, 0, &m), ARRLIST_OK); + assert_uint_equal(m, n); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_set_last_element(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int n = 8; - int m; - assert_uint_equal(arraylist_set(arr, 9, &n), ARRLIST_OK); - assert_uint_equal(arraylist_get(arr, 9, &m), ARRLIST_OK); - assert_uint_equal(m, n); + int n = 8; + int m; + assert_uint_equal(arraylist_set(arr, 9, &n), ARRLIST_OK); + assert_uint_equal(arraylist_get(arr, 9, &m), ARRLIST_OK); + assert_uint_equal(m, n); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_set_invalid_index(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - int n = 8; - assert_uint_equal(arraylist_set(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS); + int n = 8; + assert_uint_equal(arraylist_set(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_set_null_array(void **state) { - (void) state; + (void)state; - ArrayList *arr = NULL; - - int n = 8; - assert_uint_equal(arraylist_set(arr, 80, &n), ARRLIST_NULL_ARG); + 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; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - assert_uint_equal(arraylist_set(arr, 8, NULL), ARRLIST_NULL_ARG); + assert_uint_equal(arraylist_set(arr, 8, NULL), ARRLIST_NULL_ARG); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_set_while_borrowed(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - int n = 8; - assert_uint_equal(arraylist_set(arr, 5, &n), ARRLIST_OK); + int n = 8; + assert_uint_equal(arraylist_set(arr, 5, &n), ARRLIST_OK); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } -//Clear +// Clear static void test_clear_non_empty_array(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (size_t i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (size_t i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - assert_uint_equal(arraylist_clear(arr), ARRLIST_OK); - assert_uint_equal(arraylist_size(arr), 0); - assert_uint_equal(arraylist_capacity(arr), 64); + assert_uint_equal(arraylist_clear(arr), ARRLIST_OK); + assert_uint_equal(arraylist_size(arr), 0); + assert_uint_equal(arraylist_capacity(arr), 64); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_clear_already_empty_array(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - assert_uint_equal(arraylist_clear(arr), ARRLIST_OK); + assert_uint_equal(arraylist_clear(arr), ARRLIST_OK); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_clear_null_array(void **state) { - (void) state; + (void)state; - ArrayList *arr = NULL; + ArrayList *arr = NULL; - assert_uint_equal(arraylist_clear(arr), ARRLIST_NULL_ARG); + assert_uint_equal(arraylist_clear(arr), ARRLIST_NULL_ARG); } static void test_clear_while_borrowed(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - assert_uint_equal(arraylist_clear(arr), ARRLIST_IS_BORROWED); + assert_uint_equal(arraylist_clear(arr), ARRLIST_IS_BORROWED); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } -//Resize +// Resize static void test_resize_increase_capacity(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_OK); - assert_uint_equal(arraylist_capacity(arr), 128); - - arraylist_destroy(&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; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + 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); + assert_uint_equal(arraylist_resize(arr, 32), ARRLIST_OK); + assert_uint_equal(arraylist_capacity(arr), 32); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_resize_to_zero(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - assert_uint_equal(arraylist_resize(arr, 0), ARRLIST_INVALID_CAPACITY); - assert_uint_equal(arraylist_capacity(arr), 64); + assert_uint_equal(arraylist_resize(arr, 0), ARRLIST_INVALID_CAPACITY); + assert_uint_equal(arraylist_capacity(arr), 64); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_resize_to_size_max(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - assert_uint_equal(arraylist_resize(arr, SIZE_MAX), ARRLIST_ALLOC_OVERFLOW); - assert_uint_equal(arraylist_capacity(arr), 64); + assert_uint_equal(arraylist_resize(arr, SIZE_MAX), ARRLIST_ALLOC_OVERFLOW); + assert_uint_equal(arraylist_capacity(arr), 64); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_resize_null_array(void **state) { - (void) state; + (void)state; - ArrayList *arr = NULL; + ArrayList *arr = NULL; - assert_uint_equal(arraylist_resize(arr, 65), ARRLIST_NULL_ARG); + assert_uint_equal(arraylist_resize(arr, 65), ARRLIST_NULL_ARG); } static void test_resize_while_borrowed(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_IS_BORROWED); + assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_IS_BORROWED); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } // Reserve static void test_reserve_normal_capacity(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - assert_uint_equal(arraylist_reserve(arr, 32), ARRLIST_OK); - assert_uint_equal(arraylist_capacity(arr), 96); + assert_uint_equal(arraylist_reserve(arr, 32), ARRLIST_OK); + assert_uint_equal(arraylist_capacity(arr), 96); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_reserve_size_max(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - assert_uint_equal(arraylist_reserve(arr, SIZE_MAX), ARRLIST_ALLOC_OVERFLOW); - assert_uint_equal(arraylist_capacity(arr), 64); + assert_uint_equal(arraylist_reserve(arr, SIZE_MAX), ARRLIST_ALLOC_OVERFLOW); + assert_uint_equal(arraylist_capacity(arr), 64); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_reserve_size_0(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - assert_uint_equal(arraylist_reserve(arr, 0), ARRLIST_OK); - assert_uint_equal(arraylist_capacity(arr), 64); + assert_uint_equal(arraylist_reserve(arr, 0), ARRLIST_OK); + assert_uint_equal(arraylist_capacity(arr), 64); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_reserve_while_borrowed(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - assert_uint_equal(arraylist_reserve(arr, 128), ARRLIST_IS_BORROWED); + assert_uint_equal(arraylist_reserve(arr, 128), ARRLIST_IS_BORROWED); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } // Slice creation static void test_slice_valid_init(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (size_t i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (size_t i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, 10), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, 10), ARRLIST_OK); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } static void test_slice_invalid_index(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (size_t i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (size_t i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 32, 10), ARRLIST_INVALID_START); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 32, 10), + ARRLIST_INVALID_START); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_slice_invalid_len(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (size_t i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (size_t i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, 300), ARRLIST_INVALID_START); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, 300), + ARRLIST_INVALID_START); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_slice_len_zero(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (size_t i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (size_t i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, 0), ARRLIST_INVALID_START); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, 0), ARRLIST_INVALID_START); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_slice_empty_array(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, 10), ARRLIST_INVALID_ARR); - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, 10), ARRLIST_INVALID_ARR); - - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_slice_null_arr(void **state) { - (void) state; + (void)state; - ArrayList *arr = NULL; + ArrayList *arr = NULL; - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, 10), ARRLIST_NULL_ARG); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, 10), ARRLIST_NULL_ARG); } // Slice Unsafe static void test_slice_unsafe_valid_init(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (size_t i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (size_t i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 10), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 10), ARRLIST_OK); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } static void test_slice_unsafe_invalid_index(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (size_t i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (size_t i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 32, 10), ARRLIST_INVALID_START); + ArraySlice *slice; + assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 32, 10), + ARRLIST_INVALID_START); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_slice_unsafe_invalid_len(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (size_t i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (size_t i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 300), ARRLIST_INVALID_START); + ArraySlice *slice; + assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 300), + ARRLIST_INVALID_START); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_slice_unsafe_len_zero(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (size_t i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (size_t i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 0), ARRLIST_INVALID_START); + ArraySlice *slice; + assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 0), + ARRLIST_INVALID_START); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_slice_unsafe_empty_array(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 10), + ARRLIST_INVALID_ARR); - ArraySlice *slice; - assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 10), ARRLIST_INVALID_ARR); - - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_slice_unsafe_null_arr(void **state) { - (void) state; + (void)state; - ArrayList *arr = NULL; + ArrayList *arr = NULL; - ArraySlice *slice; - assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 10), ARRLIST_NULL_ARG); + ArraySlice *slice; + assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 10), + ARRLIST_NULL_ARG); } // Slice Destroy static void test_slice_destroy_valid(void **state) { - (void) state; + (void)state; - ArrayList *arr; -assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_OK); - arraylist_destroy(&arr); + assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_OK); + arraylist_destroy(&arr); } static void test_slice_destroy_null_slice(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice = NULL; + ArraySlice *slice = NULL; - assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_NULL_ARG); - arraylist_destroy(&arr); + assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_NULL_ARG); + arraylist_destroy(&arr); } static void test_slice_double_destroy(void **state) { - (void) state; + (void)state; - ArrayList *arr; -assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_OK); - assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_NULL_ARG); - arraylist_destroy(&arr); + assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_OK); + assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_NULL_ARG); + arraylist_destroy(&arr); } // Slice peek static void test_slice_peek_valid_array(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - int m; - assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_OK); - assert_int_equal(m, 0); + int m; + assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_OK); + assert_int_equal(m, 0); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } static void test_slice_peek_invalid_array(void **state) { - (void) state; + (void)state; - ArrayList *arr; -assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK); + assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK); - int m; - assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_INVALID_SLICE); - assert_int_equal(m, 0); + int m; + assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_INVALID_SLICE); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } static void test_slice_peek_null_out(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - assert_uint_equal(arrayslice_peek(slice, NULL), ARRLIST_NULL_ARG); + assert_uint_equal(arrayslice_peek(slice, NULL), ARRLIST_NULL_ARG); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } static void test_slice_peek_null_slice(void **state) { - (void) state; + (void)state; - ArraySlice *slice = NULL; + ArraySlice *slice = NULL; - int m; - assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_NULL_ARG); - assert_int_equal(m, 0); + int m; + assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_NULL_ARG); } // Slice next static void test_slice_next_valid_array(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - int m; - assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK); - assert_int_equal(m, 0); + int m; + assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK); + assert_int_equal(m, 0); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } static void test_slice_next_invalid_array(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK); + assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK); - int m; - assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_INVALID_SLICE); - assert_int_equal(m, 0); + int m; + assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_INVALID_SLICE); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } static void test_slice_next_null_out(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - assert_uint_equal(arrayslice_next(slice, NULL), ARRLIST_OK); + assert_uint_equal(arrayslice_next(slice, NULL), ARRLIST_OK); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } static void test_slice_next_null_slice(void **state) { - (void) state; + (void)state; - ArraySlice *slice = NULL; + ArraySlice *slice = NULL; - int m; - assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_NULL_ARG); - assert_int_equal(m, 0); + int m; + assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_NULL_ARG); } static void test_slice_next_until_invalid(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - int m; - for (int i = 0; i < 10; i++) { - assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK); - assert_uint_equal(m, i); - } - assert_false(arrayslice_is_valid(slice)); + int m; + for (int i = 0; i < 10; i++) { + assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK); + assert_uint_equal(m, i); + } + assert_false(arrayslice_is_valid(slice)); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } -//Slice reset +// Slice reset static void test_slice_reset_valid_slice(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - int m; - for (int i = 0; i < 10; i++) { - assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK); - assert_uint_equal(m, i); - } + int m; + for (int i = 0; i < 10; i++) { + assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK); + assert_uint_equal(m, i); + } - assert_uint_equal(arrayslice_reset(slice), ARRLIST_OK); + assert_uint_equal(arrayslice_reset(slice), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK); - assert_uint_equal(m, i); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK); + assert_uint_equal(m, i); + } - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } static void test_slice_reset_null_slice(void **state) { - (void) state; + (void)state; - ArraySlice *slice = NULL; + ArraySlice *slice = NULL; - assert_uint_equal(arrayslice_reset(slice), ARRLIST_NULL_ARG); + assert_uint_equal(arrayslice_reset(slice), ARRLIST_NULL_ARG); } -//Slice advance -//out ou bounds -//null +// Slice advance +// out ou bounds +// null static void test_slice_advance_valid_slice(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - int m; - for (int i = 0; i < 5; i++) { - assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK); - assert_uint_equal(m, i); - } + int m; + for (int i = 0; i < 5; i++) { + assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK); + assert_uint_equal(m, i); + } - assert_uint_equal(arrayslice_advance(slice, 5), ARRLIST_OK); + assert_uint_equal(arrayslice_advance(slice, 5), ARRLIST_OK); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } static void test_slice_advance_out_of_bounds(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - int m; - for (int i = 0; i < 5; i++) { - assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK); - assert_uint_equal(m, i); - } + int m; + for (int i = 0; i < 5; i++) { + assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK); + assert_uint_equal(m, i); + } - assert_uint_equal(arrayslice_advance(slice, 40), ARRLIST_OUT_OF_BOUNDS); + assert_uint_equal(arrayslice_advance(slice, 40), ARRLIST_OUT_OF_BOUNDS); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } static void test_slice_advance_size_max(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - int m; - for (int i = 0; i < 5; i++) { - assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK); - assert_uint_equal(m, i); - } + int m; + for (int i = 0; i < 5; i++) { + assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK); + assert_uint_equal(m, i); + } - assert_uint_equal(arrayslice_advance(slice, SIZE_MAX), ARRLIST_OUT_OF_BOUNDS); + assert_uint_equal(arrayslice_advance(slice, SIZE_MAX), ARRLIST_OUT_OF_BOUNDS); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } static void test_slice_advance_null_array(void **state) { - (void) state; + (void)state; - ArraySlice *slice = NULL; + ArraySlice *slice = NULL; - assert_uint_equal(arrayslice_advance(slice, 56), ARRLIST_NULL_ARG); + assert_uint_equal(arrayslice_advance(slice, 56), ARRLIST_NULL_ARG); } -//Slice to Array +// Slice to Array static void test_slice_to_array_valid(void **state) { - (void) state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - for (int i = 0; i < 10; i++) { - assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); - } + for (int i = 0; i < 10; i++) { + assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); + } - ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK); + ArraySlice *slice; + assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + ARRLIST_OK); - ArrayList *arr2; - assert_uint_equal(arrayslice_to_arraylist(&arr2, slice), ARRLIST_OK); - assert_uint_equal(arraylist_capacity(arr2), 64); - assert_uint_equal(arraylist_size(arr2), 10); + ArrayList *arr2; + assert_uint_equal(arrayslice_to_arraylist(&arr2, slice), ARRLIST_OK); + assert_uint_equal(arraylist_capacity(arr2), 64); + assert_uint_equal(arraylist_size(arr2), 10); - arraylist_destroy(&arr2); - arrayslice_destroy(&slice); - arraylist_destroy(&arr); + arraylist_destroy(&arr2); + arrayslice_destroy(&slice); + arraylist_destroy(&arr); } static void test_slice_to_array_null_slice(void **state) { - (void) state; + (void)state; - ArraySlice *slice = NULL; - ArrayList *arr = NULL; + ArraySlice *slice = NULL; + ArrayList *arr = NULL; - assert_uint_equal(arrayslice_to_arraylist(&arr, slice), ARRLIST_NULL_ARG); + assert_uint_equal(arrayslice_to_arraylist(&arr, slice), ARRLIST_NULL_ARG); } int main(void) { - const struct CMUnitTest init[] = { - cmocka_unit_test(test_init_valid_parameters), - cmocka_unit_test(test_init_zero_capacity), - cmocka_unit_test(test_init_zero_elem_size), - cmocka_unit_test(test_init_large_capacity), - }; + const struct CMUnitTest init[] = { + cmocka_unit_test(test_init_valid_parameters), + cmocka_unit_test(test_init_zero_capacity), + cmocka_unit_test(test_init_zero_elem_size), + cmocka_unit_test(test_init_large_capacity), + }; - const struct CMUnitTest destroy[] = { - cmocka_unit_test(test_destroy_valid_array), - cmocka_unit_test(test_destroy_null_array), - cmocka_unit_test(test_destroy_double), - cmocka_unit_test(test_destroy_while_borrowed), - }; + const struct CMUnitTest destroy[] = { + cmocka_unit_test(test_destroy_valid_array), + cmocka_unit_test(test_destroy_null_array), + cmocka_unit_test(test_destroy_double), + cmocka_unit_test(test_destroy_while_borrowed), + }; - const struct CMUnitTest state[] = { - cmocka_unit_test(test_capacity_after_init), - cmocka_unit_test(test_is_empty_after_init), - cmocka_unit_test(test_is_empty_after_push), - cmocka_unit_test(test_size_after_many_push), - cmocka_unit_test(test_capacity_growth_on_push), - cmocka_unit_test(test_capacity_shrink_on_pop), - }; + const struct CMUnitTest state[] = { + cmocka_unit_test(test_capacity_after_init), + cmocka_unit_test(test_is_empty_after_init), + cmocka_unit_test(test_is_empty_after_push), + cmocka_unit_test(test_size_after_many_push), + cmocka_unit_test(test_capacity_growth_on_push), + cmocka_unit_test(test_capacity_shrink_on_pop), + }; - const struct CMUnitTest push_back[] = { - cmocka_unit_test(test_push_back_single_element), - cmocka_unit_test(test_push_back_multiple_elements), - cmocka_unit_test(test_push_back_null_array), - cmocka_unit_test(test_push_back_null_data), - cmocka_unit_test(test_push_back_while_borrowed), - }; + const struct CMUnitTest push_back[] = { + cmocka_unit_test(test_push_back_single_element), + cmocka_unit_test(test_push_back_multiple_elements), + cmocka_unit_test(test_push_back_null_array), + cmocka_unit_test(test_push_back_null_data), + cmocka_unit_test(test_push_back_while_borrowed), + }; - const struct CMUnitTest push_front[] = { - cmocka_unit_test(test_push_front_single_element), - cmocka_unit_test(test_push_front_multiple_elements), - cmocka_unit_test(test_push_front_null_array), - cmocka_unit_test(test_push_front_null_data), - cmocka_unit_test(test_push_front_while_borrowed), - }; + const struct CMUnitTest push_front[] = { + cmocka_unit_test(test_push_front_single_element), + cmocka_unit_test(test_push_front_multiple_elements), + cmocka_unit_test(test_push_front_null_array), + cmocka_unit_test(test_push_front_null_data), + cmocka_unit_test(test_push_front_while_borrowed), + }; - const struct CMUnitTest insert[] = { - cmocka_unit_test(test_insert_at_beginning), - cmocka_unit_test(test_insert_at_middle), - cmocka_unit_test(test_insert_at_end), - cmocka_unit_test(test_insert_at_invalid_index), - cmocka_unit_test(test_insert_null_array), - cmocka_unit_test(test_insert_null_data), - cmocka_unit_test(test_insert_while_borrowed), - }; + const struct CMUnitTest insert[] = { + cmocka_unit_test(test_insert_at_beginning), + cmocka_unit_test(test_insert_at_middle), + cmocka_unit_test(test_insert_at_end), + cmocka_unit_test(test_insert_at_invalid_index), + cmocka_unit_test(test_insert_null_array), + cmocka_unit_test(test_insert_null_data), + cmocka_unit_test(test_insert_while_borrowed), + }; - const struct CMUnitTest pop_back[] = { - cmocka_unit_test(test_pop_back_single_element), - cmocka_unit_test(test_pop_back_multiple_elements), - cmocka_unit_test(test_pop_back_until_empty), - cmocka_unit_test(test_pop_back_empty_array), - cmocka_unit_test(test_pop_back_null_array), - cmocka_unit_test(test_pop_back_null_out), - cmocka_unit_test(test_pop_back_while_borrowed), - }; + const struct CMUnitTest pop_back[] = { + cmocka_unit_test(test_pop_back_single_element), + cmocka_unit_test(test_pop_back_multiple_elements), + cmocka_unit_test(test_pop_back_until_empty), + cmocka_unit_test(test_pop_back_empty_array), + cmocka_unit_test(test_pop_back_null_array), + cmocka_unit_test(test_pop_back_null_out), + cmocka_unit_test(test_pop_back_while_borrowed), + }; - const struct CMUnitTest pop_front[] = { - cmocka_unit_test(test_pop_front_single_element), - cmocka_unit_test(test_pop_front_multiple_elements), - cmocka_unit_test(test_pop_front_until_empty), - cmocka_unit_test(test_pop_front_empty_array), - cmocka_unit_test(test_pop_front_null_array), - cmocka_unit_test(test_pop_front_null_out), - cmocka_unit_test(test_pop_front_while_borrowed), - }; + const struct CMUnitTest pop_front[] = { + cmocka_unit_test(test_pop_front_single_element), + cmocka_unit_test(test_pop_front_multiple_elements), + cmocka_unit_test(test_pop_front_until_empty), + cmocka_unit_test(test_pop_front_empty_array), + cmocka_unit_test(test_pop_front_null_array), + cmocka_unit_test(test_pop_front_null_out), + cmocka_unit_test(test_pop_front_while_borrowed), + }; - const struct CMUnitTest remove_at[] = { - cmocka_unit_test(test_remove_at_beginning), - cmocka_unit_test(test_remove_at_middle), - cmocka_unit_test(test_remove_at_end), - cmocka_unit_test(test_remove_at_invalid_index), - cmocka_unit_test(test_remove_at_null_array), - cmocka_unit_test(test_remove_at_null_data), - cmocka_unit_test(test_remove_at_while_borrowed), - }; + const struct CMUnitTest remove_at[] = { + cmocka_unit_test(test_remove_at_beginning), + cmocka_unit_test(test_remove_at_middle), + cmocka_unit_test(test_remove_at_end), + cmocka_unit_test(test_remove_at_invalid_index), + cmocka_unit_test(test_remove_at_null_array), + cmocka_unit_test(test_remove_at_null_data), + cmocka_unit_test(test_remove_at_while_borrowed), + }; - const struct CMUnitTest get[] = { - cmocka_unit_test(test_get_valid_index), - cmocka_unit_test(test_get_first_element), - cmocka_unit_test(test_get_last_element), - cmocka_unit_test(test_get_invalid_index), - cmocka_unit_test(test_get_null_array), - cmocka_unit_test(test_get_null_out), - cmocka_unit_test(test_get_while_borrowed), - }; + const struct CMUnitTest get[] = { + cmocka_unit_test(test_get_valid_index), + cmocka_unit_test(test_get_first_element), + cmocka_unit_test(test_get_last_element), + cmocka_unit_test(test_get_invalid_index), + cmocka_unit_test(test_get_null_array), + cmocka_unit_test(test_get_null_out), + cmocka_unit_test(test_get_while_borrowed), + }; - const struct CMUnitTest set[] = { - cmocka_unit_test(test_set_valid_index), - cmocka_unit_test(test_set_first_element), - cmocka_unit_test(test_set_last_element), - cmocka_unit_test(test_set_invalid_index), - cmocka_unit_test(test_set_null_array), - cmocka_unit_test(test_set_null_data), - cmocka_unit_test(test_set_while_borrowed), - }; + const struct CMUnitTest set[] = { + cmocka_unit_test(test_set_valid_index), + cmocka_unit_test(test_set_first_element), + cmocka_unit_test(test_set_last_element), + cmocka_unit_test(test_set_invalid_index), + cmocka_unit_test(test_set_null_array), + cmocka_unit_test(test_set_null_data), + cmocka_unit_test(test_set_while_borrowed), + }; - const struct CMUnitTest clear[] = { - cmocka_unit_test(test_clear_non_empty_array), - cmocka_unit_test(test_clear_already_empty_array), - cmocka_unit_test(test_clear_null_array), - cmocka_unit_test(test_clear_while_borrowed), - }; + const struct CMUnitTest clear[] = { + cmocka_unit_test(test_clear_non_empty_array), + cmocka_unit_test(test_clear_already_empty_array), + cmocka_unit_test(test_clear_null_array), + cmocka_unit_test(test_clear_while_borrowed), + }; - const struct CMUnitTest resize[] = { - cmocka_unit_test(test_resize_increase_capacity), - cmocka_unit_test(test_resize_decrease_capacity), - cmocka_unit_test(test_resize_to_zero), - cmocka_unit_test(test_resize_to_size_max), - cmocka_unit_test(test_resize_null_array), - cmocka_unit_test(test_resize_while_borrowed), - }; + const struct CMUnitTest resize[] = { + cmocka_unit_test(test_resize_increase_capacity), + cmocka_unit_test(test_resize_decrease_capacity), + cmocka_unit_test(test_resize_to_zero), + cmocka_unit_test(test_resize_to_size_max), + cmocka_unit_test(test_resize_null_array), + cmocka_unit_test(test_resize_while_borrowed), + }; - const struct CMUnitTest reserve[] = { - cmocka_unit_test(test_reserve_normal_capacity), - cmocka_unit_test(test_reserve_size_0), - cmocka_unit_test(test_reserve_size_max), - cmocka_unit_test(test_reserve_while_borrowed), - }; + const struct CMUnitTest reserve[] = { + cmocka_unit_test(test_reserve_normal_capacity), + cmocka_unit_test(test_reserve_size_0), + cmocka_unit_test(test_reserve_size_max), + cmocka_unit_test(test_reserve_while_borrowed), + }; - const struct CMUnitTest slice_array[] = { - cmocka_unit_test(test_slice_valid_init), - cmocka_unit_test(test_slice_invalid_index), - cmocka_unit_test(test_slice_invalid_len), - cmocka_unit_test(test_slice_len_zero), - cmocka_unit_test(test_slice_empty_array), - cmocka_unit_test(test_slice_null_arr), - }; + const struct CMUnitTest slice_array[] = { + cmocka_unit_test(test_slice_valid_init), + cmocka_unit_test(test_slice_invalid_index), + cmocka_unit_test(test_slice_invalid_len), + cmocka_unit_test(test_slice_len_zero), + cmocka_unit_test(test_slice_empty_array), + cmocka_unit_test(test_slice_null_arr), + }; - const struct CMUnitTest slice_array_unsafe[] = { - cmocka_unit_test(test_slice_unsafe_valid_init), - cmocka_unit_test(test_slice_unsafe_invalid_index), - cmocka_unit_test(test_slice_unsafe_invalid_len), - cmocka_unit_test(test_slice_unsafe_len_zero), - cmocka_unit_test(test_slice_unsafe_empty_array), - cmocka_unit_test(test_slice_unsafe_null_arr), - }; + const struct CMUnitTest slice_array_unsafe[] = { + cmocka_unit_test(test_slice_unsafe_valid_init), + cmocka_unit_test(test_slice_unsafe_invalid_index), + cmocka_unit_test(test_slice_unsafe_invalid_len), + cmocka_unit_test(test_slice_unsafe_len_zero), + cmocka_unit_test(test_slice_unsafe_empty_array), + cmocka_unit_test(test_slice_unsafe_null_arr), + }; - const struct CMUnitTest slice_destroy[] = { - cmocka_unit_test(test_slice_destroy_valid), - cmocka_unit_test(test_slice_destroy_null_slice), - cmocka_unit_test(test_slice_double_destroy), - }; + const struct CMUnitTest slice_destroy[] = { + cmocka_unit_test(test_slice_destroy_valid), + cmocka_unit_test(test_slice_destroy_null_slice), + cmocka_unit_test(test_slice_double_destroy), + }; - const struct CMUnitTest slice_peek[] = { - cmocka_unit_test(test_slice_peek_valid_array), - cmocka_unit_test(test_slice_peek_invalid_array), - cmocka_unit_test(test_slice_peek_null_slice), - cmocka_unit_test(test_slice_peek_null_out), - }; + const struct CMUnitTest slice_peek[] = { + cmocka_unit_test(test_slice_peek_valid_array), + cmocka_unit_test(test_slice_peek_invalid_array), + cmocka_unit_test(test_slice_peek_null_slice), + cmocka_unit_test(test_slice_peek_null_out), + }; - const struct CMUnitTest slice_next[] = { - cmocka_unit_test(test_slice_next_valid_array), - cmocka_unit_test(test_slice_next_invalid_array), - cmocka_unit_test(test_slice_next_null_slice), - cmocka_unit_test(test_slice_next_null_out), - cmocka_unit_test(test_slice_next_until_invalid), - }; - - const struct CMUnitTest slice_reset[] = { - cmocka_unit_test(test_slice_reset_valid_slice), - cmocka_unit_test(test_slice_reset_null_slice), - }; + 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_advance[] = { - cmocka_unit_test(test_slice_advance_valid_slice), - cmocka_unit_test(test_slice_advance_out_of_bounds), - cmocka_unit_test(test_slice_advance_null_array), - cmocka_unit_test(test_slice_advance_size_max), - }; + const struct CMUnitTest slice_reset[] = { + cmocka_unit_test(test_slice_reset_valid_slice), + cmocka_unit_test(test_slice_reset_null_slice), + }; - const struct CMUnitTest slice_to_array[] = { - cmocka_unit_test(test_slice_to_array_valid), - cmocka_unit_test(test_slice_to_array_null_slice), - }; + 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; + const struct CMUnitTest slice_to_array[] = { + cmocka_unit_test(test_slice_to_array_valid), + cmocka_unit_test(test_slice_to_array_null_slice), + }; - 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); + int rc = 0; - rc += cmocka_run_group_tests(slice_array, NULL, NULL); - rc += cmocka_run_group_tests(slice_array_unsafe, NULL, NULL); - rc += cmocka_run_group_tests(slice_destroy, NULL, NULL); - rc += cmocka_run_group_tests(slice_peek, NULL, NULL); - rc += cmocka_run_group_tests(slice_next, NULL, NULL); - rc += cmocka_run_group_tests(slice_reset, NULL, NULL); - rc += cmocka_run_group_tests(slice_advance, NULL, NULL); - rc += cmocka_run_group_tests(slice_to_array, NULL, NULL); + rc += cmocka_run_group_tests(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); - return rc; + rc += cmocka_run_group_tests(slice_array, NULL, NULL); + rc += cmocka_run_group_tests(slice_array_unsafe, NULL, NULL); + rc += cmocka_run_group_tests(slice_destroy, NULL, NULL); + rc += cmocka_run_group_tests(slice_peek, NULL, NULL); + rc += cmocka_run_group_tests(slice_next, NULL, NULL); + rc += cmocka_run_group_tests(slice_reset, NULL, NULL); + rc += cmocka_run_group_tests(slice_advance, NULL, NULL); + rc += cmocka_run_group_tests(slice_to_array, NULL, NULL); + + return rc; }