Merge branch 'master' into ft_ssl

59 files changed, 1872 insertions, 374 deletions

diff --git a/test/src/algo/test_ft_qsort.c b/test/src/algo/test_ft_qsort.c
index 25a5ef6..00062b0 100644
--- a/test/src/algo/test_ft_qsort.c
+++ b/test/src/algo/test_ft_qsort.c
@@ -8,19 +8,43 @@ TEST_SETUP(ft_qsort)
 TEST_TEAR_DOWN(ft_qsort)
 {}
 
-static int compar(const void *a, const void *b)
-{
-	return *(int*)a - *(int*)b;
-}
-
 TEST(ft_qsort, basic)
 {
 	int arr[] = {3, 4, 1, 2, 7, 189, -1, -134, 7, 1, 34};
 	int sorted_arr[sizeof(arr)];
-
 	memcpy(sorted_arr, arr, sizeof(arr));
-	qsort(sorted_arr, sizeof(arr) / sizeof(int), sizeof(int), compar);
-
-	ft_qsort(arr, sizeof(arr) / sizeof(int), sizeof(int), compar);
+	qsort(sorted_arr, sizeof(arr) / sizeof(int), sizeof(int), ft_compar_int);
+	ft_qsort(arr, sizeof(arr) / sizeof(int), sizeof(int), ft_compar_int);
 	TEST_ASSERT_EQUAL_INT_ARRAY(sorted_arr, arr, sizeof(arr) / sizeof(int));
 }
+
+TEST(ft_qsort, strings)
+{
+	char *arr[] = {"zzz", "fff", "aaa"};
+	char *sorted[sizeof(arr)];
+	memcpy(sorted, arr, sizeof(arr));
+	qsort(sorted, sizeof(arr) / sizeof(char*), sizeof(char*), ft_compar_str);
+	ft_qsort(arr, sizeof(arr) / sizeof(char*), sizeof(char*), ft_compar_str);
+	TEST_ASSERT_EQUAL_STRING_ARRAY(sorted, arr, sizeof(arr) / sizeof(char*));
+
+	char *arr2[] = {"abcdef", "abcde", "abcd", "abc", "ab", "a", ""};
+	char *sorted2[sizeof(arr2)];
+	memcpy(sorted2, arr2, sizeof(arr2));
+	qsort(sorted2, sizeof(arr2) / sizeof(char*), sizeof(char*), ft_compar_str);
+	ft_qsort(arr2, sizeof(arr2) / sizeof(char*), sizeof(char*), ft_compar_str);
+	TEST_ASSERT_EQUAL_STRING_ARRAY(sorted2, arr2, sizeof(arr2) / sizeof(char*));
+
+	char *arr3[] = {"", "a", "ab", "abc", "abcd", "abcde", "abcdef"};
+	char *sorted3[sizeof(arr3)];
+	memcpy(sorted3, arr3, sizeof(arr3));
+	qsort(sorted3, sizeof(arr3) / sizeof(char*), sizeof(char*), ft_compar_str);
+	ft_qsort(arr3, sizeof(arr3) / sizeof(char*), sizeof(char*), ft_compar_str);
+	TEST_ASSERT_EQUAL_STRING_ARRAY(sorted3, arr3, sizeof(arr3) / sizeof(char*));
+
+	char *arr4[] = {"ast.c", "z.c", "path.c", "main.c", "utils.c", "preprocess.c", "env.c"};
+	char *sorted4[sizeof(arr4)];
+	memcpy(sorted4, arr4, sizeof(arr4));
+	qsort(sorted4, sizeof(arr4) / sizeof(char*), sizeof(char*), ft_compar_str);
+	ft_qsort(arr4, sizeof(arr4) / sizeof(char*), sizeof(char*), ft_compar_str);
+	TEST_ASSERT_EQUAL_STRING_ARRAY(sorted4, arr4, sizeof(arr4) / sizeof(char*));
+}
diff --git a/test/src/dstr/test_ft_dstrdestroy.c b/test/src/dstr/test_ft_dstrdestroy.c
new file mode 100644
index 0000000..1a6cb41
--- /dev/null
+++ b/test/src/dstr/test_ft_dstrdestroy.c
@@ -0,0 +1,26 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_dstrdestroy.c                              :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/04 21:04:51 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_dstrdestroy);
+
+TEST_SETUP(ft_dstrdestroy)
+{}
+
+TEST_TEAR_DOWN(ft_dstrdestroy)
+{}
+
+TEST(ft_dstrdestroy, basic)
+{
+	TEST_PASS();
+}
diff --git a/test/src/dstr/test_ft_dstrerase.c b/test/src/dstr/test_ft_dstrerase.c
new file mode 100644
index 0000000..01ed560
--- /dev/null
+++ b/test/src/dstr/test_ft_dstrerase.c
@@ -0,0 +1,69 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_dstrerase.c                                :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/05 01:02:40 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_dstrerase);
+
+TEST_SETUP(ft_dstrerase)
+{}
+
+TEST_TEAR_DOWN(ft_dstrerase)
+{}
+
+TEST(ft_dstrerase, basic)
+{
+	t_ftdstr *dstr;
+
+	dstr = ft_dstrnew("bonjour");
+	ft_dstrerase(dstr, 0, 0);
+	TEST_ASSERT_NOT_NULL(dstr);
+	TEST_ASSERT_EQUAL(7, dstr->length);
+	TEST_ASSERT_EQUAL(8, dstr->capacity);
+	TEST_ASSERT_EQUAL_STRING("bonjour", dstr->str);
+
+	ft_dstrerase(dstr, 2, 0);
+	TEST_ASSERT_NOT_NULL(dstr);
+	TEST_ASSERT_EQUAL(7, dstr->length);
+	TEST_ASSERT_EQUAL(8, dstr->capacity);
+	TEST_ASSERT_EQUAL_STRING("bonjour", dstr->str);
+
+	ft_dstrerase(dstr, 2, 1);
+	TEST_ASSERT_NOT_NULL(dstr);
+	TEST_ASSERT_EQUAL(6, dstr->length);
+	TEST_ASSERT_EQUAL(8, dstr->capacity);
+	TEST_ASSERT_EQUAL_STRING("bojour", dstr->str);
+
+	ft_dstrerase(dstr, 6, 1);
+	TEST_ASSERT_NOT_NULL(dstr);
+	TEST_ASSERT_EQUAL(6, dstr->length);
+	TEST_ASSERT_EQUAL(8, dstr->capacity);
+	TEST_ASSERT_EQUAL_STRING("bojour", dstr->str);
+
+	ft_dstrerase(dstr, 5, 1);
+	TEST_ASSERT_NOT_NULL(dstr);
+	TEST_ASSERT_EQUAL(5, dstr->length);
+	TEST_ASSERT_EQUAL(8, dstr->capacity);
+	TEST_ASSERT_EQUAL_STRING("bojou", dstr->str);
+
+	ft_dstrerase(dstr, 0, 2);
+	TEST_ASSERT_NOT_NULL(dstr);
+	TEST_ASSERT_EQUAL(3, dstr->length);
+	TEST_ASSERT_EQUAL(8, dstr->capacity);
+	TEST_ASSERT_EQUAL_STRING("jou", dstr->str);
+
+	ft_dstrerase(dstr, 0, 10);
+	TEST_ASSERT_NOT_NULL(dstr);
+	TEST_ASSERT_EQUAL(0, dstr->length);
+	TEST_ASSERT_EQUAL(8, dstr->capacity);
+	TEST_ASSERT_EQUAL_STRING("", dstr->str);
+}
diff --git a/test/src/dstr/test_ft_dstrgrow.c b/test/src/dstr/test_ft_dstrgrow.c
new file mode 100644
index 0000000..1e3edb6
--- /dev/null
+++ b/test/src/dstr/test_ft_dstrgrow.c
@@ -0,0 +1,52 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_dstrgrow.c                                 :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/04 21:12:16 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_dstrgrow);
+
+TEST_SETUP(ft_dstrgrow)
+{}
+
+TEST_TEAR_DOWN(ft_dstrgrow)
+{}
+
+TEST(ft_dstrgrow, basic)
+{
+	t_ftdstr *dstr;
+
+	dstr = ft_dstrnew("bonjour");
+	TEST_ASSERT_NOT_NULL(ft_dstrgrow(dstr, 3));
+	TEST_ASSERT_GREATER_OR_EQUAL(3, dstr->capacity - 1);
+	TEST_ASSERT_EQUAL_STRING("bonjour", dstr->str);
+	TEST_ASSERT_EQUAL(strlen("bonjour"), dstr->length);
+
+	TEST_ASSERT_NOT_NULL(ft_dstrgrow(dstr, 16));
+	TEST_ASSERT_GREATER_OR_EQUAL(16, dstr->capacity - 1);
+	TEST_ASSERT_EQUAL_STRING("bonjour", dstr->str);
+	TEST_ASSERT_EQUAL(strlen("bonjour"), dstr->length);
+
+	TEST_ASSERT_NOT_NULL(ft_dstrgrow(dstr, 8));
+	TEST_ASSERT_GREATER_OR_EQUAL(8, dstr->capacity - 1);
+	TEST_ASSERT_EQUAL_STRING("bonjour", dstr->str);
+	TEST_ASSERT_EQUAL(strlen("bonjour"), dstr->length);
+
+	TEST_ASSERT_NOT_NULL(ft_dstrgrow(dstr, 20));
+	TEST_ASSERT_GREATER_OR_EQUAL(20, dstr->capacity - 1);
+	TEST_ASSERT_EQUAL_STRING("bonjour", dstr->str);
+	TEST_ASSERT_EQUAL(strlen("bonjour"), dstr->length);
+
+	TEST_ASSERT_NOT_NULL(ft_dstrgrow(dstr, 32));
+	TEST_ASSERT_GREATER_OR_EQUAL(32, dstr->capacity - 1);
+	TEST_ASSERT_EQUAL_STRING("bonjour", dstr->str);
+	TEST_ASSERT_EQUAL(strlen("bonjour"), dstr->length);
+}
diff --git a/test/src/dstr/test_ft_dstrinsert.c b/test/src/dstr/test_ft_dstrinsert.c
new file mode 100644
index 0000000..61f407c
--- /dev/null
+++ b/test/src/dstr/test_ft_dstrinsert.c
@@ -0,0 +1,59 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_dstrinsert.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/04 21:21:51 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_dstrinsert);
+
+TEST_SETUP(ft_dstrinsert)
+{}
+
+TEST_TEAR_DOWN(ft_dstrinsert)
+{}
+
+TEST(ft_dstrinsert, basic)
+{
+	t_ftdstr *dstr;
+
+	dstr = ft_dstrnew("");
+
+	TEST_ASSERT_NULL(ft_dstrinsert(dstr, "", 1));
+	TEST_ASSERT_NULL(ft_dstrinsert(dstr, "test", 1));
+	TEST_ASSERT_NULL(ft_dstrinsert(dstr, "", 5));
+	TEST_ASSERT_NULL(ft_dstrinsert(dstr, "test", 5));
+
+	TEST_ASSERT_NOT_NULL(ft_dstrinsert(dstr, "bonjour", 0));
+	TEST_ASSERT_NOT_NULL(dstr->str);
+	TEST_ASSERT_EQUAL_STRING("bonjour", dstr->str);
+	TEST_ASSERT_EQUAL(strlen(dstr->str), dstr->length);
+	TEST_ASSERT_GREATER_THAN(strlen(dstr->str), dstr->capacity);
+
+	TEST_ASSERT_NULL(ft_dstrinsert(dstr, "abc", 8));
+
+	TEST_ASSERT_NOT_NULL(ft_dstrinsert(dstr, "{{{", 0));
+	TEST_ASSERT_NOT_NULL(dstr->str);
+	TEST_ASSERT_EQUAL_STRING("{{{bonjour", dstr->str);
+	TEST_ASSERT_EQUAL(strlen(dstr->str), dstr->length);
+	TEST_ASSERT_GREATER_THAN(strlen(dstr->str), dstr->capacity);
+
+	TEST_ASSERT_NOT_NULL(ft_dstrinsert(dstr, "]]]", dstr->length));
+	TEST_ASSERT_NOT_NULL(dstr->str);
+	TEST_ASSERT_EQUAL_STRING("{{{bonjour]]]", dstr->str);
+	TEST_ASSERT_EQUAL(strlen(dstr->str), dstr->length);
+	TEST_ASSERT_GREATER_THAN(strlen(dstr->str), dstr->capacity);
+
+	TEST_ASSERT_NOT_NULL(ft_dstrinsert(dstr, "<>", 6));
+	TEST_ASSERT_NOT_NULL(dstr->str);
+	TEST_ASSERT_EQUAL_STRING("{{{bon<>jour]]]", dstr->str);
+	TEST_ASSERT_EQUAL(strlen(dstr->str), dstr->length);
+	TEST_ASSERT_GREATER_THAN(strlen(dstr->str), dstr->capacity);
+}
diff --git a/test/src/dstr/test_ft_dstrnew.c b/test/src/dstr/test_ft_dstrnew.c
new file mode 100644
index 0000000..33024e4
--- /dev/null
+++ b/test/src/dstr/test_ft_dstrnew.c
@@ -0,0 +1,60 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_dstrnew.c                                  :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/04 21:03:25 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_dstrnew);
+
+TEST_SETUP(ft_dstrnew)
+{}
+
+TEST_TEAR_DOWN(ft_dstrnew)
+{}
+
+TEST(ft_dstrnew, basic)
+{
+	t_ftdstr *dstr;
+
+	dstr = ft_dstrnew("");
+	TEST_ASSERT_NOT_NULL(dstr);
+	TEST_ASSERT_NOT_NULL(dstr->str);
+	TEST_ASSERT_EQUAL_STRING("", dstr->str);
+	TEST_ASSERT_EQUAL(1, dstr->capacity);
+	TEST_ASSERT_EQUAL(0, dstr->length);
+	ft_dstrdestroy(dstr);
+
+	dstr = ft_dstrnew("abc");
+	TEST_ASSERT_NOT_NULL(dstr);
+	TEST_ASSERT_NOT_NULL(dstr->str);
+	TEST_ASSERT_EQUAL_STRING("abc", dstr->str);
+	TEST_ASSERT_EQUAL(strlen("abc") + 1, dstr->capacity);
+	TEST_ASSERT_EQUAL(strlen("abc"), dstr->length);
+	ft_dstrdestroy(dstr);
+
+	dstr = ft_dstrnew("hidden\0text");
+	TEST_ASSERT_NOT_NULL(dstr);
+	TEST_ASSERT_NOT_NULL(dstr->str);
+	TEST_ASSERT_EQUAL_STRING("hidden\0text", dstr->str);
+	TEST_ASSERT_EQUAL(strlen("hidden") + 1, dstr->capacity);
+	TEST_ASSERT_EQUAL(strlen("hidden"), dstr->length);
+	ft_dstrdestroy(dstr);
+
+	char *long_string = "asdkfjasl;asdjiojxocijioajsdfopijasdofijasiodfjaospidj"\
+						"fopiasjdfoijasdopifjaspoidjfopiasjdfpoiajsdfoijd";
+	dstr = ft_dstrnew(long_string);
+	TEST_ASSERT_NOT_NULL(dstr);
+	TEST_ASSERT_NOT_NULL(dstr->str);
+	TEST_ASSERT_EQUAL_STRING(long_string, dstr->str);
+	TEST_ASSERT_EQUAL(strlen(long_string) + 1, dstr->capacity);
+	TEST_ASSERT_EQUAL(strlen(long_string), dstr->length);
+	ft_dstrdestroy(dstr);
+}
diff --git a/test/src/dstr/test_ft_dstrsubstitute.c b/test/src/dstr/test_ft_dstrsubstitute.c
new file mode 100644
index 0000000..d81b944
--- /dev/null
+++ b/test/src/dstr/test_ft_dstrsubstitute.c
@@ -0,0 +1,64 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_dstrsubstitute.c                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/05 01:09:47 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_dstrsubstitute);
+
+TEST_SETUP(ft_dstrsubstitute)
+{}
+
+TEST_TEAR_DOWN(ft_dstrsubstitute)
+{}
+
+TEST(ft_dstrsubstitute, basic)
+{
+	t_ftdstr *dstr;
+
+	dstr = ft_dstrnew("bonjour");
+	TEST_ASSERT_NULL(ft_dstrsubstitute(dstr, "bonjour", 8, 1));
+
+	TEST_ASSERT_NOT_NULL(ft_dstrsubstitute(dstr, "{{{", 0, 0));
+	TEST_ASSERT_NOT_NULL(dstr);
+	TEST_ASSERT_NOT_NULL(dstr->str);
+	TEST_ASSERT_EQUAL(10, dstr->length);
+	TEST_ASSERT_GREATER_OR_EQUAL(11, dstr->capacity);
+	TEST_ASSERT_EQUAL_STRING("{{{bonjour", dstr->str);
+
+	TEST_ASSERT_NOT_NULL(ft_dstrsubstitute(dstr, "]]]", dstr->length, 0));
+	TEST_ASSERT_NOT_NULL(dstr);
+	TEST_ASSERT_NOT_NULL(dstr->str);
+	TEST_ASSERT_EQUAL(13, dstr->length);
+	TEST_ASSERT_GREATER_OR_EQUAL(14, dstr->capacity);
+	TEST_ASSERT_EQUAL_STRING("{{{bonjour]]]", dstr->str);
+
+	TEST_ASSERT_NOT_NULL(ft_dstrsubstitute(dstr, "aurevoir", 3, 7));
+	TEST_ASSERT_NOT_NULL(dstr);
+	TEST_ASSERT_NOT_NULL(dstr->str);
+	TEST_ASSERT_EQUAL(14, dstr->length);
+	TEST_ASSERT_GREATER_OR_EQUAL(15, dstr->capacity);
+	TEST_ASSERT_EQUAL_STRING("{{{aurevoir]]]", dstr->str);
+
+	TEST_ASSERT_NOT_NULL(ft_dstrsubstitute(dstr, "<>", 0, dstr->length));
+	TEST_ASSERT_NOT_NULL(dstr);
+	TEST_ASSERT_NOT_NULL(dstr->str);
+	TEST_ASSERT_EQUAL(2, dstr->length);
+	TEST_ASSERT_GREATER_OR_EQUAL(3, dstr->capacity);
+	TEST_ASSERT_EQUAL_STRING("<>", dstr->str);
+
+	TEST_ASSERT_NOT_NULL(ft_dstrsubstitute(dstr, "<>", 0, dstr->length));
+	TEST_ASSERT_NOT_NULL(dstr);
+	TEST_ASSERT_NOT_NULL(dstr->str);
+	TEST_ASSERT_EQUAL(2, dstr->length);
+	TEST_ASSERT_GREATER_OR_EQUAL(3, dstr->capacity);
+	TEST_ASSERT_EQUAL_STRING("<>", dstr->str);
+}
diff --git a/test/src/dstr/test_ft_dstrunwrap.c b/test/src/dstr/test_ft_dstrunwrap.c
new file mode 100644
index 0000000..dbc334a
--- /dev/null
+++ b/test/src/dstr/test_ft_dstrunwrap.c
@@ -0,0 +1,42 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_dstrunwrap.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/04 21:07:16 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_dstrunwrap);
+
+TEST_SETUP(ft_dstrunwrap)
+{}
+
+TEST_TEAR_DOWN(ft_dstrunwrap)
+{}
+
+TEST(ft_dstrunwrap, basic)
+{
+	t_ftdstr *dstr;
+	char *ret;
+
+	dstr = ft_dstrnew("bonjour");
+	ret = ft_dstrunwrap(dstr);
+	TEST_ASSERT_NOT_NULL(ret);
+	TEST_ASSERT_EQUAL_STRING("bonjour", ret);
+
+	dstr = ft_dstrnew("");
+	ret = ft_dstrunwrap(dstr);
+	TEST_ASSERT_NOT_NULL(ret);
+	TEST_ASSERT_EQUAL_STRING("", ret);
+
+	dstr = ft_dstrnew("hidden\0text");
+	ret = ft_dstrunwrap(dstr);
+	TEST_ASSERT_NOT_NULL(ret);
+	TEST_ASSERT_EQUAL_STRING("hidden", ret);
+}
diff --git a/test/src/ht/test_ft_htdelone.c b/test/src/ht/test_ft_htdelone.c
index 3bc0922..a64b34e 100644
--- a/test/src/ht/test_ft_htdelone.c
+++ b/test/src/ht/test_ft_htdelone.c
@@ -6,7 +6,7 @@
 /*   By: cacharle <marvin@42.fr>                    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2020/02/19 02:08:00 by cacharle          #+#    #+#             */
