# Test 07 - Dépendances multiples

Ce test vérifie que si un fichier `.c` dépend de plusieurs fichiers `.h`, toute modification d'un `.h` entraîne la recompilation du fichier `.c` concerné.

## 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-07-dependances/
├── 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 :

```makefile
CC = gcc
CFLAGS = -Wall -Wextra -Werror

# Règle par défaut
all: program

# Compilation de l'exécutable
program: main.o module.o
	$(CC) $(CFLAGS) -o program main.o module.o

# Compilation des fichiers .c en .o
main.o: main.c module.h
	$(CC) $(CFLAGS) -c main.c -o main.o

module.o: module.c module.h
	$(CC) $(CFLAGS) -c module.c -o module.o

# Nettoyage des fichiers objets et de l'exécutable
clean:
	rm -f main.o module.o program

# Nettoyage complet
mrproper: clean

# Force la recompilation
rebuild: clean all
```

## Objectif du test

Ce test vérifie que `bake` et `make` prennent en compte correctement les dépendances multiples :
1. Modifier le fichier `module.h` doit entraîner la recompilation de `main.o` et `module.o`.
2. Exécuter `make` ou `bake` sans modification ne doit rien recompiler.
3. Comparer les messages de sortie pour s'assurer que `bake` et `make` gèrent les dépendances de manière similaire.

## Comment exécuter le test

### Test manuel

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

2. Modifiez `module.h` :
   ```bash
   echo "// Modification pour test" >> module.h
   ```

3. Recompilez avec Make :
   ```bash
   make
   ```

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

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

## Résultats attendus

- Les deux outils devraient détecter les modifications de `module.h` et recompiler `main.o` et `module.o`.
- Sans modification, `bake` et `make` ne doivent pas relancer la compilation.
- Les messages de sortie devraient indiquer clairement quelles parties du programme ont été recompilées.
- Si `bake` ne gère pas correctement les dépendances, il pourrait ne pas recompiler les fichiers nécessaires ou les recompiler inutilement.