UNIVERSISTE DE SFAX Année Universitaire : 2020-2021

Faculté des Sciences de Sfax

Correction TD1-2 : Test logiciel
Niveau : 2ème Année
Enseignant de Cours : Kais HADDAR
Enseignante de TD : Farah FOURATI

Exercice 1 :

Compléter le texte ci-dessous en utilisant les termes suivant :

Bug, défaut, erreur, défaillance, défaut, méprise, qualité, risques, logiciel, test.
Un être humain peut faire une erreur (méprise), qui produit un défaut (bug) dans le code, dans un
logiciel ou un système, ou dans un document. Si un défaut dans du code est exécuté, le système
n’effectuera pas ce qu’il aurait dû faire (ou fera ce qu’il n’aurait pas dû faire), générant une
défaillance. Des défauts dans les logiciels, systèmes ou documents peuvent générer des
défaillances, mais tous les défauts ne le font pas.
Les défauts apparaissent parce que les humains peuvent se tromper et à cause des échéanciers
serrés, de la complexité du code et des infrastructures, des modifications de technologies et/ou de
multiples interactions entre les systèmes.
Les défaillances peuvent être aussi causées par des conditions d’environnement : radiations,
magnétisme, champs électroniques et pollution peuvent causer des défauts dans les
microprogrammes ou influencer l’exécution des logiciels en modifiant les conditions matérielles.
Les tests peuvent augmenter le niveau de confiance en la qualité́ d’un logiciel s’ils trouvent peu
ou pas de défauts. Un test conçu correctement et qui est exécuté́ sans erreur réduit le niveau de
risque général du système. Quand les tests trouvent des défauts, la qualité́ du système logiciel
s’accroit quand ces défauts sont corrigés.
Remarque :

1
Erreur : Action humaine produisant un résultat incorrect.
L’erreur est humaine

Défaut : Une imperfection dans un composant ou un système qui peut conduire à ce qu’un
composant ou un système n’exécute pas les fonctions requises, par exemple une instruction ou une
définition de données incorrecte. Un défaut, si rencontré lors de l’exécution, peut causer la
défaillance d’un composant ou d’un système.
Trouver un défaut sans manipuler le système

Défaillance : Écart constaté du composant ou système par rapport au livrable, au service ou au

résultat attendu [d’après Fenton]; Incapacité d’un système ou d’un composant d’exécuter une
fonction requise dans les limites spécifiées. Une défaillance peut être produite quand un défaut est
rencontré [DO-178B]
Trouver une défaillance en manipulant le système

Anomalie : toute condition qui dévie des attentes basées sur les exigences de spécifications,
documents de conception, documents utilisateurs, standards etc, ou des perceptions ou expériences
de quelqu’un. Les anomalies peuvent être trouvées pendant, mais pas uniquement, les revues, tests,
analyses, compilations ou utilisation des produits logiciels ou de la documentation applicable
[IEEE 1044]. »
Un écart entre le résultat attendu et le résultat obtenu

Source image : https://latavernedutesteur.fr/2020/11/10/difference-entre-erreur-defaut-

defaillance-et-anomalie-cynthia-lefevre/

Exercice 2 :
Elaborer des DT permettant de tester une fonction qui détermine la nature d’un caractère passé
comme paramètre d’entrée.
Correction :

Sortie observée (calculée) :

DT : Prog Classification du caractère
Caractère nature_caractere

L’un des principes du test logiciel est que le test exhaustif n’est pas possible.
On cherche l’ensemble des données de test T tel que :

Le programme (logiciel) est considéré comme une boîte noire. Nous envisageons de le tester en
vue de mettre en évidence ses erreurs par rapport à sa spécification.
Classes d’équivalences :
Codification ASCII : elle comporte 256 caractères codifiés de 0 à 255 dans cette modification, on
distingue :

2
 - Chiffres : ‘0’..’9’

- Lettres minuscules : ‘a’..’z’

