src/tests/test_str.c - develop - solidbase/C3_s21_stringplus

src/tests/test_str.c
952 строки29 KB
maxiewal
valgrind and cppcheck
04 фев 2026, 17:55
04 фев 2026, 17:55314143b
#include <check.h>
#include <stdlib.h>
#include <string.h>

#include "../s21_string.h"

// 5. Appends the string pointed to, by src to the end of the string pointed to,
// by dest up to n characters long.
// char* s21_strncat(char* dest, const char* src, s21_size n);

START_TEST(s21_strncat_test_basic) {
  char dest_s21[50] = "Hello";
  char dest_std[50] = "Hello";
  const char* src = " World";

  char* result_s21 = s21_strncat(dest_s21, src, 6);
  char* result_std = strncat(dest_std, src, 6);

  ck_assert_str_eq(result_s21, result_std);
  ck_assert_ptr_eq(result_s21, dest_s21);
}
END_TEST

START_TEST(s21_strncat_test_partial) {
  char dest_s21[50] = "Hello";
  char dest_std[50] = "Hello";
  const char* src = " World";

  s21_strncat(dest_s21, src, 3);
  strncat(dest_std, src, 3);

  ck_assert_str_eq(dest_s21, dest_std);
}
END_TEST

START_TEST(s21_strncat_test_empty_src) {
  char dest_s21[50] = "Hello";
  char dest_std[50] = "Hello";
  const char* src = "";

  s21_strncat(dest_s21, src, 5);
  strncat(dest_std, src, 5);

  ck_assert_str_eq(dest_s21, dest_std);
}
END_TEST

START_TEST(s21_strncat_test_empty_dest) {
  char dest_s21[50] = "";
  char dest_std[50] = "";
  const char* src = "Hello";

  s21_strncat(dest_s21, src, 5);
  strncat(dest_std, src, 5);

  ck_assert_str_eq(dest_s21, dest_std);
}
END_TEST

START_TEST(s21_strncat_test_zero_n) {
  char dest_s21[50] = "Hello";
  char dest_std[50] = "Hello";
  const char* src = " World";

  s21_strncat(dest_s21, src, 0);
  strncat(dest_std, src, 0);

  ck_assert_str_eq(dest_s21, dest_std);
}
END_TEST

START_TEST(s21_strncat_test_n_larger_than_src) {
  char dest_s21[50] = "Hello";
  char dest_std[50] = "Hello";
  const char* src = " Hi";

  s21_strncat(dest_s21, src, 10);
  strncat(dest_std, src, 10);

  ck_assert_str_eq(dest_s21, dest_std);
}
END_TEST

START_TEST(s21_strncat_test_special_chars) {
  char dest_s21[50] = "Test";
  char dest_std[50] = "Test";
  const char* src = "\t\n\r";

  s21_strncat(dest_s21, src, 3);
  strncat(dest_std, src, 3);

  ck_assert_str_eq(dest_s21, dest_std);
}
END_TEST

//------------------------------------------------------------------------------
// 6. Searches for the first occurrence of the character c (an unsigned char) in
// the string pointed to, by the argument str.
// char *s21_strchr(const char *str, int c);

// Test 1: Character found
START_TEST(test_strchr_found) {
  char str[] = "Hello, World!";
  char* result_s21 = s21_strchr(str, 'W');
  char* result_std = strchr(str, 'W');
  ck_assert_ptr_eq(result_s21, result_std);
}
END_TEST

// Test 2: Character not found
START_TEST(test_strchr_not_found) {
  char str[] = "Hello, World!";
  char* result_s21 = s21_strchr(str, 'Z');
  char* result_std = strchr(str, 'Z');
  ck_assert_ptr_eq(result_s21, result_std);
}
END_TEST

// Test 3: Null character
START_TEST(test_strchr_null_char) {
  char str[] = "Hello";
  char* result_s21 = s21_strchr(str, '\0');
  char* result_std = strchr(str, '\0');
  ck_assert_ptr_eq(result_s21, result_std);
}
END_TEST

// Test 4: First character
START_TEST(test_strchr_first_char) {
  char str[] = "Hello";
  char* result_s21 = s21_strchr(str, 'H');
  char* result_std = strchr(str, 'H');
  ck_assert_ptr_eq(result_s21, result_std);
}
END_TEST

