Cours 10 - Les Tests

name: inverse
layout: true
class: center, middle, inverse

---
# Inès de Courchelle
## Les tests
## 2023-2024

![image](../img/CY-tech.png)

---
layout: false
# TODAY
## Objectifs

- Utiliser des directives préprocesseurs
- Manipuler des arguments d'entrées
- Réaliser des tests unitaires
- Anticiper les bugs d'un programme

---
# TODAY
## Plan
1. Les directives préprocesseurs
2. Les arguments
3. Les tests unitaires

---
# TODAY
## Plan
1. .under[Les directives préprocesseurs]
2. Les arguments
3. Les tests unitaires

---
# Les directives préprocesseurs
## Définition
Directive exécutée lors de la première phase de la compilation

## Pourquoi ?
- l'incorporation de fichiers source (#include),
- la définition de constantes symboliques et de macros (#define),
- la compilation conditionnelle (#if, #ifdef,...)

## On n'en a déjà fait !
```c
#ifndef __puissance4_H_
#define __puissance4_H_

#define N 7

#endif
```
---
# Les directives préprocesseurs
## Exemple 1
<img src="img/exempleInclusion1.png" width=400>

---
# Les directives préprocesseurs
## VAR
<center>
<video src="videos/includepreProcesseur1.mp4" width=70 controls poster="vignette.jpg"></a>
</video>
</center>

---
# Les directives préprocesseurs
## Exemple 2
On rajoute les 2 fichiers suivants :
<img src="img/exempleInclusion2.png" width=200>

---
# Les directives préprocesseurs
## Exemple 2
<img src="img/exempleInclusion.png" width=600>

---
# Les directives préprocesseurs

## VAR
<center>
<video src="videos/includepreProcesseur2.mp4" width=400 controls poster="vignette.jpg"></a>
</video>
</center>

---
# Les directives préprocesseurs
## Exemple 2
on rajoute les instructions préprocesseurs et ça marche !

## VAR
<center>
<video src="videos/includepreProcesseur3.mp4" width=400 controls poster="vignette.jpg"></a>
</video>
</center>

---
# La directive \#define
## Objectifs
- Des constantes symboliques,
- Des macros avec paramètres.

## Définition de constantes symboliques
```c
#define NB_LIGNES 10
#define NB_COLONNES 33
#define TAILLE_MATRICE NB_LIGNES * NB_COLONNES
```

#### On a déjà fait !

---
# La directive \#define
## Des macros
Une macro avec paramètres se définit de la manière suivante :
```c
#define nom(param1,param2) contenu de la macro
```
## Exemple
```c
#define MAX(a,b) (a > b ? a : b)
```
Le processeur remplacera dans la suite du code toutes les occurences du type
```c
MAX(x,y)
```

---
# La directive \#define
## Des macros
```c
#define MAX(a,b) (a > b ? a : b)
```
- Elle prend 2 paramètres a et b .arrow[] la signature de la macro : MAX(a,b)
- Elle renvoie a ou b .arrow[] le corps de la macro (a > b ? a : b)
  - si a > b alors je renvoie a
  - si a < b alors je renvoi b

---
# La directive \#define
## le code
```c
#include<stdlib.h>
#include<stdio.h>
#define MAX(a,b) (a > b ? a : b)

int main(){
  int x,y;

printf("veuillez saisir x :\n");
  scanf("%d",&x);

printf("veuillez saisir y :\n");
  scanf("%d",&y);

printf("le plus grand entre x= %d et y=%d est %d \n",x,y,MAX(x,y));
  return 0;
}

```

---
# La directive \#define
## VAR
<center>
<video src="videos/part1/macro.mp4" width=400 controls poster="vignette.jpg"></a>
</video>
</center>

---
# La compilation conditionnelle
## Objectifs
- Incorporer ou d'exclure des parties du code source dans le texte qui sera généré par le préprocesseur
- Adapter le programme au matériel ou à l'environnement sur lequel il s'exécute
- Introduire dans le programme des instructions de débogage

---
# La compilation conditionnelle
## Objectifs
- Incorporer ou d'exclure des parties du code source dans le texte qui sera généré par le préprocesseur
- Adapter le programme au matériel ou à l'environnement sur lequel il s'exécute
- .under[Introduire dans le programme des instructions de débogage]

---
# La compilation conditionnelle
## Algo
Calculer la moyenne à partir de plusieurs notes.
```c
PROGRAMME maMoyenne
VARIABLES
    nbNotes : entier
    tabNotes : pointeur d'entier
    moyenne : reel
DEBUT
    ECRIRE("Combien de notes voulez-vous saisir ?")
    LIRE(nbNotes)
    moyenne <- 0
    POUR i allant de 0 à nbNotes FAIRE
        ECRIRE("La note n°"+i+"est :")
        LIRE(tabNotes[i])
        moyenne <- moyenne+ tabNotes[i]
    FIN POUR
    moyenne<-moyenne/nbNotes
    ECRIRE("La moyenne est : "+moyenne)
FIN
```
---
# La compilation conditionnelle
## Mon programme sans DEBUG
```c
  int nbNotes;
  int* tabNotes;
  double moyenne;

printf("Combien de notes voulez-vous saisir ? \n");
  scanf("%d",&nbNotes);
  moyenne=0;
  tabNotes = malloc(sizeof(int)*nbNotes);

for (int i=0;i<nbNotes;i++){
    printf("La note n°%d est : \n",i);
    scanf("%d",&tabNotes[i]);
    moyenne+=tabNotes[i];
  }

moyenne=moyenne/nbNotes;
  printf("La moyenne est : %.2lf \n",moyenne);
```
---
# La compilation conditionnelle
## VAR
<center>
<video src="videos/part1/moyenneSansD.mp4" width=400 controls poster="vignette.jpg"></a>
</video>
</center>

---
# La compilation conditionnelle
## Mon programme avec DEBUG
```c
  int nbNotes;
  int* tabNotes;
  double moyenne;
  printf("Combien de notes voulez-vous saisir ? \n");
  scanf("%d",&nbNotes);
  moyenne=0;
  tabNotes = malloc(sizeof(int)*nbNotes);
  #ifdef DEBUG
    printf("nbNotes : %d \n",nbNotes);
    printf("moyenne : %.2lf \n",moyenne);
  #endif
  for (int i=0;i<nbNotes;i++){
    printf("La note n°%d est : \n",i);
    scanf("%d",&tabNotes[i]);
    moyenne+=tabNotes[i];
    #ifdef DEBUG
      printf("Dans la boucle for \n");
      printf("notes[%d] : %d \n",i,tabNotes[i]);
      printf("moyenne : %.2lf \n",moyenne);
    #endif
  }
  moyenne=moyenne/nbNotes;
  printf("La moyenne est : %.2lf \n",moyenne);
```

---
# La compilation conditionnelle
## La compilation
```c
gcc -Wall -DDEBUG moyenneAvecD.c -o test
```
## VAR
<center>
<video src="videos/part1/moyenneAvecD.mp4" width=400 controls poster="vignette.jpg"></a>
</video>
</center>

---
# TODAY
## Plan
1. Les directives prépocesseurs
2. .under[Les arguments]
3. Les tests unitaires

---
# Les arguments
## Définition
Paramètres/valeurs transmis au programme sous la forme de chaînes caractère. Le séparateur des arguments est l'espace.

## Objectifs
- Donner des valeurs à des variables même si le code est compilé
- Automatiser des exécutions de code
- Réaliser des tests
- ...

---
# Les arguments
## Représentation schématique
<img src="img/argumentsRepresentation.png" width=400>

## En ligne de commande
```bash
./exe Mike Wheeler
```

## Résultat
<center>
<video src="videos/part2/bonjour.mp4" controls poster="vignette.jpg" height=150 width=150></a>
</video>
</center>

---
# Les arguments en C
## Le prototype de la fonction main
.underR[Attention :] il ne faut pas oublier de bien définir la fonction main
```c
int main(int argc, char* argv[])
```
## Explication
- .under[int argc] est le nombre d'arguments passé au programme. Le nombre est toujours supérieur ou égal à 1 car le premier argument est le nom de l'exécutable
- .under[char* argv[]] est le tableau de chaînes contenant les paramètres passés au programme

---
# Exemple
## Le code
```c
#include<stdio.h>
#include<stdlib.h>
int main(int argc, char* argv[]){
  printf("Bonjour, %s %s, Comment vas tu ?\n",argv[1],argv[2]);
  return 0;
}
```
## Compilation
```bash
gcc -Wall bonjour.c -o exe
```
## Exécution
```bash
./exe Mike Wheeler
```
---
# Exemple
## Le code
```c
#include<stdio.h>
#include<stdlib.h>
int main(int argc, char* argv[]){
  printf("Bonjour, %s %s, Comment vas tu ?\n",argv[1],argv[2]);
  return 0;
}
```

## Backstage

---
# Exemple
## VAR
<center>
<video src="videos/part2/bonjour.mp4" width=400 controls poster="vignette.jpg"></a>
</video>
</center>

---
# Exemple Générique
## Le code
```c
#include<stdio.h>
#include<stdlib.h>

int main(int argc, char* argv[]){
  for (int i=0; i<argc; i++){
    printf("Je suis le paramètre N°%d et ma valeur est %s \n",i,argv[i]);
  }
  return 0;
}
```
---
# Exemple Générique
## VAR
<center>
<video src="videos/part2/generique.mp4" width=400 controls poster="vignette.jpg"></a>
</video>
</center>

---
# Les arguments

## Attention
Un argument est toujours une chaîne de caractères ... même si l'argument est un nombre
## C-a-d
```c
#include<stdio.h>
#include<stdlib.h>
int main(int argc, char* argv[]){
    int somme;
    somme=argv[1]+argv[2];
    printf("la somme est %d \n",somme);
    return 0;
}
```
<br>
.pull-left[
#### Compilation
```bash
gcc -Wall arg.c -o exe
```
]

.pull-right[
#### Exécution
```bash
./exe 4 4
```
]

---
# Les arguments
## Attention
```c
#include<stdio.h>
#include<stdlib.h>
int main(int argc, char* argv[]){
    int somme;
    somme=argv[1]+argv[2];
    printf("la somme est %d \n",somme);
    return 0;
}
```
<img src="img/false.gif" width=200>

---
# Exemple 2
## VAR
<center>
<video src="videos/part2/sommeFaux.mp4" width=400 controls poster="vignette.jpg"></a>
</video>
</center>

---
# La solution
## atoi
Conversion des chaînes de caractères en valeur numérique via la fonction atoi()

## Le code
```c
#include<stdio.h>
#include<stdlib.h>
int main(int argc, char* argv[]){
    int somme;
    somme=atoi(argv[1])+atoi(argv[2]);
    printf("la somme est %d \n",somme);
    return 0;
}
```
---
# Exemple 2
## VAR
<center>
<video src="videos/part2/sommeVrai.mp4" width=400 controls poster="vignette.jpg"></a>
</video>
</center>

---
# Attention
## Ne pas oublier
int main (.underR[int argc, char* argv[]])

#### Sinon ça marche pas

## VAR
<center>
<video src="videos/part2/sommeFauxRetour.mp4" controls poster="vignette.jpg" height=200 width=400></a>
</video>
</center>
---
# TODAY
## Plan
1. Les directives préprocesseurs
2. Les arguments
3. .under[Les tests unitaires]

---
# Les Tests
## Différents types
- test unitaires :
- test d'intégration
- test de validation
- test de régression

## Déroulement des tests
1. choix d'un cas de test (CT)
2. Création d'une donnée de test (DT) pour CT
3. Prévoir un résultat attendu pour DT (ORACLE)
4. Exécuter le code à tester sur DT
5. Comparer le résultat avec l'Oracle grâce aux assestions

---
# Les tests unitaires
## Définition

.otro-blockquote[C'est une procédure permettant de vérifier le bon fonctionnement d'une partie précise d'un logiciel ou d'une portion d'un programme (appelée « unité » ou « module »). *source : wikipedia*]

## Que Tester ?
- Toutes les conditions d'arrêt des boucles itératives
- Toutes les branches d'exécution d'une instruction conditionnelle
- Les différentes structures de données locales

---
# Exemple 1
## Palindrome
#### ALGO
```c
FONCTION estPalindrome(mot : tableau de chaine de caractères): ENTIER
VARIABLES :
    i,res,j : entier
DEBUT
  res<-0
  i <- 0
  j <- strlen(mot) -1

TANT QUE((i <> j) ET (mot[i]=mot[j])) FAIRE
    i <- i+1
    j <- j-1
  FIN TANT QUE

res <- (i=j);

RETOURNER res;
FIN

```

---
# Exemple 1
## Palindrome

#### VAR
<center>
<video src="videos/part3/palindrome.mp4" height=200 width=150 controls poster="vignette.jpg"></a>
</video>
</center>

---
# Exemple 1
## Palindrome
#### Debuggage
<center>
<video src="videos/part3/palindromeD1.mp4" controls poster="vignette.jpg"></a>
</video>
</center>

---
# Exemple 1
## Palindrome
#### C'est long de tester
<center>
<video src="videos/part3/palindromeLong.mp4" controls poster="vignette.jpg"></a>
</video>
</center>

---
# Exemple 1
## Palindrome
#### La solution : les arguments
<center>
<video src="videos/part3/palindromeArg.mp4" controls poster="vignette.jpg"></a>
</video>
</center>

---
# Les assertions
## Définition
.otro-blockquote[Une assertion est une expression qui doit être évaluée comme vraie. Si cette évaluation échoue elle peut mettre fin à l'exécution du programme, ou bien lancer une exception. *(source : wikipedia)*]
## Dans notre cas
```c
palindrome('kayak') = 1;
palindrome('radar') = 1;
palindrome('coucou') = 0;
palindrome('n') = 1;
palindrome('') = 1;
```

---
# Les procédures de tests
## Objectifs
- tester les assertions définies avant
- automatiser les tests

## Dans notre cas
#### RAPPEL
```c
PROCEDURE testPalinKAYAK
VARIABLE
    mot : tableau de chaine de caractères
DEBUT
    mot <- "kayak"
    SI(estPalindrome(mot) ALORS
        ECRIRE("palindrome('kayak') SUCCEED !")
    SINON
        ECRIRE("palindrome('kayak') FAIL !")
    FIN SI
FIN
```
---
# Les procédures de tests
## COMMENT ?
Une procédure par assertions

## EN C
```c
void testPalinKAYAK(){
	char mot[TAILLE]="kayak";
    if (estPalindrome(mot))
        printf("palindrome('kayak') SUCCEED ! \n");
    else
        printf("palindrome('kayak') FAIL ! \n");
}
```
---
# Le programme de tests
## COMMENT ?
Programme principal qui appel toutes les procédures tests

## LES FICHIERS
<img src="img/palindromeTest.png" width=200>

---
# Le programme de tests
## VAR
<center>
<video src="videos/part3/palindromeTest.mp4" controls poster="vignette.jpg"></a>
</video>
</center>

---
# Conclusion
## Outil après compilation
Les arguments permettent d'adapter un programme à l'utilisateur. On peut modifier les entrées du programme sans recompiler le code.

## Outil pour le debbugage
Les directives préprocesseur permettent :
- d'établir la compilation conditionnelle
- de réaliser des macros

## Outil pour tester un programme
Les tests unitaires, en plusieurs étapes :
1. Les assertions
2. Les procédures
3. Le programme test

---
# La doc

## Des liens utiles
<a href="https://practicalprogramming.fr/tests-unitaires" target="_blank">practicalprogramming -> test unitaire</a>

<a href="https://openclassrooms.com/fr/courses/19980-apprenez-a-programmer-en-c/7673041-utilisez-les-directives-du-preprocesseur" target="_blank">openClassroom -> les directives du préprocesseur</a>