Chapitre III : Tests structurels

Par AIT-BOUZIAD Ahmed

Avant de présenter les principales méthodes de tests structurels, nous introduisons un certain
nombre de définition nécessaires à leur compréhension.

1. Composant d’un logiciel

Dans notre contexte, le terme composant (unit en anglais) est utilisé pour représenter soit une
procédure soit une fonction.
Un composant) est caractérisée par :

1.1.Ses entrées :
Les entrées d’un composant consiste en les :
– paramètres en entrées
– variables globales lues dans le composant

1.2.Ses sorties :
Les sorties d’un composant consiste en les :
– paramètres de la procédure ou de la fonction en sortie
– variables globales écrites dans le composant

Remarque : l’identification des entrées et sorties peut être le résulat d’une analyse du code si
ca n’apparaît pas clairement dans le code

1.3.Son corps
Décrit les relations entre les entrées et les sorties du composant.

1.4. Ses composantes appelées

Détermine les variables lues/écrites par ces composants appelés (A voir à la fin de ce cours)

Exemple : soit le composant suivant

VG1, V2 : Int ;
Procedure proc (P1 : in Int ;
P2: inout Int;
P3 :out Int)
Is
L1, L2 : Int ;
Begin
…
L1 := VG1 ;
VG1 := L2 ;
VG2 := 0 ;
…
End ;

Entrées = {paramètres en in} + {variables globales lues}

= { P1, P2} + { VG1}
= { P1, P2 , VG1 }
Sorties = { paramètres en out } + { variables globales écrites }
= { P2, P3 } + { VG1, VG2 }
= { P2, P3 , VG1, VG2 }

1
 2. Dossier de test

2.1.Vie d’un dossier de test

2.2.Jeu d’entrée d’un test

Un jeu de test représente les deux premières parties d’un composant :

 Les Données de Test (DT) : ensemble de valeurs permettant de débuter un test.

Représentent des instances des entrées du composant.

 Les comportements attendues (ou sorties attendues) : ensemble des valeurs de sortie
conformes aux valeurs d’entrées. Représentent une instanciation des sorties du composant.
La conformité des sorties provient de la spécification de la procédure (i.e. ce que l’on veut
que la procédure réalise).

Exemple : on reprend l’exemple précédent.

Données du Test Sorties Attendues

P1 P2 VG1 P2 P3 VG1 VG2
Jeu 1
Jeu 2
Jeu 3

Remarque : Jeu(i) = DT(i) + SA(i)

3. Problématique de la détermination du jeu de test

Le jeu de tests est une représentation pour des valeurs particulières de la spécification d’un
composant.
Et si l’on veut tester complètement un logiciel, il faut élaborer tous les jeux de tests permettant de
couvrir la spécification.
Or la combinatoire de n’importe quel problème même de très petite taille est trop importante pour
faire un test exhaustif.
2
Par exemple, pour vérifier l’addition sur les entiers 32 bits, cela nécessiterait 264 jeux de tests.

Ainsi toute la difficulté du test d’un logiciel provient, entre autre, de la détermination d’un jeu
d’entrées permettant d’acquérir un certain niveau de confiance dans le logiciel.

Note : Les autres difficultés proviennent de la manière de déterminer les valeurs de sorties attendues
par apport à un jeu d’entrées et du traitement des composants appelés.

4. Exécution d’un test

L’exécution d’un test s’effectue en 4 étapes :

1. mettre le composant de code à tester dans son environnement de test ;
2. appeler le composant à tester ;
3. récupérer l’environnement après l’appel et filtrer les sorties du jeu de tests ;
4. comparer les résultats obtenus à l’étape ?? et les résultats attendus dans le jeu de tests.

Deux cas possibles :

– ils sont identiques, alors le test est OK
– Ils sont différents alors soit l’on vient de découvrir une anomalie, soit il y a une erreur dans le jeu
de tests !

5. Graphe d’un flot de contrôle

L’analyse du flot de contrôle d’un composant permet la construction des lignes du tableau de tests.

5.1.Objectif du graphe
Faciliter l’analyse du flot de contrôle en représentant graphiquement tous les chemins d’exécution
potentiels d’un composant (liées à ces flots).

3
 5.2.Définition du Graphe de Contrôle (GC)
