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.

Practice

1. Which testing level focuses on checking individual parts of the software separately?

easy

A. Acceptance Testing

B. System Testing

C. Integration Testing

D. Unit Testing

Solution

1. Step 1: Understand testing levels

   Unit testing checks small parts or units of code individually.

2. Step 2: Compare options to definitions

   System testing checks the whole system, integration testing checks combined parts, acceptance testing checks if requirements are met.

3. Final Answer:

   Unit Testing -> Option D

4. Quick Check:

   Individual parts = Unit Testing [OK]

Hint: Unit testing tests small parts alone [OK]

Common Mistakes:

• Confusing integration testing with unit testing
• Thinking system testing tests parts separately
• Mixing acceptance testing with unit testing

2. Which of the following is the correct order of testing levels from smallest to largest scope?

easy

A. System Testing -> Integration Testing -> Unit Testing

B. Unit Testing -> Integration Testing -> System Testing

C. Integration Testing -> Unit Testing -> System Testing

D. Acceptance Testing -> System Testing -> Unit Testing

Solution

1. Step 1: Identify scope sizes

   Unit testing checks smallest parts, integration testing checks combined parts, system testing checks whole system.

2. Step 2: Arrange from smallest to largest

   Correct order is Unit Testing, then Integration Testing, then System Testing.

3. Final Answer:

   Unit Testing -> Integration Testing -> System Testing -> Option B

4. Quick Check:

   Smallest to largest = A [OK]

Hint: Remember: Unit, Integration, System order [OK]

Common Mistakes:

• Reversing the order of testing levels
• Confusing integration with system testing
• Including acceptance testing in the wrong place

3. Consider this scenario: A bug appears only when two modules interact but not in individual modules. Which testing level is most likely to catch this bug?

medium

A. Integration Testing

B. Unit Testing

C. System Testing

D. Acceptance Testing

Solution

1. Step 1: Analyze bug context

   The bug appears only when two modules interact, so it is related to combined parts.

2. Step 2: Match testing level to bug type

   Integration testing focuses on testing combined modules and their interactions.

3. Final Answer:

   Integration Testing -> Option A

4. Quick Check:

   Bug in combined modules = Integration Testing [OK]

Hint: Bugs in combined parts? Think Integration Testing [OK]

Common Mistakes:

• Choosing unit testing for interaction bugs
• Confusing system testing with integration testing
• Assuming acceptance testing finds module interaction bugs

4. A tester wrote a test that checks the entire software system but missed testing how modules work together. What testing level did they likely skip?

medium

A. Integration Testing

B. Unit Testing

C. Acceptance Testing

D. System Testing

Solution

1. Step 1: Understand the test scope

   The tester tested the whole system but did not check module interactions.

2. Step 2: Identify missing testing level

   Integration testing specifically checks how modules work together, so it was likely skipped.

3. Final Answer:

   Integration Testing -> Option A

4. Quick Check:

   Missed module interaction = Integration Testing [OK]

Hint: Check module interactions with Integration Testing [OK]

Common Mistakes:

• Confusing system testing with integration testing
• Assuming unit testing covers module interactions
• Thinking acceptance testing covers module integration

5. A software project has a bug that only appears when the full system runs with real user data, but not during unit or integration tests. Which testing level is best suited to find this bug?

hard

A. Unit Testing

B. Integration Testing

C. System Testing

D. Acceptance Testing

Solution

1. Step 1: Analyze bug conditions

   The bug appears only when the full system runs with real user data, not in smaller tests.

2. Step 2: Match testing level to scenario

   System testing checks the entire system working together, often with realistic data, so it is best to find such bugs.

3. Final Answer:

   System Testing -> Option C

4. Quick Check:

   Full system with real data = System Testing [OK]

Hint: Full system bugs? Use System Testing [OK]

Common Mistakes:

• Choosing unit or integration testing for full system bugs
• Confusing acceptance testing with system testing
• Ignoring the importance of real user data in tests