API tools faq
paste
Advertisement
Guest User

libft_main

a guest
Apr 25th, 2018
107
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 43.98 KB | None | 0 0
raw download clone embed print report
  1. #include "main_util.c"
  2.  
  3. int segfault;
  4. struct sigaction sig;
  5. char const segstr[] = "(segfault)";
  6.  
  7.  
  8.  
  9. void    test_bzero(char const *test_name, int can_segfault,
  10.         char *dest_libft,
  11.         char *dest_libc,
  12.         size_t length)
  13. {
  14.     segfault = setjmp(restore); if (!segfault) ft_bzero(dest_libft, length); else dest_libft = segstr;
  15.     segfault = setjmp(restore); if (!segfault)    bzero(dest_libc,  length); else dest_libc  = segstr;
  16.     test_str(test_name, "bzero",                    dest_libft,          dest_libc,          can_segfault);
  17.     test_str(NULL,      "bzero (after the '\\0's)", dest_libft + length, dest_libc + length, can_segfault);
  18. }
  19.  
  20. void    test_memset(char const *test_name, int can_segfault,
  21.         char *dest_libft,
  22.         char *dest_libc,
  23.         int byte,
  24.         size_t length)
  25. {
  26.     char *result_libft;
  27.     char *result_libc;
  28.     segfault = setjmp(restore); if (!segfault) result_libft = (char*)ft_memset(dest_libft, byte, length); else result_libft = segstr;
  29.     segfault = setjmp(restore); if (!segfault) result_libc  = (char*)   memset(dest_libc,  byte, length); else result_libc  = segstr;
  30.     test_mem(test_name, "memset arg",      dest_libft,   dest_libc, length, can_segfault);
  31.     test_mem(NULL,      "memset return", result_libft, result_libc, length, can_segfault);
  32. }
  33.  
  34. void    test_memcpy(char const *test_name, int can_segfault,
  35.         char *dest_libft,
  36.         char *dest_libc,
  37.         char const *src,
  38.         size_t src_len)
  39. {
  40.     char *result_libft;
  41.     char *result_libc;
  42.     segfault = setjmp(restore); if (!segfault) result_libft = (char*)ft_memcpy(dest_libft, src, src_len); else result_libft = segstr;
  43.     segfault = setjmp(restore); if (!segfault) result_libc  = (char*)   memcpy(dest_libc,  src, src_len); else result_libc  = segstr;
  44.     test_str(test_name, "memcpy arg",      dest_libft,   dest_libc, can_segfault);
  45.     test_str(NULL,      "memcpy return", result_libft, result_libc, can_segfault);
  46. }
  47.  
  48. void    test_memccpy(char const *test_name, int can_segfault,
  49.         char *dest_libft,
  50.         char *dest_libc,
  51.         char const *src,
  52.         char c,
  53.         size_t src_len)
  54. {
  55.     char *result_libft;
  56.     char *result_libc;
  57.     segfault = setjmp(restore); if (!segfault) result_libft = (char*)ft_memccpy(dest_libft, src, c, src_len); else result_libft = segstr;
  58.     segfault = setjmp(restore); if (!segfault) result_libc  = (char*)   memccpy(dest_libc,  src, c, src_len); else result_libc  = segstr;
  59.     test_str(test_name, "memccpy arg",      dest_libft,   dest_libc, can_segfault); if (c !='\0')
  60.     test_str(NULL,      "memccpy return", result_libft, result_libc, can_segfault);
  61. }
  62.  
  63. void    test_strcpy(char const *test_name, int can_segfault,
  64.         char *dest_libft,
  65.         char *dest_libc,
  66.         char const *src)
  67. {
  68.     char *result_libft;
  69.     char *result_libc;
  70.     segfault = setjmp(restore); if (!segfault) result_libft = (char*)ft_strcpy(dest_libft, src); else result_libft = segstr;
  71.     segfault = setjmp(restore); if (!segfault) result_libc  = (char*)   strcpy(dest_libc,  src); else result_libc  = segstr;
  72.     test_str(test_name, "strcpy arg",      dest_libft,   dest_libc, can_segfault);
  73.     test_str(NULL,      "strcpy return", result_libft, result_libc, can_segfault);
  74. }
  75.  
  76. void    test_strncpy(char const *test_name, int can_segfault,
  77.         char *dest_libft,
  78.         char *dest_libc,
  79.         char const *src,
  80.         size_t length)
  81. {
  82.     char *result_libft;
  83.     char *result_libc;
  84.     segfault = setjmp(restore); if (!segfault) result_libft = (char*)ft_strncpy(dest_libft, src, length); else result_libft = segstr;
  85.     segfault = setjmp(restore); if (!segfault) result_libc  = (char*)   strncpy(dest_libc,  src, length); else result_libc  = segstr;
  86.     test_str(test_name, "strcpy arg",      dest_libft,   dest_libc, can_segfault);
  87.     test_str(NULL,      "strcpy return", result_libft, result_libc, can_segfault);
  88. }
  89.  
  90. void    test_memalloc(char const *test_name, int can_segfault,
  91.         char *result_1,
  92.         char *result_2,
  93.         size_t length)
  94. {
  95.     int error;
  96.     segfault = setjmp(restore); if (!segfault) result_1 = (char *)ft_memalloc(MALLOC_LEN); else result_1 = segstr;
  97.     segfault = setjmp(restore); if (!segfault) result_2 = (char *)ft_memalloc(MALLOC_LEN); else result_2 = segstr;
  98.     printf("\n%s -> ", test_name);
  99.     if (result_1 == NULL) { error = TRUE; printf(C_RED"\nERROR - The 1st call returned NULL."RESET); }
  100.     if (result_2 == NULL) { error = TRUE; printf(C_RED"\nERROR - The 2nd call returned NULL."RESET); }
  101.     for (size_t i = 0; i < MALLOC_LEN; ++i)
  102.     {
  103.         if (result_1[i] || result_2[i])
  104.         {
  105.             error = TRUE;
  106.             printf(C_RED"\nERROR - Every char should be '\\0'."RESET);
  107.         }
  108.     }
  109.     if (!error) printf(C_GREEN"OK!"RESET);
  110. }
  111. void    test_strnew(char const *test_name, int can_segfault,
  112.         char *result_1,
  113.         char *result_2,
  114.         size_t length)
  115. {
  116.     int error;
  117.     segfault = setjmp(restore); if (!segfault) result_1 = (char *)ft_strnew(MALLOC_LEN); else result_1 = segstr;
  118.     segfault = setjmp(restore); if (!segfault) result_2 = (char *)ft_strnew(MALLOC_LEN); else result_2 = segstr;
  119.     printf("\n%s -> ", test_name);
  120.     if (result_1 == NULL) { error = TRUE; printf(C_RED"\nERROR - The 1st call returned NULL."RESET); }
  121.     if (result_2 == NULL) { error = TRUE; printf(C_RED"\nERROR - The 2nd call returned NULL."RESET); }
  122.     for (size_t i = 0; i < MALLOC_LEN; ++i)
  123.     {
  124.         if (result_1[i] || result_2[i])
  125.         {
  126.             error = TRUE;
  127.             printf(C_RED"\nERROR - Every char should be '\\0'."RESET);
  128.         }
  129.     }
  130.     if (!error) printf(C_GREEN"OK!"RESET);
  131. }
  132.  
  133.  
  134.  
  135. void    test_strsplit(char const *test_name, int can_segfault,
  136.         char const **expect,
  137.         char const *str,
  138.         char separator)
  139. {
  140.     char **result;
  141.     segfault = setjmp(restore);
  142.     if (!segfault) result = ft_strsplit(str, separator);
  143.     else { result = (char **)malloc(sizeof(char *)); *result = segstr; }
  144.     test_strarray(test_name, "strsplit", (char const **)result, expect, can_segfault);
  145. }
  146.  
  147.  
  148.  
  149.  
  150.  
  151.  
  152.  
  153.  
  154.  
  155.  
  156.  
  157.  
  158. int     main(void)
  159. {
  160.     memset(&sig, 0, sizeof(sigaction));
  161.     sigemptyset(&sig.sa_mask);
  162.     sig.sa_flags     = SA_NODEFER;
  163.     sig.sa_sigaction = segfault_handler;
  164.     sigaction(SIGSEGV, &sig, NULL);
  165.  
  166.  
  167.  
  168.     int num = 1;
  169.     if (*(char *)&num == 1)
  170.     {
  171.         printf(C_GREEN"\n/!\\ Processor is Little-Endian (all tests should work fine)\n"RESET);
  172.     }
  173.     else
  174.     {
  175.         printf(C_RED"\n/!\\ Processor is Big-Endian (errors may arise in certain tests: notably memcmp, and various lst tests)\n"RESET);
  176.     }
  177.     printf(C_YELLOW"\nAll the tests with written in yellow 'can segfault' are NULL pointer tests.\n"RESET);
  178.  
  179.  
  180.  
  181.     t_u32   n = 0xFFFFAAAA;
  182.     t_u32   na;
  183.     t_u32   nb;
  184.     t_u32   *nra;  
  185.     t_u32   *nrb;
  186.     t_u64   la;
  187.     t_u64   lb;
  188.     char    *sa;
  189.     char    *sb;
  190.     char    *sra;
  191.     char    *srb;
  192.     char const s1[] = "Omae wa mou shindeiru.";     size_t s1_len = strlen(s1) + 1;
  193.     char const s2[] = "Nani???";                    size_t s2_len = strlen(s2) + 1;
  194.     char const s3[] = "Un ange mange de la fange."; size_t s3_len = strlen(s3) + 1;
  195.     char    **strls;
  196.  
  197.  
  198.  
  199. //  void    *ft_memalloc(size_t size);
  200.     test_memalloc("memalloc", FALSE, sa, sb, MALLOC_LEN);
  201.  
  202. printf("\n");
  203.  
  204. //  char    *ft_strnew(size_t size);
  205.     test_strnew("strnew", FALSE, sra, srb, MALLOC_LEN);
  206.  
  207. printf("\n");
  208.  
  209. //  void    *ft_memcpy(void *dest, const void *src, size_t n);
  210.     nra = (t_u32*)ft_memcpy(&na, &n, 4);
  211.     nrb = (t_u32*)   memcpy(&nb, &n, 4);
  212.     test_int("memcpy (uint) ", "memcpy arg",    na,   nb,   FALSE);
  213.     test_int(NULL,             "memcpy return", *nra, *nrb, FALSE);
  214.  
  215.     test_memcpy("memcpy (str)  ",     FALSE, sa,   sb,   s1,   s1_len);
  216.     test_memcpy("memcpy (n = 0)",     FALSE, sa,   sb,   s1,   0);
  217.     test_memcpy("memcpy (null dest)", TRUE,  NULL, NULL, s1,   s1_len);
  218.     test_memcpy("memcpy (null src) ", TRUE,  sa,   sb,   NULL, s1_len);
  219.     test_memcpy("memcpy (both null)", TRUE,  NULL, NULL, NULL, s1_len);
  220.  
  221. printf("\n");
  222.  
  223. //  void    *ft_memccpy(void *dest, const void *src, int byte, size_t n);
  224. /*
  225.     sra = ft_memccpy(&na, &n, 0xAA, 10);
  226.     srb =    memccpy(&nb, &n, 0xAA, 10);
  227.     test_int("memccpy (uint)", "memccpy arg", na, nb, FALSE);
  228.     test_int(NULL, "memccpy return pointer difference",
  229.         (t_u32)(sra - (char *)&na),
  230.         (t_u32)(srb - (char *)&nb), FALSE);
  231. */
  232.     test_memccpy("memccpy (str) ",           FALSE,  sa,   sb,  s3,   'e', s3_len);
  233.     test_memccpy("memccpy (str, c = '\\0')", FALSE,  sa,   sb,  s3,  '\0', s3_len);
  234.     test_memccpy("memccpy (null dest)",      TRUE,  NULL, NULL, s3,   'e', s3_len);
  235.     test_memccpy("memccpy (null src) ",      TRUE,   sa,   sb,  NULL, 'e', 5);
  236.     test_memccpy("memccpy (both null)",      TRUE,  NULL, NULL, NULL, 'e', 5);
  237.  
  238. printf("\n");
  239.  
  240. //  char    *ft_strcpy(char *dest, const char *src);
  241.     test_strcpy("strcpy",             FALSE, sa,   sb,   s2);
  242.     test_strcpy("strcpy (n = 0)",     FALSE, sa,   sb,   s2);
  243.     test_strcpy("strcpy (null dest)", TRUE,  NULL, NULL, s2);
  244.     test_strcpy("strcpy (null src) ", TRUE,  sa,   sb,   NULL);
  245.     test_strcpy("strcpy (both null)", TRUE,  NULL, NULL, NULL);
  246.  
  247. printf("\n");
  248.  
  249. //  char    *ft_strncpy(char *dest, const char *src, size_t n);
  250.     test_strncpy("strncpy",                  FALSE, sa,   sb,   s1,  s1_len);
  251.     test_strncpy("strncpy (n = 0)",          FALSE, sa,   sb,   s1,  0);
  252.     test_strncpy("strncpy (n > src_len)",    FALSE, sa,   sb,   s2,  s2_len + 5);
  253.     test_strncpy("strncpy (n < src_len)",    FALSE, sa,   sb,   s1,  s1_len - 5);
  254.     test_strncpy("strncpy (several '\\0's)", FALSE, sa,   sb,   "Swag\0\0\0", 7);
  255.     test_strncpy("strncpy (null dest)",      TRUE,  NULL, NULL, s1,   5);
  256.     test_strncpy("strncpy (null src) ",      TRUE,  sa,   sb,   NULL, 5);
  257.     test_strncpy("strncpy (both null)",      TRUE,  NULL, NULL, NULL, 5);
  258.  
  259. printf("\n");
  260.  
  261. //  void    *ft_memset(void *ptr, int byte, size_t n);
  262.     test_memset("memset (str)",      FALSE,  sa,  sb,  'a', 7);
  263.     test_memset("memset (uint)",     FALSE, &na, &nb,  0xDDCCBBAA, 4);
  264.     test_memset("memset (n = 0)",    FALSE,  sa,  sb, '\0', 0);
  265.     test_memset("memset (null ptr)", TRUE,   sa,  sb,  '_', 5);
  266.  
  267. printf("\n");
  268.  
  269. //  void    ft_bzero(void *ptr, size_t n);
  270.     test_bzero("bzero",            FALSE, sa, sb, 2);
  271.     test_bzero("bzero (n = 0)",    FALSE, sa, sb, 0);
  272.     test_bzero("bzero (null ptr)", TRUE,  sa, sb, 2);
  273.  
  274. printf("\n");
  275.  
  276. //  void    *ft_memmove(void *dest, const void *src, size_t n);
  277. /* 
  278.     n = 0xDDAA3333;
  279.     nra = ft_memmove(&na, &n, 4);
  280.     nrb =    memmove(&nb, &n, 4);
  281.     test_int("memmove (uint) ", "memmove arg",    na,   nb,   FALSE);
  282.     test_int(NULL,              "memmove return", *nra, *nrb, FALSE);
  283.  
  284.     sra = ft_memmove(sa, s2, s2_len);
  285.     srb =    memmove(sb, s2, s2_len);
  286.     test_str("memmove (str)  ", "memmove arg",    sa,  sb,  FALSE);
  287.     test_str(NULL,              "memmove return", sra, srb, FALSE);
  288.  
  289.     sra = ft_memmove(sa, s1, 0);
  290.     srb =    memmove(sb, s1, 0);
  291.     test_str("memmove (n = 0)", "memmove arg",    sa,  sb,  FALSE);
  292.     test_str(NULL,              "memmove return", sra, srb, FALSE);
  293.  
  294.     sra = ft_memmove(sa + 3, sa, s1_len - 5);
  295.     srb =    memmove(sb + 3, sb, s1_len - 5);
  296.     test_str("memmove (overlapping)", "memmove arg",    sa,  sb,  FALSE);
  297.     test_str(NULL,                    "memmove return", sra, srb, FALSE);
  298. */
  299.     segfault = setjmp(restore); if (!segfault) sra = ft_memmove(NULL, s1, 5); else sra = segstr;
  300.     segfault = setjmp(restore); if (!segfault) srb =    memmove(NULL, s1, 5); else srb = segstr;
  301.     test_str("memmove (null dest)", "memmove return", sra, srb, TRUE);
  302.  
  303.     segfault = setjmp(restore); if (!segfault) sra = ft_memmove(sa, NULL, 5); else sra = segstr;
  304.     segfault = setjmp(restore); if (!segfault) srb =    memmove(sb, NULL, 5); else srb = segstr;
  305.     test_str("memmove (null src) ", "memmove arg",    sa,  sb,  TRUE);
  306.     test_str(NULL,                  "memmove return", sra, srb, TRUE);
  307.  
  308.     segfault = setjmp(restore); if (!segfault) sra = ft_memmove(NULL, NULL, 5); else sra = segstr;
  309.     segfault = setjmp(restore); if (!segfault) srb =    memmove(NULL, NULL, 5); else srb = segstr;
  310.     test_str("memmove (both null)", "memmove return", sra, srb, TRUE);
  311.  
  312. printf("\n");
  313.  
  314. //  char    *ft_strdup(const char *str);
  315.     sra = ft_strdup(s1);
  316.     srb =    strdup(s1);
  317.     test_str("strdup", "strdup return", sa, sb, FALSE);
  318. /*
  319.     segfault = setjmp(restore); if (!segfault) sra = ft_strdup(NULL); else sa = segstr;
  320.     segfault = setjmp(restore); if (!segfault) srb =    strdup(NULL); else sb = segstr;
  321.     test_str("strdup (null ptr)", "strdup return", sa, sb, TRUE);
  322. */
  323. printf("\n");
  324.  
  325. //  void    ft_strdel(char **ptr);
  326.     ft_strdel(&sra);
  327. //     strdel(&srb);
  328.     test_str("strdel", "strdel", sra ? C_RED"ERROR"RESET : C_GREEN"OK!"RESET, "(n/a)", FALSE);
  329.  
  330.     segfault = setjmp(restore); if (!segfault) { ft_strdel(NULL); sra = C_GREEN"OK!"RESET; } else sra = segstr;
  331. //  segfault = setjmp(restore); if (!segfault) {    strdel(NULL); srb = C_GREEN"OK!"RESET; } else srb = segstr;
  332.     test_str("strdel (null ptr)", "strdel", sra, "(n/a)", TRUE);
  333.  
  334. printf("\n");
  335.  
  336. //  char    *ft_strchr(char const *str, int c);
  337.     sra = ft_strchr(s1, 'm');
  338.     srb =    strchr(s1, 'm');
  339.     test_str("strchr", "strchr return", sra, srb, FALSE);
  340.  
  341.     sra = ft_strchr(s1, '_');
  342.     srb =    strchr(s1, '_');
  343.     test_str("strchr", "strchr return", sra, srb, FALSE);
  344.  
  345.     sra = ft_strchr(s3, '\0');
  346.     srb =    strchr(s3, '\0');
  347.     test_str("strchr (\\0)", "strchr return", sra, srb, FALSE);
  348.  
  349.     segfault = setjmp(restore); if (!segfault) sra = ft_strchr(NULL, '_'); else sra = segstr;
  350.     segfault = setjmp(restore); if (!segfault) srb =    strchr(NULL, '_'); else srb = segstr;
  351.     test_str("strchr (null ptr)", "strchr return", sra, srb, TRUE);
  352.  
  353. printf("\n");
  354.  
  355. //  char    *ft_strrchr(char const *str, int c);
  356.     sra = ft_strrchr(s1, 'm');
  357.     srb =    strrchr(s1, 'm');
  358.     test_str("strrchr", "strrchr return", sra, srb, FALSE);
  359.  
  360.     sra = ft_strrchr(s1, '_');
  361.     srb =    strrchr(s1, '_');
  362.     test_str("strrchr", "strrchr return", sra, srb, FALSE);
  363.  
  364.     sra = ft_strrchr(s3, '\0');
  365.     srb =    strrchr(s3, '\0');
  366.     test_str("strrchr (\\0)", "strrchr return", sra, srb, FALSE);
  367.  
  368.     segfault = setjmp(restore); if (!segfault) sra = ft_strrchr(NULL, 'm'); else sra = segstr;
  369.     segfault = setjmp(restore); if (!segfault) srb =    strrchr(NULL, 'm'); else srb = segstr;
  370.     test_str("strrchr (null ptr)", "strrchr return", sra, srb, TRUE);
  371.  
  372. printf("\n");
  373.  
  374. //  void    *ft_memchr(const void *ptr, int byte, size_t n);
  375.     na = 0xFFAABBCC; nra = ft_memchr(&na, 0xBB, 4);
  376.     nb = 0xFFAABBCC; nrb =    memchr(&nb, 0xBB, 4);
  377.     test_int("memchr (uint)", "memchr return", *((t_u16*)nra), *((t_u16*)nrb), FALSE);
  378.  
  379.     sra = ft_memchr(s1, 'u', s1_len);
  380.     srb =    memchr(s1, 'u', s1_len);
  381.     test_str("memchr (str) ", "memchr return", sra, srb, FALSE);
  382.  
  383.     segfault = setjmp(restore); if (!segfault) sra = ft_memchr(NULL, 'c', 4); else sa = segstr;
  384.     segfault = setjmp(restore); if (!segfault) srb =    memchr(NULL, 'c', 4); else sb = segstr;
  385.     test_str("memchr (null ptr)", "memchr return", sra, srb, TRUE);
  386.  
  387. printf("\n");
  388.  
  389. //  char    *ft_strstr(const char *str, const char *query);
  390.     sra = ft_strstr(s1, "mou ");
  391.     srb =    strstr(s1, "mou ");
  392.     test_str("strstr", "strstr return", sra, srb, FALSE);
  393.  
  394.     sra = ft_strstr(s2, "??");
  395.     srb =    strstr(s2, "??");
  396.     test_str("strstr", "strstr return", sra, srb, FALSE);
  397.  
  398.     sra = ft_strstr(s2, "???");
  399.     srb =    strstr(s2, "???");
  400.     test_str("strstr", "strstr return", sra, srb, FALSE);
  401.  
  402.     segfault = setjmp(restore); if (!segfault) sra = ft_strstr(NULL, "mou "); else sra = segstr;
  403.     segfault = setjmp(restore); if (!segfault) srb =    strstr(NULL, "mou "); else srb = segstr;
  404.     test_str("strstr (null str)  ", "strstr return", sra, srb, TRUE);
  405.  
  406.     segfault = setjmp(restore); if (!segfault) sra = ft_strstr(s1, NULL); else sra = segstr;
  407.     segfault = setjmp(restore); if (!segfault) srb =    strstr(s1, NULL); else srb = segstr;
  408.     test_str("strstr (null query)", "strstr return", sra, srb, TRUE);
  409.  
  410.     segfault = setjmp(restore); if (!segfault) sra = ft_strstr(NULL, NULL); else sra = segstr;
  411.     segfault = setjmp(restore); if (!segfault) srb =    strstr(NULL, NULL); else srb = segstr;
  412.     test_str("strstr (both null) ", "strstr return", sra, srb, TRUE);
  413.  
  414. printf("\n");
  415.  
  416. //  char    *ft_strnstr(const char *str, const char *query, size_t n);
  417.     sra = ft_strnstr(s1, "ou ", s1_len);
  418.     srb =    strnstr(s1, "ou ", s1_len);
  419.     test_str("strnstr", "strnstr return", sra, srb, FALSE);
  420.  
  421.     sra = ft_strnstr(s1, "ou ", 0);
  422.     srb =    strnstr(s1, "ou ", 0);
  423.     test_str("strnstr (n = 0)", "strnstr return", sra, srb, FALSE);
  424.  
  425.     sra = ft_strnstr(s1, "ou ", 3);
  426.     srb =    strnstr(s1, "ou ", 3);
  427.     test_str("strnstr (n < match)", "strnstr return", sra, srb, FALSE);
  428.  
  429.     segfault = setjmp(restore); if (!segfault) sra = ft_strnstr(NULL, "ou ", s1_len); else sra = segstr;
  430.     segfault = setjmp(restore); if (!segfault) srb =    strnstr(NULL, "ou ", s1_len); else srb = segstr;
  431.     test_str("strnstr (null str)  ", "strnstr return", sra, srb, TRUE);
  432.  
  433.     segfault = setjmp(restore); if (!segfault) sra = ft_strnstr(s1, NULL, s1_len); else sra = segstr;
  434.     segfault = setjmp(restore); if (!segfault) srb =    strnstr(s1, NULL, s1_len); else srb = segstr;
  435.     test_str("strnstr (null query)", "strnstr return", sra, srb, TRUE);
  436.  
  437.     segfault = setjmp(restore); if (!segfault) sra = ft_strnstr(NULL, NULL, 5); else sra = segstr;
  438.     segfault = setjmp(restore); if (!segfault) srb =    strnstr(NULL, NULL, 5); else srb = segstr;
  439.     test_str("strnstr (both null) ", "strnstr return", sra, srb, TRUE);
  440.  
  441. printf("\n");
  442.  
  443. //  int     ft_memcmp(const void *ptr1, const void *ptr2, size_t n);
  444. /*
  445.     na = -0x554433; //little endian in mem as CD BB AA FF
  446.     nb = -0x554F33; //little endian in mem as CD B0 AA FF
  447.     printf("na in mem: {%s}\nnb in mem: {%s}\n", ft_memhex(&na, 4), ft_memhex(&nb, 4));
  448. */
  449.     nra = &na;
  450.     nrb = &nb;
  451.     n = ft_memcmp(nra, nrb, 4);
  452.     num =  memcmp(nra, nrb, 4);
  453.     test_int("memcmp (uint)", "memcmp return", n, num, FALSE);
  454.     //note that some implementations of memcmp can know the type of argument in input,
  455.     //so they return *(int*)nra - *(int*)nrb -> not just analyzing memory as bytes like is said in the man.
  456.  
  457.     na = ft_memcmp(s2, s3, s3_len);
  458.     nb =    memcmp(s2, s3, s3_len);
  459.     test_int("memcmp (str) ", "memcmp return", na, nb, FALSE);
  460.  
  461.     segfault = setjmp(restore); if (!segfault) na = ft_memcmp(NULL, s3, s3_len); else na = 0xFFFFFFFF;
  462.     segfault = setjmp(restore); if (!segfault) nb =    memcmp(NULL, s3, s3_len); else nb = 0xFFFFFFFF;
  463.     test_str("memcmp (null str1)", "memcmp return",
  464.         (na == 0xFFFFFFFF) ? segstr : ft_itoa(na),
  465.         (nb == 0xFFFFFFFF) ? segstr : ft_itoa(nb), TRUE);
  466.  
  467.     segfault = setjmp(restore); if (!segfault) na = ft_memcmp(s2, NULL, s3_len); else na = 0xFFFFFFFF;
  468.     segfault = setjmp(restore); if (!segfault) nb =    memcmp(s2, NULL, s3_len); else nb = 0xFFFFFFFF;
  469.     test_str("memcmp (null str2)", "memcmp return",
  470.         (na == 0xFFFFFFFF) ? segstr : ft_itoa(na),
  471.         (nb == 0xFFFFFFFF) ? segstr : ft_itoa(nb), TRUE);
  472.  
  473.     segfault = setjmp(restore); if (!segfault) na = ft_memcmp(NULL, NULL, s3_len); else na = 0xFFFFFFFF;
  474.     segfault = setjmp(restore); if (!segfault) nb =    memcmp(NULL, NULL, s3_len); else nb = 0xFFFFFFFF;
  475.     test_str("memcmp (both null)", "memcmp return",
  476.         (na == 0xFFFFFFFF) ? segstr : ft_itoa(na),
  477.         (nb == 0xFFFFFFFF) ? segstr : ft_itoa(nb), TRUE);
  478.  
  479. printf("\n");
  480.  
  481. //  int     ft_strcmp(const char *str1, const char *str2);
  482.     na = ft_strcmp(s3, s2);
  483.     nb =    strcmp(s3, s2);
  484.     test_int("strcmp", "strcmp return", na, nb, FALSE);
  485.  
  486.     segfault = setjmp(restore); if (!segfault) na = ft_strcmp(NULL, s2); else na = 0xFFFFFFFF;
  487.     segfault = setjmp(restore); if (!segfault) nb =    strcmp(NULL, s2); else nb = 0xFFFFFFFF;
  488.     test_str("strcmp (null str1)", "strcmp return",
  489.         (na == 0xFFFFFFFF) ? segstr : ft_itoa(na),
  490.         (nb == 0xFFFFFFFF) ? segstr : ft_itoa(nb), TRUE);
  491.  
  492.     segfault = setjmp(restore); if (!segfault) na = ft_strcmp(s3, NULL); else na = 0xFFFFFFFF;
  493.     segfault = setjmp(restore); if (!segfault) nb =    strcmp(s3, NULL); else nb = 0xFFFFFFFF;
  494.     test_str("strcmp (null str2)", "strcmp return",
  495.         (na == 0xFFFFFFFF) ? segstr : ft_itoa(na),
  496.         (nb == 0xFFFFFFFF) ? segstr : ft_itoa(nb), TRUE);
  497.  
  498.     segfault = setjmp(restore); if (!segfault) na = ft_strcmp(NULL, NULL); else na = 0xFFFFFFFF;
  499.     segfault = setjmp(restore); if (!segfault) nb =    strcmp(NULL, NULL); else nb = 0xFFFFFFFF;
  500.     test_str("strcmp (both null)", "strcmp return",
  501.         (na == 0xFFFFFFFF) ? segstr : ft_itoa(na),
  502.         (nb == 0xFFFFFFFF) ? segstr : ft_itoa(nb), TRUE);
  503.  
  504. printf("\n");
  505.  
  506. //  int     ft_strncmp(const char *str1, const char *str2, size_t n);
  507.     na = ft_strncmp(s1, s3, 7);
  508.     nb =    strncmp(s1, s3, 7);
  509.     test_int("strncmp", "strncmp return", na, nb, FALSE);
  510.  
  511.     na = ft_strncmp("abc", "abcdef", 3);
  512.     nb =    strncmp("abc", "abcdef", 3);
  513.     test_int("strncmp", "strncmp return", na, nb, FALSE);
  514.  
  515.     na = ft_strncmp(s2 + 1, s3 + 3, 2);
  516.     nb =    strncmp(s2 + 1, s3 + 3, 2);
  517.     test_int("strncmp", "strncmp return", na, nb, FALSE);
  518.  
  519.     na = ft_strncmp(s2, s3, 0);
  520.     nb =    strncmp(s2, s3, 0);
  521.     test_int("strncmp (n = 0)", "strncmp return", na, nb, FALSE);
  522.  
  523.     segfault = setjmp(restore); if (!segfault) na = ft_strncmp(NULL, s3, 7); else na = 0xFFFFFFFF;
  524.     segfault = setjmp(restore); if (!segfault) nb =    strncmp(NULL, s3, 7); else nb = 0xFFFFFFFF;
  525.     test_str("strncmp (null str1)", "strncmp return",
  526.         (na == 0xFFFFFFFF) ? segstr : ft_itoa(na),
  527.         (nb == 0xFFFFFFFF) ? segstr : ft_itoa(nb), TRUE);
  528.  
  529.     segfault = setjmp(restore); if (!segfault) na = ft_strncmp(s1, NULL, 7); else na = 0xFFFFFFFF;
  530.     segfault = setjmp(restore); if (!segfault) nb =    strncmp(s1, NULL, 7); else nb = 0xFFFFFFFF;
  531.     test_str("strncmp (null str2)", "strncmp return",
  532.         (na == 0xFFFFFFFF) ? segstr : ft_itoa(na),
  533.         (nb == 0xFFFFFFFF) ? segstr : ft_itoa(nb), TRUE);
  534.  
  535.     segfault = setjmp(restore); if (!segfault) na = ft_strncmp(NULL, NULL, 7); else na = 0xFFFFFFFF;
  536.     segfault = setjmp(restore); if (!segfault) nb =    strncmp(NULL, NULL, 7); else nb = 0xFFFFFFFF;
  537.     test_str("strncmp (both null)", "strncmp return",
  538.         (na == 0xFFFFFFFF) ? segstr : ft_itoa(na),
  539.         (nb == 0xFFFFFFFF) ? segstr : ft_itoa(nb), TRUE);
  540.  
  541. printf("\n");
  542.  
  543. //  char    *ft_strcat(char *dest, const char *src);
  544.     sa = (char *)malloc(MALLOC_LEN);
  545.     sb = (char *)malloc(MALLOC_LEN);
  546.     ft_strcpy(sa, "Sponge\0"); sra = ft_strcat(sa, "Bob\0");
  547.     ft_strcpy(sb, "Sponge\0"); srb =    strcat(sb, "Bob\0");
  548.     test_str("strcat", "strcat return", sra, srb, FALSE);
  549.  
  550.     segfault = setjmp(restore); if (!segfault) { ft_strcpy(sa, "Sponge\0"); sra = ft_strcat(NULL, "Bob\0"); } else sra = segstr;
  551.     segfault = setjmp(restore); if (!segfault) { ft_strcpy(sb, "Sponge\0"); srb =    strcat(NULL, "Bob\0"); } else srb = segstr;
  552.     test_str("strcat (null dest)", "strcat return", sra, srb, TRUE);
  553.  
  554.     segfault = setjmp(restore); if (!segfault) { ft_strcpy(sa, "Sponge\0"); sra = ft_strcat(sa, NULL); } else sra = segstr;
  555.     segfault = setjmp(restore); if (!segfault) { ft_strcpy(sb, "Sponge\0"); srb =    strcat(sb, NULL); } else srb = segstr;
  556.     test_str("strcat (null src) ", "strcat return", sra, srb, TRUE);
  557.  
  558.     segfault = setjmp(restore); if (!segfault) { ft_strcpy(sa, "Sponge\0"); sra = ft_strcat(sa, NULL); } else sra = segstr;
  559.     segfault = setjmp(restore); if (!segfault) { ft_strcpy(sb, "Sponge\0"); srb =    strcat(sb, NULL); } else srb = segstr;
  560.     test_str("strcat (both null)", "strcat return", sra, srb, TRUE);
  561.  
  562. printf("\n");
  563.  
  564. //  char    *ft_strncat(char *dest, const char *src, size_t n);
  565.     strcpy(sa, "Sponge\0"); sra = ft_strncat(sa, "Bob", 3);
  566.     strcpy(sb, "Sponge\0"); srb = ft_strncat(sb, "Bob", 3);
  567.     test_str("strncat", "strncat return", sra, srb, FALSE);
  568.  
  569.     strcpy(sa, "Sponge\0"); sra = ft_strncat(sa, "Bobensen", 0);
  570.     strcpy(sb, "Sponge\0"); srb = ft_strncat(sb, "Bobensen", 0);
  571.     test_str("strncat (n = 0)", "strncat return", sra, srb, FALSE);
  572.  
  573.     strcpy(sa, "Sponge\0"); sra = ft_strncat(sa, "Bob", 7);
  574.     strcpy(sb, "Sponge\0"); srb = ft_strncat(sb, "Bob", 7);
  575.     test_str("strncat (n > str)", "strncat return", sra, srb, FALSE);
  576.  
  577.     strcpy(sa, "Sponge\0"); sra = ft_strncat(sa, "Bobensen", 3);
  578.     strcpy(sb, "Sponge\0"); srb = ft_strncat(sb, "Bobensen", 3);
  579.     test_str("strncat (n < str)", "strncat return", sra, srb, FALSE);
  580.  
  581.     segfault = setjmp(restore); if (!segfault) { strcpy(sa, "Sponge\0"); sra = ft_strncat(NULL, "Bobensen", 3); } else sra = segstr;
  582.     segfault = setjmp(restore); if (!segfault) { strcpy(sb, "Sponge\0"); srb = ft_strncat(NULL, "Bobensen", 3); } else srb = segstr;
  583.     test_str("strncat (null dest)", "strncat return", sra, srb, TRUE);
  584.  
  585.     segfault = setjmp(restore); if (!segfault) { strcpy(sa, "Sponge\0"); sra = ft_strncat(sa, NULL, 3); } else sra = segstr;
  586.     segfault = setjmp(restore); if (!segfault) { strcpy(sb, "Sponge\0"); srb = ft_strncat(sb, NULL, 3); } else srb = segstr;
  587.     test_str("strncat (null src) ", "strncat return", sra, srb, TRUE);
  588.  
  589.     segfault = setjmp(restore); if (!segfault) { sra = ft_strncat(NULL, NULL, 3); } else sra = segstr;
  590.     segfault = setjmp(restore); if (!segfault) { srb = ft_strncat(NULL, NULL, 3); } else srb = segstr;
  591.     test_str("strncat (both null)", "strncat return", sra, srb, TRUE);
  592.  
  593. printf("\n");
  594.  
  595. //  size_t  ft_strlcat(char *dest, const char *src, size_t size);
  596.     sa = (char *)ft_memalloc(64);
  597.     sb = (char *)ft_memalloc(64);
  598.  
  599.     strcpy(sa, "Omae wa mou"); la = ft_strlcat(sa, " shindeiru", 5);
  600.     strcpy(sb, "Omae wa mou"); lb =    strlcat(sb, " shindeiru", 5);
  601.     test_int("strlcat", "strlcat return", (t_u32)la, (t_u32)lb, FALSE);
  602.     test_str(NULL,      "strlcat arg",           sa,        sb, FALSE);
  603.  
  604.     strcpy(sa, "Omae wa mou"); la = ft_strlcat(sa, " shindeiru", 15);
  605.     strcpy(sb, "Omae wa mou"); lb =    strlcat(sb, " shindeiru", 15);
  606.     test_int("strlcat (n < str)", "strlcat return", (t_u32)la, (t_u32)lb, FALSE);
  607.     test_str(NULL,                "strlcat arg",           sa,        sb, FALSE);
  608.  
  609.     strcpy(sa, "Omae wa mou"); la = ft_strlcat(sa, " shindeiru", 50);
  610.     strcpy(sb, "Omae wa mou"); lb =    strlcat(sb, " shindeiru", 50);
  611.     test_int("strlcat (n > str)", "strlcat return", (t_u32)la, (t_u32)lb, FALSE);
  612.     test_str(NULL,                "strlcat arg",           sa,        sb, FALSE);
  613.  
  614.     strcpy(sa, "Omae wa mou"); la = ft_strlcat(sa, " shindeiru", 0);
  615.     strcpy(sb, "Omae wa mou"); lb =    strlcat(sb, " shindeiru", 0);
  616.     test_int("strlcat (n = 0)", "strlcat return", (t_u32)la, (t_u32)lb, FALSE);
  617.     test_str(NULL,              "strlcat arg",           sa,        sb, FALSE);
  618.  
  619.     segfault = setjmp(restore); if (!segfault) { strcpy(sa, "Omae wa mou"); la = ft_strlcat(NULL, " shin", 5); sra = sa; } else sra = segstr;
  620.     segfault = setjmp(restore); if (!segfault) { strcpy(sb, "Omae wa mou"); lb =    strlcat(NULL, " shin", 5); srb = sb; } else srb = segstr;
  621.     test_int("strlcat (null dest)", "strlcat return", (t_u32)la, (t_u32)lb, TRUE);
  622.     test_str(NULL,                  "strlcat arg",           sa,        sb, TRUE);
  623.  
  624.     segfault = setjmp(restore); if (!segfault) { strcpy(sa, "Omae wa mou"); la = ft_strlcat(sa, NULL, 5); sra = sa; } else sra = segstr;
  625.     segfault = setjmp(restore); if (!segfault) { strcpy(sb, "Omae wa mou"); lb =    strlcat(sb, NULL, 5); srb = sb; } else srb = segstr;
  626.     test_int("strlcat (null src) ", "strlcat return", (t_u32)la, (t_u32)lb, TRUE);
  627.     test_str(NULL,                  "strlcat arg",           sa,        sb, TRUE);
  628.  
  629.     segfault = setjmp(restore); if (!segfault) { strcpy(sa, "Omae wa mou"); la = ft_strlcat(NULL, NULL, 15); sra = sa; } else sra = segstr;
  630.     segfault = setjmp(restore); if (!segfault) { strcpy(sb, "Omae wa mou"); lb =    strlcat(NULL, NULL, 15); srb = sb; } else srb = segstr;
  631.     test_int("strlcat (both null)", "strlcat return", (t_u32)la, (t_u32)lb, TRUE);
  632.     test_str(NULL,                  "strlcat arg",           sa,        sb, TRUE);
  633.  
  634. printf("\n");
  635.  
  636. //  int     ft_isalpha(int c);
  637. //  int     ft_isdigit(int c);
  638. //  int     ft_isalnum(int c);
  639. //  int     ft_isascii(int c);
  640. //  int     ft_isprint(int c);
  641. //  int     ft_toupper(int c);
  642. //  int     ft_tolower(int c);
  643.     printf(C_BLUE"\nChar functions - all these tests should return '1'.\n");
  644.     printf("(Except after 255, those numbers are undefined behavior).\n");
  645.     printf("(Errors will be displayed if there are any).\n"RESET);
  646.     for (int i = 0; i < 258; i++)
  647.     {
  648.         if (!bool_equals(ft_isalpha(i), isalpha(i))) printf(C_RED"ERROR - ft_isalpha(%d) = %d\n"RESET, i, ft_isalpha(i));
  649.         if (!bool_equals(ft_isdigit(i), isdigit(i))) printf(C_RED"ERROR - ft_isdigit(%d) = %d\n"RESET, i, ft_isdigit(i));
  650.         if (!bool_equals(ft_isalnum(i), isalnum(i))) printf(C_RED"ERROR - ft_isalnum(%d) = %d\n"RESET, i, ft_isalnum(i));
  651.         if (!bool_equals(ft_isascii(i), isascii(i))) printf(C_RED"ERROR - ft_isascii(%d) = %d\n"RESET, i, ft_isascii(i));
  652.         if (!bool_equals(ft_isprint(i), isprint(i))) printf(C_RED"ERROR - ft_isprint(%d) = %d\n"RESET, i, ft_isprint(i));
  653.         if (!bool_equals(ft_toupper(i), toupper(i))) printf(C_RED"ERROR - ft_toupper(%d) = %d\n"RESET, i, ft_toupper(i));
  654.         if (!bool_equals(ft_tolower(i), tolower(i))) printf(C_RED"ERROR - ft_tolower(%d) = %d\n"RESET, i, ft_tolower(i));
  655.     }
  656.  
  657. printf("\n");
  658.  
  659. printf(C_BLUE"The following tests are functions not present in the standard C library.\n");
  660. printf("You may decide to protect them against segfaults or not, just stay consistent."RESET);
  661.  
  662. printf("\n");
  663.  
  664. //  void    ft_strclr(char *str);
  665. /*
  666.     printf("strclr -> "C_GREEN"OK ?"RESET);
  667.     na = ft_strlen(sa);
  668.     ft_strclr(sa);
  669.     for (unsigned int i = 0; i < na; i++)
  670.     {
  671.         if (sa[i]) printf(C_RED"\nERROR - Every char should be '\\0' after calling 'ft_strclr'."RESET);
  672.     }
  673.     sa = (char *)malloc(MALLOC_LEN);
  674.     sb = (char *)malloc(MALLOC_LEN);
  675.     strcpy(sa, s1);
  676. */
  677. printf("\n");
  678.  
  679. //  char    *ft_strrev(const char *str);
  680.     sa = ft_strrev(s1);
  681.     sb = ".uriednihs uom aw eamO";
  682.     test_str("strrev (even len)", "_strrev", sa, sb, FALSE);
  683.  
  684.     sa = ft_strrev(s2);
  685.     sb = "???inaN";
  686.     test_str("strrev (odd len) ", "_strrev", sa, sb, FALSE);
  687.  
  688.     segfault = setjmp(restore); if (!segfault) sra = ft_strrev(NULL); else sra = segstr;
  689. //  segfault = setjmp(restore); if (!segfault) srb =    strrev(NULL); else srb = segstr;
  690.     test_str("strrev (null ptr)", "_strrev", sra, segstr, TRUE);
  691.  
  692. printf("\n");
  693.  
  694. //  int     ft_strequ(const char *str1, const char *str2);
  695.     na = ft_strequ(s1, s2);
  696.     nb =   (strcmp(s1, s2) == 0);
  697.     test_int("strequ", "_strequ", na, nb, FALSE);
  698.  
  699.     na = ft_strequ(sa, s1);
  700.     nb =   (strcmp(sa, s1) == 0);
  701.     test_int("strequ", "_strequ", na, nb, FALSE);
  702.  
  703.     na = ft_strequ(sa, "");
  704.     nb =   (strcmp(sa, "") == 0);
  705.     test_int("strequ (empty str)", "_strequ", na, nb, FALSE);
  706.  
  707.     segfault = setjmp(restore); if (!segfault) na = ft_strequ(NULL, s2); else na = 0xFFFFFFFF;
  708.     test_str("strequ (null str1)", "_strequ", (na == 0xFFFFFFFF) ? segstr : ft_itoa(na), segstr, TRUE);
  709.  
  710.     segfault = setjmp(restore); if (!segfault) na = ft_strequ(s1, NULL); else na = 0xFFFFFFFF;
  711.     test_str("strequ (null str2)", "_strequ", (na == 0xFFFFFFFF) ? segstr : ft_itoa(na), segstr, TRUE);
  712.  
  713.     segfault = setjmp(restore); if (!segfault) na = ft_strequ(NULL, NULL); else na = 0xFFFFFFFF;
  714.     test_str("strequ (both null)", "_strequ", (na == 0xFFFFFFFF) ? segstr : ft_itoa(na), segstr, TRUE);
  715.  
  716. printf("\n");
  717.  
  718. //  int     ft_strnequ(const char *str1, const char *str2, size_t n)
  719.     na = ft_strnequ(s1, s2, 5);
  720.     nb =   (strncmp(s1, s2, 5) == 0);
  721.     test_int("strnequ", "_strnequ", na, nb, FALSE);
  722.  
  723.     na = ft_strnequ(sa, s1, 5);
  724.     nb =   (strncmp(sa, s1, 5) == 0);
  725.     test_int("strnequ", "_strnequ", na, nb, FALSE);
  726.  
  727.     na = ft_strnequ(sa, s1, 50);
  728.     nb =   (strncmp(sa, s1, 50) == 0);
  729.     test_int("strnequ (n > len)", "_strnequ", na, nb, FALSE);
  730.  
  731.     segfault = setjmp(restore); if (!segfault) na = ft_strnequ(NULL, s1, 5); else na = 0xFFFFFFFF;
  732.     test_str("strnequ (null str1)", "_strnequ", (na == 0xFFFFFFFF) ? segstr : ft_itoa(na), segstr, TRUE);
  733.  
  734.     segfault = setjmp(restore); if (!segfault) na = ft_strnequ(s1, NULL, 5); else na = 0xFFFFFFFF;
  735.     test_str("strnequ (null str2)", "_strnequ", (na == 0xFFFFFFFF) ? segstr : ft_itoa(na), segstr, TRUE);
  736.  
  737.     segfault = setjmp(restore); if (!segfault) na = ft_strnequ(NULL, NULL, 5); else na = 0xFFFFFFFF;
  738.     test_str("strnequ (both null)", "_strnequ", (na == 0xFFFFFFFF) ? segstr : ft_itoa(na), segstr, TRUE);
  739.  
  740. printf("\n");
  741.  
  742. //  char    *ft_strsub(const char *str, size_t start, size_t length);
  743.     sra = ft_strsub(s1, 5, 5);
  744.     srb = "wa mo";
  745.     test_str("strsub", "_strsub", sra, srb, FALSE);
  746. //  free(sra);
  747.  
  748.     sra = ft_strsub(s1, 0, 0);
  749.     test_str("strsub (len = 0)", "_strsub", sra, "", FALSE);
  750. //  if (sra && sra != segstr) free(sra);
  751.  
  752.     segfault = setjmp(restore); if (!segfault) sra = ft_strsub(s1, 5, 100); else sra = segstr;
  753.     test_str("strsub (len > str)", "_strsub", sra, NULL, FALSE);
  754.  
  755.     segfault = setjmp(restore); if (!segfault) sra = ft_strsub(s1, 100, 5); else sra = segstr;
  756.     test_str("strsub (offset > str)", "_strsub", sra, NULL, FALSE);
  757.  
  758.     segfault = setjmp(restore); if (!segfault) sra = ft_strsub(NULL, 5, 5); else sra = segstr;
  759.     test_str("strsub (null ptr)", "_strsub", sra, segstr, TRUE);
  760. //  if (sra && sra != segstr) free(sra);
  761.  
  762. printf("\n");
  763.  
  764. //  char    *ft_strjoin(const char *str1, const char *str2);
  765.     sra = ft_strjoin(s1, s2);
  766.     srb = "Omae wa mou shindeiru.Nani???";
  767.     test_str("strjoin", "_strjoin", sra, srb, FALSE);
  768. //  free(sra);
  769.  
  770.     segfault = setjmp(restore); if (!segfault) sra = ft_strjoin(NULL, s2); else sra = segstr;
  771.     test_str("strjoin (null str1)", "_strjoin", sra, segstr, TRUE);
  772. //  if (sra && sra != segstr) free(sra);
  773.  
  774.     segfault = setjmp(restore); if (!segfault) sra = ft_strjoin(s1, NULL); else sra = segstr;
  775.     test_str("strjoin (null str2)", "_strjoin", sra, segstr, TRUE);
  776. //  if (sra && sra != segstr) free(sra);
  777.  
  778.     segfault = setjmp(restore); if (!segfault) sra = ft_strjoin(s1, NULL); else sra = segstr;
  779.     test_str("strjoin (both null)", "_strjoin", sra, segstr, TRUE);
  780. //  if (sra && sra != segstr) free(sra);
  781.  
  782. printf("\n");
  783.  
  784. //  char    *ft_strtrim(const char *str);
  785.     sra = ft_strtrim("\t\n    FOR THE\tHORDE !   \t \n ");
  786.     srb = "FOR THE\tHORDE !";
  787.     test_str("strtrim", "_strtrim", sra, srb, FALSE);
  788. //  free(sra);
  789.  
  790.     sra = ft_strtrim("   swag");
  791.     srb = "swag";
  792.     test_str("strtrim", "_strtrim", sra, srb, FALSE);
  793. //  free(sra);
  794.  
  795.     sra = ft_strtrim("do u even trim bruh\n\n\n\n\t");
  796.     srb = "do u even trim bruh";
  797.     test_str("strtrim", "_strtrim", sra, srb, FALSE);
  798. //  free(sra);
  799.  
  800.     sra = ft_strtrim("\n   \n\t ");
  801.     test_str("strtrim (only whitespace)", "_strtrim", sra, "", FALSE);
  802. //  free(sra);
  803.  
  804.     segfault = setjmp(restore); if (!segfault) sra = ft_strtrim(""); else sra = segstr;
  805.     test_str("strtrim (empty string)", "_strtrim", sra, "", FALSE);
  806. //  if (sra && sra != segstr) free(sra);
  807.  
  808.     segfault = setjmp(restore); if (!segfault) sra = ft_strtrim(NULL); else sra = segstr;
  809.     test_str("strtrim (null ptr)", "_strtrim", sra, segstr, TRUE);
  810. //  if (sra && sra != segstr) free(sra);
  811.  
  812. printf("\n");
  813.  
  814. //  char    **ft_strsplit(const char *str, char c);
  815. /*
  816.     printf("\nstrsplit\n");
  817.     strls = ft_strsplit(s1, ' ');
  818.     printf("ft_strsplit: [");
  819.     for (int i = 0; strls[i]; i++)
  820.         printf("%s%s", strls[i], strls[i + 1] ? ", " : "]\n");
  821.     printf("   Expected: [Omae, wa, mou, shindeiru.]");
  822. */
  823.     char const *split_1[] = { "Omae", "wa", "mou", "shindeiru." };
  824.     test_strsplit("strsplit", FALSE, split_1, s1, ' ');
  825.  
  826.     char const *split_2[] = { "Un ", "nge m", "nge de l", " f", "nge." };
  827.     test_strsplit("strsplit", FALSE, split_2, s3, 'a');
  828.  
  829.     segfault = setjmp(restore); if (!segfault) strls = ft_strsplit(NULL, ' '); else strls = (char **)segstr;
  830.     test_str("strsplit (null ptr)", "_strsplit", (char *)strls, segstr, TRUE);
  831.  
  832. printf("\n");
  833.  
  834. //  void    ft_striter(char *str, void (*f)(char *))
  835.     strcpy(sa, "omAe wA mOu ShINDeIRu.");
  836.     ft_striter(sa, ptrtolower);
  837.     test_str("striter", "_striter", sa, "omae wa mou shindeiru.", FALSE);
  838.  
  839.     strcpy(sa, "omAe wA mOu ShINDeIRu.");
  840.     segfault = setjmp(restore); if (!segfault) ft_striter(sra, NULL); else sra = segstr;
  841.     test_str("striter (null f)   ", "_striter", sra, segstr, TRUE);
  842.  
  843.     segfault = setjmp(restore); if (!segfault) { ft_striter(NULL, ptrtolower); sra = NULL; } else sra = segstr;
  844.     test_str("striter (null str) ", "_striter", sra, segstr, TRUE);
  845.  
  846.     segfault = setjmp(restore); if (!segfault) { ft_striter(NULL, NULL); sra = NULL; } else sra = segstr;
  847.     test_str("striter (both null)", "_striter", sra, segstr, TRUE);
  848.  
  849. printf("\n");
  850.  
  851. //  void    ft_striteri(char *str, void (*f)(unsigned int, char *));
  852.     strcpy(sa, "OMAE WA MOU SHINDEIRU.");
  853.     ft_striteri(sa, ptrtolower_1on2);
  854.     test_str("striteri", "_striteri", sa, "oMaE Wa mOu sHiNdEiRu.", FALSE);
  855.  
  856.     strcpy(sa, "OMAE WA MOU SHINDEIRU.");
  857.     segfault = setjmp(restore); if (!segfault) ft_striteri(sra, NULL); else sra = segstr;
  858.     test_str("striteri (null f)   ", "_striteri", sra, segstr, TRUE);
  859.  
  860.     segfault = setjmp(restore); if (!segfault) { ft_striteri(NULL, ptrtolower_1on2); sra = NULL; } else sra = segstr;
  861.     test_str("striteri (null str) ", "_striteri", sra, segstr, TRUE);
  862.  
  863.     segfault = setjmp(restore); if (!segfault) { ft_striteri(NULL, NULL); sra = NULL; } else sra = segstr;
  864.     test_str("striteri (both null)", "_striteri", sra, segstr, TRUE);
  865.  
  866. printf("\n");
  867.  
  868. //  char    *ft_strmap(const char *str, char (*f)(char));
  869.     sa = ft_strmap("omAe wA mOu ShINDeIRu.", toupper_chr);
  870.     test_str("strmap", "_strmap", sa, "OMAE WA MOU SHINDEIRU.", FALSE);
  871.  
  872.     segfault = setjmp(restore); if (!segfault) sa = ft_strmap("omAe wA mOu ShINDeIRu.", NULL); else sa = segstr;
  873.     test_str("strmap (null f)   ", "_strmap", sa, segstr, TRUE);
  874.  
  875.     segfault = setjmp(restore); if (!segfault) sa = ft_strmap(NULL, toupper_chr); else sa = segstr;
  876.     test_str("strmap (null str) ", "_strmap", sa, segstr, TRUE);
  877.  
  878.     segfault = setjmp(restore); if (!segfault) sa = ft_strmap(NULL, NULL); else sa = segstr;
  879.     test_str("strmap (both null)", "_strmap", sa, segstr, TRUE);
  880.  
  881. printf("\n");
  882.  
  883. //  char    *ft_strmapi(const char *str, char (*f)(unsigned int, char));
  884.     sa = ft_strmapi("omae wa mou shindeiru.", toupper_1on2);
  885.     test_str("strmapi", "_strmapi", sa, "oMaE Wa mOu sHiNdEiRu.", FALSE);
  886.  
  887.     segfault = setjmp(restore); if (!segfault) sa = ft_strmapi("omAe wA mOu ShINDeIRu.", NULL); else sa = segstr;
  888.     test_str("strmapi (null f)   ", "_strmapi", sa, segstr, TRUE);
  889.  
  890.     segfault = setjmp(restore); if (!segfault) sa = ft_strmapi(NULL, toupper_1on2); else sa = segstr;
  891.     test_str("strmapi (null str) ", "_strmapi", sa, segstr, TRUE);
  892.  
  893.     segfault = setjmp(restore); if (!segfault) sa = ft_strmapi(NULL, NULL); else sa = segstr;
  894.     test_str("strmapi (both null)", "_strmapi", sa, segstr, TRUE);
  895.  
  896. printf("\n");
  897.  
  898. /*============== List functions ===============*/
  899.     t_list **a_lst;
  900.     t_list *lst_0;
  901.     t_list *lst_1;
  902.     t_list *lst_2;
  903.     t_list *lst_3;
  904.     t_list *lst_4;
  905.     char const *expect[]       = { "Omae", " wa ", "mou ", "shindeiru.", NULL };
  906.     char const *expect_upper[] = { "OMAE", " WA ", "MOU ", "SHINDEIRU.", NULL };
  907.     char const *expect_lower[] = { "omae", " wa ", "mou ", "shindeiru.", NULL };
  908.  
  909. //  t_list  *ft_lstnew(void const *content, size_t content_size);
  910.     lst_0 = ft_lstnew("Omae", 5);
  911.     lst_1 = ft_lstnew(" wa ", 5);
  912.     lst_2 = ft_lstnew("mou ", 5);
  913.     lst_3 = ft_lstnew("shindeiru.", 11);
  914.     test_int("lstnew", "_lstnew->content_size", lst_0->content_size,    5, FALSE);
  915.     test_str(NULL,     "_lstnew->content",      lst_0->content, expect[0], FALSE);
  916.     test_int(NULL,     "_lstnew->content_size", lst_1->content_size,    5, FALSE);
  917.     test_str(NULL,     "_lstnew->content",      lst_1->content, expect[1], FALSE);
  918.     test_int(NULL,     "_lstnew->content_size", lst_2->content_size,    5, FALSE);
  919.     test_str(NULL,     "_lstnew->content",      lst_2->content, expect[2], FALSE);
  920.     test_int(NULL,     "_lstnew->content_size", lst_3->content_size,   11, FALSE);
  921.     test_str(NULL,     "_lstnew->content",      lst_3->content, expect[3], FALSE);
  922.  
  923.     segfault = setjmp(restore); if (!segfault) lst_4 = ft_lstnew(NULL, 5); else lst_4->content = segstr;
  924.     test_str("lstnew (null ptr)", "_lstnew->content", lst_4->content, segstr, TRUE);
  925.  
  926. printf("\n");
  927.  
  928. //  void    ft_lstadd(t_list **alst, t_list *new_elem);
  929.     a_lst = &lst_3;
  930.     ft_lstadd(a_lst, lst_2);
  931.     ft_lstadd(a_lst, lst_1);
  932.     ft_lstadd(a_lst, lst_0);
  933.     test_lst("lstadd", "lstadd", lst_0, expect, FALSE);
  934.  
  935. printf("\n");
  936.  
  937. //  t_list  *ft_lstmap(t_list *lst, t_list *(*f)(t_list *elem));
  938.     segfault = setjmp(restore); if (!segfault) *a_lst = ft_lstmap(*a_lst, ft_lstmap_toupper); else *a_lst = NULL;
  939.     test_lst("lstmap", "lstmap", *a_lst, expect_upper, FALSE);
  940.  
  941. printf("\n");
  942.  
  943. //  ft_lstiter(t_list *lst, void (*f)(t_list *elem));
  944.     //ft_lstiter(*a_lst, ft_lstiter_tolower);
  945.     //test_lst("lstiter", "lstiter", a_lst, expect_lower, FALSE);
  946.  
  947. printf("\n");
  948. /*
  949.     if (LIBFT_EXTRA_TD)
  950.     {
  951.  
  952.     //ft_strlcpy(char *dest, char *src, size_t size);
  953.         printf(C_BLUE"\nstrlcpy\n"RESET);
  954.         sa[0] = '\0';
  955.         printf("ft_strlcpy return:%lu\n   strlcpy return: %d\n", (t_u64)ft_strlcpy(sa, "Omae wa mou shindeiru", 15), 21);
  956.         printf("ft_strlcpy arg:%s\n   strlcpy arg:%s\n", sa, "Omae wa mou sh"); //faut pas oublier \0
  957.  
  958.  
  959.     //ft_digits(int n); ft_digits_base(int n, int base);
  960.         printf("\nft_digits: %d | Expected: %d\n", ft_digits(-2147483648), 10);
  961.         printf("\nft_digits: %d | Expected: %d\n", ft_digits_base(-2147483648, 2), 32);
  962.  
  963.     //ft_memhex(const void *s, size_t n);
  964.         free(sa);
  965.         n = -2147483648;
  966.         sa = ft_memhex(&n, 4);
  967.         printf("\nft_memhex : {%s}\nExpected : 00000080 (little endian)\n", sa);
  968.  
  969.     //ft_strhex(const char *s)
  970.         free(sa);
  971.         sa = ft_strhex("abcdefgh");
  972.         printf("\nft_strhex : {%s}\nExpected : 6162636465666768\n", sa);
  973.  
  974.     //ft_split(char *str, char *sep_chars);     void    ft_putstrls(const char **strls); void   ft_putstrls_fd(const char **strls, int fd);
  975.         ft_del_strls(strls);
  976.         strls = ft_split("\nOmae\t  \nwa   mou@@shindeiru.  !!@@", " \n\t@!");
  977.         ft_putstr("\nft_split:\n");
  978.         ft_putstrls(strls);
  979.         ft_putstr("\nExpected:\nOmae\nwa\nmou\nshindeiru.\n");
  980.  
  981.     //ft_strls_join(char ** strls, char* sep)
  982.         free(sa);
  983.         sa = ft_strlsjoin(strls, "---KWEEEN---");
  984.         ft_putstr("\nft_strlsjoin: ");
  985.         ft_putstr(sa);
  986.         ft_putstr("\nExpected: Omae---KWEEEN---wa---KWEEEN---mou---KWEEEN---shindeiru.\n");
  987.  
  988.     //ft_strdivide(char *str, size_t n);
  989.         ft_del_strls(strls);
  990.         strls = ft_strdivide(sa, 10);
  991.         ft_putstr("\nft_strdivide:\n");
  992.         ft_putstrls(strls);
  993.         ft_putstr("\nExpected:\nOmae---KWE\nEEN---wa--\n-KWEEEN---\nmou---KWEE\nEN---shind\neiru.\n");
  994.  
  995.     //  void    ft_lstappend(t_list **alst, t_list *new_elem);
  996.         t_list  **mixed_list;
  997.         mixed_list = a_slst;
  998.         ft_putstr("\nft_lstappend (mind the little endianness and the fact that lst was listiter(abs)) :\n");
  999.         ft_lstappend(mixed_list, *a_ilst);
  1000.         ft_lstiter(*mixed_list, ft_puthex_llstelem);
  1001.         ft_putstr("\nExpected:\n4F 6D 61 65 00\n20 77 61 20 00\n6D 6F 75 20 00\n73 68 69 6E 64 65 69 72 75 2E 00\n00 00 00 00\n00 00 00 00\n9A 02 00 00\n09 03 00 00\n2D 00 00 00\n");
  1002.  
  1003.     //  int     ft_lstsize(t_list *lst);
  1004.         ft_putstr("\nft_lstsize : ");
  1005.         ft_putnbr(ft_lstsize(*mixed_list));
  1006.         ft_putstr("\nExpected : 9\n");
  1007.  
  1008.     //  void    *ft_lstfold(t_list *lst, void *acc, void *(*f)(void *, void *));
  1009.         ft_putstr("\nft_lstfold : ");
  1010.         n = 0;
  1011.         ft_lstfold(*a_ilst, &n, ft_add);
  1012.         ft_putnbr(n);
  1013.         ft_putstr("\nExpected : 1488\n");
  1014.  
  1015.     //  void    ft_lstdelone(t_list **alst, void (*del)(void *, size_t));
  1016.         ft_putstr("\nft_lstdelone :\n");
  1017.         t_list *tmp = (*a_ilst)->next;
  1018.         ft_lstdelone(a_ilst, ft_delete);
  1019.         //alternative fix without lstget => (*mixed_list)->next->next->next->next = 0;
  1020.         ft_lstget(*mixed_list, 3)->next = 0;
  1021.         ft_lstappend(mixed_list, tmp);
  1022.         ft_lstiter(*mixed_list, ft_puthex_llstelem);
  1023.         ft_putstr("\nExpected:\n4F 6D 61 65 00\n20 77 61 20 00\n6D 6F 75 20 00\n73 68 69 6E 64 65 69 72 75 2E 00\n00 00 00 00\n9A 02 00 00\n09 03 00 00\n2D 00 00 00\n");
  1024.  
  1025.         if (*a_ilst) // || *a_ilst || (*a_ilst)->content)
  1026.         {
  1027.             ft_putstr_fd("Error deleting with ft_lstdel\n", 2);
  1028.         }
  1029.         else
  1030.         {
  1031.             ft_putstr("Function seems to work; should still check for leaks.\n");
  1032.         }
  1033.    
  1034.     //  void    ft_lstdel(t_list **alst, void (*del)(void *, size_t));
  1035.         ft_putstr("\nft_lstdel :\n");  
  1036.         ft_lstdel(mixed_list, ft_delete);
  1037.  
  1038.         if (*mixed_list) // || *mixed_list || (*mixed_list)->content)
  1039.         {
  1040.             ft_putstr_fd("Error deleting with ft_lstdel\n", 2);
  1041.         }
  1042.         else
  1043.         {
  1044.             ft_putstr("Function seems to work; should still check for leaks.\n");
  1045.         }
  1046.     }
  1047.     else
  1048.     {
  1049.     //  void    ft_lstdelone(t_list **alst, void (*del)(void *, size_t));
  1050.         ft_putstr("\nft_lstdelone :\n");
  1051.         t_list *tmp = (*a_ilst)->next;
  1052.         ft_lstdelone(a_ilst, ft_delete);
  1053.         ft_lstiter(tmp, ft_puthex_llstelem);
  1054.         ft_putstr("\nExpected:\n00 00 00 00\n9A 02 00 00\n09 03 00 00\n2D 00 00 00\n");
  1055.         if (*a_ilst) // || *a_ilst || (*a_ilst)->content)
  1056.         {
  1057.             ft_putstr_fd("Error deleting with ft_lstdel\n", 2);
  1058.         }
  1059.         else
  1060.         {
  1061.             ft_putstr("Function seems to work; should still check for leaks.\n");
  1062.         }
  1063.    
  1064.     //  void    ft_lstdel(t_list **alst, void (*del)(void *, size_t));
  1065.         ft_putstr("\nft_lstdel :\n");  
  1066.         ft_lstdel(&tmp, ft_delete);
  1067.         ft_lstdel(a_slst, ft_delete);
  1068.         if (*a_slst || tmp) // || *a_slst || (*a_ilst)->content || tmp->content)
  1069.         {
  1070.             ft_putstr_fd("Error deleting with ft_lstdel\n", 2);
  1071.         }
  1072.         else
  1073.         {
  1074.             ft_putstr("Function seems to work; should still check for leaks.\n");
  1075.         }
  1076.     }
  1077. */
  1078.     return (0);
  1079. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!