Tutoriel sur la couverture du code : tests de branche, d'instruction et de décision

Qu'est-ce que la couverture du code ?

La couverture du code est une mesure qui décrit le degré de test du code source du programme. Il s'agit d'une forme de test en boîte blanche qui identifie les domaines du programme qui ne sont pas exercés par un ensemble de cas de test. Il crée également des cas de test pour augmenter la couverture et déterminer une mesure quantitative de la couverture du code.

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

Pourquoi utiliser les tests de couverture de code ?

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

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

Méthodes de couverture de code

Voici les principales méthodes de couverture de code

Couverture de la déclaration
Couverture des décisions
Couverture de la succursale
Toggle Couverture
Couverture FSM

Couverture de l'état

Couverture de l'état est une technique de test en boîte blanche dans laquelle toutes les instructions exécutables du code source sont exécutées au moins une fois. Il est utilisé pour calculer le nombre d'instructions du code source qui ont été exécutées. L’objectif principal de Statement Coverage est de couvrir tous les chemins, lignes et instructions possibles dans le code source.

La couverture des instructions est utilisée pour dériver un scénario basé sur la structure du code testé.

In Blanc Box Contrôle de qualité, le testeur se concentre sur le fonctionnement du logiciel. En d'autres termes, le testeur se concentrera sur le fonctionnement interne du code source concernant les organigrammes de contrôle ou les organigrammes.

Généralement, dans tout logiciel, si l'on regarde le code source, il y aura une grande variété d'éléments comme des opérateurs, des fonctions, des boucles, des gestionnaires exceptionnels, etc. En fonction de l'entrée dans le programme, certaines instructions de code peuvent ne pas être exécutées. . L’objectif de la couverture des instructions est de couvrir tous les chemins, lignes et instructions possibles dans le code.

Comprenons cela avec un exemple, comment calculer la couverture des déclarations.

Scénario pour calculer la couverture des déclarations pour un code source donné. Ici, nous prenons deux scénarios différents pour vérifier le pourcentage de couverture des déclarations pour chaque scénario.

Code source:

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 marquées en jaune sont celles qui sont exécutées selon le scénario

Nombre d'instructions exécutées = 5, Nombre total d'instructions = 7

Couverture du relevé : 5/7 = 71 %

De même nous verrons le scénario 2,

Scenario 2 :

Si A = -3, B = -9

Les instructions marquées en jaune sont celles qui sont exécutées selon le scénario.

Nombre d'instructions exécutées = 6

Nombre total de déclarations = 7

Couverture du relevé : 6/7 = 85 %

Mais dans l’ensemble, si vous voyez, toutes les déclarations sont couvertes par les deux scénarios. Nous pouvons donc conclure que la couverture globale des déclarations est de 100 %.

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

Déclarations inutilisées
Code mort
Branches inutilisées
Déclarations manquantes

Tests de couverture de décision

Couverture des décisions est une technique de test en boîte blanche qui rapporte les résultats vrais ou faux de chaque expression booléenne du code source. L'objectif des tests de couverture de décision est de couvrir et de valider tout le code source accessible en vérifiant et en s'assurant 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, ce qui rend difficile l'obtention d'une couverture à 100 %. C'est pourquoi diverses méthodes sont utilisées pour signaler cette mesure. Ces méthodes donnent la priorité aux combinaisons les plus critiques. Bien qu'elle soit similaire à la couverture de décision, elle offre une plus grande 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 code surligné en jaune sera exécuté. Ici, le résultat « Non » de la décision Si (a>5) est vérifié.

Couverture de la décision = 50 %

Scenario 2 :

La valeur de a est 6

Le code surligné en jaune sera exécuté. Ici, le résultat « Oui » de la décision Si (a>5) est vérifié.

Couverture de la décision = 50 %

Cas de test	Valeur de A	Sortie	Couverture des décisions
1	2	2	50%
2	6	18	50%

Test de couverture des succursales

Couverture de la succursale est une méthode de test en boîte blanche dans laquelle chaque résultat d'un module de code (instruction ou boucle) est testé. Le but de la couverture des branches est de garantir que chaque condition de décision de chaque branche est exécutée au moins une fois. Il permet de mesurer des fractions de segments de code indépendants et de découvrir les sections n'ayant pas de branches.

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 connaître la couverture des succursales, considérons le même exemple utilisé précédemment

Considérez le code suivant-

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

La couverture des succursales prendra également en compte les succursales inconditionnelles.

Cas de test	Valeur de A	Sortie	Couverture des décisions	Couverture de la succursale
1	2	2	50%	33%
2	6	18	50%	67%

Avantages de la couverture en succursale :

Couverture des succursales Les tests offrent les avantages suivants :

Permet de valider toutes les branches du code
Vous aide à garantir qu'aucun branchement ne conduit à une anomalie du fonctionnement du programme
La méthode de couverture des succursales supprime les problèmes qui surviennent en raison des tests de couverture des relevés
Vous permet de trouver les zones qui ne sont pas testées par d'autres méthodes de test
Il vous permet de trouver une mesure quantitative de la couverture du code
La couverture des branches ignore les branches à l'intérieur des expressions booléennes

Test de couverture des conditions

Couverture des conditions ou la couverture d'expression est une méthode de test utilisée pour tester et évaluer les variables ou les sous-expressions de l'instruction conditionnelle. L’objectif de la couverture des conditions est de vérifier les résultats individuels pour chaque condition logique. La couverture des conditions offre une meilleure sensibilité au flux de contrôle que la couverture des décisions. Dans cette couverture, seules les expressions avec des opérandes logiques sont prises en compte.

