scufcont/tests/cmocka/DString_tests.c

#include <stdlib.h>
#include <string.h>

#include <cmocka.h>

#include "scufcont/DString.h"
#include "scufcont/scufcont.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_alloc_copy(void **state) {
    (void) state;

    SCDString dstr;
    assert_true(SCDString_alloc(&dstr, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), "Hello");
    assert_uint_equal(dstr.len, strlen("Hello"));

    SCDString cpy;
    assert_true(SCDString_alloc_copy(&cpy, &dstr) == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), "Hello");
    assert_uint_equal(dstr.len, strlen("Hello"));

    SCDString_free(&dstr);
    SCDString_free(&cpy);
}

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_copy(void **state) {
    (void) state;

    SCDString dstr1;
    assert_true(SCDString_alloc(&dstr1, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr1), "Hello");

    SCDString dstr2;
    assert_true(SCDString_alloc(&dstr2, "foo", strlen("foo")) == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr2), "foo");

    assert_true(SCDString_copy(&dstr1, &dstr2) == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr2), "Hello");
    assert_uint_equal(dstr2.len, dstr1.len);
    assert_uint_equal(dstr2.capacity, dstr1.len + 1);

    SCDString_free(&dstr1);
    SCDString_free(&dstr2);
}

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_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");

    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_find_first_c_str(void **state) {
    (void) state;

    SCDString dstr;
    char *substr;
    size_t at;

    assert_true(SCDString_alloc(&dstr, "Hello World", strlen("Hello World")) == SCUFCONT_SUCCESS);
    substr = "o";
    assert_true(SCDString_find_first_c_str(&dstr, substr, 1, &at));
    assert_uint_equal(at, 4);

    substr = "lo Worl";
    assert_true(SCDString_find_first_c_str(&dstr, substr, strlen(substr), &at));
    assert_uint_equal(at, 3);

    SCDString_free(&dstr);
}

void test_SCDString_find_last_c_str(void **state) {
    (void) state;

    SCDString dstr;
    char *substr;
    size_t at;

    assert_true(SCDString_alloc(&dstr, "Hello World", strlen("Hello World")) == SCUFCONT_SUCCESS);
    substr = "o";
    assert_true(SCDString_find_last_c_str(&dstr, substr, 1, &at));
    assert_uint_equal(at, 7);

    substr = "lo Worl";
    assert_true(SCDString_find_last_c_str(&dstr, substr, strlen(substr), &at));
    assert_uint_equal(at, 3);

    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);
}

void test_SCDString_char_mod(void **state) {
    (void) state;

    SCDString dstr;
    assert_true(SCDString_alloc(&dstr, "foo", strlen("foo")) == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), "foo");

    assert_true(SCDString_char_mod(&dstr, 0, 'h') == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), "hoo");

    assert_true(SCDString_char_mod(&dstr, 1, 'a') == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), "hao");

    assert_true(SCDString_char_mod(&dstr, 2, 'b') == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), "hab");

    assert_true(SCDString_char_mod(&dstr, 3, 'b') == SCUFCONT_OUT_OF_BOUNDS);
    assert_string_equal(SCDString_c_str(&dstr), "hab");

    SCDString_free(&dstr);
}

void test_SCDString_char_remove(void **state) {
    (void) state;

    char *text = "World";
    SCDString dstr;
    assert_true(SCDString_alloc(&dstr, text, strlen(text)) == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), text);
    assert_uint_equal(dstr.len, strlen(text));

    text = "Worl";
    assert_true(SCDString_char_remove(&dstr, dstr.len - 1) == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), text);
    assert_uint_equal(dstr.len, strlen(text));

    text = "Wol";
    assert_true(SCDString_char_remove(&dstr, 2) == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), text);
    assert_uint_equal(dstr.len, strlen(text));

    text = "ol";
    assert_true(SCDString_char_remove(&dstr, 0) == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), text);
    assert_uint_equal(dstr.len, strlen(text));

    assert_true(SCDString_char_remove(&dstr, dstr.len) == SCUFCONT_OUT_OF_BOUNDS);
    assert_string_equal(SCDString_c_str(&dstr), text);
    assert_uint_equal(dstr.len, strlen(text));

    SCDString_free(&dstr);
}

void test_SCDString_char_insert(void **state) {
    (void) state;

    SCDString dstr;
    assert_true(SCDString_alloc(&dstr, "World", strlen("World")) == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), "World");
    assert_uint_equal(dstr.len, strlen("World"));

    assert_true(SCDString_char_insert(&dstr, 0, 'H') == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), "HWorld");
    assert_uint_equal(dstr.len, strlen("HWorld"));

    assert_true(SCDString_char_insert(&dstr, 1, ' ') == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), "H World");
    assert_uint_equal(dstr.len, strlen("H World"));

    assert_true(SCDString_char_insert(&dstr, 1, 'i') == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), "Hi World");
    assert_uint_equal(dstr.len, strlen("Hi World"));

    assert_true(SCDString_char_insert(&dstr, dstr.len, '!') == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), "Hi World!");
    assert_uint_equal(dstr.len, strlen("Hi World!"));

    assert_true(SCDString_char_insert(&dstr, 8, 's') == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), "Hi Worlds!");
    assert_uint_equal(dstr.len, strlen("Hi Worlds!"));

    SCDString_free(&dstr);
}

void test_SCDString_truncate(void **state) {
    (void) state;

    SCDString dstr;
    assert_true(SCDString_alloc(&dstr, "Hello World", strlen("Hello World")) == SCUFCONT_SUCCESS);

    SCDString_truncate(&dstr, 5);
    assert_string_equal(SCDString_c_str(&dstr), "Hello");

    SCDString_truncate(&dstr, 0);
    assert_string_equal(SCDString_c_str(&dstr), "");
}

void test_SCDString_replace_c_str(void **state) {
    (void) state;

    SCDString dstr;
    assert_true(SCDString_alloc(&dstr, "Hello", strlen("Hello")) == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), "Hello");
    assert_uint_equal(dstr.len, 5);

    assert_true(SCDString_replace_c_str(&dstr, "World!", strlen("World!")) == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), "World!");
    assert_uint_equal(dstr.len, 6);

    SCDString_free(&dstr);
}

void test_SCDString_trim_whitespace(void **state) {
    (void) state;

    SCDString dstr;
    const char *str = "    Hello World        ";
    const size_t str_len = strlen(str);
    assert_true(SCDString_alloc(&dstr, str, str_len) == SCUFCONT_SUCCESS);
    assert_string_equal(SCDString_c_str(&dstr), str);
    assert_uint_equal(dstr.len, str_len);

    SCDString_trim_whitespace(&dstr);
    assert_string_equal(SCDString_c_str(&dstr), "Hello World");

    SCDString_free(&dstr);
}

int DString_tests_run(void) {
    const struct CMUnitTest tests[] = {
        cmocka_unit_test(test_SCDString_alloc),
        cmocka_unit_test(test_SCDString_alloc_copy),
        cmocka_unit_test(test_SCDString_free),
        cmocka_unit_test(test_SCDString_copy),
        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_find_first_c_str),
        cmocka_unit_test(test_SCDString_find_last_c_str),
        cmocka_unit_test(test_SCDString_c_str),
        cmocka_unit_test(test_SCDString_split),
        cmocka_unit_test(test_SCDString_char_mod),
        cmocka_unit_test(test_SCDString_char_remove),
        cmocka_unit_test(test_SCDString_char_insert),
        cmocka_unit_test(test_SCDString_truncate),
        cmocka_unit_test(test_SCDString_replace_c_str),
        cmocka_unit_test(test_SCDString_trim_whitespace),
    };

    return cmocka_run_group_tests_name("DString", tests, NULL, NULL);
}