Test du Logiciel
Test du Logiciel
École Nationale des Sciences de l'Informatique (ENSI) · Génie Logiciel, Programmation · exam
Fiche de révisionCorrigé
Rédigée à partir de ce document, puis vérifiée avant publication.
L'objectif de cet exercice est d'identifier les classes d'équivalence pour différentes spécifications, puis de proposer un jeu de test utilisant les valeurs frontières. Le document source présente les solutions dans le désordre ; elles ont été réorganisées ici pour correspondre à l'ordre des questions.
Spécification : Une méthode retourne le maximum entre deux nombres.
Pour deux nombres a et b, les relations possibles déterminent nos classes d'équivalence (D) :
Jeu de test :
Spécification : Une méthode retourne vrai si on entre un nombre pair et faux sinon.
Un nombre entier d est soit pair, soit impair. L'opérateur modulo (mod) permet de définir ces classes :
Jeu de test :
Spécification : Une méthode retourne trois fois le nombre entré + 28 si le nombre est impair et la racine carrée sinon.
Bien que le traitement mathématique diffère de la question précédente, la condition d'embranchement repose exactement sur la même logique de parité. Les classes d'équivalence sont donc identiques :
Jeu de test :
Spécification : Un programme prend les couleurs des feux de circulation en entrée et retourne la consigne de sécurité.
Les entrées valides sont les trois couleurs standard. Il est également crucial de définir une classe pour les entrées invalides afin de tester la robustesse du programme :
Jeu de test :
Spécification : Paliers d'imposition selon le revenu d.
Nous définissons une classe pour chaque palier, plus une classe pour les revenus invalides (négatifs) :
Jeu de test avec valeurs frontières : Selon le document source, le jeu de test propose de tester les limites inférieures et supérieures (ou juste en dessous) de chaque palier : {-1, 0, 19 999, 20 000, 29 999, 30 000, 39 000, 40 000, 54 999, 55 000, 74 999, 75 000}
Note de correction : Le corrigé source indique 39 000 comme limite supérieure de la classe D2. Il s'agit très probablement d'une erreur typographique dans le document original, la suite logique dictant 39 999 (à l'image de 19 999, 29 999, etc.). Toutefois, par respect pour le texte source, la valeur 39 000 y figure bien. En examen réel, écrivez 39 999.
L'application prend trois entiers positifs (a, b, c) et identifie le type de triangle.
Le domaine d'entrée D est séparé selon le type de triangle :
Pour un test exhaustif, il faut distinguer les différentes permutations des côtés.
| N° | (a, b, c) | Classe ciblée | Type attendu |
|---|---|---|---|
| 1 | (3, 3, 3) | D1 | Équilatéral |
| 2 | (2, 2, 3) | D21 | Isocèle |
| 3 | (2, 3, 2) | D22 | Isocèle |
| 4 | (3, 2, 2) | D23 | Isocèle |
| 5 | (3, 4, 5) | D3 | Scalène |
| 6 | (6, 3, 3) | D41 | Invalide (6 ≥ 3+3) |
| 7 | (3, 6, 3) | D42 | Invalide (6 ≥ 3+3) |
| 8 | (3, 3, 6) | D43 | Invalide (6 ≥ 3+3) |
Nous devons définir les classes d'équivalence pour trois paramètres d'entrée distincts.
La gratuité dépendant (selon l'énoncé source) du fait d'être membre, le système doit différencier un utilisateur valide d'un utilisateur invalide ou inconnu.
Le golf est fermé lundi et mardi, et ouvert les autres jours.
L'ouverture se fait de 7h00 à 21h00, mais la dernière heure n'est pas prise en compte pour la réservation (donc max 20h00). Après 18h00, c'est gratuit pour les membres.
L'algorithme calcule la division entière de x par y par soustractions successives, en gérant le signe.
Bien que le graphe ne puisse être dessiné ici, voici la numérotation des nœuds implicite dans le corrigé :
Le but est d'exécuter chaque ligne de code au moins une fois.
x < 0, dans y < 0, et dans la boucle x >= y.Le but est de traverser toutes les branches possibles (Vrai et Faux pour chaque condition).
1 2 5 8 11 12 : x positif (saute 3,4), y positif (saute 6,7), x < y (ne rentre pas dans la boucle).1 2 3 4 5 6 7 8 9 10 11 12 : x négatif, y négatif, rentre dans la boucle.Il faut tester les chemins en répétant 0 fois, puis 1 fois chaque boucle. Note sur la correction source : Les chemins donnés par le corrigé pour 1 itération ne montrent pas explicitement la remontée vers le nœud 8 (condition de boucle). Un chemin strict serait 8 -> 9 -> 10 -> 8 -> 11. Le corrigé source l'abrège en 8 -> 9 -> 10 -> 11 -> 12. Nous reproduisons fidèlement la logique du corrigé ci-dessous.
Chemins et Jeux d'essai :
Boucle 0 fois (x < y) :
1 2 5 8 11 12 (x>0, y>0) -> Jeu : (x = 2, y = 5)1 2 3 4 5 8 11 12 (x<0, y>0) -> Jeu : (x = -2, y = 5)1 2 5 6 7 8 11 12 (x>0, y<0) -> Jeu : (x = 2, y = -5)1 2 3 4 5 6 7 8 11 12 (x<0, y<0) -> Jeu : (x = -2, y = -5)Boucle 1 fois (x >= y, puis x - y < y) :
1 2 5 8 9 10 11 12 -> Jeu : (x = 5, y = 2)1 2 3 4 5 8 9 10 11 12 -> Jeu : (x = -5, y = 2)1 2 5 6 7 8 9 10 11 12 -> Jeu : (x = 5, y = -2)1 2 3 4 5 6 7 8 9 10 11 12 -> Jeu : (x = -5, y = -2)(À modéliser mentalement d'après le code :)
x < 0. Si vrai, exécute x := -x, puis rejoint la suite z := x.if not(x=0) qui bifurque soit sur y:=5, soit sur z := z - x. Les deux branches se rejoignent, puis un second bloc if (z > 1) bifurque sur z := z / x ou z := 0.Le test (x = -2) passe dans la condition x < 0, exécute x := -x et z := x.
Toutes les instructions de P1 sont exécutées. Cependant, la couverture des arcs n'est pas complète car la transition qui "saute" le bloc x := -x (le cas où la condition est fausse) n'est jamais empruntée.
Considérons le jeu de test suivant : (x = 0, z = 1) et (x = 1, z = 3)
(x = 0, z = 1) : x=0 est vrai, donc not(x=0) est Faux -> branche z := z - x évaluée (z devient 1). Ensuite, z > 1 (1 > 1) est Faux -> branche z := 0 évaluée.(x = 1, z = 3) : x=1 est vrai, donc not(x=0) est Vrai -> branche y := 5 évaluée. Ensuite, z > 1 (3 > 1) est Vrai -> branche z := z / x évaluée.Ce jeu d'essai parcourt bien toutes les branches (arcs) possibles (Vrai et Faux de chaque if).
Cependant, il ne couvre pas toutes les combinaisons (chemins). Par exemple, le chemin croisant "branche Else du premier If" suivie de "branche Then du second If".
x = 0 et z = 3), le programme exécuterait z := z - 0 (z reste 3), puis vérifierait z > 1 (Vrai), et tenterait z := z / x soit 3 / 0, causant une division par zéro.Avertissement : Les questions de l'Exercice 6 sont présentes dans le document source (Calculer les DT suivant les critères tous-les-nœuds, tous-les-arcs, tous-les-chemins-indépendants), mais la correction officielle de cet exercice est absente du document original fourni, qui saute directement à la solution de l'Exercice 7. Par conséquent, il est impossible de reproduire le corrigé officiel de cette question.
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
Il faut atteindre l'intérieur du If imbriqué (lignes 6-7).
Il faut traverser toutes les branches (vrai/faux) de chaque condition.
La formule de la complexité cyclomatique est : e - v + 2
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
Note : Le document source marque cette section "(à revoir)". Pour couvrir toutes les instructions, il faut atteindre l'intérieur du Else (ligne 8), l'intérieur du premier If (ligne 4), et l'intérieur du Else If (ligne 6). Il faut aussi entrer dans la boucle while et valider son If interne.
Il faut traverser toutes les conditions, incluant le contournement du If dans le While (lorsque b ≤ a).
Face à une épreuve de conception de tests (Test du Logiciel, Génie Logiciel) :
if, while, et for permet de compter instantanément le nombre de chemins indépendants via la formule cyclomatique.else. Il faut un test pour exécuter le code, et un test pour vérifier ce qui se passe quand le code est ignoré.< vs ≤). Ne vous contentez pas d'une valeur au milieu d'un palier, testez toujours les deux limites exactes de ce palier.