Code Outil de couverture : Tests de relevés, de succursales et de décisions

Qu'est-ce que le Code Couverture?

Code couverture est une mesure qui décrit le degré de test du code source d'un programme. C'est une forme de test boîte blanche Cet outil identifie les zones d'un programme non couvertes par un ensemble de tests. Il permet également de créer des tests supplémentaires afin d'améliorer la couverture et de déterminer une mesure quantitative de cette couverture.

Dans la plupart des cas, un système de couverture de code recueille des informations sur le programme en cours d'exécution. Il combine ensuite ces informations avec celles du code source afin de générer un rapport sur la couverture de code de la suite de tests.

Pourquoi utiliser Code Tests de couverture ?

Voici quelques principales raisons d’utiliser la couverture de code :

• Cela vous aide à mesurer l'efficacité de la mise en œuvre des tests.
• Il offre une mesure quantitative des tests.
• Il définit le degré auquel le code source a été testé.

Code Méthodes de couverture

Voici les principales méthodes de couverture de code :

• Couverture de l'état
• Couverture des décisions
• Couverture de la succursale
• Toggle Couverture
• Couverture FSM

Couverture de l'état

Couverture de l'état La couverture d'instructions est une technique de test en boîte blanche qui consiste à exécuter au moins une fois toutes les instructions exécutables du code source. Elle permet de calculer le nombre d'instructions exécutées. Son objectif principal est de couvrir tous les chemins d'exécution, lignes et instructions possibles dans le code source.

La couverture des instructions est utilisée pour déduire des scénarios à partir de la structure du code testé.

Lors des tests en boîte blanche, le testeur se concentre sur le fonctionnement du logiciel. Autrement dit, il s'intéresse au fonctionnement interne du code source, notamment aux graphes de flux de contrôle ou aux organigrammes.

En général, dans tout logiciel, si vous examinez le code source, vous trouverez une grande variété d'éléments tels que des opérateurs, des fonctions, etc.ping, les gestionnaires d'exceptions, etc. Selon les données d'entrée du programme, certaines instructions peuvent ne pas être exécutées. L'objectif de la couverture d'instructions est de couvrir tous les chemins d'exécution, lignes et instructions possibles dans le code.

Pour mieux comprendre, prenons l'exemple du calcul de la couverture des déclarations. Nous allons examiner deux scénarios différents afin de déterminer le pourcentage de couverture des déclarations pour chacun d'eux.

Matériau Code:

Prints (int a, int b) {                       ------------  Printsum is a function
    int result = a + b;
    If (result > 0)
        Print ("Positive", result)
    Else
        Print ("Negative", result)
    }                                        -----------   End of the source code

Scenario 1 : Si A = 3, B = 9

Les instructions surlignées en jaune sont celles qui ont été exécutées conformément au scénario. Nombre d'instructions exécutées : 5. Nombre total d'instructions : 7. Couverture des instructions : 5/7 = 71 %.

Scenario 2 : Si A = -3, B = -9

Les instructions surlignées en jaune sont celles qui ont été exécutées conformément au scénario. Nombre d'instructions exécutées : 6. Nombre total d'instructions : 7. Couverture des instructions : 6/7 = 85 %.

En résumé, toutes les affirmations sont couvertes par les deux scénarios. On peut donc conclure que la couverture globale des affirmations est de 100 %.

Qu’est-ce qui est couvert par la couverture du relevé ?

1. Déclarations inutilisées
2. Dead Code
3. Branches inutilisées
4. Déclarations manquantes

Tests de couverture de décision

Couverture des décisions Le test de couverture de décision est une technique de test en boîte blanche qui indique si chaque expression booléenne du code source a la valeur booléenne (vrai ou faux). Son objectif est de couvrir et de valider l'intégralité du code source accessible en vérifiant que chaque branche de chaque point de décision possible est exécutée au moins une fois.

