⚠

Privacy Notice: When you sign in with GitHub, your quiz attempts are stored in Google Firebase so you can track your progress. This data is only accessible to the course instructor, is not otherwise shared, and will be deleted at the end of the semester. For earlier deletion, contact the instructor. Prefer to stay anonymous? Use guest mode or a GitHub account without your real name.

● Progress is being saved

03 Quiz: Coverage Concepts

Score: 0 / 20

Question Overview

Pending Correct Incorrect

Instructions

This quiz tests your understanding of code coverage concepts from Lectures 6 and 7.

Preparation: Read First

Before attempting this quiz, study the following lecture sections:

From Chapter 03 (TDD and CI): TDD and CI:

Part 2: The Coverage Problem - Why we need coverage
Part 3: Setting Up Coverage Reporting - pytest-cov basics
Part 4: Integrating Coverage into CI - Thresholds and automation

From Chapter 03 (Testing Theory and Coverage): Testing Theory & Coverage:

Section 3: The Testing Theory - Program, Model, Test Suite, Coverage Criterion
Section 4: Code Coverage (C0 and C1) - Statement vs Branch coverage, Subsumption

Why Take This Quiz?

For Your Learning:

Self-Assessment: Identify areas where you have strong understanding and topics that need review
Exam Preparation: The quiz format and difficulty mirror what you can expect in the final exam
Immediate Feedback: Get instant feedback on your answers to reinforce correct understanding
Active Recall: Testing yourself is one of the most effective learning techniques

Guidelines:

Each question has 4 options with exactly one correct answer
Try to answer without referring to the lecture materials first
Sign in with GitHub to save your progress across sessions
Or continue as guest (progress won’t be saved)

Scoring Guide

18-20 correct: Excellent! Strong grasp of coverage concepts
15-17 correct: Good understanding! Review the areas you missed
12-14 correct: Fair understanding. Revisit the lecture materials
9-11 correct: Review needed. Focus on fundamentals
Below 9: Please review Lectures 6 and 7 carefully

Question1 Definitions and Basics

Statement coverage (C0) measures:

A) The percentage of functions that have at least one test B) The percentage of executable code statements executed by tests C) The number of test cases divided by lines of code D) The percentage of branches that return True

Question2 Definitions and Basics

Branch coverage (C1) measures:

A) The percentage of code branches (True/False outcomes) executed by tests B) The number of if-statements in the code C) The percentage of functions with return statements D) How many times each line of code is executed

Question3 Definitions and Basics

A coverage criterion is:

A) A tool that measures how fast tests run B) A rule defining what must be tested to consider a test suite adequate C) The minimum number of tests required per function D) A scoring rubric for grading student code

Question4 Definitions and Basics

When we say “C1 subsumes C0,” we mean:

A) C1 tests run faster than C0 tests B) Achieving 100% C1 guarantees 100% C0 automatically C) C0 is more thorough than C1 D) C1 requires fewer tests than C0

Question5 Definitions and Basics

A test suite is “adequate” according to a coverage criterion when:

A) All tests pass without errors B) The test suite achieves 100% coverage according to that criterion C) At least 10 tests exist for each module D) Tests run in under 1 second

Question6 Understanding and Calculation

Consider this code:

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

Why does achieving 100% C1 automatically give 100% C0?

A) Because C1 counts more statements than C0 B) Because covering both branches requires executing all statements in those branches C) Because C1 tests are longer than C0 tests D) Because branch coverage is calculated after statement coverage

Question7 Understanding and Calculation

Given this code and 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"

What is the statement coverage (C0)?

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

Question8 Understanding and Calculation

Using the same categorize code with these tests:

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

What is the branch coverage (C1)?

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

Question9 Understanding and Calculation

Given this pytest-cov output:

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

What does “Missing: 18-20, 35-37” tell you?

A) Lines 18-20 and 35-37 have syntax errors B) Lines 18-20 and 35-37 were not executed by any test C) Lines 18-20 and 35-37 should be deleted D) Lines 18-20 and 35-37 contain the most important code

Question10 Understanding and Calculation

Given this code (with line numbers):

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

And this coverage report: Missing: 3, 7

Which conditions were NEVER True during testing?

A) value is None and value < 0 B) value is None and value == 0 C) value < 0 and value == 0 D) All conditions were tested as both True and False

Question11 Limitations of Coverage

A test suite achieves 100% statement coverage. This means:

A) The code is definitely correct and production-ready B) All possible inputs have been tested C) Every statement was executed, but the tests might have weak or missing assertions D) The code has no bugs

Question12 Limitations of Coverage

Consider this 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  # What's wrong?

What’s the problem with this test?

A) It doesn't achieve 100% coverage B) It uses the wrong assertion syntax C) The assertion is too weak - it doesn't verify the correct value D) The test name is not descriptive enough

Question13 Limitations of Coverage

Which of the following bugs would 100% statement coverage likely MISS?

A) A missing import statement B) An incorrect calculation formula C) A syntax error in the code D) An undefined variable

Question14 Limitations of Coverage

In which situation might 70% coverage be perfectly acceptable?

A) Never - always aim for 100% B) When the uncovered 30% is dead code or unreachable error handlers C) When tests are too expensive to write D) When the project is almost finished

Question15 Limitations of Coverage

Which statement best describes the relationship between coverage and correctness?

A) High coverage proves code correctness B) Coverage measures execution; correctness requires assertions and test design C) Low coverage proves code is incorrect D) Coverage and correctness are the same thing

Aspect	Coverage	Correctness
Measures	Code execution	Behavior verification
Tool	pytest-cov	Assertions
Question	“Was this code run?”	“Does this code work right?”

Question16 Application

Given this code (with line numbers):

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

Your coverage report shows Line 9 is missing. Which test would cover it?

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

Question17 Application

Given this code and 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: Missing lines 3, 8

To cover BOTH missing lines, you need tests with which inputs?

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

Question18 Application

Given this pytest-cov output with branch coverage enabled:

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

What does “BrPart: 3” indicate?

A) 3 branches were tested B) 3 branches are partially covered (only one outcome tested) C) 3 branches should be deleted D) 3 branches have errors

Question19 Application

Your team is setting up a CI pipeline for a financial transaction system. What coverage threshold is most appropriate?

A) 50% - Low threshold to avoid blocking deploys B) 70% - Industry standard C) 85-90% - High threshold with focus on critical paths D) 100% - Financial systems need complete coverage

Question20 Application

Why integrate coverage checks into a CI/CD pipeline?

A) To automatically fix bugs in the code B) To prevent merging code that reduces test coverage below threshold C) To make tests run faster D) To replace manual code review