Ajout du test n°22 + Correction du makefile du projet

tests/C/test-22-future-timestamp/README.md

@@ -0,0 +1,103 @@
+# Test 22 - Gestion des timestamps dans le futur
+
+Ce test vérifie le comportement de `bake` comparé à `make` lorsque le fichier source a un timestamp dans le futur par rapport à l'heure système actuelle.
+
+## 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 automatique](#test-automatique)
+  - [Test manuel](#test-manuel)
+- [Résultats attendus](#résultats-attendus)
+- [Explications techniques](#explications-techniques)
+
+## Structure du test
+
+```
+test-22-future-timestamp/
+├── README.md         # Ce fichier
+├── bake/             
+│   ├── 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
+```
+
+## Contenu des fichiers de règles
+
+Les fichiers `Makefile` et `Bakefile` contiennent les mêmes règles simples :
+
+```makefile
+main: main.c
+	gcc -o main main.c
+```
+
+## Objectif du test
+
+Ce test vérifie que `bake` se comporte comme `make` face à un cas particulier : quand un fichier source a une date de modification dans le futur (postérieure à la date système actuelle). Ce scénario peut se produire en pratique lors de changements de fuseau horaire, de synchronisations imparfaites entre systèmes de fichiers réseau, ou de manipulations manuelles des timestamps.
+
+## Scénario de test
+
+Le test suit les étapes suivantes :
+1. Compiler initialement le programme pour créer l'exécutable `main`
+2. Modifier le timestamp du fichier source `main.c` pour le placer dans le futur (+ 1 jour)
+3. Exécuter à nouveau make/bake pour voir comment ils réagissent
+4. Vérifier si les exécutables sont reconstruits ou non
+
+## 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 :
+   ```
+   cd make
+   make
+   # Modifier le timestamp du fichier source pour le mettre dans le futur
+   touch -t $(date -d "+1 day" "+%Y%m%d%H%M.%S") main.c
+   make
+   ```
+
+2. Pour Bake :
+   ```
+   cd bake
+   java -cp bakefile.jar fr.monlouyan.bakefile.Main
+   # Modifier le timestamp du fichier source pour le mettre dans le futur
+   touch -t $(date -d "+1 day" "+%Y%m%d%H%M.%S") main.c
+   java -cp bakefile.jar fr.monlouyan.bakefile.Main
+   ```
+
+3. Comparez visuellement les deux résultats.
+
+## Résultats attendus
+
+- Le comportement standard de GNU Make est de reconstruire l'exécutable si le fichier source a un timestamp dans le futur
+- `bake` devrait adopter le même comportement et reconstruire l'exécutable
+- Les messages de sortie devraient indiquer la reconstruction
+
+## Explications techniques
+
+Les systèmes de build comme make utilisent les timestamps des fichiers pour déterminer quand une recompilation est nécessaire. Quand un fichier source a une date de modification qui se situe dans le futur :
+
+1. Certains systèmes de build considèrent toujours que le fichier a été modifié et déclenchent la reconstruction
+2. D'autres peuvent avoir des comportements particuliers ou des avertissements
+
+Ce test vérifie que `bake` gère correctement ce cas particulier en adoptant le même comportement que `make`, ce qui est important pour assurer une compatibilité complète, même dans des situations inhabituelles.