Test Processes and Techniques

Application 1 - Test par Boîte Noire

Définition du problème

Il s'agit de tester une procédure triangle prenant en entrée trois entiers a, b, et c représentant les longueurs des côtés d'un triangle, et retournant :

• 0 si le triangle est invalide (un côté est nul ou négatif, ou un côté est supérieur à la somme des deux autres).
• 1 si le triangle est équilatéral (les 3 côtés sont égaux).
• 2 si le triangle est isocèle (exactement 2 côtés sont égaux).
• 3 pour un triangle valide quelconque.

Jeu d'essai

La méthode des classes d'équivalence demande de couvrir chaque cas de figure (valide et invalide) en permutant les entrées a, b et c pour s'assurer que la position du paramètre n'affecte pas le résultat.

Cas 0 : Triangle invalide On teste ici l'inégalité triangulaire et les valeurs nulles.

• Côté trop long :
  • a = 10, b = 3, c = 4
  • a = 3, b = 10, c = 4
  • a = 3, b = 4, c = 10
• Un côté nul :
  • a = 0, b = 3, c = 4
  • a = 3, b = 0, c = 4
  • a = 3, b = 4, c = 0
• Deux côtés nuls :
  • a = 0, b = 0, c = 3
  • a = 0, b = 3, c = 0
  • a = 3, b = 0, c = 0
• Trois côtés nuls :
  • a = 0, b = 0, c = 0

Cas 1 : Triangle équilatéral

• a = 3, b = 3, c = 3

Cas 2 : Triangle isocèle On permute les côtés égaux.

• a = 3, b = 3, c = 4
• a = 3, b = 4, c = 3
• a = 4, b = 3, c = 3

Cas 3 : Triangle quelconque (valide)

• a = 3, b = 4, c = 5

Application 2 - Test par Boîte Blanche (Variables a et b)

Code source et graphe

Le pseudo-code à tester est le suivant :

si (x > 10)
alors a = a + 1;
Fin si
si (x % 2 <> 0) // Le modulo donne le reste de la division par 2
alors b = b + 1;
Fin si

Le graphe de flux associé contient les nœuds suivants :

• Nœud 1 : Évaluation de (x > 10)
• Nœud 2 : Instruction a = a + 1
• Nœud 3 : Évaluation de (x % 2 <> 0)
• Nœud 4 : Instruction b = b + 1
• Nœud 5 : Fin de la séquence

Question 1 - Couverture des instructions

Suite de nœuds : Pour satisfaire la couverture des instructions, chaque instruction élémentaire doit être exécutée au moins une fois. Le chemin doit donc traverser tous les nœuds : 1 → 2 → 3 → 4 → 5.

Jeu d'essai minimum : Il faut trouver un entier x tel que x > 10 soit vrai et x % 2 <> 0 soit vrai (c'est-à-dire un nombre impair strictement supérieur à 10).

• Correction par rapport au document source : Le document propose x = 12. C'est une erreur. Avec x = 12, l'évaluation 12 % 2 <> 0 est fausse (le reste est 0), ce qui contourne le nœud 4 (b = b + 1). Le nœud 4 ne serait pas couvert.
• Bonne réponse : x = 11.

Question 2 - Couverture des arcs

Suite de nœuds : Pour la couverture des arcs (ou branches), il faut emprunter chaque transition possible au moins une fois :

• Arc 1 → 2 (condition 1 vraie)
• Arc 1 → 3 (condition 1 fausse)
• Arc 3 → 4 (condition 2 vraie)
• Arc 3 → 5 (condition 2 fausse)

Jeu d'essai minimum : Nous avons besoin de deux valeurs pour x afin de forcer les combinaisons opposées des conditions. Le document source propose x = 5 et x = 12, ce qui est correct :

• Avec x = 5 : 5 > 10 est faux (arc 1 → 3). 5 % 2 <> 0 est vrai (arc 3 → 4 → 5). Le chemin est 1 → 3 → 4 → 5.
• Avec x = 12 : 12 > 10 est vrai (arc 1 → 2 → 3). 12 % 2 <> 0 est faux (arc 3 → 5). Le chemin est 1 → 2 → 3 → 5. L'ensemble {5, 12} couvre bien les quatre arcs du graphe.

Application 3 - Test par Boîte Blanche (Division par soustractions)

Note : Le document source ne pose aucune question explicite pour cet exercice. Il fournit un bloc de code et un graphe de flux numéroté de 1 à 8. Voici l'explication de la structure attendue pour comprendre cet exercice.

Correspondance Code / Graphe de flux

Le programme effectue la division entière de x par y en comptant les soustractions successives dans z, tout en gérant les signes.

• Nœud 1 : Séquence initiale lire(x); lire(y); z = 0; signe = 1;
• Nœud 2 : Première condition Si (x < 0)
• Nœud 3 : Branche "alors" du premier Si signe = -1; x = -x;
• Nœud 4 : Deuxième condition Si (y < 0)
• Nœud 5 : Branche "alors" du deuxième Si signe = -signe; y = -y;
• Nœud 6 : Condition de la boucle Tant que (x >= y)
• Nœud 7 : Corps de la boucle x = x - y; z = z + 1;
• Nœud 8 : Instruction finale z = signe * z;

