test: tests for arrayslice to aray done

include/arraylist.h

@@ -19,12 +19,13 @@ typedef enum {
     ARRLIST_INVALID_ELEM_SIZE,
     ARRLIST_INVALID_CAPACITY,
     ARRLIST_IS_BORROWED,
+    ARRLIST_INVALID_SLICE,
 } ArrayListErr;
 
 ArrayList *arraylist_init(size_t capacity, size_t elem_size);
 ArrayListErr arraylist_destroy(ArrayList **arr);
 ArrayListErr arraylist_clear(ArrayList *arr);
-ArrayList *arraylist_copy(const ArrayList *arr);
+ArrayList *arraylist_clone(const ArrayList *arr);
 
 size_t arraylist_size(const ArrayList *arr);
 size_t arraylist_capacity(const ArrayList *arr);
@@ -52,16 +53,14 @@ ArrayListErr arrayslice_destroy(ArraySlice **slice);
 
 bool arrayslice_is_valid(const ArraySlice *slice);
 size_t arrayslice_size(const ArraySlice *slice);
-bool arrayslice_empty(const ArraySlice *slice);
 
 // peek and next can be null, get can't, like, why would you use get without
 // actually getting something?, for validating an index?, use size idiot
-ArrayListErr *arrayslice_peek(const ArraySlice *slice, void *out);
-ArrayListErr *arrayslice_next(ArraySlice *slice, void *out);
-ArrayListErr *arrayslice_get(const ArraySlice *slice, void *out);
+ArrayListErr arrayslice_peek(const ArraySlice *slice, void *out);
+ArrayListErr arrayslice_next(ArraySlice *slice, void *out);
 
-ArrayListErr *arrayslice_reset(ArraySlice *slice);
-ArrayListErr *arrayslice_advance(ArraySlice *slice, size_t n);
+ArrayListErr arrayslice_reset(ArraySlice *slice);
+ArrayListErr arrayslice_advance(ArraySlice *slice, size_t n);
 
 ArrayList *arrayslice_to_arraylist(const ArraySlice *slice);
 

src/arraylist.c

@@ -506,3 +506,101 @@ ArrayListErr arrayslice_destroy(ArraySlice **slice) {
 
     return ARRLIST_OK;
 }
