Am Ende dieser Einheit können Sie:

1. C0 (Statement) und C1 (Branch) Coverage von Hand berechnen
2. genau benennen, was als Statement zählt – und was nicht (Kommentare, Docstrings, Leerzeilen)
3. einen pytest-cov-Bericht lesen (Stmts, Miss, Branch, BrPart, Cover)
4. erklären, warum 100 % C0 ≠ 100 % C1 ist
5. die Grenzen von Coverage richtig einordnen

Roter Faden: Wir messen nicht nur Prozente – wir verstehen, wie sie zustande kommen.

Menschen schätzen schlecht, wie viel sie getestet haben. Coverage macht es messbar.

Coverage = (vom Test ausgeführte Elemente / alle Elemente) × 100 %

• Eine Zahl statt Bauchgefühl (z. B. 72 %, 88 %, 100 %)
• Zeigt konkrete Zeilennummern, die ungetestet sind
• Sagt, wo noch Testfälle fehlen

Coverage misst Ausführung, nicht Korrektheit. Hohe Coverage ≠ fehlerfreier Code – dazu später mehr.

Kernidee: Coverage ist immer Coverage eines Modells. Anderes Modell → anderes Kriterium.

Statement Coverage (C0): Jede ausführbare Anweisung mindestens einmal ausführen.

C0 = (ausgeführte Statements / alle Statements) × 100 %

• Modell: CFG, Knoten = Statements
• Schwächstes strukturelles Kriterium – nur die Basis
• Aber: Was genau ist „eine Anweisung"? Genau hier irren sich die meisten ⟶

Alle Zahlen auf den nächsten Folien stammen aus echten coverage.py-Läufen (code_examples/coverage/).

 1  """Modul-Docstring."""              ·  kein Statement
 7  import math  # Inline-Kommentar     ▸  zählt (wegen import)
10  # Block-Kommentar                   ·  kein Statement
22  def addiere(a, b=2):                ▸  zählt
26      """Funktions-Docstring."""      ·  kein Statement
27      # Kommentar im Körper           ·  kein Statement
28      summe = a + b                   ▸  zählt

Legende: ▸ = Statement (zählt für C0) · · = kein Statement

Ein Inline-Kommentar macht eine Zeile nicht „zählbar" – der Code davor tut es.

17  def deko(fn):              ▸ zählt – „covered" schon beim Import
42  def nie_aufgerufen():      ▸ zählt – „covered" schon beim Import
43      """..."""              · kein Statement
44      wert = 1               ✗ FEHLT  (Funktion nie aufgerufen)
45      return wert            ✗ FEHLT

• Die def-/class-Zeile wird beim Definieren ausgeführt, nicht beim Aufruf.
• nie_aufgerufen wird nie getestet – trotzdem ist die def-Zeile abgedeckt, nur der Körper fehlt.

22  def addiere(        ▸ 1 Statement (die ganze Signatur)
23      a,              · gehört zu Zeile 22
24      b=2,            ·
25  ):                  ·
48  CONFIG = {          ▸ 1 Statement (das ganze Literal)
49      "a": 1,         ·
50      "b": 2,         ·
51  }                   ·

Ergebnis was_zaehlt.py: 16 Statements, 14 ausgeführt, 2 fehlen
→ C0 = 14 / 16 = 88 %

"""Begrüßung."""        # Zeile 1

def gruss(name):        # Zeile 3
    # baue die Nachricht
    text = f"Hallo {name}"
    return text         # Zeile 6

Frage an Sie: Wie viele ausführbare Statements zählt coverage.py hier?

→ Lösung: 3 — die Zeilen def gruss, text = …, return text. Docstring (1) und Kommentar zählen nicht.

def verarbeite(daten, pruefen=True):
    if pruefen:
        daten = daten.strip()
    return daten.upper()

Merke: Volle Statement-Coverage kann ganze Branches übersehen. Deshalb ist C1 stärker.

def rabatt(betrag, mitglied):
    if betrag <= 0:
        return 0
    if mitglied:
        return betrag * 0.9
    return betrag

Test: nur rabatt(100, True)

→ Lösung: 6 Statements (def, 2× if, 3× return). Ausgeführt: 4 — def, beide if, return betrag * 0.9. Nicht ausgeführt: return 0, return betrag.
C0 = 4 / 6 = 67 % · C1 = 2 / 4 = 50 % (je nur eine Kante pro if).

Path Coverage
   ⊃  subsumiert
Branch Coverage (C1)
   ⊃
Statement Coverage (C0)
   ⊃
Function Coverage

Praxis: C1 statt C0+C1 messen. Ziel im Unit-Test: 70–80 %+ C1.

# Statement-Coverage + fehlende Zeilen
uv run pytest --cov=. --cov-report=term-missing

# zusätzlich Branch-Coverage (C1)
uv run pytest --cov=. --cov-branch --cov-report=term-missing

• --cov=<paket> — was gemessen wird
• --cov-report=term-missing — zeigt fehlende Zeilennummern
• --cov-branch — schaltet Branch-Coverage ein

Name     Stmts Miss Branch BrPart Cover Missing
grade.py     6    1     4      1   80%   8

- name: Tests mit Coverage
  run: uv run pytest --cov=. --cov-report=term-missing --cov-fail-under=70

• --cov-fail-under=70 lässt die CI fehlschlagen, wenn Coverage < 70 %
• Verhindert, dass die Coverage unbemerkt sinkt
• Richtwerte: 70 % Minimum · 80 % gut · 90 % sehr gut · 100 % selten sinnvoll

1. Alle Entscheidungspunkte auflisten (if, while, for, …)
2. Pro Entscheidung beide Ergebnisse erzeugen (True und False)
3. Schleifen: 0 / 1 / mehrere Durchläufe
4. Alle Rückgabewege (frühe Returns, Exceptions)
5. Coverage erneut messen und prüfen

Rückwärts denken: „Welche Eingabe macht diese Bedingung True? Welche False?"

def teile(a, b):
    return a / b          # Bug: b == 0 nicht behandelt

def test_teile():
    assert teile(10, 2) is not None   # schwache Assertion

• 100 % Coverage – und der Bug bleibt: schwache Assertion, b=0 ungetestet
• Coverage zeigt Lücken, garantiert aber keine Korrektheit
• Ergänzen mit Äquivalenzklassen & Grenzwerten