Exercises in Software Engineering and Control Flow Testing

Ce TP porte sur les techniques de test logiciel, notamment la partition en classes d'équivalence et les critères de couverture dans le contrôle de flux. Il propose plusieurs exercices permettant d'appliquer ces concepts à des méthodes ou programmes simples. Pour réaliser ce TP, il est nécessaire de comprendre les notions de classes d'équivalence, de valeurs frontières, ainsi que les critères de couverture des instructions, des arcs et des chemins dans un graphe de contrôle.

Objectifs

• Savoir définir des classes d'équivalence à partir de spécifications fonctionnelles.
• Construire des jeux de tests basés sur les valeurs frontières.
• Analyser un programme pour en extraire le graphe de contrôle.
• Appliquer les critères de couverture des instructions, des arcs et des chemins.
• Proposer des jeux de tests adaptés à chaque critère de couverture.

Prérequis et installation

• Connaissances de base en génie logiciel et tests logiciels.
• Compréhension des notions de classes d'équivalence et valeurs frontières.
• Notions de programmation et de structures de contrôle (conditions, boucles).
• Pas d'outils spécifiques requis, travail essentiellement théorique et conceptuel.

Exercice 1 : Partition en classes d’équivalence et jeu de test

Dans cet exercice, il s'agit de définir des classes d'équivalence pour plusieurs spécifications, puis de construire un jeu de test en utilisant les valeurs frontières lorsque c'est possible.

Étapes à suivre

• Pour chaque spécification, identifier les classes d'équivalence pertinentes.
• Pour chaque classe, choisir des valeurs représentatives, en privilégiant les valeurs frontières.
• Construire le jeu de test complet en combinant ces valeurs.

Exemples de solutions

• Maximum entre deux nombres : Classes : D1 = {(a,b) | a > b} D2 = {(a,b) | a < b} D3 = {(a,b) | a = b} Jeu de test : (5,2), (2,5), (5,5)
• Nombre pair : Classes : D1 = {d | d mod 2 = 0} D2 = {d | d mod 2 = 1} Jeu de test : (2), (3)
• Calcul selon parité : Méthode retourne 3 fois le nombre + 28 si impair, racine carrée sinon. Classes : D1 = {d | d mod 2 = 0} D2 = {d | d mod 2 = 1} Jeu de test : (2), (3)
• Couleurs des feux de circulation : Classes : D1 = {rouge} D2 = {vert} D3 = {jaune} D4 = {d | d ≠ rouge, vert, jaune} Jeu de test : (rouge), (vert), (jaune), (couleur inconnue)
• Calcul des impôts selon revenu : Classes : D1 = {0 ≤ d < 20 000} D2 = {20 000 ≤ d < 30 000} D3 = {30 000 ≤ d < 40 000} D4 = {40 000 ≤ d < 55 000} D5 = {55 000 ≤ d < 75 000} D6 = {d ≥ 75 000} D7 = {d < 0} (valeur invalide) Jeu de test : -1, 0, 19 999, 20 000, 29 999, 30 000, 39 000, 40 000, 54 999, 55 000, 74 999, 75 000

Exercice 2 : Test de la procédure triangle

Cette procédure reçoit trois réels a, b, c représentant les longueurs des côtés d'un triangle et retourne un code selon le type de triangle :

• 0 : triangle invalide
• 1 : triangle équilatéral
• 2 : triangle isocèle
• 3 : triangle scalène (ni isocèle ni équilatéral)

Étapes à suivre

• Définir les classes d'équivalence pour les entrées (a,b,c) selon le type de triangle.
• Préciser les sous-classes pour les triangles isocèles selon quels côtés sont égaux.
• Proposer un jeu de test couvrant tous les cas.

Classes d’équivalence

• D1 : (a,b,c) équilatéral (a=b=c)
• D21 : isocèle avec a=b ≠ c
• D22 : isocèle avec a=c ≠ b
• D23 : isocèle avec b=c ≠ a
• D3 : scalène (a≠b≠c)
• D41 : pas un triangle, a ≥ b+c
• D42 : pas un triangle, b ≥ a+c
• D43 : pas un triangle, c ≥ a+b

