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

src/tests/tests_sprintf.c
1 952 строки56 KB
Andrey
Fixed test_s21_sprintf_large_float so that it passes under valgrind
06 фев 2026, 09:08
06 фев 2026, 09:0876f6cf8
#include "tests_sprintf.h"

START_TEST(test_s21_sprintf_d) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  int num = 12345;

  int result1 = s21_sprintf(buffer1, "%d", num);
  int result2 = sprintf(buffer2, "%d", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_s) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  char* str = "Hello, World!";

  int result1 = s21_sprintf(buffer1, "%s", str);
  int result2 = sprintf(buffer2, "%s", str);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_f) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  double num = 123.456;

  int result1 = s21_sprintf(buffer1, "%.2f", num);
  int result2 = sprintf(buffer2, "%.2f", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_x) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned int num = 0xABCD;

  int result1 = s21_sprintf(buffer1, "%x", num);
  int result2 = sprintf(buffer2, "%x", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_e) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  long double num = 1.23e-111L;

  int result1 = s21_sprintf(buffer1, "%Le", num);
  int result2 = sprintf(buffer2, "%Le", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_g) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  double double_num = 12312322123.456;

  int result1 = s21_sprintf(buffer1, "%g", double_num);
  int result2 = sprintf(buffer2, "%g", double_num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_g_capital) {
  char buffer3[100] = {0};
  char buffer4[100] = {0};
  float num = 123.456;

  int result3 = s21_sprintf(buffer3, "%g", num);
  int result4 = sprintf(buffer4, "%g", num);

  ck_assert_str_eq(buffer3, buffer4);
  ck_assert_int_eq(result3, result4);
}
END_TEST

START_TEST(test_s21_sprintf_flags) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  int num = 123;

  int result1 = s21_sprintf(buffer1, "%+d", num);
  int result2 = sprintf(buffer2, "%+d", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для спецификатора %c (символы)
START_TEST(test_s21_sprintf_c) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  char ch = 'A';

  int result1 = s21_sprintf(buffer1, "%c", ch);
  int result2 = sprintf(buffer2, "%c", ch);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}

// ПОШЛИ ТЕСТЫ ДЛЯ SPRINF

