diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..b012ca5
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,12 @@
+[submodule "libft/Libftest"]
+	path = libft/Libftest
+	url = https://github.com/jtoty/Libftest.git
+[submodule "libft/libft-unit-test"]
+	path = libft/libft-unit-test
+	url = https://github.com/alelievr/libft-unit-test.git
+[submodule "libft/libftTester"]
+	path = libft/libftTester
+	url = https://github.com/Tripouille/libftTester.git
+[submodule "libft/munit"]
+	path = libft/munit
+	url = https://github.com/nemequ/munit.git
diff --git a/README.md b/README.md
index 4d4a76c..5fdc02b 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,8 @@
 # 42test
 
-Unit Testing for 42 Projects
\ No newline at end of file
+Unit Testing for 42 Projects
+
+## libft
+
+Library Forty-Two like a mini Libc for string and memory
+
diff --git a/libft/Libftest b/libft/Libftest
new file mode 160000
index 0000000..d6cdc52
--- /dev/null
+++ b/libft/Libftest
@@ -0,0 +1 @@
+Subproject commit d6cdc5255fc1aacaa19dca07d8adab0ca65e9bdb
diff --git a/libft/Makefile b/libft/Makefile
new file mode 100644
index 0000000..3c0e12b
--- /dev/null
+++ b/libft/Makefile
@@ -0,0 +1,77 @@
+# **************************************************************************** #
+#                                                                              #
+#                                                         :::      ::::::::    #
+#    Makefile                                           :+:      :+:    :+:    #
+#                                                     +:+ +:+         +:+      #
+#    By: gbaconni <gbaconni@42lausanne.ch>          +#+  +:+       +#+         #
+#                                                 +#+#+#+#+#+   +#+            #
+#    Created: 2021/10/22 09:10:00 by gbaconni          #+#    #+#              #
+#    Updated: 2021/10/22 10:23:54 by gbaconni         ###   ########.fr        #
+#                                                                              #
+# **************************************************************************** #
+#
+# make munit.out
+# make all
+# make clean
+# make fclean
+# make re
+# make
+#
+
+OUT = munit.out
+
+LIBDIR = libft
+LIB = ft
+
+HDRDIR = munit
+HDR = $(HDRDIR)/munit.h
+
+SRCDIR = .
+SRC = \
+	  $(SRCDIR)/munit.c \
+	  $(HDRDIR)/munit.c
+
+CC = gcc
+CFLAGS = -Wall -Wextra -Werror -O1
+
+RM = rm
+RMFLAGS = -f
+
+all: compile test
+
+a: compile
+	@./$(OUT) || true
+
+b: compile
+	@grep -q '/libft$$' libftTester/Makefile || sed -i '' -r 's/^(PARENT_DIR.*)/\1\/libft/' libftTester/Makefile
+	@make -C libftTester m || true
+	@make -C libftTester b || true
+
+c: compile
+	@make -C libftTester clean || true
+	@make -C Libftest all || true
+	@grep -q '^PATH_LIBFT=\.\./libft' Libftest/my_config.sh || sed -i '' -r 's/^(PATH_LIBFT)=.*/\1=..\/libft/' Libftest/my_config.sh
+	@cd Libftest && ./grademe.sh || true
+
+d: compile
+	@make -C libft-unit-test all || true
+	@cd libft-unit-test && ./run_test || true
+
+test: a b c d
+	@echo "done."
+
+compile:
+	@make -C $(LIBDIR) all
+	@$(CC) $(CFLAGS) $(SRC) -I${LIBDIR} -I$(HDRDIR) -L${LIBDIR} -l${LIB} -o $(OUT)
+
+clean:
+	@make -C $(LIBDIR) clean
+	@$(RM) $(RMFLAGS) $(OUT)
+
+fclean: clean
+	@make -C $(LIBDIR) fclean
+	@$(RM) $(RMFLAGS) $(OUT)
+
+re: fclean all
+
+
diff --git a/libft/README.md b/libft/README.md
new file mode 100644
index 0000000..0004604
--- /dev/null
+++ b/libft/README.md
@@ -0,0 +1,45 @@
+# libft
+
+## Setup
+
+Create a link to the base of your libft
+(the one with libft.a and all ft_ and Makefile files)
+
+```
+ln -snf $(find ~ -mindepth 2 -maxdepth 4 -name libft.h -exec dirname "{}" \; 2>/dev/null | head -n1) libft
+
+# You can also specify the path to your libft
+ln -snf ~/Projects/libft/git libft
+ln -snf ../../42/libft/git libft
+ln -snf ../libft libft
+```
+
+## Usage
+
+```
+make test
+
+# or
+make a
+make b
+make c
+make d
+```
+
+## External Subprojects
+
+- [jtoty/Libftest](https://github.com/jtoty/Libftest)
+- [alelievr/libft-unit-test](https://github.com/alelievr/libft-unit-test)
+- [Tripouille/libftTester](https://github.com/Tripouille/libftTester)
+- [nemequ/µnit](https://nemequ.github.io/munit/)
+
+Create subprojects
+```
+git submodule add https://github.com/jtoty/Libftest.git
+git submodule add https://github.com/alelievr/libft-unit-test.git
+git submodule add https://github.com/Tripouille/libftTester.git
+git submodule add https://github.com/nemequ/munit.git
+
+grep -q '/libft$' libftTester/Makefile || sed -i '' -r 's/^(PARENT_DIR.*)/\1\/libft/' libftTester/Makefile
+```
+
diff --git a/libft/libft b/libft/libft
new file mode 120000
index 0000000..e9bc02e
--- /dev/null
+++ b/libft/libft
@@ -0,0 +1 @@
+../../42/libft/git
\ No newline at end of file
diff --git a/libft/libft-unit-test b/libft/libft-unit-test
new file mode 160000
index 0000000..39aed22
--- /dev/null
+++ b/libft/libft-unit-test
@@ -0,0 +1 @@
+Subproject commit 39aed225356cb7452e493f9563eeb0deacd95ebc
diff --git a/libft/libftTester b/libft/libftTester
new file mode 160000
index 0000000..003db20
--- /dev/null
+++ b/libft/libftTester
@@ -0,0 +1 @@
+Subproject commit 003db205e649357688c3d225476be2725fb5cb4b
diff --git a/libft/munit b/libft/munit
new file mode 160000
index 0000000..fbbdf14
--- /dev/null
+++ b/libft/munit
@@ -0,0 +1 @@
+Subproject commit fbbdf1467eb0d04a6ee465def2e529e4c87f2118
diff --git a/libft/munit.c b/libft/munit.c
new file mode 100644
index 0000000..7d6da20
--- /dev/null
+++ b/libft/munit.c
@@ -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));
+}
diff --git a/libft/munit.sh b/libft/munit.sh
new file mode 100755
index 0000000..e76ccf3
--- /dev/null
+++ b/libft/munit.sh
@@ -0,0 +1,18 @@
+#!/bin/sh
+program=$(basename $0 .sh)".out"
+set -e
+make test
+echo
+#make fclean
+make
+echo
+echo $(basename ${PWD}):
+if [ ${DEBUG-0} -gt 0 ]; then
+	gcc -Wall -Wextra -Werror -g -fsanitize=address -O1 munit/munit.c munit.c -I munit -L. -lft -o ${program}
+else
+	gcc -Wall -Wextra -Werror munit/munit.c munit.c -I munit -L. -lft -o ${program}
+fi
+./${program} "$@"
+#make fclean
+rm -f ${program}
+rm -fr *.dSYM