SAE32_2024/tests/test-06-variables-on-cascade/README.md

# Test 06 - Gestion des variables en cascade

Ce test vérifie la prise en charge des variables en cascade dans `bake` et `make`, en analysant leur propagation correcte dans les commandes de 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 manuel](#test-manuel)
- [Résultats attendus](#résultats-attendus)

## Structure du test

```
test-06-cascade/
├── 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
```

## Contenu des fichiers de règles

Les fichiers `Makefile` et `Bakefile` utilisent des variables imbriquées pour tester la substitution en cascade :

```makefile
FLAGS = -ansi -pedantic
FLAGSS = $(FLAGS)
FLAGSSS = $(FLAGSS)
FLAGSSSS = $(FLAGSSS)
FLAGSSSSS = $(FLAGSSSS)
FLAGSSSSSS = $(FLAGSSSSS)
FLAGSSSSSSS = $(FLAGSSSSSS)

main: main.c
	gcc $(FLAGSSSSSSS) -o main main.c
```

## Objectif du test

Ce test vérifie que `bake` et `make` gèrent correctement les variables définies en cascade :
1. Vérifier que chaque variable est correctement remplacée par sa valeur résolue.
2. Vérifier que la compilation se déroule sans erreur et produit l'exécutable `main`.
3. Comparer les messages de sortie pour observer la propagation des variables.

## Comment exécuter le test

### 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 correctement remplacer les variables en cascade.
- La compilation devrait aboutir et produire un exécutable `main`.
- Les messages de sortie devraient indiquer clairement l'expansion des variables imbriquées.
- Si `bake` ne gère pas correctement la propagation des variables, la compilation pourrait échouer ou utiliser des valeurs incorrectes.