- Lettres majuscules ‘A’..’Z’

- Autres : partie complémentaire

En partant de ces classes d’équivalence, on peut proposer les données de test suivantes :

Jeu de test :

- Classe chiffre
o Cas ordinaire : ‘3 ‘ par exemple
o Cas limites : ‘0’, ‘1’, ‘8’, ‘9’
- Classe lettre minuscule
o Cas ordinaire : ‘k’
o Classification des caractères
- Classe lettre minuscule
o Cas ordinaire : ‘k’
o Cas limites : ‘a’, ‘b’, ‘y’, ‘z’
- Classe lettre majuscules
o Cas ordinaire : ‘M’
o Cas limites : ‘A’, ‘B’, ‘Y’, ‘Z’
- Autre classe : théoriquement un seul représentant fera l’affaire par exemple ‘ ;’
Rq : on a intérêt à décomposer d’avantage la classe d’équivalence autre !

3
 UNIVERSISTE DE SFAX Année Universitaire : 2020-2021
Faculté des Sciences de Sfax TD2 : Test logiciel

Section : 2ème Année LSI

Enseignant de Cours : Kais HADDAR
Enseignante de TD : Farah FOURATI

Exercice 1 :
1. Elaborer des DT permettant de tester le sous-programme qui
détermine si un entier info appartient à un ensemble de valeurs
ordonnés.
2. Tester le sous-programme proposé
3. Automatiser l’oracle de test, en passant par le sous-programme
d’ordre supérieur bsearch de la bibliothèque stdlib.h qui
implémente l’algorithme de recherche dichotomique

Exercice 2 :
1. Elaborer des DT permettant de tester le sous-programme qui permet
de tirer un tableau d’entiers.
2. Tester le sous-programme proposé.
3. Automatiser l’oracle de test, en passant par le sous-programme
d’ordre supérieur qsort de la bibliothèque stdlib.h

1
 UNIVERSISTE DE SFAX Année Universitaire : 2020-2021
Faculté des Sciences de Sfax
Correction TD 2 : Test logiciel
Niveau : 2ème Année
Enseignant de Cours : Kais HADDAR
Enseignante de TD : Farah FOURATI

Rappel :
"Les tests de programmes peuvent être utilisés pour montrer la présence de bogues, mais
jamais leur absence !"
} Principe n ° 1: } Les tests montrent la présence de défauts, mais si aucun défaut n'est trouvé,
cela ne prouve pas l'exactitude.
} Principe n ° 2: } Les tests exhaustifs sont impossibles, toutes les combinaisons d'entrées et de
conditions préalables sont impossibles à tester, au lieu de cela, il est important de se concentrer sur
l'analyse des risques et les priorités.
} Principe n ° 3: } Les tests précoces sont importants, testez le plus tôt possible et concentrez-
vous sur les objectifs définis.
} Principe n ° 4: } Regroupement de défauts, une petite section de code peut contenir la plupart
des défauts.
} Principe n ° 5: } Pesticide Paradox, utiliser sans cesse les mêmes cas de test ne mènera jamais
à la découverte de nouveaux défauts - examinez-les régulièrement.
} Principe n ° 6: } Les tests dépendent du contexte, les logiciels critiques pour la sécurité sont
testés différemment d'un site de commerce électronique.
} Principe n ° 7: } Erreur d'absence d'erreurs, si le système ne répond pas aux besoins des
utilisateurs, il n'est pas utile.

Exercice 1 :
1. Elaborer des DT permettant de tester le sous-programme qui détermine si un entier info
appartient à un ensemble de valeurs ordonnés.
2. Tester le sous-programme proposé
3. Automatiser l’oracle de test, en passant par le sous-programme d’ordre supérieur bsearch
de la bibliothèque stdlib.h qui implémente l’algorithme de recherche dichotomique

Correction 1.:

DT :
info Sortie observée
tableau trié Prog (calculée) :
recherche_dichotomique {vrai, faux}

