03 Grundlagen des Testens: CFG Tracing Übung

December 2025 (4247 Words, 24 Minutes)

Neu: Interaktive Übung verfügbar!

Möchtest du deinen Fortschritt verfolgen und sofortiges Feedback erhalten? Probiere unsere neue interaktive Version mit Fortschrittsverfolgung, sofortigen Erklärungen und Punkteberechnung.

Interaktive Übung starten →

CFG Tracing Übung: Visualisierung von Statement- und Branch-Coverage

Einführung

Diese Übung hilft dir, Code-Coverage zu verstehen, indem du Testfälle durch Kontrollflussgraphen (CFGs) verfolgst. Durch die Visualisierung, welche Knoten (Anweisungen) und Kanten (Branches) abgedeckt werden, entwickelst du ein Gespür dafür, wie Coverage funktioniert.

Vorbereitung: Zuerst lesen

Bevor du diese Übung versuchst, studiere die folgenden Vorlesungsabschnitte:

Aus Kapitel 03 (Testtheorie und Coverage): Testtheorie & Coverage:

• Abschnitt 4: Code Coverage (C0 und C1) - CFG-Beispiele, Knoten/Kanten zählen
• Abschnitt 5: Systematischer Testentwurf für Branch Coverage - Tests aus CFGs ableiten

Fokusgebiete: CFGs lesen, Pfade verfolgen, C0 und C1 berechnen

Lernziele:

• Kontrollflussgraphen lesen und verstehen
• Testfallausführung durch einen CFG verfolgen
• Statement Coverage (C0) aus Knotenabdeckung berechnen
• Branch Coverage (C1) aus Kantenabdeckung berechnen
• Verstehen, warum C1 C0 subsumiert

Anleitung:

1. Studiere den Code und seinen zugehörigen CFG
2. Verfolge die gegebenen Testfälle durch den Graphen
3. Identifiziere, welche Knoten und Kanten abgedeckt werden
4. Berechne die Coverage-Prozentsätze
5. Klicke auf “Lösung anzeigen”, um deine Antwort zu überprüfen

Zeit: 35-45 Minuten für alle Übungen

Übung 1: Einfacher CFG - classify_number()

Code

def classify_number(x):
    if x > 0:           # Node 1 (decision)
        return "pos"    # Node 2
    elif x < 0:         # Node 3 (decision)
        return "neg"    # Node 4
    else:
        return "zero"   # Node 5

Kontrollflussgraph

flowchart TD
    START([Start]) --> N1{x > 0?}
    N1 -->|True| N2[return 'pos']
    N1 -->|False| N3{x < 0?}
    N3 -->|True| N4[return 'neg']
    N3 -->|False| N5[return 'zero']
    N2 --> END([End])
    N4 --> END
    N5 --> END

Testfall

def test_positive():
    assert classify_number(5) == "pos"

Fragen

1. Welche Knoten werden von diesem Test abgedeckt?
2. Welche Kanten werden von diesem Test abgedeckt?
3. Was ist die Statement Coverage (C0)?
4. Was ist die Branch Coverage (C1)?

Übung 2: Mehrere Testfälle

Code (gleich wie Übung 1)

def classify_number(x):
    if x > 0:
        return "pos"
    elif x < 0:
        return "neg"
    else:
        return "zero"

Testfälle

def test_positive():
    assert classify_number(5) == "pos"

def test_negative():
    assert classify_number(-3) == "neg"

Fragen

1. Verfolge beide Tests durch den CFG
2. Was ist die kombinierte C0?
3. Was ist die kombinierte C1?
4. Welcher Test fehlt noch für 100% Coverage?

def test_zero():
    assert classify_number(0) == "zero"

Übung 3: calculate_grade() - Mehrere Branches

Code

def calculate_grade(score):
    if score >= 90:         # Node 1
        return "A"          # Node 2
    elif score >= 80:       # Node 3
        return "B"          # Node 4
    elif score >= 70:       # Node 5
        return "C"          # Node 6
    elif score >= 60:       # Node 7
        return "D"          # Node 8
    else:
        return "F"          # Node 9

