API tools faq
paste
akadjoker

ftlib_onecode

akadjoker
Feb 25th, 2022
63
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 22.69 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include "sigsegv.hpp"
  3. #include <climits>
  4. #include <string.h>
  5. using namespace std;
  6.  
  7. //#define TEST_ATOI
  8.  
  9. #define BEGIN {
  10. #define END }
  11.  
  12. int iTest;
  13.  
  14. void sigsegv(int signal)
  15. {
  16. (void)signal;
  17. cout << FG_LYELLOW << iTest++ << ".SIGSEGV" << ENDL;
  18. exit(EXIT_SUCCESS);
  19. }
  20.  
  21. std::ostream &
  22. operator<<(std::ostream & os, Color c)
  23. {
  24. return os << "\e[" << static_cast<int>(c) << "m";
  25. }
  26.  
  27.  
  28. std::vector<ptr> mallocList;
  29.  
  30. bool operator==(ptr const & p1, ptr const & p2)
  31. {
  32. return (p1.p == p2.p);
  33. }
  34.  
  35.  
  36. void * imalloc(size_t size) throw()
  37.  
  38. {
  39. //void *(*libc_malloc)(size_t) = (void *(*)(size_t))dlsym(RTLD_NEXT, "malloc");
  40. void * p = malloc(size);
  41. mallocListAdd(p, size);
  42. return (p);
  43. }
  44.  
  45.  
  46. void ifree(void * p) throw()
  47.  
  48. {
  49. // void (*libc_free)(void*) = (void (*)(void *))dlsym(RTLD_NEXT, "free");
  50. //libc_free(p);
  51. free(p);
  52. mallocListRemove(p);
  53. }
  54.  
  55. void mallocListAdd(void * p, size_t size)
  56. {
  57. mallocList.push_back(ptr(p, size));
  58. }
  59.  
  60. void check(bool succes)
  61. {
  62. if (succes)
  63. {
  64. std::ostringstream ss; ss << FG_GREEN << iTest++ << ".OK ";
  65. write(1, ss.str().c_str(), ss.str().size());
  66. write(1,"\n",1);
  67. }
  68. else
  69. {std::ostringstream ss; ss << FG_RED << iTest++ << ".KO "; write(1, ss.str().c_str(), ss.str().size());write(1,"\n",1);}
  70. }
  71.  
  72. void mcheck(void * p, size_t required_size)
  73. {
  74. void * p2 = imalloc(required_size);
  75.  
  76. if (malloc_usable_size(p) == malloc_usable_size(p2))
  77.  
  78.  
  79. {std::ostringstream ss; ss << FG_GREEN << iTest++ << ".MOK "; write(1, ss.str().c_str(), ss.str().size());write(1,"\n",1);}
  80. else
  81. {std::ostringstream ss; ss << FG_RED << iTest++ << ".MKO "; write(1, ss.str().c_str(), ss.str().size());write(1,"\n",1);}
  82. ifree(p2);
  83. }
  84.  
  85.  
  86. void mallocListRemove(void * p)
  87. {
  88. std::vector<ptr>::iterator it = find(mallocList.begin(), mallocList.end(), ptr(p));
  89. if (it != mallocList.end())
  90. mallocList.erase(it);
  91. }
  92.  
  93. void showLeaks(void)
  94. {
  95. if (mallocList.size() != 0)
  96. {
  97. std::ostringstream ss; ss << FG_RED << "LEAKS.KO ";
  98. write(1, ss.str().c_str(), ss.str().size());
  99. write(1,"\n",1);
  100. std::vector<ptr>::iterator it = mallocList.begin(); std::vector<ptr>::iterator ite = mallocList.end();
  101. for (; it != ite; ++it)
  102. {std::ostringstream ss; ss << "[" << it->p << " : " << it->size << "] "; write(1, ss.str().c_str(), ss.str().size());write(1,"\n",1);}
  103. }
  104. mallocList.clear();
  105. }
  106. //***********************************************************************************************************
  107. //***********************************************************************************************************
  108. char *strnstr(const char *s, const char *find, size_t slen)
  109. {
  110. char c, sc;
  111. size_t len;
  112.  
  113. if ((c = *find++) != '\0') {
  114. len = strlen(find);
  115. do {
  116. do {
  117. if (slen-- < 1 || (sc = *s++) == '\0')
  118. return (NULL);
  119. } while (sc != c);
  120. if (len > slen)
  121. return (NULL);
  122. } while (strncmp(s, find, len) != 0);
  123. s--;
  124. }
  125. return ((char *)s);
  126. }
  127. //***********************************************************************************************************
  128. //***********************************************************************************************************
  129.  
  130. void ft_write(char c)
  131. {
  132. write(1,&c,1);
  133. }
  134.  
  135. void ft_writestr(char *str)
  136. {
  137. int i;
  138.  
  139. i = 0;
  140. while(str[i] !='\0')
  141. {
  142. ft_write(str[i]);
  143. i++;
  144. }
  145. }
  146.  
  147.  
  148. int ft_strlen( const char *str)
  149. {
  150. int i;
  151.  
  152. i = 0;
  153. while(str[i] !='\0')
  154. {
  155. i++;
  156. }
  157. return i;
  158. }
  159.  
  160. int ft_strnlen( const char *str,size_t maxlen)
  161. {
  162. size_t i;
  163.  
  164. i = 0;
  165. while(str[i] !='\0' && i < maxlen)
  166. {
  167. i++;
  168. }
  169. return i;
  170. }
  171.  
  172. int ft_isspace(char c)
  173. {
  174. if (c == ' ' || c == '\n' || c == '\t'
  175. || c == '\v' || c == '\f' || c == '\r')
  176. return (1);
  177. else
  178. return (0);
  179. }
  180.  
  181. int ft_atoi(const char* str)
  182. {
  183.  
  184. long nbr;
  185. long sign;
  186. size_t i;
  187.  
  188. nbr = 0;
  189. sign = 1;
  190. i = 0;
  191. while ((str[i] != '\0') && ft_isspace(str[i]) == 1)
  192. i++;
  193.  
  194. if (str[i] == '-')
  195. sign *= -1;
  196.  
  197. if ((str[i] == '-') || (str[i] == '+'))
  198. i++;
  199.  
  200. //while ((str[i] != '\0') && ('0' <= str[i]) && (str[i] <= '9'))
  201. while ((str[i] != '\0') && (str[i] >='0') && (str[i] <= '9'))
  202. {
  203. nbr = (nbr * 10) + (str[i] - '0');
  204. if (nbr > 2147483647 && sign == 1)
  205. return (-1);
  206. if (nbr > 2147483648 && sign == -1)
  207. return (0);
  208. i++;
  209. }
  210. return (sign * nbr);
  211.  
  212. // printf("input %s , Original : %d , resultado : %d \n",str,atoi(str),total);
  213.  
  214.  
  215. }
  216.  
  217. int ft_isalnum(int c)
  218. {
  219. if ((c >= 'A' && c <= 'Z')
  220. || (c >= 'a' && c <= 'z')
  221. || (c >= '0' && c <= '9'))
  222. return (1);
  223. return (0);
  224. }
  225.  
  226. char *ft_strdup(const char *src)
  227. {
  228. int len;
  229. char *dest;
  230. int i;
  231.  
  232. i = 0;
  233. len = ft_strlen(src);
  234. dest = (char *) imalloc(sizeof(char) * (len + 1));
  235. if (!dest)
  236. return NULL;
  237.  
  238. while (src[i] != '\0')
  239. {
  240. dest[i] = src[i];
  241. i++;
  242. }
  243. dest[i] ='\0';
  244. return dest;
  245. }
  246.  
  247. char* ft_strrchr(const char* s, int c )
  248. {
  249. int i;
  250. char *tmp;
  251.  
  252. if (!s)
  253. return (NULL);
  254.  
  255. i = ft_strlen((char*)s);
  256. tmp = (char*)s;
  257. while ( i > 0)
  258. {
  259. if (tmp[i] == ( char) c)
  260. return (( char*) (tmp + i));
  261. i--;
  262. }
  263.  
  264. if (tmp[i]==(char)c)
  265. return tmp;
  266.  
  267. return (NULL);
  268.  
  269. }
  270.  
  271.  
  272.  
  273.  
  274. char* ft_strchr( char* s, int c )
  275. {
  276. int i;
  277. int len;
  278. char *save;
  279.  
  280. i = 0;
  281. len = ft_strlen(s);
  282. while (i < len)
  283. {
  284. if (((char *)s)[i] == (char) c)
  285. return (( char*) (s + i));
  286. ++i;
  287. }
  288. if (c != '\0')
  289. return (NULL);
  290.  
  291.  
  292. return ((char*)s + i);
  293. }
  294. char *ft_strnstr(const char *str, const char *to_find, size_t len)
  295. {
  296. unsigned int i;
  297. unsigned int j;
  298.  
  299. if (to_find[0] == '\0')
  300. return ((char *)str);
  301. i = 0;
  302. while (str[i] && i < len)
  303. {
  304. j = 0;
  305.  
  306. while ( (str[i + j] == to_find[j]) && (i + j < len))
  307. {
  308.  
  309. if (to_find[j + 1]=='\0')
  310. return ((char *)&str[i]);
  311. j++;
  312. }
  313. i++;
  314. }
  315. return (0);
  316. }
  317.  
  318.  
  319.  
  320.  
  321.  
  322. void ft_putnbr(int nb)
  323. {
  324. if(nb == INT_MIN)
  325. {
  326. ft_writestr("-2147486348");
  327. return;
  328. }
  329. if (nb < 0)
  330. {
  331. nb = -nb;
  332. ft_writestr("-");
  333. }
  334. if (nb >= 10)
  335. {
  336. ft_putnbr(nb / 10);
  337. ft_putnbr(nb % 10);
  338. }
  339. else
  340. ft_write(nb + '0');
  341. }
  342.  
  343.  
  344. void* ft_calloc ( size_t n, size_t size )
  345. {
  346. void *data;
  347. data =(void*) imalloc(n * size);
  348. return data;
  349. }
  350.  
  351. void ft_bzero( void *dst, size_t n )
  352. {
  353. unsigned char* tmp;
  354. int i;
  355.  
  356. i = 0;
  357. tmp =(unsigned char*)dst;
  358. while (i < n)
  359. {
  360. tmp[i] = 0;
  361. i++;
  362. }
  363. }
  364.  
  365. void *ft_memchr(const void *s, int c, size_t n)
  366. {
  367. size_t i;
  368.  
  369. i = 0;
  370. while (i < n)
  371. {
  372. if (((unsigned char *) s)[i] == (unsigned char) c)
  373. return ((void *)(s + i));
  374. i++;
  375. }
  376. return (0);
  377. }
  378.  
  379. void* ft_memset( void* dst,int c, size_t length )
  380. {
  381. unsigned char* tmp;
  382. size_t i;
  383.  
  384. i =0;
  385. tmp = (unsigned char*)dst;
  386. while(i < length)
  387. {
  388. ( (unsigned char *) tmp)[i] = (unsigned char) c;
  389. i++;
  390. }
  391. return dst;
  392. }
  393. int ft_memcmp( const void* s1, const void* s2, size_t length )
  394. {
  395. unsigned char *tmp1;
  396. unsigned char *tmp2;
  397. size_t i;
  398.  
  399. tmp1 = (unsigned char*)s1;
  400. tmp2 = (unsigned char*)s2;
  401. i =0;
  402. while (i < length)
  403. {
  404. if (tmp1[i] != tmp2[i])
  405. return (tmp1[i] - tmp2[i]);
  406. i++;
  407. }
  408. return 0;
  409. }
  410.  
  411. void* ft_memcpy( void* dst,const void* src,size_t len )
  412. {
  413. size_t i;
  414. i=0;
  415. if (src == NULL && dst == NULL)
  416. return (NULL);
  417. while (i < len)
  418. {
  419. *((char *)dst + i) = *((char *)src + i);
  420. i++;
  421. }
  422. return (dst);
  423. }
  424.  
  425. void* ft_memmove( void* dst, const void* src, size_t len )
  426. {
  427. size_t i;
  428.  
  429. if (!src && !dst)
  430. return (NULL);
  431. i = 0;
  432. if (dst < src)
  433. ft_memcpy(dst,src,len);
  434. else
  435. {
  436. i = len;
  437. while (i-- > 0)
  438. *(char *)(dst + i) = *(char *)(src + i);
  439. }
  440. return (dst);
  441. }
  442.  
  443.  
  444. int ft_strncmp( const char* s1,const char* s2,size_t n )
  445. {
  446. size_t i;
  447.  
  448. i = 0;
  449. if (n == 0)
  450. return 0;
  451. while ( (s1[i] && s2[i]) && i < (n-1) )
  452. {
  453. if (s1[i] != s2[i])
  454. break;
  455. i++;
  456. }
  457. return (s1[i] - s2[i]);
  458. }
  459.  
  460. size_t ft_strlcat( char* dst, const char* src,size_t size)
  461. {
  462. size_t srclen = ft_strlen(src);
  463. size_t dstlen = ft_strnlen(dst, size);
  464. if (dstlen == size) return size+srclen;
  465. if (srclen < size-dstlen)
  466. {
  467. ft_memcpy(dst+dstlen, src, srclen+1);
  468. } else
  469. {
  470. ft_memcpy(dst+dstlen, src, size-dstlen-1);
  471. dst[size-1] = '\0';
  472. }
  473. return dstlen + srclen;
  474. }
  475. size_t ft_strlcpy( char* dst,const char* src, size_t size )
  476. {
  477. size_t srclen = ft_strlen(src);
  478. if (srclen < size)
  479. {
  480. ft_memcpy(dst, src, srclen+1);
  481. } else
  482. if (size != 0)
  483. {
  484. ft_memcpy(dst, src, size-1);
  485. dst[size-1] = '\0';
  486. }
  487. return srclen;
  488. }
  489.  
  490. char * ft_strncpy(char * dst, const char * src, size_t maxlen)
  491. {
  492.  
  493. size_t srclen = ft_strnlen(src, maxlen);
  494. if (srclen < maxlen)
  495. {
  496. ft_memcpy(dst, src, srclen);
  497. ft_memset(dst+srclen, 0, maxlen-srclen);
  498. } else
  499. {
  500. ft_memcpy(dst, src, maxlen);
  501. }
  502. return dst;
  503. }
  504.  
  505. char *ft_substr(char const *s, unsigned int start, size_t len)
  506. {
  507.  
  508. }
  509.  
  510. char **ft_split(char const *s, char c)
  511. {
  512.  
  513. }
  514.  
  515. char *ft_strjoin(char *s1, char *s2)
  516. {
  517. }
  518.  
  519. char *ft_strtrim(char const *s1, char const *set)
  520. {
  521. }
  522.  
  523.  
  524.  
  525.  
  526.  
  527.  
  528.  
  529.  
  530.  
  531.  
  532.  
  533. //#define TEST_CALLOC
  534. #define TEST_STRDUP
  535. //#define TEST_ATOI
  536. #define TEST_BZERO
  537.  
  538. int main()
  539. {
  540. signal(SIGSEGV, sigsegv);
  541.  
  542. #ifdef TEST_ATOI
  543. BEGIN
  544. title("ft_atoi\t\t: ");
  545.  
  546. char escape[] = {9, 10, 11, 12, 13, 0};
  547. string e(escape);
  548. /* 1 */ check(ft_atoi((e + "1").c_str()) == 1); showLeaks();
  549. /* 2 */ check(ft_atoi((e + "a1").c_str()) == 0); showLeaks();
  550. /* 3 */ check(ft_atoi((e + "--1").c_str()) == 0); showLeaks();
  551. /* 4 */ check(ft_atoi((e + "++1").c_str()) == 0); showLeaks();
  552. /* 5 */ check(ft_atoi((e + "+1").c_str()) == 1); showLeaks();
  553. /* 6 */ check(ft_atoi((e + "-1").c_str()) == -1); showLeaks();
  554. /* 7 */ check(ft_atoi((e + "0").c_str()) == 0); showLeaks();
  555. /* 8 */ check(ft_atoi((e + "+42lyon").c_str()) == 42); showLeaks();
  556. /* 9 */ check(ft_atoi((e + "+101").c_str()) == 101); showLeaks();
  557. /* 10 */ check(ft_atoi((e + to_string(INT_MAX)).c_str()) == INT_MAX); showLeaks();
  558. /* 11 */ check(ft_atoi((e + to_string(INT_MIN)).c_str()) == INT_MIN); showLeaks();
  559. /* 12 */ check(ft_atoi("-+42") == 0); showLeaks();
  560. /* 13 */ check(ft_atoi("+-42") == 0); showLeaks();
  561. /* 14 */ check(ft_atoi((string("+") + e + "42").c_str()) == 0); showLeaks();
  562. /* 15 */ check(ft_atoi((string("-") + e + "42").c_str()) == 0); showLeaks();
  563. /* 16 */ check(ft_atoi((string("1") + e + "42").c_str()) == 1); showLeaks();
  564. /* 17 */ check(ft_atoi((string("-1") + e + "42").c_str()) == -1); showLeaks();
  565. write(1, "\n", 1);
  566. END
  567. #endif // TEST_ATOI
  568.  
  569. #ifdef TEST_STRDUP
  570. BEGIN
  571. title("ft_strdup\t: ")
  572.  
  573. char * s = ft_strdup((char*)"coucou");
  574. /* 1 */ check(!strcmp(s, "coucou"));
  575. /* 2 */ mcheck(s, strlen("coucou") + 1); ifree(s); showLeaks();
  576.  
  577. s = ft_strdup((char*)"");
  578. /* 3 */ check(!strcmp(s, ""));
  579. /* 4 */ mcheck(s, 1); ifree(s); showLeaks();
  580. write(1, "\n", 1);
  581. END
  582. #endif
  583.  
  584. #ifdef TEST_CALLOC
  585.  
  586.  
  587. title("ft_calloc\t: ")
  588.  
  589. void * p = ft_calloc(2, 2);
  590. char e[] = {0, 0, 0, 0};
  591. /* 1 */ check(!memcmp(p, e, 4));
  592. /* 2 */ mcheck(p, 4); ifree(p); showLeaks();
  593. write(1, "\n", 1);
  594. #endif // define
  595.  
  596.  
  597. #ifdef TEST_BZERO
  598. BEGIN
  599. title("ft_bzero\t: ")
  600. char tab[100];
  601. ft_memset(tab, 'A', 100);
  602. ft_bzero(tab, 0);
  603. /* 1 */ check(tab[0] == 'A'); showLeaks();
  604. ft_bzero(tab, 42);
  605. int i = 0;
  606. for (; i < 100 && tab[i] == 0; ++i)
  607. ;
  608. /* 2 */ check(i == 42 && tab[42] == 'A'); showLeaks();
  609. ft_memset(tab, 'A', 100); tab[0] = 0;
  610. ft_bzero(tab, 42);
  611. i = 0;
  612. for (; i < 100 && tab[i] == 0; ++i)
  613. ;
  614. /* 3 */ check(i == 42); showLeaks();
  615. write(1, "\n", 1);
  616. END
  617. #endif
  618. BEGIN
  619.  
  620. title("ft_memset\t: ")
  621.  
  622.  
  623.  
  624. char tab[100];
  625. memset(tab, 0, 100);
  626. ft_memset(tab, 'A', 0);
  627. check(tab[0] == 0); showLeaks();
  628. ft_memset(tab, 'A', 42);
  629. int i = 0;
  630. for (; i < 100 && tab[i] == 'A'; ++i)
  631. ;
  632. check(i == 42 && tab[42] == 0); showLeaks();
  633.  
  634.  
  635. char buffer[10];
  636. ft_memset( buffer, '=', 10 );
  637. buffer[9] = '\0';
  638. puts( buffer );
  639. write(1, "\n", 1);
  640. END
  641.  
  642. BEGIN
  643. signal(SIGSEGV, sigsegv);
  644. title("ft_strlen\t: ")
  645.  
  646. /* 1 */ check(ft_strlen("123") == 3); showLeaks();
  647. /* 2 */ check(ft_strlen("") == 0); showLeaks();
  648. write(1, "\n", 1);
  649. END
  650.  
  651. BEGIN
  652.  
  653. title("ft_memchr\t: ")
  654.  
  655. char s[] = {0, 1, 2 ,3 ,4 ,5};
  656. /* 1 */ check(ft_memchr(s, 0, 0) == NULL); showLeaks();
  657. /* 2 */ check(ft_memchr(s, 0, 1) == s); showLeaks();
  658. /* 3 */ check(ft_memchr(s, 2, 3) == s + 2); showLeaks();
  659. /* 4 */ check(ft_memchr(s, 6, 6) == NULL); showLeaks();
  660. /* 5 */ check(ft_memchr(s, 2 + 256, 3) == s + 2); showLeaks(); //Cast check
  661. write(1, "\n", 1);
  662.  
  663.  
  664. char buffer[80];
  665. char* where;
  666.  
  667. strcpy( buffer, "video x-rays" );
  668. where = (char *) ft_memchr( buffer, 'x', 6 );
  669. if( where == NULL ) {
  670. printf( "'x' not found\n" );
  671. } else {
  672. printf( "%s\n", where );
  673. }
  674.  
  675. where = (char *) ft_memchr( buffer, 'x', 9 );
  676. if( where == NULL ) {
  677. printf( "'r' not found\n" );
  678. } else {
  679. printf( "%s\n", where );
  680. }
  681.  
  682. END
  683.  
  684. BEGIN
  685.  
  686.  
  687. title("ft_memcmp\t: ")
  688.  
  689. char buffer[80];
  690. int retval;
  691.  
  692. strcpy( buffer, "hello" );
  693.  
  694. retval = ft_memcmp( buffer, "hello", 5 );
  695. if( retval < 0 ) {
  696. printf( "Less than\n" );
  697. } else if( retval == 0 ) {
  698. printf( "Equal to\n");
  699. } else {
  700. printf( "Greater than\n");
  701. }
  702.  
  703.  
  704. char s[] = {-128, 0, 127, 0};
  705. char sCpy[] = {-128, 0, 127, 0};
  706. char s2[] = {0, 0, 127, 0};
  707. char s3[] = {0, 0, 42, 0};
  708. /* 1 */ check(!ft_memcmp(s, sCpy, 4)); showLeaks();
  709. /* 2 */ check(!ft_memcmp(s, s2, 0)); showLeaks();
  710. /* 3 */ check(ft_memcmp(s, s2, 1) > 0); showLeaks();
  711. /* 4 */ check(ft_memcmp(s2, s, 1) < 0); showLeaks();
  712. /* 5 */ check(ft_memcmp(s2, s3, 4) != 0); showLeaks();
  713.  
  714.  
  715. write(1, "\n", 1);
  716.  
  717. END
  718.  
  719. BEGIN
  720. title("ft_memcpy\t: ")
  721.  
  722. char dest[100];
  723. memset(dest, 'A', 100);
  724. ft_memcpy(dest, "coucou", 0);
  725. /* 1 */ check(dest[0] == 'A'); showLeaks();
  726. char src[] = {0, 0};
  727. ft_memcpy(dest, src, 2);
  728. int i = 0;
  729. for (; i < 100 && dest[i] == 0; ++i)
  730. ;
  731. /* 2 */ check(i == 2 && dest[2] == 'A'); showLeaks();
  732. write(1, "\n", 1);
  733. END
  734.  
  735.  
  736. BEGIN
  737. title("ft_memmove\t: ")
  738.  
  739. char s[] = {65, 66, 67, 68, 69, 0, 45};
  740. char s0[] = { 0, 0, 0, 0, 0, 0, 0};
  741. char sCpy[] = {65, 66, 67, 68, 69, 0, 45};
  742. char sResult[] = {67, 68, 67, 68, 69, 0, 45};
  743. char sResult2[] = {67, 67, 68, 68, 69, 0, 45};
  744.  
  745. /* 1 */ check(ft_memmove(s0, s, 7) == s0 && !memcmp(s, s0, 7)); showLeaks(); //Post 0
  746. /* 2 */ check(ft_memmove(s, s + 2, 0) && !memcmp(s, sCpy, 7)); showLeaks(); //0 move
  747. /* 3 */ check(ft_memmove(s, s + 2, 2) == s && !memcmp(s, sResult, 7)); showLeaks(); //forward
  748. /* 4 */ check(ft_memmove(sResult + 1, sResult, 2) == sResult + 1 && !memcmp(sResult, sResult2, 7)); showLeaks(); //reverse
  749. write(1, "\n", 1);
  750.  
  751. char buffer[80];
  752.  
  753. strcpy( buffer, "World");
  754. ft_memmove( buffer+1, buffer, 79 );
  755. printf ("%s\n", buffer);
  756. END
  757.  
  758.  
  759. BEGIN
  760. title("ft_strchr\t: ")
  761. char s[] = "tripouille";
  762. /* 1 */ check(ft_strchr(s, 't') == s); showLeaks();
  763. /* 2 */ check(ft_strchr(s, 'l') == s + 7); showLeaks();
  764. /* 3 */ check(ft_strchr(s, 'z') == 0); showLeaks();
  765. /* 4 */ check(ft_strchr(s, 0) == s + strlen(s)); showLeaks();
  766. /* 5 */ check(ft_strchr(s, 't' + 256) == s); showLeaks();
  767. write(1, "\n", 1);
  768.  
  769. char buffer[80];
  770. char* where;
  771.  
  772. strcpy( buffer, "video x-rays" );
  773.  
  774. where = ft_strchr( buffer, 'x' );
  775.  
  776. if( where == NULL ) {
  777. printf( "'x' not found\n" );
  778. } else {
  779. printf( "'x' found: %s\n", where );
  780. }
  781.  
  782. END
  783.  
  784. BEGIN
  785. title("ft_strrchr\t: ")
  786. char s[] = "tripouille";
  787. char s2[] = "ltripouiel";
  788. /* 1 */ check(ft_strrchr(s, 't') == s); showLeaks();
  789. /* 2 */ check(ft_strrchr(s, 'l') == s + 8); showLeaks();
  790. /* 3 */ check(ft_strrchr(s2, 'l') == s2 + 9); showLeaks();
  791. /* 4 */ check(ft_strrchr(s, 'z') == NULL); showLeaks();
  792. /* 5 */ check(ft_strrchr(s, 0) == s + strlen(s)); showLeaks();
  793. /* 6 */ check(ft_strrchr(s, 't' + 256) == s); showLeaks();
  794. char * empty = (char*)calloc(1, 1);
  795. /* 7 aperez-b */ check(ft_strrchr(empty, 'V') == NULL); free(empty); showLeaks();
  796. write(1, "\n", 1);
  797.  
  798. printf( "%s\n", ft_strrchr( "abcdeabcde", 'a' ) );
  799. if( ft_strrchr( "abcdeabcde", 'x' ) == NULL )
  800. printf( "NULL\n" );
  801.  
  802. END
  803.  
  804. BEGIN
  805. title("ft_strnstr\t: ")
  806.  
  807. char haystack[30] = "aaabcabcd";
  808. char needle[10] = "aabc";
  809. char * empty = (char*)"";
  810. check(ft_strnstr(haystack, needle, 0) == 0); showLeaks();
  811. check(ft_strnstr(haystack, needle, -1) == haystack + 1); showLeaks();
  812. check(ft_strnstr(haystack, "a", -1) == haystack); showLeaks();
  813. check(ft_strnstr(haystack, "c", -1) == haystack + 4); showLeaks();
  814. check(ft_strnstr(empty, "", -1) == empty); showLeaks();
  815. check(ft_strnstr(empty, "", 0) == empty); showLeaks();
  816. check(ft_strnstr(empty, "coucou", -1) == 0); showLeaks();
  817. check(ft_strnstr(haystack, "aaabc", 5) == haystack); showLeaks();
  818. check(ft_strnstr(empty, "12345", 5) == 0); showLeaks();
  819. check(ft_strnstr(haystack, "abcd", 9) == haystack + 5); showLeaks();
  820. check(ft_strnstr(haystack, "cd", 8) == NULL); showLeaks();
  821. check(ft_strnstr(haystack, "a", 1) == haystack); showLeaks();
  822. check(ft_strnstr("1", "a", 1) == NULL); showLeaks();
  823. check(ft_strnstr("22", "b", 2) == NULL); showLeaks();
  824. write(1, "\n", 1);
  825.  
  826. char *searchingFor = "comes";
  827. char *in = "la da\ndoo a da\nnow here comes the stack\nok there it was.\n";
  828. printf("found: %s\n", ft_strnstr(in, searchingFor, ft_strlen(in)) ? "yes" : "no");
  829.  
  830.  
  831. END
  832.  
  833. BEGIN
  834. title("ft_strncmp\t: ")
  835.  
  836. /* 1 */ check(ft_strncmp("t", "", 0) == 0); showLeaks();
  837. /* 2 */ check(ft_strncmp("1234", "1235", 3) == 0); showLeaks();
  838. /* 3 */ check(ft_strncmp("1234", "1235", 4) < 0); showLeaks();
  839. /* 4 */ check(ft_strncmp("1234", "1235", -1) < 0); showLeaks();
  840. /* 5 */ check(ft_strncmp("", "", 42) == 0); showLeaks();
  841. /* 6 */ check(ft_strncmp("Tripouille", "Tripouille", 42) == 0); showLeaks();
  842. /* 7 */ check(ft_strncmp("Tripouille", "tripouille", 42) < 0); showLeaks();
  843. /* 8 */ check(ft_strncmp("Tripouille", "TriPouille", 42) > 0); showLeaks();
  844. /* 9 */ check(ft_strncmp("Tripouille", "TripouillE", 42) > 0); showLeaks();
  845. /* 10 */ check(ft_strncmp("Tripouille", "TripouilleX", 42) < 0); showLeaks();
  846. /* 11 */ check(ft_strncmp("Tripouille", "Tripouill", 42) > 0); showLeaks();
  847. /* 12 */ check(ft_strncmp("", "1", 0) == 0); showLeaks();
  848. /* 13 */ check(ft_strncmp("1", "", 0) == 0); showLeaks();
  849. /* 14 */ check(ft_strncmp("", "1", 1) < 0); showLeaks();
  850. /* 15 */ check(ft_strncmp("1", "", 1) > 0); showLeaks();
  851. /* 16 */ check(ft_strncmp("", "", 1) == 0); showLeaks();
  852. write(1, "\n", 1);
  853.  
  854. char str1[15];
  855. char str2[15];
  856. int ret;
  857.  
  858. strcpy(str1, "ABCDEF");
  859. strcpy(str2, "ABCDEF");
  860.  
  861. ret = ft_strncmp(str1, str2, 4);
  862.  
  863. if(ret < 0)
  864. {
  865. printf("str1 is less than str2 \n");
  866. } else
  867. if(ret > 0)
  868. {
  869. printf("str2 is less than str1 \n");
  870. } else {
  871. printf("str1 is equal to str2 \n");
  872. }
  873. END
  874.  
  875.  
  876. BEGIN
  877. title("ft_strlcat\t: ")
  878.  
  879. char dest[30]; memset(dest, 0, 30);
  880. char * src = (char *)"AAAAAAAAA";
  881. dest[0] = 'B';
  882. /* 1 */ check(ft_strlcat(dest, src, 0) == strlen(src) && !strcmp(dest, "B")); showLeaks();
  883. dest[0] = 'B';
  884. /* 2 */ check(ft_strlcat(dest, src, 1) == 10 && !strcmp(dest, "B")); showLeaks();
  885. memset(dest, 'B', 4);
  886. /* 3 */ check(ft_strlcat(dest, src, 3) == 3 + strlen(src) && !strcmp(dest, "BBBB")); showLeaks();
  887. /* 4 */ check(ft_strlcat(dest, src, 6) == 13 && !strcmp(dest, "BBBBA")); showLeaks();
  888. memset(dest, 'C', 5);
  889. /* 5 */ check(ft_strlcat(dest, src, -1) == 14 && !strcmp(dest, "CCCCCAAAAAAAAA")); showLeaks();
  890. memset(dest, 'C', 15);
  891. /* 6 */ check(ft_strlcat(dest, src, 17) == 24 && !strcmp(dest, "CCCCCCCCCCCCCCCA")); showLeaks();
  892. memset(dest, 0, 30);
  893. /* 7 */ check(ft_strlcat(dest, src, 1) == strlen(src) && !strcmp(dest, "")); showLeaks();
  894. memset(dest, 0, 30); memset(dest, '1', 10);
  895. /* 8 */ check(ft_strlcat(dest, src, 5) == strlen(src) + 5 && !strcmp(dest, "1111111111")); showLeaks();
  896. memset(dest, 0, 30); memset(dest, '1', 10);
  897. /* 9 */ check(ft_strlcat(dest, src, 5) == strlen(src) + 5 && !strcmp(dest, "1111111111")); showLeaks();
  898. memset(dest, 0, 30); memset(dest, '1', 10);
  899. /* 10 */ check(ft_strlcat(dest, "", 15) == 10 && !strcmp(dest, "1111111111")); showLeaks();
  900. memset(dest, 0, 30);
  901. /* 11 */ check(ft_strlcat(dest, "", 42) == 0 && !strcmp(dest, "")); showLeaks();
  902. memset(dest, 0, 30);
  903. /* 12 */ check(ft_strlcat(dest, "", 0) == 0 && !strcmp(dest, "")); showLeaks();
  904. memset(dest, 0, 30);
  905. /* 13 */ check(ft_strlcat(dest, "123", 1) == 3 && !strcmp(dest, "")); showLeaks();
  906. memset(dest, 0, 30);
  907. /* 14 */ check(ft_strlcat(dest, "123", 2) == 3 && !strcmp(dest, "1")); showLeaks();
  908. memset(dest, 0, 30);
  909. /* 15 */ check(ft_strlcat(dest, "123", 3) == 3 && !strcmp(dest, "12")); showLeaks();
  910. memset(dest, 0, 30);
  911. /* 16 */ check(ft_strlcat(dest, "123", 4) == 3 && !strcmp(dest, "123")); showLeaks();
  912. memset(dest, 0, 30);
  913. /* 17 */ check(ft_strlcat(dest, "123", 0) == 3 && !strcmp(dest, "")); showLeaks();
  914. write(1, "\n", 1);
  915.  
  916. END
  917.  
  918. BEGIN
  919. title("ft_strlcpy\t: ")
  920. char src[] = "coucou";
  921. char dest[10]; memset(dest, 'A', 10);
  922. /* 1 */ check(ft_strlcpy(dest, src, 0) == strlen(src) && dest[0] == 'A'); showLeaks();
  923. /* 2 */ check(ft_strlcpy(dest, src, 1) == strlen(src) && dest[0] == 0 && dest[1] == 'A'); showLeaks();
  924. /* 3 */ check(ft_strlcpy(dest, src, 2) == strlen(src) && dest[0] == 'c' && dest[1] == 0 && dest[2] == 'A'); showLeaks();
  925. /* 4 */ check(ft_strlcpy(dest, src, -1) == strlen(src) && !strcmp(src, dest) && dest[strlen(src) + 1] == 'A'); showLeaks(); memset(dest, 'A', 10);
  926. /* 5 */ check(ft_strlcpy(dest, src, 6) == strlen(src) && !memcmp(src, dest, 5) && dest[5] == 0); showLeaks(); memset(dest, 'A', 10);
  927. /* 6 */ check(ft_strlcpy(dest, src, 7) == strlen(src) && !memcmp(src, dest, 7)); showLeaks(); memset(dest, 'A', 10);
  928. /* 7 */ check(ft_strlcpy(dest, src, 8) == strlen(src) && !memcmp(src, dest, 7)); showLeaks(); memset(dest, 'A', 10);
  929. /* 8 */ check(ft_strlcpy(dest, "", 42) == 0 && !memcmp("", dest, 1)); showLeaks(); memset(dest, 0, 10);
  930. /* 9 */ check(ft_strlcpy(dest, "1", 0) == 1 && dest[0] == 0); showLeaks(); memset(dest, 'A', 10);
  931. write(1, "\n", 1);
  932. END
  933.  
  934.  
  935. return 0;
  936. }
  937.  
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!