my.check

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "lib_string.h"

const char a[] = "Hello world";
const char b[] = "Hello world\0";
const char c[] = "a\n\0";
const char d[] = " \n\0";
const char e[] = " \0";
const char f[] = "\n\0";
const char g[] = "\0";

#test lib_string_memcmp_test
//ok+
//null argument where non-null required: Werror
char *strs[] = {
    [0] = "aae34342g\0",
    [1] = "aae34342g",
    [2] = "a\n\0",
    [3] = " \n\0",
    [4] = " \0",
    [5] = "\n\0",
    [6] = " erwrhj232evqw\0",
    [7] = "aaa",
    [8] = "",
    [9] = "Hello world\0",
};
for (int i = 0; i < 9; i++) {
    ck_assert_int_eq(memcmp(strs[i], strs[i], i), lib_memcmp(strs[i], strs[i], i));
    ck_assert_int_eq(memcmp(strs[i], strs[i + 1], i), lib_memcmp(strs[i], strs[i + 1], i));
}
//ck_assert_int_eq(memcmp(lib_NULL, lib_NULL, 10), lib_memcmp(lib_NULL, lib_NULL, 10));

#test lib_string_strcmp_test
//ok+
//null argument where non-null required: Werror
char *strs[] = {
    [0] = "\0",
    [1] = "aae34342g",
    [2] = "a\n\0",
    [3] = " \n\0",
    [4] = " \0",
    [5] = "\n\0",
    [6] = " erwrhj232evqw\0",
};
for (int i = 0; i < 6; i += 1) {
    ck_assert_int_eq(strcmp(strs[i], strs[i + 1]), lib_strcmp(strs[i], strs[i + 1]));
}
ck_assert_int_eq(strcmp(strs[5], strs[5]), lib_strcmp(strs[5], strs[5]));
//ck_assert_int_eq(strcmp(lib_NULL, lib_NULL), lib_strcmp(lib_NULL, lib_NULL));

#test lib_string_strncmp_test
//ok+
//null argument where non-null required: Werror
char *strs[] = {
    [0] = "\0",
    [1] = "aae34342g",
    [2] = "a\n\0",
    [3] = " \n\0",
    [4] = " \0",
    [5] = "\n\0",
    [6] = " erwrhj232evqw\0",
    [7] = "aaa",
    [8] = "",
    [9] = "Hello world\0",
};
for (int i = 0; i < 9; i++) {
    ck_assert_int_eq(strncmp(strs[i], strs[i + 1], i), lib_strncmp(strs[i], strs[i + 1], i));
}
//ck_assert_int_eq(strncmp(lib_NULL, strs[0], 0), lib_strncmp(lib_NULL, strs[0], 0));
//ck_assert_int_eq(strncmp(strs[5], lib_NULL, 0), lib_strncmp(strs[5], lib_NULL, 0));
//ck_assert_int_eq(strncmp(strs[5], strs[5], 100), lib_strncmp(strs[5], strs[5], 100));

#test lib_string_memchr_test
//ok+
//null argument where non-null required: Werror
char str_1[10] = "123456789";
char str_2[10] = "";
char str_3[11] = "i am\nproger";
char str_4[50] = " schhol21\0";
char str_5[50] = " \n\0\0";
char str_6[30] = "Hello world\0";
char str_7[10] = "\0"; 
ck_assert_pstr_eq(memchr(str_1, '9', 10), lib_memchr(str_1, '9', 10));
ck_assert_pstr_eq(memchr(str_2, '0', 3), lib_memchr(str_2, '0', 3));
ck_assert_pstr_eq(memchr(str_3, '\0', 3), lib_memchr(str_3, '\0', 3));
ck_assert_pstr_eq(memchr(str_4, 'q', 16), lib_memchr(str_4, 'q', 16));
ck_assert_pstr_eq(memchr(str_5, ' ', 20), lib_memchr(str_5, ' ', 20));
ck_assert_pstr_eq(memchr(str_6, '4', 50), lib_memchr(str_6, '4', 50));
ck_assert_pstr_eq(memchr(str_7, 'b', 5), lib_memchr(str_7, 'b', 5));
//ck_assert_pstr_eq(memchr(lib_NULL, 'b', 0), lib_memchr(lib_NULL, 'b', 0));

#test lib_string_memcpy_test
//ok+
//null argument where non-null required: Werror
char str_1[20] = "i am proger";
char str_2[20] = " \0";
char str_3[20] = "i am proger";
char str_4[12] = "i am\nproger";
char str_5[10] = " schhol21\0";
char str_6[12] = "i am\nproger";
char str_7[50] = " \n\0\0";
char str_8[50] = " \n\0\0";
ck_assert_str_eq(memcpy(str_1, str_2, 8), lib_memcpy(str_3, str_2, 8));
ck_assert_str_eq(memcpy(str_1, str_2, 2), lib_memcpy(str_3, str_2, 2));
ck_assert_str_eq(memcpy(str_4, str_5, 9), lib_memcpy(str_6, str_5, 9));
ck_assert_str_eq(memcpy(str_4, str_5, 2), lib_memcpy(str_6, str_5, 2));
ck_assert_str_eq(memcpy(str_7, str_4, 0), lib_memcpy(str_8, str_4, 0));
ck_assert_str_eq(memcpy(str_7, str_5, 2), lib_memcpy(str_8, str_7, 2));
//ck_assert_pstr_eq(memcpy(lib_NULL, lib_NULL, 2), lib_memcpy(lib_NULL, lib_NULL, 2));
//ck_assert_pstr_eq(memcpy(lib_NULL, lib_NULL, 0), lib_memcpy(lib_NULL, lib_NULL, 0));
//ck_assert_pstr_eq(memcpy(lib_NULL, str_5, 0), lib_memcpy(lib_NULL, str_5, 0));
ck_assert_pstr_eq(memcpy(str_5, str_5, 0), lib_memcpy(str_5, str_5, 0));
ck_assert_pstr_eq(memcpy(str_5, str_5, 10), lib_memcpy(str_5, str_5, 10));
  
#test lib_string_memmove_test
//ok+
//null argument where non-null required: Werror
char str_1[20] = "i am proger";
char str_2[20] = " \0";
char str_3[20] = "i am proger";
char str_4[12] = "i am\nproger";
char str_5[10] = " school21\0";
char str_6[12] = "i am\nproger";
char str_7[50] = " \n\0\0";
char str_8[50] = " \n\0\0";
ck_assert_str_eq(memmove(str_1, str_2, 8), lib_memmove(str_3, str_2, 8));
ck_assert_str_eq(memmove(str_1, str_2, 2), lib_memmove(str_3, str_2, 2));
ck_assert_str_eq(memmove(str_4, str_5, 9), lib_memmove(str_6, str_5, 9));
ck_assert_str_eq(memmove(str_4, str_5, 2), lib_memmove(str_6, str_5, 2));
ck_assert_str_eq(memmove(str_7, str_4, 0), lib_memmove(str_8, str_4, 0));
ck_assert_str_eq(memmove(str_7, str_5, 2), lib_memmove(str_8, str_5, 2));
ck_assert_str_eq(memmove(str_5, str_5, 2), lib_memmove(str_5, str_5, 2));
//ck_assert_pstr_eq(memmove(lib_NULL, lib_NULL, 0), lib_memmove(lib_NULL, lib_NULL, 0));
//ck_assert_pstr_eq(memmove(lib_NULL, lib_NULL, 100), lib_memmove(lib_NULL, lib_NULL, 100));