Classes d’équivalences :
- Classe 1 : info appartient au tableau (issue positive)
- Classe 2 : info n’appartient pas au tableau (issue négative)

1
Jeu de test :
- Classe 1 ; issue positive
o Cas ordinaire : DT1={17, {10,15,17,20,24,116}}
o Cas limites :
DT2={10, {10,15,17,20,24,116}}
DT3={15, {10,15,17,20,24,116}}
DT4={24, {10,15,17,20,24,116}}
DT5={116, {10,15,17,20,24,116}}
- Classe 2 ; issue négative
o Cas ordinaire : DT6={18, {10,15,17,20,24,116}}
o Cas limites :
DT7={8, {10,15,17,20,24,116}} info < à la valeur en première position
DT8={12, {10,15,17,20,24,116}} info entre la valeur de 1ere et 2eme position
DT9={200, {10,15,17,20,24,116}} info > à la valeur en dernière position
DT10={40, {10,15,17,20,24,116}} info entre la valeur de dernière et avant
dernière position

Correction 2.:
#include <assert.h> //void assert( int condition );
#include <stdio.h>
int recherche_dichotomique(int info, int a[], unsigned n);
unsigned oracle(int info, int a[], unsigned n, int sa) {
int sc=recherche_dichotomique(info,a,n);
if(sc==sa)
return 1;
else
return 0;
}
int main(){
int a[6]={10,15,17,20,24,116} ;

//Classe 1 (issue positive)

//Cas ordinaire
assert(oracle(17, a, 6,3)) ;

//Analyse des cas limites :

assert(oracle(10, a, 6,1)) ;
assert(oracle(15, a, 6,2)) ;
assert(oracle(24, a, 6,5)) ;
assert(oracle(116, a, 6,6)) ;

//Classe 2 (issue négative)

//Cas ordinaire : DT6= (18, {10,15,17,20,24,116})
assert(oracle(18, a, 6,0)) ;

//Analyse des cas limites :

assert(oracle(8, a, 6,0)) ;
assert(oracle(12, a, 6,0)) ;
assert(oracle(200, a, 6,0)) ;

2
 assert(oracle(40, a, 6,0)) ;
//printf("\n**** ok ****\n");
return 1;
}
int recherche_dichotomique(int x, int a[], unsigned n){
int g,d,m;
g = 0;
d = n-1;
do{
m=(g+d)/2;
if (a[m] == x)
return m+1;//position non pas l'indice car erreur avec
l'indice 0! qui va être considéré comme false
else
if(x<a[m])
d=m-1;
else
g=m+1;
}while(g<=d);
return 0;//return -1;
}
Correction 3.:
#include <assert.h> //void assert( int condition );
#include <stdlib.h> /*
void * bsearch( const void * searchedValue, const void * arrayPtr,
size_t elementCount, size_t elementSize,
int (*comparatorFunction)(const void *, const void
*));
*/
#include <stdio.h>
int recherche_dichotomique(int info, int a[], unsigned n);
int comparer (const void * x, const void * y){
if( *(const int*)x < *(const int*)y )
return -1;
else if( *(const int*)x > *(const int*)y )
return 1;
else
return 0;
}
unsigned oracle(int info, int a[], unsigned n) {
int * sa= bsearch(&info,a,n,sizeof(int),comparer);
int sc=recherche_dichotomique(info,a,n);
//printf("\n%p",res);//un pointeur sur l'élément s'il existe sinon
NULL
//printf("\n%d",rd);
if(sa && sc)
return 1;
else
if(!sa && !sc)
return 1;
else
return 0;
}
int main()
{

3
 int a[6]={10,15,17,20,24,116} ;

/*
int info=21,n=6;
int * res=bsearch(&info,a,n,sizeof(int),comparer);
printf(res != NULL ? "existe" : "n'existe pas " );
*/
//Classe 1 (issue positive)
//Cas ordinaire
assert(oracle(17, a, 6)) ;

//Analyse des cas limites :

assert(oracle(10, a, 6)) ;
assert(oracle(15, a, 6)) ;
assert(oracle(24, a, 6)) ;
assert(oracle(116, a, 6)) ;

//Classe 2 (issue négative)

//Cas ordinaire : DT6= (18, {10,15,17,20,24,116})
assert(oracle(18, a, 6)) ;

//Analyse des cas limites :

assert(oracle(8, a, 6)) ;
assert(oracle(12, a, 6)) ;
assert(oracle(200, a, 6)) ;
assert(oracle(40, a, 6)) ;

return 1;
}
int recherche_dichotomique(int x, int a[], unsigned n){
int g,d,m;
g = 0;
d = n-1;
do{
m=(g+d)/2;
if (a[m] == x)
return m+1;//position non pas l'indice car erreur avec
l'indice 0! qui va être considéré comme false
else
if(x<a[m])
d=m-1;
else
g=m+1;
}while(g<=d);
return 0;//return -1;
}

