diff --git a/tests/C/test-09-handling-comment/README.md b/tests/C/test-09-handling-comment/README.md index a340aa1..db614ad 100644 --- a/tests/C/test-09-handling-comment/README.md +++ b/tests/C/test-09-handling-comment/README.md @@ -1 +1,113 @@ -On fait un test pour voir si le makefile gère bien les commentaires (ils peuvent être placée un peu partout) \ No newline at end of file +# 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 automatique](#test-automatique) + - [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 +└── run_test09.sh # Programme de test automatique +``` + +## 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 automatique + +1. Rendez le script de test exécutable : + ```bash + chmod +x run_test09.sh + ``` + +2. Lancez le script de test : + ```bash + ./run_test09.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. 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. diff --git a/tests/C/test-10-phony/README.md b/tests/C/test-10-phony/README.md new file mode 100644 index 0000000..4280dab --- /dev/null +++ b/tests/C/test-10-phony/README.md @@ -0,0 +1,106 @@ +# Test 10 - Gestion des cibles .PHONY + +Ce test vérifie que `bake` et `make` gèrent correctement les cibles `.PHONY`, qui ne correspondent pas à des fichiers mais à des commandes spécifiques comme `clean`. + +## 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-10-phony/ +├── 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 +└── run_test10.sh # Programme de test automatique +``` + +## Contenu des fichiers de règles + +Les fichiers `Makefile` et `Bakefile` contiennent les règles suivantes, incluant une cible `.PHONY` pour `clean` : + +```makefile +.PHONY: clean + +all: program + +program: main.o module.o + gcc -o program main.o module.o + +main.o: main.c + gcc -c main.c -o main.o + +module.o: module.c + gcc -c module.c -o module.o + +clean: + rm -f program main.o module.o + echo "Clean executed!" +``` + +## Objectif du test + +Ce test vérifie que `bake` et `make` gèrent correctement les cibles `.PHONY` : +1. La cible `clean` doit toujours s'exécuter même si les fichiers à supprimer n'existent pas. +2. La compilation doit fonctionner normalement et générer l'exécutable `program`. +3. Comparer les messages de sortie pour s'assurer que `bake` et `make` gèrent `.PHONY` de la même manière. + +## Comment exécuter le test + +### Test automatique + +1. Rendez le script de test exécutable : + ```bash + chmod +x run_test10.sh + ``` + +2. Lancez le script de test : + ```bash + ./run_test10.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. Exécutez la cible `clean` : + ```bash + make clean + ``` + Vous devez voir `Clean executed!` affiché. + +3. Faites la même procédure avec Bake : + ```bash + cd bake + java -cp bakefile.jar fr.monlouyan.bakefile.Main clean + ``` + +4. Comparez les résultats et les messages affichés. + +## Résultats attendus + +- `make clean` et `bake clean` doivent exécuter la commande de nettoyage sans erreur. +- `Clean executed!` doit s'afficher après l'exécution de la cible `clean`. +- `make all` et `bake all` doivent compiler correctement le programme. +- Si `bake` ne gère pas correctement `.PHONY`, la cible `clean` pourrait ne pas s'exécuter ou ne pas fonctionner correctement. diff --git a/tests/C/test-11-error-in-code/README.md b/tests/C/test-11-error-in-code/README.md index 306987e..53d00c6 100644 --- a/tests/C/test-11-error-in-code/README.md +++ b/tests/C/test-11-error-in-code/README.md @@ -1 +1,87 @@ -Quand il y a une erreur dans le code, ça affiche l'erreur + stop le programme exactement comme make. \ No newline at end of file +# Test 11 - Gestion des erreurs de compilation + +Ce test vérifie que `bake` et `make` affichent correctement les erreurs de compilation et stoppent l'exécution en cas d'erreur, comme le ferait `make`. + +## 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-11-erreurs/ +├── README.md # Ce fichier +├── bake/ +│ ├── Bakefile # Fichier de règles pour bake +│ ├── bakefile.jar # Exécutable de bake (JAR) +│ ├── main.c # Fichier source contenant des erreurs +├── make/ +│ ├── Makefile # Fichier de règles pour make +│ ├── main.c # Fichier source contenant des erreurs +└── run_test11.sh # Programme de test automatique +``` + +## Contenu des fichiers de règles + +Les fichiers `Makefile` et `Bakefile` contiennent les règles suivantes : + +```makefile +all: main + +main: main.c + gcc -o main main.c + +clean: + rm -f main +``` + +## Objectif du test + +Ce test vérifie que `bake` et `make` : +1. Détectent correctement les erreurs de compilation dans `main.c`. +2. Affichent les messages d'erreur correspondants. +3. Arrêtent l'exécution du processus de compilation en cas d'erreur. +4. Comparent les messages de sortie pour s'assurer que `bake` et `make` gèrent les erreurs de manière similaire. + +## Comment exécuter le test + +### Test automatique + +1. Rendez le script de test exécutable : + ```bash + chmod +x run_test11.sh + ``` + +2. Lancez le script de test : + ```bash + ./run_test11.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. Essayez de compiler avec Make : + ```bash + cd make + make + ``` + Vous devriez voir une erreur de compilation et l'arrêt du programme. + +2. Faites la même procédure avec Bake : + ```bash + cd bake + java -cp bakefile.jar fr.monlouyan.bakefile.Main + ``` + Vous devriez voir une erreur de compilation similaire et l'arrêt du programme. + +## Résultats attendus + +- `make` et `bake` doivent afficher les erreurs de compilation. +- L'exécution doit s'arrêter sans produire d'exécutable `main`. +- `bake` et `make` doivent avoir un comportement similaire dans la gestion des erreurs. diff --git a/tests/C/test-12-file-dont-exist/README.md b/tests/C/test-12-file-dont-exist/README.md new file mode 100644 index 0000000..e1712ba --- /dev/null +++ b/tests/C/test-12-file-dont-exist/README.md @@ -0,0 +1,88 @@ +# Test 12 - Gestion des fichiers manquants + +Ce test vérifie que `bake` et `make` gèrent correctement les cas où un fichier source requis est absent. +L'exécution doit afficher une erreur et stopper la 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 automatique](#test-automatique) + - [Test manuel](#test-manuel) +- [Résultats attendus](#résultats-attendus) + +## Structure du test + +``` +test-12-fichier-manquant/ +├── README.md # Ce fichier +├── bake/ +│ ├── Bakefile # Fichier de règles pour bake +│ ├── bakefile.jar # Exécutable de bake (JAR) +│ ├── (main.c manquant) # Fichier source absent +├── make/ +│ ├── Makefile # Fichier de règles pour make +│ ├── (main.c manquant) # Fichier source absent +└── run_test12.sh # Programme de test automatique +``` + +## Contenu des fichiers de règles + +Les fichiers `Makefile` et `Bakefile` contiennent les règles suivantes : + +```makefile +all: main + +main: main.c + gcc -o main main.c + +clean: + rm -f main +``` + +## Objectif du test + +Ce test vérifie que `bake` et `make` : +1. Détectent l'absence du fichier `main.c`. +2. Affichent une erreur explicite indiquant l'absence du fichier requis. +3. Stoppent l'exécution du processus de compilation. +4. Comparent les messages de sortie pour s'assurer que `bake` et `make` gèrent l'erreur de manière similaire. + +## Comment exécuter le test + +### Test automatique + +1. Rendez le script de test exécutable : + ```bash + chmod +x run_test12.sh + ``` + +2. Lancez le script de test : + ```bash + ./run_test12.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. Essayez de compiler avec Make : + ```bash + cd make + make + ``` + Vous devriez voir une erreur indiquant que `main.c` est manquant. + +2. Faites la même procédure avec Bake : + ```bash + cd bake + java -cp bakefile.jar fr.monlouyan.bakefile.Main + ``` + Vous devriez voir une erreur similaire et l'arrêt du programme. + +## Résultats attendus + +- `make` et `bake` doivent afficher une erreur indiquant que `main.c` est absent. +- L'exécution doit s'arrêter sans produire d'exécutable `main`. +- `bake` et `make` doivent avoir un comportement similaire dans la gestion des fichiers manquants. diff --git a/tests/C/test-13-dependancy-dont-exist/README.md b/tests/C/test-13-dependancy-dont-exist/README.md new file mode 100644 index 0000000..5bee0fe --- /dev/null +++ b/tests/C/test-13-dependancy-dont-exist/README.md @@ -0,0 +1,90 @@ +# Test 13 - Gestion des dépendances inexistantes + +Ce test vérifie que `bake` et `make` gèrent correctement les cas où une dépendance requise est absente. +L'exécution doit afficher une erreur et stopper la 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 automatique](#test-automatique) + - [Test manuel](#test-manuel) +- [Résultats attendus](#résultats-attendus) + +## Structure du test + +``` +test-13-dependance-inexistante/ +├── README.md # Ce fichier +├── bake/ +│ ├── Bakefile # Fichier de règles pour bake +│ ├── bakefile.jar # Exécutable de bake (JAR) +│ ├── main.c # Fichier source principal +│ ├── (test manquant) # Dépendance absente +├── make/ +│ ├── Makefile # Fichier de règles pour make +│ ├── main.c # Fichier source principal +│ ├── (test manquant) # Dépendance absente +└── run_test13.sh # Programme de test automatique +``` + +## Contenu des fichiers de règles + +Les fichiers `Makefile` et `Bakefile` contiennent les règles suivantes : + +```makefile +all: main + +main: main.c test + gcc -o main main.c + +clean: + rm -f main +``` + +## Objectif du test + +Ce test vérifie que `bake` et `make` : +1. Détectent l'absence du fichier `test`. +2. Affichent une erreur explicite indiquant l'absence de la dépendance requise. +3. Stoppent l'exécution du processus de compilation. +4. Comparent les messages de sortie pour s'assurer que `bake` et `make` gèrent l'erreur de manière similaire. + +## Comment exécuter le test + +### Test automatique + +1. Rendez le script de test exécutable : + ```bash + chmod +x run_test13.sh + ``` + +2. Lancez le script de test : + ```bash + ./run_test13.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. Essayez de compiler avec Make : + ```bash + cd make + make + ``` + Vous devriez voir une erreur indiquant que `test` est manquant. + +2. Faites la même procédure avec Bake : + ```bash + cd bake + java -cp bakefile.jar fr.monlouyan.bakefile.Main + ``` + Vous devriez voir une erreur similaire et l'arrêt du programme. + +## Résultats attendus + +- `make` et `bake` doivent afficher une erreur indiquant que `test` est absent. +- L'exécution doit s'arrêter sans produire d'exécutable `main`. +- `bake` et `make` doivent avoir un comportement similaire dans la gestion des dépendances manquantes. diff --git a/tests/C/test-15-subdir-build/README.md b/tests/C/test-15-subdir-build/README.md index 74d0d6f..73af0b4 100644 --- a/tests/C/test-15-subdir-build/README.md +++ b/tests/C/test-15-subdir-build/README.md @@ -1 +1,97 @@ -En gros, on vérifie si bake arrive à compiler un fichier qui est dans un sous répertoire (src) et mettre le résultat de la compilation dans un sous répertoire (build) \ No newline at end of file +# Test 15 - Compilation avec sous-répertoires + +Ce test vérifie si `bake` et `make` peuvent compiler un fichier source situé dans un sous-répertoire (`src/`) et placer l'exécutable résultant dans un autre sous-répertoire (`build/`). + +## 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-15-sous-repertoires/ +├── README.md # Ce fichier +├── bake/ +│ ├── Bakefile # Fichier de règles pour bake +│ ├── bakefile.jar # Exécutable de bake (JAR) +│ ├── src/ +│ │ ├── main.c # Fichier source principal +│ ├── build/ # Dossier où sera placé l'exécutable +├── make/ +│ ├── Makefile # Fichier de règles pour make +│ ├── src/ +│ │ ├── main.c # Fichier source principal +│ ├── build/ # Dossier où sera placé l'exécutable +└── run_test15.sh # Programme de test automatique +``` + +## Contenu des fichiers de règles + +Les fichiers `Makefile` et `Bakefile` contiennent les règles suivantes : + +```makefile +CC = gcc +CFLAGS = -Wall -Wextra + +build/main: src/main.c + mkdir -p build + $(CC) $(CFLAGS) -o build/main src/main.c +``` + +## Objectif du test + +Ce test vérifie que `bake` et `make` : +1. Reconnaissent que le fichier source est situé dans un sous-répertoire (`src/`). +2. Créent le répertoire `build/` si celui-ci n'existe pas. +3. Compilent `main.c` et placent l'exécutable dans `build/main`. +4. Comparent les messages de sortie pour s'assurer que `bake` et `make` gèrent correctement les sous-répertoires. + +## Comment exécuter le test + +### Test automatique + +1. Rendez le script de test exécutable : + ```bash + chmod +x run_test15.sh + ``` + +2. Lancez le script de test : + ```bash + ./run_test15.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 + ``` + L'exécutable `build/main` doit être généré. + +2. Exécutez le programme compilé : + ```bash + ./build/main + ``` + Vous devriez voir `Hello from Bake & Make!` affiché. + +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 compiler le programme sans erreur. +- L'exécutable `build/main` doit être généré et exécutable. +- `Hello from Bake & Make!` doit être affiché lors de l'exécution du programme. diff --git a/tests/C/test-16-strange-variables/README.md b/tests/C/test-16-strange-variables/README.md index ac524a9..0fdd3e6 100644 --- a/tests/C/test-16-strange-variables/README.md +++ b/tests/C/test-16-strange-variables/README.md @@ -1,5 +1,110 @@ -test avec des variables sur plusieurs lignes +# Test 16 - Gestion des variables sur plusieurs lignes -au lieu de : -ansi -pedantic -on a : -ansi \ - -pendantic \ No newline at end of file +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 automatique](#test-automatique) + - [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 +└── run_test16.sh # Programme de test automatique +``` + +## 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 automatique + +1. Rendez le script de test exécutable : + ```bash + chmod +x run_test16.sh + ``` + +2. Lancez le script de test : + ```bash + ./run_test16.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 + ``` + 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. diff --git a/tests/C/test-17-rule-without-command/README.md b/tests/C/test-17-rule-without-command/README.md index e69de29..4c29474 100644 --- a/tests/C/test-17-rule-without-command/README.md +++ b/tests/C/test-17-rule-without-command/README.md @@ -0,0 +1,88 @@ +# Test 17 - Règles sans commandes + +Ce test vérifie si `bake` et `make` gèrent correctement les règles sans commandes et leur propagation +dans les dépendances. + +## 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-17-rule-without-command/ +├── README.md # Ce fichier +├── bake/ +│ ├── Bakefile # Fichier de règles pour bake +│ ├── bakefile.jar # Exécutable de bake (JAR) +├── make/ +│ ├── Makefile # Fichier de règles pour make +└── run_test17.sh # Programme de test automatique +``` + +## Contenu des fichiers de règles + +Les fichiers `Makefile` et `Bakefile` contiennent les règles suivantes : + +```makefile +all: dep1 dep2 + +dep1: + +dep2: dep3 + +dep3: + touch dep3 +``` + +## Objectif du test + +Ce test vérifie que `bake` et `make` : +1. Gèrent correctement les règles sans commandes explicites. +2. Exécutent correctement les dépendances lorsque c'est nécessaire. +3. Exécutent uniquement les règles qui ont des commandes (ici `dep3`). +4. Comparent les messages de sortie pour s'assurer que `bake` et `make` ont le même comportement. + +## Comment exécuter le test + +### Test automatique + +1. Rendez le script de test exécutable : + ```bash + chmod +x run_test17.sh + ``` + +2. Lancez le script de test : + ```bash + ./run_test17.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. Exécutez la compilation avec Make : + ```bash + cd make + make + ``` + Seule `dep3` doit être exécutée (avec `touch dep3`). + +2. Faites la même procédure 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 + +- `bake` et `make` doivent traiter correctement les règles sans commandes. +- Seule la règle `dep3` doit exécuter `touch dep3`. +- Aucune erreur ne doit être affichée.