#test lib_string_memset_test
//ok
char str_1[10] = "123456789";
char str_2[10] = "123456789";
char str_3[10] = "";
char str_4[10] = "";
char str_5[20] = "i am\nproger";
char str_6[20] = "i am\nproger";
char str_7[50] = " schhol21\0";
char str_8[50] = " schhol21\0";
char str_9[20] = "\0";
char str_10[20] = "\0";
char str_11[20] = "2423523";
char str_12[20] = "2423523";
ck_assert_str_eq(memset(str_1, 'k', 3), lib_memset(str_2, 'k', 3));
ck_assert_str_eq(memset(str_3, '0', 3), lib_memset(str_4, '0', 3));
ck_assert_str_eq(memset(str_5, '\0', 3), lib_memset(str_6, '\0', 3));
ck_assert_str_eq(memset(str_7, 'q', 16), lib_memset(str_8, 'q', 16));
ck_assert_str_eq(memset(str_9, 'q', 16), lib_memset(str_10, 'q', 16));
ck_assert_str_eq(memset(str_11, 'a', 19), lib_memset(str_12, 'a', 19));

#test lib_string_strcat_test
//ok+
// Signal 4 (overload buffer)
char str_1[50] = "f352feeew";
char str_2[10] = " ";
char str_3[50] = "f352feeew";
char str_4[25] = "1234567890";
char str_5[15] = "abcdefghij";
char str_6[25] = "1234567890";
char str_7[20] = "Hello\n";
char str_8[20] = "vbb";
char str_9[20] = "Hello\n";
char str_10[15] = "S";
char str_11[10] = "";
char str_12[15] = "S";
char str_13[20] = "HELP";
char str_14[15] = "no\t";
char str_15[20] = "HELP";
ck_assert_str_eq(strcat(str_1, str_2), lib_strcat(str_3, str_2));
ck_assert_str_eq(strcat(str_4, str_5), lib_strcat(str_6, str_5));
ck_assert_str_eq(strcat(str_7, str_8), lib_strcat(str_9, str_8));
ck_assert_str_eq(strcat(str_10, str_11), lib_strcat(str_12, str_11));
ck_assert_str_eq(strcat(str_13, str_14), lib_strcat(str_15, str_14));

#test lib_string_strncat_test
//ok(+Signal 4)
//null argument where non-null required: Werror
char str_1[50] = "f352feeew";
char str_2[10] = " ";
char str_3[50] = "f352feeew";
char str_4[25] = "1234567890";
char str_5[15] = "abcdefghij";
char str_6[25] = "1234567890";
char str_7[20] = "Hello\n";
char str_8[20] = "vbb";
char str_9[20] = "Hello\n";
char str_10[15] = "S";
char str_11[10] = "";
char str_12[15] = "S";
char str_13[20] = "HELP";
char str_14[15] = "no\t";
char str_15[20] = "HELP";
ck_assert_str_eq(strncat(str_1, str_2, 15), lib_strncat(str_3, str_2, 15));
ck_assert_str_eq(strncat(str_4, str_5, 24), lib_strncat(str_6, str_5, 24));
ck_assert_str_eq(strncat(str_7, str_8, 19), lib_strncat(str_9, str_8, 19));
ck_assert_str_eq(strncat(str_10, str_11, 0), lib_strncat(str_12, str_11, 0));
ck_assert_str_eq(strncat(str_13, str_14, 19), lib_strncat(str_15, str_14, 19));
//ck_assert_pstr_eq(strncat(lib_NULL, lib_NULL, 0), lib_strncat(lib_NULL, lib_NULL, 0));

#test lib_string_strchr_test
//ok+
//null argument where non-null required: Werror
ck_assert_pstr_eq(strchr(a, 'l'), lib_strchr(a, 'l'));
ck_assert_pstr_eq(strchr(a, 'n'), lib_strchr(a, 'n'));
ck_assert_pstr_eq(strchr(a, '\0'), lib_strchr(a, '\0'));
ck_assert_pstr_eq(strchr(g, '\0'), lib_strchr(g, '\0'));
ck_assert_pstr_eq(strchr(e, ' '), lib_strchr(e, ' '));
ck_assert_pstr_eq(strchr(e, ' '), lib_strchr(e, ' '));

#test lib_string_lib_strcpy_test
//ok+
//null argument where non-null required: Werror
char str_1[50] = "f352feeew";
char str_2[50] = "f352feeew";
char str_3[25] = "1234567890";
char str_4[25] = "1234567890";
char str_5[20] = "Hello\n";
char str_6[20] = "Hello\n";
char str_7[15] = "S";
char str_8[15] = "S";
char str_9[20] = "HELP";
char str_10[20] = "HELP";
char str_11[20] = "i am\nproger";
char str_12[20] = "i am\nproger";
char str_13[50] = " \n\0\0";
char str_14[50] = " \n\0\0";
ck_assert_str_eq(strcpy(str_1, a), lib_strcpy(str_2, a));
ck_assert_str_eq(strcpy(str_3, b), lib_strcpy(str_4, b));
ck_assert_str_eq(strcpy(str_5, c), lib_strcpy(str_6, c));
ck_assert_str_eq(strcpy(str_7, d), lib_strcpy(str_8, d));
ck_assert_str_eq(strcpy(str_9, e), lib_strcpy(str_10, e));
ck_assert_str_eq(strcpy(str_11, f), lib_strcpy(str_12, f));
ck_assert_str_eq(strcpy(str_13, g), lib_strcpy(str_14, g));

#test lib_string_strncpy_test
char str_1[50] = "f352feeew";
char str_2[50] = "f352feeew";
char str_3[25] = "1234567890";
char str_4[25] = "1234567890";
char str_5[20] = "Hello\n";
char str_6[20] = "Hello\n";
char str_7[15] = "S";
char str_8[15] = "S";
char str_9[20] = "HELP";
char str_10[20] = "HELP";
char str_11[20] = "i am\nproger";
char str_12[20] = "i am\nproger";
char str_13[50] = " \n\0\0";
char str_14[50] = " \n\0\0";
ck_assert_str_eq(strncpy(str_1, a, 15), lib_strncpy(str_2, a, 15));
ck_assert_str_eq(strncpy(str_3, b, 20), lib_strncpy(str_4, b, 20));
ck_assert_str_eq(strncpy(str_5, c, 20), lib_strncpy(str_6, c, 20));
ck_assert_str_eq(strncpy(str_7, d, 0), lib_strncpy(str_8, d, 0));
ck_assert_str_eq(strncpy(str_9, e, 20), lib_strncpy(str_10, e, 20));
ck_assert_str_eq(strncpy(str_11, f, 1), lib_strncpy(str_12, f, 1));
ck_assert_str_eq(strncpy(str_13, g, 50), lib_strncpy(str_14, g, 50));
//ck_assert_pstr_eq(strncpy(lib_NULL, lib_NULL, 0), lib_strncpy(lib_NULL, lib_NULL, 0));

