Menü

Tutorial zur Codeabdeckung: Zweig, Anweisung, Funktionsabdeckung

  • Haupt
  • Andere
  • Tutorial zur Codeabdeckung: Zweig, Anweisung, Funktionsabdeckung

code coverage tutorial

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

In diesem umfassenden Tutorial wird erläutert, was Code Coverage beim Testen von Software ist, welche Arten, Vor- und Nachteile es hat:

Das ultimative Ziel eines jeden Softwareentwicklungsunternehmens ist die Entwicklung von Software von guter Qualität. Um dieses Ziel zu erreichen, muss die Software gründlich getestet werden.

Das Testen ist daher ein wesentlicher Bestandteil der Entwicklung einer Softwareanwendung. Daher ist es wichtig, dass die entwickelte Software vom Entwickler überprüft wird (was während der Unit-Test-Phase durchgeführt wird) und dann an das QC-Team weitergeleitet wird, um gründlich getestet zu werden, um sicherzustellen, dass es nur minimale oder keine Fehler gibt.

Code-Abdeckung

Die Software wird einem Unit-Test unterzogen, bevor sie zum Testen an das eigentliche Testteam freigegeben wird. Da dieses Testen das Testen auf Codeebene umfasst, wird es vom Entwickler durchgeführt. Dies geschieht, um sicherzustellen, dass jeder Teil des zu testenden Codes wie erwartet funktioniert.

Hier werden kleine Codeblöcke, die entwickelt wurden, isoliert getestet, um ihre Richtigkeit sicherzustellen. Aber die Frage, die sich einem Entwickler oft stellt, ist Wie viel Unit-Test sollte durchgeführt werden? und die Antwort darauf liegt in der Code-Abdeckung.

In diesem Tutorial erfahren Sie genau, was Code Coverage ist und warum wir es brauchen. Sie werden erfahren, wie es sich von der Testabdeckung unterscheidet.

Wir werden uns auch die Tools und Methoden ansehen, die für die Codeabdeckung verwendet werden, und gegen Ende dieses Tutorials werden wir die Vorteile und die Nachteile sehen. Einige der mit Code Coverage verbundenen Mythen würden hier ebenfalls behandelt.

Was du lernen wirst:

Was ist Code-Abdeckung?

Code-Abdeckung

Dies ist eine wichtige Einheitentestmetrik. Es ist praktisch, die Wirksamkeit von Unit-Tests zu kennen. Dies ist eine Kennzahl, die angibt, wie viel Prozent des Quellcodes beim Testen ausgeführt werden.

In einfachen Worten, Das Ausmaß, in dem der Quellcode eines Softwareprogramms oder einer Anwendung während des Testens ausgeführt wird, wird als Code Coverage bezeichnet.

Wenn die Tests den gesamten Code einschließlich aller Zweige, Bedingungen oder Schleifen ausführen, würden wir sagen, dass alle möglichen Szenarien vollständig abgedeckt sind und die Codeabdeckung somit 100% beträgt. Um dies noch besser zu verstehen, nehmen wir ein Beispiel.

Im Folgenden wird ein einfacher Code angegeben, mit dem zwei Zahlen hinzugefügt und das Ergebnis abhängig vom Wert des Ergebnisses angezeigt werden.

Input a, b Let c = a + b If c <10, print c Else, print ‘Sorry’

Das obige Programm akzeptiert zwei Eingaben, d. H. 'A' und 'b'. Die Summe von beiden wird in der Variablen c gespeichert. Wenn der Wert von c kleiner als 10 ist, wird der Wert von 'c' gedruckt, andernfalls wird 'Sorry' gedruckt.

Wenn wir nun einige Tests haben, um das obige Programm mit den Werten von a & b so zu validieren, dass die Summe immer kleiner als 10 ist, wird der else-Teil des Codes nie ausgeführt. In einem solchen Szenario würden wir sagen, dass die Abdeckung nicht vollständig ist.

