TestString.c

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

#include "string.h"
#include "exception.h"
#include "TestString.h"

bool TestCreate()
{
    const size_t length = 10;
    string* str = STRING.Create(length);

    if (str == NULL) {
        printf("Test failed: Create() returned NULL\n");
        ClearException();
        return false;
    }

    if (str->length != length) {
        printf("Test failed: length is not equal to %zu\n", length);
        STRING.Free(&str);
        ClearException();
        return false;
    }

    if (str->chars[length] != '\0') {
        printf("Test failed: chars[%zu] is not equal to \\0\n", length);
        STRING.Free(&str);
        ClearException();
        return false;
    }

    if (str->info != &STRING) {
        printf("Test failed: info is not equal to &STRING\n");
        STRING.Free(&str);
        ClearException();
        return false;
    }

    STRING.Free(&str);
    ClearException();
    return true;
}

bool TestCopy() {
    const char* test_string = "Test string";
    string* str = STRING.Create(0);

    for (size_t i = 0; i < strlen(test_string); ++i)
        STRING.Add(str, test_string[i]);

    string* copy = STRING.Copy(str);

    if (copy == NULL) {
        printf("Test failed: Copy() returned NULL\n");
        STRING.Free(&str);
        ClearException();
        return false;
    }

    if (strcmp(copy->chars, str->chars) != 0) {
        printf("Test failed: copied string does not match the original string\n");
        STRING.Free(&str);
        STRING.Free(&copy);
        ClearException();
        return false;
    }

    if (copy->info != &STRING) {
        printf("Test failed: info is not equal to &STRING\n");
        STRING.Free(&str);
        STRING.Free(&copy);
        ClearException();
        return false;
    }

    STRING.Free(&copy);

    STRING.Copy(NULL);

    if (!IsException() || GetException().type != ErrorPointerIsEmpty)
    {
        printf("Test failed[Copy]: check throw exception by str\n");
        STRING.Free(&str);
        STRING.Free(&copy);
        ClearException();
        return false;
    }

    ClearException();

    str->info = NULL;
    STRING.Copy(str);

    if (!IsException() || GetException().type != ErrorPointerIsEmpty)
    {
        printf("Test failed[Copy]: check throw exception by str info\n");
        STRING.Free(&str);
        STRING.Free(&copy);
        ClearException();
        return false;
    }

    ClearException();
    return true;
}

bool TestFree() {
    const char* test_string = "Test string";
    string* str = STRING.Create(0);

    for (size_t i = 0; i < strlen(test_string); ++i)
        STRING.Add(str, test_string[i]);

    // Проверяем, что функция не вызывает ошибок
    STRING.Free(&str);

    if (IsException())
    {
        printf("Test failed: first free\n");
        return false;
    }

    // Проверяем, что функция не пытается освободить уже освобожденную строку
    STRING.Free(&str);

    if (!IsException())
    {
        printf("Test failed: double free is broke\n");
        return false;
    }

    ClearException();

    STRING.Free(NULL);

    if (!IsException() || GetException().type != ErrorPointerIsEmpty)
    {
        printf("Test failed[Free]: check throw exception by str\n");
        ClearException();
        return false;
    }

    ClearException();

    str = STRING.Create(0);

    for (size_t i = 0; i < strlen(test_string); ++i)
        STRING.Add(str, test_string[i]);

    str->info = NULL;
    STRING.Free(&str);

    if (!IsException() || GetException().type != ErrorPointerIsEmpty)
    {
        printf("Test failed[Free]: check throw exception by str info\n");
        STRING.Free(&str);
        ClearException();
        return false;
    }

    ClearException();
    return true;
}

bool TestCompare() {
    const char* test_string1 = "Test string";
    const char* test_string2 = "test string";
    const char* test_string3 = "Test string2";
    string* str1 = STRING.Create(0);
    string* str2 = STRING.Create(0);
    string* str3 = STRING.Create(0);

    for (size_t i = 0; i < strlen(test_string1); ++i)
        STRING.Add(str1, test_string1[i]);

    for (size_t i = 0; i < strlen(test_string2); ++i)
        STRING.Add(str2, test_string2[i]);

    for (size_t i = 0; i < strlen(test_string3); ++i)
        STRING.Add(str3, test_string3[i]);

    // Проверяем, что функция возвращает 0 при сравнении строк с одинаковым содержимым
    if (STRING.Compare(str1, str1, true) != 0) {
        printf("Test failed: compare str1 and str1 with sensitive\n");
        return false;
    }

    // Проверяем, что функция возвращает отрицательное значение, когда первая строка меньше второй
    if (STRING.Compare(str1, str3, true) >= 0) {
        printf("Test failed: compare str1 and str3 with sensitive\n");
        return false;
    }

    // Проверяем, что функция возвращает положительное значение, когда первая строка больше второй
    if (STRING.Compare(str3, str1, true) <= 0) {
        printf("Test failed: compare str3 and str1 with sensitive\n");
        return false;
    }

    // Проверяем, что функция возвращает корректное значение при использовании регистронезависимого сравнения
    if (STRING.Compare(str1, str2, false) != 0) {
        printf("Test failed: compare str1 and str2 with no sensitive\n");
        return false;
    }

    STRING.Compare(NULL, NULL, true);

    if (!IsException() || GetException().type != ErrorPointerIsEmpty)
    {
        printf("Test failed[Compare]: check throw exception by str\n");
        STRING.Free(&str1);
        STRING.Free(&str2);
        STRING.Free(&str3);
        ClearException();
        return false;
    }

    ClearException();

    str1->info = NULL;
    STRING.Compare(str1, str1, true);

    if (!IsException() || GetException().type != ErrorPointerIsEmpty)
    {
        printf("Test failed[Compare]: check throw exception by str info\n");
        STRING.Free(&str1);
        STRING.Free(&str2);
        STRING.Free(&str3);
        ClearException();
        return false;
    }

    STRING.Free(&str1);
    STRING.Free(&str2);
    STRING.Free(&str3);

    ClearException();
    return true;
}

bool TestSet() {
    // Создание строки
    string* str = STRING.Create(10);

    // Установка символов
    STRING.Set(str, 0, 'a');
    STRING.Set(str, 1, 'b');
    STRING.Set(str, 2, 'c');

    // Проверка значений символов
    if (str->chars[0] != 'a' || str->chars[1] != 'b' || str->chars[2] != 'c') {
        return false;
    }

    // Установка символа в недопустимую позицию
    STRING.Set(str, 10, 'd');
    bool exceptionThrown = IsException();

    STRING.Set(NULL, 6, 'd');

    if (!IsException() || GetException().type != ErrorPointerIsEmpty)
    {
        printf("Test failed[Set]: check throw exception by str\n");
        STRING.Free(&str);
        ClearException();
        return false;
    }

    ClearException();

    str->info = NULL;
    STRING.Set(str, 6, 'a');

    if (!IsException() || GetException().type != ErrorPointerIsEmpty) {
        printf("Test failed[Set]: check throw exception by str info\n");
        STRING.Free(&str);
        ClearException();
        return false;
    }

    // Освобождение памяти
    STRING.Free(&str);

    ClearException();
    return exceptionThrown;
}

bool TestGet()
{
    string* str = STRING.Create(10);
    strcpy(str->chars, "abcdefghij");

    // Тестируем Get с корректными аргументами
    char result1 = STRING.Get(str, 0);
    char expected1 = 'a';
    if (result1 != expected1) {
        printf("Ошибка: ожидаемый результат '%c', полученный результат '%c'\n", expected1, result1);
    }

    // Тестируем Get с некорректным значением позиции
    char result2 = STRING.Get(str, 11);
    char expected2 = '\0';
    if (result2 != expected2) {
        printf("Ошибка: ожидаемый результат '%c', полученный результат '%c'\n", expected2, result2);
    }

    STRING.Get(NULL, 6);

    if (!IsException() || GetException().type != ErrorPointerIsEmpty)
    {
        printf("Test failed[Get]: check throw exception by str\n");
        STRING.Free(&str);
        ClearException();
        return false;
    }

    ClearException();

    str->info = NULL;
    STRING.Get(str, 6);

    if (!IsException() || GetException().type != ErrorPointerIsEmpty) {
        printf("Test failed[Get]: check throw exception by str info\n");
        STRING.Free(&str);
        ClearException();
        return false;
    }

    // Освобождаем память, выделенную для тестовой строки
    STRING.Free(&str);

    ClearException();
    return true;
}

