src/tests/test_sprintf.c - develop - ne-ilyxa/C2_s21_stringplus

src/tests/test_sprintf.c
1 241 строка38 KB
git1worker
Check all
27 янв 2024, 21:56
27 янв 2024, 21:56ca96060
#include <check.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

#include "../s21_string.h"

START_TEST(test_1) {
  char buffer1[20000];
  char buffer2[20000];

  char c = 'a';
  short e = 10;

  sprintf(buffer1, "%c|%10c|%-10c|%*c\n", c, c, c, e, c);
  s21_sprintf(buffer2, "%c|%10c|%-10c|%*c\n", c, c, c, e, c);

  ck_assert_str_eq(buffer1, buffer2);
}
END_TEST

START_TEST(test_2) {
  char buffer1[20000];
  char buffer2[20000];

  for (int b = -100; b <= 100; ++b) {
    sprintf(buffer1,
            "%d|%+d|% d|%010d|%+010d|%-10d|%hd|%ld|%.10d|% "
            ".10d|%+.10d|%*d|%.*d|%13.10d\n",
            b, b, b, b, b, b, (short)b, (long)b, b, b, b, 10, b, 10, b, b);
    s21_sprintf(buffer2,
                "%d|%+d|% d|%010d|%+010d|%-10d|%hd|%ld|%.10d|% "
                ".10d|%+.10d|%*d|%.*d|%13.10d\n",
                b, b, b, b, b, b, (short)b, (long)b, b, b, b, 10, b, 10, b, b);

    ck_assert_str_eq(buffer1, buffer2);
  }
  for (int b = 10000; b < INT32_MAX / 10; b *= 10) {
    sprintf(buffer1,
            "%d|%+d|% d|%010d|%+010d|%-10d|%hd|%ld|%.10d|% "
            ".10d|%+.10d|%*d|%.*d|%13.10d\n",
            b, b, b, b, b, b, (short)b, (long)b, b, b, b, 10, b, 10, b, b);
    s21_sprintf(buffer2,
                "%d|%+d|% d|%010d|%+010d|%-10d|%hd|%ld|%.10d|% "
                ".10d|%+.10d|%*d|%.*d|%13.10d\n",
                b, b, b, b, b, b, (short)b, (long)b, b, b, b, 10, b, 10, b, b);

    ck_assert_str_eq(buffer1, buffer2);
  }
}
END_TEST

START_TEST(test_4) {
  char buffer1[20000];
  char buffer2[20000];

  for (float b = -100; b <= 100; b += 0.5) {
    sprintf(buffer1,
            "\n%e|%+e|% e|% 015e|%+015e|%-15e|%Le|%.10e|% "
            ".10e|%+.10e|%#e|%*e|%.*e|%23.10e\n",
            b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 15, b, b);
    s21_sprintf(buffer2,
                "\n%e|%+e|% e|% 015e|%+015e|%-15e|%Le|%.10e|% "
                ".10e|%+.10e|%#e|%*e|%.*e|%23.10e\n",
                b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 15, b, b);

    ck_assert_str_eq(buffer1, buffer2);
  }
  float b = 1000000000.2323;
  sprintf(buffer1,
          "\n%e|%+e|% e|% 015e|%+015e|%-15e|%Le|%.10e|% "
          ".10e|%+.10e|%#e|%*e|%.*e|%23.10e\n",
          b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 15, b, b);
  s21_sprintf(buffer2,
              "\n%e|%+e|% e|% 015e|%+015e|%-15e|%Le|%.10e|% "
              ".10e|%+.10e|%#e|%*e|%.*e|%23.10e\n",
              b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 15, b, b);

  ck_assert_str_eq(buffer1, buffer2);

  b = 1334002130000.2323;
  sprintf(buffer1,
          "\n%e|%+e|% e|% 015e|%+015e|%-15e|%Le|%.10e|% "
          ".10e|%+.10e|%#e|%*e|%.*e|%23.10e\n",
          b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 15, b, b);
  s21_sprintf(buffer2,
              "\n%e|%+e|% e|% 015e|%+015e|%-15e|%Le|%.10e|% "
              ".10e|%+.10e|%#e|%*e|%.*e|%23.10e\n",
              b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 15, b, b);

  ck_assert_str_eq(buffer1, buffer2);

  b = 1345233320045350.5523;
  sprintf(buffer1,
          "\n%e|%+e|% e|% 015e|%+015e|%-15e|%Le|%.10e|% "
          ".10e|%+.10e|%#e|%*e|%.*e|%23.10e\n",
          b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 15, b, b);
  s21_sprintf(buffer2,
              "\n%e|%+e|% e|% 015e|%+015e|%-15e|%Le|%.10e|% "
              ".10e|%+.10e|%#e|%*e|%.*e|%23.10e\n",
              b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 15, b, b);

  ck_assert_str_eq(buffer1, buffer2);
  b = 999999999999.999;
  sprintf(buffer1,
          "\n%.3e|%e|%+e|% e|% 015e|%+015e|%-15e|%Le|%.10e|% "
          ".10e|%+.10e|%#e|%*e|%.*e|%23.10e\n",
          b, b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 15, b, b);
  s21_sprintf(buffer2,
              "\n%.3e|%e|%+e|% e|% 015e|%+015e|%-15e|%Le|%.10e|% "
              ".10e|%+.10e|%#e|%*e|%.*e|%23.10e\n",
              b, b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 15, b, b);

  ck_assert_str_eq(buffer1, buffer2);
}
END_TEST