+
+bool arrayslice_is_valid(const ArraySlice *slice) {
+    if (slice == NULL) {
+        return false;
+    }
+
+    return slice->current != slice->end;
+}
+
+size_t arrayslice_size(const ArraySlice *slice) {
+    if (slice == NULL) {
+        return 0;
+    }
+
+    return slice->end - slice->start;
+}
+
+ArrayListErr arrayslice_peek(const ArraySlice *slice, void *out) {
+    if (slice == NULL || out == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (slice->current >= slice->end) {
+        return ARRLIST_INVALID_SLICE;
+    }
+
+    arraylist_get(slice->arr, slice->current, out);
+
+    return ARRLIST_OK;
+}
+
+ArrayListErr arrayslice_next(ArraySlice *slice, void *out) {
+    // HERE, it makes sense that you want to advance to the next
+    // without actually getting the value so it's good
+    if (slice == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (slice->current == slice->end) {
+        return ARRLIST_INVALID_SLICE;
+    }
+
+    arraylist_get(slice->arr, slice->current, out);
+
+    slice->current++;
+    return ARRLIST_OK;
+}
+
+ArrayListErr arrayslice_reset(ArraySlice *slice) {
+    if (slice == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    slice->current = slice->start;
+
+    return ARRLIST_OK;
+}
+
+ArrayListErr arrayslice_advance(ArraySlice *slice, size_t n) {
+    if (slice == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (n > SIZE_MAX - slice->current || slice->current + n > slice->end) {
+        return ARRLIST_OUT_OF_BOUNDS;
+    }
+    
+    slice->current += n;
+
+    return ARRLIST_OK;
+}
+
+ArrayList *arrayslice_to_arraylist(const ArraySlice *slice) {
+    if (slice == NULL || slice->arr == NULL) {
+        return NULL;
+    }
+
+    if (slice->start >= slice->end) {
+        return NULL;
+    }
+
+    size_t len = slice->end - slice->start;
+
+    ArrayList *new_arr = arraylist_init(arraylist_capacity(slice->arr), slice->arr->elem_size);
+    if (new_arr == NULL) {
+        return NULL;
+    }
+
+    memcpy(
+        new_arr->buffer,
+        slice->arr->buffer + (slice->start * slice->arr->elem_size),
+        slice->arr->elem_size * len
+    );
+
+    new_arr->len = len;
+
+    return new_arr;
+}

test/test_arraylist.c

@@ -1339,6 +1339,475 @@ static void test_slice_null_arr(void **state) {
     assert_null(slice);
 }
 
+// Slice Unsafe
+static void test_slice_unsafe_valid_init(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);
+    }
+
+    ArraySlice *slice = arraylist_slice(arr, 0, 10);
+    assert_non_null(slice);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
+static void test_slice_unsafe_invalid_index(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);
+    }
+
+    ArraySlice *slice = arraylist_slice(arr, 32, 10);
+    assert_null(slice);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_slice_unsafe_invalid_len(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);
+    }
+
+    ArraySlice *slice = arraylist_slice(arr, 0, 300);
+    assert_null(slice);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_slice_unsafe_len_zero(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);
+    }
+
+    ArraySlice *slice = arraylist_slice(arr, 0, 0);
+    assert_null(slice);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_slice_unsafe_empty_array(void **state) {
+    (void) state;
+
+    ArrayList *arr = arraylist_init(64, sizeof(int));
+    assert_non_null(arr);
+
+
+    ArraySlice *slice = arraylist_slice(arr, 0, 10);
+    assert_null(slice);
+
+    arraylist_destroy(&arr);
+}
+
+static void test_slice_unsafe_null_arr(void **state) {
+    (void) state;
+
+    ArrayList *arr = NULL;
+
+    ArraySlice *slice = arraylist_slice(arr, 0, 10);
+    assert_null(slice);
+}
+
+// Slice Destroy
+static void test_slice_destroy_valid(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(arrayslice_destroy(&slice), ARRLIST_OK);
+    arraylist_destroy(&arr);
+}
+
+static void test_slice_destroy_null_slice(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 = NULL;
+
+    assert_uint_equal(arrayslice_destroy(&slice), ARRLIST_NULL_ARG);
+    arraylist_destroy(&arr);
+}
+
+static void test_slice_double_destroy(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(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;
+
+    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 m;
+    assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_OK);
+    assert_int_equal(m, 0);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
+static void test_slice_peek_invalid_array(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(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);
+}
+
+static void test_slice_peek_null_out(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(arrayslice_peek(slice, NULL), ARRLIST_NULL_ARG);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
+static void test_slice_peek_null_slice(void **state) {
+    (void) state;
+
+    ArraySlice *slice = NULL;
+
+    int m;
+    assert_uint_equal(arrayslice_peek(slice, &m), ARRLIST_NULL_ARG);
+    assert_int_equal(m, 0);
+}
+
+// Slice next
+static void test_slice_next_valid_array(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 m;
+    assert_uint_equal(arrayslice_next(slice, &m), ARRLIST_OK);
+    assert_int_equal(m, 0);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
+static void test_slice_next_invalid_array(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(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);
+}
+
+static void test_slice_next_null_out(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(arrayslice_next(slice, NULL), ARRLIST_OK);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
+static void test_slice_next_null_slice(void **state) {
+    (void) state;
+
+    ArraySlice *slice = NULL;
+
+    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) {
+    (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 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);
+}
+
+//Slice reset
+static void test_slice_reset_valid_slice(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 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);
+
+    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);
+}
+
+static void test_slice_reset_null_slice(void **state) {
+    (void) state;
+
+    ArraySlice *slice = NULL;
+
+    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;
+
+    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 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);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
+static void test_slice_advance_out_of_bounds(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 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);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
+static void test_slice_advance_size_max(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 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);
+
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
+static void test_slice_advance_null_array(void **state) {
+    (void) state;
+
+    ArraySlice *slice = NULL;
+
+    assert_uint_equal(arrayslice_advance(slice, 56), ARRLIST_NULL_ARG);
+}
+
+//Slice to Array
+static void test_slice_to_array_valid(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);
+
+    ArrayList *arr2 = arrayslice_to_arraylist(slice);
+    assert_non_null(arr2);
+    assert_uint_equal(arraylist_capacity(arr2), 64);
+    assert_uint_equal(arraylist_size(arr2), 10);
+
+    arraylist_destroy(&arr2);
+    arrayslice_destroy(&slice);
+    arraylist_destroy(&arr);
+}
+
+static void test_slice_to_array_null_slice(void **state) {
+    (void) state;
+
+    ArraySlice *slice = NULL;
+
+    assert_null(arrayslice_to_arraylist(slice));
+}
+
 int main(void) {
     const struct CMUnitTest init[] = {
         cmocka_unit_test(test_init_valid_parameters),
@@ -1471,6 +1940,53 @@ int main(void) {
         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_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_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_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),
+    };
+
     int rc = 0;
 
     rc += cmocka_run_group_tests(init, NULL, NULL);
@@ -1489,6 +2005,13 @@ int main(void) {
     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);
 
     return rc;
 }