===== ISTEM =====
Here is my function and its test file.

```python
# scores.py
def normalize_scores(scores):
    """Scale scores to 0..100. An empty list returns []."""
    lo, hi = min(scores), max(scores)
    return [round(100 * (s - lo) / (hi - lo)) for s in scores]
```

```python
# test_scores.py
from scores import normalize_scores

def test_basic():
    assert normalize_scores([0, 5, 10]) == [0, 50, 100]

def test_negative():
    assert normalize_scores([-10, 0, 10]) == [0, 50, 100]

def test_empty():
    assert normalize_scores([]) == []

def test_all_equal():
    assert normalize_scores([7, 7, 7]) == [0, 0, 0]

def test_order():
    assert normalize_scores([10, 0]) == [100, 0]
```

Without running anything, read the code and tell me which of these tests will fail and why.

===== HAM YANIT =====
Based on reading the code, here is the analysis of the tests:

### The failing test
**`test_empty()`** will fail with a `ValueError`.
*   **Why:** Inside `normalize_scores`, the function calls `min(scores)` and `max(scores)`. If the input is an empty list, these built-in functions raise a `ValueError: min() arg is an empty sequence`.

**`test_all_equal()`** will also fail with a `ZeroDivisionError`.
*   **Why:** If all elements are equal (e.g., `[7, 7, 7]`), `lo` becomes 7 and `hi` becomes 7. The denominator `(hi - lo)` results in `(7 - 7) = 0`. Calculating `(s - lo) / 0` triggers a division by zero error.

### Summary of logic
*   **`test_basic`**: Will pass. `min=0, max=10, diff=10`. `(0-0)/10=0`, `(5-0)/10=0.5`, `(10-0)/10=1`. Result: `[0, 50, 100]`.
*   **`test_negative`**: Will pass. `min=-10, max=10, diff=20`. `(-10 - -10)/20=0`, `(0 - -10)/20=0.5`, `(10 - -10)/20=1`. Result: `[0, 50, 100]`.
*   **`test_empty`**: **Fails** (ValueError).
*   **`test_all_equal`**: **Fails** (ZeroDivisionError).
*   **`test_order`**: Will pass. `min=0, max=10, diff=10`. `(10-0)/10=1`, `(0-0)/10=0`. Result: `[100, 0]`.