START_TEST(test_5) {
  char buffer1[20000];
  char buffer2[20000];

  for (float b = -100; b <= 100; b += 0.5) {
    sprintf(buffer1,
            "%E|%+E|% E|%015E|%+015E|%-15E|%LE|%.10E|% "
            ".10E|%+.10E|%#E|%*E|%.*E|%23.10E\n",
            b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 15, b, b);
    s21_sprintf(buffer2,
                "%E|%+E|% E|%015E|%+015E|%-15E|%LE|%.10E|% "
                ".10E|%+.10E|%#E|%*E|%.*E|%23.10E\n",
                b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 15, b, b);

    ck_assert_str_eq(buffer1, buffer2);
  }
}
END_TEST

START_TEST(test_6) {
  char buffer1[20000];
  char buffer2[20000];

  for (double b = -100; b <= 100; b += 0.01) {
    sprintf(buffer1,
            "\n%f|%+f|% f|%010f|%+010f|%-10f|%Lf|% "
            ".10f|%+.10f|%#f|%*f|%.*f|%23.10f\n",
            b, b, b, b, b, b, (long double)b, b, b, b, 15, b, 15, b, b);
    s21_sprintf(buffer2,
                "\n%f|%+f|% f|%010f|%+010f|%-10f|%Lf|% "
                ".10f|%+.10f|%#f|%*f|%.*f|%23.10f\n",
                b, b, b, b, b, b, (long double)b, b, b, b, 15, b, 15, b, b);

    ck_assert_str_eq(buffer1, buffer2);
  }
  float b = 0.55555555555;
  sprintf(buffer1,
          "\n%f|%+f|% f|%010f|%+010f|%-10f|%Lf|% "
          ".10f|%+.10f|%#f|%*f|%.*f|%23.10f|%lf\n",
          b, b, b, b, b, b, (long double)b, b, b, b, 15, b, 15, b, b,
          (double)b);
  s21_sprintf(buffer2,
              "\n%f|%+f|% f|%010f|%+010f|%-10f|%Lf|% "
              ".10f|%+.10f|%#f|%*f|%.*f|%23.10f|%lf\n",
              b, b, b, b, b, b, (long double)b, b, b, b, 15, b, 15, b, b,
              (double)b);
  ck_assert_str_eq(buffer1, buffer2);
}
END_TEST