Dies war nur ein kleines Beispiel, um die Bedeutung von Code Coverage zu verdeutlichen. Wenn wir mehr erforschen, werden Sie mehr Klarheit darüber gewinnen.

Warum wir Code Coverage brauchen

Notwendigkeit einer Code-Abdeckung

(Bild Quelle ))

Verschiedene Gründe machen Code Coverage unerlässlich und einige davon sind unten aufgeführt:

wie man eine DVD kostenlos rippt
  • Es hilft festzustellen, dass die Software im Vergleich zu Software ohne gute Codeabdeckung weniger Fehler aufweist.
  • Durch die Unterstützung bei der Verbesserung der Codequalität wird indirekt die Bereitstellung einer besseren Qualitätssoftware unterstützt.
  • Es ist eine Maßnahme, mit der die Wirksamkeit des Tests ermittelt werden kann (Wirksamkeit der Unit-Tests, die zum Testen des Codes geschrieben wurden).
  • Hilft bei der Identifizierung der Teile des Quellcodes, die nicht getestet werden würden.
  • Es hilft festzustellen, ob die aktuellen Tests (Unit-Tests) ausreichend sind oder nicht und ob weitere Tests erforderlich sind.

Code Coverage Vs Test Coverage

CC gegen TC

Um den Unterschied zwischen Code Coverage und Test Coverage zu verstehen, verstehen wir zunächst die Bedeutung von Test Coverage.

Testabdeckung

Es ist ein Maß dafür, wie viele Teile der erwarteten Tests beim Testen einer Software abgedeckt wurden. Durch ‘Erwartete Tests’ Wir meinen den vollständigen Satz von Testfällen, die geschrieben wurden, um ausgeführt zu werden, um eine bestimmte Software zu testen.

Angenommen, zum Testen einer Software wurden insgesamt 500 Testfälle geschrieben. Jetzt wurden im Rahmen der Testaktivität nur noch 300 Testfälle ausgeführt. Nehmen wir an, dies liegt an Zeitmangel. In diesem Fall wäre das Folgende die Testabdeckung.

Testabdeckung = (Ausgeführte Testfälle / Gesamttestfälle) * 100
= (300/500) * 100
= 60%

Vergleichen wir dies mit der Code-Abdeckung.

Code-Abdeckung

Es ist eine Kennzahl, die zeigt, inwieweit ein Quellcode einer Anwendung beim Testen des Codes ausgeführt wird. Es zeigt somit, inwieweit ein Quellcode getestet werden würde.

Angenommen, um eine Anwendung mit 500 Codezeilen zu testen, werden nur 400 Codezeilen durch Tests ausgeführt. Nehmen wir an, dass dies darauf zurückzuführen ist, dass eine bestimmte Schleife / Bedingung nicht ausgeführt wird. In diesem Fall wäre das Folgende die Codeabdeckung.

Codeabdeckung = (Anzahl der ausgeführten Codezeilen / Gesamtzahl der Codezeilen) * 100
= (400/500) * 100
= 80%

Nachfolgend sind die Unterschiede zwischen Code Coverage und Test Coverage aufgeführt:

TestabdeckungCode-Abdeckung
Dies ist ein Maß dafür, wie viel Teil der erwarteten Tests beim Testen einer Software abgedeckt wurde.Es ist eine Kennzahl, die zeigt, inwieweit ein Quellcode einer Anwendung beim Testen des Codes ausgeführt wird.
Die Testabdeckung kann mit der folgenden Formel berechnet werden:

Testabdeckung = (Ausgeführte Testfälle / Gesamttestfälle) * 100		Die Codeabdeckung kann mit der folgenden Formel berechnet werden:

Codeabdeckung = (Anzahl der ausgeführten Codezeilen / Gesamtzahl der Codezeilen) * 100

Methoden

Hier werden wir die verschiedenen Methoden diskutieren, mit denen die Code-Abdeckung gemessen werden kann / kann.

Um diese Methoden zu verstehen, werfen wir einen Blick auf das folgende Codefragment:

