Initial Commit
This commit is contained in:
Baco
879
libft/munit.c
Normal file
879
libft/munit.c
Normal file
@@ -0,0 +1,879 @@
|
||||
/* ************************************************************************** */
|
||||
/* */
|
||||
/* ::: :::::::: */
|
||||
/* munit.c :+: :+: :+: */
|
||||
/* +:+ +:+ +:+ */
|
||||
/* By: gbaconni <gbaconni@42lausanne.ch> +#+ +:+ +#+ */
|
||||
/* +#+#+#+#+#+ +#+ */
|
||||
/* Created: 2021/10/14 09:22:30 by gbaconni #+# #+# */
|
||||
/* Updated: 2021/10/20 09:31:27 by gbaconni ### ########.fr */
|
||||
/* */
|
||||
/* ************************************************************************** */
|
||||
|
||||
#include "munit.h"
|
||||
#include "libft.h"
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
|
||||
#ifdef __GNU_LIBRARY__
|
||||
|
||||
size_t strnlen(const char *s, size_t maxlen);
|
||||
size_t strlcpy(char *dst, const char *src, size_t dstsize);
|
||||
size_t strlcat(char *dst, const char *src, size_t dstsize);
|
||||
|
||||
size_t strnlen(const char *s, size_t maxlen)
|
||||
{
|
||||
size_t len;
|
||||
|
||||
len = 0;
|
||||
while (s[len] != '\0' && --maxlen != 0)
|
||||
len++;
|
||||
return (len);
|
||||
}
|
||||
|
||||
size_t strlcpy(char *dst, const char *src, size_t dstsize)
|
||||
{
|
||||
size_t srcsize;
|
||||
|
||||
srcsize = strlen(src);
|
||||
if (srcsize < dstsize)
|
||||
{
|
||||
memcpy(dst, src, srcsize + 1);
|
||||
}
|
||||
else if (dstsize != 0)
|
||||
{
|
||||
memcpy(dst, src, dstsize - 1);
|
||||
dst[dstsize - 1] = '\0';
|
||||
}
|
||||
return (srcsize);
|
||||
}
|
||||
|
||||
size_t strlcat(char *dst, const char *src, size_t dstsize)
|
||||
{
|
||||
char *d;
|
||||
const char *s;
|
||||
size_t n;
|
||||
|
||||
d = dst;
|
||||
d += strlen(d);
|
||||
s = src;
|
||||
n = strnlen(s, dstsize);
|
||||
d[n] = '\0';
|
||||
memcpy(d, s, n);
|
||||
return ((d - dst) + n);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static char char_bs[2] = { '\b', '\0' };
|
||||
static char char_tab[2] = { '\t', '\0' };
|
||||
static char char_lf[2] = { '\n', '\0' };
|
||||
static char char_cr[2] = { '\r', '\0' };
|
||||
|
||||
static char *char_params[] = {
|
||||
(char *) "A",
|
||||
(char *) "F",
|
||||
(char *) "T",
|
||||
(char *) "Z",
|
||||
(char *) "a",
|
||||
(char *) "f",
|
||||
(char *) "t",
|
||||
(char *) "z",
|
||||
(char *) "0",
|
||||
(char *) "4",
|
||||
(char *) "2",
|
||||
(char *) "9",
|
||||
(char *) "$",
|
||||
(char *) "!",
|
||||
(char *) " ",
|
||||
(char *) "",
|
||||
(char *) char_bs,
|
||||
(char *) char_tab,
|
||||
(char *) char_lf,
|
||||
(char *) char_cr,
|
||||
NULL
|
||||
};
|
||||
|
||||
static MunitParameterEnum test_c_params[] = {
|
||||
{ (char *) "c", char_params },
|
||||
{ NULL, NULL },
|
||||
};
|
||||
|
||||
static char *string_params[] = {
|
||||
(char *) "uncopyrightables",
|
||||
(char *) "42lausanne",
|
||||
(char *) "lausanne",
|
||||
(char *) "!{}&*",
|
||||
(char *) "42",
|
||||
(char *) "a",
|
||||
(char *) " ",
|
||||
(char *) "",
|
||||
NULL
|
||||
};
|
||||
|
||||
static MunitParameterEnum test_s_params[] = {
|
||||
{ (char *) "s", string_params },
|
||||
{ NULL, NULL },
|
||||
};
|
||||
|
||||
static MunitParameterEnum test_str_params[] = {
|
||||
{ (char *) "str", string_params },
|
||||
{ NULL, NULL },
|
||||
};
|
||||
|
||||
static MunitParameterEnum test_s1_params[] = {
|
||||
{ (char *) "s1", string_params },
|
||||
{ NULL, NULL },
|
||||
};
|
||||
|
||||
static MunitParameterEnum test_dst_src_params[] = {
|
||||
{ (char *) "dst", string_params },
|
||||
{ (char *) "src", string_params },
|
||||
{ NULL, NULL },
|
||||
};
|
||||
|
||||
static MunitParameterEnum test_s1_s2_params[] = {
|
||||
{ (char *) "s1", string_params },
|
||||
{ (char *) "s2", string_params },
|
||||
{ NULL, NULL },
|
||||
};
|
||||
|
||||
static MunitParameterEnum test_haystack_needle_params[] = {
|
||||
{ (char *) "haystack", string_params },
|
||||
{ (char *) "needle", string_params },
|
||||
{ NULL, NULL },
|
||||
};
|
||||
|
||||
static char *int_params[] = {
|
||||
(char *) "-2147483648",
|
||||
(char *) "-42",
|
||||
(char *) "0",
|
||||
(char *) "42",
|
||||
(char *) "2147483647",
|
||||
NULL
|
||||
};
|
||||
|
||||
static MunitParameterEnum test_b_c_params[] = {
|
||||
{ (char *) "b", string_params },
|
||||
{ (char *) "c", char_params },
|
||||
{ NULL, NULL },
|
||||
};
|
||||
|
||||
static MunitParameterEnum test_s_c_params[] = {
|
||||
{ (char *) "s", string_params },
|
||||
{ (char *) "c", char_params },
|
||||
{ NULL, NULL },
|
||||
};
|
||||
|
||||
static MunitParameterEnum test_n_params[] = {
|
||||
{ (char *) "n", int_params },
|
||||
{ NULL, NULL },
|
||||
};
|
||||
|
||||
static MunitResult test_ft_strlen(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
const char *s;
|
||||
|
||||
(void) user_data;
|
||||
s = munit_parameters_get(params, "s");
|
||||
munit_assert_size(ft_strlen(s), ==, strlen(s));
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_strlcpy(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
char *ft_dst;
|
||||
char *dst;
|
||||
const char *src;
|
||||
size_t dstsize;
|
||||
|
||||
(void) user_data;
|
||||
dstsize = strlen(munit_parameters_get(params, "dst")) + 1;
|
||||
ft_dst = (char *) malloc(dstsize * sizeof(char));
|
||||
if (ft_dst == NULL)
|
||||
return (MUNIT_ERROR);
|
||||
memset(ft_dst, '@', dstsize * sizeof(char));
|
||||
dst = (char *) malloc(dstsize * sizeof(char));
|
||||
if (dst == NULL)
|
||||
return (MUNIT_ERROR);
|
||||
memset(dst, '@', dstsize * sizeof(char));
|
||||
src = (const char *) munit_parameters_get(params, "src");
|
||||
(void) strncpy(ft_dst, munit_parameters_get(params, "dst"), dstsize);
|
||||
(void) strncpy(dst, munit_parameters_get(params, "dst"), dstsize);
|
||||
munit_assert_size(ft_strlcpy(ft_dst, src, dstsize), ==, strlcpy(dst, src, dstsize));
|
||||
munit_assert_string_equal(ft_dst, dst);
|
||||
munit_assert_memory_equal(dstsize, ft_dst, dst);
|
||||
free(ft_dst);
|
||||
free(dst);
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_strlcat(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
char *ft_dst;
|
||||
char *dst;
|
||||
const char *src;
|
||||
size_t dstsize;
|
||||
|
||||
(void) user_data;
|
||||
dstsize = strlen(munit_parameters_get(params, "dst")) + strlen(munit_parameters_get(params, "src")) + 1;
|
||||
ft_dst = (char *) malloc(dstsize * sizeof(char));
|
||||
if (ft_dst == NULL)
|
||||
return (MUNIT_ERROR);
|
||||
memset(ft_dst, '@', dstsize * sizeof(char));
|
||||
dst = (char *) malloc(dstsize * sizeof(char));
|
||||
if (dst == NULL)
|
||||
return (MUNIT_ERROR);
|
||||
memset(dst, '@', dstsize * sizeof(char));
|
||||
src = (const char *) munit_parameters_get(params, "src");
|
||||
(void) strncpy(ft_dst, munit_parameters_get(params, "dst"), dstsize);
|
||||
(void) strncpy(dst, munit_parameters_get(params, "dst"), dstsize);
|
||||
munit_assert_size(ft_strlcat(ft_dst, src, dstsize), ==, strlcat(dst, src, dstsize));
|
||||
munit_assert_string_equal(ft_dst, dst);
|
||||
munit_assert_memory_equal(dstsize, ft_dst, dst);
|
||||
free(ft_dst);
|
||||
free(dst);
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_isalpha(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
int c;
|
||||
|
||||
(void) user_data;
|
||||
c = (int) (munit_parameters_get(params, "c"))[0];
|
||||
#ifdef __GNU_LIBRARY__
|
||||
munit_assert_int((ft_isalpha(c) == 0), ==,(isalpha(c) == 0));
|
||||
#else
|
||||
munit_assert_int(ft_isalpha(c), ==, isalpha(c));
|
||||
#endif
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_isdigit(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
int c;
|
||||
|
||||
(void) user_data;
|
||||
c = (int) (munit_parameters_get(params, "c"))[0];
|
||||
#ifdef __GNU_LIBRARY__
|
||||
munit_assert_int((ft_isdigit(c) == 0), ==, (isdigit(c) == 0));
|
||||
#else
|
||||
munit_assert_int(ft_isdigit(c), ==, isdigit(c));
|
||||
#endif
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_isalnum(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
int c;
|
||||
|
||||
(void) user_data;
|
||||
c = (int) (munit_parameters_get(params, "c"))[0];
|
||||
#ifdef __GNU_LIBRARY__
|
||||
munit_assert_int((ft_isalnum(c) == 0), ==, (isalnum(c) == 0));
|
||||
#else
|
||||
munit_assert_int(ft_isalnum(c), ==, isalnum(c));
|
||||
#endif
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_isascii(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
int c;
|
||||
|
||||
(void) user_data;
|
||||
c = (int) (munit_parameters_get(params, "c"))[0];
|
||||
#ifdef __GNU_LIBRARY__
|
||||
munit_assert_int((ft_isascii(c) == 0), ==, (isascii(c) == 0));
|
||||
#else
|
||||
munit_assert_int(ft_isascii(c), ==, isascii(c));
|
||||
#endif
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_isprint(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
int c;
|
||||
|
||||
(void) user_data;
|
||||
c = (int) (munit_parameters_get(params, "c"))[0];
|
||||
#ifdef __GNU_LIBRARY__
|
||||
munit_assert_int((ft_isprint(c) == 0), ==, (isprint(c) == 0));
|
||||
#else
|
||||
munit_assert_int((int) ft_isprint(c), ==, (int) isprint(c));
|
||||
#endif
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_toupper(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
int c;
|
||||
|
||||
(void) user_data;
|
||||
c = (int) (munit_parameters_get(params, "c"))[0];
|
||||
munit_assert_int(ft_toupper(c), ==, toupper(c));
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_tolower(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
int c;
|
||||
|
||||
(void) user_data;
|
||||
c = (int) (munit_parameters_get(params, "c"))[0];
|
||||
munit_assert_int(ft_tolower(c), ==, tolower(c));
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_atoi(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
const char *str;
|
||||
|
||||
(void) user_data;
|
||||
str = munit_parameters_get(params, "str");
|
||||
munit_assert_int(ft_atoi(str), ==, atoi(str));
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_itoa(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
const char *str;
|
||||
char *ft_str;
|
||||
int n;
|
||||
|
||||
(void) user_data;
|
||||
str = munit_parameters_get(params, "n");
|
||||
n = atoi(str);
|
||||
ft_str = ft_itoa(n);
|
||||
munit_assert_string_equal(ft_str, str);
|
||||
munit_assert_memory_equal(strlen(str), ft_str, str);
|
||||
free(ft_str);
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_strncmp(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
const char *s1;
|
||||
const char *s2;
|
||||
size_t n;
|
||||
|
||||
(void) user_data;
|
||||
s1 = (const char *) munit_parameters_get(params, "s1");
|
||||
s2 = (const char *) munit_parameters_get(params, "s2");
|
||||
n = strlen(s1);
|
||||
munit_assert_int(ft_strncmp(s1, s2, n), ==, strncmp(s1, s2, n));
|
||||
n = strlen(s2);
|
||||
munit_assert_int(ft_strncmp(s1, s2, n), ==, strncmp(s1, s2, n));
|
||||
n = 4;
|
||||
munit_assert_int(ft_strncmp(s1, s2, n), ==, strncmp(s1, s2, n));
|
||||
n = 2;
|
||||
munit_assert_int(ft_strncmp(s1, s2, n), ==, strncmp(s1, s2, n));
|
||||
n = 0;
|
||||
munit_assert_int(ft_strncmp(s1, s2, n), ==, strncmp(s1, s2, n));
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_memcmp(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
const void *s1;
|
||||
const void *s2;
|
||||
size_t n;
|
||||
|
||||
(void) user_data;
|
||||
s1 = (void *) munit_parameters_get(params, "s1");
|
||||
s2 = (void *) munit_parameters_get(params, "s2");
|
||||
n = strlen((char *) s1);
|
||||
munit_assert_int(ft_memcmp(s1, s2, n), ==, memcmp(s1, s2, n));
|
||||
n = strlen((char *) s2);
|
||||
munit_assert_int(ft_memcmp(s1, s2, n), ==, memcmp(s1, s2, n));
|
||||
n = 4;
|
||||
munit_assert_int(ft_memcmp(s1, s2, n), ==, memcmp(s1, s2, n));
|
||||
n = 2;
|
||||
munit_assert_int(ft_memcmp(s1, s2, n), ==, memcmp(s1, s2, n));
|
||||
n = 0;
|
||||
munit_assert_int(ft_memcmp(s1, s2, n), ==, memcmp(s1, s2, n));
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_bzero(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
void *ft_s;
|
||||
void *s;
|
||||
size_t n;
|
||||
|
||||
(void) user_data;
|
||||
n = strlen(munit_parameters_get(params, "s")) + 1;
|
||||
s = (void *) malloc(n * sizeof(unsigned char));
|
||||
if (s == NULL)
|
||||
return (MUNIT_ERROR);
|
||||
memset(s, '@', n * sizeof(unsigned char));
|
||||
ft_s = (void *) malloc(n * sizeof(unsigned char));
|
||||
if (ft_s == NULL)
|
||||
return (MUNIT_ERROR);
|
||||
memset(ft_s, '@', n * sizeof(unsigned char));
|
||||
(void) strncpy(s, munit_parameters_get(params, "s"), n);
|
||||
(void) strncpy(ft_s, munit_parameters_get(params, "s"), n);
|
||||
bzero(s, n);
|
||||
ft_bzero(ft_s, n);
|
||||
munit_assert_memory_equal(n, ft_s, s);
|
||||
free(ft_s);
|
||||
free(s);
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_memset(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
void *ft_b;
|
||||
void *b;
|
||||
int c;
|
||||
size_t len;
|
||||
|
||||
(void) user_data;
|
||||
len = strlen(munit_parameters_get(params, "b")) + 1;
|
||||
c = (int) (munit_parameters_get(params, "c"))[0];
|
||||
b = (void *) malloc(len * sizeof(unsigned char));
|
||||
if (b == NULL)
|
||||
return (MUNIT_ERROR);
|
||||
memset(b, '@', len * sizeof(unsigned char));
|
||||
ft_b = (void *) malloc(len * sizeof(unsigned char));
|
||||
if (ft_b == NULL)
|
||||
return (MUNIT_ERROR);
|
||||
memset(ft_b, '@', len * sizeof(unsigned char));
|
||||
(void) strncpy(b, munit_parameters_get(params, "b"), len);
|
||||
(void) strncpy(ft_b, munit_parameters_get(params, "b"), len);
|
||||
memset(b, c, len);
|
||||
ft_memset(ft_b, c, len);
|
||||
munit_assert_memory_equal(len, ft_b, b);
|
||||
free(ft_b);
|
||||
free(b);
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_memchr(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
const char *s;
|
||||
int c;
|
||||
size_t n;
|
||||
char *ft_str;
|
||||
char *str;
|
||||
|
||||
(void) user_data;
|
||||
s = munit_parameters_get(params, "s");
|
||||
c = (int) (munit_parameters_get(params, "c"))[0];
|
||||
n = strlen(s) + 1;
|
||||
str = (char *) memchr(s, c, n);
|
||||
ft_str = (char *) ft_memchr(s, c, n);
|
||||
if (str != NULL && ft_str != NULL)
|
||||
{
|
||||
munit_assert_string_equal(ft_str, str);
|
||||
munit_assert_memory_equal(n, ft_str, str);
|
||||
}
|
||||
else if (str == NULL)
|
||||
{
|
||||
munit_assert_null(ft_str);
|
||||
}
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_strchr(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
const char *s;
|
||||
int c;
|
||||
size_t n;
|
||||
char *ft_str;
|
||||
char *str;
|
||||
|
||||
(void) user_data;
|
||||
s = munit_parameters_get(params, "s");
|
||||
c = (int) (munit_parameters_get(params, "c"))[0];
|
||||
n = strlen(s) + 1;
|
||||
str = strchr(s, c);
|
||||
ft_str = ft_strchr(s, c);
|
||||
if (str != NULL && ft_str != NULL)
|
||||
{
|
||||
munit_assert_string_equal(ft_str, str);
|
||||
munit_assert_memory_equal(n, ft_str, str);
|
||||
}
|
||||
else if (str == NULL)
|
||||
{
|
||||
munit_assert_null(ft_str);
|
||||
}
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_strrchr(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
const char *s;
|
||||
int c;
|
||||
size_t n;
|
||||
char *ft_str;
|
||||
char *str;
|
||||
|
||||
(void) user_data;
|
||||
s = munit_parameters_get(params, "s");
|
||||
c = (int) (munit_parameters_get(params, "c"))[0];
|
||||
n = strlen(s) + 1;
|
||||
str = strrchr(s, c);
|
||||
ft_str = ft_strrchr(s, c);
|
||||
if (str != NULL && ft_str != NULL)
|
||||
{
|
||||
munit_assert_string_equal(ft_str, str);
|
||||
munit_assert_memory_equal(n, ft_str, str);
|
||||
}
|
||||
else if (str == NULL)
|
||||
{
|
||||
munit_assert_null(ft_str);
|
||||
}
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_strnstr(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
const char *haystack;
|
||||
const char *needle;
|
||||
size_t len;
|
||||
size_t n;
|
||||
char *ft_str;
|
||||
char *str;
|
||||
|
||||
(void) user_data;
|
||||
haystack = (const char *) munit_parameters_get(params, "haystack");
|
||||
needle = (const char *) munit_parameters_get(params, "needle");
|
||||
n = strlen(haystack);
|
||||
len = n;
|
||||
while (len != 0)
|
||||
{
|
||||
ft_str = ft_strnstr(haystack, needle, len);
|
||||
#ifdef __GNU_LIBRARY__
|
||||
str = strstr(haystack, needle);
|
||||
#else
|
||||
str = strnstr(haystack, needle, len);
|
||||
#endif
|
||||
if (str != NULL && ft_str != NULL)
|
||||
{
|
||||
munit_assert_string_equal(ft_str, str);
|
||||
munit_assert_memory_equal(n, ft_str, str);
|
||||
}
|
||||
else if (str == NULL)
|
||||
{
|
||||
munit_assert_null(ft_str);
|
||||
}
|
||||
len--;
|
||||
}
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_strdup(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
const char *s1;
|
||||
size_t n;
|
||||
char *ft_str;
|
||||
char *str;
|
||||
|
||||
(void) user_data;
|
||||
s1 = (const char *) munit_parameters_get(params, "s1");
|
||||
n = strlen(s1);
|
||||
ft_str = ft_strdup(s1);
|
||||
str = strdup(s1);
|
||||
if (str != NULL && ft_str != NULL)
|
||||
{
|
||||
munit_assert_string_equal(ft_str, str);
|
||||
munit_assert_memory_equal(n, ft_str, str);
|
||||
}
|
||||
else if (str == NULL)
|
||||
{
|
||||
munit_assert_null(ft_str);
|
||||
}
|
||||
free(ft_str);
|
||||
free(str);
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_memcpy(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
char *ft_dst;
|
||||
char *dst;
|
||||
const char *src;
|
||||
size_t n;
|
||||
char *ft_str;
|
||||
char *str;
|
||||
|
||||
(void) user_data;
|
||||
n = strlen(munit_parameters_get(params, "dst")) + 1;
|
||||
ft_dst = (char *) malloc(n * sizeof(char));
|
||||
if (ft_dst == NULL)
|
||||
return (MUNIT_ERROR);
|
||||
memset(ft_dst, '@', n * sizeof(unsigned char));
|
||||
dst = (char *) malloc(n * sizeof(char));
|
||||
if (dst == NULL)
|
||||
return (MUNIT_ERROR);
|
||||
memset(dst, '@', n * sizeof(unsigned char));
|
||||
(void) strncpy(ft_dst, munit_parameters_get(params, "dst"), n);
|
||||
(void) strncpy(dst, munit_parameters_get(params, "dst"), n);
|
||||
src = (const char *) munit_parameters_get(params, "src");
|
||||
ft_str = ft_memcpy(ft_dst, src, n);
|
||||
str = memcpy(dst, src, n);
|
||||
munit_assert_string_equal(ft_dst, dst);
|
||||
munit_assert_string_equal(ft_str, str);
|
||||
munit_assert_memory_equal(n, ft_dst, dst);
|
||||
munit_assert_memory_equal(n, ft_str, str);
|
||||
free(ft_dst);
|
||||
free(dst);
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_memmove(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
char *ft_dst;
|
||||
char *dst;
|
||||
const char *src;
|
||||
size_t len;
|
||||
char *ft_str;
|
||||
char *str;
|
||||
|
||||
(void) user_data;
|
||||
len = strlen(munit_parameters_get(params, "dst")) + 1;
|
||||
ft_dst = (char *) malloc(len * sizeof(char));
|
||||
if (ft_dst == NULL)
|
||||
return (MUNIT_ERROR);
|
||||
memset(ft_dst, '@', len * sizeof(char));
|
||||
dst = (char *) malloc(len * sizeof(char));
|
||||
if (dst == NULL)
|
||||
return (MUNIT_ERROR);
|
||||
memset(dst, '@', len * sizeof(char));
|
||||
(void) strncpy(ft_dst, munit_parameters_get(params, "dst"), len);
|
||||
(void) strncpy(dst, munit_parameters_get(params, "dst"), len);
|
||||
src = (const char *) munit_parameters_get(params, "src");
|
||||
ft_str = ft_memmove(ft_dst, src, len);
|
||||
str = memmove(dst, src, len);
|
||||
munit_assert_string_equal(ft_dst, dst);
|
||||
munit_assert_string_equal(ft_str, str);
|
||||
munit_assert_memory_equal(len, ft_dst, dst);
|
||||
munit_assert_memory_equal(len, ft_str, str);
|
||||
free(ft_dst);
|
||||
free(dst);
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_calloc(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
size_t count;
|
||||
size_t size;
|
||||
char *ft_str;
|
||||
char *str;
|
||||
|
||||
(void) user_data;
|
||||
(void) params;
|
||||
count = 42;
|
||||
size = sizeof(char);
|
||||
while (count)
|
||||
{
|
||||
ft_str = (char *) ft_calloc(count, size);
|
||||
if (ft_str == NULL)
|
||||
return (MUNIT_ERROR);
|
||||
str = (char *) calloc(count, size);
|
||||
if (str == NULL)
|
||||
return (MUNIT_ERROR);
|
||||
munit_assert_string_equal(ft_str, str);
|
||||
munit_assert_memory_equal(count * size, ft_str, str);
|
||||
free(ft_str);
|
||||
free(str);
|
||||
count--;
|
||||
}
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_putchar_fd(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
int fd;
|
||||
int count;
|
||||
char c;
|
||||
char str[1];
|
||||
char name[256];
|
||||
|
||||
(void) user_data;
|
||||
c = (char) (munit_parameters_get(params, "c"))[0];
|
||||
fd = -1;
|
||||
memset(name, 0, sizeof(name));
|
||||
strncpy(name,"/tmp/.ft_XXXXXX", 16);
|
||||
fd = mkstemp(name);
|
||||
if (fd == -1)
|
||||
return (MUNIT_ERROR);
|
||||
ft_putchar_fd(c, fd);
|
||||
(void) lseek(fd, 0, SEEK_SET);
|
||||
count = read(fd, str, 1);
|
||||
munit_assert_int(count, ==, 1);
|
||||
munit_assert_int(str[0], ==, c);
|
||||
unlink(name);
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_putstr_fd(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
int fd;
|
||||
int count;
|
||||
int n;
|
||||
char *s;
|
||||
char *str;
|
||||
char name[256];
|
||||
|
||||
(void) user_data;
|
||||
s = (char *) munit_parameters_get(params, "s");
|
||||
n = strlen(s);
|
||||
fd = -1;
|
||||
str = (char *) malloc((n + 1) * sizeof(char));
|
||||
if (str == NULL)
|
||||
return (MUNIT_ERROR);
|
||||
memset(str, '@', (n + 1) * sizeof(char));
|
||||
memset(name, 0, sizeof(name));
|
||||
strncpy(name,"/tmp/.ft_XXXXXX", 16);
|
||||
fd = mkstemp(name);
|
||||
if (fd == -1)
|
||||
return (MUNIT_ERROR);
|
||||
ft_putstr_fd(s, fd);
|
||||
(void) lseek(fd, 0, SEEK_SET);
|
||||
count = read(fd, str, n);
|
||||
str[n] = '\0';
|
||||
munit_assert_int(count, ==, n);
|
||||
munit_assert_string_equal(str, s);
|
||||
munit_assert_memory_equal(n + 1, str, s);
|
||||
unlink(name);
|
||||
free(str);
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_putendl_fd(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
int fd;
|
||||
int count;
|
||||
int n;
|
||||
char *s;
|
||||
char *str;
|
||||
char name[256];
|
||||
|
||||
(void) user_data;
|
||||
s = (char *) munit_parameters_get(params, "s");
|
||||
n = strlen(s);
|
||||
fd = -1;
|
||||
str = (char *) malloc((n + 1) * sizeof(char));
|
||||
if (str == NULL)
|
||||
return (MUNIT_ERROR);
|
||||
memset(str, '@', (n + 1) * sizeof(char));
|
||||
memset(name, 0, sizeof(name));
|
||||
strncpy(name,"/tmp/.ft_XXXXXX", 16);
|
||||
fd = mkstemp(name);
|
||||
if (fd == -1)
|
||||
return (MUNIT_ERROR);
|
||||
ft_putendl_fd(s, fd);
|
||||
(void) lseek(fd, 0, SEEK_SET);
|
||||
count = read(fd, str, n);
|
||||
str[n] = '\0';
|
||||
munit_assert_int(count, ==, n);
|
||||
munit_assert_string_equal(str, s);
|
||||
munit_assert_memory_equal(n, str, s);
|
||||
count = read(fd, str, 1);
|
||||
munit_assert_int(count, ==, 1);
|
||||
munit_assert_int(str[0], ==, '\n');
|
||||
unlink(name);
|
||||
free(str);
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
static MunitResult test_ft_putnbr_fd(const MunitParameter params[], void* user_data)
|
||||
{
|
||||
int fd;
|
||||
int count;
|
||||
char name[256];
|
||||
const char *str;
|
||||
char *ft_str;
|
||||
int n;
|
||||
int len;
|
||||
|
||||
(void) user_data;
|
||||
str = munit_parameters_get(params, "n");
|
||||
n = atoi(str);
|
||||
ft_str = ft_itoa(n);
|
||||
fd = -1;
|
||||
len = strlen(str);
|
||||
ft_str = (char *) malloc((len + 1) * sizeof(char));
|
||||
if (ft_str == NULL)
|
||||
return (MUNIT_ERROR);
|
||||
memset(ft_str, '@', (len + 1) * sizeof(char));
|
||||
memset(name, 0, sizeof(name));
|
||||
strncpy(name,"/tmp/.ft_XXXXXX", 16);
|
||||
fd = mkstemp(name);
|
||||
if (fd == -1)
|
||||
return (MUNIT_ERROR);
|
||||
ft_putnbr_fd(n, fd);
|
||||
len = lseek(fd, 0, SEEK_END);
|
||||
(void) lseek(fd, 0, SEEK_SET);
|
||||
count = read(fd, ft_str, len);
|
||||
ft_str[len] = '\0';
|
||||
munit_assert_int(count, ==, len);
|
||||
munit_assert_string_equal(ft_str, str);
|
||||
munit_assert_memory_equal(len, ft_str, str);
|
||||
unlink(name);
|
||||
free(ft_str);
|
||||
return (MUNIT_OK);
|
||||
}
|
||||
|
||||
/*
|
||||
void ft_striteri(char *s, void (*f)(unsigned int, char*));
|
||||
char *ft_strmapi(char const *s, char (*f)(unsigned int, char));
|
||||
|
||||
char *ft_strjoin(char const *s1, char const *s2);
|
||||
char *ft_strtrim(char const *s1, char const *set);
|
||||
char *ft_substr(char const *s, unsigned int start, size_t len);
|
||||
char **ft_split(char const *s, char c);
|
||||
*/
|
||||
|
||||
static MunitTest test_suite_tests[] = {
|
||||
{ (char*) "/libft/ft_strlen", test_ft_strlen, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_s_params },
|
||||
{ (char*) "/libft/ft_strlcat", test_ft_strlcat, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_dst_src_params },
|
||||
{ (char*) "/libft/ft_strlcpy", test_ft_strlcpy, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_dst_src_params },
|
||||
{ (char*) "/libft/ft_isalpha", test_ft_isalpha, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_c_params },
|
||||
{ (char*) "/libft/ft_isdigit", test_ft_isdigit, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_c_params },
|
||||
{ (char*) "/libft/ft_isalnum", test_ft_isalnum, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_c_params },
|
||||
{ (char*) "/libft/ft_isascii", test_ft_isascii, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_c_params },
|
||||
{ (char*) "/libft/ft_isprint", test_ft_isprint, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_c_params },
|
||||
{ (char*) "/libft/ft_toupper", test_ft_toupper, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_c_params },
|
||||
{ (char*) "/libft/ft_tolower", test_ft_tolower, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_c_params },
|
||||
{ (char*) "/libft/ft_atoi", test_ft_atoi, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_str_params },
|
||||
{ (char*) "/libft/ft_itoa", test_ft_itoa, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_n_params },
|
||||
{ (char*) "/libft/ft_strncmp", test_ft_strncmp, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_s1_s2_params },
|
||||
{ (char*) "/libft/ft_memcmp", test_ft_memcmp, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_s1_s2_params },
|
||||
{ (char*) "/libft/ft_bzero", test_ft_bzero, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_s_params },
|
||||
{ (char*) "/libft/ft_memset", test_ft_memset, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_b_c_params },
|
||||
{ (char*) "/libft/ft_memchr", test_ft_memchr, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_s_c_params },
|
||||
{ (char*) "/libft/ft_strchr", test_ft_strchr, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_s_c_params },
|
||||
{ (char*) "/libft/ft_strrchr", test_ft_strrchr, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_s_c_params },
|
||||
{ (char*) "/libft/ft_strnstr", test_ft_strnstr, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_haystack_needle_params },
|
||||
{ (char*) "/libft/ft_strdup", test_ft_strdup, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_s1_params },
|
||||
{ (char*) "/libft/ft_memcpy", test_ft_memcpy, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_dst_src_params },
|
||||
{ (char*) "/libft/ft_memmove", test_ft_memmove, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_dst_src_params },
|
||||
{ (char*) "/libft/ft_calloc", test_ft_calloc, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL },
|
||||
{ (char*) "/libft/ft_putchar_fd", test_ft_putchar_fd, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_c_params },
|
||||
{ (char*) "/libft/ft_putstr_fd", test_ft_putstr_fd, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_s_params },
|
||||
{ (char*) "/libft/ft_putendl_fd", test_ft_putendl_fd, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_s_params },
|
||||
{ (char*) "/libft/ft_putnbr_fd", test_ft_putnbr_fd, NULL, NULL, MUNIT_TEST_OPTION_NONE, test_n_params },
|
||||
{ NULL, NULL, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL }
|
||||
};
|
||||
|
||||
static const MunitSuite test_suite = {
|
||||
(char*) "42lausanne",
|
||||
test_suite_tests,
|
||||
NULL,
|
||||
1,
|
||||
MUNIT_SUITE_OPTION_NONE
|
||||
};
|
||||
|
||||
int main(int argc, char* argv[MUNIT_ARRAY_PARAM(argc + 1)])
|
||||
{
|
||||
munit_uint8_t data[42];
|
||||
|
||||
munit_rand_memory(sizeof(data), data);
|
||||
return (munit_suite_main(&test_suite, (void *) data, argc, argv));
|
||||
}
|
||||
Reference in New Issue
Block a user