Test-driven development (TDD) in Software Engineering - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the primary purpose of writing tests before code in TDD?

In Test-driven development (TDD), developers write tests before writing the actual code. What is the main reason for this practice?

A To reduce the total number of tests needed later

B To avoid writing documentation for the code

C To delay coding until all requirements are finalized

D To ensure the code meets requirements and to guide design decisions

💡 Hint

Think about how tests influence the coding process and design.

Writing tests first helps clarify requirements and guides the design of the code to meet those requirements effectively.

📋 Factual

intermediate

Which of the following best describes the TDD cycle?

Identify the correct sequence of steps in the Test-driven development cycle.

A Write test → Write code → Refactor

B Write test → Refactor → Write code

C Refactor → Write test → Write code

D Write code → Write test → Refactor

💡 Hint

Remember the mantra: Red, Green, Refactor.

The TDD cycle starts by writing a failing test, then writing code to pass the test, and finally refactoring the code.

🔍 Analysis

advanced

What is a common risk if tests are not refactored during TDD?

During TDD, after making tests pass, developers refactor code and tests. What risk arises if tests are not refactored properly?

A The application will run faster

B Code coverage will automatically increase

C Tests may become brittle and fail unnecessarily on minor changes

D Developers will write fewer tests overall

💡 Hint

Consider how test quality affects maintenance.

If tests are not refactored, they can become tightly coupled to implementation details, causing failures when code changes even if behavior is correct.

❓ Comparison

advanced

How does TDD differ from traditional testing approaches?

Compare Test-driven development (TDD) with traditional testing methods. Which statement best highlights a key difference?

A TDD requires no tests, while traditional testing requires many

B TDD integrates testing into the development process by writing tests first, while traditional testing often happens after coding

C Traditional testing focuses on writing tests before code, TDD writes tests after code

D TDD eliminates the need for debugging, traditional testing does not

💡 Hint

Think about when tests are created in each approach.

TDD emphasizes writing tests before code to guide development, whereas traditional testing usually occurs after the code is written.

❓ Reasoning

expert

Why might TDD improve software design quality?

Explain why practicing Test-driven development can lead to better software design.

A Because writing tests first forces developers to think about requirements and design in small, manageable units

B Because TDD removes the need for code reviews

C Because TDD guarantees zero bugs in the final product

D Because TDD allows skipping documentation

💡 Hint

Consider how TDD influences the way developers approach coding tasks.

Writing tests first encourages developers to focus on clear, testable requirements and modular design, improving overall software quality.

Practice

1. What is the main purpose of Test-driven development (TDD)?

easy

A. To write tests before writing the actual code

B. To write code first and then tests later

C. To avoid writing any tests

D. To write documentation before coding

Solution

1. Step 1: Understand TDD process

   TDD means writing tests before the actual code to guide development.

2. Step 2: Identify the main goal

   The main goal is to ensure code correctness by writing tests first.

3. Final Answer:

   To write tests before writing the actual code -> Option A

4. Quick Check:

   TDD = Write tests first [OK]

Hint: Remember: TDD starts with tests, not code [OK]

Common Mistakes:

• Thinking code is written before tests
• Confusing TDD with writing documentation
• Believing tests are optional in TDD

2. Which of the following is the correct order of steps in the TDD cycle?

easy

A. Write code, write test, refactor

B. Write test, write code, refactor

C. Refactor, write code, write test

D. Write test, refactor, write code

Solution

1. Step 1: Recall TDD cycle steps

   The TDD cycle is: write a failing test, write code to pass it, then refactor.

2. Step 2: Match the correct sequence

   Write test, write code, refactor matches this order exactly.

3. Final Answer:

   Write test, write code, refactor -> Option B

4. Quick Check:

   TDD cycle = Test -> Code -> Refactor [OK]

Hint: TDD always starts with a failing test [OK]

Common Mistakes:

• Writing code before tests
• Refactoring before writing code
• Mixing the order of steps

3. Consider this TDD scenario:
1. Write a test that expects function add(2, 3) to return 5.
2. Implement add function as def add(a, b): return a - b
3. Run the test.
What will be the test result?

medium

A. Syntax error in function definition

B. Test passes successfully

C. Test fails because the function returns wrong result

D. Test is skipped automatically

Solution

1. Step 1: Analyze the function implementation

   The function subtracts b from a instead of adding them.

2. Step 2: Compare expected and actual results

   Calling add(2, 3) returns -1, but test expects 5, so test fails.

3. Final Answer:

   Test fails because the function returns wrong result -> Option C

4. Quick Check:

   Wrong function logic = Test fails [OK]

Hint: Check if function logic matches test expectation [OK]

Common Mistakes:

• Assuming test passes despite wrong logic
• Confusing syntax error with logic error
• Thinking tests skip automatically

4. You wrote a test first but it never fails even before implementing the code. What is the likely problem?

medium

A. Test is not written correctly to check the feature

B. Code is already perfect and needs no changes

C. Test framework is broken and skips tests

D. You forgot to run the test

Solution

1. Step 1: Understand TDD failing test requirement

   In TDD, the first test should fail because code is not implemented yet.

2. Step 2: Identify why test never fails

   If test never fails, it likely does not check the feature properly or has wrong assertions.

3. Final Answer:

   Test is not written correctly to check the feature -> Option A

4. Quick Check:

   Failing test means correct test setup [OK]

Hint: First test must fail to guide development [OK]

Common Mistakes:

• Assuming code is perfect without implementation
• Blaming test framework without checking test code
• Forgetting to run tests

5. You want to use TDD to develop a function that returns only even numbers from a list. Which sequence of steps best follows TDD principles?

hard

A. Write code and tests simultaneously, then refactor

B. Write code to filter evens, then write tests to check it

C. Write tests after finishing all code

D. Write a test for filtering evens, write code to pass test, then refactor code

Solution

1. Step 1: Recall TDD workflow

   TDD requires writing a failing test first, then code to pass it, then refactoring.

2. Step 2: Match steps to TDD

   Write a test for filtering evens, write code to pass test, then refactor code follows this exact sequence for developing the function.

3. Final Answer:

   Write a test for filtering evens, write code to pass test, then refactor code -> Option D

4. Quick Check:

   TDD = Test -> Code -> Refactor [OK]

Hint: Always start with a test that fails for new feature [OK]

Common Mistakes:

• Writing code before tests
• Writing tests after code completion
• Mixing test and code writing steps