dynamic_array/src/test_dynamic_array.c

#include "unity.h"

#include "dynamic_array.h"


void setUp() {
}

void tearDown() {
}


void test_array_create_without_options(void) {
    const Array *array = array_create(NULL);
    TEST_ASSERT_EQUAL(DYNAMIC_ARRAY_DEFAULT_ARRAY_SIZE, array->capacity);
}


void test_array_create_with_options(void) {
    const int EXPECTED_CAPACITY = 20;

    const Array *array = array_create(&(ArrayCreateOptions){
        .initial_size = EXPECTED_CAPACITY
    });
    TEST_ASSERT_EQUAL(EXPECTED_CAPACITY, array->capacity);
}


void test_array_deconstruct(void) {
    Array *array = array_create(NULL);
    array_deconstructor(&array);
    TEST_ASSERT_NULL(array);
}


void test_array_resize_expand(void) {
    Array *array = array_create(NULL);
    const size_t ORIGINAL_CAPACITY = array->capacity;
    const int NEW_CAPACITY = 30;

    array_resize(array, NEW_CAPACITY);

    TEST_ASSERT_EQUAL(NEW_CAPACITY, array->capacity);
    TEST_ASSERT_GREATER_THAN(ORIGINAL_CAPACITY, array->capacity);

    array_deconstructor(&array);
}


void test_array_resize_shrink(void) {
    Array *array = array_create(&(ArrayCreateOptions){.initial_size = 50, .element_size = sizeof(int)});
    const int NEW_CAPACITY = 20;

    array_resize(array, NEW_CAPACITY);

    TEST_ASSERT_EQUAL(NEW_CAPACITY, array->capacity);

    array_deconstructor(&array);
}


void test_array_set_value_within_capacity(void) {
    Array *p_array = array_create(NULL);
    const int INDEX = 5;
    const int EXPECTED_VALUE = 42;

    array_set_value(p_array, INDEX, &EXPECTED_VALUE);

    const int VALUE = *(int*)array_get_value(p_array, INDEX);

    TEST_ASSERT_EQUAL(EXPECTED_VALUE, VALUE);

    array_deconstructor(&p_array);
}


void test_array_set_value_beyond_capacity(void) {
    Array *p_array = array_create(NULL);
    const int INDEX = 50;
    const int EXPECTED_VALUE = 99;
    const size_t ORIGINAL_CAPACITY = p_array->capacity;

    array_set_value(p_array, INDEX, &EXPECTED_VALUE);

    const int VALUE = *(int*)array_get_value(p_array, INDEX);

    TEST_ASSERT_GREATER_THAN(ORIGINAL_CAPACITY, p_array->capacity);
    TEST_ASSERT_EQUAL(EXPECTED_VALUE, VALUE);

    array_deconstructor(&p_array);
}


void test_array_get_value_valid_index(void) {
    Array *p_array = array_create(NULL);
    const int INDEX = 3;
    const int EXPECTED_VALUE = 77;

    array_set_value(p_array, INDEX, &EXPECTED_VALUE);
    const int *result = array_get_value(p_array, INDEX);

    TEST_ASSERT_NOT_NULL(result);
    TEST_ASSERT_EQUAL(EXPECTED_VALUE, *result);

    array_deconstructor(&p_array);
}


void test_array_get_value_zero_index(void) {
    Array *array = array_create(NULL);
    const int VALUE = 100;

    array_set_value(array, 0, &VALUE);
    const int *result = array_get_value(array, 0);

    TEST_ASSERT_NOT_NULL(result);
    TEST_ASSERT_EQUAL(VALUE, *result);

    array_deconstructor(&array);
}


void test_array_get_value_beyond_capacity(void) {
    Array *array = array_create(NULL);

    const int *result = array_get_value(array, array->capacity + 1);

    TEST_ASSERT_NULL(result);

    array_deconstructor(&array);
}


void test_array_multiple_operations(void) {
    Array *array = array_create(&(ArrayCreateOptions){.initial_size = 5, .element_size = sizeof(int)});

    const int VALUE = 42;

    array_set_value(array, 0, &VALUE);
    TEST_ASSERT_EQUAL(VALUE, *(int *)array_get_value(array, 0));

    array_set_value(array, 1, &VALUE);
    TEST_ASSERT_EQUAL(VALUE, *(int *)array_get_value(array, 1));

    array_set_value(array, 2, &VALUE);
    TEST_ASSERT_EQUAL(VALUE, *(int *)array_get_value(array, 2));

    array_set_value(array, 10, &VALUE);
    TEST_ASSERT_EQUAL(VALUE, *(int *)array_get_value(array, 10));

    array_deconstructor(&array);
}


void test_array_get_capacity_default(void) {
    Array *array = array_create(NULL);

    const size_t capacity = array_get_capacity(array);

    TEST_ASSERT_EQUAL(DYNAMIC_ARRAY_DEFAULT_ARRAY_SIZE, capacity);

    array_deconstructor(&array);
}


void test_array_get_capacity_custom_size(void) {
    const int EXPECTED_CAPACITY = 25;
    Array *array = array_create(&(ArrayCreateOptions){.initial_size = EXPECTED_CAPACITY});

    const size_t capacity = array_get_capacity(array);

    TEST_ASSERT_EQUAL(EXPECTED_CAPACITY, capacity);

    array_deconstructor(&array);
}


void test_array_get_capacity_after_resize(void) {
    Array *array = array_create(NULL);
    const size_t ORIGINAL_CAPACITY = array_get_capacity(array);
    const size_t NEW_CAPACITY = 50;

    array_resize(array, NEW_CAPACITY);
    const size_t capacity = array_get_capacity(array);

    TEST_ASSERT_EQUAL(NEW_CAPACITY, capacity);
    TEST_ASSERT_NOT_EQUAL(ORIGINAL_CAPACITY, capacity);

    array_deconstructor(&array);
}


void test_array_get_size_initial(void) {
    Array *array = array_create(NULL);

    const size_t size = array_get_size(array);

    TEST_ASSERT_EQUAL(0, size);

    array_deconstructor(&array);
}


void test_array_get_size_after_single_set(void) {
    Array *array = array_create(NULL);

    const int VALUE = 42;

    array_set_value(array, 0, &VALUE);
    const size_t size = array_get_size(array);

    TEST_ASSERT_EQUAL(1, size);

    array_deconstructor(&array);
}


void test_array_get_size_after_multiple_sets(void) {
    Array *array = array_create(NULL);

    const int VALUE = 42;

    array_set_value(array, 0, &VALUE);
    array_set_value(array, 1, &VALUE);
    array_set_value(array, 2, &VALUE);
    const size_t size = array_get_size(array);

    TEST_ASSERT_EQUAL(3, size);

    array_deconstructor(&array);
}


void test_array_get_size_with_gap_in_indices(void) {
    Array *array = array_create(NULL);

    const int VALUE = 42;

    array_set_value(array, 0, &VALUE);
    array_set_value(array, 5, &VALUE);
    const size_t size = array_get_size(array);

    TEST_ASSERT_EQUAL(6, size);

    array_deconstructor(&array);
}


void test_array_get_size_capacity_relationship(void) {
    Array *array = array_create(&(ArrayCreateOptions){.initial_size = 10});

    const int VALUE = 42;

    array_set_value(array, 0, &VALUE);
    array_set_value(array, 1, &VALUE);
    array_set_value(array, 2, &VALUE);

    const size_t size = array_get_size(array);
    const size_t capacity = array_get_capacity(array);

    TEST_ASSERT_LESS_OR_EQUAL(capacity, size);
    TEST_ASSERT_EQUAL(3, size);
    TEST_ASSERT_EQUAL(10, capacity);

    array_deconstructor(&array);
}


