单元测试编写

以下是使用 `pytest` 编写的单元测试代码，这些代码专门为你给出的 `add` 函数编写，涵盖了指定的测试场景。每个测试用例都具有描述性的名称，以便清楚地了解其目的。由于 `add` 函数没有外部依赖，也不需要使用模拟。

```python
import pytest
from your_module import add  # 假设函数保存在 your_module.py 中

def test_add_with_positive_integers():
    """
    测试函数 add 在输入正整数时能正确返回结果。
    """
    assert add(1, 2) == 3

def test_add_with_negative_integers():
    """
    测试函数 add 在输入负整数时能正确返回结果。
    """
    assert add(-5, -3) == -8

def test_add_with_type_error():
    """
    测试函数 add 在输入非整数值时是否抛出正确的 TypeError。
    """
    with pytest.raises(TypeError):
        add("text", 2)
```

### 测试说明
1. **`test_add_with_positive_integers`**  
   测试了两个正整数的输入，验证程序是否正确计算并返回 `3`。
2. **`test_add_with_negative_integers`**  
   测试了负整数的输入，验证程序是否正确计算并返回 `-8`。
3. **`test_add_with_type_error`**  
   测试了非整数值（如字符串 `text`）作为输入，验证程序是否能够检测并抛出 `TypeError`。

---

### 如何运行测试
1. 在项目中安装 `pytest`：  
   ```bash
   pip install pytest
   ```

2. 保存上述测试代码为 `test_add.py` 文件。

3. 在命令行运行测试：  
   ```bash
   pytest test_add.py
   ```

4. 观察测试输出：  
   如果代码正确运行，所有测试用例都应该通过，你会看到类似于：
   ```plaintext
   ============================= test session starts =============================
   ...
   collected 3 items

   test_add.py ...                                                           [100%]

   ============================== 3 passed in 0.02s ==============================
   ```

请确保你的 `add` 函数所在的模块路径正确，然后运行测试以验证功能！

以下是使用 JUnit 为 `findMax` 方法编写的单元测试代码，包含描述性方法名称并覆盖所列的三种测试场景。

```java
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class FindMaxTest {

    // Test case 1: Input integer array {1, 2, 3}, function returns max value 3
    @Test
    void testFindMaxWithValidArray() {
        // Arrange
        int[] nums = {1, 2, 3};
        int expected = 3;

        // Act
        int result = new FindMax().findMax(nums);

        // Assert
        assertEquals(expected, result, "The findMax method should return the maximum value in the array.");
    }

    // Test case 2: Input empty array {}, function throws IllegalArgumentException
    @Test
    void testFindMaxWithEmptyArray() {
        // Arrange
        int[] nums = {};

        // Act & Assert
        Exception exception = assertThrows(IllegalArgumentException.class, () -> {
            new FindMax().findMax(nums);
        });

        // Verify exception message if necessary
        assertEquals("Array cannot be null or empty", exception.getMessage(),
                "The findMax method should throw IllegalArgumentException with the correct message when the input array is empty.");
    }

    // Test case 3: Input NULL array, function throws IllegalArgumentException
    @Test
    void testFindMaxWithNullArray() {
        // Arrange
        int[] nums = null;

        // Act & Assert
        Exception exception = assertThrows(IllegalArgumentException.class, () -> {
            new FindMax().findMax(nums);
        });

        // Verify exception message if necessary
        assertEquals("Array cannot be null or empty", exception.getMessage(),
                "The findMax method should throw IllegalArgumentException with the correct message when the input array is null.");
    }
}
```

### 说明
1. **测试框架**：使用 `JUnit Jupiter`（JUnit 5），因为这是目前最受欢迎的单元测试框架之一。
2. **组织测试用例**：
   - 使用描述性的测试方法名称，清楚地表明每个测试的目的。
   - 将每个测试用例拆分为三个部分，分别是 Arrange（设置测试数据）、Act（调用方法）和 Assert（验证结果）。