Par exemple, si une expression comporte des opérations booléennes telles que AND, OR, XOR, ce qui indique des possibilités totales.

La couverture des conditions ne donne pas de garantie quant à la couverture complète de la décision.

La formule pour calculer la couverture des conditions :

Mise en situation :

Pour l’expression ci-dessus, nous avons 4 combinaisons possibles

Considérez l'entrée suivante

X = 3 Y = 4	(X	VRAI	La couverture des conditions est de ¼ = 25 %
A = 3 B = 4	(une>b)	FAUX	La couverture des conditions est de ¼ = 25 %

Couverture des machines à états finis

La couverture par machine à états finis est certainement le type de méthode de couverture de code le plus complexe. En effet, cela agit sur le comportement de la conception. Dans cette méthode de couverture, vous devez rechercher combien d'États spécifiques au temps sont visités, transités. Il vérifie également combien de séquences sont incluses dans une machine à états finis.

Quel type de couverture de code choisir

C’est certainement la réponse la plus difficile à donner. Afin de sélectionner une méthode de couverture, le testeur doit vérifier que le

le code testé présente un ou plusieurs défauts non découverts
coût de la pénalité potentielle
coût de la perte de réputation
coût de la vente perdue, 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.

Couverture du code et couverture fonctionnelle

Couverture de code	Couverture fonctionnelle
La couverture du code vous indique dans quelle mesure le code source a été utilisé par votre banc de test.	La couverture fonctionnelle mesure dans quelle mesure la fonctionnalité de la conception a été couverte par votre banc de test.
N'utilisez jamais de spécification de conception	Utiliser les spécifications de conception
Réalisé par les développeurs	Réalisé par des testeurs

Outils de couverture de code

Voici une liste des outils importants de couverture de code :

Nom de l'outil	Description
Cobertura	Il s'agit d'un outil de couverture de code open source. Il mesure la couverture des tests en instrumentant une base de code et analyse quelles lignes de code sont en cours d'exécution et lesquelles ne sont pas exécutées lors de l'exécution de la suite de tests.
Clover	Clover réduit également le temps de test en exécutant uniquement les tests qui couvrent le code de l'application modifié depuis la version précédente.
Partenaire Dev	DevPartner permet aux développeurs d'analyser Java code pour la qualité et la complexité du code.
Emma	EMMA prend en charge la couverture de classe, de méthode, de ligne et de bloc de base, les niveaux de fichier source agrégé, de classe et de méthode.
Kalistick	Kalistick est une application tierce qui analyse les codes avec différentes perspectives.
CoView et CoAnt	Coding Software est un outil de couverture de code pour les métriques, la création d'objets fictifs, la testabilité du code, la couverture des chemins et des branches, etc.
Bullseye pour C++	BulseyeCoverage est un outil de couverture de code pour C++ et C.
Sonar	Sonar est un outil de couverture de code ouvert qui vous aide à gérer la qualité du code.

Avantages et inconvénients de l'utilisation de la couverture de code

Avantages de la couverture du code	Inconvénients de la couverture du code
Utile pour évaluer une mesure quantitative de la couverture du code	Même lorsqu'une fonctionnalité spécifique n'est pas implémentée dans la conception, la couverture du code indique toujours une couverture de 100 %.
Il vous permet de créer des cas de test supplémentaires pour augmenter la couverture	Il n'est pas possible de déterminer si nous avons testé toutes les valeurs possibles d'une fonctionnalité à l'aide de la couverture du code.
Il permet de retrouver les domaines d'un programme qui ne sont pas exercés par un ensemble de cas de tests	La couverture du code ne dit pas non plus dans quelle mesure et dans quelle mesure vous avez couvert votre logique
	Dans le cas où la fonction spécifiée n'est pas implémentée ou n'est pas incluse dans la spécification, les techniques basées sur la structure ne peuvent pas trouver ce problème.

Résumé

La couverture du code est une mesure qui décrit le degré de test du code source du programme.
Il vous aide à mesurer l’efficacité de la mise en œuvre des tests
Cinq méthodes de couverture de code sont 1.) Couverture de déclaration 2.) Couverture de condition 3) Couverture de succursale 4) Toggle Couverture 5) Couverture FSM
La couverture des instructions implique l'exécution de toutes les instructions exécutables dans le code source au moins une fois
La couverture des décisions rapporte les résultats vrais ou faux de chaque expression booléenne
Dans la couverture des branches, chaque résultat d'un module de code est testé
Conditionnel révélera comment les variables ou sous-expressions de l'instruction conditionnelle sont évaluées
La couverture de machines à états finis est certainement le type de méthode de couverture de code le plus complexe.
Afin de sélectionner une méthode de couverture, le testeur doit vérifier le coût de la pénalité potentielle, de la perte de réputation, de la vente perdue, etc.
La couverture du code vous indique dans quelle mesure le code source a été testé par votre banc de test, tandis que la couverture fonctionnelle mesure dans quelle mesure les fonctionnalités de la conception ont été couvertes.
Cobertura, JTest, Clover, Emma, Kalistick sont quelques outils importants de couverture de code
La couverture du code vous permet de créer des cas de test supplémentaires pour augmenter la couverture
La couverture du code ne vous aide pas à déterminer si nous avons testé toutes les valeurs possibles d'une fonctionnalité

Tu pourrais aimer: