├── ressources ├── example.png └── header.png ├── main_bonus.c ├── main_mandatory.c ├── main_all.c ├── README.md ├── utils.c ├── expand.c ├── tester.sh ├── bonus.c └── mandatory.c /ressources/example.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/gmarcha/42_libft_tester/HEAD/ressources/example.png -------------------------------------------------------------------------------- /ressources/header.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/gmarcha/42_libft_tester/HEAD/ressources/header.png -------------------------------------------------------------------------------- /main_bonus.c: -------------------------------------------------------------------------------- 1 | #include "bonus.c" 2 | 3 | int main(void) 4 | { 5 | bonus(); 6 | END("@2021, 42 Libft Tester, bonus part."); 7 | return (0); 8 | } -------------------------------------------------------------------------------- /main_mandatory.c: -------------------------------------------------------------------------------- 1 | #include "mandatory.c" 2 | 3 | int main(void) 4 | { 5 | mandatory(); 6 | END("@2021, 42 Libft Tester, mandatory part."); 7 | return (0); 8 | } -------------------------------------------------------------------------------- /main_all.c: -------------------------------------------------------------------------------- 1 | #include "mandatory.c" 2 | #include "bonus.c" 3 | #include "expand.c" 4 | 5 | int main(void) 6 | { 7 | mandatory(); 8 | bonus(); 9 | expand(); 10 | END("@2021, 42 Libft Tester, all parts."); 11 | return (0); 12 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # 42 Libft Tester 2 | A simple step-by-step tester to C 42 Library. (Outdated) 3 | 4 | # How to use it ? 5 | - Clone the repository in your Libft directory, go in the tester directory, and run `tester.sh` with an argument: 6 | ``` 7 | ./tester.sh mand 8 | ./tester.sh bonus 9 | ./tester.sh all 10 | ``` 11 | - Press Enter to perform each test. 12 | - To add tests for external functions, write asserts in `expand.c`, and change function `expand` in same file. 13 | 14 | ![Begin with check for forbidden functions and norminette.](/ressources/header.png) 15 | ![An example of an ouput.](/ressources/example.png) 16 | -------------------------------------------------------------------------------- /utils.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | void printf_rgb(char *rgb, char *format, ...) 8 | { 9 | va_list args; 10 | 11 | printf("\033[38;2;%sm", rgb); 12 | va_start(args, format); 13 | vprintf(format, args); 14 | va_end(args); 15 | printf("\033[0m"); 16 | } 17 | 18 | void out_cmp(void) 19 | { 20 | int fd_test = open("out_test", O_RDONLY); 21 | int fd_user = open("out_user", O_RDONLY); 22 | char ret_test[4096] = {0}; 23 | char ret_user[4096] = {0}; 24 | 25 | read(fd_test, ret_test, 4096); 26 | read(fd_user, ret_user, 4096); 27 | if (strcmp(ret_test, ret_user) == 0) 28 | printf_rgb("57;181;74", "$> OK!\n"); 29 | else 30 | printf_rgb("222;56;43", "$> KO! invalid diff.\n"); 31 | close(fd_test); 32 | close(fd_user); 33 | } 34 | -------------------------------------------------------------------------------- /expand.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include "../libft.h" 11 | 12 | #define S1 "============================================================================================================================================" 13 | #define S2 "--------------------------------------------------------------------------------------------------------------------------------------------" 14 | #define S3 "____________________________________________________________________________________________________________________________________________" 15 | #define SEP printf_rgb("255;199;6", S2"\n") 16 | #define HEADER(str) getchar();printf_rgb("136;23;152;1", "\n"S3"\n\n%140s\n", str) 17 | #define END(str) printf_rgb("136;23;152;3", "\n%140s\n%140s\n%140s\n", "Test finished.", str, "https://github.com/gmarcha") 18 | 19 | void printf_rgb(char *rgb, char *format, ...); 20 | 21 | void assert_ft_example(void) 22 | { 23 | 24 | } 25 | 26 | void expand(void) 27 | { 28 | void (*test[1])() = { 29 | assert_ft_example 30 | }; 31 | for (int i = 0; i < 1; i++) 32 | if (fork() == 0) 33 | { 34 | test[i](); 35 | exit(0); 36 | } 37 | else 38 | wait(0); 39 | } -------------------------------------------------------------------------------- /tester.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash 2 | 3 | SEP="============================================================================================================================================" 4 | # MAND="ft_memset.c ft_bzero.c ft_memcpy.c ft_memccpy.c ft_memmove.c ft_memchr.c ft_memcmp.c ft_strlen.c ft_isalpha.c ft_isdigit.c ft_isalnum.c ft_isascii.c ft_isprint.c ft_toupper.c ft_tolower.c ft_strchr.c ft_strrchr.c ft_strncmp.c ft_strlcpy.c ft_strlcat.c ft_strnstr.c ft_atoi.c ft_calloc.c ft_strdup.c ft_substr.c ft_strjoin.c ft_strtrim.c ft_split.c ft_itoa.c ft_strmapi.c ft_putchar_fd.c ft_putstr_fd.c ft_putendl_fd.c ft_putnbr_fd.c" 5 | # BONUS="ft_lstnew.c ft_lstadd_front.c ft_lstsize.c ft_lstlast.c ft_lstadd_back.c ft_lstdelone.c ft_lstclear.c ft_lstiter.c ft_lstmap.c" 6 | FILES="../*.c" 7 | 8 | if [ -z $1 ]; then 9 | printf "usage: ./tester.sh [mand/bonus/all]\n" 10 | printf "\t\t-m, --mand: mandatory part only\n" 11 | printf "\t\t-b, --bonus: bonus part only\n" 12 | printf "\t\t-a, --all: both of them\n" 13 | exit 1 14 | fi 15 | if [ $1 != "mand" ] && [ $1 != "bonus" ] && [ $1 != "all" ] && [ $1 != "m" ] && [ $1 != "b" ] && [ $1 != "a" ]; then 16 | printf "error: invalid args.\n" 17 | exit 1 18 | fi 19 | if [ $1 = "mand" ] || [ $1 = "m" ]; then 20 | MAIN="main_mandatory.c utils.c" 21 | fi 22 | if [ $1 = "bonus" ] || [ $1 = "b" ]; then 23 | MAIN="main_bonus.c utils.c" 24 | fi 25 | if [ $1 = "all" ] || [ $1 = "a" ]; then 26 | MAIN="main_all.c utils.c" 27 | fi 28 | 29 | printf "\033[38;2;136;23;152;1;3m$SEP\n\n" 30 | echo " ██╗ ██╗██████╗ ██╗ ██╗██████╗ ███████╗████████╗ ████████╗███████╗███████╗████████╗███████╗██████╗ " 31 | echo " ██║ ██║╚════██╗ ██║ ██║██╔══██╗██╔════╝╚══██╔══╝ ╚══██╔══╝██╔════╝██╔════╝╚══██╔══╝██╔════╝██╔══██╗" 32 | echo " ███████║ █████╔╝ ██║ ██║██████╔╝█████╗ ██║ ██║ █████╗ ███████╗ ██║ █████╗ ██████╔╝" 33 | echo " ╚════██║██╔═══╝ ██║ ██║██╔══██╗██╔══╝ ██║ ██║ ██╔══╝ ╚════██║ ██║ ██╔══╝ ██╔══██╗" 34 | echo " ██║███████╗ ███████╗██║██████╔╝██║ ██║ ██║ ███████╗███████║ ██║ ███████╗██║ ██║" 35 | echo " ╚═╝╚══════╝ ╚══════╝╚═╝╚═════╝ ╚═╝ ╚═╝ ╚═╝ ╚══════╝╚══════╝ ╚═╝ ╚══════╝╚═╝ ╚═╝" 36 | printf "\n$SEP\n\nForbidden functions:\n\n\033[0;38;2;222;56;43m" 37 | FUN=("[^_]open(" "[^_]read(" "[^_]close(" 38 | "[^_]printf(" "[^_]memset(" "[^_]bzero(" "[^_]memcpy(" "[^_]memccpy(" "[^_]memmove(" "[^_]memchr(" "[^_]memcmp(" 39 | "[^_]strlen(" "[^_]isspace(" "[^_]isupper(" "[^_]islower(" "[^_]isalpha(" "[^_]isdigit(" "[^_]isalnum(" "[^_]isascii(" 40 | "[^_]isprint(" "[^_]toupper(" "[^_]tolower(" "[^_]strchr(" "[^_]strrchr(" "[^_]strcmp(" "[^_]strncmp(" "[^_]strcpy(" 41 | "[^_]strncpy(" "[^_]strlcpy(" "[^_]strcat(" "[^_]strncat(" "[^_]strlcat(" "[^_]strstr(" "[^_]strnstr(" "[^_]atoi(" 42 | "[^_]atol(" "[^_]itoa(" "[^_]calloc(" "[^_]realloc(" "[^_]strdup(") 43 | K=0 44 | for element in ${FUN[@]}; do 45 | grep -nH "$element" $FILES 46 | if [ $? -eq 0 ]; then 47 | ((K++)) 48 | fi 49 | done 50 | if [ $K -eq 0 ]; then 51 | printf "\033[38;2;57;181;74mCheat free.\n" 52 | fi 53 | printf "\033[38;2;136;23;152;1;3m\n$SEP\n\nNorm test:\n\n\033[0;38;2;57;181;74m" 54 | norminette libft.h $FILES | grep "OK" 55 | printf "\n\033[0;38;2;222;56;43m" 56 | norminette libft.h $FILES | grep "Error" 57 | printf "\n\033[0m" 58 | gcc -Wall -Wextra -Werror -fsanitize=address $MAIN $FILES 59 | ./a.out 60 | rm -rf a.out -------------------------------------------------------------------------------- /bonus.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include "../libft.h" 11 | 12 | #define S1 "============================================================================================================================================" 13 | #define S2 "--------------------------------------------------------------------------------------------------------------------------------------------" 14 | #define S3 "____________________________________________________________________________________________________________________________________________" 15 | #define SEP printf_rgb("255;199;6", S2"\n") 16 | #define HEADER(str) getchar();printf_rgb("136;23;152;1", "\n"S3"\n\n%140s\n", str) 17 | #define END(str) printf_rgb("136;23;152;3", "\n%140s\n%140s\n%140s\n", "Test finished.", str, "https://github.com/gmarcha") 18 | 19 | void printf_rgb(char *rgb, char *format, ...); 20 | 21 | void out_cmp(void); 22 | 23 | t_list *test_lstnew(void *content) 24 | { 25 | t_list *node; 26 | 27 | node = (t_list *)malloc(sizeof(t_list)); 28 | if (node == 0) 29 | return (0); 30 | node->content = content; 31 | node->next = 0; 32 | return (node); 33 | } 34 | 35 | void test_lstadd_front(t_list **alst, t_list *new) 36 | { 37 | t_list *node; 38 | 39 | if (!new) 40 | return ; 41 | node = *alst; 42 | *alst = new; 43 | (*alst)->next = node; 44 | } 45 | 46 | int test_lstsize(t_list *lst) 47 | { 48 | int i; 49 | 50 | i = 0; 51 | while (lst) 52 | { 53 | lst = lst->next; 54 | i++; 55 | } 56 | return (i); 57 | } 58 | 59 | t_list *test_lstlast(t_list *lst) 60 | { 61 | if (!lst) 62 | return (0); 63 | while (lst->next) 64 | lst = lst->next; 65 | return (lst); 66 | } 67 | 68 | void test_lstadd_back(t_list **alst, t_list *new) 69 | { 70 | t_list *node; 71 | 72 | if (!alst || !new) 73 | return ; 74 | if (!*alst) 75 | { 76 | *alst = new; 77 | return ; 78 | } 79 | node = *alst; 80 | while (node->next) 81 | node = node->next; 82 | node->next = new; 83 | } 84 | 85 | void test_lstdelone(t_list *lst, void (*del)(void*)) 86 | { 87 | if (!lst) 88 | return ; 89 | if (lst->content) 90 | del(lst->content); 91 | free(lst); 92 | } 93 | 94 | void test_lstclear(t_list **lst, void (*del)(void*)) 95 | { 96 | t_list *tmp; 97 | t_list *node; 98 | 99 | if (!*lst) 100 | return ; 101 | node = *lst; 102 | while (node) 103 | { 104 | tmp = node; 105 | node = node->next; 106 | test_lstdelone(tmp, del); 107 | } 108 | *lst = 0; 109 | } 110 | 111 | void test_lstiter(t_list *lst, void (*f)(void *)) 112 | { 113 | if (!lst) 114 | return ; 115 | while (lst) 116 | { 117 | f(lst->content); 118 | lst = lst->next; 119 | } 120 | } 121 | 122 | void *test_freelst(t_list *lst, void (*del)(void *)) 123 | { 124 | t_list *tmp; 125 | 126 | while (lst) 127 | { 128 | tmp = lst; 129 | lst = lst->next; 130 | if (tmp->content) 131 | del(tmp->content); 132 | free(tmp); 133 | } 134 | return (0); 135 | } 136 | 137 | t_list *test_lstmap(t_list *lst, void *(*f)(void *), void (*del)(void *)) 138 | { 139 | t_list *new; 140 | t_list *node; 141 | 142 | if (!lst) 143 | return (0); 144 | new = (t_list *)malloc(sizeof(t_list)); 145 | if (new == 0) 146 | return (0); 147 | new->content = f(lst->content); 148 | new->next = 0; 149 | node = new; 150 | lst = lst->next; 151 | while (lst) 152 | { 153 | node->next = (t_list *)malloc(sizeof(t_list)); 154 | if (node->next == 0) 155 | return (test_freelst(new, del)); 156 | node->next->content = f(lst->content); 157 | node->next->next = 0; 158 | node = node->next; 159 | lst = lst->next; 160 | } 161 | return (new); 162 | } 163 | 164 | void endl(void *data) 165 | { 166 | char *str; 167 | int i; 168 | 169 | str = data; 170 | i = 0; 171 | while (str[i]) 172 | i++; 173 | write(1, str, i); 174 | write(1, "\n", 1); 175 | } 176 | 177 | void destroy(t_list *lst) 178 | { 179 | t_list *tmp; 180 | 181 | while (lst) 182 | { 183 | tmp = lst; 184 | lst = lst->next; 185 | free(tmp); 186 | } 187 | } 188 | 189 | void lst_ret_cmp(t_list *ret_test, t_list *ret_user) 190 | { 191 | int ret_cmp; 192 | 193 | ret_cmp = (ret_test == 0 || ret_user == 0) ? (ret_test == ret_user) ? 0 : 1 : (ret_test->content == 0 || ret_user->content == 0) ? (ret_test->content == ret_user->content) ? 0 : 1 : strcmp(ret_test->content, ret_user->content); 194 | if (ret_cmp == 0) 195 | printf_rgb("57;181;74", "$> OK!\n"); 196 | else 197 | { 198 | printf_rgb("222;56;43", "$> KO! expected: "); 199 | if (ret_test) 200 | printf_rgb("222;56;43", "%20s", ret_test->content); 201 | else 202 | printf_rgb("222;56;43", "%20s", "no list element"); 203 | printf_rgb("222;56;43", ", result: "); 204 | if (ret_user) 205 | printf_rgb("222;56;43", "%20s", ret_user->content); 206 | else 207 | printf_rgb("222;56;43", "%20s", "no list element"); 208 | printf_rgb("222;56;43", ".\n"); 209 | } 210 | } 211 | 212 | void lst_out_cmp(t_list *ret_test, t_list *ret_user) 213 | { 214 | int k; 215 | 216 | if (ret_test != 0 && ret_user != 0) 217 | { 218 | k = 1; 219 | while (ret_test || ret_user) 220 | { 221 | if (ret_test != 0 && ret_user != 0) 222 | { 223 | if (strcmp(ret_test->content, ret_user->content) == 0) 224 | printf_rgb("57;181;74", "$> Element %d : OK!\n", k); 225 | else 226 | printf_rgb("222;56;43", "$> Element %d : KO! expected: %6s, result: %6s.\n", k, ret_test->content, ret_user->content); 227 | } 228 | else 229 | printf_rgb("222;56;43", "$> Element %d : KO! invalid element.\n", k); 230 | k++; 231 | if (ret_test) 232 | ret_test = ret_test->next; 233 | if (ret_user) 234 | ret_user = ret_user->next; 235 | } 236 | } 237 | else 238 | printf_rgb("222;56;43", "$> KO! invalid list."); 239 | } 240 | 241 | void assert_ft_lstnew(void) 242 | { 243 | char *strs[] = {"Hello World!", "", 0}; 244 | t_list *ret_test; 245 | t_list *ret_user; 246 | 247 | HEADER("assert_ft_lstnew"); 248 | for (int i = 0; i < 3; i++) 249 | { 250 | if (fork() == 0) 251 | { 252 | SEP; 253 | printf_rgb("255;199;6", "test: str = %13s.\n", strs[i]); 254 | ret_test = test_lstnew(strs[i]); 255 | ret_user = ft_lstnew(strs[i]); 256 | lst_ret_cmp(ret_test, ret_user); 257 | free(ret_test); 258 | free(ret_user); 259 | exit(0); 260 | } 261 | else 262 | wait(0); 263 | } 264 | } 265 | 266 | void assert_ft_lstadd(char *name, void (*f)(t_list **, t_list *), void (*ft_f)(t_list **, t_list *)) 267 | { 268 | char *strs[] = {"Third", "Second", "First", 0}; 269 | t_list *ret_test = 0; 270 | t_list *ret_user = 0; 271 | 272 | HEADER(name); 273 | SEP; 274 | printf_rgb("255;199;6", "test: add three elements.\n"); 275 | for (int i = 0; strs[i]; i++) 276 | { 277 | f(&ret_test, test_lstnew(strs[i])); 278 | ft_f(&ret_user, test_lstnew(strs[i])); 279 | } 280 | lst_out_cmp(ret_test, ret_user); 281 | destroy(ret_test); 282 | destroy(ret_user); 283 | } 284 | 285 | void assert_ft_lstadd_front(void) 286 | { 287 | assert_ft_lstadd("assert_ft_lstadd_front", test_lstadd_front, ft_lstadd_front); 288 | } 289 | 290 | void assert_ft_lstadd_back(void) 291 | { 292 | assert_ft_lstadd("assert_ft_lstadd_back", test_lstadd_back, ft_lstadd_back); 293 | } 294 | 295 | void assert_ft_lstsize(void) 296 | { 297 | char **arrs[] = {(char *[]){"Third", "Second", "First", 0}, 298 | (char *[]){"", 0}, 299 | (char *[]){0}, 300 | 0}; 301 | t_list *test = 0; 302 | int ret_test = 0; 303 | int ret_user = 0; 304 | 305 | HEADER("assert_ft_lstsize"); 306 | for (int i = 0; arrs[i]; i++) 307 | { 308 | if (fork() == 0) 309 | { 310 | SEP; 311 | for (int j = 0; arrs[i][j]; j++) 312 | test_lstadd_front(&test, test_lstnew(arrs[i][j])); 313 | printf_rgb("255;199;6", "test: list of size %d.\n", ret_test = test_lstsize(test)); 314 | ret_user = ft_lstsize(test); 315 | if (ret_test == ret_user) 316 | printf_rgb("57;181;74", "$> OK!\n"); 317 | else 318 | printf_rgb("222;56;43", "$> KO! expected: %d, result: %d.\n", ret_test, ret_user); 319 | destroy(test); 320 | test = 0; 321 | exit(0); 322 | } 323 | else 324 | wait(0); 325 | } 326 | } 327 | 328 | void assert_ft_lstlast(void) 329 | { 330 | char **arrs[] = {(char *[]){"Third", "Second", "First", 0}, 331 | (char *[]){"", 0}, 332 | (char *[]){0}, 333 | 0}; 334 | t_list *test = 0; 335 | t_list *ret_test; 336 | t_list *ret_user; 337 | 338 | HEADER("assert_ft_lstlast"); 339 | for (int i = 0; arrs[i]; i++) 340 | { 341 | if (fork() == 0) 342 | { 343 | SEP; 344 | for (int j = 0; arrs[i][j]; j++) 345 | test_lstadd_front(&test, test_lstnew(arrs[i][j])); 346 | printf_rgb("255;199;6", "test: last element = %s.\n", arrs[i][0]); 347 | ret_test = test_lstlast(test); 348 | ret_user = ft_lstlast(test); 349 | lst_ret_cmp(ret_test, ret_user); 350 | destroy(test); 351 | test = 0; 352 | exit(0); 353 | } 354 | else 355 | wait(0); 356 | } 357 | } 358 | 359 | void assert_ft_lstdelone(void) 360 | { 361 | char *strs[] = {"Hello World!", 0}; 362 | t_list *ret; 363 | 364 | HEADER("assert_ft_lstdelone"); 365 | for (int i = 0; i < 2; i++) 366 | { 367 | if (fork() == 0) 368 | { 369 | SEP; 370 | printf_rgb("255;199;6", "test: element->content = %12s.\n", strs[i]); 371 | if (strs[i]) 372 | ret = test_lstnew(strdup(strs[i])); 373 | else 374 | ret = test_lstnew(strs[i]); 375 | ft_lstdelone(ret, free); 376 | printf_rgb("57;181;74", "$> Done!\n"); 377 | exit(0); 378 | } 379 | else 380 | wait(0); 381 | } 382 | } 383 | 384 | void assert_ft_lstclear(void) 385 | { 386 | char **arrs[] = {(char *[]){"Third", "Second", "First", 0}, 387 | (char *[]){"", 0}, 388 | (char *[]){0}, 389 | 0}; 390 | t_list *test = 0; 391 | 392 | HEADER("assert_ft_lstclear"); 393 | for (int i = 0; arrs[i]; i++) 394 | { 395 | if (fork() == 0) 396 | { 397 | SEP; 398 | for (int j = 0; arrs[i][j]; j++) 399 | test_lstadd_front(&test, test_lstnew(strdup(arrs[i][j]))); 400 | printf_rgb("255;199;6", "test: list size = %d.\n", test_lstsize(test)); 401 | ft_lstclear(&test, free); 402 | printf_rgb("57;181;74", "$> Done!\n"); 403 | exit(0); 404 | } 405 | else 406 | wait(0); 407 | } 408 | } 409 | 410 | void test_iter(void *s) 411 | { 412 | printf("%s\n", (char *)s); 413 | } 414 | 415 | void assert_ft_lstiter(void) 416 | { 417 | int fd_test; 418 | int fd_user; 419 | char *strs[] = {"Third", "Second", "First", 0}; 420 | t_list *ret_test = 0; 421 | t_list *ret_user = 0; 422 | 423 | HEADER("assert_ft_lstiter"); 424 | SEP; 425 | if (fork() == 0) 426 | { 427 | for (int j = 0; strs[j]; j++) 428 | test_lstadd_front(&ret_test, test_lstnew(strs[j])); 429 | for (int j = 0; strs[j]; j++) 430 | test_lstadd_front(&ret_user, test_lstnew(strs[j])); 431 | printf_rgb("255;199;6", "test: iterate through linked list.\n"); 432 | if (fork() == 0) 433 | { 434 | fd_test = open("out_test", O_CREAT | O_WRONLY | O_TRUNC); 435 | dup2(fd_test, 1); 436 | test_lstiter(ret_test, test_iter); 437 | close(fd_test); 438 | exit(0); 439 | } 440 | else 441 | wait(0); 442 | if (fork() == 0) 443 | { 444 | fd_user = open("out_user", O_CREAT | O_WRONLY | O_TRUNC); 445 | dup2(fd_user, 1); 446 | ft_lstiter(ret_user, test_iter); 447 | close(fd_user); 448 | exit(0); 449 | } 450 | else 451 | wait(0); 452 | exit(0); 453 | out_cmp(); 454 | remove("out_test"); 455 | remove("out_user"); 456 | destroy(ret_test); 457 | destroy(ret_user); 458 | exit(0); 459 | } 460 | else 461 | wait(0); 462 | } 463 | 464 | // void assert_ft_lstmap(void) 465 | // { 466 | 467 | // } 468 | 469 | void bonus(void) 470 | { 471 | void (*test[9 - 2])() = { 472 | assert_ft_lstnew, 473 | assert_ft_lstadd_front, 474 | assert_ft_lstsize, 475 | assert_ft_lstlast, 476 | assert_ft_lstadd_back, 477 | assert_ft_lstdelone, 478 | assert_ft_lstclear 479 | // assert_ft_lstiter, 480 | // assert_ft_lstmap 481 | }; 482 | for (int i = 0; i < 9 - 2; i++) 483 | if (fork() == 0) 484 | { 485 | test[i](); 486 | exit(0); 487 | } 488 | else 489 | wait(0); 490 | } 491 | -------------------------------------------------------------------------------- /mandatory.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include "../libft.h" 11 | 12 | #define S1 "============================================================================================================================================" 13 | #define S2 "--------------------------------------------------------------------------------------------------------------------------------------------" 14 | #define S3 "____________________________________________________________________________________________________________________________________________" 15 | #define SEP printf_rgb("255;199;6", S2"\n") 16 | #define HEADER(str) getchar();printf_rgb("136;23;152;1", "\n"S3"\n\n%140s\n", str) 17 | #define END(str) printf_rgb("136;23;152;3", "\n%140s\n%140s\n%140s\n", "Test finished.", str, "https://github.com/gmarcha") 18 | 19 | void printf_rgb(char *rgb, char *format, ...); 20 | 21 | void out_cmp(void); 22 | 23 | size_t bsd_strlcpy(char * dst, const char * src, size_t maxlen) 24 | { 25 | const size_t srclen = strlen(src); 26 | 27 | if (srclen + 1 < maxlen) { 28 | memcpy(dst, src, srclen + 1); 29 | } else if (maxlen != 0) { 30 | memcpy(dst, src, maxlen - 1); 31 | dst[maxlen - 1] = '\0'; 32 | } 33 | return (srclen); 34 | } 35 | 36 | size_t bsd_strlcat(char *dst, const char *src, size_t siz) 37 | { 38 | char *d = dst; 39 | const char *s = src; 40 | size_t n = siz; 41 | size_t dlen; 42 | 43 | while (n-- != 0 && *d != '\0') 44 | d++; 45 | dlen = d - dst; 46 | n = siz - dlen; 47 | if (n == 0) 48 | return(dlen + strlen(s)); 49 | while (*s != '\0') { 50 | if (n != 1) { 51 | *d++ = *s; 52 | n--; 53 | } 54 | s++; 55 | } 56 | *d = '\0'; 57 | return(dlen + (s - src)); 58 | } 59 | 60 | char *bsd_strnstr(const char *s, const char *find, size_t slen) 61 | { 62 | char c, sc; 63 | size_t len; 64 | 65 | if ((c = *find++) != '\0') { 66 | len = strlen(find); 67 | do { 68 | do { 69 | if (slen-- < 1 || (sc = *s++) == '\0') 70 | return (NULL); 71 | } while (sc != c); 72 | if (len > slen) 73 | return (NULL); 74 | } while (strncmp(s, find, len) != 0); 75 | s--; 76 | } 77 | return ((char *)s); 78 | } 79 | 80 | char *test_substr(char const *s, unsigned int start, size_t len) 81 | { 82 | char *str; 83 | size_t len_s; 84 | size_t i; 85 | 86 | len_s = ft_strlen(s); 87 | if (len_s < start) 88 | str = (char *)malloc(1); 89 | else if (len_s - start < len) 90 | str = (char *)malloc(len_s - start + 1); 91 | else 92 | str = (char *)malloc(len + 1); 93 | if (str == 0) 94 | return (0); 95 | i = 0; 96 | if (start < len_s) 97 | { 98 | while (s[i + start] && i < len) 99 | { 100 | str[i] = s[i + start]; 101 | i++; 102 | } 103 | } 104 | str[i] = 0; 105 | return (str); 106 | } 107 | 108 | char *test_strjoin(char const *s1, char const *s2) 109 | { 110 | char *str; 111 | int i; 112 | int j; 113 | 114 | str = (char *)malloc(ft_strlen(s1) + ft_strlen(s2) + 1); 115 | if (str == 0) 116 | return (0); 117 | i = -1; 118 | while (s1[++i]) 119 | str[i] = s1[i]; 120 | j = -1; 121 | while (s2[++j]) 122 | str[i + j] = s2[j]; 123 | str[i + j] = 0; 124 | return (str); 125 | } 126 | 127 | static int test_ischarset(char c, const char *set) 128 | { 129 | int i; 130 | 131 | i = 0; 132 | while (set[i]) 133 | if (set[i++] == c) 134 | return (1); 135 | return (0); 136 | } 137 | 138 | char *test_strtrim(char const *s1, char const *set) 139 | { 140 | char *str; 141 | int start; 142 | int end; 143 | int i; 144 | 145 | start = 0; 146 | while (s1[start] && test_ischarset(s1[start], set)) 147 | start++; 148 | end = ft_strlen(s1); 149 | while (start < end && test_ischarset(s1[end - 1], set)) 150 | end--; 151 | str = (char *)malloc(end - start + 1); 152 | if (str == 0) 153 | return (0); 154 | i = 0; 155 | while (start < end) 156 | str[i++] = s1[start++]; 157 | str[i] = 0; 158 | return (str); 159 | } 160 | 161 | static char **test_free_strs(char **strs, int size) 162 | { 163 | int i; 164 | 165 | i = 0; 166 | while (i < size) 167 | free(strs[i++]); 168 | free(strs); 169 | return (0); 170 | } 171 | 172 | static int test_get_nbr_words(const char *str, char sep) 173 | { 174 | int count; 175 | int i; 176 | 177 | count = 0; 178 | i = 0; 179 | while (str[i]) 180 | { 181 | while (str[i] && str[i] == sep) 182 | i++; 183 | if (str[i] && str[i] != sep) 184 | count++; 185 | while (str[i] && str[i] != sep) 186 | i++; 187 | } 188 | return (count); 189 | } 190 | 191 | static char *test_allocate_string(char const *s, char c) 192 | { 193 | char *str; 194 | int j; 195 | 196 | j = 0; 197 | while (s[j] && s[j] != c) 198 | j++; 199 | str = (char *)malloc(j + 1); 200 | if (str == 0) 201 | return (0); 202 | return (str); 203 | } 204 | 205 | char **test_split(char const *s, char c) 206 | { 207 | char **strs; 208 | int len; 209 | int i; 210 | int j; 211 | 212 | len = test_get_nbr_words(s, c); 213 | strs = (char **)malloc(sizeof(char *) * (len + 1)); 214 | if (strs == 0) 215 | return (0); 216 | i = 0; 217 | while (i < len) 218 | { 219 | while (*s && *s == c) 220 | s++; 221 | strs[i] = test_allocate_string(s, c); 222 | if (strs[i] == 0) 223 | return (test_free_strs(strs, i)); 224 | j = 0; 225 | while (*s && *s != c) 226 | strs[i][j++] = *s++; 227 | strs[i++][j] = 0; 228 | } 229 | strs[i] = 0; 230 | return (strs); 231 | } 232 | 233 | static size_t test_nbrlen(int n) 234 | { 235 | size_t len; 236 | 237 | len = 0; 238 | if (n <= 0) 239 | len++; 240 | while (n) 241 | { 242 | n /= 10; 243 | len++; 244 | } 245 | return (len); 246 | } 247 | 248 | char *test_itoa(int n) 249 | { 250 | char *nbr; 251 | size_t len; 252 | unsigned int nb; 253 | 254 | len = test_nbrlen(n); 255 | nbr = (char *)malloc(len + 1); 256 | if (nbr == 0) 257 | return (0); 258 | nbr[len] = 0; 259 | nb = n; 260 | if (n < 0) 261 | nb = -n; 262 | while (len--) 263 | { 264 | nbr[len] = "0123456789"[nb % 10]; 265 | nb /= 10; 266 | } 267 | if (n < 0) 268 | nbr[0] = '-'; 269 | return (nbr); 270 | } 271 | 272 | char *test_strmapi(char const *s, char (*f)(unsigned int, char)) 273 | { 274 | char *str; 275 | int i; 276 | 277 | i = 0; 278 | while (s[i]) 279 | i++; 280 | str = (char *)malloc(i + 1); 281 | if (str == 0) 282 | return (0); 283 | i = -1; 284 | while (s[++i]) 285 | str[i] = f(i, s[i]); 286 | str[i] = 0; 287 | return (str); 288 | } 289 | 290 | void test_putchar_fd(char c, int fd) 291 | { 292 | write(fd, &c, 1); 293 | } 294 | 295 | void test_putstr_fd(char *s, int fd) 296 | { 297 | size_t i; 298 | 299 | i = 0; 300 | while (s[i]) 301 | i++; 302 | write(fd, s, i); 303 | } 304 | 305 | void test_putendl_fd(char *s, int fd) 306 | { 307 | test_putstr_fd(s, fd); 308 | write(fd, "\n", 1); 309 | } 310 | 311 | void test_putnbr_fd(int n, int fd) 312 | { 313 | unsigned int nb; 314 | 315 | if (n < 0) 316 | nb = -n; 317 | else 318 | nb = n; 319 | if (n < 0) 320 | write(fd, "-", 1); 321 | if (nb >= 10) 322 | test_putnbr_fd(nb / 10, fd); 323 | write(fd, &"0123456789"[nb % 10], 1); 324 | } 325 | 326 | void int_ret_cmp(int ret_test, int ret_user) 327 | { 328 | if (ret_test == ret_user) 329 | printf_rgb("57;181;74", "$> OK!\n"); 330 | else 331 | printf_rgb("222;56;43", "$> KO! expected: %11d, result: %11d.\n", ret_test, ret_user); 332 | } 333 | 334 | void signed_ret_cmp(int ret_test, int ret_user) 335 | { 336 | int ret_cmp; 337 | 338 | ret_cmp = 339 | ((ret_test <= 0) ? (ret_test == 0) ? 0 : -1 : 1) - 340 | ((ret_user <= 0) ? (ret_user == 0) ? 0 : -1 : 1); 341 | if (ret_cmp == 0) 342 | printf_rgb("57;181;74", "$> OK!\n"); 343 | else 344 | printf_rgb("222;56;43", "$> KO! expected: %14s, result: %14s.\n", 345 | (ret_test <= 0) ? (ret_test == 0) ? "zero" : "negative value" : "postive_value", 346 | (ret_user <= 0) ? (ret_user == 0) ? "zero" : "negative value" : "postive_value"); 347 | } 348 | 349 | void str_out_cmp(char test[], char user[]) 350 | { 351 | int out_cmp; 352 | 353 | out_cmp = strcmp(test, user); 354 | if (out_cmp == 0) 355 | printf_rgb("57;181;74", "$> OK!\n"); 356 | else 357 | printf_rgb("222;56;43", "$> KO! expected: %20s, result: %20s.\n", test, user); 358 | } 359 | 360 | void str_ret_cmp(char *ret_test, char *ret_user) 361 | { 362 | int ret_cmp; 363 | 364 | ret_cmp = (ret_test == 0 || ret_user == 0) ? (ret_test == ret_user) ? 0 : 1 : strcmp(ret_test, ret_user); 365 | if (ret_cmp == 0) 366 | printf_rgb("57;181;74", "$> OK!\n"); 367 | else 368 | printf_rgb("222;56;43", "$> KO! expected: %20s, result: %20s.\n", ret_test, ret_user); 369 | } 370 | 371 | void str_out_ret_cmp(char test[], char user[], char *ret_test, char *ret_user) 372 | { 373 | int out_cmp; 374 | int ret_cmp; 375 | 376 | out_cmp = strcmp(test, user); 377 | ret_cmp = (ret_test == 0 || ret_user == 0) ? (ret_test == ret_user) ? 0 : 1 : strcmp(ret_test, ret_user); 378 | if (out_cmp == 0 && ret_cmp == 0) 379 | printf_rgb("57;181;74", "$> OK!\n"); 380 | else 381 | { 382 | if (out_cmp == 0) 383 | printf_rgb("57;181;74", "$> OK diff!\n"); 384 | else 385 | printf_rgb("222;56;43", "$> KO %-13s expected: %20s, result: %20s.\n", "diff!", test, user); 386 | if (ret_cmp == 0) 387 | printf_rgb("57;181;74", "$> OK return value!\n"); 388 | else 389 | printf_rgb("222;56;43", "$> KO %-13s expected: %20s, result: %20s.\n", "return value!", ret_test, ret_user); 390 | } 391 | } 392 | 393 | void str_out_int_ret_cmp(char *test, char *user, size_t ret_test, size_t ret_user) 394 | { 395 | int out_cmp; 396 | int ret_cmp; 397 | 398 | out_cmp = strcmp(test, user); 399 | ret_cmp = ret_test - ret_user; 400 | if (out_cmp == 0 && ret_cmp == 0) 401 | printf_rgb("57;181;74", "$> OK!\n"); 402 | else 403 | { 404 | if (out_cmp == 0) 405 | printf_rgb("57;181;74", "$> OK diff!\n"); 406 | else 407 | printf_rgb("222;56;43", "$> KO %-13s expected: %20s, result: %20s.\n", "diff!", test, user); 408 | if (ret_cmp == 0) 409 | printf_rgb("57;181;74", "$> OK return value!\n"); 410 | else 411 | printf_rgb("222;56;43", "$> KO %-13s expected: %2lu, result: %2lu.\n", "return value!", ret_test, ret_user); 412 | } 413 | } 414 | 415 | 416 | 417 | /* ************************************************************************** */ 418 | /* */ 419 | /* MANDATORY PART */ 420 | /* */ 421 | /* ************************************************************************** */ 422 | 423 | void assert_ft_memset(void) 424 | { 425 | char charset[] = "libf"; 426 | int input[] = {0, 19, 1, 20}; 427 | char test[21] = {0}; 428 | char user[21] = {0}; 429 | char *ret_test; 430 | char *ret_user; 431 | 432 | HEADER("assert_ft_memset"); 433 | for (int i = 0; i < 4; i++) 434 | { 435 | if (fork() == 0) 436 | { 437 | SEP; 438 | memset(test, 97, 20); 439 | memset(user, 97, 20); 440 | printf_rgb("255;199;6", "test: dest = %20s, value = %c, size = %2d.\n", test, charset[i], input[i]); 441 | ret_test = (char *)memset(test, charset[i], input[i]); 442 | ret_user = (char *)ft_memset(user, charset[i], input[i]); 443 | str_out_ret_cmp(test, user, ret_test, ret_user); 444 | exit(0); 445 | } 446 | else 447 | wait(0); 448 | } 449 | } 450 | 451 | void assert_ft_bzero(void) 452 | { 453 | int input[] = {0, 20}; 454 | char test[21] = {0}; 455 | char user[21] = {0}; 456 | 457 | HEADER("assert_ft_bzero"); 458 | for (int i = 0; i < 2; i++) 459 | { 460 | if (fork() == 0) 461 | { 462 | SEP; 463 | memset(test, 97, 20); 464 | memset(user, 97, 20); 465 | printf_rgb("255;199;6", "test: dest = %20s, size = %2d.\n", test, input[i]); 466 | bzero(test, input[i]); 467 | ft_bzero(user, input[i]); 468 | str_out_cmp(test, user); 469 | exit(0); 470 | } 471 | else 472 | wait(0); 473 | } 474 | } 475 | 476 | void assert_ft_memcpy(void) 477 | { 478 | char *strs[] = {"test", 479 | "Hello World!", 480 | "p0bJcViB9wsMKfasue4c", 481 | 0}; 482 | int input[] = {0, 1, 20}; 483 | char test[21] = {0}; 484 | char user[21] = {0}; 485 | char *ret_test; 486 | char *ret_user; 487 | 488 | HEADER("assert_ft_memcpy"); 489 | for (int i = 0; strs[i]; i++) 490 | { 491 | if (fork() == 0) 492 | { 493 | SEP; 494 | memset(test, 97, 20); 495 | memset(user, 97, 20); 496 | printf_rgb("255;199;6", "test: dest = %20s, src = %20s, size = %2d.\n", test, strs[i], input[i]); 497 | ret_test = (char *)memcpy(test, strs[i], input[i]); 498 | ret_user = (char *)ft_memcpy(user, strs[i], input[i]); 499 | str_out_ret_cmp(test, user, ret_test, ret_user); 500 | exit(0); 501 | } 502 | else 503 | wait(0); 504 | } 505 | } 506 | 507 | void assert_ft_memccpy(void) 508 | { 509 | char *strs[] = {"gi751e8puUangYNEuztn", 510 | "dON70HMbi1DsIWM0FVi3", 511 | "p0bJcViB9wsMKfasue4c", 512 | "tNiLO0DXeV8znbDcIPy1", 513 | 0}; 514 | char c = 'W'; 515 | int input[] = {0, 19, 1, 20}; 516 | char test[21] = {0}; 517 | char user[21] = {0}; 518 | char *ret_test; 519 | char *ret_user; 520 | 521 | HEADER("assert_ft_memccpy"); 522 | for (int i = 0; strs[i]; i++) 523 | { 524 | if (fork() == 0) 525 | { 526 | SEP; 527 | memset(test, 97, 20); 528 | memset(user, 97, 20); 529 | printf_rgb("255;199;6", "test: dest = %20s, src = %20s, value = %c, size = %2d.\n", test, strs[i], c, input[i]); 530 | ret_test = (char *)memccpy(test, strs[i], c, input[i]); 531 | ret_user = (char *)ft_memccpy(user, strs[i], c, input[i]); 532 | str_out_ret_cmp(test, user, ret_test, ret_user); 533 | exit(0); 534 | } 535 | else 536 | wait(0); 537 | } 538 | } 539 | 540 | void assert_ft_memmove(void) 541 | { 542 | char *strs[] = {"gi751e8puUangYNEuztn", 543 | "dON70HMbi1DsIWM0FVi3", 544 | "p0bJcViB9wsMKfasue4c", 545 | "tNiLO0DXeV8znbDcIPy1", 546 | 0}; 547 | int input[] = {0, 19, 1, 20}; 548 | int overlap_a[] = {0, 10}; 549 | int overlap_b[] = {10, 0}; 550 | char test[21] = {0}; 551 | char user[21] = {0}; 552 | char *ret_test; 553 | char *ret_user; 554 | 555 | HEADER("assert_ft_memmove"); 556 | for (int i = 0; i < 4; i++) 557 | { 558 | if (fork() == 0) 559 | { 560 | SEP; 561 | memset(test, 97, 20); 562 | memset(user, 97, 20); 563 | printf_rgb("255;199;6", "test: dest = %20s, src = %20s, size = %2d.\n", test, strs[i], input[i]); 564 | ret_test = memmove(test, strs[i], input[i]); 565 | ret_user = ft_memmove(user, strs[i], input[i]); 566 | str_out_ret_cmp(test, user, ret_test, ret_user); 567 | exit(0); 568 | } 569 | else 570 | wait(0); 571 | } 572 | for (int i = 0; i < 2; i++) 573 | { 574 | if (fork() == 0) 575 | { 576 | SEP; 577 | memset(test, 97, 10);memset(test + 10, 98, 10); 578 | memset(user, 97, 10);memset(user + 10, 98, 10); 579 | printf_rgb("255;199;6", "test: dest = %20s, src = %20s, size = %2d.\n", test + overlap_a[i], test + overlap_b[i], 10); 580 | ret_test = memmove(test + overlap_a[i], test + overlap_b[i], 10); 581 | ret_user = ft_memmove(user + overlap_a[i], user + overlap_b[i], 10); 582 | str_out_ret_cmp(test, user, ret_test, ret_user); 583 | exit(0); 584 | } 585 | else 586 | wait(0); 587 | } 588 | } 589 | 590 | void assert_ft_memchr(void) 591 | { 592 | char charset[] = "aatx"; 593 | int input[] = {0, 1, 20, 20}; 594 | char test[21] = {0}; 595 | char user[21] = {0}; 596 | char *ret_test; 597 | char *ret_user; 598 | 599 | for (int i = 0; i < 20; i++) 600 | memset(test + i, i + 97, 1); 601 | for (int i = 0; i < 20; i++) 602 | memset(user + i, i + 97, 1); 603 | HEADER("assert_ft_memchr"); 604 | for (int i = 0; i < 4; i++) 605 | { 606 | if (fork() == 0) 607 | { 608 | SEP; 609 | printf_rgb("255;199;6", "test: dest = %20s, value = %c, size = %2d.\n", test, charset[i], input[i]); 610 | ret_test = (char *)memchr(test, charset[i], input[i]); 611 | ret_user = (char *)ft_memchr(user, charset[i], input[i]); 612 | str_ret_cmp(ret_test, ret_user); 613 | exit(0); 614 | } 615 | else 616 | wait(0); 617 | } 618 | } 619 | 620 | void assert_ft_memcmp(void) 621 | { 622 | char *strs[] = {"", 623 | "", 624 | "aaaaaaaaaaaaaaaaaaaa", 625 | "aaaaaaaaaaaaaaaaaaaa", 626 | "aaaaaaaaaaaaaaaaaaaa", 627 | "abcdefghijklmnopqrst", 628 | "abcdefghijklmnopqrsz", 629 | 0}; 630 | int input[] = {0, 1, 0, 1, 2, 20, 20}; 631 | char test[] = "abcdefghijklmnopqrst"; 632 | char user[] = "abcdefghijklmnopqrst"; 633 | int ret_test; 634 | int ret_user; 635 | 636 | HEADER("assert_ft_memcmp"); 637 | for (int i = 0; i < 7; i++) 638 | { 639 | if (fork() == 0) 640 | { 641 | SEP; 642 | printf_rgb("255;199;6", "test: s1 = %20s, s2 = %20s, size = %2d.\n", test, strs[i], input[i]); 643 | ret_test = memcmp(test, strs[i], input[i]); 644 | ret_user = ft_memcmp(user, strs[i], input[i]); 645 | signed_ret_cmp(ret_test, ret_user); 646 | exit(0); 647 | } 648 | else 649 | wait(0); 650 | } 651 | } 652 | 653 | void assert_ft_strlen(void) 654 | { 655 | char *strs[] = {"", "Hello World!", 0}; 656 | int ret_test; 657 | int ret_user; 658 | 659 | HEADER("assert_ft_strlen"); 660 | for (int i = 0; strs[i]; i++) 661 | { 662 | if (fork() == 0) 663 | { 664 | SEP; 665 | printf_rgb("255;199;6", "test: str = %12s.\n", strs[i]); 666 | ret_test = strlen(strs[i]); 667 | ret_user = ft_strlen(strs[i]); 668 | int_ret_cmp(ret_test, ret_user); 669 | exit(0); 670 | } 671 | else 672 | wait(0); 673 | } 674 | } 675 | 676 | void assert_ft_is_to(char *name, int (*f)(int), int (*ft_f)(int), int flag) 677 | { 678 | int ret_test; 679 | int ret_user; 680 | int is_valid = 0; 681 | 682 | HEADER(name); 683 | SEP; 684 | printf_rgb("255;199;6", "test: all characters.\n"); 685 | for (int i = 0; i < 256; i++) 686 | { 687 | ret_test = (flag == 0) ? !!f(i) : f(i); 688 | ret_user = (flag == 0) ? !!ft_f(i) : ft_f(i); 689 | if (ret_test != ret_user) 690 | { 691 | if (flag == 0) 692 | printf_rgb("222;56;43", "$> KO! test: %3d, expected: %14s, result: %14s.\n", i, 693 | (ret_test == 0) ? "zero" : "postive_value", 694 | (ret_user == 0) ? "zero" : "postive_value"); 695 | if (flag == 1) 696 | printf_rgb("222;56;43", "$> KO! test: %3d, expected: %3d, result: %3d.\n", i, ret_test, ret_user); 697 | is_valid++; 698 | } 699 | } 700 | if (is_valid == 0) 701 | printf_rgb("57;181;74", "$> OK!\n"); 702 | } 703 | 704 | void assert_ft_isalpha(void) 705 | { 706 | assert_ft_is_to("assert_ft_isalpha", isalpha, ft_isalpha, 0); 707 | } 708 | 709 | void assert_ft_isdigit(void) 710 | { 711 | assert_ft_is_to("assert_ft_isdigit", isdigit, ft_isdigit, 0); 712 | } 713 | 714 | void assert_ft_isalnum(void) 715 | { 716 | assert_ft_is_to("assert_ft_isalnum", isalnum, ft_isalnum, 0); 717 | } 718 | 719 | void assert_ft_isascii(void) 720 | { 721 | assert_ft_is_to("assert_ft_isascii", isascii, ft_isascii, 0); 722 | } 723 | 724 | void assert_ft_isprint(void) 725 | { 726 | assert_ft_is_to("assert_ft_isprint", isprint, ft_isprint, 0); 727 | } 728 | 729 | void assert_ft_toupper(void) 730 | { 731 | assert_ft_is_to("assert_ft_toupper", toupper, ft_toupper, 1); 732 | } 733 | 734 | void assert_ft_tolower(void) 735 | { 736 | assert_ft_is_to("assert_ft_tolower", tolower, ft_tolower, 1); 737 | } 738 | 739 | void assert_ft_strchr_(char *name, char *(*f)(const char *, int), char *(*ft_f)(const char *, int)) 740 | { 741 | char charset[] = "zaj"; 742 | char test[] = "abcdefghijabcdefghij"; 743 | char user[] = "abcdefghijabcdefghij"; 744 | char *ret_test; 745 | char *ret_user; 746 | 747 | HEADER(name); 748 | for (int i = 0; i < 4; i++) 749 | { 750 | if (fork() == 0) 751 | { 752 | SEP; 753 | printf_rgb("255;199;6", "test: dest = %20s, value = %c.\n", test, charset[i]); 754 | ret_test = f(test, charset[i]); 755 | ret_user = ft_f(user, charset[i]); 756 | str_ret_cmp(ret_test, ret_user); 757 | exit(0); 758 | } 759 | else 760 | wait(0); 761 | } 762 | } 763 | 764 | void assert_ft_strchr(void) 765 | { 766 | assert_ft_strchr_("assert_strchr", strchr, ft_strchr); 767 | } 768 | 769 | void assert_ft_strrchr(void) 770 | { 771 | assert_ft_strchr_("assert_strrchr", strrchr, ft_strrchr); 772 | } 773 | 774 | void assert_ft_strncmp(void) 775 | { 776 | char *strs[] = {"", 777 | "", 778 | "aaaaaaaaaaaaaaaaaaaa", 779 | "aaaaaaaaaaaaaaaaaaaa", 780 | "aaaaaaaaaaaaaaaaaaaa", 781 | "abcdefghijklmnopqrst", 782 | "abcdefghijklmnopqrsz", 783 | 0}; 784 | int input[] = {0, 1, 0, 1, 2, 20, 20}; 785 | char test[] = "abcdefghijklmnopqrst"; 786 | char user[] = "abcdefghijklmnopqrst"; 787 | int ret_test; 788 | int ret_user; 789 | 790 | HEADER("assert_ft_strncmp"); 791 | for (int i = 0; i < 7; i++) 792 | { 793 | if (fork() == 0) 794 | { 795 | SEP; 796 | printf_rgb("255;199;6", "test: s1 = %20s, s2 = %20s, size = %2d.\n", test, strs[i], input[i]); 797 | ret_test = strncmp(test, strs[i], input[i]); 798 | ret_user = ft_strncmp(user, strs[i], input[i]); 799 | signed_ret_cmp(ret_test, ret_user); 800 | exit(0); 801 | } 802 | else 803 | wait(0); 804 | } 805 | } 806 | 807 | void assert_ft_strlcpy(void) 808 | { 809 | char *strs[] = {"test", 810 | "test", 811 | "Hello World!", 812 | "p0bJcViB9wsMKfasue4c", 813 | ""}; 814 | int input[] = {0, 1, 2, 20, 20}; 815 | char test[21] = {0}; 816 | char user[21] = {0}; 817 | size_t ret_test; 818 | size_t ret_user; 819 | 820 | HEADER("assert_ft_strlcpy"); 821 | for (int i = 0; i < 5; i++) 822 | { 823 | if (fork() == 0) 824 | { 825 | SEP; 826 | memset(test, 97, 20); 827 | memset(user, 97, 20); 828 | printf_rgb("255;199;6", "test: dest = %20s, src = %20s, size = %2d.\n", test, strs[i], input[i]); 829 | ret_test = bsd_strlcpy(test, strs[i], input[i]); 830 | ret_user = ft_strlcpy(user, strs[i], input[i]); 831 | str_out_int_ret_cmp(test, user, ret_test, ret_user); 832 | exit(0); 833 | } 834 | else 835 | wait(0); 836 | } 837 | } 838 | 839 | void assert_ft_strlcat(void) 840 | { 841 | char *strs[] = {"test", 842 | "test", 843 | "World!", 844 | "p0bJcViB9w", 845 | "tNiLO0DXeV8znbDcIPy1"}; 846 | int input[] = {20, 21, 22, 40, 40}; 847 | char test[41] = {0}; 848 | char user[41] = {0}; 849 | size_t ret_test; 850 | size_t ret_user; 851 | 852 | HEADER("assert_ft_strlcat"); 853 | for (int i = 0; i < 5; i++) 854 | { 855 | if (fork() == 0) 856 | { 857 | SEP; 858 | memset(test, 97, 40);memset(test + 20, 0, 20); 859 | memset(user, 97, 40);memset(user + 20, 0, 20); 860 | printf_rgb("255;199;6", "test: dest = %20s, src = %20s, size = %2d.\n", test, strs[i], input[i]); 861 | ret_test = bsd_strlcat(test, strs[i], input[i]); 862 | ret_user = ft_strlcat(user, strs[i], input[i]); 863 | str_out_int_ret_cmp(test, user, ret_test, ret_user); 864 | exit(0); 865 | } 866 | else 867 | wait(0); 868 | } 869 | } 870 | 871 | void assert_ft_strnstr(void) 872 | { 873 | char *strs[] = {"test", "H", "!", "!", "Hello World!", "Hello World!", "", "", 0}; 874 | char *str = "Hello World!"; 875 | int input[] = {12, 1, 1, 12, 1, 12, 0, 12}; 876 | char *ret_test; 877 | char *ret_user; 878 | 879 | HEADER("assert_ft_strnstr"); 880 | for (int i = 0; strs[i]; i++) 881 | { 882 | if (fork() == 0) 883 | { 884 | SEP; 885 | printf_rgb("255;199;6", "test: big = %12s, little = %12s, len = %2d.\n", str, strs[i], input[i]); 886 | ret_test = bsd_strnstr(str, strs[i], input[i]); 887 | ret_user = ft_strnstr(str, strs[i], input[i]); 888 | str_ret_cmp(ret_test, ret_user); 889 | exit(0); 890 | } 891 | else 892 | wait(0); 893 | } 894 | } 895 | 896 | void assert_ft_atoi(void) 897 | { 898 | char *strs[] = {"", "a42", " a42", "--42", "++42", "+42", "0", "-1", "2147483647", "-2147483648", 0}; 899 | int ret_test; 900 | int ret_user; 901 | 902 | HEADER("assert_ft_atoi"); 903 | for (int i = 0; strs[i]; i++) 904 | { 905 | if (fork() == 0) 906 | { 907 | SEP; 908 | printf_rgb("255;199;6", "test: str = %11s.\n", strs[i]); 909 | ret_test = atoi(strs[i]); 910 | ret_user = ft_atoi(strs[i]); 911 | int_ret_cmp(ret_test, ret_user); 912 | exit(0); 913 | } 914 | else 915 | wait(0); 916 | } 917 | } 918 | 919 | void assert_ft_calloc(void) 920 | { 921 | int input[] = {0, 1, 100}; 922 | void *ret_test; 923 | void *ret_user; 924 | int ret_cmp; 925 | 926 | HEADER("assert_ft_calloc"); 927 | for (int i = 0; i < 3; i++) 928 | { 929 | if (fork() == 0) 930 | { 931 | SEP; 932 | printf_rgb("255;199;6", "test: type = char, size = %3d.\n", input[i]); 933 | ret_test = calloc(input[i], 1); 934 | ret_user = ft_calloc(input[i], 1); 935 | ret_cmp = (ret_test == 0 || ret_user == 0) ? (ret_test == ret_user) ? 0 : 1 : memcmp(ret_test, ret_user, input[i]); 936 | if (ret_cmp == 0) 937 | printf_rgb("57;181;74", "$> OK!\n"); 938 | else 939 | printf_rgb("222;56;43", "$> KO! invalid diff.\n"); 940 | free(ret_test); 941 | free(ret_user); 942 | exit(0); 943 | } 944 | else 945 | wait(0); 946 | } 947 | } 948 | 949 | void assert_ft_strdup(void) 950 | { 951 | char *strs[] = {"", "Hello World!", 0}; 952 | char *ret_test; 953 | char *ret_user; 954 | 955 | HEADER("assert_ft_strdup"); 956 | for (int i = 0; strs[i]; i++) 957 | { 958 | if (fork() == 0) 959 | { 960 | SEP; 961 | printf_rgb("255;199;6", "test: src = %20s.\n", strs[i]); 962 | ret_test = strdup(strs[i]); 963 | ret_user = ft_strdup(strs[i]); 964 | str_ret_cmp(ret_test, ret_user); 965 | free(ret_test); 966 | free(ret_user); 967 | exit(0); 968 | } 969 | else 970 | wait(0); 971 | } 972 | } 973 | 974 | void assert_ft_substr(void) 975 | { 976 | int start[] = {0, 100, 0, 23, 25, 1, 43}; 977 | int len[] = {100, 100, 20, 20, 20, 1, 1}; 978 | char str[] = "Hello World! Welcome to the 42 Libft Test :)"; 979 | char *ret_test; 980 | char *ret_user; 981 | 982 | HEADER("assert_ft_substr"); 983 | for (int i = 0; i < 7; i++) 984 | { 985 | if (fork() == 0) 986 | { 987 | SEP; 988 | printf_rgb("255;199;6", "test: str = %s, start = %3d, len = %3d.\n", str, start[i], len[i]); 989 | ret_test = test_substr(str, start[i], len[i]); 990 | ret_user = ft_substr(str, start[i], len[i]); 991 | str_ret_cmp(ret_test, ret_user); 992 | free(ret_test); 993 | free(ret_user); 994 | exit(0); 995 | } 996 | else 997 | wait(0); 998 | } 999 | } 1000 | 1001 | void assert_ft_strjoin(void) 1002 | { 1003 | char *s1[] = {"", "Hello World!", "", "test", 0}; 1004 | char *s2[] = {"", "", "Hello World!", "test", 0}; 1005 | char *ret_test; 1006 | char *ret_user; 1007 | 1008 | HEADER("assert_ft_strjoin"); 1009 | for (int i = 0; s1[i]; i++) 1010 | { 1011 | if (fork() == 0) 1012 | { 1013 | SEP; 1014 | printf_rgb("255;199;6", "test: s1 = %12s, s2 = %12s.\n", s1[i], s2[i]); 1015 | ret_test = test_strjoin(s1[i], s2[i]); 1016 | ret_user = ft_strjoin(s1[i], s2[i]); 1017 | str_ret_cmp(ret_test, ret_user); 1018 | free(ret_test); 1019 | free(ret_user); 1020 | exit(0); 1021 | } 1022 | else 1023 | wait(0); 1024 | } 1025 | } 1026 | 1027 | void assert_ft_strtrim(void) 1028 | { 1029 | char *strs[] = {"", 1030 | "Hello World!", 1031 | "Hello___World!", 1032 | "____Hello World!", 1033 | "Hello World!-------", 1034 | "_____Hello World!------", 1035 | 0}; 1036 | char charset[] = "-_"; 1037 | char *ret_test; 1038 | char *ret_user; 1039 | 1040 | HEADER("assert_ft_strtrim"); 1041 | for (int i = 0; strs[i]; i++) 1042 | { 1043 | if (fork() == 0) 1044 | { 1045 | SEP; 1046 | printf_rgb("255;199;6", "test: str = %23s, charset = %s.\n", strs[i], charset); 1047 | ret_test = test_strtrim(strs[i], charset); 1048 | ret_user = ft_strtrim(strs[i], charset); 1049 | str_ret_cmp(ret_test, ret_user); 1050 | free(ret_test); 1051 | free(ret_user); 1052 | exit(0); 1053 | } 1054 | else 1055 | wait(0); 1056 | } 1057 | } 1058 | 1059 | void assert_ft_split(void) 1060 | { 1061 | char *strs[] = {"-----", 1062 | "gh-----", 1063 | "----gh", 1064 | "-----gh--", 1065 | "gh-gh-----", 1066 | "-----gh-----gh", 1067 | "-----gh--gh---gh--gh---gh---", 1068 | "", 1069 | 0}; 1070 | char sep = '-'; 1071 | char **ret_test; 1072 | char **ret_user; 1073 | int ret_cmp; 1074 | 1075 | HEADER("assert_ft_split"); 1076 | for (int i = 0; strs[i]; i++) 1077 | { 1078 | if (fork() == 0) 1079 | { 1080 | SEP; 1081 | printf_rgb("255;199;6", "test: str = %28s, sep = %c.\n", strs[i], sep); 1082 | ret_test = test_split(strs[i], sep); 1083 | ret_user = ft_split(strs[i], sep); 1084 | if (ret_test != 0 && ret_user != 0) 1085 | for (int j = 0; ret_test[j] || ret_user[j]; j++) 1086 | { 1087 | ret_cmp = (ret_test[j] == 0 || ret_user[j] == 0) ? (ret_test[j] == ret_user[j]) ? 0 : 1 : strcmp(ret_test[j], ret_user[j]); 1088 | if (ret_cmp == 0) 1089 | printf_rgb("57;181;74", "$> Line %d : OK!\n", j + 1); 1090 | else 1091 | printf_rgb("222;56;43", "$> Line %d : KO! expected: %2s, result: %2s.\n", j + 1, ret_test[j], ret_user[j]); 1092 | if (ret_test[j] != 0) 1093 | free(ret_test[j]); 1094 | if (ret_user[j] != 0) 1095 | free(ret_user[j]); 1096 | } 1097 | else 1098 | { 1099 | printf_rgb("222;56;43", "$> KO! invalid split."); 1100 | if (ret_test != 0) 1101 | for (int j = 0; ret_test[j]; j++) 1102 | if (ret_test[j] != 0) 1103 | free(ret_test[j]); 1104 | if (ret_user != 0) 1105 | for (int j = 0; ret_user[j]; j++) 1106 | if (ret_user[j] != 0) 1107 | free(ret_user[j]); 1108 | } 1109 | if (ret_test != 0) 1110 | free(ret_test); 1111 | if (ret_user != 0) 1112 | free(ret_user); 1113 | exit(0); 1114 | } 1115 | else 1116 | wait(0); 1117 | } 1118 | } 1119 | 1120 | void assert_ft_itoa(void) 1121 | { 1122 | int input[] = {0, 1, -1, 42, -42, 2147483647, -2147483648}; 1123 | char *ret_test; 1124 | char *ret_user; 1125 | 1126 | HEADER("assert_ft_itoa"); 1127 | for (int i = 0; i < 7; i++) 1128 | { 1129 | if (fork() == 0) 1130 | { 1131 | SEP; 1132 | printf_rgb("255;199;6", "test: nb = %11d.\n", input[i]); 1133 | ret_test = test_itoa(input[i]); 1134 | ret_user = ft_itoa(input[i]); 1135 | str_ret_cmp(ret_test, ret_user); 1136 | free(ret_test); 1137 | free(ret_user); 1138 | exit(0); 1139 | } 1140 | else 1141 | wait(0); 1142 | } 1143 | } 1144 | 1145 | char f_strmapi(unsigned i, char c) 1146 | { 1147 | return (c + i); 1148 | } 1149 | 1150 | void assert_ft_strmapi(void) 1151 | { 1152 | char *strs[] = {"Hello World!", "0123", "1234", "", 0}; 1153 | char *ret_test; 1154 | char *ret_user; 1155 | 1156 | HEADER("assert_ft_strmapi"); 1157 | for (int i = 0; strs[i]; i++) 1158 | { 1159 | if (fork() == 0) 1160 | { 1161 | SEP; 1162 | printf_rgb("255;199;6", "test: str = %12s.\n", strs[i]); 1163 | ret_test = test_strmapi(strs[i], f_strmapi); 1164 | ret_user = ft_strmapi(strs[i], f_strmapi); 1165 | str_ret_cmp(ret_test, ret_user); 1166 | free(ret_test); 1167 | free(ret_user); 1168 | exit(0); 1169 | } 1170 | else 1171 | wait(0); 1172 | } 1173 | } 1174 | 1175 | void assert_ft_putchar_fd(void) 1176 | { 1177 | int fd_test = open("out_test", O_CREAT | O_WRONLY | O_TRUNC); 1178 | int fd_user = open("out_user", O_CREAT | O_WRONLY | O_TRUNC); 1179 | 1180 | HEADER("assert_ft_putchar_fd"); 1181 | SEP; 1182 | printf_rgb("255;199;6", "test: all characters.\n"); 1183 | for (int i = 1; i < 256; i++) 1184 | { 1185 | test_putchar_fd(i, fd_test); 1186 | ft_putchar_fd(i, fd_user); 1187 | } 1188 | close(fd_test); 1189 | close(fd_user); 1190 | out_cmp(); 1191 | remove("out_test"); 1192 | remove("out_user"); 1193 | } 1194 | 1195 | void assert_ft_putstr_fd(void) 1196 | { 1197 | int fd_test = open("out_test", O_CREAT | O_WRONLY | O_TRUNC); 1198 | int fd_user = open("out_user", O_CREAT | O_WRONLY | O_TRUNC); 1199 | char *strs[] = {"Hello World!", " ", "", 0}; 1200 | 1201 | HEADER("assert_ft_putstr_fd"); 1202 | SEP; 1203 | printf_rgb("255;199;6", "test: Hello World!, one space, empty string.\n"); 1204 | for (int i = 0; strs[i]; i++) 1205 | { 1206 | test_putstr_fd(strs[i], fd_test); 1207 | ft_putstr_fd(strs[i], fd_user); 1208 | } 1209 | close(fd_test); 1210 | close(fd_user); 1211 | out_cmp(); 1212 | remove("out_test"); 1213 | remove("out_user"); 1214 | } 1215 | 1216 | void assert_ft_putendl_fd(void) 1217 | { 1218 | int fd_test = open("out_test", O_CREAT | O_WRONLY | O_TRUNC); 1219 | int fd_user = open("out_user", O_CREAT | O_WRONLY | O_TRUNC); 1220 | char *strs[] = {"Hello World!", " ", "", 0}; 1221 | 1222 | HEADER("assert_ft_putendl_fd"); 1223 | SEP; 1224 | printf_rgb("255;199;6", "test: Hello World!, one space, empty string.\n"); 1225 | for (int i = 0; strs[i]; i++) 1226 | { 1227 | test_putendl_fd(strs[i], fd_test); 1228 | ft_putendl_fd(strs[i], fd_user); 1229 | } 1230 | close(fd_test); 1231 | close(fd_user); 1232 | out_cmp(); 1233 | remove("out_test"); 1234 | remove("out_user"); 1235 | } 1236 | 1237 | void assert_ft_putnbr_fd(void) 1238 | { 1239 | int fd_test = open("out_test", O_CREAT | O_WRONLY | O_TRUNC); 1240 | int fd_user = open("out_user", O_CREAT | O_WRONLY | O_TRUNC); 1241 | int input[] = {0, 1, -1, 42, -42, 2147483647, -2147483648}; 1242 | 1243 | HEADER("assert_ft_putnbr_fd"); 1244 | SEP; 1245 | printf_rgb("255;199;6", "test: 0, -1, 1, 42, -42, 2147483647, -2147483648.\n"); 1246 | for (int i = 0; i < 7; i++) 1247 | { 1248 | test_putnbr_fd(input[i], fd_test); 1249 | ft_putnbr_fd(input[i], fd_user); 1250 | } 1251 | close(fd_test); 1252 | close(fd_user); 1253 | out_cmp(); 1254 | remove("out_test"); 1255 | remove("out_user"); 1256 | } 1257 | 1258 | void mandatory(void) 1259 | { 1260 | void (*test[34])() = { 1261 | assert_ft_memset, 1262 | assert_ft_bzero, 1263 | assert_ft_memcpy, 1264 | assert_ft_memccpy, 1265 | assert_ft_memmove, 1266 | assert_ft_memchr, 1267 | assert_ft_memcmp, 1268 | assert_ft_strlen, 1269 | assert_ft_isalpha, 1270 | assert_ft_isdigit, 1271 | assert_ft_isalnum, 1272 | assert_ft_isascii, 1273 | assert_ft_isprint, 1274 | assert_ft_toupper, 1275 | assert_ft_tolower, 1276 | assert_ft_strchr, 1277 | assert_ft_strrchr, 1278 | assert_ft_strncmp, 1279 | assert_ft_strlcpy, 1280 | assert_ft_strlcat, 1281 | assert_ft_strnstr, 1282 | assert_ft_atoi, 1283 | assert_ft_calloc, 1284 | assert_ft_strdup, 1285 | assert_ft_substr, 1286 | assert_ft_strjoin, 1287 | assert_ft_strtrim, 1288 | assert_ft_split, 1289 | assert_ft_itoa, 1290 | assert_ft_strmapi, 1291 | assert_ft_putchar_fd, 1292 | assert_ft_putstr_fd, 1293 | assert_ft_putendl_fd, 1294 | assert_ft_putnbr_fd 1295 | }; 1296 | for (int i = 0; i < 34; i++) 1297 | if (fork() == 0) 1298 | { 1299 | test[i](); 1300 | exit(0); 1301 | } 1302 | else 1303 | wait(0); 1304 | } 1305 | --------------------------------------------------------------------------------