Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen Revision Vorhergehende Überarbeitung
modul:m450:learningunits:lu02:coverage [2024/10/01 10:54] – msutermodul:m450:learningunits:lu02:coverage [2026/11/11 10:54] (aktuell) – Überarbeitet: fachliche Fehler bei Zweig- und Bedingungsabdeckung korrigiert, durchgerechnetes Beispiel, Mehrfachbedingung, Grenzen, coverage.py, Kontrollfragen admin
Zeile 1: Zeile 1:
 ====== LU02c - Test Coverage ====== ====== LU02c - Test Coverage ======
-//Siehe auch [[https://www.browserstack.com/guide/test-coverage-techniques|BrowserStack - Test Coverage Techniques]]// +<WRAP center round info 80%> 
- +**Auf einen Blick**\\ 
-<WRAP center round info 60%> +Die Testabdeckung (Coverage) misst, welcher Anteil einer Software durch die Testfälle tatsächlich geprüft wurde. 
-Testabdeckung bezeichnet das Verhältnis zwischen den möglichen und den tatsächlich getesteten Teilen einer Software. +Die Codeabdeckung zählt zum Beispiel, wie viele Anweisungen, Zweige und Bedingungen bei allen Testfällen zusammen mindestens einmal ausgeführt wurden.
-Beispielsweise misst die Codeabdeckung das Verhältnis zwischen allen vorhandenen Codezeilen und den Codezeilen, die in allen Testfällen ausgeführt wurden.+
 </WRAP> </WRAP>
  
-Testabdeckung kann als Metrik in jeder Teststufe verwendet werden. +===== Lernziele ===== 
-Beim Unit-Test wird unter anderem der Prozentsatz der ausgeführten Codezeilen überprüft.+Sie können 
 +  * Funktions-, Anweisungs-, Zweig- und Bedingungsabdeckung unterscheiden, 
 +  * die Abdeckung für ein kleines Programm von Hand berechnen, 
 +  * gezielt Testfälle ergänzen, um die Abdeckung zu erhöhen, 
 +  * erklären, warum 100 % Abdeckung kein fehlerfreies Programm garantiert.
  
-===== Vorteile von Testabdeckung ===== +===== Wozu Testabdeckung? ===== 
-Wenn wir die Testabdeckung unserer Anwendung kontinuierlich messen, ergeben sich einige Vorteile:+  * **Lücken finden:** Wir sehen, welcher Code noch nie getestet wurde, und können gezielt Testfälle ergänzen. 
 +  * **Doppelspurigkeiten erkennen:** Testfälle, die genau dasselbe abdecken, lassen sich zusammenlegen. 
 +  * **Fortschritt messen:** Die Abdeckung ist eine einfache Kennzahl, um zu entscheiden, ob genug getestet wurde (Testende-Kriterium, siehe [[.:teststrategie|LU02a]]).
  
-  * **Früheres Erkennen**: Wir erkennen Lücken in unserer Anwendung oder in den Testfällen früher. Je früher wir ein Problem erkennen, desto einfacher ist es, es zu beheben. +Die Codeabdeckung gehört zum **Glassbox-Test**: Man braucht den Quellcode, um sie zu bestimmen. Sie wird vor allem bei Komponenten- und Integrationstests eingesetzt.
-  * **Redundanzen eliminieren**: Die Testabdeckung hilft uns, Redundanzen zu erkennen und zu beseitigen. +
-  * **Weniger Aufwand**: Eine bessere Testabdeckung bedeutet weniger Fehler in späteren Teststufen und in der Produktion. Dadurch verringert sich der Aufwand für die Fehlerbehebung und die Qualitätssicherung.+
  