-/*   Updated: 2020/02/19 02:46:10 by cacharle         ###   ########.fr       */
+/*   Updated: 2020/04/03 07:08:38 by charles          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -20,23 +20,17 @@ TEST_SETUP(ft_htdelone)
 TEST_TEAR_DOWN(ft_htdelone)
 {}
 
-static void st_del(t_ftht_content *v)
-{
-	free(v->key);
-	free(v);
-}
-
 TEST(ft_htdelone, basic)
 {
 	t_ftht *ht = ft_htnew(3);
 
-	ft_htset(ht, "bonjour", "je", st_del);
-	ft_htset(ht, "a", "yay", st_del);
-	ft_htset(ht, "b", "aasdf", st_del);
-	ft_htset(ht, "c", "a", st_del);
-	ft_htset(ht, "d", "dd", st_del);
+	ft_htset(ht, "bonjour", strdup("je"), free);
+	ft_htset(ht, "a", strdup("yay"), free);
+	ft_htset(ht, "b", strdup("aasdf"), free);
+	ft_htset(ht, "c", "a", NULL);
+	ft_htset(ht, "d", "dd", NULL);
 
-	ft_htdelone(ht, "bonjour", st_del);
+	ft_htdelone(ht, "bonjour", free);
 	void *ptr = ft_htget(ht, "bonjour");
 	TEST_ASSERT_NULL(ptr);
 	TEST_ASSERT_NOT_NULL(ft_htget(ht, "a"));
@@ -44,25 +38,25 @@ TEST(ft_htdelone, basic)
 	TEST_ASSERT_NOT_NULL(ft_htget(ht, "c"));
 	TEST_ASSERT_NOT_NULL(ft_htget(ht, "d"));
 
-	ft_htdelone(ht, "a", st_del);
+	ft_htdelone(ht, "a", free);
 	ptr = ft_htget(ht, "a");
 	TEST_ASSERT_NULL(ptr);
 	TEST_ASSERT_NOT_NULL(ft_htget(ht, "b"));
 	TEST_ASSERT_NOT_NULL(ft_htget(ht, "c"));
 	TEST_ASSERT_NOT_NULL(ft_htget(ht, "d"));
 
-	ft_htdelone(ht, "b", st_del);
+	ft_htdelone(ht, "b", free);
 	ptr = ft_htget(ht, "b");
 	TEST_ASSERT_NULL(ptr);
 	TEST_ASSERT_NOT_NULL(ft_htget(ht, "c"));
 	TEST_ASSERT_NOT_NULL(ft_htget(ht, "d"));
 
-	ft_htdelone(ht, "c", st_del);
+	ft_htdelone(ht, "c", NULL);
 	ptr = ft_htget(ht, "c");
 	TEST_ASSERT_NULL(ptr);
 	TEST_ASSERT_NOT_NULL(ft_htget(ht, "d"));
 
-	ft_htdelone(ht, "d", st_del);
+	ft_htdelone(ht, "d", NULL);
 	ptr = ft_htget(ht, "d");
 	TEST_ASSERT_NULL(ptr);
 }
diff --git a/test/src/ht/test_ft_htdestroy.c b/test/src/ht/test_ft_htdestroy.c
index 360a7a0..4d212e1 100644
--- a/test/src/ht/test_ft_htdestroy.c
+++ b/test/src/ht/test_ft_htdestroy.c
@@ -6,7 +6,7 @@
 /*   By: cacharle <marvin@42.fr>                    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2020/02/19 02:45:27 by cacharle          #+#    #+#             */
-/*   Updated: 2020/02/19 02:49:36 by cacharle         ###   ########.fr       */
+/*   Updated: 2020/04/03 07:07:07 by charles          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -20,19 +20,13 @@ TEST_SETUP(ft_htdestroy)
 TEST_TEAR_DOWN(ft_htdestroy)
 {}
 
-static void st_del(t_ftht_content *v)
-{
-	free(v->key);
-	free(v);
-}
-
 TEST(ft_htdestroy, basic)
 {
 	t_ftht *ht = ft_htnew(2);
 
-	ft_htset(ht, "a", "1", st_del);
-	ft_htset(ht, "b", "2", st_del);
-	ft_htset(ht, "c", "3", st_del);
-	ft_htset(ht, "d", "4", st_del);
-	ft_htdestroy(ht, st_del);
+	ft_htset(ht, "a", strdup("1"), free);
+	ft_htset(ht, "b", strdup("2"), free);
+	ft_htset(ht, "c", "3", NULL);
+	ft_htset(ht, "d", "4", NULL);
+	ft_htdestroy(ht, NULL);
 }
diff --git a/test/src/ht/test_ft_htget.c b/test/src/ht/test_ft_htget.c
index 5db06b7..4d4b4eb 100644
--- a/test/src/ht/test_ft_htget.c
+++ b/test/src/ht/test_ft_htget.c
@@ -16,12 +16,6 @@ TEST_TEAR_DOWN(ft_htget)
 
 int helper_segfault_pid;
 
-static void st_del(t_ftht_content *c)
-{
-	free(c->key);
-	free(c);
-}
-
 TEST(ft_htget, segfault)
 {
 	TEST_ASSERT_SEGFAULT(ft_htget((t_ftht*)NULL, ""));
@@ -43,72 +37,72 @@ TEST(ft_htget, error_null)
 
 TEST(ft_htget, basic)
 {
-	ft_htset(ht, strdup("a"), strdup("data1"), st_del);
-	ft_htset(ht, strdup("b"), strdup("data2"), st_del);
-	ft_htset(ht, strdup("c"), strdup("data3"), st_del);
+	ft_htset(ht, strdup("a"), strdup("data1"), free);
+	ft_htset(ht, strdup("b"), strdup("data2"), free);
+	ft_htset(ht, strdup("c"), strdup("data3"), free);
 
 	char *s = ft_htget(ht, "a");
 	TEST_ASSERT_NOT_NULL(s);
-	TEST_ASSERT_EQUAL_STRING(s, "data1"); 
+	TEST_ASSERT_EQUAL_STRING(s, "data1");
 
 	s = ft_htget(ht, "b");
 	TEST_ASSERT_NOT_NULL(s);
-	TEST_ASSERT_EQUAL_STRING(s, "data2"); 
+	TEST_ASSERT_EQUAL_STRING(s, "data2");
 
 	s = ft_htget(ht, "c");
 	TEST_ASSERT_NOT_NULL(s);
-	TEST_ASSERT_EQUAL_STRING(s, "data3"); 
+	TEST_ASSERT_EQUAL_STRING(s, "data3");
 
-	ft_htset(ht, strdup("a"), strdup("bonjour1"), st_del);
-	ft_htset(ht, strdup("b"), strdup("bonjour2"), st_del);
-	ft_htset(ht, strdup("c"), strdup("bonjour3"), st_del);
+	ft_htset(ht, strdup("a"), strdup("bonjour1"), free);
+	ft_htset(ht, strdup("b"), strdup("bonjour2"), free);
+	ft_htset(ht, strdup("c"), strdup("bonjour3"), free);
 
 	s = ft_htget(ht, "a");
 	TEST_ASSERT_NOT_NULL(s);
-	TEST_ASSERT_EQUAL_STRING(s, "bonjour1"); 
+	TEST_ASSERT_EQUAL_STRING(s, "bonjour1");
 
 	s = ft_htget(ht, "b");
 	TEST_ASSERT_NOT_NULL(s);
-	TEST_ASSERT_EQUAL_STRING(s, "bonjour2"); 
+	TEST_ASSERT_EQUAL_STRING(s, "bonjour2");
 
 	s = ft_htget(ht, "c");
 	TEST_ASSERT_NOT_NULL(s);
-	TEST_ASSERT_EQUAL_STRING(s, "bonjour3"); 
+	TEST_ASSERT_EQUAL_STRING(s, "bonjour3");
 }
 
 TEST(ft_htget, collision)
 {
 	t_ftht *small = ft_htnew(1);
 
-	ft_htset(small, strdup("a"), strdup("data1"), st_del);
-	ft_htset(small, strdup("b"), strdup("data2"), st_del);
-	ft_htset(small, strdup("c"), strdup("data3"), st_del);
+	ft_htset(small, strdup("a"), strdup("data1"), free);
+	ft_htset(small, strdup("b"), strdup("data2"), free);
+	ft_htset(small, strdup("c"), strdup("data3"), free);
 
 	char *s = ft_htget(small, "a");
 	TEST_ASSERT_NOT_NULL(s);
-	TEST_ASSERT_EQUAL_STRING(s, "data1"); 
+	TEST_ASSERT_EQUAL_STRING(s, "data1");
 
 	s = ft_htget(small, "b");
 	TEST_ASSERT_NOT_NULL(s);
-	TEST_ASSERT_EQUAL_STRING(s, "data2"); 
+	TEST_ASSERT_EQUAL_STRING(s, "data2");
 
 	s = ft_htget(small, "c");
 	TEST_ASSERT_NOT_NULL(s);
-	TEST_ASSERT_EQUAL_STRING(s, "data3"); 
+	TEST_ASSERT_EQUAL_STRING(s, "data3");
 
-	ft_htset(small, strdup("a"), strdup("bonjour1"), st_del);
-	ft_htset(small, strdup("b"), strdup("bonjour2"), st_del);
-	ft_htset(small, strdup("c"), strdup("bonjour3"), st_del);
+	ft_htset(small, strdup("a"), strdup("bonjour1"), free);
+	ft_htset(small, strdup("b"), strdup("bonjour2"), free);
+	ft_htset(small, strdup("c"), strdup("bonjour3"), free);
 
 	s = ft_htget(small, "a");
 	TEST_ASSERT_NOT_NULL(s);
-	TEST_ASSERT_EQUAL_STRING(s, "bonjour1"); 
+	TEST_ASSERT_EQUAL_STRING(s, "bonjour1");
 
 	s = ft_htget(small, "b");
 	TEST_ASSERT_NOT_NULL(s);
-	TEST_ASSERT_EQUAL_STRING(s, "bonjour2"); 
+	TEST_ASSERT_EQUAL_STRING(s, "bonjour2");
 
 	s = ft_htget(small, "c");
 	TEST_ASSERT_NOT_NULL(s);
-	TEST_ASSERT_EQUAL_STRING(s, "bonjour3"); 
+	TEST_ASSERT_EQUAL_STRING(s, "bonjour3");
 }
diff --git a/test/src/ht/test_ft_htnew.c b/test/src/ht/test_ft_htnew.c
index 6b90f03..17bca6a 100644
--- a/test/src/ht/test_ft_htnew.c
+++ b/test/src/ht/test_ft_htnew.c
@@ -6,7 +6,7 @@
 /*   By: cacharle <marvin@42.fr>                    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2020/02/12 22:30:06 by cacharle          #+#    #+#             */
-/*   Updated: 2020/02/17 04:18:20 by cacharle         ###   ########.fr       */
+/*   Updated: 2020/02/28 12:15:32 by cacharle         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -42,7 +42,7 @@ TEST(ft_htnew, happy_path)
 	ht = ft_htnew(10);
 	TEST_ASSERT_NOT_NULL(ht);
 	TEST_ASSERT_EQUAL(10, ht->size);
-	TEST_ASSERT_NOT_NULL(ht->entries);
+	TEST_ASSERT_NOT_NULL(ht->buckets);
 	for (t_ftsize i = 0; i < ht->size; i++)
-		TEST_ASSERT_NULL(ht->entries[i]);
+		TEST_ASSERT_NULL(ht->buckets[i]);
 }
diff --git a/test/src/ht/test_ft_htset.c b/test/src/ht/test_ft_htset.c
index f161206..70232fd 100644
--- a/test/src/ht/test_ft_htset.c
+++ b/test/src/ht/test_ft_htset.c
@@ -14,12 +14,6 @@ TEST_TEAR_DOWN(ft_htset)
 	/* ft_htdestroy_key(ht); */
 }
 
