Added SCDString_concat_char

include/scufcont/DString.h

@@ -28,6 +28,7 @@ bool SCDString_equal_next_chars_c_str(
     const size_t str_len,
     const size_t s
 );
+ScufContResult SCDString_concat_char(SCDString *const dstr, const char ch);
 ScufContResult SCDString_concat_c_str(
     SCDString *const dstr,
     const char *str,

src/DString.c

@@ -97,6 +97,22 @@ bool SCDString_equal_next_chars_c_str(
     return true;
 }
 
+ScufContResult SCDString_concat_char(SCDString *const dstr, const char ch) {
+    const size_t new_len = dstr->len + 1;
+    if (new_len > dstr->capacity) {
+        ScufContResult res = SCDString_reserve(dstr, new_len + 1);
+        if (res != SCUFCONT_SUCCESS) {
+            return res;
+        }
+    }
+
+    dstr->data[new_len - 1] = ch;
+    dstr->data[new_len] = '\0';
+    dstr->len = new_len;
+
+    return SCUFCONT_SUCCESS;
+}
+
 ScufContResult SCDString_concat_c_str(
     SCDString *const dstr,
     const char *str,

src/scufcont.c

@@ -9,5 +9,7 @@ const char* ScufContResult_to_str(const ScufContResult res) {
 
     switch (res) {
     SCUFCONT_RESULT_X(ScufContResult_to_str_case)
+    default:
+        return "INVALID ScufContResult";
     }
 }

tests/cmocka/DString_tests.c

@@ -1,15 +1,15 @@
-#include <string.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include <cmocka.h>
 
-#include "scufcont/scufcont.h"
 #include "scufcont/DString.h"
+#include "scufcont/scufcont.h"
 
-void test_SCDString_alloc(void** state) {
+void test_SCDString_alloc(void **state) {
     (void) state;
 
-    const char* c_str = "Hello";
+    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);
@@ -21,7 +21,7 @@ void test_SCDString_alloc(void** state) {
     free(dstr.data);
 }
 
-void test_SCDString_free(void** state) {
+void test_SCDString_free(void **state) {
     (void) state;
 
     SCDString dstr;
@@ -34,7 +34,7 @@ void test_SCDString_free(void** state) {
     assert_true(dstr.capacity == 0);
 }
 
-void test_SCDString_equal(void** state) {
+void test_SCDString_equal(void **state) {
     (void) state;
 
     SCDString s1;
@@ -58,12 +58,12 @@ void test_SCDString_equal(void** state) {
     SCDString_free(&s2);
 }
 
-void test_SCDString_equal_c_str(void** state) {
+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_alloc(&s1, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
+    char *s2 = "Hello";
     assert_true(SCDString_equal_c_str(&s1, s2));
     SCDString_free(&s1);
 
@@ -78,40 +78,54 @@ void test_SCDString_equal_c_str(void** state) {
     SCDString_free(&s1);
 }
 
-void test_SCDString_equal_next_chars_c_str(void** state) {
+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";
+    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 test_SCDString_concat_char(void **state) {
+    (void) state;
+
+    SCDString dstr;
+    assert_true(SCDString_alloc(&dstr, "World", strlen("World")) == SCUFCONT_SUCCESS);
+    assert_string_equal(dstr.data, "World");
+
+    SCDString_concat_char(&dstr, 'l');
+    assert_string_equal(dstr.data, "Worldl");
+
+    SCDString_concat_char(&dstr, 'y');
+    assert_string_equal(dstr.data, "Worldly");
+}
+
+void test_SCDString_concat_c_str(void **state) {
     (void) state;
 
-    const char* dstr_c_str = "Hello";
-    const char* c_str = " World";
+    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_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 test_SCDString_c_str(void **state) {
     (void) state;
 
-    const char* c_str = "Hello";
+    const char *c_str = "Hello";
     SCDString dstr;
     assert_true(SCDString_alloc(&dstr, c_str, strlen(c_str)) == SCUFCONT_SUCCESS);
 
@@ -122,13 +136,13 @@ void test_SCDString_c_str(void** state) {
     assert_string_equal("Hello World", SCDString_c_str(&dstr));
 }
 
-void test_SCDString_split(void** state) {
+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;
+    SCDString *arr = NULL;
     ScufContResult res = SCDString_split(&dstr, " ", &arr, &arr_len);
     assert_true(res == SCUFCONT_SUCCESS);
     assert_true(arr_len == 2);
@@ -157,6 +171,7 @@ int DString_tests_run(void) {
         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_char),
         cmocka_unit_test(test_SCDString_concat_c_str),
         cmocka_unit_test(test_SCDString_c_str),
         cmocka_unit_test(test_SCDString_split),