Jeu de test proposé

(3, 3, 3)  // équilatéral
(2, 2, 3)  // isocèle a=b
(2, 3, 2)  // isocèle a=c
(3, 2, 2)  // isocèle b=c
(3, 4, 5)  // scalène
(6, 3, 3)  // pas triangle (a ≥ b+c)
(3, 6, 3)  // pas triangle (b ≥ a+c)
(3, 3, 6)  // pas triangle (c ≥ a+b)

Exercice 3 : Application de réservation de golf

Cette application permet de réserver des départs au golf, fermé les lundis et mardis, ouvert de 7h00 à 21h00 les autres jours. La réservation une heure avant la fermeture n'est pas prise en compte. Les départs après 18h00 permettent une entrée gratuite. L'utilisateur entre un nom d'utilisateur, choisit un jour et une tranche horaire de 10 minutes.

Étapes à suivre

• Définir les classes d'équivalence pour chaque entrée : nom d'utilisateur, jour, heure.
• Proposer un jeu de test pertinent pour chaque classe.

Classes d’équivalence et jeux de test

• Nom d’utilisateur : D1 = {golfeurlogin} (valide) D2 = {autres chaînes} (invalide) Jeu de test : (golfeurlogin), (fajdlkjfka)
• Journée : D1 = {lundi, mardi} (fermé) D2 = {mercredi, jeudi, vendredi, samedi, dimanche} (ouvert) Jeu de test : (lundi), (mercredi)
• Heures : D1 = {heures < 7 ou > 20} (hors ouverture) D2 = {18 ≤ heure ≤ 20} (entrée gratuite possible) D3 = {7 ≤ heure < 18} (heures normales) Jeu de test : (6:50, 7:00, 17:50, 18:00, 19:50, 20:00)

Exercice 4 : Analyse d’un programme et critères de couverture

Le programme suivant effectue une division entière avec gestion du signe :

lire(x)
lire(y)
z = 0
signe = 1
si x < 0 alors
  signe = -1
  x = - x
finsi

si y < 0 alors
  signe = - signe
  y = - y
finsi

tant que x >= y faire
  x = x - y
  z = z + 1
fin

z = signe * z

Étapes à suivre

1. Tracer le graphe de contrôle numéroté.
2. Déterminer la suite de nœuds pour la couverture des instructions et proposer un jeu de test minimal.
3. Déterminer la suite de nœuds pour la couverture des arcs et proposer un jeu de test minimal.
4. Déterminer la suite de nœuds pour la couverture des 1-chemins (boucle répétée 0 ou 1 fois) et proposer un jeu de test minimal.

Solutions proposées

• Couverture des instructions : Nœuds parcourus : 1 2 3 4 5 6 7 8 9 10 11 12 Jeu de test : (x = -5, y = -2)
• Couverture des arcs : Suites de nœuds : 1 2 5 8 11 12 1 2 3 4 5 6 7 8 9 10 11 12 Jeux de test : (x=2, y=5) et (x=-5, y=-2)
• Couverture des 1-chemins : Suites de nœuds (exemples) : 1 2 5 8 11 12 et 1 2 5 8 9 10 11 12 1 2 3 4 5 8 11 12 et 1 2 3 4 5 8 9 10 11 12 1 2 5 6 7 8 11 12 et 1 2 5 6 7 8 9 10 11 12 1 2 3 4 5 6 7 8 11 12 et 1 2 3 4 5 6 7 8 9 10 11 12 Jeux de test : (x=2, y=5), (x=5, y=2), (x=-2, y=5), (x=-5, y=2), (x=2, y=-5), (x=5, y=-2), (x=-2, y=-5), (x=-5, y=-2)

Exercice 5 : Graphes de contrôle et jeux de test pour P1 et P2

Les programmes P1 et P2 sont :

P1:
if x < 0 then
  x := -x ;
end if ;
z := x ;

P2:
if (not (x = 0)) then
  y := 5 ;
else
  z := z - x ;
end if ;
if (z > 1) then
  z := z / x ;
else
  z := 0 ;
end if ;

Étapes à suivre

