Test-Driven Generation

Generate implementation code that satisfies existing unit tests through an iterative test-driven development workflow.

Workflow

1. Analyze Tests

Read and understand the provided test file(s):

• Identify what functions/classes/methods need to be implemented
• Extract input/output expectations from assertions
• Note edge cases, error conditions, and special behaviors
• Understand dependencies and imports

2. Generate Implementation

Create implementation code that should satisfy the tests:

For Python:

• Match the exact function/class signatures expected by tests
• Implement logic to satisfy assertions
• Handle all tested edge cases
• Add necessary imports and dependencies

For Java:

• Match exact method signatures and return types
• Implement logic within the correct class structure
• Handle exceptions as tested
• Add required imports and annotations

3. Run Tests

Execute the test suite to verify the implementation:

Python:

bash
pytest <test_file>.py -v
# or
python -m unittest <test_file>.py -v

Java:

bash
mvn test
# or
gradle test
# or for single test file
javac <TestFile>.java && java org.junit.runner.JUnitCore <TestFile>

4. Debug Failures

If tests fail, analyze the failure output:

• Read the assertion error messages carefully
• Identify which specific test cases are failing
• Understand what the test expected vs. what was returned
• Locate the bug in the implementation

5. Iterate

Fix the implementation based on failure analysis:

• Update the code to handle the failing case
• Re-run tests to verify the fix
• Repeat until all tests pass

Best Practices

Code Quality

• Write clean, readable implementation code
• Use descriptive variable names
• Add comments for complex logic
• Follow language conventions (PEP 8 for Python, Java naming conventions)

Test Understanding

• Read ALL test cases before implementing
• Don't assume - verify exact expected behavior from assertions
• Pay attention to parametrized tests and edge cases
• Check test fixtures and setup methods for context

Debugging Strategy

• Start with the first failing test
• Fix one test at a time when possible
• After each fix, run the full suite to catch regressions
• If stuck, re-read the test to verify understanding

Common Pitfalls

• Type mismatches: Ensure return types match exactly (e.g., int vs float, List vs array)
• Off-by-one errors: Carefully check boundary conditions
• Null/None handling: Implement null checks if tests verify null behavior
• Exception types: Raise/throw the exact exception type the test expects
• Mutable state: Reset state between test runs if using class-level variables

Example Session

User provides test_calculator.py:

python
import pytest
from calculator import Calculator

def test_add():
    calc = Calculator()
    assert calc.add(2, 3) == 5
    assert calc.add(-1, 1) == 0

def test_divide():
    calc = Calculator()
    assert calc.divide(10, 2) == 5
    with pytest.raises(ValueError):
        calc.divide(10, 0)

Step 1: Analyze - need Calculator class with add() and divide() methods, divide should raise ValueError on zero

Step 2: Generate calculator.py:

python
class Calculator:
    def add(self, a, b):
        return a + b

    def divide(self, a, b):
        if b == 0:
            raise ValueError("Cannot divide by zero")
        return a / b

Step 3: Run pytest test_calculator.py -v

Step 4: If failure occurs, read error and identify issue

Step 5: Fix and re-run until passing

Language-Specific Notes

Python

• Use type hints when test imports suggest them
• Match pytest vs unittest assertion styles
• Check for setUp/tearDown or fixtures that provide context
• Watch for @pytest.mark.parametrize for multiple test cases

Java

• Match access modifiers (public/private/protected)
• Implement interfaces if tests verify interface compliance
• Use correct exception handling (throws vs try-catch)
• Check for @Before/@After setup methods
• Watch for @ParameterizedTest annotations