START_TEST(test_7) {
  char buffer1[20000];
  char buffer2[20000];

  for (float b = -100; b <= 1000; b += 0.5) {
    sprintf(buffer1,
            "\n%g|%+g|% g|%015g|%+015g|%-15g|%Lg|%.10g|% "
            ".10g|%+.10g|%#g|%*g|%.*g|%23.10g\n",
            b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 15, b, b);
    s21_sprintf(buffer2,
                "\n%g|%+g|% g|%015g|%+015g|%-15g|%Lg|%.10g|% "
                ".10g|%+.10g|%#g|%*g|%.*g|%23.10g\n",
                b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 15, b, b);

    ck_assert_str_eq(buffer1, buffer2);
  }
  float b = 1125.55;
  sprintf(buffer1,
          "\n%g|%+g|% g|%015g|%+015g|%-15g|%Lg|%.10g|% "
          ".10g|%+.10g|%#g|%*g|%.*g|%23.10g|%.3g\n",
          b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 10, b, b, b);
  s21_sprintf(buffer2,
              "\n%g|%+g|% g|%015g|%+015g|%-15g|%Lg|%.10g|% "
              ".10g|%+.10g|%#g|%*g|%.*g|%23.10g|%.3g\n",
              b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 10, b, b, b);
  ck_assert_str_eq(buffer1, buffer2);
  b = 99999999.99;
  sprintf(buffer1,
          "\n%g|%+g|% g|%015g|%+015g|%-15g|%Lg|%.10g|% "
          ".10g|%+.10g|%#g|%*g|%.*g|%23.10g|%.3g\n",
          b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 10, b, b, b);
  s21_sprintf(buffer2,
              "\n%g|%+g|% g|%015g|%+015g|%-15g|%Lg|%.10g|% "
              ".10g|%+.10g|%#g|%*g|%.*g|%23.10g|%.3g\n",
              b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 10, b, b, b);
  ck_assert_str_eq(buffer1, buffer2);
  b = 9.9999999999;
  sprintf(buffer1,
          "\n%g|%+g|% g|%015g|%+015g|%-15g|%Lg|%.10g|% "
          ".10g|%+.10g|%#g|%*g|%.*g|%23.10g|%.3g\n",
          b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 10, b, b, b);
  s21_sprintf(buffer2,
              "\n%g|%+g|% g|%015g|%+015g|%-15g|%Lg|%.10g|% "
              ".10g|%+.10g|%#g|%*g|%.*g|%23.10g|%.3g\n",
              b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 10, b, b, b);
  ck_assert_str_eq(buffer1, buffer2);
  b = 123123123123131.55;
  sprintf(buffer1,
          "\n%g|%+g|% g|%015g|%+015g|%-15g|%Lg|%.10g|% "
          ".10g|%+.10g|%#g|%*g|%.*g|%23.10g|%.3g\n",
          b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 10, b, b, b);
  s21_sprintf(buffer2,
              "\n%g|%+g|% g|%015g|%+015g|%-15g|%Lg|%.10g|% "
              ".10g|%+.10g|%#g|%*g|%.*g|%23.10g|%.3g\n",
              b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 10, b, b, b);
  ck_assert_str_eq(buffer1, buffer2);
}
END_TEST

START_TEST(test_8) {
  char buffer1[20000];
  char buffer2[20000];

  for (float b = -100; b <= 100; b += 0.5) {
    sprintf(buffer1,
            "%G|%+G|% G|%015G|%+015G|%-15G|%LG|%.10G|% "
            ".10G|%+.10G|%#G|%*G|%.*G|%23.10G\n",
            b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 15, b, b);
    s21_sprintf(buffer2,
                "%G|%+G|% G|%015G|%+015G|%-15G|%LG|%.10G|% "
                ".10G|%+.10G|%#G|%*G|%.*G|%23.10G\n",
                b, b, b, b, b, b, (long double)b, b, b, b, b, 15, b, 15, b, b);

    ck_assert_str_eq(buffer1, buffer2);
  }
}
END_TEST

START_TEST(test_9) {
  char buffer1[20000];
  char buffer2[20000];

  for (unsigned b = 0; b <= 100; ++b) {
    sprintf(buffer1,
            "%o|%010o|%-10o|%ho|%lo|%.10o|%#o|%#.4o|%*o|%.*o|%23.10o\n", b, b,
            b, (unsigned short)b, (unsigned long)b, b, b, b, 15, b, 15, b, b);
    s21_sprintf(
        buffer2, "%o|%010o|%-10o|%ho|%lo|%.10o|%#o|%#.4o|%*o|%.*o|%23.10o\n", b,
        b, b, (unsigned short)b, (unsigned long)b, b, b, b, 15, b, 15, b, b);

    ck_assert_str_eq(buffer1, buffer2);
  }
  unsigned b = 1231212312U;
  sprintf(buffer1, "%o|%010o|%-10o|%ho|%lo|%.10o|%#o|%#.4o|%*o|%.*o|%23.10o\n",
          b, b, b, (unsigned short)b, (unsigned long)b, b, b, b, 15, b, 15, b,
          b);
  s21_sprintf(buffer2,
              "%o|%010o|%-10o|%ho|%lo|%.10o|%#o|%#.4o|%*o|%.*o|%23.10o\n", b, b,
              b, (unsigned short)b, (unsigned long)b, b, b, b, 15, b, 15, b, b);
  ck_assert_str_eq(buffer1, buffer2);
  b = UINT32_MAX;
  sprintf(buffer1, "%o|%010o|%-10o|%ho|%lo|%.10o|%#o|%#.4o|%*o|%.*o|%23.10o\n",
          b, b, b, (unsigned short)b, (unsigned long)b, b, b, b, 15, b, 15, b,
          b);
  s21_sprintf(buffer2,
              "%o|%010o|%-10o|%ho|%lo|%.10o|%#o|%#.4o|%*o|%.*o|%23.10o\n", b, b,
              b, (unsigned short)b, (unsigned long)b, b, b, b, 15, b, 15, b, b);
  ck_assert_str_eq(buffer1, buffer2);
  b = 1231200312U;
  sprintf(buffer1, "%o|%010o|%-10o|%ho|%lo|%.10o|%#o|%#.4o|%*o|%.*o|%23.10o\n",
          b, b, b, (unsigned short)b, (unsigned long)b, b, b, b, 15, b, 15, b,
          b);
  s21_sprintf(buffer2,
              "%o|%010o|%-10o|%ho|%lo|%.10o|%#o|%#.4o|%*o|%.*o|%23.10o\n", b, b,
              b, (unsigned short)b, (unsigned long)b, b, b, b, 15, b, 15, b, b);
  ck_assert_str_eq(buffer1, buffer2);
  b = 1;
  sprintf(buffer1, "%o|%010o|%-10o|%ho|%lo|%.10o|%#o|%#.4o|%*o|%.*o|%23.10o\n",
          b, b, b, (unsigned short)b, (unsigned long)b, b, b, b, 15, b, 15, b,
          b);
  s21_sprintf(buffer2,
              "%o|%010o|%-10o|%ho|%lo|%.10o|%#o|%#.4o|%*o|%.*o|%23.10o\n", b, b,
              b, (unsigned short)b, (unsigned long)b, b, b, b, 15, b, 15, b, b);
  ck_assert_str_eq(buffer1, buffer2);
}
END_TEST