#test lib_string_strpbrk_test
char str_1[11] = "0123456789";
char str_2[10] = "369";
char str_3[10] = "Hello";
char str_4[10];
ck_assert_str_eq(strpbrk(str_1, str_2), lib_strpbrk(str_1, str_2));
ck_assert_ptr_eq(strpbrk(str_3, str_1), lib_strpbrk(str_3, str_1));
ck_assert_ptr_eq(strpbrk(str_4, str_3), lib_strpbrk(str_4, str_3));

#test lib_string_strrchr_test
ck_assert_pstr_eq(strrchr(a, 'b'), lib_strrchr(a, 'b'));
ck_assert_pstr_eq(strrchr(a, 'l'), lib_strrchr(a, 'l'));
ck_assert_pstr_eq(strrchr(b, '\n'), lib_strrchr(b, '\n'));
ck_assert_pstr_eq(strrchr(c, 'a'), lib_strrchr(c, 'a'));
ck_assert_pstr_eq(strrchr(g, '\0'), lib_strrchr(g, '\0'));
ck_assert_pstr_eq(strrchr(e, ' '), lib_strrchr(e, ' '));

#test lib_string_strstr_test
char str_3[20] = "Hello woHello";
ck_assert_ptr_eq(strstr(str_3, "hello"), lib_strstr(str_3, "hello"));
ck_assert_ptr_eq(strstr(str_3, "Hello"), lib_strstr(str_3, "Hello"));
ck_assert_ptr_eq(strstr(str_3, "Hello"), lib_strstr(str_3, "Hello"));
ck_assert_ptr_eq(strstr(str_3, "Hello world !!!"), lib_strstr(str_3, "Hello world !!"));
ck_assert_ptr_eq(strstr(str_3, "Hello"), lib_strstr(str_3, "Hello"));

#test lib_string_strerror_test
for (int i = 0; i < MAX_ERROR; i++) {
    ck_assert_str_eq(strerror(i), lib_strerror(i));
}

#test lib_string_strtok_test
char str_1[50] = "f352feeew";
char str_2[50] = "f352feeew";
char str_3[25] = "1234567890";
char str_4[25] = "1234567890";
char str_5[20] = "Hello\n";
char str_6[20] = "Hello\n";
char str_7[] = " \0";
char str_8[] = " \0";
ck_assert_pstr_eq(strtok(str_1, " "), lib_strtok(str_2, " "));
ck_assert_pstr_eq(strtok(str_3, " "), lib_strtok(str_4, " "));
ck_assert_pstr_eq(strtok(str_5, " "), lib_strtok(str_6, " "));
ck_assert_pstr_eq(strtok(str_7, " "), lib_strtok(str_8, " "));

#test lib_string_strcspn_test
ck_assert_uint_eq(strspn(a, a), lib_strspn(a, a));
ck_assert_uint_eq(strspn(a, b), lib_strspn(a, b));
ck_assert_uint_eq(strspn(a, c), lib_strspn(a, c));
ck_assert_uint_eq(strspn(a, d), lib_strspn(a, d));
ck_assert_uint_eq(strspn(a, e), lib_strspn(a, e));
ck_assert_uint_eq(strspn(b, b), lib_strspn(b, b));
ck_assert_uint_eq(strspn(b, c), lib_strspn(b, c));
ck_assert_uint_eq(strspn(b, d), lib_strspn(b, d));
ck_assert_uint_eq(strspn(b, e), lib_strspn(b, e));
ck_assert_uint_eq(strspn(b, f), lib_strspn(b, f));
ck_assert_uint_eq(strspn(b, g), lib_strspn(b, g));
ck_assert_uint_eq(strspn(c, g), lib_strspn(c, g));
ck_assert_uint_eq(strspn(d, a), lib_strspn(d, a));
ck_assert_uint_eq(strspn(d, b), lib_strspn(d, b));
ck_assert_uint_eq(strspn(d, c), lib_strspn(d, c));
ck_assert_uint_eq(strspn(d, d), lib_strspn(d, d));
ck_assert_uint_eq(strspn(d, e), lib_strspn(d, e));
ck_assert_uint_eq(strspn(d, f), lib_strspn(d, f));
ck_assert_uint_eq(strspn(d, g), lib_strspn(d, g));

#test lib_string_strlen_test
//ok
//null argument where non-null required
ck_assert_uint_eq(strlen(a), lib_strlen(a));
ck_assert_uint_eq(strlen(b), lib_strlen(b));
ck_assert_uint_eq(strlen(c), lib_strlen(c));
ck_assert_uint_eq(strlen(d), lib_strlen(d));
ck_assert_uint_eq(strlen(e), lib_strlen(e));
ck_assert_uint_eq(strlen(f), lib_strlen(f));
ck_assert_uint_eq(strlen(g), lib_strlen(g));
ck_assert_uint_eq(strlen(" \0"), lib_strlen(" \0"));
ck_assert_uint_eq(strlen(""), lib_strlen(""));

#test lib_string_strspn_test
//ok
ck_assert_uint_eq(strcspn(a, a), lib_strcspn(a, a));
ck_assert_uint_eq(strcspn(a, b), lib_strcspn(a, b));
ck_assert_uint_eq(strcspn(a, c), lib_strcspn(a, c));
ck_assert_uint_eq(strcspn(a, g), lib_strcspn(a, g));
ck_assert_uint_eq(strcspn(b, a), lib_strcspn(b, a));
ck_assert_uint_eq(strcspn(b, b), lib_strcspn(b, b));
ck_assert_uint_eq(strcspn(b, c), lib_strcspn(b, c));
ck_assert_uint_eq(strcspn(b, d), lib_strcspn(b, d));
ck_assert_uint_eq(strcspn(b, e), lib_strcspn(b, e));
ck_assert_uint_eq(strcspn(b, f), lib_strcspn(b, f));
ck_assert_uint_eq(strcspn(c, g), lib_strcspn(c, g));
ck_assert_uint_eq(strcspn(d, a), lib_strcspn(d, a));
ck_assert_uint_eq(strcspn(d, b), lib_strcspn(d, b));
ck_assert_uint_eq(strcspn(d, c), lib_strcspn(d, c));
ck_assert_uint_eq(strcspn(d, d), lib_strcspn(d, d));
ck_assert_uint_eq(strcspn(d, e), lib_strcspn(d, e));
ck_assert_uint_eq(strcspn(d, f), lib_strcspn(d, f));
ck_assert_uint_eq(strcspn(d, g), lib_strcspn(d, g));

#test lib_string_to_upper_test
char *resStringToUpper = (char *)lib_to_upper(a);
char *expected = "HELLO WORLD";
ck_assert_str_eq(expected, resStringToUpper);
free(resStringToUpper);

#test lib_string_to_lower_test
char *resStringToLower = (char *)lib_to_lower(a);
char *expected = "hello world";
ck_assert_str_eq(expected, resStringToLower);
free(resStringToLower);

#test lib_string_insert_test
char *startString = "iWantGoToHome";
char *insertString = "GFG";
char *expected = "iWantGFGGoToHome";    
char *resStringInsert = (char *)lib_insert(startString, insertString, 5);
ck_assert_str_eq(expected, resStringInsert);
free(resStringInsert);

