diff --git a/tests/C/test-05-variables/README.md b/tests/C/test-05-variables/README.md index 28b2bdc..004edf3 100644 --- a/tests/C/test-05-variables/README.md +++ b/tests/C/test-05-variables/README.md @@ -1 +1,88 @@ -# Test 5 : Utilisation de variables +# Test 05 - Utilisation de variables + +Ce test vérifie la prise en charge des variables dans `bake` et `make`, en comparant leur comportement lors de la compilation d'un programme simple. + +## 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-05-variables/ +├── README.md # Ce fichier +├── bake/ +│ ├── 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_test05.sh # Programme de test automatique +``` + +## Contenu des fichiers de règles + +Les fichiers `Makefile` et `Bakefile` utilisent des variables pour améliorer la lisibilité et la maintenance : + +```makefile +FLAGS = -ansi -pedantic +COMPILATEUR = gcc +OPTIONS = -o +EXECUTABLE = main +SOURCE = main.c + +main: main.c + $(COMPILATEUR) $(FLAGS) $(OPTIONS) $(EXECUTABLE) $(SOURCE) +``` + +## Objectif du test + +Ce test vérifie que `bake` et `make` interprètent correctement les variables : +1. Vérifier que les variables définies dans le fichier de règles sont bien reconnues et substituées dans les commandes. +2. Vérifier que la compilation se déroule correctement en utilisant les variables. +3. Comparer les messages de sortie de `bake` et `make` pour s'assurer qu'ils prennent en compte les variables correctement. + +## Comment exécuter le test + +### Test automatique + +1. Rendez le script de test exécutable : + ```bash + chmod +x run_test05.sh + ``` + +2. Lancez le script de test : + ```bash + ./run_test05.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. Compilez 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 + +- Les deux outils devraient reconnaître et substituer correctement les variables dans les commandes. +- La compilation devrait aboutir et produire un exécutable `main`. +- Les messages de sortie devraient indiquer clairement que les variables ont été utilisées dans la commande de compilation. +- Si les variables ne sont pas prises en compte correctement, `bake` pourrait échouer à compiler `main.c`. diff --git a/tests/C/test-06-variables-on-cascade/README.md b/tests/C/test-06-variables-on-cascade/README.md index 0baeab4..8e505bf 100644 --- a/tests/C/test-06-variables-on-cascade/README.md +++ b/tests/C/test-06-variables-on-cascade/README.md @@ -1 +1,90 @@ -# Test 6 : Gestion des variables en cascade +# Test 06 - Gestion des variables en cascade + +Ce test vérifie la prise en charge des variables en cascade dans `bake` et `make`, en analysant leur propagation correcte dans les commandes 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-06-cascade/ +├── README.md # Ce fichier +├── bake/ +│ ├── 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 +``` + +## Contenu des fichiers de règles + +Les fichiers `Makefile` et `Bakefile` utilisent des variables imbriquées pour tester la substitution en cascade : + +```makefile +FLAGS = -ansi -pedantic +FLAGSS = $(FLAGS) +FLAGSSS = $(FLAGSS) +FLAGSSSS = $(FLAGSSS) +FLAGSSSSS = $(FLAGSSSS) +FLAGSSSSSS = $(FLAGSSSSS) +FLAGSSSSSSS = $(FLAGSSSSSS) + +main: main.c + gcc $(FLAGSSSSSSS) -o main main.c +``` + +## Objectif du test + +Ce test vérifie que `bake` et `make` gèrent correctement les variables définies en cascade : +1. Vérifier que chaque variable est correctement remplacée par sa valeur résolue. +2. Vérifier que la compilation se déroule sans erreur et produit l'exécutable `main`. +3. Comparer les messages de sortie pour observer la propagation des variables. + +## 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 : + ```bash + cd make + make + ``` + +2. Compilez 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 + +- Les deux outils devraient correctement remplacer les variables en cascade. +- La compilation devrait aboutir et produire un exécutable `main`. +- Les messages de sortie devraient indiquer clairement l'expansion des variables imbriquées. +- Si `bake` ne gère pas correctement la propagation des variables, la compilation pourrait échouer ou utiliser des valeurs incorrectes. diff --git a/tests/C/test-07-dependency/README.md b/tests/C/test-07-dependency/README.md index b2926c0..3772348 100644 --- a/tests/C/test-07-dependency/README.md +++ b/tests/C/test-07-dependency/README.md @@ -1 +1,120 @@ -Dépendances multiples : Vérifier que si un fichier .c dépend de plusieurs fichiers .h, toute modification d'un .h entraîne la recompilation du .c. \ No newline at end of file +# 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 automatique](#test-automatique) + - [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 +└── run_test07.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 -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 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 : + ```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. diff --git a/tests/C/test-08-space-vs-tabulation/README.md b/tests/C/test-08-space-vs-tabulation/README.md new file mode 100644 index 0000000..03fa466 --- /dev/null +++ b/tests/C/test-08-space-vs-tabulation/README.md @@ -0,0 +1,89 @@ +# Test 08 - Gestion des espaces et tabulations + +Ce test vérifie que `bake` et `make` gèrent correctement les tabulations et les espaces dans les fichiers de règles. +Un mauvais usage des espaces au lieu des tabulations devrait provoquer une erreur. + +## 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-08-tabulations/ +├── 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_test08.sh # Programme de test automatique +``` + +## Contenu des fichiers de règles + +Les fichiers `Makefile` et `Bakefile` contiennent les règles suivantes : + +```makefile +all: + echo "Cette ligne est correcte" + +test_espaces: + echo "Cette ligne utilise une tabulation" + echo "Cette ligne utilise des espaces et doit provoquer une erreur" +``` + +## Objectif du test + +Ce test vérifie que `bake` et `make` appliquent correctement la règle selon laquelle les commandes doivent être indentées avec des tabulations et non des espaces : +1. La cible `all` doit s'exécuter sans erreur. +2. La cible `test_espaces` doit provoquer une erreur à cause de l'utilisation d'espaces au lieu d'une tabulation. +3. Comparer les messages d'erreur de `bake` et `make`. + +## 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 : + ```bash + cd make + make all + ``` + +2. Exécutez la règle incorrecte : + ```bash + make test_espaces + ``` + Une erreur doit apparaître. + +3. Faites la même procédure avec Bake : + ```bash + cd bake + java -cp bakefile.jar fr.monlouyan.bakefile.Main all + java -cp bakefile.jar fr.monlouyan.bakefile.Main test_espaces + ``` + +## Résultats attendus + +- `make all` et `bake all` doivent s'exécuter sans erreur. +- `make test_espaces` et `bake test_espaces` doivent échouer en indiquant que la ligne est mal formatée. +- Les messages d'erreur doivent indiquer clairement l'origine du problème (espaces au lieu de tabulations).