test/test_arraylist.c

@@ -80,6 +80,26 @@ static void test_destroy_double(void **state) {
     assert_null(arr);
 }
 
+static void test_destroy_while_borrowed(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
+    assert_non_null(slice);
+
+
+    assert_uint_equal(arraylist_destroy(&arr), ARRLIST_IS_BORROWED);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
 // State
 static void test_capacity_after_init(void **state) {
     (void) state;
@@ -254,6 +274,26 @@ static void test_push_back_null_data(void **state) {
     arraylist_destroy(&arr);
 }
 
+static void test_push_back_while_borrowed(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
+    assert_non_null(slice);
+
+    int n = 8;
+    assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_IS_BORROWED);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
 // Push front
 static void test_push_front_single_element(void **state) {
     (void) state;
@@ -311,6 +351,26 @@ static void test_push_front_null_data(void **state) {
     arraylist_destroy(&arr);
 }
 
+static void test_push_front_while_borrowed(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
+    assert_non_null(slice);
+
+    int n = 8;
+    assert_uint_equal(arraylist_push_front(arr, &n), ARRLIST_IS_BORROWED);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
 // Insert
 static void test_insert_at_beginning(void **state) {
     (void) state;
@@ -409,6 +469,26 @@ static void test_insert_null_data(void **state) {
     arraylist_destroy(&arr);
 }
 
+static void test_insert_while_borrowed(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
+    assert_non_null(slice);
+
+    int n = 8;
+    assert_uint_equal(arraylist_insert(arr, 2, &n), ARRLIST_IS_BORROWED);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
 // Pop back
 static void test_pop_back_single_element(void **state) {
     (void) state;
@@ -504,6 +584,26 @@ static void test_pop_back_null_out(void **state) {
     arraylist_destroy(&arr);
 }
 
+static void test_pop_back_while_borrowed(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
+    assert_non_null(slice);
+
+    int n = 8;
+    assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_IS_BORROWED);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
 // Pop front
 static void test_pop_front_single_element(void **state) {
     (void) state;
@@ -601,6 +701,26 @@ static void test_pop_front_null_out(void **state) {
     arraylist_destroy(&arr);
 }
 
+static void test_pop_front_while_borrowed(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
+    assert_non_null(slice);
+
+    int n = 8;
+    assert_uint_equal(arraylist_pop_front(arr, &n), ARRLIST_IS_BORROWED);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
 // Remove at
 static void test_remove_at_beginning(void **state) {
     (void) state;
@@ -695,6 +815,26 @@ static void test_remove_at_null_data(void **state) {
     arraylist_destroy(&arr);
 }
 
+static void test_remove_at_while_borrowed(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
+    assert_non_null(slice);
+
+    int n = 8;
+    assert_uint_equal(arraylist_remove_at(arr, 5, &n), ARRLIST_IS_BORROWED);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
 // Get
 static void test_get_valid_index(void **state) {
     (void) state;
@@ -788,6 +928,26 @@ static void test_get_null_out(void **state) {
     arraylist_destroy(&arr);
 }
 
+static void test_get_while_borrowed(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
+    assert_non_null(slice);
+
+    int n = 8;
+    assert_uint_equal(arraylist_get(arr, 5, &n), ARRLIST_OK);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
 // Set
 static void test_set_valid_index(void **state) {
     (void) state;
@@ -883,6 +1043,26 @@ static void test_set_null_data(void **state) {
     arraylist_destroy(&arr);
 }
 
+static void test_set_while_borrowed(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
+    assert_non_null(slice);
+
+    int n = 8;
+    assert_uint_equal(arraylist_set(arr, 5, &n), ARRLIST_OK);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
 //Clear
 static void test_clear_non_empty_array(void **state) {
     (void) state;
@@ -920,6 +1100,25 @@ static void test_clear_null_array(void **state) {
     assert_uint_equal(arraylist_clear(arr), ARRLIST_NULL_ARG);
 }
 
+static void test_clear_while_borrowed(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
+    assert_non_null(slice);
+
+    assert_uint_equal(arraylist_clear(arr), ARRLIST_IS_BORROWED);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
 //Resize
 static void test_resize_increase_capacity(void **state) {
     (void) state;
@@ -977,6 +1176,25 @@ static void test_resize_null_array(void **state) {
     assert_uint_equal(arraylist_resize(arr, 65), ARRLIST_NULL_ARG);
 }
 
+static void test_resize_while_borrowed(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
+    assert_non_null(slice);
+
+    assert_uint_equal(arraylist_resize(arr, 128), ARRLIST_IS_BORROWED);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
 // Reserve
 static void test_reserve_normal_capacity(void **state) {
     (void) state;
@@ -1014,6 +1232,25 @@ static void test_reserve_size_0(void **state) {
     arraylist_destroy(&arr);
 }
 
+static void test_reserve_while_borrowed(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+    for (int i = 0; i < 10; i++) {
+        assert_uint_equal(arraylist_push_back(arr, &i), ARRLIST_OK);
+    }
+
+    ArraySlice *slice = arraylist_slice(arr, 0, arraylist_size(arr));
+    assert_non_null(slice);
+
+    assert_uint_equal(arraylist_reserve(arr, 128), ARRLIST_IS_BORROWED);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
 // Slice creation
 static void test_slice_valid_init(void **state) {
     (void) state;
@@ -1044,6 +1281,7 @@ int main(void) {
         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[] = {
@@ -1060,6 +1298,7 @@ int main(void) {
         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[] = {
@@ -1067,6 +1306,7 @@ int main(void) {
         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[] = {
@@ -1076,6 +1316,7 @@ int main(void) {
         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[] = {
@@ -1085,6 +1326,7 @@ int main(void) {
         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[] = {
@@ -1094,6 +1336,7 @@ int main(void) {
         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[] = {
@@ -1103,6 +1346,7 @@ int main(void) {
         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[] = {
@@ -1112,6 +1356,7 @@ int main(void) {
         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[] = {
@@ -1121,12 +1366,14 @@ int main(void) {
         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 resize[] = {
@@ -1135,12 +1382,14 @@ int main(void) {
         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 slice_init[] = {