Was ist ein angemessener Prozentsatz der Codeabdeckung für Unit-Tests (und warum)?[geschlossen]

StackOverflow https://stackoverflow.com/questions/90002

Frage

Wenn Sie einen Mindestprozentsatz an Codeabdeckung für Unit-Tests vorschreiben würden, vielleicht sogar als Voraussetzung für die Übergabe an ein Repository, welcher wäre dieser?

Bitte erläutern Sie, wie Sie zu Ihrer Antwort gekommen sind (denn wenn Sie nur eine Zahl ausgewählt hätten, hätte ich das ganz alleine tun können ;)

War es hilfreich?

Lösung

Diese Prosa von Alberto Savoia beantwortet genau diese Frage (in einem schön unterhaltsame Weise das an!):

http://www.artima.com/forums/flat. jsp? Forum = 106 & thread = 204677

  

Testivus On Test Coverage

     

An einem frühen Morgen, ein Programmierer gefragt   der große Meister:

     

„Ich bin bereit, einige Unit-Tests zu schreiben. Was für Codeabdeckung sollte ich darauf abzielen   für?“

     

Der große Meister antwortete:

     

„Nicht über Berichterstattung Sorge, nur ein paar gute Tests schreiben.“

     

Der Programmierer lächelte, verbeugte sich und   links.

     

...

     

Später an diesem Tag ein zweiter Programmierer   die gleiche Frage gestellt.

     

Der große Meister in einem Topf wies der   kochendem Wasser und sagte:

     

„Wie viele Reiskörner soll ich in diesem Topf?“

     

Der Programmierer, sucht verwirrt,   antwortete:

     

„Wie kann ich Ihnen vielleicht sagen? Es hängt davon ab, wie viele Menschen, die Sie brauchen, um   Futter, wie hungrig sie sind, was andere   Lebensmittel, die Sie dienen, wie viel Reis   Sie zur Verfügung haben, und so weiter.“

     

„Genau“, sagte der großen Meister.

     

Der zweite Programmierer lächelte, verbeugte sich,   und links.

     

...

     

Gegen Ende des Tages, ein Drittel   Programmierer kam und fragte die gleiche   Frage über Code Coverage.

     

„Achtzig Prozent und nicht weniger!“ Antworteten den Meister mit strengen Stimme,   mit der Faust auf dem Tisch hämmert.

     

Der dritte Programmierer lächelte, verbeugte sich,   und links.

     

...

     

Nach dieser letzten Antwort, ein junger   Lehrling näherte sich die großen   Master:

     

„Great Meister, heute habe ich mitgehört beantworten Sie die gleiche Frage über   Codeabdeckung mit drei verschiedenen   Antworten. Warum?“

     

Der große Meister stand von seinem   Stuhl:

     

„Kommen Sie etwas frischen Tee mit mir bekommen und lassen Sie sich darüber reden.“

     

Nachdem sie füllten ihre Tassen mit   Rauchen heiß grüner Tee, der große   Meister begann zu beantworten:

     

„Der erste Programmierer ist neu und nur mit dem Testen begonnen.   Gerade jetzt hat er eine Menge Code und keine   Tests. Er hat einen langen Weg zu gehen;   wobei der Schwerpunkt auf Codeabdeckung zu diesem Zeitpunkt   wäre deprimierend und ziemlich nutzlos.   Er ist besser dran, nur Gewöhnung   Schreiben und einige Tests laufen. Er kann   Sorgen über Berichterstattung später.“

     

„Der zweite Programmierer, auf der anderen Seite, ist durchaus Erfahrung sowohl   bei der Programmierung und Prüfung. Wenn ich   antwortete mit ihr, wie viele Körner zu fragen   Ich Reis soll ich in einem Topf,   erkennen, half ihr, dass die Menge an   notwendigen Tests hängt von einer Reihe   von Faktoren ab, und sie weiß, diejenigen,   Faktoren besser als ich - es ist ihr   Code, nachdem alle. Es gibt keine einzige,   einfach, zu beantworten, und sie ist klug genug,   die Wahrheit und Arbeit zu handhaben mit   das.“

     

„Ich verstehe“, sagte der junge Lehrling,   „Aber wenn es keine einzige einfache   Antwort, warum haben Sie beantworten die   dritter Programmierer ‚Achtzig Prozent und   nicht weniger?“

     

Der große Meister lachte so hart und   laut, dass sein Bauch, Hinweise darauf, dass er   trank mehr als nur grüner Tee,   floppte nach oben und unten.

     

„Der dritte Programmierer will nur einfache Antworten - auch wenn es   keine einfachen Antworten ... und dann nicht   folgen sie trotzdem.“

     

Der junge Lehrling und die ergraute   großer Meister beendete ihre trinken   Tee in kontemplativer Stille.

Andere Tipps

