Test-driven development (TDD) in Software Engineering - Mini Project: Build & Apply

Test-driven development (TDD)

📖 Scenario: You are working on a small software feature that calculates the area of a rectangle. To ensure your code works correctly, you will use Test-driven development (TDD). This means you will first write a test that defines the expected behavior, then write the code to pass the test, and finally complete the setup.

🎯 Goal: Build a simple TDD cycle by writing a test case for a rectangle area function, then write the function to pass the test, and finally complete the test setup.

📋 What You'll Learn

Create a test function named test_rectangle_area that checks if the area calculation is correct for a rectangle with width 5 and height 10.

Create a function named rectangle_area that takes width and height as parameters and returns the area.

Complete the test setup by calling the test function to run the test.

💡 Why This Matters

🌍 Real World

TDD is used in software development to ensure code quality and reduce bugs by writing tests before code.

💼 Career

Many software engineering roles require knowledge of TDD to write reliable and maintainable code.

1

Write the test function

Write a test function called test_rectangle_area that checks if calling rectangle_area(5, 10) returns 50. Use an assert statement inside the function.

Software Engineering

# Write the test function test_rectangle_area
# Your code here

Hint

Remember, the test function should use assert to check the expected output.

2

Write the function to pass the test

Write a function called rectangle_area that takes two parameters: width and height. It should return the product of width and height.

Software Engineering

def test_rectangle_area():
    assert rectangle_area(5, 10) == 50

# Write the rectangle_area function
# Your code here

Hint

The function should multiply width and height and return the result.

3

Call the test function

Add a call to the test_rectangle_area() function at the end of the code to run the test.

Software Engineering

def test_rectangle_area():
    assert rectangle_area(5, 10) == 50

def rectangle_area(width, height):
    return width * height

# Call the test function
# Your code here

Hint

Simply call the test function by its name followed by parentheses.

4

Complete the TDD cycle

Add a print statement print("Test passed!") after calling test_rectangle_area() to confirm the test passed successfully.

Software Engineering

def test_rectangle_area():
    assert rectangle_area(5, 10) == 50

def rectangle_area(width, height):
    return width * height

test_rectangle_area()

# Print confirmation message
# Your code here

Hint

This message helps confirm that the test ran without errors.

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