Add (int a, int b) { If (b > a) { b = b - a Print b } If (a > b) { b = a – b Print b } Else Print ‘0’ }

Statement Coverage

Diese Methode gibt an, ob alle möglichen ausführbaren Codeanweisungen im Quellcode mindestens einmal ausgeführt wurden. Mit dieser Methode wird sichergestellt, dass jede Zeile des Quellcodes mindestens einmal von den Tests abgedeckt wird.

Dies mag einfach klingen, aber bei der Messung der Kontoauszugsabdeckung ist Vorsicht geboten. Der Grund dafür ist, dass in einem Quellcode möglicherweise eine bestimmte Bedingung vorliegt, die abhängig von den Eingabewerten möglicherweise nicht ausgeführt wird.

Dies würde bedeuten, dass nicht alle Codezeilen beim Testen abgedeckt würden. Daher müssen wir möglicherweise unterschiedliche Eingabewertsätze verwenden, um alle diese Bedingungen im Quellcode abzudecken.

doppelt verknüpftes Listen-C ++ - Tutorial

Zum Beispiel, Wenn im obigen Quellcode die Eingabewerte als 2 und 3 angenommen werden, wird der 'Else' -Teil des Codes nicht ausgeführt. Wenn die Eingabewerte jedoch vom Typ 3 und 2 sind, wird der If-Teil des Codes nicht ausgeführt.

Dies bedeutet, dass bei beiden Wertesätzen unserer Kontoauszugsdeckung die Deckung nicht 100% betragen würde. In einem solchen Fall müssen wir die Tests möglicherweise mit allen drei ((2, 3), (3, 2), (0, 0)) Werten ausführen, um eine 100% ige Anweisungsabdeckung sicherzustellen.

Funktionsabdeckung

Wie der Name schon sagt, misst diese Methode, inwieweit die im Quellcode enthaltenen Funktionen während des Testens abgedeckt werden. Alle Funktionen im Quellcode werden während der Testausführung getestet. Auch hier muss sichergestellt werden, dass wir diese Funktionen auf unterschiedliche Werte testen, damit die Funktion gründlich getestet wird.

In einem Quellcode kann es mehrere Funktionen geben, und abhängig von den verwendeten Eingabewerten kann eine Funktion aufgerufen werden oder nicht. Der Zweck der Funktionsabdeckung besteht daher darin, sicherzustellen, dass jede Funktion benötigt wird.

Zum Beispiel, Wenn unsere Tests im obigen Quellcode die Funktion 'Hinzufügen' auch nur einmal aufrufen, wird dies als vollständige Funktionsabdeckung bezeichnet.

Zustandsdeckung

In einem Quellcode, wo immer wir eine Bedingung haben, wäre das Ergebnis ein Boolescher Wert von entweder wahr oder falsch. Die Bedingungsabdeckung zielt darauf ab festzustellen, ob die Tests beide Werte abdecken, d. H. Richtig, falsch.

Wenn im Quellcode jede auftretende Bedingung sowohl für den wahren als auch für den falschen Zustand ausgewertet wird, gilt die Bedingungsabdeckung für den Code als vollständig.

Zum Beispiel, Wenn im obigen Code die Wertesätze (2, 3) und (4, 2) verwendet werden, beträgt die Bedingungsabdeckung 100%. Wenn der Datensatz (2, 3) verwendet wird, wird (b> a) als wahr und (a> b) als falsch ausgewertet. In ähnlicher Weise wird, wenn der Datensatz (4, 2) verwendet wird, (b> a) als falsch und (a> b) als wahr ausgewertet.

Somit haben beide Bedingungen beide Werte, d. H. Wahr und falsch, abgedeckt. Daher wäre die Zustandsabdeckung 100%.

Zweigstellenabdeckung

Diese Methode soll sicherstellen, dass jeder Zweig, der in jeder bedingten Struktur erscheint, im Quellcode ausgeführt wird. Im obigen Code sollten beispielsweise alle 'If' -Anweisungen und alle zugehörigen 'Else' -Anweisungen durch den Test für eine 100% ige Zweigabdeckung abgedeckt werden.

