From 579a26f5593039ffbbd1a81e45ecf0ef8797cb5d Mon Sep 17 00:00:00 2001 From: nass1pro Date: Tue, 9 Jun 2020 19:48:34 +0200 Subject: add lexer add single quote --- test_mini/libft/test/src/algo/test_ft_bsearch.c | 55 ++++++++++ test_mini/libft/test/src/algo/test_ft_compar_int.c | 20 ++++ test_mini/libft/test/src/algo/test_ft_heapsort.c | 27 +++++ test_mini/libft/test/src/algo/test_ft_is_set.c | 23 +++++ test_mini/libft/test/src/algo/test_ft_lfind.c | 38 +++++++ test_mini/libft/test/src/algo/test_ft_lsearch.c | 52 ++++++++++ test_mini/libft/test/src/algo/test_ft_mergesort.c | 26 +++++ test_mini/libft/test/src/algo/test_ft_qsort.c | 26 +++++ test_mini/libft/test/src/algo/test_ft_reverse.c | 19 ++++ test_mini/libft/test/src/ctype/test_ft_isalnum.c | 15 +++ test_mini/libft/test/src/ctype/test_ft_isalpha.c | 15 +++ test_mini/libft/test/src/ctype/test_ft_isascii.c | 15 +++ test_mini/libft/test/src/ctype/test_ft_isblank.c | 15 +++ test_mini/libft/test/src/ctype/test_ft_isdigit.c | 15 +++ test_mini/libft/test/src/ctype/test_ft_isprint.c | 15 +++ test_mini/libft/test/src/ctype/test_ft_isspace.c | 15 +++ test_mini/libft/test/src/ctype/test_ft_todigit.c | 20 ++++ test_mini/libft/test/src/ctype/test_ft_tolower.c | 15 +++ test_mini/libft/test/src/ctype/test_ft_toupper.c | 15 +++ test_mini/libft/test/src/ht/test_ft_htdelone.c | 68 ++++++++++++ test_mini/libft/test/src/ht/test_ft_htdestroy.c | 38 +++++++ test_mini/libft/test/src/ht/test_ft_htget.c | 114 +++++++++++++++++++++ test_mini/libft/test/src/ht/test_ft_hthash.c | 0 test_mini/libft/test/src/ht/test_ft_htnew.c | 48 +++++++++ test_mini/libft/test/src/ht/test_ft_htset.c | 100 ++++++++++++++++++ test_mini/libft/test/src/ht/test_ftht_entry_new.c | 43 ++++++++ test_mini/libft/test/src/lst/test_ft_lstbsearch.c | 37 +++++++ test_mini/libft/test/src/lst/test_ft_lstdelone.c | 26 +++++ test_mini/libft/test/src/lst/test_ft_lstdestroy.c | 14 +++ test_mini/libft/test/src/lst/test_ft_lstiter.c | 52 ++++++++++ test_mini/libft/test/src/lst/test_ft_lstlast.c | 29 ++++++ test_mini/libft/test/src/lst/test_ft_lstlfind.c | 55 ++++++++++ test_mini/libft/test/src/lst/test_ft_lstlsearch.c | 55 ++++++++++ test_mini/libft/test/src/lst/test_ft_lstmap.c | 82 +++++++++++++++ test_mini/libft/test/src/lst/test_ft_lstnew.c | 25 +++++ .../libft/test/src/lst/test_ft_lstpop_front.c | 31 ++++++ .../libft/test/src/lst/test_ft_lstpush_back.c | 41 ++++++++ .../libft/test/src/lst/test_ft_lstpush_front.c | 41 ++++++++ .../libft/test/src/lst/test_ft_lstremove_if.c | 70 +++++++++++++ test_mini/libft/test/src/lst/test_ft_lstreverse.c | 45 ++++++++ .../libft/test/src/lst/test_ft_lstreverse_ret.c | 45 ++++++++ test_mini/libft/test/src/lst/test_ft_lstsize.c | 37 +++++++ test_mini/libft/test/src/lst/test_ft_lstsort.c | 38 +++++++ .../libft/test/src/lst/test_ft_lstsorted_merge.c | 40 ++++++++ test_mini/libft/test/src/main.c | 85 +++++++++++++++ test_mini/libft/test/src/mem/test_ft_bzero.c | 30 ++++++ test_mini/libft/test/src/mem/test_ft_calloc.c | 33 ++++++ test_mini/libft/test/src/mem/test_ft_memccpy.c | 45 ++++++++ test_mini/libft/test/src/mem/test_ft_memchr.c | 35 +++++++ test_mini/libft/test/src/mem/test_ft_memcmp.c | 42 ++++++++ test_mini/libft/test/src/mem/test_ft_memcpy.c | 47 +++++++++ test_mini/libft/test/src/mem/test_ft_memmem.c | 65 ++++++++++++ test_mini/libft/test/src/mem/test_ft_memmove.c | 39 +++++++ test_mini/libft/test/src/mem/test_ft_memset.c | 42 ++++++++ .../libft/test/src/mem/test_ft_memset_pattern4.c | 42 ++++++++ test_mini/libft/test/src/mem/test_ft_memswap.c | 41 ++++++++ test_mini/libft/test/src/runner/test_runner_algo.c | 59 +++++++++++ .../libft/test/src/runner/test_runner_ctype.c | 64 ++++++++++++ test_mini/libft/test/src/runner/test_runner_ht.c | 51 +++++++++ test_mini/libft/test/src/runner/test_runner_lst.c | 103 +++++++++++++++++++ test_mini/libft/test/src/runner/test_runner_mem.c | 69 +++++++++++++ test_mini/libft/test/src/runner/test_runner_str.c | 6 ++ test_mini/libft/test/src/runner/test_runner_vec.c | 50 +++++++++ test_mini/libft/test/src/str/test_ft_strlen.c | 24 +++++ test_mini/libft/test/src/vec/test_ft_vecdestroy.c | 26 +++++ test_mini/libft/test/src/vec/test_ft_vecgrow.c | 47 +++++++++ test_mini/libft/test/src/vec/test_ft_veciter.c | 52 ++++++++++ test_mini/libft/test/src/vec/test_ft_vecnew.c | 47 +++++++++ test_mini/libft/test/src/vec/test_ft_vecpop.c | 47 +++++++++ test_mini/libft/test/src/vec/test_ft_vecpush.c | 57 +++++++++++ test_mini/libft/test/src/vec/test_ft_vecremove.c | 64 ++++++++++++ 71 files changed, 2927 insertions(+) create mode 100644 test_mini/libft/test/src/algo/test_ft_bsearch.c create mode 100644 test_mini/libft/test/src/algo/test_ft_compar_int.c create mode 100644 test_mini/libft/test/src/algo/test_ft_heapsort.c create mode 100644 test_mini/libft/test/src/algo/test_ft_is_set.c create mode 100644 test_mini/libft/test/src/algo/test_ft_lfind.c create mode 100644 test_mini/libft/test/src/algo/test_ft_lsearch.c create mode 100644 test_mini/libft/test/src/algo/test_ft_mergesort.c create mode 100644 test_mini/libft/test/src/algo/test_ft_qsort.c create mode 100644 test_mini/libft/test/src/algo/test_ft_reverse.c create mode 100644 test_mini/libft/test/src/ctype/test_ft_isalnum.c create mode 100644 test_mini/libft/test/src/ctype/test_ft_isalpha.c create mode 100644 test_mini/libft/test/src/ctype/test_ft_isascii.c create mode 100644 test_mini/libft/test/src/ctype/test_ft_isblank.c create mode 100644 test_mini/libft/test/src/ctype/test_ft_isdigit.c create mode 100644 test_mini/libft/test/src/ctype/test_ft_isprint.c create mode 100644 test_mini/libft/test/src/ctype/test_ft_isspace.c create mode 100644 test_mini/libft/test/src/ctype/test_ft_todigit.c create mode 100644 test_mini/libft/test/src/ctype/test_ft_tolower.c create mode 100644 test_mini/libft/test/src/ctype/test_ft_toupper.c create mode 100644 test_mini/libft/test/src/ht/test_ft_htdelone.c create mode 100644 test_mini/libft/test/src/ht/test_ft_htdestroy.c create mode 100644 test_mini/libft/test/src/ht/test_ft_htget.c create mode 100644 test_mini/libft/test/src/ht/test_ft_hthash.c create mode 100644 test_mini/libft/test/src/ht/test_ft_htnew.c create mode 100644 test_mini/libft/test/src/ht/test_ft_htset.c create mode 100644 test_mini/libft/test/src/ht/test_ftht_entry_new.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstbsearch.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstdelone.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstdestroy.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstiter.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstlast.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstlfind.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstlsearch.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstmap.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstnew.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstpop_front.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstpush_back.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstpush_front.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstremove_if.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstreverse.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstreverse_ret.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstsize.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstsort.c create mode 100644 test_mini/libft/test/src/lst/test_ft_lstsorted_merge.c create mode 100644 test_mini/libft/test/src/main.c create mode 100644 test_mini/libft/test/src/mem/test_ft_bzero.c create mode 100644 test_mini/libft/test/src/mem/test_ft_calloc.c create mode 100644 test_mini/libft/test/src/mem/test_ft_memccpy.c create mode 100644 test_mini/libft/test/src/mem/test_ft_memchr.c create mode 100644 test_mini/libft/test/src/mem/test_ft_memcmp.c create mode 100644 test_mini/libft/test/src/mem/test_ft_memcpy.c create mode 100644 test_mini/libft/test/src/mem/test_ft_memmem.c create mode 100644 test_mini/libft/test/src/mem/test_ft_memmove.c create mode 100644 test_mini/libft/test/src/mem/test_ft_memset.c create mode 100644 test_mini/libft/test/src/mem/test_ft_memset_pattern4.c create mode 100644 test_mini/libft/test/src/mem/test_ft_memswap.c create mode 100644 test_mini/libft/test/src/runner/test_runner_algo.c create mode 100644 test_mini/libft/test/src/runner/test_runner_ctype.c create mode 100644 test_mini/libft/test/src/runner/test_runner_ht.c create mode 100644 test_mini/libft/test/src/runner/test_runner_lst.c create mode 100644 test_mini/libft/test/src/runner/test_runner_mem.c create mode 100644 test_mini/libft/test/src/runner/test_runner_str.c create mode 100644 test_mini/libft/test/src/runner/test_runner_vec.c create mode 100644 test_mini/libft/test/src/str/test_ft_strlen.c create mode 100644 test_mini/libft/test/src/vec/test_ft_vecdestroy.c create mode 100644 test_mini/libft/test/src/vec/test_ft_vecgrow.c create mode 100644 test_mini/libft/test/src/vec/test_ft_veciter.c create mode 100644 test_mini/libft/test/src/vec/test_ft_vecnew.c create mode 100644 test_mini/libft/test/src/vec/test_ft_vecpop.c create mode 100644 test_mini/libft/test/src/vec/test_ft_vecpush.c create mode 100644 test_mini/libft/test/src/vec/test_ft_vecremove.c (limited to 'test_mini/libft/test/src') 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 +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* 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 +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* 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 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 +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* 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 +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* 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 +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* 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 +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* 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 +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* 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); +