# Test 04 - Compilation après modification du code source

Ce test vérifie le comportement de `bake` comparé à `make` lorsque l'exécutable cible existe déjà mais que le code source a été modifié depuis la dernière compilation.

## 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-04-edited/
├── 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 (modifié)
├── make/
│   ├── Makefile      # Fichier de règles pour make
│   ├── main          # Exécutable déjà compilé
│   └── main.c        # Fichier source C (modifié)
└── run_test04.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ù le code source a été modifié :
1. Vérifier que les deux outils détectent correctement que la cible `main` existe déjà
2. Vérifier que les deux outils détectent que le fichier source `main.c` a été modifié depuis la dernière compilation
3. Vérifier que les deux outils reconstruisent l'exécutable `main` pour prendre en compte les modifications
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_test04.sh
   ```

2. Lancez le script de test :
   ```
   ./run_test04.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. Modifiez les fichiers source dans les deux répertoires :
   ```
   echo "// Modification pour test" >> make/main.c
   echo "// Modification pour test" >> bake/main.c
   ```

2. Pour Make : 
   ```
   cd make
   make
   ```

3. Pour Bake : 
   ```
   cd bake
   java -cp bakefile.jar fr.monlouyan.bakefile.Main
   ```

4. 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 détecter que le fichier source `main.c` a été modifié depuis la dernière compilation
- Les deux outils devraient reconstruire l'exécutable `main` pour prendre en compte les modifications
- Les datestamps des exécutables devraient être mis à jour

Ce test vérifie la fonctionnalité essentielle d'un système de build qui consiste à reconstruire les cibles lorsque leurs dépendances ont été modifiées, assurant ainsi que l'exécutable reflète toujours l'état actuel du code source.