3. **异常测试**：
   - `assertThrows` 方法用于验证是否抛出了预期的异常，并且可以校验抛出异常的消息内容。
4. **验证消息**：
   - 用 `assertEquals` 检查异常消息，确保它是开发者期望的输出。

### 假定条件
1. 定义 `FindMax` 类，其中包含 `findMax` 方法（假设在顶级类 `FindMax` 中实现）。
2. 不涉及外部操作，因此没有使用模拟框架，例如 Mockito。

### 测试环境
该代码需要 JUnit 5（JUnit Jupiter）支持，配置 `Maven` 时需要添加以下依赖：

```xml
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.10.0</version>
    <scope>test</scope>
</dependency>
```

运行以上单元测试代码后，您将验证 `findMax` 方法中的逻辑是否符合预期。

为了给你提到的 `fetchData` 函数编写完整的单元测试，我们将使用 Jest 的 `jest.mock()` 和 `global.fetch` 来模拟 `fetch` 的行为。同时覆盖所有提到的测试场景。

以下是完整的测试代码：

```javascript
// fetchData.js
const fetchData = async (url) => {
    if (!url) {
        throw new Error('URL cannot be empty');
    }
    const response = await fetch(url);
    if (!response.ok) {
        throw new Error('Network response was not ok');
    }
    return response.json();
};

module.exports = fetchData;
```

下面是 Jest 单元测试代码：

```javascript
// fetchData.test.js
const fetchData = require('./fetchData');

describe("fetchData function tests", () => {
    beforeEach(() => {
        // 重置 fetch 的模拟函数
        global.fetch = jest.fn();
    });

    afterEach(() => {
        // 清除 mocks 确保每个测试用例独立
        jest.clearAllMocks();
    });

    test("should return data when URL is valid and fetch is successful", async () => {
        const mockResponseData = { message: 'Success' };

        // 模拟 fetch 的行为
        global.fetch.mockResolvedValueOnce({
            ok: true,
            json: jest.fn().mockResolvedValueOnce(mockResponseData),
        });

        const url = "https://example.com/api";
        const data = await fetchData(url);

        // 断言 fetch 被正确调用
        expect(global.fetch).toHaveBeenCalledWith(url);
        // 断言返回结果正确
        expect(data).toEqual(mockResponseData);
    });

    test("should throw an error when URL parameter is an empty string", async () => {
        await expect(fetchData("")).rejects.toThrow('URL cannot be empty');
        // 确定 fetch 不会被调用
        expect(global.fetch).not.toHaveBeenCalled();
    });

    test("should throw an error when fetch returns a non-ok response", async () => {
        // 模拟 fetch 返回一个非 ok 的响应
        global.fetch.mockResolvedValueOnce({
            ok: false,
            json: jest.fn(),
        });

        const url = "https://example.com/api";
        await expect(fetchData(url)).rejects.toThrow('Network response was not ok');

        // 确保 fetch 被正确调用
        expect(global.fetch).toHaveBeenCalledWith(url);
    });
});
```

### 说明：
1. **第一种情况**: 使用一个有效的 `url`，模拟 `fetch` 返回一个成功的响应 (`ok: true`) 和含有正确数据结构的 `json()` 回调。通过 `jest.fn()` 模拟返回值，并且验证返回值是否符合预期。
2. **第二种情况**: 当 `url` 为空字符串时，直接应当抛出错误，同时确保 `fetch` 不会被调用。
3. **第三种情况**: 模拟一个 `fetch` 的失败请求 (`ok: false`)，捕获并验证是否抛出了网络错误。
4. **数据隔离**: 使用 `beforeEach()` 和 `afterEach()` 重置和清理 `fetch` 的 Mock 函数，以确保测试用例相互独立。

### 运行测试：
确保已安装 Jest，在命令行运行以下命令来测试：
```bash
jest fetchData.test.js
```

### 可选增强：
- 你可以在测试文件顶部直接通过 `jest.mock()` 自动模拟 `fetch` 请求。
- 添加测试报告以确认覆盖率（可通过 `jest --coverage` 完成）。