HideyoshiNakazone/dynamic_array
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: update CMake configuration and add clang-format file
Some checks failed
CI / build (pull_request) Failing after 1m24s
Details

Browse Source
This commit is contained in:
Vitor Hideyoshi
2026-04-15 18:02:24 -03:00
parent 7940c4a86e
commit c4e7627d1f
5 changed files with 171 additions and 451 deletions
Download Patch File Download Diff File Expand all files Collapse all files

430
src/test_dynamic_array.c
View File

@@ -3,361 +3,142 @@
#include "dynamic_array.h"
void setUp() {
}
void setUp(void) {}
void tearDown() {
}
void tearDown(void) {}
void test_array_create_without_options(void) {
const Array *array = array_create(NULL);
TEST_ASSERT_EQUAL(DYNAMIC_ARRAY_DEFAULT_ARRAY_SIZE, array->capacity);
int *arr = NULL;
array_create(arr);
const ArrayHeader *header = array_get_header(arr);
TEST_ASSERT_EQUAL(DYNAMIC_ARRAY_DEFAULT_ARRAY_SIZE, header->capacity);
array_destroy(arr);
}
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_destroy(void) {
int *arr = NULL;
array_create(arr);
array_destroy(arr);
TEST_ASSERT_NULL(arr);
}
void test_array_deconstruct(void) {
Array *array = array_create(NULL);
array_deconstructor(&array);
TEST_ASSERT_NULL(array);
void test_array_size_initial(void) {
int *arr = NULL;
array_create(arr);
TEST_ASSERT_EQUAL(0, array_get_header(arr)->size);
array_destroy(arr);
}
void test_array_resize_expand(void) {
Array *array = array_create(NULL);
const size_t ORIGINAL_CAPACITY = array->capacity;
const int NEW_CAPACITY = 30;
void test_array_push_value(void) {
int *arr = NULL;
array_create(arr);
array_resize(array, NEW_CAPACITY);
array_push_value(arr, 42);
TEST_ASSERT_EQUAL(NEW_CAPACITY, array->capacity);
TEST_ASSERT_GREATER_THAN(ORIGINAL_CAPACITY, array->capacity);
TEST_ASSERT_EQUAL(42, arr[0]);
TEST_ASSERT_EQUAL(1, array_get_header(arr)->size);
array_deconstructor(&array);
array_destroy(arr);
}
void test_array_resize_shrink(void) {
Array *array = array_create(&(ArrayCreateOptions){.initial_size = 50, .element_size = sizeof(int)});
const int NEW_CAPACITY = 20;
void test_array_push_multiple_values(void) {
int *arr = NULL;
array_create(arr);
array_resize(array, NEW_CAPACITY);
array_push_value(arr, 10);
array_push_value(arr, 20);
array_push_value(arr, 30);
TEST_ASSERT_EQUAL(NEW_CAPACITY, array->capacity);
TEST_ASSERT_EQUAL(10, arr[0]);
TEST_ASSERT_EQUAL(20, arr[1]);
TEST_ASSERT_EQUAL(30, arr[2]);
TEST_ASSERT_EQUAL(3, array_get_header(arr)->size);
array_deconstructor(&array);
array_destroy(arr);
}
void test_array_set_value_within_capacity(void) {
Array *p_array = array_create(NULL);
const int INDEX = 5;
const int EXPECTED_VALUE = 42;
void test_array_pop_decrements_size(void) {
int *arr = NULL;
array_create(arr);
array_set_value(p_array, INDEX, &EXPECTED_VALUE);
array_push_value(arr, 42);
array_push_value(arr, 99);
array_pop(arr);
const int VALUE = *(int*)array_get_value(p_array, INDEX);
TEST_ASSERT_EQUAL(1, array_get_header(arr)->size);
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);
array_destroy(arr);
}
void test_array_get_capacity_default(void) {
Array *array = array_create(NULL);
int *arr = NULL;
array_create(arr);
const size_t capacity = array_get_capacity(array);
TEST_ASSERT_EQUAL(DYNAMIC_ARRAY_DEFAULT_ARRAY_SIZE, array_get_header(arr)->capacity);
TEST_ASSERT_EQUAL(DYNAMIC_ARRAY_DEFAULT_ARRAY_SIZE, capacity);
array_deconstructor(&array);
array_destroy(arr);
}
void test_array_get_capacity_custom_size(void) {
const int EXPECTED_CAPACITY = 25;
Array *array = array_create(&(ArrayCreateOptions){.initial_size = EXPECTED_CAPACITY});
void test_array_size_capacity_relationship(void) {
int *arr = NULL;
array_create(arr);
const size_t capacity = array_get_capacity(array);
array_push_value(arr, 1);
array_push_value(arr, 2);
array_push_value(arr, 3);
TEST_ASSERT_EQUAL(EXPECTED_CAPACITY, capacity);
const ArrayHeader *header = array_get_header(arr);
TEST_ASSERT_EQUAL(3, header->size);
TEST_ASSERT_LESS_OR_EQUAL(header->capacity, header->size);
array_deconstructor(&array);
array_destroy(arr);
}
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;
void test_array_push_beyond_capacity(void) {
int *arr = NULL;
array_create(arr);
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);
const int num_elements = DYNAMIC_ARRAY_DEFAULT_ARRAY_SIZE * 2;
for (int i = 0; i < num_elements; i++) {
array_push_value(arr, i);
}
TEST_ASSERT_EQUAL(array_get_size(p_array), number_of_elements);
const ArrayHeader *header = array_get_header(arr);
TEST_ASSERT_EQUAL(num_elements, header->size);
TEST_ASSERT_GREATER_THAN(DYNAMIC_ARRAY_DEFAULT_ARRAY_SIZE, header->capacity);
array_destroy(arr);
}
void test_array_values_correct_after_growth(void) {
int *arr = NULL;
array_create(arr);
const int num_elements = 1000;
for (int i = 0; i < num_elements; i++) {
array_push_value(arr, i);
}
TEST_ASSERT_EQUAL(num_elements, array_get_header(arr)->size);
for (int i = 0; i < num_elements; i++) {
TEST_ASSERT_EQUAL(i, arr[i]);
}
array_destroy(arr);
}
@@ -366,30 +147,15 @@ 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_destroy);
RUN_TEST(test_array_size_initial);
RUN_TEST(test_array_push_value);
RUN_TEST(test_array_push_multiple_values);
RUN_TEST(test_array_pop_decrements_size);
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);
RUN_TEST(test_array_size_capacity_relationship);
RUN_TEST(test_array_push_beyond_capacity);
RUN_TEST(test_array_values_correct_after_growth);
return UNITY_END();
}