# Test 05 - Utilisation de variables

Ce test vérifie la prise en charge des variables dans `bake` et `make`, en comparant leur comportement lors de la compilation d'un programme simple.

## 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-05-variables/
├── README.md         # Ce fichier
├── bake/             
│   ├── Bakefile      # Fichier de règles pour bake
│   ├── bakefile.jar  # Exécutable de bake (JAR)
│   ├── main.c        # Fichier source C
├── make/
│   ├── Makefile      # Fichier de règles pour make
│   ├── main.c        # Fichier source C
└── run_test05.sh     # Programme de test automatique
```

## Contenu des fichiers de règles

Les fichiers `Makefile` et `Bakefile` utilisent des variables pour améliorer la lisibilité et la maintenance :

```makefile
FLAGS = -ansi -pedantic
COMPILATEUR = gcc
OPTIONS = -o
EXECUTABLE = main
SOURCE = main.c

main: main.c
	$(COMPILATEUR) $(FLAGS) $(OPTIONS) $(EXECUTABLE) $(SOURCE)
```

## Objectif du test

Ce test vérifie que `bake` et `make` interprètent correctement les variables :
1. Vérifier que les variables définies dans le fichier de règles sont bien reconnues et substituées dans les commandes.
2. Vérifier que la compilation se déroule correctement en utilisant les variables.
3. Comparer les messages de sortie de `bake` et `make` pour s'assurer qu'ils prennent en compte les variables correctement.

## Comment exécuter le test

### Test automatique

1. Rendez le script de test exécutable :
   ```bash
   chmod +x run_test05.sh
   ```

2. Lancez le script de test :
   ```bash
   ./run_test05.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. Compilez avec Make : 
   ```bash
   cd make
   make
   ```

2. Compilez avec Bake : 
   ```bash
   cd bake
   java -cp bakefile.jar fr.monlouyan.bakefile.Main
   ```

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

## Résultats attendus

- Les deux outils devraient reconnaître et substituer correctement les variables dans les commandes.
- La compilation devrait aboutir et produire un exécutable `main`.
- Les messages de sortie devraient indiquer clairement que les variables ont été utilisées dans la commande de compilation.
- Si les variables ne sont pas prises en compte correctement, `bake` pourrait échouer à compiler `main.c`.