Kontrollflussgraph

flowchart TD
    START([Start]) --> N1{score >= 90?}
    N1 -->|True| N2[return 'A']
    N1 -->|False| N3{score >= 80?}
    N3 -->|True| N4[return 'B']
    N3 -->|False| N5{score >= 70?}
    N5 -->|True| N6[return 'C']
    N5 -->|False| N7{score >= 60?}
    N7 -->|True| N8[return 'D']
    N7 -->|False| N9[return 'F']
    N2 --> END([End])
    N4 --> END
    N6 --> END
    N8 --> END
    N9 --> END

Testfälle

def test_grade_A():
    assert calculate_grade(95) == "A"

def test_grade_B():
    assert calculate_grade(85) == "B"

Fragen

1. Verfolge beide Tests und markiere abgedeckte Knoten/Kanten
2. Berechne C0 und C1
3. Wie viele weitere Tests werden für 100% C1 benötigt?

def test_grade_C():
    assert calculate_grade(75) == "C"

def test_grade_D():
    assert calculate_grade(65) == "D"

def test_grade_F():
    assert calculate_grade(50) == "F"

Übung 4: C0 vs C1 Vergleich

Code

def check_eligibility(age, has_license):
    if age >= 18:               # Node 1
        if has_license:         # Node 2
            return "approved"   # Node 3
        return "need license"   # Node 4
    return "too young"          # Node 5

Kontrollflussgraph

flowchart TD
    START([Start]) --> N1{age >= 18?}
    N1 -->|True| N2{has_license?}
    N1 -->|False| N5[return 'too young']
    N2 -->|True| N3[return 'approved']
    N2 -->|False| N4[return 'need license']
    N3 --> END([End])
    N4 --> END
    N5 --> END

Testfälle

def test_approved():
    assert check_eligibility(25, True) == "approved"

def test_need_license():
    assert check_eligibility(20, False) == "need license"

Fragen

1. Was ist C0 für diese beiden Tests?
2. Was ist C1 für diese beiden Tests?
3. Ist C0 > C1, C0 < C1, oder C0 == C1?
4. Was sagt dir das über die Beziehung zwischen C0 und C1?

def test_too_young():
    assert check_eligibility(16, True) == "too young"

Übung 5: Verschachtelte Bedingungen

Code

def validate_password(password):
    if len(password) < 8:           # Node 1
        return "too short"          # Node 2

    has_upper = any(c.isupper() for c in password)  # Node 3
    has_digit = any(c.isdigit() for c in password)  # Node 4

    if not has_upper:               # Node 5
        return "need uppercase"     # Node 6
    if not has_digit:               # Node 7
        return "need digit"         # Node 8
    return "valid"                  # Node 9

Kontrollflussgraph

flowchart TD
    START([Start]) --> N1{len < 8?}
    N1 -->|True| N2[return 'too short']
    N1 -->|False| N3[has_upper = ...]
    N3 --> N4[has_digit = ...]
    N4 --> N5{not has_upper?}
    N5 -->|True| N6[return 'need uppercase']
    N5 -->|False| N7{not has_digit?}
    N7 -->|True| N8[return 'need digit']
    N7 -->|False| N9[return 'valid']
    N2 --> END([End])
    N6 --> END
    N8 --> END
    N9 --> END

Testfall

def test_valid_password():
    assert validate_password("SecurePass1") == "valid"

Fragen

1. Verfolge den Test durch den CFG
2. Berechne C0
3. Berechne C1
4. Liste ALLE Testfälle auf, die für 100% C1 benötigt werden

def test_too_short():
    assert validate_password("Short1") == "too short"  # len = 6

def test_need_uppercase():
    assert validate_password("lowercase1") == "need uppercase"

def test_need_digit():
    assert validate_password("NoDigitHere") == "need digit"

def test_valid():
    assert validate_password("SecurePass1") == "valid"

def test_too_short():
    assert validate_password("Short1") == "too short"

