scufcont/tests/cmocka/DArray_tests.c

#include <cmocka.h>
#include <stdlib.h>
#include <time.h>

#include "scufcont/DArray.h"
#include "scufcont/scufcont.h"

SCDARRAY_HEADER(int, int);
SCDARRAY_IMPL(int, int)

void test_DArray_alloc(void **state) {
    (void) state;

    SCDArray_int arr;
    assert_true(SCDArray_int_alloc(&arr, NULL) == SCUFCONT_SUCCESS);
    assert_non_null(arr.data);
    assert_uint_equal(arr.len, 0u);
    assert_uint_equal(arr.capacity, 1u);

    SCDArray_int_free(&arr);
}

void test_DArray_alloc_copy(void **state) {
    (void) state;

    srand(time(NULL));

    SCDArray_int arr;
    assert_true(SCDArray_int_alloc(&arr, NULL) == SCUFCONT_SUCCESS);

    const size_t elems_n = rand() % 100;
    for (size_t i = 0; i < elems_n; i++) {
        const int elem = rand();
        assert_true(SCDArray_int_push_back(&arr, &elem) == SCUFCONT_SUCCESS);
    }

    SCDArray_int copied;
    assert_true(SCDArray_int_alloc_copy(&copied, &arr) == SCUFCONT_SUCCESS);
    assert_non_null(copied.data);
    assert_uint_equal(copied.capacity, arr.capacity);
    assert_uint_equal(copied.len, arr.len);
    assert_memory_equal(copied.data, arr.data, copied.len);

    SCDArray_int_free(&arr);
    SCDArray_int_free(&copied);
}

void test_DArray_push_back(void **state) {
    (void) state;

    SCDArray_int arr;
    SCDArray_int_alloc(&arr, NULL);

    assert_true(SCDArray_int_push_back(&arr, &(int) { 7 }) == SCUFCONT_SUCCESS);
    assert_true(arr.data[0] == 7);

    assert_true(SCDArray_int_push_back(&arr, &(int) { 10 }) == SCUFCONT_SUCCESS);
    assert_true(arr.data[0] == 7);
    assert_true(arr.data[1] == 10);

    SCDArray_int_free(&arr);
}

void test_DArray_at(void **state) {
    (void) state;

    SCDArray_int arr;
    SCDArray_int_alloc(&arr, NULL);

    assert_true(SCDArray_int_push_back(&arr, &(int) { 7 }) == SCUFCONT_SUCCESS);
    assert_int_equal(*SCDArray_int_at(&arr, 0), 7);

    assert_true(SCDArray_int_push_back(&arr, &(int) { 10 }) == SCUFCONT_SUCCESS);
    assert_int_equal(*SCDArray_int_at(&arr, 0), 7);
    assert_int_equal(*SCDArray_int_at(&arr, 1), 10);

    SCDArray_int_free(&arr);
}

void test_DArray_push_back_multiple(void **state) {
    (void) state;

    SCDArray_int arr;
    SCDArray_int_alloc(&arr, NULL);

    int nums[] = { 1, 2, 3, 4, 5 };
    const size_t nums_len = sizeof(nums) / sizeof(nums[0]);
    assert_true(SCDArray_int_push_back_multiple(&arr, nums, sizeof(nums) / sizeof(nums[0])) == SCUFCONT_SUCCESS);
    for (size_t i = 0; i < arr.len; i++) {
        assert_int_equal(*SCDArray_int_at(&arr, i), nums[i]);
    }
    int nums2[] = { 6, 7, 8 };
    const size_t nums2_len = sizeof(nums2) / sizeof(nums2[0]);
    assert_true(SCDArray_int_push_back_multiple(&arr, nums2, sizeof(nums2) / sizeof(nums2[0])) == SCUFCONT_SUCCESS);
    for (size_t i = 0; i < nums_len; i++) {
        assert_int_equal(*SCDArray_int_at(&arr, i), nums[i]);
    }
    for (size_t i = 0; i < nums2_len; i++) {
        assert_int_equal(*SCDArray_int_at(&arr, i + nums_len), nums2[i]);
    }

    SCDArray_int_free(&arr);
}

void test_DArray_remove(void **state) {
    (void) state;

    SCDArray_int arr;
    SCDArray_int_alloc(&arr, NULL);

    int nums[] = { 1, 2, 3, 4, 5 };
    SCDArray_int_push_back_multiple(&arr, nums, sizeof(nums) / sizeof(nums[0]));
    for (size_t i = 0; i < arr.len; i++) {
        assert_int_equal(*SCDArray_int_at(&arr, i), nums[i]);
    }

    // Remove last
    {
        const size_t old_len = arr.len;
        SCDArray_int_remove(&arr, arr.len - 1);
        assert_uint_equal(arr.len, old_len - 1);
        int new_nums[] = { 1, 2, 3, 4 };
        assert_uint_equal(arr.len, sizeof(new_nums) / sizeof(new_nums[0]));
        for (size_t i = 0; i < arr.len; i++) {
            assert_int_equal(*SCDArray_int_at(&arr, i), new_nums[i]);
        }
    }

    // Remove from middle
    {
        const size_t old_len = arr.len;
        SCDArray_int_remove(&arr, 1);
        assert_uint_equal(arr.len, old_len - 1);
        int new_nums[] = { 1, 3, 4 };
        assert_uint_equal(arr.len, sizeof(new_nums) / sizeof(new_nums[0]));
        for (size_t i = 0; i < arr.len; i++) {
            assert_int_equal(*SCDArray_int_at(&arr, i), new_nums[i]);
        }
    }

    // Remove first
    {
        const size_t old_len = arr.len;
        SCDArray_int_remove(&arr, 0);
        assert_uint_equal(arr.len, old_len - 1);
        int new_nums[] = { 3, 4 };
        assert_uint_equal(arr.len, sizeof(new_nums) / sizeof(new_nums[0]));
        for (size_t i = 0; i < arr.len; i++) {
            assert_int_equal(*SCDArray_int_at(&arr, i), new_nums[i]);
        }
    }

    SCDArray_int_free(&arr);
}

void test_DArray_clear(void **state) {
    (void) state;

    SCDArray_int arr;
    SCDArray_int_alloc(&arr, NULL);

    for (int i = 1; i <= 10; i++) {
        SCDArray_int_push_back(&arr, &i);
    }

    assert_uint_equal(arr.len, 10);
    for (int i = 0; i < 10; i++) {
        const int *const n = SCDArray_int_at(&arr, i);
        assert_int_equal(*n, i + 1);
    }

    SCDArray_int_clear(&arr);
    assert_uint_equal(arr.len, 0);
}

int DArray_tests_run(void) {
    const struct CMUnitTest tests[] = {
        cmocka_unit_test(test_DArray_alloc),
        cmocka_unit_test(test_DArray_alloc_copy),
        cmocka_unit_test(test_DArray_push_back),
        cmocka_unit_test(test_DArray_at),
        cmocka_unit_test(test_DArray_push_back_multiple),
        cmocka_unit_test(test_DArray_remove),
        cmocka_unit_test(test_DArray_clear)
    };

    return cmocka_run_group_tests_name("DArray", tests, NULL, NULL);
}