===== 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 the provided code, the test **`test_empty()`** and **`test_all_equal()`** will fail.

Here is why:

### 1. `test_empty()` will fail
*   **The Issue:** Inside `normalize_scores`, you call `min(scores)` and `max(scores)`.
*   **The Result:** When passed an empty list `[]`, the `min()` and `max()` functions raise a **`ValueError: min() arg is an empty sequence`**. The function will crash before it can return `[]`.

### 2. `test_all_equal()` will fail
*   **The Issue:** Inside the list comprehension, you perform the calculation `(s - lo) / (hi - lo)`.
*   **The Result:** If all elements are equal (e.g., `[7, 7, 7]`), then `lo` is 7 and `hi` is 7. This results in `hi - lo = 0`, which triggers a **`ZeroDivisionError: division by zero`**.

***

**Suggested Fix:**
You can handle these edge cases by adding a check at the start of your function:

```python
def normalize_scores(scores):
    if not scores:
        return []
    lo, hi = min(scores), max(scores)
    if lo == hi:
        return [0 for _ in scores]
    return [round(100 * (s - lo) / (hi - lo)) for s in scores]
```