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

src/tests/test_strproc.c
237 строк7 KB
Andrey
Fix always true conditions
06 фев 2026, 08:32
06 фев 2026, 08:32481262c
#include <check.h>
#include <stdlib.h>
#include <string.h>

#include "../s21_string.h"

//-----------------------------------------------------------------------------
// Part 5. Bonus. Implementation of special string processing functions
// Special string processing functions (from the String class in C#)
//-----------------------------------------------------------------------------

// Returns a copy of string (str) converted to uppercase. In case of any error,
// return NULL.
// void *s21_to_upper(const char *str);

// Test 1:
START_TEST(s21_to_upper_basic_string) {
  const char* str = " Hello darkness, my old friend ";
  const char* expected = " HELLO DARKNESS, MY OLD FRIEND ";
  char* result = s21_to_upper(str);
  if (!expected) ck_assert_ptr_eq(result, S21_NULL);
  if (expected) ck_assert_str_eq(result, expected);
  free(result);
}
END_TEST

// Test 2:
START_TEST(s21_to_upper_zerostr) {
  const char* str = "";
  const char* expected = "";
  char* result = s21_to_upper(str);
  if (!expected) ck_assert_ptr_eq(result, S21_NULL);
  if (expected) ck_assert_str_eq(result, expected);
  free(result);
}
END_TEST

// Returns a copy of string (str) converted to lowercase. In case of any error,
// return NULL.
// void *s21_to_lower(const char *str);

// Test 1:
START_TEST(s21_to_lower_basic_string) {
  const char* str = " HELLO DARKNESS, MY OLD FRIEND ";
  const char* expected = " hello darkness, my old friend ";
  char* result = s21_to_lower(str);
  if (!expected) ck_assert_ptr_eq(result, S21_NULL);
  if (expected) ck_assert_str_eq(result, expected);
  free(result);
}
END_TEST

// Test 2:
START_TEST(s21_to_lower_zerostr) {
  const char* str = "";
  const char* expected = "";
  char* result = s21_to_lower(str);
  if (!expected) ck_assert_ptr_eq(result, S21_NULL);
  if (expected) ck_assert_str_eq(result, expected);
  free(result);
}
END_TEST

// Returns a new string in which a specified string (str) is inserted at a
// specified index position (start_index) in the given string (src). In case of
// any error, return NULL.
// void *s21_insert(const char *src, const char *str, s21_size start_index)

// Test 1:
START_TEST(s21_insert_basic_string) {
  const char* src = " Hello my old friend ";
  const char* str = "darkness, ";
  const char* expected = " Hello darkness, my old friend ";
  char* result = s21_insert(src, str, 7);
  if (!expected) ck_assert_ptr_eq(result, S21_NULL);
  if (expected) ck_assert_str_eq(result, expected);
  free(result);
}
END_TEST

// Test 2:
START_TEST(s21_insert_zero_insert) {
  const char* src = " Hello my old friend ";
  const char* str = "";
  const char* expected = " Hello my old friend ";
  char* result = s21_insert(src, str, 7);
  if (!expected) ck_assert_ptr_eq(result, S21_NULL);
  if (expected) ck_assert_str_eq(result, expected);
  free(result);
}
END_TEST

// Test 3:
START_TEST(s21_insert_index_more_then_lenght) {
  const char* src = " Hello my old friend ";
  const char* str = "darkness, ";
  char* result = s21_insert(src, str, 128);
  ck_assert_ptr_eq(result, S21_NULL);
  if (result) free(result);
}
END_TEST

// Returns a new string in which all leading and trailing occurrences of a set
// of specified characters (trim_chars) from the given string (src) are removed.
// In case of any error, return NULL.
// void *s21_trim(const char *src, const char *trim_chars)

// Test 1:
START_TEST(s21_trim_basic_string) {
  const char* src = " Hello darkness, my old friend!";
  const char* trim_chars = " !";
  const char* expected = "Hello darkness, my old friend";
  char* result = s21_trim(src, trim_chars);
  if (expected) ck_assert_str_eq(result, expected);
  if (result) free(result);
}
END_TEST

