ajout README 9 à 17
This commit is contained in:
parent
cbcfd60ab1
commit
434f9b3985
@ -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)
|
||||
# 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.
|
||||
|
||||
106
tests/C/test-10-phony/README.md
Normal file
106
tests/C/test-10-phony/README.md
Normal file
@ -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.
|
||||
@ -1 +1,87 @@
|
||||
Quand il y a une erreur dans le code, ça affiche l'erreur + stop le programme exactement comme make.
|
||||
# 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.
|
||||
|
||||
88
tests/C/test-12-file-dont-exist/README.md
Normal file
88
tests/C/test-12-file-dont-exist/README.md
Normal file
@ -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.
|
||||
90
tests/C/test-13-dependancy-dont-exist/README.md
Normal file
90
tests/C/test-13-dependancy-dont-exist/README.md
Normal file
@ -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.
|
||||
@ -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)
|
||||
# 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.
|
||||
|
||||
@ -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
|
||||
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.
|
||||
|
||||
@ -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.
|
||||
Loading…
x
Reference in New Issue
Block a user