bool TestSum() {
    // Testing successful execution of the function
    const char* test_str1 = "hello";
    const char* test_str2 = " world";

    string* str1 = STRING.Create(0);
    string* str2 = STRING.Create(0);

    for (size_t i = 0; i < strlen(test_str1); ++i)
        STRING.Add(str1, test_str1[i]);

    for (size_t i = 0; i < strlen(test_str2); ++i)
        STRING.Add(str2, test_str2[i]);

    string* result = STRING.Sum(str1, str2);

    if (strcmp(result->chars, "hello world") != 0) {
        printf("Error: the result of the function does not match the expected result.\n");
        STRING.Free(&str1);
        STRING.Free(&str2);
        STRING.Free(&result);
        return false;
    }

    if (result->length != 12) {
        printf("Error: the length of the result of the function does not match the expected length.\n");
        STRING.Free(&str1);
        STRING.Free(&str2);
        STRING.Free(&result);
        return false;
    }

    STRING.Free(&result);

    // Testing returning NULL with incorrect input data
    result = STRING.Sum(str1, NULL);

    if (result != NULL) {
        printf("Error: the function should have returned NULL when passing incorrect input data.\n");
        STRING.Free(&str1);
        STRING.Free(&str2);
        STRING.Free(&result);
        return false;
    }

    STRING.Free(&result);
    ClearException();

    // Testing returning NULL with incorrect input data
    result = STRING.Sum(NULL, str2);

    if (result != NULL) {
        printf("Error: the function should have returned NULL when passing incorrect input data.\n");
        STRING.Free(&str1);
        STRING.Free(&str2);
        STRING.Free(&result);
        return false;
    }

    ClearException();
    STRING.Sum(NULL, NULL);

    if (!IsException() || GetException().type != ErrorPointerIsEmpty)
    {
        printf("Test failed[Sum]: check throw exception by str\n");
        STRING.Free(&str1);
        STRING.Free(&str2);
        ClearException();
        return false;
    }

    ClearException();

    str1->info = NULL;
    STRING.Sum(str1, str1);

    if (!IsException() || GetException().type != ErrorPointerIsEmpty) {
        printf("Test failed[Sum]: check throw exception by str info\n");
        STRING.Free(&str1);
        STRING.Free(&str2);
        ClearException();
        return false;
    }

    STRING.Free(&result);
    STRING.Free(&str1);
    STRING.Free(&str2);

    ClearException();
    return true;
}

bool TestAdd() {
    // Testing successful execution of the function
    const char* str = "hello";
    string* string_obj = STRING.Create(0);

    for (size_t i = 0; i < strlen(str); ++i)
        STRING.Add(string_obj, str[i]);

    STRING.Add(string_obj, '!');

    if (strcmp(string_obj->chars, "hello!") != 0) {
        printf("Error: the result of the function does not match the expected result.\n");
        STRING.Free(&string_obj);
        return false;
    }

    if (string_obj->length != 6) {
        printf("Error: the length of the result of the function does not match the expected length.\n");
        STRING.Free(&string_obj);
        return false;
    }

    STRING.Free(&string_obj);
    ClearException();

    STRING.Add(NULL, '!');

    if (!IsException() || GetException().type != ErrorPointerIsEmpty)
    {
        printf("Test failed[Add]: check throw exception by str\n");
        STRING.Free(&string_obj);
        ClearException();
        return false;
    }

    ClearException();

    string_obj = STRING.Create(0);

    for (size_t i = 0; i < strlen(str); ++i)
        STRING.Add(string_obj, str[i]);

    string_obj->info = NULL;
    STRING.Add(string_obj, '!');

    if (!IsException() || GetException().type != ErrorPointerIsEmpty) {
        printf("Test failed[Add]: check throw exception by str info\n");
        STRING.Free(&string_obj);
        ClearException();
        return false;
    }

    STRING.Free(&string_obj);
    ClearException();
    return true;
}

bool TestSubStr() {
    // Testing successful execution of the function
    const char* str = "hello world";
    string* string_obj = STRING.Create(0);

    for (size_t i = 0; i < strlen(str); ++i)
        STRING.Add(string_obj, str[i]);

    string* new_string_obj = STRING.SubStr(string_obj, 0, 5);

    if (strcmp(new_string_obj->chars, "hello") != 0) {
        printf("Error: the result of the function does not match the expected result.\n");
        STRING.Free(&new_string_obj);
        STRING.Free(&string_obj);
        return false;
    }

    if (new_string_obj->length != 5) {
        printf("Error: the length of the result of the function does not match the expected length.\n");
        STRING.Free(&new_string_obj);
        STRING.Free(&string_obj);
        return false;
    }

    STRING.Free(&new_string_obj);

    // Testing returning NULL with incorrect input data
    ClearException();
    new_string_obj = STRING.SubStr(string_obj, 6, 5);

    if (new_string_obj != NULL) {
        printf("Error: the function should have returned NULL when passing incorrect input data.\n");
        STRING.Free(&new_string_obj);
        STRING.Free(&string_obj);
        return false;
    }

    ClearException();
    STRING.Free(&new_string_obj);
    new_string_obj = STRING.SubStr(string_obj, 0, 11);

    if (new_string_obj != NULL) {
        printf("Error: the function should have returned NULL when passing incorrect input data.\n");
        STRING.Free(&new_string_obj);
        STRING.Free(&string_obj);
        return false;
    }

    ClearException();
    STRING.Free(&new_string_obj);
    new_string_obj = STRING.SubStr(string_obj, 6, 4);

    if (new_string_obj != NULL) {
        printf("Error: the function should have returned NULL when passing incorrect input data.\n");
        STRING.Free(&new_string_obj);
        STRING.Free(&string_obj);
        return false;
    }

    ClearException();

    STRING.SubStr(NULL, 1, 1);

    if (!IsException() || GetException().type != ErrorPointerIsEmpty)
    {
        printf("Test failed[SubStr]: check throw exception by str\n");
        STRING.Free(&string_obj);
        ClearException();
        return false;
    }

    ClearException();

    string_obj->info = NULL;
    STRING.SubStr(string_obj, 1, 1);

    if (!IsException() || GetException().type != ErrorPointerIsEmpty) {
        printf("Test failed[SubStr]: check throw exception by str info\n");
        STRING.Free(&string_obj);
        ClearException();
        return false;
    }

    STRING.Free(&new_string_obj);
    STRING.Free(&string_obj);

    ClearException();
    return true;
}