-===== Code-Abdeckung (Code Coverage) ===== +===== Die Arten der Codeabdeckung ===== 
-Code Coverage ist für das White Box Testing in Unit- und Integrationstests von großer Bedeutung. +^ Abdeckung                                    ^ Frage                                                                 ^ Berechnung                                                 ^ 
-Mit Hilfe von Werkzeugen wird gemessen, wie vollständig der Code getestet wurde. +| **Funktionsabdeckung** (Function Coverage)   | Wurde jede Funktion mindestens einmal aufgerufen?                     | aufgerufene Funktionen ÷ alle Funktionen                   | 
-Eine hohe Code Coverage erhöht die Wahrscheinlichkeit, dass Fehler frühzeitig erkannt und behoben werden. +| **Anweisungsabdeckung** (Statement Coverage) | Wurde jede Anweisung mindestens einmal ausgeführt?                    | ausgeführte Anweisungen ÷ alle Anweisungen                 | 
-Darüber hinaus helfen Kennzahlen zur Codeabdeckung zu erkennen, welche zusätzlichen Testfälle benötigt werden.+| **Zweigabdeckung** (Branch Coverage)         | Wurde bei jeder Verzweigung jeder Weg mindestens einmal genommen?     | genommene Zweige ÷ alle Zweige                             | 
 +| **Bedingungsabdeckung** (Condition Coverage) | Hat jede (Teil-)Bedingung mindestens einmal ''true'' und einmal ''false'' ergeben? | aufgetretene Ergebnisse ÷ (2 × Anzahl Bedingungen) |
  
-Die Code Coverage setzt sich aus mehreren Ebenen zusammen. +Die Arten sind von schwach nach stark geordnet: 100 % Zweigabdeckung schliesst 100 % Anweisungsabdeckung ein, aber nicht umgekehrt.
-==== Anweisungsabdeckung (Statement Coverage) ==== +
-Die Anweisungsabdeckung misst, wieviel Prozent der Anweisungen im Sourcecode ausgeführt wurden.+
  
-==== Zweigabdeckung (Branch Coverage) ==== +===== Anweisung oder Zweig? ===== 
-Die Zweigabdeckung misst, ob bei jeder Entscheidung innerhalb des Codes (if, while, until, switch, ...) jeder Zweig einmal durchgeführt wurde. +<WRAP group> 
- +<WRAP half column> 
-| <code python> +<code python> 
-num1 = int(input('Number >')) +zahl = int(input('Zahl > ')) 
-if num1 > 0: +if zahl > 0: 
-    print('valid') +    print('gültig') 
-</code> | <code python> +</code> 
-num1 = int(input('Number >')) +</WRAP> 
-if num1 > 0: +<WRAP half column> 
-    print('valid')+<code python> 
 +zahl = int(input('Zahl > ')) 
 +if zahl > 0: 
 +    print('gültig')
 else: else:
-    print('invalid') +    print('ungültig') 
-</code> |  +</code> 
-| Da es im Code nur einen Branch für ''if'' gibt, reicht ein einziger Testfall um eine Branch Coverage von 100% zu erreichen. | In diesem Beispielcode brauchen wir 2 Testfälle für ''if'' und ''else''. |+</WRAP> 
 +</WRAP>
  
 +^                       ^ Links (ohne ''else'')                                                             ^ Rechts (mit ''else'')                         ^
 +^ Anweisungsabdeckung 100 % | **1 Testfall** genügt, z. B. ''5'': Alle Anweisungen werden ausgeführt.       | **2 Testfälle**, z. B. ''5'' und ''-5''        |
 +^ Zweigabdeckung 100 %  | **2 Testfälle**: Auch der unsichtbare Weg «Bedingung ist ''false'', nichts passiert» ist ein Zweig. | **2 Testfälle**, z. B. ''5'' und ''-5''        |
  
-==== Bedingungsabdeckung (Condition Coverage) ==== +<WRAP center round important 80%> 
-Die Bedingungsabdeckung misst, ob jede (Teil-)Bedingung einmal mit ''true'' und einmal mit ''false'' ausgewertet wurde.+Ein ''if'' ohne ''else'' hat trotzdem zwei Zweige. Gerade der fehlende ''else''-Fall versteckt oft Fehler, zum Beispiel eine vergessene Fehlermeldung. 
 +</WRAP>
  