Zum Beispiel, Wenn im obigen Code die Wertesätze (2, 3), (4, 2), (1, 1) verwendet werden, beträgt die Zweigabdeckung 100%. Wenn Datensatz (2, 3) verwendet wird, wird (b> a) und der erste If-Zweig ausgeführt. Wenn der Datensatz (4, 2) verwendet wird, wird (a> b) als wahr ausgewertet und der zweite If-Zweig wird ausgeführt.

Mit dem Datensatz (1, 1) wird der Zweig 'Else' als wahr ausgewertet und ausgeführt. Dadurch wird eine 100% ige Filialabdeckung sichergestellt.

Branch Coverage Vs Condition Coverage

Die Zweigabdeckung wird häufig mit der Zustandsabdeckung verwechselt, die beiden sind jedoch unterschiedlich.

Lassen Sie uns dies anhand eines einfachen Beispiels verstehen.

If (a >0) & (b >0) Then Print “Hello” Else Print “Bye”

Schreiben wir den Datensatz auf, der für die Vervollständigung benötigt wird Branchenabdeckung:

(1, 1) - In diesem Fall sind 'a' und 'b' beide wahr, sodass die If-Bedingung ausgeführt wird.
(1, 0) - In diesem Fall ist 'a' wahr und 'b' wäre falsch, daher wird der andere Teil des Codes ausgeführt.

Wie wir wissen, besteht der Zweck der Zweigstellenabdeckung darin, jeden Zweig mindestens einmal auszuführen, und dieser Zweck wird erreicht.

Zustandsdeckung:

(1, 0) - In diesem Fall ist 'a' wahr und 'b' wäre falsch.
(0, 1) - In diesem Fall ist 'a' falsch und 'b' wäre wahr.

Der Zweck der Bedingungsabdeckung besteht darin, für jede ausgeführte Bedingung jeweils wahr und falsch zu erhalten, und dieser Zweck wird hier erreicht.

Haben Sie bemerkt, dass der else-Teil in Condition Coverage nicht ausgeführt wird? Hier unterscheidet sich die Zustandsabdeckung von der Zweigabdeckung.

Tools für die Codeabdeckung

Um die Codeabdeckung einer Software zu messen, stehen auf dem Markt verschiedene Tools zur Verfügung.

Nachfolgend sind einige der Tools aufgeführt, die Ihnen als Referenz dienen:

  • Parasoft JTest
  • Testwell CTC ++
  • Abdeckung
  • JaCoCo
  • CodeCover
  • BullseyeCoverage
  • EMMA
  • Offene Abdeckung
  • NCover
  • COCO zerquetschen
  • CoverageMeter
  • GCT
  • TCAT C / C ++
  • Gretel
  • JCov

Empfohlene Lektüre => Tools zur Codeabdeckung

Der obige Link enthält die folgenden Informationen zu diesen Tools:

  • Hauptmerkmale
  • Lizenz-Typ
  • Offizielle URL
  • Vor-und Nachteile
  • Letzte Version

Leistungen

Wie oben gezeigt, ist es aus den folgenden Gründen eine sehr nützliche Testmetrik:

  • Es hilft, diejenigen Bereiche in einem Quellcode zu identifizieren, die von den Tests nicht getestet / aufgedeckt würden.
  • Es ist praktisch, um verwendeten / toten Code zu identifizieren und dadurch die Codequalität zu verbessern.
  • Die Wirksamkeit der Unit-Tests kann mit Hilfe von Code Coverage ermittelt werden.
  • Mit diesen Metriken kann Software mit besserer Qualität geliefert werden.

Nachteile

  • Der Versuch, eine 100% ige Codeabdeckung anzustreben, führt manchmal zu einer mangelnden Robustheit der Tests, was dazu führt, dass die fehleranfälligen Szenarien nicht erfasst werden.
  • Im Gegensatz zur allgemeinen Wahrnehmung kann nicht garantiert werden, ob die entworfene Software alle Anforderungen erfüllt.