START_TEST(test_10) {
  char buffer1[20000];
  char buffer2[20000];

  char aa[] = "2123";

  sprintf(buffer1, "%s|%-10.2s|%.2s|%5s|%*s|%.*s|\n", aa, aa, aa, aa, 15, aa,
          15, aa);
  s21_sprintf(buffer2, "%s|%-10.2s|%.2s|%5s|%*s|%.*s|\n", aa, aa, aa, aa, 15,
              aa, 15, aa);

  ck_assert_str_eq(buffer1, buffer2);
}
END_TEST

START_TEST(test_11) {
  char buffer1[20000];
  char buffer2[20000];

  for (unsigned b = 0; b <= 100; ++b) {
    sprintf(buffer1, "%u|%010u|%-10u|%hu|%lu|%.10u|%*u|%.*u|%23.10u\n", b, b, b,
            (unsigned short)b, (unsigned long)b, b, 15, b, 15, b, b);
    s21_sprintf(buffer2, "%u|%010u|%-10u|%hu|%lu|%.10u|%*u|%.*u|%23.10u\n", b,
                b, b, (unsigned short)b, (unsigned long)b, b, 15, b, 15, b, b);

    ck_assert_str_eq(buffer1, buffer2);
  }
  unsigned b = UINT32_MAX;
  sprintf(buffer1, "%u|%010u|%-10u|%hu|%lu|%.10u|%*u|%.*u|%23.10u\n", b, b, b,
          (unsigned short)b, (unsigned long)b, b, 15, b, 15, b, b);
  s21_sprintf(buffer2, "%u|%010u|%-10u|%hu|%lu|%.10u|%*u|%.*u|%23.10u\n", b, b,
              b, (unsigned short)b, (unsigned long)b, b, 15, b, 15, b, b);
  ck_assert_str_eq(buffer1, buffer2);
}
END_TEST

START_TEST(test_12) {
  char buffer1[20000];
  char buffer2[20000];

  for (int b = -100; b <= 100; ++b) {
    sprintf(buffer1,
            "%x|%010x|%-10x|%#20x|%.10x|%#x|%#.10x|%*x|%.*x|%23.10x|%hx|%lx\n",
            b, b, b, b, b, b, b, 15, b, 15, b, b, (short)b, (long)b);
    s21_sprintf(
        buffer2,
        "%x|%010x|%-10x|%#20x|%.10x|%#x|%#.10x|%*x|%.*x|%23.10x|%hx|%lx\n", b,
        b, b, b, b, b, b, 15, b, 15, b, b, (short)b, (long)b);

    ck_assert_str_eq(buffer1, buffer2);
  }
  int b = INT32_MAX;
  sprintf(buffer1,
          "%x|%010x|%-10x|%#20x|%.10x|%#x|%#.10x|%*x|%.*x|%23.10x|%hx|%lx\n", b,
          b, b, b, b, b, b, 15, b, 15, b, b, (short)b, (long)b);
  s21_sprintf(
      buffer2,
      "%x|%010x|%-10x|%#20x|%.10x|%#x|%#.10x|%*x|%.*x|%23.10x|%hx|%lx\n", b, b,
      b, b, b, b, b, 15, b, 15, b, b, (short)b, (long)b);

  ck_assert_str_eq(buffer1, buffer2);
  b = INT32_MIN;
  sprintf(buffer1,
          "%x|%010x|%-10x|%#20x|%.10x|%#x|%#.10x|%*x|%.*x|%23.10x|%hx|%lx\n", b,
          b, b, b, b, b, b, 15, b, 15, b, b, (short)b, (long)b);
  s21_sprintf(
      buffer2,
      "%x|%010x|%-10x|%#20x|%.10x|%#x|%#.10x|%*x|%.*x|%23.10x|%hx|%lx\n", b, b,
      b, b, b, b, b, 15, b, 15, b, b, (short)b, (long)b);

  ck_assert_str_eq(buffer1, buffer2);
}
END_TEST

