aaro/ScufCont
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Renamed DynArray to DArray and added first tests

Browse Source
This commit is contained in:
Aaro Saila
2026-08-09 23:36:48 +03:00
parent faa660125e
commit 331529a05d
10 changed files with 384 additions and 352 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
tests/cmocka/DArray_tests.c Normal file
View File

@@ -0,0 +1,17 @@
#include <cmocka.h>
#include "DArray.h"
SCDARRAY_HEADER(int, int)
SCDARRAY_IMPL(int, int)
void DArray_alloc_test(void** state) {
(void) state;
SCDArray_int arr;
assert_true(SCDArray_int_alloc(&arr) == SCUFCONT_SUCCESS);
assert_non_null(arr.data);
assert_uint_equal(arr.len, 0u);
assert_uint_equal(arr.capacity, 1u);
}

166
tests/cmocka/DString_tests.c Normal file
View File

@@ -0,0 +1,166 @@
#include <string.h>
#include <stdlib.h>
#include <cmocka.h>
#include "scufcont.h"
#include "DString.h"
void test_SCDString_alloc(void** state) {
(void) state;
const char* c_str = "Hello";
const size_t c_str_len = strlen(c_str);
SCDString dstr;
assert_true(SCDString_alloc(&dstr, c_str, c_str_len) == SCUFCONT_SUCCESS);
assert_memory_equal(dstr.data, c_str, c_str_len + 1);
assert_true(dstr.len == c_str_len);
assert_true(dstr.capacity == c_str_len + 1);
free(dstr.data);
}
void test_SCDString_free(void** state) {
(void) state;
SCDString dstr;
assert_true(SCDString_alloc(&dstr, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
SCDString_free(&dstr);
assert_null(dstr.data);
assert_true(dstr.len == 0);
assert_true(dstr.capacity == 0);
}
void test_SCDString_equal(void** state) {
(void) state;
SCDString s1;
assert_true(SCDString_alloc(&s1, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
SCDString s2;
assert_true(SCDString_alloc(&s2, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
assert_true(SCDString_equal(&s1, &s2));
SCDString_free(&s1);
SCDString_free(&s2);
assert_true(SCDString_alloc(&s1, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
assert_true(SCDString_alloc(&s2, "Hell0", strlen("Hell0")) == SCUFCONT_SUCCESS);
assert_false(SCDString_equal(&s1, &s2));
SCDString_free(&s1);
SCDString_free(&s2);
assert_true(SCDString_alloc(&s1, "Hello World", strlen("Hello World")) == SCUFCONT_SUCCESS);
assert_true(SCDString_alloc(&s2, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
assert_false(SCDString_equal(&s1, &s2));
SCDString_free(&s1);
SCDString_free(&s2);
}
void test_SCDString_equal_c_str(void** state) {
(void) state;
SCDString s1;
assert_true(SCDString_alloc(&s1,"Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
char* s2 = "Hello";
assert_true(SCDString_equal_c_str(&s1, s2));
SCDString_free(&s1);
assert_true(SCDString_alloc(&s1, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
s2 = "Hell0";
assert_false(SCDString_equal_c_str(&s1, s2));
SCDString_free(&s1);
assert_true(SCDString_alloc(&s1, "Hello World", strlen("Hello World")) == SCUFCONT_SUCCESS);
s2 = "Hello";
assert_false(SCDString_equal_c_str(&s1, s2));
SCDString_free(&s1);
}
void test_SCDString_equal_next_chars_c_str(void** state) {
(void) state;
SCDString dstr;
assert_true(SCDString_alloc(&dstr, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
char* str = "ll";
size_t str_len = strlen(str);
assert_true(SCDString_equal_next_chars_c_str(&dstr, str, str_len, 2));
assert_false(SCDString_equal_next_chars_c_str(&dstr, str, str_len, 1));
SCDString_free(&dstr);
}
void test_SCDString_concat_c_str(void** state) {
(void) state;
const char* dstr_c_str = "Hello";
const char* c_str = " World";
const size_t combined_length = strlen(dstr_c_str) + strlen(c_str);
SCDString dstr;
assert_true(SCDString_alloc(&dstr, dstr_c_str, strlen("Hello")) == SCUFCONT_SUCCESS);
SCDString_concat_c_str(&dstr, c_str, strlen(c_str));
assert_memory_equal(dstr.data, (void*) "Hello World\0", strlen("Hello World") + 1);
assert_true(dstr.len == combined_length);
assert_true(dstr.capacity == combined_length + 1);
SCDString_free(&dstr);
}
void test_SCDString_c_str(void** state) {
(void) state;
const char* c_str = "Hello";
SCDString dstr;
assert_true(SCDString_alloc(&dstr, c_str, strlen(c_str)) == SCUFCONT_SUCCESS);
assert_string_equal(c_str, SCDString_c_str(&dstr));
SCDString_concat_c_str(&dstr, " World", strlen(" World"));
assert_string_equal("Hello World", SCDString_c_str(&dstr));
}
void test_SCDString_split(void** state) {
(void) state;
SCDString dstr;
assert_true(SCDString_alloc(&dstr, "Hello World", strlen("Hello World")) == SCUFCONT_SUCCESS);
size_t arr_len = 0;
SCDString* arr = NULL;
ScufContResult res = SCDString_split(&dstr, " ", &arr, &arr_len);
assert_true(res == SCUFCONT_SUCCESS);
assert_true(arr_len == 2);
assert_string_equal(SCDString_c_str(arr), "Hello");
assert_string_equal(SCDString_c_str(arr + 1), "World");
SCDString_free(&dstr);
SCDString_split_arr_free(&arr, arr_len);
assert_true(arr == NULL);
assert_true(SCDString_alloc(&dstr, " Hello World", strlen(" Hello World")) == SCUFCONT_SUCCESS);
arr_len = 0;
res = SCDString_split(&dstr, " ", &arr, &arr_len);
assert_true(arr_len == 3);
assert_string_equal(SCDString_c_str(arr), "");
assert_string_equal(SCDString_c_str(arr + 1), "Hello");
assert_string_equal(SCDString_c_str(arr + 2), "World");
SCDString_free(&dstr);
SCDString_split_arr_free(&arr, arr_len);
assert_true(arr == NULL);
}
int DString_tests_run(void) {
const struct CMUnitTest tests[] = {
cmocka_unit_test(test_SCDString_alloc),
cmocka_unit_test(test_SCDString_free),
cmocka_unit_test(test_SCDString_equal),
cmocka_unit_test(test_SCDString_equal_c_str),
cmocka_unit_test(test_SCDString_equal_next_chars_c_str),
cmocka_unit_test(test_SCDString_concat_c_str),
cmocka_unit_test(test_SCDString_c_str),
cmocka_unit_test(test_SCDString_split),
};
return cmocka_run_group_tests_name("DString", tests, NULL, NULL);
}

165
tests/cmocka/main.c
View File

@@ -1,167 +1,12 @@
#include <string.h>
#include <stdlib.h>
#include <cmocka.h>
#include "scufcont.h"
#include "DynString.h"
void test_DynString_alloc(void** state) {
(void) state;
const char* c_str = "Hello";
const size_t c_str_len = strlen(c_str);
DynString dstr;
assert_true(DynString_alloc(&dstr, c_str, c_str_len) == SCUFCONT_SUCCESS);
assert_memory_equal(dstr.data, c_str, c_str_len + 1);
assert_true(dstr.len == c_str_len);
assert_true(dstr.capacity == c_str_len + 1);
free(dstr.data);
}
void test_DynString_free(void** state) {
(void) state;
DynString dstr;
assert_true(DynString_alloc(&dstr, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
DynString_free(&dstr);
assert_null(dstr.data);
assert_true(dstr.len == 0);
assert_true(dstr.capacity == 0);
}
void test_DynString_equal(void** state) {
(void) state;
DynString s1;
assert_true(DynString_alloc(&s1, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
DynString s2;
assert_true(DynString_alloc(&s2, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
assert_true(DynString_equal(&s1, &s2));
DynString_free(&s1);
DynString_free(&s2);
assert_true(DynString_alloc(&s1, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
assert_true(DynString_alloc(&s2, "Hell0", strlen("Hell0")) == SCUFCONT_SUCCESS);
assert_false(DynString_equal(&s1, &s2));
DynString_free(&s1);
DynString_free(&s2);
assert_true(DynString_alloc(&s1, "Hello World", strlen("Hello World")) == SCUFCONT_SUCCESS);
assert_true(DynString_alloc(&s2, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
assert_false(DynString_equal(&s1, &s2));
DynString_free(&s1);
DynString_free(&s2);
}
void test_DynString_equal_c_str(void** state) {
(void) state;
DynString s1;
assert_true(DynString_alloc(&s1,"Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
char* s2 = "Hello";
assert_true(DynString_equal_c_str(&s1, s2));
DynString_free(&s1);
assert_true(DynString_alloc(&s1, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
s2 = "Hell0";
assert_false(DynString_equal_c_str(&s1, s2));
DynString_free(&s1);
assert_true(DynString_alloc(&s1, "Hello World", strlen("Hello World")) == SCUFCONT_SUCCESS);
s2 = "Hello";
assert_false(DynString_equal_c_str(&s1, s2));
DynString_free(&s1);
}
void test_DynString_equal_next_chars_c_str(void** state) {
(void) state;
DynString dstr;
assert_true(DynString_alloc(&dstr, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
char* str = "ll";
size_t str_len = strlen(str);
assert_true(DynString_equal_next_chars_c_str(&dstr, str, str_len, 2));
assert_false(DynString_equal_next_chars_c_str(&dstr, str, str_len, 1));
DynString_free(&dstr);
}
void test_DynString_concat_c_str(void** state) {
(void) state;
const char* dstr_c_str = "Hello";
const char* c_str = " World";
const size_t combined_length = strlen(dstr_c_str) + strlen(c_str);
DynString dstr;
assert_true(DynString_alloc(&dstr, dstr_c_str, strlen("Hello")) == SCUFCONT_SUCCESS);
DynString_concat_c_str(&dstr, c_str, strlen(c_str));
assert_memory_equal(dstr.data, (void*) "Hello World\0", strlen("Hello World") + 1);
assert_true(dstr.len == combined_length);
assert_true(dstr.capacity == combined_length + 1);
DynString_free(&dstr);
}
void test_DynString_c_str(void** state) {
(void) state;
const char* c_str = "Hello";
DynString dstr;
assert_true(DynString_alloc(&dstr, c_str, strlen(c_str)) == SCUFCONT_SUCCESS);
assert_string_equal(c_str, DynString_c_str(&dstr));
DynString_concat_c_str(&dstr, " World", strlen(" World"));
assert_string_equal("Hello World", DynString_c_str(&dstr));
}
void test_DynString_split(void** state) {
(void) state;
DynString dstr;
assert_true(DynString_alloc(&dstr, "Hello World", strlen("Hello World")) == SCUFCONT_SUCCESS);
size_t arr_len = 0;
DynString* arr = NULL;
ScufContResult res = DynString_split(&dstr, " ", &arr, &arr_len);
assert_true(res == SCUFCONT_SUCCESS);
assert_true(arr_len == 2);
assert_string_equal(DynString_c_str(arr), "Hello");
assert_string_equal(DynString_c_str(arr + 1), "World");
DynString_free(&dstr);
DynString_split_arr_free(&arr, arr_len);
assert_true(arr == NULL);
assert_true(DynString_alloc(&dstr, " Hello World", strlen(" Hello World")) == SCUFCONT_SUCCESS);
arr_len = 0;
res = DynString_split(&dstr, " ", &arr, &arr_len);
assert_true(arr_len == 3);
assert_string_equal(DynString_c_str(arr), "");
assert_string_equal(DynString_c_str(arr + 1), "Hello");
assert_string_equal(DynString_c_str(arr + 2), "World");
DynString_free(&dstr);
DynString_split_arr_free(&arr, arr_len);
assert_true(arr == NULL);
}
int DString_tests_run(void);
int main(void) {
const struct CMUnitTest tests[] = {
cmocka_unit_test(test_DynString_alloc),
cmocka_unit_test(test_DynString_free),
cmocka_unit_test(test_DynString_equal),
cmocka_unit_test(test_DynString_equal_c_str),
cmocka_unit_test(test_DynString_equal_next_chars_c_str),
cmocka_unit_test(test_DynString_concat_c_str),
cmocka_unit_test(test_DynString_c_str),
cmocka_unit_test(test_DynString_split),
};
int failed = 0;
return cmocka_run_group_tests(tests, NULL, NULL);
failed = DString_tests_run();
return failed;
}

1
tests/cmocka/meson.build
View File

@@ -1,5 +1,6 @@
cmocka_tests = executable(
'cmocka_tests',
'DString_tests.c',
'main.c',
include_directories: [
scufcont_include