//------------------------------------------------------------------------------
// 7. Compares at most the first n bytes of str1 and str2.
// int s21_strncmp(const char *str1, const char *str2, s21_size n);

START_TEST(test_strncmp_equal) {
  char str1[] = "Hello";
  char str2[] = "Hello";
  int result_s21 = s21_strncmp(str1, str2, 5);
  int result_std = strncmp(str1, str2, 5);
  ck_assert_int_eq(result_s21, result_std);
}
END_TEST

START_TEST(test_strncmp_less) {
  char str1[] = "Hello";
  char str2[] = "World";
  int result_s21 = s21_strncmp(str1, str2, 5);
  int result_std = strncmp(str1, str2, 5);
  ck_assert_int_lt(result_s21, 0);
  ck_assert_int_lt(result_std, 0);
}
END_TEST

START_TEST(test_strncmp_greater) {
  char str1[] = "World";
  char str2[] = "Hello";
  int result_s21 = s21_strncmp(str1, str2, 5);
  int result_std = strncmp(str1, str2, 5);
  ck_assert_int_gt(result_s21, 0);
  ck_assert_int_gt(result_std, 0);
}
END_TEST

START_TEST(test_strncmp_partial) {
  char str1[] = "Hello";
  char str2[] = "Help";
  int result_s21 = s21_strncmp(str1, str2, 3);
  int result_std = strncmp(str1, str2, 3);
  ck_assert_int_eq(result_s21, result_std);
}
END_TEST

//------------------------------------------------------------------------------
// 8. Copies up to n characters from the string pointed to, by src to dest.
// char *s21_strncpy(char *dest, const char *src, s21_size n);

START_TEST(test_strncpy_basic) {
  char src[] = "Hello";
  char dest_s21[20] = {0};
  char dest_std[20] = {0};

  s21_strncpy(dest_s21, src, 5);
  strncpy(dest_std, src, 5);

  ck_assert_mem_eq(dest_s21, dest_std, 20);
}
END_TEST

START_TEST(test_strncpy_with_padding) {
  char src[] = "Hi";
  char dest_s21[10] = "xxxxxxxxxx";
  char dest_std[10] = "xxxxxxxxxx";

  s21_strncpy(dest_s21, src, 10);
  strncpy(dest_std, src, 10);

  ck_assert_mem_eq(dest_s21, dest_std, 10);
}
END_TEST

START_TEST(test_strncpy_partial) {
  char src[] = "Hello, World!";
  char dest_s21[20] = {0};
  char dest_std[20] = {0};

  s21_strncpy(dest_s21, src, 5);
  strncpy(dest_std, src, 5);

  ck_assert_mem_eq(dest_s21, dest_std, 20);
}
END_TEST

START_TEST(test_strncpy_zero_bytes) {
  char src[] = "Hello";
  char dest_s21[10] = "World";
  char dest_std[10] = "World";

  s21_strncpy(dest_s21, src, 0);
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstringop-truncation"
#endif
  strncpy(dest_std, src, 0);
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif

  ck_assert_mem_eq(dest_s21, dest_std, 10);
}
END_TEST

//------------------------------------------------------------------------------
// 9. Calculates the length of the initial segment of str1 which consists
// entirely of characters not in str2.
// s21_size s21_strcspn(const char *str1, const char *str2);

START_TEST(test_strcspn_found) {
  char str1[] = "Hello, World!";
  char str2[] = "World";
  s21_size result_s21 = s21_strcspn(str1, str2);
  size_t result_std = strcspn(str1, str2);
  ck_assert_int_eq(result_s21, result_std);
}
END_TEST

START_TEST(test_strcspn_not_found) {
  char str1[] = "Hello";
  char str2[] = "xyz";
  s21_size result_s21 = s21_strcspn(str1, str2);
  size_t result_std = strcspn(str1, str2);
  ck_assert_int_eq(result_s21, result_std);
}
END_TEST

START_TEST(test_strcspn_empty_str1) {
  char str1[] = "";
  char str2[] = "abc";
  s21_size result_s21 = s21_strcspn(str1, str2);
  size_t result_std = strcspn(str1, str2);
  ck_assert_int_eq(result_s21, result_std);
}
END_TEST

START_TEST(test_strcspn_first_char) {
  char str1[] = "Hello";
  char str2[] = "H";
  s21_size result_s21 = s21_strcspn(str1, str2);
  size_t result_std = strcspn(str1, str2);
  ck_assert_int_eq(result_s21, result_std);
}
END_TEST

