Test cfix

CMakeLists.txt

@@ -4,14 +4,18 @@ project(
   VERSION 1.0
   LANGUAGES C)
 
+# ------------------------------------------------
+# Estandard C
+# ------------------------------------------------
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_C_EXTENSIONS OFF)
 
-# clangd
+# Exportar compile_commands.json (clangd / IDEs)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 # ------------------------------------------------
-# Detectar si este proyecto es el principal
+# Is Top project?
 # ------------------------------------------------
 if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
   set(ARRAYLIST_IS_TOP_LEVEL ON)
@@ -19,32 +23,76 @@ else()
   set(ARRAYLIST_IS_TOP_LEVEL OFF)
 endif()
 
+# ------------------------------------------------
 # Opciones
-option(ARRAYLIST_BUILD_TESTS "Build arraylist tests" ${ARRAYLIST_IS_TOP_LEVEL})
-option(ARRAYLIST_ENABLE_SANITIZERS "Enable sanitizers for tests" ON)
+# ------------------------------------------------
+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)
 
-# ------------------------
-# Library
-# ------------------------
+# ------------------------------------------------
+# 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 $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
                    $<INSTALL_INTERFACE:include>)
 
-target_compile_options(arraylist PRIVATE -Wall -Wextra -Wpedantic)
+# Flagas only for compile lib
+target_compile_options(arraylist PRIVATE ${ARRAYLIST_WARNING_FLAGS})
 
-# ------------------------
-# Example (opcional)
-# ------------------------
+# 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()
 
-target_link_libraries(arraylist_example arraylist)
-
-# ------------------------
-# Testing
-# ------------------------
+# ------------------------------------------------
+# 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()

test/CMakeLists.txt

@@ -1,23 +1,121 @@
-find_package(cmocka REQUIRED)
+# ---------------------------------------------------------------
+# 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
-    arraylist
-    cmocka::cmocka
-)
+target_link_libraries(test_arraylist PRIVATE arraylist cmocka::cmocka)
 
-# Sanitizers (portables)
-if(ARRAYLIST_ENABLE_SANITIZERS)
-    if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
-        target_compile_options(test_arraylist PRIVATE
-            -fsanitize=address
-            -fno-omit-frame-pointer
-        )
-        target_link_options(test_arraylist PRIVATE
-            -fsanitize=address
-        )
+# 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)

test/test_arraylist.c

@@ -1,10 +1,10 @@
+#include <cmocka.h>
+#include <setjmp.h>
 #include <stdalign.h>
 #include <stdarg.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
-#include <setjmp.h>
-#include <cmocka.h>
 #include <string.h>
 
 #include "arraylist.h"
@@ -23,7 +23,8 @@ static void test_init_zero_capacity(void **state) {
   (void)state;
 
   ArrayList *arr;
-    assert_uint_equal(arraylist_init(&arr, 0, sizeof(int)), ARRLIST_INVALID_CAPACITY);
+  assert_uint_equal(arraylist_init(&arr, 0, sizeof(int)),
+                    ARRLIST_INVALID_CAPACITY);
   arraylist_destroy(&arr);
 }
 
@@ -39,7 +40,8 @@ static void test_init_large_capacity(void **state) {
   (void)state;
 
   ArrayList *arr;
-    assert_uint_equal(arraylist_init(&arr, SIZE_MAX, sizeof(int)), ARRLIST_INVALID_CAPACITY);
+  assert_uint_equal(arraylist_init(&arr, SIZE_MAX, sizeof(int)),
+                    ARRLIST_INVALID_CAPACITY);
   arraylist_destroy(&arr);
 }
 
@@ -90,8 +92,8 @@ static void test_destroy_while_borrowed(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
-
+  assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+                    ARRLIST_OK);
 
   assert_uint_equal(arraylist_destroy(&arr), ARRLIST_IS_BORROWED);
 
