单元测试生成

以下是为 `add` 函数编写的全面单元测试代码，使用了 `pytest` 测试框架，确保测试覆盖以下场景：边界条件、正常输入、空值输入，以及正向和反向用例。

```python
import pytest

# 假设被测试函数定义在 "math_operations.py" 文件中
# from math_operations import add
from your_module import add  # 替换成你的模块路径

# 测试正常输入
@pytest.mark.parametrize(
    "a, b, expected",
    [
        (1, 1, 2),         # 正常正数相加
        (-1, -1, -2),      # 负数相加
        (1.5, 2.5, 4.0),   # 浮点数相加
        (0, 0, 0),         # 边界条件：0 加 0
        (100, 200, 300),   # 较大的正整数
        (-100, 50, -50),   # 正数和负数相加
    ]
)
def test_add_normal_cases(a, b, expected):
    assert add(a, b) == expected


# 测试空值输入
def test_add_with_none():
    with pytest.raises(TypeError):
        add(None, None)  # 两个参数都为 None

    with pytest.raises(TypeError):
        add(None, 1)  # 一个为空值

    with pytest.raises(TypeError):
        add(1, None)  # 一个为空值


# 测试非数值输入（反向用例）
@pytest.mark.parametrize(
    "a, b",
    [
        ("1", 2),         # 字符串和数字相加
        ([], 1),          # 列表和数字相加
        ({}, 1),          # 字典和数字相加
        (set(), 1),       # 集合和数字相加
        (True, 1),        # 布尔值和数字相加
    ]
)
def test_add_invalid_input(a, b):
    with pytest.raises(TypeError):  # 预期抛出 TypeError
        add(a, b)


# 边界条件测试
@pytest.mark.parametrize(
    "a, b, expected",
    [
        (float('inf'), 1, float('inf')),       # 正无穷大
        (float('-inf'), 1, float('-inf')),     # 负无穷大
        (float('inf'), float('-inf'), float('nan')),  # 正无穷加负无穷
        (0, float('nan'), float('nan')),       # 与 NaN 相加的情况
    ]
)
def test_add_boundary_cases(a, b, expected):
    result = add(a, b)
    if expected != expected:  # NaN 检测
        assert result != result
    else:
        assert result == expected


# 模拟依赖项（这里纯函数无外部依赖，不需要模拟依赖）
# 如果函数有外部依赖，例如数据库查询、网络请求等，可以通过 mock 的方式模拟依赖的行为。

```

### 测试说明：
1. **`test_add_normal_cases`**: 测试了一系列正常输入，包括正数、负数、浮点数、边界（包含 0）、较大整数以及混合正负数。
2. **`test_add_with_none`**: 测试了输入为 `None` 的边界情况，预期函数抛出 `TypeError`。
3. **`test_add_invalid_input`**: 使用非数值输入测试函数是否能够正确处理错误类型的参数，预期抛出 `TypeError`。
4. **`test_add_boundary_cases`**: 测试了特殊情况下的边界值输入：无穷大、NaN 等，确保函数处理这些边界值时的行为符合预期。
5. 模拟依赖项的部分在当前例子中不需要，因为 `add` 是一个纯函数，没有外部依赖。

### 运行测试
在命令行中运行以下命令以运行测试：
```bash
pytest -v
```

`pytest` 将会以详细模式显示测试结果，每个场景的结果都会清晰显示。

以下是针对 `multiply` 方法使用 JUnit 编写的单元测试。我们将覆盖所有提到的场景，包括正常输入、非法输入、最大最小值输入、正向与反向用例，以及边界条件。

需要注意的是原始函数 `multiply` 方法接收的是两个整数 `int x` 和 `int y`，并简单返回它们的乘积。由于该函数无异常处理或依赖项，没有直接的「非法输入」，我们假设非法输入不适用于 `multiply`。测试重点会放在边界条件测试上，例如最大值、最小值溢出等。

以下是单元测试代码：

### 测试代码

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

public class MultiplyTest {

    // 待测试的方法
    public int multiply(int x, int y) {
        return x * y;
    }

    // 正常输入测试：两个正整数
    @Test
    public void testNormalPositiveInput() {
        assertEquals(20, multiply(4, 5), "Multiply of 4 and 5 should be 20");
    }

    // 正常输入测试：一个正整数和零
    @Test
    public void testMultiplyWithZero() {
        assertEquals(0, multiply(4, 0), "Multiply of 4 and 0 should be 0");
        assertEquals(0, multiply(0, 100), "Multiply of 0 and 100 should be 0");
    }

    // 正常输入测试：两个负整数
    @Test
    public void testNegativeInput() {
        assertEquals(20, multiply(-4, -5), "Multiply of -4 and -5 should be 20");
    }

    // 正常输入测试：一个正整数和一个负整数
    @Test
    public void testPositiveAndNegativeInput() {
        assertEquals(-20, multiply(4, -5), "Multiply of 4 and -5 should be -20");
        assertEquals(-20, multiply(-4, 5), "Multiply of -4 and 5 should be -20");
    }