Code Coverage ist eine irreführende Metrik, wenn 100% ige Abdeckung ist Ihr Ziel (statt 100% -Prüfung aller Funktionen).

  • Sie können ein 100% erhalten, indem einmal alle Linien treffen. Allerdings könnte man noch eine bestimmte Sequenz (logischen Pfad), in dem zu kurz kommen zu testen diese Linien sind betroffen.
  • Sie konnte nicht 100% aber immer noch alle Ihre 80% / Freq verwendeten Code-Pfade getestet. Mit Tests, die jeder ‚werfen ExceptionTypeX‘ oder ähnliche defensive Programmierung Wachen Sie in gesteckt haben zu testen ist ein ‚nice to have‘ kein ‚must have‘

So vertrauen sich selbst oder Ihre Entwickler gründlich zu sein und jeden Pfad durch ihren Code zu decken. Seien Sie pragmatisch und nicht die magische 100% Abdeckung jagen. Wenn Sie Ihren Code TDD sollten Sie ein 90% + Abdeckung als Bonus bekommen. Verwenden Sie Code-Coverage markieren Teile des Codes Sie verpasst haben (sollte nicht passieren, wenn Sie obwohl TDD .. da Sie Code schreiben, nur einen Testdurchlauf zu machen. Kein Code kann ohne seinen Partner-Test bestehen.)

Code-Abdeckung ist groß, aber die Funktionalität Abdeckung ist sogar noch besser. Ich glaube nicht, jede einzelne Zeile in abdecke ich schreibe. Aber ich glaube, schriftlich 100% Testabdeckung aller Funktionalität, die ich zur Verfügung stellen möchte (auch für die zusätzliche kühlen Funktionen, die ich mit mir selbst kam und welche nicht in den Sitzungen diskutiert).

Ich interessiere mich nicht, wenn ich Code haben würde, die in den Tests nicht abgedeckt ist, aber ich würde interessieren, wenn ich meinen Code Refactoring würde und ein anderes Verhalten am Ende mit. Daher ist zu 100% Funktionalität Abdeckung mein einziges Ziel.

Die akzeptierte Antwort macht einen guten Punkt - es gibt nicht eine einzige Zahl, den Sinn als Standard für jedes Projekt machen wird. Es gibt Projekte, die einen solchen Standard brauchen nicht nur. Wo die akzeptierte Antwort kurz fällt, meiner Meinung nach, ist in der beschreibt, wie könnte man diese Entscheidung für ein bestimmtes Projekt machen.

Ich werde einen Schuss nehmen so zu tun. Ich bin kein Experte in der Prüftechnik und würde sich freuen, eine fundierte Antwort zu sehen.

Wenn Code-Coverage-Anforderungen einstellen

Erstens, warum würden Sie einen solchen Standard in erster Linie aufzwingen wollen? Im Allgemeinen wollen, wenn Sie empirisches Vertrauen in Ihrem Prozess einzuführen. Was meine ich mit „empirischen Vertrauen“? Nun, die eigentliche Ziel Richtigkeit . Für die meisten Software, können wir nicht wissen dies über alle Eingänge, so dass wir regeln für diesen Code zu sagen ist gut getestet . Das ist mehr erkennbar, ist aber immer noch ein subjektiver Standard: Es wird immer offen sein zu diskutieren, ob Sie es getroffen haben. Diese Debatten sind nützlich und sollten auftreten, aber auch Unsicherheit aus.

Code-Coverage ist eine objektive Messung: Sobald Sie Ihre Berichterstattung Bericht sehen, gibt es keine Unklarheit darüber, ob Standards erfüllt sind nützlich sind. Ist es Korrektheit beweisen? Gar nicht, aber es hat eine klare Beziehung zu, wie gut getestet ist der Code, der wiederum ist unsere beste Weg, das Vertrauen in die Korrektheit zu erhöhen. Code Coverage ist eine messbare Annäherung der unermesslichen Qualitäten wir kümmern uns um.

