Qu'est-ce que la couverture de code et comment vous la mesurez?
Qu'est-ce que la couverture de code et comment vous la mesurez?
On m'a posé cette question concernant notre couverture de code de test d'automatisation. Il semble que, en dehors des outils automatisés, il s’agisse davantage d’art que de science. Existe-t-il des exemples concrets d'utilisation de la couverture de code?
La couverture de code est une mesure du nombre de lignes/blocs/arcs de votre code exécutés pendant l'exécution des tests automatisés.
La couverture de code est collectée à l'aide d'un outil spécialisé pour instrumenter les fichiers binaires afin d'ajouter des appels de traçage et d'exécuter un ensemble complet de tests automatisés sur le produit instrumenté. Un bon outil vous donnera non seulement le pourcentage de code exécuté, mais vous permettra également d’explorer les données et de voir exactement quelles lignes de code ont été exécutées au cours d’un test particulier.
Notre équipe utilise Magellan - un ensemble interne d’outils de couverture de code. Si vous êtes un magasin .NET, Visual Studio a intégré des outils permettant de collecter la couverture de code. Vous pouvez également lancer des outils personnalisés, tels que cet article décrit.
Si vous êtes un magasin C++, Intel a quelques outils qui fonctionnent sous Windows et Linux, bien que je ne les aie pas utilisés. J'ai aussi entendu parler de l'outil gcov pour GCC, mais je n'en sais rien et je ne peux pas vous donner de lien.
En ce qui concerne notre utilisation - la couverture de code est l’un de nos critères de sortie pour chaque étape. Nous disposons en réalité de trois mesures de couverture de code: la couverture issue des tests unitaires (de l’équipe de développement), les tests de scénarios (de l’équipe de tests) et la couverture combinée.
BTW, bien que la couverture de code soit un bon indicateur du nombre de tests que vous effectuez, ce n'est pas nécessairement un bon indicateur du niveau de test de votre produit. Il y a d'autres mesures que vous devriez utiliser avec la couverture de code pour assurer la qualité.
La couverture de code vérifie en gros que la quantité de votre code est couverte par des tests. Donc, si vous avez une couverture de code de 90%, cela signifie qu'il y a 10% de code qui n'est pas couvert par des tests. Je sais que vous pensez peut-être que 90% du code est couvert, mais vous devez regarder sous un angle différent. Qu'est-ce qui vous empêche d'obtenir une couverture de code à 100%?
Un bon exemple sera celui-ci:
if(customer.IsOldCustomer())
{
}
else
{
}
Maintenant, dans le code ci-dessus, il y a deux chemins/branches. Si vous cliquez toujours sur la branche "OUI", vous ne couvrez pas la partie else et cela apparaîtra dans les résultats de la couverture de code. C'est bien parce que maintenant vous savez que ce qui n'est pas couvert et que vous pouvez écrire un test pour couvrir la partie restante. S'il n'y avait pas de couverture de code, vous êtes simplement assis sur une bombe à retardement pour exploser.
NCover est un bon outil pour mesurer la couverture de code.
Rappelez-vous simplement qu'avoir une "couverture de code à 100%" ne signifie pas que tout est complètement testé - bien que cela signifie que chaque ligne de code est testée, cela ne signifie pas qu'elles sont testées dans toutes les situations (courantes).
J'utiliserais une couverture de code pour mettre en évidence des morceaux de code pour lesquels je devrais probablement écrire des tests. Par exemple, si l'outil de couverture de code indique que myImportantFunction () n'est pas exécuté lors de l'exécution de mes tests unitaires actuels, ils devraient probablement être améliorés.
En gros, une couverture de code à 100% ne signifie pas que votre code est parfait. Utilisez-le comme guide pour rédiger des tests plus complets (unitaires).
Complétant quelques points de nombreuses réponses précédentes:
La couverture de code signifie que votre ensemble de tests couvre bien votre code source. c'est-à-dire dans quelle mesure le code source est-il couvert par l'ensemble des cas de test?.
Comme mentionné dans les réponses ci-dessus, il existe divers critères de couverture, tels que chemins, conditions, fonctions, déclarations, etc. Mais d'autres critères doivent être couverts:
- Couverture de condition: toutes les expressions booléennes à évaluer comme vraies et fausses.
- Prise de décision: il ne suffit pas que les expressions booléennes soient évaluées une fois pour toutes comme vraies et fausses, mais pour couvrir tous les corps ultérieurs si-elseif-else.
- Couverture de boucle: signifie que toutes les boucles possibles ont été exécutées une fois, plusieurs fois et à zéro. De même, si nous avons une hypothèse sur la limite maximale, alors, si cela est réalisable, testez les durées limites maximales et un de plus que les durées limites maximales.
- Couverture d'entrée et de sortie: teste tous les appels possibles et leur valeur de retour.
- Paramètre Valeur Couverture (PVC). Pour vérifier si toutes les valeurs possibles d'un paramètre sont testées. Par exemple, une chaîne peut être n'importe laquelle de ces entités: a) null, b) vide, c) espace (espace, tabulations, nouvelle ligne), d) chaîne valide, e) chaîne non valide, f) chaîne à octet unique, g ) chaîne sur deux octets. L'échec de tester chaque valeur de paramètre possible peut laisser un bogue. Si vous testez une seule de ces lignes, vous obtiendrez une couverture de code de 100% puisque chaque ligne est couverte, mais comme une seule des sept options est testée, cela signifie qu'une couverture de 14,2% seulement de la valeur du paramètre est utilisée.
- Couverture d'héritage: dans le cas d'une source orientée objet, lors du renvoi d'un objet dérivé référencé par la classe de base, la couverture à évaluer, si un objet frère est renvoyé, doit être testée.
Remarque: l'analyse de code statique recherche s'il existe un code inaccessible ou suspendu, c'est-à-dire un code non couvert par un autre appel de fonction. Et aussi d'autres couvertures statiques. Même si l'analyse de code statique indique que 100% du code est couvert, elle ne fournit aucun rapport sur votre jeu de tests si toute la couverture de code possible est testée.
La couverture de code a été bien expliquée dans les réponses précédentes. Donc, ceci est plus une réponse à la deuxième partie de la question.
Nous avons utilisé trois outils pour déterminer la couverture de code.
- JTest - un outil propriétaire construit sur JUnit. (Il génère également des tests unitaires.)
- Cobertura - un outil de couverture de code source ouvert pouvant être facilement associé à des tests JUnit pour générer des rapports.
- Emma - un autre - celui-ci que nous avons utilisé dans un but légèrement différent de celui des tests unitaires. Il a été utilisé pour générer des rapports de couverture lorsque les utilisateurs finaux ont accès à l'application Web. Associé à des outils de test Web (exemple: Canoo), il peut vous fournir des rapports de couverture très utiles vous indiquant la quantité de code recouverte lors de l’utilisation type de l’utilisateur final.
Nous utilisons ces outils pour
- Vérifiez que les développeurs ont écrit de bons tests unitaires
- Assurez-vous que tout le code est parcouru lors du test de la boîte noire
La couverture de code est simplement une mesure du code qui est testé. Il existe une variété de critères de couverture qui peuvent être mesurés, mais ce sont généralement les divers chemins, conditions, fonctions et déclarations d'un programme qui constituent la couverture totale. La métrique de couverture de code est juste un pourcentage de tests qui exécutent chacun de ces critères de couverture.
En ce qui concerne le suivi de la couverture des tests unitaires sur mes projets, j'utilise des outils d'analyse de code statique pour assurer le suivi.
Pour Perl, il existe l'excellent module Devel :: Cover que j'utilise régulièrement sur mes modules.
Si la construction et l'installation sont gérées par Module :: Build, vous pouvez simplement exécuter ./Build testcover pour obtenir un site HTML sympa qui vous indique la couverture par sous-ligne, ligne et condition. n'a pas été couvert.
Dans les réponses précédentes, la couverture du code a été bien expliquée. J'ajoute simplement quelques connaissances relatives aux outils si vous travaillez sur les plateformes iOS et OSX, Xcode fournit la possibilité de tester et de surveiller la couverture de code.
Liens de référence:
https://medium.com/zendesk-engineering/code-coverage-and-xcode-6b2fb8756a51
Ces deux liens sont utiles pour apprendre et explorer la couverture de code avec Xcode.