⚠

Hinweis zur Privatsphäre: Wenn Sie sich mit Ihrem GitHub-Konto anmelden, werden Ihre Quiz-Versuche in Google Firebase gespeichert, damit Sie Ihren Fortschritt verfolgen können. Diese Daten sind nur für den Kursleiter einsehbar, werden nicht anderweitig weitergegeben und nach Semesterende gelöscht. Frühere Löschung auf Anfrage beim Kursleiter. Möchten Sie anonym bleiben? Nutzen Sie den Gastmodus oder ein GitHub-Konto ohne Ihren echten Namen.

Lädt...

Melden Sie sich an, um Ihren Fortschritt zu speichern und auf allen Geräten zu sehen.

● Fortschritt wird gespeichert

03 Quiz: Coverage Konzepte

Punkte: 0 / 20

Fragen-Übersicht

Offen Richtig Falsch

Anleitung

Dieses Quiz testet dein Verständnis der Code Coverage-Konzepte aus den Vorlesungen 6 und 7.

Vorbereitung: Zuerst lesen

Bevor du dieses Quiz versuchst, studiere die folgenden Vorlesungsabschnitte:

Aus Kapitel 03 (TDD und CI): TDD und CI:

Teil 2: Das Coverage-Problem - Warum wir Coverage brauchen
Teil 3: Coverage Reporting einrichten - pytest-cov Grundlagen
Teil 4: Coverage in CI integrieren - Schwellenwerte und Automatisierung

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

Abschnitt 3: Die Testtheorie - Programm, Modell, Testsuite, Coverage-Kriterium
Abschnitt 4: Code Coverage (C0 und C1) - Statement vs Branch Coverage, Subsumption

Warum dieses Quiz machen?

Für dein Lernen:

Selbsteinschätzung: Identifiziere Bereiche, in denen du ein gutes Verständnis hast, und Themen, die Wiederholung brauchen
Prüfungsvorbereitung: Das Quizformat und die Schwierigkeit spiegeln wider, was du in der Abschlussprüfung erwarten kannst
Sofortiges Feedback: Erhalte sofort Rückmeldung zu deinen Antworten
Aktives Erinnern: Dich selbst zu testen ist eine der effektivsten Lerntechniken

Richtlinien:

Jede Frage hat 4 Optionen mit genau einer richtigen Antwort
Versuche zuerst zu antworten, ohne auf die Vorlesungsmaterialien zu schauen
Melde dich mit GitHub an, um deinen Fortschritt zu speichern
Oder fahre als Gast fort (Fortschritt wird nicht gespeichert)

Bewertungsleitfaden

18-20 richtig: Ausgezeichnet! Starkes Verständnis von Coverage-Konzepten
15-17 richtig: Gutes Verständnis! Wiederhole die Bereiche, die du verpasst hast
12-14 richtig: Ausreichendes Verständnis. Schau dir die Vorlesungsmaterialien noch einmal an
9-11 richtig: Wiederholung nötig. Konzentriere dich auf Grundlagen
Unter 9: Bitte wiederhole Vorlesungen 6 und 7 sorgfältig

Frage1 Definitionen und Grundlagen

Statement Coverage (C0) misst:

A) Den Prozentsatz der Funktionen, die mindestens einen Test haben B) Den Prozentsatz der ausführbaren Code-Anweisungen, die von Tests ausgeführt werden C) Die Anzahl der Testfälle geteilt durch Codezeilen D) Den Prozentsatz der Branches, die True zurückgeben

Frage2 Definitionen und Grundlagen

Branch Coverage (C1) misst:

A) Den Prozentsatz der Code-Branches (True/False-Ergebnisse), die von Tests ausgeführt werden B) Die Anzahl der if-Anweisungen im Code C) Den Prozentsatz der Funktionen mit return-Anweisungen D) Wie oft jede Codezeile ausgeführt wird

Frage3 Definitionen und Grundlagen

Ein Coverage-Kriterium ist:

