# Test 24 - Chaîne de dépendances longues

Ce test vérifie la manière dont `bake` et `make` gèrent une longue série de dépendances en cascade, où chaque cible dépend de la précédente.

## Sommaire
- [Structure du test](#structure-du-test)
- [Contenu des fichiers de règles](#contenu-des-fichiers-de-règles)
- [Objectif du test](#objectif-du-test)
- [Scénario de test](#scénario-de-test)
- [Comment exécuter le test](#comment-exécuter-le-test)
  - [Test manuel](#test-manuel)
- [Résultats attendus](#résultats-attendus)

## Structure du test

```
test-24-long-dependency-chain/
├── README.md         # Ce fichier
├── bake/             
│   ├── Bakefile      # Fichier de règles pour bake
│   ├── bakefile.jar  # Exécutable de bake (JAR)
└── make/
    └── Makefile      # Fichier de règles pour make
```

## Contenu des fichiers de règles

Les fichiers `Makefile` et `Bakefile` contiennent une longue chaîne de dépendances comme suit :

```makefile
all: target50

target50: target49
	echo "Building target50"

target49: target48
	echo "Building target49"

...

target2: target1
	echo "Building target2"

target1:
	echo "Building target1"
```

## Objectif du test

Ce test vérifie que `bake` et `make` :
1. Résolvent correctement une longue chaîne de dépendances.
2. Exécutent les cibles dans le bon ordre, en commençant par `target1` jusqu'à `target50`.
3. Ne rencontrent pas de limitations de profondeur de résolution des dépendances.
4. Comparent les messages de sortie pour s'assurer que `bake` et `make` ont le même comportement.

## Scénario de test

1. Exécuter `make` et `bake` sans fichiers préexistants pour observer la construction de toutes les cibles.
2. Réexécuter `make` et `bake` pour voir s'ils détectent que toutes les cibles sont déjà construites et n'ont pas besoin d'être reconstituées.

## Comment exécuter le test

### Test manuel

1. Exécutez la compilation avec Make : 
   ```bash
   cd make
   make
   ```
   Toutes les cibles de `target1` à `target50` doivent être construites dans l'ordre.

2. Faites la même procédure avec Bake : 
   ```bash
   cd bake
   java -cp bakefile.jar fr.monlouyan.bakefile.Main
   ```

3. Réexécutez `make` et `bake` sans supprimer les fichiers pour voir s'ils détectent que tout est déjà construit.

4. Comparez les résultats et les messages affichés.

## Résultats attendus

- `bake` et `make` doivent exécuter les cibles dans le bon ordre.
- Une exécution répétée de `make` et `bake` ne doit rien reconstruire si rien n'a changé.
- Les messages de sortie doivent être identiques entre `bake` et `make`.