-static void st_del(t_ftht_content *c)
-{
-	free(c->key);
-	free(c);
-}
-
 TEST(ft_htset, segfault)
 {
 	TEST_ASSERT_SEGFAULT(ft_htset(NULL, "", strdup(""), NULL));
@@ -43,7 +37,7 @@ TEST(ft_htset, error_null)
 
 TEST(ft_htset, happy_path)
 {
-	t_ftht_content *content = ft_htset(ht, "bonjour", strdup("content"), NULL);
+	t_ftht_entry *content = ft_htset(ht, "bonjour", strdup("content"), NULL);
 	TEST_ASSERT_NOT_NULL(content);
 	TEST_ASSERT_NOT_NULL(content->key);
 	TEST_ASSERT_NOT_NULL(content->value);
@@ -57,14 +51,14 @@ TEST(ft_htset, reset)
 
 	small = ft_htnew(3);
 
-	t_ftht_content *content = ft_htset(small, "bonjour", ft_strdup("content"), st_del);
+	t_ftht_entry *content = ft_htset(small, "bonjour", ft_strdup("content"), free);
 	TEST_ASSERT_NOT_NULL(content);
 	TEST_ASSERT_NOT_NULL(content->key);
 	TEST_ASSERT_NOT_NULL(content->value);
 	TEST_ASSERT_EQUAL_STRING(content->key, "bonjour");
 	TEST_ASSERT_EQUAL_STRING(content->value, "content");
-	
-	t_ftht_content *content_re = ft_htset(small, "bonjour", ft_strdup("yo"), st_del);
+
+	t_ftht_entry *content_re = ft_htset(small, "bonjour", ft_strdup("yo"), free);
 	TEST_ASSERT_NOT_NULL(content_re);
 	TEST_ASSERT_NOT_NULL(content_re->key);
 	TEST_ASSERT_NOT_NULL(content_re->value);
@@ -77,21 +71,21 @@ TEST(ft_htset, collision)
 	t_ftht *small = NULL;
 	small = ft_htnew(1);
 
-	t_ftht_content *content1 = ft_htset(ht, "bonjour", strdup("content1"), st_del);
+	t_ftht_entry *content1 = ft_htset(small, "bonjour", strdup("content1"), free);
 	TEST_ASSERT_NOT_NULL(content1);
 	TEST_ASSERT_NOT_NULL(content1->key);
 	TEST_ASSERT_NOT_NULL(content1->value);
 	TEST_ASSERT_EQUAL_STRING(content1->key, "bonjour");
 	TEST_ASSERT_EQUAL_STRING(content1->value, "content1");
 
-	t_ftht_content *content2 = ft_htset(ht, "aurevoir", strdup("content2"), st_del);
+	t_ftht_entry *content2 = ft_htset(small, "aurevoir", strdup("content2"), free);
 	TEST_ASSERT_NOT_NULL(content2);
 	TEST_ASSERT_NOT_NULL(content2->key);
 	TEST_ASSERT_NOT_NULL(content2->value);
 	TEST_ASSERT_EQUAL_STRING(content2->key, "aurevoir");
 	TEST_ASSERT_EQUAL_STRING(content2->value, "content2");
 
-	t_ftht_content *content3 = ft_htset(ht, "aloa", strdup("content3"), st_del);
+	t_ftht_entry *content3 = ft_htset(small, "aloa", strdup("content3"), free);
 	TEST_ASSERT_NOT_NULL(content3);
 	TEST_ASSERT_NOT_NULL(content3->key);
 	TEST_ASSERT_NOT_NULL(content3->value);
diff --git a/test/src/ht/test_ft_htcontent_new.c b/test/src/ht/test_ftht_entry_new.c
index 6993581..a566600 100644
--- a/test/src/ht/test_ft_htcontent_new.c
+++ b/test/src/ht/test_ftht_entry_new.c
@@ -1,7 +1,7 @@
 /* ************************************************************************** */
 /*                                                                            */
 /*                                                        :::      ::::::::   */
-/*   test_ft_htcontent_new.c                            :+:      :+:    :+:   */
+/*   test_ft_htentry_new.c                            :+:      :+:    :+:   */
 /*                                                    +:+ +:+         +:+     */
 /*   By: cacharle <marvin@42.fr>                    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
@@ -12,26 +12,26 @@
 
 #include "libft_test.h"
 
-TEST_GROUP(ft_htcontent_new);
+TEST_GROUP(ft_htentry_new);
 
-TEST_SETUP(ft_htcontent_new)
+TEST_SETUP(ft_htentry_new)
 {}
 
-TEST_TEAR_DOWN(ft_htcontent_new)
+TEST_TEAR_DOWN(ft_htentry_new)
 {}
 
-TEST(ft_htcontent_new, basic)
+TEST(ft_htentry_new, basic)
 {
-	t_ftht_content *c = NULL;
+	t_ftht_entry *c = NULL;
 
 	char *k = "bonjour";
-	c = ft_htcontent_new(k, NULL);
+	c = ft_htentry_new(k, NULL);
 	TEST_ASSERT_NOT_NULL(c);
 	TEST_ASSERT(k != c->key);
 	TEST_ASSERT_EQUAL_STRING(k, c->key);
 	TEST_ASSERT_NULL(c->value); 
 
-	c = ft_htcontent_new(k, k);
+	c = ft_htentry_new(k, k);
 	TEST_ASSERT_NOT_NULL(c);
 	TEST_ASSERT(k != c->key);
 	TEST_ASSERT_EQUAL_STRING(k, c->key);
diff --git a/test/src/lst/test_ft_lstadd_back.c b/test/src/lst/test_ft_lstadd_back.c
deleted file mode 100644
index 42e749c..0000000
--- a/test/src/lst/test_ft_lstadd_back.c
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "libft_test.h"
-
-TEST_GROUP(ft_lstadd_back);
-
-TEST_SETUP(ft_lstadd_back)
-{}
-
-TEST_TEAR_DOWN(ft_lstadd_back)
-{}
-
-TEST(ft_lstadd_back, basic)
-{
-	t_ftlst *lst;
-	int a = 1;
-	int b = 2;
-	int c = 2;
-
-	lst = ft_lstnew(&a);
-	TEST_ASSERT_NOT_NULL(lst);
-
-	ft_lstadd_back(&lst, ft_lstnew(&b));
-	TEST_ASSERT_NOT_NULL(lst);
-	TEST_ASSERT_EQUAL_PTR(&a, lst->content);
-	TEST_ASSERT_EQUAL(a, *(int*)lst->content);
-	TEST_ASSERT_NOT_NULL(lst->next);
-	TEST_ASSERT_EQUAL_PTR(&b, lst->next->content);
-	TEST_ASSERT_EQUAL(b, *(int*)lst->next->content);
-
-	ft_lstadd_back(&lst, ft_lstnew(&c));
-	TEST_ASSERT_NOT_NULL(lst);
-	TEST_ASSERT_EQUAL_PTR(&a, lst->content);
-	TEST_ASSERT_EQUAL(a, *(int*)lst->content);
-	TEST_ASSERT_NOT_NULL(lst->next);
-	TEST_ASSERT_EQUAL_PTR(&b, lst->next->content);
-	TEST_ASSERT_EQUAL(b, *(int*)lst->next->content);
-	TEST_ASSERT_NOT_NULL(lst->next->next);
-	TEST_ASSERT_EQUAL_PTR(&c, lst->next->next->content);
-	TEST_ASSERT_EQUAL(c, *(int*)lst->next->next->content);
-
-	ft_lstclear(&lst, NULL);
-}
diff --git a/test/src/lst/test_ft_lstadd_front.c b/test/src/lst/test_ft_lstadd_front.c
deleted file mode 100644
index 21b7617..0000000
--- a/test/src/lst/test_ft_lstadd_front.c
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "libft_test.h"
-
-TEST_GROUP(ft_lstadd_front);
-
-TEST_SETUP(ft_lstadd_front)
-{}
-
-TEST_TEAR_DOWN(ft_lstadd_front)
-{}
-
-TEST(ft_lstadd_front, basic)
-{
-	t_ftlst *lst;
-	int a = 1;
-	int b = 2;
-	int c = 2;
-
-	lst = ft_lstnew(&a);
-	TEST_ASSERT_NOT_NULL(lst);
-
-	ft_lstadd_front(&lst, ft_lstnew(&b));
-	TEST_ASSERT_NOT_NULL(lst);
-	TEST_ASSERT_EQUAL_PTR(&b, lst->content);
-	TEST_ASSERT_EQUAL(b, *(int*)lst->content);
-	TEST_ASSERT_NOT_NULL(lst->next);
-	TEST_ASSERT_EQUAL_PTR(&a, lst->next->content);
-	TEST_ASSERT_EQUAL(a, *(int*)lst->next->content);
-
-	ft_lstadd_front(&lst, ft_lstnew(&c));
-	TEST_ASSERT_NOT_NULL(lst);
-	TEST_ASSERT_EQUAL_PTR(&c, lst->content);
-	TEST_ASSERT_EQUAL(c, *(int*)lst->content);
-	TEST_ASSERT_NOT_NULL(lst->next);
-	TEST_ASSERT_EQUAL_PTR(&b, lst->next->content);
-	TEST_ASSERT_EQUAL(b, *(int*)lst->next->content);
-	TEST_ASSERT_NOT_NULL(lst->next->next);
-	TEST_ASSERT_EQUAL_PTR(&a, lst->next->next->content);
-	TEST_ASSERT_EQUAL(a, *(int*)lst->next->next->content);
-
-	ft_lstclear(&lst, NULL);
-}
diff --git a/test/src/lst/test_ft_lstbsearch.c b/test/src/lst/test_ft_lstbsearch.c
index 218f0bf..81f2578 100644
--- a/test/src/lst/test_ft_lstbsearch.c
+++ b/test/src/lst/test_ft_lstbsearch.c
@@ -17,10 +17,10 @@ TEST(ft_lstbsearch, basic)
 	int c = 3;
 	int d = 4;
 
-	ft_lstadd_front(&lst, ft_lstnew(&c));
-	ft_lstadd_front(&lst, ft_lstnew(&b));
-	ft_lstadd_front(&lst, ft_lstnew(&a));
-	ft_lstadd_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&c));
+	ft_lstpush_front(&lst, ft_lstnew(&b));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
 
 	found = ft_lstbsearch(lst, ft_compar_int, &c);
 	TEST_ASSERT_NOT_NULL(found);
@@ -33,5 +33,5 @@ TEST(ft_lstbsearch, basic)
 	found = ft_lstbsearch(lst, ft_compar_int, &d);
 	TEST_ASSERT_NULL(found);
 
-	ft_lstclear(&lst, NULL);
+	ft_lstdestroy(&lst, NULL);
 }
diff --git a/test/src/lst/test_ft_lstclear.c b/test/src/lst/test_ft_lstclear.c
deleted file mode 100644
index acffb17..0000000
--- a/test/src/lst/test_ft_lstclear.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "libft_test.h"
-
-TEST_GROUP(ft_lstclear);
-
-TEST_SETUP(ft_lstclear)
-{}
-
-TEST_TEAR_DOWN(ft_lstclear)
-{}
-
-TEST(ft_lstclear, basic)
-{
-	TEST_PASS();  // how to test free?
-}
diff --git a/test/src/lst/test_ft_lstdestroy.c b/test/src/lst/test_ft_lstdestroy.c
new file mode 100644
index 0000000..e7b98c5
--- /dev/null
+++ b/test/src/lst/test_ft_lstdestroy.c
@@ -0,0 +1,14 @@
+#include "libft_test.h"
+
+TEST_GROUP(ft_lstdestroy);
+
+TEST_SETUP(ft_lstdestroy)
+{}
+
+TEST_TEAR_DOWN(ft_lstdestroy)
+{}
+
+TEST(ft_lstdestroy, basic)
+{
+	TEST_PASS();  // how to test free?
+}
diff --git a/test/src/lst/test_ft_lstiter.c b/test/src/lst/test_ft_lstiter.c
index c8bf90d..53b1380 100644
--- a/test/src/lst/test_ft_lstiter.c
+++ b/test/src/lst/test_ft_lstiter.c
@@ -26,27 +26,27 @@ TEST(ft_lstiter, basic)
 	ft_lstiter(lst, square_iter_func);
 	TEST_ASSERT_NULL(lst);
 
-	ft_lstadd_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
 	ft_lstiter(lst, square_iter_func);
-	TEST_ASSERT_EQUAL(4, *(int*)lst->content);
+	TEST_ASSERT_EQUAL(4, *(int*)lst->data);
 
-	ft_lstadd_front(&lst, ft_lstnew(&b));
+	ft_lstpush_front(&lst, ft_lstnew(&b));
 	ft_lstiter(lst, square_iter_func);
-	TEST_ASSERT_EQUAL(9, *(int*)lst->content);
-	TEST_ASSERT_EQUAL(16, *(int*)lst->next->content);
+	TEST_ASSERT_EQUAL(9, *(int*)lst->data);
+	TEST_ASSERT_EQUAL(16, *(int*)lst->next->data);
 
-	ft_lstadd_front(&lst, ft_lstnew(&c));
+	ft_lstpush_front(&lst, ft_lstnew(&c));
 	ft_lstiter(lst, square_iter_func);
-	TEST_ASSERT_EQUAL(16, *(int*)lst->content);
-	TEST_ASSERT_EQUAL(81, *(int*)lst->next->content);
-	TEST_ASSERT_EQUAL(256, *(int*)lst->next->next->content);
+	TEST_ASSERT_EQUAL(16, *(int*)lst->data);
+	TEST_ASSERT_EQUAL(81, *(int*)lst->next->data);
+	TEST_ASSERT_EQUAL(256, *(int*)lst->next->next->data);
 
-	ft_lstadd_front(&lst, ft_lstnew(&d));
+	ft_lstpush_front(&lst, ft_lstnew(&d));
 	ft_lstiter(lst, square_iter_func);
-	TEST_ASSERT_EQUAL(25, *(int*)lst->content);
-	TEST_ASSERT_EQUAL(256, *(int*)lst->next->content);
-	TEST_ASSERT_EQUAL(81 * 81, *(int*)lst->next->next->content);
-	TEST_ASSERT_EQUAL(256 * 256, *(int*)lst->next->next->next->content);
+	TEST_ASSERT_EQUAL(25, *(int*)lst->data);
+	TEST_ASSERT_EQUAL(256, *(int*)lst->next->data);
+	TEST_ASSERT_EQUAL(81 * 81, *(int*)lst->next->next->data);
+	TEST_ASSERT_EQUAL(256 * 256, *(int*)lst->next->next->next->data);
 
-	ft_lstclear(&lst, NULL);
+	ft_lstdestroy(&lst, NULL);
 }
diff --git a/test/src/lst/test_ft_lstlast.c b/test/src/lst/test_ft_lstlast.c
index 6b44c28..82c8096 100644
--- a/test/src/lst/test_ft_lstlast.c
+++ b/test/src/lst/test_ft_lstlast.c
@@ -16,14 +16,14 @@ TEST(ft_lstlast, basic)
 	int c = 3;
 	int d = 4;
 
-	ft_lstadd_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
 	TEST_ASSERT_EQUAL_PTR(lst, ft_lstlast(lst));
-	ft_lstadd_front(&lst, ft_lstnew(&b));
+	ft_lstpush_front(&lst, ft_lstnew(&b));
 	TEST_ASSERT_EQUAL_PTR(lst->next, ft_lstlast(lst));
-	ft_lstadd_front(&lst, ft_lstnew(&c));
+	ft_lstpush_front(&lst, ft_lstnew(&c));
 	TEST_ASSERT_EQUAL_PTR(lst->next->next, ft_lstlast(lst));
-	ft_lstadd_front(&lst, ft_lstnew(&d));
+	ft_lstpush_front(&lst, ft_lstnew(&d));
 	TEST_ASSERT_EQUAL_PTR(lst->next->next->next, ft_lstlast(lst));
 
-	ft_lstclear(&lst, NULL);
+	ft_lstdestroy(&lst, NULL);
 }
diff --git a/test/src/lst/test_ft_lstlfind.c b/test/src/lst/test_ft_lstlfind.c
index 493a8ad..1851436 100644
--- a/test/src/lst/test_ft_lstlfind.c
+++ b/test/src/lst/test_ft_lstlfind.c
@@ -29,13 +29,13 @@ TEST(ft_lstlfind, basic)
 	int c = 3;
 	int d = 4;
 
-	ft_lstadd_front(&lst, ft_lstnew(&c));
-	ft_lstadd_front(&lst, ft_lstnew(&c));
-	ft_lstadd_front(&lst, ft_lstnew(&a));
-	ft_lstadd_front(&lst, ft_lstnew(&c));
-	ft_lstadd_front(&lst, ft_lstnew(&b));
-	ft_lstadd_front(&lst, ft_lstnew(&a));
-	ft_lstadd_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&c));
+	ft_lstpush_front(&lst, ft_lstnew(&c));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&c));
+	ft_lstpush_front(&lst, ft_lstnew(&b));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
 
 	found = ft_lstlfind(lst, ft_compar_int, &c);
 	TEST_ASSERT_EQUAL_PTR(lst->next->next->next, found);
@@ -51,5 +51,5 @@ TEST(ft_lstlfind, basic)
 	found = ft_lstlfind(lst, ft_compar_int, &d);
 	TEST_ASSERT_NULL(found);
 
-	ft_lstclear(&lst, NULL);
+	ft_lstdestroy(&lst, NULL);
 }
diff --git a/test/src/lst/test_ft_lstlsearch.c b/test/src/lst/test_ft_lstlsearch.c
index c9f9c64..83a8f4e 100644
--- a/test/src/lst/test_ft_lstlsearch.c
+++ b/test/src/lst/test_ft_lstlsearch.c
@@ -29,13 +29,13 @@ TEST(ft_lstlsearch, basic)
 	int c = 3;
 	int d = 4;
 
-	ft_lstadd_front(&lst, ft_lstnew(&c));
-	ft_lstadd_front(&lst, ft_lstnew(&c));
-	ft_lstadd_front(&lst, ft_lstnew(&a));
-	ft_lstadd_front(&lst, ft_lstnew(&c));
-	ft_lstadd_front(&lst, ft_lstnew(&b));
-	ft_lstadd_front(&lst, ft_lstnew(&a));
-	ft_lstadd_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&c));
+	ft_lstpush_front(&lst, ft_lstnew(&c));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&c));
+	ft_lstpush_front(&lst, ft_lstnew(&b));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
 
 	found = ft_lstlsearch(lst, ft_compar_int, &c);
 	TEST_ASSERT_EQUAL_PTR(lst->next->next->next, found);
@@ -51,5 +51,5 @@ TEST(ft_lstlsearch, basic)
 	found = ft_lstlsearch(lst, ft_compar_int, &d);
 	TEST_ASSERT_EQUAL_PTR(ft_lstlast(lst), found);
 
-	ft_lstclear(&lst, NULL);
+	ft_lstdestroy(&lst, NULL);
 }
diff --git a/test/src/lst/test_ft_lstmap.c b/test/src/lst/test_ft_lstmap.c
index 4abdddc..53c2f7a 100644
--- a/test/src/lst/test_ft_lstmap.c
+++ b/test/src/lst/test_ft_lstmap.c
@@ -29,54 +29,54 @@ TEST(ft_lstmap, basic)
 	mapped = ft_lstmap(lst, f_square, free);
 	TEST_ASSERT_NULL(mapped);
 
-	ft_lstadd_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
 	mapped = ft_lstmap(lst, f_square, free);
 	TEST_ASSERT_NOT_NULL(mapped);
-	TEST_ASSERT_NOT_NULL(mapped->content);
-	TEST_ASSERT_EQUAL(4, *(int*)mapped->content);
+	TEST_ASSERT_NOT_NULL(mapped->data);
+	TEST_ASSERT_EQUAL(4, *(int*)mapped->data);
 	TEST_ASSERT_NULL(mapped->next);
-	ft_lstclear(&mapped, free);
+	ft_lstdestroy(&mapped, free);
 
-	ft_lstadd_front(&lst, ft_lstnew(&b));
+	ft_lstpush_front(&lst, ft_lstnew(&b));
 	mapped = ft_lstmap(lst, f_square, free);
 	TEST_ASSERT_NOT_NULL(mapped);
-	TEST_ASSERT_NOT_NULL(mapped->content);
-	TEST_ASSERT_EQUAL(9, *(int*)mapped->content);
+	TEST_ASSERT_NOT_NULL(mapped->data);
+	TEST_ASSERT_EQUAL(9, *(int*)mapped->data);
 	TEST_ASSERT_NOT_NULL(mapped->next);
-	TEST_ASSERT_NOT_NULL(mapped->next->content);
-	TEST_ASSERT_EQUAL(4, *(int*)mapped->next->content);
+	TEST_ASSERT_NOT_NULL(mapped->next->data);
+	TEST_ASSERT_EQUAL(4, *(int*)mapped->next->data);
 	TEST_ASSERT_NULL(mapped->next->next);
-	ft_lstclear(&mapped, free);
+	ft_lstdestroy(&mapped, free);
 
-	ft_lstadd_front(&lst, ft_lstnew(&c));
+	ft_lstpush_front(&lst, ft_lstnew(&c));
 	mapped = ft_lstmap(lst, f_square, free);
 	TEST_ASSERT_NOT_NULL(mapped);
-	TEST_ASSERT_NOT_NULL(mapped->content);
-	TEST_ASSERT_EQUAL(16, *(int*)mapped->content);
+	TEST_ASSERT_NOT_NULL(mapped->data);
+	TEST_ASSERT_EQUAL(16, *(int*)mapped->data);
 	TEST_ASSERT_NOT_NULL(mapped->next);
-	TEST_ASSERT_NOT_NULL(mapped->next->content);
-	TEST_ASSERT_EQUAL(9, *(int*)mapped->next->content);
+	TEST_ASSERT_NOT_NULL(mapped->next->data);
+	TEST_ASSERT_EQUAL(9, *(int*)mapped->next->data);
 	TEST_ASSERT_NOT_NULL(mapped->next->next);
-	TEST_ASSERT_NOT_NULL(mapped->next->next->content);
-	TEST_ASSERT_EQUAL(4, *(int*)mapped->next->next->content);
+	TEST_ASSERT_NOT_NULL(mapped->next->next->data);
+	TEST_ASSERT_EQUAL(4, *(int*)mapped->next->next->data);
 	TEST_ASSERT_NULL(mapped->next->next->next);
-	ft_lstclear(&mapped, free);
+	ft_lstdestroy(&mapped, free);
 
-	ft_lstadd_front(&lst, ft_lstnew(&d));
+	ft_lstpush_front(&lst, ft_lstnew(&d));
 	mapped = ft_lstmap(lst, f_square, free);
 	TEST_ASSERT_NOT_NULL(mapped);
-	TEST_ASSERT_NOT_NULL(mapped->content);
-	TEST_ASSERT_EQUAL(25, *(int*)mapped->content);
+	TEST_ASSERT_NOT_NULL(mapped->data);
+	TEST_ASSERT_EQUAL(25, *(int*)mapped->data);
 	TEST_ASSERT_NOT_NULL(mapped->next);
-	TEST_ASSERT_NOT_NULL(mapped->next->content);
-	TEST_ASSERT_EQUAL(16, *(int*)mapped->next->content);
+	TEST_ASSERT_NOT_NULL(mapped->next->data);
+	TEST_ASSERT_EQUAL(16, *(int*)mapped->next->data);
 	TEST_ASSERT_NOT_NULL(mapped->next->next);
-	TEST_ASSERT_NOT_NULL(mapped->next->next->content);
-	TEST_ASSERT_EQUAL(9, *(int*)mapped->next->next->content);
+	TEST_ASSERT_NOT_NULL(mapped->next->next->data);
+	TEST_ASSERT_EQUAL(9, *(int*)mapped->next->next->data);
 	TEST_ASSERT_NOT_NULL(mapped->next->next->next);
-	TEST_ASSERT_NOT_NULL(mapped->next->next->next->content);
-	TEST_ASSERT_EQUAL(4, *(int*)mapped->next->next->next->content);
-	ft_lstclear(&mapped, free);
+	TEST_ASSERT_NOT_NULL(mapped->next->next->next->data);
+	TEST_ASSERT_EQUAL(4, *(int*)mapped->next->next->next->data);
+	ft_lstdestroy(&mapped, free);
 
-	ft_lstclear(&lst, NULL);
+	ft_lstdestroy(&lst, NULL);
 }
diff --git a/test/src/lst/test_ft_lstnew.c b/test/src/lst/test_ft_lstnew.c
index bdb0066..518c885 100644
--- a/test/src/lst/test_ft_lstnew.c
+++ b/test/src/lst/test_ft_lstnew.c
@@ -15,11 +15,11 @@ TEST(ft_lstnew, basic)
 
 	lst = ft_lstnew(&a);
 	TEST_ASSERT_NOT_NULL(lst);
-	TEST_ASSERT_EQUAL_PTR(&a, lst->content);
-	TEST_ASSERT_EQUAL(a, *(int*)lst->content);
+	TEST_ASSERT_EQUAL_PTR(&a, lst->data);
+	TEST_ASSERT_EQUAL(a, *(int*)lst->data);
 
 	/* free(lst); */
 	lst = ft_lstnew(NULL);
 	TEST_ASSERT_NOT_NULL(lst);
-	TEST_ASSERT_NULL(lst->content);
+	TEST_ASSERT_NULL(lst->data);
 }
diff --git a/test/src/lst/test_ft_lstpop_front.c b/test/src/lst/test_ft_lstpop_front.c
index 18815d4..827afe6 100644
--- a/test/src/lst/test_ft_lstpop_front.c
+++ b/test/src/lst/test_ft_lstpop_front.c
@@ -15,16 +15,16 @@ TEST(ft_lstpop_front, basic)
 	int b = 2;
 	int c = 3;
 
-	ft_lstadd_front(&lst, ft_lstnew(&a));
-	ft_lstadd_front(&lst, ft_lstnew(&b));
-	ft_lstadd_front(&lst, ft_lstnew(&c));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&b));
+	ft_lstpush_front(&lst, ft_lstnew(&c));
 
 	ft_lstpop_front(&lst, NULL);
