# Test 16 - Gestion des variables sur plusieurs lignes

Ce test vérifie si `bake` et `make` gèrent correctement les variables définies sur plusieurs lignes 
avec un caractère de continuation (`\`).

## 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-16-variables-multi-lignes/
├── README.md         # Ce fichier
├── bake/             
│   ├── Bakefile      # Fichier de règles pour bake
│   ├── bakefile.jar  # Exécutable de bake (JAR)
│   ├── main.c        # Fichier source principal
│   ├── module.c      # Fichier source du module
└── make/
    ├── Makefile      # Fichier de règles pour make
    ├── main.c        # Fichier source principal
    └── module.c      # Fichier source du module

```

## Contenu des fichiers de règles

Les fichiers `Makefile` et `Bakefile` utilisent des variables définies sur plusieurs lignes :

```makefile
COMPILER = gcc
CFLAGS = -Wall \
         -ansi \
         -pedantic
OUTPUT = program

OBJS = main.o module.o

# Règle principale
$(OUTPUT): $(OBJS) 
	$(COMPILER) $(CFLAGS) -o $(OUTPUT) $(OBJS) 

main.o: main.c
	$(COMPILER) $(CFLAGS) -c main.c -o main.o

module.o: module.c
	$(COMPILER) $(CFLAGS) -c module.c -o module.o

clean:
	rm -f $(OUTPUT) $(OBJS)
```

## Objectif du test

Ce test vérifie que `bake` et `make` :
1. Interprètent correctement les variables définies sur plusieurs lignes avec `\`.
2. Utilisent les options de compilation définies par `CFLAGS` sans erreur.
3. Gèrent correctement la compilation et la création de l'exécutable `program`.
4. Comparent les messages de sortie pour s'assurer que `bake` et `make` gèrent les variables multi-lignes de manière similaire.

## Comment exécuter le test

### Test manuel

1. Compilez avec Make : 
   ```bash
   cd make
   make
   ```
   L'exécutable `program` doit être généré.

2. Exécutez le programme compilé :
   ```bash
   ./program
   ```
   Le programme doit s'exécuter normalement.

3. Faites la même procédure avec Bake : 
   ```bash
   cd bake
   java -cp bakefile.jar fr.monlouyan.bakefile.Main
   ```

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

## Résultats attendus

- `bake` et `make` doivent interpréter correctement les variables multi-lignes.
- La compilation doit réussir et produire l'exécutable `program`.
- L'exécution de `program` ne doit pas rencontrer d'erreurs.
