From a057f237986acf6f04d2f4760a8797b007e5e3f7 Mon Sep 17 00:00:00 2001 From: laentropia Date: Wed, 10 Jun 2026 11:18:10 -0600 Subject: [PATCH 1/3] 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 From c983fd22ad7fc98bd9614d8d5cc9ea97694e531a Mon Sep 17 00:00:00 2001 From: laentropia Date: Wed, 10 Jun 2026 13:33:26 -0600 Subject: [PATCH 2/3] refactor: ArrayList and ArraySlice uses Allocator --- include/lae_arraylist.h | 26 +++++++++++++---- src/lae_arraylist.c | 65 ++++++++++++++++++++++++++++++++--------- 2 files changed, 72 insertions(+), 19 deletions(-) diff --git a/include/lae_arraylist.h b/include/lae_arraylist.h index dee609d..a836467 100644 --- a/include/lae_arraylist.h +++ b/include/lae_arraylist.h @@ -1,6 +1,7 @@ #ifndef LAE_ARRAYLIST_H #define LAE_ARRAYLIST_H +#include "lae_allocator.h" #include #include #include @@ -25,7 +26,11 @@ typedef enum { ARRLIST_BORROW_UNDERFLOW, } ArrayListErr; -ArrayListErr arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size); +ArrayListErr arraylist_init( + ArrayList **arr, + Allocator allocator, + size_t capacity, + size_t elem_size); ArrayListErr arraylist_destroy(ArrayList **arr); ArrayListErr arraylist_clear(ArrayList *arr); ArrayList *arraylist_clone(const ArrayList *arr); @@ -50,11 +55,19 @@ 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( + ArraySlice **slice, + Allocator allocator, + ArrayList *arr, + size_t start, + size_t len); ArrayListErr arraylist_slice_unsafe( - ArraySlice **slice, ArrayList *arr, size_t start, size_t len); + ArraySlice **slice, + Allocator allocator, + ArrayList *arr, + size_t start, + size_t len); ArrayListErr arrayslice_destroy(ArraySlice **slice); @@ -69,6 +82,9 @@ ArrayListErr arrayslice_next(ArraySlice *slice, void *out); ArrayListErr arrayslice_reset(ArraySlice *slice); ArrayListErr arrayslice_advance(ArraySlice *slice, size_t n); -ArrayListErr arrayslice_to_arraylist(ArrayList **arr, const ArraySlice *slice); +ArrayListErr arrayslice_to_arraylist( + ArrayList **arr, + Allocator allocator, + const ArraySlice *slice); #endif diff --git a/src/lae_arraylist.c b/src/lae_arraylist.c index eab4ee5..ae8efc0 100644 --- a/src/lae_arraylist.c +++ b/src/lae_arraylist.c @@ -1,4 +1,6 @@ #include "lae_arraylist.h" +#include "lae_allocator.h" +#include #include #include #include @@ -10,6 +12,8 @@ struct ArrayList { size_t len; size_t elem_size; size_t borrows; + + Allocator allocator; }; struct ArraySlice { @@ -18,6 +22,8 @@ struct ArraySlice { size_t end; size_t current; bool is_safe; + + Allocator allocator; }; // Grow and shrink factor is 2, 1.5 might give different results i guess @@ -26,8 +32,11 @@ 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, + Allocator allocator, + size_t capacity, + size_t elem_size) { if (arr == NULL) { return ARRLIST_NULL_ARG; } @@ -46,7 +55,8 @@ arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size) { return ARRLIST_INVALID_CAPACITY; } - ArrayList *new_arr = malloc(sizeof(ArrayList)); + ArrayList *new_arr = + allocator.alloc(allocator.ctx, sizeof(ArrayList), alignof(ArrayList)); if (new_arr == NULL) { return ARRLIST_BAD_ALLOC; } @@ -55,9 +65,14 @@ arraylist_init(ArrayList **arr, size_t capacity, size_t elem_size) { new_arr->elem_size = elem_size; new_arr->len = 0; new_arr->borrows = 0; - new_arr->buffer = malloc(capacity * elem_size); + new_arr->buffer = allocator.alloc(allocator.ctx, capacity * elem_size, 0); + new_arr->allocator = allocator; if (new_arr->buffer == NULL) { - free(new_arr); + allocator.free( + allocator.ctx, + new_arr, + sizeof(ArrayList), + alignof(ArrayList)); return ARRLIST_BAD_ALLOC; } @@ -74,9 +89,12 @@ ArrayListErr arraylist_destroy(ArrayList **arr) { return ARRLIST_IS_BORROWED; } + ArrayList *tmp = *arr; + // No problem on using free on NULL :) - free((*arr)->buffer); - free(*arr); + tmp->allocator.free(tmp->allocator.ctx, tmp->buffer, tmp->capacity, 0); + tmp->allocator + .free(tmp->allocator.ctx, tmp, sizeof(ArrayList), alignof(ArrayList)); *arr = NULL; return ARRLIST_OK; @@ -417,8 +435,12 @@ 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, + Allocator allocator, + ArrayList *arr, + size_t start, + size_t len) { if (arr == NULL || slice == NULL) { return ARRLIST_NULL_ARG; } @@ -435,7 +457,8 @@ arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, size_t len) { return ARRLIST_INVALID_START; } - ArraySlice *new_slice = malloc(sizeof(ArraySlice)); + ArraySlice *new_slice = + allocator.alloc(allocator.ctx, sizeof(ArraySlice), alignof(ArraySlice)); if (new_slice == NULL) { return ARRLIST_BAD_ALLOC; } @@ -445,6 +468,7 @@ arraylist_slice(ArraySlice **slice, ArrayList *arr, size_t start, size_t len) { new_slice->end = start + len; new_slice->current = start; new_slice->is_safe = true; + new_slice->allocator = allocator; arr->borrows++; *slice = new_slice; @@ -452,7 +476,11 @@ 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) { + ArraySlice **slice, + Allocator allocator, + ArrayList *arr, + size_t start, + size_t len) { if (arr == NULL || slice == NULL) { return ARRLIST_NULL_ARG; } @@ -469,7 +497,8 @@ ArrayListErr arraylist_slice_unsafe( return ARRLIST_INVALID_START; } - ArraySlice *new_slice = malloc(sizeof(ArraySlice)); + ArraySlice *new_slice = + allocator.alloc(allocator.ctx, sizeof(ArraySlice), alignof(ArraySlice)); if (new_slice == NULL) { return ARRLIST_BAD_ALLOC; } @@ -493,7 +522,11 @@ ArrayListErr arrayslice_destroy(ArraySlice **slice) { (*slice)->arr->borrows--; } - free(*slice); + (*slice)->allocator.free( + (*slice)->allocator.ctx, + *slice, + sizeof(ArraySlice), + alignof(ArraySlice)); *slice = NULL; return ARRLIST_OK; @@ -570,7 +603,10 @@ ArrayListErr arrayslice_advance(ArraySlice *slice, size_t n) { return ARRLIST_OK; } -ArrayListErr arrayslice_to_arraylist(ArrayList **arr, const ArraySlice *slice) { +ArrayListErr arrayslice_to_arraylist( + ArrayList **arr, + Allocator allocator, + const ArraySlice *slice) { if (slice == NULL || slice->arr == NULL) { return ARRLIST_NULL_ARG; } @@ -588,6 +624,7 @@ ArrayListErr arrayslice_to_arraylist(ArrayList **arr, const ArraySlice *slice) { ArrayList *new_arr; ArrayListErr init_err = arraylist_init( &new_arr, + allocator, arraylist_capacity(slice->arr), slice->arr->elem_size); From 1a0afd331c14d625c34eede36f0c704ad8c2d7c2 Mon Sep 17 00:00:00 2001 From: laentropia Date: Wed, 10 Jun 2026 14:49:28 -0600 Subject: [PATCH 3/3] test: done for refactor, ready to merge --- src/lae_arraylist.c | 1 + test/test_arraylist.c | 593 ++++++++++++++++++++++++++++++++---------- xmake.lua | 2 +- 3 files changed, 461 insertions(+), 135 deletions(-) diff --git a/src/lae_arraylist.c b/src/lae_arraylist.c index ae8efc0..47e8bb5 100644 --- a/src/lae_arraylist.c +++ b/src/lae_arraylist.c @@ -508,6 +508,7 @@ ArrayListErr arraylist_slice_unsafe( new_slice->end = start + len; new_slice->current = start; new_slice->is_safe = false; + new_slice->allocator = allocator; *slice = new_slice; return ARRLIST_OK; diff --git a/test/test_arraylist.c b/test/test_arraylist.c index bd14211..0ac85a2 100644 --- a/test/test_arraylist.c +++ b/test/test_arraylist.c @@ -7,6 +7,7 @@ #include #include +#include "lae_allocator.h" #include "lae_arraylist.h" // INIT @@ -15,7 +16,9 @@ static void test_init_valid_parameters(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); arraylist_destroy(&arr); } @@ -24,7 +27,7 @@ static void test_init_zero_capacity(void **state) { ArrayList *arr; assert_uint_equal( - arraylist_init(&arr, 0, sizeof(int)), + arraylist_init(&arr, allocator_default(), 0, sizeof(int)), ARRLIST_INVALID_CAPACITY); arraylist_destroy(&arr); } @@ -33,7 +36,9 @@ static void test_init_zero_elem_size(void **state) { (void)state; ArrayList *arr; - assert_uint_equal(arraylist_init(&arr, 64, 0), ARRLIST_INVALID_ELEM_SIZE); + assert_uint_equal( + arraylist_init(&arr, allocator_default(), 64, 0), + ARRLIST_INVALID_ELEM_SIZE); arraylist_destroy(&arr); } @@ -42,7 +47,7 @@ static void test_init_large_capacity(void **state) { ArrayList *arr; assert_uint_equal( - arraylist_init(&arr, SIZE_MAX, sizeof(int)), + arraylist_init(&arr, allocator_default(), SIZE_MAX, sizeof(int)), ARRLIST_INVALID_CAPACITY); arraylist_destroy(&arr); } @@ -53,7 +58,9 @@ static void test_destroy_valid_array(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); arraylist_destroy(&arr); assert_null(arr); } @@ -72,7 +79,9 @@ static void test_destroy_double(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); ArrayListErr err = arraylist_destroy(&arr); assert_uint_equal(err, ARRLIST_OK); @@ -87,7 +96,9 @@ static void test_destroy_while_borrowed(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -95,7 +106,12 @@ static void test_destroy_while_borrowed(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); assert_uint_equal(arraylist_destroy(&arr), ARRLIST_IS_BORROWED); @@ -109,7 +125,9 @@ static void test_capacity_after_init(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); assert_uint_equal(arraylist_capacity(arr), 64); @@ -120,7 +138,9 @@ static void test_is_empty_after_init(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); assert_true(arraylist_is_empty(arr)); @@ -131,7 +151,9 @@ static void test_is_empty_after_push(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); int n = 8; assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); @@ -145,7 +167,9 @@ static void test_size_after_many_push(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); int n = 8; assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); @@ -167,7 +191,9 @@ static void test_capacity_growth_on_push(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 2, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 2, sizeof(int)), + ARRLIST_OK); int n = 8; assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); @@ -186,7 +212,9 @@ static void test_capacity_shrink_on_pop(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 8, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 8, sizeof(int)), + ARRLIST_OK); int n = 8; assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); @@ -201,7 +229,9 @@ static void test_push_back_single_element(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); int n = 8; assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); @@ -218,7 +248,9 @@ static void test_push_back_multiple_elements(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); int n = 8; assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); @@ -272,7 +304,7 @@ static void test_push_back_null_data(void **state) { (void)state; ArrayList *arr; - arraylist_init(&arr, 64, sizeof(int)); + arraylist_init(&arr, allocator_default(), 64, sizeof(int)); assert_uint_equal(arraylist_push_back(arr, NULL), ARRLIST_NULL_ARG); @@ -283,7 +315,9 @@ static void test_push_back_while_borrowed(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -291,7 +325,12 @@ static void test_push_back_while_borrowed(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); int n = 8; @@ -306,7 +345,9 @@ static void test_push_front_single_element(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); int n = 8; int m; @@ -322,7 +363,9 @@ static void test_push_front_multiple_elements(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); int n = 8; int m; @@ -351,7 +394,9 @@ static void test_push_front_null_data(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); assert_int_equal(arraylist_push_front(arr, NULL), ARRLIST_NULL_ARG); @@ -362,7 +407,9 @@ static void test_push_front_while_borrowed(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -370,7 +417,12 @@ static void test_push_front_while_borrowed(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); int n = 8; @@ -385,7 +437,9 @@ static void test_insert_at_beginning(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -406,7 +460,9 @@ static void test_insert_at_middle(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -427,7 +483,9 @@ static void test_insert_at_end(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -448,7 +506,9 @@ static void test_insert_at_invalid_index(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); int n = 8; assert_uint_equal(arraylist_insert(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS); @@ -469,7 +529,9 @@ static void test_insert_null_data(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); assert_uint_equal(arraylist_insert(arr, 0, NULL), ARRLIST_NULL_ARG); @@ -480,7 +542,9 @@ static void test_insert_while_borrowed(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -488,7 +552,12 @@ static void test_insert_while_borrowed(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); int n = 8; @@ -503,7 +572,9 @@ static void test_pop_back_single_element(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -520,7 +591,9 @@ static void test_pop_back_multiple_elements(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -540,7 +613,9 @@ static void test_pop_back_until_empty(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -562,7 +637,9 @@ static void test_pop_back_empty_array(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); int n; assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_EMPTY); @@ -583,7 +660,9 @@ static void test_pop_back_null_out(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); int n = 8; assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); @@ -597,7 +676,9 @@ static void test_pop_back_while_borrowed(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -605,7 +686,12 @@ static void test_pop_back_while_borrowed(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); int n = 8; @@ -620,7 +706,9 @@ static void test_pop_front_single_element(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -637,7 +725,9 @@ static void test_pop_front_multiple_elements(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -658,7 +748,9 @@ static void test_pop_front_until_empty(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -681,7 +773,9 @@ static void test_pop_front_empty_array(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); int n; assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_EMPTY); @@ -702,7 +796,9 @@ static void test_pop_front_null_out(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); int n = 8; assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); @@ -716,7 +812,9 @@ static void test_pop_front_while_borrowed(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -724,7 +822,12 @@ static void test_pop_front_while_borrowed(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); assert_non_null(slice); @@ -740,7 +843,9 @@ static void test_remove_at_beginning(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -759,7 +864,9 @@ static void test_remove_at_middle(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -778,7 +885,9 @@ static void test_remove_at_end(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -797,7 +906,9 @@ static void test_remove_at_invalid_index(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); int n = 8; assert_uint_equal(arraylist_remove_at(arr, 80, &n), ARRLIST_OUT_OF_BOUNDS); @@ -818,7 +929,9 @@ static void test_remove_at_null_data(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); int n = 8; assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK); @@ -832,7 +945,9 @@ static void test_remove_at_while_borrowed(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -840,7 +955,12 @@ static void test_remove_at_while_borrowed(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); int n = 8; @@ -855,7 +975,9 @@ static void test_get_valid_index(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -872,7 +994,9 @@ static void test_get_first_element(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -889,7 +1013,9 @@ static void test_get_last_element(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -906,7 +1032,9 @@ static void test_get_invalid_index(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -931,7 +1059,9 @@ static void test_get_null_out(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -946,7 +1076,9 @@ static void test_get_while_borrowed(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -954,7 +1086,12 @@ static void test_get_while_borrowed(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); int n = 8; @@ -969,7 +1106,9 @@ static void test_set_valid_index(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -988,7 +1127,9 @@ static void test_set_first_element(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1007,7 +1148,9 @@ static void test_set_last_element(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1026,7 +1169,9 @@ static void test_set_invalid_index(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1051,7 +1196,9 @@ static void test_set_null_data(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); assert_uint_equal(arraylist_set(arr, 8, NULL), ARRLIST_NULL_ARG); @@ -1062,7 +1209,9 @@ static void test_set_while_borrowed(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1070,7 +1219,12 @@ static void test_set_while_borrowed(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); int n = 8; @@ -1085,7 +1239,9 @@ static void test_clear_non_empty_array(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (size_t i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1102,7 +1258,9 @@ static void test_clear_already_empty_array(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); assert_uint_equal(arraylist_clear(arr), ARRLIST_OK); @@ -1121,7 +1279,9 @@ static void test_clear_while_borrowed(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1129,7 +1289,12 @@ static void test_clear_while_borrowed(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); assert_uint_equal(arraylist_clear(arr), ARRLIST_IS_BORROWED); @@ -1143,7 +1308,9 @@ static void test_resize_increase_capacity(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_OK); assert_uint_equal(arraylist_capacity(arr), 128); @@ -1155,7 +1322,9 @@ static void test_resize_decrease_capacity(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); assert_uint_equal(arraylist_resize(arr, 32), ARRLIST_OK); assert_uint_equal(arraylist_capacity(arr), 32); @@ -1167,7 +1336,9 @@ static void test_resize_to_zero(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); assert_uint_equal(arraylist_resize(arr, 0), ARRLIST_INVALID_CAPACITY); assert_uint_equal(arraylist_capacity(arr), 64); @@ -1179,7 +1350,9 @@ static void test_resize_to_size_max(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); assert_uint_equal(arraylist_resize(arr, SIZE_MAX), ARRLIST_ALLOC_OVERFLOW); assert_uint_equal(arraylist_capacity(arr), 64); @@ -1199,7 +1372,9 @@ static void test_resize_while_borrowed(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1207,7 +1382,12 @@ static void test_resize_while_borrowed(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_IS_BORROWED); @@ -1221,7 +1401,9 @@ static void test_reserve_normal_capacity(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); assert_uint_equal(arraylist_reserve(arr, 32), ARRLIST_OK); assert_uint_equal(arraylist_capacity(arr), 96); @@ -1233,7 +1415,9 @@ static void test_reserve_size_max(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); assert_uint_equal(arraylist_reserve(arr, SIZE_MAX), ARRLIST_ALLOC_OVERFLOW); assert_uint_equal(arraylist_capacity(arr), 64); @@ -1245,7 +1429,9 @@ static void test_reserve_size_0(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); assert_uint_equal(arraylist_reserve(arr, 0), ARRLIST_OK); assert_uint_equal(arraylist_capacity(arr), 64); @@ -1257,7 +1443,9 @@ static void test_reserve_while_borrowed(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1265,7 +1453,12 @@ static void test_reserve_while_borrowed(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); assert_uint_equal(arraylist_reserve(arr, 128), ARRLIST_IS_BORROWED); @@ -1279,14 +1472,18 @@ static void test_slice_valid_init(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (size_t i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); } ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, 10), ARRLIST_OK); + assert_uint_equal( + arraylist_slice(&slice, allocator_default(), arr, 0, 10), + ARRLIST_OK); arrayslice_destroy(&slice); arraylist_destroy(&arr); @@ -1296,7 +1493,9 @@ static void test_slice_invalid_index(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (size_t i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1304,7 +1503,7 @@ static void test_slice_invalid_index(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 32, 10), + arraylist_slice(&slice, allocator_default(), arr, 32, 10), ARRLIST_INVALID_START); arraylist_destroy(&arr); @@ -1314,7 +1513,9 @@ static void test_slice_invalid_len(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (size_t i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1322,7 +1523,7 @@ static void test_slice_invalid_len(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, 300), + arraylist_slice(&slice, allocator_default(), arr, 0, 300), ARRLIST_INVALID_START); arraylist_destroy(&arr); @@ -1332,7 +1533,9 @@ static void test_slice_len_zero(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (size_t i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1340,7 +1543,7 @@ static void test_slice_len_zero(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, 0), + arraylist_slice(&slice, allocator_default(), arr, 0, 0), ARRLIST_INVALID_START); arraylist_destroy(&arr); @@ -1350,10 +1553,14 @@ static void test_slice_empty_array(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, 10), ARRLIST_INVALID_ARR); + assert_uint_equal( + arraylist_slice(&slice, allocator_default(), arr, 0, 10), + ARRLIST_INVALID_ARR); arraylist_destroy(&arr); } @@ -1364,7 +1571,9 @@ static void test_slice_null_arr(void **state) { ArrayList *arr = NULL; ArraySlice *slice; - assert_uint_equal(arraylist_slice(&slice, arr, 0, 10), ARRLIST_NULL_ARG); + assert_uint_equal( + arraylist_slice(&slice, allocator_default(), arr, 0, 10), + ARRLIST_NULL_ARG); } // Slice Unsafe @@ -1372,14 +1581,18 @@ static void test_slice_unsafe_valid_init(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (size_t i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); } ArraySlice *slice; - assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 10), ARRLIST_OK); + assert_uint_equal( + arraylist_slice_unsafe(&slice, allocator_default(), arr, 0, 10), + ARRLIST_OK); arrayslice_destroy(&slice); arraylist_destroy(&arr); @@ -1389,7 +1602,9 @@ static void test_slice_unsafe_invalid_index(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (size_t i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1397,7 +1612,7 @@ static void test_slice_unsafe_invalid_index(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice_unsafe(&slice, arr, 32, 10), + arraylist_slice_unsafe(&slice, allocator_default(), arr, 32, 10), ARRLIST_INVALID_START); arraylist_destroy(&arr); @@ -1407,7 +1622,9 @@ static void test_slice_unsafe_invalid_len(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (size_t i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1415,7 +1632,7 @@ static void test_slice_unsafe_invalid_len(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice_unsafe(&slice, arr, 0, 300), + arraylist_slice_unsafe(&slice, allocator_default(), arr, 0, 300), ARRLIST_INVALID_START); arraylist_destroy(&arr); @@ -1425,7 +1642,9 @@ static void test_slice_unsafe_len_zero(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (size_t i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1433,7 +1652,7 @@ static void test_slice_unsafe_len_zero(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice_unsafe(&slice, arr, 0, 0), + arraylist_slice_unsafe(&slice, allocator_default(), arr, 0, 0), ARRLIST_INVALID_START); arraylist_destroy(&arr); @@ -1443,11 +1662,13 @@ static void test_slice_unsafe_empty_array(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); ArraySlice *slice; assert_uint_equal( - arraylist_slice_unsafe(&slice, arr, 0, 10), + arraylist_slice_unsafe(&slice, allocator_default(), arr, 0, 10), ARRLIST_INVALID_ARR); arraylist_destroy(&arr); @@ -1460,7 +1681,7 @@ static void test_slice_unsafe_null_arr(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice_unsafe(&slice, arr, 0, 10), + arraylist_slice_unsafe(&slice, allocator_default(), arr, 0, 10), ARRLIST_NULL_ARG); } @@ -1469,7 +1690,9 @@ static void test_slice_destroy_valid(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1477,7 +1700,12 @@ static void test_slice_destroy_valid(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_OK); @@ -1488,7 +1716,9 @@ static void test_slice_destroy_null_slice(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1504,14 +1734,21 @@ static void test_slice_double_destroy(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 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)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_OK); @@ -1524,14 +1761,21 @@ static void test_slice_peek_valid_array(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 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)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); int m; @@ -1546,7 +1790,9 @@ static void test_slice_peek_invalid_array(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1554,7 +1800,12 @@ static void test_slice_peek_invalid_array(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK); @@ -1570,7 +1821,9 @@ static void test_slice_peek_null_out(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1578,7 +1831,12 @@ static void test_slice_peek_null_out(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); assert_uint_equal(arrayslice_peek(slice, NULL), ARRLIST_NULL_ARG); @@ -1601,7 +1859,9 @@ static void test_slice_next_valid_array(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1609,7 +1869,12 @@ static void test_slice_next_valid_array(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); int m; @@ -1624,7 +1889,9 @@ static void test_slice_next_invalid_array(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1632,7 +1899,12 @@ static void test_slice_next_invalid_array(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK); @@ -1648,7 +1920,9 @@ static void test_slice_next_null_out(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1656,7 +1930,12 @@ static void test_slice_next_null_out(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); assert_uint_equal(arrayslice_next(slice, NULL), ARRLIST_OK); @@ -1678,7 +1957,9 @@ static void test_slice_next_until_invalid(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1686,7 +1967,12 @@ static void test_slice_next_until_invalid(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); int m; @@ -1705,7 +1991,9 @@ static void test_slice_reset_valid_slice(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1713,7 +2001,12 @@ static void test_slice_reset_valid_slice(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); int m; @@ -1748,7 +2041,9 @@ static void test_slice_advance_valid_slice(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1756,7 +2051,12 @@ static void test_slice_advance_valid_slice(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); int m; @@ -1775,7 +2075,9 @@ static void test_slice_advance_out_of_bounds(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1783,7 +2085,12 @@ static void test_slice_advance_out_of_bounds(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); int m; @@ -1802,7 +2109,9 @@ static void test_slice_advance_size_max(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1810,7 +2119,12 @@ static void test_slice_advance_size_max(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); int m; @@ -1840,7 +2154,9 @@ static void test_slice_to_array_valid(void **state) { (void)state; ArrayList *arr; - assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK); + assert_int_equal( + arraylist_init(&arr, allocator_default(), 64, sizeof(int)), + ARRLIST_OK); for (int i = 0; i < 10; i++) { assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK); @@ -1848,11 +2164,18 @@ static void test_slice_to_array_valid(void **state) { ArraySlice *slice; assert_uint_equal( - arraylist_slice(&slice, arr, 0, arraylist_size(arr)), + arraylist_slice( + &slice, + allocator_default(), + arr, + 0, + arraylist_size(arr)), ARRLIST_OK); ArrayList *arr2; - assert_uint_equal(arrayslice_to_arraylist(&arr2, slice), ARRLIST_OK); + assert_uint_equal( + arrayslice_to_arraylist(&arr2, allocator_default(), slice), + ARRLIST_OK); assert_uint_equal(arraylist_capacity(arr2), 64); assert_uint_equal(arraylist_size(arr2), 10); @@ -1867,7 +2190,9 @@ static void test_slice_to_array_null_slice(void **state) { ArraySlice *slice = NULL; ArrayList *arr = NULL; - assert_uint_equal(arrayslice_to_arraylist(&arr, slice), ARRLIST_NULL_ARG); + assert_uint_equal( + arrayslice_to_arraylist(&arr, allocator_default(), slice), + ARRLIST_NULL_ARG); } int main(void) { diff --git a/xmake.lua b/xmake.lua index 7564556..d8c8452 100644 --- a/xmake.lua +++ b/xmake.lua @@ -75,7 +75,7 @@ end -- ========================================================= if has_config("tests") then - target("test_arena") + target("test_arraylist") set_kind("binary") add_files("test/test_arraylist.c")