END_TEST
// Тесты для спецификатора %u (беззнаковые целые числа)
START_TEST(test_s21_sprintf_u) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned int num = 12345;

  int result1 = s21_sprintf(buffer1, "%u", num);
  int result2 = sprintf(buffer2, "%u", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для спецификатора %x и %X (шестнадцатеричные числа)
START_TEST(test_s21_sprintf_x_lower) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned int num = 0xABCD;

  int result1 = s21_sprintf(buffer1, "%x", num);
  int result2 = sprintf(buffer2, "%x", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_x_upper) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned int num = 0xABCD;

  int result1 = s21_sprintf(buffer1, "%X", num);
  int result2 = sprintf(buffer2, "%X", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для спецификатора %o (восьмеричные числа)
START_TEST(test_s21_sprintf_o) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned int num = 0777;

  int result1 = s21_sprintf(buffer1, "%o", num);
  int result2 = sprintf(buffer2, "%o", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для спецификатора %p (указатели)
START_TEST(test_s21_sprintf_p) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  void* ptr = (void*)0xABCDEF;

  int result1 = s21_sprintf(buffer1, "%p", ptr);
  int result2 = sprintf(buffer2, "%p", ptr);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для спецификатора %e и %E (экспоненциальная запись)
START_TEST(test_s21_sprintf_e_lower) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  double num = 123.456;
  int result1 = s21_sprintf(buffer1, "%e", num);
  int result2 = sprintf(buffer2, "%e", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_e_upper) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  double num = 123.456;

  int result1 = s21_sprintf(buffer1, "%E", num);
  int result2 = sprintf(buffer2, "%E", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для спецификатора %g и %G (выбор между %f и %e)
START_TEST(test_s21_sprintf_g_lower) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  double num = 123.456;

  int result1 = s21_sprintf(buffer1, "%g", num);
  int result2 = sprintf(buffer2, "%g", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_g_upper) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  double num = 123.456;

  int result1 = s21_sprintf(buffer1, "%G", num);
  int result2 = sprintf(buffer2, "%G", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для флагов форматирования
START_TEST(test_s21_sprintf_flags_plus) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  int num = 123;

  int result1 = s21_sprintf(buffer1, "%+d", num);
  int result2 = sprintf(buffer2, "%+d", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_flags_space) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  int num = 123;

  int result1 = s21_sprintf(buffer1, "% d", num);
  int result2 = sprintf(buffer2, "% d", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_flags_zero) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  int num = 123;

  int result1 = s21_sprintf(buffer1, "%05d", num);
  int result2 = sprintf(buffer2, "%05d", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_flags_minus) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  int num = 123;

  int result1 = s21_sprintf(buffer1, "%-5d", num);
  int result2 = sprintf(buffer2, "%-5d", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_flags_double_plus) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  double num = 1.4;

  int result1 = s21_sprintf(buffer1, "%+09.3lf", num);
  int result2 = sprintf(buffer2, "%+09.3lf", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для ширины и точности
START_TEST(test_s21_sprintf_width) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  int num = 123;

  int result1 = s21_sprintf(buffer1, "%5d", num);
  int result2 = sprintf(buffer2, "%5d", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_precision) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  double num = 123.456;

  int result1 = s21_sprintf(buffer1, "%.4f", num);
  int result2 = sprintf(buffer2, "%.4f", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для комбинированных случаев
START_TEST(test_s21_sprintf_combined) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  int num = 123;
  double dbl = 123.456;
  char* str = "Hello";

  int result1 = s21_sprintf(buffer1, "%+05d %.2f %s", num, dbl, str);
  int result2 = sprintf(buffer2, "%+05d %.2f %s", num, dbl, str);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на комбинацию флагов +, 0, и ширины:
START_TEST(test_s21_sprintf_flags_plus_zero_width) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  int num = 123;

  int result1 = s21_sprintf(buffer1, "%+08d", num);
  int result2 = sprintf(buffer2, "%+08d", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на комбинацию флагов -, #, и ширины:
START_TEST(test_s21_sprintf_flags_minus_hash_width) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  int num = 123;

  int result1 = s21_sprintf(buffer1, "%-10x", num);
  int result2 = sprintf(buffer2, "%-10x", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на комбинацию флагов (пробел), +, и точности:
START_TEST(test_s21_sprintf_flags_space_plus_precision) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  int num = -123;

  int result1 = s21_sprintf(buffer1, "%+.5d", num);
  int result2 = sprintf(buffer2, "%+.5d", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// // Тесты на неправильные аргументы
// // Тест на неправильный спецификатор:
// START_TEST(test_s21_sprintf_invalid_specifier) {
//   char buffer1[100] = {0};
//   char buffer2[100] = {0};
//   int num = 123;

//   int result1 = s21_sprintf(buffer1, "%z", num);  // Неправильный
//   спецификатор int result2 = sprintf(buffer2, "%z", num);      // Ожидаем
//   ошибку

//   ck_assert_str_eq(buffer1, buffer2);  // Оба должны вернуть пустую строку
//   ck_assert_int_eq(result1, result2);
// }
// END_TEST

// // Тест на отсутствие аргумента:
// START_TEST(test_s21_sprintf_missing_argument) {
//   char buffer1[100] = {0};
//   char buffer2[100] = {0};

//   int result1 = s21_sprintf(buffer1, "%d");  // Нет аргумента
//   int result2 = sprintf(buffer2, "%d");      // Ожидаем ошибку

//   ck_assert_str_eq(buffer1, buffer2);  // Оба должны вернуть пустую строку
//   ck_assert_int_eq(result1, result2);
// }
// END_TEST

// . Тесты на граничные условия
// Тест на максимальное значение int:
START_TEST(test_s21_sprintf_int_max) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  int num = INT_MAX;

  int result1 = s21_sprintf(buffer1, "%d", num);
  int result2 = sprintf(buffer2, "%d", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на минимальное значение int:
START_TEST(test_s21_sprintf_int_min) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  int num = INT_MIN;

  int result1 = s21_sprintf(buffer1, "%d", num);
  int result2 = sprintf(buffer2, "%d", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на очень большое число с плавающей точкой:
START_TEST(test_s21_sprintf_large_float) {
  char buffer1[400] = {0};
  char buffer2[400] = {0};
  long double num = 1.7976931348623157e+10L;  // Максимальное значение double

  int result1 = s21_sprintf(buffer1, "%Lf", num);
  int result2 = sprintf(buffer2, "%Lf", num);
  ck_assert_int_eq(strncmp(buffer1, buffer2, 17), 0);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты на спецификаторы с разной точностью и шириной
// Тест на ширину и точность для строки:
START_TEST(test_s21_sprintf_string_width_precision) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  char* str = "Hello, World!";

  int result1 = s21_sprintf(buffer1, "%20.5s", str);
  int result2 = sprintf(buffer2, "%20.5s", str);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на ширину и точность для чисел с плавающей точкой:
START_TEST(test_s21_sprintf_float_width_precision) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  double num = 123.456789;

  int result1 = s21_sprintf(buffer1, "%10.3f", num);
  int result2 = sprintf(buffer2, "%10.3f", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты на спецификаторы с разными системами счисления
// Тест на шестнадцатеричное число с флагом #:
START_TEST(test_s21_sprintf_hex_hash) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned int num = 0xABCD;

  int result1 = s21_sprintf(buffer1, "%#x", num);
  int result2 = sprintf(buffer2, "%#x", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на восьмеричное число с флагом #:
START_TEST(test_s21_sprintf_octal_hash) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned int num = 0777;

  int result1 = s21_sprintf(buffer1, "%#o", num);
  int result2 = sprintf(buffer2, "%#o", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты на спецификаторы %n
// START_TEST(test_s21_sprintf_n_specifier) {
//   char buffer1[100] = {0};
//   char buffer2[100] = {0};
//   int count1 = 0, count2 = 0;

//   int result1 = s21_sprintf(buffer1, "Hello, World!%n", &count1);
//   int result2 = sprintf(buffer2, "Hello, World!%n", &count2);

//   ck_assert_str_eq(buffer1, buffer2);
//   ck_assert_int_eq(result1, result2);
//   ck_assert_int_eq(count1, count2);
// }
// END_TEST

// Тесты на спецификаторы %p
START_TEST(test_s21_sprintf_pointer) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  void* ptr = (void*)0xABCDEF;

  int result1 = s21_sprintf(buffer1, "%p", ptr);
  int result2 = sprintf(buffer2, "%p", ptr);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты на спецификаторы %p
START_TEST(test_s21_sprintf_pointer_left) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  void* ptr = (void*)0xABCDEF;

  int result1 = s21_sprintf(buffer1, "%-10p", ptr);
  int result2 = sprintf(buffer2, "%-10p", ptr);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты на спецификаторы %p
START_TEST(test_s21_sprintf_pointer_right) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  void* ptr = (void*)0xABCDEF;

  int result1 = s21_sprintf(buffer1, "%10p", ptr);
  int result2 = sprintf(buffer2, "%10p", ptr);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест: символ после %p + char
START_TEST(test_s21_sprintf_pointer_with_trailing_char) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  void* ptr = (void*)0x1234;

  // Формат: "%pX" — ожидаем "0x1234X"
  int result1 = s21_sprintf(buffer1, "%pX", ptr);
  int result2 = sprintf(buffer2, "%pX", ptr);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты на спецификаторы %g и %G
// Тест на спецификатор %g с большим числом:
START_TEST(test_s21_sprintf_g_large_number) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  double num = 1.23e+10;

  int result1 = s21_sprintf(buffer1, "%g", num);
  int result2 = sprintf(buffer2, "%g", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %G с маленьким числом:
START_TEST(test_s21_sprintf_G_small_number) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  double num = 1.23e-10;

  int result1 = s21_sprintf(buffer1, "%G", num);
  int result2 = sprintf(buffer2, "%G", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты на спецификаторы %e и %E
// Тест на спецификатор %e с отрицательным числом:
START_TEST(test_s21_sprintf_e_negative) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  double num = -123.456;

  int result1 = s21_sprintf(buffer1, "%e", num);
  int result2 = sprintf(buffer2, "%e", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %E с нулем:
START_TEST(test_s21_sprintf_E_zero) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  double num = 0.0;

  int result1 = s21_sprintf(buffer1, "%E", num);
  int result2 = sprintf(buffer2, "%E", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %u с максимальным значением:
START_TEST(test_s21_sprintf_u_max) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned int num = UINT_MAX;

  int result1 = s21_sprintf(buffer1, "%u", num);
  int result2 = sprintf(buffer2, "%u", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %c с нулевым символом:
START_TEST(test_s21_sprintf_c_null) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  char ch = '\0';

  int result1 = s21_sprintf(buffer1, "%c", ch);
  int result2 = sprintf(buffer2, "%c", ch);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %s с пустой строкой:
START_TEST(test_s21_sprintf_s_empty) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  char* str = "";

  int result1 = s21_sprintf(buffer1, "%s", str);
  int result2 = sprintf(buffer2, "%s", str);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %f с отрицательным числом:
START_TEST(test_s21_sprintf_f_negative) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  double num = -123.456;

  int result1 = s21_sprintf(buffer1, "%f", num);
  int result2 = sprintf(buffer2, "%f", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %d с нулем:
START_TEST(test_s21_sprintf_d_zero) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  int num = 0;

  int result1 = s21_sprintf(buffer1, "%d", num);
  int result2 = sprintf(buffer2, "%d", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %x с нулем:
START_TEST(test_s21_sprintf_x_zero) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned int num = 0;

  int result1 = s21_sprintf(buffer1, "%x", num);
  int result2 = sprintf(buffer2, "%x", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %o с нулем:
START_TEST(test_s21_sprintf_o_zero) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned int num = 0;

  int result1 = s21_sprintf(buffer1, "%o", num);
  int result2 = sprintf(buffer2, "%o", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %p с нулевым указателем:
START_TEST(test_s21_sprintf_p_null) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  void* ptr = NULL;

  int result1 = s21_sprintf(buffer1, "%p", ptr);
  int result2 = sprintf(buffer2, "%p", ptr);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %g с нулем:
START_TEST(test_s21_sprintf_g_zero) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  double num = 0.0;

  int result1 = s21_sprintf(buffer1, "%g", num);
  int result2 = sprintf(buffer2, "%g", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %u с нулем:
START_TEST(test_s21_sprintf_u_zero) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned int num = 0;

  int result1 = s21_sprintf(buffer1, "%u", num);
  int result2 = sprintf(buffer2, "%u", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %c с символом новой строки:
START_TEST(test_s21_sprintf_c_newline) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  char ch = '\n';

  int result1 = s21_sprintf(buffer1, "%c", ch);
  int result2 = sprintf(buffer2, "%c", ch);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %s с нулевым указателем:
// START_TEST(test_s21_sprintf_s_null) {
//   char buffer1[100] = {0};
//   char buffer2[100] = {0};
//   char *str = NULL;

//   int result1 = s21_sprintf(buffer1, "%s", str);
//   int result2 = sprintf(buffer2, "%s", str);

//   ck_assert_str_eq(buffer1, buffer2);
//   ck_assert_int_eq(result1, result2);
// }
// END_TEST

// Тест на спецификатор %f с нулем:
START_TEST(test_s21_sprintf_f_zero) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  double num = 0.0;

  int result1 = s21_sprintf(buffer1, "%f", num);
  int result2 = sprintf(buffer2, "%f", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %x с отрицательным числом:
START_TEST(test_s21_sprintf_x_negative) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned int num = -123;

  int result1 = s21_sprintf(buffer1, "%x", num);
  int result2 = sprintf(buffer2, "%x", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %o с отрицательным числом:
START_TEST(test_s21_sprintf_o_negative) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned int num = -123;

  int result1 = s21_sprintf(buffer1, "%o", num);
  int result2 = sprintf(buffer2, "%o", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %p с отрицательным числом:
START_TEST(test_s21_sprintf_p_negative) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  void* ptr = (void*)-123;

  int result1 = s21_sprintf(buffer1, "%p", ptr);
  int result2 = sprintf(buffer2, "%p", ptr);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %n с отрицательным числом:
// START_TEST(test_s21_sprintf_n_negative) {
//   char buffer1[100] = {0};
//   char buffer2[100] = {0};
//   int count1 = -123, count2 = -123;

//   int result1 = s21_sprintf(buffer1, "Hello, World!%n", &count1);
//   int result2 = sprintf(buffer2, "Hello, World!%n", &count2);

//   ck_assert_str_eq(buffer1, buffer2);
//   ck_assert_int_eq(result1, result2);
//   ck_assert_int_eq(count1, count2);
// }
// END_TEST

// Тест на спецификатор %g с отрицательным числом:
START_TEST(test_s21_sprintf_g_negative) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  double num = -123.456;

  int result1 = s21_sprintf(buffer1, "%g", num);
  int result2 = sprintf(buffer2, "%g", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %u с отрицательным числом:
START_TEST(test_s21_sprintf_u_negative) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned int num = -123;

  int result1 = s21_sprintf(buffer1, "%u", num);
  int result2 = sprintf(buffer2, "%u", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %c с отрицательным числом:
START_TEST(test_s21_sprintf_c_negative) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  char ch = -123;

  int result1 = s21_sprintf(buffer1, "%c", ch);
  int result2 = sprintf(buffer2, "%c", ch);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест на спецификатор %d с отрицательным числом:
START_TEST(test_s21_sprintf_d_negative) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  int num = -123;

  int result1 = s21_sprintf(buffer1, "%d", num);
  int result2 = sprintf(buffer2, "%d", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для %ls (широкие строки)
START_TEST(test_s21_sprintf_ls) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  wchar_t* wide_str = L"Hello, World!";

  int result1 = s21_sprintf(buffer1, "%ls", wide_str);
  int result2 = sprintf(buffer2, "%ls", wide_str);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для %lc (широкие символы)
START_TEST(test_s21_sprintf_lc) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned int wide_char = L'A';

  int result1 = s21_sprintf(buffer1, "%lc", wide_char);
  int result2 = sprintf(buffer2, "%lc", wide_char);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для %* (ширина и точность через аргумент)
START_TEST(test_s21_sprintf_width_precision_star) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  int width = 10;
  int precision = 4;
  double num = 123.456789;

  int result1 = s21_sprintf(buffer1, "%*.*f", width, precision, num);
  int result2 = sprintf(buffer2, "%*.*f", width, precision, num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для %Lf (long double)
START_TEST(test_s21_sprintf_long_double) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  long double num = 123.456789L;

  int result1 = s21_sprintf(buffer1, "%Lf", num);
  int result2 = sprintf(buffer2, "%Lf", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для %lu (unsigned long)
START_TEST(test_s21_sprintf_unsigned_long) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned long num = 123456789UL;

  int result1 = s21_sprintf(buffer1, "%lu", num);
  int result2 = sprintf(buffer2, "%lu", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для %% (символ процента)
START_TEST(test_s21_sprintf_percent) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%%");
  int result2 = sprintf(buffer2, "%%");

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для %ld (long int)
START_TEST(test_s21_sprintf_long_int) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  long int num = 123456789L;

  int result1 = s21_sprintf(buffer1, "%ld", num);
  int result2 = sprintf(buffer2, "%ld", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для %lld (long long int)
// START_TEST(test_s21_sprintf_long_long_int) {
//   char buffer1[100] = {0};
//   char buffer2[100] = {0};
//   long long int num = 123456789012345LL;

//   int result1 = s21_sprintf(buffer1, "%lld", num);
//   int result2 = sprintf(buffer2, "%lld", num);

//   ck_assert_str_eq(buffer1, buffer2);
//   ck_assert_int_eq(result1, result2);
// }
// END_TEST

// Тесты для %llu (unsigned long long int)
// START_TEST(test_s21_sprintf_unsigned_long_long_int) {
//   char buffer1[100] = {0};
//   char buffer2[100] = {0};
//   unsigned long long int num = 123456789012345ULL;

//   int result1 = s21_sprintf(buffer1, "%llu", num);
//   int result2 = sprintf(buffer2, "%llu", num);

//   ck_assert_str_eq(buffer1, buffer2);
//   ck_assert_int_eq(result1, result2);
// }
// END_TEST

// Тесты для %h (short int)
START_TEST(test_s21_sprintf_short_int) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  short int num = 12345;

  int result1 = s21_sprintf(buffer1, "%hd", num);
  int result2 = sprintf(buffer2, "%hd", num);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тесты для %hhu (unsigned char)
// START_TEST(test_s21_sprintf_unsigned_char) {
//   char buffer1[100] = {0};
//   char buffer2[100] = {0};
//   unsigned char num = 255;

//   int result1 = s21_sprintf(buffer1, "%hhu", num);
//   int result2 = sprintf(buffer2, "%hhu", num);

//   ck_assert_str_eq(buffer1, buffer2);
//   ck_assert_int_eq(result1, result2);
// }
// END_TEST

// Тесты для %n (количество записанных символов)
// START_TEST(test_s21_sprintf_n) {
//   char buffer1[100] = {0};
//   char buffer2[100] = {0};
//   int count1 = 0, count2 = 0;

//   int result1 = s21_sprintf(buffer1, "Hello, World!%n", &count1);
//   int result2 = sprintf(buffer2, "Hello, World!%n", &count2);

//   ck_assert_str_eq(buffer1, buffer2);
//   ck_assert_int_eq(result1, result2);
//   ck_assert_int_eq(count1, count2);
// }
// END_TEST
// Тест всех флагов для d
START_TEST(test_s21_sprintf_allFlag_d1) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%+20.5d", 1232332);
  int result2 = sprintf(buffer2, "%+20.5d", 1232332);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_d2) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%- 20.7d", 123);
  int result2 = sprintf(buffer2, "%- 20.7d", 123);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST
// Тест всех флагов для i
START_TEST(test_s21_sprintf_allFlag_i1) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%+20.5i", 1232332);
  int result2 = sprintf(buffer2, "%+20.5i", 1232332);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_i2) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%- 20.7i", 123);
  int result2 = sprintf(buffer2, "%- 20.7i", 123);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST
// Тест всех флагов для f
START_TEST(test_s21_sprintf_allFlag_f1) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%#+020.5f", 1232332.);
  int result2 = sprintf(buffer2, "%#+020.5f", 1232332.);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_f2) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%- 20.0f", 123.);
  int result2 = sprintf(buffer2, "%- 20.0f", 123.);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_f3) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%020.5Lf", -123.123L);
  int result2 = sprintf(buffer2, "%020.5Lf", -123.123L);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_f4) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%0.0e", 0.);
  int result2 = sprintf(buffer2, "%0.0e", 0.);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST
// Тест всех флагов для u
START_TEST(test_s21_sprintf_allFlag_u1) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%*.*u", 20, 8, 123u);
  int result2 = sprintf(buffer2, "%*.*u", 20, 8, 123u);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_u2) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%-*.*u", 20, 8, -123u);
  int result2 = sprintf(buffer2, "%-*.*u", 20, 8, -123u);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_u3) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%-.*u", 8, 123u);
  int result2 = sprintf(buffer2, "%-.*u", 8, 123u);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

// Тест всех флагов для o
START_TEST(test_s21_sprintf_allFlag_o1) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%#*.*lo", 20, 8, 12332l);
  int result2 = sprintf(buffer2, "%#*.*lo", 20, 8, 12332l);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_o2) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%-#*.*ho", 20, 8, (short unsigned)12332);
  int result2 = sprintf(buffer2, "%-#*.*ho", 20, 8, (short unsigned)12332);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_o3) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%-*.llo", 20, -1233223232ll);
  int result2 = sprintf(buffer2, "%-*llo", 20, -1233223232ll);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST
// Тест всех флагов для e
START_TEST(test_s21_sprintf_allFlag_e1) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%+#*.*Le", 20, 8, 123123.123123L);
  int result2 = sprintf(buffer2, "%+#*.*Le", 20, 8, 123123.123123L);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_e2) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%- *.*e", 20, 8, 1231232323.);
  int result2 = sprintf(buffer2, "%- *.*e", 20, 8, 1231232323.);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_e3) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%0*.*e", 20, 8, .99999999999);
  int result2 = sprintf(buffer2, "%0*.*e", 20, 8, .99999999999);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_e4) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%0.0e", 0.);
  int result2 = sprintf(buffer2, "%0.0e", 0.);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_e5) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%20Le", 123e-145L);
  int result2 = sprintf(buffer2, "%20Le", 123e-145L);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_e6) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%-20Le", 123e+145L);
  int result2 = sprintf(buffer2, "%-20Le", 123e+145L);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST
// Тест всех флагов для E
START_TEST(test_s21_sprintf_allFlag_E1) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%+#*.*LE", 20, 8, 123123.123123L);
  int result2 = sprintf(buffer2, "%+#*.*LE", 20, 8, 123123.123123L);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_E2) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%- *.*E", 20, 8, 1231232323.);
  int result2 = sprintf(buffer2, "%- *.*E", 20, 8, 1231232323.);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_E3) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%0*.*E", 20, 8, .99999999999);
  int result2 = sprintf(buffer2, "%0*.*E", 20, 8, .99999999999);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_E4) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%0.0E", 0.);
  int result2 = sprintf(buffer2, "%0.0E", 0.);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_E5) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%20LE", 123e-145L);
  int result2 = sprintf(buffer2, "%20LE", 123e-145L);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_E6) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%-20LE", 123e+145L);
  int result2 = sprintf(buffer2, "%-20LE", 123e+145L);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST
// Тест всех флагов для g
START_TEST(test_s21_sprintf_allFlag_g1) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%+*.*Lg", 20, 8, 123123.123123L);
  int result2 = sprintf(buffer2, "%+*.*Lg", 20, 8, 123123.123123L);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_g2) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%-# *.*g", 20, 8, 123.000000000);
  int result2 = sprintf(buffer2, "%-# *.*g", 20, 8, 123.000000000);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_g3) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%0*Lg", 20, 1.12340L);
  int result2 = sprintf(buffer2, "%0*Lg", 20, 1.12340L);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST
// Тест всех флагов для G
START_TEST(test_s21_sprintf_allFlag_G1) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%+*.*LG", 20, 8, 123123.123123L);
  int result2 = sprintf(buffer2, "%+*.*LG", 20, 8, 123123.123123L);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_G2) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%-# *.*G", 20, 8, 123.000000000);
  int result2 = sprintf(buffer2, "%-# *.*G", 20, 8, 123.000000000);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_G3) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%0*LG", 20, 1.12340L);
  int result2 = sprintf(buffer2, "%0*LG", 20, 1.12340L);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST
// Тест всех флагов для x
START_TEST(test_s21_sprintf_allFlag_x1) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%#*.*lx", 20, 8, 12345l);
  int result2 = sprintf(buffer2, "%#*.*lx", 20, 8, 12345l);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_x2) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%-#*.*llx", 20, 8, 12345ll);
  int result2 = sprintf(buffer2, "%-#*.*llx", 20, 8, 12345ll);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_x3) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%#*.*hx", 20, 8, (short unsigned)-12345);
  int result2 = sprintf(buffer2, "%#*.*hx", 20, 8, (short unsigned)-12345);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_x4) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%-.8x", 0x235543);
  int result2 = sprintf(buffer2, "%-.8x", 0x235543);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST
// Тест всех флагов для X
START_TEST(test_s21_sprintf_allFlag_X1) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%#*.*lX", 20, 8, 12345l);
  int result2 = sprintf(buffer2, "%#*.*lX", 20, 8, 12345l);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_X2) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%-#*.*llX", 20, 8, 12345ll);
  int result2 = sprintf(buffer2, "%-#*.*llX", 20, 8, 12345ll);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_X3) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%#*.*hX", 20, 8, (short unsigned)-12345);
  int result2 = sprintf(buffer2, "%#*.*hX", 20, 8, (short unsigned)-12345);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_X4) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%-.8X", 0x235543);
  int result2 = sprintf(buffer2, "%-.8X", 0x235543);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST
// Тест всех флагов для c
START_TEST(test_s21_sprintf_allFlag_c1) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned int d = L'\U0001F600';
  setlocale(LC_ALL, "");
  int result1 = s21_sprintf(buffer1, "%*lc", 20, d);
  int result2 = sprintf(buffer2, "%*lc", 20, d);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_c2) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  unsigned int d = L'\U0001F600';
  setlocale(LC_ALL, "");
  int result1 = s21_sprintf(buffer1, "%-*lc", 20, d);
  int result2 = sprintf(buffer2, "%-*lc", 20, d);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_c3) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%-*c", 20, 'r');
  int result2 = sprintf(buffer2, "%-*c", 20, 'r');

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST
// Тест всех флагов для s
START_TEST(test_s21_sprintf_allFlag_s1) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  setlocale(LC_ALL, "");
  int result1 =
      s21_sprintf(buffer1, "%*ls", 20, L"\U0001F600\U0001F680\U0001F525");
  int result2 = sprintf(buffer2, "%*ls", 20, L"\U0001F600\U0001F680\U0001F525");

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_s2) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};
  setlocale(LC_ALL, "");
  int result1 =
      s21_sprintf(buffer1, "%-*.2ls", 20, L"\U0001F600\U0001F680\U0001F525");
  int result2 =
      sprintf(buffer2, "%-*.2ls", 20, L"\U0001F600\U0001F680\U0001F525");

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_s3) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 =
      s21_sprintf(buffer1, "%-.10s", "hello world, pivo + popa = goooood");
  int result2 =
      sprintf(buffer2, "%-.10s", "hello world, pivo + popa = goooood");

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST
// тест на удаление точки
START_TEST(test_s21_sprintf_allFlag_delPoint1) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%-#.0f", 100.);
  int result2 = sprintf(buffer2, "%-#.0f", 100.);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_delPoint2) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%-#10.0f", 100.);
  int result2 = sprintf(buffer2, "%-#10.0f", 100.);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_delPoint3) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%-#10.0e", 100.);
  int result2 = sprintf(buffer2, "%-#10.0e", 100.);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_delPoint4) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%#+10.0f", 100.);
  int result2 = sprintf(buffer2, "%#+10.0f", 100.);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_delPoint5) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%#+010.0f", 100.);
  int result2 = sprintf(buffer2, "%#+010.0f", 100.);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