//------------------------------------------------------------------------------
// 10. Searches an internal array for the error number errnum and returns a
// pointer to an error message string. You need to declare macros containing
// arrays of error messages for mac and linux operating systems. Error
// descriptions are available in the original library. Checking the current OS
// is carried out using directives.
// char *s21_strerror(int errnum) { ; }

// Test 1: Basic string test
START_TEST(s21_strerror_test_basic_string) {
  for (int err = -1; err < 200; err++) {
    char* result = s21_strerror(err);
    char* expected = strerror(err);
    if (!expected) ck_assert_ptr_eq(result, S21_NULL);
    if (expected) ck_assert_int_ne(result[0], '\0');
  }
}
END_TEST

//------------------------------------------------------------------------------
// 11. Computes the length of the string str up to but not including the
// terminating null character.
// s21_size s21_strlen(const char *str);

// Test 1: Basic string test
START_TEST(s21_strlen_test_basic_string) {
  const char* str = "Hello";
  s21_size result = s21_strlen(str);
  size_t expected = strlen(str);
  ck_assert_msg(result == expected, "s21_strlen(\"%s\") = %zu, expected %zu",
                str, result, expected);
}
END_TEST

// Test 2: Empty string
START_TEST(s21_strlen_test_empty_string) {
  const char* str = "";
  s21_size result = s21_strlen(str);
  size_t expected = strlen(str);
  ck_assert_msg(result == expected, "s21_strlen(\"\") = %zu, expected %zu",
                result, expected);
}
END_TEST

// Test 3: String with spaces
START_TEST(s21_strlen_test_string_with_spaces) {
  const char* str = "Hello World";
  s21_size result = s21_strlen(str);
  size_t expected = strlen(str);
  ck_assert_msg(result == expected, "s21_strlen(\"%s\") = %zu, expected %zu",
                str, result, expected);
}
END_TEST

// Test 4: String with special characters
START_TEST(s21_strlen_test_special_characters) {
  const char* str = "\t\n\r\x1B";
  s21_size result = s21_strlen(str);
  size_t expected = strlen(str);
  ck_assert_msg(result == expected,
                "s21_strlen(special_chars) = %zu, expected %zu", result,
                expected);
}
END_TEST

// Test 5: Long string
START_TEST(s21_strlen_test_long_string) {
  char long_str[1000];
  for (int i = 0; i < 999; i++) {
    long_str[i] = 'A' + (i % 26);
  }
  long_str[999] = '\0';

  s21_size result = s21_strlen(long_str);
  size_t expected = strlen(long_str);
  ck_assert_msg(result == expected, "s21_strlen(long_str) = %zu, expected %zu",
                result, expected);
}
END_TEST

// Test 6: Comparison with standard strlen
START_TEST(s21_strlen_test_against_standard_strlen) {
  const char* test_strings[] = {"test",        "",
                                "hello world", "1234567890",
                                "!@#$%^&*()",  "multi\nline\tstring\r\n",
                                NULL};

  for (int i = 0; test_strings[i] != NULL; i++) {
    s21_size s21_result = s21_strlen(test_strings[i]);
    size_t std_result = strlen(test_strings[i]);
    ck_assert_msg(s21_result == std_result,
                  "String: \"%s\" - s21_strlen = %zu, strlen = %zu",
                  test_strings[i], s21_result, std_result);
  }
}
END_TEST

// Test 7: UTF-8 characters
START_TEST(s21_strlen_test_utf8_string) {
  const char* str = "Привет";
  s21_size result = s21_strlen(str);
  size_t expected = strlen(str);
  ck_assert_msg(result == expected, "s21_strlen(UTF-8) = %zu, expected %zu",
                result, expected);
}
END_TEST

// Test 8: Edge case - test for reasonable values
START_TEST(s21_strlen_test_reasonable_values) {
  const char* str = "test";
  s21_size result = s21_strlen(str);

  // Check that result is reasonable
  ck_assert_msg(result < 1000,
                "Result %zu should be reasonable for short string", result);

  // Compare with strlen
  ck_assert_msg(result == strlen(str), "s21_strlen(\"%s\") = %zu, strlen = %zu",
                str, result, strlen(str));
}
END_TEST