Einige spezifischen Fälle, in denen einen empirischen Standard mit dem Wert hinzufügen könnte:

  • Um Beteiligten gerecht werden. Bei vielen Projekten gibt es verschiedene Akteure, die ein Interesse an dem Software-Qualität haben, die nicht die Entwicklung in der Tag zu Tag beteiligt sein können von der Software (Manager, technischer Leiter zu sagen, etc.) „wir werden alle Tests schreiben, haben wir wirklich brauchen“ ist nicht überzeugend: sie sind entweder vollständig vertrauen müssen, oder überprüfen, mit dem laufenden naher Aufsicht (vorausgesetzt, sie auch das technische Verständnis, dies zu tun) Providing. messbare Standards und erklärt, wie sie vernünftigerweise ungefähre tatsächliche Ziele sind besser.
  • Teamverhalten normalisieren. Stakeholder zur Seite, wenn Sie in einem Team arbeiten, in dem mehrere Personen Code und Tests schreiben, gibt es Raum für Mehrdeutigkeit für was als „gut getestet.“ Sie alle Ihre Kollegen haben die gleiche Vorstellung davon, welche Ebene der Prüfung gut genug ist? Wahrscheinlich nicht. Wie bringen Sie das? Finden Sie eine Metrik, die Sie alle zustimmen können und akzeptieren es als eine vernünftige Annäherung. Dies ist vor allem (aber nicht ausschließlich) nützlich in großen Teams, wo Leitungen können nicht direkt Aufsicht über Junior-Entwickler haben, zum Beispiel. Es geht auch um Netzwerke des Vertrauens, aber ohne objektive Messungen, ist es leicht, das Verhalten der Gruppe inkonsistent zu werden, auch wenn jeder in gutem Glauben handelt.
  • So halten Sie sich ehrlich. Auch wenn Sie der einzige Entwickler sind und nur für Ihr Projekt Stakeholder, könnten Sie für die Software im Auge bestimmte Eigenschaften haben. Statt machen laufende subjektive Einschätzungen darüber, wie gut getestet ist die Software (die Arbeit dauert) können Sie Code-Coverage als vernünftige Annäherung verwenden, und lassen Sie es für Sie Maschinen messen.

Welche Metriken verwenden

Code-Abdeckung ist nicht eine einzige Metrik; Es gibt verschiedene Möglichkeiten der Berichterstattung zu messen. Welche Sie könnten einen Standard gesetzt hängt davon ab, was Sie diesen Standard verwenden zu erfüllen.

Ich werde zwei gemeinsame Metriken als Beispiele für verwenden, wenn Sie sie verwenden können Maßstäbe zu setzen:

  • Statement Berichterstattung : Wie viel Prozent der Aussagen wurden während des Tests ausgeführt? Nützliche ein Gefühl für die physische Abdeckung Ihres Codes zu bekommen: Wie viel von dem Code, den ich geschrieben habe, habe ich eigentlich getestet?
    • Diese Art der Berichterstattung supPorts ein schwächeres Korrektheit Argument, aber es ist auch leichter zu erreichen. Wenn Sie nur Code-Coverage mit, um sicherzustellen, , die die Dinge getestet (und nicht als Indikator für die Testqualität darüber hinaus), dann Anweisungsüberdeckung wahrscheinlich ausreichend ist.
  • Zweigüberdeckung : Wenn es logische Verzweigung (beispielsweise ein if) haben beide Zweige bewertet worden? Dies gibt ein besseres Gefühl für die logische Abdeckung Ihres Codes: Wie viele der möglichen Wege meinen Code nehmen kann ich getestet?
    • Diese Art der Berichterstattung ist ein viel besserer Indikator, dass ein Programm über einen umfassenden Satz von Eingängen getestet. Wenn Sie Code-Coverage als die beste empirische Annäherung für das Vertrauen in die Richtigkeit verwenden, sollten Sie Standards basierend auf Zweigüberdeckung oder ähnlich eingestellt.

Es gibt viele andere Metriken (line Abdeckung ist ähnlich Anweisungsüberdeckung ergibt aber unterschiedliche numerische Ergebnisse für mehrzeilige Aussagen, zum Beispiel; bedingte Reichweite und Pfadüberdeckung ist Zweigüberdeckung ähnlich, aber eine detailliertere Ansicht des reflektieren mögliche Permutationen der Programmausführung auftreten könnten.)

Wie viele Prozent zu verlangen

Schließlich zurück auf die ursprüngliche Frage: Wenn Sie Code-Coverage-Standards gesetzt, was soll diese Zahl sein

Hoffentlich ist es an dieser Stelle klar, dass wir eine Angleichung reden zu beginnen, so dass jede Zahl, die wir von Natur aus ungefähren holen sein wird.

