Why different testing levels catch different bugs in Testing Fundamentals - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why Unit Tests Catch Different Bugs Than System Tests

Which statement best explains why unit tests and system tests catch different types of bugs?

A Unit tests only check the database, while system tests only check the network connections.

B Unit tests focus on small parts of code in isolation, so they catch bugs in individual functions, while system tests check the whole application and catch bugs in how parts work together.

C Unit tests are done by developers and system tests by users, so unit tests catch user errors and system tests catch coding errors.

D Unit tests run slower than system tests, so they catch performance bugs, while system tests catch only user interface bugs.

💡 Hint

Think about the size of the code each test level looks at.

Unit tests check small pieces of code alone, so they find bugs inside those pieces. System tests check the whole app working together, so they find bugs in how parts interact.

🧠 Conceptual

intermediate

Integration Testing Finds Bugs Missed by Unit Tests

Why can integration testing find bugs that unit testing might miss?

A Because integration testing checks how different modules work together, it can find bugs in their interaction that unit tests, which test modules alone, cannot find.

B Because integration testing runs faster, it can find bugs quicker than unit tests.

C Because integration testing uses real user data, it finds bugs that unit tests miss due to fake data.

D Because integration testing only tests the user interface, it finds bugs unit tests miss in the UI.

💡 Hint

Think about what integration testing focuses on compared to unit testing.

Integration testing looks at how modules connect and work together, so it finds bugs in their communication that unit tests, which test modules separately, do not catch.

❓ Predict Output

advanced

Test Execution Result for Different Testing Levels

Given the following test results, which testing level likely caught the bug?

Test Results:
- Unit Test: Passed
- Integration Test: Failed
- System Test: Passed

What does this suggest about the bug?

A The bug is in the whole system's user interface, caught by system testing.

B The bug is inside a single function, caught by unit testing.

C The bug is in the database, missed by all tests.

D The bug is in how modules work together, caught by integration testing.

💡 Hint

Look at which test failed and what it tests.

Unit tests passed, so individual parts work. System tests passed, so the whole system works. Integration test failed, so the problem is in how parts connect.

❓ assertion

advanced

Assertion to Verify Bug Found at System Testing Level

Which assertion best checks that a bug found during system testing is fixed?

Testing Fundamentals

def test_system_feature():
    result = run_full_system_feature()
    # Which assertion below is best here?

A assert result is not None, 'Result is None'

B assert isinstance(result, dict), 'Result is not a dictionary'

C assert result == expected_output, 'System feature output mismatch'

D assert len(result) > 0, 'Result is empty'

💡 Hint

Think about what confirms the feature works correctly.

Checking the exact output matches expected confirms the bug fix. Other assertions check only type or presence, not correctness.

❓ framework

expert

Choosing Testing Levels for a New Feature

You are designing tests for a new feature that involves multiple modules and user interaction. Which testing levels should you include to catch different bugs effectively?

A Unit tests for each module, integration tests for module interactions, and system tests for full feature behavior.

B Only system tests, because they cover everything including modules and user interaction.

C Only unit tests, because they are faster and catch all bugs inside modules.

D Only integration tests, because they check how modules work together.

💡 Hint

Think about the strengths of each testing level and what bugs they catch.

Unit tests catch bugs inside modules, integration tests catch bugs in module connections, and system tests catch bugs in the full feature including user interaction. Using all three covers all bug types.