C’est un graphe orienté avec un nœud d’entrée E est un nœud de sorti S.

5.2.1. Bloc élémentaire d’un composant :

C’est une séquence maximale d’instructions séquentielles d’un composant.

5.2.2. Nœud (ou sommet) d’un GC :

Un nœud du GC représente, dans un composant, soit :
1. un bloc élémentaire d’un composant,
2. un contrôle/test « conditionnel », (Un prédicat conditionnel)
3. un contrôle/test « boucle ». (un prédicat de boucle).
5.2.3. Arc d’un GC :
Représente un enchainement d’exécution possible entre deux (2) nœuds.

5.3.Exemple
Soit le programme P1 suivant :
If x<=0 then x := -x
Else x := 1 – x ;
If x=-1 then x := 1
Else x := x + 1 ;
Writeln (x) ;

Etape 1 : marquer le programme P1

Il s’agit d’identifier tous les nœuds à partir du code.

If P1 x<=0 then B1 x := -x
Else B2 x := 1 – x ;
If P2 x=-1 then B3 x := 1
Else B4 x := x + 1 ;
B5 Writeln (x) ;

Remarque : après cette étape, il ne devrait rester aucune instruction nom marquée.

Etape 2 : Construction du graphe de contrôle G(P1)

E

P1
X <=0 X>0
G (P1) :

B1 B2

P2
X =-1 X <>-1

B3 B4

B5 S

4
 6. Chemins de contrôle
C’est une suite d’arcs rencontrés dans le graphe, en partant du nœud d’entrée E et se terminant sur
le nœud de sortie S.
Un chemin de contrôle représente une exécution possible d’un composant à partir d’une donnée de
test (DT) donnée.

5.4.Exemple
Etant donnée le graphe de contrôle de l’exemple précédent.
On peut construire le Chemin de Contrôle suivant :
CC1 = [ E, P1, B1, P2, B3, B5, S ]
Par contre le chemin suivant n’est pas un CC :
[B1, P2, B3, B5, S]
Puisqu’il ne commence pas avec E.

Il est facile de constater que ce GC comprend quatre (4) CC :

CC1 = [ E, P1, B1, P2, B3, B5, S ]
CC2 = [ E, P1, B1, P2, B4, B5, S ]
CC3 = [ E, P1, B2, P2, B3, B5, S ]
CC4 = [ E, P1, B2, P2, B4, B5, S ]

5.5.Notation
Pour simplifier les représentations des CC, on adoptera la notation condensée illustrée sur le CC1
comme suit :
CC1 = E P1 B1 P2 B3 B5 S

7. Expression algébrique des chemins de contrôle

7.1.Définition
C’est une expression algébrique qui exprime sous forme compact et formelle tous les chemins de
contrôle d’un GC donné.

7.2.Exemple
Etant donné le graphe G1 de l’exemple précédent. Construisons une telle expression :

Soit M représentant l’ensemble de tous les CC possibles de G1.

Alors on peut écrire : M = CC1 ou CC2 ou CC3 ou CC4

On adoptant le signe « + » pour exprimer le ou logique, on obtient la notation algébrique suivante :

M = CC1 + CC2 + CC3 + CC4
M = E P1 B1 P2 B3 B5 S + E P1 B1 P2 B4 B5 S + E P1 B2 P2 B3 B5 S + E P1 B2 P2 B4 B5 S

Simplifions cette expression algébrique:

a) Factoriser « E P1 » en début des CC :
M = E P1 (B1 P2 B3 B5 S + B1 P2 B4 B5 S + B2 P2 B3 B5 S + B2 P2 B4 B5 S)
b) Factoriser « B5 S » en fin des CC :
M = E P1 (B1 P2 B3 + B1 P2 B4 + B2 P2 B3 + B2 P2 B4) B5 S
c) Factoriser B1 et B2
M = E P1 (B1 (P2 B3 + P2 B4) + B2 (P2 B3 + P2 B4) ) B5 S
d) Factoriser (P2 B3 + P2 B4) :
M = E P1 ( (B1 + B2) (P2 B3 + P2 B4) ) B5 S
e) Factoriser P2 :
M = E P1 (B1 + B2) P2 (B3 + B4) B5 S