Einige Zahlen, die man könnte wählen:

  • 100% . Sie könnten diese wählen, weil Sie alles sicher sein wollen, getestet wird. Dies gibt Ihnen keinen Einblick in die Testqualität, aber tut Ihnen sagen, dass einige Test einiger Qualität jede Aussage (oder Zweig, etc.) berührt hat Auch dies kommt zurück, um Maß an Vertrauen: Wenn Ihre Berichterstattung unter 100% liegt Sie wissen einige Teilmenge des Codes ist nicht getestet.
    • Man könnte argumentieren, dass dieses dumme ist, und Sie sollten nur die Teile des Codes testen, die wirklich wichtig sind. Ich würde behaupten, dass Sie sollten auch nur die Teile des Codes halten, die wirklich wichtig sind. Codeabdeckung kann durch Entfernen nicht getesteten Code auch verbessert werden.
  • 99% (oder 95%, andere Zahlen in den hohen neunziger Jahre.) Geeignete in Fällen, in denen Sie ein Maß an Vertrauen vermitteln wollen ähnlich zu 100%, aber lassen Sie sich etwas Spielraum über die gelegentliche schwer zu Test Ecke von Code keine Sorgen zu machen.
  • 80% . Ich habe diese Nummer in Gebrauch ein paar Mal gesehen, und nicht vollständig wissen, wo es entsteht. I denken es könnte eine seltsame Veruntreuung der 80-20 Regel sein; im Allgemeinen ist es die Absicht, hier zu zeigen, dass die meisten des Codes getestet wird. (Ja, 51% wäre auch „die meisten“, aber 80% mehr reflektiert, was die meisten Menschen bedeuten von den meisten.) Das für Mittelgrund Fällen angemessen ist, wo „gut getestet“ nicht eine hohe Priorität (die Sie nicht wollen Aufwand auf niedrigen Wert Tests verschwenden), ist aber genug von einer Priorität, die Sie noch einige Standards an Ort und Stelle haben mögen.

Ich habe Zahlen nicht weniger als 80% in der Praxis gesehen, und habe eine harte Zeit einen Fall vorstellen, wo man sie einstellen würde. Die Rolle dieser Normen ist das Vertrauen in die Richtigkeit zu erhöhen und Zahlen unter 80% sind nicht besonders vertrauenerweckend. (Ja, das ist subjektiv, aber auch hier ist die Idee, die subjektive Wahl einmal zu machen, wenn Sie den Standard, und dann eine objektive Messung verwenden geht nach vorn.)

Andere Anmerkungen

Die oben geht davon aus, dass Korrektheit ist das Ziel. Codeabdeckung ist nur Informationen; es kann auf andere Ziele relevant sein. Zum Beispiel, wenn Sie über die Wartbarkeit betroffen sind, kümmern Sie wahrscheinlich über lose Kopplung, die durch Testbarkeit nachgewiesen werden kann, was wiederum kann (in bestimmten Moden) von Codeabdeckung gemessen werden. So Ihr Code-Coverage-standard liefert eine empirische Basis zur Annäherung an die Qualität der „Wartbarkeit“ als auch.

Meine Lieblingscodeabdeckung ist zu 100% mit einem Stern. Der Stern kommt, weil ich es vorziehen, Werkzeuge zu verwenden, die mir erlauben, bestimmte Linien als Linien zu markieren, die „nicht zählen“. Wenn ich 100% der Linien abgedeckt haben, die „count“, ich fertig bin.

Der zugrunde liegende Prozess ist:

  1. Ich schreibe meine Tests alle Funktionen und Rand Fällen auszuüben I (in der Regel arbeiten aus der Dokumentation) denken.
  2. Ich betreibe die Code-Coverage-Tools
  3. prüfen ich alle Linien oder Pfade nicht abgedeckt und alle, die ich nicht wichtig oder nicht erreichbar betrachten (durch defensive Programmierung) Ich markiere als nicht mitgerechnet
  4. Ich schreibe neue Tests die fehlenden Zeilen und zur Verbesserung der Dokumentation zu decken, wenn diese Grenzfälle nicht erwähnt werden.

Auf diese Weise, wenn ich und meine Mitarbeiter neuen Code hinzufügen oder die Tests in der Zukunft ändern, gibt es eine helle Linie, uns zu sagen, wenn wir etwas verpaßt wichtig - die Reichweite unter 100% gesunken. Aber es bietet auch die Flexibilität, mit verschiedenen Test Prioritäten zu befassen.

ich einen anderen anectode auf Testabdeckung haben würde Ich mag würde teilen.

Wir haben ein riesiges Projekt, bei über twitter, ich stellte fest, dass mit 700 Unit-Tests, wir nur haben 20% Code Coverage .

Scott Hanselman antwortete mit Worte der Weisheit :

  

Ist es die richtige 20%? Ist es das 20%   dass stellt den Code der Benutzer   trifft am meisten? Sie könnten hinzufügen 50   Tests und fügen Sie nur 2%.

Auch hier geht es zurück zu meinem

Wenn dies eine perfekte Welt, 100% des Code würde durch Unit-Tests abgedeckt werden. Da dies jedoch nicht eine perfekte Welt ist, ist es eine Frage dessen, was Sie Zeit für haben. Als Ergebnis empfehlen Fokussierung ich weniger auf einen bestimmten Prozentsatz, und mehr auf die kritischen Bereiche zu konzentrieren. Wenn Ihr Code gut geschrieben (oder zumindest eine angemessene Faksimile davon) sollte es mehrere wichtige Punkte, in denen APIs anderen Code ausgesetzt sind.