Exercice 2 :
1. Elaborer des DT permettant de tester le sous-programme qui permet de tirer un tableau
d’entiers.
2. Tester le sous-programme proposé.
3. Automatiser l’oracle de test, en passant par le sous-programme d’ordre supérieur qsort
de la bibliothèque stdlib.h

4
Correction 1.:

DT :
Tableau Sortie observée (calculée) :
Tableau trié
Prog tri

DT1={{3,6,8,10},4}// tableau trié

DT2={{4,3,2,1,0},5}//tableau inversé
DT3={{66,1,2,0,-1,77},6}//ordre quelconque (cas ordinaire )

Correction 2.:
3 Processus de test

DT : Donnée
Implémentation
de test
sous test

Exécution Spécification

Sortie calculée Sortie attendue

ou observée
Fonction
Oracle non : c-à-d, on a trouvé
oui
non un contre-exemple
Critère d’arrêt
oui : digne de confiance

La fonction oracle permet de comparer la sortie observée par rapport à la29 sortie
attendue.
#include<assert.h>
void tri(int tab[], unsigned n);
/*
DT1={{3,6,8,10},4}//tableau trié
DT2={{4,3,2,1,0},5}//tableau inversé
DT3={{66,1,2,0,-1,77},6}//ordre quelconque (cas ordinaire )
*/
int oracle(int a[], int b[], unsigned n){
int i=0;
tri(a,n);
while(i<n && a[i]==b[i])
i++;
if(i<n)
return 0;
else
return 1;
}
int main(){
int dt1[]={3,6,8,10},a1[]={3,6,8,10} ;
assert(oracle(dt1,a1,4));

int dt2[]={4,3,2,1,0},a2[]={0,1,2,3,4} ;

5
 assert(oracle(dt2,a2,5));

int dt3[]={66,1,2,0,-1,77},a3[]={-1,0,1,2,66,77} ;
assert(oracle(dt3,a3,6));
return 1;
}
void tri(int tab[], unsigned n){//tri insertion
int i,j,tmp;
for (i=1 ; i < n; i++) {
j = i;
while (j > 0 && tab[j-1] > tab[j]) {
tmp = tab[j];
tab[j] = tab[j-1];
tab[j-1] = tmp;
j--;
}
}
}

Correction 3.:

Implémentation
digne de confiance Implémentation
DT : Donnée sous test
de test

Exécution Exécution

Sortie attendue Sortie observée

oui : génération éventuelle Oracle non : Implémentation sous test n’est