A) Ein Werkzeug, das misst, wie schnell Tests laufen B) Eine Regel, die definiert, was getestet werden muss, um eine Testsuite als angemessen zu betrachten C) Die minimale Anzahl von Tests, die pro Funktion erforderlich sind D) Ein Bewertungsschema für die Benotung von Studenten-Code

Frage4 Definitionen und Grundlagen

Wenn wir sagen “C1 subsumiert C0,” meinen wir:

A) C1-Tests laufen schneller als C0-Tests B) Das Erreichen von 100% C1 garantiert automatisch 100% C0 C) C0 ist gründlicher als C1 D) C1 erfordert weniger Tests als C0

Frage5 Definitionen und Grundlagen

Eine Testsuite ist “angemessen” nach einem Coverage-Kriterium, wenn:

A) Alle Tests ohne Fehler bestehen B) Die Testsuite 100% Coverage nach diesem Kriterium erreicht C) Mindestens 10 Tests für jedes Modul existieren D) Tests in unter 1 Sekunde laufen

Frage6 Verständnis und Berechnung

Betrachte diesen Code:

def check(value):
    if value > 0:
        return "positive"
    else:
        return "negative"

Warum gibt das Erreichen von 100% C1 automatisch 100% C0?

A) Weil C1 mehr Anweisungen zählt als C0 B) Weil das Abdecken beider Branches erfordert, alle Anweisungen in diesen Branches auszuführen C) Weil C1-Tests länger sind als C0-Tests D) Weil Branch Coverage nach Statement Coverage berechnet wird

Frage7 Verständnis und Berechnung

Gegeben dieser Code und Test:

def categorize(score):
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    else:
        return "F"

# Test:
def test_high_score():
    assert categorize(95) == "A"

Was ist die Statement Coverage (C0)?

A) 25% B) 40% C) 50% D) 100%

Frage8 Verständnis und Berechnung

Mit dem gleichen categorize-Code mit diesen Tests:

def test_scores():
    assert categorize(95) == "A"
    assert categorize(85) == "B"

Was ist die Branch Coverage (C1)?

A) 25% B) 50% C) 75% D) 100%

Frage9 Verständnis und Berechnung

Gegeben diese pytest-cov Ausgabe:

Name              Stmts   Miss  Cover   Missing
-----------------------------------------------
src/utils.py         24      6    75%   18-20, 35-37
-----------------------------------------------

Was sagt dir “Missing: 18-20, 35-37”?

A) Zeilen 18-20 und 35-37 haben Syntaxfehler B) Zeilen 18-20 und 35-37 wurden von keinem Test ausgeführt C) Zeilen 18-20 und 35-37 sollten gelöscht werden D) Zeilen 18-20 und 35-37 enthalten den wichtigsten Code

Frage10 Verständnis und Berechnung

Gegeben dieser Code (mit Zeilennummern):

def validate(value):
    if value is None:
        return "Error"
    if value < 0:
        return "Negative"
    if value == 0:
        return "Zero"
    return "Positive"

Und dieser Coverage Report: Missing: 3, 7

Welche Bedingungen waren NIEMALS True während des Testens?

A) value is None und value < 0 B) value is None und value == 0 C) value < 0 und value == 0 D) Alle Bedingungen wurden als True und False getestet

Frage11 Grenzen von Coverage

Eine Testsuite erreicht 100% Statement Coverage. Das bedeutet:

A) Der Code ist definitiv korrekt und produktionsreif B) Alle möglichen Eingaben wurden getestet C) Jede Anweisung wurde ausgeführt, aber die Tests könnten schwache oder fehlende Assertions haben D) Der Code hat keine Bugs

Frage12 Grenzen von Coverage

Betrachte diesen Test:

def calculate_total(items, discount_percent):
    total = sum(items)
    if discount_percent > 0:
        discount = total * (discount_percent / 100)
        total = total - discount
    return total

def test_calculate_total():
    result = calculate_total([10, 20, 30], 10)
    assert result > 0  # Was ist falsch?

Was ist das Problem mit diesem Test?