Konzentrieren Sie Ihre Testaufwände auf diesen APIs. Stellen Sie sicher, dass die APIs 1) sind gut dokumentiert und 2) Testfälle geschrieben, die die Dokumentation entsprechen. Wenn die erwarteten Ergebnisse nicht mit dem docs zusammenpassen, dann haben Sie einen Fehler in Ihren Code entweder, Dokumentation oder Testfällen. All das sind gut Tierarzt aus.

Viel Glück!

Für ein gut aufgebautes System, in der Unit-Tests, die Entwicklung von Anfang an getrieben haben würde ich sagen, 85% eine sehr geringe Zahl ist. Kleine Klassen entworfen prüfbar sein sollte nicht schwer sein, besser abzudecken als das.

Es ist einfach, diese Frage mit so etwas wie zu entlassen:

  • Covered Linien Logik nicht gleich getestet und man sollte zu viel in den Prozentsatz nicht lesen.

Das stimmt, aber es gibt einige wichtige Punkte, über Code Coverage gemacht werden. Nach meiner Erfahrung ist diese Metrik tatsächlich sehr nützlich, wenn richtig eingesetzt. Having said that, habe ich nicht alle Systeme gesehen, und ich bin sicher, es gibt Tonnen von ihnen, wo es schwer ist, um Code-Coverage-Analyse zu sehen einen wirklichen Wert hinzufügen. sieht so verschieden ist und der Umfang der zur Verfügung stehenden Testframework kann Code kann unterschiedlich sein.

Auch meine Argumentation betrifft vor allem der ganz kurzer Test Feedback-Schleifen. Für das Produkt, das ich auf die kürzeste Rückkopplungsschleife bin Entwicklung ist sehr flexibel und deckt alles von Tests, Klassenarbeiten zu Inter-Prozess-Signalisierung. typischerweise ein lieferbares Teilproduktes Testen dauert 5 Minuten und für eine so kurze Rückkopplungsschleife ist es in der Tat möglich, die Testergebnisse zu verwenden (und insbesondere die Code-Coverage-Metrik, die wir hier suchen) Commits im Repository abzulehnen oder anzunehmen.

Wenn die Code-Coverage-Metrik verwenden, sollten Sie nicht nur einen festen (beliebig) Prozentsatz aufweisen, die erfüllt werden müssen. Das Tun Sie nicht geben die wirklichen Vorteile von Code-Coverage-Analyse meiner Meinung nach. Stattdessen definieren Sie die folgenden Kennzahlen:

  • Low-Water-Mark (LWM), die niedrigste Zahl der ungedeckten Linien jemals in dem getesteten System gesehen
  • High Water Mark (HWM), der höchste Code-Coverage-Prozentsatz je für das zu testende System gesehen

Neuer Code kann nur hinzugefügt werden, wenn wir über dem LWM nicht gehen, und wir gehen nicht unter dem HWM. Mit anderen Worten, die Codeabdeckung ist nicht erlaubt, zu verringern und neuer Code soll abgedeckt werden. Beachten Sie, wie ich sagen soll und nicht muss (siehe unten).

Aber bedeutet dies nicht, dass es unmöglich sein wird alt bewährten Müll zu reinigen entfernt, die Sie für mehr keine Verwendung haben? Ja, und das ist, warum Sie über diese Dinge pragmatisch sein müssen. Es gibt Situationen, in denen die Regeln gebrochen werden, aber für die typische Tag zu Tag Integration meiner Erfahrung, dass diese Metriken sind sehr nützlich. Sie geben die folgenden zwei Auswirkungen.

  • Prüfbar Code wird gefördert. Wenn neuen Code hinzugefügt haben Sie wirklich anstrengen den Code testbar zu machen, weil Sie müssen versuchen, alles mit Ihrem Testfall zu decken. Prüfbaren Code ist in der Regel eine gute Sache.

  • Testabdeckung für Legacy-Code wird im Laufe der Zeit zu erhöhen. Wenn neuen Code hinzugefügt und nicht in der Lage, es mit einem Testfall abzudecken, kann man versuchen, einig Legacy-Code zu decken, anstatt um die LWM Regel zu bekommen. Dies kann manchmal notwendig Betrug zumindest gibt den positiven Nebeneffekt, dass die Abdeckung von Legacy-Code im Laufe der Zeit erhöhen, so dass die scheinbar strenge Durchsetzung dieser Regeln ganz pragmatisch in der Praxis.

Und wieder, wenn die Rückkopplungsschleife zu lang ist, kann es zu Setup so etwas wie dies in dem Integrationsprozess vollständig unpraktikabel sein.

Ich möchte auch zwei weitere allgemeine Vorteile des Code-Coverage-Metrik nennen.

