1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

// src/calculator.rs
// 这是一个简单的计算器模块，我们将为它编写单元测试

/// 加法函数：计算两个 i32 整数的和
/// # 示例
/// assert_eq!(add(2, 3), 5);
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

/// 减法函数：计算两个 i32 整数的差
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}

/// 乘法函数：计算两个 i32 整数的积
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

/// 除法函数：计算两个 i32 整数的商
/// 如果除数为零，会 panic（这是一个有争议的设计，但这是一本 Rust 教程，我们假装这是正常的）
pub fn divide(a: i32, b: i32) -> i32 {
    if b == 0 {
        panic!("除数不能为零！你是在玩火知道吗？");
    }
    a / b
}

// 这里是单元测试模块，注意 #[cfg(test)] 属性
#[cfg(test)]
mod tests {
    // 注意：这里我们导入了父模块的项（super）
    // 这样就可以直接使用 add, subtract 等函数，而不需要写 super::add
    use super::*;

    #[test]
    fn test_add() {
        // 测试加法基本功能
        assert_eq!(add(2, 3), 5);
        // 测试负数
        assert_eq!(add(-1, 1), 0);
        // 测试零
        assert_eq!(add(0, 0), 0);
    }

    #[test]
    fn test_subtract() {
        assert_eq!(subtract(5, 3), 2);
        assert_eq!(subtract(3, 5), -2);
    }

    #[test]
    fn test_multiply() {
        assert_eq!(multiply(3, 4), 12);
        assert_eq!(multiply(-2, 5), -10);
    }

    #[test]
    #[should_panic(expected = "除数不能为零")]
    fn test_divide_by_zero() {
        divide(10, 0); // 这应该 panic
    }