#test lib_string_trim_test
const char *trims = "*.";
const char *str = ".....My name is Mahesh Chand****";
const char *expected = "My name is Mahesh Chand";
char *resStringTrim = lib_trim(str, trims);
ck_assert_str_eq(expected, resStringTrim);
free(resStringTrim);

#test lib_sscanf_null_test1
char fstr[] = "%d";
int aM = 0;
int M = lib_sscanf(NULL, fstr, &aM);
int N = -1;
ck_assert_int_eq(M, N);

#test lib_sscanf_null_test2
char str[] = " ";
int aM = 0;
int M = lib_sscanf(str, NULL, &aM);
int N = -1;
ck_assert_int_eq(M, N);

#test lib_sscanf_eof_test1
char fstr[] = "%d";
char str[] = "        ";
int aM = 0, aN = 0;
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(M, N);

#test lib_sscanf_eof_test2
char fstr[] = "%d ";
char str[] = "1234";
int aM = 0, aN = 0;
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(M, N);

#test lib_sscanf_eof_test3
char fstr[] = "%d ";
char str[] = "               ";
int aM = 0, aN = 0;
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(M, N);

#test lib_sscanf_eof_test4
char fstr[] = " %f";
char str[] = "  ";
int aM = 0, aN = 0;
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(M, N);

#test lib_sscanf_int_test1
int aM = 0, aN = 2;
char fstr[] = "%*d %d";
char str[] = "123 456";
int N = lib_sscanf(str, fstr, &aM);
int M = sscanf("123 456", fstr, &aN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);

#test lib_sscanf_int_test2
int aM = 0, aN = 0, bM = 0, bN = 0;
char fstr[] = "%d %d";
char str[] = "12w3 456";
int M = lib_sscanf(str, fstr, &aM, &bM);
int N = sscanf(str, fstr, &aN, &bN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bN, bM);

#test lib_sscanf_int_test3
int aM = 0, aN = 23, bM = 0, bN = 0;
char fstr[] = "%3d %3d";
char str[] = " 12w3 456";
int M = lib_sscanf(str, fstr, &aM, &bM);
int N = sscanf(str, fstr, &aN, &bN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);

#test lib_sscanf_int_test4
int aM = 0, aN = 2, bM = 0, bN = 3;
char fstr[] = "%5d %5d";
char str[] = " 123 456";
int M = lib_sscanf(str, fstr, &aM, &bM);
int N = sscanf(str, fstr, &aN, &bN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);

#test lib_sscanf_int_test5
long aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char fstr[] = "%ld %ld %ld %ld";
const char str[] = "55215 6326 77237 11";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_int_test6
int aM, aN, bM, bN;
int M = lib_sscanf("1 2147483649", "%5d %d", &aM, &bM);
int N = sscanf("1 2147483649", "%5d %d", &aN, &bN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bN, bM);

#test lib_sscanf_int_test7
short int a1 = 0, a2 = 0, b1 = 0, b2 = 0, c1 = 0, c2 = 0, d1 = 0, d2 = 0;
const char str[] = "1337 21 5008 3000";
const char fstr[] = "%hd %hd %hd %hd";
int M = lib_sscanf(str, fstr, &a1, &b1, &c1, &d1);
int N = sscanf(str, fstr, &a2, &b2, &c2, &d2);
ck_assert_int_eq(M, N);
ck_assert_int_eq(a1, a2);
ck_assert_int_eq(b1, b2);
ck_assert_int_eq(c1, c2);
ck_assert_int_eq(d1, d2);

#test lib_sscanf_int_test8
long long aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = "131237 2221 503208 300004";
const char fstr[] = "%lld %lld %lld %lld";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_int_test9
long long aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = "1337 21 5008 300004";
const char fstr[] = "%1lld %3lld %1lld %4lld";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_int_test10
long long aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = "1312437";
const char fstr[] = "%1lld %1lld %1lld %1lld";

int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_int_test11
long long aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = "22222222222222225";
const char fstr[] = "%3lld%lld%1lld%5lld";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_int_test12
long long aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = "5212";
const char fstr[] = "%15lld %1lld %1lld %1lld";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dM);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_int_test13
long long aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = "11337 ++3 -5 ------4";
const char fstr[] = "%lld %lld %lld %lld";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);  
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_int_test14
long long aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = "-1337 +1 -1 -1";
const char fstr[] = "%15lld %1lld %1lld %5lld";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_int_test15
long long aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = "1 01 10 0";
const char fstr[] = "%lld %lld %lld %lld";
int res1 = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int res2 = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(res1, res2);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_uint_test1
unsigned short aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = "-2160 +491 --6156 1200";
const char fstr[] = "%hu %hu %hu %hu";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_uint_test2
unsigned short aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0;
const char str[] = "-15927 +251 --1250 12";
const char fstr[] = "%hu %hu %hu";
int M = lib_sscanf(str, fstr, &aN, &bN, &cN);
int N = sscanf(str, fstr, &aM, &bM, &cM);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);

#test lib_sscanf_uint_test3
unsigned int aM = 0, aN = 0;
const char str[] = "4294967295";
const char fstr[] = "%u";
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(M, N);
ck_assert_uint_eq(aM, aN);

#test lib_sscanf_uint_test4
unsigned int aM = 0, aN = 0;
const char str[] = "5294967295";
const char fstr[] = "%u";
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(M, N);
ck_assert_uint_eq(aM, aN);

#test lib_sscanf_upperHex_test1
int aM, aN;
const char str[] = "F";
const char fstr[] = "%X";
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);

#test lib_sscanf_upperHex_test2
int aM, aN;
const char str[] = "0xFFFFFFFFFF";
const char fstr[] = "%X";
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);

#test lib_sscanf_upperHex_test3
int aM, aN;
const char str[] = "";
const char fstr[] = "%X";
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(M, N);

#test lib_sscanf_upperHex_test4
int aM, aN;
const char str[] = "qF";
const char fstr[] = "%X";
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(M, N);

#test lib_sscanf_upperHex_test5
unsigned short aM, aN;
const char str[] = "F";
const char fstr[] = "%hX";
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);

#test lib_sscanf_upperHex_test6
const char str[] = "0xFF0x0xFFF 0xFFxFF";
const char fstr[] = "%*X";
int M = lib_sscanf(str, fstr);
int N = sscanf(str, fstr);
ck_assert_int_eq(M, N);

#test lib_sscanf_upperHex_test7
unsigned int aM = 0, aN = 0;
const char str[] = "tqwqpl";
const char fstr[] = "%X";
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(M, N);

#test lib_sscanf_upperHex_test8
unsigned int aM = 0, aN = 0;
const char str[] = "-e";
const char fstr[] = "%X";
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);

#test lib_sscanf_octal_test1
unsigned int aM = 0, aN = 0;
const char str[] = "777";
const char fstr[] = "%o";
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aN, aM);

#test lib_sscanf_octal_test2
unsigned int aM = 0, aN = 0, bM = 0, bN = 0;
const char str[] = "0x777777777777777777 777";
const char fstr[] = "%o %o";
int M = lib_sscanf(str, fstr, &aM, &bM);
int N = sscanf(str, fstr, &aN, &bN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);

#test lib_sscanf_octal_test3
int aM = 0, aN = 0;
const char str[] = "0x";
const char fstr[] = "%o";
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aN, aM);

