Path coverage in Testing Fundamentals - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Path Coverage Basics

Consider a simple function with two if statements in sequence. How many unique execution paths should be tested to achieve 100% path coverage?

Testing Fundamentals

def example(x, y):
    if x > 0:
        print("X positive")
    if y > 0:
        print("Y positive")

A 4

B 3

C 2

D 5

💡 Hint

Each if statement can be true or false independently.

Each if statement has two possible outcomes (true or false). With two independent ifs, total paths = 2 * 2 = 4.

❓ Predict Output

intermediate

Output of Path Coverage Example

What is the output when calling test_func(3, -1)?

Testing Fundamentals

def test_func(a, b):
    if a > 0:
        print("A positive")
    else:
        print("A non-positive")
    if b > 0:
        print("B positive")
    else:
        print("B non-positive")

# Call: test_func(3, -1)

A A positive\nB positive

B A non-positive\nB positive

C A positive\nB non-positive

D A non-positive\nB non-positive

💡 Hint

Check each if condition with the given inputs.

a=3 > 0 so prints 'A positive'. b=-1 <= 0 so prints 'B non-positive'.

❓ assertion

advanced

Assertion for Full Path Coverage

Which assertion best verifies that all paths in the following function have been executed at least once?

Testing Fundamentals

def check_values(x, y):
    if x > 10:
        if y < 5:
            return "Path 1"
        else:
            return "Path 2"
    else:
        return "Path 3"

A assert results == ["Path 1", "Path 2", "Path 3"]

B assert set(results) == {"Path 1", "Path 2", "Path 3"}

C assert "Path 1" in results and "Path 2" in results

D assert len(results) == 3

💡 Hint

All unique paths must be covered regardless of order.

Using a set comparison ensures all unique paths are covered, order does not matter.

🔧 Debug

advanced

Identify Path Coverage Miscount

Given this code, a tester claims there are 3 paths. Is this correct? If not, what is the correct number of paths?

Testing Fundamentals

def sample(x, y):
    if x > 0:
        if y > 0:
            return 1
    return 0

A Correct, there are 3 paths: both true, first true second false, first false

B Incorrect, there are 2 paths: both true and others combined

C Incorrect, there are 4 paths: all combinations of x and y conditions

D Incorrect, there is only 1 path because y is checked only if x > 0

💡 Hint

Consider when the second if is evaluated.

The second if is inside the first if, creating three distinct paths: 1. x <= 0 (first false) -> return 0; 2. x > 0 and y > 0 (both true) -> return 1; 3. x > 0 and y <= 0 (first true, second false) -> return 0. These are unique sequences of branches despite sharing a return statement.

❓ framework

expert

Designing Tests for Full Path Coverage

You have a function with three nested if statements. How many test cases are needed to guarantee 100% path coverage?

Function structure:

if A:
    if B:
        if C:
            do X
        else:
            do Y
    else:
        do Z
else:
    do W

A 8 test cases

B 5 test cases

C 6 test cases

D 4 test cases

💡 Hint

Count unique paths from root to leaves in the nested if structure.

Paths are:
1) A true, B true, C true
2) A true, B true, C false
3) A true, B false
4) A false
So total 4 unique paths.