From 7a2b69fba174d6d96cabb981d86413abee4c1fcf Mon Sep 17 00:00:00 2001 From: Louay DARDOURI <louay.dardouri@etu.u-pec.fr> Date: Sun, 16 Mar 2025 12:15:34 +0100 Subject: [PATCH] readme test 26 27 28 29 30 31 32 et modif README TEST --- tests/README.md | 14 ++- tests/test-26-rule-in-rule/README.md | 82 +++++++++++++ tests/test-27-conditions-if/README.md | 99 ++++++++++++++++ tests/test-28-silent/README.md | 74 ++++++++++++ tests/test-29-variable-dont-exist/README.md | 77 +++++++++---- .../README.md | 49 ++++++++ .../README_Test_30 (3).md | 64 +++++++++++ tests/test-31-redirection/README.md | 108 +++++++++++++++++- tests/test-32-exit/README.md | 58 ++++++++++ 9 files changed, 600 insertions(+), 25 deletions(-) create mode 100644 tests/test-26-rule-in-rule/README.md create mode 100644 tests/test-27-conditions-if/README.md create mode 100644 tests/test-28-silent/README.md create mode 100644 tests/test-30-command-chaining-operators/README.md create mode 100644 tests/test-30-command-chaining-operators/README_Test_30 (3).md create mode 100644 tests/test-32-exit/README.md diff --git a/tests/README.md b/tests/README.md index 8f9abd5..c326607 100644 --- a/tests/README.md +++ b/tests/README.md @@ -4,8 +4,8 @@ Cette suite de tests compare le comportement de `bake` à celui de `make` pour v ## Table des tests -| N° | Nom du test | Description | -|----|-------------|-------------| +| N° | Nom du test | Description | +|---- |-------------|-------------| | [01](#test-01-from-nothing) | Compilation depuis zéro | Vérifie la compilation d'un programme à partir de rien | | [02](#test-02-already-exist) | Fichier déjà existant | Teste le comportement quand l'exécutable est déjà présent | | [03](#test-03-circular) | Dépendances circulaires | Teste la détection des dépendances circulaires | @@ -37,6 +37,10 @@ Cette suite de tests compare le comportement de `bake` à celui de `make` pour v | [29](#test-29-variable-dont-exist) | Variables inexistantes | Teste le comportement lorsqu'une variable non définie est utilisée | | [30](#test-30-command-chaining-operators) | Chaînage de commandes | Vérifie l'utilisation des opérateurs `&&`, `||`, `;` | | [31](#test-31-redirection) | Redirections I/O | Vérifie la gestion des redirections (`>`, `>>`, `<`) et pipes (`|`) | +| [32](#test-32-exit) | Gestion de `exit` | Teste le comportement des commandes `exit` pour arrêter l'exécution | + +## Détails des nouveaux tests + ## Détails des tests @@ -194,3 +198,9 @@ Vérifie l'utilisation des opérateurs `&&`, `||` et `;` pour chaîner plusieurs [Test détaillé](test-31-redirection/) Teste la gestion des redirections d'entrée et de sortie (`>`, `>>`, `<`) ainsi que des pipes (`|`) dans `bake` et `make`. + + +### Test 32: Gestion de `exit` +[Test détaillé](test-32-exit/) + +Vérifie comment `bake` et `make` gèrent les commandes `exit` qui arrêtent l'exécution. \ No newline at end of file diff --git a/tests/test-26-rule-in-rule/README.md b/tests/test-26-rule-in-rule/README.md new file mode 100644 index 0000000..965b5fa --- /dev/null +++ b/tests/test-26-rule-in-rule/README.md @@ -0,0 +1,82 @@ +# Test 26 - Règle imbriquée dans une autre règle + +Ce test vérifie comment `bake` et `make` gèrent les règles imbriquées (c'est-à-dire lorsqu'une règle dépend d'une autre qui est également une règle). + +## 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-26-rule-in-rule/ +├── README.md # Ce fichier +├── bake/ +│ ├── Bakefile # Fichier de règles pour bake +│ ├── bakefile.jar # Exécutable de bake (JAR) +│ ├── Main.java # Fichier source +│ ├── Main.class # Fichier compilé +├── make/ +│ ├── Makefile # Fichier de règles pour make +│ ├── Main.java # Fichier source +│ ├── Main.class # Fichier compilé +``` + +## Contenu des fichiers de règles + +Les fichiers `Makefile` et `Bakefile` contiennent la règle suivante : + +```makefile +Main.class: Main.java + javac Main.java -Xlint:unchecked +``` + +## Objectif du test + +Ce test a pour but de vérifier que `bake` et `make` : +1. Gèrent correctement les dépendances entre règles. +2. Recompilent `Main.class` seulement si `Main.java` a été modifié. +3. Ne recompileront pas `Main.class` si `Main.java` n’a pas été modifié. + +## Scénario de test + +1. Compiler `Main.java` pour générer `Main.class`. +2. Exécuter `make` et `bake` sans modifications pour voir si une recompilation est déclenchée. +3. Modifier `Main.java` et relancer `make` et `bake` pour voir si une recompilation est bien déclenchée. + +## Comment exécuter le test + +### Test manuel + +1. Compiler avec Make : + ```bash + cd make + make + ``` + Le fichier `Main.class` doit être généré. + +2. Compiler avec Bake : + ```bash + cd bake + java -cp bakefile.jar fr.monlouyan.bakefile.Main + ``` + +3. Vérifier si `Main.class` est bien généré. + +4. Modifier `Main.java` et relancer la compilation : + ```bash + echo "// Modification" >> Main.java + make + ``` + +5. Vérifier si `make` et `bake` détectent la modification et recompilent `Main.class`. + +## Résultats attendus + +- `bake` et `make` doivent compiler `Main.java` en `Main.class` si `Main.class` n'existe pas ou si `Main.java` a été modifié. +- Si `Main.java` n’a pas été modifié, `make` et `bake` ne doivent pas recompiler `Main.class`. diff --git a/tests/test-27-conditions-if/README.md b/tests/test-27-conditions-if/README.md new file mode 100644 index 0000000..3a8fff9 --- /dev/null +++ b/tests/test-27-conditions-if/README.md @@ -0,0 +1,99 @@ +# Test 27 - Gestion des conditions IF + +Ce test vérifie comment `bake` et `make` gèrent les conditions `if` dans les commandes de compilation, en particulier pour tester l'existence d'un fichier avant de l'écraser ou de le recréer. + +## 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-27-conditions-if/ +├── 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 la logique conditionnelle suivante : + +```makefile +# Définition de la cible principale +all: fichier.txt + @echo "La cible fichier.txt est à jour." + +# Cible qui vérifie si le fichier existe +# Si le fichier existe, ne rien faire +# Sinon, le créer avec touch +fichier.txt: + @if [ -f "fichier.txt" ]; then echo "Le fichier fichier.txt existe déjà, rien à faire."; else echo "Le fichier fichier.txt n'existe pas, création..."; touch fichier.txt; echo "Le fichier fichier.txt a été créé."; fi + +# Cible pour nettoyer le fichier créé +.PHONY: clean +clean: + @echo "Suppression de fichier.txt..." + @rm -f fichier.txt +``` + +## Objectif du test + +Ce test a pour but de vérifier que `bake` et `make` : +1. Vérifient correctement si `fichier.txt` existe avant de l'écraser. +2. N'exécutent pas la création de `fichier.txt` si celui-ci existe déjà. +3. Suppriment `fichier.txt` proprement avec la cible `clean`. + +## Scénario de test + +1. Exécuter `make` et `bake` une première fois pour voir la création du fichier. +2. Exécuter `make` et `bake` une seconde fois pour voir si la condition empêche la recréation du fichier. +3. Supprimer `fichier.txt` et relancer `make` et `bake` pour vérifier que le fichier est bien recréé. + +## Comment exécuter le test + +### Test manuel + +1. Exécuter `make` et `bake` : + ```bash + cd make + make + ``` + Le fichier `fichier.txt` doit être créé. + +2. Exécuter `make` et `bake` à nouveau : + ```bash + make + ``` + Il ne doit pas y avoir de recréation du fichier. + +3. Supprimer `fichier.txt` et relancer `make` : + ```bash + make clean + make + ``` + Le fichier doit être recréé. + +4. Répéter les mêmes étapes avec `bake` : + ```bash + cd bake + java -cp bakefile.jar fr.monlouyan.bakefile.Main + java -cp bakefile.jar fr.monlouyan.bakefile.Main clean + java -cp bakefile.jar fr.monlouyan.bakefile.Main + ``` + +5. Vérifier les résultats et comparer le comportement avec `make`. + +## Résultats attendus + +- `bake` et `make` doivent créer `fichier.txt` uniquement si celui-ci n'existe pas. +- Un deuxième appel à `make` ou `bake` ne doit pas recréer `fichier.txt` s'il est déjà présent. +- La cible `clean` doit supprimer le fichier proprement. diff --git a/tests/test-28-silent/README.md b/tests/test-28-silent/README.md new file mode 100644 index 0000000..2f82c42 --- /dev/null +++ b/tests/test-28-silent/README.md @@ -0,0 +1,74 @@ +# Test 28 - Gestion des commandes silencieuses et suppression forcée + +Ce test vérifie comment `bake` et `make` gèrent les commandes silencieuses (`@`) et la suppression forcée (`-`). + +## 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-28-silent/ +├── README.md +├── bake/ +│ ├── Bakefile +│ ├── bakefile.jar +├── make/ +│ ├── Makefile +``` + +## Contenu des fichiers de règles + +Les fichiers `Makefile` et `Bakefile` contiennent : + +```makefile +all: main + +main: + echo "Compilation de main..." + touch main + +clean: + - rm main + @echo "Fichiers nettoyés." +``` + +## Objectif du test + +Ce test vérifie que `bake` et `make` : +1. Exécutent les commandes de compilation normalement. +2. Gèrent correctement le `-` devant `rm` pour ignorer les erreurs si le fichier n'existe pas. +3. Masquent l'affichage de la commande `echo "Fichiers nettoyés."` grâce à `@`. + +## Scénario de test + +1. Exécuter `make` et `bake` pour compiler `main`. +2. Exécuter la cible `clean` et observer la suppression. +3. Exécuter `make clean` et `bake clean` quand `main` n'existe pas pour vérifier que l'erreur est ignorée. + +## Comment exécuter le test + +### Test manuel + +```bash +cd make +make +make clean +make clean # Tester la suppression sans le fichier + +cd bake +java -cp bakefile.jar fr.monlouyan.bakefile.Main +java -cp bakefile.jar fr.monlouyan.bakefile.Main clean +java -cp bakefile.jar fr.monlouyan.bakefile.Main clean +``` + +## Résultats attendus + +- `bake` et `make` doivent exécuter `clean` sans erreur même si `main` n'existe pas. +- La suppression doit être silencieuse (grâce au `@`). diff --git a/tests/test-29-variable-dont-exist/README.md b/tests/test-29-variable-dont-exist/README.md index bc2960d..27133b6 100644 --- a/tests/test-29-variable-dont-exist/README.md +++ b/tests/test-29-variable-dont-exist/README.md @@ -1,26 +1,61 @@ -en gros ici on vérifie ce qu'il se passe quand on essaye d'utiliser une variable qui n'existe pas. +# Test 29 - Gestion des variables non définies -Exemple : +Ce test vérifie comment `bake` et `make` réagissent lorsqu'une variable non définie est utilisée dans une commande. -bake = -moncef@MacBook-Pro-de-Moncef bake % bake -Création du fichier -touch test.txt -Essai de création d'un fichier avec une variable qui n'existe pas -touch $(NOM_FICHIER2) -sh: NOM_FICHIER2: command not found -usage: touch [-A [-][[hh]mm]SS] [-achm] [-r file] [-t [[CC]YY]MMDDhhmm[.SS]] - [-d YYYY-MM-DDThh:mm:SS[.frac][tz]] file ... -bake: *** [main] Error 1 +## 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 -make = +``` +test-29-variable-missing/ +├── README.md +├── bake/ +│ ├── Bakefile +│ ├── bakefile.jar +├── make/ +│ ├── Makefile +└── run_test29.sh +``` -moncef@MacBook-Pro-de-Moncef make % make -Création du fichier -touch test.txt -Essai de création d'un fichier avec une variable qui n'existe pas -touch -usage: touch [-A [-][[hh]mm]SS] [-achm] [-r file] [-t [[CC]YY]MMDDhhmm[.SS]] - [-d YYYY-MM-DDThh:mm:SS[.frac][tz]] file ... -make: *** [main] Error 1 \ No newline at end of file +## Contenu des fichiers de règles + +```makefile +NOM_FICHIER = test.txt + +main: + @echo "Création du fichier" + touch $(NOM_FICHIER) + @echo "Essai de création d'un fichier avec une variable qui n'existe pas" + touch $(NOM_FICHIER2) +``` + +## Objectif du test + +Ce test vérifie : +1. Si `bake` et `make` détectent l'utilisation d'une variable non définie (`NOM_FICHIER2`). +2. Si une erreur est affichée. + +## Scénario de test + +1. Exécuter `make` et `bake` pour voir la gestion de la variable manquante. + +## Test manuel + +```bash +cd make +make + +cd bake +java -cp bakefile.jar fr.monlouyan.bakefile.Main +``` + +## Résultats attendus + +- `bake` et `make` doivent afficher une erreur pour `NOM_FICHIER2` car elle n'est pas définie. diff --git a/tests/test-30-command-chaining-operators/README.md b/tests/test-30-command-chaining-operators/README.md new file mode 100644 index 0000000..6a692fb --- /dev/null +++ b/tests/test-30-command-chaining-operators/README.md @@ -0,0 +1,49 @@ +# Test 30 - Gestion des opérateurs de chaînage (`&&` et `\`) + +Ce test vérifie comment `bake` et `make` interprètent les commandes avec les opérateurs `&&` et `\`. + +## Structure du test + +``` +test-30-command-chaining/ +├── README.md +├── bake/ +│ ├── Bakefile +│ ├── bakefile.jar +├── make/ +│ ├── Makefile +└── run_test30.sh +``` + +## Contenu des fichiers de règles + +```makefile +Main.class: Main.java + javac Main.java && echo "Compilation terminée" + +main: Main.class + java Main && echo "Exécution terminée" +``` + +## Objectif du test + +Ce test vérifie que : +1. `bake` et `make` exécutent correctement les commandes chaînées (`&&`). +2. L’exécution s’arrête si une commande échoue. + +## Test manuel + +```bash +cd make +make +make main + +cd bake +java -cp bakefile.jar fr.monlouyan.bakefile.Main +java -cp bakefile.jar fr.monlouyan.bakefile.Main main +``` + +## Résultats attendus + +- Si `javac` échoue, `echo "Compilation terminée"` ne doit pas s'afficher. +- Si `java Main` échoue, `echo "Exécution terminée"` ne doit pas s'afficher. diff --git a/tests/test-30-command-chaining-operators/README_Test_30 (3).md b/tests/test-30-command-chaining-operators/README_Test_30 (3).md new file mode 100644 index 0000000..85c31dd --- /dev/null +++ b/tests/test-30-command-chaining-operators/README_Test_30 (3).md @@ -0,0 +1,64 @@ +# Test 30 - Gestion des opérateurs de chaînage (`&&` et `\`) + +Ce test vérifie comment `bake` et `make` interprètent les commandes avec les opérateurs `&&` et `\`. + +## 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-30-command-chaining/ +├── README.md +├── bake/ +│ ├── Bakefile +│ ├── bakefile.jar +├── make/ +│ ├── Makefile +└── run_test30.sh +``` + +## Contenu des fichiers de règles + +```makefile +Main.class: Main.java + javac Main.java && echo "Compilation terminée" + +main: Main.class + java Main && echo "Exécution terminée" +``` + +## Objectif du test + +Ce test vérifie que : +1. `bake` et `make` exécutent correctement les commandes chaînées (`&&`). +2. L’exécution s’arrête si une commande échoue. + +## Scénario de test + +1. Compiler `Main.java` en `Main.class`. +2. Exécuter `make` et `bake` pour voir si les commandes sont exécutées correctement. +3. Observer si les erreurs interrompent bien la compilation ou l'exécution. + +## Test manuel + +```bash +cd make +make +make main + +cd bake +java -cp bakefile.jar fr.monlouyan.bakefile.Main +java -cp bakefile.jar fr.monlouyan.bakefile.Main main +``` + +## Résultats attendus + +- Si `javac` échoue, `echo "Compilation terminée"` ne doit pas s'afficher. +- Si `java Main` échoue, `echo "Exécution terminée"` ne doit pas s'afficher. diff --git a/tests/test-31-redirection/README.md b/tests/test-31-redirection/README.md index 7f6ae1d..834e8d7 100644 --- a/tests/test-31-redirection/README.md +++ b/tests/test-31-redirection/README.md @@ -1,2 +1,106 @@ -En gros, ici on vérifie si ça marche les redirections -jors j'envoie mon echo dans un fichier \ No newline at end of file +# Test 31 - Gestion des redirections I/O + +Ce test vérifie comment `bake` et `make` gèrent les redirections d'entrée/sortie (`>`, `>>`, `<`, `|`). + +## 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-31-redirection/ +├── README.md +├── bake/ +│ ├── Bakefile +│ ├── bakefile.jar +├── make/ +│ ├── Makefile +``` + +## Contenu des fichiers de règles + +```makefile +.PHONY: all test-output test-append test-input test-multiple test-pipe test-cleanup + +all: test-output test-append test-input test-multiple test-pipe + @echo "Tous les tests de redirection I/O sont terminés" + +# Test de redirection de sortie standard (>) +test-output: + @echo "Test de redirection de sortie >" + echo "Contenu écrit avec redirection >" > output.txt + @cat output.txt + @echo "-----------------------------" + +# Test de redirection avec ajout (>>) +test-append: + @echo "Test de redirection avec ajout >>" + echo "Première ligne" > append.txt + echo "Deuxième ligne ajoutée" >> append.txt + @cat append.txt + @echo "-----------------------------" + +# Test de redirection d'entrée (<) +test-input: + @echo "Test de redirection d'entrée <" + echo "Contenu à lire" > input.txt + cat < input.txt + @echo "-----------------------------" + +# Test de redirections multiples +test-multiple: + @echo "Test de redirections multiples" + echo "Ligne 1" > multi.txt + echo "Ligne 2" >> multi.txt + cat < multi.txt > multi-output.txt + @cat multi-output.txt + @echo "-----------------------------" + +# Test de pipe | +test-pipe: + @echo "Test de pipe |" + echo "LIGNE UN\nLIGNE DEUX\nLIGNE TROIS" | grep LIGNE | wc -l + @echo "-----------------------------" + +# Nettoyage des fichiers créés +test-cleanup: + @echo "Nettoyage des fichiers de test" + rm -f output.txt append.txt input.txt multi.txt multi-output.txt +``` + +## Objectif du test + +Ce test vérifie que `bake` et `make` : +1. Gèrent correctement la redirection de sortie standard `>` et `>>`. +2. Lisent des fichiers en redirigeant l'entrée `<`. +3. Traitent les redirections combinées (`<` et `>` en même temps). +4. Gèrent correctement les pipes `|` pour la manipulation de commandes. + +## Scénario de test + +1. Exécuter `make` et `bake` pour voir la gestion des redirections. +2. Vérifier le contenu des fichiers créés. +3. Supprimer les fichiers après le test. + +## Test manuel + +```bash +cd make +make all +make test-cleanup + +cd bake +java -cp bakefile.jar fr.monlouyan.bakefile.Main all +java -cp bakefile.jar fr.monlouyan.bakefile.Main test-cleanup +``` + +## Résultats attendus + +- Les fichiers créés doivent contenir les résultats attendus des redirections. +- Les pipes doivent fonctionner comme prévu. diff --git a/tests/test-32-exit/README.md b/tests/test-32-exit/README.md new file mode 100644 index 0000000..865abea --- /dev/null +++ b/tests/test-32-exit/README.md @@ -0,0 +1,58 @@ +# Test 32 - Gestion des commandes EXIT + +Ce test vérifie comment `bake` et `make` gèrent les commandes `exit` qui arrêtent l'exécution. + +## 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-32-exit/ +├── README.md +├── bake/ +│ ├── Bakefile +│ ├── bakefile.jar +├── make/ +│ ├── Makefile +``` + +## Contenu des fichiers de règles + +```makefile +fail: + (exit 1) + (echo "Ce echo ne devrait pas s'afficher") +``` + +## Objectif du test + +Ce test vérifie : +1. Si `bake` et `make` arrêtent bien l'exécution après un `exit 1`. +2. Si les commandes après `exit 1` ne sont pas exécutées. + +## Scénario de test + +1. Exécuter `make fail` et `bake fail`. +2. Vérifier que `echo "Ce echo ne devrait pas s'afficher"` n'apparaît pas. + +## Test manuel + +```bash +cd make +make fail + +cd bake +java -cp bakefile.jar fr.monlouyan.bakefile.Main fail +``` + +## Résultats attendus + +- L'exécution doit s'arrêter immédiatement après `exit 1`. +- La ligne `echo "Ce echo ne devrait pas s'afficher"` ne doit pas être exécutée.