Condition coverage in Testing Fundamentals - Build an Automation Script

Test condition coverage for a function with multiple conditions

Preconditions (2)

Step 1: Call the function with inputs (True, True)

Step 2: Call the function with inputs (True, False)

Step 3: Call the function with inputs (False, True)

Step 4: Call the function with inputs (False, False)

Step 5: Verify that each condition in the function has been evaluated to both True and False at least once

✅ Expected Result: All conditions inside the function have been tested for both True and False values, ensuring condition coverage.

Automation Requirements - pytest

Assertions Needed:

Assert the function returns expected output for each input combination

Assert that all conditions in the function are exercised with True and False values

Best Practices:

Use parameterized tests to cover all input combinations

Keep tests simple and focused on one function

Use clear and descriptive test names

Automated Solution

Testing Fundamentals

import pytest

# Function with multiple conditions to test

def check_conditions(a: bool, b: bool) -> str:
    if a and b:
        return "Both True"
    elif a and not b:
        return "A True, B False"
    elif not a and b:
        return "A False, B True"
    else:
        return "Both False"

# Parameterized test to cover all condition combinations
@pytest.mark.parametrize("a,b,expected", [
    (True, True, "Both True"),
    (True, False, "A True, B False"),
    (False, True, "A False, B True"),
    (False, False, "Both False")
])
def test_check_conditions(a, b, expected):
    result = check_conditions(a, b)
    assert result == expected, f"Expected {expected} but got {result}"

The function check_conditions has two boolean inputs and multiple conditions combined with and and not. To achieve condition coverage, we must test all possible True/False values for each condition.

The test uses pytest.mark.parametrize to run the test function four times with all combinations of a and b. Each test asserts the function returns the expected string for that input.

This ensures each condition (a and b) is evaluated as True and False at least once, fulfilling condition coverage requirements.

Common Mistakes - 3 Pitfalls

Testing only some input combinations instead of all

Using print statements instead of assertions

Hardcoding expected outputs without understanding conditions

Bonus Challenge

Now add data-driven testing with 3 different sets of boolean inputs and expected outputs using pytest parameterize.

Show Hint

Practice

1. What does condition coverage ensure in software testing?

easy

A. All possible input values are tested

B. Only the overall decision outcome is tested once

C. Each part of a decision is tested for both true and false outcomes

D. Only syntax errors are detected

Solution

1. Step 1: Understand condition coverage definition

   Condition coverage requires testing each atomic condition in a decision for both true and false values.

2. Step 2: Compare options with definition

   Each part of a decision is tested for both true and false outcomes matches this definition exactly, while others describe different testing scopes.

3. Final Answer:

   Each part of a decision is tested for both true and false outcomes -> Option C

4. Quick Check:

   Condition coverage = test each condition true/false [OK]

Hint: Test each condition true and false separately [OK]

Common Mistakes:

• Confusing condition coverage with decision coverage
• Thinking only overall decision outcome matters
• Assuming all inputs must be tested

2. Which of the following is the correct syntax to represent a condition in a test case for condition coverage?

easy

A. if a and b then ...

B. if a && b { ... }

C. if (a & b) { ... }

D. if (a && b) { ... }

Solution

1. Step 1: Identify correct syntax for logical AND in common languages

   In languages like JavaScript, Java, and C, logical AND is written as && inside parentheses.

2. Step 2: Evaluate each option

   if (a && b) { ... } uses correct syntax with parentheses and &&. if a and b then ... uses incorrect syntax (no parentheses, wrong keywords). if (a & b) { ... } uses bitwise AND &, not logical AND. if a && b { ... } misses parentheses.

3. Final Answer:

   if (a && b) { ... } -> Option D

4. Quick Check:

   Logical AND syntax = && with parentheses [OK]

Hint: Use parentheses and && for logical AND [OK]

Common Mistakes:

• Using single & instead of && for logical AND
• Omitting parentheses around conditions
• Using incorrect keywords like 'then'

3. Consider the decision: if (x > 0 && y == 5). Which test inputs achieve full condition coverage?

medium

A. x=1, y=5 and x=-1, y=4

B. x=1, y=5 and x=1, y=4

C. x=0, y=5 and x=1, y=5

D. x=1, y=5 and x=-1, y=5

Solution

1. Step 1: Identify conditions and their true/false values

   Conditions: (x > 0) and (y == 5). To cover both true and false for each, we need inputs where x > 0 is true and false, and y == 5 is true and false.

2. Step 2: Check each option for condition coverage

   x=1, y=5 and x=-1, y=4: x=1,y=5 (x>0 true, y==5 true), x=-1,y=4 (x>0 false, y==5 false) covers all true/false for both conditions. Others miss some false cases.

3. Final Answer:

   x=1, y=5 and x=-1, y=4 -> Option A

4. Quick Check:

   Test each condition true and false separately [OK]

Hint: Test each condition true and false independently [OK]

Common Mistakes:

• Testing only overall decision true/false
• Missing false case for one condition
• Assuming one test covers all conditions

4. Given the code snippet:

if (a || b) {
  // do something
}

Which test set achieves condition coverage?

medium

A. a=true, b=false and a=false, b=true

B. a=true, b=false and a=false, b=false

C. a=true, b=true only

D. a=false, b=false only

Solution

1. Step 1: Understand condition coverage for OR operator

   For a || b, condition coverage requires testing a and b each as true and false separately.

2. Step 2: Evaluate test sets

   a=true, b=false and a=false, b=true tests a=true,b=false (a true, b false) and a=false,b=true (a false, b true), covering both true and false for each condition. Others miss some cases.

3. Final Answer:

   a=true, b=false and a=false, b=true -> Option A

4. Quick Check:

   Test each condition true and false separately [OK]

Hint: Test each condition true and false separately for OR [OK]

Common Mistakes:

• Confusing with decision coverage
• Assuming one test covers both conditions
• Ignoring condition coverage for OR

5. You have the decision: if ((p && q) || r). Which minimal test set achieves full condition coverage?

hard

A. p=true, q=true, r=false; p=false, q=true, r=false; p=false, q=false, r=false

B. p=true, q=false, r=false; p=false, q=true, r=false; p=false, q=false, r=true

C. p=true, q=true, r=false; p=false, q=false, r=false

D. p=true, q=false, r=true; p=false, q=false, r=false

Solution

1. Step 1: Identify atomic conditions and their true/false needs

   Conditions: p, q, r. Condition coverage requires each to be true and false at least once.

2. Step 2: Check each test set for coverage

   p=true, q=false, r=false; p=false, q=true, r=false; p=false, q=false, r=true tests p=true,q=false,r=false (p true, q false, r false), p=false,q=true,r=false (p false, q true, r false), and p=false,q=false,r=true (p false, q false, r true). This covers true and false for all conditions minimally.

3. Final Answer:

   p=true, q=false, r=false; p=false, q=true, r=false; p=false, q=false, r=true -> Option B

4. Quick Check:

   Each condition true and false tested once [OK]

Hint: Test each condition true and false once in minimal sets [OK]

Common Mistakes:

• Missing false case for one condition
• Testing only overall decision outcomes
• Using redundant tests beyond minimal coverage