# Test 02 - Compilation avec exécutable existant

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.

## 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)
- [Comment exécuter le test](#comment-exécuter-le-test)
  - [Test automatique](#test-automatique)
  - [Test manuel](#test-manuel)
- [Résultats attendus](#résultats-attendus)

## Structure du test

```
test-02-existing-executable/
├── README.md         # Ce fichier
├── bake/             
│   ├── Bakefile      # Fichier de règles pour bake
│   ├── bakefile.jar  # Exécutable de bake (JAR)
│   ├── main          # Exécutable déjà compilé
│   └── main.c        # Fichier source C
├── make/
│   ├── Makefile      # Fichier de règles pour make
│   ├── main          # Exécutable déjà compilé
│   └── main.c        # Fichier source C
└── run_test02.sh     # Programme de test automatique
```

## Contenu des fichiers de règles

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.