1. Tracer les graphes de contrôle pour P1 et P2.
2. Pour P1, proposer un jeu de test satisfaisant la couverture des instructions mais pas celle des arcs.
3. Pour P2, proposer un jeu de test satisfaisant la couverture des arcs mais pas celle des chemins.

Solutions

• Pour P1, le test (x = -2) satisfait la couverture des instructions mais pas celle des arcs. Il faut aussi tester x positif.
• Pour P2, le jeu (x=0, z=1), (x=1, z=3) couvre les arcs mais pas les chemins, ne détectant pas la division par zéro. Le jeu (x=0, z=3), (x=1, z=1), (x=0, z=1), (x=1, z=3) couvre les chemins et détecte la division par zéro.

Exercice 6 : Calcul des DT selon critères de couverture

Programme P3 :

if n ≤ 0 then
  n := 1 - n
end;
if n pair then
  n := n / 2
else
  n := 3 * n + 1
end;
write(n);

Calculer les jeux de tests (DT) selon les critères suivants :

• Couverture de tous les nœuds
• Couverture de tous les arcs
• Couverture de tous les chemins indépendants

Le détail des classes d’équivalence et jeux de tests n’est pas fourni dans le document source.

Exercice 7 : Jeux de tests pour la fonction Function(a, b)

Programme :

1 : Function (a, b)
2 : If (a < 10)
3 :   c := a + b
4 :   a := a + 1
5 :   If (b > 10)
6 :     d := a - b
7 :     b := b - 1
8 :   EndIf
9 : EndIf
10 : EndFunction

Jeux de tests selon critères

• Couverture des instructions : (a=5, b=15)
• Couverture des arcs : (5,5), (20,5), (5,15)
• Couverture des chemins indépendants : Nombre de chemins = e - v + 2 = 8 - 7 + 2 = 3 Jeu de test : (5,5), (20,5), (5,15)

Exercice 8 : Jeux de tests pour le programme P

Programme P :

1 : Fonction(int a, int b, int c)
2 : d := a + b + c
3 : if (a = b)
4 :   d := d * 2
5 : else if (a = c)
6 :   d := d / 2
7 : else
8 :   d := a
9 : endif
10 : endif
11 : while (c > 10)
12 :   d := d + b + a
13 :   c := c - 1
14 :   if (b > a)
15 :     d := d * 5
16 :   endif
17 : endwhile
18 : endFunction

Étapes à suivre

• Définir les classes d’équivalence pour les entrées (a,b,c) selon les conditions du programme.
• Proposer des jeux de tests pour la couverture des instructions et des arcs.

Solutions proposées

• Couverture des instructions : Classes : D1 = {(a,b,c) | b > a, c > 10, c ≠ a} D2 = {(a,b,c) | a = b} D3 = {(a,b,c) | a ≠ b, a = c} Jeu de test : (5,10,20), (5,5,5), (5,10,5)
• Couverture des arcs : Classes : D1 = {(a,b,c) | a = b, c > 10} D2 = {(a,b,c) | b > a, c = a, c > 10} D3 = {(a,b,c) | b > a, c ≠ a, c > 10} Jeu de test : (5,5,15), (15,10,15), (15,10,20)

Résultats attendus

• Identification correcte des classes d’équivalence pour chaque spécification ou programme.
• Jeux de tests couvrant toutes les classes, avec valeurs frontières lorsque possible.
• Pour les programmes, graphes de contrôle corrects et jeux de tests satisfaisant les critères de couverture demandés.
• Reconnaissance des cas invalides et gestion des erreurs dans les tests.

Pièges courants

• Ne pas distinguer toutes les classes d’équivalence, notamment les cas limites (ex : égalité, valeurs négatives).
• Oublier les valeurs frontières dans les jeux de tests.
• Confondre couverture des instructions et couverture des arcs, ce qui peut laisser des chemins non testés.
• Ne pas tester les cas invalides (ex : pas un triangle, revenu négatif).
• Dans les boucles, ne pas tester les cas où la boucle ne s’exécute pas, s’exécute une fois, puis plusieurs fois.
• Pour les programmes avec conditions imbriquées, oublier de tester toutes les combinaisons possibles.