-| <code python> +===== Bedingungsabdeckung bei verknüpften Bedingungen ===== 
-num1 = int(input('Number >')) +Besteht eine Bedingung aus mehreren Teilbedingungen, die mit ''and'' oder ''or'' verknüpft sind, betrachtet die Bedingungsabdeckung **jede Teilbedingung einzeln**.
-if num1 > 0: +
-    print('valid') +
-</code> | <code python> +
-num1 = int(input('Number >')) +
-if num1 > 0: +
-    print('valid') +
-else: +
-    print('invalid') +
-</code> |  +
-| Auch wenn es im linken Beispiel keinen ''else''-Zweig gibt, müssen wir für die Decision Coverage beide möglichen Ergebnisse für die Bedingung prüfen. Beide Beispiele benötigen also 2 Testfälle. ||+
  
 <code python> <code python>
-num1 = int(input('Number >')) +zahl = int(input('Zahl > ')) 
-if num1 > 0 and num1 < 100: +if zahl > 0 and zahl < 100: 
-    print('valid')+    print('gültig')
 </code> </code>
  
-In diesem Beispiel haben wir eine verknüpfte Bedingung. +^ Testfall ^ ''zahl > 0'' ^ ''zahl < 100'' ^ Gesamt  ^ 
-Somit müssen wir alle 4 möglichen Kombinationen von ''true'' und ''false'' der Teilbedingungen testen: +| ''-5''   | false        | (wird nicht geprüft) | false | 
-^ ''num1 > 0'' ^ ''num1 < 100'' ^ +| ''150''  | true         | false          | false   | 
-| true | true | +| ''50''   | true         | true           | true    | 
-| true | false | + 
-| false | true | +  * **Bedingungsabdeckung:** Mit ''-5'' und ''150'' hat jede Teilbedingung einmal ''true'' und einmal ''false'' ergeben? Nein: ''zahl < 100'' war bei ''-5'' gar nicht an der Reihe. Mit ''150'' und ''50'' ist ''zahl < 100'' abgedeckt, mit ''-5'' und ''50'' ist ''zahl > 0'' abgedeckt. Alle drei Testfälle zusammen erreichen 100 %. 
-| false | false |+  * **Mehrfachbedingungsabdeckung:** Sie verlangt alle Kombinationen der Teilbedingungen. Die Kombination ''false''/''false'' ist hier aber unmöglich, weil keine Zahl gleichzeitig kleiner gleich 0 und grösser gleich 100 ist. Solche unmöglichen Kombinationen zählen nicht. 
 + 
 +<WRAP center round tip 80%> 
 +**Kurzschlussauswertung:** Python wertet ''and'' und ''or'' von links nach rechts aus und hört auf, sobald das Ergebnis feststeht. Ist bei ''and'' der linke Teil ''false'', wird der rechte gar nicht geprüft. Das muss man beim Zählen berücksichtigen. 
 +</WRAP> 
 + 
 +===== Durchgerechnetes Beispiel ===== 
 +<code python> 
 +def rabatt(alter, mitglied): 
 +    prozent = 0                       # A1 
 +    if alter < 16 or alter >= 65:     # B1: alter < 16, B2: alter >= 65 
 +        prozent = 50                  # A2 
 +    if mitglied:                      # B3 
 +        prozent = prozent + 10        # A3 
 +    return prozent                    # A4 
 +</code> 
 + 
 +Das Programm hat 4 Anweisungen (A1–A4), 4 Zweige (2 ''if'' mit je ''true'' und ''false'') und 3 Teilbedingungen (B1–B3). 
 + 
 +^ Testfälle                              ^ Anweisungen        ^ Zweige            ^ Bedingungen                                        ^ 
 +| T1: ''rabatt(70, True)''               | A1–A4: **4/4 = 100 %** | if1 true, if2 true: **2/4 = 50 %** | B1 false, B2 true, B3 true: **3/6 = 50 %** | 
 +| T1 + T2: ''rabatt(30, False)''         | **100 %**          | zusätzlich if1 false, if2 false: **4/4 = 100 %** | zusätzlich B2 false, B3 false: **5/6 ≈ 83 %** | 
 +| T1 + T2 + T3: ''rabatt(10, True)''     | **100 %**          | **100 %**         | zusätzlich B1 true: **6/6 = 100 %**             | 
 + 
 +Schon ein einziger Testfall erreicht 100 % Anweisungsabdeckung. Für die Bedingungsabdeckung braucht es drei, weil die Kinder (''alter < 16'') sonst nie geprüft würden. 
 + 
 +===== Schleifen ===== 
 +Auch ''while''- und ''for''-Schleifen enthalten eine Bedingung: 
 +  * ''true'': Der Schleifenkörper wird ausgeführt. 
 +  * ''false'': Die Schleife wird verlassen. Das passiert bei jeder Schleife, die endet. 
 + 
 +Für eine vollständige Abdeckung braucht es mindestens einen Testfall, bei dem der Schleifenkörper ausgeführt wird. Sinnvoll sind zusätzlich Testfälle, bei denen die Schleife **gar nicht**, **genau einmal** und **mehrmals** durchlaufen wird. 
 + 
 +===== Grenzen der Codeabdeckung ===== 
 +<WRAP center round important 80%> 
 +100 % Codeabdeckung heisst nicht, dass das Programm fehlerfrei ist. 
 +</WRAP> 
 +  * **Fehlender Code wird nicht entdeckt:** Hat die Programmiererin die Prüfung auf negative Beträge vergessen, gibt es dafür auch keine Zeile, die nicht abgedeckt wäre. Solche Fehler findet nur der Blackbox-Test. 
 +  * **Falsche Werte werden nicht entdeckt:** Ein Testfall kann eine Zeile ausführen, ohne das Ergebnis richtig zu prüfen. 
 +  * **Aufwand:** Die letzten Prozente sind oft sehr teuer. In der Praxis sind Zielwerte von 70–90 % üblich. 
 + 
 +===== Abdeckung automatisch messen ===== 
 +Von Hand ist das Zählen nur bei kleinen Programmen machbar (siehe [[.:aufgaben:coverage|LU02.A02 - Markieren mit dem Leuchtstift]]). 
 +In Python misst das Paket ''pytest-cov'' (basiert auf ''coverage.py'') die Abdeckung automatisch: 
 + 
 +<code bash> 
 +pip install pytest-cov 
 +pytest --cov=rabatt --cov-branch --cov-report=term-missing 
 +</code> 
 + 
 +Der Bericht zeigt pro Datei die Anweisungs- und Zweigabdeckung und listet die Zeilen auf, die nie ausgeführt wurden. 
 + 
 +===== Kontrollfragen ===== 
 +  - Warum genügt bei ''if'' ohne ''else'' ein Testfall für 100 % Anweisungsabdeckung, aber nicht für 100 % Zweigabdeckung? 
 +  - Wie viele Testfälle brauchen Sie mindestens für 100 % Bedingungsabdeckung bei ''if alter >= 18 and ausweis:''? Nennen Sie konkrete Werte. 
 +  - Ein Programm hat 100 % Zweigabdeckung und trotzdem einen Fehler. Wie ist das möglich? 
 +  - Welche drei Durchläufe einer Schleife sollte man testen?
  
-==== Funktionsabdeckung (Function Coverage) ==== +===== Quellen ===== 
-Die Funktionsabdeckung misst die Anzahl der ausgeführten Funktionen im Verhältnis zur Anzahl aller Funktionen.+  * [[https://www.browserstack.com/guide/test-coverage-techniques|BrowserStack - Test Coverage Techniques]] 
 +  * [[https://coverage.readthedocs.io/|coverage.py - Dokumentation]]
  
 ---- ----
  • modul/m450/learningunits/lu02/coverage.txt
  • Zuletzt geändert: 2026/11/11 10:54
  • von admin