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.

Practice

1. What does path coverage testing ensure in software testing?

easy

A. All possible routes through the code are tested

B. Only the most common routes are tested

C. Only the start and end points are tested

D. Only the user interface is tested

Solution

1. Step 1: Understand path coverage meaning

   Path coverage means testing every possible route or path through the code's decision points.

2. Step 2: Compare options with definition

   All possible routes through the code are tested matches this definition exactly, while others limit testing scope incorrectly.

3. Final Answer:

   All possible routes through the code are tested -> Option A

4. Quick Check:

   Path coverage = all routes tested [OK]

Hint: Path coverage means testing every route through code [OK]

Common Mistakes:

• Confusing path coverage with statement coverage
• Thinking it tests only common or simple paths
• Assuming it tests only UI or start/end points

2. Which of the following is the correct way to represent path coverage in a decision structure?

easy

A. Testing only the true branch of an if statement

B. Testing only the false branch of an if statement

C. Testing both true and false branches of an if statement

D. Skipping the if statement entirely

Solution

1. Step 1: Understand path coverage in decisions

   Path coverage requires testing all possible outcomes of decisions, including both true and false branches.

2. Step 2: Match options to requirement

   Only Testing both true and false branches of an if statement tests both branches, fulfilling path coverage requirements.

3. Final Answer:

   Testing both true and false branches of an if statement -> Option C

4. Quick Check:

   Both branches tested = path coverage [OK]

Hint: Test all branches of decisions for path coverage [OK]

Common Mistakes:

• Testing only one branch of a decision
• Ignoring false branches
• Skipping decision points

3. Consider this code snippet:

if (x > 0) {
  if (x < 10) {
    print("A");
  } else {
    print("B");
  }
} else {
  print("C");
}

How many unique paths must be tested for full path coverage?

medium

A. 2

B. 3

C. 4

D. 5

Solution

1. Step 1: Identify decision points and paths

   There are two if statements: outer (x > 0) and inner (x < 10). Paths are:
   1) x > 0 and x < 10 -> print "A"
   2) x > 0 and x >= 10 -> print "B"
   3) x <= 0 -> print "C"

2. Step 2: Count unique paths

   There are 3 unique paths through the code based on these conditions.

3. Final Answer:

   3 -> Option B

4. Quick Check:

   Two decisions create 3 paths [OK]

Hint: Count all decision outcomes to find paths [OK]

Common Mistakes:

• Counting only outer if branches
• Assuming paths multiply incorrectly
• Forgetting else branch path

4. You have this code:

if (a > 5) {
  if (b == 0) {
    print("X");
  }
} else {
  print("Y");
}

Which test case is missing for full path coverage?

medium

A. a = 6, b = 1

B. a = 6, b = 0

C. a = 4, b = 0

D. a = 4, b = 1

Solution

1. Step 1: Identify all paths

   Paths are:
   1) a > 5 and b == 0 -> print "X"
   2) a > 5 and b != 0 -> no print
   3) a <= 5 -> print "Y"

2. Step 2: Check test cases for coverage

   The test case a = 6, b = 1 covers path 2, which is missing from the others.

3. Final Answer:

   a = 6, b = 1 -> Option A

4. Quick Check:

   Test all branches including no-action paths [OK]

Hint: Include tests for conditions with no output too [OK]

Common Mistakes:

• Ignoring paths with no print or action
• Testing only true branches
• Missing else branch tests

5. Given this nested decision code:

if (x > 0) {
  if (y > 0) {
    print("P");
  } else {
    print("Q");
  }
} else {
  if (y > 0) {
    print("R");
  } else {
    print("S");
  }
}

How many test cases are needed for full path coverage, and why?

hard

A. 2, because only outer if matters

B. 5, because of extra hidden paths

C. 3, because some inner paths overlap

D. 4, because each if-else pair creates 2 paths

Solution

1. Step 1: Analyze nested if-else structure

   There are two if-else blocks nested:
   - Outer if (x > 0) with two inner paths (y > 0 and y <= 0)
   - Outer else (x <= 0) with two inner paths (y > 0 and y <= 0)

2. Step 2: Calculate total paths

   Each outer branch has 2 inner branches, so total paths = 2 (outer) * 2 (inner) = 4.

3. Final Answer:

   4, because each if-else pair creates 2 paths -> Option D

4. Quick Check:

   Nested if-else multiply paths = 4 [OK]

Hint: Multiply branches of nested decisions for paths count [OK]

Common Mistakes:

• Counting only outer or inner branches
• Assuming overlapping paths reduce count
• Adding extra paths without basis