bool TestFindSub()
{
    const char* test_str1 = "The quick brown fox jumps over the lazy dog";
    const char* test_what1 = "fox";

    string* str1 = STRING.Create(0);
    string* what1 = STRING.Create(0);

    for (size_t i = 0; i < strlen(test_str1); ++i)
        STRING.Add(str1, test_str1[i]);

    for (size_t i = 0; i < strlen(test_what1); ++i)
        STRING.Add(what1, test_what1[i]);

    size_t from1 = 0;
    bool caseSensitive1 = true;
    int expected1 = 16;
    size_t actual1 = STRING.FindSub(str1, what1, from1, caseSensitive1);

    if (actual1 != expected1) {
        printf("Test failed: FindSub with sensitive\n");
        STRING.Free(&str1);
        STRING.Free(&what1);
        return false;
    }

    STRING.Free(&str1);
    STRING.Free(&what1);

    const char* test_str2 = "The quick brown fox jumps over the lazy dog";
    const char*  test_what2 = "DOG";

    string* str2 = STRING.Create(0);
    string* what2 = STRING.Create(0);

    for (size_t i = 0; i < strlen(test_str2); ++i)
        STRING.Add(str2, test_str2[i]);

    for (size_t i = 0; i < strlen(test_what2); ++i)
        STRING.Add(what2, test_what2[i]);

    size_t from2 = 0;
    bool caseSensitive2 = false;
    int expected2 = 40;
    size_t actual2 = STRING.FindSub(str2, what2, from2, caseSensitive2);

    if (actual2 != expected2) {
        printf("Test failed: FindSub without sensitive\n");
        STRING.Free(&str2);
        STRING.Free(&what2);
        return false;
    }

    ClearException();

    STRING.FindSub(NULL, NULL, 1, true);

    if (!IsException() || GetException().type != ErrorPointerIsEmpty)
    {
        printf("Test failed[FindSub]: check throw exception by str\n");
        STRING.Free(&str2);
        STRING.Free(&what2);
        ClearException();
        return false;
    }

    ClearException();

    str2->info = NULL;
    what2->info = NULL;
    STRING.FindSub(str2, what2, 1, true);

    if (!IsException() || GetException().type != ErrorPointerIsEmpty) {
        printf("Test failed[FindSub]: check throw exception by str info\n");
        STRING.Free(&str2);
        STRING.Free(&what2);
        ClearException();
        return false;
    }

    STRING.Free(&str1);
    STRING.Free(&what1);
    ClearException();
    return true;
}

bool AllTestString()
{
    if (TestCreate())
        printf("[Test group string Create passed]\n");
    else
        return false;

    if (TestCopy())
        printf("[Test group string Copy passed]\n");
    else
        return false;

    if (TestFree())
        printf("[Test group string Free passed]\n");
    else
        return false;

    if (TestCompare())
        printf("[Test group string Compare passed]\n");
    else
        return false;

    if (TestSet())
        printf("[Test group string Set passed]\n");
    else
        return false;

    if (TestGet())
        printf("[Test group string Get passed]\n");
    else
        return false;

    if (TestSum())
        printf("[Test group string Sum passed]\n");
    else
        return false;

    if (TestAdd())
        printf("[Test group string Add passed]\n");
    else
        return false;

    if (TestSubStr())
        printf("[Test group string SubStr passed]\n");
    else
        return false;

    if (TestFindSub())
        printf("[Test group string FindSub passed]\n");
    else
        return false;

    return true;
}