// Test 9: String with only null character
START_TEST(s21_strlen_test_only_null_char) {
  char str[1] = {'\0'};
  s21_size result = s21_strlen(str);
  size_t expected = strlen(str);
  ck_assert_msg(result == expected, "s21_strlen(\"\\0\") = %zu, expected %zu",
                result, expected);
}
END_TEST

// Test 10: Iterative test with different lengths
START_TEST(s21_strlen_test_iterative_lengths) {
  for (int i = 0; i < 100; i++) {
    char buf[i + 1];
    for (int j = 0; j < i; j++) {
      buf[j] = 'x';
    }
    buf[i] = '\0';

    s21_size result = s21_strlen(buf);
    size_t expected = strlen(buf);
    ck_assert_msg(result == expected,
                  "Length %d: s21_strlen = %zu, strlen = %zu", i, result,
                  expected);
  }
}
END_TEST

//------------------------------------------------------------------------------
// 12. Finds the first character in the string str1 that matches any character
// specified in str2.
// char *s21_strpbrk(const char *str1, const char *str2)
// Test 1: Basic string test
START_TEST(s21_strpbrk_test_basic_string) {
  const char* str1 = "Hello";
  const char* str2 = "Darling";
  char* result = s21_strpbrk(str1, str2);
  char* expected = strpbrk(str1, str2);
  ck_assert_msg(result == expected,
                "s21_strpbrk(\"%s\", \"%s\") = %p, expected %p", str1, str2,
                result, expected);
}
END_TEST

// Test 2: Empty str1 test
START_TEST(s21_strpbrk_test_empty_str1) {
  const char* str1 = "";
  const char* str2 = "Darling";
  char* result = s21_strpbrk(str1, str2);
  char* expected = strpbrk(str1, str2);
  ck_assert_msg(result == expected,
                "s21_strpbrk(\"%s\", \"%s\") = %p, expected %p", str1, str2,
                result, expected);
}
END_TEST

// Test 3: Empty str2 test
START_TEST(s21_strpbrk_test_empty_str2) {
  const char* str1 = "Hello";
  const char* str2 = "";
  char* result = s21_strpbrk(str1, str2);
  char* expected = strpbrk(str1, str2);
  ck_assert_msg(result == expected,
                "s21_strpbrk(\"%s\", \"%s\") = %p, expected %p", str1, str2,
                result, expected);
}
END_TEST

// Test 4: Empty str1 & str2 test
START_TEST(s21_strpbrk_test_empty_str1_str2) {
  const char* str1 = "";
  const char* str2 = "";
  char* result = s21_strpbrk(str1, str2);
  char* expected = strpbrk(str1, str2);
  ck_assert_msg(result == expected,
                "s21_strpbrk(\"%s\", \"%s\") = %p, expected %p", str1, str2,
                result, expected);
}
END_TEST

// Test 5: Zero match test
START_TEST(s21_strpbrk_test_zero_match) {
  const char* str1 = "Hello";
  const char* str2 = "Buy";
  char* result = s21_strpbrk(str1, str2);
  char* expected = strpbrk(str1, str2);
  ck_assert_msg(result == expected,
                "s21_strpbrk(\"%s\", \"%s\") = %p, expected %p", str1, str2,
                result, expected);
}
END_TEST

//------------------------------------------------------------------------------
// 13. Searches for the last occurrence of the character c (an unsigned char) in
// the string pointed to by the argument str.
// char *s21_strrchr(const char *str, int c);

// Test 1: Basic string test
START_TEST(s21_strrchr_test_basic_string) {
  const char* str = "Hello";
  int c = 'l';
  char* result = s21_strrchr(str, c);
  char* expected = strrchr(str, c);
  ck_assert_msg(result == expected, "s21_strrchr(\"%s\", %c) = %p, expected %p",
                str, (unsigned char)c, result, expected);
}
END_TEST

// Test 2: Empty string
START_TEST(s21_strrchr_test_empty_string) {
  const char* str = "";
  int c = 'l';
  char* result = s21_strrchr(str, c);
  char* expected = strrchr(str, c);
  ck_assert_msg(result == expected, "s21_strrchr(\"%s\", %c) = %p, expected %p",
                str, (unsigned char)c, result, expected);
}
END_TEST