des nouvelles DT pas conforme à la spécification
#include<assert.h>
#include <stdlib.h> /*
void qsort( void * array, size_t elementCount, size_t elementSize,
int (*compareFunction)( const void*, const void* )43);
paramètres:
1. Paramètres non fonctionnels: variables qui portent des valeurs
2. Paramètres fonctionnels: procedures et fonctions
*/
void tri(int tab[], unsigned n);
int comparer (const void * x, const void * y){
if( *(const int*)x < *(const int*)y )
return -1;
else if( *(const int*)x > *(const int*)y )
return 1;
else
return 0;
}
int oracle(int a[], unsigned n){
int i=0;
int q[n];

6
 for(int j=0;j<n;j++)
q[j]=a[j];
tri(a,n);
qsort(q,n,sizeof(int),comparer);

while(i<n && a[i]==q[i])

i++;
if(i<n)
return 0;//false
else
return 1;//true
}
void main(){
int tab1[]={3,6,8,10} ;
assert(oracle(tab1,4));

int tab2[]={4,3,2,1,0} ;
assert(oracle(tab2,5));

int tab3[]={66,1,2,0,-1,77};
assert(oracle(tab3,6));
}
void tri(int tab[], unsigned n){//tri insertion
int i,j,tmp;
for (i=1 ; i < n; i++) {
j = i;

while (j > 0 && tab[j-1] > tab[j]) {

tmp = tab[j];
tab[j] = tab[j-1];
tab[j-1] = tmp;

j--;
}
}
}

7
 UNIVERSISTE DE SFAX Année Universitaire : 2020-2021
Faculté des Sciences de Sfax TD3 : Test logiciel

Section : 2ème Année LSI

Enseignant de Cours : Kais HADDAR
Enseignante TD : Farah FOURATI

Exercice 1 :
void p(int x){
if(x<=0)
1. Etablir le graphe de flot de contrôle de ce
x=-x ;
else programme
x=1-x ; 2. Fournir l’expression des chemins. Déduire
if(x==-1) combien existe-t-il de chemins ?
x=1 ;
else
x=x+1 ;
print("%d",x) ;}

Exercice 2 :
int f(int n){
if (n<=0) 1. Etablir le graphe de flot de contrôle de ce
n = 1-n; programme
if (n%2==0)
2. Fournir l’expression des chemins. Déduire
n = n/2;
else combien existe-t-il de chemins pour une CFG?
n = 3*n+1; 3. Donner des DTs pour tous les nœuds
return n;} 4. Donner des DTs pour tous les arcs
5. Donner des DTs pour toutes les PLCS

Exercice 3 :
int f(int* tab, int key){
int i = 0; int res; bool found = false; 1. Etablir le graphe de flot de contrôle de ce
while(!found){ programme
if(tab[i]==key){ 2. Fournir l’expression des chemins. Déduire
found=true; res=i;} combien existe-t-il de chemins pour une CFG?
i = i+1;} 3. Donner des DTs pour tous les nœuds
return res;} 4. Donner des DTs pour tous les arcs
5. Donner des DTs pour toutes les PLCS

1
graphe de flot de contrôle
Correction exercice 1 :

(le
g). a
x<=0 x>0
t un
x := -x x := 1-x
b c
e.

d
x = -1 x ≠ -1
s
x := 1 f x := x+1
e

g
println(x)

Le graphe comprend 4 chemins de contrôle :

β1=[a,b,d,f,g]
β2=[a,b,d,e,g] 69

β3=[a,c,d,f,g]
β4=[a,c,d,e,g]
La forme algébrique :
abdfg + abdeg + acdfg + acdeg
= a(bdf + bde + cdf + cde)g
= a(b + c)d(e + f)g
è 1.(1+1).1.(1+1).1=4

2
 BB – Correction
Exercice exercice
1 2:

n<=0

n=1-n b n>0

n%2==0 c n%2!=0

n=n/2 d e n=3*n+1

f
return n

flot de contrôle de ce programme

Question 2 : L’expression des chemins :
n des chemins
abcdf+abcef+acdf+acef
a(1+b)c(e+d)f
= a(b+1)c(d+e)f 73