-	TEST_ASSERT_EQUAL_PTR(&b, lst->content);
-	TEST_ASSERT_EQUAL_PTR(&a, lst->next->content);
+	TEST_ASSERT_EQUAL_PTR(&b, lst->data);
+	TEST_ASSERT_EQUAL_PTR(&a, lst->next->data);
 
 	ft_lstpop_front(&lst, NULL);
-	TEST_ASSERT_EQUAL_PTR(&a, lst->content);
+	TEST_ASSERT_EQUAL_PTR(&a, lst->data);
 
 	ft_lstpop_front(&lst, NULL);
 	TEST_ASSERT_NULL(lst);
diff --git a/test/src/lst/test_ft_lstpush_back.c b/test/src/lst/test_ft_lstpush_back.c
new file mode 100644
index 0000000..9f0d97b
--- /dev/null
+++ b/test/src/lst/test_ft_lstpush_back.c
@@ -0,0 +1,41 @@
+#include "libft_test.h"
+
+TEST_GROUP(ft_lstpush_back);
+
+TEST_SETUP(ft_lstpush_back)
+{}
+
+TEST_TEAR_DOWN(ft_lstpush_back)
+{}
+
+TEST(ft_lstpush_back, basic)
+{
+	t_ftlst *lst;
+	int a = 1;
+	int b = 2;
+	int c = 2;
+
+	lst = ft_lstnew(&a);
+	TEST_ASSERT_NOT_NULL(lst);
+
+	ft_lstpush_back(&lst, ft_lstnew(&b));
+	TEST_ASSERT_NOT_NULL(lst);
+	TEST_ASSERT_EQUAL_PTR(&a, lst->data);
+	TEST_ASSERT_EQUAL(a, *(int*)lst->data);
+	TEST_ASSERT_NOT_NULL(lst->next);
+	TEST_ASSERT_EQUAL_PTR(&b, lst->next->data);
+	TEST_ASSERT_EQUAL(b, *(int*)lst->next->data);
+
+	ft_lstpush_back(&lst, ft_lstnew(&c));
+	TEST_ASSERT_NOT_NULL(lst);
+	TEST_ASSERT_EQUAL_PTR(&a, lst->data);
+	TEST_ASSERT_EQUAL(a, *(int*)lst->data);
+	TEST_ASSERT_NOT_NULL(lst->next);
+	TEST_ASSERT_EQUAL_PTR(&b, lst->next->data);
+	TEST_ASSERT_EQUAL(b, *(int*)lst->next->data);
+	TEST_ASSERT_NOT_NULL(lst->next->next);
+	TEST_ASSERT_EQUAL_PTR(&c, lst->next->next->data);
+	TEST_ASSERT_EQUAL(c, *(int*)lst->next->next->data);
+
+	ft_lstdestroy(&lst, NULL);
+}
diff --git a/test/src/lst/test_ft_lstpush_front.c b/test/src/lst/test_ft_lstpush_front.c
new file mode 100644
index 0000000..4a6af9f
--- /dev/null
+++ b/test/src/lst/test_ft_lstpush_front.c
@@ -0,0 +1,41 @@
+#include "libft_test.h"
+
+TEST_GROUP(ft_lstpush_front);
+
+TEST_SETUP(ft_lstpush_front)
+{}
+
+TEST_TEAR_DOWN(ft_lstpush_front)
+{}
+
+TEST(ft_lstpush_front, basic)
+{
+	t_ftlst *lst;
+	int a = 1;
+	int b = 2;
+	int c = 2;
+
+	lst = ft_lstnew(&a);
+	TEST_ASSERT_NOT_NULL(lst);
+
+	ft_lstpush_front(&lst, ft_lstnew(&b));
+	TEST_ASSERT_NOT_NULL(lst);
+	TEST_ASSERT_EQUAL_PTR(&b, lst->data);
+	TEST_ASSERT_EQUAL(b, *(int*)lst->data);
+	TEST_ASSERT_NOT_NULL(lst->next);
+	TEST_ASSERT_EQUAL_PTR(&a, lst->next->data);
+	TEST_ASSERT_EQUAL(a, *(int*)lst->next->data);
+
+	ft_lstpush_front(&lst, ft_lstnew(&c));
+	TEST_ASSERT_NOT_NULL(lst);
+	TEST_ASSERT_EQUAL_PTR(&c, lst->data);
+	TEST_ASSERT_EQUAL(c, *(int*)lst->data);
+	TEST_ASSERT_NOT_NULL(lst->next);
+	TEST_ASSERT_EQUAL_PTR(&b, lst->next->data);
+	TEST_ASSERT_EQUAL(b, *(int*)lst->next->data);
+	TEST_ASSERT_NOT_NULL(lst->next->next);
+	TEST_ASSERT_EQUAL_PTR(&a, lst->next->next->data);
+	TEST_ASSERT_EQUAL(a, *(int*)lst->next->next->data);
+
+	ft_lstdestroy(&lst, NULL);
+}
diff --git a/test/src/lst/test_ft_lstremove_if.c b/test/src/lst/test_ft_lstremove_if.c
index e32a262..a79016b 100644
--- a/test/src/lst/test_ft_lstremove_if.c
+++ b/test/src/lst/test_ft_lstremove_if.c
@@ -16,14 +16,14 @@ TEST(ft_lstremove_if, basic)
 	int c = 3;
 	int d = 4;
 
-	ft_lstadd_back(&lst, ft_lstnew(&a));
-	ft_lstadd_back(&lst, ft_lstnew(&b));
-	ft_lstadd_back(&lst, ft_lstnew(&c));
-	ft_lstadd_back(&lst, ft_lstnew(&d));
-	ft_lstadd_back(&lst, ft_lstnew(&d));
-	ft_lstadd_back(&lst, ft_lstnew(&d));
-	ft_lstadd_back(&lst, ft_lstnew(&a));
-	ft_lstadd_back(&lst, ft_lstnew(&a));
+	ft_lstpush_back(&lst, ft_lstnew(&a));
+	ft_lstpush_back(&lst, ft_lstnew(&b));
+	ft_lstpush_back(&lst, ft_lstnew(&c));
+	ft_lstpush_back(&lst, ft_lstnew(&d));
+	ft_lstpush_back(&lst, ft_lstnew(&d));
+	ft_lstpush_back(&lst, ft_lstnew(&d));
+	ft_lstpush_back(&lst, ft_lstnew(&a));
+	ft_lstpush_back(&lst, ft_lstnew(&a));
 
 	ft_lstremove_if(&lst, ft_compar_int, &a, NULL);
 	TEST_ASSERT_NOT_NULL(lst);
@@ -31,39 +31,39 @@ TEST(ft_lstremove_if, basic)
 	TEST_ASSERT_NOT_NULL(lst->next->next);
 	TEST_ASSERT_NOT_NULL(lst->next->next->next);
 	TEST_ASSERT_NOT_NULL(lst->next->next->next->next);