// Test 3: Empty pattern
START_TEST(s21_strrchr_empty_pattern) {
  const char* str = "Hello";
  int c = '\0';
  char* result = s21_strrchr(str, c);
  char* expected = strrchr(str, c);
  ck_assert_msg(result == expected, "s21_strrchr(\"%s\", %c) = %p, expected %p",
                str, (unsigned char)c, result, expected);
}
END_TEST

// Test 4: String of long zero character
START_TEST(s21_strrchr_test_longzerochar) {
  const char str[10] = {0};
  int c = '\0';
  char* result = s21_strrchr(str, c);
  char* expected = strrchr(str, c);
  ck_assert_msg(result == expected, "s21_strrchr(\"%s\", %c) = %p, expected %p",
                str, (unsigned char)c, result, expected);
}
END_TEST

// Test 5: Not ASCII c
// START_TEST(s21_strrchr_test_notasciic) {
//   const char* str = "Hello";
//   int c = -1024;
//   char* result = s21_strrchr(str, c);
//   char* expected = strrchr(str, c);
//   ck_assert_msg(result == expected, "s21_strrchr(\"%s\", %i) = %p, expected
//   %p",
//                 str, c, result, expected);
// }
// END_TEST

//------------------------------------------------------------------------------
// 14. Finds the first occurrence of the entire string needle (not including the
// terminating null character) which appears in the string haystack.
// char *s21_strstr(const char *haystack, const char *needle);

// Test 1:
START_TEST(s21_strstr_test_basic_string) {
  const char* haystack = "Hello darkness, my old friend";
  const char* needle = " old ";
  char* result = s21_strstr(haystack, needle);
  char* expected = strstr(haystack, needle);
  ck_assert_msg(result == expected,
                "s21_strstr(\"%s\", \"%s\") = %p, expected %p", haystack,
                needle, result, expected);
}
END_TEST

// Test 2:
START_TEST(s21_strstr_test_basic_string2) {
  const char* haystack = "Hello darkness, my old friend";
  const char* needle = "friend";
  char* result = s21_strstr(haystack, needle);
  char* expected = strstr(haystack, needle);
  ck_assert_msg(result == expected,
                "s21_strstr(\"%s\", \"%s\") = %p, expected %p", haystack,
                needle, result, expected);
}
END_TEST

// Test 3:
START_TEST(s21_strstr_test_empty_needle) {
  const char* haystack = "Hello darkness, my old friend";
  const char* needle = "";
  char* result = s21_strstr(haystack, needle);
  char* expected = strstr(haystack, needle);
  ck_assert_msg(result == expected,
                "s21_strstr(\"%s\", \"%s\") = %p, expected %p", haystack,
                needle, result, expected);
}
END_TEST

// Test 4:
START_TEST(s21_strstr_test_empty_both) {
  const char* haystack = "";
  const char* needle = "";
  char* result = s21_strstr(haystack, needle);
  char* expected = strstr(haystack, needle);
  ck_assert_msg(result == expected,
                "s21_strstr(\"%s\", \"%s\") = %p, expected %p", haystack,
                needle, result, expected);
}
END_TEST

// Test 5:
START_TEST(s21_strstr_test_no_match) {
  const char* haystack = "Hello darkness, my old friend";
  const char* needle = "new friend";
  char* result = s21_strstr(haystack, needle);
  char* expected = strstr(haystack, needle);
  ck_assert_msg(result == expected,
                "s21_strstr(\"%s\", \"%s\") = %p, expected %p", haystack,
                needle, result, expected);
}
END_TEST

// Test 6:
START_TEST(s21_strstr_test_few_matches) {
  const char* haystack = "Hello darkness, my old friend";
  const char* needle = "e";
  char* result = s21_strstr(haystack, needle);
  char* expected = strstr(haystack, needle);
  ck_assert_msg(result == expected,
                "s21_strstr(\"%s\", \"%s\") = %p, expected %p", haystack,
                needle, result, expected);
}
END_TEST

//------------------------------------------------------------------------------
// 15. Breaks string str into a series of tokens separated by delim.
// char *s21_strtok(char *str, const char *delim);

void printbuf(char* str, int n) {
  printf("\"");
  for (int i = 0; i < n; i++) {
    if (!str[i]) {
      printf("\033[1;31m");
      printf("_");
      printf("\033[0m");
    } else {
      printf("%c", str[i]);
    }
  }
  printf("\"");
}