Pour couvrir tous les arcs de ce programme, un jeu d'essai pertinent devrait inclure un cas où x > 0, y > 0, un cas où x < 0, un cas où y < 0, ainsi que des valeurs qui font entrer dans la boucle et d'autres qui l'ignorent.

Application 2 (bis) - Recherche dans un tableau

Note : Le document source indique par erreur "Application 2" une nouvelle fois et omet de poser une question textuelle. Il s'agit d'une analyse de graphe d'une fonction de recherche.

Le code parcourt un tableau (indexé de 1 à number of items) pour trouver un desired element. Dans ce pseudo-code, le symbole # signifie "différent de" (équivalent à != ou <>). L'exercice sous-jacent consiste à identifier les chemins pour vérifier la robustesse de la boucle while. Si number of items = 0, le code saute la recherche et va directement à la vérification finale (qui échouera puisque found reste false), empêchant ainsi une erreur d'index.

Application 4 - Test par Boîte Blanche : Comparaison de chaînes

Définition du problème

Générer un jeu d'essai couvrant tous les chemins d'exécution possibles d'un programme de comparaison de chaînes de caractères. Contrainte : La plus petite chaîne a une longueur maximale de 2 caractères (0, 1 ou 2).

Code source et graphe

Lire(string1, string2)
SI (string1.length = string2.length)
Alors
    i = 1
    Tant que ((i <= string1.length) et (string1.character[i] = string2.character[i]))
        i = i + 1
    Fin tant que
    SI (i = string1.length + 1)
    Alors
        Afficher("chaînes égales")
    Fin si
Fin si

Chemins d'exécution et Jeu d'essai

Pour parcourir exhaustivement les chemins compte tenu de la limite de taille, nous devons jouer sur la taille des chaînes et l'itération où une différence est détectée.

1. Chemin contournant la boucle (les longueurs sont différentes) :
   • Strings : "a" et "ab"
   • Exécution : Les longueurs diffèrent, le programme saute directement au Fin si principal.
2. Chemin sans entrer dans la boucle (longueurs égales à 0) :
   • Strings : "" (vide) et "" (vide)
   • Exécution : La condition du Tant que est fausse dès la première évaluation (i <= 0 est faux car i = 1). Les chaînes sont déclarées égales.
3. Chemin avec 1 itération, caractères différents (erreur à l'indice 1) :
   • Strings : "a" et "b"
   • Exécution : Longueurs égales à 1. On entre dans la boucle, mais string1.character[1] ≠ string2.character[1]. La boucle s'arrête, les chaînes ne sont pas égales.
4. Chemin avec 1 itération, caractères identiques (succès, longueur 1) :
   • Strings : "a" et "a"
   • Exécution : Les caractères à l'indice 1 sont identiques, i passe à 2. La boucle s'arrête car i > 1. Les chaînes sont égales.
5. Chemin avec 2 itérations, erreur à l'indice 2 :
   • Strings : "aa" et "ab"
   • Exécution : L'indice 1 correspond. À l'indice 2, les caractères diffèrent. La boucle s'arrête prématurément, les chaînes ne sont pas égales.
6. Chemin avec 2 itérations complètes (succès, longueur 2) :
   • Strings : "aa" et "aa"
   • Exécution : Les caractères des indices 1 et 2 correspondent. i passe à 3. Les chaînes sont égales.
7. Chemin avec 3 itérations (mentionné dans la source) :
   • Strings : "aaa" et "aab"
   • Exécution : Impossible dans ce contexte précis, car l'énoncé contraint la longueur maximale à 2.

Méthode

Face à ce type de sujet de test d'applications, voici comment structurer votre réflexion :

1. Identifier la technique demandée :
   • Boîte Noire (Fonctionnel) : Vous ne regardez pas le code. Vous vous basez uniquement sur les spécifications. Identifiez les classes d'équivalence (entrées valides, entrées invalides aux limites) et testez un représentant de chaque classe (voir Application 1).
   • Boîte Blanche (Structurel) : Vous devez analyser le code et son graphe de flux de contrôle (Control Flow Graph).
2. Mesurer la complexité cyclomatique (Nombre de Mac Cabe) :
   • Formule : Complexité = Nombre d'Arcs - Nombre de Nœuds + 2.
   • Cela vous indique le nombre de chemins indépendants dans votre programme, et donc le nombre minimal de tests requis pour une couverture totale des chemins.
3. Différencier les niveaux de couverture (Boîte Blanche) :
   • Couverture des instructions : Trouver les valeurs d'entrée qui garantissent que chaque ligne de code est lue au moins une fois. Souvent, un seul scénario bien choisi suffit si le programme ne comporte pas de bifurcations mutuellement exclusives.
   • Couverture des arcs (branches) : S'assurer que chaque Si et chaque condition de boucle est évalué à la fois à "Vrai" et à "Faux".
   • Couverture des chemins : Plus exhaustif, il s'agit d'explorer toutes les trajectoires possibles à travers l'algorithme (comme démontré dans l'Application 4, limité par la taille maximale).
4. Vérifier la logique numérique : Ne faites jamais aveuglément confiance aux solutions imprimées sans recalculer l'état des variables (comme démontré dans l'Application 2 où x = 12 échouait silencieusement sur la vérification du modulo). Tracez manuellement les valeurs pas à pas.