-	TEST_ASSERT_NOT_NULL(lst->content);
-	TEST_ASSERT_NOT_NULL(lst->next->content);
-	TEST_ASSERT_NOT_NULL(lst->next->next->content);
-	TEST_ASSERT_NOT_NULL(lst->next->next->next->content);
-	TEST_ASSERT_NOT_NULL(lst->next->next->next->next->content);
-	TEST_ASSERT_EQUAL(b, *(int*)lst->content);
-	TEST_ASSERT_EQUAL(c, *(int*)lst->next->content);
-	TEST_ASSERT_EQUAL(d, *(int*)lst->next->next->content);
-	TEST_ASSERT_EQUAL(d, *(int*)lst->next->next->next->content);
-	TEST_ASSERT_EQUAL(d, *(int*)lst->next->next->next->next->content);
+	TEST_ASSERT_NOT_NULL(lst->data);
+	TEST_ASSERT_NOT_NULL(lst->next->data);
+	TEST_ASSERT_NOT_NULL(lst->next->next->data);
+	TEST_ASSERT_NOT_NULL(lst->next->next->next->data);
+	TEST_ASSERT_NOT_NULL(lst->next->next->next->next->data);
+	TEST_ASSERT_EQUAL(b, *(int*)lst->data);
+	TEST_ASSERT_EQUAL(c, *(int*)lst->next->data);
+	TEST_ASSERT_EQUAL(d, *(int*)lst->next->next->data);
+	TEST_ASSERT_EQUAL(d, *(int*)lst->next->next->next->data);
+	TEST_ASSERT_EQUAL(d, *(int*)lst->next->next->next->next->data);
 
 	ft_lstremove_if(&lst, ft_compar_int, &b, NULL);
 	TEST_ASSERT_NOT_NULL(lst);
 	TEST_ASSERT_NOT_NULL(lst->next);
 	TEST_ASSERT_NOT_NULL(lst->next->next);
 	TEST_ASSERT_NOT_NULL(lst->next->next->next);
-	TEST_ASSERT_NOT_NULL(lst->content);
-	TEST_ASSERT_NOT_NULL(lst->next->content);
-	TEST_ASSERT_NOT_NULL(lst->next->next->content);
-	TEST_ASSERT_EQUAL(c, *(int*)lst->content);
-	TEST_ASSERT_EQUAL(d, *(int*)lst->next->content);
-	TEST_ASSERT_EQUAL(d, *(int*)lst->next->next->content);
-	TEST_ASSERT_EQUAL(d, *(int*)lst->next->next->next->content);
+	TEST_ASSERT_NOT_NULL(lst->data);
+	TEST_ASSERT_NOT_NULL(lst->next->data);
+	TEST_ASSERT_NOT_NULL(lst->next->next->data);
+	TEST_ASSERT_EQUAL(c, *(int*)lst->data);
+	TEST_ASSERT_EQUAL(d, *(int*)lst->next->data);
+	TEST_ASSERT_EQUAL(d, *(int*)lst->next->next->data);
+	TEST_ASSERT_EQUAL(d, *(int*)lst->next->next->next->data);
 
 	ft_lstremove_if(&lst, ft_compar_int, &d, NULL);
 	TEST_ASSERT_NOT_NULL(lst);
-	TEST_ASSERT_NOT_NULL(lst->content);
-	TEST_ASSERT_EQUAL(c, *(int*)lst->content);
+	TEST_ASSERT_NOT_NULL(lst->data);
+	TEST_ASSERT_EQUAL(c, *(int*)lst->data);
 
 	ft_lstremove_if(&lst, ft_compar_int, &d, NULL);
 	TEST_ASSERT_NOT_NULL(lst);
-	TEST_ASSERT_NOT_NULL(lst->content);
-	TEST_ASSERT_EQUAL(c, *(int*)lst->content);
+	TEST_ASSERT_NOT_NULL(lst->data);
+	TEST_ASSERT_EQUAL(c, *(int*)lst->data);
 
 	ft_lstremove_if(&lst, ft_compar_int, &c, NULL);
 	TEST_ASSERT_NULL(lst);
diff --git a/test/src/lst/test_ft_lstreverse.c b/test/src/lst/test_ft_lstreverse.c
index d22bfdc..a0a7d4e 100644
--- a/test/src/lst/test_ft_lstreverse.c
+++ b/test/src/lst/test_ft_lstreverse.c
@@ -19,27 +19,27 @@ TEST(ft_lstreverse, basic)
 	ft_lstreverse(&lst);
 	TEST_ASSERT_NULL(lst);
 
-	ft_lstadd_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
 	ft_lstreverse(&lst);
-	TEST_ASSERT_EQUAL_PTR(&a, lst->content);
+	TEST_ASSERT_EQUAL_PTR(&a, lst->data);
 
-	ft_lstadd_front(&lst, ft_lstnew(&b));
+	ft_lstpush_front(&lst, ft_lstnew(&b));
 	ft_lstreverse(&lst);
-	TEST_ASSERT_EQUAL_PTR(&a, lst->content);
-	TEST_ASSERT_EQUAL_PTR(&b, lst->next->content);
+	TEST_ASSERT_EQUAL_PTR(&a, lst->data);
+	TEST_ASSERT_EQUAL_PTR(&b, lst->next->data);
 
-	ft_lstadd_front(&lst, ft_lstnew(&c));
+	ft_lstpush_front(&lst, ft_lstnew(&c));
 	ft_lstreverse(&lst);
-	TEST_ASSERT_EQUAL_PTR(&b, lst->content);
-	TEST_ASSERT_EQUAL_PTR(&a, lst->next->content);
-	TEST_ASSERT_EQUAL_PTR(&c, lst->next->next->content);
+	TEST_ASSERT_EQUAL_PTR(&b, lst->data);
+	TEST_ASSERT_EQUAL_PTR(&a, lst->next->data);
+	TEST_ASSERT_EQUAL_PTR(&c, lst->next->next->data);
 
-	ft_lstadd_front(&lst, ft_lstnew(&d));
+	ft_lstpush_front(&lst, ft_lstnew(&d));
 	ft_lstreverse(&lst);
-	TEST_ASSERT_EQUAL_PTR(&c, lst->content);
-	TEST_ASSERT_EQUAL_PTR(&a, lst->next->content);
-	TEST_ASSERT_EQUAL_PTR(&b, lst->next->next->content);
-	TEST_ASSERT_EQUAL_PTR(&d, lst->next->next->next->content);
+	TEST_ASSERT_EQUAL_PTR(&c, lst->data);
+	TEST_ASSERT_EQUAL_PTR(&a, lst->next->data);
+	TEST_ASSERT_EQUAL_PTR(&b, lst->next->next->data);
+	TEST_ASSERT_EQUAL_PTR(&d, lst->next->next->next->data);
 
-	ft_lstclear(&lst, NULL);
+	ft_lstdestroy(&lst, NULL);
 }
diff --git a/test/src/lst/test_ft_lstreverse_ret.c b/test/src/lst/test_ft_lstreverse_ret.c
index 6a85ddf..e6fc278 100644
--- a/test/src/lst/test_ft_lstreverse_ret.c
+++ b/test/src/lst/test_ft_lstreverse_ret.c
@@ -19,27 +19,27 @@ TEST(ft_lstreverse_ret, basic)
 	lst = ft_lstreverse_ret(lst);
 	TEST_ASSERT_NULL(lst);
 
-	ft_lstadd_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
 	lst = ft_lstreverse_ret(lst);
-	TEST_ASSERT_EQUAL_PTR(&a, lst->content);
+	TEST_ASSERT_EQUAL_PTR(&a, lst->data);
 
-	ft_lstadd_front(&lst, ft_lstnew(&b));
+	ft_lstpush_front(&lst, ft_lstnew(&b));
 	lst = ft_lstreverse_ret(lst);
-	TEST_ASSERT_EQUAL_PTR(&a, lst->content);
-	TEST_ASSERT_EQUAL_PTR(&b, lst->next->content);
+	TEST_ASSERT_EQUAL_PTR(&a, lst->data);
+	TEST_ASSERT_EQUAL_PTR(&b, lst->next->data);
 
-	ft_lstadd_front(&lst, ft_lstnew(&c));
+	ft_lstpush_front(&lst, ft_lstnew(&c));
 	lst = ft_lstreverse_ret(lst);
-	TEST_ASSERT_EQUAL_PTR(&b, lst->content);
-	TEST_ASSERT_EQUAL_PTR(&a, lst->next->content);
-	TEST_ASSERT_EQUAL_PTR(&c, lst->next->next->content);
+	TEST_ASSERT_EQUAL_PTR(&b, lst->data);
+	TEST_ASSERT_EQUAL_PTR(&a, lst->next->data);
+	TEST_ASSERT_EQUAL_PTR(&c, lst->next->next->data);
 
-	ft_lstadd_front(&lst, ft_lstnew(&d));
+	ft_lstpush_front(&lst, ft_lstnew(&d));
 	lst = ft_lstreverse_ret(lst);
-	TEST_ASSERT_EQUAL_PTR(&c, lst->content);
-	TEST_ASSERT_EQUAL_PTR(&a, lst->next->content);
-	TEST_ASSERT_EQUAL_PTR(&b, lst->next->next->content);
-	TEST_ASSERT_EQUAL_PTR(&d, lst->next->next->next->content);
+	TEST_ASSERT_EQUAL_PTR(&c, lst->data);
+	TEST_ASSERT_EQUAL_PTR(&a, lst->next->data);
+	TEST_ASSERT_EQUAL_PTR(&b, lst->next->next->data);
+	TEST_ASSERT_EQUAL_PTR(&d, lst->next->next->next->data);
 
-	ft_lstclear(&lst, NULL);
+	ft_lstdestroy(&lst, NULL);
 }
diff --git a/test/src/lst/test_ft_lstsize.c b/test/src/lst/test_ft_lstsize.c
index c80bc7c..d3b78bb 100644
--- a/test/src/lst/test_ft_lstsize.c
+++ b/test/src/lst/test_ft_lstsize.c
@@ -16,22 +16,22 @@ TEST(ft_lstsize, basic)
 	TEST_ASSERT_EQUAL(0, ft_lstsize(lst));
 	lst = ft_lstnew(&a);
 	TEST_ASSERT_EQUAL(1, ft_lstsize(lst));
-	ft_lstadd_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
 	TEST_ASSERT_EQUAL(2, ft_lstsize(lst));
-	ft_lstadd_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
 	TEST_ASSERT_EQUAL(3, ft_lstsize(lst));
-	ft_lstadd_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
 	TEST_ASSERT_EQUAL(4, ft_lstsize(lst));
-	ft_lstadd_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
 	TEST_ASSERT_EQUAL(5, ft_lstsize(lst));
-	ft_lstadd_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
 	TEST_ASSERT_EQUAL(6, ft_lstsize(lst));
-	ft_lstadd_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
 	TEST_ASSERT_EQUAL(7, ft_lstsize(lst));
-	ft_lstadd_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
 	TEST_ASSERT_EQUAL(8, ft_lstsize(lst));
-	ft_lstadd_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
 	TEST_ASSERT_EQUAL(9, ft_lstsize(lst));
 
-	ft_lstclear(&lst, NULL);
+	ft_lstdestroy(&lst, NULL);
 }
diff --git a/test/src/lst/test_ft_lstsort.c b/test/src/lst/test_ft_lstsort.c
index e1e1566..3b771ae 100644
--- a/test/src/lst/test_ft_lstsort.c
+++ b/test/src/lst/test_ft_lstsort.c
@@ -16,23 +16,23 @@ TEST(ft_lstsort, basic)
 	int c = 4;
 	int d = -3;
 
-	ft_lstadd_front(&lst, ft_lstnew(&a));
-	ft_lstadd_front(&lst, ft_lstnew(&b));
-	ft_lstadd_front(&lst, ft_lstnew(&c));
-	ft_lstadd_front(&lst, ft_lstnew(&d));
+	ft_lstpush_front(&lst, ft_lstnew(&a));
+	ft_lstpush_front(&lst, ft_lstnew(&b));
+	ft_lstpush_front(&lst, ft_lstnew(&c));
+	ft_lstpush_front(&lst, ft_lstnew(&d));
 	ft_lstsort(&lst, ft_compar_int);
 
 	TEST_ASSERT_NOT_NULL(lst);
 	TEST_ASSERT_NOT_NULL(lst->next);
 	TEST_ASSERT_NOT_NULL(lst->next->next);
 	TEST_ASSERT_NOT_NULL(lst->next->next->next);
-	TEST_ASSERT_NOT_NULL(lst->content);
-	TEST_ASSERT_NOT_NULL(lst->next->content);
-	TEST_ASSERT_NOT_NULL(lst->next->next->content);
-	TEST_ASSERT_NOT_NULL(lst->next->next->next->content);
+	TEST_ASSERT_NOT_NULL(lst->data);
+	TEST_ASSERT_NOT_NULL(lst->next->data);
+	TEST_ASSERT_NOT_NULL(lst->next->next->data);
+	TEST_ASSERT_NOT_NULL(lst->next->next->next->data);
 
-	TEST_ASSERT_EQUAL(-3, *(int*)lst->content);
-	TEST_ASSERT_EQUAL(-1, *(int*)lst->next->content);
-	TEST_ASSERT_EQUAL(1, *(int*)lst->next->next->content);
-	TEST_ASSERT_EQUAL(4, *(int*)lst->next->next->next->content);
+	TEST_ASSERT_EQUAL(-3, *(int*)lst->data);
+	TEST_ASSERT_EQUAL(-1, *(int*)lst->next->data);
+	TEST_ASSERT_EQUAL(1, *(int*)lst->next->next->data);
+	TEST_ASSERT_EQUAL(4, *(int*)lst->next->next->next->data);
 }
diff --git a/test/src/lst/test_ft_lstsorted_merge.c b/test/src/lst/test_ft_lstsorted_merge.c
index 4c548c9..9839cd7 100644
--- a/test/src/lst/test_ft_lstsorted_merge.c
+++ b/test/src/lst/test_ft_lstsorted_merge.c
@@ -18,23 +18,23 @@ TEST(ft_lstsorted_merge, basic)
 	int d = 4;
 	int e = 5;
 
-	ft_lstadd_front(&lst1, ft_lstnew(&a));
-	ft_lstadd_front(&lst1, ft_lstnew(&d));
-	ft_lstadd_front(&lst1, ft_lstnew(&e));
-	ft_lstadd_front(&lst1, ft_lstnew(&d));
-	ft_lstadd_front(&lst1, ft_lstnew(&a));
-
-	ft_lstadd_front(&lst2, ft_lstnew(&e));
-	ft_lstadd_front(&lst2, ft_lstnew(&a));
-	ft_lstadd_front(&lst2, ft_lstnew(&b));
-	ft_lstadd_front(&lst2, ft_lstnew(&d));
-	ft_lstadd_front(&lst2, ft_lstnew(&c));
+	ft_lstpush_front(&lst1, ft_lstnew(&a));
+	ft_lstpush_front(&lst1, ft_lstnew(&d));
+	ft_lstpush_front(&lst1, ft_lstnew(&e));
+	ft_lstpush_front(&lst1, ft_lstnew(&d));
+	ft_lstpush_front(&lst1, ft_lstnew(&a));
+
+	ft_lstpush_front(&lst2, ft_lstnew(&e));
+	ft_lstpush_front(&lst2, ft_lstnew(&a));
+	ft_lstpush_front(&lst2, ft_lstnew(&b));
+	ft_lstpush_front(&lst2, ft_lstnew(&d));
+	ft_lstpush_front(&lst2, ft_lstnew(&c));
 
 	ft_lstsort(&lst1, ft_compar_int);
 	ft_lstsort(&lst2, ft_compar_int);
 
 	lst1 = ft_lstsorted_merge(lst1, lst2, ft_compar_int);
 	for (; lst1->next != NULL; lst1 = lst1->next)
-		if (ft_compar_int(lst1->content, lst1->next->content) > 0)
+		if (ft_compar_int(lst1->data, lst1->next->data) > 0)
 			TEST_FAIL();
 }
diff --git a/test/src/main.c b/test/src/main.c
index e93c623..357e02e 100644
--- a/test/src/main.c
+++ b/test/src/main.c
@@ -29,9 +29,15 @@ static void run_all_test(void)
 
 	// str
 	RUN_TEST_GROUP(ft_strlen);
+	RUN_TEST_GROUP(ft_fnmatch);
+	RUN_TEST_GROUP(ft_strsjoin);
+	RUN_TEST_GROUP(ft_strsjoinf);
+	RUN_TEST_GROUP(ft_strsub);
+	RUN_TEST_GROUP(ft_strsubf);
+	RUN_TEST_GROUP(ft_strtof);
 
 	// ht
-	RUN_TEST_GROUP(ft_htcontent_new);
+	RUN_TEST_GROUP(ft_htentry_new);
 	RUN_TEST_GROUP(ft_htnew);
 	RUN_TEST_GROUP(ft_htget);
 	RUN_TEST_GROUP(ft_htset);
@@ -50,12 +56,12 @@ static void run_all_test(void)
 	RUN_TEST_GROUP(ft_reverse);
 
 	// lst
-	RUN_TEST_GROUP(ft_lstadd_back);
-	RUN_TEST_GROUP(ft_lstadd_front);
+	RUN_TEST_GROUP(ft_lstpush_back);
+	RUN_TEST_GROUP(ft_lstpush_front);
 	RUN_TEST_GROUP(ft_lstbsearch);
 	RUN_TEST_GROUP(ft_lstlsearch);
 	RUN_TEST_GROUP(ft_lstlfind);
