code couverture est une mesure trompeuse si 100% de couverture est votre objectif (au lieu de 100% de test de toutes les fonctionnalités).

• Vous pourriez obtenir un 100% en frappant de toutes les lignes en une fois. Cependant, vous pourrait encore manquer de tester une séquence particulière (chemin logique), dans laquelle ces lignes sont touchées.
• vous ne pouviez pas obtenir un 100% mais vous avez tout de même testé tous vos codes-chemins 80%/freq utilisés. Avoir des tests qui testent chaque "throw Exceptionypex" ou similaire une programmation défensive de la garde vous avez mis en est un "gentil", pas un "must have"

alors faites confiance à vous-même ou à vos développeurs pour être minutieux et couvrir chaque chemin à travers leur code. Soyez pragmatique et ne courez pas après la couverture magique à 100%. Si vous enregistrez votre code, vous devriez obtenir une couverture de 90% + en bonus. Utilisez le code-coverage pour mettre en évidence les morceaux de code que vous avez manqués (ne devrait pas se produire si vous TDD cependant.. puisque vous écrivez le code seulement pour réussir un test. Aucun code ne peut exister sans le test du partenaire. )

est excellente, mais la couverture de fonctionnalité est encore meilleure. Je ne crois pas à couvrir chaque ligne que j'écris. Mais je crois en l'écriture de 100% de couverture de test de toutes les fonctionnalités que je veux fournir (même pour les fonctionnalités supplémentaires que je suis venu avec moi-même et qui n'ont pas été discutés lors des réunions).

Je ne me soucie pas si j'aurais du code qui n'est pas couvert dans les tests, mais je me soucierais si je reformulais mon code et finir par avoir un différent comportement. Par conséquent, 100% de couverture de fonctionnalité est ma seule cible.

la réponse acceptée est un bon point - il n'y a pas un seul chiffre qui va avoir du sens comme norme pour chaque projet. Il y a des projets qui n'ont tout simplement pas besoin d'une telle norme. À mon avis, la réponse acceptée ne correspond pas à la description de la façon dont on pourrait prendre cette décision pour un projet donné.

je vais tenter ma chance. Je ne suis pas un expert en ingénierie d'essais et je serais heureux de voir une réponse plus éclairée.

quand établir les exigences de couverture des codes

d'Abord, pourquoi voulez-vous imposer une telle norme en premier lieu? En général, quand vous voulez introduire la confiance empirique dans votre processus. Qu'est-ce que j'entends par "confiance empirique"? Eh bien, le vrai but rectitude . Pour la plupart des logiciels, nous ne pouvons pas le savoir pour toutes les entrées, donc nous nous contentons de dire que le code est bien testé . C'est plus connaissable, mais est encore une norme subjective: il sera toujours ouvert au débat si vous l'avez rencontré ou non. Ces débats sont utiles et devraient avoir lieu, mais ils exposent également l'incertitude.

de la couverture de Code est un objectif de la mesure: une Fois que vous voyez votre rapport de couverture, il n'existe aucune ambiguïté quant à savoir si les normes ont été respectées sont utiles. N'est-il prouver l'exactitude? Pas du tout, mais il a un rapport clair à la façon dont le code est bien testé, qui à son tour est notre meilleure façon d'augmenter la confiance dans son exactitude. La couverture du Code est une approximation mesurable des qualités incommensurables qui nous tiennent à cœur.

Certains cas spécifiques où le fait d'avoir une analyse empirique de la norme pourraient ajouter de la valeur:

• pour satisfaire les parties prenantes. pour de nombreux projets, il y a différents acteurs qui s'intéressent à la qualité des logiciels et qui ne sont pas nécessairement impliqués dans le développement quotidien du logiciel (gestionnaires, pistes techniques, etc. Le fait de dire "nous allons faire tous les tests dont nous avons vraiment besoin" n'est pas convaincant: soit ils doivent faire entièrement confiance, soit ils doivent vérifier avec une supervision étroite continue (en supposant qu'ils ont même la compréhension technique pour le faire.) Il est préférable de fournir des normes mesurables et d'expliquer comment elles se rapprochent raisonnablement des objectifs réels.
• pour normaliser le comportement de l'équipe. intervenants mis à part, si vous travaillez dans une équipe où plusieurs personnes sont code de rédaction et tests, il y a place à l'ambiguïté pour ce qui se qualifie comme "bien testé."Faites tous vos collègues ont la même idée de ce niveau de test est assez bon? Probablement pas. Comment conciliez-vous cela? Trouvez une métrique sur laquelle vous pouvez tous vous entendre et l'accepter comme une approximation raisonnable. Cela est particulièrement (mais pas exclusivement) utile dans les grandes équipes, où les prospects peuvent ne pas avoir de contrôle direct sur les développeurs juniors, par exemple. Les réseaux de confiance sont également importants, mais sans objectif les mesures, il est facile pour le comportement du groupe de devenir incohérent, même si tout le monde agit de bonne foi.
• pour être honnête. même si vous êtes le seul développeur et le seul intervenant pour votre projet, vous pourriez avoir certaines qualités à l'esprit pour le logiciel. Au lieu de faire des évaluations subjectives continues sur la façon dont le logiciel est bien testé( ce qui nécessite du travail), vous pouvez utiliser la couverture du code comme une approximation raisonnable, et laissez les machines le mesurent pour vous.

quels paramètres utiliser

la couverture du Code N'est pas une mesure unique; il existe plusieurs façons de mesurer la couverture. Celui sur lequel vous pourriez établir une norme dépend de ce que vous utilisez cette norme pour satisfaire.

je vais utiliser deux mesures courantes comme exemples de quand vous pourriez les utiliser pour établir des normes:

• déclaration couverture : quel pourcentage de déclarations ont été exécutées pendant les tests? Utile pour avoir une idée de la couverture physique de votre code: quelle quantité du code que j'ai écrit ai-je réellement testé?
  • ce type de couverture soutient un argument d'exactitude plus faible, mais est également plus facile à réaliser. Si vous utilisez seulement la couverture de code pour s'assurer que choses sont testés (et pas comme un indicateur de la qualité du test au-delà cela) alors la couverture de l'énoncé est probablement suffisante.
• couverture des branches : Lorsqu'il y a une logique de branchement (par exemple un if ), les deux branches ont-elles été évaluées? Cela donne un meilleur sens de la couverture logique de votre code: combien de chemins possibles mon code peut prendre ai-je testé?
  • Ce genre de couverture est un bien meilleur indicateur qu'un programme a été testé sur un ensemble complet d'entrées. Si vous utilisez la couverture de code comme meilleure approximation empirique pour la confiance dans l'exactitude, Vous devriez établir des normes basées sur la couverture de la branche ou similaire.

il existe de nombreux autres paramètres (la couverture de ligne est similaire à la couverture de l'énoncé, mais donne des résultats numériques différents pour les énoncés multilignes, par exemple; la couverture conditionnelle et la couverture du sentier sont similaires à celles de la Direction générale couverture, mais reflètent une vue plus détaillée des permutations possibles de l'exécution du programme que vous pourriez rencontrer.)

quel pourcentage exiger

enfin, revenons à la question initiale: si vous établissez des normes de couverture du code, quel devrait être ce nombre?

J'espère qu'il est clair à ce stade que nous parlons d'une approximation pour commencer, donc tout nombre que nous choisirons sera essentiellement approximatif.

Quelques chiffres que l'on pourrait choisir:

• 100% . Vous pouvez choisir ce parce que vous voulez être sûr que tout est testé. Cela ne vous donne aucun aperçu de la qualité du test, mais vous indique qu'un test d'une certaine qualité a touché chaque déclaration (ou branche, etc.) Encore une fois, cela revient à un degré de confiance: si votre couverture est inférieure à 100%, vous savez un sous-ensemble de votre code n'est pas testé.
  • Certains diront que c'est stupide, et vous ne devriez tester les parties de votre code qui sont vraiment importantes. Je dirais que vous devriez aussi garder les parties de votre code qui sont vraiment importantes. La couverture du Code peut également être améliorée en supprimant le code non testé.
• 99% (ou 95%, d'autres nombres dans les années quatre-vingt-dix élevées.) Dans les cas où vous souhaitez transmettre un niveau de confiance similaire à 100%, mais laissez-vous une certaine marge pour ne pas vous soucier du coin de code occasionnel difficile à tester.
• 80% . J'ai vu ce nombre plusieurs fois, et je ne sais pas vraiment d'où il vient. J' penser il pourrait être un drôle de détournement de la règle des 80-20; en général, l'intention ici est de montrer que plus de votre code est testé. (Oui, 51% serait aussi "plus", mais 80% est plus reflétant de ce que la plupart des gens signifie par la plupart.) Cela est approprié pour les cas de milieu de terrain où "bien testé" n'est pas une priorité élevée (vous ne voulez pas gaspiller les efforts sur les tests de faible valeur), mais est assez d'une priorité que vous souhaitez toujours avoir une certaine norme en place.

Je n'ai pas vu de nombres inférieurs à 80% dans la pratique, et j'ai du mal à imaginer un cas où l'on pourrait les définir. Le rôle de ces normes visent à accroître la confiance dans l'exactitude, et les nombres inférieurs à 80% ne sont pas particulièrement inspirants de confiance. (Oui, c'est subjectif, mais encore une fois, l'idée est de faire le choix subjectif une fois que vous fixez la norme, et puis utiliser une mesure objective aller de l'avant.)

autres notes

ce qui précède suppose que l'exactitude est le but. La couverture du Code n'est qu'une information; elle peut être pertinente à d'autres fins. Par exemple, si vous êtes en ce qui concerne la maintenabilité, vous vous souciez probablement du couplage lâche, qui peut être démontré par la testabilité, qui à son tour peut être mesurée (dans certains modes) par couverture de code. Si votre couverture de code standard fournit une base empirique pour l'estimation de la qualité de "maintenabilité".

ma couverture préférée est 100% avec un astérisque. L'astérisque vient parce que je préfère utiliser des outils qui me permettent de marquer certaines lignes comme des lignes qui "ne comptent pas". Si j'ai couvert 100% des lignes qui "comptent", je suis fait.

le processus sous-jacent est:

1. j'écris mes tests pour exercer toutes les fonctionnalités et les cas de bord que je peux penser (généralement en travaillant à partir de la documentation).
2. Je cours le les outils de couverture de code
3. j'examine toutes les lignes ou les chemins non couverts et tous ceux que je considère comme non importants ou inaccessibles (en raison de la programmation défensive) je marque comme ne comptant pas
4. j'écris de nouveaux tests pour couvrir les lignes manquantes et améliorer la documentation si ces bordures ne sont pas mentionnées.

de cette façon si moi et mes collaborateurs ajoutent un nouveau code ou modifient les tests dans le futur, il y a une ligne brillante pour nous dire si nous on a oublié quelque chose d'important - la couverture est tombée sous la barre des 100%. Cependant, il offre également la souplesse nécessaire pour traiter les différents tests de priorités.

j'aimerais partager un autre anectode sur la couverture des tests.

nous avons un projet énorme dans lequel, sur twitter, j'ai noté que, avec 700 tests unitaires, nous avons seulement 20% de couverture de code .

Scott, Hanselman , a répondu avec paroles de sagesse :

est-ce le bon 20%? Est-ce la 20% que représente le code de vos utilisateurs frapper la la plupart des? Tu pourrais en ajouter 50 de plus. tests et seulement ajouter 2%.

encore une fois, il remonte à mon Testivus sur la couverture de Code réponse. Combien de riz devrait vous mettre dans le pot? Il dépend.

85% serait un bon point de départ pour l'enregistrement critères.

j'avais probablement choisi une variété de barres plus élevées pour les critères d'expédition - selon la criticité des sous-systèmes/composants testés.

si ce monde était parfait, 100% du code serait couvert par des tests unitaires. Cependant, comme ce n'est pas un monde parfait, c'est une question de temps. En conséquence, je recommande de se concentrer moins sur un pourcentage précis et de se concentrer davantage sur les domaines critiques. Si votre code est bien rédigé (ou au moins une copie raisonnable de celui-ci), il devrait y avoir plusieurs points clés où les IPA sont exposés à d'autres codes.

concentrez vos efforts de test sur ces API. Assurez-vous que les IPA sont 1) bien documentés et 2) que les cas d'essai sont écrits qui correspondent à la documentation. Si les résultats attendus ne correspondent pas avec les docs, alors vous avez un bug dans votre code, documentation ou cas de test. Tous de qui sont bons pour l'efp.

bonne chance!

pour un système bien conçu, où les tests unitaires ont conduit le développement dès le début, je dirais que 85% est un nombre assez faible. Les petites classes conçues pour être testables ne devraient pas être difficiles à couvrir mieux que cela.

il est facile de rejeter cette question avec quelque chose comme:

• les lignes couvertes ne correspondent pas à la logique testée et il ne faut pas trop lire dans le pourcentage.

vrai, mais là quelques points importants à propos de la couverture de code. D'après mon expérience, cette métrique est en fait très utile, lorsqu'elle est utilisée correctement. Cela dit, Je n'ai pas vu tous les systèmes et je suis sûr qu'il y en a des tonnes où il est difficile de voir l'analyse de couverture de code Ajouter une valeur réelle. Le Code peut sembler si différent et la portée du cadre de test disponible peut varier.

aussi, mon raisonnement concerne principalement des boucles de rétroaction de test assez courtes. Pour le produit que je développe la boucle de rétroaction la plus courte est assez flexible, couvrant tout, des tests de classe à la signalisation inter-processus. La mise à l'essai d'un sous-produit livrable prend généralement 5 minutes et, pour une boucle de rétroaction aussi courte, il est en effet possible d'utiliser les résultats des essais (et en particulier la métrique de couverture du code que nous examinons ici) pour rejeter ou accepter des propagations dans le dépôt.

lorsque vous utilisez la métrique de couverture de code, vous ne devez pas seulement avoir un fixe (arbitraire)) pourcentage qui doit être remplie. faire ceci ne vous donne pas les avantages réels de l'analyse de couverture de code à mon avis. Définissez plutôt les paramètres suivants:

• laisse de Basse Mer (LWM), le plus petit nombre de lignes non recouvertes jamais vu dans le système à l'essai
• la Marque des Hautes Eaux (LHE), le plus haut pourcentage de couverture de code jamais vu pour le système en cours de test

nouveau code ne peut être ajouté si nous n'allons pas au-dessus de la LWM et nous n'allons pas au-dessous de la HWM. En d'autres termes, la couverture de code est non autorisé à diminuer , et le nouveau code devrait être couvert. Remarquez comment je dis devrait et ne doit pas (expliqué ci-dessous).

mais cela ne signifie-t-il pas qu'il sera impossible de nettoyer les vieux déchets éprouvés dont vous n'avez plus besoin? Oui, et c'est pourquoi tu dois être pragmatique à propos de ces choses. Il existe des situations où les règles doivent être cassé, mais pour votre intégration quotidienne typique mon expérience il que ces mesures sont très utiles. Ils donnent les deux implications.

• le code à tester est promu. Lors de l'ajout de nouveau code, vous devez vraiment faire un effort pour rendre le code testable, parce que vous devrez essayer de couvrir tout cela avec vos cas de test. Le code vérifiable est généralement une bonne chose.

• de couverture de Test pour l'héritage le code augmente avec le temps. Lorsque vous ajoutez un nouveau code et que vous n'êtes pas en mesure de le couvrir avec un cas d'essai, vous pouvez essayer de couvrir un code existant à la place pour contourner la règle LWM. Cette tricherie parfois nécessaire au moins Donne l'effet secondaire positif que la couverture de l'ancien code augmentera avec le temps, rendant l'application apparemment stricte de ces règles tout à fait pragmatique dans la pratique.

et de nouveau, si la boucle de rétroaction est trop longue, il pourrait être complètement, peu pratique pour l'installation de ce genre dans le processus d'intégration.

j'aimerais également mentionner deux avantages plus généraux de la métrique de couverture du code.

• L'analyse de la couverture du Code fait partie de l'analyse du code dynamique (par opposition à l'analyse statique, C'est-à-dire La Peluche). Problèmes identifiés lors de l'analyse de code dynamique (par des outils tels que le purifier de la famille, http://www-03.ibm.com/software/products/en/rational-purify-family ) sont des choses comme les lectures de mémoire non initialisées (UMR), les fuites de mémoire, etc. ces problèmes ne peuvent être trouvés que si le code est couvert par un cas d'essai exécuté . Le code qui est le plus difficile à couvrir dans un cas de test est généralement les cas anormaux dans le système, mais si vous voulez que le système échoue gracieusement (i.e. trace d'erreur au lieu de crash), vous pourriez vouloir mettre un certain effort à couvrir le cas anormaux dans l'analyse du code dynamique aussi. Avec juste un peu de malchance, un UMR peut mener à un segfault ou pire.

• les gens sont fiers de garder 100% pour le nouveau code, et les gens discutent des problèmes de test avec une passion similaire à d'autres problèmes de mise en œuvre. Comment cette fonction peut être écrite dans un plus testable? Comment feriez-vous pour essayer de couvrir ce cas anormal, etc.

Et un négatif, par souci d'exhaustivité.

• dans un grand projet avec beaucoup de développeurs impliqués, tout le monde ne va pas être un test-génie à coup sûr. Certaines personnes ont tendance à utiliser les métriques de couverture de code, comme preuve que le code est testé et c'est très loin de la vérité , comme mentionné dans de nombreuses autres réponses à cette question. C'est une métrique qui peut vous donner de bons avantages si elle est utilisée correctement, mais si elle est mal utilisée, elle peut en fait conduire à mauvais test. Mis à part les effets secondaires très précieux mentionnés ci-dessus, une ligne couverte montre seulement que le système à l'essai peut atteindre cette ligne pour certaines données d'entrée et qu'il peut s'exécuter sans accrochage ni écrasement.

beaucoup de magasins n'évaluent pas les tests, donc si vous êtes au - dessus de zéro au moins il ya une certaine appréciation de la valeur-donc sans doute non-zéro n'est pas mauvais car beaucoup sont encore zéro.

dans le monde.Net les gens citent souvent 80% comme raisonnable. Mais ils le disent au niveau de la solution. Je préfère mesurer au niveau du projet: 30% pourrait être bien pour le projet D'UI si vous avez le sélénium, etc ou des tests manuels, 20% pour le projet de couche de données pourrait être bien, mais 95%+ pourrait être tout à fait réalisable pour le couche de règles commerciales, si ce n'est pas entièrement nécessaire. Ainsi, la couverture globale peut être, disons, de 60%, mais la logique commerciale critique peut être beaucoup plus élevée.

j'ai aussi entendu ceci: aspirez à 100% et vous atteindrez 80%; mais aspirez à 80% et vous atteindrez 40%.

ligne de fond: appliquez la règle 80:20, et laissez le compte de bugs de votre application vous guider.

j'utilise cobertura, et quel que soit le pourcentage, je recommande de garder à jour les valeurs de la tâche cobertura-check. À tout le moins, augmentez le taux d'intérêt total et le taux d'intérêt total juste au-dessous de votre couverture actuelle, mais jamais abaisser ces valeurs. Liez aussi la propriété d'échec de construction de fourmilière à cette tâche. Si la construction échoue à cause du manque de couverture, vous savez le code ajouté par quelqu'un mais ne l'a pas testé. Exemple:

<cobertura-check linerate="0"
                 branchrate="0"
                 totallinerate="70"
                 totalbranchrate="90"
                 failureproperty="build.failed" />

quand je pense que mon code n'est pas suffisamment testé à l'unité, et que je ne sais pas quoi tester ensuite, j'utilise la couverture pour m'aider à décider quoi tester ensuite.

si j'augmente la couverture dans un test unitaire - je sais que ce test unitaire vaut quelque chose.

code non couvert, 50% couvert ou 97% couvert.

n'est qu'une autre mesure. En soi, elle peut être très trompeuse (voir ). www.thoughtworks.com/insights/blog/are-test-coverage-metrics-overrated ). Votre objectif ne devrait donc pas être d'atteindre une couverture de code de 100%, mais plutôt de vous assurer que vous testez tous les scénarios pertinents de votre application.

si vous avez fait des tests à l'unité pendant un certain temps, Je ne vois aucune raison pour que cela ne s'approche pas de 95%+. Cependant, au minimum, j'ai toujours travaillé avec 80%, même lorsque de nouveaux tests.

ce nombre ne doit inclure que le code écrit dans le projet (à l'exclusion des cadres, des plugins, etc.) et peut-être même exclure certaines classes composées entièrement de code écrit d'appels vers du code extérieur. Ce genre d'appel devrait être moqué/entaillé.

D'une façon générale, d'après les divers documents sur les pratiques exemplaires d'excellence en génie que j'ai lus, 80% du nouveau code dans les essais unitaires est le point qui rapporte le meilleur rendement. Aller plus haut que CC% taux une faible quantité de défauts pour le montant de l'effort exercé. Il s'agit d'une pratique qui est utilisé par de nombreuses grandes entreprises.

Malheureusement, la plupart de ces résultats sont internes aux sociétés, il n'y a pas public littératures que je peux vous.

Code couverture est grande, mais seulement tant que les avantages que vous obtenez de celui-ci l'emportent sur le coût/effort de l'atteindre.

nous avons travaillé à une norme de 80% depuis un certain temps, mais nous venons de prendre la décision d'abandonner cette pratique et de nous concentrer davantage sur nos tests. Se concentrer sur la logique complexe de l'entreprise, etc.

cette décision a été prise en raison de la quantité croissante de temps que nous avons passé à poursuivre la couverture du code et à maintenir existant des tests unitaires. Nous avons senti que nous avions obtenu au point où nous en étions de notre couverture de code a été jugée moins de l'effort que nous avons dû mettre en pour l'atteindre.

Check out Crap4j . C'est une approche un peu plus sophistiquée que la couverture en code. Il combine des mesures de couverture de code avec des mesures de complexité, puis vous montre ce code complexe n'est pas actuellement testé.

ma réponse à cette énigme est d'avoir 100% de couverture de ligne du code que vous pouvez tester et 0% de couverture de ligne du code que vous ne pouvez pas tester.

ma pratique actuelle en Python est de diviser mon .les modules py en deux dossiers: app1 / et app2/ et lors de l'exécution des tests unitaires calculent la couverture de ces deux dossiers et vérifient visuellement (I doit automatiser ce jour) que app1 a une couverture de 100% et app2 a une couverture de 0%.

Quand / si je constate que ces chiffres diffèrent de la norme i enquête et modifier la conception du code de sorte que la couverture est conforme à la norme.

cela signifie que je peux recommander d'atteindre une couverture 100% ligne du code de bibliothèque.

j'examine aussi occasionnellement app2 / pour voir si je peux tester n'importe quel code là, et si je peux le déplacer dans app1 /

maintenant je ne suis pas trop inquiet au sujet de la couverture globale parce que cela peut varier cela dépend énormément de la taille du projet, mais généralement j'ai vu 70% à plus de 90%.

avec python, je devrais être en mesure de concevoir un test de fumée qui pourrait exécuter automatiquement mon application tout en mesurant la couverture et avec un peu de chance gagner un aggréagate de 100% en combinant le test de fumée avec des chiffres unitaires d'essai.

voir la couverture d'un autre point de vue: code bien écrit avec un flux clair de contrôle est le plus facile à couvrir, le plus facile à lire, et généralement le code le moins buggy. En écrivant le code avec la clarté et la coverability à l'esprit, et en écrivant les tests de l'unité en parallèle avec le code, vous obtenez les meilleurs résultats IMHO.

à mon avis, la réponse est"cela dépend de combien de temps vous avez". J'essaie d'atteindre 100% mais je ne fais pas d'histoires si je ne l'obtiens pas avec le temps que j'ai.

quand j'écris des tests unitaires, je porte un chapeau différent de celui que je porte lors de l'élaboration du code de production. Je pense à ce que le code testé prétend faire et quelles sont les situations qui peuvent le briser.

j'ai l'habitude de suivre les critères suivants ou les règles:

1. que le test unitaire devrait être une forme de documentation sur le comportement attendu de mes codes, c'est-à-dire: le résultat attendu étant donné un certain input et les exceptions qu'il peut jeter que les clients peuvent vouloir attraper (ce que les utilisateurs de mon code devraient savoir?)

2. que le test de L'unité devrait m'aider à découvrir ce que si des conditions que je n'ai peut-être pas encore pensé. (Comment rendre mon code stable et robuste?)

si ces deux règles ne produisent pas une couverture de 100%, qu'il en soit ainsi. Mais une fois que j'ai le temps, j'analyse les blocs et les lignes non couverts et je détermine s'il y a encore des cas de test sans tests unitaires ou si le code doit être remanié pour éliminer les codes inutiles.

je préfère ne BDD, qui utilise une combinaison de tests d'acceptation automatique, éventuellement, d'autres tests d'intégration et tests unitaires. Pour moi, la question Est de savoir quelle devrait être la couverture cible de la suite de tests automatisée dans son ensemble.

cela mis à part, la réponse dépend de votre méthodologie, de votre langue et de vos outils de test et de couverture. Quand vous faites du TDD en Ruby ou en Python, il n'est pas difficile de maintenir une couverture à 100%, et cela en vaut la peine. il est beaucoup plus facile de gérer la couverture à 100% plutôt qu'à 90%. C'est-à-dire qu'il est beaucoup plus facile de combler les lacunes de la couverture au fur et à mesure qu'elles apparaissent (et lorsque vous faites des DTM, les lacunes de la couverture sont rares et elles valent généralement le coup d'être comblées) que de gérer une liste de lacunes que vous n'avez pas comblées et de rater les régressions de la couverture en raison de votre contexte constant de code non couvert.

La réponse dépend aussi de l'histoire de votre projet. J'ai seulement trouvé que ce qui précède pour être pratique dans les projets gérés de cette façon depuis le début. J'ai grandement amélioré la couverture des grands projets patrimoniaux, et cela en valait la peine, mais je n'ai jamais trouvé pratique de revenir en arrière et de combler toutes les lacunes de la couverture, parce que le vieux code non testé n'est pas assez bien compris pour le faire correctement et rapidement.

cela dépend beaucoup de votre application. Par exemple, certaines applications consistent principalement en du code GUI qui ne peut pas être testé à l'unité.

Je ne pense pas qu'il puisse y avoir une telle règle B/W.

Le Code devrait être revu, en accordant une attention particulière aux détails critiques.

Cependant, s'il n'a pas été testé, il a un bug!

brève réponse: 60-80%

longue réponse: Je pense que cela dépend entièrement de la nature de votre projet. Je commence généralement un projet par unité testant chaque pièce pratique. À la première" sortie " du projet, vous devriez avoir un assez bon pourcentage de base basé sur le type de programmation que vous faites. À ce moment-là, vous pouvez commencer à "appliquer" une couverture de code minimum.

selon la criticité du code, entre 75% et 85% est une bonne règle empirique. Le code d'expédition devrait certainement être testé plus en profondeur que dans les services publics de la maison, etc.

cela doit dépendre de la phase dans laquelle vous êtes dans le cycle de développement de votre application.

si vous avez été au développement pendant un certain temps et avez beaucoup de code déjà mis en œuvre et que vous venez de réaliser que vous devez penser à la couverture de code, alors vous devez vérifier votre couverture actuelle (si elle existe) et puis utiliser cette base de référence pour fixer des jalons à chaque sprint (ou une augmentation moyenne sur une période de sprints), ce qui signifie prendre des dettes de code tandis que continuer à fournir la valeur de l'utilisateur final (au moins dans mon expérience l'utilisateur final ne se soucie pas un peu si vous avez augmenté la couverture de test s'ils ne voient pas de nouvelles fonctionnalités).

selon votre domaine, il n'est pas déraisonnable de tirer pour 95%, mais je dois dire en moyenne Votre va être à la recherche d'un cas moyen de 85% à 90%.

je pense que le meilleur symptôme d'une couverture correcte du code est que la quantité de problèmes concrets que les tests unitaires aident à résoudre correspond raisonnablement à la taille du code de tests unitaires que vous avez créé.

je pense que ce qui importe le plus est de savoir quelle est l'évolution de la couverture dans le temps et de comprendre les raisons des changements dans la tendance. Si vous affichez les changements dans la tendance comme bonne ou mauvaise dépend de votre analyse de la raison.

nous ciblions >80% jusqu'à quelques jours en arrière, mais après que nous ayons utilisé beaucoup de code généré, nous ne nous soucions pas de l'âge du%, mais plutôt de faire appel à l'examinateur sur la couverture requise.

de L'affichage de Testivus je pense que le contexte de réponse devrait être le second programmeur. Cela dit, d'un point de vue pratique, nous avons besoin de paramètres / objectifs à atteindre. Je considère que cela peut être "testé" dans un processus Agile en analysant le code que nous avons l'architecture, la fonctionnalité (Récits d'utilisateurs), et puis venir avec un nombre. Sur la base de mon expérience dans le Domaine Des Télécommunications, je dirais que 60% est une bonne valeur à vérifier.