From a057f237986acf6f04d2f4760a8797b007e5e3f7 Mon Sep 17 00:00:00 2001 From: laentropia Date: Wed, 10 Jun 2026 11:18:10 -0600 Subject: [PATCH] refactor: xmake in use, compiles and tests fine --- .gitignore | 6 + CMakeLists.txt | 98 - include/{arraylist.h => lae_arraylist.h} | 20 +- src/{arraylist.c => lae_arraylist.c} | 69 +- test/CMakeLists.txt | 121 -- test/test_arraylist.c | 2489 +++++++++++----------- xmake.lua | 94 + 7 files changed, 1401 insertions(+), 1496 deletions(-) delete mode 100644 CMakeLists.txt rename include/{arraylist.h => lae_arraylist.h} (84%) rename src/{arraylist.c => lae_arraylist.c} (90%) delete mode 100644 test/CMakeLists.txt create mode 100644 xmake.lua diff --git a/.gitignore b/.gitignore index 0bd57ed..d1a83ec 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,12 @@ out/ out/Debug/ out/Release/ +# xmake +xmake/ +xmake/* +.xmake +.xmake/* + # Cmake files CMakeCache.txt CMakeFiles/ diff --git a/CMakeLists.txt b/CMakeLists.txt deleted file mode 100644 index 03891fd..0000000 --- a/CMakeLists.txt +++ /dev/null @@ -1,98 +0,0 @@ -cmake_minimum_required(VERSION 3.20) -project( - arraylist - VERSION 1.0 - LANGUAGES C) - -# ------------------------------------------------ -# Estandard C -# ------------------------------------------------ -set(CMAKE_C_STANDARD 11) -set(CMAKE_C_STANDARD_REQUIRED ON) -set(CMAKE_C_EXTENSIONS OFF) - -# Exportar compile_commands.json (clangd / IDEs) -set(CMAKE_EXPORT_COMPILE_COMMANDS ON) - -# ------------------------------------------------ -# Is Top project? -# ------------------------------------------------ -if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR) - set(ARRAYLIST_IS_TOP_LEVEL ON) -else() - set(ARRAYLIST_IS_TOP_LEVEL OFF) -endif() - -# ------------------------------------------------ -# Opciones -# ------------------------------------------------ -option(ARRAYLIST_BUILD_TESTS "Build tests" ${ARRAYLIST_IS_TOP_LEVEL}) -option(ARRAYLIST_BUILD_EXAMPLE "Build example" ${ARRAYLIST_IS_TOP_LEVEL}) -option(ARRAYLIST_ENABLE_INSTALL "Enable install" ${ARRAYLIST_IS_TOP_LEVEL}) -option(ARRAYLIST_ENABLE_SANITIZERS "Enable Sanitizers for test" ON) - -# ------------------------------------------------ -# Warning Flags (GCC/Clang vs MSVC) -# ------------------------------------------------ -if(MSVC) - set(ARRAYLIST_WARNING_FLAGS /W4) -else() - set(ARRAYLIST_WARNING_FLAGS -Wall -Wextra -Wpedantic) -endif() - -# ------------------------------------------------ -# Main Library -# ------------------------------------------------ -add_library(arraylist src/arraylist.c) - -# Alias con namespace → los consumidores via CPM/FetchContent pueden escribir -# target_link_libraries(mi_app arraylist::arraylist) -add_library(arraylist::arraylist ALIAS arraylist) - -target_include_directories( - arraylist PUBLIC $ - $) - -# Flagas only for compile lib -target_compile_options(arraylist PRIVATE ${ARRAYLIST_WARNING_FLAGS}) - -# Propagates c11 as requirement -target_compile_features(arraylist PUBLIC c_std_11) - -# ------------------------------------------------ -# Example only built when is main proyect -# ------------------------------------------------ -if(ARRAYLIST_BUILD_EXAMPLE) - add_executable(arraylist_example src/main.c) - target_link_libraries(arraylist_example PRIVATE arraylist) -endif() - -# ------------------------------------------------ -# Tests -# ------------------------------------------------ -if(ARRAYLIST_BUILD_TESTS) - enable_testing() - add_subdirectory(test) -endif() - -# ------------------------------------------------ -# Installation rules -# ------------------------------------------------ -if(ARRAYLIST_ENABLE_INSTALL) - include(GNUInstallDirs) - - install( - TARGETS arraylist - EXPORT arraylistTargets - ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} - LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} - RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}) - - install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) - - install( - EXPORT arraylistTargets - FILE arraylistTargets.cmake - NAMESPACE arraylist:: - DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/arraylist) -endif() diff --git a/include/arraylist.h b/include/lae_arraylist.h similarity index 84% rename from include/arraylist.h rename to include/lae_arraylist.h index 78149a6..dee609d 100644 --- a/include/arraylist.h +++ b/include/lae_arraylist.h @@ -1,9 +1,9 @@ -#ifndef ARRAYLIST_H -#define ARRAYLIST_H +#ifndef LAE_ARRAYLIST_H +#define LAE_ARRAYLIST_H #include -#include #include +#include typedef struct ArrayList ArrayList; @@ -35,8 +35,8 @@ size_t arraylist_capacity(const ArrayList *arr); bool arraylist_is_empty(const ArrayList *arr); ArrayListErr arraylist_push_back(ArrayList *arr, void *data); -ArrayListErr arraylist_insert(ArrayList*arr, size_t index, void *data); -ArrayListErr arraylist_push_front(ArrayList* arr, void *data); +ArrayListErr arraylist_insert(ArrayList *arr, size_t index, void *data); +ArrayListErr arraylist_push_front(ArrayList *arr, void *data); // Here out can be null for not having anything writen ArrayListErr arraylist_pop_back(ArrayList *arr, void *out); @@ -49,9 +49,13 @@ ArrayListErr arraylist_set(ArrayList *arr, size_t index, void *data); ArrayListErr arraylist_resize(ArrayList *arr, size_t new_capacity); ArrayListErr arraylist_reserve(ArrayList *arr, size_t size_to_reserve); -//Slice stuff -ArrayListErr arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, size_t len); -ArrayListErr arraylist_slice_unsafe(ArraySlice **slice, ArrayList *arr, size_t start, size_t len); +// Slice stuff +ArrayListErr +arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, size_t len); + +ArrayListErr arraylist_slice_unsafe( + ArraySlice **slice, ArrayList *arr, size_t start, size_t len); + ArrayListErr arrayslice_destroy(ArraySlice **slice); bool arrayslice_is_valid(const ArraySlice *slice); diff --git a/src/arraylist.c b/src/lae_arraylist.c similarity index 90% rename from src/arraylist.c rename to src/lae_arraylist.c index b401d0f..eab4ee5 100644 --- a/src/arraylist.c +++ b/src/lae_arraylist.c @@ -1,10 +1,10 @@ -#include "arraylist.h" +#include "lae_arraylist.h" #include #include #include #include -struct ArrayList{ +struct ArrayList { uint8_t *buffer; size_t capacity; size_t len; @@ -26,11 +26,12 @@ struct ArraySlice { static ArrayListErr arraylist_grow(ArrayList *arr); static ArrayListErr arraylist_shrink(ArrayList *arr); -ArrayListErr arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size) { +ArrayListErr +arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size) { if (arr == NULL) { return ARRLIST_NULL_ARG; } - + *arr = NULL; if (capacity == 0) { @@ -122,7 +123,7 @@ static ArrayListErr arraylist_grow(ArrayList *arr) { size_t new_capacity = arr->capacity * 2; if (new_capacity > SIZE_MAX / arr->elem_size) { - return ARRLIST_ALLOC_OVERFLOW; + return ARRLIST_ALLOC_OVERFLOW; } void *tmp = realloc(arr->buffer, new_capacity * arr->elem_size); @@ -139,10 +140,10 @@ static ArrayListErr arraylist_shrink(ArrayList *arr) { size_t new_capacity = arr->capacity / 2; if (new_capacity > SIZE_MAX / arr->elem_size) { - return ARRLIST_ALLOC_OVERFLOW; + return ARRLIST_ALLOC_OVERFLOW; } - - void *tmp = realloc(arr->buffer, new_capacity *arr->elem_size); + + void *tmp = realloc(arr->buffer, new_capacity * arr->elem_size); if (tmp == NULL) { return ARRLIST_BAD_ALLOC; } @@ -195,13 +196,9 @@ ArrayListErr arraylist_push_front(ArrayList *arr, void *data) { memmove( arr->buffer + arr->elem_size, arr->buffer, - (arr->len) * arr->elem_size - ); + (arr->len) * arr->elem_size); - memcpy( - arr->buffer, - data, - arr->elem_size); + memcpy(arr->buffer, data, arr->elem_size); arr->len++; @@ -233,9 +230,7 @@ ArrayListErr arraylist_insert(ArrayList *arr, size_t index, void *data) { arr->buffer + (index * arr->elem_size), (arr->len - index) * arr->elem_size); - memcpy(arr->buffer + (index * arr->elem_size), - data, - arr->elem_size); + memcpy(arr->buffer + (index * arr->elem_size), data, arr->elem_size); arr->len++; @@ -295,11 +290,7 @@ ArrayListErr arraylist_pop_front(ArrayList *arr, void *out) { } if (out != NULL) { - memcpy( - out, - arr->buffer, - arr->elem_size - ); + memcpy(out, arr->buffer, arr->elem_size); } memmove( @@ -330,11 +321,7 @@ ArrayListErr arraylist_remove_at(ArrayList *arr, size_t index, void *out) { } if (out != NULL) { - memcpy( - out, - arr->buffer + (index * arr->elem_size), - arr->elem_size - ); + memcpy(out, arr->buffer + (index * arr->elem_size), arr->elem_size); } memmove( @@ -356,10 +343,7 @@ ArrayListErr arraylist_get(const ArrayList *arr, size_t index, void *out) { return ARRLIST_OUT_OF_BOUNDS; } - memcpy( - out, - arr->buffer + (index * arr->elem_size), - arr->elem_size); + memcpy(out, arr->buffer + (index * arr->elem_size), arr->elem_size); return ARRLIST_OK; } @@ -373,10 +357,7 @@ ArrayListErr arraylist_set(ArrayList *arr, size_t index, void *data) { return ARRLIST_OUT_OF_BOUNDS; } - memcpy( - arr->buffer + (index * arr->elem_size), - data, - arr->elem_size); + memcpy(arr->buffer + (index * arr->elem_size), data, arr->elem_size); return ARRLIST_OK; } @@ -395,7 +376,7 @@ ArrayListErr arraylist_resize(ArrayList *arr, size_t new_capacity) { } if (new_capacity > SIZE_MAX / arr->elem_size) { - return ARRLIST_ALLOC_OVERFLOW; + return ARRLIST_ALLOC_OVERFLOW; } uint8_t *tmp = realloc(arr->buffer, new_capacity * arr->elem_size); @@ -420,7 +401,7 @@ ArrayListErr arraylist_reserve(ArrayList *arr, size_t size_to_reserve) { if (arr->capacity + size_to_reserve > SIZE_MAX / arr->elem_size || size_to_reserve > SIZE_MAX / arr->elem_size) { - return ARRLIST_ALLOC_OVERFLOW; + return ARRLIST_ALLOC_OVERFLOW; } uint8_t *tmp = realloc( @@ -436,7 +417,8 @@ ArrayListErr arraylist_reserve(ArrayList *arr, size_t size_to_reserve) { return ARRLIST_OK; } -ArrayListErr arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, size_t len) { +ArrayListErr +arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, size_t len) { if (arr == NULL || slice == NULL) { return ARRLIST_NULL_ARG; } @@ -469,7 +451,8 @@ ArrayListErr arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, s return ARRLIST_OK; } -ArrayListErr arraylist_slice_unsafe(ArraySlice **slice, ArrayList *arr, size_t start, size_t len) { +ArrayListErr arraylist_slice_unsafe( + ArraySlice **slice, ArrayList *arr, size_t start, size_t len) { if (arr == NULL || slice == NULL) { return ARRLIST_NULL_ARG; } @@ -581,7 +564,7 @@ ArrayListErr arrayslice_advance(ArraySlice *slice, size_t n) { if (n > SIZE_MAX - slice->current || slice->current + n > slice->end) { return ARRLIST_OUT_OF_BOUNDS; } - + slice->current += n; return ARRLIST_OK; @@ -606,8 +589,7 @@ ArrayListErr arrayslice_to_arraylist(ArrayList **arr, const ArraySlice *slice) { ArrayListErr init_err = arraylist_init( &new_arr, arraylist_capacity(slice->arr), - slice->arr->elem_size - ); + slice->arr->elem_size); if (init_err != ARRLIST_OK) { return init_err; @@ -616,8 +598,7 @@ ArrayListErr arrayslice_to_arraylist(ArrayList **arr, const ArraySlice *slice) { memcpy( new_arr->buffer, slice->arr->buffer + (slice->start * slice->arr->elem_size), - slice->arr->elem_size * len - ); + slice->arr->elem_size * len); new_arr->len = len; diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt deleted file mode 100644 index 99e14c4..0000000 --- a/test/CMakeLists.txt +++ /dev/null @@ -1,121 +0,0 @@ -# --------------------------------------------------------------- -# First search cmocka and automatically download if necessary -# --------------------------------------------------------------- -find_package(cmocka QUIET) - -if(NOT cmocka_FOUND) - message( - STATUS - "[arraylist] cmocka was not fount in the system — downloading with FetchContent..." - ) - - include(FetchContent) - FetchContent_Declare( - cmocka - GIT_REPOSITORY https://git.cryptomilk.org/projects/cmocka.git - GIT_TAG cmocka-1.1.7 - GIT_SHALLOW TRUE) - - set(WITH_STATIC_LIB - ON - CACHE BOOL "" FORCE) - set(WITH_SHARED_LIB - OFF - CACHE BOOL "" FORCE) - set(WITH_CMOCKERY_SUPPORT - OFF - CACHE BOOL "" FORCE) - set(WITH_EXAMPLES - OFF - CACHE BOOL "" FORCE) - set(UNIT_TESTING - OFF - CACHE BOOL "" FORCE) - set(PICKY_DEVELOPER - OFF - CACHE BOOL "" FORCE) - - FetchContent_MakeAvailable(cmocka) - - # cmocka can export its target as "cmocka" or "cmocka-static" create alias if - # it doesnt exist - if(NOT TARGET cmocka::cmocka) - if(TARGET cmocka-static) - add_library(cmocka::cmocka ALIAS cmocka-static) - elseif(TARGET cmocka) - add_library(cmocka::cmocka ALIAS cmocka) - else() - message( - WARNING - "[arraylist] cmocka::cmocka target could not be tested — skipping tests" - ) - return() - endif() - endif() -endif() - -# --------------------------------------------------------------- -# Verifiy ASAN support -# --------------------------------------------------------------- -set(ARRAYLIST_USE_ASAN OFF) - -if(ARRAYLIST_ENABLE_SANITIZERS) - if(MSVC) - if(MSVC_VERSION GREATER_EQUAL 1928) - set(ARRAYLIST_USE_ASAN ON) - else() - message( - STATUS - "[arraylist] MSVC < 16.9 doesnt support ASAN — sanitizers deactivated." - ) - endif() - elseif(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang" AND NOT WIN32) - include(CheckCCompilerFlag) - check_c_compiler_flag(-fsanitize=address ARRAYLIST_COMPILER_HAS_ASAN) - if(ARRAYLIST_COMPILER_HAS_ASAN) - set(ARRAYLIST_USE_ASAN ON) - else() - message( - STATUS - "[arraylist] Compiler doesnt support -fsanitize=address — sanitizers deactivated." - ) - endif() - else() - message( - STATUS - "[arraylist] Platform/compiler doesnt support ASAN — sanitizers deactivated." - ) - endif() - - if(ARRAYLIST_USE_ASAN) - message(STATUS "[arraylist] ASAN Enabled for tests") - endif() -endif() - -# --------------------------------------------------------------- -# Test execuatable -# --------------------------------------------------------------- -add_executable(test_arraylist test_arraylist.c) - -target_link_libraries(test_arraylist PRIVATE arraylist cmocka::cmocka) - -# Same as lib -target_compile_features(test_arraylist PRIVATE c_std_11) - -# Apply asan -if(ARRAYLIST_USE_ASAN) - if(MSVC) - target_compile_options(test_arraylist PRIVATE /fsanitize=address) - else() - target_compile_options(test_arraylist PRIVATE -fsanitize=address - -fno-omit-frame-pointer) - target_link_options(test_arraylist PRIVATE -fsanitize=address) - endif() -endif() - -# --------------------------------------------------------------- -# Register with CTests -# --------------------------------------------------------------- -add_test(NAME arraylist_tests COMMAND test_arraylist) - -set_tests_properties(arraylist_tests PROPERTIES TIMEOUT 30) diff --git a/test/test_arraylist.c b/test/test_arraylist.c index 9a190f5..bd14211 100644 --- a/test/test_arraylist.c +++ b/test/test_arraylist.c @@ -7,2034 +7,2073 @@ #include #include -#include "arraylist.h" +#include "lae_arraylist.h" // INIT static void test_init_valid_parameters(void **state) { - (void)state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - arraylist_destroy(&arr); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 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; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); - arraylist_destroy(&arr); - assert_null(arr); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 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); + int n = 8; + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); - assert_false(arraylist_is_empty(arr)); + assert_false(arraylist_is_empty(arr)); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_size_after_many_push(void **state) { - (void)state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 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, 2, &b), ARRLIST_OK); + assert_int_equal(b, 10); - assert_uint_equal(arraylist_get(arr, 3, &b), ARRLIST_OK); - assert_int_equal(b, 11); + assert_uint_equal(arraylist_get(arr, 3, &b), ARRLIST_OK); + assert_int_equal(b, 11); - assert_uint_equal(arraylist_get(arr, 4, &b), ARRLIST_OK); - assert_int_equal(b, 12); + assert_uint_equal(arraylist_get(arr, 4, &b), ARRLIST_OK); + assert_int_equal(b, 12); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_push_back_null_array(void **state) { - (void)state; + (void)state; - ArrayList *arr = NULL; + ArrayList *arr = NULL; - int n = 8; - assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_NULL_ARG); + int n = 8; + assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_NULL_ARG); } static void test_push_back_null_data(void **state) { - (void)state; + (void)state; - ArrayList *arr; - arraylist_init(&arr, 64, sizeof(int)); + ArrayList *arr; + arraylist_init(&arr, 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; + ArrayList *arr = NULL; - int n = 8; - assert_uint_equal(arraylist_set(arr, 80, &n), ARRLIST_NULL_ARG); + int n = 8; + assert_uint_equal(arraylist_set(arr, 80, &n), ARRLIST_NULL_ARG); } static void test_set_null_data(void **state) { - (void)state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 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 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 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); + assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_OK); + assert_uint_equal(arraylist_capacity(arr), 128); - arraylist_destroy(&arr); + arraylist_destroy(&arr); } static void test_resize_decrease_capacity(void **state) { - (void)state; + (void)state; - ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + ArrayList *arr; + assert_int_equal(arraylist_init(&arr, 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); + 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); + 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); + 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); + 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 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 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 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_next[] = { + cmocka_unit_test(test_slice_next_valid_array), + cmocka_unit_test(test_slice_next_invalid_array), + cmocka_unit_test(test_slice_next_null_slice), + cmocka_unit_test(test_slice_next_null_out), + cmocka_unit_test(test_slice_next_until_invalid), + }; - const struct CMUnitTest slice_reset[] = { - cmocka_unit_test(test_slice_reset_valid_slice), - cmocka_unit_test(test_slice_reset_null_slice), - }; + const struct CMUnitTest slice_reset[] = { + cmocka_unit_test(test_slice_reset_valid_slice), + cmocka_unit_test(test_slice_reset_null_slice), + }; - const struct CMUnitTest slice_advance[] = { - cmocka_unit_test(test_slice_advance_valid_slice), - cmocka_unit_test(test_slice_advance_out_of_bounds), - cmocka_unit_test(test_slice_advance_null_array), - cmocka_unit_test(test_slice_advance_size_max), - }; + const struct CMUnitTest slice_advance[] = { + cmocka_unit_test(test_slice_advance_valid_slice), + cmocka_unit_test(test_slice_advance_out_of_bounds), + cmocka_unit_test(test_slice_advance_null_array), + cmocka_unit_test(test_slice_advance_size_max), + }; - const struct CMUnitTest slice_to_array[] = { - cmocka_unit_test(test_slice_to_array_valid), - cmocka_unit_test(test_slice_to_array_null_slice), - }; + const struct CMUnitTest slice_to_array[] = { + cmocka_unit_test(test_slice_to_array_valid), + cmocka_unit_test(test_slice_to_array_null_slice), + }; - int rc = 0; + int rc = 0; - rc += cmocka_run_group_tests(init, NULL, NULL); - rc += cmocka_run_group_tests(destroy, NULL, NULL); - rc += cmocka_run_group_tests(state, NULL, NULL); - rc += cmocka_run_group_tests(push_back, NULL, NULL); - rc += cmocka_run_group_tests(push_front, NULL, NULL); - rc += cmocka_run_group_tests(insert, NULL, NULL); - rc += cmocka_run_group_tests(pop_back, NULL, NULL); - rc += cmocka_run_group_tests(pop_front, NULL, NULL); - rc += cmocka_run_group_tests(remove_at, NULL, NULL); - rc += cmocka_run_group_tests(get, NULL, NULL); - rc += cmocka_run_group_tests(set, NULL, NULL); - rc += cmocka_run_group_tests(clear, NULL, NULL); - rc += cmocka_run_group_tests(resize, NULL, NULL); - rc += cmocka_run_group_tests(reserve, NULL, NULL); + rc += cmocka_run_group_tests(init, NULL, NULL); + rc += cmocka_run_group_tests(destroy, NULL, NULL); + rc += cmocka_run_group_tests(state, NULL, NULL); + rc += cmocka_run_group_tests(push_back, NULL, NULL); + rc += cmocka_run_group_tests(push_front, NULL, NULL); + rc += cmocka_run_group_tests(insert, NULL, NULL); + rc += cmocka_run_group_tests(pop_back, NULL, NULL); + rc += cmocka_run_group_tests(pop_front, NULL, NULL); + rc += cmocka_run_group_tests(remove_at, NULL, NULL); + rc += cmocka_run_group_tests(get, NULL, NULL); + rc += cmocka_run_group_tests(set, NULL, NULL); + rc += cmocka_run_group_tests(clear, NULL, NULL); + rc += cmocka_run_group_tests(resize, NULL, NULL); + rc += cmocka_run_group_tests(reserve, NULL, NULL); - rc += cmocka_run_group_tests(slice_array, NULL, NULL); - rc += cmocka_run_group_tests(slice_array_unsafe, NULL, NULL); - rc += cmocka_run_group_tests(slice_destroy, NULL, NULL); - rc += cmocka_run_group_tests(slice_peek, NULL, NULL); - rc += cmocka_run_group_tests(slice_next, NULL, NULL); - rc += cmocka_run_group_tests(slice_reset, NULL, NULL); - rc += cmocka_run_group_tests(slice_advance, NULL, NULL); - rc += cmocka_run_group_tests(slice_to_array, NULL, NULL); + rc += cmocka_run_group_tests(slice_array, NULL, NULL); + rc += cmocka_run_group_tests(slice_array_unsafe, NULL, NULL); + rc += cmocka_run_group_tests(slice_destroy, NULL, NULL); + rc += cmocka_run_group_tests(slice_peek, NULL, NULL); + rc += cmocka_run_group_tests(slice_next, NULL, NULL); + rc += cmocka_run_group_tests(slice_reset, NULL, NULL); + rc += cmocka_run_group_tests(slice_advance, NULL, NULL); + rc += cmocka_run_group_tests(slice_to_array, NULL, NULL); - return rc; + return rc; } diff --git a/xmake.lua b/xmake.lua new file mode 100644 index 0000000..7564556 --- /dev/null +++ b/xmake.lua @@ -0,0 +1,94 @@ +set_project("lae_arraylist") +set_version("1.0.0") + +set_languages("c11") + +add_rules("mode.debug", "mode.release") + +-- clang compile commands +add_rules("plugin.compile_commands.autoupdate") + +-- ========================================================= +-- Options +-- ========================================================= + +option("tests") +set_default(false) +set_showmenu(true) +option_end() + +option("example") +set_default(false) +set_showmenu(true) +option_end() + +option("asan") +set_default(false) +set_showmenu(true) +option_end() + +-- ========================================================= +-- Packages +-- ========================================================= + +-- Run xmake repo --add lae-repo https://laentropia-homelab.tail7368da.ts.net/laentropia/xmake-repo.git +-- to add my repo :) + +add_requires("cmocka", { optional = true }) -- For tests +add_requires("lae_allocator") + +-- ========================================================= +-- Library +-- ========================================================= + +target("lae_arraylist") +set_kind("static") + +add_packages("lae_allocator", { public = true }) + +add_files("src/lae_arraylist.c") + +add_headerfiles("include/*.h") + +add_includedirs("include", { public = true }) + +if is_mode("debug") then + add_cflags("-Wall", "-Wextra", "-Wpedantic") +end + +-- ========================================================= +-- Example executable +-- ========================================================= + +if has_config("example") then + target("example") + set_kind("binary") + + add_deps("lae_arraylist") + add_packages("lae_allocator") + + add_files("src/main.c") +end + +-- ========================================================= +-- Tests +-- ========================================================= + +if has_config("tests") then + target("test_arena") + set_kind("binary") + + add_files("test/test_arraylist.c") + + add_deps("lae_arraylist") + + add_packages("cmocka") + + add_tests("default") + + if has_config("asan") then + add_cflags("-fsanitize=address", "-fno-omit-frame-pointer", { force = true }) + + add_ldflags("-fsanitize=address", { force = true }) + end +end