Code Repair Generation Combo

Code Repair + Generation Combo

Automatically diagnose and repair buggy code while generating comprehensive tests to verify correctness and prevent regressions.

Workflow

Follow this systematic approach for bug fixing and test generation:

1. Understand the Bug

Read the buggy code - Use Read tool to examine the problematic code thoroughly.

Analyze the specification - Understand expected behavior from:

• Natural language description from user
• Existing failing test cases
• Input/output examples provided
• Error messages or stack traces

Identify the scope - Determine if the bug affects:

• A single function
• Multiple related functions
• An entire module
• Cross-module interactions

2. Diagnose the Root Cause

Trace the logic - Walk through the code execution mentally or with examples.

Identify the bug type:

• Logic error: Code runs but produces wrong results (off-by-one, wrong operator, incorrect condition)
• Runtime error: Code crashes or throws exceptions (null pointer, array out of bounds, type mismatch)

Pinpoint the exact location - Identify the specific lines causing the issue.

Understand side effects - Check if the bug affects other parts of the codebase.

3. Fix the Code

Apply minimal changes - Fix only what's broken, preserve existing functionality.

Use Edit tool - Make precise changes to the buggy code.

Verify the fix logic - Ensure the fix addresses the root cause, not just symptoms.

Preserve code style - Match existing formatting, naming conventions, and patterns.

4. Generate Comprehensive Tests

Load testing patterns - Read the appropriate reference file:

• Python: references/python-testing.md
• Java: references/java-testing.md
• C++: references/cpp-testing.md

Create test cases covering:

• Normal cases: Typical valid inputs
• Edge cases: Boundary values, empty inputs, single elements
• Error cases: Invalid inputs, null values, exceptions
• Regression cases: Specific inputs that triggered the original bug

Update existing tests if they exist, or create new test files following language conventions.

Use parametrized tests when testing multiple similar cases.

5. Verify and Run Tests

Execute the tests - Use Bash tool to run the test suite:

• Python: pytest test_file.py -v
• Java: mvn test or gradle test
• C++: ./test_executable or ctest

Ensure all tests pass - If tests fail, revisit the fix.

Check coverage - Verify that the fix and related code paths are tested.

6. Generate Bug Fix Report

Use the report template - Read assets/bug-fix-report-template.md and populate it with:

• Summary of the bug and fix
• Root cause analysis
• Changes made with file paths and line numbers
• Test coverage details
• Verification of regression safety

Be specific and clear - Include code snippets, test results, and reasoning.

Example Usage

Example 1: Python logic error

User: "This factorial function returns 24 instead of 120 for input 5. Fix it."

1. Read the buggy code
2. Identify: off-by-one error in loop range
3. Fix: Change `range(1, n)` to `range(1, n+1)`
4. Generate tests covering 0, 1, 5, negative numbers
5. Run pytest and verify all pass
6. Generate report

Example 2: Java runtime error

User: "My sorting method throws NullPointerException with null elements."

1. Read the code and identify null comparison issue
2. Fix: Add null checks before comparisons
3. Generate JUnit tests for arrays with nulls, empty arrays, normal cases
4. Run tests and verify
5. Generate report

Example 3: C++ logic error with examples

User: "Binary search returns -1 for existing elements. For [1,3,5,7,9] and target 5, should return 2."

1. Read code and trace with provided example
2. Identify: incorrect mid calculation or boundary condition
3. Fix the bug
4. Generate Google Test cases with provided example and additional edge cases
5. Compile and run tests
6. Generate report

Language-Specific Notes

Python:

• Use pytest framework
• Follow PEP 8 style
• Use type hints if present in original code

Java:

• Use JUnit 5 framework
• Follow Java naming conventions
• Handle null safety explicitly

C++:

• Use Google Test or Catch2
• Check for memory leaks with valgrind if applicable
• Handle pointer safety and bounds checking

Resources

references/ - Testing patterns and best practices for each language

assets/ - Bug fix report template for consistent documentation