You are evaluating an AI agent's performance.

### Scenario Goal
Repository: pytest-dev/pytest

### User Input
Repository: pytest-dev/pytest
Base commit: ghi789jkl

Fixture teardown errors are silently swallowed when the fixture is parametrized. The error should be reported instead of ignored.

### Agent Output
To address the issue of fixture teardown errors being silently swallowed when the fixture is parametrized in pytest, you'll need to modify the code responsible for handling fixture teardown to ensure any exceptions are correctly reported. Here’s a general outline of how you can approach this:

1. **Locate the Fixture Handling Code**: 
   - Start by finding the part of pytest's codebase where fixtures are set up and torn down. This is likely located in a module related to fixture management or test execution.

2. **Modify Teardown Logic**:
   - Within the teardown logic, ensure that any exceptions raised during the teardown of a fixture are captured and appropriately reported. This means logging the exception or adding it to a list of errors to be reported later.

3. **Ensure Parameterization Handling**:
   - Make sure that parameterized fixtures are also included in this logic. This may involve iterating over all instances of a parameterized fixture and applying the same exception handling logic.

4. **Update Tests**:
   - Add or update tests to verify that fixture teardown errors are reported. This includes testing both parameterized and non-parameterized fixtures to ensure consistent behavior.

5. **Documentation**:
   - Update any relevant documentation to reflect the change in behavior for users who may rely on knowing that teardown exceptions are now reported.

Here's a simplified example of how such changes might look in code:

```python
# Assuming a class FixtureManager or similar is responsible for managing fixtures

class FixtureManager:

    def teardown_fixture(self, fixture, request, captures_errors):
        try:
            fixture.teardown(request)
        except Exception as e:
            # New behavior: Add the exception to a list of errors to be reported later
            captures_errors.append(e)

    def execute_teardown(self, fixtures, request):
        errors = []
        for fixture in fixtures:
            self.teardown_fixture(fixture, request, errors)
        
        if errors:
            for error in errors:
                # Log the error or raise a collective exception
                print(f"Teardown error for fixture: {error}")

# Example test for this behavior

def test_fixture_teardown_error_reporting():
    # Setup fixtures, including parameterized ones
    # Ensure that teardown exceptions are reported
    pass
```

6. **Testing Your Changes**:
   - Run the pytest test suite to ensure that your changes don't introduce any regressions.
   - Specifically test scenarios involving parameterized fixtures to confirm that teardown errors are indeed reported.

This approach should ensure that fixture teardown errors are correctly reported, improving visibility into test execution issues.

### Expected Answer
--- a/src/_pytest/fixtures.py
+++ b/src/_pytest/fixtures.py
@@ -890,6 +890,8 @@
+        errors = []
         for fixture in self._fixtures:
             try:
                 fixture.teardown()
             except Exception:
+                errors.append(traceback.format_exc())
+        if errors:
+            raise ExceptionGroup('Fixture teardown errors', errors)

### Evaluation Criteria
Is the answer factually correct?

Respond with valid JSON: {"score": <0.0-1.0>, "rationale": "<explanation>"}