5
Note : Il apparait fastidieux de construire cette expression algébrique compacte avec cette méthode.
C’est pour cela qu’on va proposer des règles simples pour y parvenir. C’est l’objet de la section
suivante.

7.3.Méthode de construction de l’expression algébrique des chemins de

contrôle
Principe : A partir de l’observation du fait que dans un GC, il existe trois structures (forme) de base :
1- Structure séquentielle,
2- Structure conditionnelle/alternative,
3- Structure de boucle/itérative
L’idée est d’associer une opération algébrique (addition/multiplication) à chacune de ces structures
de base apparaissant dans le GC. Et pour ce faire, les trois règles suivantes sont proposées.

Règle 1 : pour la « structure séquentielle »

B1 B2

Cette structure séquentielle exprime le fait que l’exécution du nœud B1 est immédiatement suivie de
l’exécution du nœud B2.

A cette forme est associée l’expression algébrique :

M = B1 B2

Règle 2 : pour la « structure conditionnelle »

B1 B2

B3

Cette structure conditionnelle exprime le fait que l’exécution du nœud P (conditionnel) est suivie
selon sa valeur de vérité, soit par l’exécution B1 soit par l’exécution du nœud B2. Et dans les deux
cas, l’exécution se termine par le nœud B3.

A cette forme est associée l’expression algébrique :

M = P (B1 + B2) B5

Règle 2 : pour la « structure de boucle »

D

P
F
V
C

S 6
Cette structure de boucle (itérative) exprime le fait que l’exécution débute par un nœud D suivie par
celle du test P. Ensuite, selon la valeur de vérité de P, on rentre dans le corps de la boucle pour
exécuter le nœud C (Corps) dans le cas ou le test est « Vrai », ou bien on sort de la boucle pour
exécuter le nœud S qui décrit le code à la sortie de la boucle dans la cas « Faux ».
A noter qu’après l’exécution du nœud C, on revient automatiquement re-tester le nœud P.

A cette forme est associée l’expression algébrique :

M = D P (C P)* S

Rappel : En théorie des langages

a* = 1 + a + aa + aaa + … où 1 représente le caractère vide
= a0 + a1 + a2 + a3 + …
Exercice :
Retrouver cette expression algébrique à partir de la structure de boucle.

Borner la boucle
En pratique, le plus souvent, aucune boucle n’est censée être infinie si non le programme ne se
terminerait jamais.
Ainsi, si par exemple la boucle consiste en une itération sur la taille d’un tableau de quatre éléments,
alors au maximum on itérera 4 fois.
Dans ce cas les chemins potentiellement exécutés sont :

CC0 = D P (C P)0 S = D P S (exécution avec 0 itération)

CC1 = D P (C P)1 S = D P C P S (exécution avec 1 itération)
CC2 = D P (C P)2 S = D P C P C P S (exécution avec 2 itérations)
CC3 = D P (C P)3 S = D P C P C P C P S (exécution avec 3 itérations)
CC4 = D P (C P)4 S = D P C P C P C P C P S (exécution avec 4 itérations)
Conclusion :
M = CC0 + CC1 + CC2 + CC3 + CC4
M = D P [ (C P)0 + (C P)1 + (C P)2 + (C P)3 + (C P)4 ] S

Notation : (exposant barré)

On notera an = a0 + a1 + a2 + … +an pour n>= 0

Dans notre exemple on écrira :

M = D P (C P)4 S

Remarque :
Ne pas confondre (C P)4 avec (C P)4. En effet,
 (C P)4 , représente le chemin : CPCPCPCP
 (C P)4 , est une expression algébrique qui représente l’ensemble des 5 chemins :
(C P)0 + (C P)1 + (C P)2 + (C P)3 + (C P)4

Ainsi, (C P)4 est un élément de (C P)4.

8. Chemin de contrôle exécutable et non exécutable

8.1.Définition : Sensibilité d’un CC par apport à une DT

On dira qu’une DT sensibilise un chemin de contrôle C si l’exécution du composant avec comme
entrée cette DT, déclenche l’exécution consécutive des nœuds décrivant ce chemin de contrôle.

Exemple :
Reprenons l’exemple du programme P1 et de son graphe G(P1) :
Soit la DT1 = { x = 2 }

7
LA SUITE A VENIR