void printvisual(const char* delim, char* str0, char* str1, char* str2, int n) {
  printf("\nchar '\\0' is \"\033[1;31m");
  printf("_");
  printf("\033[0m\"");
  printf(", delim:\"%s\"\n", delim);
  printf("      orig:");
  printbuf(str0, n);
  printf("\n    strtok:");
  printbuf(str1, n);
  printf("\ns21_strtok:");
  printbuf(str2, n);
  printf("\n");
}

// Test 1:
START_TEST(s21_strtok_test_basic_string) {
  char str0[68] =
      " Hello darkness, my old friend... I've come to talk with you again.";
  char str1[68] =
      " Hello darkness, my old friend... I've come to talk with you again,";
  char str2[68] =
      " Hello darkness, my old friend... I've come to talk with you again,";
  const char* delim = " ,.";
  char* result = s21_strtok(str2, delim);
  char* expected = strtok(str1, delim);

  printf("\033[0m");
  printf(
      "---------------------------------------------------------------------"
      "------------\n"
      "-------------- A special test for s21_strtok function ---------------"
      "------------\n"
      "-------------- Because it modifies the original string --------------"
      "------------\n"
      "---------------------------------------------------------------------"
      "------------\n");
  printf("s21_strtok_test_basic_string:\n");
  printf("Tokens expected|result:\n");
  printf("\"%s\"|\"%s\"\n", expected, result);

  if (expected == NULL || result == NULL) {
    ck_assert_ptr_eq(result, expected);
  } else {
    ck_assert_str_eq(result, expected);
  }

  while (expected) {
    result = s21_strtok(S21_NULL, delim);
    expected = strtok(S21_NULL, delim);
    printf("\"%s\"|\"%s\"\n", expected, result);
    if (expected == NULL || result == NULL) {
      ck_assert_ptr_eq(result, expected);
    } else {
      ck_assert_str_eq(result, expected);
    }
  }

  printvisual(delim, str0, str1, str2, 68);
  printf(
      "------------------------------------------------------------------------"
      "---------\n");
}
END_TEST

// Test 2:
START_TEST(s21_strtok_test_empty_str) {
  char str0[1] = "";
  char str1[1] = "";
  char str2[1] = "";
  const char* delim = " ,.";
  char* result = s21_strtok(str2, delim);
  char* expected = strtok(str1, delim);

  printf("s21_strtok_test_empty_str:\n");
  printf("Tokens expected|result:\n");
  printf("\"%s\"|\"%s\"\n", expected, result);

  if (expected == NULL || result == NULL) {
    ck_assert_ptr_eq(result, expected);
  } else {
    ck_assert_str_eq(result, expected);
  }

  while (expected) {
    result = s21_strtok(S21_NULL, delim);
    expected = strtok(S21_NULL, delim);
    printf("\"%s\"|\"%s\"\n", expected, result);
    if (expected == NULL || result == NULL) {
      ck_assert_ptr_eq(result, expected);
    } else {
      ck_assert_str_eq(result, expected);
    }
  }

  printvisual(delim, str0, str1, str2, 1);
  printf(
      "------------------------------------------------------------------------"
      "---------\n");
}
END_TEST

// Test 3:
START_TEST(s21_strtok_test_delim_only) {
  char str0[4] = " ,.";
  char str1[4] = " ,.";
  char str2[4] = " ,.";
  const char* delim = " ,.";
  char* result = s21_strtok(str2, delim);
  char* expected = strtok(str1, delim);

  printf("s21_strtok_test_delim_only:\n");
  printf("Tokens expected|result:\n");
  printf("\"%s\"|\"%s\"\n", expected, result);

  if (expected == NULL || result == NULL) {
    ck_assert_ptr_eq(result, expected);
  } else {
    ck_assert_str_eq(result, expected);
  }

  while (expected) {
    result = s21_strtok(S21_NULL, delim);
    expected = strtok(S21_NULL, delim);
    printf("\"%s\"|\"%s\"\n", expected, result);
    if (expected == NULL || result == NULL) {
      ck_assert_ptr_eq(result, expected);
    } else {
      ck_assert_str_eq(result, expected);
    }
  }

  printvisual(delim, str0, str1, str2, 4);
  printf(
      "------------------------------------------------------------------------"
      "---------\n");
}
END_TEST