    // 边界条件测试：整数最大值和最小值
    @Test
    public void testBoundaryConditions() {
        assertEquals(Integer.MAX_VALUE, multiply(Integer.MAX_VALUE, 1), "Multiply of Integer.MAX_VALUE and 1 should be Integer.MAX_VALUE");
        assertEquals(Integer.MIN_VALUE, multiply(Integer.MIN_VALUE, 1), "Multiply of Integer.MIN_VALUE and 1 should be Integer.MIN_VALUE");
    }

    // 边界条件：可能的整数溢出
    @Test
    public void testOverflow() {
        assertEquals(0, multiply(Integer.MIN_VALUE, 0), "Multiply of Integer.MIN_VALUE and 0 should be 0");

        // 对可能存在的溢出行为进行保护
        assertThrows(ArithmeticException.class, new Executable() {
            @Override
            public void execute() {
                int result = multiply(Integer.MAX_VALUE, 2); // 假象溢出手段 /保护灵活

以下是基于 `Google Test` 的单元测试代码，它对 `divide` 函数测试了正向、反向用例、边界条件和异常情况：

```cpp
#include <gtest/gtest.h>
#include <stdexcept>

// 被测试函数
int divide(int a, int b) {
    if (b != 0) return a / b;
    throw std::invalid_argument("Division by zero");
}

// 测试用例
TEST(DivideFunctionTest, NormalInputs) {
    // 正常输入测试的正向用例
    EXPECT_EQ(divide(4, 2), 2);
    EXPECT_EQ(divide(9, 3), 3);
    EXPECT_EQ(divide(-10, 2), -5);
    EXPECT_EQ(divide(10, -2), -5);
    EXPECT_EQ(divide(-10, -2), 5);

    // 正常输入测试的反向用例
    EXPECT_NE(divide(5, 2), 3);  // 5 / 2 = 2（整数除法）
    EXPECT_NE(divide(8, 4), 1);  // 8 / 4 = 2
}

TEST(DivideFunctionTest, DivisionByZero) {
    // 异常情况：除以零应该抛出异常
    EXPECT_THROW(divide(5, 0), std::invalid_argument);
    EXPECT_THROW(divide(0, 0), std::invalid_argument);
}

TEST(DivideFunctionTest, DivisionWithZeroDividend) {
    // 边界条件：被除数为 0
    EXPECT_EQ(divide(0, 1), 0);   // 0 / 1 = 0
    EXPECT_EQ(divide(0, -1), 0);  // 0 / -1 = 0
}

TEST(DivideFunctionTest, BoundaryInputs) {
    // 测试 int 的边界值
    EXPECT_EQ(divide(INT_MAX, 1), INT_MAX);   // 最大正数除以 1
    EXPECT_EQ(divide(INT_MIN, 1), INT_MIN);   // 最小负数除以 1
    EXPECT_EQ(divide(INT_MIN, -1), INT_MAX);  // 特殊情况：整型溢出（INT_MIN / -1）
    EXPECT_EQ(divide(INT_MAX, INT_MAX), 1);   // 自身除以自身
    EXPECT_EQ(divide(INT_MIN, INT_MIN), 1);   // 自身除以自身

    // 边界值条件下的其他测试
    EXPECT_EQ(divide(1, INT_MAX), 0);  // 1 / INT_MAX = 0（截断）
    EXPECT_EQ(divide(-1, INT_MAX), 0); // -1 / INT_MAX = 0（截断）
}

TEST(DivideFunctionTest, ReversedInputs) {
    // 测试输入的正负相反场景
    EXPECT_EQ(divide(10, -2), -5);  // 正数除以负数
    EXPECT_EQ(divide(-10, 2), -5);  // 负数除以正数
    EXPECT_EQ(divide(-10, -2), 5);  // 负数除以负数
    EXPECT_EQ(divide(10, 2), 5);    // 正数除以正数
}

```

---

### 测试解释：

1. **正常输入测试**：
   - 测试常规情况下的函数行为，例如 `(4, 2)` 应正常返回 `2`。
   - 包括正向用例（与预期结果匹配）和反向用例（结果不应匹配某个特定非预期值）。

2. **异常情况测试**：
   - 测试不合法输入，例如除零操作 `divide(5, 0)`，应该抛出一个异常 `std::invalid_argument`。

3. **边界条件测试**：
   - 检查特殊数值边界条件，例如 `INT_MAX` 和 `INT_MIN`，确保函数能够正确处理整数的最大值和最小值。

4. **边界起点测试**：
   - 当除数接近±1、被除数为±0等情况时，测试行为是否合理。

5. **反向测试**：
   - 调换输入的正负号，验证输出结果的符号是否合乎预期。

---

### 运行测试：

1. 安装 Google Test 库。
2. 编写上述测试代码并链接到 Google Test。
3. 使用 `cmake` 或命令行执行，例如：
   ```bash
   g++ -std=c++11 -lgtest -lgtest_main -pthread divide_test.cpp -o divide_test
   ./divide_test
   ```

测试目标是确保函数行为在所有场景下都健壮可靠，让潜在缺陷早日显现。希望这段代码对你有所帮助！