def test_need_uppercase():
    assert validate_password("lowercase1") == "need uppercase"

def test_need_digit():
    assert validate_password("NoDigitHere") == "need digit"

Übung 6: Early Returns

Code

def calculate_discount(amount, is_member, coupon_code):
    if amount <= 0:                     # Node 1
        return 0                        # Node 2

    discount = 0                        # Node 3

    if is_member:                       # Node 4
        discount += 10                  # Node 5

    if coupon_code == "SAVE20":         # Node 6
        discount += 20                  # Node 7
    elif coupon_code == "SAVE10":       # Node 8
        discount += 10                  # Node 9

    return amount * (discount / 100)    # Node 10

Kontrollflussgraph

flowchart TD
    START([Start]) --> N1{amount <= 0?}
    N1 -->|True| N2[return 0]
    N1 -->|False| N3[discount = 0]
    N3 --> N4{is_member?}
    N4 -->|True| N5[discount += 10]
    N4 -->|False| N6a[skip]
    N5 --> N6{coupon == 'SAVE20'?}
    N6a --> N6
    N6 -->|True| N7[discount += 20]
    N6 -->|False| N8{coupon == 'SAVE10'?}
    N7 --> N10[return calculated]
    N8 -->|True| N9[discount += 10]
    N8 -->|False| N10
    N9 --> N10
    N2 --> END([End])
    N10 --> END

Testfälle

def test_member_with_save20():
    result = calculate_discount(100, True, "SAVE20")
    assert result == 30  # 10% member + 20% coupon

def test_non_member_no_coupon():
    result = calculate_discount(100, False, None)
    assert result == 0  # No discounts

Fragen

1. Verfolge beide Tests durch den CFG
2. Welche Branches sind noch nicht abgedeckt?
3. Wie viele Tests werden für 100% C1 benötigt?

def test_invalid_amount():
    assert calculate_discount(0, True, "SAVE20") == 0

def test_save10_coupon():
    result = calculate_discount(100, False, "SAVE10")
    assert result == 10

Übung 7: Komplexe Bedingungen (Fortgeschritten)

Code

def approve_loan(income, credit_score, has_collateral):
    # Automatic rejection
    if income < 30000:                          # Node 1
        return "rejected: low income"           # Node 2

    if credit_score < 600:                      # Node 3
        return "rejected: poor credit"          # Node 4

    # Premium approval
    if income >= 100000 and credit_score >= 750:  # Node 5
        return "approved: premium"              # Node 6

    # Standard approval with collateral
    if credit_score >= 700 or has_collateral:   # Node 7
        return "approved: standard"             # Node 8

    return "manual review required"             # Node 9

Kontrollflussgraph

flowchart TD
    START([Start]) --> N1{income < 30k?}
    N1 -->|True| N2[rejected: low income]
    N1 -->|False| N3{credit < 600?}
    N3 -->|True| N4[rejected: poor credit]
    N3 -->|False| N5{income>=100k AND credit>=750?}
    N5 -->|True| N6[approved: premium]
    N5 -->|False| N7{credit>=700 OR collateral?}
    N7 -->|True| N8[approved: standard]
    N7 -->|False| N9[manual review]
    N2 --> END([End])
    N4 --> END
    N6 --> END
    N8 --> END
    N9 --> END

Testsuite

def test_premium_approval():
    assert approve_loan(150000, 800, False) == "approved: premium"

def test_standard_with_good_credit():
    assert approve_loan(50000, 720, False) == "approved: standard"

def test_standard_with_collateral():
    assert approve_loan(50000, 650, True) == "approved: standard"

Fragen

1. Berechne C0 und C1 für diese Testsuite
2. Welche Entscheidungsergebnisse sind NICHT abgedeckt?
3. Entwirf zusätzliche Tests um 100% C1 zu erreichen

def test_rejected_low_income():
    # Deckt N1 True, N2 ab
    assert approve_loan(20000, 750, True) == "rejected: low income"

def test_rejected_poor_credit():
    # Deckt N3 True, N4 ab
    assert approve_loan(50000, 500, True) == "rejected: poor credit"

