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

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

#include "../s21_string.h"

// Tests for s21_memchr
// 1. Searches for the first occurrence of the character c (an unsigned char) in
// the first n bytes of the string pointed to, by the argument str.
// void* s21_memchr(const void* str, int c, s21_size n)
START_TEST(test_memchr_found) {
  char str[] = "Hello, World!";
  char* result_s21 = s21_memchr(str, 'W', 13);
  char* result_std = memchr(str, 'W', 13);
  ck_assert_ptr_eq(result_s21, result_std);
}
END_TEST

START_TEST(test_memchr_not_found) {
  char str[] = "Hello, World!";
  char* result_s21 = s21_memchr(str, 'Z', 13);
  char* result_std = memchr(str, 'Z', 13);
  ck_assert_ptr_eq(result_s21, result_std);
}
END_TEST

START_TEST(test_memchr_null_char) {
  char str[] = "Hello\0World";
  char* result_s21 = s21_memchr(str, '\0', 11);
  char* result_std = memchr(str, '\0', 11);
  ck_assert_ptr_eq(result_s21, result_std);
}
END_TEST

START_TEST(test_memchr_first_byte) {
  char str[] = "Hello";
  char* result_s21 = s21_memchr(str, 'H', 5);
  char* result_std = memchr(str, 'H', 5);
  ck_assert_ptr_eq(result_s21, result_std);
}
END_TEST

START_TEST(test_memchr_nonascii_c) {
  char str[] = "Hello";
  char* result_s21 = s21_memchr(str, 230, 5);
  char* result_std =
      memchr(str, 230, 5);  // cppcheck ругаестя на не аски символы
  ck_assert_ptr_eq(result_s21, result_std);
}
END_TEST

// Tests for s21_memcmp
START_TEST(test_memcmp_equal) {
  char str1[] = "Hello";
  char str2[] = "Hello";
  int result_s21 = s21_memcmp(str1, str2, 5);
  int result_std = memcmp(str1, str2, 5);
  ck_assert_int_eq(result_s21, result_std);
}
END_TEST

START_TEST(test_memcmp_less) {
  char str1[] = "Hello";
  char str2[] = "World";
  int result_s21 = s21_memcmp(str1, str2, 5);
  int result_std = memcmp(str1, str2, 5);
  ck_assert_int_lt(result_s21, 0);
  ck_assert_int_lt(result_std, 0);
}
END_TEST

START_TEST(test_memcmp_greater) {
  char str1[] = "World";
  char str2[] = "Hello";
  int result_s21 = s21_memcmp(str1, str2, 5);
  int result_std = memcmp(str1, str2, 5);
  ck_assert_int_gt(result_s21, 0);
  ck_assert_int_gt(result_std, 0);
}
END_TEST

START_TEST(test_memcmp_partial) {
  char str1[] = "Hello";
  char str2[] = "Help";
  int result_s21 = s21_memcmp(str1, str2, 3);
  int result_std = memcmp(str1, str2, 3);
  ck_assert_int_eq(result_s21, result_std);
}
END_TEST

// Tests for s21_memcpy
START_TEST(test_memcpy_basic) {
  char src[] = "Hello, World!";
  char dest_s21[20] = {0};
  char dest_std[20] = {0};

  s21_memcpy(dest_s21, src, 13);
  memcpy(dest_std, src, 13);

  ck_assert_mem_eq(dest_s21, dest_std, 13);
}
END_TEST

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

  s21_memcpy(dest_s21, src, 11);
  memcpy(dest_std, src, 11);

  ck_assert_mem_eq(dest_s21, dest_std, 11);
}
END_TEST

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

  s21_memcpy(dest_s21, src, 0);
  memcpy(dest_std, src, 0);

  ck_assert_mem_eq(dest_s21, dest_std, 5);
}
END_TEST

// Tests for s21_memset
START_TEST(test_memset_basic) {
  char str_s21[20] = "Hello, World!";
  char str_std[20] = "Hello, World!";

  s21_memset(str_s21, 'A', 5);
  memset(str_std, 'A', 5);

  ck_assert_mem_eq(str_s21, str_std, 13);
}
END_TEST

START_TEST(test_memset_zero) {
  char str_s21[20] = "Hello, World!";
  char str_std[20] = "Hello, World!";

  s21_memset(str_s21, 0, 13);
  memset(str_std, 0, 13);

  ck_assert_mem_eq(str_s21, str_std, 13);
}
END_TEST

START_TEST(test_memset_full) {
  char str_s21[10] = {0};
  char str_std[10] = {0};

  s21_memset(str_s21, 'X', 10);
  memset(str_std, 'X', 10);

  ck_assert_mem_eq(str_s21, str_std, 10);
}
END_TEST

START_TEST(test_memset_nonascii_c) {
  char str_s21[20] = "Hello, World!";
  char str_std[20] = "Hello, World!";

  s21_memset(str_s21, -1024, 5);
  memset(str_std, -1024, 5);

  ck_assert_mem_eq(str_s21, str_std, 13);
}
END_TEST

// Suite creation
Suite* mem_suite(void) {
  Suite* s = suite_create("MEM Functions");

  TCase* tc_memchr = tcase_create("memchr");
  tcase_add_test(tc_memchr, test_memchr_found);
  tcase_add_test(tc_memchr, test_memchr_not_found);
  tcase_add_test(tc_memchr, test_memchr_null_char);
  tcase_add_test(tc_memchr, test_memchr_first_byte);
  tcase_add_test(tc_memchr, test_memchr_nonascii_c);
  suite_add_tcase(s, tc_memchr);

  TCase* tc_memcmp = tcase_create("memcmp");
  tcase_add_test(tc_memcmp, test_memcmp_equal);
  tcase_add_test(tc_memcmp, test_memcmp_less);
  tcase_add_test(tc_memcmp, test_memcmp_greater);
  tcase_add_test(tc_memcmp, test_memcmp_partial);
  suite_add_tcase(s, tc_memcmp);

  TCase* tc_memcpy = tcase_create("memcpy");
  tcase_add_test(tc_memcpy, test_memcpy_basic);
  tcase_add_test(tc_memcpy, test_memcpy_with_null);
  tcase_add_test(tc_memcpy, test_memcpy_zero_bytes);
  suite_add_tcase(s, tc_memcpy);

  TCase* tc_memset = tcase_create("memset");
  tcase_add_test(tc_memset, test_memset_basic);
  tcase_add_test(tc_memset, test_memset_zero);
  tcase_add_test(tc_memset, test_memset_full);
  tcase_add_test(tc_memset, test_memset_nonascii_c);
  suite_add_tcase(s, tc_memset);

  return s;
}

int main(void) {
  Suite* s = mem_suite();
  SRunner* sr = srunner_create(s);

  printf("\033[1;33m");
  srunner_run_all(sr, CK_NORMAL);
  int number_failed = srunner_ntests_failed(sr);
  srunner_free(sr);
  printf("\033[0m");

  return (number_failed == 0) ? 0 : 1;
}