Und eine negative, auf Vollständigkeit.

  • In einem großen Projekt mit vielen beteiligten Entwicklern, jeder wird nicht ein Test-Genie sicher sein. neigen einige Menschen die Code-Coverage-Metrik als Beweis zu verwenden, dass der Code getestet wird, und das ist sehr weit von der Wahrheit , wie in vielen der anderen Antworten auf diese Frage erwähnt. Es ist eine Metrik, die Sie ein paar nette Vorteile geben kann, wenn sie richtig verwendet werden, aber wenn es missbraucht wird es in der Tat kann zu schlechten Tests führen. Abgesehen von den sehr wertvollen Nebenwirkungen über eine überdachte Linie erwähnt zeigt nur, dass das System im Test dieser Linie für einige Eingangsdaten erreichen kann und dass es ausführen kann, ohne aufzulegen oder abstürzt.

85% wäre ein guter Ausgangspunkt für checkin Kriterien sein.

Ich würde wählte wahrscheinlich eine Vielzahl von höheren Bars Versandkriterien - abhängig von der Kritikalität der Teilsysteme / Komponenten getestet werden

.

Viele Geschäfte nicht Wert-Tests, wenn Sie also über Null zumindest gibt es eine gewisse Wertschätzung wert -. So wohl nicht Null ist nicht schlecht, wie viele sind noch Null

In der .NET-Welt zitieren die Menschen oft 80% als reasonble. Aber sie sagen, dass dies auf Lösungsebene. Ich ziehe es auf Projektebene messen: 30% könnte für UI-Projekt in Ordnung sein, wenn Sie Selen, etc oder manuelle Tests haben, 20% für die Datenschicht Projekt in Ordnung sein könnte, aber 95% + könnte für das Geschäft durchaus erreichbar sein Regeln Schicht, wenn nicht ganz notwendig. So ist die Gesamtabdeckung sein kann, sagen, 60%, aber die kritische Business-Logik kann viel höher sein.

aspire zu 100% und Sie erhalten 80% schlagen;:

Ich habe auch dieses gehört aber danach streben, zu 80%, und Sie werden 40% betroffen.

Fazit: Übernehmen Sie die 80:20 Regel und lassen Fehler Ihrer App zählen Sie führen

.

Ich benutze cobertura, und was auch immer der Prozentsatz, würde ich empfehlen, die Werte in der cobertura-Prüfaufgabe up-to-date zu halten. Im Minimum hält totallinerate und totalbranchrate Erhöhung unter Ihrer aktuellen Berichterstattung nur, aber nie , diese Werte senken. bindet auch in der Ant-Build-Ausfall-Eigenschaft auf diese Aufgabe. Wenn die Erstellung wegen des Mangels an Berichterstattung ausfällt, wissen Sie jemand Code hinzugefügt, hat es aber nicht getestet. Beispiel: 

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

Wenn ich denke, mein Code ist nicht genug Einheit getestet, und ich bin mir nicht sicher, was als nächstes zu testen, verwende ich Abdeckung mir, um zu entscheiden, was als nächstes zu prüfen.

Wenn ich Abdeckung in einem Unit-Test erhöhen -. Ich weiß, das Gerät zu testen etwas wert

Dies gilt für Code, der nicht bedeckt ist, 50% abgedeckt oder 97% abgedeckt.

Code-Coverage ist nur eine andere Metrik. An und für sich, es kann sehr irreführend sein (siehe www.thoughtworks .com / Einblicke / Blog / sind Test-coverage-Metriken-hoch genug ). Ihr Ziel sollte es daher nicht 100% Codeabdeckung zu erreichen, sondern um sicherzustellen, dass Sie alle relevanten Szenarien der Anwendung testen.

Wenn Sie schon für eine anständige Menge an Zeit, Unit-Tests getan, sehe ich keinen Grund für sie nicht mehr als 95% + zu nähern. Jedoch auf einem Minimum, ich habe immer mit 80% gearbeitet, auch wenn neue Tests.

Diese Zahl sollte nur Code enthält, in dem Projekt geschrieben (ausgenommen Frameworks, Plugins, etc.) und vielleicht sogar bestimmte Klassen ganz von Code von Anrufen außerhalb Code geschrieben komponiert auszuschließen. Diese Art von Anruf sollte verspottet / stubbed werden.

Im Allgemeinen von den mehr Engineering Excellence Best Practices Papieren, die ich gelesen habe, 80% für neuen Code in Unit-Tests ist der Punkt, der die beste Rendite ergibt. Gehen über dem CC% ergibt sich eine geringere Menge von Fehlern für den Aufwand ausgeübt. Dies ist eine bewährte Methode, die von vielen großen Unternehmen eingesetzt wird.

Leider sind die meisten dieser Ergebnisse intern zu Unternehmen, so gibt es keine öffentlichen Literaturen, die ich zeigen können Sie auf.

Code-Abdeckung ist groß, aber nur so lange, wie die Vorteile, die Sie von ihm bekommen schwerer wiegen als die Kosten / Aufwand es zu erreichen.