START_TEST(test_s21_sprintf_allFlag_delPoint6) {
  char buffer1[100] = {0};
  char buffer2[100] = {0};

  int result1 = s21_sprintf(buffer1, "%#+.0f", 100.);
  int result2 = sprintf(buffer2, "%#+.0f", 100.);

  ck_assert_str_eq(buffer1, buffer2);
  ck_assert_int_eq(result1, result2);
}
END_TEST

Suite* s21_sprintf_suite() {
  Suite* s = suite_create("s21_sprintf");
  TCase* tc_core = tcase_create("core");

  tcase_add_test(tc_core, test_s21_sprintf_d);
  tcase_add_test(tc_core, test_s21_sprintf_s);
  tcase_add_test(tc_core, test_s21_sprintf_x);
  tcase_add_test(tc_core, test_s21_sprintf_e);
  tcase_add_test(tc_core, test_s21_sprintf_g);
  tcase_add_test(tc_core, test_s21_sprintf_flags);
  tcase_add_test(tc_core, test_s21_sprintf_c);
  tcase_add_test(tc_core, test_s21_sprintf_u);
  tcase_add_test(tc_core, test_s21_sprintf_x_lower);
  tcase_add_test(tc_core, test_s21_sprintf_x_upper);
  tcase_add_test(tc_core, test_s21_sprintf_o);
  tcase_add_test(tc_core, test_s21_sprintf_p);
  tcase_add_test(tc_core, test_s21_sprintf_e_lower);
  tcase_add_test(tc_core, test_s21_sprintf_e_upper);
  tcase_add_test(tc_core, test_s21_sprintf_g_lower);
  tcase_add_test(tc_core, test_s21_sprintf_g_upper);
  tcase_add_test(tc_core, test_s21_sprintf_precision);
  tcase_add_test(tc_core, test_s21_sprintf_g_capital);
  tcase_add_test(tc_core, test_s21_sprintf_flags_plus);
  tcase_add_test(tc_core, test_s21_sprintf_flags_space);
  tcase_add_test(tc_core, test_s21_sprintf_flags_minus);
  tcase_add_test(tc_core, test_s21_sprintf_flags_double_plus);
  tcase_add_test(tc_core, test_s21_sprintf_width);
  tcase_add_test(tc_core, test_s21_sprintf_f);
  tcase_add_test(tc_core, test_s21_sprintf_flags_zero);
  tcase_add_test(tc_core, test_s21_sprintf_combined);

  tcase_add_test(tc_core, test_s21_sprintf_flags_plus_zero_width);
  tcase_add_test(tc_core, test_s21_sprintf_flags_minus_hash_width);
  tcase_add_test(
      tc_core,
      test_s21_sprintf_flags_space_plus_precision);  // failed: buffer1 ==
                                                     // "-123", buffer2 ==
                                                     // "-00123"
  tcase_add_test(tc_core, test_s21_sprintf_int_max);
  tcase_add_test(tc_core, test_s21_sprintf_int_min);
  tcase_add_test(tc_core,
                 test_s21_sprintf_large_float);  // (after this point) Received
                                                 // signal 6 (Aborted)
  tcase_add_test(
      tc_core,
      test_s21_sprintf_string_width_precision);  // failed: buffer1 == " Hello,
                                                 // World!", buffer2 == " Hello"
  tcase_add_test(tc_core, test_s21_sprintf_float_width_precision);
  tcase_add_test(tc_core, test_s21_sprintf_hex_hash);
  tcase_add_test(tc_core, test_s21_sprintf_octal_hash);
  // tcase_add_test(tc_core, test_s21_sprintf_n_specifier); // failed: count1 ==
  // 0, count2 == 13
  tcase_add_test(tc_core, test_s21_sprintf_pointer);
  tcase_add_test(tc_core, test_s21_sprintf_pointer_left);
  tcase_add_test(tc_core, test_s21_sprintf_pointer_right);
  tcase_add_test(tc_core, test_s21_sprintf_pointer_with_trailing_char);
  tcase_add_test(tc_core, test_s21_sprintf_g_large_number);
  tcase_add_test(tc_core, test_s21_sprintf_G_small_number);
  tcase_add_test(
      tc_core,
      test_s21_sprintf_e_negative);  // failed: buffer1 == "-123.456000e+00",
                                     // buffer2 == "-1.234560e+02"
  tcase_add_test(
      tc_core,
      test_s21_sprintf_E_zero);  // (after this point) Test timeout expired
  tcase_add_test(tc_core, test_s21_sprintf_u_max);
  tcase_add_test(
      tc_core, test_s21_sprintf_c_null);  // failed: result1 == 0, result2 == 1
  tcase_add_test(tc_core, test_s21_sprintf_s_empty);
  tcase_add_test(tc_core, test_s21_sprintf_f_negative);
  tcase_add_test(tc_core, test_s21_sprintf_d_zero);
  tcase_add_test(tc_core, test_s21_sprintf_x_zero);
  tcase_add_test(tc_core, test_s21_sprintf_o_zero);
  tcase_add_test(tc_core,
                 test_s21_sprintf_p_null);  //  failed: buffer1 == "0x0",
                                            //  buffer2 == "(nil)"
  tcase_add_test(tc_core,
                 test_s21_sprintf_g_zero);  //  failed: buffer1 == "0x0",
                                            //  buffer2 == "(nil)"
  tcase_add_test(tc_core, test_s21_sprintf_u_zero);
  tcase_add_test(tc_core, test_s21_sprintf_c_newline);
  // tcase_add_test(tc_core,
  //                test_s21_sprintf_s_null);  //  (after this point) Received
  //   signal 11 (Segmentation fault)
  tcase_add_test(
      tc_core,
      test_s21_sprintf_f_zero);  // (after this point) Test timeout expired
  tcase_add_test(tc_core, test_s21_sprintf_x_negative);
  tcase_add_test(tc_core, test_s21_sprintf_o_negative);
  tcase_add_test(tc_core,
                 test_s21_sprintf_p_negative);  //  buffer1 == "0x7b", buffer2
                                                //  == "0xffffffffffffff85"
  // tcase_add_test(tc_core, test_s21_sprintf_n_negative); // count1 == -123,
  // count2 == 13
  tcase_add_test(tc_core,
                 test_s21_sprintf_g_negative);  //  buffer1 == "-123.46",
                                                //  buffer2 == "-123.456"
  tcase_add_test(tc_core, test_s21_sprintf_u_negative);
  tcase_add_test(tc_core, test_s21_sprintf_c_negative);
  tcase_add_test(tc_core, test_s21_sprintf_d_negative);

  // ЕЩЕ БОЛЬШЕ ТЕСТОВ, Я УЖЕ ИМИ ОБМАЗЫВАЮСЬ
  tcase_add_test(tc_core, test_s21_sprintf_ls);
  tcase_add_test(tc_core, test_s21_sprintf_lc);
  tcase_add_test(tc_core, test_s21_sprintf_width_precision_star);
  tcase_add_test(tc_core, test_s21_sprintf_long_double);
  tcase_add_test(tc_core, test_s21_sprintf_unsigned_long);
  tcase_add_test(tc_core, test_s21_sprintf_percent);
  tcase_add_test(tc_core, test_s21_sprintf_long_int);
  // tcase_add_test(tc_core, test_s21_sprintf_long_long_int); // failed: buffer1
  // == "d", buffer2 == "123456789012345" tcase_add_test(tc_core,
  // test_s21_sprintf_unsigned_long_long_int); // failed: buffer1 == "u",
  // buffer2 == "123456789012345"
  tcase_add_test(tc_core, test_s21_sprintf_short_int);
  // tcase_add_test(tc_core, test_s21_sprintf_unsigned_char); // failed: buffer1
  // == "u", buffer2 == "255" tcase_add_test(tc_core, test_s21_sprintf_n); //
  // failed: count1 == 0, count2 == 13
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_d1);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_d2);

  tcase_add_test(tc_core, test_s21_sprintf_allFlag_i1);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_i2);

  tcase_add_test(tc_core, test_s21_sprintf_allFlag_f1);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_f2);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_f3);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_f4);

  tcase_add_test(tc_core, test_s21_sprintf_allFlag_u1);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_u2);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_u3);

  tcase_add_test(tc_core, test_s21_sprintf_allFlag_o1);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_o2);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_o3);

  tcase_add_test(tc_core, test_s21_sprintf_allFlag_e1);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_e2);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_e3);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_e4);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_e5);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_e6);

  tcase_add_test(tc_core, test_s21_sprintf_allFlag_E1);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_E2);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_E3);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_E4);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_E5);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_E6);

  tcase_add_test(tc_core, test_s21_sprintf_allFlag_g1);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_g2);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_g3);

  tcase_add_test(tc_core, test_s21_sprintf_allFlag_G1);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_G2);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_G3);

  tcase_add_test(tc_core, test_s21_sprintf_allFlag_x1);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_x2);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_x3);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_x4);

  tcase_add_test(tc_core, test_s21_sprintf_allFlag_X1);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_X2);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_X3);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_X4);

  tcase_add_test(tc_core, test_s21_sprintf_allFlag_c1);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_c2);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_c3);

  tcase_add_test(tc_core, test_s21_sprintf_allFlag_s1);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_s2);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_s3);

  tcase_add_test(tc_core, test_s21_sprintf_allFlag_delPoint1);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_delPoint2);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_delPoint3);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_delPoint4);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_delPoint5);
  tcase_add_test(tc_core, test_s21_sprintf_allFlag_delPoint6);
  suite_add_tcase(s, tc_core);

  return s;
}
int main() {
  // int number_failed = 0;
  Suite* s = S21_NULL;
  SRunner* sr = S21_NULL;
  sr = srunner_create(S21_NULL);
  s = s21_sprintf_suite();
  srunner_add_suite(sr, s);
  printf(YELLOW);
  srunner_run_all(sr, CK_NORMAL);
  printf(RESET);
  int number_failed = srunner_ntests_failed(sr);
  srunner_free(sr);
  // return 0;
  return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}