// Test 4:
START_TEST(s21_strtok_test_no_match) {
  char str0[6] = "Hello";
  char str1[6] = "Hello";
  char str2[6] = "Hello";
  const char* delim = " ,.";
  char* result = s21_strtok(str2, delim);
  char* expected = strtok(str1, delim);

  printf("s21_strtok_test_no_match:\n");
  printf("Tokens expected|result:\n");
  printf("\"%s\"|\"%s\"\n", expected, result);

  if (expected == NULL || result == NULL) {
    ck_assert_ptr_eq(result, expected);
  } else {
    ck_assert_str_eq(result, expected);
  }

  while (expected) {
    result = s21_strtok(S21_NULL, delim);
    expected = strtok(S21_NULL, delim);
    printf("\"%s\"|\"%s\"\n", expected, result);
    if (expected == NULL || result == NULL) {
      ck_assert_ptr_eq(result, expected);
    } else {
      ck_assert_str_eq(result, expected);
    }
  }

  printvisual(delim, str0, str1, str2, 6);
  printf(
      "------------------------------------------------------------------------"
      "---------\n");
  printf("\033[1;33m");
}
END_TEST

//------------------------------------------------------------------------------
// Create test suite
Suite* test_str_suite(void) {
  Suite* s;

  s = suite_create("STR Functions");

  // Tests for 5. char* s21_strncat(char* dest, const char* src, s21_size n);
  TCase* tc_s21_strncat = tcase_create("s21_strncat");
  tcase_add_test(tc_s21_strncat, s21_strncat_test_basic);
  tcase_add_test(tc_s21_strncat, s21_strncat_test_partial);
  tcase_add_test(tc_s21_strncat, s21_strncat_test_empty_src);
  tcase_add_test(tc_s21_strncat, s21_strncat_test_empty_dest);
  tcase_add_test(tc_s21_strncat, s21_strncat_test_zero_n);
  tcase_add_test(tc_s21_strncat, s21_strncat_test_n_larger_than_src);
  tcase_add_test(tc_s21_strncat, s21_strncat_test_special_chars);
  suite_add_tcase(s, tc_s21_strncat);

  // Tests for 6. char *s21_strchr(const char *str, int c);
  TCase* tc_s21_strchr = tcase_create("s21_strchr");
  tcase_add_test(tc_s21_strchr, test_strchr_found);
  tcase_add_test(tc_s21_strchr, test_strchr_not_found);
  tcase_add_test(tc_s21_strchr, test_strchr_null_char);
  tcase_add_test(tc_s21_strchr, test_strchr_first_char);
  suite_add_tcase(s, tc_s21_strchr);

  // Tests for 7. int s21_strncmp(const char *str1, const char *str2, s21_size
  // n);
  TCase* tc_s21_strncmp = tcase_create("s21_strncmp");
  tcase_add_test(tc_s21_strncmp, test_strncmp_equal);
  tcase_add_test(tc_s21_strncmp, test_strncmp_less);
  tcase_add_test(tc_s21_strncmp, test_strncmp_greater);
  tcase_add_test(tc_s21_strncmp, test_strncmp_partial);
  suite_add_tcase(s, tc_s21_strncmp);

  // Tests for 8. char *s21_strncpy(char *dest, const char *src, s21_size n);
  TCase* tc_s21_strncpy = tcase_create("s21_strncpy");
  tcase_add_test(tc_s21_strncpy, test_strncpy_basic);
  tcase_add_test(tc_s21_strncpy, test_strncpy_with_padding);
  tcase_add_test(tc_s21_strncpy, test_strncpy_partial);
  tcase_add_test(tc_s21_strncpy, test_strncpy_zero_bytes);
  suite_add_tcase(s, tc_s21_strncpy);

  // Tests for 9. s21_size s21_strcspn(const char *str1, const char *str2);
  TCase* tc_s21_strcspn = tcase_create("s21_strcspn");
  tcase_add_test(tc_s21_strcspn, test_strcspn_found);
  tcase_add_test(tc_s21_strcspn, test_strcspn_not_found);
  tcase_add_test(tc_s21_strcspn, test_strcspn_empty_str1);
  tcase_add_test(tc_s21_strcspn, test_strcspn_first_char);
  suite_add_tcase(s, tc_s21_strcspn);

  // Tests for 10. char *s21_strerror(int errnum) { ; }
  TCase* tc_s21_strerror = tcase_create("s21_strerror");
  tcase_add_test(tc_s21_strerror, s21_strerror_test_basic_string);
  suite_add_tcase(s, tc_s21_strerror);

  // Tests for 11. s21_size s21_strlen(const char *str);
  TCase* tc_s21_strlen = tcase_create("s21_strlen");
  tcase_add_test(tc_s21_strlen, s21_strlen_test_basic_string);
  tcase_add_test(tc_s21_strlen, s21_strlen_test_empty_string);
  tcase_add_test(tc_s21_strlen, s21_strlen_test_string_with_spaces);
  tcase_add_test(tc_s21_strlen, s21_strlen_test_special_characters);
  tcase_add_test(tc_s21_strlen, s21_strlen_test_only_null_char);
  tcase_add_test(tc_s21_strlen, s21_strlen_test_iterative_lengths);
  tcase_add_test(tc_s21_strlen, s21_strlen_test_against_standard_strlen);
  tcase_add_test(tc_s21_strlen, s21_strlen_test_long_string);
  tcase_add_test(tc_s21_strlen, s21_strlen_test_utf8_string);
  tcase_add_test(tc_s21_strlen, s21_strlen_test_reasonable_values);
  suite_add_tcase(s, tc_s21_strlen);

  // Tests for 12. char *s21_strpbrk(const char *str1, const char *str2);
  TCase* tc_s21_strpbrk = tcase_create("s21_strpbrk");
  tcase_add_test(tc_s21_strpbrk, s21_strpbrk_test_basic_string);
  tcase_add_test(tc_s21_strpbrk, s21_strpbrk_test_empty_str1);
  tcase_add_test(tc_s21_strpbrk, s21_strpbrk_test_empty_str2);
  tcase_add_test(tc_s21_strpbrk, s21_strpbrk_test_empty_str1_str2);
  tcase_add_test(tc_s21_strpbrk, s21_strpbrk_test_zero_match);
  suite_add_tcase(s, tc_s21_strpbrk);

  // Tests for 13. char *s21_strrchr(const char *str, int c);
  TCase* tc_s21_strrchr = tcase_create("s21_strrchr");
  tcase_add_test(tc_s21_strrchr, s21_strrchr_test_basic_string);
  tcase_add_test(tc_s21_strrchr, s21_strrchr_test_empty_string);
  tcase_add_test(tc_s21_strrchr, s21_strrchr_empty_pattern);
  tcase_add_test(tc_s21_strrchr, s21_strrchr_test_longzerochar);
  // tcase_add_test(tc_s21_strrchr, s21_strrchr_test_notasciic);
  suite_add_tcase(s, tc_s21_strrchr);

  // Tests for 15. char *s21_strstr(const char *haystack, const char *needle);
  TCase* tc_s21_strstr = tcase_create("s21_strstr");
  tcase_add_test(tc_s21_strstr, s21_strstr_test_basic_string);
  tcase_add_test(tc_s21_strstr, s21_strstr_test_basic_string2);
  tcase_add_test(tc_s21_strstr, s21_strstr_test_empty_needle);
  tcase_add_test(tc_s21_strstr, s21_strstr_test_empty_both);
  tcase_add_test(tc_s21_strstr, s21_strstr_test_no_match);
  tcase_add_test(tc_s21_strstr, s21_strstr_test_few_matches);
  suite_add_tcase(s, tc_s21_strstr);

  // Tests for 16. char *s21_strtok(char *str, const char *delim);
  TCase* tc_s21_strtok = tcase_create("s21_strtok");
  tcase_add_test(tc_s21_strtok, s21_strtok_test_basic_string);
  tcase_add_test(tc_s21_strtok, s21_strtok_test_empty_str);
  tcase_add_test(tc_s21_strtok, s21_strtok_test_delim_only);
  tcase_add_test(tc_s21_strtok, s21_strtok_test_no_match);
  suite_add_tcase(s, tc_s21_strtok);

  return s;
}

int main(void) {
  int number_failed;
  Suite* s;
  SRunner* sr;

  s = test_str_suite();
  sr = srunner_create(s);

  printf("\033[1;33m");
  // Run tests
  srunner_run_all(sr, CK_NORMAL);
  number_failed = srunner_ntests_failed(sr);

  // Cleanup
  srunner_free(sr);
  printf("\033[0m");

  return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}