First commit

tests/cmocka/main.c

@@ -0,0 +1,167 @@
+#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 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),
+    };
+
+    return cmocka_run_group_tests(tests, NULL, NULL);
+}
+

tests/cmocka/meson.build

@@ -0,0 +1,18 @@
+  cmocka_tests = executable(
+    'cmocka_tests',
+    'main.c',
+    include_directories: [
+      scufcont_include
+    ],
+    c_args: [
+      c_args,
+      '-ggdb',
+      '-O0'
+    ],
+    dependencies: [
+      cmocka_dep
+    ],
+    link_with: [ scufcont_lib ]
+  )
+
+  test('cmocka', cmocka_tests)

tests/meson.build

@@ -0,0 +1 @@
+subdir('cmocka')