Wir haben seit einiger Zeit zu einem Standard von 80% arbeiten, aber wir haben gerade den decison diese zu verlassen und stattdessen seine mehr auf unseren Tests. Die Konzentration auf die komplexen Business-Logik usw.,

Diese Entscheidung wurde aufgrund der zunehmenden Menge Zeit in Anspruch genommen wir Code Coverage verbringen jagen und bestehende Unit-Tests zu halten. Wir haben das Gefühl wir an den Punkt gekommen waren, wo der Nutzen, den wir waren von unserer Code-Coverage erhalten wurde als kleiner sein als der Aufwand, den wir in setzen mussten, um es zu erreichen.

Ich ziehe BDD zu tun, die eine Kombination von automatisierten Abnahmetests verwendet, möglicherweise auch andere Integrationstests und Unit-Tests. Die Frage für mich ist es, was die angestrebte Abdeckung der automatisierten Testsuite als Ganze sein sollte.

Davon abgesehen, hängt die Antwort auf Ihre Methodik, die Sprache und das Testen und Coverage Tools. Wenn TDD in Ruby oder Python zu tun ist es nicht schwer 100% Abdeckung zu halten, und es lohnt sich zu tun. Es ist viel einfacher zu 100% Abdeckung zu verwalten als 90-something Prozent Deckung. Das heißt, es ist viel einfacher, Deckungslücken zu füllen, wie sie erscheinen (und wenn Lücken TDD gut Berichterstattung zu tun sind selten und in der Regel Ihrer Zeit wert ), als es ist, eine Liste von Deckungslücken zu verwalten, die Sie nicht um aufgrund Ihres konstanten Hintergrund von ungedecktem Code und Fehlschlagabdeckung Regressionen bekommen haben.

Die Antwort hängt auch von der Geschichte des Projekts. Ich habe festgestellt, nur die oben in Projekten praktisch zu sein, dass die Art und Weise von Anfang an geführt werden. Ich habe stark die Abdeckung großer Legacy-Projekte verbessert, und es lohnt sich schon so zu tun, aber ich habe es nie gefunden praktisch zurück zu gehen und jede Abdeckung Lücke zu füllen, weil alte ungetesteten Code ist genug nicht gut verstanden, so richtig zu tun und schnell.

Schauen Sie sich Crap4j . Es ist ein etwas anspruchsvollere Ansatz als gerade Codeabdeckung. Es kombiniert Code-Coverage-Messungen mit Komplexität Messungen, und dann sehen Sie, was komplexer Code ist derzeit nicht getestet.

Meine Antwort auf dieses Rätsel ist 100% -Linie Abdeckung des Codes haben Sie testen können, und 0% -Linie Abdeckung des Codes kann man nicht testen.

in Python Meine derzeitige Praxis ist meine Py-Module in zwei Ordner zu teilen: app1 / und app2 / und beim Ausführen von Unit-Tests die Erfassung dieser beiden Ordner und visuell zu überprüfen, berechnen (I muss automatisieren dies ein Tag), dass app1 hat 100% Abdeckung und app2 hat 0% Deckung.

Wenn / wenn ich finde, dass diese Zahlen von Standard abweichen ich investigage und das Design des Codes ändern, so dass die Berichterstattung der Norm entspricht.

Das bedeutet, dass ich empfehlen kann 100% -Linie Abdeckung des Bibliothekscode zu erreichen.

ich gelegentlich auch app2 / um zu sehen, wenn ich könnte möglich Test enthaltener Code dort, überprüfen und wenn ich kann ich es bewegen in app1 /

Jetzt bin ich nicht allzu besorgt über die Gesamtdeckung, weil das wild in Abhängigkeit von der Größe des Projektes kann variieren, aber im Allgemeinen habe ich 70% auf über 90% gesehen.

Mit Python, soll ich in der Lage sein, einen Rauchtest zu entwickeln, die automatisch meine app laufen konnten, während Berichterstattung Messen und hoffentlich eine aggreagate von 100% gewinnen, wenn den Rauchtest mit Unittest Figuren kombiniert werden.

Viewing Abdeckung aus einer anderen Perspektive: Gut geschriebener Code mit einem klaren Ablauf der Steuerung ist die am einfachsten zu decken, die am einfachsten zu lesen, und in der Regel der am wenigsten fehlerhafte Code. Durch das Schreiben von Code mit Klarheit und Überdeckbarkeitsgraph im Auge, und durch die Unit-Tests parallel mit dem Code zu schreiben, können Sie die besten Ergebnisse IMHO erhalten.

Meiner Meinung nach, ist die Antwort „Es hängt davon ab, wie viel Zeit Sie haben“. Ich versuche, 100% zu erreichen, aber ich weiß nicht viel Aufhebens machen, wenn ich es nicht mit der Zeit bekommen ich habe.