void test_array_get_size_after_resize_beyond_capacity(void) {
    Array *array = array_create(&(ArrayCreateOptions){.initial_size = 5, .element_size = sizeof(int)});

    const int VALUE = 42;

    array_set_value(array,  0, &VALUE);
    array_set_value(array, 15, &VALUE);
    const size_t size = array_get_size(array);
    const size_t capacity = array_get_capacity(array);

    TEST_ASSERT_EQUAL(16, size);
    TEST_ASSERT_LESS_OR_EQUAL(capacity, size);

    array_deconstructor(&array);
}


void test_array_get_value_as(void) {
    Array *p_array = array_create(&(ArrayCreateOptions){
        .initial_size = 5,
        .element_size = sizeof(int)
    });
    const int VALUE = 42;

    array_set_value(p_array, 0, &VALUE);

    const int *value = array_get_value_as(int, p_array, 0);

    TEST_ASSERT_EQUAL(VALUE, *value);
}


void test_array_get_value_as_invalid_type(void) {
    Array *p_array = array_create(&(ArrayCreateOptions){
        .initial_size = 5,
        .element_size = sizeof(int)
    });
    const int VALUE = 42;

    array_set_value(p_array, 0, &VALUE);

    const void *value = array_get_value_as(double, p_array, 0);

    TEST_ASSERT_NULL(value);
}


void test_array_set_value_as(void) {
    Array *p_array = array_create(&(ArrayCreateOptions){
        .initial_size = 5,
        .element_size = sizeof(double)
    });

    const double VALUE = 42;

    const int result = array_set_value_as(double, p_array, 0, &VALUE);
    TEST_ASSERT_EQUAL(result, 0);
}


void test_array_set_value_as_invalid_type(void) {
    Array *p_array = array_create(&(ArrayCreateOptions){
        .initial_size = 5,
        .element_size = sizeof(double)
    });

    const int VALUE = 42;

    const int result = array_set_value_as(double, p_array, 0, &VALUE);
    TEST_ASSERT_EQUAL(result, 0);
}


void test_adding_elements(void) {
    typedef struct {
        int value;
    } Element;

    Array *p_array = array_create(&(ArrayCreateOptions){
        .initial_size = 10,
        .element_size = sizeof(Element)
    });

    const int number_of_elements = 1000;

    for (int index = 0; index < number_of_elements; index++) {
        Element element = { index };
        const int result = array_set_value_as(Element, p_array, index, &element);
        TEST_ASSERT_EQUAL(result, 0);
    }

    TEST_ASSERT_EQUAL(array_get_size(p_array), number_of_elements);
}


int main(void)
{
    UNITY_BEGIN();

    RUN_TEST(test_array_create_without_options);
    RUN_TEST(test_array_create_with_options);
    RUN_TEST(test_array_deconstruct);
    RUN_TEST(test_array_resize_expand);
    RUN_TEST(test_array_resize_shrink);
    RUN_TEST(test_array_set_value_within_capacity);
    RUN_TEST(test_array_set_value_beyond_capacity);
    RUN_TEST(test_array_get_value_valid_index);
    RUN_TEST(test_array_get_value_zero_index);
    RUN_TEST(test_array_get_value_beyond_capacity);
    RUN_TEST(test_array_multiple_operations);
    RUN_TEST(test_array_get_capacity_default);
    RUN_TEST(test_array_get_capacity_custom_size);
    RUN_TEST(test_array_get_capacity_after_resize);
    RUN_TEST(test_array_get_size_initial);
    RUN_TEST(test_array_get_size_after_single_set);
    RUN_TEST(test_array_get_size_after_multiple_sets);
    RUN_TEST(test_array_get_size_with_gap_in_indices);
    RUN_TEST(test_array_get_size_capacity_relationship);
    RUN_TEST(test_array_get_size_after_resize_beyond_capacity);
    RUN_TEST(test_array_get_value_as);
    RUN_TEST(test_array_get_value_as_invalid_type);
    RUN_TEST(test_array_set_value_as);
    RUN_TEST(test_array_set_value_as_invalid_type);
    RUN_TEST(test_adding_elements);

    return UNITY_END();
}