#test lib_sscanf_octal_test4
int aM = 0, aN = 0;
const char str[] = "";
const char fstr[] = "%o";
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(N, M);

#test lib_sscanf_specs_test1
int aM = 0, aN = 0;
int bM = 0, bN = 0;
const char str[] = "12keppa12";
const char fstr[] = "%dkeppapos%d";
int M = lib_sscanf(str, fstr, &aM, &bM);
int N = sscanf(str, fstr, &aN, &bN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);

#test lib_sscanf_i_test1
long long aM = 0, aN = 0, cM = 0, cN = 0;
char bM = 0, bN = 0, dM = 0, dN = 0;
const char str[] = "100500-600+700+400";
const char fstr[] = "%lli%c%lli%c";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_i_test2
long long aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = "  55555 f f f5555555 ddd   4    3    1 ";
const char fstr[] = "%lli %lld %lld %lli";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_i_test3
long long aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = "  055555 0f 0f 0f5555555 0ddd   4    3    1 ";
const char fstr[] = "%lli %lld %lld %lli";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_i_test4
long long aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = "0xFFF 0xA123123 0x123123 0x0";
const char fstr[] = "%lli %lld %lld %lli";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_i_test5
long long aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = " 0xFFFF 0xf 0xf 0xf5555555 ddd   4    3    1 ";
const char fstr[] = "%lli %lld %lld %lli";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_i_test6
long long aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = "300500-600+700 111";
const char fstr[] = "%lli %lld %lld %lli";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_n_test1
long long aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
int nM = 0, nN = 5;
const char str[BUFF_SIZE] = "50 160 70 80";
const char fstr[BUFF_SIZE] = "%lli %lli %n %lli %lli";
int M = lib_sscanf(str, fstr, &aM, &bM, &nM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &nN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(nM, nN);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_n_test2
int n1 = 1, n2 = 5;
char s1[BUFF_SIZE] = {'\0'};
char s2[BUFF_SIZE] = {'\0'};
char s3[BUFF_SIZE] = {'\0'};
char s5[BUFF_SIZE] = {'\0'};
char s6[BUFF_SIZE] = {'\0'};
char s7[BUFF_SIZE] = {'\0'};
const char str[] = "cqwrqM 1241! asewrdfewrf aewrt asewwetsdf 81248";
const char fstr[] = "%s %s %n %s";
int M = lib_sscanf(str, fstr, s1, s2, &n1, s3);
int N = sscanf(str, fstr, s5, s6, &n2, s7);
ck_assert_int_eq(M, N);
ck_assert_int_eq(n1, n2);
ck_assert_str_eq(s1, s5);
ck_assert_str_eq(s2, s6);
ck_assert_str_eq(s3, s7);

#test lib_sscanf_n_test3
long long aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
int nM = 0, nN = 53;
const char str[] = "50 60 70 80";
const char fstr[] = "%lli %lli %n %lli %lli";
int M = lib_sscanf(str, fstr, &aM, &bM, &nM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &nN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(nM, nN);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);


#test lib_sscanf_ptr_test1
int *aM = 0, *aN;
int M = lib_sscanf("0x7fff5fbff7d8", "%p", &aM);
int N = sscanf("0x7fff5fbff7d8", "%p", &aN);
ck_assert_int_eq(M, N);
ck_assert_ptr_eq(aM, aN);

#test lib_sscanf_ptr_test2
int *aM = 0, *aN = 0, *bM = 0, *bN = 0, *cM = 0, *cN = 0, *dM = 0, *dN = 0;
const char str[] = "0xFFFF 0xAAAA 0x7123 0xBBC1FF";
const char fstr[] = "%p %p %p %p";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_ptr_eq(aM, aN);
ck_assert_ptr_eq(bM, bN);
ck_assert_ptr_eq(cM, cN);
ck_assert_ptr_eq(dM, dN);

#test lib_sscanf_ptr_test3
int *aN = 0, *aM = 0, *bN = 0, *bM = 0, *cM = 0, *cN = 0, *dM = 0, *dN = 0;
const char str[] = "0xFFFF 0xAAAA 0x7123 0xBBC1FF";
const char fstr[] = "%p %p %p %p";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_ptr_eq(aM, aN);
ck_assert_ptr_eq(bM, bN);
ck_assert_ptr_eq(cM, cN);
ck_assert_ptr_eq(dM, dN);

#test lib_sscanf_float_test1
char fstr[] = "%f %f %f %f";
char str[] = "  1.1 2.2 3.3 4.4";
float aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_float_eq(aM, aN);
ck_assert_float_eq(bM, bN);
ck_assert_float_eq(cM, cN);
ck_assert_float_eq(dM, dN);

#test lib_sscanf_float_test2
float aM = 0, bM = 0, cM = 0, dM = 0;
float aN = 0, bN = 0, cN = 0, dN = 0;
const char str[] = "55123.4 -6.11125 814231.333 +5.01201";
const char fstr[] = "%f %f %f %f";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_float_eq(aM, aN);
ck_assert_float_eq(bM, bN);
ck_assert_float_eq(cM, cN);
ck_assert_float_eq(dM, dN);

#test lib_sscanf_float_test3
long double aM = 1, aN = 0, bM = 1, bN = 0, cM = 1, cN = 0, dM = 1, dN = 0;
const char str[] = "512213.1 -5.31235 4221.3333 +10.002101";
const char fstr[] = "%Lf %Lf %Lf %Lf";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_double_eq_tol(aM, aN, TOL);
ck_assert_double_eq_tol(bM, bN, TOL);
ck_assert_double_eq_tol(cM, cN, TOL);
ck_assert_double_eq_tol(dM, dN, TOL);

#test lib_sscanf_float_test4
double aN = 0, aM = 0, bM = 0, bN = 0, cN = 0, cM = 0, dN = 0, dM = 0;
const char str[] = "0.00214001 -521633 10. .";
const char fstr[] = "%lf %lf %lf %lf";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_double_eq_tol(aM, aN, TOL);
ck_assert_double_eq_tol(bM, bN, TOL);
ck_assert_double_eq_tol(cM, cN, TOL);
ck_assert_double_eq_tol(dM, dN, TOL);

#test lib_sscanf_float_test5
float aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = ". . . .";
const char fstr[] = "%f %f %f %f";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_double_eq_tol(aM, aN, TOL);
ck_assert_double_eq_tol(bM, bN, TOL);
ck_assert_double_eq_tol(cM, cN, TOL);
ck_assert_double_eq_tol(dM, dN, TOL);

#test lib_sscanf_float_test6
long double aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = "513.41 -4.14135 414.3333 +112.0001";
const char fstr[] = "%Lf %Lf %Lf %Lf";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_double_eq_tol(aM, aN, TOL);
ck_assert_double_eq_tol(bM, bN, TOL);
ck_assert_double_eq_tol(cM, cN, TOL);
ck_assert_double_eq_tol(dM, dN, TOL);

#test lib_sscanf_float_test7
float aM = 0, aN = 0, bM = 0, bN = 0;
const char str[] = "5910.1 -412.925 5522121.333 +2.0001";
const char fstr[] = "%*f %f %f %*f";
int M = lib_sscanf(str, fstr, &aM, &bM);
int N = sscanf(str, fstr, &aN, &bN);
ck_assert_int_eq(M, N);
ck_assert_float_eq_tol(aM, aN, 1e-7);
ck_assert_float_eq(bM, bN);

#test lib_sscanf_sci_test8
float aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dN = 0, dM = 0;
const char str[] = "1.4441 1.31e+4 -3.31e-4 0.444e-5";
const char fstr[] = "%G %G %G %G";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_double_eq_tol(aM, aN, TOL);
ck_assert_double_eq_tol(bM, bN, TOL);
ck_assert_double_eq_tol(cM, cN, TOL);
ck_assert_double_eq_tol(dM, dN, TOL);

#test lib_sscanf_sci_test9
float aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = "inf 1.31e+4 NaN 0.444e-5";
const char fstr[] = "%G %G %G %G";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_ldouble_eq(aM, aN);
ck_assert_double_eq_tol(bM, bN, TOL);
ck_assert_float_nan(cM);
ck_assert_float_nan(cN);
ck_assert_double_eq_tol(dM, dN, TOL);

#test lib_sscanf_sci_test10
float aN = 0, aM = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
const char str[] = "Nan NAN 0.0000 0";
const char fstr[] = "%G %G %G %G";
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_float_nan(aM);
ck_assert_float_nan(aN);
ck_assert_float_nan(bM);
ck_assert_float_nan(bN);
ck_assert_ldouble_eq(cM, cN);
ck_assert_ldouble_eq(dM, dN);

#test lib_sscanf_double_test1
char fstr[] = "%le %le %le %le";
char str[] = "  1.1e1 2.2e2 3.3e3 4.4e4";
double aM = 0, aN = 0, bM =     0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_double_eq(aM, aN);
ck_assert_double_eq(bM, bN);
ck_assert_double_eq(cM, cN);
ck_assert_double_eq(dM, dN);

#test lib_sscanf_double_test2
char fstr[] = "%lE %lE %lE %lE";
char str[] = "  1.1E10 2.2E2 3.3E3 4.4E4";
double aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);

