# Test 09 - Gestion des commentaires dans le Makefile

Ce test vérifie que `bake` et `make` gèrent correctement les commentaires placés à différents endroits dans le fichier de règles. 
Les commentaires ne doivent pas perturber l'exécution du script 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-09-commentaires/
├── 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
│   ├── module.h      # Fichier d'en-tête
└── make/
    ├── Makefile      # Fichier de règles pour make
    ├── main.c        # Fichier source principal
    ├── module.c      # Fichier source du module
    └── module.h      # Fichier d'en-tête

```

## Contenu des fichiers de règles

Les fichiers `Makefile` et `Bakefile` contiennent les règles suivantes avec des commentaires placés à différents endroits :

```makefile
# Définition des variables
COMPILER = gcc  # On utilise gcc comme compilateur
CFLAGS = -Wall -Wextra  # Options de compilation
OUTPUT = program  # Nom de l'exécutable

# Liste des fichiers objets
OBJS = main.o module.o  # Chaque .o correspond à un fichier source

# Règle principale
$(OUTPUT): $(OBJS)  # L'exécutable dépend des fichiers objets
	$(COMPILER) $(CFLAGS) -o $(OUTPUT) $(OBJS)  # Compilation finale

# Compilation des fichiers objets
main.o: main.c  # Dépendance explicite
	$(COMPILER) $(CFLAGS) -c main.c -o main.o  # Compilation de main.c

module.o: module.c  # Autre dépendance
	$(COMPILER) $(CFLAGS) -c module.c -o module.o  # Compilation de module.c

# Nettoyage des fichiers générés
clean:  # Cible pour supprimer les fichiers de compilation
	rm -f $(OUTPUT) $(OBJS)  # Suppression des fichiers objets et de l'exécutable

# Fin du Bakefile
```

## Objectif du test

Ce test vérifie que `bake` et `make` interprètent correctement les commentaires sans affecter l'exécution du processus de compilation :
1. Vérifier que les commentaires sont ignorés et ne gênent pas l'exécution.
2. Confirmer que les fichiers sources sont bien compilés et l'exécutable est généré correctement.
3. Comparer les messages de sortie pour s'assurer que `bake` et `make` gèrent les commentaires de manière similaire.

## Comment exécuter le test

### Test manuel

1. Compilez avec Make : 
   ```bash
   cd make
   make
   ```

2. Exécutez l'exécutable :
   ```bash
   ./program
   ```

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

- Les deux outils doivent ignorer les commentaires et exécuter les commandes normalement.
- L'exécutable `program` doit être généré sans erreur.
- Les messages de sortie doivent indiquer que `bake` et `make` ont bien interprété le fichier de règles.
