/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   munit.c                                            :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: gbaconni <gbaconni@42lausanne.ch>          +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2021/10/23 16:09:04 by gbaconni          #+#    #+#             */
/*   Updated: 2021/10/29 12:02:14 by gbaconni         ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#include "munit.h"
#include "libft.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <unistd.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);
#endif

static char	bs[2] = { '\b', '\0' };
static char	tab[2] = { '\t', '\0' };
static char	lf[2] = { '\n', '\0' };
static 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 *) bs,
	(char *) tab,
	(char *) lf,
	(char *) cr,
	NULL
};

static MunitParameterEnum	test_c_params[] = {
	{ (char *) "c", char_params },
	{ NULL, NULL },
};

static char	*string_params[] = {
	(char *) "uncopyrightables", 
	(char *) "42lausanne.ch", 
	(char *) "42lausanne", 
	(char *) "123456789", 
	(char *) "lausanne", 
	(char *) "42.fr", 
	(char *) "!{}&*", 
	(char *) "42", 
	(char *) "CH", 
	(char *) "Ch", 
	(char *) "ch", 
	(char *) "a", 
	(char *) "\r", 
	(char *) "\n", 
	(char *) "\b", 
	(char *) "\t", 
	(char *) "\v", 
	(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 *) "-123456789", 
	(char *) "-12345678", 
	(char *) "-1234567", 
	(char *) "-123456", 
	(char *) "-12345", 
	(char *) "-1234", 
	(char *) "-123", 
	(char *) "-42", 
	(char *) "-1", 
	(char *) "0", 
	(char *) "1", 
	(char *) "42", 
	(char *) "123", 
	(char *) "1234", 
	(char *) "12345", 
	(char *) "123456", 
	(char *) "1234567", 
	(char *) "12345678", 
	(char *) "123456789", 
	(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));
	//if (strcmp(s, "NULL") == 0)
	//	munit_assert_size(ft_strlen(NULL), ==, strlen(NULL));
	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 *) munit_malloc(dstsize * sizeof(char));
	if (ft_dst == NULL)
		return (MUNIT_ERROR);
	memset(ft_dst, '@', dstsize);
	dst = (char *) munit_malloc(dstsize * sizeof(char));
	if (dst == NULL)
		return (MUNIT_ERROR);
	memset(dst, '@', dstsize);
	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 *) munit_malloc(dstsize * sizeof(char));
	if (ft_dst == NULL)
		return (MUNIT_ERROR);
	memset(ft_dst, '@', dstsize);
	dst = (char *) munit_malloc(dstsize * sizeof(char));
	if (dst == NULL)
		return (MUNIT_ERROR);
	memset(dst, '@', dstsize);
	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;
#ifdef __GNU_LIBRARY__
	(void) user_data;
	(void) params;
	(void) s1;
	(void) s2;
	(void) n;
#else
	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));
#endif
	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 *) munit_malloc(n * sizeof(unsigned char));
	if (s == NULL)
		return (MUNIT_ERROR);
	memset(s, '@', n);
	ft_s = (void *) munit_malloc(n * sizeof(unsigned char));
	if (ft_s == NULL)
		return (MUNIT_ERROR);
	memset(ft_s, '@', n);
	(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 *) munit_malloc(len * sizeof(unsigned char));
	if (b == NULL)
		return (MUNIT_ERROR);
	memset(b, '@', len);
	ft_b = (void *) munit_malloc(len * sizeof(unsigned char));
	if (ft_b == NULL)
		return (MUNIT_ERROR);
	memset(ft_b, '@', len);
	(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_ptr_equal(ft_str, 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_ptr_equal(ft_str, 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_ptr_equal(ft_str, 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);
		}
#ifndef __GNU_LIBRARY__
		else
		{
			munit_assert_ptr_equal(ft_str, str);
		}
#endif
		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_ptr_equal(ft_str, 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 *) munit_malloc(n * sizeof(char));
	if (ft_dst == NULL)
		return (MUNIT_ERROR);
	memset(ft_dst, '@', n);
	dst = (char *) munit_malloc(n * sizeof(char));
	if (dst == NULL)
		return (MUNIT_ERROR);
	memset(dst, '@', n);
	(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 *) munit_malloc(len * sizeof(char));
	if (ft_dst == NULL)
		return (MUNIT_ERROR);
	memset(ft_dst, '@', len);
	dst = (char *) munit_malloc(len * sizeof(char));
	if (dst == NULL)
		return (MUNIT_ERROR);
	memset(dst, '@', len);
	(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 *) munit_malloc((n + 1) * sizeof(char));
	if (str == NULL)
		return (MUNIT_ERROR);
	memset(str, '@', (n + 1));
	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 *) munit_malloc((n + 1) * sizeof(char));
	if (str == NULL)
		return (MUNIT_ERROR);
	memset(str, '@', (n + 1));
	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 *) munit_malloc((len + 1) * sizeof(char));
	if (ft_str == NULL)
		return (MUNIT_ERROR);
	memset(ft_str, '@', (len + 1));
	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));
}

#ifdef __GNU_LIBRARY__
size_t	strnlen(const char *s, size_t maxlen)
{
	size_t	len;

	len = 0;
	while (len < maxlen && *s++ != '\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)
{
	size_t	srclen;
	size_t	dstlen;
	size_t	cpylen;

	srclen = strlen(src);
	dstlen = strnlen(dst, dstsize);
	if (dstlen == dstsize)
		return (dstsize + srclen);
	if (srclen < dstsize - dstlen)
		cpylen = srclen + 1;
	else
		cpylen = dstsize - dstlen - 1;
	memcpy(dst + dstlen, src, cpylen);
	dst[dstsize - 1] = '\0';
	return (dstlen + srclen);
}
#endif