#test lib_sscanf_double_test3
char fstr[] = "%lE %lE %lE %lE";
char str[] = "  1.1E10 2.2E2          3.3E3 4.4E4          ";
double aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);

#test lib_sscanf_exp_test1
char fstr[] = "%e %e %e %e";
char str[] = "  1.1e1 2.2e2 3.3e3 4.4e4";
float aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_float_eq(aM, aN);
ck_assert_float_eq(bM, bN);
ck_assert_float_eq(cM, cN);
ck_assert_float_eq(dM, dN);

#test lib_sscanf_exp_test2
char fstr[] = "%E %E %E %E";
char str[] = "  1.1E1 2.2E2 3.3E3 4.4E4";
float aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_float_eq(aM, aN);
ck_assert_float_eq(bM, bN);
ck_assert_float_eq(cM, cN);
ck_assert_float_eq(dM, dN);

#test lib_sscanf_char_test1
char fstr[] = "%c %c %c %c";
char str[] = "   a     b c d";
int aM = 0, aN = 3, bM = 1, bN = 3, cM = 0, cN = 7, dM = 0, dN = 8;
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_char_test2
char fstr[] = "%c%c%c%c";
char str[] = "abcd";
int aM = 0, aN = 5, bM = 0, bN = 5, cM = 0, cN = 5, dM = 0, dN = 5;
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_char_test3
char fstr[] = "%c %c %c %c";
char str[] = "   000 0    ";
int aM = 0, aN = 5, bM = 0, bN = 5, cM = 0, cN = 5, dM = 0, dN = 5;
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_char_test4
char fstr[] = "%c%c%c%c";
char str[] = "\\\n\tt\t";
int aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_char_test5
char fstr[] = "%c %c %c %c";
char str[] = "z ' ' /";
int aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_char_test6
char fstr[] = "%c%*c%c%c";
char str[] = "ABCD";
int aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0;
int M = lib_sscanf(str, fstr, &aM, &bM, &cM);
int N = sscanf(str, fstr, &aN, &bN, &cN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);

#test lib_sscanf_char_test7
char fstr[] = "%c %c %c %c";
char str[] = "z *'@";
int aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_char_test8
char fstr[] = "%1c %c %c %0c";
char str[] = "z *'@";
int aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_char_test9
char fstr[] = "%*c%*c%*c%c";
char str[] = "abcde";
int aM = 0, aN = 0;
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);

#test lib_sscanf_char_test10
char fstr[] = "%*c%*c%*c%*c";
char str[] = "   c ";
int aM = 0, aN = 0;
int M = lib_sscanf(str, fstr, &aM);
int N = sscanf(str, fstr, &aN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);

#test lib_sscanf_string_test1
char s1[BUFF_SIZE] = {'\0'};
char s2[BUFF_SIZE] = {'\0'};
char s3[BUFF_SIZE] = {'\0'};
char s4[BUFF_SIZE] = {'\0'};
char s5[BUFF_SIZE] = {'\0'};
char s6[BUFF_SIZE] = {'\0'};
char s7[BUFF_SIZE] = {'\0'};
char s8[BUFF_SIZE] = {'\0'};
const char str[] = "checks Wtf ijussWannaSleep gimme750Exp Anuroba";
const char fstr[] = "%s %s %s %s";
int16_t M = lib_sscanf(str, fstr, s1, s2, s3, s4);
int16_t N = sscanf(str, fstr, s5, s6, s7, s8);
ck_assert_int_eq(M, N);
ck_assert_str_eq(s1, s5);
ck_assert_str_eq(s2, s6);
ck_assert_str_eq(s3, s7);
ck_assert_str_eq(s4, s8);

#test lib_sscanf_string_test2
char s1[BUFF_SIZE] = {'\0'};
char s2[BUFF_SIZE] = {'\0'};
char s3[BUFF_SIZE] = {'\0'};
char s4[BUFF_SIZE] = {'\0'};
char s5[BUFF_SIZE] = {'\0'};
char s6[BUFF_SIZE] = {'\0'};
char s7[BUFF_SIZE] = {'\0'};
char s8[BUFF_SIZE] = {'\0'};
const char str[] = "checks\twtf\tijustwannasleep\tgimme750exp";
const char fstr[] = "%s%s%s%s";
int M = lib_sscanf(str, fstr, s1, s2, s3, s4);
int N = sscanf(str, fstr, s5, s6, s7, s8);
ck_assert_int_eq(M, N);
ck_assert_str_eq(s1, s5);
ck_assert_str_eq(s2, s6);
ck_assert_str_eq(s3, s7);
ck_assert_str_eq(s4, s8);

#test lib_sscanf_string_test3
char s1[BUFF_SIZE] = {'\0'};
char s2[BUFF_SIZE] = {'\0'};
char s3[BUFF_SIZE] = {'\0'};
char s4[BUFF_SIZE] = {'\0'};
char s5[BUFF_SIZE] = {'\0'};
char s6[BUFF_SIZE] = {'\0'};
char s7[BUFF_SIZE] = {'\0'};
char s8[BUFF_SIZE] = {'\0'};
const char str[] = "checks\twtf\tijustwannasleep\tgimme750exp";
const char fstr[] = "%350s%1s%1s\t%3s";
int M = lib_sscanf(str, fstr, s1, s2, s3, s4);
int N = sscanf(str, fstr, s5, s6, s7, s8);
ck_assert_int_eq(M, N);
ck_assert_str_eq(s1, s5);
ck_assert_str_eq(s2, s6);
ck_assert_str_eq(s3, s7);
ck_assert_str_eq(s4, s8);

