Bug To Patch Generator

FAILED tests/test_calculator.py::test_divide - ZeroDivisionError: division by zero

def test_divide():
    result = divide(10, 0)
    assert result == None  # Expected to return None for division by zero

Traceback (most recent call last):
  File "app.py", line 42, in process_data
    result = data[index]
IndexError: list index out of range

Title: App crashes when processing empty file
Steps to reproduce:
1. Upload empty CSV file
2. Click "Process"
3. App crashes with NoneType error

Expected: Error message shown to user
Actual: Application crashes

# Read the source file
def divide(a, b):
    return a / b  # Bug: No check for b == 0

# Before (buggy code)
def divide(a, b):
    return a / b

# After (fixed code)
def divide(a, b):
    if b == 0:
        return None  # or raise ValueError("Cannot divide by zero")
    return a / b

# Test that should now pass
def test_divide_by_zero():
    assert divide(10, 0) is None

# Additional tests for edge cases
def test_divide_normal():
    assert divide(10, 2) == 5

def test_divide_negative():
    assert divide(-10, 2) == -5

AttributeError: 'NoneType' object has no attribute 'upper'

def format_name(name):
    return name.upper()

def format_name(name):
    if name is None:
        return ""  # or raise ValueError("Name cannot be None")
    return name.upper()

# Option 1: Raise exception
def format_name(name):
    if name is None:
        raise ValueError("Name cannot be None")
    return name.upper()

# Option 2: Use default parameter
def format_name(name=None):
    return (name or "").upper()

# Option 3: Type hint and early return
def format_name(name: str | None) -> str:
    if not name:
        return ""
    return name.upper()

IndexError: list index out of range

def test_get_last_element():
    arr = [1, 2, 3]
    assert get_element(arr, 3) == 3  # Want last element

def get_element(arr, index):
    return arr[index]  # index 3 is out of bounds for length 3

def get_element(arr, index):
    if index < 0 or index >= len(arr):
        raise IndexError(f"Index {index} out of range for array of length {len(arr)}")
    return arr[index]

def get_element(arr, index):
    """Get element at index. Supports negative indexing."""
    try:
        return arr[index]
    except IndexError:
        raise IndexError(f"Index {index} out of range for array of length {len(arr)}")

Application crashes when file doesn't exist
FileNotFoundError: [Errno 2] No such file or directory: 'config.json'

def load_config():
    with open('config.json') as f:
        return json.load(f)

def load_config():
    try:
        with open('config.json') as f:
            return json.load(f)
    except FileNotFoundError:
        # Return default config
        return {"debug": False, "port": 8080}
    except json.JSONDecodeError as e:
        raise ValueError(f"Invalid JSON in config.json: {e}")

import logging

def load_config():
    try:
        with open('config.json') as f:
            return json.load(f)
    except FileNotFoundError:
        logging.warning("config.json not found, using defaults")
        return {"debug": False, "port": 8080}
    except json.JSONDecodeError as e:
        logging.error(f"Invalid JSON in config.json: {e}")
        raise

def test_is_even():
    assert is_even(0) == True  # FAILS
    assert is_even(2) == True
    assert is_even(3) == False

def is_even(n):
    if n % 2:  # Bug: 0 % 2 == 0 which is falsy
        return False
    return True

def is_even(n):
    return n % 2 == 0  # Explicitly check equality

Intermittent test failure in multithreaded code
AssertionError: Expected counter=1000, got counter=987

class Counter:
    def __init__(self):
        self.count = 0

    def increment(self):
        self.count += 1  # Not atomic!

import threading

class Counter:
    def __init__(self):
        self.count = 0
        self.lock = threading.Lock()

    def increment(self):
        with self.lock:
            self.count += 1

from threading import Lock
from threading import local

class Counter:
    def __init__(self):
        self.count = 0
        self._lock = Lock()

    def increment(self):
        with self._lock:
            self.count += 1

# Or use atomic integer
from threading import Lock

class Counter:
    def __init__(self):
        from queue import Queue
        self._queue = Queue()
        self.count = 0

# Better: use threading.local or atomic types
import threading

class AtomicCounter:
    def __init__(self):
        self._value = 0
        self._lock = threading.Lock()

    def increment(self):
        with self._lock:
            self._value += 1
            return self._value

    @property
    def value(self):
        with self._lock:
            return self._value