# 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.