Dans ce type de couverture, les expressions peuvent devenir complexes, rendant difficile l'obtention d'une couverture à 100 %. C'est pourquoi différentes méthodes sont utilisées pour calculer cette métrique. Ces méthodes privilégient les combinaisons les plus critiques. Bien que similaire à la couverture des branches, elle offre une meilleure sensibilité au flux de contrôle.

Exemple de couverture de décision

Considérez le code suivant :

Demo(int a) {
    If (a > 5)
        a = a * 3
    Print (a)
    }

Scenario 1 : La valeur de a est 2. Le résultat « Non » de la décision Si (a>5) est vérifié, donc la couverture de la décision = 50 %.

Scenario 2 : La valeur de a est 6. Le résultat « Oui » de la décision Si (a>5) est vérifié, donc la couverture de la décision = 50 %.

Test de couverture des succursales

Couverture de la succursale La couverture de branche est une méthode de test en boîte blanche qui consiste à tester chaque résultat d'un module de code (instruction ou boucle). Son objectif est de garantir que chaque condition de décision de chaque branche est exécutée au moins une fois. Elle permet de mesurer la proportion de segments de code indépendants et d'identifier les sections sans branche.

Par exemple, si les résultats sont binaires, vous devez tester à la fois les résultats Vrai et Faux.

La formule pour calculer la couverture des succursales :

Exemple de couverture de succursale

Pour comprendre la couverture des branches, reprenons l'exemple précédent. La couverture des branches prendra également en compte les branches inconditionnelles.

Avantages de la couverture en succursale :

• Permet de valider toutes les branches du code.
• Permet de s'assurer qu'aucune branche ne provoque d'anomalie dans le fonctionnement du programme.
• Résout les problèmes qui surviennent lors des tests de couverture des instructions.
• Permet de trouver des zones qui ne sont pas testées par d'autres méthodes de test.
• Permet de trouver une mesure quantitative de la couverture de code.
• La couverture des branches ignore les branches à l'intérieur des expressions booléennes.

Test de couverture des conditions

Couverture des conditionsLa couverture d'expressions, ou analyse conditionnelle, est une méthode de test permettant d'évaluer les variables ou sous-expressions d'une instruction conditionnelle. Son objectif est de vérifier les résultats individuels de chaque condition logique. La couverture conditionnelle offre une meilleure sensibilité au flux de contrôle que la couverture de décisions. Seules les expressions comportant des opérandes logiques sont prises en compte.

Par exemple, si une expression comporte des opérations booléennes comme ET, OU ou OU exclusif, cela indique le nombre total de possibilités. La couverture des conditions ne garantit pas une couverture complète des décisions.

La formule pour calculer la couverture des conditions :

Pour une expression à deux opérandes, il existe quatre combinaisons possibles : TT, FF, TF et FT. Prenons l’exemple de l’entrée X=3, Y=4 (x b) FAUX, ce qui donne une couverture des conditions de 1/4 = 25 %.

Couverture des machines à états finis

La couverture des automates finis est sans conteste la méthode de couverture de code la plus complexe. En effet, elle analyse le comportement du système. Cette méthode consiste à examiner la fréquence d'accès à chaque état et le nombre de transitions qui le traversent, ainsi que le nombre de séquences présentes dans l'automate fini.

Quel type de Code Couverture à choisir

C’est assurément la réponse la plus difficile à donner. Pour choisir une méthode de couverture, le testeur doit vérifier si :

• Le code testé présente un ou plusieurs défauts non détectés.
• coût de la pénalité potentielle,
• coût de la réputation perdue,
• coût des ventes perdues, etc.

Plus la probabilité que des défauts entraînent des échecs de production coûteux est élevée, plus le niveau de couverture que vous devez choisir est sévère.

Code Couverture vs. Couverture fonctionnelle

Code Outils de couverture

Voici une liste d'outils importants pour l'analyse de la couverture de code :

Avantages et inconvénients de l'utilisation Code Couverture

FAQ