├── .gitignore ├── README.md ├── ft_ls ├── .gitignore ├── diff_me.sh └── t_dir │ ├── 42 │ ├── .president │ ├── couloir │ └── ln_couloir ├── getnextline ├── cmp.txt └── main.c └── libft └── main.c /.gitignore: -------------------------------------------------------------------------------- 1 | # Object files 2 | *.o 3 | *.ko 4 | 5 | # Libraries 6 | *.lib 7 | *.a 8 | 9 | # Shared objects (inc. Windows DLLs) 10 | *.dll 11 | *.so 12 | *.so.* 13 | *.dylib 14 | 15 | # Executables 16 | *.exe 17 | *.out 18 | *.app 19 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Maintest 2 | ======== 3 | 4 | Vous avez le droit de contribuer et de faire des issues :) 5 | 6 | 7 | 8 | Merci de faire un petit tour sur les github de 9 | 10 | https://github.com/QuentinPerez 11 | 12 | https://github.com/mfontain 13 | 14 | https://github.com/alex8092 15 | 16 | https://github.com/gabtoubl 17 | 18 | https://github.com/soyel 19 | 20 | https://github.com/stherman 21 | 22 | Paul motte 23 | -------------------------------------------------------------------------------- /ft_ls/.gitignore: -------------------------------------------------------------------------------- 1 | our 2 | your 3 | -------------------------------------------------------------------------------- /ft_ls/diff_me.sh: -------------------------------------------------------------------------------- 1 | # **************************************************************************** # 2 | # # 3 | # ::: :::::::: # 4 | # diff_me.sh :+: :+: :+: # 5 | # +:+ +:+ +:+ # 6 | # By: stherman +#+ +:+ +#+ # 7 | # +#+#+#+#+#+ +#+ # 8 | # Created: 2013/11/27 09:02:59 by stherman #+# #+# # 9 | # Updated: 2016/11/13 03:44:22 by tplessis ### ########.fr # 10 | # # 11 | # **************************************************************************** # 12 | 13 | #!/bin/sh 14 | 15 | INTERACTIVE_MODE=1 16 | while [ ! -z "${1}" ]; do 17 | if [[ "${1}" =~ ^-- ]] 18 | then 19 | if [ "${1}" == "--non-interactive" ] 20 | then 21 | INTERACTIVE_MODE=0 22 | else 23 | printf "\033[31m${1}: Invalid option\n\033[0m" 24 | exit 25 | fi 26 | else 27 | FT_LS_PATH="${1}" 28 | fi 29 | shift 1 30 | done 31 | if [ -z "${FT_LS_PATH}" ]; then FT_LS_PATH="./ft_ls"; fi 32 | 33 | clear 34 | 35 | if [ ! -e "${FT_LS_PATH}" ]; then 36 | printf "\033[31m${FT_LS_PATH}: No such file\n\033[0m" 37 | exit 38 | fi 39 | 40 | printf "\033[44m\033[1;37m" 41 | 42 | printf "# **************************************************************************** #\n" 43 | printf "# #\n" 44 | printf "# ::: :::::::: #\n" 45 | printf "# :+: :+: :+: #\n" 46 | printf "# +:+ +:+ +:+ #\n" 47 | printf "# ~ TESTS WITH ONE ARGUMENT ~ +#+ +:+ +#+ #\n" 48 | printf "# +#+#+#+#+#+ +#+ #\n" 49 | printf "# #+# #+# #\n" 50 | printf "# ### ########.fr #\n" 51 | printf "# #\n" 52 | printf "# **************************************************************************** #\n\n\n" 53 | 54 | printf "\033[0m" 55 | 56 | SUCCESS= /bin/ls -1 -l t_dir > our && "${FT_LS_PATH}" -l t_dir > your 57 | if !(diff --brief your our) || !($SUCCESS) then 58 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -l\033[0m\n\n" 59 | diff your our 60 | else 61 | printf "\n\033[32mSuccess:\t\033[37;1m ls -l\033[0m\n\n" 62 | fi 63 | 64 | SUCCESS= /bin/ls -1 -a t_dir > our && "${FT_LS_PATH}" -a t_dir > your 65 | if !(diff --brief your our) || !($SUCCESS) then 66 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -a\033[0m\n\n" 67 | diff your our 68 | else 69 | printf "\n\033[32mSuccess:\t\033[37;1m ls -a\033[0m\n\n" 70 | fi 71 | 72 | SUCCESS= /bin/ls -1 -r t_dir > our && "${FT_LS_PATH}" -r t_dir > your 73 | if !(diff --brief your our) || !($SUCCESS) then 74 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -r\033[0m\n\n" 75 | diff your our 76 | else 77 | printf "\n\033[32mSuccess:\t\033[37;1m ls -r\033[0m\n\n" 78 | fi 79 | 80 | SUCCESS= /bin/ls -1 -R t_dir > our && "${FT_LS_PATH}" -R t_dir > your 81 | if !(diff --brief your our) || !($SUCCESS) then 82 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -R\033[0m\n\n" 83 | diff your our 84 | else 85 | printf "\n\033[32mSuccess:\t\033[37;1m ls -R\033[0m\n\n" 86 | fi 87 | 88 | SUCCESS= /bin/ls -1 -t t_dir > our && "${FT_LS_PATH}" -t t_dir > your 89 | if !(diff --brief your our) || !($SUCCESS) then 90 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -t\033[0m\n\n" 91 | diff your our 92 | else 93 | printf "\n\033[32mSuccess:\t\033[37;1m ls -t\033[0m\n\n" 94 | fi 95 | 96 | [ "${INTERACTIVE_MODE}" -eq "1" ] && printf "\n\n\033[1;37mPlease press a key to continue :D: \033[0m" && read 97 | 98 | # -------------------------------------------------------------------------------------------------------------- # 99 | # -------------------------------------------------------------------------------------------------------------- # 100 | # TEST_2 ------------------------------------------------------------------------------------------------ # 101 | # -------------------------------------------------------------------------------------------------------------- # 102 | # -------------------------------------------------------------------------------------------------------------- # 103 | 104 | [ "${INTERACTIVE_MODE}" -eq "1" ] && clear 105 | 106 | printf "\033[44m\033[1;37m" 107 | 108 | printf "# **************************************************************************** #\n" 109 | printf "# #\n" 110 | printf "# ::: :::::::: #\n" 111 | printf "# :+: :+: :+: #\n" 112 | printf "# +:+ +:+ +:+ #\n" 113 | printf "# ~ TESTS WITH TWO OR MORE ARGUMENT ~ +#+ +:+ +#+ #\n" 114 | printf "# +#+#+#+#+#+ +#+ #\n" 115 | printf "# #+# #+# #\n" 116 | printf "# ### ########.fr #\n" 117 | printf "# #\n" 118 | printf "# **************************************************************************** #\n\n\n" 119 | 120 | printf "\033[0m" 121 | 122 | SUCCESS= /bin/ls -1 -l -a t_dir > our && "${FT_LS_PATH}" -l -a t_dir > your 123 | if !(diff --brief your our) || !($SUCCESS) then 124 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -l -a\033[0m\n\n" 125 | diff your our 126 | else 127 | printf "\n\033[32mSuccess:\t\033[37;1m ls -l -a\033[0m\n\n" 128 | fi 129 | 130 | SUCCESS= /bin/ls -1 -l -a -r t_dir > our && "${FT_LS_PATH}" -l -a -r t_dir > your 131 | if !(diff --brief your our) || !($SUCCESS) then 132 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -l -a -r\033[0m\n\n" 133 | diff your our 134 | else 135 | printf "\n\033[32mSuccess:\t\033[37;1m ls -l -a -r\033[0m\n\n" 136 | fi 137 | 138 | SUCCESS= /bin/ls -1 -l -a -r -R t_dir > our && "${FT_LS_PATH}" -l -a -r -R t_dir > your 139 | if !(diff --brief your our) || !($SUCCESS) then 140 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -l -a -r -R\033[0m\n\n" 141 | diff your our 142 | else 143 | printf "\n\033[32mSuccess:\t\033[37;1m ls -l -a -r -R\033[0m\n\n" 144 | fi 145 | 146 | SUCCESS= /bin/ls -1 -l -a -r -R -t t_dir > our && "${FT_LS_PATH}" -l -a -r -R -t t_dir > your 147 | if !(diff --brief your our) || !($SUCCESS) then 148 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -l -a -r -R -t\033[0m\n\n" 149 | diff your our 150 | else 151 | printf "\n\033[32mSuccess:\t\033[37;1m ls -l -a -r -R -t\033[0m\n\n" 152 | fi 153 | 154 | [ "${INTERACTIVE_MODE}" -eq "1" ] && printf "\n\n\033[1;37mPlease press a key to continue :D: \033[0m" && read 155 | 156 | # -------------------------------------------------------------------------------------------------------------- # 157 | # -------------------------------------------------------------------------------------------------------------- # 158 | # TEST_3 ------------------------------------------------------------------------------------------------ # 159 | # -------------------------------------------------------------------------------------------------------------- # 160 | # -------------------------------------------------------------------------------------------------------------- # 161 | 162 | [ "${INTERACTIVE_MODE}" -eq "1" ] && clear 163 | 164 | printf "\033[44m\033[1;37m" 165 | 166 | printf "# **************************************************************************** #\n" 167 | printf "# #\n" 168 | printf "# ::: :::::::: #\n" 169 | printf "# :+: :+: :+: #\n" 170 | printf "# +:+ +:+ +:+ #\n" 171 | printf "# ~ TEST WITH JOINED ARGUMENTS ~ +#+ +:+ +#+ #\n" 172 | printf "# +#+#+#+#+#+ +#+ #\n" 173 | printf "# #+# #+# #\n" 174 | printf "# ### ########.fr #\n" 175 | printf "# #\n" 176 | printf "# **************************************************************************** #\n\n\n" 177 | 178 | printf "\033[0m" 179 | 180 | SUCCESS= /bin/ls -1 -la t_dir > our && "${FT_LS_PATH}" -la t_dir > your 181 | if !(diff --brief your our) || !($SUCCESS) then 182 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -la\033[0m\n\n" 183 | diff your our 184 | else 185 | printf "\n\033[32mSuccess:\t\033[37;1m ls -la\033[0m\n\n" 186 | fi 187 | 188 | SUCCESS= /bin/ls -1 -rla t_dir > our && "${FT_LS_PATH}" -rla t_dir > your 189 | if !(diff --brief your our) || !($SUCCESS) then 190 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -rla\033[0m\n\n" 191 | diff your our 192 | else 193 | printf "\n\033[32mSuccess:\t\033[37;1m ls -rla\033[0m\n\n" 194 | fi 195 | 196 | SUCCESS= /bin/ls -1 -rlRa t_dir > our && "${FT_LS_PATH}" -rlRa t_dir > your 197 | if !(diff --brief your our) || !($SUCCESS) then 198 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -rlRa\033[0m\n\n" 199 | diff your our 200 | else 201 | printf "\n\033[32mSuccess:\t\033[37;1m ls -rlRa\033[0m\n\n" 202 | fi 203 | 204 | SUCCESS= /bin/ls -1 -trlRa t_dir > our && "${FT_LS_PATH}" -trlRa t_dir > your 205 | if !(diff --brief your our) || !($SUCCESS) then 206 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -trlRa\033[0m\n\n" 207 | diff your our 208 | else 209 | printf "\n\033[32mSuccess:\t\033[37;1m ls -trlRa\033[0m\n\n" 210 | fi 211 | 212 | [ "${INTERACTIVE_MODE}" -eq "1" ] && printf "\n\n\033[1;37mPlease press a key to continue :D: \033[0m" && read 213 | 214 | # -------------------------------------------------------------------------------------------------------------- # 215 | # -------------------------------------------------------------------------------------------------------------- # 216 | # TEST_4 ------------------------------------------------------------------------------------------------ # 217 | # -------------------------------------------------------------------------------------------------------------- # 218 | # -------------------------------------------------------------------------------------------------------------- # 219 | 220 | [ "${INTERACTIVE_MODE}" -eq "1" ] && clear 221 | 222 | printf "\033[44m\033[1;37m" 223 | 224 | printf "# **************************************************************************** #\n" 225 | printf "# #\n" 226 | printf "# ::: :::::::: #\n" 227 | printf "# :+: :+: :+: #\n" 228 | printf "# +:+ +:+ +:+ #\n" 229 | printf "# ~ TESTS THAT FAILS IN /bin/ls -1 ~ +#+ +:+ +#+ #\n" 230 | printf "# +#+#+#+#+#+ +#+ #\n" 231 | printf "# #+# #+# #\n" 232 | printf "# ### ########.fr #\n" 233 | printf "# #\n" 234 | printf "# **************************************************************************** #\n\n\n" 235 | 236 | printf "\033[0m" 237 | 238 | /bin/ls -. t_dir > our 2> our2 239 | OUR_RET=($?) 240 | "${FT_LS_PATH}" -. t_dir > your 2> your2 241 | YOUR_RET=($?) 242 | if [ $OUR_RET -ne $YOUR_RET ]; then 243 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -.\033[0m\n\n" 244 | printf "/bin/ls return: %d | ft_ls return: %d\n\n" $OUR_RET $YOUR_RET 245 | elif [ $OUR_RET -ne 0 ] && [ $(wc -l < our2) -ne 0 ] && [ $(wc -l < your2) -eq 0 ]; then 246 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -.\033[0m\n\n" 247 | diff your2 our2 248 | elif !(diff --brief your our) then 249 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -.\033[0m\n\n" 250 | diff your our 251 | else 252 | printf "\n\033[32mSuccess:\t\033[37;1m ls -.\033[0m\n\n" 253 | fi 254 | 255 | /bin/ls -1 -l. t_dir > our 2> our2 256 | OUR_RET=($?) 257 | "${FT_LS_PATH}" -l. t_dir > your 2> your2 258 | YOUR_RET=($?) 259 | if [ $OUR_RET -ne $YOUR_RET ]; then 260 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -l.\033[0m\n\n" 261 | printf "/bin/ls return: %d | ft_ls return: %d\n\n" $OUR_RET $YOUR_RET 262 | elif [ $OUR_RET -ne 0 ] && [ $(wc -l < our2) -ne 0 ] && [ $(wc -l < your2) -eq 0 ]; then 263 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -l.\033[0m\n\n" 264 | diff your2 our2 265 | elif !(diff --brief your our) then 266 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -l.\033[0m\n\n" 267 | diff your our 268 | else 269 | printf "\n\033[32mSuccess:\t\033[37;1m ls -l.\033[0m\n\n" 270 | fi 271 | 272 | /bin/ls -1 -.r t_dir > our 2> our2 273 | OUR_RET=($?) 274 | "${FT_LS_PATH}" -.r t_dir > your 2> your2 275 | YOUR_RET=($?) 276 | if [ $OUR_RET -ne $YOUR_RET ]; then 277 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -.r\033[0m\n\n" 278 | printf "/bin/ls return: %d | ft_ls return: %d\n\n" $OUR_RET $YOUR_RET 279 | elif [ $OUR_RET -ne 0 ] && [ $(wc -l < our2) -ne 0 ] && [ $(wc -l < your2) -eq 0 ]; then 280 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -.r\033[0m\n\n" 281 | diff your2 our2 282 | elif !(diff --brief your our) then 283 | printf "\r\n\033[31mError:\t\t\033[0m\033[37;1m ls -.r\033[0m\n\n" 284 | diff your our 285 | else 286 | printf "\n\033[32mSuccess:\t\033[37;1m ls -.r\033[0m\n\n" 287 | fi 288 | 289 | [ "${INTERACTIVE_MODE}" -eq "1" ] && printf "\n\n\033[1;37mPlease press a key to continue :D: \033[0m" && read 290 | 291 | rm -f your2 292 | rm -f our2 293 | rm -f your 294 | rm -f our 295 | -------------------------------------------------------------------------------- /ft_ls/t_dir/.president: -------------------------------------------------------------------------------- 1 | Nicolas Sadirac 2 | -------------------------------------------------------------------------------- /ft_ls/t_dir/42: -------------------------------------------------------------------------------- 1 | 42 2 | -------------------------------------------------------------------------------- /ft_ls/t_dir/couloir: -------------------------------------------------------------------------------- 1 | Au long loin du long couloir 2 | cake batie aux anneaux de vitres 3 | et rail lissé d'entre-deux portes closes 4 | La ligne d'un iris ceinture-de-feux 5 | le tien 6 | irradie le tapis rouge où mes pas 7 | tentent d'inscrire mon ch'min. 8 | 9 | Explosion. 10 | C'est un volcan de tes yeux, 11 | miroirs sans teints convalescents, 12 | qui, enfin, éclate : 13 | chakra... 14 | 15 | Coulée de lave qui savonne 16 | l'épiderme du sol, 17 | Coulée brulis de la grande verte vierge 18 | Rougeoiment feuillu d'été amérindien. 19 | C'est la joie et le plaisir violents 20 | illuminant le monde, 21 | notre monde. 22 | 23 | Sur la fusion dansante des entrailles mellifuges 24 | notre jeune chat 25 | - notre vrai chat - 26 | avance serein sur les flammes, 27 | comme un christ se jouant de la gravité. 28 | 29 | Parce qu'il ne brule-hurle pas de douleur, je sais : 30 | rêve. Un des miens. 31 | -------------------------------------------------------------------------------- /ft_ls/t_dir/ln_couloir: -------------------------------------------------------------------------------- 1 | couloir -------------------------------------------------------------------------------- /getnextline/cmp.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/QuentinPerez/Maintest/999b91d2ff3154a0bfe7188f21c9de05a36c0095/getnextline/cmp.txt -------------------------------------------------------------------------------- /getnextline/main.c: -------------------------------------------------------------------------------- 1 | /* ************************************************************************** */ 2 | /* */ 3 | /* ::: :::::::: */ 4 | /* main.c :+: :+: :+: */ 5 | /* +:+ +:+ +:+ */ 6 | /* By: student@42 <@student.42.fr> +#+ +:+ +#+ */ 7 | /* +#+#+#+#+#+ +#+ */ 8 | /* Created: 2013/12/01 22:10:06 by student@42 #+# #+# */ 9 | /* Updated: 2013/12/03 13:35:51 by qperez ### ########.fr */ 10 | /* */ 11 | /* ************************************************************************** */ 12 | 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | int get_next_line(int fd, char **line); 21 | 22 | int main(int argc, char ** argv) 23 | { 24 | int fd; 25 | int fd2; 26 | char *line; 27 | pid_t child; 28 | char n = '\n'; 29 | 30 | if (argc < 2) 31 | { 32 | printf("Usage %s \n", argv[0]); 33 | return (1); 34 | } 35 | fd = open(argv[1], O_RDONLY); 36 | fd2 = open("me.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666); 37 | if (fd == -1 || fd2 == -1) 38 | { 39 | perror("open"); 40 | close(fd); 41 | close(fd2); 42 | return (-1); 43 | } 44 | while (get_next_line(fd, &line) == 1) 45 | { 46 | write(fd2, line, strlen(line)); 47 | write(fd2, &n, 1); // attention si le fichier test n a pas de \n et que ca affiche une erreur c'est normal 48 | free(line); // vous inquietez pas 49 | } 50 | close(fd); 51 | close(fd2); 52 | child = fork(); 53 | if (child == 0) 54 | { 55 | char *arg[] = {"/usr/bin/diff", NULL, "me.txt", NULL}; 56 | 57 | arg[1] = argv[1]; 58 | execve(arg[0], arg, NULL); 59 | exit(0); 60 | } 61 | else 62 | wait(NULL); // bad code I know ... but it's not the project 63 | (void)argc; 64 | (void)argv; 65 | return (0); 66 | } 67 | 68 | -------------------------------------------------------------------------------- /libft/main.c: -------------------------------------------------------------------------------- 1 | /* ************************************************************************** */ 2 | /* */ 3 | /* ::: :::::::: */ 4 | /* main.c :+: :+: :+: */ 5 | /* +:+ +:+ +:+ */ 6 | /* By: student@42 <@student.42.fr> +#+ +:+ +#+ */ 7 | /* +#+#+#+#+#+ +#+ */ 8 | /* Created: 2013/11/22 14:43:06 by student@42 #+# #+# */ 9 | /* Updated: 2015/12/07 14:50:01 by ### ########.fr */ 10 | /* */ 11 | /* ************************************************************************** */ 12 | 13 | /* 14 | * 15 | * Salut la nouvelle promo merci de remercier les contributeurs 16 | * 17 | * https://github.com/QuentinPerez 18 | * https://github.com/mfontain 19 | * https://github.com/alex8092 20 | * https://github.com/gabtoubl 21 | * https://github.com/soyel 22 | * https://github.com/stherman 23 | * https://github.com/jplot 24 | * 25 | */ 26 | 27 | /* 28 | ** author : qperez 29 | ** HardCore + strtrim + Fixes: mfontain 30 | ** Fixes strsplit, strequ: gabtoubl 31 | ** Fixes strsplit, strjoin, strsub, strtrim, itoa, strequ, strnequ: stherman 32 | ** Crash handle : ele-goug 33 | ** Detailed error messages : jpucelle 34 | ** 35 | ** Any segfault ? Probably caused by a NULL test. ex : ft_memset(NULL, 0, 0); 36 | */ 37 | 38 | #ifdef __linux__ 39 | #define SIGEMT 7 40 | #endif 41 | 42 | #include 43 | #include 44 | #include 45 | #include 46 | #include 47 | #include 48 | #include 49 | #include 50 | 51 | #include /* compile with -I./ */ 52 | 53 | #define D_ERROR { printf("Error Line %d, Funct %s ", __LINE__ - 1, __func__); return (0); } 54 | #define D_ADD_HCTEST(name) uf_add_test(test, "\033[33m"#name"\033[0m", uf_test_##name); 55 | #define D_ADD_TEST(name) uf_add_test(test, #name, uf_test_##name); 56 | #define D_TEST 60 57 | #define RANDT 512 58 | #define LONG 10000 59 | 60 | int uf_test_strtrim(void); 61 | int uf_test_strsplit(void); 62 | int uf_test_strjoin(void); 63 | int uf_test_strsub(void); 64 | int uf_test_itoa(void); 65 | int uf_test_strnequ(void); 66 | int uf_test_strequ(void); 67 | int uf_test_strmapi(void); 68 | int uf_test_strmap(void); 69 | int uf_test_striteri(void); 70 | int uf_test_striter(void); 71 | int uf_test_strclr(void); 72 | int uf_test_strdel(void); 73 | int uf_test_strnew(void); 74 | int uf_test_memalloc_and_del(void); 75 | int uf_test_tolower(void); 76 | int uf_test_toupper(void); 77 | int uf_test_isprint(void); 78 | int uf_test_isascii(void); 79 | int uf_test_isalnum(void); 80 | int uf_test_isdigit(void); 81 | int uf_test_isalpha(void); 82 | int uf_test_atoi(void); 83 | int uf_test_strncmp(void); 84 | int uf_test_strcmp(void); 85 | int uf_test_strnstr(void); 86 | int uf_test_strstr(void); 87 | int uf_test_strrchr(void); 88 | int uf_test_strchr(void); 89 | int uf_test_strlcat(void); 90 | int uf_test_strncat(void); 91 | int uf_test_strcat(void); 92 | int uf_test_strncpy(void); 93 | int uf_test_strcpy(void); 94 | int uf_test_strdup(void); 95 | int uf_test_strlen(void); 96 | int uf_test_memmove(void); 97 | int uf_test_memchr(void); 98 | int uf_test_memcmp(void); 99 | int uf_test_memccpy(void); 100 | int uf_test_memcpy(void); 101 | int uf_test_memset(void); 102 | int uf_test_bzero(void); 103 | int uf_test_lstnew(void); 104 | int uf_test_lstdelone(void); 105 | int uf_test_lstdel(void); 106 | int uf_test_lstadd(void); 107 | int uf_test_lstiter(void); 108 | int uf_test_lstmap(void); 109 | 110 | typedef struct s_test 111 | { 112 | const char *name; 113 | int (*funct)(void); 114 | bool set; 115 | } t_test; 116 | 117 | void uf_add_test(t_test *test, const char *name, int (*funct)(void)) 118 | { 119 | static int i = 0; 120 | 121 | test[i].name = name; 122 | test[i].funct = funct; 123 | test[i].set = true; 124 | test[i + 1].set = false; 125 | i = i + 1; 126 | } 127 | 128 | int main(void) 129 | { 130 | int i; 131 | t_test test[D_TEST]; 132 | int status; 133 | pid_t pid; 134 | 135 | srand(time(NULL)); 136 | printf("[\033[33mYellow Tests\033[0m] are Hardcore\n"); 137 | i = 0; 138 | memset(test, 0, D_TEST); 139 | /* 140 | * Si vous n'avez pas la fonction il suffit de mettre en commentaire 141 | */ 142 | /* 143 | * Example : vous n'avez pas memset vous commentez 144 | * // #define D_MEMSET 145 | * // D_ADD_TEST(...) 146 | */ 147 | #define D_MEMSET 148 | D_ADD_HCTEST(memset); 149 | #define D_BZERO 150 | D_ADD_HCTEST(bzero); 151 | #define D_MEMCPY 152 | D_ADD_HCTEST(memcpy); 153 | #define D_MEMCCPY 154 | D_ADD_HCTEST(memccpy); 155 | #define D_MEMMOVE 156 | D_ADD_HCTEST(memmove); 157 | #define D_MEMCHR 158 | D_ADD_HCTEST(memchr); 159 | #define D_MEMCMP 160 | D_ADD_HCTEST(memcmp); 161 | #define D_STRLEN 162 | D_ADD_TEST(strlen); 163 | #define D_STRDUP 164 | D_ADD_TEST(strdup); 165 | #define D_STRCPY 166 | D_ADD_HCTEST(strcpy); 167 | #define D_STRNCPY 168 | D_ADD_HCTEST(strncpy); 169 | #define D_STRCAT 170 | D_ADD_TEST(strcat); 171 | #define D_STRNCAT 172 | D_ADD_TEST(strncat); 173 | #ifndef __linux 174 | #define D_STRLCAT 175 | D_ADD_TEST(strlcat); 176 | #endif 177 | #define D_STRCHR 178 | D_ADD_TEST(strchr); 179 | #define D_STRRCHR 180 | D_ADD_TEST(strrchr); 181 | #define D_STRSTR 182 | D_ADD_TEST(strstr); 183 | #ifndef __linux 184 | #define D_STRNSTR 185 | D_ADD_TEST(strnstr); 186 | #endif 187 | #define D_STRCMP 188 | D_ADD_TEST(strcmp); 189 | #define D_STRNCMP 190 | D_ADD_TEST(strncmp); 191 | #define D_ATOI 192 | D_ADD_HCTEST(atoi); 193 | #define D_ISALPHA 194 | D_ADD_HCTEST(isalpha); 195 | #define D_ISDIGIT 196 | D_ADD_HCTEST(isdigit); 197 | #define D_ISALNUM 198 | D_ADD_HCTEST(isalnum); 199 | #define D_ISASCII 200 | D_ADD_HCTEST(isascii); 201 | #define D_ISPRINT 202 | D_ADD_HCTEST(isprint); 203 | #define D_TOUPPER 204 | D_ADD_HCTEST(toupper); 205 | #define D_TOLOWER 206 | D_ADD_HCTEST(tolower); 207 | #define D_MEMALLOC_AND_DEL 208 | D_ADD_TEST(memalloc_and_del); 209 | #define D_STRNEW 210 | D_ADD_TEST(strnew); 211 | #define D_STRDEL 212 | D_ADD_TEST(strdel); 213 | #define D_STRCLR 214 | D_ADD_TEST(strclr); 215 | #define D_STRITER 216 | D_ADD_TEST(striter); 217 | #define D_STRITERI 218 | D_ADD_TEST(striteri); 219 | #define D_STRMAP 220 | D_ADD_TEST(strmap); 221 | #define D_STRMAPI 222 | D_ADD_TEST(strmapi); 223 | #define D_STREQU 224 | D_ADD_TEST(strequ); 225 | #define D_STRNEQU 226 | D_ADD_TEST(strnequ); 227 | #define D_STRSUB 228 | D_ADD_TEST(strsub); 229 | #define D_STRJOIN 230 | D_ADD_TEST(strjoin); 231 | #define D_STRSPLIT 232 | D_ADD_TEST(strsplit); 233 | #define D_ITOA 234 | D_ADD_TEST(itoa); 235 | #define D_STRTRIM 236 | D_ADD_TEST(strtrim); 237 | #define D_LSTNEW 238 | D_ADD_TEST(lstnew); 239 | #define D_LSTDELONE 240 | D_ADD_TEST(lstdelone); 241 | #define D_LSTDEL 242 | D_ADD_TEST(lstdel); 243 | #define D_LSTADD 244 | D_ADD_TEST(lstadd); 245 | #define D_LSTITER 246 | D_ADD_TEST(lstiter); 247 | #define D_LSTMAP 248 | D_ADD_TEST(lstmap); 249 | while (test[i].set == true) 250 | { 251 | printf("Test [%s] : ", test[i].name); 252 | fflush(stdout); 253 | if ((pid = fork()) == 0) 254 | { 255 | if (test[i].funct() == 0) 256 | printf("\033[31mFAIL\033[0m\n"); 257 | else 258 | printf("\033[32mOK\033[0m\n"); 259 | exit(0); 260 | } 261 | if (pid == -1) 262 | printf("\033[33mUNABLE TO FORK\033[0m\n"); 263 | else 264 | { 265 | if (waitpid(pid, &status, 0) != -1) 266 | { 267 | if (WIFSIGNALED(status)) 268 | { 269 | if (WTERMSIG(status) == SIGSEGV) 270 | printf("\033[33mSegmentation Fault\033[0m\n"); 271 | else if (WTERMSIG(status) == SIGEMT) 272 | printf("\033[33mBus Error\033[0m\n"); 273 | else if (WTERMSIG(status) == SIGILL) 274 | printf("\033[33mIllegal Instruction\033[0m\n"); 275 | else 276 | printf("\033[33mThe processus receive the signal %d\033[0m\n", WTERMSIG(status)); 277 | } 278 | } 279 | else 280 | perror("Waitpid"); 281 | } 282 | i = i + 1; 283 | } 284 | return (0); 285 | } 286 | 287 | void uf_del_callback(void *d, size_t s) 288 | { 289 | free(d); 290 | (void)s; 291 | } 292 | 293 | /* 294 | ** Thx pmotte for the test 295 | */ 296 | 297 | #ifdef D_LSTMAP 298 | 299 | t_list *uf_testmap(t_list *elem) 300 | { 301 | t_list *new; 302 | char *content; 303 | size_t i; 304 | 305 | content = ft_strdup((char *)(elem->content)); 306 | i = 0; 307 | while (i < ft_strlen(content)) 308 | { 309 | content[i] += 1; 310 | ++i; 311 | } 312 | new = ft_lstnew((void const *) content, 5); 313 | free(content); 314 | return (new); 315 | } 316 | 317 | int uf_test_lstmap(void) 318 | { 319 | t_list *lst_initial; 320 | t_list *lst; 321 | char *content; 322 | t_list *(*f)(t_list *); 323 | 324 | content = "toto"; 325 | lst_initial = ft_lstnew((void const *) content, 5); 326 | content = "tata"; 327 | lst_initial->next = ft_lstnew((void const *) content, 5); 328 | content = "tutu"; 329 | lst_initial->next->next = ft_lstnew((void const *) content, 5); 330 | f = &uf_testmap; 331 | lst = ft_lstmap(lst_initial, f); 332 | if (!strcmp((const char *) lst->content, (const char *) lst_initial->content) || strcmp((const char *) lst->content, "upup")) 333 | D_ERROR; 334 | if (!strcmp((const char *) lst->next->content, (const char *) lst_initial->next->content) || strcmp((const char *) lst->next->content, "ubub")) 335 | D_ERROR; 336 | if (!strcmp((const char *) lst->next->next->content, (const char *) lst_initial->next->next->content) || strcmp((const char *) lst->next->next->content, "uvuv")) 337 | D_ERROR; 338 | return (1); 339 | } 340 | #endif 341 | 342 | #ifdef D_LSTITER 343 | void uf_iter_callback(t_list *v) 344 | { 345 | *(size_t*)v->content = *(size_t*)v->content + 1; 346 | } 347 | 348 | int uf_test_lstiter(void) 349 | { 350 | t_list *begin; 351 | size_t v; 352 | size_t w; 353 | 354 | v = 1; 355 | w = 2; 356 | begin = ft_lstnew(&v, sizeof(size_t)); 357 | begin->next = ft_lstnew(&w, sizeof(size_t)); 358 | ft_lstiter(begin, uf_iter_callback); 359 | if (*(size_t*)begin->content != 2) 360 | D_ERROR; 361 | if (*(size_t*)begin->next->content != 3) 362 | D_ERROR; 363 | free(begin->next); 364 | free(begin); 365 | return (1); 366 | } 367 | #endif 368 | 369 | #ifdef D_LSTADD 370 | int uf_test_lstadd(void) 371 | { 372 | t_list *begin; 373 | t_list *add; 374 | t_list *tmp; 375 | size_t v; 376 | 377 | v = 1; 378 | begin = ft_lstnew(&v, sizeof(size_t)); 379 | tmp = begin; 380 | add = ft_lstnew(&v, sizeof(size_t)); 381 | ft_lstadd(&begin, add); 382 | if (begin != add) 383 | D_ERROR; 384 | if (begin->next != tmp) 385 | D_ERROR; 386 | free(begin->next); 387 | free(begin); 388 | return (1); 389 | } 390 | #endif 391 | 392 | #ifdef D_LSTDELONE 393 | int uf_test_lstdelone(void) 394 | { 395 | t_list *begin; 396 | size_t v; 397 | 398 | v = 1; 399 | begin = ft_lstnew(&v, sizeof(void *)); 400 | begin->next = ft_lstnew(&v, sizeof(void *)); 401 | begin->next->next = ft_lstnew(&v, sizeof(void *)); 402 | ft_lstdelone(&begin->next->next, uf_del_callback); 403 | if (begin->next->next != NULL) 404 | D_ERROR; 405 | ft_lstdelone(&begin->next, uf_del_callback); 406 | if (begin->next != NULL) 407 | D_ERROR; 408 | ft_lstdelone(&begin, uf_del_callback); 409 | if (begin != NULL) 410 | D_ERROR; 411 | return (1); 412 | } 413 | #endif 414 | 415 | #ifdef D_LSTDEL 416 | int uf_test_lstdel(void) 417 | { 418 | t_list *begin; 419 | size_t v; 420 | 421 | v = 1; 422 | begin = ft_lstnew(&v, sizeof(void *)); 423 | begin->next = ft_lstnew(&v, sizeof(void *)); 424 | begin->next->next = ft_lstnew(&v, sizeof(void *)); 425 | ft_lstdel(&begin, uf_del_callback); 426 | if (begin != NULL) 427 | D_ERROR; 428 | return (1); 429 | } 430 | #endif 431 | 432 | #ifdef D_LSTNEW 433 | int uf_test_lstnew(void) 434 | { 435 | t_list *begin; 436 | size_t v; 437 | 438 | v = 1; 439 | begin = ft_lstnew(NULL, 36); 440 | if (begin != 0 && (begin->content_size != 0 || begin->content != NULL)) 441 | D_ERROR; 442 | free(begin); 443 | begin = ft_lstnew(&v, sizeof(size_t)); 444 | if (begin != NULL) 445 | { 446 | if (&v == begin->content) 447 | D_ERROR; 448 | if (*(size_t*)begin->content != 1) 449 | D_ERROR; 450 | if (begin->content_size != sizeof(size_t)) 451 | D_ERROR; 452 | if (begin->next != 0) 453 | D_ERROR; 454 | } 455 | free(begin); 456 | return (1); 457 | } 458 | #endif 459 | 460 | int uf_free_tab(void **tab) 461 | { 462 | unsigned int i; 463 | 464 | if (tab == NULL) 465 | return (0); 466 | i = 0; 467 | while (tab[i] != NULL) 468 | { 469 | free(tab[i]); 470 | i = i + 1; 471 | } 472 | free(tab); 473 | return (1); 474 | } 475 | 476 | #ifdef D_STRTRIM 477 | int uf_test_strtrim(void) 478 | { 479 | char str[] = " \t \t\nBon\t \njour\t\n \n "; 480 | char str2[] = "Bonjour"; 481 | char str3[] = " \t\t\t "; 482 | char *r; 483 | 484 | ft_strtrim(NULL); 485 | r = ft_strtrim(str); 486 | if (strcmp(r, "Bon\t \njour")) 487 | { 488 | printf("Error Line %d, Funct %s : \n\033[31mft_strstrim(\" \t \t\nBon\t \njour\t\n \n \").\nExpected ret = \"Bon\t \njour\" \ 489 | but have ret = \"%s\"\033[0m\n", __LINE__ - 2, __func__, r); 490 | free(r); 491 | return (0); 492 | } 493 | free(r); 494 | r = ft_strtrim(str2); 495 | if (strcmp(r, "Bonjour") || (str2 == r)) 496 | { 497 | printf("Error Line %d, Funct %s : \n\033[31mft_strstrim(\"Bonjour\").\nExpected ret = \"Bonjour\" and differents pointers\ 498 | but have ret = \"%s\" and our: %p / your: %p\033[0m\n", __LINE__ - 2, __func__, r, str2, r); 499 | free(r); 500 | return (0); 501 | } 502 | free(r); 503 | r = ft_strtrim(str3); 504 | if (strcmp(r, "") || (str3 == r)) 505 | { 506 | printf("Error Line %d, Funct %s : \n\033[31mft_strstrim(\" \t\t\t \").\nExpected ret = \"\" and different\ 507 | s pointers but have ret = \"%s\" and our: %p / your: %p\033[0m\n", __LINE__ - 2, __func__, r, str3, r); 508 | free(r); 509 | return (0); 510 | } 511 | free(r); 512 | return (1); 513 | } 514 | #endif 515 | 516 | #ifdef D_STRSPLIT 517 | int uf_test_strsplit(void) 518 | { 519 | char **ret; 520 | 521 | ft_strsplit(NULL, 0); 522 | ft_strsplit(NULL, 'a'); 523 | ret = ft_strsplit("", '*'); 524 | if (ret == NULL || ret[0] != NULL) 525 | { 526 | printf("Error Line %d, Funct %s : \ 527 | \nYour function has return NULL or the first pointer in your tab is NULL\n", __LINE__ - 2, __func__); 528 | uf_free_tab((void **)ret); 529 | return (0); 530 | } 531 | uf_free_tab((void **)ret); 532 | ret = ft_strsplit("*********", '*'); 533 | if (ret == NULL || ret[0] != NULL) 534 | { 535 | printf("Error Line %d, Funct %s : \ 536 | \nYour function has return NULL or the first pointer in your tab is NULL\n", __LINE__ - 2, __func__); 537 | uf_free_tab((void **)ret); 538 | return (0); 539 | } 540 | if (uf_free_tab((void **)ret) == 0) 541 | { 542 | printf("Error Line %d, Funct %s : \nUnable to free your tab in first test\n", __LINE__ - 2, __func__); 543 | return (0); 544 | } 545 | ret = ft_strsplit("hello", '*'); 546 | if (ret[1] != NULL && strcmp(ret[0], "hello") != 0) 547 | { 548 | printf("Error Line %d, Funct %s : \n\033[31mft_strsplit(\"hello\", '*').\nExpected tab[0] = \"hello\" and tab[1] = NULL \ 549 | but have tab[0] = \"%s\" and tab[1] = \"%s\"\033[0m\n", __LINE__ - 2, __func__, ret[0], ret[1]); 550 | uf_free_tab((void **)ret); 551 | return (0); 552 | } 553 | if (uf_free_tab((void **)ret) == 0) 554 | { 555 | printf("Error Line %d, Funct %s : \n\033[31mUnable to free your tab in second test\033[0m\n", __LINE__ - 2, __func__); 556 | return (0); 557 | } 558 | ret = ft_strsplit("*hello", '*'); 559 | if (ret[1] != NULL && strcmp(ret[0], "hello") != 0) 560 | { 561 | printf("Error Line %d, Funct %s : \n\033[31mft_strsplit(\"*hello\", '*').\nExpected tab[0] = \"hello\" and tab[1] = NULL \ 562 | but have tab[0] = \"%s\" and tab[1] = \"%s\"\033[0m\n", __LINE__ - 2, __func__, ret[0], ret[1]); 563 | uf_free_tab((void **)ret); 564 | return (0); 565 | } 566 | if (uf_free_tab((void **)ret) == 0) 567 | { 568 | printf("Error Line %d, Funct %s : \n\033[31mUnable to free your tab in third test\033[0m\n", __LINE__ - 2, __func__); 569 | return (0); 570 | } 571 | ret = ft_strsplit("*hello*", '*'); 572 | if (ret[1] != NULL && strcmp(ret[0], "hello") != 0) 573 | { 574 | printf("Error Line %d, Funct %s : \n\033[31mft_strsplit(\"*hello*\", '*').\nExpected tab[0] = \"hello\" and tab[1] = NULL \ 575 | but have tab[0] = \"%s\" and tab[1] = \"%s\"\033[0m\n", __LINE__ - 2, __func__, ret[0], ret[1]); 576 | uf_free_tab((void **)ret); 577 | return (0); 578 | } 579 | if (uf_free_tab((void **)ret) == 0) 580 | { 581 | printf("Error Line %d, Funct %s : \n\033[31mUnable to free your tab in third test\033[0m\n", __LINE__ - 2, __func__); 582 | return (0); 583 | } 584 | ret = ft_strsplit("*hel*lo*", '*'); 585 | if (ret[2] != NULL && strcmp(ret[0], "hel") != 0 && strcmp(ret[1], "lo") != 0) 586 | { 587 | printf("Error Line %d, Funct %s : \n\033[31mft_strsplit(\"*hel*lo*\", '*').\nExpected tab[0] = \"hel\", tab[1] = \"lo\" and tab[2] = NULL \ 588 | but have tab[0] = \"%s\", tab[1] = \"%s\" and tab[2] = \"%s\"\033[0m\n", __LINE__ - 2, __func__, ret[0], ret[1], ret[2]); 589 | uf_free_tab((void **)ret); 590 | return (0); 591 | } 592 | if (uf_free_tab((void **)ret) == 0) 593 | { 594 | printf("Error Line %d, Funct %s : \n\033[31mUnable to free your tab in fourth test\033[0m\n", __LINE__ - 2, __func__); 595 | return (0); 596 | } 597 | ret = ft_strsplit("*hel*lo*f", '*'); 598 | if (ret[3] != NULL && strcmp(ret[0], "hel") != 0 && strcmp(ret[1], "lo") != 0 && 599 | strcmp(ret[2], "f") != 0) 600 | { 601 | printf("Error Line %d, Funct %s : \n\033[31mft_strsplit(\"*hel*lo*f\", '*').\nExpected tab[0] = \"hel\", tab[1] = \"lo\", tab[2] = \"f\" and tab[3] = NULL \ 602 | but have tab[0] = \"%s\", tab[1] = \"%s\", tab[2] = \"%s\" and tab[3] = \"%s\"\033[0m\n", __LINE__ - 2, __func__, ret[0], ret[1], ret[2], ret[3]); 603 | uf_free_tab((void **)ret); 604 | return (0); 605 | } 606 | if (uf_free_tab((void **)ret) == 0) 607 | { 608 | printf("Error Line %d, Funct %s : \n\033[31mUnable to free your tab in fifth test\033[0m\n", __LINE__ - 2, __func__); 609 | return (0); 610 | } 611 | ret = ft_strsplit("g*hel*lo*f", '*'); 612 | if (ret[4] != NULL && strcmp(ret[0], "g") != 0 && strcmp(ret[1], "hel") != 0 && 613 | strcmp(ret[2], "lo") != 0 && strcmp(ret[3], "f") != 0) 614 | { 615 | printf("Error Line %d, Funct %s : \n\033[31mft_strsplit(\"g*hel*lo*f\", '*').\nExpected tab[0] = \"g\", tab[1] = \"hel\", tab[2] = \"lo\", tab[3] = \"f\" and tab[4] = NULL \ 616 | but have tab[0] = \"%s\", tab[1] = \"%s\", tab[2] = \"%s\", tab[3] = \"%s\" and tab[4] = \"%s\"\033[0m\n", __LINE__ - 2, __func__, ret[0], ret[1], ret[2], ret[3], ret[4]); 617 | uf_free_tab((void **)ret); 618 | return (0); 619 | } 620 | if (uf_free_tab((void **)ret) == 0) 621 | { 622 | printf("Error Line %d, Funct %s : \n\033[31mUnable to free your tab in sixth test\033[0m\n", __LINE__ - 2, __func__); 623 | return (0); 624 | } 625 | ret = ft_strsplit("***hel****lo**", '*'); 626 | if (ret[2] != NULL && strcmp(ret[0], "hel") != 0 && strcmp(ret[1], "lo") != 0) 627 | { 628 | printf("Error Line %d, Funct %s : \n\033[31mft_strsplit(\"*hel****lo*\", '*').\nExpected tab[0] = \"hel\", tab[1] = \"lo\" and tab[2] = NULL \ 629 | but have tab[0] = \"%s\", tab[1] = \"%s\" and tab[2] = \"%s\"\033[0m\n", __LINE__ - 2, __func__, ret[0], ret[1], ret[2]); 630 | uf_free_tab((void **)ret); 631 | return (0); 632 | } 633 | if (uf_free_tab((void **)ret) == 0) 634 | { 635 | printf("Error Line %d, Funct %s : \n\033[31mUnable to free your tab in seventh test\033[0m\n", __LINE__ - 2, __func__); 636 | return (0); 637 | } 638 | return (1); 639 | } 640 | #endif 641 | 642 | #ifdef D_STRJOIN 643 | int uf_test_strjoin(void) 644 | { 645 | char *ret; 646 | 647 | ft_strjoin(NULL, NULL); 648 | ft_strjoin(NULL, ""); 649 | ft_strjoin("", NULL); 650 | ret = ft_strjoin("Hello ", "boys"); 651 | if (strcmp(ret, "Hello boys") != 0) 652 | { 653 | D_ERROR 654 | free(ret); 655 | return (0); 656 | } 657 | free(ret); 658 | ret = ft_strjoin("", "boys"); 659 | if (strcmp(ret, "boys") != 0) 660 | { 661 | D_ERROR 662 | free(ret); 663 | return (0); 664 | } 665 | free(ret); 666 | ret = ft_strjoin("Hello ", ""); 667 | if (strcmp(ret, "Hello ") != 0) 668 | { 669 | D_ERROR 670 | free(ret); 671 | return (0); 672 | } 673 | free(ret); 674 | ret = ft_strjoin("", ""); 675 | if (strcmp(ret, "") != 0) 676 | { 677 | D_ERROR 678 | free(ret); 679 | return (0); 680 | } 681 | free(ret); 682 | return (1); 683 | } 684 | #endif 685 | 686 | #ifdef D_STRSUB 687 | int uf_test_strsub(void) 688 | { 689 | char *ret; 690 | char str[] = "*Hello*"; 691 | 692 | ft_strsub(NULL, 0, 0); 693 | ft_strsub(NULL, 1, 0); 694 | ft_strsub(NULL, 1, 1); 695 | ft_strsub(NULL, 0, 1); 696 | ret = ft_strsub(str, 1, 5); 697 | if (strcmp(ret, "Hello") != 0) 698 | { 699 | D_ERROR 700 | return (0); 701 | } 702 | ret = ft_strsub(str, 3, 1); 703 | if (strcmp(ret, "l") != 0) 704 | { 705 | D_ERROR 706 | return (0); 707 | } 708 | return (1); 709 | } 710 | #endif 711 | 712 | void uf_striteri_callback(unsigned int i, char *s) 713 | { 714 | *s = *s + i; 715 | } 716 | 717 | void uf_striter_callback(char *s) 718 | { 719 | *s = *s + 1; 720 | } 721 | 722 | char uf_strmap_callback(char s) 723 | { 724 | return (s + 1); 725 | } 726 | 727 | char uf_strmapi_callback(unsigned int i, char s) 728 | { 729 | return (s + i); 730 | } 731 | 732 | #ifdef D_ITOA 733 | int uf_test_itoa(void) 734 | { 735 | char *ret; 736 | if (strcmp(ret = ft_itoa(0), "0") != 0) 737 | { 738 | printf("Error Line %d, Funct %s : \n\033[31mft_itoa(0).\nExpected ret = \"0\" \ 739 | but have ret = \"%s\"\033[0m\n", __LINE__ - 2, __func__, ret); 740 | free(ret); 741 | return (0); 742 | } 743 | free(ret); 744 | if (strcmp(ret = ft_itoa(-123), "-123") != 0) 745 | { 746 | printf("Error Line %d, Funct %s : \n\033[31mft_itoa(-123).\nExpected ret = \"-123\" \ 747 | but have ret = \"%s\"\033[0m\n", __LINE__ - 2, __func__, ret); 748 | free(ret); 749 | return (0); 750 | } 751 | free(ret); 752 | if (strcmp(ret = ft_itoa(123), "123") != 0) 753 | { 754 | printf("Error Line %d, Funct %s : \n\033[31mft_itoa(123).\nExpected ret = \"123\" \ 755 | but have ret = \"%s\"\033[0m\n", __LINE__ - 2, __func__, ret); 756 | free(ret); 757 | return (0); 758 | } 759 | free(ret); 760 | if (strcmp(ret = ft_itoa(-2147483648), "-2147483648") != 0) 761 | { 762 | printf("Error Line %d, Funct %s : \n\033[31mft_itoa(-2147483648).\nExpected ret = \"-2147483648\" \ 763 | but have ret = \"%s\"\033[0m\n", __LINE__ - 2, __func__, ret); 764 | free(ret); 765 | return (0); 766 | } 767 | free(ret); 768 | if (strcmp(ret = ft_itoa(2147483647), "2147483647") != 0) 769 | { 770 | printf("Error Line %d, Funct %s : \n\033[31mft_itoa(2147483647).\nExpected ret = \"2147483647\" \ 771 | but have ret = \"%s\"\033[0m\n", __LINE__ - 2, __func__, ret); 772 | free(ret); 773 | return (0); 774 | } 775 | free(ret); 776 | return (1); 777 | } 778 | #endif 779 | 780 | #ifdef D_STRNEQU 781 | int uf_test_strnequ(void) 782 | { 783 | int ret; 784 | 785 | ft_strnequ(NULL, NULL, 0); 786 | ft_strnequ(NULL, NULL, 1); 787 | ft_strnequ(NULL, "", 1); 788 | ft_strnequ("", NULL, 1); 789 | ret = 0; 790 | if ((ret = ft_strnequ("abc", "abc", 2)) != 1) 791 | { 792 | printf("Error Line %d, Funct %s : \n\033[31mft_strnequ(\"abc\", \"abc\", 2).\nExpected ret = \"1\" \ 793 | but have ret = \"%d\"\033[0m\n", __LINE__ - 2, __func__, ret); 794 | return (0); 795 | } 796 | if ((ret = ft_strnequ("cba", "abc", 2)) != 0) 797 | { 798 | printf("Error Line %d, Funct %s : \n\033[31mft_strnequ(\"cba\", \"abc\", 2).\nExpected ret = \"0\" \ 799 | but have ret = \"%d\"\033[0m\n", __LINE__ - 2, __func__, ret); 800 | return (0); 801 | } 802 | if ((ret = ft_strnequ("abc", "cba", 2)) != 0) 803 | { 804 | printf("Error Line %d, Funct %s : \n\033[31mft_strnequ(\"abc\", \"cba\", 2).\nExpected ret = \"0\" \ 805 | but have ret = \"%d\"\033[0m\n", __LINE__ - 2, __func__, ret); 806 | return (0); 807 | } 808 | if ((ret = ft_strnequ("abc", "abd", 2)) != 1) 809 | { 810 | printf("Error Line %d, Funct %s : \n\033[31mft_strnequ(\"abc\", \"abd\", 2).\nExpected ret = \"1\" \ 811 | but have ret = \"%d\"\033[0m\n", __LINE__ - 2, __func__, ret); 812 | return (0); 813 | } 814 | if ((ret = ft_strnequ("", "", 3)) != 1) 815 | { 816 | printf("Error Line %d, Funct %s : \n\033[31mft_strnequ(\"\", \"\", 3).\nExpected ret = \"1\" \ 817 | but have ret = \"%d\"\033[0m\n", __LINE__ - 2, __func__, ret); 818 | return (0); 819 | } 820 | return (1); 821 | } 822 | #endif 823 | 824 | #ifdef D_STREQU 825 | int uf_test_strequ(void) 826 | { 827 | int ret; 828 | char *str; 829 | 830 | ft_strequ(NULL, NULL); 831 | ft_strequ("", NULL); 832 | ft_strequ(NULL, ""); 833 | ret = 0; 834 | str = strdup("abc"); /* FIX un faux OK si l'user a mis "if s1 == s2 return 1;" */ 835 | if ((ret = ft_strequ(str, "abc")) != 1) 836 | { 837 | printf("Error Line %d, Funct %s : \n\033[31mft_strequ(\"abc\", \"abc\").\nExpected ret = \"1\" \ 838 | but have ret = \"%d\"\033[0m\n", __LINE__ - 2, __func__, ret); 839 | free(str); 840 | return (0); 841 | } 842 | free(str); 843 | if ((ret = ft_strequ("cba", "abc")) != 0) 844 | { 845 | printf("Error Line %d, Funct %s : \n\033[31mft_strequ(\"cba\", \"abc\").\nExpected ret = \"0\" \ 846 | but have ret = \"%d\"\033[0m\n", __LINE__ - 2, __func__, ret); 847 | return (0); 848 | } 849 | if ((ret = ft_strequ("abc", "cba")) != 0) 850 | { 851 | printf("Error Line %d, Funct %s : \n\033[31mft_strequ(\"abc\", \"cba\").\nExpected ret = \"0\" \ 852 | but have ret = \"%d\"\033[0m\n", __LINE__ - 2, __func__, ret); 853 | return (0); 854 | } 855 | if ((ret = ft_strequ("", "")) != 1) 856 | { 857 | printf("Error Line %d, Funct %s : \n\033[31mft_strequ(\"\", \"\").\nExpected ret = \"1\" \ 858 | but have ret = \"%d\"\033[0m\n", __LINE__ - 2, __func__, ret); 859 | return (0); 860 | } 861 | if ((ret = ft_strequ("abc", "abcd")) != 0) 862 | { 863 | printf("Error Line %d, Funct %s : \n\033[31mft_strequ(\"abc\", \"abcd\").\nExpected ret = \"0\" \ 864 | but have ret = \"%d\"\033[0m\n", __LINE__ - 2, __func__, ret); 865 | return (0); 866 | } 867 | if ((ret = ft_strequ("abcd", "abc")) != 0) 868 | { 869 | printf("Error Line %d, Funct %s : \n\033[31mft_strequ(\"abcd\", \"abc\").\nExpected ret = \"0\" \ 870 | but have ret = \"%d\"\033[0m\n", __LINE__ - 2, __func__, ret); 871 | return (0); 872 | } 873 | return (1); 874 | } 875 | #endif 876 | 877 | #ifdef D_STRMAPI 878 | int uf_test_strmapi(void) 879 | { 880 | char str[] = "Hello"; 881 | char empty[] = ""; 882 | char *ret; 883 | 884 | ft_strmapi(NULL, NULL); 885 | ft_strmapi(empty, NULL); 886 | ret = ft_strmapi(str, uf_strmapi_callback); 887 | if (strcmp(ret, "Hfnos") != 0) 888 | { 889 | printf("Error Line %d, Funct %s ", __LINE__ - 1, __func__); 890 | free(ret); 891 | return (0); 892 | } 893 | free(ret); 894 | return (1); 895 | } 896 | #endif 897 | 898 | #ifdef D_STRMAP 899 | int uf_test_strmap(void) 900 | { 901 | char str[] = "Hello"; 902 | char *ret; 903 | 904 | ft_strmap(NULL, NULL); 905 | ft_strmap("", NULL); 906 | ret = ft_strmap(str, uf_strmap_callback); 907 | if (strcmp(ret, "Ifmmp") != 0) 908 | { 909 | printf("Error Line %d, Funct %s ", __LINE__ - 1, __func__); 910 | free(ret); 911 | return (0); 912 | } 913 | free(ret); 914 | return (1); 915 | } 916 | #endif 917 | 918 | #ifdef D_STRITERI 919 | int uf_test_striteri(void) 920 | { 921 | char str[] = "Hello"; 922 | 923 | ft_striteri(NULL, NULL); 924 | ft_striteri(str, NULL); 925 | ft_striteri(str, uf_striteri_callback); 926 | if (strcmp(str, "Hfnos") != 0) 927 | D_ERROR 928 | return (1); 929 | } 930 | #endif 931 | 932 | #ifdef D_STRITER 933 | int uf_test_striter(void) 934 | { 935 | char str[] = "Hello"; 936 | 937 | ft_striter(NULL, NULL); 938 | ft_striter(str, NULL); 939 | ft_striter(str, uf_striter_callback); 940 | if (strcmp(str, "Ifmmp") != 0) 941 | D_ERROR 942 | return (1); 943 | } 944 | #endif 945 | 946 | #ifdef D_STRCLR 947 | int uf_test_strclr(void) 948 | { 949 | int i; 950 | char str[] = "Hello"; 951 | 952 | i = 0; 953 | ft_strclr(NULL); 954 | ft_strclr(str); 955 | while (i < 6) 956 | { 957 | if (str[i] != '\0') 958 | D_ERROR 959 | i = i + 1; 960 | } 961 | return (1); 962 | } 963 | #endif 964 | 965 | #ifdef D_STRDEL 966 | int uf_test_strdel(void) 967 | { 968 | char *ret; 969 | 970 | ft_strdel(NULL); 971 | ret = ft_strnew(4); 972 | ft_strdel(&ret); 973 | if (ret != NULL) 974 | D_ERROR 975 | ret = ft_strnew(0); 976 | ft_strdel(&ret); 977 | if (ret != NULL) 978 | D_ERROR 979 | return (1); 980 | } 981 | #endif 982 | 983 | #ifdef D_STRNEW 984 | int uf_test_strnew(void) 985 | { 986 | char *ret; 987 | int i; 988 | 989 | i = 0; 990 | ret = ft_strnew(4); 991 | if (ret != NULL) 992 | { 993 | while (i < 5) 994 | { 995 | if (ret[i] != '\0') 996 | D_ERROR 997 | i = i + 1; 998 | } 999 | } 1000 | return (1); 1001 | } 1002 | #endif 1003 | 1004 | #ifdef D_MEMALLOC_AND_DEL 1005 | int uf_test_memalloc_and_del(void) 1006 | { 1007 | void *ret; 1008 | 1009 | ret = ft_memalloc(4); 1010 | ft_memdel(&ret); 1011 | if (ret != NULL) 1012 | D_ERROR 1013 | return (1); 1014 | } 1015 | #endif 1016 | 1017 | #ifdef D_TOLOWER 1018 | int uf_test_tolower(void) 1019 | { 1020 | int i; 1021 | 1022 | i = -300; 1023 | while (i < 300) 1024 | { 1025 | if (tolower(i) != ft_tolower(i)) 1026 | D_ERROR 1027 | i = i + 1; 1028 | } 1029 | return (1); 1030 | } 1031 | #endif 1032 | 1033 | #ifdef D_TOUPPER 1034 | int uf_test_toupper(void) 1035 | { 1036 | int i; 1037 | 1038 | i = -300; 1039 | while (i < 300) 1040 | { 1041 | if (toupper(i) != ft_toupper(i)) 1042 | D_ERROR 1043 | i = i + 1; 1044 | } 1045 | return (1); 1046 | } 1047 | #endif 1048 | 1049 | #ifdef D_ISPRINT 1050 | int uf_test_isprint(void) 1051 | { 1052 | int i; 1053 | 1054 | i = -300; 1055 | while (i < 300) 1056 | { 1057 | if (isprint(i) != ft_isprint(i)) 1058 | D_ERROR 1059 | i = i + 1; 1060 | } 1061 | return (1); 1062 | } 1063 | #endif 1064 | 1065 | #ifdef D_ISASCII 1066 | int uf_test_isascii(void) 1067 | { 1068 | int i; 1069 | 1070 | i = -300; 1071 | while (i < 300) 1072 | { 1073 | if (isascii(i) != ft_isascii(i)) 1074 | D_ERROR 1075 | i = i + 1; 1076 | } 1077 | return (1); 1078 | } 1079 | #endif 1080 | 1081 | #ifdef D_ISALNUM 1082 | int uf_test_isalnum(void) 1083 | { 1084 | int i; 1085 | 1086 | i = -300; 1087 | while (i < 300) 1088 | { 1089 | if (isalnum(i) != ft_isalnum(i)) 1090 | D_ERROR 1091 | i = i + 1; 1092 | } 1093 | return (1); 1094 | } 1095 | #endif 1096 | 1097 | #ifdef D_ISDIGIT 1098 | int uf_test_isdigit(void) 1099 | { 1100 | int i; 1101 | 1102 | i = -300; 1103 | while (i < 300) 1104 | { 1105 | if (isdigit(i) != ft_isdigit(i)) 1106 | D_ERROR 1107 | i = i + 1; 1108 | } 1109 | return (1); 1110 | } 1111 | #endif 1112 | 1113 | #ifdef D_ISALPHA 1114 | int uf_test_isalpha(void) 1115 | { 1116 | int i; 1117 | 1118 | i = -300; 1119 | while (i < 300) 1120 | { 1121 | if (isalpha(i) != ft_isalpha(i)) 1122 | D_ERROR 1123 | i = i + 1; 1124 | } 1125 | return (1); 1126 | } 1127 | #endif 1128 | 1129 | #ifdef D_ATOI 1130 | int uf_test_atoi(void) 1131 | { 1132 | size_t i, j; 1133 | char str[12] = {0}; 1134 | 1135 | if (atoi("\n\v\t\r\f -123") != ft_atoi("\n\v\t\r\f -123")) 1136 | D_ERROR 1137 | if (atoi("12-3") != ft_atoi("12-3")) 1138 | D_ERROR 1139 | if (atoi("-+123") != ft_atoi("-+123")) 1140 | D_ERROR 1141 | if (atoi("a123") != ft_atoi("a123")) 1142 | D_ERROR 1143 | if (atoi("123a") != ft_atoi("123a")) 1144 | D_ERROR 1145 | if (atoi("123") != ft_atoi("123")) 1146 | D_ERROR 1147 | if (atoi("-123") != ft_atoi("-123")) 1148 | D_ERROR 1149 | if (atoi("+123") != ft_atoi("+123")) 1150 | D_ERROR 1151 | if (atoi(" - 123") != ft_atoi(" - 123")) 1152 | D_ERROR 1153 | if (atoi("\t -123") != ft_atoi("\t -123")) 1154 | D_ERROR 1155 | if (atoi("-2147483648") != ft_atoi("-2147483648")) 1156 | D_ERROR 1157 | if (atoi("2147483647") != ft_atoi("2147483647")) 1158 | D_ERROR 1159 | if (atoi("") != ft_atoi("")) 1160 | D_ERROR 1161 | i = 0; 1162 | while (i < RANDT) 1163 | { 1164 | j = 0; 1165 | while (j < 10) 1166 | { 1167 | str[j] = ((char)(rand() % 10) + '0'); 1168 | j++; 1169 | } 1170 | str[11] = 0; 1171 | if (atoi(str) != ft_atoi(str)) 1172 | D_ERROR 1173 | i++; 1174 | } 1175 | return (1); 1176 | } 1177 | #endif 1178 | 1179 | /* 1180 | ** Don't be stupid ppl, be careful with this noob noob noob test 1181 | */ 1182 | 1183 | #ifdef D_STRNCMP 1184 | int uf_test_strncmp(void) 1185 | { 1186 | int a; 1187 | 1188 | a = ft_strncmp("abc", "abc", 2); 1189 | #ifdef __clang__ 1190 | if (strncmp("abc", "abc", 2) != a) 1191 | D_ERROR; 1192 | #else 1193 | if (a) 1194 | D_ERROR; 1195 | #endif 1196 | 1197 | a = ft_strncmp("cba", "abc", 2); 1198 | #ifdef __clang__ 1199 | if (strncmp("cba", "abc", 2) != a) 1200 | D_ERROR; 1201 | #else 1202 | if (!a) 1203 | D_ERROR; 1204 | #endif 1205 | 1206 | a = ft_strncmp("abc", "cba", 2); 1207 | #ifdef __clang__ 1208 | if (strncmp("abc", "cba", 2) != a) 1209 | D_ERROR; 1210 | #else 1211 | if (!a) 1212 | D_ERROR; 1213 | #endif 1214 | 1215 | a = ft_strncmp("", "", 3); 1216 | #ifdef __clang__ 1217 | if (strncmp("", "", 3) != a) 1218 | D_ERROR; 1219 | #else 1220 | if (a) 1221 | D_ERROR; 1222 | #endif 1223 | 1224 | a = ft_strncmp("q", "a", 0); 1225 | #ifdef __clang__ 1226 | if (strncmp("q", "a", 0) != a) 1227 | D_ERROR; 1228 | #else 1229 | if (a) 1230 | D_ERROR; 1231 | #endif 1232 | 1233 | a = ft_strncmp("abc", "abd", 2); 1234 | #ifdef __clang__ 1235 | if(strncmp("abc", "abd", 2) != a) 1236 | D_ERROR; 1237 | #else 1238 | if (a) 1239 | D_ERROR; 1240 | #endif 1241 | 1242 | return (1); 1243 | } 1244 | #endif 1245 | 1246 | /* 1247 | ** Don't be stupid ppl, be careful with this noob noob noob test 1248 | */ 1249 | 1250 | #ifdef D_STRCMP 1251 | int uf_test_strcmp(void) 1252 | { 1253 | int a; 1254 | 1255 | a = ft_strcmp("abc", "abc"); 1256 | #ifdef __clang__ 1257 | if (a != strcmp("abc", "abc")) 1258 | D_ERROR; 1259 | #endif 1260 | #ifndef __clang__ 1261 | if (a) 1262 | D_ERROR; 1263 | #endif 1264 | a = ft_strcmp("cba", "abc"); 1265 | #ifdef __clang__ 1266 | if (a != strcmp("cba", "abc")) 1267 | D_ERROR; 1268 | #endif 1269 | #ifndef __clang__ 1270 | if (!a) 1271 | D_ERROR; 1272 | #endif 1273 | a = ft_strcmp("abc", "cba"); 1274 | #ifdef __clang__ 1275 | if (a != strcmp("abc", "cba")) 1276 | D_ERROR; 1277 | #endif 1278 | #ifndef __clang__ 1279 | if (!a) 1280 | D_ERROR; 1281 | #endif 1282 | if (ft_strcmp("", "") != strcmp("", "")) 1283 | D_ERROR; 1284 | return (1); 1285 | } 1286 | #endif 1287 | 1288 | #ifdef D_STRNSTR 1289 | int uf_test_strnstr(void) 1290 | { 1291 | char *str = "Hello les genw"; 1292 | 1293 | 1294 | if (strnstr(str, "Hello", 6) != ft_strnstr(str, "Hello", 6)) 1295 | D_ERROR; 1296 | if (strnstr(str, "Hello", 3) != ft_strnstr(str, "Hello", 3)) 1297 | D_ERROR; 1298 | if (strnstr(str, "les", 1) != ft_strnstr(str, "les", 1)) 1299 | D_ERROR; 1300 | if (strnstr(str, "gen", 2) != ft_strnstr(str, "gen", 2)) 1301 | D_ERROR; 1302 | if (strnstr(str, "w", 0) != ft_strnstr(str, "w", 0)) 1303 | D_ERROR; 1304 | if (strnstr(str, "", 3) != ft_strnstr(str, "", 3)) 1305 | D_ERROR; 1306 | return (1); 1307 | } 1308 | #endif 1309 | 1310 | #ifdef D_STRSTR 1311 | int uf_test_strstr(void) 1312 | { 1313 | char *str = "Hello les genw"; 1314 | 1315 | if (strstr(str, "Hello") != ft_strstr(str, "Hello")) 1316 | D_ERROR; 1317 | if (strstr(str, "les") != ft_strstr(str, "les")) 1318 | D_ERROR; 1319 | if (strstr(str, "gen") != ft_strstr(str, "gen")) 1320 | D_ERROR; 1321 | if (strstr(str, "w") != ft_strstr(str, "w")) 1322 | D_ERROR; 1323 | if (strstr(str, "") != ft_strstr(str, "")) 1324 | D_ERROR; 1325 | if (strstr("", "") != ft_strstr("", "")) 1326 | D_ERROR; 1327 | return (1); 1328 | } 1329 | #endif 1330 | 1331 | #ifdef D_STRRCHR 1332 | int uf_test_strrchr(void) 1333 | { 1334 | char str[] = "Hello je tesx"; 1335 | 1336 | if (strrchr(str, 'H') != ft_strrchr(str, 'H')) 1337 | { 1338 | printf("notre=%s\nvotre=%s\n", strrchr(str, 'H'), ft_strrchr(str, 'H')); 1339 | D_ERROR 1340 | } 1341 | if (strrchr(str, 'j') != ft_strrchr(str, 'j')) 1342 | { 1343 | printf("\nnotre=%s\nvotre=%s\n", strrchr(str, 'j'), ft_strrchr(str, 'j')); 1344 | D_ERROR 1345 | } 1346 | if (strrchr(str, 'x') != ft_strrchr(str, 'x')) 1347 | { 1348 | printf("\nnotre=%s\nvotre=%s\n", strrchr(str, 'x'), ft_strrchr(str, 'x')); 1349 | D_ERROR 1350 | } 1351 | if (strrchr(str, 0) != ft_strrchr(str, 0)) 1352 | { 1353 | printf("\nnotre=%s\nvotre=%s\n", strrchr(str, 0), ft_strrchr(str, 0)); 1354 | D_ERROR 1355 | } 1356 | return (1); 1357 | } 1358 | #endif 1359 | 1360 | #ifdef D_STRCHR 1361 | int uf_test_strchr(void) 1362 | { 1363 | char str[] = "Hello je tesx"; 1364 | 1365 | if (strchr(str, 'H') != ft_strchr(str, 'H')) 1366 | D_ERROR 1367 | if (strchr(str, 'j') != ft_strchr(str, 'j')) 1368 | D_ERROR 1369 | if (strchr(str, 'x') != ft_strchr(str, 'x')) 1370 | D_ERROR 1371 | if (strchr(str, 'y') != ft_strchr(str, 'y')) 1372 | D_ERROR 1373 | if (strchr(str, 0) != ft_strchr(str, 0)) 1374 | D_ERROR 1375 | return (1); 1376 | } 1377 | #endif 1378 | 1379 | /* 1380 | ** Not HardCore but better than original 1381 | ** Fixes by pmotte 1382 | */ 1383 | 1384 | #ifdef D_STRLCAT 1385 | int uf_test_strlcat(void) 1386 | { 1387 | char dest[50] = {0}; 1388 | char dest2[50] = {0}; 1389 | size_t i, j, k; 1390 | 1391 | if (strlcat(dest, "Hello ", 4) != ft_strlcat(dest2, "Hello ", 4)) 1392 | D_ERROR 1393 | memset(dest, 0, sizeof(dest)); 1394 | memset(dest2, 0, sizeof(dest)); 1395 | j = strlcat(dest, "Hello ", 4); 1396 | k = ft_strlcat(dest2, "Hello ", 4); 1397 | if (strcmp(dest, dest2) != 0 || j != k) 1398 | D_ERROR 1399 | j = strlcat(dest, "Hello ", 1); 1400 | k = ft_strlcat(dest2, "Hello ", 1); 1401 | if (strcmp(dest, dest2) != 0 || j != k) 1402 | D_ERROR 1403 | i = 0; 1404 | while (i < 6) 1405 | { 1406 | dest[4 + i] = 'z'; 1407 | dest2[4 + i] = 'z'; 1408 | ++i; 1409 | } 1410 | j = strlcat(dest, "abc", 6); 1411 | k = ft_strlcat(dest2, "abc", 6); 1412 | if (strcmp(dest, dest2) != 0 || j != k) 1413 | D_ERROR 1414 | return (1); 1415 | } 1416 | #endif 1417 | 1418 | /* 1419 | ** Better than original by mfontain 1420 | */ 1421 | 1422 | #ifdef D_STRNCAT 1423 | int uf_test_strncat(void) 1424 | { 1425 | char dest[50] = {0}; 1426 | char dest2[50] = {0}; 1427 | 1428 | if (strncat(dest, "hello ", 2) != ft_strncat(dest, "hello ", 2)) 1429 | D_ERROR 1430 | memset(dest, 0, sizeof(dest)); 1431 | strncat(dest, "Hello ", 4); 1432 | ft_strncat(dest2, "Hello ", 4); 1433 | if (strcmp(dest, dest2) != 0) 1434 | D_ERROR 1435 | strncat(dest, "Hello ", 2); 1436 | ft_strncat(dest2, "Hello ", 2); 1437 | if (strcmp(dest, dest2) != 0) 1438 | D_ERROR 1439 | strncat(dest, "Hello ", 10); 1440 | ft_strncat(dest2, "Hello ", 10); 1441 | if (strcmp(dest, dest2) != 0) 1442 | D_ERROR 1443 | strncat(dest, "1234\n78", 7); 1444 | ft_strncat(dest2, "1234\n78", 7); 1445 | if (strcmp(dest, dest2) != 0) 1446 | D_ERROR 1447 | return (1); 1448 | } 1449 | #endif 1450 | 1451 | #ifdef D_STRCAT 1452 | int uf_test_strcat(void) 1453 | { 1454 | char dest[50] = {0}; 1455 | char dest2[50] = {0}; 1456 | 1457 | if (strcat(dest, "hello ") != ft_strcat(dest, "hello ")) 1458 | D_ERROR 1459 | memset(dest, 0, sizeof(dest)); 1460 | strcat(dest, "Hello "); 1461 | ft_strcat(dest2, "Hello "); 1462 | if (strcmp(dest, dest2) != 0) 1463 | D_ERROR 1464 | strcat(dest, "Hello "); 1465 | ft_strcat(dest2, "Hello "); 1466 | if (strcmp(dest, dest2) != 0) 1467 | D_ERROR 1468 | return (1); 1469 | } 1470 | #endif 1471 | 1472 | #ifdef D_STRNCPY 1473 | int uf_test_strncpy(void) 1474 | { 1475 | char ctab[11], ctab2[21], ctab3[21]; 1476 | int i, j; 1477 | size_t k; 1478 | 1479 | k = 0; 1480 | while (k < 21) 1481 | { 1482 | i = 0; 1483 | while (i < RANDT) 1484 | { 1485 | j = 0; 1486 | while (j < 21) 1487 | { 1488 | if (j < 11) 1489 | ctab[j] = ((char)rand() % 26) + 'a'; 1490 | ctab2[j] = 'Z'; 1491 | ctab3[j] = 'Z'; 1492 | j++; 1493 | } 1494 | ctab[10] = 0; 1495 | ctab2[20] = 0; 1496 | ctab3[20] = 0; 1497 | if (strncpy(ctab2, ctab, k) != ctab2 || ft_strncpy(ctab3, ctab, k) != ctab3) 1498 | D_ERROR 1499 | if (strcmp(ctab2, ctab3)) 1500 | D_ERROR 1501 | ++i; 1502 | } 1503 | k++; 1504 | } 1505 | return (1); 1506 | } 1507 | #endif 1508 | 1509 | #ifdef D_STRCPY 1510 | int uf_test_strcpy(void) 1511 | { 1512 | char dest[50] = {0}; 1513 | char dest2[50] = {0}; 1514 | 1515 | 1516 | char ctab[11], ctab2[11], ctab3[11]; 1517 | int i, j; 1518 | size_t k; 1519 | 1520 | k = 0; 1521 | while (k <= sizeof(ctab)) 1522 | { 1523 | i = 0; 1524 | while (i < RANDT) 1525 | { 1526 | j = 0; 1527 | while (j < 11) 1528 | { 1529 | ctab[j] = (char)rand(); 1530 | ctab2[j] = 0; ctab3[j] = 0; 1531 | j++; 1532 | } 1533 | ctab[10] = 0; 1534 | if (strcpy(ctab2, ctab) != ctab2 || ft_strcpy(ctab3, ctab) != ctab3) 1535 | D_ERROR 1536 | if (strcmp(ctab2, ctab3)) 1537 | D_ERROR 1538 | ++i; 1539 | } 1540 | k++; 1541 | } 1542 | if (strcpy(dest, "Hello foo") != ft_strcpy(dest, "Hello foo")) 1543 | D_ERROR 1544 | strcpy(dest, "Hello foo"); 1545 | ft_strcpy(dest2, "Hello foo"); 1546 | if (strcmp(dest, dest2) != 0) 1547 | D_ERROR 1548 | strcpy(dest, "Hello"); 1549 | ft_strcpy(dest2, "Hello"); 1550 | if (strcmp(dest, dest2) != 0) 1551 | D_ERROR 1552 | return (1); 1553 | } 1554 | #endif 1555 | 1556 | #ifdef D_STRDUP 1557 | int uf_test_strdup(void) 1558 | { 1559 | char *ret1; 1560 | char *ret2; 1561 | 1562 | ret1 = strdup(""); 1563 | ret2 = ft_strdup(""); 1564 | if (strcmp(ret1, ret2) != 0) 1565 | D_ERROR 1566 | free(ret1); 1567 | free(ret2); 1568 | ret1 = strdup("hello"); 1569 | ret2 = ft_strdup("hello"); 1570 | if (strcmp(ret1, ret2) != 0) 1571 | D_ERROR 1572 | free(ret1); 1573 | free(ret2); 1574 | return (1); 1575 | } 1576 | #endif 1577 | 1578 | #ifdef D_STRLEN 1579 | int uf_test_strlen(void) 1580 | { 1581 | if (strlen("") != ft_strlen("")) 1582 | D_ERROR 1583 | if (strlen("abc") != ft_strlen("abc")) 1584 | D_ERROR 1585 | if (strlen("a") != ft_strlen("a")) 1586 | D_ERROR 1587 | return (1); 1588 | } 1589 | #endif 1590 | 1591 | #ifdef D_MEMMOVE 1592 | int uf_test_memmove(void) 1593 | { 1594 | char str[] = "memmove can be very useful......"; 1595 | char str2[] = "memmove can be very useful......"; 1596 | char str3[] = "memmove can be very useful......"; 1597 | char str4[] = "memmove can be very useful......"; 1598 | 1599 | char s1[101], t1[101]; 1600 | char s2[101], t2[101]; 1601 | size_t i, j; 1602 | 1603 | i = 0; 1604 | while (i < RANDT) 1605 | { 1606 | j = 0; 1607 | while (j < 100) 1608 | { 1609 | s1[j] = (char)rand(); 1610 | s2[j] = (char)rand(); 1611 | j++; 1612 | } 1613 | s1[100] = 0; s2[100] = 0; 1614 | memcpy(t1, s1, sizeof(s1)); 1615 | memcpy(t2, s2, sizeof(s2)); 1616 | if (strcmp(memmove(str + 10, str + 5, 10), ft_memmove(str2 + 10, str2 + 5, 10)) != 0) 1617 | D_ERROR 1618 | if (strcmp(memmove(str3 + 5, str3 + 10, 10), ft_memmove(str4 + 5, str4 + 10, 10)) != 0) 1619 | D_ERROR 1620 | if (strcmp(memmove(s1, s2, 2), ft_memmove(t1, t2, 2)) != 0) 1621 | D_ERROR 1622 | if (strcmp(memmove(s1, s1 + 25, 30), ft_memmove(t1, t1 + 25, 30)) != 0) 1623 | D_ERROR 1624 | if (strcmp(memmove(s1 + 30, s1, 40), ft_memmove(t1 + 30, t1, 40)) != 0) 1625 | D_ERROR 1626 | ++i; 1627 | } 1628 | return (1); 1629 | } 1630 | #endif 1631 | 1632 | #ifdef D_MEMCHR 1633 | int uf_test_memchr(void) 1634 | { 1635 | char ctab[11]; 1636 | int itab[11]; 1637 | unsigned long ltab[11]; 1638 | size_t j; 1639 | int i; 1640 | 1641 | i = -300; 1642 | memchr(NULL, 0, 0); 1643 | ft_memchr(NULL, 0, 0); 1644 | while (i < 300) 1645 | { 1646 | j = 0; 1647 | while (j < 11) 1648 | { 1649 | ctab[j] = (char)rand(); 1650 | itab[j] = rand(); 1651 | ltab[j] = (unsigned long)rand() * LONG; 1652 | j++; 1653 | } 1654 | if (memchr(ctab, i, sizeof(ctab)) != ft_memchr(ctab, i, sizeof(ctab))) 1655 | D_ERROR 1656 | if (memchr(itab, i, sizeof(itab)) != ft_memchr(itab, i, sizeof(itab))) 1657 | D_ERROR 1658 | if (memchr(ltab, i, sizeof(ltab)) != ft_memchr(ltab, i, sizeof(ltab))) 1659 | D_ERROR 1660 | ++i; 1661 | } 1662 | return (1); 1663 | } 1664 | #endif 1665 | 1666 | #ifdef D_MEMCMP 1667 | int uf_test_memcmp(void) 1668 | { 1669 | char ctab[11], ctab2[11]; 1670 | int itab[11], itab2[11]; 1671 | unsigned long ltab[11], ltab2[11]; 1672 | size_t i, j; 1673 | 1674 | #ifdef __clang__ 1675 | if (memcmp(NULL, NULL, 0) != ft_memcmp(NULL, NULL, 0)) 1676 | D_ERROR 1677 | #endif 1678 | i = 0; 1679 | while (i < 11) 1680 | { 1681 | j = 0; 1682 | while (j < 11) 1683 | { 1684 | ctab[j] = (char)rand(); 1685 | ctab2[j] = (char)rand(); 1686 | itab[j] = rand(); 1687 | itab2[j] = rand(); 1688 | ltab[j] = (unsigned long)rand() * LONG; 1689 | ltab2[j] = (unsigned long)rand() * LONG; 1690 | j++; 1691 | } 1692 | if (memcmp(ctab, ctab2, sizeof(ctab)) != ft_memcmp(ctab, ctab2, sizeof(ctab))) 1693 | D_ERROR 1694 | memcpy(ctab2, ctab, sizeof(ctab)); 1695 | if (memcmp(ctab, ctab2, sizeof(ctab)) != ft_memcmp(ctab, ctab2, sizeof(ctab))) 1696 | D_ERROR 1697 | if (memcmp(itab, itab2, sizeof(itab)) != ft_memcmp(itab, itab2, sizeof(itab))) 1698 | D_ERROR 1699 | memcpy(itab2, itab, sizeof(itab)); 1700 | if (memcmp(itab, itab2, sizeof(itab)) != ft_memcmp(itab, itab2, sizeof(itab))) 1701 | D_ERROR 1702 | if (memcmp(ltab, ltab2, sizeof(ltab)) != ft_memcmp(ltab, ltab2, sizeof(ltab))) 1703 | D_ERROR 1704 | memcpy(ltab2, ltab, sizeof(ltab)); 1705 | if (memcmp(ltab, ltab2, sizeof(ltab)) != ft_memcmp(ltab, ltab2, sizeof(ltab))) 1706 | D_ERROR 1707 | ++i; 1708 | } 1709 | return (1); 1710 | } 1711 | #endif 1712 | 1713 | #ifdef D_MEMCCPY 1714 | int uf_test_memccpy(void) 1715 | { 1716 | char ctab[11], ctab2[11], ctab3[11]; 1717 | int itab[11], itab2[11], itab3[11]; 1718 | unsigned long ltab[11], ltab2[11], ltab3[11]; 1719 | int i, j; 1720 | size_t k; 1721 | void *temp, *temp2; 1722 | 1723 | #ifdef __clang__ 1724 | memccpy(NULL, NULL, 0, 0); 1725 | ft_memccpy(NULL, NULL, 0, 0); 1726 | #endif 1727 | k = 0; 1728 | while (k <= sizeof(ltab)) 1729 | { 1730 | i = 0; 1731 | while (i < RANDT) 1732 | { 1733 | j = 0; 1734 | while (j < 11) 1735 | { 1736 | ctab[j] = (char)rand(); 1737 | ctab2[j] = 0; ctab3[j] = 0; 1738 | itab[j] = rand(); 1739 | itab2[j] = 0; itab3[j] = 0; 1740 | ltab[j] = (unsigned long)rand() * LONG; 1741 | ltab2[j] = 0; ltab3[j] = 0; 1742 | j++; 1743 | } 1744 | temp = memccpy(ctab2, ctab, 'a', (k < sizeof(ctab)) ? k : sizeof(ctab)); 1745 | memcpy(ctab3, ctab2, sizeof(ctab)); 1746 | memset(ctab2, 0, sizeof(ctab2)); 1747 | temp2 = ft_memccpy(ctab2, ctab, 'a', (k < sizeof(ctab)) ? k : sizeof(ctab)); 1748 | if ((memcmp(ctab2, ctab3, sizeof(ctab)) != 0 || (temp != temp2))) 1749 | D_ERROR 1750 | temp = memccpy(itab2, itab, 'a', (k < sizeof(itab)) ? k : sizeof(itab)); 1751 | memcpy(itab3, itab2, sizeof(itab)); 1752 | memset(itab2, 0, sizeof(itab2)); 1753 | temp2 = ft_memccpy(itab2, itab, 'a', (k < sizeof(itab)) ? k : sizeof(itab)); 1754 | if ((memcmp(itab2, itab3, sizeof(itab)) != 0 || (temp != temp2))) 1755 | D_ERROR 1756 | temp = memccpy(ltab2, ltab, 'a', (k < sizeof(ltab)) ? k : sizeof(ltab)); 1757 | memcpy(ltab3, ltab2, sizeof(ltab)); 1758 | memset(ltab2, 0, sizeof(ltab2)); 1759 | temp2 = ft_memccpy(ltab2, ltab, 'a', (k < sizeof(ltab)) ? k : sizeof(ltab)); 1760 | if ((memcmp(ltab2, ltab3, sizeof(ltab)) != 0 || (temp != temp2))) 1761 | D_ERROR 1762 | ++i; 1763 | } 1764 | ++k; 1765 | } 1766 | return (1); 1767 | } 1768 | #endif 1769 | 1770 | #ifdef D_MEMCPY 1771 | int uf_test_memcpy(void) 1772 | { 1773 | char ctab[11], ctab2[11], ctab3[11]; 1774 | int itab[11], itab2[11], itab3[11]; 1775 | unsigned long ltab[11], ltab2[11], ltab3[11]; 1776 | int i, j; 1777 | size_t k; 1778 | void *temp, *temp2, *temp3; 1779 | 1780 | #ifdef __clang__ 1781 | memcpy(NULL, NULL, 0); 1782 | ft_memcpy(NULL, NULL, 0); 1783 | #endif 1784 | k = 0; 1785 | while (k <= sizeof(ltab)) 1786 | { 1787 | i = 0; 1788 | while (i < RANDT) 1789 | { 1790 | j = 0; 1791 | while (j < 11) 1792 | { 1793 | ctab[j] = (char)rand(); 1794 | ctab2[j] = 0; ctab3[j] = 0; 1795 | itab[j] = rand(); 1796 | itab2[j] = 0; itab3[j] = 0; 1797 | ltab[j] = (unsigned long)rand() * LONG; 1798 | ltab2[j] = 0; ltab3[j] = 0; 1799 | j++; 1800 | } 1801 | memcpy(ctab2, ctab, (k < sizeof(ctab)) ? k : sizeof(ctab)); 1802 | temp = ft_memcpy(ctab3, ctab, (k < sizeof(ctab)) ? k : sizeof(ctab)); 1803 | memcpy(itab2, itab, (k < sizeof(itab)) ? k : sizeof(itab)); 1804 | temp2 = ft_memcpy(itab3, itab, (k < sizeof(itab)) ? k : sizeof(itab)); 1805 | memcpy(ltab2, ltab, (k < sizeof(ltab)) ? k : sizeof(ltab)); 1806 | temp3 = ft_memcpy(ltab3, ltab, (k < sizeof(ltab)) ? k : sizeof(ltab)); 1807 | if ((memcmp(itab2, itab3, sizeof(itab)) != 0 || (temp2 != itab3))) 1808 | D_ERROR 1809 | if (memcmp(ctab2, ctab3, sizeof(ctab)) != 0 || temp != ctab3) 1810 | D_ERROR 1811 | if (memcmp(ltab2, ltab3, sizeof(ltab)) != 0 ||( temp3 != ltab3)) 1812 | D_ERROR 1813 | ++i; 1814 | } 1815 | ++k; 1816 | } 1817 | return (1); 1818 | } 1819 | #endif 1820 | 1821 | #ifdef D_MEMSET 1822 | int uf_test_memset(void) 1823 | { 1824 | char ctab[11], ctab2[11]; 1825 | int itab[11], itab2[11]; 1826 | unsigned long ltab[11], ltab2[11]; 1827 | size_t i, j, k; 1828 | void *temp, *temp2; 1829 | 1830 | #ifdef __clang__ 1831 | memset(NULL, 0, 0); 1832 | ft_memset(NULL, 0, 0); 1833 | #endif 1834 | k = 0; 1835 | while (k <= sizeof(ltab)) 1836 | { 1837 | i = 0; 1838 | while (i < RANDT) 1839 | { 1840 | j = 0; 1841 | while (j < 11) 1842 | { 1843 | ctab[j] = (char)rand(); 1844 | itab[j] = rand(); 1845 | ltab[j] = (unsigned long)rand() * LONG; 1846 | j++; 1847 | } 1848 | memcpy(ctab2, ctab, sizeof(ctab)); 1849 | memcpy(itab2, itab, sizeof(itab)); 1850 | memcpy(ltab2, ltab, sizeof(ltab)); 1851 | temp = ft_memset(itab, i, (k < sizeof(itab)) ? k : sizeof(itab)); 1852 | temp2 = memset(itab2, i, (k < sizeof(itab)) ? k : sizeof(itab)); 1853 | if (memcmp(itab, itab2, sizeof(itab)) != 0 || temp != itab || temp2 != itab2) 1854 | D_ERROR 1855 | temp = ft_memset(ctab, i, (k < sizeof(ctab)) ? k : sizeof(ctab)); 1856 | temp2 = memset(ctab2, i, (k < sizeof(ctab)) ? k : sizeof(ctab)); 1857 | if (memcmp(ctab, ctab2, sizeof(ctab)) != 0 || temp != ctab || temp2 != ctab2) 1858 | D_ERROR 1859 | temp = ft_memset(ltab, i, (k < sizeof(ltab)) ? k : sizeof(ltab)); 1860 | temp2 = memset(ltab2, i, (k < sizeof(ltab)) ? k : sizeof(ltab)); 1861 | if (memcmp(ltab, ltab2, sizeof(ltab)) != 0 || temp != ltab || temp2 != ltab2) 1862 | D_ERROR 1863 | ++i; 1864 | } 1865 | ++k; 1866 | } 1867 | return (1); 1868 | } 1869 | #endif 1870 | 1871 | #ifdef D_BZERO 1872 | int uf_test_bzero(void) 1873 | { 1874 | char ctab[11], ctab2[11]; 1875 | int itab[11], itab2[11]; 1876 | unsigned long ltab[11], ltab2[11]; 1877 | size_t i, j; 1878 | 1879 | i = 0; 1880 | #ifdef __clang__ 1881 | bzero(NULL, 0); 1882 | ft_bzero(NULL, 0); 1883 | #endif 1884 | while (i < 11) 1885 | { 1886 | j = 0; 1887 | while (j < 11) 1888 | { 1889 | ctab[j] = (char)rand(); 1890 | itab[j] = rand(); 1891 | ltab[j] = (unsigned long)rand() * LONG; 1892 | j++; 1893 | } 1894 | memcpy(ctab2, ctab, sizeof(ctab)); 1895 | memcpy(itab2, itab, sizeof(itab)); 1896 | memcpy(ltab2, ltab, sizeof(ltab)); 1897 | bzero(ctab2, i); 1898 | ft_bzero(ctab, i); 1899 | if (memcmp(ctab, ctab2, sizeof(ctab)) != 0) 1900 | D_ERROR 1901 | bzero(itab2, i); 1902 | ft_bzero(itab, i); 1903 | if (memcmp(itab, itab2, sizeof(itab)) != 0) 1904 | D_ERROR 1905 | bzero(ltab2, i); 1906 | ft_bzero(ltab, i); 1907 | if (memcmp(ltab, ltab2, sizeof(ltab)) != 0) 1908 | D_ERROR 1909 | ++i; 1910 | } 1911 | return (1); 1912 | } 1913 | #endif 1914 | --------------------------------------------------------------------------------