-	RUN_TEST_GROUP(ft_lstclear);
+	RUN_TEST_GROUP(ft_lstdestroy);
 	RUN_TEST_GROUP(ft_lstdelone);
 	RUN_TEST_GROUP(ft_lstiter);
 	RUN_TEST_GROUP(ft_lstlast);
@@ -68,8 +74,29 @@ static void run_all_test(void)
 	RUN_TEST_GROUP(ft_lstsize);
 	RUN_TEST_GROUP(ft_lstsort);
 	RUN_TEST_GROUP(ft_lstsorted_merge);
+
+	// vec
+	RUN_TEST_GROUP(ft_vecdestroy);
+	RUN_TEST_GROUP(ft_vecgrow);
+	RUN_TEST_GROUP(ft_veciter);
+	RUN_TEST_GROUP(ft_vecnew);
+	RUN_TEST_GROUP(ft_vecpop);
+	RUN_TEST_GROUP(ft_vecpush);
+	RUN_TEST_GROUP(ft_vecremove);
+	RUN_TEST_GROUP(ft_vecinsert);
+	RUN_TEST_GROUP(ft_vecpush_safe);
+
+	// dstr
+	RUN_TEST_GROUP(ft_dstrdestroy);
+	RUN_TEST_GROUP(ft_dstrgrow);
+	RUN_TEST_GROUP(ft_dstrinsert);
+	RUN_TEST_GROUP(ft_dstrnew);
+	RUN_TEST_GROUP(ft_dstrunwrap);
+	RUN_TEST_GROUP(ft_dstrsubstitute);
+	RUN_TEST_GROUP(ft_dstrerase);
 }
 