// Test 2:
START_TEST(s21_trim_zero_trim) {
  const char* src = " \t\n\r\f\vHello darkness, my old friend \n";
  const char* trim_chars = "";
  const char* expected = "Hello darkness, my old friend";
  char* result = s21_trim(src, trim_chars);
  if (!expected) ck_assert_ptr_eq(result, S21_NULL);
  if (expected) ck_assert_str_eq(result, expected);
  if (result) free(result);
}
END_TEST

// Test 3:
START_TEST(s21_trim_NULL_trim) {
  const char* src = " \t\n\r\f\vHello darkness, my old friend \n";
  const char* trim_chars = S21_NULL;
  const char* expected = "Hello darkness, my old friend";
  char* result = s21_trim(src, trim_chars);
  if (!expected) ck_assert_ptr_eq(result, S21_NULL);
  if (expected) ck_assert_str_eq(result, expected);
  if (result) free(result);
}
END_TEST

// Test 4:
START_TEST(s21_trim_only_trim) {
  const char* src = " ABCDE ";
  const char* trim_chars = " ABCDE";
  const char* expected = "";
  char* result = s21_trim(src, trim_chars);
  if (!expected) ck_assert_ptr_eq(result, S21_NULL);
  if (expected) ck_assert_str_eq(result, expected);
  if (result) free(result);
}
END_TEST

// Test 5:
START_TEST(s21_trim_zero_src) {
  const char* src = "";
  const char* trim_chars = " ABCDE";
  const char* expected = "";
  char* result = s21_trim(src, trim_chars);
  if (!expected) ck_assert_ptr_eq(result, S21_NULL);
  if (expected) ck_assert_str_eq(result, expected);
  if (result) free(result);
}
END_TEST

// Test 6:
START_TEST(s21_trim_one_symbol) {
  const char* src = "X";
  const char* trim_chars = " ABCDE";
  const char* expected = "X";
  char* result = s21_trim(src, trim_chars);
  if (!expected) ck_assert_ptr_eq(result, S21_NULL);
  if (expected) ck_assert_str_eq(result, expected);
  if (result) free(result);
}
END_TEST

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

  s = suite_create("STRPROC Functions");

  // Tests for void *s21_to_upper(const char *str);
  TCase* tc_s21_to_upper = tcase_create("s21_to_upper");
  tcase_add_test(tc_s21_to_upper, s21_to_upper_basic_string);
  tcase_add_test(tc_s21_to_upper, s21_to_upper_zerostr);
  suite_add_tcase(s, tc_s21_to_upper);

  // Tests for void *s21_to_lower(const char *str);
  TCase* tc_s21_to_lower = tcase_create("s21_to_lower");
  tcase_add_test(tc_s21_to_lower, s21_to_lower_basic_string);
  tcase_add_test(tc_s21_to_lower, s21_to_lower_zerostr);
  suite_add_tcase(s, tc_s21_to_lower);

  // Tests for void *s21_insert(const char *src, const char *str, s21_size
  // start_index)
  TCase* tc_s21_insert = tcase_create("s21_insert");
  tcase_add_test(tc_s21_insert, s21_insert_basic_string);
  tcase_add_test(tc_s21_insert, s21_insert_zero_insert);
  tcase_add_test(tc_s21_insert, s21_insert_index_more_then_lenght);
  suite_add_tcase(s, tc_s21_insert);

  // Tests for void *s21_trim(const char *src, const char *trim_chars)
  TCase* tc_s21_trim = tcase_create("s21_trim");
  tcase_add_test(tc_s21_trim, s21_trim_basic_string);
  tcase_add_test(tc_s21_trim, s21_trim_zero_trim);
  tcase_add_test(tc_s21_trim, s21_trim_NULL_trim);
  tcase_add_test(tc_s21_trim, s21_trim_only_trim);
  tcase_add_test(tc_s21_trim, s21_trim_zero_src);
  tcase_add_test(tc_s21_trim, s21_trim_one_symbol);
  suite_add_tcase(s, tc_s21_trim);

  return s;
}

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

  s = test_strproc_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;
}