===== 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 =====
Let's analyze each test one by one and determine which will **fail**, and **why**.

---

### ✅ **Test: `test_basic()`**
```python
assert normalize_scores([0, 5, 10]) == [0, 50, 100]
```

- **Input:** `[0, 5, 10]`
- `lo = 0`, `hi = 10`
- Formula: `round(100 * (s - lo) / (hi - lo))`
  - For `0`: `round(100 * (0 - 0) / 10) = 0`
  - For `5`: `round(100 * (5 - 0) / 10) = 50`
  - For `10`: `round(100 * (10 - 0) / 10) = 100`
- ✅ **Passes.**

---

### ✅ **Test: `test_negative()`**
```python
assert normalize_scores([-10, 0, 10]) == [0, 50, 100]
```

- **Input:** `[-10, 0, 10]`
- `lo = -10`, `hi = 10`
- Formula: `round(100 * (s - lo) / (hi - lo))`
  - For `-10`: `round(100 * (-10 - (-10)) / (10 - (-10))) = 0`
  - For `0`: `round(100 * (0 - (-10)) / 20) = 50`
  - For `10`: `round(100 * (10 - (-10)) / 20) = 100`
- ✅ **Passes.**

---

### ✅ **Test: `test_empty()`**
```python
assert normalize_scores([]) == []
```

- The function returns `[]` for an empty list.
- ✅ **Passes.**

---

### ✅ **Test: `test_all_equal()`**
```python
assert normalize_scores([7, 7, 7]) == [0, 0, 0]
```

- All values are the same, so `lo = hi = 7`
- Division by zero (`hi - lo = 0`) will occur.
- **But**, in Python, if you divide by zero, it raises a `ZeroDivisionError`.
- So this test will **fail**, but **not** because of an incorrect result — it will **crash** due to a **runtime error**.
- ❌ **Fails with a `ZeroDivisionError`**.

---

### ❌ **Test: `test_order()`**
```python
assert normalize_scores([10, 0]) == [100, 0]
```

- **Input:** `[10, 0]`
- `lo = 0`, `hi = 10`
- Formula:
  - For `10`: `round(100 * (10 - 0) / (10 - 0)) = 100`
  - For `0`: `round(100 * (0 - 0) / (10 - 0)) = 0`
- ✅ **Passes.**

---

## ✅ **Summary of Results:**

| Test Name       | Passes? | Reason |
|-----------------|---------|--------|
| `test_basic()`  | ✅      | Correct calculation |
| `test_negative()`| ✅      | Correct calculation |
| `test_empty()`  | ✅      | Correct return value |
| `test_all_equal()`| ❌      | **Crashes** with `ZeroDivisionError` |
| `test_order()`  | ✅      | Correct calculation |

---

### ✅ **Final Answer:**
- **The test `test_all_equal()` will fail**, because it causes a **ZeroDivisionError** when all values are equal.