Ce test vérifie le comportement de `bake` comparé à `make` lorsque l'exécutable cible existe déjà et qu'aucune modification n'a été apportée au code source.
Les fichiers `Makefile` et `Bakefile` contiennent les mêmes règles :
```makefile
main: main.c
gcc -o main main.c
```
## Objectif du test
Ce test vérifie que `bake` se comporte comme `make` dans le scénario où l'exécutable existe déjà :
1. Vérifier que les deux outils détectent correctement que la cible `main` existe déjà
2. Vérifier que les deux outils analysent les dépendances pour déterminer si la reconstruction est nécessaire
3. Vérifier que les deux outils évitent de reconstruire l'exécutable quand aucune modification n'a été apportée au code source
4. Comparer les messages de sortie des deux outils
## Comment exécuter le test
### Test automatique
1. Rendez le script de test exécutable :
```
chmod +x run_test02.sh
```
2. Lancez le script de test :
```
./run_test02.sh
```
3. Consultez les résultats affichés dans le terminal et dans le fichier de log généré dans le répertoire `logs/`.
### Test manuel
1. Pour Make :
```
cd make
make
```
2. Pour Bake :
```
cd bake
java -cp bakefile.jar fr.monlouyan.bakefile.Main
```
3. Comparez les deux résultats.
## Résultats attendus
- Les deux outils devraient détecter que la cible `main` existe déjà
- Les deux outils devraient vérifier les dates de modification des fichiers source et de l'exécutable
- Les deux outils devraient déterminer qu'aucune reconstruction n'est nécessaire (les fichiers source n'ayant pas été modifiés)
- Les messages de sortie devraient être similaires, indiquant qu'aucune action n'a été effectuée
- Les datestamps des exécutables ne devraient pas être modifiés
Ce test vérifie la fonctionnalité essentielle d'un système de build qui consiste à ne pas reconstruire des cibles qui sont déjà à jour, optimisant ainsi le temps de compilation.
