diff --git a/Makefile b/Makefile index 8bd368c..951b024 100644 --- a/Makefile +++ b/Makefile @@ -10,7 +10,13 @@ LIBFT_DIR = ./libft SRC = $(SRC_DIR)/main.c \ $(SRC_DIR)/check_args.c \ $(SRC_DIR)/generate_stack.c \ - $(SRC_DIR)/nano_sort.c \ + $(SRC_DIR)/sort/sort.c \ + $(SRC_DIR)/sort/micro_sort.c \ + $(SRC_DIR)/sort/nano_sort.c \ + $(SRC_DIR)/stack_operations/push.c \ + $(SRC_DIR)/stack_operations/swap.c \ + $(SRC_DIR)/stack_operations/rotate.c \ + $(SRC_DIR)/stack_operations/ft_lst_before.c \ $(SRC_DIR)/utils/exit_with_error.c OBJ = $(patsubst $(SRC_DIR)/%.c, $(BUILD_DIR)/%.o, $(SRC)) DEP = $(patsubst $(SRC_DIR)/%.c, $(BUILD_DIR)/%.d, $(SRC)) @@ -19,7 +25,12 @@ INCLUDE = -I $(INC_DIR) CXXFLAGS = -std=c++20 -Wall -Wextra -Werror TEST_DIR = ./test -TEST_SRC = $(TEST_DIR)/test_is_invalid_argument.cpp +TEST_SRC = $(TEST_DIR)/test_check_args.cpp \ + $(TEST_DIR)/test_push_stack.cpp \ + $(TEST_DIR)/test_reverse_rotate_stack.cpp \ + $(TEST_DIR)/test_rotate_stack.cpp \ + $(TEST_DIR)/test_swap_stack.cpp \ + $(TEST_DIR)/test_sort.cpp TEST_OBJ = $(filter-out $(BUILD_DIR)/main.o, $(patsubst $(SRC_DIR)/%.c, $(BUILD_DIR)/%.o, $(SRC))) GTEST_VERSION = 1.14.0 GTEST_DIR = ./test/gtest diff --git a/include/push_swap.h b/include/push_swap.h index 3a2f4c8..4d88759 100644 --- a/include/push_swap.h +++ b/include/push_swap.h @@ -6,7 +6,7 @@ /* By: reasuke +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/01/10 12:37:54 by reasuke #+# #+# */ -/* Updated: 2024/01/15 13:19:05 by reasuke ### ########.fr */ +/* Updated: 2024/01/17 16:22:03 by reasuke ### ########.fr */ /* */ /* ************************************************************************** */ @@ -27,7 +27,21 @@ int check_args(int argc, char **argv); t_list *generate_stack(int argc, char **argv); -void nano_sort(t_list *stack, int argc); +void sort(t_list **stack_a, t_list **stack_b, int num_a); +void nano_sort(t_list **stack, int num_a); +void micro_sort(t_list **stack_a, t_list **stack_b, int num_a); + +void operate_sa(t_list **stack_a); +void operate_sb(t_list **stack_b); +void operate_ra(t_list **stack_a); +void operate_rra(t_list **stack_a); +void operate_pa(t_list **stack_b, t_list **stack_a); +void operate_pb(t_list **stack_a, t_list **stack_b); +void push_stack(t_list **stack_1, t_list **stack_2); +void swap_stack(t_list **stack); +void rotate_stack(t_list **stack); +void reverse_rotate_stack(t_list **stack); +t_list *ft_lst_before(t_list *lst, t_list *trg); void exit_with_error(void); diff --git a/src/main.c b/src/main.c index 6d5c0cc..df78444 100644 --- a/src/main.c +++ b/src/main.c @@ -6,7 +6,7 @@ /* By: reasuke +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/01/10 12:37:36 by reasuke #+# #+# */ -/* Updated: 2024/01/15 13:04:27 by reasuke ### ########.fr */ +/* Updated: 2024/01/16 13:13:30 by reasuke ### ########.fr */ /* */ /* ************************************************************************** */ @@ -26,7 +26,7 @@ void destructor(void) void put_void(void *content) { - puts(content); + ft_printf("%d\n", *(int *)content); } #endif @@ -34,11 +34,12 @@ void put_void(void *content) int main(int argc, char **argv) { t_list *stack_a; + t_list *stack_b; check_args(argc, argv); stack_a = generate_stack(argc, argv); - if (argc < 5) - nano_sort(stack_a, argc); + stack_b = NULL; + sort(&stack_a, &stack_b, argc - 1); ft_lstclear(&stack_a, free); return (0); } diff --git a/src/sort/micro_sort.c b/src/sort/micro_sort.c new file mode 100644 index 0000000..9ecbab9 --- /dev/null +++ b/src/sort/micro_sort.c @@ -0,0 +1,81 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* micro_sort.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: reasuke +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/01/15 16:32:27 by reasuke #+# #+# */ +/* Updated: 2024/01/17 17:43:30 by reasuke ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "push_swap.h" + +static int _first(t_list **stack) +{ + return (*(int *)(*stack)->content); +} + +static int _second(t_list **stack) +{ + return (*(int *)(*stack)->next->content); +} + +static void _handle_4(t_list **stack_a, t_list **stack_b) +{ + operate_pb(stack_a, stack_b); + nano_sort(stack_a, 3); + if (_first(stack_b) == 1) + operate_pa(stack_b, stack_a); + else if (_first(stack_b) == 2) + { + operate_pa(stack_b, stack_a); + operate_sa(stack_a); + } + else if (_first(stack_b) == 3) + { + operate_rra(stack_a); + operate_pa(stack_b, stack_a); + operate_ra(stack_a); + operate_ra(stack_a); + } + else if (_first(stack_b) == 4) + { + operate_pa(stack_b, stack_a); + operate_ra(stack_a); + } +} + +static void _handle_5(t_list **stack_a, t_list **stack_b) +{ + operate_pb(stack_a, stack_b); + operate_pb(stack_a, stack_b); + nano_sort(stack_a, 3); + if (_first(stack_b) < _second(stack_b)) + operate_sb(stack_b); + if (_first(stack_b) == 5) + { + operate_pa(stack_b, stack_a); + operate_rra(stack_a); + } + else + { + while (_first(stack_a) != _first(stack_b) + 1) + operate_ra(stack_a); + operate_pa(stack_b, stack_a); + } + while (_first(stack_a) != _first(stack_b) + 1) + operate_rra(stack_a); + operate_pa(stack_b, stack_a); + while (_first(stack_a) != 1) + operate_rra(stack_a); +} + +void micro_sort(t_list **stack_a, t_list **stack_b, int num_a) +{ + if (num_a == 4) + _handle_4(stack_a, stack_b); + else if (num_a == 5) + _handle_5(stack_a, stack_b); +} diff --git a/src/nano_sort.c b/src/sort/nano_sort.c similarity index 50% rename from src/nano_sort.c rename to src/sort/nano_sort.c index 4bf9fc0..e9ee64d 100644 --- a/src/nano_sort.c +++ b/src/sort/nano_sort.c @@ -6,57 +6,57 @@ /* By: reasuke +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/01/12 15:58:22 by reasuke #+# #+# */ -/* Updated: 2024/01/15 12:58:12 by reasuke ### ########.fr */ +/* Updated: 2024/01/17 16:04:38 by reasuke ### ########.fr */ /* */ /* ************************************************************************** */ #include "push_swap.h" -static void _handle_2(t_list *stack) +static void _handle_2(t_list **stack) { int first; int second; - first = *(int *)stack->content; - second = *(int *)stack->next->content; + first = *(int *)(*stack)->content; + second = *(int *)(*stack)->next->content; if (first > second) + { + swap_stack(stack); ft_putendl_fd("sa", STDOUT_FILENO); + } } -static void _handel_3(t_list *stack) +static void _handle_3(t_list **stack) { int first; int second; int third; - first = *(int *)stack->content; - second = *(int *)stack->next->content; - third = *(int *)stack->next->next->content; - if (first == 2 && second == 1 && third == 3) - ft_putendl_fd("sa", STDOUT_FILENO); - else if (first == 3 && second == 2 && third == 1) + first = *(int *)(*stack)->content; + second = *(int *)(*stack)->next->content; + third = *(int *)(*stack)->next->next->content; + if (second < first && first < third) + operate_sa(stack); + else if (third < second && second < first) { - ft_putendl_fd("sa", STDOUT_FILENO); - ft_putendl_fd("rra", STDOUT_FILENO); + operate_sa(stack); + operate_rra(stack); } - else if (first == 3 && second == 1 && third == 2) - ft_putendl_fd("ra", STDOUT_FILENO); - else if (first == 1 && second == 3 && third == 2) + else if (second < third && third < first) + operate_ra(stack); + else if (first < third && third < second) { - ft_putendl_fd("sa", STDOUT_FILENO); - ft_putendl_fd("ra", STDOUT_FILENO); + operate_sa(stack); + operate_ra(stack); } - else if (first == 2 && second == 3 && third == 1) - ft_putendl_fd("rra", STDOUT_FILENO); + else if (third < first && first < second) + operate_rra(stack); } -void nano_sort(t_list *stack, int argc) +void nano_sort(t_list **stack, int num_a) { - int num_of_element; - - num_of_element = argc - 1; - if (num_of_element == 2) + if (num_a == 2) _handle_2(stack); - else if (num_of_element == 3) - _handel_3(stack); + else if (num_a == 3) + _handle_3(stack); } diff --git a/src/sort/sort.c b/src/sort/sort.c new file mode 100644 index 0000000..b44876c --- /dev/null +++ b/src/sort/sort.c @@ -0,0 +1,21 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* sort.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: reasuke +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/01/15 15:10:35 by reasuke #+# #+# */ +/* Updated: 2024/01/17 16:08:05 by reasuke ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "push_swap.h" + +void sort(t_list **stack_a, t_list **stack_b, int num_a) +{ + if (num_a <= 3) + nano_sort(stack_a, num_a); + else if (num_a <= 5) + micro_sort(stack_a, stack_b, num_a); +} diff --git a/src/stack_operations/ft_lst_before.c b/src/stack_operations/ft_lst_before.c new file mode 100644 index 0000000..fd8ef57 --- /dev/null +++ b/src/stack_operations/ft_lst_before.c @@ -0,0 +1,27 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lst_before.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: reasuke +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/01/15 16:54:29 by reasuke #+# #+# */ +/* Updated: 2024/01/15 16:54:44 by reasuke ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "push_swap.h" + +t_list *ft_lst_before(t_list *lst, t_list *trg) +{ + t_list *before; + + if (!lst) + return (NULL); + before = lst; + while (before->next && before->next != trg) + before = before->next; + if (before->next != trg) + return (NULL); + return (before); +} diff --git a/src/stack_operations/push.c b/src/stack_operations/push.c new file mode 100644 index 0000000..fd163ef --- /dev/null +++ b/src/stack_operations/push.c @@ -0,0 +1,37 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* push.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: reasuke +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/01/15 15:56:53 by reasuke #+# #+# */ +/* Updated: 2024/01/15 17:02:11 by reasuke ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "push_swap.h" + +void push_stack(t_list **stack_1, t_list **stack_2) +{ + t_list *stack_1_first; + + if (!*stack_1) + return ; + stack_1_first = *stack_1; + *stack_1 = (*stack_1)->next; + stack_1_first->next = NULL; + ft_lstadd_front(stack_2, stack_1_first); +} + +void operate_pa(t_list **stack_b, t_list **stack_a) +{ + push_stack(stack_b, stack_a); + ft_putendl_fd("pa", STDOUT_FILENO); +} + +void operate_pb(t_list **stack_a, t_list **stack_b) +{ + push_stack(stack_a, stack_b); + ft_putendl_fd("pb", STDOUT_FILENO); +} diff --git a/src/stack_operations/rotate.c b/src/stack_operations/rotate.c new file mode 100644 index 0000000..22e27a8 --- /dev/null +++ b/src/stack_operations/rotate.c @@ -0,0 +1,53 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* rotate.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: reasuke +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/01/15 14:05:46 by reasuke #+# #+# */ +/* Updated: 2024/01/15 16:56:39 by reasuke ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "push_swap.h" + +void rotate_stack(t_list **stack) +{ + t_list *second; + t_list *last; + + if (ft_lstsize(*stack) < 2) + return ; + second = (*stack)->next; + last = ft_lstlast(*stack); + last->next = *stack; + (*stack)->next = NULL; + *stack = second; +} + +void reverse_rotate_stack(t_list **stack) +{ + t_list *before_last; + t_list *last; + + if (ft_lstsize(*stack) < 2) + return ; + last = ft_lstlast(*stack); + before_last = ft_lst_before(*stack, last); + before_last->next = NULL; + last->next = *stack; + *stack = last; +} + +void operate_ra(t_list **stack_a) +{ + rotate_stack(stack_a); + ft_putendl_fd("ra", STDOUT_FILENO); +} + +void operate_rra(t_list **stack_a) +{ + reverse_rotate_stack(stack_a); + ft_putendl_fd("rra", STDOUT_FILENO); +} diff --git a/src/stack_operations/swap.c b/src/stack_operations/swap.c new file mode 100644 index 0000000..42a30df --- /dev/null +++ b/src/stack_operations/swap.c @@ -0,0 +1,37 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* swap.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: reasuke +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/01/15 13:28:54 by reasuke #+# #+# */ +/* Updated: 2024/01/17 16:21:26 by reasuke ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "push_swap.h" + +void swap_stack(t_list **stack) +{ + t_list *second; + + if (ft_lstsize(*stack) < 2) + return ; + second = (*stack)->next; + (*stack)->next = (*stack)->next->next; + second->next = *stack; + *stack = second; +} + +void operate_sa(t_list **stack_a) +{ + swap_stack(stack_a); + ft_putendl_fd("sa", STDOUT_FILENO); +} + +void operate_sb(t_list **stack_b) +{ + swap_stack(stack_b); + ft_putendl_fd("sb", STDOUT_FILENO); +} diff --git a/test/test_is_invalid_argument.cpp b/test/test_check_args.cpp similarity index 100% rename from test/test_is_invalid_argument.cpp rename to test/test_check_args.cpp diff --git a/test/test_ft_lst_before.cpp b/test/test_ft_lst_before.cpp new file mode 100644 index 0000000..78e79b1 --- /dev/null +++ b/test/test_ft_lst_before.cpp @@ -0,0 +1,47 @@ +// Copyright 2024, reasuke + +#include "gtest/gtest.h" + +extern "C" { + #include "push_swap.h" +} + +static void *convert_const_char_to_void(const char *str) { + const void *const_element = static_cast(str); + void *element = const_cast(const_element); + + return element; +} + +TEST(ft_lst_before, test) { + t_list *stack; + void *element0 = convert_const_char_to_void("0"); + void *element1 = convert_const_char_to_void("1"); + void *element2 = convert_const_char_to_void("2"); + void *element3 = convert_const_char_to_void("3"); + void *element4 = convert_const_char_to_void("4"); + t_list *lst0 = ft_lstnew(element0); + t_list *lst1 = ft_lstnew(element1); + t_list *lst2 = ft_lstnew(element2); + t_list *lst3 = ft_lstnew(element3); + t_list *lst4 = ft_lstnew(element4); + t_list *dummy = ft_lstnew(convert_const_char_to_void("dummy")); + + + stack = NULL; + ft_lstadd_back(&stack, lst0); + ft_lstadd_back(&stack, lst1); + ft_lstadd_back(&stack, lst2); + ft_lstadd_back(&stack, lst3); + ft_lstadd_back(&stack, lst4); + + // not found + EXPECT_EQ(ft_lst_before(stack, lst0), nullptr); + EXPECT_EQ(ft_lst_before(stack, dummy), nullptr); + + // found + EXPECT_EQ(ft_lst_before(stack, lst1)->content, element0); + EXPECT_EQ(ft_lst_before(stack, lst2)->content, element1); + EXPECT_EQ(ft_lst_before(stack, lst3)->content, element2); + EXPECT_EQ(ft_lst_before(stack, lst4)->content, element3); +} diff --git a/test/test_push_stack.cpp b/test/test_push_stack.cpp new file mode 100644 index 0000000..66a29a1 --- /dev/null +++ b/test/test_push_stack.cpp @@ -0,0 +1,101 @@ +// Copyright 2024, reasuke + +#include "gtest/gtest.h" + +extern "C" { + #include "push_swap.h" +} + +static void *convert_const_char_to_void(const char *str) { + const void *const_element = static_cast(str); + void *element = const_cast(const_element); + + return element; +} + +TEST(push_stack, noElements) { + t_list *stack_a; + t_list *stack_b; + + stack_a = NULL; + stack_b = NULL; + + push_stack(&stack_a, &stack_b); + + EXPECT_EQ(stack_a, nullptr); + EXPECT_EQ(stack_b, nullptr); +} + +TEST(push_stack, nullPush) { + t_list *stack_a; + t_list *stack_b; + void *element_10 = convert_const_char_to_void("10"); + + stack_a = NULL; + stack_b = NULL; + ft_lstadd_back(&stack_b, ft_lstnew(element_10)); + + push_stack(&stack_a, &stack_b); + + EXPECT_EQ(stack_a, nullptr); + EXPECT_EQ(stack_b->content, element_10); + EXPECT_EQ(stack_b->next, nullptr); +} + +TEST(push_stack, pushToNull) { + t_list *stack_a; + void *element_00 = convert_const_char_to_void("00"); + t_list *stack_b; + + stack_a = NULL; + ft_lstadd_back(&stack_a, ft_lstnew(element_00)); + stack_b = NULL; + + push_stack(&stack_a, &stack_b); + + EXPECT_EQ(stack_a, nullptr); + EXPECT_EQ(stack_b->content, element_00); + EXPECT_EQ(stack_b->next, nullptr); +} + +TEST(push_stack, fiveElements) { + t_list *stack_a; + void *element_00 = convert_const_char_to_void("00"); + void *element_01 = convert_const_char_to_void("01"); + void *element_02 = convert_const_char_to_void("02"); + void *element_03 = convert_const_char_to_void("03"); + void *element_04 = convert_const_char_to_void("04"); + t_list *stack_b; + void *element_10 = convert_const_char_to_void("10"); + void *element_11 = convert_const_char_to_void("11"); + void *element_12 = convert_const_char_to_void("12"); + void *element_13 = convert_const_char_to_void("13"); + void *element_14 = convert_const_char_to_void("14"); + + stack_a = NULL; + ft_lstadd_back(&stack_a, ft_lstnew(element_00)); + ft_lstadd_back(&stack_a, ft_lstnew(element_01)); + ft_lstadd_back(&stack_a, ft_lstnew(element_02)); + ft_lstadd_back(&stack_a, ft_lstnew(element_03)); + ft_lstadd_back(&stack_a, ft_lstnew(element_04)); + stack_b = NULL; + ft_lstadd_back(&stack_b, ft_lstnew(element_10)); + ft_lstadd_back(&stack_b, ft_lstnew(element_11)); + ft_lstadd_back(&stack_b, ft_lstnew(element_12)); + ft_lstadd_back(&stack_b, ft_lstnew(element_13)); + ft_lstadd_back(&stack_b, ft_lstnew(element_14)); + + push_stack(&stack_a, &stack_b); + EXPECT_EQ(stack_a->content, element_01); + EXPECT_EQ(stack_a->next->content, element_02); + EXPECT_EQ(stack_a->next->next->content, element_03); + EXPECT_EQ(stack_a->next->next->next->content, element_04); + EXPECT_EQ(stack_a->next->next->next->next, nullptr); + EXPECT_EQ(stack_b->content, element_00); + EXPECT_EQ(stack_b->next->content, element_10); + EXPECT_EQ(stack_b->next->next->content, element_11); + EXPECT_EQ(stack_b->next->next->next->content, element_12); + EXPECT_EQ(stack_b->next->next->next->next->content, element_13); + EXPECT_EQ(stack_b->next->next->next->next->next->content, element_14); + EXPECT_EQ(stack_b->next->next->next->next->next->next, nullptr); +} diff --git a/test/test_reverse_rotate_stack.cpp b/test/test_reverse_rotate_stack.cpp new file mode 100644 index 0000000..a0c8946 --- /dev/null +++ b/test/test_reverse_rotate_stack.cpp @@ -0,0 +1,62 @@ +// Copyright 2024, reasuke + +#include "gtest/gtest.h" + +extern "C" { + #include "push_swap.h" +} + +static void *convert_const_char_to_void(const char *str) { + const void *const_element = static_cast(str); + void *element = const_cast(const_element); + + return element; +} + +TEST(reverse_rotate, oneElement) { + t_list *stack; + void *element0 = convert_const_char_to_void("0"); + + stack = NULL; + ft_lstadd_back(&stack, ft_lstnew(element0)); + reverse_rotate_stack(&stack); + EXPECT_EQ(stack->content, element0); + EXPECT_EQ(stack->next, nullptr); +} + +TEST(reverse_rotate, twoElements) { + t_list *stack; + void *element0 = convert_const_char_to_void("0"); + void *element1 = convert_const_char_to_void("1"); + + stack = NULL; + ft_lstadd_back(&stack, ft_lstnew(element0)); + ft_lstadd_back(&stack, ft_lstnew(element1)); + reverse_rotate_stack(&stack); + EXPECT_EQ(stack->content, element1); + EXPECT_EQ(stack->next->content, element0); + EXPECT_EQ(stack->next->next, nullptr); +} + +TEST(reverse_rotate, fiveElements) { + t_list *stack; + void *element0 = convert_const_char_to_void("0"); + void *element1 = convert_const_char_to_void("1"); + void *element2 = convert_const_char_to_void("2"); + void *element3 = convert_const_char_to_void("3"); + void *element4 = convert_const_char_to_void("4"); + + stack = NULL; + ft_lstadd_back(&stack, ft_lstnew(element0)); + ft_lstadd_back(&stack, ft_lstnew(element1)); + ft_lstadd_back(&stack, ft_lstnew(element2)); + ft_lstadd_back(&stack, ft_lstnew(element3)); + ft_lstadd_back(&stack, ft_lstnew(element4)); + reverse_rotate_stack(&stack); + EXPECT_EQ(stack->content, element4); + EXPECT_EQ(stack->next->content, element0); + EXPECT_EQ(stack->next->next->content, element1); + EXPECT_EQ(stack->next->next->next->content, element2); + EXPECT_EQ(stack->next->next->next->next->content, element3); + EXPECT_EQ(stack->next->next->next->next->next, nullptr); +} diff --git a/test/test_rotate_stack.cpp b/test/test_rotate_stack.cpp new file mode 100644 index 0000000..e5425f9 --- /dev/null +++ b/test/test_rotate_stack.cpp @@ -0,0 +1,62 @@ +// Copyright 2024, reasuke + +#include "gtest/gtest.h" + +extern "C" { + #include "push_swap.h" +} + +static void *convert_const_char_to_void(const char *str) { + const void *const_element = static_cast(str); + void *element = const_cast(const_element); + + return element; +} + +TEST(rotate, oneElement) { + t_list *stack; + void *element0 = convert_const_char_to_void("0"); + + stack = NULL; + ft_lstadd_back(&stack, ft_lstnew(element0)); + rotate_stack(&stack); + EXPECT_EQ(stack->content, element0); + EXPECT_EQ(stack->next, nullptr); +} + +TEST(rotate, twoElements) { + t_list *stack; + void *element0 = convert_const_char_to_void("0"); + void *element1 = convert_const_char_to_void("1"); + + stack = NULL; + ft_lstadd_back(&stack, ft_lstnew(element0)); + ft_lstadd_back(&stack, ft_lstnew(element1)); + rotate_stack(&stack); + EXPECT_EQ(stack->content, element1); + EXPECT_EQ(stack->next->content, element0); + EXPECT_EQ(stack->next->next, nullptr); +} + +TEST(rotate, fiveElements) { + t_list *stack; + void *element0 = convert_const_char_to_void("0"); + void *element1 = convert_const_char_to_void("1"); + void *element2 = convert_const_char_to_void("2"); + void *element3 = convert_const_char_to_void("3"); + void *element4 = convert_const_char_to_void("4"); + + stack = NULL; + ft_lstadd_back(&stack, ft_lstnew(element0)); + ft_lstadd_back(&stack, ft_lstnew(element1)); + ft_lstadd_back(&stack, ft_lstnew(element2)); + ft_lstadd_back(&stack, ft_lstnew(element3)); + ft_lstadd_back(&stack, ft_lstnew(element4)); + rotate_stack(&stack); + EXPECT_EQ(stack->content, element1); + EXPECT_EQ(stack->next->content, element2); + EXPECT_EQ(stack->next->next->content, element3); + EXPECT_EQ(stack->next->next->next->content, element4); + EXPECT_EQ(stack->next->next->next->next->content, element0); + EXPECT_EQ(stack->next->next->next->next->next, nullptr); +} diff --git a/test/test_sort.cpp b/test/test_sort.cpp new file mode 100644 index 0000000..24f2a97 --- /dev/null +++ b/test/test_sort.cpp @@ -0,0 +1,78 @@ +// Copyright 2024, reasuke + +#include +#include + +#include "gtest/gtest.h" + +extern "C" { + #include "push_swap.h" +} + +static void sort_test_main(int N) { + // initialize vector + // e.g. N = 3 -> v = {1, 2, 3} + std::vector v(N); + for (int i = 0; i < N; ++i) { + v[i] = i + 1; + } + + // generate permutation of v (N! patterns) + // e.g. N = 3, generate the below vectors (3! = 6 patterns) + // {1, 2, 3} + // {1, 3, 2} + // {2, 1, 3} + // {2, 3, 1} + // {3, 1, 2} + // {3, 2, 1} + do { + // initialize stack + t_list *stack_a = NULL; + t_list *stack_b = NULL; + for (int &i : v) { + ft_lstadd_back(&stack_a, ft_lstnew(new int(i))); + } + // sort + sort(&stack_a, &stack_b, N); + // check if the order is appropreate + for (int i = 1; stack_a; ++i, stack_a = stack_a->next) { + EXPECT_EQ(*(int *)stack_a->content, i); + } + } while (std::next_permutation(v.begin(), v.end())); +} + +static void sort_test(int N) { + // save stdout + int stdout_copy = dup(STDOUT_FILENO); + // redirect stdout to /dev/null + int dev_null = open("/dev/null", O_WRONLY); + dup2(dev_null, 1); + close(dev_null); + + // execute test + sort_test_main(N); + + // revert stdout + dup2(stdout_copy, STDOUT_FILENO); + close(stdout_copy); +} + +TEST(sort, oneElement) { + sort_test(1); +} + +TEST(sort, twoElements) { + sort_test(2); +} + +TEST(sort, threeEelments) { + sort_test(3); +} + +TEST(sort, fourElements) { + sort_test(4); +} + +TEST(sort, fiveElements) { + sort_test(5); +} diff --git a/test/test_swap_stack.cpp b/test/test_swap_stack.cpp new file mode 100644 index 0000000..66d265b --- /dev/null +++ b/test/test_swap_stack.cpp @@ -0,0 +1,62 @@ +// Copyright 2024, reasuke + +#include "gtest/gtest.h" + +extern "C" { + #include "push_swap.h" +} + +static void *convert_const_char_to_void(const char *str) { + const void *const_element = static_cast(str); + void *element = const_cast(const_element); + + return element; +} + +TEST(swap, oneElement) { + t_list *stack; + void *element0 = convert_const_char_to_void("0"); + + stack = NULL; + ft_lstadd_back(&stack, ft_lstnew(element0)); + swap_stack(&stack); + EXPECT_EQ(stack->content, element0); + EXPECT_EQ(stack->next, nullptr); +} + +TEST(swap, twoElements) { + t_list *stack; + void *element0 = convert_const_char_to_void("0"); + void *element1 = convert_const_char_to_void("1"); + + stack = NULL; + ft_lstadd_back(&stack, ft_lstnew(element0)); + ft_lstadd_back(&stack, ft_lstnew(element1)); + swap_stack(&stack); + EXPECT_EQ(stack->content, element1); + EXPECT_EQ(stack->next->content, element0); + EXPECT_EQ(stack->next->next, nullptr); +} + +TEST(swap, fiveElements) { + t_list *stack; + void *element0 = convert_const_char_to_void("0"); + void *element1 = convert_const_char_to_void("1"); + void *element2 = convert_const_char_to_void("2"); + void *element3 = convert_const_char_to_void("3"); + void *element4 = convert_const_char_to_void("4"); + + stack = NULL; + ft_lstadd_back(&stack, ft_lstnew(element0)); + ft_lstadd_back(&stack, ft_lstnew(element1)); + ft_lstadd_back(&stack, ft_lstnew(element2)); + ft_lstadd_back(&stack, ft_lstnew(element3)); + ft_lstadd_back(&stack, ft_lstnew(element4)); + swap_stack(&stack); + EXPECT_EQ(stack->content, element1); + EXPECT_EQ(stack->next->content, element0); + EXPECT_EQ(stack->next->next->content, element2); + EXPECT_EQ(stack->next->next->next->content, element3); + EXPECT_EQ(stack->next->next->next->next->content, element4); + EXPECT_EQ(stack->next->next->next->next->next, nullptr); +}