#test lib_sscanf_string_test4
char s1[BUFF_SIZE] = {'\0'};
char s2[BUFF_SIZE] = {'\0'};
char s3[BUFF_SIZE] = {'\0'};
char s4[BUFF_SIZE] = {'\0'};
char s5[BUFF_SIZE] = {'\0'};
char s6[BUFF_SIZE] = {'\0'};char s7[BUFF_SIZE] = {'\0'};
char s8[BUFF_SIZE] = {'\0'};
const char str[] = "checks\twtf\tijustwannasleep\tgimme750exp";
const char fstr[] = "%3s%2s%5s%5s";
int M = lib_sscanf(str, fstr, s1, s2, s3, s4);
int N = sscanf(str, fstr, s5, s6, s7, s8);
ck_assert_int_eq(M, N);
ck_assert_str_eq(s1, s5);
ck_assert_str_eq(s2, s6);
ck_assert_str_eq(s3, s7);
ck_assert_str_eq(s4, s8);

#test lib_sscanf_string_test5
unsigned long long int aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0;
long long dM = 0, dN = 0;
long double eM = 0, eN = 0;
char s1[BUFF_SIZE] = {'\0'};
char s2[BUFF_SIZE] = {'\0'};
char s3[BUFF_SIZE] = {'\0'};
char s4[BUFF_SIZE] = {'\0'};
char s5[BUFF_SIZE] = {'\0'};
char s6[BUFF_SIZE] = {'\0'};
char s7[BUFF_SIZE] = {'\0'};
char s8[BUFF_SIZE] = {'\0'};
char s9[BUFF_SIZE] = {'\0'};
char s10[BUFF_SIZE] = {'\0'};
const char str[] = "4412414eeeeeee\teeeeeee";
const char fstr[] = "%5s %1s %*s %*s %llu %s %llu %llu %lld %Lf %33s";
int M = lib_sscanf(str, fstr, s7, s9, &aM, s5, &bM, &cM, &dM, &eM, s1);
int N = sscanf(str, fstr, s8, s10, &aN, s6, &bN, &cN, &dN, &eN, s2);
ck_assert_int_eq(M, N);
ck_assert_str_eq(s1, s2);
ck_assert_str_eq(s3, s4);
ck_assert_str_eq(s5, s6);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);

#test lib_sscanf_common_test1
char fstr[] = "%% %c % test%c %c";
char str[] = "   000 0    ";
int aM = 0, aN = 0, bM = 0, bN = 0, cM = 0, cN = 0, dM = 0, dN = 0;
int M = lib_sscanf(str, fstr, &aM, &bM, &cM, &dM);
int N = sscanf(str, fstr, &aN, &bN, &cN, &dN);
ck_assert_int_eq(M, N);
ck_assert_int_eq(aM, aN);
ck_assert_int_eq(bM, bN);
ck_assert_int_eq(cM, cN);
ck_assert_int_eq(dM, dN);


