diff options
| author | nass1pro <nass1pro@gmail.com> | 2020-06-09 19:48:34 +0200 |
|---|---|---|
| committer | nass1pro <nass1pro@gmail.com> | 2020-06-13 11:31:00 +0200 |
| commit | 579a26f5593039ffbbd1a81e45ecf0ef8797cb5d (patch) | |
| tree | c5b6761db98e27d15bab3fb45ba9e0a646cf06e0 /test_mini/libft/test/src | |
| parent | 9fabc25a980550afc6337fd729632462f2680daa (diff) | |
| download | minishell-579a26f5593039ffbbd1a81e45ecf0ef8797cb5d.tar.gz minishell-579a26f5593039ffbbd1a81e45ecf0ef8797cb5d.tar.bz2 minishell-579a26f5593039ffbbd1a81e45ecf0ef8797cb5d.zip | |
add lexer
add single quote
Diffstat (limited to 'test_mini/libft/test/src')
71 files changed, 2927 insertions, 0 deletions
diff --git a/test_mini/libft/test/src/algo/test_ft_bsearch.c b/test_mini/libft/test/src/algo/test_ft_bsearch.c new file mode 100644 index 0000000..27858ee --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_bsearch.c @@ -0,0 +1,55 @@ +#include "libft_test.h" + +TEST_GROUP(ft_bsearch); + +TEST_SETUP(ft_bsearch) +{} + +TEST_TEAR_DOWN(ft_bsearch) +{} + +TEST(ft_bsearch, basic) +{ + int arr[] = {3, 4, 1, 2, 7, 189, -1, -134, 7, 1, 34}; + t_ftsearch_const consts; + + int a = 189; + consts.key = &a; + consts.compar = ft_compar_int; + + size_t nelp = sizeof(arr) / sizeof(int); + qsort(arr, nelp, sizeof(int), ft_compar_int); + + void *ptr = ft_bsearch(arr, nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(bsearch(consts.key, arr, nelp, sizeof(int), consts.compar), ptr); + + int b = 123; + consts.key = &b; + ptr = ft_bsearch(arr, nelp, sizeof(int), &consts); + TEST_ASSERT_NULL(ptr); + + int c = -134; + consts.key = &c; + ptr = ft_bsearch(arr, nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(bsearch(consts.key, arr, nelp, sizeof(int), consts.compar), ptr); + + int e = 1; + consts.key = &e; + ptr = ft_bsearch(arr, nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(bsearch(consts.key, arr, nelp, sizeof(int), consts.compar), ptr); + + int d = -1; + consts.key = &d; + ptr = ft_bsearch(arr, nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(bsearch(consts.key, arr, nelp, sizeof(int), consts.compar), ptr); + + int f = 34; + consts.key = &f; + ptr = ft_bsearch(arr, nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(bsearch(consts.key, arr, nelp, sizeof(int), consts.compar), ptr); + + int g = 7; + consts.key = &g; + ptr = ft_bsearch(arr, nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(bsearch(consts.key, arr, nelp, sizeof(int), consts.compar), ptr); +} diff --git a/test_mini/libft/test/src/algo/test_ft_compar_int.c b/test_mini/libft/test/src/algo/test_ft_compar_int.c new file mode 100644 index 0000000..39cc322 --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_compar_int.c @@ -0,0 +1,20 @@ +#include "libft_test.h" + +TEST_GROUP(ft_compar_int); + +TEST_SETUP(ft_compar_int) +{} + +TEST_TEAR_DOWN(ft_compar_int) +{} + +TEST(ft_compar_int, basic) +{ + int a = 4; + int b = 3; + + TEST_ASSERT_GREATER_THAN(0, ft_compar_int(&a, &b)); + TEST_ASSERT_LESS_THAN(0, ft_compar_int(&b, &a)); + TEST_ASSERT_EQUAL(0, ft_compar_int(&a, &a)); + TEST_ASSERT_EQUAL(0, ft_compar_int(&b, &b)); +} diff --git a/test_mini/libft/test/src/algo/test_ft_heapsort.c b/test_mini/libft/test/src/algo/test_ft_heapsort.c new file mode 100644 index 0000000..6c2c3fb --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_heapsort.c @@ -0,0 +1,27 @@ +#include "libft_test.h" + +TEST_GROUP(ft_heapsort); + +TEST_SETUP(ft_heapsort) +{} + +TEST_TEAR_DOWN(ft_heapsort) +{} + +static int compar(const void *a, const void *b) +{ + return *(int*)a - *(int*)b; +} + +TEST(ft_heapsort, basic) +{ + TEST_IGNORE(); + 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_heapsort(arr, sizeof(arr) / sizeof(int), sizeof(int), compar); + TEST_ASSERT_EQUAL_INT_ARRAY(sorted_arr, arr, sizeof(arr) / sizeof(int)); +} diff --git a/test_mini/libft/test/src/algo/test_ft_is_set.c b/test_mini/libft/test/src/algo/test_ft_is_set.c new file mode 100644 index 0000000..604ec53 --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_is_set.c @@ -0,0 +1,23 @@ +#include "libft_test.h" + +TEST_GROUP(ft_is_set); + +TEST_SETUP(ft_is_set) +{} + +TEST_TEAR_DOWN(ft_is_set) +{} + +static int compar(const void *a, const void *b) +{ + return *(int*)a - *(int*)b; +} + +TEST(ft_is_set, basic) +{ + int arr[] = {3, 4, 1, 2, 7, 189, -1, -134, 7, 1, 34}; + int unique_arr[] = {3, 4, 2, 189, -1, -134, 7, 1, 34}; + + TEST_ASSERT_FALSE(ft_is_set(arr, sizeof(arr) / sizeof(int), sizeof(int), compar)); + TEST_ASSERT_TRUE(ft_is_set(unique_arr, sizeof(unique_arr) / sizeof(int), sizeof(int), compar)); +} diff --git a/test_mini/libft/test/src/algo/test_ft_lfind.c b/test_mini/libft/test/src/algo/test_ft_lfind.c new file mode 100644 index 0000000..0080d55 --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_lfind.c @@ -0,0 +1,38 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lfind); + +TEST_SETUP(ft_lfind) +{} + +TEST_TEAR_DOWN(ft_lfind) +{} + +TEST(ft_lfind, basic) +{ + int arr[] = {3, 4, 1, 2, 7, 189, -1, -134, 7, 1, 34}; + t_ftsearch_const consts; + + int a = 189; + consts.key = &a; + consts.compar = ft_compar_int; + + size_t nelp = sizeof(arr) / sizeof(int); + void *ptr = ft_lfind(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(arr + 5, ptr); + + int b = 123; + consts.key = &b; + ptr = ft_lfind(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_NULL(ptr); + + int c = 34; + consts.key = &c; + ptr = ft_lfind(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(arr + 10, ptr); + + int d = 3; + consts.key = &d; + ptr = ft_lfind(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(arr, ptr); +} diff --git a/test_mini/libft/test/src/algo/test_ft_lsearch.c b/test_mini/libft/test/src/algo/test_ft_lsearch.c new file mode 100644 index 0000000..13fae13 --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_lsearch.c @@ -0,0 +1,52 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lsearch); + +TEST_SETUP(ft_lsearch) +{} + +TEST_TEAR_DOWN(ft_lsearch) +{} + +TEST(ft_lsearch, basic) +{ + int arr[32] = {3, 4, 1, 2, 7, 189, -1, -134, 7, 1, 34}; + t_ftsearch_const consts; + + int a = 189; + consts.key = &a; + consts.compar = ft_compar_int; + + size_t nelp = 11; + void *ptr = ft_lsearch(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(arr + 5, ptr); + + int c = 34; + consts.key = &c; + ptr = ft_lsearch(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(arr + 10, ptr); + + int d = 3; + consts.key = &d; + ptr = ft_lsearch(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL_PTR(arr, ptr); + + int b = 123; + consts.key = &b; + ptr = ft_lsearch(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL(12, nelp); + TEST_ASSERT_EQUAL(123, arr[11]); + TEST_ASSERT_EQUAL_PTR(arr + 11, ptr); + + ptr = ft_lsearch(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL(12, nelp); + TEST_ASSERT_EQUAL(123, arr[11]); + TEST_ASSERT_EQUAL_PTR(arr + 11, ptr); + + int e = 1234; + consts.key = &e; + ptr = ft_lsearch(arr, &nelp, sizeof(int), &consts); + TEST_ASSERT_EQUAL(13, nelp); + TEST_ASSERT_EQUAL(1234, arr[12]); + TEST_ASSERT_EQUAL_PTR(arr + 12, ptr); +} diff --git a/test_mini/libft/test/src/algo/test_ft_mergesort.c b/test_mini/libft/test/src/algo/test_ft_mergesort.c new file mode 100644 index 0000000..567e31d --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_mergesort.c @@ -0,0 +1,26 @@ +#include "libft_test.h" + +TEST_GROUP(ft_mergesort); + +TEST_SETUP(ft_mergesort) +{} + +TEST_TEAR_DOWN(ft_mergesort) +{} + +static int compar(const void *a, const void *b) +{ + return *(int*)a - *(int*)b; +} + +TEST(ft_mergesort, 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_mergesort(arr, sizeof(arr) / sizeof(int), sizeof(int), compar); + TEST_ASSERT_EQUAL_INT_ARRAY(sorted_arr, arr, sizeof(arr) / sizeof(int)); +} diff --git a/test_mini/libft/test/src/algo/test_ft_qsort.c b/test_mini/libft/test/src/algo/test_ft_qsort.c new file mode 100644 index 0000000..25a5ef6 --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_qsort.c @@ -0,0 +1,26 @@ +#include "libft_test.h" + +TEST_GROUP(ft_qsort); + +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); + TEST_ASSERT_EQUAL_INT_ARRAY(sorted_arr, arr, sizeof(arr) / sizeof(int)); +} diff --git a/test_mini/libft/test/src/algo/test_ft_reverse.c b/test_mini/libft/test/src/algo/test_ft_reverse.c new file mode 100644 index 0000000..feca520 --- /dev/null +++ b/test_mini/libft/test/src/algo/test_ft_reverse.c @@ -0,0 +1,19 @@ +#include "libft_test.h" + +TEST_GROUP(ft_reverse); + +TEST_SETUP(ft_reverse) +{} + +TEST_TEAR_DOWN(ft_reverse) +{} + +TEST(ft_reverse, basic) +{ + int arr[] = {3, 4, 1, 2, 7, 189, -1, -134, 7, 1, 34}; + int rev_arr[] = {34, 1, 7, -134, -1, 189, 7, 2, 1, 4, 3}; + + ft_reverse(arr, sizeof(arr) / sizeof(int), sizeof(int)); + TEST_ASSERT_EQUAL_INT_ARRAY(rev_arr, arr, sizeof(arr) / sizeof(int)); + +} diff --git a/test_mini/libft/test/src/ctype/test_ft_isalnum.c b/test_mini/libft/test/src/ctype/test_ft_isalnum.c new file mode 100644 index 0000000..0019a03 --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_isalnum.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_isalnum); + +TEST_SETUP(ft_isalnum) +{} + +TEST_TEAR_DOWN(ft_isalnum) +{} + +TEST(ft_isalnum, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(!!isalnum(i), !!ft_isalnum(i)); +} diff --git a/test_mini/libft/test/src/ctype/test_ft_isalpha.c b/test_mini/libft/test/src/ctype/test_ft_isalpha.c new file mode 100644 index 0000000..9846985 --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_isalpha.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_isalpha); + +TEST_SETUP(ft_isalpha) +{} + +TEST_TEAR_DOWN(ft_isalpha) +{} + +TEST(ft_isalpha, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(!!isalpha(i), !!ft_isalpha(i)); +} diff --git a/test_mini/libft/test/src/ctype/test_ft_isascii.c b/test_mini/libft/test/src/ctype/test_ft_isascii.c new file mode 100644 index 0000000..c052571 --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_isascii.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_isascii); + +TEST_SETUP(ft_isascii) +{} + +TEST_TEAR_DOWN(ft_isascii) +{} + +TEST(ft_isascii, base) +{ + for (int i = 0; i < UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(!!isascii(i), !!ft_isascii(i)); +} diff --git a/test_mini/libft/test/src/ctype/test_ft_isblank.c b/test_mini/libft/test/src/ctype/test_ft_isblank.c new file mode 100644 index 0000000..3c8460f --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_isblank.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_isblank); + +TEST_SETUP(ft_isblank) +{} + +TEST_TEAR_DOWN(ft_isblank) +{} + +TEST(ft_isblank, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(!!isblank(i), !!ft_isblank(i)); +} diff --git a/test_mini/libft/test/src/ctype/test_ft_isdigit.c b/test_mini/libft/test/src/ctype/test_ft_isdigit.c new file mode 100644 index 0000000..74c210b --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_isdigit.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_isdigit); + +TEST_SETUP(ft_isdigit) +{} + +TEST_TEAR_DOWN(ft_isdigit) +{} + +TEST(ft_isdigit, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(!!isdigit(i), !!ft_isdigit(i)); +} diff --git a/test_mini/libft/test/src/ctype/test_ft_isprint.c b/test_mini/libft/test/src/ctype/test_ft_isprint.c new file mode 100644 index 0000000..0f15661 --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_isprint.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_isprint); + +TEST_SETUP(ft_isprint) +{} + +TEST_TEAR_DOWN(ft_isprint) +{} + +TEST(ft_isprint, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(!!isprint(i), !!ft_isprint(i)); +} diff --git a/test_mini/libft/test/src/ctype/test_ft_isspace.c b/test_mini/libft/test/src/ctype/test_ft_isspace.c new file mode 100644 index 0000000..f94a1ea --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_isspace.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_isspace); + +TEST_SETUP(ft_isspace) +{} + +TEST_TEAR_DOWN(ft_isspace) +{} + +TEST(ft_isspace, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(!!isspace(i), !!ft_isspace(i)); +} diff --git a/test_mini/libft/test/src/ctype/test_ft_todigit.c b/test_mini/libft/test/src/ctype/test_ft_todigit.c new file mode 100644 index 0000000..cd8d9f3 --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_todigit.c @@ -0,0 +1,20 @@ +#include "libft_test.h" + +TEST_GROUP(ft_todigit); + +TEST_SETUP(ft_todigit) +{} + +TEST_TEAR_DOWN(ft_todigit) +{} + +TEST(ft_todigit, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + { + if (isdigit(i)) + TEST_ASSERT_EQUAL(i - '0', ft_todigit(i)); + else + TEST_ASSERT_EQUAL(-1, ft_todigit(i)); + } +} diff --git a/test_mini/libft/test/src/ctype/test_ft_tolower.c b/test_mini/libft/test/src/ctype/test_ft_tolower.c new file mode 100644 index 0000000..9465544 --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_tolower.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_tolower); + +TEST_SETUP(ft_tolower) +{} + +TEST_TEAR_DOWN(ft_tolower) +{} + +TEST(ft_tolower, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(tolower(i), ft_tolower(i)); +} diff --git a/test_mini/libft/test/src/ctype/test_ft_toupper.c b/test_mini/libft/test/src/ctype/test_ft_toupper.c new file mode 100644 index 0000000..b23c08b --- /dev/null +++ b/test_mini/libft/test/src/ctype/test_ft_toupper.c @@ -0,0 +1,15 @@ +#include "libft_test.h" + +TEST_GROUP(ft_toupper); + +TEST_SETUP(ft_toupper) +{} + +TEST_TEAR_DOWN(ft_toupper) +{} + +TEST(ft_toupper, base) +{ + for (int i = 0; i <= UCHAR_MAX; i++) + TEST_ASSERT_EQUAL(toupper(i), ft_toupper(i)); +} diff --git a/test_mini/libft/test/src/ht/test_ft_htdelone.c b/test_mini/libft/test/src/ht/test_ft_htdelone.c new file mode 100644 index 0000000..5ba4822 --- /dev/null +++ b/test_mini/libft/test/src/ht/test_ft_htdelone.c @@ -0,0 +1,68 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_htdelone.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/19 02:08:00 by cacharle #+# #+# */ +/* Updated: 2020/02/19 02:46:10 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_htdelone); + +TEST_SETUP(ft_htdelone) +{} + +TEST_TEAR_DOWN(ft_htdelone) +{} + +static void st_del(t_ftht_entry *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_htdelone(ht, "bonjour", st_del); + void *ptr = ft_htget(ht, "bonjour"); + TEST_ASSERT_NULL(ptr); + TEST_ASSERT_NOT_NULL(ft_htget(ht, "a")); + 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, "a", st_del); + 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); + 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); + ptr = ft_htget(ht, "c"); + TEST_ASSERT_NULL(ptr); + TEST_ASSERT_NOT_NULL(ft_htget(ht, "d")); + + ft_htdelone(ht, "d", st_del); + ptr = ft_htget(ht, "d"); + TEST_ASSERT_NULL(ptr); +} diff --git a/test_mini/libft/test/src/ht/test_ft_htdestroy.c b/test_mini/libft/test/src/ht/test_ft_htdestroy.c new file mode 100644 index 0000000..1512a48 --- /dev/null +++ b/test_mini/libft/test/src/ht/test_ft_htdestroy.c @@ -0,0 +1,38 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_htdestroy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/19 02:45:27 by cacharle #+# #+# */ +/* Updated: 2020/02/19 02:49:36 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_htdestroy); + +TEST_SETUP(ft_htdestroy) +{} + +TEST_TEAR_DOWN(ft_htdestroy) +{} + +static void st_del(t_ftht_entry *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); +} diff --git a/test_mini/libft/test/src/ht/test_ft_htget.c b/test_mini/libft/test/src/ht/test_ft_htget.c new file mode 100644 index 0000000..386c3dc --- /dev/null +++ b/test_mini/libft/test/src/ht/test_ft_htget.c @@ -0,0 +1,114 @@ +#include "libft_test.h" + +TEST_GROUP(ft_htget); + +static t_ftht *ht; + +TEST_SETUP(ft_htget) +{ + ht = ft_htnew(10); +} + +TEST_TEAR_DOWN(ft_htget) +{ + /* ft_htdestroy_key(ht); */ +} + +int helper_segfault_pid; + +static void st_del(t_ftht_entry *c) +{ + free(c->key); + free(c); +} + +TEST(ft_htget, segfault) +{ + TEST_ASSERT_SEGFAULT(ft_htget((t_ftht*)NULL, "")); + TEST_ASSERT_SEGFAULT(ft_htget(ft_htnew(1), (char*)NULL)); + TEST_ASSERT_SEGFAULT(ft_htget(ft_htnew(1), "")); + TEST_ASSERT_SEGFAULT(ft_htget(ft_htnew(1), "asdkfhjaklsdfhahjsdfk")); +} + +TEST(ft_htget, error_null) +{ + TEST_ASSERT_NULL(ft_htget(NULL, NULL)); + TEST_ASSERT_NULL(ft_htget(ht, NULL)); + TEST_ASSERT_NULL(ft_htget(NULL, "")); + TEST_ASSERT_NULL(ft_htget(ht, "")); + TEST_ASSERT_NULL(ft_htget(ht, "hi")); + TEST_ASSERT_NULL(ft_htget(ht, "asdfkasdflk")); + TEST_ASSERT_NULL(ft_htget(ht, "asdhfalsdhflahsdfhjasklehjfklwhjekrlanklshasdfkasdflk")); +} + +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); + + char *s = ft_htget(ht, "a"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "data1"); + + s = ft_htget(ht, "b"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "data2"); + + s = ft_htget(ht, "c"); + TEST_ASSERT_NOT_NULL(s); + 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); + + s = ft_htget(ht, "a"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "bonjour1"); + + s = ft_htget(ht, "b"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "bonjour2"); + + s = ft_htget(ht, "c"); + TEST_ASSERT_NOT_NULL(s); + 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); + + char *s = ft_htget(small, "a"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "data1"); + + s = ft_htget(small, "b"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "data2"); + + s = ft_htget(small, "c"); + TEST_ASSERT_NOT_NULL(s); + 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); + + s = ft_htget(small, "a"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "bonjour1"); + + s = ft_htget(small, "b"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "bonjour2"); + + s = ft_htget(small, "c"); + TEST_ASSERT_NOT_NULL(s); + TEST_ASSERT_EQUAL_STRING(s, "bonjour3"); +} diff --git a/test_mini/libft/test/src/ht/test_ft_hthash.c b/test_mini/libft/test/src/ht/test_ft_hthash.c new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/test_mini/libft/test/src/ht/test_ft_hthash.c diff --git a/test_mini/libft/test/src/ht/test_ft_htnew.c b/test_mini/libft/test/src/ht/test_ft_htnew.c new file mode 100644 index 0000000..17bca6a --- /dev/null +++ b/test_mini/libft/test/src/ht/test_ft_htnew.c @@ -0,0 +1,48 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_htnew.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/12 22:30:06 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:15:32 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_htnew); + +TEST_SETUP(ft_htnew) +{} + +TEST_TEAR_DOWN(ft_htnew) +{} + +int helper_segfault_pid; + +TEST(ft_htnew, segfault) +{ + TEST_ASSERT_SEGFAULT(ft_htnew(10)); + TEST_ASSERT_SEGFAULT(ft_htnew(0)); + TEST_ASSERT_SEGFAULT(ft_htnew((1 << 14) + 1)); +} + +TEST(ft_htnew, error_null) +{ + TEST_ASSERT_NOT_NULL(ft_htnew(10)); + TEST_ASSERT_NULL(ft_htnew(0)); +} + +TEST(ft_htnew, happy_path) +{ + t_ftht *ht; + + ht = ft_htnew(10); + TEST_ASSERT_NOT_NULL(ht); + TEST_ASSERT_EQUAL(10, ht->size); + TEST_ASSERT_NOT_NULL(ht->buckets); + for (t_ftsize i = 0; i < ht->size; i++) + TEST_ASSERT_NULL(ht->buckets[i]); +} diff --git a/test_mini/libft/test/src/ht/test_ft_htset.c b/test_mini/libft/test/src/ht/test_ft_htset.c new file mode 100644 index 0000000..96d848e --- /dev/null +++ b/test_mini/libft/test/src/ht/test_ft_htset.c @@ -0,0 +1,100 @@ +#include "libft_test.h" + +TEST_GROUP(ft_htset); + +static t_ftht *ht; + +TEST_SETUP(ft_htset) +{ + ht = ft_htnew(10); +} + +TEST_TEAR_DOWN(ft_htset) +{ + /* ft_htdestroy_key(ht); */ +} + +static void st_del(t_ftht_entry *c) +{ + free(c->key); + free(c); +} + +TEST(ft_htset, segfault) +{ + TEST_ASSERT_SEGFAULT(ft_htset(NULL, "", strdup(""), NULL)); + TEST_ASSERT_SEGFAULT(ft_htset(ft_htnew(1), NULL, strdup(""), NULL)); + TEST_ASSERT_SEGFAULT(ft_htset(ft_htnew(1), "", NULL, NULL)); + TEST_ASSERT_SEGFAULT(ft_htset(ft_htnew(1), "", strdup(""), NULL)); + TEST_ASSERT_SEGFAULT(ft_htset(ft_htnew(1), "hi", strdup(""), NULL)); + TEST_ASSERT_SEGFAULT(ft_htset(ft_htnew(1), "asdfasdfasdc", strdup(""), NULL)); +} + +TEST(ft_htset, error_null) +{ + TEST_ASSERT_NULL(ft_htset(NULL, "", strdup("1"), NULL)); + TEST_ASSERT_NULL(ft_htset(ht, NULL, strdup("2"), NULL)); + TEST_ASSERT_NOT_NULL(ft_htset(ht, "", strdup("3"), NULL)); + TEST_ASSERT_NOT_NULL(ft_htset(ht, "a", strdup("4"), NULL)); + TEST_ASSERT_NOT_NULL(ft_htset(ht, "b", strdup("5"), NULL)); + TEST_ASSERT_NOT_NULL(ft_htset(ht, "c", strdup("6"), NULL)); + TEST_ASSERT_NOT_NULL(ft_htset(ht, "d", strdup("7"), NULL)); +} + +TEST(ft_htset, happy_path) +{ + 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); + TEST_ASSERT_EQUAL_STRING(content->key, "bonjour"); + TEST_ASSERT_EQUAL_STRING(content->value, "content"); +} + +TEST(ft_htset, reset) +{ + t_ftht *small = NULL; + + small = ft_htnew(3); + + t_ftht_entry *content = ft_htset(small, "bonjour", ft_strdup("content"), st_del); + 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_entry *content_re = ft_htset(small, "bonjour", ft_strdup("yo"), st_del); + TEST_ASSERT_NOT_NULL(content_re); + TEST_ASSERT_NOT_NULL(content_re->key); + TEST_ASSERT_NOT_NULL(content_re->value); + TEST_ASSERT_EQUAL_STRING("bonjour", content_re->key); + TEST_ASSERT_EQUAL_STRING("yo", content_re->value); +} + +TEST(ft_htset, collision) +{ + t_ftht *small = NULL; + small = ft_htnew(1); + + t_ftht_entry *content1 = ft_htset(small, "bonjour", strdup("content1"), st_del); + 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_entry *content2 = ft_htset(small, "aurevoir", strdup("content2"), st_del); + 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_entry *content3 = ft_htset(small, "aloa", strdup("content3"), st_del); + TEST_ASSERT_NOT_NULL(content3); + TEST_ASSERT_NOT_NULL(content3->key); + TEST_ASSERT_NOT_NULL(content3->value); + TEST_ASSERT_EQUAL_STRING(content3->key, "aloa"); + TEST_ASSERT_EQUAL_STRING(content3->value, "content3"); +} diff --git a/test_mini/libft/test/src/ht/test_ftht_entry_new.c b/test_mini/libft/test/src/ht/test_ftht_entry_new.c new file mode 100644 index 0000000..a566600 --- /dev/null +++ b/test_mini/libft/test/src/ht/test_ftht_entry_new.c @@ -0,0 +1,43 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_htentry_new.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/17 04:07:04 by cacharle #+# #+# */ +/* Updated: 2020/02/17 04:15:39 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_htentry_new); + +TEST_SETUP(ft_htentry_new) +{} + +TEST_TEAR_DOWN(ft_htentry_new) +{} + +TEST(ft_htentry_new, basic) +{ + t_ftht_entry *c = NULL; + + char *k = "bonjour"; + 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_htentry_new(k, k); + TEST_ASSERT_NOT_NULL(c); + TEST_ASSERT(k != c->key); + TEST_ASSERT_EQUAL_STRING(k, c->key); + TEST_ASSERT_EQUAL_PTR(k, c->value); + TEST_ASSERT_EQUAL_STRING(k, (char*)c->value); + + /* free(c->key); */ + /* free(c); */ +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstbsearch.c b/test_mini/libft/test/src/lst/test_ft_lstbsearch.c new file mode 100644 index 0000000..81f2578 --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstbsearch.c @@ -0,0 +1,37 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstbsearch); + +TEST_SETUP(ft_lstbsearch) +{} + +TEST_TEAR_DOWN(ft_lstbsearch) +{} + +TEST(ft_lstbsearch, basic) +{ + t_ftlst *found = NULL; + t_ftlst *lst = NULL; + int a = 1; + int b = 2; + int c = 3; + int d = 4; + + 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); + found = ft_lstbsearch(lst, ft_compar_int, &c); + TEST_ASSERT_NOT_NULL(found); + found = ft_lstbsearch(lst, ft_compar_int, &b); + TEST_ASSERT_NOT_NULL(found); + found = ft_lstbsearch(lst, ft_compar_int, &a); + TEST_ASSERT_NOT_NULL(found); + found = ft_lstbsearch(lst, ft_compar_int, &d); + TEST_ASSERT_NULL(found); + + ft_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstdelone.c b/test_mini/libft/test/src/lst/test_ft_lstdelone.c new file mode 100644 index 0000000..881a93b --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstdelone.c @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_lstdelone.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/19 02:01:33 by cacharle #+# #+# */ +/* Updated: 2020/02/19 02:07:27 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_lstdelone); + +TEST_SETUP(ft_lstdelone) +{} + +TEST_TEAR_DOWN(ft_lstdelone) +{} + +TEST(ft_lstdelone, basic) +{ + TEST_PASS(); // how to test free? +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstdestroy.c b/test_mini/libft/test/src/lst/test_ft_lstdestroy.c new file mode 100644 index 0000000..e7b98c5 --- /dev/null +++ b/test_mini/libft/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_mini/libft/test/src/lst/test_ft_lstiter.c b/test_mini/libft/test/src/lst/test_ft_lstiter.c new file mode 100644 index 0000000..53b1380 --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstiter.c @@ -0,0 +1,52 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstiter); + +TEST_SETUP(ft_lstiter) +{} + +TEST_TEAR_DOWN(ft_lstiter) +{} + +static void square_iter_func(void *data) +{ + int *d = (int*)data; + + *d = *d * *d; +} + +TEST(ft_lstiter, basic) +{ + t_ftlst *lst = NULL; + int a = 2; + int b = 3; + int c = 4; + int d = 5; + + ft_lstiter(lst, square_iter_func); + TEST_ASSERT_NULL(lst); + + ft_lstpush_front(&lst, ft_lstnew(&a)); + ft_lstiter(lst, square_iter_func); + TEST_ASSERT_EQUAL(4, *(int*)lst->data); + + ft_lstpush_front(&lst, ft_lstnew(&b)); + ft_lstiter(lst, square_iter_func); + TEST_ASSERT_EQUAL(9, *(int*)lst->data); + TEST_ASSERT_EQUAL(16, *(int*)lst->next->data); + + ft_lstpush_front(&lst, ft_lstnew(&c)); + ft_lstiter(lst, square_iter_func); + 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_lstpush_front(&lst, ft_lstnew(&d)); + ft_lstiter(lst, square_iter_func); + 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_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstlast.c b/test_mini/libft/test/src/lst/test_ft_lstlast.c new file mode 100644 index 0000000..82c8096 --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstlast.c @@ -0,0 +1,29 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstlast); + +TEST_SETUP(ft_lstlast) +{} + +TEST_TEAR_DOWN(ft_lstlast) +{} + +TEST(ft_lstlast, basic) +{ + t_ftlst *lst = NULL; + int a = 1; + int b = 2; + int c = 3; + int d = 4; + + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL_PTR(lst, ft_lstlast(lst)); + ft_lstpush_front(&lst, ft_lstnew(&b)); + TEST_ASSERT_EQUAL_PTR(lst->next, ft_lstlast(lst)); + ft_lstpush_front(&lst, ft_lstnew(&c)); + TEST_ASSERT_EQUAL_PTR(lst->next->next, ft_lstlast(lst)); + ft_lstpush_front(&lst, ft_lstnew(&d)); + TEST_ASSERT_EQUAL_PTR(lst->next->next->next, ft_lstlast(lst)); + + ft_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstlfind.c b/test_mini/libft/test/src/lst/test_ft_lstlfind.c new file mode 100644 index 0000000..1851436 --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstlfind.c @@ -0,0 +1,55 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_lstlfind.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/17 03:08:15 by cacharle #+# #+# */ +/* Updated: 2020/02/17 03:34:40 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_lstlfind); + +TEST_SETUP(ft_lstlfind) +{} + +TEST_TEAR_DOWN(ft_lstlfind) +{} + +TEST(ft_lstlfind, basic) +{ + t_ftlst *found = NULL; + t_ftlst *lst = NULL; + int a = 1; + int b = 2; + int c = 3; + int d = 4; + + 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); + found = ft_lstlfind(lst, ft_compar_int, &c); + TEST_ASSERT_EQUAL_PTR(lst->next->next->next, found); + + found = ft_lstlfind(lst, ft_compar_int, &b); + TEST_ASSERT_EQUAL_PTR(lst->next->next, found); + + found = ft_lstlfind(lst, ft_compar_int, &a); + TEST_ASSERT_EQUAL_PTR(lst, found); + + found = ft_lstlfind(lst, ft_compar_int, &d); + TEST_ASSERT_NULL(found); + + ft_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstlsearch.c b/test_mini/libft/test/src/lst/test_ft_lstlsearch.c new file mode 100644 index 0000000..83a8f4e --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstlsearch.c @@ -0,0 +1,55 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_lstlsearch.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/17 03:21:46 by cacharle #+# #+# */ +/* Updated: 2020/02/17 03:35:37 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_lstlsearch); + +TEST_SETUP(ft_lstlsearch) +{} + +TEST_TEAR_DOWN(ft_lstlsearch) +{} + +TEST(ft_lstlsearch, basic) +{ + t_ftlst *found = NULL; + t_ftlst *lst = NULL; + int a = 1; + int b = 2; + int c = 3; + int d = 4; + + 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); + found = ft_lstlsearch(lst, ft_compar_int, &c); + TEST_ASSERT_EQUAL_PTR(lst->next->next->next, found); + + found = ft_lstlsearch(lst, ft_compar_int, &b); + TEST_ASSERT_EQUAL_PTR(lst->next->next, found); + + found = ft_lstlsearch(lst, ft_compar_int, &a); + TEST_ASSERT_EQUAL_PTR(lst, found); + + found = ft_lstlsearch(lst, ft_compar_int, &d); + TEST_ASSERT_EQUAL_PTR(ft_lstlast(lst), found); + + ft_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstmap.c b/test_mini/libft/test/src/lst/test_ft_lstmap.c new file mode 100644 index 0000000..53c2f7a --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstmap.c @@ -0,0 +1,82 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstmap); + +TEST_SETUP(ft_lstmap) +{} + +TEST_TEAR_DOWN(ft_lstmap) +{} + +static void *f_square(void *data) +{ + int *d = malloc(sizeof(int)); + + *d = *(int*)data; + *d = *d * *d; + return d; +} + +TEST(ft_lstmap, basic) +{ + t_ftlst *lst = NULL; + t_ftlst *mapped = NULL; + int a = 2; + int b = 3; + int c = 4; + int d = 5; + + mapped = ft_lstmap(lst, f_square, free); + TEST_ASSERT_NULL(mapped); + + ft_lstpush_front(&lst, ft_lstnew(&a)); + mapped = ft_lstmap(lst, f_square, free); + TEST_ASSERT_NOT_NULL(mapped); + TEST_ASSERT_NOT_NULL(mapped->data); + TEST_ASSERT_EQUAL(4, *(int*)mapped->data); + TEST_ASSERT_NULL(mapped->next); + ft_lstdestroy(&mapped, free); + + ft_lstpush_front(&lst, ft_lstnew(&b)); + mapped = ft_lstmap(lst, f_square, free); + TEST_ASSERT_NOT_NULL(mapped); + 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->data); + TEST_ASSERT_EQUAL(4, *(int*)mapped->next->data); + TEST_ASSERT_NULL(mapped->next->next); + ft_lstdestroy(&mapped, free); + + ft_lstpush_front(&lst, ft_lstnew(&c)); + mapped = ft_lstmap(lst, f_square, free); + TEST_ASSERT_NOT_NULL(mapped); + 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->data); + TEST_ASSERT_EQUAL(9, *(int*)mapped->next->data); + TEST_ASSERT_NOT_NULL(mapped->next->next); + 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_lstdestroy(&mapped, free); + + ft_lstpush_front(&lst, ft_lstnew(&d)); + mapped = ft_lstmap(lst, f_square, free); + TEST_ASSERT_NOT_NULL(mapped); + 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->data); + TEST_ASSERT_EQUAL(16, *(int*)mapped->next->data); + TEST_ASSERT_NOT_NULL(mapped->next->next); + 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->data); + TEST_ASSERT_EQUAL(4, *(int*)mapped->next->next->next->data); + ft_lstdestroy(&mapped, free); + + ft_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstnew.c b/test_mini/libft/test/src/lst/test_ft_lstnew.c new file mode 100644 index 0000000..518c885 --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstnew.c @@ -0,0 +1,25 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstnew); + +TEST_SETUP(ft_lstnew) +{} + +TEST_TEAR_DOWN(ft_lstnew) +{} + +TEST(ft_lstnew, basic) +{ + t_ftlst *lst; + int a = 4; + + lst = ft_lstnew(&a); + TEST_ASSERT_NOT_NULL(lst); + 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->data); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstpop_front.c b/test_mini/libft/test/src/lst/test_ft_lstpop_front.c new file mode 100644 index 0000000..827afe6 --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstpop_front.c @@ -0,0 +1,31 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstpop_front); + +TEST_SETUP(ft_lstpop_front) +{} + +TEST_TEAR_DOWN(ft_lstpop_front) +{} + +TEST(ft_lstpop_front, basic) +{ + t_ftlst *lst = NULL; + int a = 1; + int b = 2; + int c = 3; + + 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->data); + TEST_ASSERT_EQUAL_PTR(&a, lst->next->data); + + ft_lstpop_front(&lst, NULL); + TEST_ASSERT_EQUAL_PTR(&a, lst->data); + + ft_lstpop_front(&lst, NULL); + TEST_ASSERT_NULL(lst); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstpush_back.c b/test_mini/libft/test/src/lst/test_ft_lstpush_back.c new file mode 100644 index 0000000..9f0d97b --- /dev/null +++ b/test_mini/libft/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_mini/libft/test/src/lst/test_ft_lstpush_front.c b/test_mini/libft/test/src/lst/test_ft_lstpush_front.c new file mode 100644 index 0000000..4a6af9f --- /dev/null +++ b/test_mini/libft/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_mini/libft/test/src/lst/test_ft_lstremove_if.c b/test_mini/libft/test/src/lst/test_ft_lstremove_if.c new file mode 100644 index 0000000..a79016b --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstremove_if.c @@ -0,0 +1,70 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstremove_if); + +TEST_SETUP(ft_lstremove_if) +{} + +TEST_TEAR_DOWN(ft_lstremove_if) +{} + +TEST(ft_lstremove_if, basic) +{ + t_ftlst *lst = NULL; + int a = 1; + int b = 2; + int c = 3; + int d = 4; + + 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); + 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->next->next->next->next); + 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->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->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->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_mini/libft/test/src/lst/test_ft_lstreverse.c b/test_mini/libft/test/src/lst/test_ft_lstreverse.c new file mode 100644 index 0000000..a0a7d4e --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstreverse.c @@ -0,0 +1,45 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstreverse); + +TEST_SETUP(ft_lstreverse) +{} + +TEST_TEAR_DOWN(ft_lstreverse) +{} + +TEST(ft_lstreverse, basic) +{ + t_ftlst *lst = NULL; + int a = 1; + int b = 2; + int c = 3; + int d = 4; + + ft_lstreverse(&lst); + TEST_ASSERT_NULL(lst); + + ft_lstpush_front(&lst, ft_lstnew(&a)); + ft_lstreverse(&lst); + TEST_ASSERT_EQUAL_PTR(&a, lst->data); + + ft_lstpush_front(&lst, ft_lstnew(&b)); + ft_lstreverse(&lst); + TEST_ASSERT_EQUAL_PTR(&a, lst->data); + TEST_ASSERT_EQUAL_PTR(&b, lst->next->data); + + ft_lstpush_front(&lst, ft_lstnew(&c)); + ft_lstreverse(&lst); + 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_lstpush_front(&lst, ft_lstnew(&d)); + ft_lstreverse(&lst); + 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_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstreverse_ret.c b/test_mini/libft/test/src/lst/test_ft_lstreverse_ret.c new file mode 100644 index 0000000..e6fc278 --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstreverse_ret.c @@ -0,0 +1,45 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstreverse_ret); + +TEST_SETUP(ft_lstreverse_ret) +{} + +TEST_TEAR_DOWN(ft_lstreverse_ret) +{} + +TEST(ft_lstreverse_ret, basic) +{ + t_ftlst *lst = NULL; + int a = 1; + int b = 2; + int c = 3; + int d = 4; + + lst = ft_lstreverse_ret(lst); + TEST_ASSERT_NULL(lst); + + ft_lstpush_front(&lst, ft_lstnew(&a)); + lst = ft_lstreverse_ret(lst); + TEST_ASSERT_EQUAL_PTR(&a, lst->data); + + ft_lstpush_front(&lst, ft_lstnew(&b)); + lst = ft_lstreverse_ret(lst); + TEST_ASSERT_EQUAL_PTR(&a, lst->data); + TEST_ASSERT_EQUAL_PTR(&b, lst->next->data); + + ft_lstpush_front(&lst, ft_lstnew(&c)); + lst = ft_lstreverse_ret(lst); + 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_lstpush_front(&lst, ft_lstnew(&d)); + lst = ft_lstreverse_ret(lst); + 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_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstsize.c b/test_mini/libft/test/src/lst/test_ft_lstsize.c new file mode 100644 index 0000000..d3b78bb --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstsize.c @@ -0,0 +1,37 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstsize); + +TEST_SETUP(ft_lstsize) +{} + +TEST_TEAR_DOWN(ft_lstsize) +{} + +TEST(ft_lstsize, basic) +{ + t_ftlst *lst = NULL; + int a = 1; + + TEST_ASSERT_EQUAL(0, ft_lstsize(lst)); + lst = ft_lstnew(&a); + TEST_ASSERT_EQUAL(1, ft_lstsize(lst)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL(2, ft_lstsize(lst)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL(3, ft_lstsize(lst)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL(4, ft_lstsize(lst)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL(5, ft_lstsize(lst)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL(6, ft_lstsize(lst)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL(7, ft_lstsize(lst)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL(8, ft_lstsize(lst)); + ft_lstpush_front(&lst, ft_lstnew(&a)); + TEST_ASSERT_EQUAL(9, ft_lstsize(lst)); + + ft_lstdestroy(&lst, NULL); +} diff --git a/test_mini/libft/test/src/lst/test_ft_lstsort.c b/test_mini/libft/test/src/lst/test_ft_lstsort.c new file mode 100644 index 0000000..3b771ae --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstsort.c @@ -0,0 +1,38 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstsort); + +TEST_SETUP(ft_lstsort) +{} + +TEST_TEAR_DOWN(ft_lstsort) +{} + +TEST(ft_lstsort, basic) +{ + t_ftlst *lst = NULL; + int a = 1; + int b = -1; + int c = 4; + int d = -3; + + 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->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->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_mini/libft/test/src/lst/test_ft_lstsorted_merge.c b/test_mini/libft/test/src/lst/test_ft_lstsorted_merge.c new file mode 100644 index 0000000..9839cd7 --- /dev/null +++ b/test_mini/libft/test/src/lst/test_ft_lstsorted_merge.c @@ -0,0 +1,40 @@ +#include "libft_test.h" + +TEST_GROUP(ft_lstsorted_merge); + +TEST_SETUP(ft_lstsorted_merge) +{} + +TEST_TEAR_DOWN(ft_lstsorted_merge) +{} + +TEST(ft_lstsorted_merge, basic) +{ + t_ftlst *lst1 = NULL; + t_ftlst *lst2 = NULL; + int a = 1; + int b = 2; + int c = 3; + int d = 4; + int e = 5; + + 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->data, lst1->next->data) > 0) + TEST_FAIL(); +} diff --git a/test_mini/libft/test/src/main.c b/test_mini/libft/test/src/main.c new file mode 100644 index 0000000..8884f81 --- /dev/null +++ b/test_mini/libft/test/src/main.c @@ -0,0 +1,85 @@ +#include "libft_test.h" + +static void run_all_test(void) +{ + // ctype + RUN_TEST_GROUP(ft_isalnum); + RUN_TEST_GROUP(ft_isalpha); + RUN_TEST_GROUP(ft_isascii); + RUN_TEST_GROUP(ft_isblank); + RUN_TEST_GROUP(ft_isdigit); + RUN_TEST_GROUP(ft_isprint); + RUN_TEST_GROUP(ft_isspace); + RUN_TEST_GROUP(ft_todigit); + RUN_TEST_GROUP(ft_tolower); + RUN_TEST_GROUP(ft_toupper); + + // mem + RUN_TEST_GROUP(ft_bzero); + RUN_TEST_GROUP(ft_calloc); + RUN_TEST_GROUP(ft_memccpy); + RUN_TEST_GROUP(ft_memchr); + RUN_TEST_GROUP(ft_memcmp); + RUN_TEST_GROUP(ft_memcpy); + RUN_TEST_GROUP(ft_memmem); + RUN_TEST_GROUP(ft_memmove); + RUN_TEST_GROUP(ft_memset); + RUN_TEST_GROUP(ft_memset_pattern4); + RUN_TEST_GROUP(ft_memswap); + + // str + RUN_TEST_GROUP(ft_strlen); + + // ht + RUN_TEST_GROUP(ft_htentry_new); + RUN_TEST_GROUP(ft_htnew); + RUN_TEST_GROUP(ft_htget); + RUN_TEST_GROUP(ft_htset); + RUN_TEST_GROUP(ft_htdelone); + RUN_TEST_GROUP(ft_htdestroy); + + // algo + RUN_TEST_GROUP(ft_bsearch); + RUN_TEST_GROUP(ft_compar_int); + RUN_TEST_GROUP(ft_heapsort); + RUN_TEST_GROUP(ft_is_set); + RUN_TEST_GROUP(ft_lfind); + RUN_TEST_GROUP(ft_lsearch); + RUN_TEST_GROUP(ft_mergesort); + RUN_TEST_GROUP(ft_qsort); + RUN_TEST_GROUP(ft_reverse); + + // lst + 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_lstdestroy); + RUN_TEST_GROUP(ft_lstdelone); + RUN_TEST_GROUP(ft_lstiter); + RUN_TEST_GROUP(ft_lstlast); + RUN_TEST_GROUP(ft_lstmap); + RUN_TEST_GROUP(ft_lstnew); + RUN_TEST_GROUP(ft_lstpop_front); + RUN_TEST_GROUP(ft_lstremove_if); + RUN_TEST_GROUP(ft_lstreverse); + RUN_TEST_GROUP(ft_lstreverse_ret); + 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); +} + +int main(int argc, const char **argv) +{ + return UnityMain(argc, argv, run_all_test); +} diff --git a/test_mini/libft/test/src/mem/test_ft_bzero.c b/test_mini/libft/test/src/mem/test_ft_bzero.c new file mode 100644 index 0000000..20e560d --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_bzero.c @@ -0,0 +1,30 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_bzero.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:32:20 by cacharle #+# #+# */ +/* Updated: 2020/02/13 04:30:39 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_bzero); + +TEST_SETUP(ft_bzero) +{} + +TEST_TEAR_DOWN(ft_bzero) +{} + +TEST(ft_bzero, basic) +{ + char buf[32] = {'a'}; + + ft_bzero(buf, 32); + for (int i = 0; i < 32; i++) + TEST_ASSERT_EQUAL(0x0, buf[i]); +} diff --git a/test_mini/libft/test/src/mem/test_ft_calloc.c b/test_mini/libft/test/src/mem/test_ft_calloc.c new file mode 100644 index 0000000..0df9b95 --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_calloc.c @@ -0,0 +1,33 @@ +#include "libft_test.h" + +TEST_GROUP(ft_calloc); + +TEST_SETUP(ft_calloc) +{} + +TEST_TEAR_DOWN(ft_calloc) +{} + +TEST(ft_calloc, basic) +{ + char *ptr = NULL; + + ptr = ft_calloc(45, sizeof(char)); + TEST_ASSERT_NOT_NULL(ptr); +#ifdef __APPLE__ + TEST_ASSERT_GREATER_THAN(45 * sizeof(char) - 1, malloc_size(ptr)); +#endif + for (int i = 0; i < 45; i++) + TEST_ASSERT_EQUAL(0x0, ptr[i]); + /* free(ptr); */ + + int *ptrint = NULL; + ptrint = ft_calloc(10, sizeof(int)); + TEST_ASSERT_NOT_NULL(ptr); +#ifdef __APPLE__ + TEST_ASSERT_GREATER_THAN(10 * sizeof(int) - 1, malloc_size(ptrint)); +#endif + for (int i = 0; i < 10; i++) + TEST_ASSERT_EQUAL(0x0, ptrint[i]); + /* free(ptrint); */ +} diff --git a/test_mini/libft/test/src/mem/test_ft_memccpy.c b/test_mini/libft/test/src/mem/test_ft_memccpy.c new file mode 100644 index 0000000..39925a1 --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memccpy.c @@ -0,0 +1,45 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memccpy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:34:13 by cacharle #+# #+# */ +/* Updated: 2020/02/13 19:35:17 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memccpy); + +TEST_SETUP(ft_memccpy) +{} + +TEST_TEAR_DOWN(ft_memccpy) +{} + +TEST(ft_memccpy, basic) +{ + char buf[32] = "bonjour"; + char buf2[32] = {0}; + + char *ptr = ft_memccpy(buf2, buf, 0x0, 32); + TEST_ASSERT_EQUAL_PTR(&buf2[8], ptr); + for (int i = 0; i < 32; i++) + TEST_ASSERT_EQUAL_CHAR(buf[i], buf2[i]); + + ptr = ft_memccpy(buf2, buf, 0x1, 32); + TEST_ASSERT_NULL(ptr); + for (int i = 0; i < 32; i++) + TEST_ASSERT_EQUAL_CHAR(buf[i], buf2[i]); + + char buf3[10] = "aurevoir"; + ptr = ft_memccpy(buf, buf3, 'e', 10); + TEST_ASSERT_EQUAL_PTR(buf + 4, ptr); + for (int i = 0; i < 4; i++) + TEST_ASSERT_EQUAL_CHAR(buf[i], buf3[i]); + for (int i = 4; i < 32; i++) + TEST_ASSERT_EQUAL_CHAR(buf[i], buf2[i]); +} diff --git a/test_mini/libft/test/src/mem/test_ft_memchr.c b/test_mini/libft/test/src/mem/test_ft_memchr.c new file mode 100644 index 0000000..135edfb --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memchr.c @@ -0,0 +1,35 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memchr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:33:14 by cacharle #+# #+# */ +/* Updated: 2020/02/13 19:38:17 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memchr); + +TEST_SETUP(ft_memchr) +{} + +TEST_TEAR_DOWN(ft_memchr) +{} + +TEST(ft_memchr, basic) +{ + char *a = "bonjour"; + + char *ptr = ft_memchr(a, 'j', sizeof(a)); + TEST_ASSERT_EQUAL_PTR(a + 3, ptr); + + ptr = ft_memchr(a, 'z', sizeof(a)); + TEST_ASSERT_NULL(ptr); + + ptr = ft_memchr(a, '\0', sizeof(a)); + TEST_ASSERT_EQUAL_PTR(a + 7, ptr); +} diff --git a/test_mini/libft/test/src/mem/test_ft_memcmp.c b/test_mini/libft/test/src/mem/test_ft_memcmp.c new file mode 100644 index 0000000..81871a1 --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memcmp.c @@ -0,0 +1,42 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memcmp.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:32:16 by cacharle #+# #+# */ +/* Updated: 2020/02/13 19:41:08 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memcmp); + +TEST_SETUP(ft_memcmp) +{} + +TEST_TEAR_DOWN(ft_memcmp) +{} + +TEST(ft_memcmp, basic) +{ + char buf1[32] = "bonjour"; + char buf2[32] = "bonjoure"; + + int res = ft_memcmp(buf1, buf2, 32); + TEST_ASSERT_LESS_THAN(0, res); + + res = ft_memcmp(buf2, buf1, 32); + TEST_ASSERT_GREATER_THAN(0, res); + + res = ft_memcmp(buf2, buf1, 7); + TEST_ASSERT_EQUAL(0, res); + res = ft_memcmp(buf2, buf1, 6); + TEST_ASSERT_EQUAL(0, res); + res = ft_memcmp(buf2, buf1, 3); + TEST_ASSERT_EQUAL(0, res); + res = ft_memcmp(buf2, buf1, 0); + TEST_ASSERT_EQUAL(0, res); +} diff --git a/test_mini/libft/test/src/mem/test_ft_memcpy.c b/test_mini/libft/test/src/mem/test_ft_memcpy.c new file mode 100644 index 0000000..3afe817 --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memcpy.c @@ -0,0 +1,47 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memcpy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:33:22 by cacharle #+# #+# */ +/* Updated: 2020/02/13 04:27:55 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memcpy); + +TEST_SETUP(ft_memcpy) +{} + +TEST_TEAR_DOWN(ft_memcpy) +{} + +TEST(ft_memcpy, basic) +{ + void *ptr; + unsigned char buf1[32] = {0}; + unsigned char buf2[32] = "bonjour"; + + ptr = ft_memcpy(buf1, buf2, 32); + TEST_ASSERT_NOT_NULL(ptr); + TEST_ASSERT_EQUAL_PTR(buf1, ptr); + TEST_ASSERT_EQUAL(0, memcmp(buf1, buf2, 32)); + + ptr = ft_memcpy(buf1, "yo", 3); + TEST_ASSERT_NOT_NULL(ptr); + TEST_ASSERT_EQUAL_PTR(buf1, ptr); + TEST_ASSERT_EQUAL(0, memcmp(buf1, "yo", 3)); + TEST_ASSERT_EQUAL(0, memcmp(buf1 + 3, buf2 + 3, 32 - 3)); + + char saved[32]; + + memcpy(saved, buf2, 32); + ptr = ft_memcpy(buf2, "", 0); + TEST_ASSERT_NOT_NULL(ptr); + TEST_ASSERT_EQUAL_PTR(buf2, ptr); + TEST_ASSERT_EQUAL(0, memcmp(buf2, saved, 32)); +} diff --git a/test_mini/libft/test/src/mem/test_ft_memmem.c b/test_mini/libft/test/src/mem/test_ft_memmem.c new file mode 100644 index 0000000..67514a5 --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memmem.c @@ -0,0 +1,65 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memmem.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:33:50 by cacharle #+# #+# */ +/* Updated: 2020/02/13 21:04:22 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memmem); + +TEST_SETUP(ft_memmem) +{} + +TEST_TEAR_DOWN(ft_memmem) +{} + +TEST(ft_memmem, basic) +{ + char haystack[32] = "bonjour"; + char *ptr; + + ptr = ft_memmem(haystack, sizeof(haystack), "jour\0", 5); + TEST_ASSERT_EQUAL_PTR(haystack + 3, ptr); + + ptr = ft_memmem(haystack, sizeof(haystack), "jour", 4); + TEST_ASSERT_EQUAL_PTR(haystack + 3, ptr); + + ptr = ft_memmem(haystack, sizeof(haystack), "jo", 2); + TEST_ASSERT_EQUAL_PTR(haystack + 3, ptr); + + ptr = ft_memmem(haystack, sizeof(haystack), "j", 1); + TEST_ASSERT_EQUAL_PTR(haystack + 3, ptr); + + ptr = ft_memmem(haystack, sizeof(haystack), "yo", 2); + TEST_ASSERT_NULL(ptr); + + ptr = ft_memmem(haystack, sizeof(haystack), "\0", 1); + TEST_ASSERT_EQUAL_PTR(haystack + 7, ptr); + + ptr = ft_memmem(haystack, sizeof(haystack), "bon", 3); + TEST_ASSERT_EQUAL_PTR(haystack, ptr); + + ptr = ft_memmem(haystack, sizeof(haystack), "on", 2); + TEST_ASSERT_EQUAL_PTR(haystack + 1, ptr); +} + +TEST(ft_memmem, invalid_len) +{ + char buf[32] = {0}; + + void *ptr = ft_memmem(buf, 2, "jour", 4); + TEST_ASSERT_NULL(ptr); + + ptr = ft_memmem(buf, 0, "jour", 4); + TEST_ASSERT_NULL(ptr); + + ptr = ft_memmem(buf, 2, "jour", 0); + TEST_ASSERT_NULL(ptr); +} diff --git a/test_mini/libft/test/src/mem/test_ft_memmove.c b/test_mini/libft/test/src/mem/test_ft_memmove.c new file mode 100644 index 0000000..158cda9 --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memmove.c @@ -0,0 +1,39 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memmove.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:34:21 by cacharle #+# #+# */ +/* Updated: 2020/02/13 19:49:07 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memmove); + +TEST_SETUP(ft_memmove) +{} + +TEST_TEAR_DOWN(ft_memmove) +{} + +TEST(ft_memmove, basic) +{ + char buf1[32] = "bonjour"; + + char *ptr = ft_memmove(buf1, buf1 + 2, 29); + TEST_ASSERT_EQUAL_PTR(buf1, ptr); + TEST_ASSERT_EQUAL_STRING("njour", buf1); + + ptr = ft_memmove(buf1 + 2, buf1, 29); + TEST_ASSERT_EQUAL_PTR(buf1 + 2, ptr); + TEST_ASSERT_EQUAL_STRING("njour", ptr); + TEST_ASSERT_EQUAL_STRING("njnjour", buf1); + + ptr = ft_memmove(buf1, buf1, 32); + TEST_ASSERT_EQUAL_PTR(buf1, ptr); + TEST_ASSERT_EQUAL_STRING("njnjour", ptr); +} diff --git a/test_mini/libft/test/src/mem/test_ft_memset.c b/test_mini/libft/test/src/mem/test_ft_memset.c new file mode 100644 index 0000000..7ec5846 --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memset.c @@ -0,0 +1,42 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memset.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:32:28 by cacharle #+# #+# */ +/* Updated: 2020/02/13 04:21:58 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memset); + +TEST_SETUP(ft_memset) +{} + +TEST_TEAR_DOWN(ft_memset) +{} + +TEST(ft_memset, basic) +{ + int i; + unsigned char buf[32] = {0}; + + ft_memset(buf, 0xfa, 32); + for (i = 0; i < 32; i++) + TEST_ASSERT_EQUAL(0xfa, buf[i]); + + ft_memset(buf, 0x00, 15); + for (i = 0; i < 15; i++) + TEST_ASSERT_EQUAL(0x00, buf[i]); + while (i++ < 31) + TEST_ASSERT_EQUAL(0xfa, buf[i]); + + ft_memset(buf, 0x10, 31); + for (int i = 0; i < 31; i++) + TEST_ASSERT_EQUAL(0x10, buf[i]); + TEST_ASSERT_EQUAL(0xfa, buf[31]); +} diff --git a/test_mini/libft/test/src/mem/test_ft_memset_pattern4.c b/test_mini/libft/test/src/mem/test_ft_memset_pattern4.c new file mode 100644 index 0000000..0e2806a --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memset_pattern4.c @@ -0,0 +1,42 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memset_pattern4.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:32:43 by cacharle #+# #+# */ +/* Updated: 2020/02/13 19:57:48 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memset_pattern4); + +TEST_SETUP(ft_memset_pattern4) +{} + +TEST_TEAR_DOWN(ft_memset_pattern4) +{} + +TEST(ft_memset_pattern4, basic) +{ + char buf[17] = {0}; + char *pattern4 = "1234"; + + ft_memset_pattern4(buf, pattern4, 16); + TEST_ASSERT_EQUAL_STRING("1234123412341234", buf); + + char buf1[10] = {0}; + ft_memset_pattern4(buf1, "1234", 9); + TEST_ASSERT_EQUAL_STRING("123412341", buf1); + + char buf2[11] = {0}; + ft_memset_pattern4(buf2, "1234", 10); + TEST_ASSERT_EQUAL_STRING("1234123412", buf2); + + char buf3[12] = {0}; + ft_memset_pattern4(buf3, "1234", 11); + TEST_ASSERT_EQUAL_STRING("12341234123", buf3); +} diff --git a/test_mini/libft/test/src/mem/test_ft_memswap.c b/test_mini/libft/test/src/mem/test_ft_memswap.c new file mode 100644 index 0000000..72c3402 --- /dev/null +++ b/test_mini/libft/test/src/mem/test_ft_memswap.c @@ -0,0 +1,41 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_memswap.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:38:27 by cacharle #+# #+# */ +/* Updated: 2020/02/13 04:18:14 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP(ft_memswap); + +TEST_SETUP(ft_memswap) +{} + +TEST_TEAR_DOWN(ft_memswap) +{} + +TEST(ft_memswap, basic) +{ + char buf1[32] = "bonjour"; + char buf2[32] = "aurevoir"; + ft_memswap(buf1, buf2, 32); + TEST_ASSERT_EQUAL_STRING("bonjour", buf2); + TEST_ASSERT_EQUAL_STRING("aurevoir", buf1); + ft_memswap(buf1, buf2, 3); + TEST_ASSERT_EQUAL_STRING("aurjour", buf2); + TEST_ASSERT_EQUAL_STRING("bonevoir", buf1); + ft_memswap(buf1, buf2, 0); + TEST_ASSERT_EQUAL_STRING("aurjour", buf2); + TEST_ASSERT_EQUAL_STRING("bonevoir", buf1); + int a = 1234567; + int b = 7654321; + ft_memswap(&a, &b, sizeof(int)); + TEST_ASSERT_EQUAL(7654321, a); + TEST_ASSERT_EQUAL(1234567, b); +} diff --git a/test_mini/libft/test/src/runner/test_runner_algo.c b/test_mini/libft/test/src/runner/test_runner_algo.c new file mode 100644 index 0000000..8873797 --- /dev/null +++ b/test_mini/libft/test/src/runner/test_runner_algo.c @@ -0,0 +1,59 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_runner_algo.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 21:25:52 by cacharle #+# #+# */ +/* Updated: 2020/02/13 21:37:15 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + + +TEST_GROUP_RUNNER(ft_bsearch) +{ + RUN_TEST_CASE(ft_bsearch, basic); +} + +TEST_GROUP_RUNNER(ft_compar_int) +{ + RUN_TEST_CASE(ft_compar_int, basic); +} + +TEST_GROUP_RUNNER(ft_heapsort) +{ + RUN_TEST_CASE(ft_heapsort, basic); +} + +TEST_GROUP_RUNNER(ft_is_set) +{ + RUN_TEST_CASE(ft_is_set, basic); +} + +TEST_GROUP_RUNNER(ft_lfind) +{ + RUN_TEST_CASE(ft_lfind, basic); +} + +TEST_GROUP_RUNNER(ft_lsearch) +{ + RUN_TEST_CASE(ft_lsearch, basic); +} + +TEST_GROUP_RUNNER(ft_mergesort) +{ + RUN_TEST_CASE(ft_mergesort, basic); +} + +TEST_GROUP_RUNNER(ft_qsort) +{ + RUN_TEST_CASE(ft_qsort, basic); +} + +TEST_GROUP_RUNNER(ft_reverse) +{ + RUN_TEST_CASE(ft_reverse, basic); +} diff --git a/test_mini/libft/test/src/runner/test_runner_ctype.c b/test_mini/libft/test/src/runner/test_runner_ctype.c new file mode 100644 index 0000000..7f9148e --- /dev/null +++ b/test_mini/libft/test/src/runner/test_runner_ctype.c @@ -0,0 +1,64 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_runner_ctype.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/12 22:44:43 by cacharle #+# #+# */ +/* Updated: 2020/02/12 23:13:02 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP_RUNNER(ft_isalnum) +{ + RUN_TEST_CASE(ft_isalnum, base); +} + +TEST_GROUP_RUNNER(ft_isalpha) +{ + RUN_TEST_CASE(ft_isalpha, base); +} + +TEST_GROUP_RUNNER(ft_isascii) +{ + RUN_TEST_CASE(ft_isascii, base); +} + +TEST_GROUP_RUNNER(ft_isblank) +{ + RUN_TEST_CASE(ft_isblank, base); +} + +TEST_GROUP_RUNNER(ft_isdigit) +{ + RUN_TEST_CASE(ft_isdigit, base); +} + +TEST_GROUP_RUNNER(ft_isprint) +{ + RUN_TEST_CASE(ft_isprint, base); +} + +TEST_GROUP_RUNNER(ft_isspace) +{ + RUN_TEST_CASE(ft_isspace, base); +} + +TEST_GROUP_RUNNER(ft_todigit) +{ + RUN_TEST_CASE(ft_todigit, base); +} + +TEST_GROUP_RUNNER(ft_tolower) +{ + RUN_TEST_CASE(ft_tolower, base); +} + +TEST_GROUP_RUNNER(ft_toupper) +{ + RUN_TEST_CASE(ft_toupper, base); +} + diff --git a/test_mini/libft/test/src/runner/test_runner_ht.c b/test_mini/libft/test/src/runner/test_runner_ht.c new file mode 100644 index 0000000..1563a72 --- /dev/null +++ b/test_mini/libft/test/src/runner/test_runner_ht.c @@ -0,0 +1,51 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_runner_ht.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/12 22:44:39 by cacharle #+# #+# */ +/* Updated: 2020/02/28 12:17:33 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP_RUNNER(ft_htentry_new) +{ + RUN_TEST_CASE(ft_htentry_new, basic); +} + +TEST_GROUP_RUNNER(ft_htnew) +{ + RUN_TEST_CASE(ft_htnew, segfault); + RUN_TEST_CASE(ft_htnew, error_null); + RUN_TEST_CASE(ft_htnew, happy_path); +} + +TEST_GROUP_RUNNER(ft_htget) +{ + RUN_TEST_CASE(ft_htget, segfault); + RUN_TEST_CASE(ft_htget, error_null); + RUN_TEST_CASE(ft_htget, basic); +} + +TEST_GROUP_RUNNER(ft_htset) +{ + RUN_TEST_CASE(ft_htset, segfault); + RUN_TEST_CASE(ft_htset, error_null); + RUN_TEST_CASE(ft_htset, happy_path); + RUN_TEST_CASE(ft_htset, reset); + RUN_TEST_CASE(ft_htset, collision); +} + +TEST_GROUP_RUNNER(ft_htdelone) +{ + RUN_TEST_CASE(ft_htdelone, basic); +} + +TEST_GROUP_RUNNER(ft_htdestroy) +{ + RUN_TEST_CASE(ft_htdestroy, basic); +} diff --git a/test_mini/libft/test/src/runner/test_runner_lst.c b/test_mini/libft/test/src/runner/test_runner_lst.c new file mode 100644 index 0000000..5ae9557 --- /dev/null +++ b/test_mini/libft/test/src/runner/test_runner_lst.c @@ -0,0 +1,103 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_runner_lst.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/15 03:54:05 by cacharle #+# #+# */ +/* Updated: 2020/02/17 03:24:41 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP_RUNNER(ft_lstpush_back) +{ + RUN_TEST_CASE(ft_lstpush_back, basic); +} + +TEST_GROUP_RUNNER(ft_lstpush_front) +{ + RUN_TEST_CASE(ft_lstpush_front, basic); +} + +TEST_GROUP_RUNNER(ft_lstbsearch) +{ + RUN_TEST_CASE(ft_lstbsearch, basic); +} + +TEST_GROUP_RUNNER(ft_lstlsearch) +{ + RUN_TEST_CASE(ft_lstlsearch, basic); +} + +TEST_GROUP_RUNNER(ft_lstlfind) +{ + RUN_TEST_CASE(ft_lstlfind, basic); +} + +TEST_GROUP_RUNNER(ft_lstdestroy) +{ + RUN_TEST_CASE(ft_lstdestroy, basic); +} + +TEST_GROUP_RUNNER(ft_lstdelone) +{ + RUN_TEST_CASE(ft_lstdelone, basic); +} + +TEST_GROUP_RUNNER(ft_lstiter) +{ + RUN_TEST_CASE(ft_lstiter, basic); +} + +TEST_GROUP_RUNNER(ft_lstlast) +{ + RUN_TEST_CASE(ft_lstlast, basic); +} + +TEST_GROUP_RUNNER(ft_lstmap) +{ + RUN_TEST_CASE(ft_lstmap, basic); +} + +TEST_GROUP_RUNNER(ft_lstnew) +{ + RUN_TEST_CASE(ft_lstnew, basic); +} + +TEST_GROUP_RUNNER(ft_lstpop_front) +{ + RUN_TEST_CASE(ft_lstpop_front, basic); +} + +TEST_GROUP_RUNNER(ft_lstremove_if) +{ + RUN_TEST_CASE(ft_lstremove_if, basic); +} + +TEST_GROUP_RUNNER(ft_lstreverse) +{ + RUN_TEST_CASE(ft_lstreverse, basic); +} + +TEST_GROUP_RUNNER(ft_lstreverse_ret) +{ + RUN_TEST_CASE(ft_lstreverse_ret, basic); +} + +TEST_GROUP_RUNNER(ft_lstsize) +{ + RUN_TEST_CASE(ft_lstsize, basic); +} + +TEST_GROUP_RUNNER(ft_lstsort) +{ + RUN_TEST_CASE(ft_lstsort, basic); +} + +TEST_GROUP_RUNNER(ft_lstsorted_merge) +{ + RUN_TEST_CASE(ft_lstsorted_merge, basic); +} diff --git a/test_mini/libft/test/src/runner/test_runner_mem.c b/test_mini/libft/test/src/runner/test_runner_mem.c new file mode 100644 index 0000000..093d064 --- /dev/null +++ b/test_mini/libft/test/src/runner/test_runner_mem.c @@ -0,0 +1,69 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_runner_mem.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: cacharle <marvin@42.fr> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/02/13 03:36:16 by cacharle #+# #+# */ +/* Updated: 2020/02/13 20:40:24 by cacharle ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft_test.h" + +TEST_GROUP_RUNNER(ft_bzero) +{ + RUN_TEST_CASE(ft_bzero, basic); +} + +TEST_GROUP_RUNNER(ft_calloc) +{ + RUN_TEST_CASE(ft_calloc, basic); +} + +TEST_GROUP_RUNNER(ft_memccpy) +{ + RUN_TEST_CASE(ft_memccpy, basic); +} + +TEST_GROUP_RUNNER(ft_memchr) +{ + RUN_TEST_CASE(ft_memchr, basic); +} + +TEST_GROUP_RUNNER(ft_memcmp) +{ + RUN_TEST_CASE(ft_memcmp, basic); +} + +TEST_GROUP_RUNNER(ft_memcpy) +{ + RUN_TEST_CASE(ft_memcpy, basic); +} + +TEST_GROUP_RUNNER(ft_memmem) +{ + RUN_TEST_CASE(ft_memmem, basic); + RUN_TEST_CASE(ft_memmem, invalid_len); +} + +TEST_GROUP_RUNNER(ft_memmove) +{ + RUN_TEST_CASE(ft_memmove, basic); +} + +TEST_GROUP_RUNNER(ft_memset) +{ + RUN_TEST_CASE(ft_memset, basic); +} + +TEST_GROUP_RUNNER(ft_memset_pattern4) +{ + RUN_TEST_CASE(ft_memset_pattern4, basic); +} + +TEST_GROUP_RUNNER(ft_memswap) +{ + RUN_TEST_CASE(ft_memswap, basic); +} diff --git a/test_mini/libft/test/src/runner/test_runner_str.c b/test_mini/libft/test/src/runner/test_runner_str.c new file mode 100644 index 0000000..3d829ad --- /dev/null +++ b/test_mini/libft/test/src/runner/test_runner_str.c @@ -0,0 +1,6 @@ +#include "libft_test.h" + +TEST_GROUP_RUNNER(ft_strlen) +{ + RUN_TEST_CASE(ft_strlen, basic); +} diff --git a/test_mini/libft/test/src/runner/test_runner_vec.c b/test_mini/libft/test/src/runner/test_runner_vec.c new file mode 100644 index 0000000..e0d3008 --- /dev/null +++ b/test_mini/libft/test/src/runner/test_runner_vec.c @@ -0,0 +1,50 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_runner_vec.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 19:55:53 by charles #+# #+# */ +/* Updated: 2020/04/01 22:49:28 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); +} + diff --git a/test_mini/libft/test/src/str/test_ft_strlen.c b/test_mini/libft/test/src/str/test_ft_strlen.c new file mode 100644 index 0000000..f251fc6 --- /dev/null +++ b/test_mini/libft/test/src/str/test_ft_strlen.c @@ -0,0 +1,24 @@ +#include "libft_test.h" + +TEST_GROUP(ft_strlen); + +TEST_SETUP(ft_strlen) +{} + +TEST_TEAR_DOWN(ft_strlen) +{} + +#define TEST_ASSERT_FT_STRLEN(str) do { \ + if (strlen(str) != ft_strlen(str)) \ + TEST_FAIL(); \ +} while(0); + +TEST(ft_strlen, basic) +{ + TEST_ASSERT_FT_STRLEN(""); + TEST_ASSERT_FT_STRLEN("bonjour"); + TEST_ASSERT_FT_STRLEN("1"); + TEST_ASSERT_FT_STRLEN("asodifuaosidjoiasjdfoijasklfqwkberkjqwerkjqwlkenrmnqwerjkqwehfakjs"); + TEST_ASSERT_FT_STRLEN("im\0hidden"); + TEST_ASSERT_FT_STRLEN("987987\xff\xee\xaasdfioxcv"); +} diff --git a/test_mini/libft/test/src/vec/test_ft_vecdestroy.c b/test_mini/libft/test/src/vec/test_ft_vecdestroy.c new file mode 100644 index 0000000..4f121dc --- /dev/null +++ b/test_mini/libft/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_mini/libft/test/src/vec/test_ft_vecgrow.c b/test_mini/libft/test/src/vec/test_ft_vecgrow.c new file mode 100644 index 0000000..0b40390 --- /dev/null +++ b/test_mini/libft/test/src/vec/test_ft_vecgrow.c @@ -0,0 +1,47 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* test_ft_vecgrow.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: charles <charles.cabergs@gmail.com> +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2020/04/01 19:41:59 by charles #+# #+# */ +/* Updated: 2020/04/01 21:17:13 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); + TEST_ASSERT_NOT_NULL(ft_vecgrow(vec)); + TEST_ASSERT_EQUAL(2, vec->capacity); + TEST_ASSERT_EQUAL(0, vec->size); + TEST_ASSERT_NOT_NULL(ft_vecgrow(vec)); + TEST_ASSERT_EQUAL(3, vec->capacity); + TEST_ASSERT_EQUAL(0, vec->size); + TEST_ASSERT_NOT_NULL(ft_vecgrow(vec)); + TEST_ASSERT_EQUAL(4, vec->capacity); + TEST_ASSERT_EQUAL(0, vec->size); + TEST_ASSERT_NOT_NULL(ft_vecgrow(vec)); + TEST_ASSERT_EQUAL(6, vec->capacity); + TEST_ASSERT_EQUAL(0, vec->size); + TEST_ASSERT_NOT_NULL(ft_vecgrow(vec)); + TEST_ASSERT_EQUAL(9, vec->capacity); + TEST_ASSERT_EQUAL(0, vec->size); + TEST_ASSERT_NOT_NULL(ft_vecgrow(vec)); + TEST_ASSERT_EQUAL(13, vec->capacity); + TEST_ASSERT_EQUAL(0, vec->size); + + ft_vecdestroy(vec, NULL); +} diff --git a/test_mini/libft/test/src/vec/test_ft_veciter.c b/test_mini/libft/test/src/vec/test_ft_veciter.c new file mode 100644 index 0000000..fac28c1 --- /dev/null +++ b/test_mini/libft/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_mini/libft/test/src/vec/test_ft_vecnew.c b/test_mini/libft/test/src/vec/test_ft_vecnew.c new file mode 100644 index 0000000..579a182 --- /dev/null +++ b/test_mini/libft/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_mini/libft/test/src/vec/test_ft_vecpop.c b/test_mini/libft/test/src/vec/test_ft_vecpop.c new file mode 100644 index 0000000..2ee96d2 --- /dev/null +++ b/test_mini/libft/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_mini/libft/test/src/vec/test_ft_vecpush.c b/test_mini/libft/test/src/vec/test_ft_vecpush.c new file mode 100644 index 0000000..05efc7a --- /dev/null +++ b/test_mini/libft/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_mini/libft/test/src/vec/test_ft_vecremove.c b/test_mini/libft/test/src/vec/test_ft_vecremove.c new file mode 100644 index 0000000..8cecc19 --- /dev/null +++ b/test_mini/libft/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); +} |