    #[test]
    fn test_divide() {
        assert_eq!(divide(10, 2), 5);
        assert_eq!(divide(-10, 2), -5);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#[cfg(test)]
mod advanced_tests {
    use super::*;

    // 普通测试：正常情况下应该通过
    #[test]
    fn normal_test() {
        assert!(true, "true 当然是 true，不然呢？");
    }

    // 预期 panic 的测试：除零错误
    #[test]
    #[should_panic(expected = "除数不能为零")]
    fn test_divide_should_panic() {
        divide(1, 0);
    }

    // 被忽略的测试：这只"懒测试"不会被执行
    #[test]
    #[ignore]
    fn test_ignored() {
        // 我被 ignore 了，所以我永远不会运行
        // 也许是因为我太慢了，也许是因为我太难了
        // 也许只是因为写我的人还没想好怎么实现我
        panic!("这个 panic 永远不会发生，因为测试被忽略了");
    }

    // 带超时（需要 nightly）的测试
    // 注意：在稳定版 Rust 中，timeout 需要通过 cargo test 的参数指定
    // 或者使用 testthat crate
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

// src/internal.rs

/// 内部使用的辅助函数，判断一个数是否为正数
/// 注意：这个函数没有 pub，是私有的
fn is_positive(n: i32) -> bool {
    n > 0
}

/// 内部使用的辅助函数，对输入做安全检查
/// 如果输入为负数或零，会返回 None
fn validate_positive(n: i32) -> Option<i32> {
    if n <= 0 {
        None
    } else {
        Some(n)
    }
}

/// 公开 API：计算正整数的阶乘
/// 注意：0! = 1（数学定义），所以这里处理的是非负整数
pub fn factorial(n: i32) -> i32 {
    if n < 0 {
        panic!("阶乘只支持非负整数，你传了个 {} 是想怎样？", n);
    }

    match n {
        0 => 1,  // 0! = 1
        1 => 1,
        _ => n * factorial(n - 1)
    }
}

// 测试模块
#[cfg(test)]
mod tests {
    use super::*;

    // 测试私有函数 is_positive —— 在 Rust 中这是完全合法的！
    #[test]
    fn test_is_positive() {
        assert!(is_positive(42));
        assert!(is_positive(1));
        assert!(!is_positive(0));
        assert!(!is_positive(-1));
        assert!(!is_positive(-999));
    }

    #[test]
    fn test_validate_positive() {
        assert_eq!(validate_positive(5), Some(5));
        assert_eq!(validate_positive(1), Some(1));
        assert_eq!(validate_positive(0), None);
        assert_eq!(validate_positive(-1), None);
        assert_eq!(validate_positive(-100), None);
    }

    // 公有 API 测试
    #[test]
    fn test_factorial() {
        assert_eq!(factorial(0), 1);  // 0! = 1
        assert_eq!(factorial(1), 1);
        assert_eq!(factorial(5), 120);
        assert_eq!(factorial(10), 3628800);
    }

    #[test]
    #[should_panic(expected = "阶乘只支持非负整数")]
    fn test_factorial_negative() {
        factorial(-1);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// tests/test_integration.rs
// 这是一个集成测试文件，它是一个独立的二进制，不是库

// 首先，需要把我们要测试的 crate 引入作用域
// 使用 extern crate（Rust 2018 之前）或直接 use（Rust 2018 之后）
// 这里演示 Rust 2018+ 的写法

use my_project::Calculator; // 假设 lib.rs 导出了 Calculator

#[test]
fn test_calculator_add() {
    let calc = Calculator::new();
    assert_eq!(calc.add(2, 3), 5);
}

#[test]
fn test_calculator_chain() {
    let calc = Calculator::new();
    calc.add(10, 5);
    calc.multiply(3, 4);
    // 假设 Calculator 有 display 方法返回当前值
    assert_eq!(calc.display(), 45); // (10+5) * 3 = 45
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// tests/common/mod.rs
// 共享的测试辅助代码

/// 创建一个带默认值的计算器，用于测试
pub fn create_default_calculator() -> my_project::Calculator {
    let calc = my_project::Calculator::new();
    calc
}

/// 打印测试分隔线，让输出更美观
pub fn print_test_divider(name: &str) {
    println!("\n{}", "=".repeat(60));
    println!("测试: {}", name);
    println!("{}", "=".repeat(60));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// tests/test_integration.rs
// 使用 common 模块中的辅助代码

mod common; // 引入 common 模块

use my_project::Calculator;

#[test]
fn test_with_helper() {
    common::print_test_divider("带辅助函数的测试");
    let calc = common::create_default_calculator();
    assert_eq!(calc.add(1, 1), 2);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

// src/lib.rs
// 库的主入口文件

/// 计算器模块
pub mod calculator {
    /// 一个简单的计算器结构体
    pub struct Calculator {
        value: i32,
    }

    impl Calculator {
        /// 创建新的计算器实例，初始值为 0
        pub fn new() -> Self {
            Calculator { value: 0 }
        }

        /// 加法：将输入的两个数相加，并将结果存储到 value
        pub fn add(&mut self, a: i32, b: i32) -> i32 {
            self.value = a + b;
            self.value
        }

        /// 减法：将输入的两个数相减，并将结果存储到 value
        pub fn sub(&mut self, a: i32, b: i32) -> i32 {
            self.value = a - b;
            self.value
        }

        /// 乘法：将输入的两个数相乘，并将结果存储到 value
        pub fn mul(&mut self, a: i32, b: i32) -> i32 {
            self.value = a * b;
            self.value
        }

        /// 除法：将输入的两个数相除，并将结果存储到 value
        /// 如果除数为零，会 panic
        pub fn div(&mut self, a: i32, b: i32) -> i32 {
            if b == 0 {
                panic!("除数不能为零！你在试图打开通往数学地狱的大门吗？");
            }
            self.value = a / b;
            self.value
        }

        /// 获取当前计算器的值
        pub fn get_value(&self) -> i32 {
            self.value
        }

        /// 重置计算器值为 0
        pub fn reset(&mut self) {
            self.value = 0;
        }
    }

    // 为 Calculator 实现 Default trait，这样可以用 ..Default::default() 来创建
    impl Default for Calculator {
        fn default() -> Self {
            Self::new()
        }
    }
}

#[cfg(test)]
mod tests {
    use super::calculator::Calculator;
    use super::*;

    #[test]
    fn test_calculator_basic() {
        let mut calc = Calculator::new();
        assert_eq!(calc.get_value(), 0);
        
        calc.add(10, 5);
        assert_eq!(calc.get_value(), 15);
        
        calc.reset();
        assert_eq!(calc.get_value(), 0);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

// tests/calculator_integration.rs
// 集成测试：站在用户角度测试计算器的公开 API

use my_project::calculator::Calculator;

#[test]
fn test_calculator_operations() {
    let mut calc = Calculator::new();
    
    // 测试加法
    let result = calc.add(100, 200);
    assert_eq!(result, 300);
    assert_eq!(calc.get_value(), 300);
    
    // 测试减法
    let result = calc.sub(calc.get_value(), 50);
    assert_eq!(result, 250);
    
    // 测试乘法
    let result = calc.mul(3, 4);
    assert_eq!(result, 12);
    
    // 测试除法
    let result = calc.div(100, 4);
    assert_eq!(result, 25);
}

#[test]
fn test_calculator_chaining() {
    // 测试连续操作
    let mut calc = Calculator::new();
    
    // 连续加法
    calc.add(1, 2); // value = 3
    calc.add(3, 4); // value = 7
    calc.add(5, 6); // value = 11
    
    assert_eq!(calc.get_value(), 11);
}

#[test]
#[should_panic(expected = "除数不能为零")]
fn test_divide_by_zero() {
    let mut calc = Calculator::new();
    calc.div(10, 0); // 这应该 panic
}

#[test]
fn test_default() {
    // 测试 Default 实现
    let calc = Calculator::default();
    assert_eq!(calc.get_value(), 0);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

$ cargo test --test calculator_integration
   Compiling my_project v0.1.0
    Finished test [unoptimized + debuginfo]
     Running tests/calculator_integration.rs

running 4 tests
test test_calculator_operations ... ok
test test_calculator_chaining ... ok
test test_divide_by_zero ... ok
test test_default ... ok

test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

1
2
3
4
5
6
7
8
9

// tests/ui/divide_by_zero.rs
// 这段代码故意写错，预期编译器会报错

// 当尝试编译这段代码时，Rust 编译器会报错
// 因为整数除法需要两个操作数，但我们只给了一个

fn main() {
    let result = 10 / ; // 缺少除数，语法错误！
}

1
2
3
4
5
6
7
8
9

// tests/ui/private_field_access.rs
// 测试：尝试直接访问私有字段应该导致编译错误

fn main() {
    // 假设 Temperature 的 fahrenheit 字段是私有的
    // 这段代码应该编译失败，因为外部代码不能直接访问私有字段
    let temp = Temperature { fahrenheit: 98.6 };
    //                    ^^^^^^^^^^^^^^^^^^ 错误：字段 `fahrenheit` 是私有的
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

$ cargo test --test ui divide_by_zero
   Compiling my_project v0.1.0
    Building tests/ui/divide_by_zero.rs

error: compiling my_project v0.1.0 (tests/ui/divide_by_zero.rs) failed

--- stderr
error: unexpected token: `;`
 --> tests/ui/divide_by_zero.rs:3:17
  |
3 |     let result = 10 / ;
  |                      ^ expected expression

---

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

// src/lib.rs

/// 计算字符串中单词的数量
///
/// # 示例
///
/// ```
/// use my_project::count_words;
/// assert_eq!(count_words("hello world"), 2);
/// assert_eq!(count_words("Rust 是一门很棒的语言"), 3);
/// ```
///
/// # 参数
/// * `s` - 输入的字符串
///
/// # 返回值
/// 返回单词的数量（以空格分隔）
pub fn count_words(s: &str) -> usize {
    s.split_whitespace().count()
}

/// 判断一个数是否为质数
///
/// # 示例
///
/// ```
/// use my_project::is_prime;
///
/// assert!(is_prime(2));
/// assert!(is_prime(3));
/// assert!(is_prime(5));
/// assert!(!is_prime(4));
/// assert!(!is_prime(1));
/// assert!(!is_prime(0));
/// ```
pub fn is_prime(n: u32) -> bool {
    if n < 2 {
        return false;
    }
    for i in 2..n {
        if n % i == 0 {
            return false;
        }
    }
    true
}

/// 一个表示温度的结构体
///
/// # 示例
///
/// 创建华氏温度并转换为摄氏温度：
///
/// ```
/// use my_project::Temperature;
///
/// let hot = Temperature::from_fahrenheit(98.6);
/// println!("体温是 {} 摄氏度", hot.to_celsius());
/// // 输出类似: 体温是 37 摄氏度
/// ```
#[derive(Debug, Clone, Copy)]
pub struct Temperature {
    fahrenheit: f64,
}

impl Temperature {
    /// 从华氏温度创建温度对象
    ///
    /// # 示例
    ///
    /// ```
    /// use my_project::Temperature;
    ///
    /// let temp = Temperature::from_fahrenheit(32.0);
    /// assert_eq!(temp.to_celsius(), 0.0); // 冰点
    /// ```
    pub fn from_fahrenheit(f: f64) -> Self {
        Temperature { fahrenheit: f }
    }

    /// 转换为摄氏温度
    ///
    /// # 示例
    ///
    /// ```
    /// use my_project::Temperature;
    ///
    /// let temp = Temperature::from_fahrenheit(212.0);
    /// assert!((temp.to_celsius() - 100.0).abs() < 0.001); // 沸点
    /// ```
    pub fn to_celsius(&self) -> f64 {
        (self.fahrenheit - 32.0) * 5.0 / 9.0
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

$ cargo test --doc
   Compiling my_project v0.1.0
    Documenting my_project v0.1.0
     Running doctests (examples are compiled and run as tests)

running 5 tests
src/lib.rs:13: count_words ... ok
src/lib.rs:20: is_prime ... ok
src/lib.rs:39: Temperature::from_fahrenheit ... ok
src/lib.rs:48: Temperature::to_celsius ... ok
src/lib.rs:34: Temperature struct ... ok

test result: ok. 5 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

/// 计算斐波那契数列（忽略此代码块）
///
/// ```ignore
/// // 这个例子太长了，运行时会花费很长时间
/// fn fibonacci(n: u64) -> u64 {
///     match n {
///         0 => 0,
///         1 => 1,
///         _ => fibonacci(n - 1) + fibonacci(n - 2),
///     }
/// }
/// ```
pub fn some_unrelated_function() {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

/// 正确创建温度的方式：
///
/// ```
/// use my_project::Temperature;
/// let temp = Temperature::from_fahrenheit(25.0);
/// ```
///
/// 错误：直接访问字段是不允许的！
///
/// ```compile_fail
/// let temp = Temperature { fahrenheit: 25.0 }; // 编译错误！字段是私有的
/// ```
pub fn some_function() {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

/// # 正确的用法
///
/// ```
/// use my_project::counter::Counter;
///
/// let mut c = Counter::new();
/// c.increment();
/// assert_eq!(c.get(), 1);
/// ```
///
/// # 错误的用法
///
/// 这个错误用法会被编译器阻止：
///
/// ```compile_fail,E0603
/// // Counter::value 是私有的，无法直接访问
/// let c = Counter { value: 10 }; // 私有字段不能这样初始化
/// ```
pub mod counter {
    /// 计数器
    pub struct Counter {
        value: i32, // 私有字段
    }

    impl Counter {
        /// 创建新计数器
        pub fn new() -> Self {
            Counter { value: 0 }
        }

        /// 增加计数
        pub fn increment(&mut self) {
            self.value += 1;
        }

        /// 获取当前值
        pub fn get(&self) -> i32 {
            self.value
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_basic_assertion() {
        // 基本 assert! 用法
        let is_even = |x: i32| x % 2 == 0;
        
        assert!(is_even(4), "4 应该是偶数，这条消息在 assert 失败时显示");
        assert!(!is_even(3), "3 不是偶数");
    }

    #[test]
    fn test_debug_assert() {
        // debug_assert! 在 release 模式下会被完全删除
        let value = 42;
        
        debug_assert!(value > 0, "value 应该是正数");
        debug_assert!(value < 100, "value 应该小于 100");
        
        // 这些在 cargo build --release 时不会执行任何检查
        // 但在 cargo build（debug）时会检查
    }

    #[test]
    fn test_assertion_with_formatted_message() {
        let name = "Alice";
        let age = 25;
        
        // assert! 支持格式化消息，和 println! 一样的语法
        assert!(
            age >= 18,
            "用户 {} 年龄是 {}，未满 18 岁，拒绝访问！",
            name, age
        );
    }

    #[test]
    fn test_logic_assertions() {
        // assert! 可以用于复杂的逻辑表达式
        let x = 10;
        let y = 20;
        
        assert!(
            x > 0 && y > 0,
            "两个数都应该是正数: x={}, y={}", x, y
        );
        
        assert!(
            x < y,
            "x({}) 应该小于 y({})", x, y
        );
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

#[cfg(test)]
mod tests {
    #[test]
    fn test_assert_eq_basics() {
        // 数字比较
        assert_eq!(2 + 2, 4);
        
        // 字符串比较
        assert_eq!("hello".to_uppercase(), "HELLO");
        
        // 数组比较
        assert_eq!([1, 2, 3], [1, 2, 3]);
        
        // 布尔比较
        assert_eq!(5 > 3, true);
    }

    #[test]
    fn test_assert_eq_with_vec() {
        let v1 = vec![1, 2, 3];
        let v2 = vec![1, 2, 3];
        
        // Vec 的 assert_eq! 会打印出完整内容
        assert_eq!(v1, v2);
    }

    #[test]
    fn test_assert_eq_failure_output() {
        let actual = 42;
        let expected = 43;
        
        // 当这个 assert 失败时，你会看到类似这样的输出：
        // thread 'test_assert_eq_failure_output' panicked at 'assertion failed: `(left == right)`
        //   left: `42`
        //  right: `43`
        // ', src/lib.rs:XX:XX
        
        // 下面这行会失败，取消注释可以看效果
        // assert_eq!(actual, expected);
    }

    #[test]
    fn test_debug_assert_eq() {
        let x = 100;
        let y = 100;
        
        // debug_assert_eq! 在 release 模式被忽略
        debug_assert_eq!(x, y);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#[cfg(test)]
mod tests {
    #[test]
    fn test_assert_ne_basic() {
        // 不相等的值
        assert_ne!(1, 2);
        assert_ne!("apple", "banana");
        assert_ne!(vec![1, 2], vec![3, 4]);
        
        // 逻辑上不相等
        assert_ne!(10 > 5, false); // 10 > 5 是 true，不等于 false
    }

    #[test]
    fn test_value_changed() {
        let mut v = vec![1, 2, 3];
        let original_len = v.len();
        
        v.push(4);
        
        // 确认 push 确实改变了长度
        assert_ne!(v.len(), original_len, "push 后长度应该变化");
        assert_eq!(v.len(), 4);
    }

    #[test]
    fn test_mutation() {
        let mut s = String::from("hello");
        let original = s.clone();
        
        s.push_str(", world");
        
        // 确认字符串确实被修改了
        assert_ne!(s, original, "字符串修改后应该和原来不同");
        assert_eq!(s, "hello, world");
    }

    #[test]
    fn test_assert_ne_failure_message() {
        let a = 10;
        let b = 10;
        
        // 取消注释可以看到失败输出
        // assert_ne!(a, b); // thread panicked: assertion failed: a != b
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

#[cfg(test)]
mod tests {
    #[derive(Debug, Clone)]
    struct User {
        name: String,
        age: u32,
        email: String,
    }

    impl User {
        fn new(name: &str, age: u32, email: &str) -> Self {
            User {
                name: name.to_string(),
                age,
                email: email.to_string(),
            }
        }
    }

    #[test]
    fn test_user_creation() {
        let user = User::new("Alice", 30, "alice@example.com");
        
        assert_eq!(user.name, "Alice");
        assert_eq!(user.age, 30);
        assert_eq!(user.email, "alice@example.com");
    }

    #[test]
    fn test_validation_with_custom_messages() {
        let age = 15;
        
        // 提供更多上下文信息
        assert!(
            age >= 18,
            "用户未满 18 岁，禁止注册。实际年龄: {}", age
        );
    }

    #[test]
    fn test_order_processing() {
        let cart_total = 150.0;
        let discount_threshold = 100.0;
        let discount_amount = 10.0;
        
        let final_price = if cart_total > discount_threshold {
            cart_total - discount_amount
        } else {
            cart_total
        };
        
        assert_eq!(
            final_price,
            140.0,
            "购物车总价为 {}，超过 {}，应享受 {} 折扣",
            cart_total, discount_threshold, discount_amount
        );
    }

    #[test]
    fn test_complex_assertion_message() {
        let numbers = vec![1, 2, 3, 4, 5];
        let expected_sum = 15;
        let expected_product = 120;
        
        let actual_sum: i32 = numbers.iter().sum();
        let actual_product: i32 = numbers.iter().product();
        
        assert_eq!(
            actual_sum,
            expected_sum,
            "数字 {:?} 的和应该是 {}，实际是 {}", 
            numbers, expected_sum, actual_sum
        );
        
        assert_eq!(
            actual_product,
            expected_product,
            "数字 {:?} 的积应该是 {}，实际是 {}",
            numbers, expected_product, actual_product
        );
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 基本用法：运行所有测试（单元测试 + 集成测试 + 文档测试）
$ cargo test

# 只运行单元测试和集成测试（不包括文档测试）
$ cargo test --lib

# 只运行文档测试
$ cargo test --doc

# 运行特定测试（只显示名字匹配的测试）
$ cargo test test_name

# 显示测试输出（默认情况下，测试通过时的 println! 输出被隐藏）
$ cargo test -- --nocapture

# 指定测试线程数（默认是 CPU 核心数）
$ cargo test -- --test-threads=1

# 并行运行测试但显示详细输出
$ cargo test -- --nocapture --test-threads=4

1
2
3
4
5

# 运行库中的所有单元测试
$ cargo test --lib

# 运行库中名字匹配 add 的测试
$ cargo test --lib add

1
2
3
4
5

# 只运行文档测试
$ cargo test --doc

# 运行文档测试中匹配某个模式的测试
$ cargo test --doc Temperature

1
2
3
4
5
6
7
8

# 运行 tests/integration.rs 这个集成测试
$ cargo test --test integration

# 运行 tests/api.rs
$ cargo test --test api

# 运行同时显示输出
$ cargo test --test integration -- --nocapture

1
2
3
4
5

# 运行测试并显示 stdout 输出
$ cargo test -- --nocapture

# 只对特定测试显示输出
$ cargo test test_with_println -- --nocapture

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// 带有打印输出的测试
#[test]
fn test_with_println() {
    let result = vec![1, 2, 3, 4, 5];
    
    println!("测试输入: {:?}", result);
    
    let sum: i32 = result.iter().sum();
    let expected = 15;
    
    println!("计算得到 sum = {}，期望 sum = {}", sum, expected);
    
    assert_eq!(sum, expected);
    
    println!("测试通过！sum = {}", sum);
}

1
2
3
4
5
6
7
8

# 用 1 个线程运行测试（串行，输出更容易阅读）
$ cargo test -- --test-threads=1

# 用 4 个线程运行测试
$ cargo test -- --test-threads=4

# 用尽可能多的线程（unlimited）
$ cargo test -- --test-threads=0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

#[cfg(test)]
mod tests {
    use super::*;

    // 正常测试：验证 divide 函数在正常输入时的行为
    #[test]
    fn test_divide_normal() {
        assert_eq!(divide(10, 2), 5);
        assert_eq!(divide(-10, 2), -5);
        assert_eq!(divide(0, 1), 0);
    }

    // 预期 panic 测试：验证除零会导致 panic
    #[test]
    #[should_panic(expected = "除数不能为零")]
    fn test_divide_by_zero_should_panic() {
        divide(10, 0);
    }

    // 预期 panic 测试：验证对负数开平方根会 panic
    #[test]
    #[should_panic(expected = "不能对负数开平方根")]
    fn test_sqrt_negative_should_panic() {
        sqrt(-1.0);
    }

    // 预期 panic 测试：验证空 vector 的 pop 会 panic
    #[test]
    #[should_panic(expected = "pop from empty vector")]
    fn test_pop_empty_should_panic() {
        let v: Vec<i32> = vec![];
        v.pop(); // 应该 panic
    }

    // 预期 panic 测试：验证超出范围索引会 panic
    #[test]
    #[should_panic(expected = "index out of bounds")]
    fn test_vec_index_out_of_bounds_should_panic() {
        let v = vec![1, 2, 3];
        let _ = v[100]; // 应该 panic
    }

    // 预期 panic 测试：验证自定义 panic 消息
    #[test]
    #[should_panic(expected = "账户余额不足")]
    fn test_withdraw_insufficient_funds_should_panic() {
        let mut account = BankAccount::new(100);
        account.withdraw(200); // 应该 panic，消息包含"账户余额不足"
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#[cfg(test)]
mod tests {
    // 假设我们有多种 panic 场景的代码

    // 场景 1：除数不能为零
    #[test]
    #[should_panic(expected = "除数不能为零")]
    fn test_divide_by_zero() {
        divide(10, 0);
    }

    // 场景 2：被除数不能为负数
    #[test]
    #[should_panic(expected = "被除数不能为负数")]
    fn test_divide_negative_dividend() {
        divide(-10, 2);
    }

    // 场景 3：结果溢出
    #[test]
    #[should_panic(expected = "计算结果溢出")]
    fn test_divide_overflow() {
        divide(i32::MAX, 1); // 如果实现有问题可能溢出
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#[cfg(test)]
mod tests {
    use super::*;

    // 普通测试：总是运行
    #[test]
    fn test_quick_operation() {
        assert!(true);
    }

    // 被忽略的测试：不会运行
    #[test]
    #[ignore]
    fn test_slow_database_operation() {
        // 这个测试需要连接真实的数据库，太慢了
        // 平时开发时不运行，只在 CI 或手动验证时运行
        // let db = Database::connect("production-server");
        // assert!(db.query("SELECT * FROM users").is_ok());
    }

    // 被忽略的测试：需要特定条件
    #[test]
    #[ignore]
    fn test_platform_specific_feature() {
        // 这个功能只在 Windows 上有效
        // 在 Linux 上测试没意义
        #[cfg(target_os = "windows")]
        {
            // Windows 特定实现
        }
    }

    // 运行所有测试包括 ignored 的：
    // cargo test -- --ignored
    
    // 注意：cargo test 没有 --ignored-only 这样的标志
    // 如果只想运行 ignored 的测试，可以结合 --ignored 和测试名过滤
    // cargo test -- --ignored <pattern>  # 只运行 ignored 且名字匹配的测试
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// 使用 testthat crate 实现超时测试

#[cfg(test)]
mod tests {
    use std::time::Duration;
    use std::thread;

    // 简单的手动超时测试
    #[test]
    fn test_with_manual_timeout() {
        let handle = thread::spawn(|| {
            // 模拟一个可能很慢的操作
            expensive_computation()
        });

        // 等待线程完成，最多等 5 秒
        let result = handle.join_timeout(Duration::from_secs(5));
        
        assert!(result.is_ok(), "测试超时！操作执行时间超过 5 秒");
    }

    fn expensive_computation() {
        // 模拟耗时操作
        thread::sleep(Duration::from_millis(100));
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#![feature(test)]

extern crate test;

#[test]
#[test::timeout(secs = 2)]
fn test_with_timeout() {
    // 如果这个测试运行超过 2 秒，会自动失败
    thread::sleep(Duration::from_secs(3));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#![feature(bench_black_box)]

extern crate test;

use test::Bencher;

#[cfg(test)]
mod benchmarks {
    use super::*;
    use test::black_box;

    #[bench]
    fn bench_simple_addition(b: &mut Bencher) {
        // b.iter 闭包内的代码会被多次运行并计时
        b.iter(|| {
            let mut sum = 0;
            for i in 0..1000 {
                sum += i;
            }
            sum
        });
    }

    #[bench]
    fn bench_vector_creation(b: &mut Bencher) {
        b.iter(|| {
            (0..1000).collect::<Vec<_>>()
        });
    }

    #[bench]
    fn bench_string_concat(b: &mut Bencher) {
        b.iter(|| {
            let mut s = String::new();
            for i in 0..100 {
                s.push_str("hello");
            }
            s
        });
    }
}

1
2
3
4
5
6

[dev-dependencies]
criterion = "0.5"

[[bench]]
name = "my_benchmark"
harness = false

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

// benches/my_benchmark.rs
// 注意：基准测试文件放在 benches/ 目录，不是 tests/

use criterion::{black_box, criterion_group, criterion_main, Criterion};

/// 待测试的函数
fn fibonacci(n: u64) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        _ => fibonacci(n - 1) + fibonacci(n - 2),
    }
}

/// 迭代版本的斐波那契（更高效）
fn fibonacci_iterative(n: u64) -> u64 {
    if n <= 1 {
        return n;
    }
    let mut a = 0;
    let mut b = 1;
    for _ in 2..=n {
        let temp = a + b;
        a = b;
        b = temp;
    }
    b
}

fn bench_fibonacci(c: &mut Criterion) {
    let mut group = c.benchmark_group("fibonacci");
    
    // 测试递归版本（慢）
    group.bench_function("recursive_10", |b| {
        b.iter(|| fibonacci(black_box(10)))
    });
    
    // 测试迭代版本（快）
    group.bench_function("iterative_10", |b| {
        b.iter(|| fibonacci_iterative(black_box(10)))
    });
    
    // 测试更大的输入
    group.bench_function("iterative_40", |b| {
        b.iter(|| fibonacci_iterative(black_box(40)))
    });
    
    group.finish();
}

criterion_group!(benches, bench_fibonacci);
criterion_main!(benches);

1
2
3
4
5
6
7

# 开发时运行基准测试
$ cargo bench

# criterion 会输出类似这样的结果：
# fibonacci/iterative_40
#                         time: [25.123 us 25.456 us 25.789 us]
#                         change: [-1.23% +0.45% +2.10%] (p = 0.23 not significant)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

use criterion::{black_box, Criterion};

fn fibonacci_benchmark(c: &mut Criterion) {
    let mut c = c.benchmark_group("fibonacci");
    
    // 配置图表输出
    c.sample_size(100)           // 每个测试采样 100 次
      .noise_threshold(0.05)     // 允许 5% 的噪声
      .warm_up_time(std::time::Duration::from_secs(1)); // 预热 1 秒
    
    c.bench_function("fib_30", |b| {
        b.iter(|| fibonacci_iterative(black_box(30)))
    });
}

1
2
3
4
5

# 安装 cargo-fuzz
$ cargo install cargo-fuzz

# 在项目根目录初始化模糊测试目标
$ cargo fuzz init

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// fuzz/fuzz_targets/fuzz_target_1.rs

#![no_main]
use libfuzzer_sys::fuzz_target;

fuzz_target!(|data: &[u8]| {
    // 将字节数据解析为字符串（可能会失败）
    if let Ok(s) = std::str::from_utf8(data) {
        // 测试字符串处理函数
        let trimmed = s.trim();
        let upper = trimmed.to_uppercase();
        let lower = trimmed.to_lowercase();
        
        // 测试字符串替换
        let replaced = trimmed.replace("a", "b");
        
        // 测试解析为数字（如果可能）
        if let Ok(num) = trimmed.parse::<i64>() {
            // 数字解析成功，测试一些运算
            let _ = num.checked_add(1);
            let _ = num.checked_mul(2);
        }
    }
});

1
2
3
4
5
6
7
8

# 运行模糊测试，持续 60 秒
$ cargo fuzz run fuzz_target_1 -- -max_total_time=60

# 运行模糊测试，持续到发现 bug 或 无限时间
$ cargo fuzz run fuzz_target_1

# 查看模糊测试的统计信息
$ cargo fuzz stats

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 初始化语料库目录
$ mkdir -p fuzz/corpus

# 添加一些样例文件
$ echo "hello world" > fuzz/corpus/hello.txt
$ echo "12345" > fuzz/corpus/number.txt
$ echo '{"key": "value"}' > fuzz/corpus/json.txt

# 运行模糊测试，会使用 corpus 目录中的文件作为种子
$ cargo fuzz run fuzz_target_1 fuzz/corpus

1
2
3

# 使用一个现有的语料库（如 JSON 测试集）
$ git clone https://github.com/nst/JSONTestSuite.git fuzz/json_corpus
$ cargo fuzz run json_parser fuzz/json_corpus

1
2

[dev-dependencies]
mockall = "0.12"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// src/lib.rs

/// 这是一个需要被 Mock 的 trait
pub trait Database {
    /// 连接数据库
    fn connect(&mut self) -> Result<(), String>;
    
    /// 查询用户
    fn query_user(&self, id: u64) -> Result<Option<String>, String>;
    
    /// 插入用户
    fn insert_user(&mut self, name: &str) -> Result<u64, String>;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12