FIX: parsing cleanup

flags/algorithms_sort.c

@@ -46,14 +46,10 @@ void	complex(t_stacks *stacks)
 	radix(stacks);
 }
 
-void	adaptive(t_stacks *stacks, char **tab)
+void	adaptive(t_stacks *stacks)
 {
-	int		i;
 	float	disorder;
 
-	i = 0;
-	while (!ft_isdigit(tab[i][0]) && tab[i])
-		i++;
 	disorder = stacks->disorder;
 	if (disorder < 0.2)
 		simple(stacks);
@@ -61,5 +57,4 @@ void	adaptive(t_stacks *stacks, char **tab)
 		medium(stacks);
 	else
 		complex(stacks);
-	return ;
 }

flags/flag.c

@@ -26,61 +26,14 @@ int	calcul_mod(int argc, char **argv)
 	return (mod);
 }
 
-int	pos_flag(char **argv, int mod)
+void	flags(t_stacks *stacks)
 {
-	if (mod == 1 || mod == 4)
-	{
-		if (!ft_strncmp(argv[1], "--bench", 20))
-			return (1);
-	}
-	else if (mod == 2 || mod == 5)
-	{
-		if (!ft_strncmp(argv[1], "--bench", 20))
-			return (1);
-		else
-			return (2);
-	}
-	return (0);
-}
-
-int	pos_bench(char **argv, int mod)
-{
-	if (mod == 1 || mod == 4)
-	{
-		if (ft_strncmp(argv[1], "--bench", 20))
-			return (1);
-	}
-	else if (mod == 2 || mod == 5)
-	{
-		if (ft_strncmp(argv[1], "--bench", 20))
-			return (1);
-		else
-			return (2);
-	}
-	return (0);
-}
-
-void	flags(int pos, int pos_b, char **argv, t_stacks *stacks)
-{
-	if (ft_strncmp(argv[pos], "--simple", 30) && pos > 0)
-	{
-		stacks->algo = 1;
+	if (stacks->algo == 1)
 		simple(stacks);
-	}
-	else if (ft_strncmp(argv[pos], "--medium", 30) && pos > 0)
-	{
-		stacks->algo = 2;
+	if (stacks->algo == 1)
 		medium(stacks);
-	}
-	else if (ft_strncmp(argv[pos], "--complex", 30) && pos > 0)
-	{
-		stacks->algo = 3;
+	if (stacks->algo == 1)
 		complex(stacks);
-	}
-	else if (ft_strncmp(argv[pos], "--adaptive", 30) && pos > 0)
-		adaptive(stacks, argv);
 	else
-		adaptive(stacks, argv);
-	if (pos_b > 0)
-		stacks->bench = 1;
+		adaptive(stacks);
 }

includes/flags.h

@@ -16,10 +16,8 @@
 void	simple(t_stacks *stacks);
 void	medium(t_stacks *stacks);
 void	complex(t_stacks *stacks);
-void	adaptive(t_stacks *stacks, char **tab);
-void	flags(int pos, int pos_b, char **argv, t_stacks *stacks);
-int		pos_bench(char **argv, int mod);
-int		pos_flag(char **argv, int mod);
+void	adaptive(t_stacks *stacks);
+void	flags(t_stacks *stacks);
 int		calcul_mod(int argc, char **argv);
 void	print_bench(t_stacks *stacks);
 

main.c

@@ -27,16 +27,8 @@ static int	push_swap(char **tab, int len, int mod)
 	if (!stacks)
 		return (0);
 	indexer(stacks);
-	if (check_order(stacks->a))
-	{
-		flags(0, pos_bench(tab, mod), tab, stacks);
-		if (stacks->bench == 1)
-			print_bench(stacks);
-		free_all(stacks);
-		return (0);
-	}
-	stacks->disorder = compute_disorder(tab, wich_mod(mod));
-	flags(pos_flag(tab, mod), pos_bench(tab, mod), tab, stacks);
+	if (!check_order(stacks->a))
+		flags(stacks);
 	if (stacks->bench == 1)
 		print_bench(stacks);
 	free_all(stacks);

parsing/checker.c

