296 lines
7.4 KiB
C
296 lines
7.4 KiB
C
#include <stdalign.h>
|
|
#include <stdarg.h>
|
|
#include <stdbool.h>
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
#include <setjmp.h>
|
|
#include <cmocka.h>
|
|
#include <string.h>
|
|
|
|
#include "arraylist.h"
|
|
|
|
// INIT
|
|
|
|
static void test_init_valid_parameters(void **state) {
|
|
(void) state;
|
|
|
|
ArrayList *arr = arraylist_init(64, sizeof(int));
|
|
assert_non_null(arr);
|
|
arraylist_destroy(&arr);
|
|
}
|
|
|
|
static void test_init_zero_capacity(void **state) {
|
|
(void) state;
|
|
|
|
ArrayList *arr = arraylist_init(0, sizeof(int));
|
|
assert_null(arr);
|
|
arraylist_destroy(&arr);
|
|
}
|
|
|
|
static void test_init_zero_elem_size(void **state) {
|
|
(void) state;
|
|
|
|
ArrayList *arr = arraylist_init(64, 0);
|
|
assert_null(arr);
|
|
arraylist_destroy(&arr);
|
|
}
|
|
|
|
static void test_init_large_capacity(void **state) {
|
|
(void) state;
|
|
|
|
ArrayList *arr = arraylist_init(SIZE_MAX, sizeof(int));
|
|
assert_null(arr);
|
|
arraylist_destroy(&arr);
|
|
}
|
|
|
|
// DESTROY
|
|
|
|
static void test_destroy_valid_array(void **state) {
|
|
(void) state;
|
|
|
|
ArrayList *arr = arraylist_init(64, sizeof(int));
|
|
assert_non_null(arr);
|
|
|
|
arraylist_destroy(&arr);
|
|
assert_null(arr);
|
|
}
|
|
|
|
static void test_destroy_null_array(void **state) {
|
|
(void) state;
|
|
|
|
ArrayList *arr = NULL;
|
|
ArrayListErr err = arraylist_destroy(&arr);
|
|
|
|
assert_null(arr);
|
|
assert_uint_equal(err, ARRLIST_NULL_ARG);
|
|
}
|
|
|
|
static void test_destroy_double(void **state) {
|
|
(void) state;
|
|
|
|
ArrayList *arr = arraylist_init(64, sizeof(int));
|
|
assert_non_null(arr);
|
|
|
|
ArrayListErr err = arraylist_destroy(&arr);
|
|
assert_uint_equal(err, ARRLIST_OK);
|
|
assert_null(arr);
|
|
|
|
err = arraylist_destroy(&arr);
|
|
assert_uint_equal(err, ARRLIST_NULL_ARG);
|
|
assert_null(arr);
|
|
}
|
|
|
|
// State
|
|
static void test_capacity_after_init(void **state) {
|
|
(void) state;
|
|
|
|
ArrayList *arr = arraylist_init(64, sizeof(int));
|
|
assert_non_null(arr);
|
|
|
|
assert_uint_equal(arraylist_capacity(arr), 64);
|
|
|
|
arraylist_destroy(&arr);
|
|
}
|
|
|
|
static void test_is_empty_after_init(void **state) {
|
|
(void) state;
|
|
|
|
ArrayList *arr = arraylist_init(64, sizeof(int));
|
|
assert_non_null(arr);
|
|
|
|
assert_true(arraylist_is_empty(arr));
|
|
|
|
arraylist_destroy(&arr);
|
|
}
|
|
|
|
static void test_is_empty_after_push(void **state) {
|
|
(void) state;
|
|
|
|
ArrayList *arr = arraylist_init(64, sizeof(int));
|
|
assert_non_null(arr);
|
|
|
|
int n = 8;
|
|
assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
|
|
|
|
assert_false(arraylist_is_empty(arr));
|
|
|
|
arraylist_destroy(&arr);
|
|
}
|
|
|
|
static void test_size_after_many_push(void **state) {
|
|
(void) state;
|
|
|
|
ArrayList *arr = arraylist_init(64, sizeof(int));
|
|
assert_non_null(arr);
|
|
|
|
int n = 8;
|
|
assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
|
|
assert_uint_equal(arraylist_size(arr), 1);
|
|
|
|
assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
|
|
assert_uint_equal(arraylist_size(arr), 2);
|
|
|
|
assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
|
|
assert_uint_equal(arraylist_size(arr), 3);
|
|
|
|
assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
|
|
assert_uint_equal(arraylist_size(arr), 4);
|
|
|
|
arraylist_destroy(&arr);
|
|
}
|
|
|
|
static void test_capacity_growth_on_push(void **state) {
|
|
(void) state;
|
|
|
|
ArrayList *arr = arraylist_init(2, sizeof(int));
|
|
assert_non_null(arr);
|
|
|
|
int n = 8;
|
|
assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
|
|
assert_uint_equal(arraylist_capacity(arr), 2);
|
|
|
|
assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
|
|
assert_uint_equal(arraylist_capacity(arr), 2);
|
|
|
|
assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
|
|
assert_uint_equal(arraylist_capacity(arr), 4);
|
|
|
|
arraylist_destroy(&arr);
|
|
}
|
|
|
|
static void test_capacity_shrink_on_pop(void **state) {
|
|
(void) state;
|
|
|
|
ArrayList *arr = arraylist_init(8, sizeof(int));
|
|
assert_non_null(arr);
|
|
|
|
int n = 8;
|
|
assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
|
|
assert_uint_equal(arraylist_pop_back(arr, &n), ARRLIST_OK);
|
|
assert_uint_equal(arraylist_capacity(arr), 4);
|
|
|
|
arraylist_destroy(&arr);
|
|
}
|
|
|
|
// push_back
|
|
static void test_push_back_single_element(void **state) {
|
|
(void) state;
|
|
|
|
ArrayList *arr = arraylist_init(64, sizeof(int));
|
|
assert_non_null(arr);
|
|
|
|
int n = 8;
|
|
assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
|
|
assert_uint_equal(arraylist_size(arr), 1);
|
|
|
|
int b;
|
|
assert_uint_equal(arraylist_get(arr, 0, &b), ARRLIST_OK);
|
|
assert_int_equal(b, 8);
|
|
|
|
arraylist_destroy(&arr);
|
|
}
|
|
|
|
static void test_push_back_multiple_elements(void **state) {
|
|
(void) state;
|
|
|
|
ArrayList *arr = arraylist_init(64, sizeof(int));
|
|
assert_non_null(arr);
|
|
|
|
int n = 8;
|
|
assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
|
|
assert_uint_equal(arraylist_size(arr), 1);
|
|
|
|
n = 9;
|
|
assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
|
|
assert_uint_equal(arraylist_size(arr), 2);
|
|
|
|
n = 10;
|
|
assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
|
|
assert_uint_equal(arraylist_size(arr), 3);
|
|
|
|
n = 11;
|
|
assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
|
|
assert_uint_equal(arraylist_size(arr), 4);
|
|
|
|
n = 12;
|
|
assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_OK);
|
|
assert_uint_equal(arraylist_size(arr), 5);
|
|
|
|
int b;
|
|
assert_uint_equal(arraylist_get(arr, 0, &b), ARRLIST_OK);
|
|
assert_int_equal(b, 8);
|
|
|
|
assert_uint_equal(arraylist_get(arr, 1, &b), ARRLIST_OK);
|
|
assert_int_equal(b, 9);
|
|
|
|
assert_uint_equal(arraylist_get(arr, 2, &b), ARRLIST_OK);
|
|
assert_int_equal(b, 10);
|
|
|
|
assert_uint_equal(arraylist_get(arr, 3, &b), ARRLIST_OK);
|
|
assert_int_equal(b, 11);
|
|
|
|
assert_uint_equal(arraylist_get(arr, 4, &b), ARRLIST_OK);
|
|
assert_int_equal(b, 12);
|
|
|
|
arraylist_destroy(&arr);
|
|
}
|
|
|
|
static void test_push_back_null_array(void **state) {
|
|
(void) state;
|
|
|
|
ArrayList *arr = NULL;
|
|
|
|
int n = 8;
|
|
assert_uint_equal(arraylist_push_back(arr, &n), ARRLIST_NULL_ARG);
|
|
}
|
|
|
|
static void test_push_back_null_data(void **state) {
|
|
(void) state;
|
|
|
|
ArrayList *arr = arraylist_init(64, sizeof(int));
|
|
|
|
assert_uint_equal(arraylist_push_back(arr, NULL), ARRLIST_NULL_ARG);
|
|
|
|
arraylist_destroy(&arr);
|
|
}
|
|
|
|
int main(void) {
|
|
const struct CMUnitTest init[] = {
|
|
cmocka_unit_test(test_init_valid_parameters),
|
|
cmocka_unit_test(test_init_zero_capacity),
|
|
cmocka_unit_test(test_init_zero_elem_size),
|
|
cmocka_unit_test(test_init_large_capacity),
|
|
};
|
|
|
|
const struct CMUnitTest destroy[] = {
|
|
cmocka_unit_test(test_destroy_valid_array),
|
|
cmocka_unit_test(test_destroy_null_array),
|
|
cmocka_unit_test(test_destroy_double),
|
|
};
|
|
|
|
const struct CMUnitTest state[] = {
|
|
cmocka_unit_test(test_capacity_after_init),
|
|
cmocka_unit_test(test_is_empty_after_init),
|
|
cmocka_unit_test(test_is_empty_after_push),
|
|
cmocka_unit_test(test_size_after_many_push),
|
|
cmocka_unit_test(test_capacity_growth_on_push),
|
|
cmocka_unit_test(test_capacity_shrink_on_pop),
|
|
};
|
|
|
|
const struct CMUnitTest push_back[] = {
|
|
cmocka_unit_test(test_push_back_single_element),
|
|
cmocka_unit_test(test_push_back_multiple_elements),
|
|
cmocka_unit_test(test_push_back_null_array),
|
|
cmocka_unit_test(test_push_back_null_data),
|
|
};
|
|
|
|
int rc = 0;
|
|
|
|
rc += cmocka_run_group_tests(init, NULL, NULL);
|
|
rc += cmocka_run_group_tests(destroy, NULL, NULL);
|
|
rc += cmocka_run_group_tests(state, NULL, NULL);
|
|
rc += cmocka_run_group_tests(push_back, NULL, NULL);
|
|
|
|
return rc;
|
|
}
|