Mythen gegen Fakten

MythosTatsache
Durch eine 100% ige Codeabdeckung wird sichergestellt, dass die Software keine Fehler aufweist.Nein, eine 100% ige Codeabdeckung kann keine fehlerfreie Software garantieren. Eine gute Codeabdeckung in Verbindung mit guten Bemühungen des QC-Teams kann eine Software mit minimalen oder keinen Fehlern sicherstellen.
Eine 100% ige Codeabdeckung bedeutet, dass der geschriebene Code perfekt ist.Nein, in der Tat kann der Code nicht als perfekt bezeichnet werden, obwohl die Codeabdeckung 100% beträgt, wenn wichtige Anforderungen überhaupt nicht vom Code erfasst wurden.
Code Coverage misst die Wirksamkeit von Tests, die an einem Softwareprodukt durchgeführt werden.Nein, Code Coverage ist nur eine Maßnahme, mit der die Wirksamkeit von Komponententests getestet wird, d. H. Die Tests, die nur für den Quellcode einer Software ausgeführt werden.

FAQs

F # 1) Was ist eine akzeptable Code-Abdeckung?

Antworten: Das Erreichen einer 100% igen Codeabdeckung sollte nicht das Ziel beim Testen von Softwarecode sein. Aber warum nicht? Um den Grund zu verstehen, müssen Sie möglicherweise etwas tiefer tauchen, um die zugrunde liegende Bedeutung zu verstehen.

Wenn wir eine 100% ige Abdeckung anstreben, kommt es häufiger vor, dass der Schwerpunkt beim Entwerfen der Tests darauf liegt, sicherzustellen, dass jede Anweisung, Schleife, Verzweigung oder Bedingung getestet wird. Wir werden also zu viele Anstrengungen unternehmen, die sich angesichts der aufgewendeten Zeit möglicherweise nicht lohnen.

Darüber hinaus führt die Konzentration auf eine hohe Abdeckung auch dazu, dass wichtige Szenarien übersehen werden, in denen wahrscheinlich Fehler auftreten, da wir lediglich sicherstellen möchten, dass jede Codezeile getestet wird.

Die Konzentration auf eine hohe Codeabdeckung ist nicht immer so wichtig, und es kann auch keine feste Zahl sein, auf die zum Testen verschiedener Codes abgezielt werden soll. Im Allgemeinen sollte jedoch eine Abdeckung von 75% - 80% eine ideale Zahl sein.

Beim Testen unseres Codes sollte das Hauptaugenmerk darauf liegen, sicherzustellen, dass die kritischen und wahrscheinlich fehleranfälligen Szenarien abgedeckt werden. Wenn diese versäumt werden, haben unsere Tests trotz einer 100% igen Codeabdeckung einfach eine schlechte Testwirksamkeit.

Q # 2) Wie überprüfe ich meine Code-Abdeckung?

Antworten: Um den Prozentsatz der Codeabdeckung zu testen, den Sie möglicherweise durch die zum Testen des Codes entwickelten Tests erzielt haben, haben wir verschiedene Tools auf dem Markt. Abhängig von der verwendeten Programmiersprache haben wir verschiedene Werkzeuge.

Einige von ihnen sind unten aufgeführt:

  • Java - Berichterstattung, JaCoCo
  • Javascript - Blanket.js, Istanbul
  • Python - Coverage.py
  • Rubin - SimpleCov

Mit diesen Tools können wir einen vollständigen Bericht über unsere Tests erhalten, der uns hilft zu wissen, welcher Teil des Codes ausgeführt wird und welcher von unseren Tests übersehen wird.

Q # 3) Ist Code Coverage eine gute Metrik?

Antworten: In realen Szenarien ist dies bis zu einem gewissen Grad und auf bestimmte Weise nützlich.