@@ -1,64 +0,0 @@
-/* ************************************************************************** */
-/*                                                                            */
-/*                                                        :::      ::::::::   */
-/*   checker.c                                          :+:      :+:    :+:   */
-/*                                                    +:+ +:+         +:+     */
-/*   By: dgaillet <dgaillet@student.42.fr>          +#+  +:+       +#+        */
-/*                                                +#+#+#+#+#+   +#+           */
-/*   Created: 2026/01/08 12:37:12 by dgaillet          #+#    #+#             */
-/*   Updated: 2026/01/08 13:17:36 by dgaillet         ###   ########lyon.fr   */
-/*                                                                            */
-/* ************************************************************************** */
-
-#include "push_swap.h"
-#include "parsing.h"
-
-static int	check_digits(char *str)
-{
-	int	i;
-
-	i = 0;
-	while (str[i])
-	{
-		if (!ft_isdigit(str[i]) && str[i] != ' ')
-			return (0);
-		i++;
-	}
-	return (1);
-}
-
-static int	check_flags(char *str)
-{
-	if (!ft_strncmp("--simple", str, ft_strlen(str)))
-		return (1);
-	else if (!ft_strncmp("--medium", str, ft_strlen(str)))
-		return (1);
-	else if (!ft_strncmp("--complex", str, ft_strlen(str)))
-		return (1);
-	else if (!ft_strncmp("--adaptative", str, ft_strlen(str)))
-		return (1);
-	return (0);
-}
-
-int	checker(int argc, char **argv)
-{
-	int	i;
-	int	methods_flag;
-	int	bench;
-
-	bench = 0;
-	methods_flag = 0;
-	i = 0;
-	while (++i < argc)
-	{
-		if (check_flags(argv[1]) && !methods_flag)
-			methods_flag = 1;
-		else if (!ft_strncmp("--bench", argv[1], ft_strlen(argv[1])) && !bench)
-			bench = 1;
-		else if (check_digits(argv[1]))
-			continue ;
-		else
-			return (0);
-	}
-	return (1);
-}

parsing/parsing.c

@@ -65,6 +65,25 @@ static void	set_t_stacks(t_stacks *stacks)
 	stacks->rrr = 0;
 }
 
+static void	set_flags(int argc, char **argv, t_stacks *stacks)
+{
+	int	i;
+
+	i = 1;
+	while (i < argc)
+	{
+		if (ft_strncmp(argv[i], "--simple", ft_strlen(argv[i])))
+			stacks->algo = 1;
+		else if (ft_strncmp(argv[i], "--medium", ft_strlen(argv[i])))
+			stacks->algo = 2;
+		else if (ft_strncmp(argv[i], "--complex", ft_strlen(argv[i])))
+			stacks->algo = 3;
+		if (ft_strncmp(argv[i], "--bench", ft_strlen(argv[i])))
+			stacks->bench = 1;
+		i++;
+	}
+}
+
 t_stacks	*init_stacks(int argc, char **argv, int mod)
 {
 	t_stacks	*stacks;
@@ -81,5 +100,7 @@ t_stacks	*init_stacks(int argc, char **argv, int mod)
 		return (NULL);
 	}
 	stacks->a = a;
+	set_flags(argc, argv, stacks);
+	stacks->disorder = compute_disorder(argv, wich_mod(mod));
 	return (stacks);
 }

test_push_swap.sh