Wenn ich Unit-Tests schreiben, trage ich einen anderen Hut gegenüber dem Hut, den ich trage, wenn die Produktion Code zu entwickeln. Ich denke, über das, was der getesteten Code behauptet zu tun, und was sind die Situationen, die es möglich brechen können.

ich in der Regel die folgenden Kriterien oder Regeln folgen:

  1. Dass die Einheit Test eine Form der Dokumentation auf, was das erwartete Verhalten meines Codes, dh sein sollte. die erwartete Ausgabe einen bestimmten Eingang gegeben und die Ausnahmen kann es werfen, dass die Kunden fangen möchten (Was Nutzer meines Code sollte wissen?)

  2. Dass die Einheit Test soll mir das, was, wenn die Bedingungen entdecken helfen, die ich noch nicht von mag gedacht haben. (Wie mein Code stabil und robust machen?)

Wenn diese beiden Regeln nicht zu 100% Deckung produzieren dann soll es so sein. Aber einmal, ich habe die Zeit, analysiere ich die unbedeckten Blöcke und Linien und bestimmen, ob es noch Testfälle ohne Unit-Tests sind oder wenn der Code muss Refactoring werden, um die unnötigen Codes beseitigen.

Es hängt stark von Ihrer Anwendung. Zum Beispiel bestehen einige Anwendungen meist von GUI-Code, der nicht als Einheit getestet werden kann.

Ich glaube nicht, es kann so eine B / W Regel sein.
Code sollte mit besonderer Aufmerksamkeit auf die kritischen Details überprüft werden.
wenn es wurde jedoch nicht getestet worden ist, hat es einen Fehler!

Kurze Antwort: 60-80%

Lange Antwort: Ich denke, es hängt ganz von der Art des Projektes. Ich beginne normalerweise ein Projekt durch die Einheit jedes praktisches Stück zu testen. Mit der ersten „Freigabe“ des Projektes sollen Sie eine ziemlich gute Basis Prozentsatz von der Art der Programmierung auf Basis haben Sie tun. An diesem Punkt können Sie „Erzwingen“ eine Mindestcodeabdeckung starten.

Je nach Kritikalität des Codes, überall von 75% bis 85% ist eine gute Faustregel. Versand Code sollte auf jeden Fall getestet gründlicher als im Haus Nebenkosten, usw.

Dies muss davon abhängen, in welcher Phase Ihres Anwendungsentwicklungslebenszyklus Sie sich befinden.

Wenn Sie schon eine Weile in der Entwicklung sind und bereits viel Code implementiert haben und gerade erst erkennen, dass Sie über die Codeabdeckung nachdenken müssen, müssen Sie Ihre aktuelle Abdeckung überprüfen (falls vorhanden) und diese Baseline dann verwenden Setzen Sie bei jedem Sprint Meilensteine ​​(oder einen durchschnittlichen Anstieg über einen Zeitraum von Sprints), was bedeutet, dass Sie Codeschulden übernehmen und gleichzeitig weiterhin einen Mehrwert für den Endbenutzer liefern (zumindest meiner Erfahrung nach ist es dem Endbenutzer egal, ob Sie den Test erhöht haben). Abdeckung, wenn sie keine neuen Funktionen sehen).

Abhängig von Ihrer Domain ist es nicht unvernünftig, auf 95 % zu zielen, aber ich würde sagen, im Durchschnitt werden Sie mit einem durchschnittlichen Fall von 85 % bis 90 % rechnen.

Ich denke, die beste Symptom der richtigen Code-Coverage ist die Menge an konkreten Problemen Unit-Tests zu beheben helfen, entspricht einem angemessenen Verhältnis zu Größe von Unit-Tests Code, den Sie erstellt.

Ich denke, dass die meisten, was kann Materie ist zu wissen, was die Berichterstattung Trend im Laufe der Zeit und das Verständnis der Gründe für die Veränderungen im Trend. Egal, ob Sie die Änderungen im Trend, wie gut oder schlecht ist, hängt von Ihrer Analyse des Grundes anzuzeigen.

Wir zielten> 80% bis wenige Tage zurück, aber nachdem wir eine Menge erzeugten Code verwendet, Wir interessieren uns nicht für% Alter, sondern Kritiker Anruf übernehmen die Abdeckung erforderlich ist.

Von der Testivus Posting Ich denke, die Antwort Kontext der zweite Programmierer sein sollte. sagte, dies von einem praktischen Standpunkt aus gesehen haben wir Parameter / Ziele müssen streben. Ich denke, dass dies „getestet“ in einem agilen Prozess wird, indem man den Code analysieren wir die Architektur, Funktionalität (User Stories), und dann mit einer Reihe kommen. Aufgrund meiner Erfahrung im Telecom-Bereich würde ich sagen, dass 60% ist ein guter Wert zu überprüfen.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top