API: Cutting my losses and having singular types and files for the 4
types { char, int, float, string } and can come back later to make it
one type to call.
GITIGNORE: Added tests and Makefile to cleanup fuzzyfinder but dont need
them pushed either as I have enough testing done.
This commit is contained in:
+193
-190
@@ -1,5 +1,5 @@
|
||||
#include <assert.h>
|
||||
#include <char/char.h>
|
||||
#include <int/int.h>
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
@@ -23,15 +23,15 @@ __asan_default_options(void)
|
||||
static void
|
||||
test_push_back_single(void)
|
||||
{
|
||||
printf("[1] Testing push_back with a single character...\n");
|
||||
_VecCharInternal vec = VEC_INIT;
|
||||
printf("[1] Testing push_back with a single integer...\n");
|
||||
_VecIntInternal vec = VEC_INIT;
|
||||
err_t err = ERR_T_INIT;
|
||||
_vec_char_push_back(&vec, 'A', &err);
|
||||
_vec_int_push_back(&vec, 65, &err);
|
||||
|
||||
assert(err.flags == 0);
|
||||
assert(vec._internal_size == 1);
|
||||
assert(vec._internal_arr[0] == 'A');
|
||||
_vec_char_delete(&vec, &err);
|
||||
assert(vec._internal_arr[0] == 65);
|
||||
_vec_int_delete(&vec, &err);
|
||||
printf("Passed\n");
|
||||
}
|
||||
|
||||
@@ -39,13 +39,13 @@ static void
|
||||
test_null_guards(void)
|
||||
{
|
||||
printf("[2] Testing null pointer checks in __null_check...\n");
|
||||
_VecCharInternal vec = VEC_INIT;
|
||||
_VecIntInternal vec = VEC_INIT;
|
||||
err_t err = ERR_T_INIT;
|
||||
|
||||
size_t res1 = __null_check(&vec, nullptr);
|
||||
assert(res1 == ERR_ERR_T_NULL);
|
||||
|
||||
size_t res2 = __null_check((const _VecCharInternal*)nullptr, &err);
|
||||
size_t res2 = __null_check((const _VecIntInternal*)nullptr, &err);
|
||||
assert(res2 == ERR_VEC_NULL);
|
||||
assert((err.flags & ERR_VEC_NULL) != 0);
|
||||
|
||||
@@ -60,7 +60,7 @@ test_null_guards(void)
|
||||
assert((err.flags & ERR_BUF_NULL) != 0);
|
||||
|
||||
err = (err_t)ERR_T_INIT;
|
||||
size_t res5 = __null_check((const char*)nullptr, nullptr);
|
||||
size_t res5 = __null_check((const int*)nullptr, nullptr);
|
||||
assert(res5 == ERR_ERR_T_NULL);
|
||||
|
||||
printf("Passed\n");
|
||||
@@ -98,42 +98,42 @@ test_origin_override(void)
|
||||
static void
|
||||
test_print_vec(void)
|
||||
{
|
||||
_VecCharInternal vec = VEC_INIT;
|
||||
_VecIntInternal vec = VEC_INIT;
|
||||
err_t err = ERR_T_INIT;
|
||||
|
||||
printf("[4] Testing print_vec with null vector\n");
|
||||
_vec_char_print_vec(nullptr, &err);
|
||||
_vec_int_print_vec(nullptr, &err);
|
||||
assert((err.flags & ERR_VEC_NULL) != 0);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[5] Testing print_vec with null array\n");
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_print_vec(&vec, &err);
|
||||
_vec_int_print_vec(&vec, &err);
|
||||
assert((err.flags & ERR_BUF_NULL) != 0);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[6] Testing print_vec with null err\n");
|
||||
_vec_char_print_vec(&vec, nullptr);
|
||||
_vec_int_print_vec(&vec, nullptr);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[7] Testing print_vec with valid parameters\n");
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_push_back(&vec, 'a', &err);
|
||||
_vec_char_push_back(&vec, 'b', &err);
|
||||
_vec_char_print_vec(&vec, &err);
|
||||
_vec_char_delete(&vec, &err);
|
||||
_vec_int_push_back(&vec, 1, &err);
|
||||
_vec_int_push_back(&vec, 2, &err);
|
||||
_vec_int_print_vec(&vec, &err);
|
||||
_vec_int_delete(&vec, &err);
|
||||
printf("Passed\n");
|
||||
}
|
||||
|
||||
static void
|
||||
test_cpy(void)
|
||||
{
|
||||
char arr[3] = { 'a', 'b', 'c' };
|
||||
_VecCharInternal blank = VEC_INIT;
|
||||
int arr[3] = { 1, 2, 3 };
|
||||
_VecIntInternal blank = VEC_INIT;
|
||||
|
||||
printf("[8] Testing _vec_char_cpy with null source arr\n");
|
||||
printf("[8] Testing _vec_int_cpy with null source arr\n");
|
||||
err_t err1 = ERR_T_INIT;
|
||||
_VecCharInternal tmp = _vec_char_cpy(nullptr, 3, &err1);
|
||||
_VecIntInternal tmp = _vec_int_cpy(nullptr, 3, &err1);
|
||||
assert(blank._internal_arr == tmp._internal_arr &&
|
||||
blank._internal_capacity == tmp._internal_capacity &&
|
||||
blank._internal_size == tmp._internal_size &&
|
||||
@@ -141,17 +141,17 @@ test_cpy(void)
|
||||
assert((err1.flags & ERR_BUF_NULL) != 0);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[9] Testing _vec_char_cpy with null err\n");
|
||||
_VecCharInternal res2 = _vec_char_cpy(arr, 3, nullptr);
|
||||
printf("[9] Testing _vec_int_cpy with null err\n");
|
||||
_VecIntInternal res2 = _vec_int_cpy(arr, 3, nullptr);
|
||||
assert(blank._internal_arr == res2._internal_arr &&
|
||||
blank._internal_capacity == res2._internal_capacity &&
|
||||
blank._internal_size == res2._internal_size &&
|
||||
blank._internal_max_size == res2._internal_max_size);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[10] Testing _vec_char_cpy with size 0\n");
|
||||
printf("[10] Testing _vec_int_cpy with size 0\n");
|
||||
err_t err3 = ERR_T_INIT;
|
||||
_VecCharInternal res3 = _vec_char_cpy(arr, 0, &err3);
|
||||
_VecIntInternal res3 = _vec_int_cpy(arr, 0, &err3);
|
||||
assert(blank._internal_arr == res3._internal_arr &&
|
||||
blank._internal_capacity == res3._internal_capacity &&
|
||||
blank._internal_size == res3._internal_size &&
|
||||
@@ -159,10 +159,10 @@ test_cpy(void)
|
||||
assert((err3.flags & ERR_SIZE_ZERO) != 0);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[11] Testing _vec_char_cpy with size exceeding max_size\n");
|
||||
printf("[11] Testing _vec_int_cpy with size exceeding max_size\n");
|
||||
err_t err4 = ERR_T_INIT;
|
||||
_VecCharInternal res4 =
|
||||
_vec_char_cpy(arr, res3._internal_max_size + 1, &err4);
|
||||
_VecIntInternal res4 =
|
||||
_vec_int_cpy(arr, res3._internal_max_size + 1, &err4);
|
||||
assert(blank._internal_arr == res4._internal_arr &&
|
||||
blank._internal_capacity == res4._internal_capacity &&
|
||||
blank._internal_size == res4._internal_size &&
|
||||
@@ -170,22 +170,23 @@ test_cpy(void)
|
||||
assert((err4.flags & ERR_SIZE_OVERFLOW) != 0);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[12] Testing _vec_char_cpy allocation failure\n");
|
||||
printf("[12] Testing _vec_int_cpy allocation failure\n");
|
||||
err_t err5 = ERR_T_INIT;
|
||||
size_t huge_size = ((size_t)1 << 40);
|
||||
_VecCharInternal res5 = _vec_char_cpy(arr, huge_size, &err5);
|
||||
_VecIntInternal res5 = _vec_int_cpy(arr, huge_size, &err5);
|
||||
assert(res5._internal_arr == blank._internal_arr);
|
||||
assert((err5.flags & ERR_ALLOC_FAIL) != 0);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[13] Testing _vec_char_cpy with valid inputs\n");
|
||||
printf("[13] Testing _vec_int_cpy with valid inputs\n");
|
||||
err_t err = ERR_T_INIT;
|
||||
char res[4] = { 'a', 'b', 'c', 'd' };
|
||||
_VecCharInternal vec = _vec_char_cpy(res, 4, &err);
|
||||
int res[4] = { 10, 20, 30, 40 };
|
||||
_VecIntInternal vec = _vec_int_cpy(res, 4, &err);
|
||||
assert(err.flags == 0);
|
||||
assert(vec._internal_size == 4);
|
||||
assert(vec._internal_capacity == 4);
|
||||
assert(memcmp(vec._internal_arr, res, 4) == 0);
|
||||
_vec_char_delete(&vec, &err);
|
||||
assert(memcmp(vec._internal_arr, res, sizeof(int) * 4) == 0);
|
||||
_vec_int_delete(&vec, &err);
|
||||
printf("Passed\n");
|
||||
}
|
||||
|
||||
@@ -196,151 +197,151 @@ test_cpy(void)
|
||||
static void
|
||||
test_push_back(void)
|
||||
{
|
||||
printf("[14] Testing _vec_char_push_back null vec\n");
|
||||
printf("[14] Testing _vec_int_push_back null vec\n");
|
||||
err_t err = ERR_T_INIT;
|
||||
_vec_char_push_back(nullptr, 'a', &err);
|
||||
_vec_int_push_back(nullptr, 1, &err);
|
||||
assert((err.flags & ERR_VEC_NULL) != 0);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[15] Testing _vec_char_push_back null err\n");
|
||||
_VecCharInternal vec1 = VEC_INIT;
|
||||
_vec_char_push_back(&vec1, 'a', nullptr);
|
||||
printf("[15] Testing _vec_int_push_back null err\n");
|
||||
_VecIntInternal vec1 = VEC_INIT;
|
||||
_vec_int_push_back(&vec1, 1, nullptr);
|
||||
assert(vec1._internal_size == 1);
|
||||
_vec_char_delete(&vec1, &err);
|
||||
_vec_int_delete(&vec1, &err);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[16] Testing _vec_char_push_back size overflow\n");
|
||||
_VecCharInternal vec2 = VEC_INIT;
|
||||
printf("[16] Testing _vec_int_push_back size overflow\n");
|
||||
_VecIntInternal vec2 = VEC_INIT;
|
||||
err_t err2 = ERR_T_INIT;
|
||||
vec2._internal_size = vec2._internal_max_size;
|
||||
_vec_char_push_back(&vec2, 'a', &err2);
|
||||
_vec_int_push_back(&vec2, 1, &err2);
|
||||
assert((err2.flags & ERR_SIZE_OVERFLOW) != 0);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[17] Testing push_back capacity growth realloc\n");
|
||||
err_t err3 = ERR_T_INIT;
|
||||
_VecCharInternal vec3 = VEC_INIT;
|
||||
for (char c = '0'; c <= '9'; c++)
|
||||
_VecIntInternal vec3 = VEC_INIT;
|
||||
for (int val = 0; val < 10; val++)
|
||||
{
|
||||
_vec_char_push_back(&vec3, c, &err3);
|
||||
_vec_int_push_back(&vec3, val, &err3);
|
||||
assert(err3.flags == 0);
|
||||
}
|
||||
assert(vec3._internal_size == 10);
|
||||
assert(vec3._internal_capacity >= 10);
|
||||
_vec_char_delete(&vec3, &err3);
|
||||
_vec_int_delete(&vec3, &err3);
|
||||
printf("Passed\n");
|
||||
}
|
||||
|
||||
static void
|
||||
test_pop_back(void)
|
||||
{
|
||||
_VecCharInternal vec = VEC_INIT;
|
||||
_VecIntInternal vec = VEC_INIT;
|
||||
err_t err = ERR_T_INIT;
|
||||
|
||||
printf("[18] Testing _vec_char_pop_back null vector\n");
|
||||
_vec_char_pop_back(nullptr, &err);
|
||||
printf("[18] Testing _vec_int_pop_back null vector\n");
|
||||
_vec_int_pop_back(nullptr, &err);
|
||||
assert((err.flags & ERR_VEC_NULL) != 0);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[19] Testing _vec_char_pop_back size 0\n");
|
||||
printf("[19] Testing _vec_int_pop_back size 0\n");
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_push_back(&vec, 'x', &err);
|
||||
_vec_char_pop_back(&vec,
|
||||
&err); // size is now 0, but buffer is allocated
|
||||
_vec_int_push_back(&vec, 42, &err);
|
||||
_vec_int_pop_back(&vec,
|
||||
&err); // size is now 0, but buffer is allocated
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_pop_back(&vec, &err);
|
||||
_vec_int_pop_back(&vec, &err);
|
||||
assert((err.flags & ERR_SIZE_ZERO) != 0);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[20] Testing _vec_char_pop_back valid pop\n");
|
||||
printf("[20] Testing _vec_int_pop_back valid pop\n");
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_push_back(&vec, 'a', &err);
|
||||
_vec_char_push_back(&vec, 'b', &err);
|
||||
_vec_int_push_back(&vec, 1, &err);
|
||||
_vec_int_push_back(&vec, 2, &err);
|
||||
assert(vec._internal_size == 2);
|
||||
_vec_char_pop_back(&vec, &err);
|
||||
_vec_int_pop_back(&vec, &err);
|
||||
assert(vec._internal_size == 1);
|
||||
assert(vec._internal_arr[0] == 'a');
|
||||
assert(vec._internal_arr[0] == 1);
|
||||
assert(vec._internal_arr[1] == 0);
|
||||
_vec_char_delete(&vec, &err);
|
||||
_vec_int_delete(&vec, &err);
|
||||
printf("Passed\n");
|
||||
}
|
||||
|
||||
static void
|
||||
test_reserve(void)
|
||||
{
|
||||
_VecCharInternal vec = VEC_INIT;
|
||||
_VecIntInternal vec = VEC_INIT;
|
||||
err_t err = ERR_T_INIT;
|
||||
|
||||
printf("[21] Testing _vec_char_reserve null vector\n");
|
||||
_vec_char_reserve(nullptr, 1, &err);
|
||||
printf("[21] Testing _vec_int_reserve null vector\n");
|
||||
_vec_int_reserve(nullptr, 1, &err);
|
||||
assert((err.flags & ERR_VEC_NULL) != 0);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[22] Testing _vec_char_reserve capacity 0\n");
|
||||
printf("[22] Testing _vec_int_reserve capacity 0\n");
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_reserve(&vec, 0, &err);
|
||||
_vec_int_reserve(&vec, 0, &err);
|
||||
assert((err.flags & ERR_SIZE_ZERO) != 0);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[23] Testing _vec_char_reserve calloc on unallocated buffer\n");
|
||||
printf("[23] Testing _vec_int_reserve calloc on unallocated buffer\n");
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_reserve(&vec, 32, &err);
|
||||
_vec_int_reserve(&vec, 32, &err);
|
||||
assert(err.flags == 0);
|
||||
assert(vec._internal_capacity == 32);
|
||||
assert(vec._internal_arr != nullptr);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[24] Testing _vec_char_reserve realloc to larger capacity\n");
|
||||
_vec_char_reserve(&vec, 64, &err);
|
||||
printf("[24] Testing _vec_int_reserve realloc to larger capacity\n");
|
||||
_vec_int_reserve(&vec, 64, &err);
|
||||
assert(err.flags == 0);
|
||||
assert(vec._internal_capacity == 64);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[25] Testing _vec_char_reserve truncating size\n");
|
||||
printf("[25] Testing _vec_int_reserve truncating size\n");
|
||||
vec._internal_size = 50;
|
||||
_vec_char_reserve(&vec, 20, &err);
|
||||
_vec_int_reserve(&vec, 20, &err);
|
||||
assert(vec._internal_size == 20);
|
||||
assert(vec._internal_capacity == 20);
|
||||
_vec_char_delete(&vec, &err);
|
||||
_vec_int_delete(&vec, &err);
|
||||
printf("Passed\n");
|
||||
}
|
||||
|
||||
static void
|
||||
test_shrink_to_fit(void)
|
||||
{
|
||||
_VecCharInternal vec = VEC_INIT;
|
||||
_VecIntInternal vec = VEC_INIT;
|
||||
err_t err = ERR_T_INIT;
|
||||
|
||||
printf("[26] Testing _vec_char_shrink_to_fit null vector\n");
|
||||
_vec_char_shrink_to_fit(nullptr, &err);
|
||||
printf("[26] Testing _vec_int_shrink_to_fit null vector\n");
|
||||
_vec_int_shrink_to_fit(nullptr, &err);
|
||||
assert((err.flags & ERR_VEC_NULL) != 0);
|
||||
printf("Passed\n");
|
||||
|
||||
printf(
|
||||
"[27] Testing _vec_char_shrink_to_fit size 0 with allocated "
|
||||
"[27] Testing _vec_int_shrink_to_fit size 0 with allocated "
|
||||
"buffer\n");
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_push_back(&vec, 'a', &err);
|
||||
_vec_char_pop_back(&vec, &err);
|
||||
_vec_int_push_back(&vec, 1, &err);
|
||||
_vec_int_pop_back(&vec, &err);
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_shrink_to_fit(&vec, &err);
|
||||
_vec_int_shrink_to_fit(&vec, &err);
|
||||
assert((err.flags & ERR_SIZE_ZERO) != 0);
|
||||
printf("Passed\n");
|
||||
|
||||
printf("[28] Testing _vec_char_shrink_to_fit normal shrinkage\n");
|
||||
_vec_char_reserve(&vec, 128, &err);
|
||||
for (char c = '0'; c < '5'; c++)
|
||||
printf("[28] Testing _vec_int_shrink_to_fit normal shrinkage\n");
|
||||
_vec_int_reserve(&vec, 128, &err);
|
||||
for (int val = 0; val < 5; val++)
|
||||
{
|
||||
_vec_char_push_back(&vec, c, &err);
|
||||
_vec_int_push_back(&vec, val, &err);
|
||||
}
|
||||
assert(vec._internal_capacity == 128);
|
||||
assert(vec._internal_size == 5);
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_shrink_to_fit(&vec, &err);
|
||||
_vec_int_shrink_to_fit(&vec, &err);
|
||||
assert(err.flags == 0);
|
||||
assert(vec._internal_capacity == 5);
|
||||
assert(vec._internal_size == 5);
|
||||
_vec_char_delete(&vec, &err);
|
||||
_vec_int_delete(&vec, &err);
|
||||
printf("Passed\n");
|
||||
}
|
||||
|
||||
@@ -352,75 +353,75 @@ static void
|
||||
test_getters_and_access(void)
|
||||
{
|
||||
printf("[29] Testing getters, clear, and boundary element access...\n");
|
||||
_VecCharInternal vec = VEC_INIT;
|
||||
_VecIntInternal vec = VEC_INIT;
|
||||
err_t err = ERR_T_INIT;
|
||||
|
||||
// 1. Null pointer check
|
||||
assert(_vec_char_data(nullptr, &err) == nullptr);
|
||||
assert(_vec_int_data(nullptr, &err) == nullptr);
|
||||
assert((err.flags & ERR_VEC_NULL) != 0);
|
||||
|
||||
err = (err_t)ERR_T_INIT;
|
||||
assert(_vec_char_size(nullptr, &err) == 0);
|
||||
assert(_vec_int_size(nullptr, &err) == 0);
|
||||
assert((err.flags & ERR_VEC_NULL) != 0);
|
||||
|
||||
err = (err_t)ERR_T_INIT;
|
||||
assert(_vec_char_capacity(nullptr, &err) == 0);
|
||||
assert(_vec_int_capacity(nullptr, &err) == 0);
|
||||
assert((err.flags & ERR_VEC_NULL) != 0);
|
||||
|
||||
err = (err_t)ERR_T_INIT;
|
||||
assert(_vec_char_max_size(nullptr, &err) == 0);
|
||||
assert(_vec_int_max_size(nullptr, &err) == 0);
|
||||
assert((err.flags & ERR_VEC_NULL) != 0);
|
||||
|
||||
// 2. Unallocated buffer check for empty()
|
||||
err = (err_t)ERR_T_INIT;
|
||||
size_t unalloc_empty = _vec_char_empty(&vec, &err);
|
||||
size_t unalloc_empty = _vec_int_empty(&vec, &err);
|
||||
assert((err.flags & ERR_BUF_NULL) != 0);
|
||||
assert(unalloc_empty != 0);
|
||||
|
||||
// 3. Allocate the buffer and pop so size is 0 with valid arr
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_push_back(&vec, 'x', &err);
|
||||
_vec_char_pop_back(&vec, &err);
|
||||
_vec_int_push_back(&vec, 100, &err);
|
||||
_vec_int_pop_back(&vec, &err);
|
||||
err = (err_t)ERR_T_INIT;
|
||||
|
||||
// Now _internal_arr is non-null and size is 0:
|
||||
assert(_vec_char_empty(&vec, &err) == 0);
|
||||
assert(_vec_int_empty(&vec, &err) == 0);
|
||||
|
||||
// Boundary element access on size 0
|
||||
err = (err_t)ERR_T_INIT;
|
||||
assert(_vec_char_front(&vec, &err) == 0 ||
|
||||
assert(_vec_int_front(&vec, &err) == 0 ||
|
||||
(err.flags & ERR_OUT_OF_BOUNDS) != 0);
|
||||
|
||||
err = (err_t)ERR_T_INIT;
|
||||
assert(_vec_char_back(&vec, &err) == 0 ||
|
||||
assert(_vec_int_back(&vec, &err) == 0 ||
|
||||
(err.flags & ERR_OUT_OF_BOUNDS) != 0);
|
||||
|
||||
// 4. Populate container
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_push_back(&vec, 'x', &err);
|
||||
_vec_char_push_back(&vec, 'y', &err);
|
||||
_vec_char_push_back(&vec, 'z', &err);
|
||||
_vec_int_push_back(&vec, 10, &err);
|
||||
_vec_int_push_back(&vec, 20, &err);
|
||||
_vec_int_push_back(&vec, 30, &err);
|
||||
|
||||
assert(_vec_char_size(&vec, &err) == 3);
|
||||
assert(_vec_char_capacity(&vec, &err) >= 3);
|
||||
assert(_vec_char_data(&vec, &err) == vec._internal_arr);
|
||||
assert(_vec_char_front(&vec, &err) == 'x');
|
||||
assert(_vec_char_back(&vec, &err) == 'z');
|
||||
assert(_vec_char_begin(&vec, &err) == 0);
|
||||
assert(_vec_char_end(&vec, &err) == 2);
|
||||
assert(_vec_int_size(&vec, &err) == 3);
|
||||
assert(_vec_int_capacity(&vec, &err) >= 3);
|
||||
assert(_vec_int_data(&vec, &err) == vec._internal_arr);
|
||||
assert(_vec_int_front(&vec, &err) == 10);
|
||||
assert(_vec_int_back(&vec, &err) == 30);
|
||||
assert(_vec_int_begin(&vec, &err) == 0);
|
||||
assert(_vec_int_end(&vec, &err) == 2);
|
||||
|
||||
// Out of bounds at()
|
||||
err = (err_t)ERR_T_INIT;
|
||||
assert(_vec_char_at(&vec, 10, &err) == nullptr);
|
||||
assert(_vec_int_at(&vec, 10, &err) == nullptr);
|
||||
assert((err.flags & ERR_OUT_OF_BOUNDS) != 0);
|
||||
|
||||
// Clear container
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_clear(&vec, &err);
|
||||
_vec_int_clear(&vec, &err);
|
||||
assert(vec._internal_size == 0);
|
||||
assert(vec._internal_arr[0] == 0);
|
||||
|
||||
_vec_char_delete(&vec, &err);
|
||||
_vec_int_delete(&vec, &err);
|
||||
assert(vec._internal_arr == nullptr);
|
||||
assert(vec._internal_size == 0);
|
||||
assert(vec._internal_capacity == 0);
|
||||
@@ -435,220 +436,222 @@ test_getters_and_access(void)
|
||||
static void
|
||||
test_swap(void)
|
||||
{
|
||||
printf("[30] Testing _vec_char_swap...\n");
|
||||
_VecCharInternal a = VEC_INIT;
|
||||
_VecCharInternal b = VEC_INIT;
|
||||
printf("[30] Testing _vec_int_swap...\n");
|
||||
_VecIntInternal a = VEC_INIT;
|
||||
_VecIntInternal b = VEC_INIT;
|
||||
err_t err = ERR_T_INIT;
|
||||
|
||||
// Null vector checks
|
||||
_vec_char_swap(nullptr, &b, &err);
|
||||
_vec_int_swap(nullptr, &b, &err);
|
||||
assert((err.flags & ERR_VEC_NULL) != 0);
|
||||
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_swap(&a, nullptr, &err);
|
||||
_vec_int_swap(&a, nullptr, &err);
|
||||
assert((err.flags & ERR_VEC_NULL) != 0);
|
||||
|
||||
// Normal swap
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_push_back(&a, 'A', &err);
|
||||
_vec_char_push_back(&b, 'B', &err);
|
||||
_vec_char_push_back(&b, 'C', &err);
|
||||
_vec_int_push_back(&a, 100, &err);
|
||||
_vec_int_push_back(&b, 200, &err);
|
||||
_vec_int_push_back(&b, 300, &err);
|
||||
|
||||
_vec_char_swap(&a, &b, &err);
|
||||
_vec_int_swap(&a, &b, &err);
|
||||
assert(a._internal_size == 2);
|
||||
assert(a._internal_arr[0] == 'B');
|
||||
assert(a._internal_arr[0] == 200);
|
||||
assert(b._internal_size == 1);
|
||||
assert(b._internal_arr[0] == 'A');
|
||||
assert(b._internal_arr[0] == 100);
|
||||
|
||||
_vec_char_delete(&a, &err);
|
||||
_vec_char_delete(&b, &err);
|
||||
_vec_int_delete(&a, &err);
|
||||
_vec_int_delete(&b, &err);
|
||||
printf("Passed\n");
|
||||
}
|
||||
|
||||
static void
|
||||
test_erase_variants(void)
|
||||
{
|
||||
printf("[31] Testing _vec_char_erase single & range overloads...\n");
|
||||
_VecCharInternal vec = VEC_INIT;
|
||||
printf("[31] Testing _vec_int_erase single & range overloads...\n");
|
||||
_VecIntInternal vec = VEC_INIT;
|
||||
err_t err = ERR_T_INIT;
|
||||
|
||||
for (char c = '0'; c <= '5'; c++)
|
||||
for (int val = 0; val <= 5; val++)
|
||||
{
|
||||
_vec_char_push_back(&vec, c, &err);
|
||||
} // "012345"
|
||||
_vec_int_push_back(&vec, val, &err);
|
||||
} // {0, 1, 2, 3, 4, 5}
|
||||
|
||||
// Single element erase out of bounds (noop)
|
||||
_vec_char_erase(&vec, 10, &err);
|
||||
_vec_int_erase(&vec, 10, &err);
|
||||
assert(vec._internal_size == 6);
|
||||
|
||||
// Erase index 2 ('2') -> "01345"
|
||||
_vec_char_erase(&vec, 2, &err);
|
||||
// Erase index 2 (value 2) -> {0, 1, 3, 4, 5}
|
||||
_vec_int_erase(&vec, 2, &err);
|
||||
assert(vec._internal_size == 5);
|
||||
assert(vec._internal_arr[2] == '3');
|
||||
assert(vec._internal_arr[2] == 3);
|
||||
|
||||
// Range erase invalid bounds
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_erase(&vec, 4, 2, &err); // iter_end <= iter_start
|
||||
_vec_int_erase(&vec, 4, 2, &err); // iter_end <= iter_start
|
||||
assert((err.flags & ERR_OUT_OF_BOUNDS) != 0);
|
||||
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_erase(&vec, 0, 10, &err); // iter_end > size
|
||||
_vec_int_erase(&vec, 0, 10, &err); // iter_end > size
|
||||
assert((err.flags & ERR_OUT_OF_BOUNDS) != 0);
|
||||
|
||||
// Range erase middle: index 1 through 3 ("0[13]45" -> "045")
|
||||
// Range erase middle: index 1 through 3 ({0, [1, 3], 4, 5} -> {0, 4,
|
||||
// 5})
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_erase(&vec, 1, 3, &err);
|
||||
_vec_int_erase(&vec, 1, 3, &err);
|
||||
assert(vec._internal_size == 3);
|
||||
assert(vec._internal_arr[0] == '0');
|
||||
assert(vec._internal_arr[1] == '4');
|
||||
assert(vec._internal_arr[2] == '5');
|
||||
assert(vec._internal_arr[0] == 0);
|
||||
assert(vec._internal_arr[1] == 4);
|
||||
assert(vec._internal_arr[2] == 5);
|
||||
|
||||
_vec_char_delete(&vec, &err);
|
||||
_vec_int_delete(&vec, &err);
|
||||
printf("Passed\n");
|
||||
}
|
||||
|
||||
static void
|
||||
test_resize(void)
|
||||
{
|
||||
printf("[32] Testing _vec_char_resize (zero-fill & value-fill)...\n");
|
||||
_VecCharInternal vec = VEC_INIT;
|
||||
printf("[32] Testing _vec_int_resize (zero-fill & value-fill)...\n");
|
||||
_VecIntInternal vec = VEC_INIT;
|
||||
err_t err = ERR_T_INIT;
|
||||
|
||||
// Null vector
|
||||
_vec_char_resize((_VecCharInternal*)nullptr, 10, &err);
|
||||
_vec_int_resize((_VecIntInternal*)nullptr, 10, &err);
|
||||
assert((err.flags & ERR_VEC_NULL) != 0);
|
||||
|
||||
// Resize unallocated buffer to size 5
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_resize(&vec, 5, &err);
|
||||
_vec_int_resize(&vec, 5, &err);
|
||||
assert(err.flags == 0);
|
||||
assert(vec._internal_size == 5);
|
||||
assert(vec._internal_arr[0] == 0);
|
||||
|
||||
// Same size requested
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_resize(&vec, 5, &err);
|
||||
_vec_int_resize(&vec, 5, &err);
|
||||
assert((err.flags & ERR_OUT_OF_BOUNDS) != 0);
|
||||
|
||||
// Exceeds max size
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_resize(&vec, vec._internal_max_size + 1, &err);
|
||||
_vec_int_resize(&vec, vec._internal_max_size + 1, &err);
|
||||
assert((err.flags & ERR_SIZE_OVERFLOW) != 0);
|
||||
|
||||
// Grow with value fill
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_resize(&vec, 8, 'Z', &err);
|
||||
_vec_int_resize(&vec, 8, 5, &err);
|
||||
assert(vec._internal_size == 8);
|
||||
assert(vec._internal_arr[5] == 'Z');
|
||||
assert(vec._internal_arr[7] == 'Z');
|
||||
assert(vec._internal_arr[5] == 5);
|
||||
assert(vec._internal_arr[7] == 5);
|
||||
|
||||
// Shrink with value fill
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_resize(&vec, 3, 'A', &err);
|
||||
_vec_int_resize(&vec, 3, 10, &err);
|
||||
assert(vec._internal_size == 3);
|
||||
|
||||
_vec_char_delete(&vec, &err);
|
||||
_vec_int_delete(&vec, &err);
|
||||
printf("Passed\n");
|
||||
}
|
||||
|
||||
static void
|
||||
test_assign(void)
|
||||
{
|
||||
printf("[33] Testing _vec_char_assign overloads...\n");
|
||||
_VecCharInternal dst = VEC_INIT;
|
||||
_VecCharInternal src = VEC_INIT;
|
||||
printf("[33] Testing _vec_int_assign overloads...\n");
|
||||
_VecIntInternal dst = VEC_INIT;
|
||||
_VecIntInternal src = VEC_INIT;
|
||||
err_t err = ERR_T_INIT;
|
||||
|
||||
// Populate src: 'A', 'B', 'C', 'D', 'E'
|
||||
for (char c = 'A'; c <= 'E'; c++)
|
||||
// Populate src: 1, 2, 3, 4, 5
|
||||
for (int val = 1; val <= 5; val++)
|
||||
{
|
||||
_vec_char_push_back(&src, c, &err);
|
||||
_vec_int_push_back(&src, val, &err);
|
||||
}
|
||||
|
||||
// Allocate dst buffer first so it is not unallocated
|
||||
_vec_char_push_back(&dst, 'z', &err);
|
||||
_vec_int_push_back(&dst, 999, &err);
|
||||
err = (err_t)ERR_T_INIT;
|
||||
|
||||
// 1. Fill assign: 4 'X's
|
||||
_vec_char_assign(&dst, 4, 'X', &err);
|
||||
// 1. Fill assign: 4 42's
|
||||
_vec_int_assign(&dst, 4, 42, &err);
|
||||
assert(err.flags == 0);
|
||||
assert(dst._internal_size == 4);
|
||||
assert(dst._internal_arr[0] == 'X');
|
||||
assert(dst._internal_arr[3] == 'X');
|
||||
assert(dst._internal_arr[0] == 42);
|
||||
assert(dst._internal_arr[3] == 42);
|
||||
|
||||
// 2. Fill assign with 0 amount
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_assign(&dst, 0, 'Y', &err);
|
||||
_vec_int_assign(&dst, 0, 50, &err);
|
||||
assert((err.flags & ERR_SIZE_ZERO) != 0);
|
||||
|
||||
// 3. Range assign self-buffer check
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_assign(&dst, &dst, 0, 2, &err);
|
||||
_vec_int_assign(&dst, &dst, 0, 2, &err);
|
||||
assert((err.flags & ERR_DOUBLE_BUF) != 0);
|
||||
|
||||
// 4. Range assign invalid sub-range (start >= end)
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_assign(&dst, &src, 3, 2, &err);
|
||||
_vec_int_assign(&dst, &src, 3, 2, &err);
|
||||
assert((err.flags & ERR_OUT_OF_BOUNDS) != 0);
|
||||
|
||||
// 5. Range assign out of bounds end
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_assign(&dst, &src, 0, 10, &err);
|
||||
_vec_int_assign(&dst, &src, 0, 10, &err);
|
||||
assert((err.flags & ERR_OUT_OF_BOUNDS) != 0);
|
||||
|
||||
_vec_char_delete(&dst, &err);
|
||||
_vec_char_delete(&src, &err);
|
||||
_vec_int_delete(&dst, &err);
|
||||
_vec_int_delete(&src, &err);
|
||||
printf("Passed\n");
|
||||
}
|
||||
|
||||
static void
|
||||
test_insert(void)
|
||||
{
|
||||
printf("[34] Testing _vec_char_insert overloads...\n");
|
||||
_VecCharInternal vec = VEC_INIT;
|
||||
_VecCharInternal other = VEC_INIT;
|
||||
printf("[34] Testing _vec_int_insert overloads...\n");
|
||||
_VecIntInternal vec = VEC_INIT;
|
||||
_VecIntInternal other = VEC_INIT;
|
||||
err_t err = ERR_T_INIT;
|
||||
|
||||
// Single insert on unallocated buffer
|
||||
_vec_char_insert(&vec, 0, 'M', &err);
|
||||
_vec_int_insert(&vec, 0, 500, &err);
|
||||
assert(vec._internal_size == 1);
|
||||
assert(vec._internal_arr[0] == 'M');
|
||||
assert(vec._internal_arr[0] == 500);
|
||||
|
||||
// Single insert out of bounds
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_insert(&vec, 5, 'O', &err);
|
||||
_vec_int_insert(&vec, 5, 999, &err);
|
||||
assert((err.flags & ERR_OUT_OF_BOUNDS) != 0);
|
||||
|
||||
// Single insert at middle: index 0 ('A', then 'M' shifts to 1)
|
||||
// Single insert at middle: index 0 (100, then 500 shifts to 1)
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_insert(&vec, 0, 'A', &err);
|
||||
_vec_int_insert(&vec, 0, 100, &err);
|
||||
assert(vec._internal_size == 2);
|
||||
assert(vec._internal_arr[0] == 'A');
|
||||
assert(vec._internal_arr[1] == 'M');
|
||||
assert(vec._internal_arr[0] == 100);
|
||||
assert(vec._internal_arr[1] == 500);
|
||||
|
||||
// Repeated insert: insert 3 'B's at index 1 -> 'A', 'B', 'B', 'B', 'M'
|
||||
_vec_char_insert(&vec, 1, 3, 'B', &err);
|
||||
// Repeated insert: insert 3 200s at index 1 -> {100, 200, 200, 200,
|
||||
// 500}
|
||||
_vec_int_insert(&vec, 1, 3, 200, &err);
|
||||
assert(vec._internal_size == 5);
|
||||
assert(vec._internal_arr[1] == 'B');
|
||||
assert(vec._internal_arr[3] == 'B');
|
||||
assert(vec._internal_arr[4] == 'M');
|
||||
assert(vec._internal_arr[1] == 200);
|
||||
assert(vec._internal_arr[3] == 200);
|
||||
assert(vec._internal_arr[4] == 500);
|
||||
|
||||
// Repeated insert amount 0
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_insert(&vec, 0, 0, 'Z', &err);
|
||||
_vec_int_insert(&vec, 0, 0, 300, &err);
|
||||
assert((err.flags & ERR_SIZE_ZERO) != 0);
|
||||
|
||||
// Vector-from-vector range insert
|
||||
_vec_char_push_back(&other, '1', &err);
|
||||
_vec_char_push_back(&other, '2', &err);
|
||||
_vec_int_push_back(&other, 1, &err);
|
||||
_vec_int_push_back(&other, 2, &err);
|
||||
|
||||
// Double buffer check
|
||||
err = (err_t)ERR_T_INIT;
|
||||
_vec_char_insert(&vec, &vec, 0, 0, 1, &err);
|
||||
_vec_int_insert(&vec, &vec, 0, 0, 1, &err);
|
||||
assert((err.flags & ERR_DOUBLE_BUF) != 0);
|
||||
|
||||
_vec_char_delete(&vec, &err);
|
||||
_vec_char_delete(&other, &err);
|
||||
_vec_int_delete(&vec, &err);
|
||||
_vec_int_delete(&other, &err);
|
||||
printf("Passed\n");
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user