Test-driven development (TDD) in Software Engineering - Time & Space Complexity

Time Complexity: Test-driven development (TDD)

O(n)

Understanding Time Complexity

When using Test-driven development (TDD), we write tests before code. Understanding time complexity here means looking at how the number of tests and code changes affect the time spent developing and running tests.

We want to know: How does the effort grow as the project or test suite grows?

Scenario Under Consideration

Analyze the time complexity of running tests in a TDD cycle.

for each new feature:
    write a failing test
    write code to pass the test
    run all tests
    if tests pass:
        proceed to next feature
    else:
        fix code and rerun tests

This snippet shows the basic TDD loop: write a test, write code, run all tests, and repeat until all tests pass.

Identify Repeating Operations

In this TDD process, the main repeating operation is running all tests after each code change.

• Primary operation: Running the full test suite
• How many times: Once after every code change or test addition

How Execution Grows With Input

As the number of tests grows, running all tests takes more time each cycle.

Input Size (number of tests)	Approx. Operations (test runs)
10	Runs 10 tests each cycle
100	Runs 100 tests each cycle
1000	Runs 1000 tests each cycle

Pattern observation: The time to run tests grows roughly in direct proportion to the number of tests.

Final Time Complexity

Time Complexity: O(n)

This means the time to run tests grows linearly with the number of tests in the suite.

Common Mistake

[X] Wrong: "Running tests after each change takes the same time no matter how many tests exist."

[OK] Correct: As tests increase, running all tests takes longer, so the time grows with the number of tests.

Interview Connect

Understanding how test suite size affects development time shows you think about practical software quality and efficiency. This skill helps you balance writing enough tests without slowing down progress.

Self-Check

"What if we only ran the tests related to the changed code instead of the full suite? How would the time complexity change?"

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