Wenn wir uns zunächst die Einschränkungen ansehen, wissen wir sehr gut, dass eine 100% ige Abdeckung weder garantiert, dass der Code fehlerfrei ist, noch garantiert, dass alle Anforderungen im Code abgedeckt sind, dh trotz einer 100% igen Code-Abdeckung, die wir sind Es ist sehr wahrscheinlich, dass der Code Fehler enthält. Der Grund dafür ist, dass die Abdeckung nicht sicherstellt, dass alle Szenarien getestet wurden.

Wenn beim Schreiben des Codes Anforderungen übersprungen wurden, erfolgt keine Zuordnung der Anforderungen zu dem Code, der im Rahmen der Codeabdeckung berücksichtigt wird.

Kern Java Interview Fragen für erfahrene

Wir können jedoch nicht leugnen, dass wir bei der Verwendung von Code Coverage als Metrik eine Vorstellung davon bekommen, ob wir die grundlegenden Anforderungen zum Testen jeder Zeile unseres Codes abgedeckt haben. Dieser Prozentsatz der Abdeckung gibt uns eine Vorstellung davon, wie viele Teile unseres Codes mit unseren Komponententests ausgeführt werden.

Wir erfahren, wie viel von unserem Code nicht ausgeführt werden würde. Dies hilft uns wiederum zu entscheiden, wie viel mehr Unit-Tests benötigt werden und für welche Teile des Codes.

Wir können daher den Schluss ziehen, dass eine schlechte Abdeckung uns eine Vorstellung von der Unwirksamkeit der Komponententests gibt. Gleichzeitig ist die Gewährleistung einer 100% igen Abdeckung keine Garantie für einen fehlerfreien Code. Daher muss ein ausgewogener Ansatz verfolgt werden, bei dem die Bedeutung eines hohen Prozentsatzes der Codeabdeckung nicht überbetont wird.

Q # 4) Wie kann ich meine Codeabdeckung verbessern?

Antworten: Der Code-Coverage-Bericht, der von Coverage-Tools wie JaCoCo, Istanbul usw. bereitgestellt wird, zeigt die Bereiche, die von den Tests abgedeckt werden, und auch diejenigen, die ungetestet bleiben würden.

Wenn Sie die nicht getesteten Teile des Codes kennen, können Tests entweder manuell oder mit einem beliebigen Automatisierungstool geschrieben werden, um die Bereiche abzudecken, die sonst nicht getestet würden, und dadurch die Codeabdeckung zu erhöhen.

Eine wichtige Sache, die hier zu beachten ist, ist, dass wir zwar Hunderte von Codezeilen schreiben können, um eine Funktion im Code zu testen, die Abdeckung jedoch möglicherweise sehr gering ist. Der Grund dafür ist, dass ein zu tiefes Testen eines Teils des riesigen Codes nicht dazu beiträgt, die Codeabdeckung zu erhöhen.

Wenn das Ziel darin besteht, die Abdeckung zu erhöhen, muss darauf geachtet werden, alle Funktionen, Bedingungen und Schleifen abzudecken, anstatt tief in eine einzelne Funktion einzutauchen und große Tests für diese einzelne Funktion zu schreiben.

Fazit

In der heutigen schnelllebigen Internetwelt ist ein qualitativ hochwertiges Softwareprodukt erforderlich.

Die Sicherstellung einer qualitativ hochwertigen Software liegt nicht nur in der Verantwortung eines QS-Ingenieurs, sondern auch in der Verantwortung des Entwicklers. Code Coverage ist daher von großem Nutzen, wenn es darum geht, dem QS-Team von den Entwicklern ein Qualitätsprodukt zu liefern.

In diesem Tutorial wurde alles über Code Coverage und seine Verwendung erklärt. Wir haben uns auch etwas eingehender mit dem Unterschied zwischen Code Coverage und Test Coverage befasst. Außerdem haben wir ein Verständnis für die verwendeten Methoden und eine Vielzahl von Code Coverage-Tools erhalten.

Vor- und Nachteile wurden hier erläutert. Schließlich haben wir einige der Mythen und FAQs im Zusammenhang mit der Code-Berichterstattung beseitigt

Fröhliches Lesen!!

Literatur-Empfehlungen

^