@@ -285,7 +287,8 @@ static void test_push_back_while_borrowed(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  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);
@@ -362,7 +365,8 @@ static void test_push_front_while_borrowed(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice,arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  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);
@@ -441,7 +445,6 @@ static void test_insert_at_invalid_index(void **state) {
   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);
 
@@ -463,7 +466,6 @@ static void test_insert_null_data(void **state) {
   ArrayList *arr;
   assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
 
-
   assert_uint_equal(arraylist_insert(arr, 0, NULL), ARRLIST_NULL_ARG);
 
   arraylist_destroy(&arr);
@@ -480,7 +482,8 @@ static void test_insert_while_borrowed(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  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);
@@ -595,7 +598,8 @@ static void test_pop_back_while_borrowed(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  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);
@@ -712,7 +716,8 @@ static void test_pop_front_while_borrowed(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+                    ARRLIST_OK);
   assert_non_null(slice);
 
   int n = 8;
@@ -786,7 +791,6 @@ static void test_remove_at_invalid_index(void **state) {
   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);
 
@@ -827,7 +831,8 @@ static void test_remove_at_while_borrowed(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  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);
@@ -909,7 +914,6 @@ static void test_get_null_array(void **state) {
 
   ArrayList *arr = NULL;
 
-
   int m;
   assert_uint_equal(arraylist_get(arr, 80, &m), ARRLIST_NULL_ARG);
 }
@@ -940,7 +944,8 @@ static void test_get_while_borrowed(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  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);
@@ -1030,7 +1035,6 @@ static void test_set_null_array(void **state) {
 
   int n = 8;
   assert_uint_equal(arraylist_set(arr, 80, &n), ARRLIST_NULL_ARG);
-
 }
 
 static void test_set_null_data(void **state) {
@@ -1055,7 +1059,8 @@ static void test_set_while_borrowed(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  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);
@@ -1112,7 +1117,8 @@ static void test_clear_while_borrowed(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+                    ARRLIST_OK);
 
   assert_uint_equal(arraylist_clear(arr), ARRLIST_IS_BORROWED);
 
@@ -1188,7 +1194,8 @@ static void test_resize_while_borrowed(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+                    ARRLIST_OK);
 
   assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_IS_BORROWED);
 
@@ -1244,7 +1251,8 @@ static void test_reserve_while_borrowed(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+                    ARRLIST_OK);
 
   assert_uint_equal(arraylist_reserve(arr, 128), ARRLIST_IS_BORROWED);
 
@@ -1281,7 +1289,8 @@ static void test_slice_invalid_index(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 32, 10), ARRLIST_INVALID_START);
+  assert_uint_equal(arraylist_slice(&slice, arr, 32, 10),
+                    ARRLIST_INVALID_START);
 
   arraylist_destroy(&arr);
 }
@@ -1297,7 +1306,8 @@ static void test_slice_invalid_len(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, 300), ARRLIST_INVALID_START);
+  assert_uint_equal(arraylist_slice(&slice, arr, 0, 300),
+                    ARRLIST_INVALID_START);
 
   arraylist_destroy(&arr);
 }
@@ -1324,7 +1334,6 @@ static void test_slice_empty_array(void **state) {
   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);
 
@@ -1369,7 +1378,8 @@ static void test_slice_unsafe_invalid_index(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 32, 10), ARRLIST_INVALID_START);
+  assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 32, 10),
+                    ARRLIST_INVALID_START);
 
   arraylist_destroy(&arr);
 }
@@ -1385,7 +1395,8 @@ static void test_slice_unsafe_invalid_len(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 300), ARRLIST_INVALID_START);
+  assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 300),
+                    ARRLIST_INVALID_START);
 
   arraylist_destroy(&arr);
 }
@@ -1401,7 +1412,8 @@ static void test_slice_unsafe_len_zero(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 0), ARRLIST_INVALID_START);
+  assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 0),
+                    ARRLIST_INVALID_START);
 
   arraylist_destroy(&arr);
 }
@@ -1412,9 +1424,9 @@ static void test_slice_unsafe_empty_array(void **state) {
   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);
