diff --git a/tests/test-06-variables-on-cascade/README.md b/tests/test-06-variables-on-cascade/README.md index 8e505bf..ef88d31 100644 --- a/tests/test-06-variables-on-cascade/README.md +++ b/tests/test-06-variables-on-cascade/README.md @@ -7,7 +7,6 @@ Ce test vérifie la prise en charge des variables en cascade dans `bake` et `mak - [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) @@ -20,10 +19,9 @@ test-06-cascade/ │ ├── 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 -└── run_test06.sh # Programme de test automatique +└──make/ + ├── Makefile # Fichier de règles pour make + └── main.c # Fichier source C ``` ## Contenu des fichiers de règles @@ -52,20 +50,6 @@ Ce test vérifie que `bake` et `make` gèrent correctement les variables défini ## Comment exécuter le test -### Test automatique - -1. Rendez le script de test exécutable : - ```bash - chmod +x run_test06.sh - ``` - -2. Lancez le script de test : - ```bash - ./run_test06.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 : diff --git a/tests/test-07-dependency/README.md b/tests/test-07-dependency/README.md index 3772348..9540880 100644 --- a/tests/test-07-dependency/README.md +++ b/tests/test-07-dependency/README.md @@ -7,7 +7,6 @@ Ce test vérifie que si un fichier `.c` dépend de plusieurs fichiers `.h`, tout - [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) @@ -22,12 +21,12 @@ test-07-dependances/ │ ├── 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_test07.sh # Programme de test automatique +└── 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 @@ -72,20 +71,6 @@ Ce test vérifie que `bake` et `make` prennent en compte correctement les dépen ## Comment exécuter le test -### Test automatique - -1. Rendez le script de test exécutable : - ```bash - chmod +x run_test07.sh - ``` - -2. Lancez le script de test : - ```bash - ./run_test07.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 : diff --git a/tests/test-08-space-vs-tabulation/README.md b/tests/test-08-space-vs-tabulation/README.md index 03fa466..b71f45e 100644 --- a/tests/test-08-space-vs-tabulation/README.md +++ b/tests/test-08-space-vs-tabulation/README.md @@ -8,7 +8,6 @@ Un mauvais usage des espaces au lieu des tabulations devrait provoquer une erreu - [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) @@ -20,9 +19,9 @@ test-08-tabulations/ ├── bake/ │ ├── Bakefile # Fichier de règles pour bake │ ├── bakefile.jar # Exécutable de bake (JAR) -├── make/ -│ ├── Makefile # Fichier de règles pour make -└── run_test08.sh # Programme de test automatique +└── make/ + └── Makefile # Fichier de règles pour make + ``` ## Contenu des fichiers de règles @@ -47,20 +46,6 @@ Ce test vérifie que `bake` et `make` appliquent correctement la règle selon la ## Comment exécuter le test -### Test automatique - -1. Rendez le script de test exécutable : - ```bash - chmod +x run_test08.sh - ``` - -2. Lancez le script de test : - ```bash - ./run_test08.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 règle correcte avec Make : diff --git a/tests/test-09-handling-comment/README.md b/tests/test-09-handling-comment/README.md index db614ad..e0a90be 100644 --- a/tests/test-09-handling-comment/README.md +++ b/tests/test-09-handling-comment/README.md @@ -8,7 +8,6 @@ Les commentaires ne doivent pas perturber l'exécution du script de compilation. - [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) @@ -23,12 +22,12 @@ test-09-commentaires/ │ ├── 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 +└── 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 @@ -71,20 +70,6 @@ Ce test vérifie que `bake` et `make` interprètent correctement les commentaire ## 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 : diff --git a/tests/test-10-phony/README.md b/tests/test-10-phony/README.md index 4280dab..27dfc62 100644 --- a/tests/test-10-phony/README.md +++ b/tests/test-10-phony/README.md @@ -7,7 +7,6 @@ Ce test vérifie que `bake` et `make` gèrent correctement les cibles `.PHONY`, - [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) @@ -22,12 +21,12 @@ test-10-phony/ │ ├── 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 +└── 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 @@ -62,20 +61,6 @@ Ce test vérifie que `bake` et `make` gèrent correctement les cibles `.PHONY` : ## 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 : diff --git a/tests/test-11-error-in-code/README.md b/tests/test-11-error-in-code/README.md index 53d00c6..5061d7e 100644 --- a/tests/test-11-error-in-code/README.md +++ b/tests/test-11-error-in-code/README.md @@ -7,7 +7,6 @@ Ce test vérifie que `bake` et `make` affichent correctement les erreurs de comp - [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) @@ -20,10 +19,10 @@ test-11-erreurs/ │ ├── 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 +└── make/ + ├── Makefile # Fichier de règles pour make + └── main.c # Fichier source contenant des erreurs + ``` ## Contenu des fichiers de règles @@ -50,20 +49,6 @@ Ce test vérifie que `bake` et `make` : ## 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 : diff --git a/tests/test-12-file-dont-exist/README.md b/tests/test-12-file-dont-exist/README.md index e1712ba..3bf1e82 100644 --- a/tests/test-12-file-dont-exist/README.md +++ b/tests/test-12-file-dont-exist/README.md @@ -8,7 +8,6 @@ L'exécution doit afficher une erreur et stopper la compilation. - [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) @@ -21,10 +20,9 @@ test-12-fichier-manquant/ │ ├── 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 +└── make/ + ├── Makefile # Fichier de règles pour make + └── (main.c manquant) # Fichier source absent ``` ## Contenu des fichiers de règles @@ -51,20 +49,6 @@ Ce test vérifie que `bake` et `make` : ## 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 : diff --git a/tests/test-13-dependancy-dont-exist/README.md b/tests/test-13-dependancy-dont-exist/README.md index 5bee0fe..b8657ad 100644 --- a/tests/test-13-dependancy-dont-exist/README.md +++ b/tests/test-13-dependancy-dont-exist/README.md @@ -8,7 +8,6 @@ L'exécution doit afficher une erreur et stopper la compilation. - [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) @@ -22,11 +21,11 @@ test-13-dependance-inexistante/ │ ├── 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 +└── make/ + ├── Makefile # Fichier de règles pour make + ├── main.c # Fichier source principal + └── (test manquant) # Dépendance absente + ``` ## Contenu des fichiers de règles @@ -53,20 +52,6 @@ Ce test vérifie que `bake` et `make` : ## 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 : diff --git a/tests/test-15-subdir-build/README.md b/tests/test-15-subdir-build/README.md index 73af0b4..d15f21c 100644 --- a/tests/test-15-subdir-build/README.md +++ b/tests/test-15-subdir-build/README.md @@ -7,7 +7,6 @@ Ce test vérifie si `bake` et `make` peuvent compiler un fichier source situé d - [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) @@ -22,12 +21,11 @@ test-15-sous-repertoires/ │ ├── 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 +└── make/ + ├── Makefile # Fichier de règles pour make + ├── src/ + │ ├── main.c # Fichier source principal + └── build/ # Dossier où sera placé l'exécutable ``` ## Contenu des fichiers de règles @@ -53,20 +51,6 @@ Ce test vérifie que `bake` et `make` : ## 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 : diff --git a/tests/test-16-strange-variables/README.md b/tests/test-16-strange-variables/README.md index 0fdd3e6..2a2bd4f 100644 --- a/tests/test-16-strange-variables/README.md +++ b/tests/test-16-strange-variables/README.md @@ -8,7 +8,6 @@ avec un caractère de continuation (`\`). - [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) @@ -22,11 +21,11 @@ test-16-variables-multi-lignes/ │ ├── 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 +└── 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 @@ -66,20 +65,6 @@ Ce test vérifie que `bake` et `make` : ## 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 : diff --git a/tests/test-17-rule-without-command/README.md b/tests/test-17-rule-without-command/README.md index 4c29474..2a83f1d 100644 --- a/tests/test-17-rule-without-command/README.md +++ b/tests/test-17-rule-without-command/README.md @@ -8,7 +8,6 @@ dans les dépendances. - [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) @@ -20,9 +19,8 @@ test-17-rule-without-command/ ├── 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 +└── make/ + └── Makefile # Fichier de règles pour make ``` ## Contenu des fichiers de règles diff --git a/tests/test-18-path-characters/README.md b/tests/test-18-path-characters/README.md new file mode 100644 index 0000000..24d8b68 --- /dev/null +++ b/tests/test-18-path-characters/README.md @@ -0,0 +1,96 @@ +# Test 18 - Gestion des caractères spéciaux dans les chemins + +Ce test vérifie si `bake` et `make` gèrent correctement les chemins contenant divers types de caractères, +comme `~` pour le répertoire personnel, `/tmp/`, des chemins avec des barres obliques `/`, des tirets `-`, et des underscores `_`. + +## 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-18-path-characters/ +├── 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 +``` + +## Contenu des fichiers de règles + +Les fichiers `Makefile` et `Bakefile` contiennent les règles suivantes : + +```makefile +all: ~/temp/test.txt /tmp/test.txt ./path/with/slashes/test.txt path-with-dashes.txt path_with_underscores.txt + +~/temp/test.txt: + mkdir -p ~/temp + echo "Content in home directory" > ~/temp/test.txt + +/tmp/test.txt: + echo "Content in tmp directory" > /tmp/test.txt + +./path/with/slashes/test.txt: + mkdir -p ./path/with/slashes + echo "Content in path with slashes" > ./path/with/slashes/test.txt + +path-with-dashes.txt: + echo "Content in file with dashes" > path-with-dashes.txt + +path_with_underscores.txt: + echo "Content in file with underscores" > path_with_underscores.txt + +clean: + rm -rf ~/temp/test.txt /tmp/test.txt ./path/with/slashes path-with-dashes.txt path_with_underscores.txt +``` + +## Objectif du test + +Ce test vérifie que `bake` et `make` : +1. Interprètent correctement les chemins contenant des caractères spéciaux comme `~`, `/`, `-`, et `_`. +2. Créent les fichiers aux emplacements indiqués. +3. Nettoient correctement les fichiers avec la cible `clean`. +4. Comparent les messages de sortie pour s'assurer que `bake` et `make` gèrent les chemins de manière identique. + +## Comment exécuter le test + +### Test manuel + +1. Générez les fichiers avec Make : + ```bash + cd make + make + ``` + Tous les fichiers doivent être créés aux emplacements spécifiés. + +2. Vérifiez que les fichiers existent : + ```bash + ls ~/temp/test.txt /tmp/test.txt ./path/with/slashes/test.txt path-with-dashes.txt path_with_underscores.txt + ``` + +3. Faites la même procédure avec Bake : + ```bash + cd bake + java -cp bakefile.jar fr.monlouyan.bakefile.Main + ``` + +4. Exécutez le nettoyage : + ```bash + make clean + ``` + Tous les fichiers doivent être supprimés. + +5. Comparez les résultats et les messages affichés. + +## Résultats attendus + +- `bake` et `make` doivent interpréter correctement les chemins et créer les fichiers sans erreur. +- Tous les fichiers doivent être créés aux bons emplacements. +- La cible `clean` doit supprimer correctement tous les fichiers. diff --git a/tests/test-19-multiple-targets/README.md b/tests/test-19-multiple-targets/README.md new file mode 100644 index 0000000..2205ff4 --- /dev/null +++ b/tests/test-19-multiple-targets/README.md @@ -0,0 +1,94 @@ +# Test 19 - Gestion des cibles multiples + +Ce test vérifie si `bake` et `make` gèrent correctement les règles ayant plusieurs cibles et leurs 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 manuel](#test-manuel) +- [Résultats attendus](#résultats-attendus) + +## Structure du test + +``` +test-19-multiple-targets/ +├── 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 +``` + +## Contenu des fichiers de règles + +Les fichiers `Makefile` et `Bakefile` contiennent les règles suivantes : + +```makefile +# Règle avec plusieurs cibles et sans dépendance +target1 target2 target3: + echo "Première règle avec 3 cibles séparées par des espaces" + touch target1 target2 target3 + +# Règle avec plusieurs cibles et avec dépendances +file1 file2: target1 target2 + echo "Deuxième règle avec 2 cibles et 2 dépendances" + echo "Contenu 1" > file1 + echo "Contenu 2" > file2 + +# Règle avec une seule cible et plusieurs dépendances +final: file1 file2 target3 + echo "Règle finale qui dépend de tout le reste" + cat file1 file2 > final + +# Règle pour nettoyer +clean: + rm -f target1 target2 target3 file1 file2 final +``` + +## Objectif du test + +Ce test vérifie que `bake` et `make` : +1. Interprètent correctement les règles ayant plusieurs cibles. +2. Créent toutes les cibles indiquées par une même règle. +3. Exécutent les dépendances dans l'ordre correct. +4. Produisent un fichier final `final` contenant les résultats de `file1` et `file2`. +5. Suppriment correctement tous les fichiers avec la cible `clean`. + +## Comment exécuter le test + +### Test manuel + +1. Exécutez la compilation avec Make : + ```bash + cd make + make + ``` + Tous les fichiers doivent être créés correctement. + +2. Vérifiez que `final` contient bien les contenus de `file1` et `file2` : + ```bash + cat final + ``` + +3. Faites la même procédure avec Bake : + ```bash + cd bake + java -cp bakefile.jar fr.monlouyan.bakefile.Main + ``` + +4. Exécutez le nettoyage : + ```bash + make clean + ``` + Tous les fichiers doivent être supprimés. + +5. Comparez les résultats et les messages affichés. + +## Résultats attendus + +- `bake` et `make` doivent interpréter correctement les règles avec plusieurs cibles. +- Tous les fichiers doivent être créés aux bons emplacements. +- La cible `clean` doit supprimer correctement tous les fichiers. diff --git a/tests/test-20-circular-2/README.md b/tests/test-20-circular-2/README.md new file mode 100644 index 0000000..7e1ddbf --- /dev/null +++ b/tests/test-20-circular-2/README.md @@ -0,0 +1,72 @@ +# Test 20 - Gestion des dépendances circulaires (cas 2) + +Ce test vérifie si `bake` et `make` gèrent correctement les dépendances circulaires, c'est-à-dire lorsqu'une cible dépend directement ou indirectement d'elle-même. + +## 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-20-circular-2/ +├── 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 +``` + +## Contenu des fichiers de règles + +Les fichiers `Makefile` et `Bakefile` contiennent les règles suivantes : + +```makefile +all: A + +A: B C + echo "Building A" + +B: C + echo "Building B" + +C: A + echo "Building C" +``` + +## Objectif du test + +Ce test vérifie que `bake` et `make` : +1. Détectent correctement la boucle circulaire entre `A`, `B` et `C`. +2. Affichent un message d'erreur explicite indiquant la présence d'une dépendance circulaire. +3. Empêchent l'exécution infinie de la compilation. +4. Comparent les messages de sortie pour s'assurer que `bake` et `make` ont un comportement similaire. + +## Comment exécuter le test + +### Test manuel + +1. Essayez de compiler avec Make : + ```bash + cd make + make + ``` + Une erreur de dépendance circulaire doit apparaître. + +2. Faites la même procédure avec Bake : + ```bash + cd bake + java -cp bakefile.jar fr.monlouyan.bakefile.Main + ``` + Un message d'erreur similaire doit s'afficher. + +## Résultats attendus + +- `bake` et `make` doivent afficher une erreur indiquant la boucle circulaire. +- L'exécution doit être stoppée immédiatement. +- `bake` et `make` doivent avoir un comportement similaire face aux dépendances circulaires. diff --git a/tests/test-21-generate/README.md b/tests/test-21-generate/README.md new file mode 100644 index 0000000..03b6439 --- /dev/null +++ b/tests/test-21-generate/README.md @@ -0,0 +1,79 @@ +# Test 21 - Génération de fichiers dans le processus de build + +Ce test vérifie si `bake` et `make` gèrent correctement la génération de fichiers intermédiaires +dans le processus de construction, notamment lorsqu'un script est généré avant d'être exécuté. + +## 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-21-generate/ +├── 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 + +``` + +## Contenu des fichiers de règles + +Les fichiers `Makefile` et `Bakefile` contiennent les règles suivantes : + +```makefile +all: output.txt + +output.txt: generate.sh + bash generate.sh > output.txt + +generate.sh: + echo "echo 'Hello, World!'" > generate.sh + chmod +x generate.sh +``` + +## Objectif du test + +Ce test vérifie que `bake` et `make` : +1. Génèrent correctement le script `generate.sh` avant de l'exécuter. +2. Exécutent `generate.sh` pour produire `output.txt`. +3. S'assurent que `output.txt` contient bien `Hello, World!`. +4. Comparent les messages de sortie pour s'assurer que `bake` et `make` gèrent ce cas de manière identique. + +## Comment exécuter le test + +### Test manuel + +1. Exécutez la compilation avec Make : + ```bash + cd make + make + ``` + Le fichier `output.txt` doit être généré. + +2. Vérifiez son contenu : + ```bash + cat output.txt + ``` + Il doit afficher `Hello, World!`. + +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 générer correctement `generate.sh` avant de l'exécuter. +- `output.txt` doit être créé et contenir `Hello, World!`. +- Les messages de sortie doivent indiquer que le script a été exécuté correctement. diff --git a/tests/test-22-future-timestamp/README.md b/tests/test-22-future-timestamp/README.md index 1eefdd6..ab0d43b 100644 --- a/tests/test-22-future-timestamp/README.md +++ b/tests/test-22-future-timestamp/README.md @@ -8,7 +8,6 @@ Ce test vérifie le comportement de `bake` comparé à `make` lorsque le fichier - [Objectif du test](#objectif-du-test) - [Scénario de test](#scénario-de-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) - [Explications techniques](#explications-techniques) @@ -22,10 +21,9 @@ test-22-future-timestamp/ │ ├── Bakefile # Fichier de règles pour bake │ ├── bakefile.jar # Exécutable de bake (JAR) │ └── main.c # Fichier source C (avec timestamp dans le futur) -├── make/ -│ ├── Makefile # Fichier de règles pour make -│ └── main.c # Fichier source C (avec timestamp dans le futur) -└── run_test22.sh # Programme de test automatique +└── make/ + ├── Makefile # Fichier de règles pour make + └── main.c # Fichier source C (avec timestamp dans le futur) ``` ## Contenu des fichiers de règles @@ -51,20 +49,6 @@ Le test suit les étapes suivantes : ## Comment exécuter le test -### Test automatique - -1. Rendez le script de test exécutable : - ``` - chmod +x run_test22.sh - ``` - -2. Lancez le script de test : - ``` - ./run_test22.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. Pour Make : diff --git a/tests/test-23-identical-timestamps/README.md b/tests/test-23-identical-timestamps/README.md new file mode 100644 index 0000000..4b8b029 --- /dev/null +++ b/tests/test-23-identical-timestamps/README.md @@ -0,0 +1,89 @@ +# Test 23 - Gestion des timestamps identiques + +Ce test vérifie le comportement de `bake` comparé à `make` lorsque le fichier source et la cible ont des timestamps strictement identiques. + +## 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) +- [Scénario de test](#scénario-de-test) +- [Comment exécuter le test](#comment-exécuter-le-test) + - [Test manuel](#test-manuel) +- [Résultats attendus](#résultats-attendus) +- [Explications techniques](#explications-techniques) + +## Structure du test + +``` +test-23-identical-timestamps/ +├── README.md # Ce fichier +├── bake/ +│ ├── Bakefile # Fichier de règles pour bake +│ ├── bakefile.jar # Exécutable de bake (JAR) +│ ├── input.txt # Fichier source +│ ├── output.txt # Fichier cible (avec timestamp identique) +└── make/ + ├── Makefile # Fichier de règles pour make + ├── input.txt # Fichier source + └── output.txt # Fichier cible (avec timestamp identique) +``` + +## Contenu des fichiers de règles + +Les fichiers `Makefile` et `Bakefile` contiennent les mêmes règles simples : + +```makefile +all: output.txt + +output.txt: input.txt + cat input.txt > output.txt + +input.txt: + echo "Test" > input.txt +``` + +## Objectif du test + +Ce test vérifie que `bake` se comporte comme `make` face à un cas particulier : quand le fichier source `input.txt` et la cible `output.txt` ont exactement le même timestamp. Ce scénario peut se produire lors de synchronisations de fichiers rapides ou d'opérations automatisées qui modifient simultanément les fichiers source et cible. + +## Scénario de test + +Le test suit les étapes suivantes : +1. Créer le fichier source `input.txt` +2. Générer la cible `output.txt` à partir du fichier source +3. Aligner les timestamps des deux fichiers pour qu'ils soient identiques +4. Exécuter `make` et `bake` pour observer s'ils considèrent la cible comme à jour + +## Comment exécuter le test + +### Test manuel + +1. Pour Make : + ```bash + cd make + make + # Aligner les timestamps des fichiers + touch -r input.txt output.txt + make + ``` + +2. Pour Bake : + ```bash + cd bake + java -cp bakefile.jar fr.monlouyan.bakefile.Main + # Aligner les timestamps des fichiers + touch -r input.txt output.txt + java -cp bakefile.jar fr.monlouyan.bakefile.Main + ``` + +3. Comparez visuellement les deux résultats. + +## Résultats attendus + +- `make` et `bake` devraient considérer `output.txt` comme à jour et ne pas le reconstruire. +- Aucun message de recompilation ne devrait apparaître après la synchronisation des timestamps. +- Si `bake` ou `make` reconstruisent `output.txt`, cela indique une différence dans leur gestion des timestamps identiques. + +## Explications techniques + +En fonctionnement normal, `make` et `bake` vérifient la date de modification des fichiers pour déterminer s'il faut recompiler une cible. Lorsque la cible et sa dépendance ont le même timestamp, la cible est considérée à jour, et aucune action n'est entreprise. Ce test vérifie que `bake` suit bien cette logique. diff --git a/tests/test-24-50target/README.md b/tests/test-24-50target/README.md new file mode 100644 index 0000000..be2b3f3 --- /dev/null +++ b/tests/test-24-50target/README.md @@ -0,0 +1,86 @@ +# Test 24 - Chaîne de dépendances longues + +Ce test vérifie la manière dont `bake` et `make` gèrent une longue série de dépendances en cascade, où chaque cible dépend de la précédente. + +## 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) +- [Scénario de test](#scénario-de-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-24-long-dependency-chain/ +├── 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 +``` + +## Contenu des fichiers de règles + +Les fichiers `Makefile` et `Bakefile` contiennent une longue chaîne de dépendances comme suit : + +```makefile +all: target50 + +target50: target49 + echo "Building target50" + +target49: target48 + echo "Building target49" + +... + +target2: target1 + echo "Building target2" + +target1: + echo "Building target1" +``` + +## Objectif du test + +Ce test vérifie que `bake` et `make` : +1. Résolvent correctement une longue chaîne de dépendances. +2. Exécutent les cibles dans le bon ordre, en commençant par `target1` jusqu'à `target50`. +3. Ne rencontrent pas de limitations de profondeur de résolution des dépendances. +4. Comparent les messages de sortie pour s'assurer que `bake` et `make` ont le même comportement. + +## Scénario de test + +1. Exécuter `make` et `bake` sans fichiers préexistants pour observer la construction de toutes les cibles. +2. Réexécuter `make` et `bake` pour voir s'ils détectent que toutes les cibles sont déjà construites et n'ont pas besoin d'être reconstituées. + +## Comment exécuter le test + +### Test manuel + +1. Exécutez la compilation avec Make : + ```bash + cd make + make + ``` + Toutes les cibles de `target1` à `target50` doivent être construites dans l'ordre. + +2. Faites la même procédure avec Bake : + ```bash + cd bake + java -cp bakefile.jar fr.monlouyan.bakefile.Main + ``` + +3. Réexécutez `make` et `bake` sans supprimer les fichiers pour voir s'ils détectent que tout est déjà construit. + +4. Comparez les résultats et les messages affichés. + +## Résultats attendus + +- `bake` et `make` doivent exécuter les cibles dans le bon ordre. +- Une exécution répétée de `make` et `bake` ne doit rien reconstruire si rien n'a changé. +- Les messages de sortie doivent être identiques entre `bake` et `make`.