Branch coverage in PyTest - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to assert the function returns True for positive input.

PyTest

def is_positive(num):
    return num > 0

def test_positive():
    assert is_positive([1]) == True

Drag options to blanks, or click blank then click option'

A0

B-3

C5

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Using zero or negative numbers which return False.

The function returns True only if the input is greater than zero. Using 5 tests the positive branch.

2fill in blank

medium

Complete the test to check the function returns False for zero input.

PyTest

def is_positive(num):
    return num > 0

def test_zero():
    assert is_positive([1]) == False

Drag options to blanks, or click blank then click option'

A10

B0

C-1

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using positive numbers which return True.

The function returns False when the input is zero because zero is not greater than zero.

3fill in blank

hard

Fix the error in the test to cover the negative branch correctly.

PyTest

def is_positive(num):
    return num > 0

def test_negative():
    assert is_positive([1]) == False

Drag options to blanks, or click blank then click option'

A-2

B0

C5

D3

Attempts:

3 left

💡 Hint

Common Mistakes

Using zero or positive numbers which do not test the negative branch.

Negative numbers like -2 cause the function to return False, covering the negative branch.

4fill in blank

hard

Fill both blanks to complete a test that covers both branches using pytest parametrize.

PyTest

import pytest

@pytest.mark.parametrize('input, expected', [
    ([1], True),
    ([2], False)
])
def test_is_positive(input, expected):
    assert is_positive(input) == expected

Drag options to blanks, or click blank then click option'

A10

B-5

C0

D7

Attempts:

3 left

💡 Hint

Common Mistakes

Using zero which returns False but is not negative.

10 is positive and should return True; -5 is negative and should return False, covering both branches.

5fill in blank

hard

Fill all three blanks to create a test function that covers positive, zero, and negative inputs with correct assertions.

PyTest

import pytest

@pytest.mark.parametrize('num, expected', [
    ([1], True),
    ([2], False),
    ([3], False)
])
def test_branch_coverage(num, expected):
    assert is_positive(num) == expected

Drag options to blanks, or click blank then click option'

A3

B0

C-1

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Using zero as positive or negative.

5 is positive (True), 0 is zero (False), and -1 is negative (False), covering all branches.

Practice

1.

What does branch coverage measure in pytest testing?

easy

A. It checks if all decision paths in the code are tested.

B. It measures how many lines of code are executed.

C. It counts the number of test cases written.

D. It verifies the syntax correctness of the test code.

Solution

1. Step 1: Understand branch coverage concept

   Branch coverage ensures every possible path in decision points (like if-else) is tested.

2. Step 2: Compare with other coverage types

   Line coverage counts executed lines, but branch coverage focuses on decision paths.

3. Final Answer:

   It checks if all decision paths in the code are tested. -> Option A

4. Quick Check:

   Branch coverage = all decision paths tested [OK]

Hint: Branch coverage tests all if-else paths, not just lines [OK]

Common Mistakes:

• Confusing branch coverage with line coverage
• Thinking it counts test cases
• Assuming it checks syntax errors

2.

Which pytest command option enables branch coverage measurement?

easy

A. pytest --cov --cov-branch

B. pytest --branch-coverage

C. pytest --cov-branch

D. pytest --coverage-branch

Solution

1. Step 1: Recall pytest coverage options

   The option --cov enables coverage measurement, and --cov-branch adds branch coverage.

2. Step 2: Identify correct combined command

   Both options must be used together as pytest --cov --cov-branch to measure branch coverage.

3. Final Answer:

   pytest --cov --cov-branch -> Option A

4. Quick Check:

   Use --cov with --cov-branch for branch coverage [OK]

Hint: Use both --cov and --cov-branch together [OK]

Common Mistakes:

• Using only --cov-branch without --cov
• Typing incorrect option names
• Assuming branch coverage is default

3.

Given this code snippet tested with pytest and branch coverage enabled, what is the branch coverage result?

def check_num(x):
    if x > 0:
        return "Positive"
    else:
        return "Non-positive"

# Test cases:
assert check_num(5) == "Positive"

medium

A. 100% branch coverage

B. 75% branch coverage

C. 0% branch coverage

D. 50% branch coverage

Solution

1. Step 1: Identify branches in the code

   The function has two branches: one for x > 0 and one for else (x ≤ 0).

2. Step 2: Check which branches are tested

   The test calls check_num(5), which covers only the x > 0 branch, missing the else branch.

3. Final Answer:

   50% branch coverage -> Option D

4. Quick Check:

   One branch tested out of two = 50% [OK]

Hint: Test all if-else paths to get 100% branch coverage [OK]

Common Mistakes:

• Assuming one test covers all branches
• Confusing line coverage with branch coverage
• Ignoring else branch testing

4.

Identify the error in this pytest test that aims for full branch coverage:

def classify(n):
    if n > 10:
        return "High"
    elif n > 5:
        return "Medium"
    else:
        return "Low"

def test_classify():
    assert classify(12) == "High"
    assert classify(7) == "Medium"

medium

A. Syntax error in the test function.

B. Incorrect expected values in assertions.

C. Missing test for the else branch (n ≤ 5).

D. The function classify has no return statement.

Solution

1. Step 1: Analyze branches in classify()

   There are three branches: n > 10, n > 5, and else (n ≤ 5).

2. Step 2: Check test coverage of branches

   Tests cover n=12 (High) and n=7 (Medium), but no test covers n ≤ 5 (Low) branch.

3. Final Answer:

   Missing test for the else branch (n ≤ 5). -> Option C

4. Quick Check:

   All branches need tests for full coverage [OK]

Hint: Test all if, elif, else branches to avoid missing coverage [OK]

Common Mistakes:

• Assuming two tests cover all branches
• Looking for syntax errors where none exist
• Ignoring else branch testing

5.

You have this function. Which set of test inputs achieves 100% branch coverage?

def analyze_score(score):
    if score >= 90:
        return "A"
    elif score >= 75:
        return "B"
    else:
        return "C"

hard

A. [90, 85, 76]

B. [95, 80, 70]

C. [91, 74, 60]

D. [89, 84, 73]

Solution

1. Step 1: Identify all branches

   Branches: score ≥ 90 ("A"), score ≥ 75 ("B"), else "C".

2. Step 2: Check which inputs cover all branches

   Input 95 covers "A" branch; 80 covers score ≥ 75 ("B"); 70 covers else "C" branch. This covers all branches.

3. Final Answer:

   [95, 80, 70] -> Option B

4. Quick Check:

   Test inputs cover all if-elif-else paths [OK]

Hint: Pick inputs hitting each if, elif, else branch [OK]

Common Mistakes:

• Missing coverage for one of the branches
• Choosing inputs that skip else branch
• Assuming close values cover all branches