# Exemple de test unitaire avec CodePlay

Dans cet exercice, vous devez afficher un message de salutation puis vérifier que la sortie correspond bien à ce qui est attendu.

## Énoncé

Écrivez un programme qui affiche :

```text
Bonjour 42
```

```{codeplay}
:assertions: exact:Bonjour 42

print("Bonjour 42")
```

## Variante courte

Si vous voulez vérifier une seule condition, vous pouvez écrire :

```{codeplay}
:exec:
:assert: contains:42

print(42)
```

## Exemple multiligne

Voici un exemple où la sortie comporte plusieurs lignes :

```{codeplay}
:assertions: exact:0\n1\n2\n3;code:for

for i in range(4):
    print(i)
```

## Exemple avec input()

Vous pouvez aussi injecter une valeur prédéfinie pour `input()` :

```{codeplay}
:inputs: Alice
:assertions: exact:Bonjour Alice

nom = input("Prénom : ")
print("Bonjour " + nom)
```

## Exemple avec trois inputs

Vous pouvez aussi fournir plusieurs valeurs pour plusieurs appels à `input()` :

```{codeplay}
:exec:
:inputs: Alice|Bob|Charlie
:assertions: exact:Bonjour Alice\nBonjour Bob\nBonjour Charlie

for i in range(3):
    nom = input("Prénom : ")
    print("Bonjour " + nom)
```

Calculez 2 puissance 10 et stockez-le dans la variable `res`, puis exécuter le code.

```{codeplay}
---
hints: Quel est l'opérateur pour élever à la puissance ?
---
===
res = 
===
if res == 1024 :
  print('Bravo!')
else :
  print(f'Tu as obtenu le nombre {res}. Essaie encore! ')
```

##

Exemple avec un indice

```{codeplay}
:hints: Quel est l'opérateur pour élever à la puissance ?
:assertions: exact:1024; code:**

===
res = 
===
print(res)
```

## Explication

Le directive `codeplay` peut valider la sortie du programme, le code écrit par l’élève, ainsi que les valeurs fournies à `input()`.

### 1. Syntaxe générale des assertions

Vous pouvez définir une ou plusieurs assertions avec l’option `:assertions:`.

- Une assertion simple :

  ```text
  :assertions: exact:Bonjour 42
  ```

- Plusieurs assertions à la fois : séparez-les par `;` :

  ```text
  :assertions: exact:Bonjour 42;contains:42
  ```

- Vous pouvez aussi utiliser l’option courte `:assert:` qui ajoute des assertions de la même façon :

  ```text
  :exec:
  :assert: contains:42
  ```

### 2. Types d’assertions disponibles

- `exact:texte` ou `equals:texte` : vérifie que la sortie produite est exactement égale au texte attendu.
  - Pour une sortie sur plusieurs lignes, utilisez `\n` pour représenter les retours à la ligne :

    ```text
    :assertions: exact:0\n1\n2\n3
    ```

- `contains:texte` : vérifie qu’une sous-chaîne apparaît dans la sortie.

  ```text
  :assertions: contains:42
  ```

- `regex:pattern` : vérifie la sortie avec une expression rationnelle.

  ```text
  :assertions: regex:^Bonjour .*$
  ```

- `code:fragment` : vérifie que le code de l’élève contient un fragment donné.
  - C’est utile pour vérifier qu’une structure particulière a été utilisée, par exemple une boucle `for`.

  ```text
  :assertions: code:for
  ```

### 3. Cas avec plusieurs paramètres

- Plusieurs assertions :

  ```text
  :assertions: exact:Bonjour Alice;contains:Alice;code:input
  ```

- Plusieurs valeurs d’entrée pour plusieurs appels à `input()` : séparez les valeurs par `|` dans `:inputs:` ou `:input:`.

  ```text
  :inputs: Alice|Bob|Charlie
  ```

- Pour une sortie attendue sur plusieurs lignes avec plusieurs assertions, vous pouvez combiner les deux idées :

  ```text
  :assertions: exact:Bonjour Alice\nBonjour Bob\nBonjour Charlie;code:for
  ```

### 4. Résultat affiché à l’élève

Après exécution, le résultat est affiché directement dans la page HTML avec un statut de validation visible : succès ou échec, selon les assertions définies.