test: added test for reserve

include/arraylist.h

@@ -7,6 +7,11 @@
 
 typedef struct ArrayList ArrayList;
 
+// FUCK, i forgot one of the main reasons i wanted to
+// implement arrays myself was because i needed 
+// array slices or something like this and i completely
+// forgot, fuck, guess i will implement it once i get
+// the tests done.
 typedef struct {
     ArrayList *array;
     size_t offset;

src/arraylist.c

@@ -64,9 +64,6 @@ ArrayListErr arraylist_clear(ArrayList *arr) {
         return ARRLIST_NULL_ARG;
     }
 
-    memset(arr->buffer, 0, arr->capacity * arr->elem_size);
-    arr->capacity = 0;
-    arr->elem_size = 0;
     arr->len = 0;
     return ARRLIST_OK;
 }
@@ -279,7 +276,7 @@ ArrayListErr arraylist_remove_at(ArrayList *arr, size_t index, void *out) {
     }
 
     if (arr->len < 1) {
-        return ARRLIST_OK;
+        return ARRLIST_EMPTY;
     }
 
     if (out != NULL) {
@@ -362,11 +359,9 @@ ArrayListErr arraylist_reserve(ArrayList *arr, size_t size_to_reserve) {
         return ARRLIST_NULL_ARG;
     }
 
-    if (size_to_reserve < 1) {
-        return ARRLIST_INVALID_CAPACITY;
-    }
+    if (arr->capacity + size_to_reserve > SIZE_MAX / arr->elem_size ||
+        size_to_reserve > SIZE_MAX / arr->elem_size) {
 
-    if (arr->capacity + size_to_reserve > SIZE_MAX / arr->elem_size) {
         return  ARRLIST_ALLOC_OVERFLOW;
     }
 

test/test_arraylist.c

@@ -883,6 +883,137 @@ static void test_set_null_data(void **state) {
     arraylist_destroy(&arr);
 }
 
+//Clear
+static void test_clear_non_empty_array(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (size_t i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    assert_uint_equal(arraylist_clear(arr), ARRLIST_OK);
+    assert_uint_equal(arraylist_size(arr), 0);
+    assert_uint_equal(arraylist_capacity(arr), 64);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_clear_already_empty_array(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    assert_uint_equal(arraylist_clear(arr), ARRLIST_OK);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_clear_null_array(void **state) {
+    (void) state;
+
+    ArrayList *arr = NULL;
+
+    assert_uint_equal(arraylist_clear(arr), ARRLIST_NULL_ARG);
+}
+
+//Resize
+static void test_resize_increase_capacity(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_OK);
+    assert_uint_equal(arraylist_capacity(arr), 128);
+    
+    arraylist_destroy(&arr);
+}
+
+static void test_resize_decrease_capacity(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    assert_uint_equal(arraylist_resize(arr, 32), ARRLIST_OK);
+    assert_uint_equal(arraylist_capacity(arr), 32);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_resize_to_zero(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    assert_uint_equal(arraylist_resize(arr, 0), ARRLIST_INVALID_CAPACITY);
+    assert_uint_equal(arraylist_capacity(arr), 64);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_resize_to_size_max(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    assert_uint_equal(arraylist_resize(arr, SIZE_MAX), ARRLIST_ALLOC_OVERFLOW);
+    assert_uint_equal(arraylist_capacity(arr), 64);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_resize_null_array(void **state) {
+    (void) state;
+
+    ArrayList *arr = NULL;
+
+    assert_uint_equal(arraylist_resize(arr, 65), ARRLIST_NULL_ARG);
+}
+
+// Reserve
+static void test_reserve_normal_capacity(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    assert_uint_equal(arraylist_reserve(arr, 32), ARRLIST_OK);
+    assert_uint_equal(arraylist_capacity(arr), 96);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_reserve_size_max(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    assert_uint_equal(arraylist_reserve(arr, SIZE_MAX), ARRLIST_ALLOC_OVERFLOW);
+    assert_uint_equal(arraylist_capacity(arr), 64);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_reserve_size_0(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    assert_uint_equal(arraylist_reserve(arr, 0), ARRLIST_OK);
+    assert_uint_equal(arraylist_capacity(arr), 64);
+
+    arraylist_destroy(&arr);
+}
+
 int main(void) {
     const struct CMUnitTest init[] = {
         cmocka_unit_test(test_init_valid_parameters),
@@ -974,6 +1105,26 @@ int main(void) {
         cmocka_unit_test(test_set_null_data),
     };
 
+    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),
+    };
+
+    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),
+    };
+
+    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),
+    };
+
     int rc = 0;
 
     rc += cmocka_run_group_tests(init, NULL, NULL);
@@ -987,6 +1138,9 @@ int main(void) {
     rc += cmocka_run_group_tests(remove_at, NULL, NULL);
     rc += cmocka_run_group_tests(get, NULL, NULL);
     rc += cmocka_run_group_tests(set, NULL, NULL);
+    rc += cmocka_run_group_tests(clear, NULL, NULL);
+    rc += cmocka_run_group_tests(resize, NULL, NULL);
+    rc += cmocka_run_group_tests(reserve, NULL, NULL);
 
     return rc;
 }