def test_manual_review():
    # Deckt N7 False, N9 ab
    # Braucht: income >= 30k, credit >= 600 aber < 700, keine Sicherheit
    assert approve_loan(50000, 650, False) == "manual review required"

Übung 8: Entwirf deine eigenen Tests

Code

def process_order(total, user_type, promo_code):
    if total <= 0:                          # Node 1
        return "invalid order"              # Node 2

    base_discount = 0                       # Node 3

    if user_type == "premium":              # Node 4
        base_discount = 15                  # Node 5
    elif user_type == "member":             # Node 6
        base_discount = 5                   # Node 7

    if promo_code == "FLASH50":             # Node 8
        if total >= 100:                    # Node 9
            return f"discount: 50%"         # Node 10
        return "promo requires $100+"       # Node 11

    if base_discount > 0:                   # Node 12
        return f"discount: {base_discount}%"  # Node 13

    return "no discount"                    # Node 14

Herausforderung

Ohne einen fertigen CFG oder Tests, entwirf eine Testsuite, die erreicht:

1. 100% Statement Coverage (C0)
2. 100% Branch Coverage (C1)

Fragen

1. Zeichne den CFG (auf Papier oder verfolge ihn gedanklich)
2. Liste alle Entscheidungspunkte und ihre Branches auf
3. Entwirf die minimale Testsuite für 100% C1
4. Verifiziere deine Coverage indem du jeden Test verfolgst

# Test 1: Ungültige Bestellung (N1 True)
def test_invalid_order():
    assert process_order(0, "guest", None) == "invalid order"

# Test 2: Premium-Nutzer, keine Promo (N4 True, N8 False, N12 True)
def test_premium_no_promo():
    assert process_order(50, "premium", None) == "discount: 15%"

# Test 3: Mitglied-Nutzer, keine Promo (N4 False, N6 True, N12 True)
def test_member_no_promo():
    assert process_order(50, "member", None) == "discount: 5%"

# Test 4: Gast, FLASH50 Promo, hoher Betrag (N4 False, N6 False, N8 True, N9 True)
def test_flash50_high_total():
    assert process_order(150, "guest", "FLASH50") == "discount: 50%"

# Test 5: Gast, FLASH50 Promo, niedriger Betrag (N8 True, N9 False)
def test_flash50_low_total():
    assert process_order(50, "guest", "FLASH50") == "promo requires $100+"

# Test 6: Gast, keine Promo (N8 False, N12 False)
def test_guest_no_promo():
    assert process_order(50, "guest", None) == "no discount"

Zusammenfassung

Was du gelernt hast

Nach Abschluss dieser Übungen solltest du in der Lage sein:

• Kontrollflussgraphen zu lesen und zu interpretieren
• Testfallausführung durch Code-Pfade zu verfolgen
• Statement Coverage (C0) durch Zählen abgedeckter Knoten zu berechnen
• Branch Coverage (C1) durch Zählen abgedeckter Kanten zu berechnen
• Tests zu entwerfen, um spezifische Coverage-Ziele zu erreichen
• Zu verstehen, warum C1 C0 subsumiert

Wichtige Formeln

Statement Coverage (C0):

\(\text{C0} = \frac{\text{Ausgeführte Knoten}}{\text{Gesamte Knoten}} \times 100\%\)

Branch Coverage (C1):

\(\text{C1} = \frac{\text{Genommene Kanten}}{\text{Gesamte Entscheidungskanten}} \times 100\%\)

Häufige Muster

1. Early Returns erzeugen oft nicht abgedeckte Branches
2. Verschachtelte Bedingungen erfordern Tests für jede Kombination
3. Ein Testpfad deckt normalerweise ~30-50% der Branches ab
4. 100% C1 benötigt typischerweise einen Test pro eindeutigem Ergebnis

Was kommt als nächstes?

Fahre mit der Coverage Detective Übung fort, um das Analysieren echter pytest-cov Reports und das Entwerfen von Tests zur Abdeckung fehlenden Codes zu üben.