è 1(1+1)1(1+1)1=4
Question 3 : n=0, n=-1
Notez Bien que, la DT={ n=0} sensibilise le chemin [abcdf], on dit que
[abcdf]est un chemin exécutable, son taux de couverture N1 est
5/6=0.83
Taux de couverture (N1)= nb de nœuds couverts/nb total de nœuds
Question 4 : n=2, n=-2
Notez Bien que, la DT={ n=2} sensibilise le chemin [acdf], son taux de
couverture N2 est 3/7=0.42
Taux de couverture (N2) = nb d’arcs couverts/nb total d’arcs
Question 5 : Une PLCS est une portion linéaire de code suivie d’un
saut, i.e. une séquence d’instructions entre deux branchements

3
 PLCS= [a,b,c], [a,c], [c,d,f], [c,e,f]
On cherche à couvrir tous les PLCS, DTs : n=-1, n=1
Question 6 : Chemin indépendant : chemin introduisant un ensemble
nouveau d’instructions ou le traitement d’une nouvelle condition.
Nombre minimal de cas de tests ; Le nombre de chemins indépendants
pour un graphe G est V(G) c’est-à-dire
Nb arcs – Nb nœuds + 2 ou Nb conditions + 1 (if, while, for, case, ...)
DTs pour tous les chemins indépendants n=-1, n=1, n=3
BB – Exercice 2
Correction exercice 3 :
nt key){
a
a

se; found
b f
{
!found
d
c
tab[i]==key
tab[i]
!=key d

Remarque
flot de contrôle : [abf] est un chemin non exécutable ; aucune DT capable de
de ce programme
des chemins sensibiliser ce chemin
ab ( c ( 21 :+L’expression
Question d ) eb )* f des chemins : ab ( c ( 1+d ) eb )* f
74
è 1.1(1(1+1).1.1)N.1 =2N donc L’infini
Question 3 : [1], 1
Question 4 : [2,1], 1
Question 5 : PLCS= [a,b], [b,f] , [b,c,e] , [b,c,d,e,b]

4
 UNIVERSISTE DE SFAX Année Universitaire : 2020-2021
Faculté des Sciences de Sfax Test logiciel

Niveau : 2ème Année LSI

Enseignant de Cours : Kais HADDAR
Enseignante de TD : Farah FOURATI
L’objectif de ce TP est d’écrire et d’exécuter des tests unitaires avec JUnit pour une classe Java.

Outils utilisés : l’environnement de développement intégré Eclipse, plugin pour les test unitaires
JUnit 5.x et l’outil d’analyse de couverture structurel Emma

Exercice 1 : Ecrivez un ensemble de tests JUnit pour tester une méthode qui permet de faire la
somme de deux entiers.

Exercice 2 : Exécuter cette classe couvrant toutes les méthodes de déclaration d'assert
importantes dans JUnit.

class AssertTest {
@Test
public void testAssert(){
//Variable declaration
String string1=new String("Junit");
String string2="Junit";
String string3="test";
String string4="test";
String string5=null;
int variable1=1;
int variable2=2;
int[] airethematicArrary1 = { 1, 2, 3 };
int[] airethematicArrary2 = { 1, 2, 3 };
//Assert statements
assertEquals(string1,string2);
assertSame(string3, string4);
assertNotSame(string1, string3);
assertNotNull(string1);
assertNull(string5);
assertTrue(variable1<variable2);
assertFalse(variable1>variable2);
assertArrayEquals(airethematicArrary1, airethematicArrary2); }
Exercice 3 : Ecrivez un ensemble de tests JUnit pour tester une méthode qui permet de
rechercher la valeur minimale dans un tableau d’entiers.

Exercice 4 :
1. Ecrire une classe Personne, munir cette classe d’un constructeur, des getters et des setters
et d’une méthode equals.
2. À partir de la spécification de la classe Personne, écrivez un ensemble de tests JUnit pour
cette classe. Pensez à tester aussi bien les cas qui doivent réussir que les cas qui doivent
lever une exception : l’objectif est de couvrir un maximum de cas différents parmi les cas
possibles.