START_TEST(test_13) {
  char buffer1[20000];
  char buffer2[20000];

  for (int b = -1000; b <= 100; ++b) {
    sprintf(buffer1, "%X|%010X|%-10X|%.10X|%#X|%#.10X|%*X|%.*X|%23.10X\n", b, b,
            b, b, b, b, 15, b, 15, b, b);
    s21_sprintf(buffer2, "%X|%010X|%-10X|%.10X|%#X|%#.10X|%*X|%.*X|%23.10X\n",
                b, b, b, b, b, b, 15, b, 15, b, b);

    ck_assert_str_eq(buffer1, buffer2);
  }
}
END_TEST

START_TEST(test_14) {
  char buffer1[20000];
  char buffer2[20000];

  int a = -10;
  int *b = &a;

  sprintf(buffer1, "%p|%50p|%*p|%-50p\n", b, b, 15, b, b);
  s21_sprintf(buffer2, "%p|%50p|%*p|%-50p\n", b, b, 15, b, b);

  ck_assert_str_eq(buffer1, buffer2);
}
END_TEST

START_TEST(test_15) {
  char buffer1[20000];
  char buffer2[20000];

  sprintf(buffer1, "%%\n");
  s21_sprintf(buffer2, "%%\n");

  ck_assert_str_eq(buffer1, buffer2);
}
END_TEST

#define BUFFER 1000

START_TEST(s21_sprintf_f_test) {
  char str[1000];
  char str_orig[1000];

  double b = 12.11;

  int res_1_orig = sprintf(str_orig, "%.f", b);

  int res_1 = s21_sprintf(str, "%.f", b);

  ck_assert_int_eq(res_1, res_1_orig);
  ck_assert_str_eq(str, str_orig);

  double b_2 = 0.002345;

  int res_2_orig = sprintf(str_orig, "%+-10.3f", b_2);
  int res_2 = s21_sprintf(str, "%+-10.3f", b_2);
  ck_assert_int_eq(res_2, res_2_orig);
  ck_assert_str_eq(str, str_orig);

  double b_7 = 1234523459.123456789;
  int res_7 = s21_sprintf(str, "%.5f", b_7);
  int res_7_orig = sprintf(str_orig, "%.5f", b_7);

  ck_assert_int_eq(res_7, res_7_orig);
  ck_assert_str_eq(str, str_orig);

  double b_8 = 1;
  int res_8 = s21_sprintf(str, "%f", b_8);
  int res_8_orig = sprintf(str_orig, "%f", b_8);

  ck_assert_int_eq(res_8, res_8_orig);
  ck_assert_str_eq(str, str_orig);

  double b_9 = 0.00345;
  int res_9 = s21_sprintf(str, "%f", b_9);
  int res_9_orig = sprintf(str_orig, "%f", b_9);

  ck_assert_int_eq(res_9, res_9_orig);
  ck_assert_str_eq(str, str_orig);

  double b_10 = 0.00345;
  int res_10 = s21_sprintf(str, "%f", b_10);
  int res_10_orig = sprintf(str_orig, "%f", b_10);

  ck_assert_int_eq(res_10, res_10_orig);
  ck_assert_str_eq(str, str_orig);

  double b_11 = 1234567.00345;
  int res_11 = s21_sprintf(str, "%.11f", b_11);
  int res_11_orig = sprintf(str_orig, "%.11f", b_11);

  ck_assert_int_eq(res_11, res_11_orig);
  ck_assert_str_eq(str, str_orig);

  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\n%f TEST %.f TEST %4f TEST %4.f TEST %5.10f!";
  double num_1 = 76.756589367;
  int res1 = s21_sprintf(str1, str3, num_1, num_1, num_1, num_1, num_1);
  int res2 = sprintf(str2, str3, num_1, num_1, num_1, num_1, num_1);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);

  char str4[BUFFER] = "";
  char str5[BUFFER] = "";
  char *str6 = "\n%f TEST %.f TEST %3f TEST %4.f TEST %5.10f!";
  double num_2 = -76.756589367;
  int res3 = s21_sprintf(str4, str6, num_2, num_2, num_2, num_2, num_2);
  int res4 = sprintf(str5, str6, num_2, num_2, num_2, num_2, num_2);
  ck_assert_pstr_eq(str4, str5);
  ck_assert_int_eq(res3, res4);
}
END_TEST