#test lib_sprintf_int_test1
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "This is a simple value %d";
int val = 923;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test2
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "This is not so easy value %5d";
int val = 923.21;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test3
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "This is not so easy value %d";
int val = -923.21;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test4
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%55.50d";
int val = -923.21;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test5
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "This is again so %d easy value";
int val = -923.21;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test6
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%.5i";
int val = -923;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test7
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%-5i";
int val = 923;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test8
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%+15d";
int val = -923;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test9
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%012i";
int val = -923;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test10
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "check %0*d";
int val = -923, width = 5;
int M = lib_sprintf(strM, format, width, val);
int N = sprintf(strN, format, width, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test11
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%0.*i";
int val = -923;
int M = lib_sprintf(strM, format, 555, val);
int N = sprintf(strN, format, 555, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test12
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char format[] = "%0.*i %d %4.*i %0#+13d %d";
int val = 69;
int M = lib_sprintf(strM, format, 5, val, -10431, 13, 5311, 0, -581253581);
int N = sprintf(strN, format, 5, val, -10431, 13, 5311, 0, -581253581);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test13
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char format[] = "%+5.31li";
long int val = 698518581899;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test14
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%-16.9hi";
short int val = 6958;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test15
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%0.*ld";
long val = 8581385185;
int M = lib_sprintf(strM, format, 5, val);
int N = sprintf(strN, format, 5, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test16
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%.0ld";
long val = 8581385185;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test17
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "% d";
long val = 0;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test18
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%012i";
int val = 69;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_int_test19
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%.0d";
int val = 0;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_char_test1
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%c";
char c = '\0';
int M = lib_sprintf(strM, format, c);
int N = sprintf(strN, format, c);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_char_test2
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%c";
char c = '5';
int M = lib_sprintf(strM, format, c);
int N = sprintf(strN, format, c);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_char_test3
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "% -10c";
char c = '-';
int M = lib_sprintf(strM, format, c);
int N = sprintf(strN, format, c);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_char_test4
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%15c";
char c = 'l';
int M = lib_sprintf(strM, format, c);
int N = sprintf(strN, format, c);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_char_test5
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%c";
char *c = " ";
int M = lib_sprintf(strM, format, c);
int N = sprintf(strN, format, c);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_char_test6
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%c";
char *c = "";
int M = lib_sprintf(strM, format, c);
int N = sprintf(strN, format, c);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_char_test7
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%c";
char *c = "%";
int M = lib_sprintf(strM, format, c);
int N = sprintf(strN, format, c);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_char_test8
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%c";
char c = '%';
int M = lib_sprintf(strM, format, c);
int N = sprintf(strN, format, c);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_char_test9
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%c";
char c = '\t';
int M = lib_sprintf(strM, format, c);
int N = sprintf(strN, format, c);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_char_test10
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%c";
char c = 'c';
int M = lib_sprintf(strM, format, c);
int N = sprintf(strN, format, c);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_char_test11
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%c %s";
char c = 'c';
char *str = "weg=3202";
int M = lib_sprintf(strM, format, c, str);
int N = sprintf(strN, format, c, str);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_str_test1
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%s";
char *str = "what the f is this";
int M = lib_sprintf(strM, format, str);
int N = sprintf(strN, format, str);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_str_test2
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%100.5s   %-16.9hi";
char *str = "what the f is this";
int val = 1050;
int M = lib_sprintf(strM, format, str, val);
int N = sprintf(strN, format, str, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_str_test3
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%100.52s   %-16.9hi";
char *str = "-what the f is this";
int val = 1050;
int M = lib_sprintf(strM, format, str, val);
int N = sprintf(strN, format, str, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_str_test4
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%.15s";
char *str = "-what thewqqwrqw qr f is this";
int M = lib_sprintf(strM, format, str);
int N = sprintf(strN, format, str);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_str_test5
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%-15.9s";
char *str = "-what thewqqwrqw qr f is this";
int M = lib_sprintf(strM, format, str);
int N = sprintf(strN, format, str);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_str_test6
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%s%s%s%s";
char *str0 = "-what thewqqwrqw qr f is this-what thewqqwrqw qr f is this-what thewqqwrqw qr f is this";
char *str1 = "";
char *str2 = "89152510-001-2-0-414241271389480913";
char *str3 = "gqwo12010120";
int M = lib_sprintf(strM, format, str0, str1, str2, str3);
int N = sprintf(strN, format, str0, str1, str2, str3);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_str_test7
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%s %c %s %d";
char *str0;
char c1;
char *str1;
char val = 0;
int M = lib_sprintf(strM, format, str0, c1, str1, val);
int N = sprintf(strN, format, str0, c1,  str1, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_unsigned_test1
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%u %u";
unsigned val = 1050;
unsigned val1 = -51;
int M = lib_sprintf(strM, format, val, val1);
int N = sprintf(strN, format, val, val1);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_unsigned_test2
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%-16u";
unsigned int val = -1251140;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_unsigned_test3
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%.51u";
unsigned val = -1251140;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_unsigned_test4
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%15hu";
unsigned short int val = -12510;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_unsigned_test5
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%lu";
unsigned long int val = -949149114140;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_unsigned_test6
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%lu %u %hu %.5u %5.u";
unsigned long int val = 949149114140;
int M = lib_sprintf(strM, format, val, 14, 1441, 14414, 9681);
int N = sprintf(strN, format, val, 14, 1441, 14414, 9681);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_unsigned_test7
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%u";
unsigned int val = -949140;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_ptr_test1
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%p";
int M = lib_sprintf(strM, format, format);
int N = sprintf(strN, format, format);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_ptr_test2
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%15p";
int M = lib_sprintf(strM, format, format);
int N = sprintf(strN, format, format);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_ptr_test3
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%125.15p";
int M = lib_sprintf(strM, format, format);
int N = sprintf(strN, format, format);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_hex_test1
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%#X";
unsigned int val = 255;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_hex_test2
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%#0- +124x";
unsigned int val = (unsigned)INT32_MIN;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_hex_test3
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%#-015X";
unsigned int val = 0;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_hex_test4
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%#x";
unsigned int val = INT32_MAX;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_hex_test5
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%#15x";
unsigned int val = INT32_MAX;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_hex_test6
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%#015.25x";
unsigned int val = INT32_MAX;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_hex_test7
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%#+-015.25x";
unsigned int val = INT32_MAX;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_hex_test8
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%#*.6x";
int val1 = 12, val2 = 0;
int M = lib_sprintf(strM, format, val1, val2);
int N = sprintf(strN, format, val1, val2);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_hex_test9
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%#3.*x%#3x%-7.*x%#-1.8x%4.3x%#2.15x%*.*x%*.1x%3x%-1x";
int v1 = 3, v2 = 124201, v3 = 45125, v4 = 0, v5 = 22141, v6 = 0, v7 = 419;
int v8 = 999, v9 = 13, v10 = 16, v11 = 33, v12 = 119, v13 = 21, v14 = 0, v15 = 152;
int M = lib_sprintf(strM, format, v1, v2, v3, v4, v5, v6, v7, v8, v10, v11, v12, v13, v14, v15);
int N = sprintf(strN, format, v1, v2, v3, v4, v5, v6, v7, v8, v10, v11, v12, v13, v14, v15);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_hex_test10
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%hx";
short int val = 12451;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_octal_test1
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%#15.2o";
unsigned int val = INT32_MAX;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_octal_test2
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%#+50.*o";
int val = 11241;
int M = lib_sprintf(strM, format, 5, val);
int N = sprintf(strN, format, 5, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_octal_test3
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%-0*.*o";
int val = 141251;
int M = lib_sprintf(strM, format, 50, 135, val);
int N = sprintf(strN, format, 50, 135, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_octal_test4
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "% 015.*o";
int val = 141251;
int M = lib_sprintf(strM, format, 50, 135, val);
int N = sprintf(strN, format, 50, 135, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_octal_test5
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%-5.51o";
int val = 64340;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_float_test1
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%f";
double val = 5412;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_float_test2
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%Lf";
long double val = 15299125.131513541241351;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_float_test3
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%15Lf";
long double val = 121.521;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_float_test4
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%.0Lf";
long double val = 1512.35;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_float_test5
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%.Lf";
long double val = 151525.351521;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_float_test6
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%.15Lf";
long double val = 151525.351521;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_float_test7
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%.15Lf";
long double val = -151525.351521;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_float_test8
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%.15Lf";
long double val = 616161201230.145125151212;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_float_test9
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%# f";
float val = 0;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_float_test10
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format =  "% .0f %.lf %Lf %f %lf %Lf";
float val = 0;
double val1 = 0;
long double val2 = 3515315.153151;
float val3 = 5.5;
double val4 = 9851.51351;
long double val5 = 95919539159.53151351131;
int M = lib_sprintf(strM, format, val, val1, val2, val3, val4, val5);
int N = sprintf(strN, format, val, val1, val2, val3, val4, val5);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_float_test11
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%# -14.f";
float val = 0;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_float_test12
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%#+14.f";
float val = 0;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_exp_test1
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%2E";
float val = 10e+3;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_exp_test2
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%2e";
float val = 10e+3;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_ext_test3
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%e";
float val = 15e-6;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_exp_test4
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%#e";
float val = 15e-6;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_exp_test5
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%# 05.6e";
float val = 15e-6;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_exp_test6
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%#+05.6e";
float val = 15e-6;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_exp_test7
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%# -10.11E";
float val = 15e-10;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_sci_test1
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%G";
float val = 15e-10;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_sci_test2
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%G";
float val = 15e-3;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_sci_test3
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%G";
float val = 1e5;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_sci_test4
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%g";
float val = 1.1553252e6;;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_sci_test5
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%5g";
float val = 1.1553e6;;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_sci_test6
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%10.9g";
float val = 1.1553e6;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_sci_test7
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%10.12g";
float val = 1.1553e6;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_sci_test8
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "% 10.12g";
float val = 1.1553e8;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_sci_test9
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%-10.12g";
float val = 1.1553e8;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_sci_test10
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%+10.12g";
float val = 1.1553e2;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_sci_test11
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%+10.12g";
float val = 1.1553e2;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_sci_test12
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%0g";
float val = 1.1553e2;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_sci_test13
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%.0g";
double val = 0.123000;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_sci_test14
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%.g";
double val = 0.0004;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_common_test1
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%% eqgew %d";
unsigned int val = 255;
int M = lib_sprintf(strM, format, val);
int N = sprintf(strN, format, val);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_common_test2
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "%#e %12f %s";
float val = 10e+3;
float val1 = 123.124;
char *str = "check if null";
int M = lib_sprintf(strM, format, val, val1, str);
int N = sprintf(strN, format, val, val1, str);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_common_test3
char strM[BUFF_SIZE];
char strN[BUFF_SIZE];
char *format = "% 0.0hi% 0.0hu% 0.0hd % 0.0hf";
int M = lib_sprintf(strM, format, 1, 222, 33333333333, 166513.1232);
int N = sprintf(strN, format, 1, 222, 33333333333, 166513.1232);
ck_assert_int_eq(M, N);
ck_assert_str_eq(strM, strN);

#test lib_sprintf_common_test4