Merge branch 'main' of https://grond.iut-fbleau.fr/stiti/SAE32_2024
This commit is contained in:
commit
23477951fe
tests
test-06-variables-on-cascade
test-07-dependency
test-08-space-vs-tabulation
test-09-handling-comment
test-10-phony
test-11-error-in-code
test-12-file-dont-exist
test-13-dependancy-dont-exist
test-15-subdir-build
test-16-strange-variables
test-17-rule-without-command
test-18-path-characters
test-19-multiple-targets
test-20-circular-2
test-21-generate
test-22-future-timestamp
test-23-identical-timestamps
test-24-50target
@ -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 :
|
||||
|
||||
@ -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 :
|
||||
|
||||
@ -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 :
|
||||
|
||||
@ -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 :
|
||||
|
||||
@ -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 :
|
||||
|
||||
@ -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 :
|
||||
|
||||
@ -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 :
|
||||
|
||||
@ -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 :
|
||||
|
||||
@ -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 :
|
||||
|
||||
@ -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 :
|
||||
|
||||
@ -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
|
||||
|
||||
96
tests/test-18-path-characters/README.md
Normal file
96
tests/test-18-path-characters/README.md
Normal file
@ -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.
|
||||
94
tests/test-19-multiple-targets/README.md
Normal file
94
tests/test-19-multiple-targets/README.md
Normal file
@ -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.
|
||||
72
tests/test-20-circular-2/README.md
Normal file
72
tests/test-20-circular-2/README.md
Normal file
@ -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.
|
||||
79
tests/test-21-generate/README.md
Normal file
79
tests/test-21-generate/README.md
Normal file
@ -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.
|
||||
@ -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 :
|
||||
|
||||
89
tests/test-23-identical-timestamps/README.md
Normal file
89
tests/test-23-identical-timestamps/README.md
Normal file
@ -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.
|
||||
86
tests/test-24-50target/README.md
Normal file
86
tests/test-24-50target/README.md
Normal file
@ -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`.
|
||||
Loading…
x
Reference in New Issue
Block a user