Rust插件库yare的使用：轻量级、高效插件系统开发框架

Yare是一个基于过程宏的参数化测试库，允许使用单个测试定义来测试多种不同的输入场景。测试用例可以通过parameterized属性来定义，而不是使用test属性。

特性

• 参数化：指定不同的输入来测试多个场景
• 灵活性：参数化测试用例参数可以是表达式
• 开箱即用：适用于任何Rust版本，无需自定义测试框架
• 可重用性：定义一次测试用例，在不同测试中重复使用
• 可读性：使用熟悉的Rust属性语法保持代码可读性
• 可识别性：每个测试用例都有用户定义的名称
• 经过实战检验：已在多个crate中使用多年

示例代码

第一个示例

fn add5<T: Into<u32>>(component: T) -> u32 {
    component.into() + 5
}

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

    #[parameterized(
      zero_plus_five = { 0, 5 },
      one_plus_five = { 1, 6 },
      two_plus_five = { 2, 7 },
    )]
    fn test_add5(input: u16, expected: u32) {
        assert_eq!(add5(input), expected);
    }
}

带有枚举值的示例

enum Fruit {
    Apple,
    Bramble(BrambleFruit),
    Pear,
}

trait NameOf {
    fn name_of(&self) -> &str;
}

impl NameOf for Fruit {
    fn name_of(&self) -> &str {
        match self {
            Fruit::Apple => "apple",
            Fruit::Bramble(fruit) => fruit.name_of(),
            Fruit::Pear => "pear",
        }
    }
}

enum BrambleFruit {
    Blackberry,
}

impl NameOf for BrambleFruit {
    fn name_of(&self) -> &str {
        match self {
            BrambleFruit::Blackberry => "blackberry",
        }
    }
}

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

    #[parameterized(
      apple = { Fruit::Apple, "apple" },
      pear = { Fruit::Pear, "pear" },
      blackberry = { Fruit::Bramble(BrambleFruit::Blackberry), "blackberry" },
    )]
    fn a_fruity_test(fruit: Fruit, name: &str) {
        assert_eq!(fruit.name_of(), name)
    }
}

完整示例Demo

use std::sync::atomic::{AtomicU32, Ordering};
use yare::parameterized;

// 模拟掷骰子函数
fn roll_dice(seed: &AtomicU32) -> u8 {
    let mut current = seed.load(Ordering::Relaxed);
    loop {
        let new = current.wrapping_mul(1664525).wrapping_add(1013904223);
        match seed.compare_exchange_weak(current, new, Ordering::Relaxed, Ordering::Relaxed) {
            Ok(_) => return (new % 6 + 1) as u8,  // 返回1-6之间的随机数
            Err(e) => current = e,
        }
    }
}

#[parameterized(
    test_case_1 = { roll_dice(&AtomicU32::new(0)), 1 },  // 固定种子测试
    test_case_2 = { roll_dice(&AtomicU32::new(42)), 4 }, // 不同种子测试
)]
fn test_dice_roll(seed: u32, expected_min: u8) {
    let seed = AtomicU32::new(seed);
    let result = roll_dice(&seed);
    assert!(result >= expected_min && result <= 6);
}

// 异步测试示例
#[parameterized(
    fast_case = { 50, 50 },
    slow_case = { 200, 200 },
)]
#[test_macro(tokio::test)]
async fn test_async_sleep(wait_ms: u64, expected_elapsed: u128) {
    let start = std::time::Instant::now();
    tokio::time::sleep(tokio::time::Duration::from_millis(wait_ms)).await;
    let elapsed = start.elapsed().as_millis();
    assert!(elapsed >= expected_elapsed);
}

// 带有返回值的测试
#[parameterized(
    success_case = { Ok(42) },
    error_case = { Err("test error") },
)]
fn test_with_result(result: Result<i32, &str>) -> Result<(), &str> {
    let value = result?;
    assert_eq!(value, 42);
    Ok(())
}

如何使用

1. 添加依赖到Cargo.toml:

yare = "3.0.0"

1. 在测试模块中使用:

use yare::parameterized;

#[parameterized(
    case1 = { param1, param2 },
    case2 = { param3, param4 },
)]
fn test_function(arg1: Type1, arg2: Type2) {
    // 测试逻辑
}

许可证

Yare采用双许可证：

• MIT许可证
• Apache-2.0许可证

您可以选择其中任一许可证使用。