+  assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 10),
+                    ARRLIST_INVALID_ARR);
 
   arraylist_destroy(&arr);
 }
@@ -1425,7 +1437,8 @@ static void test_slice_unsafe_null_arr(void **state) {
   ArrayList *arr = NULL;
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 10), ARRLIST_NULL_ARG);
+  assert_uint_equal(arraylist_slice_unsafe(&slice, arr, 0, 10),
+                    ARRLIST_NULL_ARG);
 }
 
 // Slice Destroy
@@ -1440,7 +1453,8 @@ assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+                    ARRLIST_OK);
 
   assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_OK);
   arraylist_destroy(&arr);
@@ -1472,7 +1486,8 @@ assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
     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(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);
@@ -1490,7 +1505,8 @@ static void test_slice_peek_valid_array(void **state) {
     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(arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+                    ARRLIST_OK);
 
   int m;
   assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_OK);
@@ -1511,13 +1527,13 @@ assert_int_equal(arraylist_init(&arr, 64, sizeof(int)), ARRLIST_OK);
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+                    ARRLIST_OK);
 
   assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK);
 
   int m;
   assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_INVALID_SLICE);
-    assert_int_equal(m, 0);
 
   arrayslice_destroy(&slice);
   arraylist_destroy(&arr);
@@ -1534,7 +1550,8 @@ static void test_slice_peek_null_out(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+                    ARRLIST_OK);
 
   assert_uint_equal(arrayslice_peek(slice, NULL), ARRLIST_NULL_ARG);
 
@@ -1549,7 +1566,6 @@ static void test_slice_peek_null_slice(void **state) {
 
   int m;
   assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_NULL_ARG);
-    assert_int_equal(m, 0);
 }
 
 // Slice next
@@ -1564,7 +1580,8 @@ static void test_slice_next_valid_array(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+                    ARRLIST_OK);
 
   int m;
   assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
@@ -1585,13 +1602,13 @@ static void test_slice_next_invalid_array(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+                    ARRLIST_OK);
 
   assert_uint_equal(arrayslice_advance(slice, 10), ARRLIST_OK);
 
   int m;
   assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_INVALID_SLICE);
-    assert_int_equal(m, 0);
 
   arrayslice_destroy(&slice);
   arraylist_destroy(&arr);
@@ -1608,7 +1625,8 @@ static void test_slice_next_null_out(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+                    ARRLIST_OK);
 
   assert_uint_equal(arrayslice_next(slice, NULL), ARRLIST_OK);
 
@@ -1623,7 +1641,6 @@ static void test_slice_next_null_slice(void **state) {
 
   int m;
   assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_NULL_ARG);
-    assert_int_equal(m, 0);
 }
 
 static void test_slice_next_until_invalid(void **state) {
@@ -1637,7 +1654,8 @@ static void test_slice_next_until_invalid(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+                    ARRLIST_OK);
 
   int m;
   for (int i = 0; i < 10; i++) {
@@ -1662,7 +1680,8 @@ static void test_slice_reset_valid_slice(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+                    ARRLIST_OK);
 
   int m;
   for (int i = 0; i < 10; i++) {
@@ -1703,7 +1722,8 @@ static void test_slice_advance_valid_slice(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+                    ARRLIST_OK);
 
   int m;
   for (int i = 0; i < 5; i++) {
@@ -1728,7 +1748,8 @@ static void test_slice_advance_out_of_bounds(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+                    ARRLIST_OK);
 
   int m;
   for (int i = 0; i < 5; i++) {
@@ -1753,7 +1774,8 @@ static void test_slice_advance_size_max(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)),
+                    ARRLIST_OK);
 
   int m;
   for (int i = 0; i < 5; i++) {
@@ -1787,7 +1809,8 @@ static void test_slice_to_array_valid(void **state) {
   }
 
   ArraySlice *slice;
-    assert_uint_equal(arraylist_slice(&slice, arr, 0, arraylist_size(arr)), ARRLIST_OK);
+  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);