+
 int main(int argc, const char **argv)
 {
 	return UnityMain(argc, argv, run_all_test);
diff --git a/test/src/mem/test_ft_memchr.c b/test/src/mem/test_ft_memchr.c
index 135edfb..6473e20 100644
--- a/test/src/mem/test_ft_memchr.c
+++ b/test/src/mem/test_ft_memchr.c
@@ -6,7 +6,7 @@
 /*   By: cacharle <marvin@42.fr>                    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2020/02/13 03:33:14 by cacharle          #+#    #+#             */
-/*   Updated: 2020/02/13 19:38:17 by cacharle         ###   ########.fr       */
+/*   Updated: 2020/05/12 21:14:31 by charles          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -32,4 +32,7 @@ TEST(ft_memchr, basic)
 
 	ptr = ft_memchr(a, '\0', sizeof(a));
 	TEST_ASSERT_EQUAL_PTR(a + 7, ptr);
+
+	ptr = ft_memchr("v 1", '\n', 4);
+	TEST_ASSERT_NULL(ptr);
 }
diff --git a/test/src/runner/test_runner_algo.c b/test/src/runner/test_runner_algo.c
index 8873797..f2afdb3 100644
--- a/test/src/runner/test_runner_algo.c
+++ b/test/src/runner/test_runner_algo.c
@@ -6,7 +6,7 @@
 /*   By: cacharle <marvin@42.fr>                    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2020/02/13 21:25:52 by cacharle          #+#    #+#             */
-/*   Updated: 2020/02/13 21:37:15 by cacharle         ###   ########.fr       */
+/*   Updated: 2020/04/04 15:22:43 by charles          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -51,6 +51,7 @@ TEST_GROUP_RUNNER(ft_mergesort)
 TEST_GROUP_RUNNER(ft_qsort)
 {
 	RUN_TEST_CASE(ft_qsort, basic);
+	RUN_TEST_CASE(ft_qsort, strings);
 }
 
 TEST_GROUP_RUNNER(ft_reverse)
diff --git a/test/src/runner/test_runner_dstr.c b/test/src/runner/test_runner_dstr.c
new file mode 100644
index 0000000..a6d9bdd
--- /dev/null
+++ b/test/src/runner/test_runner_dstr.c
@@ -0,0 +1,48 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_runner_dstr.c                                 :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/04 20:44:42 by charles           #+#    #+#             */
+/*   Updated: 2020/04/05 00:48:08 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP_RUNNER(ft_dstrdestroy)
+{
+	RUN_TEST_CASE(ft_dstrdestroy, basic);
+}
+
+TEST_GROUP_RUNNER(ft_dstrgrow)
+{
+	RUN_TEST_CASE(ft_dstrgrow, basic);
+}
+
+TEST_GROUP_RUNNER(ft_dstrinsert)
+{
+	RUN_TEST_CASE(ft_dstrinsert, basic);
+}
+
+TEST_GROUP_RUNNER(ft_dstrnew)
+{
+	RUN_TEST_CASE(ft_dstrnew, basic);
+}
+
+TEST_GROUP_RUNNER(ft_dstrunwrap)
+{
+	RUN_TEST_CASE(ft_dstrunwrap, basic);
+}
+
+TEST_GROUP_RUNNER(ft_dstrsubstitute)
+{
+	RUN_TEST_CASE(ft_dstrsubstitute, basic);
+}
+
+TEST_GROUP_RUNNER(ft_dstrerase)
+{
+	RUN_TEST_CASE(ft_dstrerase, basic);
+}
diff --git a/test/src/runner/test_runner_ht.c b/test/src/runner/test_runner_ht.c
index 6f83006..e7fbcf3 100644
--- a/test/src/runner/test_runner_ht.c
+++ b/test/src/runner/test_runner_ht.c
@@ -6,15 +6,15 @@
 /*   By: cacharle <marvin@42.fr>                    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2020/02/12 22:44:39 by cacharle          #+#    #+#             */
-/*   Updated: 2020/02/19 02:46:34 by cacharle         ###   ########.fr       */
+/*   Updated: 2020/04/03 07:11:32 by charles          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "libft_test.h"
 
-TEST_GROUP_RUNNER(ft_htcontent_new)
+TEST_GROUP_RUNNER(ft_htentry_new)
 {
-	RUN_TEST_CASE(ft_htcontent_new, basic);
+	RUN_TEST_CASE(ft_htentry_new, basic);
 }
 
 TEST_GROUP_RUNNER(ft_htnew)
diff --git a/test/src/runner/test_runner_lst.c b/test/src/runner/test_runner_lst.c
index 483e120..5ae9557 100644
--- a/test/src/runner/test_runner_lst.c
+++ b/test/src/runner/test_runner_lst.c
@@ -12,14 +12,14 @@
 
 #include "libft_test.h"
 
-TEST_GROUP_RUNNER(ft_lstadd_back)
+TEST_GROUP_RUNNER(ft_lstpush_back)
 {
-	RUN_TEST_CASE(ft_lstadd_back, basic);
+	RUN_TEST_CASE(ft_lstpush_back, basic);
 }
 
-TEST_GROUP_RUNNER(ft_lstadd_front)
+TEST_GROUP_RUNNER(ft_lstpush_front)
 {
-	RUN_TEST_CASE(ft_lstadd_front, basic);
+	RUN_TEST_CASE(ft_lstpush_front, basic);
 }
 
 TEST_GROUP_RUNNER(ft_lstbsearch)
@@ -37,9 +37,9 @@ TEST_GROUP_RUNNER(ft_lstlfind)
 	RUN_TEST_CASE(ft_lstlfind, basic);
 }
 
-TEST_GROUP_RUNNER(ft_lstclear)
+TEST_GROUP_RUNNER(ft_lstdestroy)
 {
-	RUN_TEST_CASE(ft_lstclear, basic);
+	RUN_TEST_CASE(ft_lstdestroy, basic);
 }
 
 TEST_GROUP_RUNNER(ft_lstdelone)
diff --git a/test/src/runner/test_runner_str.c b/test/src/runner/test_runner_str.c
index 3d829ad..c2cf2a7 100644
--- a/test/src/runner/test_runner_str.c
+++ b/test/src/runner/test_runner_str.c
@@ -4,3 +4,33 @@ TEST_GROUP_RUNNER(ft_strlen)
 {
 	RUN_TEST_CASE(ft_strlen, basic);
 }
+
+TEST_GROUP_RUNNER(ft_fnmatch)
+{
+	RUN_TEST_CASE(ft_fnmatch, basic);
+}
+
+TEST_GROUP_RUNNER(ft_strsjoin)
+{
+	RUN_TEST_CASE(ft_strsjoin, basic);
+}
+
+TEST_GROUP_RUNNER(ft_strsjoinf)
+{
+	RUN_TEST_CASE(ft_strsjoinf, basic);
+}
+
+TEST_GROUP_RUNNER(ft_strsub)
+{
+	RUN_TEST_CASE(ft_strsub, basic);
+}
+
+TEST_GROUP_RUNNER(ft_strsubf)
+{
+	RUN_TEST_CASE(ft_strsubf, basic);
+}
+
+TEST_GROUP_RUNNER(ft_strtof)
+{
+	RUN_TEST_CASE(ft_strtof, basic);
+}
diff --git a/test/src/runner/test_runner_vec.c b/test/src/runner/test_runner_vec.c
new file mode 100644
index 0000000..5a57def
--- /dev/null
+++ b/test/src/runner/test_runner_vec.c
@@ -0,0 +1,64 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_runner_vec.c                                  :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:55:53 by charles           #+#    #+#             */
+/*   Updated: 2020/04/04 23:26:54 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+
+#include "libft_test.h"
+
+TEST_GROUP_RUNNER(ft_vecdestroy)
+{
+	RUN_TEST_CASE(ft_vecdestroy, basic);
+}
+
+TEST_GROUP_RUNNER(ft_vecgrow)
+{
+	RUN_TEST_CASE(ft_vecgrow, basic);
+}
+
+TEST_GROUP_RUNNER(ft_veciter)
+{
+	RUN_TEST_CASE(ft_veciter, basic);
+}
+
+TEST_GROUP_RUNNER(ft_vecnew)
+{
+	RUN_TEST_CASE(ft_vecnew, basic);
+}
+
+TEST_GROUP_RUNNER(ft_vecpop)
+{
+	RUN_TEST_CASE(ft_vecpop, basic);
+}
+
+TEST_GROUP_RUNNER(ft_vecpush)
+{
+	RUN_TEST_CASE(ft_vecpush, basic);
+}
+
+TEST_GROUP_RUNNER(ft_vecremove)
+{
+	RUN_TEST_CASE(ft_vecremove, basic);
+}
+
+TEST_GROUP_RUNNER(ft_vecinsert)
+{
+	RUN_TEST_CASE(ft_vecinsert, basic);
+}
+
+TEST_GROUP_RUNNER(ft_vecsort)
+{
+	RUN_TEST_CASE(ft_vecsort, basic);
+}
+
+TEST_GROUP_RUNNER(ft_vecpush_safe)
+{
+	RUN_TEST_CASE(ft_vecpush_safe, basic);
+}
diff --git a/test/src/str/test_ft_fnmatch.c b/test/src/str/test_ft_fnmatch.c
new file mode 100644
index 0000000..f7dc892
--- /dev/null
+++ b/test/src/str/test_ft_fnmatch.c
@@ -0,0 +1,117 @@
+#include "libft_test.h"
+
+TEST_GROUP(ft_fnmatch);
+
+TEST_SETUP(ft_fnmatch)
+{}
+
+TEST_TEAR_DOWN(ft_fnmatch)
+{}
+
+TEST(ft_fnmatch, basic)
+{
+	TEST_ASSERT_TRUE(ft_fnmatch("", ""));
+	TEST_ASSERT_TRUE(ft_fnmatch("l", "l"));
+	TEST_ASSERT_TRUE(ft_fnmatch("kl", "kl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("jkl", "jkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("ijkl", "ijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("hijkl", "hijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("ghijkl", "ghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("fghijkl", "fghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("efghijkl", "efghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("defghijkl", "defghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("cdefghijkl", "cdefghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("bcdefghijkl", "bcdefghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("abcdefghijkl", "abcdefghijkl"));
+
+	TEST_ASSERT_FALSE(ft_fnmatch("", "a"));
+	TEST_ASSERT_FALSE(ft_fnmatch("", "ab"));
+	TEST_ASSERT_FALSE(ft_fnmatch("", "abc"));
+	TEST_ASSERT_FALSE(ft_fnmatch("a", "ab"));
+	TEST_ASSERT_FALSE(ft_fnmatch("ab", "abc"));
+	TEST_ASSERT_FALSE(ft_fnmatch("a", ""));
+	TEST_ASSERT_FALSE(ft_fnmatch("ab", ""));
+	TEST_ASSERT_FALSE(ft_fnmatch("abc", ""));
+	TEST_ASSERT_FALSE(ft_fnmatch("ab", "a"));
+	TEST_ASSERT_FALSE(ft_fnmatch("abc", "ab"));
+
+	TEST_ASSERT_TRUE(ft_fnmatch("*", ""));
+	TEST_ASSERT_TRUE(ft_fnmatch("*", "l"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*", "kl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*", "jkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*", "ijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*", "hijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*", "ghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*", "fghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*", "efghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*", "defghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*", "cdefghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*", "bcdefghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*", "abcdefghijkl"));
+
+	TEST_ASSERT_TRUE(ft_fnmatch("*.c", ".c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.c", "l.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.c", "kl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.c", "jkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.c", "ijkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.c", "hijkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.c", "ghijkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.c", "fghijkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.c", "efghijkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.c", "defghijkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.c", "cdefghijkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.c", "bcdefghijkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.c", "abcdefghijkl.c"));
+
+	TEST_ASSERT_TRUE(ft_fnmatch("../*", "../"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*", "../l"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*", "../kl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*", "../jkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*", "../ijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*", "../hijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*", "../ghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*", "../fghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*", "../efghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*", "../defghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*", "../cdefghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*", "../bcdefghijkl"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*", "../abcdefghijkl"));
+
+	TEST_ASSERT_TRUE(ft_fnmatch("../*.c", "../.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*.c", "../l.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*.c", "../kl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*.c", "../jkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*.c", "../ijkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*.c", "../hijkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*.c", "../ghijkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*.c", "../fghijkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*.c", "../efghijkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*.c", "../defghijkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*.c", "../cdefghijkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*.c", "../bcdefghijkl.c"));
+	TEST_ASSERT_TRUE(ft_fnmatch("../*.c", "../abcdefghijkl.c"));
+
+	TEST_ASSERT_TRUE(ft_fnmatch("*.*", "."));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.*", "a.a"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.*", "ab.ab"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.*", "abc.abc"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.*", "abcd.abcd"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.*", "abcde.abcde"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.*", "abcdef.abcdef"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.*", "abcdefg.abcdefg"));
+	TEST_ASSERT_TRUE(ft_fnmatch("*.*", "abcdefgh.abcdefgh"));
+
+	TEST_ASSERT_FALSE(ft_fnmatch("*.c", ".h"));
+	TEST_ASSERT_FALSE(ft_fnmatch("*.c", "a.h"));
+	TEST_ASSERT_FALSE(ft_fnmatch("*.c", "ab.h"));
+	TEST_ASSERT_FALSE(ft_fnmatch("*.c", "abc.h"));
+	TEST_ASSERT_FALSE(ft_fnmatch("*.c", "abcd.h"));
+
+	TEST_ASSERT_FALSE(ft_fnmatch("*.c", ".h"));
+	TEST_ASSERT_FALSE(ft_fnmatch("*.c", "a.h"));
+	TEST_ASSERT_FALSE(ft_fnmatch("*.c", "ab.h"));
+	TEST_ASSERT_FALSE(ft_fnmatch("*.c", "abc.h"));
+	TEST_ASSERT_FALSE(ft_fnmatch("*.c", "abcd.h"));
+
+	TEST_ASSERT_TRUE(ft_fnmatch("da*da*da*", "daaadabadmanda"));
+}
diff --git a/test/src/str/test_ft_strlen.c b/test/src/str/test_ft_strlen.c
index f251fc6..47ca69b 100644
--- a/test/src/str/test_ft_strlen.c
+++ b/test/src/str/test_ft_strlen.c
@@ -21,4 +21,40 @@ TEST(ft_strlen, basic)
 	TEST_ASSERT_FT_STRLEN("asodifuaosidjoiasjdfoijasklfqwkberkjqwerkjqwlkenrmnqwerjkqwehfakjs");
 	TEST_ASSERT_FT_STRLEN("im\0hidden");
 	TEST_ASSERT_FT_STRLEN("987987\xff\xee\xaasdfioxcv");
+
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghijklmnopqrstuvwxyz");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghijklmnopqrstuvwxy");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghijklmnopqrstuvwx");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghijklmnopqrstuvw");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghijklmnopqrstuv");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghijklmnopqrstu");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghijklmnopqrst");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghijklmnopqrs");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghijklmnopqr");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghijklmnopq");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghijklmnop");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghijklmno");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghijklmn");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghijklm");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghijkl");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghijk");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghij");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefghi");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefgh");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdefg");
+	TEST_ASSERT_FT_STRLEN("0123456789abcdef");
+	TEST_ASSERT_FT_STRLEN("0123456789abcde");
+	TEST_ASSERT_FT_STRLEN("0123456789abcd");
+	TEST_ASSERT_FT_STRLEN("0123456789abc");
+	TEST_ASSERT_FT_STRLEN("0123456789ab");
+	TEST_ASSERT_FT_STRLEN("0123456789a");
+	TEST_ASSERT_FT_STRLEN("012345678");
+	TEST_ASSERT_FT_STRLEN("01234567");
+	TEST_ASSERT_FT_STRLEN("0123456");
+	TEST_ASSERT_FT_STRLEN("012345");
+	TEST_ASSERT_FT_STRLEN("01234");
+	TEST_ASSERT_FT_STRLEN("0123");
+	TEST_ASSERT_FT_STRLEN("012");
+	TEST_ASSERT_FT_STRLEN("01");
+	TEST_ASSERT_FT_STRLEN("0");
 }
diff --git a/test/src/str/test_ft_strsjoin.c b/test/src/str/test_ft_strsjoin.c
new file mode 100644
index 0000000..0fac07b
--- /dev/null
+++ b/test/src/str/test_ft_strsjoin.c
@@ -0,0 +1,57 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_strsjoin.c                                 :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/04 23:32:26 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_strsjoin);
+
+TEST_SETUP(ft_strsjoin)
+{}
+
+TEST_TEAR_DOWN(ft_strsjoin)
+{}
+
+TEST(ft_strsjoin, basic)
+{
+	char *join;
+	char *arr[] = {"bonjour", "je", "suis", NULL};
+	char *arr2[] = {"", "bonjour", "", "", "", "je", "suis", NULL};
+	char *null_arr[] = {NULL};
+
+	join = ft_strsjoin(arr, " ");
+	TEST_ASSERT_NOT_NULL(join);
+	TEST_ASSERT_EQUAL_STRING("bonjour je suis", join);
+
+	join = ft_strsjoin(arr, "<|>");
+	TEST_ASSERT_NOT_NULL(join);
+	TEST_ASSERT_EQUAL_STRING("bonjour<|>je<|>suis", join);
+
+	join = ft_strsjoin(arr, "");
+	TEST_ASSERT_NOT_NULL(join);
+	TEST_ASSERT_EQUAL_STRING("bonjourjesuis", join);
+
+	join = ft_strsjoin(arr2, " ");
+	TEST_ASSERT_NOT_NULL(join);
+	TEST_ASSERT_EQUAL_STRING("bonjour je suis", join);
+
+	join = ft_strsjoin(arr2, "<|>");
+	TEST_ASSERT_NOT_NULL(join);
+	TEST_ASSERT_EQUAL_STRING("bonjour<|>je<|>suis", join);
+
+	join = ft_strsjoin(arr2, "");
+	TEST_ASSERT_NOT_NULL(join);
+	TEST_ASSERT_EQUAL_STRING("bonjourjesuis", join);
+
+	join = ft_strsjoin(null_arr, "abc");
+	TEST_ASSERT_NOT_NULL(join);
+	TEST_ASSERT_EQUAL_STRING("", join);
+}
diff --git a/test/src/str/test_ft_strsjoinf.c b/test/src/str/test_ft_strsjoinf.c
new file mode 100644
index 0000000..d5184a9
--- /dev/null
+++ b/test/src/str/test_ft_strsjoinf.c
@@ -0,0 +1,87 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_strsjoinf.c                                :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/04 23:25:39 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_strsjoinf);
+
+TEST_SETUP(ft_strsjoinf)
+{}
+
+TEST_TEAR_DOWN(ft_strsjoinf)
+{}
+
+TEST(ft_strsjoinf, basic)
+{
+	char *join;
+	char *arr_orig[] = {"bonjour", "je", "suis", NULL};
+	char *arr2_orig[] = {"", "bonjour", "", "", "", "je", "suis", NULL};
+	char **null_arr;
+	char **arr;
+	char **arr2;
+
+	size_t i;
+
+	arr = malloc(sizeof(arr_orig));
+	for (i = 0; i < sizeof(arr_orig) / sizeof(char*) - 1; i++)
+		arr[i] = strdup(arr_orig[i]);
+	arr[i] = NULL;
+	join = ft_strsjoinf(arr, " ");
+	TEST_ASSERT_NOT_NULL(join);
+	TEST_ASSERT_EQUAL_STRING("bonjour je suis", join);
+
+	arr = malloc(sizeof(arr_orig));
+	for (i = 0; i < sizeof(arr_orig) / sizeof(char*) - 1; i++)
+		arr[i] = strdup(arr_orig[i]);
+	arr[i] = NULL;
+	join = ft_strsjoinf(arr, "<|>");
+	TEST_ASSERT_NOT_NULL(join);
+	TEST_ASSERT_EQUAL_STRING("bonjour<|>je<|>suis", join);
+
+	arr = malloc(sizeof(arr_orig));
+	for (i = 0; i < sizeof(arr_orig) / sizeof(char*) - 1; i++)
+		arr[i] = strdup(arr_orig[i]);
+	arr[i] = NULL;
+	join = ft_strsjoinf(arr, "");
+	TEST_ASSERT_NOT_NULL(join);
+	TEST_ASSERT_EQUAL_STRING("bonjourjesuis", join);
+
+	arr2 = malloc(sizeof(arr2_orig));
+	for (i = 0; i < sizeof(arr2_orig) / sizeof(char*) - 1; i++)
+		arr2[i] = strdup(arr2_orig[i]);
+	arr2[i] = NULL;
+	join = ft_strsjoinf(arr2, " ");
+	TEST_ASSERT_NOT_NULL(join);
+	TEST_ASSERT_EQUAL_STRING("bonjour je suis", join);
+
+	arr2 = malloc(sizeof(arr2_orig));
+	for (i = 0; i < sizeof(arr2_orig) / sizeof(char*) - 1; i++)
+		arr2[i] = strdup(arr2_orig[i]);
+	arr2[i] = NULL;
+	join = ft_strsjoinf(arr2, "<|>");
+	TEST_ASSERT_NOT_NULL(join);
+	TEST_ASSERT_EQUAL_STRING("bonjour<|>je<|>suis", join);
+
+	arr2 = malloc(sizeof(arr2_orig));
+	for (i = 0; i < sizeof(arr2_orig) / sizeof(char*) - 1; i++)
+		arr2[i] = strdup(arr2_orig[i]);
+	arr2[i] = NULL;
+	join = ft_strsjoinf(arr2, "");
+	TEST_ASSERT_NOT_NULL(join);
+	TEST_ASSERT_EQUAL_STRING("bonjourjesuis", join);
+
+	null_arr = malloc(sizeof(char*));
+	null_arr[0] = NULL;
+	join = ft_strsjoinf(null_arr, "abc");
+	TEST_ASSERT_NOT_NULL(join);
+	TEST_ASSERT_EQUAL_STRING("", join);
+}
diff --git a/test/src/str/test_ft_strsub.c b/test/src/str/test_ft_strsub.c
new file mode 100644
index 0000000..91ab4d3
--- /dev/null
+++ b/test/src/str/test_ft_strsub.c
@@ -0,0 +1,54 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_strsub.c                                   :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/05 14:02:11 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_strsub);
+
+TEST_SETUP(ft_strsub)
+{}
+
+TEST_TEAR_DOWN(ft_strsub)
+{}
+
+TEST(ft_strsub, basic)
+{
+	char *s = "[test]";
+	char *ret;
+
+	ret = ft_strsub(s, 0, strlen(s));
+	TEST_ASSERT_NOT_NULL(ret);
+	TEST_ASSERT_EQUAL_STRING("[test]", ret);
+	free(ret);
+
+	ret = ft_strsub(s, 1, strlen(s) - 2);
+	TEST_ASSERT_NOT_NULL(ret);
+	TEST_ASSERT_EQUAL_STRING("test", ret);
+	free(ret);
+
+	ret = ft_strsub(s, strlen(s) - 4, 100);
+	TEST_ASSERT_NOT_NULL(ret);
+	TEST_ASSERT_EQUAL_STRING("est]", ret);
+	free(ret);
+
+	ret = ft_strsub(s, 3, 100);
+	TEST_ASSERT_NOT_NULL(ret);
+	TEST_ASSERT_EQUAL_STRING("st]", ret);
+	free(ret);
+
+	ret = ft_strsub(s, strlen(s), 100);
+	TEST_ASSERT_NOT_NULL(ret);
+	TEST_ASSERT_EQUAL_STRING("", ret);
+	free(ret);
+
+	TEST_ASSERT_NULL(ft_strsub(s, strlen(s) + 1, 1));
+}
diff --git a/test/src/str/test_ft_strsubf.c b/test/src/str/test_ft_strsubf.c
new file mode 100644
index 0000000..827c849
--- /dev/null
+++ b/test/src/str/test_ft_strsubf.c
@@ -0,0 +1,61 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_strsubf.c                                  :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/05 14:03:20 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_strsubf);
+
+TEST_SETUP(ft_strsubf)
+{}
+
+TEST_TEAR_DOWN(ft_strsubf)
+{}
+
+TEST(ft_strsubf, basic)
+{
+	char *orig = "[test]";
+	char *s;
+	char *ret;
+
+	s = strdup(orig);
+	ret = ft_strsub(s, 0, strlen(s));
+	TEST_ASSERT_NOT_NULL(ret);
+	TEST_ASSERT_EQUAL_STRING("[test]", ret);
+	free(ret);
+
+	s = strdup(orig);
+	ret = ft_strsub(s, 1, strlen(s) - 2);
+	TEST_ASSERT_NOT_NULL(ret);
+	TEST_ASSERT_EQUAL_STRING("test", ret);
+	free(ret);
+
+	s = strdup(orig);
+	ret = ft_strsub(s, strlen(s) - 4, 100);
+	TEST_ASSERT_NOT_NULL(ret);
+	TEST_ASSERT_EQUAL_STRING("est]", ret);
+	free(ret);
+
+	s = strdup(orig);
+	ret = ft_strsub(s, 3, 100);
+	TEST_ASSERT_NOT_NULL(ret);
+	TEST_ASSERT_EQUAL_STRING("st]", ret);
+	free(ret);
+
+	s = strdup(orig);
+	ret = ft_strsub(s, strlen(s), 100);
+	TEST_ASSERT_NOT_NULL(ret);
+	TEST_ASSERT_EQUAL_STRING("", ret);
+	free(ret);
+
+	s = strdup(orig);
+	TEST_ASSERT_NULL(ft_strsub(s, strlen(s) + 1, 1));
+}
diff --git a/test/src/str/test_ft_strtof.c b/test/src/str/test_ft_strtof.c
new file mode 100644
index 0000000..65290a9
--- /dev/null
+++ b/test/src/str/test_ft_strtof.c
@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_strtof.c                                   :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/05/10 21:58:21 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_strtof);
+
+TEST_SETUP(ft_strtof)
+{}
+
+TEST_TEAR_DOWN(ft_strtof)
+{}
+
+TEST(ft_strtof, basic)
+{
+	/* float foo; */
+
+	/* foo = ft_strtof("0.0", NULL); */
+	/* TEST_ASSERT(0); */
+}
diff --git a/test/src/vec/test_ft_vecdestroy.c b/test/src/vec/test_ft_vecdestroy.c
new file mode 100644
index 0000000..4f121dc
--- /dev/null
+++ b/test/src/vec/test_ft_vecdestroy.c
@@ -0,0 +1,26 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_vecdestroy.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/01 19:55:14 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_vecdestroy);
+
+TEST_SETUP(ft_vecdestroy)
+{}
+
+TEST_TEAR_DOWN(ft_vecdestroy)
+{}
+
+TEST(ft_vecdestroy, basic)
+{
+	TEST_PASS();
+}
diff --git a/test/src/vec/test_ft_vecgrow.c b/test/src/vec/test_ft_vecgrow.c
new file mode 100644
index 0000000..8a80c7e
--- /dev/null
+++ b/test/src/vec/test_ft_vecgrow.c
@@ -0,0 +1,74 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_vecgrow.c                                  :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/02 10:41:28 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_vecgrow);
+
+TEST_SETUP(ft_vecgrow)
+{}
+
+TEST_TEAR_DOWN(ft_vecgrow)
+{}
+
+TEST(ft_vecgrow, basic)
+{
+	t_ftvec *vec = ft_vecnew(1);
+	TEST_ASSERT_NOT_NULL(vec);
+	vec->size = 1;
+	vec->data[0] = (void*)(0xfefefefeUL << 32);
+
+	TEST_ASSERT_NOT_NULL(ft_vecgrow(vec));
+	TEST_ASSERT_EQUAL(2, vec->capacity);
+	TEST_ASSERT_EQUAL(1, vec->size);
+	TEST_ASSERT_EQUAL_HEX64(0xfefefefeUL << 32, vec->data[0]);
+	vec->size = 2;
+	vec->data[1] = (void*)(0xfafafafaUL << 32);
+
+	TEST_ASSERT_NOT_NULL(ft_vecgrow(vec));
+	TEST_ASSERT_EQUAL(3, vec->capacity);
+	TEST_ASSERT_EQUAL(2, vec->size);
+	TEST_ASSERT_EQUAL_HEX64(0xfefefefeUL << 32, vec->data[0]);
+	TEST_ASSERT_EQUAL_HEX64(0xfafafafaUL << 32, vec->data[1]);
+	vec->size = 3;
+	vec->data[2] = (void*)(0xfbfbfbfbUL << 32);
+
+	TEST_ASSERT_NOT_NULL(ft_vecgrow(vec));
+	TEST_ASSERT_EQUAL(4, vec->capacity);
+	TEST_ASSERT_EQUAL(3, vec->size);
+	TEST_ASSERT_EQUAL_HEX64(0xfefefefeUL << 32, vec->data[0]);
+	TEST_ASSERT_EQUAL_HEX64(0xfafafafaUL << 32, vec->data[1]);
+	TEST_ASSERT_EQUAL_HEX64(0xfbfbfbfbUL << 32, vec->data[2]);
+
+	TEST_ASSERT_NOT_NULL(ft_vecgrow(vec));
+	TEST_ASSERT_EQUAL(6, vec->capacity);
+	TEST_ASSERT_EQUAL(3, vec->size);
+	TEST_ASSERT_EQUAL_HEX64(0xfefefefeUL << 32, vec->data[0]);
+	TEST_ASSERT_EQUAL_HEX64(0xfafafafaUL << 32, vec->data[1]);
+	TEST_ASSERT_EQUAL_HEX64(0xfbfbfbfbUL << 32, vec->data[2]);
+
+	TEST_ASSERT_NOT_NULL(ft_vecgrow(vec));
+	TEST_ASSERT_EQUAL(9, vec->capacity);
+	TEST_ASSERT_EQUAL(3, vec->size);
+	TEST_ASSERT_EQUAL_HEX64(0xfefefefeUL << 32, vec->data[0]);
+	TEST_ASSERT_EQUAL_HEX64(0xfafafafaUL << 32, vec->data[1]);
+	TEST_ASSERT_EQUAL_HEX64(0xfbfbfbfbUL << 32, vec->data[2]);
+
+	TEST_ASSERT_NOT_NULL(ft_vecgrow(vec));
+	TEST_ASSERT_EQUAL(13, vec->capacity);
+	TEST_ASSERT_EQUAL(3, vec->size);
+	TEST_ASSERT_EQUAL_HEX64(0xfefefefeUL << 32, vec->data[0]);
+	TEST_ASSERT_EQUAL_HEX64(0xfafafafaUL << 32, vec->data[1]);
+	TEST_ASSERT_EQUAL_HEX64(0xfbfbfbfbUL << 32, vec->data[2]);
+
+	ft_vecdestroy(vec, NULL);
+}
diff --git a/test/src/vec/test_ft_vecinsert.c b/test/src/vec/test_ft_vecinsert.c
new file mode 100644
index 0000000..9b89813
--- /dev/null
+++ b/test/src/vec/test_ft_vecinsert.c
@@ -0,0 +1,66 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_vecinsert.c                                :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 22:48:58 by charles           #+#    #+#             */
+/*   Updated: 2020/04/02 11:05:14 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_vecinsert);
+
+TEST_SETUP(ft_vecinsert)
+{}
+
+TEST_TEAR_DOWN(ft_vecinsert)
+{}
+
+TEST(ft_vecinsert, basic)
+{
+	t_ftvec *vec;
+
+	vec = ft_vecnew(2);
+	vec->data[0] = (void*)(1UL << 32);
+	vec->data[1] = (void*)(2UL << 32);
+	vec->size = 2;
+
+	TEST_ASSERT_NOT_NULL(ft_vecinsert(vec, 0, (void*)(0xfefefefeUL << 32)));
+	TEST_ASSERT_EQUAL(3, vec->capacity);
+	TEST_ASSERT_EQUAL(3, vec->size);
+	TEST_ASSERT_EQUAL_HEX64((void*)(0xfefefefeUL << 32), vec->data[0]);
+	TEST_ASSERT_EQUAL_HEX64((void*)(1UL << 32), vec->data[1]);
+	TEST_ASSERT_EQUAL_HEX64((void*)(2UL << 32), vec->data[2]);
+
+	TEST_ASSERT_NOT_NULL(ft_vecinsert(vec, 1, (void*)(0xfafafafaUL << 32)));
+	TEST_ASSERT_EQUAL(4, vec->capacity);
+	TEST_ASSERT_EQUAL(4, vec->size);
+	TEST_ASSERT_EQUAL_HEX64((void*)(0xfefefefeUL << 32), vec->data[0]);
+	TEST_ASSERT_EQUAL_HEX64((void*)(0xfafafafaUL << 32), vec->data[1]);
+	TEST_ASSERT_EQUAL_HEX64((void*)(1UL << 32), vec->data[2]);
+	TEST_ASSERT_EQUAL_HEX64((void*)(2UL << 32), vec->data[3]);
+
+	TEST_ASSERT_NOT_NULL(ft_vecinsert(vec, 2, (void*)(0xfbfbfbfbUL << 32)));
+	TEST_ASSERT_EQUAL(6, vec->capacity);
+	TEST_ASSERT_EQUAL(5, vec->size);
+	TEST_ASSERT_EQUAL_HEX64((void*)(0xfefefefeUL << 32), vec->data[0]);
+	TEST_ASSERT_EQUAL_HEX64((void*)(0xfafafafaUL << 32), vec->data[1]);
+	TEST_ASSERT_EQUAL_HEX64((void*)(0xfbfbfbfbUL << 32), vec->data[2]);
+	TEST_ASSERT_EQUAL_HEX64((void*)(1UL << 32), vec->data[3]);
+
+	TEST_ASSERT_NOT_NULL(ft_vecinsert(vec, vec->size, (void*)(0xfcUL << 31)));
+	TEST_ASSERT_EQUAL(6, vec->capacity);
+	TEST_ASSERT_EQUAL(6, vec->size);
+	TEST_ASSERT_EQUAL_HEX64((void*)(0xfefefefeUL << 32), vec->data[0]);
+	TEST_ASSERT_EQUAL_HEX64((void*)(0xfafafafaUL << 32), vec->data[1]);
+	TEST_ASSERT_EQUAL_HEX64((void*)(0xfbfbfbfbUL << 32), vec->data[2]);
+	TEST_ASSERT_EQUAL_HEX64((void*)(1UL << 32), vec->data[3]);
+	TEST_ASSERT_EQUAL_HEX64((void*)(2UL << 32), vec->data[4]);
+	TEST_ASSERT_EQUAL_HEX64((void*)(0xfcUL << 31), vec->data[5]);
+
+	ft_vecdestroy(vec, NULL);
+}
diff --git a/test/src/vec/test_ft_veciter.c b/test/src/vec/test_ft_veciter.c
new file mode 100644
index 0000000..fac28c1
--- /dev/null
+++ b/test/src/vec/test_ft_veciter.c
@@ -0,0 +1,52 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_veciter.c                                  :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/01 20:20:41 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_veciter);
+
+TEST_SETUP(ft_veciter)
+{}
+
+TEST_TEAR_DOWN(ft_veciter)
+{}
+
+static void iter_func(void *x)
+{
+	*(int*)x = *(int*)x * *(int*)x;
+}
+
+static void iter_func2(void *x)
+{
+	*(int*)x = *(int*)x - 100;
+}
+
+TEST(ft_veciter, basic)
+{
+	int	tmp[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+	t_ftvec *vec;
+
+	vec = ft_vecnew(10);
+	TEST_ASSERT_NOT_NULL(vec);
+	TEST_ASSERT_NOT_NULL(vec->data);
+	for (int i = 0; i < 10; i++)
+		vec->data[i] = tmp + i;
+	vec->size = 10;
+	ft_veciter(vec, iter_func);
+	for (int i = 0; i < 10; i++)
+		TEST_ASSERT_EQUAL(i * i, *(int*)vec->data[i]);
+	ft_veciter(vec, iter_func2);
+	for (int i = 0; i < 10; i++)
+		TEST_ASSERT_EQUAL(i * i - 100, *(int*)vec->data[i]);
+
+	ft_vecdestroy(vec, NULL);
+}
diff --git a/test/src/vec/test_ft_vecnew.c b/test/src/vec/test_ft_vecnew.c
new file mode 100644
index 0000000..579a182
--- /dev/null
+++ b/test/src/vec/test_ft_vecnew.c
@@ -0,0 +1,47 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_vecnew.c                                   :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/01 20:01:37 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_vecnew);
+
+TEST_SETUP(ft_vecnew)
+{}
+
+TEST_TEAR_DOWN(ft_vecnew)
+{}
+
+TEST(ft_vecnew, basic)
+{
+	t_ftvec *vec;
+
+	vec = ft_vecnew(0);
+	TEST_ASSERT_NOT_NULL(vec);
+	TEST_ASSERT_NOT_NULL(vec->data);
+	TEST_ASSERT_EQUAL(1, vec->capacity);
+	TEST_ASSERT_EQUAL(0, vec->size);
+	ft_vecdestroy(vec, NULL);
+
+	vec = ft_vecnew(10);
+	TEST_ASSERT_NOT_NULL(vec);
+	TEST_ASSERT_NOT_NULL(vec->data);
+	TEST_ASSERT_EQUAL(10, vec->capacity);
+	TEST_ASSERT_EQUAL(0, vec->size);
+	ft_vecdestroy(vec, NULL);
+
+	vec = ft_vecnew(256);
+	TEST_ASSERT_NOT_NULL(vec);
+	TEST_ASSERT_NOT_NULL(vec->data);
+	TEST_ASSERT_EQUAL(256, vec->capacity);
+	TEST_ASSERT_EQUAL(0, vec->size);
+	ft_vecdestroy(vec, NULL);
+}
diff --git a/test/src/vec/test_ft_vecpop.c b/test/src/vec/test_ft_vecpop.c
new file mode 100644
index 0000000..2ee96d2
--- /dev/null
+++ b/test/src/vec/test_ft_vecpop.c
@@ -0,0 +1,47 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_vecpop.c                                   :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/01 20:26:37 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_vecpop);
+
+TEST_SETUP(ft_vecpop)
+{}
+
+TEST_TEAR_DOWN(ft_vecpop)
+{}
+
+TEST(ft_vecpop, basic)
+{
+	t_ftvec *vec;
+
+	vec = ft_vecnew(3);
+	TEST_ASSERT_NOT_NULL(vec);
+	TEST_ASSERT_NOT_NULL(vec->data);
+
+	vec->size = 3;
+	for (long i = 0; i < 3; i++)
+		vec->data[i] = (void*)i;
+
+	ft_vecpop(vec, NULL);
+	TEST_ASSERT_EQUAL(2, vec->size);
+	TEST_ASSERT_EQUAL(3, vec->capacity);
+	ft_vecpop(vec, NULL);
+	TEST_ASSERT_EQUAL(1, vec->size);
+	TEST_ASSERT_EQUAL(3, vec->capacity);
+	ft_vecpop(vec, NULL);
+	TEST_ASSERT_EQUAL(0, vec->size);
+	TEST_ASSERT_EQUAL(3, vec->capacity);
+	ft_vecpop(vec, NULL);
+	TEST_ASSERT_EQUAL(0, vec->size);
+	TEST_ASSERT_EQUAL(3, vec->capacity);
+}
diff --git a/test/src/vec/test_ft_vecpush.c b/test/src/vec/test_ft_vecpush.c
new file mode 100644
index 0000000..05efc7a
--- /dev/null
+++ b/test/src/vec/test_ft_vecpush.c
@@ -0,0 +1,57 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_vecpush.c                                  :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/01 20:23:00 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_vecpush);
+
+TEST_SETUP(ft_vecpush)
+{}
+
+TEST_TEAR_DOWN(ft_vecpush)
+{}
+
+TEST(ft_vecpush, basic)
+{
+	t_ftvec *vec;
+
+	vec = ft_vecnew(2);
+	TEST_ASSERT_NOT_NULL(vec);
+	TEST_ASSERT_NOT_NULL(vec->data);
+
+	TEST_ASSERT_NOT_NULL(ft_vecpush(vec, (void*)10));
+	TEST_ASSERT_EQUAL(1, vec->size);
+	TEST_ASSERT_EQUAL(2, vec->capacity);
+	TEST_ASSERT_EQUAL(10, (long)vec->data[0]);
+
+	TEST_ASSERT_NOT_NULL(ft_vecpush(vec, (void*)11));
+	TEST_ASSERT_EQUAL(2, vec->size);
+	TEST_ASSERT_EQUAL(2, vec->capacity);
+	TEST_ASSERT_EQUAL(11, (long)vec->data[1]);
+
+	TEST_ASSERT_NOT_NULL(ft_vecpush(vec, (void*)12));
+	TEST_ASSERT_EQUAL(3, vec->size);
+	TEST_ASSERT_EQUAL(2 * 1.5, vec->capacity);
+	TEST_ASSERT_EQUAL(12, (long)vec->data[2]);
+
+	TEST_ASSERT_NOT_NULL(ft_vecpush(vec, (void*)13));
+	TEST_ASSERT_EQUAL(4, vec->size);
+	TEST_ASSERT_EQUAL(2 * 1.5 * 1.5, vec->capacity);
+	TEST_ASSERT_EQUAL(13, (long)vec->data[3]);
+
+	TEST_ASSERT_NOT_NULL(ft_vecpush(vec, (void*)14));
+	TEST_ASSERT_EQUAL(5, vec->size);
+	TEST_ASSERT_EQUAL(2 * 1.5 * 1.5 * 1.5, vec->capacity);
+	TEST_ASSERT_EQUAL(14, (long)vec->data[4]);
+
+	ft_vecdestroy(vec, NULL);
+}
diff --git a/test/src/vec/test_ft_vecpush_safe.c b/test/src/vec/test_ft_vecpush_safe.c
new file mode 100644
index 0000000..8546829
--- /dev/null
+++ b/test/src/vec/test_ft_vecpush_safe.c
@@ -0,0 +1,45 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_vecpush_safe.c                             :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 19:41:59 by charles           #+#    #+#             */
+/*   Updated: 2020/04/04 23:31:08 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_vecpush_safe);
+
+TEST_SETUP(ft_vecpush_safe)
+{}
+
+TEST_TEAR_DOWN(ft_vecpush_safe)
+{}
+
+TEST(ft_vecpush_safe, basic)
+{
+	t_ftvec *vec;
+
+	vec = ft_vecnew(1);
+	TEST_ASSERT_NULL(ft_vecpush_safe(vec, NULL));
+
+	TEST_ASSERT_NOT_NULL(ft_vecpush_safe(vec, (void*)0x1UL));
+	TEST_ASSERT_EQUAL_HEX(0x1, (unsigned long)vec->data[0]);
+	TEST_ASSERT_GREATER_OR_EQUAL(1, vec->capacity);
+	TEST_ASSERT_EQUAL(1, vec->size);
+
+	TEST_ASSERT_NULL(ft_vecpush_safe(vec, NULL));
+	TEST_ASSERT_NULL(ft_vecpush_safe(vec, NULL));
+
+	TEST_ASSERT_NOT_NULL(ft_vecpush_safe(vec, (void*)0x2UL));
+	TEST_ASSERT_EQUAL_HEX(0x2, (unsigned long)vec->data[1]);
+	TEST_ASSERT_GREATER_OR_EQUAL(2, vec->capacity);
+	TEST_ASSERT_EQUAL(2, vec->size);
+
+	TEST_ASSERT_NULL(ft_vecpush_safe(vec, NULL));
+	TEST_ASSERT_NULL(ft_vecpush_safe(vec, NULL));
+}
diff --git a/test/src/vec/test_ft_vecremove.c b/test/src/vec/test_ft_vecremove.c
new file mode 100644
index 0000000..8cecc19
--- /dev/null
+++ b/test/src/vec/test_ft_vecremove.c
@@ -0,0 +1,64 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_vecremove.c                                :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/01 22:48:58 by charles           #+#    #+#             */
+/*   Updated: 2020/04/01 22:56:37 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_vecremove);
+
+TEST_SETUP(ft_vecremove)
+{}
+
+TEST_TEAR_DOWN(ft_vecremove)
+{}
+
+TEST(ft_vecremove, basic)
+{
+	t_ftvec *vec;
+
+	vec = ft_vecnew(4);
+	for (size_t i = 0; i < 4; i++)
+		vec->data[i] = (void*)(i + 1);
+	vec->size = 4;
+
+	ft_vecremove(vec, 0, NULL);
+	TEST_ASSERT_EQUAL(3, vec->size);
+	TEST_ASSERT_EQUAL(4, vec->capacity);
+	TEST_ASSERT_EQUAL_UINT64(2, (size_t)vec->data[0]);
+	TEST_ASSERT_EQUAL_UINT64(3, (size_t)vec->data[1]);
+	TEST_ASSERT_EQUAL_UINT64(4, (size_t)vec->data[2]);
+
+	ft_vecremove(vec, 1, NULL);
+	TEST_ASSERT_EQUAL(2, vec->size);
+	TEST_ASSERT_EQUAL(4, vec->capacity);
+	TEST_ASSERT_EQUAL_UINT64(2, (size_t)vec->data[0]);
+	TEST_ASSERT_EQUAL_UINT64(4, (size_t)vec->data[1]);
+
+	ft_vecremove(vec, 1, NULL);
+	TEST_ASSERT_EQUAL(1, vec->size);
+	TEST_ASSERT_EQUAL(4, vec->capacity);
+	TEST_ASSERT_EQUAL_UINT64(2, (size_t)vec->data[0]);
+
+	ft_vecremove(vec, 1, NULL);
+	TEST_ASSERT_EQUAL(1, vec->size);
+	TEST_ASSERT_EQUAL(4, vec->capacity);
+	TEST_ASSERT_EQUAL_UINT64(2, (size_t)vec->data[0]);
+
+	ft_vecremove(vec, 0, NULL);
+	TEST_ASSERT_EQUAL(0, vec->size);
+	TEST_ASSERT_EQUAL(4, vec->capacity);
+
+	ft_vecremove(vec, 0, NULL);
+	TEST_ASSERT_EQUAL(0, vec->size);
+	TEST_ASSERT_EQUAL(4, vec->capacity);
+
+	ft_vecdestroy(vec, NULL);
+}
diff --git a/test/src/vec/test_ft_vecsort.c b/test/src/vec/test_ft_vecsort.c
new file mode 100644
index 0000000..bfdad01
--- /dev/null
+++ b/test/src/vec/test_ft_vecsort.c
@@ -0,0 +1,34 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   test_ft_vecsort.c                                  :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/04 19:31:13 by charles           #+#    #+#             */
+/*   Updated: 2020/04/04 19:45:27 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft_test.h"
+
+TEST_GROUP(ft_vecsort);
+
+TEST_SETUP(ft_vecsort)
+{}
+
+TEST_TEAR_DOWN(ft_vecsort)
+{}
+
+TEST(ft_vecsort, basic)
+{
+	t_ftvec *vec = ft_vecnew(1);
+	char*	arr[]    = {"bonjour", "je", "suis", "lala", "z", "b"};
+	char*	sorted[] = {"bonjour", "je", "suis", "lala", "z", "b"};
+
+	for (size_t i = 0; i < sizeof(arr) / sizeof(char*); i++)
+		ft_vecpush(vec, arr[i]);
+	ft_vecsort(vec, ft_compar_str);
+	ft_qsort(sorted, sizeof(sorted) / sizeof(char*), sizeof(char*), ft_compar_str);
+	TEST_ASSERT_EQUAL_STRING_ARRAY(sorted, vec->data, vec->size);
+}