A) Er erreicht keine 100% Coverage B) Er verwendet die falsche Assertion-Syntax C) Die Assertion ist zu schwach - sie verifiziert nicht den korrekten Wert D) Der Testname ist nicht aussagekräftig genug

Frage13 Grenzen von Coverage

Welchen der folgenden Bugs würde 100% Statement Coverage wahrscheinlich VERPASSEN?

A) Eine fehlende Import-Anweisung B) Eine falsche Berechnungsformel C) Einen Syntaxfehler im Code D) Eine undefinierte Variable

Frage14 Grenzen von Coverage

In welcher Situation könnte 70% Coverage völlig akzeptabel sein?

A) Niemals - strebe immer 100% an B) Wenn die nicht abgedeckten 30% toter Code oder unerreichbare Fehlerbehandler sind C) Wenn Tests zu teuer zu schreiben sind D) Wenn das Projekt fast fertig ist

Frage15 Grenzen von Coverage

Welche Aussage beschreibt am besten die Beziehung zwischen Coverage und Korrektheit?

A) Hohe Coverage beweist Code-Korrektheit B) Coverage misst Ausführung; Korrektheit erfordert Assertions und Testdesign C) Niedrige Coverage beweist, dass Code inkorrekt ist D) Coverage und Korrektheit sind dasselbe

Aspekt	Coverage	Korrektheit
Misst	Code-Ausführung	Verhaltensverifikation
Werkzeug	pytest-cov	Assertions
Frage	“Wurde der Code ausgeführt?”	“Funktioniert der Code richtig?”

Frage16 Anwendung

Gegeben dieser Code (mit Zeilennummern):

def classify_age(age):
    if age < 0:
        return "Invalid"
    elif age < 18:
        return "Minor"
    elif age < 65:
        return "Adult"
    else:
        return "Senior"

Dein Coverage Report zeigt, dass Zeile 9 fehlt. Welcher Test würde sie abdecken?

A) assert classify_age(-5) == "Invalid" B) assert classify_age(17) == "Minor" C) assert classify_age(30) == "Adult" D) assert classify_age(70) == "Senior"

Frage17 Anwendung

Gegeben dieser Code und Coverage Report:

def calculate_shipping(weight, express=False):
    if weight <= 0:
        raise ValueError("Invalid")

    base_cost = weight * 2.0

    if express:
        return base_cost * 1.5
    return base_cost

Coverage Report: Fehlende Zeilen 3, 8

Um BEIDE fehlenden Zeilen abzudecken, brauchst du Tests mit welchen Eingaben?

A) weight=5, express=True nur B) weight=-1 und weight=5, express=True C) weight=0 und weight=5, express=False D) weight=5, express=True und weight=10, express=True

Frage18 Anwendung

Gegeben diese pytest-cov Ausgabe mit aktivierter Branch Coverage:

Name              Stmts   Miss Branch BrPart  Cover
----------------------------------------------------
src/validator.py     20      2     10      3    82%
----------------------------------------------------

Was bedeutet “BrPart: 3”?

A) 3 Branches wurden getestet B) 3 Branches sind teilweise abgedeckt (nur ein Ergebnis getestet) C) 3 Branches sollten gelöscht werden D) 3 Branches haben Fehler

Frage19 Anwendung

Dein Team richtet eine CI-Pipeline für ein Finanztransaktionssystem ein. Welcher Coverage-Schwellenwert ist am angemessensten?

A) 50% - Niedriger Schwellenwert, um Deployments nicht zu blockieren B) 70% - Industriestandard C) 85-90% - Hoher Schwellenwert mit Fokus auf kritische Pfade D) 100% - Finanzsysteme brauchen vollständige Coverage

Frage20 Anwendung

Warum Coverage-Checks in eine CI/CD-Pipeline integrieren?

A) Um Bugs im Code automatisch zu beheben B) Um zu verhindern, dass Code gemerged wird, der die Test-Coverage unter den Schwellenwert senkt C) Um Tests schneller zu machen D) Um manuelles Code-Review zu ersetzen