@@ -1,765 +0,0 @@
-#!/usr/bin/env bash
-# Script complet push_swap 42
-# Avec tests pour tous les flags, piles déjà triées, leaks, stress et benchmark
-
-PS=./push_swap
-CK=./checker_linux
-VALGRIND="valgrind --leak-check=full --show-leak-kinds=all --errors-for-leak-kinds=all --error-exitcode=42"
-
-GREEN="\033[0;32m"
-RED="\033[0;31m"
-YELLOW="\033[1;33m"
-NC="\033[0m"
-
-fail=0
-
-# =========================
-# UTILS
-# =========================
-
-expect_exact() {
-    NAME="$1"
-    CMD="$2"
-    EXPECT="$3"
-    OUT=$(eval "$CMD" 2>&1)
-    RET=$?
-    if diff -u <(printf "%s\n" "$EXPECT") <(printf "%s\n" "$OUT") >/dev/null && [ $RET -eq 0 ]; then
-        echo -e "${GREEN}[OK]${NC} $NAME"
-    else
-        echo -e "${RED}[KO]${NC} $NAME"
-        echo "EXPECTED: $EXPECT (return 0)"
-        echo "GOT     : $OUT (return $RET)"
-        fail=1
-    fi
-}
-
-check_sort() {
-    local ARG="$1"
-    local FLAG="$2"
-    
-    # Exécuter push_swap
-    OUT=$(eval "$PS $FLAG $ARG" 2>/dev/null)
-    RET=$?
-    
-    # Compter les opérations
-    if [ -z "$OUT" ]; then
-        OPS=0
-    else
-        OPS=$(echo "$OUT" | wc -l)
-    fi
-    
-    # Si 0 opération, vérifier si la pile est déjà triée
-    if [ $OPS -eq 0 ] && [ $RET -eq 0 ]; then
-        # Tester si c'est bien trié avec un checker "à vide"
-        echo "" | eval "$CK $ARG" 2>/dev/null | grep -q "OK"
-        if [ $? -eq 0 ]; then
-            echo -e "${GREEN}[OK]${NC} $FLAG $ARG (ops=0, already sorted)"
-            return
-        fi
-    fi
-    
-    # Vérifier avec checker (si ops > 0)
-    if [ $OPS -gt 0 ]; then
-        RES=$(echo "$OUT" | eval "$CK $ARG" 2>/dev/null)
-    else
-        RES=""
-    fi
-    
-    # Si déjà trié (1 2 3), accepter 0 ou 1 opération
-    if echo "$ARG" | grep -qE '1.*2.*3' && [ $(echo "$ARG" | grep -o '[0-9]' | wc -l) -eq 3 ]; then
-        if [ "$RES" = "OK" ] || [ $OPS -eq 0 ]; then
-            if [ $RET -eq 0 ]; then
-                echo -e "${GREEN}[OK]${NC} $FLAG $ARG (ops=$OPS)"
-                return
-            fi
-        fi
-    fi
-    
-    # Sinon, comportement normal
-    if [ "$RES" = "OK" ] && [ $RET -eq 0 ]; then
-        echo -e "${GREEN}[OK]${NC} $FLAG $ARG (ops=$OPS)"
-    else
-        echo -e "${RED}[KO]${NC} $FLAG $ARG (ops=$OPS, checker=$RES, return=$RET)"
-        fail=1
-    fi
-}
-check_leak() {
-    ARG="$1"
-    FLAG="$2"
-    $VALGRIND $PS $FLAG $ARG >/dev/null 2>&1
-    if [ $? -eq 42 ]; then
-        echo -e "${RED}[LEAK ❌]${NC} $FLAG $ARG"
-        fail=1
-    else
-        echo -e "${GREEN}[NO LEAK ✅]${NC} $FLAG $ARG"
-    fi
-}
-
-random_arg() {
-    N=$1
-    seq -$((N*10)) $((N*10)) | shuf | head -n $N | tr '\n' ' '
-}
-
-# =========================
-# CAS DEJA TRIE (ops <= 1 accepté)
-# =========================
-echo -e "\n${YELLOW}=== CAS DEJA TRIE ===${NC}"
-for FLAG in "" "--simple" "--medium" "--complex" "--adaptive"; do
-    ARG="1 2 3"
-    OUT=$($PS $FLAG $ARG 2>/dev/null)
-    RET=$?
-    
-    if [ $RET -eq 0 ]; then
-        if [ -z "$OUT" ]; then
-            echo -e "${GREEN}[OK]${NC} Pile déjà triée $FLAG (0 ops)"
-        else
-            OPS=$(echo "$OUT" | wc -l)
-            RES=$(echo "$OUT" | $CK $ARG 2>/dev/null)
-            if [ "$RES" = "OK" ] && [ $OPS -le 1 ]; then
-                echo -e "${GREEN}[OK]${NC} Pile déjà triée $FLAG (ops=$OPS)"
-            else
-                echo -e "${RED}[KO]${NC} Pile déjà triée $FLAG (ops=$OPS, checker=$RES)"
-                fail=1
-            fi
-        fi
-    else
-        echo -e "${RED}[KO]${NC} Pile déjà triée $FLAG (return=$RET)"
-        fail=1
-    fi
-done
-
-# =========================
-# ERREURS STRICTES
-# =========================
-echo -e "${YELLOW}=== ERREURS STRICTES ===${NC}"
-expect_exact "doublons"      "$PS 1 2 1" "Error"
-expect_exact "lettre"        "$PS 1 a 3" "Error"
-expect_exact "overflow +"    "$PS 2147483648" "Error"
-expect_exact "overflow -"    "$PS -2147483649" "Error"
-expect_exact "flag"          "$PS --help" "Error"
-
-# =========================
-# CAS PAS D'ARGUMENT
-# =========================
-echo -e "\n${YELLOW}=== CAS PAS D'ARGUMENT ===${NC}"
-for FLAG in "" "--simple" "--medium" "--complex" "--adaptive"; do
-    OUT=$($PS $FLAG)
-    RET=$?
-    OPS=$(echo "$OUT" | wc -l)
-    if [ -z "$OUT" ] && [ $RET -eq 0 ]; then
-        echo -e "${GREEN}[OK]${NC} Pas d'argument $FLAG (aucune sortie, return 0)"
-    else
-        echo -e "${RED}[KO]${NC} Pas d'argument $FLAG (sortie inattendue ou return $RET)"
-        fail=1
-    fi
-done
-
-
-
-# =========================
-# PARSING / FORMAT
-# =========================
-echo -e "\n${YELLOW}=== PARSING / FORMAT ===${NC}"
-for FLAG in "" "--simple" "--medium" "--complex" "--adaptive"; do
-    check_sort "\"1 2 3\"" "$FLAG"
-    check_sort "\"  1   2   3 \"" "$FLAG"
-    check_sort $'1\t2\t3' "$FLAG"
-    check_sort "1  2   3" "$FLAG"
-done
-
-# =========================
-# TRI SIMPLES
-# =========================
-echo -e "\n${YELLOW}=== TRI SIMPLES ===${NC}"
-for FLAG in "" "--simple" "--medium" "--complex" "--adaptive"; do
-    check_sort "2 1" "$FLAG"
-    check_sort "3 2 1" "$FLAG"
-    check_sort "5 1 4 2 3" "$FLAG"
-done
-
-# =========================
-# RANDOM TESTS
-# =========================
-echo -e "\n${YELLOW}=== RANDOM TESTS 10 NUMS ===${NC}"
-for i in {1..5}; do
-    ARG=$(random_arg 10)
-    for FLAG in "" "--simple" "--medium" "--complex" "--adaptive"; do
-        check_sort "$ARG" "$FLAG"
-    done
-done
-
-# =========================
-# STRESS TESTS
-# =========================
-echo -e "\n${YELLOW}=== STRESS TESTS ===${NC}"
-for N in 100 500; do
-    ARG=$(random_arg $N)
-    for FLAG in "" "--simple" "--medium" "--complex" "--adaptive"; do
-        OPS=$($PS $FLAG $ARG | wc -l)
-        RES=$(echo "$($PS $FLAG $ARG)" | $CK $ARG 2>/dev/null)
-        RET=$?
-        echo "$FLAG $N numbers → ops=$OPS result=$RES return=$RET"
-    done
-done
-
-sorted_arg() {
-    seq 1 $1 | tr '\n' ' '
-}
-
-reverse_arg() {
-    seq $1 -1 1 | tr '\n' ' '
-}
-
-almost_sorted_arg() {
-    seq 1 $1 | shuf -n $1 --random-source=<(yes 42) | tr '\n' ' '
-}
-
-verdict() {
-    local avg=$1
-    local limit=$2
-
-    if (( avg <= limit )); then
-        echo -e "${GREEN}OK${NC}"
-    else
-        echo -e "${RED}KO${NC}"
-    fi
-}
-
-
-# =========================
-# BENCHMARK 100 TESTS
-# =========================
-echo -e "\n${YELLOW}=== TEST STRUCTURÉ 100 ELEMENTS ===${NC}"
-
-LIMIT_100=2000
-
-for TYPE in sorted reverse almost; do
-    sum=0; min=999999; max=0
-
-    for i in {1..50}; do
-        case $TYPE in
-            sorted)  ARG=$(sorted_arg 100) ;;
-            reverse) ARG=$(reverse_arg 100) ;;
-            almost)  ARG=$(almost_sorted_arg 100) ;;
-        esac
-
-        C=$($PS $ARG | wc -l)
-        ((sum+=C))
-        ((C<min)) && min=$C
-        ((C>max)) && max=$C
-    done
-
-    avg=$((sum/50))
-    result=$(verdict $avg $LIMIT_100)
-
-    echo "$TYPE → min=$min max=$max avg=$avg → $result"
-done
-
-
-
-# =========================
-# BENCHMARK 500 TESTS
-# =========================
-echo -e "\n${YELLOW}=== TEST STRUCTURÉ 500 ELEMENTS ===${NC}"
-
-LIMIT_500=12000
-
-for TYPE in sorted reverse almost; do
-    sum=0; min=999999; max=0
-
-    for i in {1..20}; do
-        case $TYPE in
-            sorted)  ARG=$(sorted_arg 500) ;;
-            reverse) ARG=$(reverse_arg 500) ;;
-            almost)  ARG=$(almost_sorted_arg 500) ;;
-        esac
-
-        C=$($PS $ARG | wc -l)
-        ((sum+=C))
-        ((C<min)) && min=$C
-        ((C>max)) && max=$C
-    done
-
-    avg=$((sum/20))
-    result=$(verdict $avg $LIMIT_500)
-
-    echo "$TYPE → min=$min max=$max avg=$avg → $result"
-done
-
-
-# =========================
-# LEAKS
-# =========================
-echo -e "\n${YELLOW}=== LEAKS ===${NC}"
-for ARG in "2 1" "1 2 3" "1 2 2" "$(random_arg 100)"; do
-    for FLAG in "" "--simple" "--medium" "--complex" "--adaptive"; do
-        check_leak "$ARG" "$FLAG"
-    done
-done
-
-# =========================
-# RESULT FINAL
-# =========================
-if [ $fail -eq 0 ]; then
-    echo -e "\n${GREEN}ALL TESTS PASSED 🎉${NC}"
-else
-    echo -e "\n${RED}SOME TESTS FAILED ❌${NC}"
-fi
-
-
-# Tests des checkers (checker_linux et bonus checker)
-
-PS=./push_swap
-CK_LINUX=./checker_linux
-CK_BONUS=./checker
-VALGRIND="valgrind --leak-check=full --show-leak-kinds=all --errors-for-leak-kinds=all --error-exitcode=42"
-
-GREEN="\033[0;32m"
-RED="\033[0;31m"
-YELLOW="\033[1;33m"
-BLUE="\033[0;34m"
-NC="\033[0m"
-
-fail=0
-
-random_arg() {
-    N=$1
-    seq -$((N*10)) $((N*10)) | shuf | head -n $N | tr '\n' ' '
-}
-
-check_leak_checker() {
-    ARG="$1"
-    OPS="$2"
-    CHECKER="$3"
-    echo "$OPS" | $VALGRIND $CHECKER $ARG >/dev/null 2>&1
-    if [ $? -eq 42 ]; then
-        echo -e "${RED}[LEAK ❌]${NC} $(basename $CHECKER) '$ARG'"
-        fail=1
-    else
-        echo -e "${GREEN}[NO LEAK ✅]${NC} $(basename $CHECKER) '$ARG'"
-    fi
-}
-
-# =========================
-# TESTS CHECKER_LINUX
-# =========================
-echo -e "${BLUE}╔════════════════════════════════════════╗${NC}"
-echo -e "${BLUE}║       TESTS CHECKER_LINUX             ║${NC}"
-echo -e "${BLUE}╚════════════════════════════════════════╝${NC}"
-
-echo -e "\n${YELLOW}=== CHECKER_LINUX: Erreurs ===${NC}"
-
-# Doublons
-RES=$(echo "" | $CK_LINUX 1 2 1 2>&1)
-if [ "$RES" = "Error" ]; then
-    echo -e "${GREEN}[OK]${NC} Doublons → Error"
-else
-    echo -e "${RED}[KO]${NC} Doublons (got: '$RES')"
-    fail=1
-fi
-
-# Lettre
-RES=$(echo "" | $CK_LINUX 1 a 3 2>&1)
-if [ "$RES" = "Error" ]; then
-    echo -e "${GREEN}[OK]${NC} Lettre → Error"
-else
-    echo -e "${RED}[KO]${NC} Lettre (got: '$RES')"
-    fail=1
-fi
-
-# Overflow
-RES=$(echo "" | $CK_LINUX 2147483648 2>&1)
-if [ "$RES" = "Error" ]; then
-    echo -e "${GREEN}[OK]${NC} Overflow → Error"
-else
-    echo -e "${RED}[KO]${NC} Overflow (got: '$RES')"
-    fail=1
-fi
-
-# Opération invalide
-RES=$(echo "invalid_op" | $CK_LINUX 1 2 3 2>&1)
-if [ "$RES" = "Error" ]; then
-    echo -e "${GREEN}[OK]${NC} Op invalide → Error"
-else
-    echo -e "${RED}[KO]${NC} Op invalide (got: '$RES')"
-    fail=1
-fi
-
-echo -e "\n${YELLOW}=== CHECKER_LINUX: Pas d'argument ===${NC}"
-OUT=$(echo "" | $CK_LINUX 2>&1)
-RET=$?
-if [ -z "$OUT" ] && [ $RET -eq 0 ]; then
-    echo -e "${GREEN}[OK]${NC} Pas d'argument"
-else
-    echo -e "${RED}[KO]${NC} Pas d'argument (out='$OUT', ret=$RET)"
-    fail=1
-fi
-
-
-echo -e "\n${YELLOW}=== CHECKER_LINUX: Opérations valides ===${NC}"
-
-# sa sur "2 1"
-RES=$(echo "sa" | $CK_LINUX 2 1)
-if [ "$RES" = "OK" ]; then
-    echo -e "${GREEN}[OK]${NC} sa sur '2 1' → OK"
-else
-    echo -e "${RED}[KO]${NC} sa sur '2 1' (got: '$RES')"
-    fail=1
-fi
-
-# Séquence complète
-ARG="3 2 1"
-OPS=$($PS $ARG)
-RES=$(echo "$OPS" | $CK_LINUX $ARG)
-if [ "$RES" = "OK" ]; then
-    echo -e "${GREEN}[OK]${NC} Séquence '$ARG' → OK"
-else
-    echo -e "${RED}[KO]${NC} Séquence '$ARG' (got: '$RES')"
-    fail=1
-fi
-
-echo -e "\n${YELLOW}=== CHECKER_LINUX: Pile non triée ===${NC}"
-RES=$(echo "sa" | $CK_LINUX 3 2 1)
-if [ "$RES" = "KO" ]; then
-    echo -e "${GREEN}[OK]${NC} Détecte pile non triée → KO"
-else
-    echo -e "${RED}[KO]${NC} Pile non triée (got: '$RES')"
-    fail=1
-fi
-
-echo -e "\n${YELLOW}=== CHECKER_LINUX: Stress test ===${NC}"
-for N in 10 100 500; do
-    ARG=$(random_arg $N)
-    OPS=$($PS $ARG 2>/dev/null)
-    RES=$(echo "$OPS" | $CK_LINUX $ARG 2>/dev/null)
-    if [ "$RES" = "OK" ]; then
-        echo -e "${GREEN}✓${NC} $N nombres → OK"
-    else
-        echo -e "${RED}✗${NC} $N nombres → $RES"
-        fail=1
-    fi
-done
-
-echo -e "\n${YELLOW}=== CHECKER_LINUX: Leaks ===${NC}"
-check_leak_checker "2 1" "sa" "$CK_LINUX"
-check_leak_checker "1 2 3" "" "$CK_LINUX"
-check_leak_checker "1 2 2" "" "$CK_LINUX"
-ARG=$(random_arg 50)
-OPS=$($PS $ARG)
-check_leak_checker "$ARG" "$OPS" "$CK_LINUX"
-
-# =========================
-# TESTS BONUS CHECKER
-# =========================
-if [ -f "$CK_BONUS" ]; then
-    echo -e "\n${BLUE}╔════════════════════════════════════════╗${NC}"
-    echo -e "${BLUE}║       TESTS BONUS CHECKER             ║${NC}"
-    echo -e "${BLUE}╚════════════════════════════════════════╝${NC}"
-    
-    echo -e "\n${YELLOW}=== BONUS: Erreurs ===${NC}"
-    
-    # Doublons
-    RES=$(echo "" | $CK_BONUS 1 2 1 2>&1)
-    if [ "$RES" = "Error" ]; then
-        echo -e "${GREEN}[OK]${NC} Doublons → Error"
-    else
-        echo -e "${RED}[KO]${NC} Doublons (got: '$RES')"
-        fail=1
-    fi
-    
-    # Lettre
-    RES=$(echo "" | $CK_BONUS 1 a 3 2>&1)
-    if [ "$RES" = "Error" ]; then
-        echo -e "${GREEN}[OK]${NC} Lettre → Error"
-    else
-        echo -e "${RED}[KO]${NC} Lettre (got: '$RES')"
-        fail=1
-    fi
-    
-    # Overflow
-    RES=$(echo "" | $CK_BONUS 2147483648 2>&1)
-    if [ "$RES" = "Error" ]; then
-        echo -e "${GREEN}[OK]${NC} Overflow → Error"
-    else
-        echo -e "${RED}[KO]${NC} Overflow (got: '$RES')"
-        fail=1
-    fi
-    
-    # Opération invalide
-    RES=$(echo "xx" | $CK_BONUS 3 2 1 2>&1)
-    if [ "$RES" = "Error" ]; then
-        echo -e "${GREEN}[OK]${NC} Op invalide → Error"
-    else
-        echo -e "${RED}[KO]${NC} Op invalide (got: '$RES')"
-        fail=1
-    fi
-    
-    echo -e "\n${YELLOW}=== BONUS: Pas d'argument ===${NC}"
-    OUT=$(echo "" | $CK_BONUS 2>&1)
-    RET=$?
-    if [ -z "$OUT" ] && [ $RET -eq 0 ]; then
-        echo -e "${GREEN}[OK]${NC} Pas d'argument"
-    else
-        echo -e "${RED}[KO]${NC} Pas d'argument (out='$OUT', ret=$RET)"
-        fail=1
-    fi
-    
-    echo -e "\n${YELLOW}=== BONUS: Pile déjà triée ===${NC}"
-   RES=$(echo "" | $CK_BONUS 1 2 3)
-if [ "$RES" = "OK" ] || [ -z "$RES" ]; then
-    echo -e "${GREEN}[OK]${NC} Pile triée (0 ops) → OK"
-else
-    echo -e "${RED}[KO]${NC} Pile triée (got: '$RES')"
-    fail=1
-fi
-
-    
-    echo -e "\n${YELLOW}=== BONUS: Opérations valides ===${NC}"
-    
-    # sa sur "2 1"
-    RES=$(echo "sa" | $CK_BONUS 2 1)
-    if [ "$RES" = "OK" ]; then
-        echo -e "${GREEN}[OK]${NC} sa sur '2 1' → OK"
-    else
-        echo -e "${RED}[KO]${NC} sa sur '2 1' (got: '$RES')"
-        fail=1
-    fi
-    
-    # pb sur pile vide b
-    RES=$(echo "pb" | $CK_BONUS 2 1 2>/dev/null)
-    if [ "$RES" = "KO" ]; then
-        echo -e "${GREEN}[OK]${NC} pb (pile b reste vide) → KO"
-    else
-        echo -e "${YELLOW}[INFO]${NC} pb sur pile vide (got: '$RES')"
-    fi
-    
-    # Séquence complète
-    ARG="3 2 1"
-    OPS=$($PS $ARG)
-    RES=$(echo "$OPS" | $CK_BONUS $ARG)
-    if [ "$RES" = "OK" ]; then
-        echo -e "${GREEN}[OK]${NC} Séquence '$ARG' → OK"
-    else
-        echo -e "${RED}[KO]${NC} Séquence '$ARG' (got: '$RES')"
-        fail=1
-    fi
-    
-    echo -e "\n${YELLOW}=== BONUS: Pile non triée ===${NC}"
-    RES=$(echo "sa" | $CK_BONUS 3 2 1)
-    if [ "$RES" = "KO" ]; then
-        echo -e "${GREEN}[OK]${NC} Détecte pile non triée → KO"
-    else
-        echo -e "${RED}[KO]${NC} Pile non triée (got: '$RES')"
-        fail=1
-    fi
-    
-    echo -e "\n${YELLOW}=== BONUS: Comparaison avec checker_linux ===${NC}"
-    passed=0
-    total=20
-    for i in $(seq 1 $total); do
-        ARG=$(random_arg 10)
-        OPS=$($PS $ARG 2>/dev/null)
-        
-        RES_LINUX=$(echo "$OPS" | $CK_LINUX $ARG 2>/dev/null)
-        RES_BONUS=$(echo "$OPS" | $CK_BONUS $ARG 2>/dev/null)
-        
-        if [ "$RES_LINUX" = "$RES_BONUS" ]; then
-            ((passed++))
-        else
-            echo -e "${RED}[DIFF]${NC} Args: $(echo $ARG | cut -d' ' -f1-5)..."
-            echo "  Linux: $RES_LINUX"
-            echo "  Bonus: $RES_BONUS"
-            fail=1
-        fi
-    done
-    echo "$passed/$total tests concordent"
-    
-    echo -e "\n${YELLOW}=== BONUS: Parsing ===${NC}"
-    
-    # Avec guillemets
-  RES=$(echo "" | eval "$CK_BONUS \"1 2 3\"")
-if [ "$RES" = "OK" ] || [ -z "$RES" ]; then
-    echo -e "${GREEN}[OK]${NC} Parsing guillemets"
-else
-    echo -e "${RED}[KO]${NC} Parsing guillemets (got: '$RES')"
-    fail=1
-fi
-
-    
-    # Espaces multiples
-   if [ "$RES" = "OK" ] || [ -z "$RES" ]; then
-    echo -e "${GREEN}[OK]${NC} Espaces multiples"
-else
-    echo -e "${RED}[KO]${NC} Espaces multiples (got: '$RES')"
-    fail=1
-fi
-
-    
-    echo -e "\n${YELLOW}=== BONUS: Stress test ===${NC}"
-    for N in 10 100 500; do
-        ARG=$(random_arg $N)
-        OPS=$($PS $ARG 2>/dev/null)
-        RES=$(echo "$OPS" | $CK_BONUS $ARG 2>/dev/null)
-        if [ "$RES" = "OK" ]; then
-            echo -e "${GREEN}✓${NC} $N nombres → OK"
-        else
-            echo -e "${RED}✗${NC} $N nombres → $RES"
-            fail=1
-        fi
-    done
-    
-    echo -e "\n${YELLOW}=== BONUS: Toutes les opérations ===${NC}"
-    
-    # Test sa
-    RES=$(echo "sa" | $CK_BONUS 3 1 2)
-    [ "$RES" = "KO" ] && echo -e "${GREEN}[OK]${NC} sa" || echo -e "${RED}[KO]${NC} sa (got: '$RES')"
-    
-    # Test sb (avec pb avant)
-    RES=$(echo -e "pb\nsb" | $CK_BONUS 1 3 2)
-    [ "$RES" = "KO" ] && echo -e "${GREEN}[OK]${NC} sb" || echo -e "${RED}[KO]${NC} sb (got: '$RES')"
-    
-    # Test ss
-    RES=$(echo -e "pb\nss" | $CK_BONUS 2 1 4 3)
-    [ "$RES" = "KO" ] && echo -e "${GREEN}[OK]${NC} ss" || echo -e "${RED}[KO]${NC} ss (got: '$RES')"
-    
-    # Test pa
-    RES=$(echo -e "pb\npa" | $CK_BONUS 1 2 3)
-    [ "$RES" = "OK" ] && echo -e "${GREEN}[OK]${NC} pa" || echo -e "${RED}[KO]${NC} pa (got: '$RES')"
-    
-    # Test pb
-    RES=$(echo "pb" | $CK_BONUS 1 2 3)
-    [ "$RES" = "KO" ] && echo -e "${GREEN}[OK]${NC} pb" || echo -e "${RED}[KO]${NC} pb (got: '$RES')"
-    
-    # Test ra
-    RES=$(echo "ra" | $CK_BONUS 2 3 1)
-    [ "$RES" = "KO" ] && echo -e "${GREEN}[OK]${NC} ra" || echo -e "${RED}[KO]${NC} ra (got: '$RES')"
-    
-    # Test rb
-    RES=$(echo -e "pb\nrb" | $CK_BONUS 1 2 3)
-    [ "$RES" = "KO" ] && echo -e "${GREEN}[OK]${NC} rb" || echo -e "${RED}[KO]${NC} rb (got: '$RES')"
-    
-    # Test rr
-    RES=$(echo -e "pb\nrr" | $CK_BONUS 2 3 1)
-    [ "$RES" = "KO" ] && echo -e "${GREEN}[OK]${NC} rr" || echo -e "${RED}[KO]${NC} rr (got: '$RES')"
-    
-    # Test rra
-    RES=$(echo "rra" | $CK_BONUS 3 1 2)
-    [ "$RES" = "KO" ] && echo -e "${GREEN}[OK]${NC} rra" || echo -e "${RED}[KO]${NC} rra (got: '$RES')"
-    
-    # Test rrb
-    RES=$(echo -e "pb\nrrb" | $CK_BONUS 1 2 3)
-    [ "$RES" = "KO" ] && echo -e "${GREEN}[OK]${NC} rrb" || echo -e "${RED}[KO]${NC} rrb (got: '$RES')"
-    
-    # Test rrr
-    RES=$(echo -e "pb\nrrr" | $CK_BONUS 3 1 2)
-    [ "$RES" = "KO" ] && echo -e "${GREEN}[OK]${NC} rrr" || echo -e "${RED}[KO]${NC} rrr (got: '$RES')"
-    
-    echo -e "\n${YELLOW}=== BONUS: Leaks ===${NC}"
-    check_leak_checker "2 1" "sa" "$CK_BONUS"
-    check_leak_checker "1 2 3" " $CK_BONUS"
-    check_leak_checker "1 2 2" "" "$CK_BONUS"
-    ARG=$(random_arg 50)
-    OPS=$($PS $ARG)
-    check_leak_checker "$ARG" "$OPS" "$CK_BONUS"
-    
-else
-    echo -e "\n${YELLOW}⚠ Checker bonus non trouvé (./checker)${NC}"
-fi
-
-# =========================
-# RESULT FINAL
-# =========================
-echo -e "\n${BLUE}═══════════════════════════════════════${NC}"
-if [ $fail -eq 0 ]; then
-    echo -e "${GREEN}✓ ALL CHECKER TESTS PASSED 🎉${NC}"
-else
-    echo -e "${RED}✗ SOME CHECKER TESTS FAILED ❌${NC}"
-fi
-echo -e "${BLUE}═══════════════════════════════════════${NC}"
-
-# =========================
-# TEST PUSH_SWAP AVEC CHECKER_LINUX (VERSION ÉTENDUE)
-# =========================
-echo -e "\n${YELLOW}=== TEST PUSH_SWAP AVEC CHECKER_LINUX (ÉTENDU) ===${NC}"
-
-for N in 3 5 10 50 100 500; do
-    ARG=$(random_arg $N)
-    echo -e "\nPile aléatoire ($N éléments): $ARG"
-
-    # Générer les opérations avec push_swap
-    OPS=$($PS $ARG 2>/dev/null)
-    N_OPS=$(echo "$OPS" | wc -l)
-
-    # Vérifier avec checker_linux
-    if [ -z "$OPS" ]; then
-        # Pas d'opérations → pile déjà triée
-        echo "" | $CK $ARG >/dev/null 2>&1
-        CK_RET=$?
-    else
-        printf "%s\n" "$OPS" | $CK $ARG >/dev/null 2>&1
-        CK_RET=$?
-    fi
-
-    echo "Nombre d'opérations: $N_OPS"
-    echo "Checker Linux return code: $CK_RET"
-
-    if [ $CK_RET -eq 0 ]; then
-        echo -e "${GREEN}[OK] Pile triée correctement${NC}"
-    elif [ $CK_RET -eq 1 ]; then
-        echo -e "${RED}[KO] Pile non triée${NC}"
-        fail=1
-    else
-        echo -e "${RED}[ERROR] Checker a retourné une erreur${NC}"
-        fail=1
-    fi
-done
-
-# =========================
-# TESTS DE PILES INVERSÉES
-# =========================
-echo -e "\n${YELLOW}=== TESTS PILES INVERSÉES ===${NC}"
-for ARG in "3 2 1" "5 4 3 2 1" "10 9 8 7 6 5 4 3 2 1"; do
-    OPS=$($PS $ARG 2>/dev/null)
-    N_OPS=$(echo "$OPS" | wc -l)
-    printf "%s\n" "$OPS" | $CK $ARG >/dev/null 2>&1
-    CK_RET=$?
-
-    if [ $CK_RET -eq 0 ]; then
-        echo -e "${GREEN}[OK] Pile inversée triée correctement ($ARG, ops=$N_OPS)${NC}"
-    else
-        echo -e "${RED}[KO] Pile inversée non triée ($ARG)${NC}"
-        fail=1
-    fi
-done
-
-# =========================
-# TESTS DE VALEURS LIMITES
-# =========================
-echo -e "\n${YELLOW}=== TESTS VALEURS LIMITES ===${NC}"
-for ARG in "2147483647 -2147483648 0" ; do
-    OPS=$($PS $ARG 2>/dev/null)
-    N_OPS=$(echo "$OPS" | wc -l)
-    printf "%s\n" "$OPS" | $CK $ARG >/dev/null 2>&1
-    CK_RET=$?
-
-    if [ $CK_RET -eq 0 ]; then
-        echo -e "${GREEN}[OK] Valeurs limites triées correctement ($ARG, ops=$N_OPS)${NC}"
-    else
-        echo -e "${RED}[KO] Valeurs limites non triées ($ARG)${NC}"
-        fail=1
-    fi
-done
-
-# =========================
-# TESTS D'ENTRÉES INVALIDES
-# =========================
-echo -e "\n${YELLOW}=== TESTS ENTRÉES INVALIDES ===${NC}"
-for ARG in "1 2 2" "1 a 3" "2147483648 -2147483649"; do
-    RES=$($PS $ARG 2>&1)
-    if echo "$RES" | grep -q "Error"; then
-        echo -e "${GREEN}[OK] Entrée invalide détectée ($ARG)${NC}"
-    else
-        echo -e "${RED}[KO] Entrée invalide non détectée ($ARG)${NC}"
-        fail=1
-    fi
-done