START_TEST(sprintf_1_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\n%f TEST %.f TEST %4f TEST %4.f TEST %5.10f!";
  double num = 76.756589367;
  int res1 = s21_sprintf(str1, str3, num, num, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_2_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\n%f TEST %.f TEST %3f TEST %4.f TEST %5.10f!";
  double num = -76.756589367;
  int res1 = s21_sprintf(str1, str3, num, num, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_3_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\n%Lf\n%.Lf!";
  long double num_long = -76.756589;
  int res1 = s21_sprintf(str1, str3, num_long, num_long);
  int res2 = sprintf(str2, str3, num_long, num_long);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_4_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\n%20.10f\n%20.15f\n%-20.5f!";
  double num = -76.756589;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_5_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\n%Lf\n%.Lf\n%+-#Lf\n%+#.Lf\n%-#.Lf!";
  long double num = 76.756589;
  int res1 = s21_sprintf(str1, str3, num, num, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_6_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %5f\ntest: %6.1f\ntest: %8.2f!";
  double num = 76.756589;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_7_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %10.5f\ntest: %12.4f!";
  double num = 76.756589;
  int res1 = s21_sprintf(str1, str3, num, num);
  int res2 = sprintf(str2, str3, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_8_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %15.1f\ntest: %16.2f\ntest: %18.3f!";
  double num = -7648938790.756589;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_9_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %10.4f\ntest: %25.5f!";
  double num = -7648938790.756589;
  int res1 = s21_sprintf(str1, str3, num, num);
  int res2 = sprintf(str2, str3, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_10_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %+15.f\ntest: %+#16.f\ntest: %+#18.0f!";
  double num = 7648938790.456589;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_11_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %+ 18.0f\ntest: %+10.f\ntest: %+25.f!";
  double num = 7648938790.756589;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_12_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %-26.1f\ntest: %-18.0f\ntest: %#-10.f!";
  double num = 7648938790.756589;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_13_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %-#15.f\ntest: %-+25.f!";
  double num = 7648938790.756589;
  int res1 = s21_sprintf(str1, str3, num, num);
  int res2 = sprintf(str2, str3, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_14_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %-15.4f!\ntest: %-26.1f!\ntest: %-18.0f!";
  double num = -365289.3462865487;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_15_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "%#-10.9f";
  // char *str3 = "\ntest: %#-10.9f!\ntest: %-+25.15f!";
  double num = -365289.3462865487;
  int res1 = s21_sprintf(str1, str3, num, num);
  int res2 = sprintf(str2, str3, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_16_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %15.13f!\ntest: %26.15f!";
  double num = -365289.34628654873789362746834;
  int res1 = s21_sprintf(str1, str3, num, num);
  int res2 = sprintf(str2, str3, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_17_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %18.7f!\ntest: %10.15f!\ntest: %25.15f!";
  double num = -365289.34628654873789362746834;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_18_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %15.13f!\ntest: %26.15f!";
  double num = 365289.34628654873789362746834;
  int res1 = s21_sprintf(str1, str3, num, num);
  int res2 = sprintf(str2, str3, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_19_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %18.7f!\ntest: %10.15f!";
  double num = 365289.34628654873789362746834;
  int res1 = s21_sprintf(str1, str3, num, num);
  int res2 = sprintf(str2, str3, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_20_f) {
  // printf("SSSSSSstart 20 case\n");
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %- 23.14f!\ntest: %+ 25.15f!";
  double num = 365289.34628654873789362746834;
  int res1 = s21_sprintf(str1, str3, num, num);
  int res2 = sprintf(str2, str3, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_21_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: % 15f!\ntest: % -26f!\ntest: %- 18f!";
  double num = -365789.34;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_22_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %+- 14f!\ntest: %+ 10f!\ntest: % +25f!";
  double num = -365789.34;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_23_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: % 14f!\ntest: % -27f!\ntest: %- 19f!";
  double num = 365789.34;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_24_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %+- 16f!\ntest: %+ 44f!\ntest: % +35f!";
  double num = 365789.34;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_25_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %26Lf!\ntest: %18Lf!\ntest: %60Lf!";
  long double num = -3752765839673496.34;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_26_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %15Lf!test: %100Lf!";
  long double num = -3752765839673496.34;
  int res1 = s21_sprintf(str1, str3, num, num);
  int res2 = sprintf(str2, str3, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_27_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %- 26Lf!\ntest: %+- 18Lf!\ntest: %60Lf!";
  long double num = 3752765839673496.34;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_28_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: % +15Lf!test: %100Lf!";
  long double num = 3752765839673496.34;
  int res1 = s21_sprintf(str1, str3, num, num);
  int res2 = sprintf(str2, str3, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST
// Функциональная ошибка
START_TEST(sprintf_30_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %020f!\ntest: %-020f!\ntest: %+025f!";
  double num = 837564.4753366;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_31_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %-+ 025.5f!\ntest: %- 020.4f\ntest: %+ 016.6f!";
  double num = 837564.4753366;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_32_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %015f!\ntest: %-026f!\ntest: %+018f!";
  double num = -947.6785643;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_33_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %+- 010.2f!\ntest: %- 025.7f\ntest: %+- 18.4f!";
  double num = -947.6785643;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_34_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: % 15.1Lf!\ntest: % -26.15Lf!\ntest: %- 30.15Lf!";
  long double num = 278.723786;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_35_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %+ 50.15Lf!\ntest: % +40.15Lf!";
  long double num = 278.723786;
  int res1 = s21_sprintf(str1, str3, num, num);
  int res2 = sprintf(str2, str3, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_36_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: % 15.1Lf!\ntest: % -26.13Lf!\ntest: %- 30.8Lf!";
  long double num = -2358.367776967;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_37_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %+ 50.14Lf!\ntest: % +40.14Lf!";
  long double num = -2358.367776967;
  int res1 = s21_sprintf(str1, str3, num, num);
  int res2 = sprintf(str2, str3, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_38_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %.1Lf!\ntest: %.2Lf!\ntest: %.3Lf!";
  long double num = -9999.99999;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_39_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %.10Lf!\ntest: %.6Lf!\ntest: %.Lf!";
  long double num = -9999.99999;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_40_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %.1Lf!\ntest: %.2Lf!\ntest: %.3Lf!";
  long double num = 000000000000000.00000000000;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_41_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %.6Lf!\ntest: %.Lf\ntest: %+ 0Lf!!";
  long double num = 000000000000000.00000000000;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_42_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %.1Lf!\ntest: %.2Lf!\ntest: %.3Lf!";
  long double num = -635293201236310753.6495633;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_43_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %+ 0Lf!\ntest: %.6Lf!\ntest: %.15Lf!";
  long double num = -635293201236310753.6495633;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_44_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %.1Lf!\ntest: %.2Lf!\ntest: %.3Lf!";
  long double num = -236310753.6495633;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_45_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %+ 0Lf!\ntest: %.6Lf!\ntest: %.13Lf!";
  long double num = -236310753.6495633;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_46_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %.1Lf!\ntest: %.2Lf!\ntest: %.3Lf!";
  long double num = -9125781235683689988.;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_47_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %+ 0Lf!\ntest: %.6Lf!\ntest: %.15Lf!";
  long double num = -9125781235683689988.;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_50_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %25.5Lf!\ntest: %Lf!\ntest: %-50Lf!";
  long double num = -9125781235683689988.;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_51_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %+ 0Lf!\ntest: %060Lf!\ntest: %.15Lf!";
  long double num = -9125781235683689988.;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_52_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\ntest: %-+.1Lf!\ntest: %- .2Lf!\ntest: %-0.3Lf!";
  long double num = -0.999999;
  int res1 = s21_sprintf(str1, str3, num, num, num);
  int res2 = sprintf(str2, str3, num, num, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_54_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\nfshgkaljck% 10.12f hgsakul";
  double num = 0.235300;
  int res1 = s21_sprintf(str1, str3, num);
  int res2 = sprintf(str2, str3, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_55_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\n%f";
  double num = 0.00000001;
  int res1 = s21_sprintf(str1, str3, num);
  int res2 = sprintf(str2, str3, num);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

START_TEST(sprintf_56_f) {
  char str1[BUFFER] = "";
  char str2[BUFFER] = "";
  char *str3 = "\n%.5f %.5f %.5f %.5f";
  double num1 = -999.666;
  double num2 = 0.0001;
  double num3 = 666.999;
  double num4 = -100.001;
  int res1 = s21_sprintf(str1, str3, num1, num2, num3, num4);
  int res2 = sprintf(str2, str3, num1, num2, num3, num4);
  ck_assert_pstr_eq(str1, str2);
  ck_assert_int_eq(res1, res2);
}
END_TEST

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

  s = suite_create("MySuite");

  tc = tcase_create("TestCase");
  tcase_add_test(tc, test_1);
  suite_add_tcase(s, tc);

  tc = tcase_create("TestCase");
  tcase_add_test(tc, test_2);
  suite_add_tcase(s, tc);

  tc = tcase_create("TestCase");
  tcase_add_test(tc, test_4);
  suite_add_tcase(s, tc);

  tc = tcase_create("TestCase");
  tcase_add_test(tc, test_5);
  suite_add_tcase(s, tc);

  tc = tcase_create("TestCase");
  tcase_add_test(tc, test_6);
  suite_add_tcase(s, tc);

  tc = tcase_create("TestCase");
  tcase_add_test(tc, test_7);
  suite_add_tcase(s, tc);

  tc = tcase_create("TestCase");
  tcase_add_test(tc, test_8);
  suite_add_tcase(s, tc);

  tc = tcase_create("TestCase");
  tcase_add_test(tc, test_9);
  suite_add_tcase(s, tc);

  tc = tcase_create("TestCase");
  tcase_add_test(tc, test_10);
  suite_add_tcase(s, tc);

  tc = tcase_create("TestCase");
  tcase_add_test(tc, test_11);
  suite_add_tcase(s, tc);

  tc = tcase_create("TestCase");
  tcase_add_test(tc, test_12);
  suite_add_tcase(s, tc);

  tc = tcase_create("TestCase");
  tcase_add_test(tc, test_13);
  suite_add_tcase(s, tc);

  tc = tcase_create("TestCase");
  tcase_add_test(tc, test_14);
  suite_add_tcase(s, tc);

  tc = tcase_create("TestCase");
  tcase_add_test(tc, test_15);
  suite_add_tcase(s, tc);

  TCase *tc_core = tcase_create("TestCase");
  tcase_add_test(tc_core, s21_sprintf_f_test);
  tcase_add_test(tc_core, sprintf_1_f);
  tcase_add_test(tc_core, sprintf_2_f);
  tcase_add_test(tc_core, sprintf_3_f);
  tcase_add_test(tc_core, sprintf_4_f);
  tcase_add_test(tc_core, sprintf_5_f);
  tcase_add_test(tc_core, sprintf_6_f);
  tcase_add_test(tc_core, sprintf_7_f);
  tcase_add_test(tc_core, sprintf_8_f);
  tcase_add_test(tc_core, sprintf_9_f);
  tcase_add_test(tc_core, sprintf_10_f);
  tcase_add_test(tc_core, sprintf_11_f);
  tcase_add_test(tc_core, sprintf_12_f);
  tcase_add_test(tc_core, sprintf_13_f);
  tcase_add_test(tc_core, sprintf_14_f);
  tcase_add_test(tc_core, sprintf_15_f);
  tcase_add_test(tc_core, sprintf_16_f);
  tcase_add_test(tc_core, sprintf_17_f);
  tcase_add_test(tc_core, sprintf_18_f);
  tcase_add_test(tc_core, sprintf_19_f);
  tcase_add_test(tc_core, sprintf_20_f);
  tcase_add_test(tc_core, sprintf_21_f);
  tcase_add_test(tc_core, sprintf_22_f);
  tcase_add_test(tc_core, sprintf_23_f);
  tcase_add_test(tc_core, sprintf_24_f);
  tcase_add_test(tc_core, sprintf_25_f);
  tcase_add_test(tc_core, sprintf_26_f);
  tcase_add_test(tc_core, sprintf_27_f);
  tcase_add_test(tc_core, sprintf_28_f);
  tcase_add_test(tc_core, sprintf_30_f);
  tcase_add_test(tc_core, sprintf_31_f);
  tcase_add_test(tc_core, sprintf_32_f);
  tcase_add_test(tc_core, sprintf_33_f);
  tcase_add_test(tc_core, sprintf_34_f);
  tcase_add_test(tc_core, sprintf_35_f);
  tcase_add_test(tc_core, sprintf_36_f);
  tcase_add_test(tc_core, sprintf_37_f);
  tcase_add_test(tc_core, sprintf_38_f);
  tcase_add_test(tc_core, sprintf_39_f);
  tcase_add_test(tc_core, sprintf_40_f);
  tcase_add_test(tc_core, sprintf_41_f);
  tcase_add_test(tc_core, sprintf_42_f);
  tcase_add_test(tc_core, sprintf_43_f);
  tcase_add_test(tc_core, sprintf_44_f);
  tcase_add_test(tc_core, sprintf_45_f);
  tcase_add_test(tc_core, sprintf_46_f);
  tcase_add_test(tc_core, sprintf_47_f);
  tcase_add_test(tc_core, sprintf_50_f);
  tcase_add_test(tc_core, sprintf_51_f);
  tcase_add_test(tc_core, sprintf_52_f);
  tcase_add_test(tc_core, sprintf_54_f);
  tcase_add_test(tc_core, sprintf_55_f);
  tcase_add_test(tc_core, sprintf_56_f);

  suite_add_tcase(s, tc_core);

  sr = srunner_create(s);
  srunner_run_all(sr, CK_VERBOSE);
  int number_failed = srunner_ntests_failed(sr);
  srunner_free(sr);

  return number_failed;
}