Rust嵌入式测试宏库embedded-test-macros使用指南

简介

embedded-test-macros是一个专门为Rust嵌入式开发设计的测试宏库，旨在简化嵌入式系统中的单元测试和集成测试流程。它为嵌入式开发者提供了更符合硬件开发场景的测试工具，特别适合在资源受限的环境中编写和运行测试。

主要特性

• 提供嵌入式友好的测试宏
• 支持硬件相关测试场景
• 简化测试结构
• 与cortex-m-rt等嵌入式运行时良好集成
• 提供硬件感知的断言功能

安装

在Cargo.toml中添加依赖：

[dependencies]
embedded-test-macros = "0.1"

基本使用方法

1. 基本测试宏

use embedded_test_macros::embedded_test;

#[embedded_test]
fn test_adc_reading() {
    let adc = Adc::new();
    let reading = adc.read_channel(0);
    assert_within_range!(reading, 0..=4095, "ADC读数超出预期范围");
}

2. 硬件初始化测试

#[embedded_test(setup = init_hardware)]
fn test_pwm_output() {
    let pwm = Pwm::new();
    pwm.set_duty_cycle(50);
    assert_io_level!(PWM_PIN, High, "PWM输出不正确");
}

fn init_hardware() {
    // 初始化所有硬件外设
    init_clock();
    init_gpio();
    init_pwm();
}

3. 带超时的测试

#[embedded_test(timeout_ms = 100)]
fn test_sensor_response() {
    let sensor = Sensor::new();
    let response = sensor.query();
    assert!(response.is_ok(), "传感器未在超时时间内响应");
}

高级功能

1. 硬件相关断言

#[embedded_test]
fn test_uart_transmission() {
    let uart = Uart::new();
    uart.write(b"test");
    assert_io_sequence!(UART_RX_PIN, [High, Low, Low, High], "UART传输数据不匹配");
}

2. 中断处理测试

#[embedded_test(enable_interrupts = true)]
fn test_timer_interrupt() {
    static INTERRUPT_FIRED: AtomicBool = AtomicBool::new(false);
    
    let timer = Timer::new();
    timer.set_interrupt_handler(|| INTERRUPT_FIRED.store(true, Ordering::SeqCst));
    timer.start(100);
    
    while !INTERRUPT_FIRED.load(Ordering::SeqCst) {}
    assert!(true, "定时器中断未触发");
}

3. 多线程测试

#[embedded_test(threads = 2)]
fn test_thread_safety() {
    let shared = Mutex::new(0);
    
    let thread1 = spawn(|| {
        let mut guard = shared.lock();
        *guard += 1;
    });
    
    let thread2 = spawn(|| {
        let mut guard = shared.lock();
        *guard += 1;
    });
    
    thread1.join();
    thread2.join();
    
    assert_eq!(*shared.lock(), 2, "线程安全测试失败");
}

与标准测试框架集成

embedded-test-macros可以与标准的#[test]属性一起使用：

#[test]
#[embedded_test]
fn hybrid_test() {
    // 既可以在主机上运行的标准测试
    // 也可以在目标硬件上运行的嵌入式测试
}

测试输出

库提供了嵌入式友好的输出格式：

[EMBEDDED TEST] test_adc_reading... OK (12ms)
[EMBEDDED TEST] test_pwm_output... FAIL (PWM输出不正确)

最佳实践

1. 为每个硬件外设创建单独的测试模块
2. 使用setup功能初始化复杂硬件配置
3. 合理设置测试超时时间
4. 将关键硬件验证测试标记为#[critical_test]
5. 结合defmt等日志框架增强测试输出

注意事项

• 确保测试代码不会影响实际应用逻辑
• 注意资源冲突问题
• 在真实硬件上运行前，尽可能在模拟器中验证测试
• 考虑添加硬件复位后的状态验证

完整示例代码

下面是一个完整的嵌入式测试示例，展示了如何测试一个嵌入式系统中的多个硬件组件：

#![no_std]
#![no_main]

use embedded_test_macros::embedded_test;
use cortex_m_rt::entry;
use panic_halt as _;

// 模拟硬件外设
struct Adc;
struct Pwm;
struct Sensor;
struct Uart;

impl Adc {
    fn new() -> Self { Adc }
    fn read_channel(&self, _ch: u8) -> u16 { 2048 } // 模拟ADC读数
}

impl Pwm {
    fn new() -> Self { Pwm }
    fn set_duty_cycle(&self, _percent: u8) {}
}

impl Sensor {
    fn new() -> Self { Sensor }
    fn query(&self) -> Result<(), ()> { Ok(()) }
}

impl Uart {
    fn new() -> Self { Uart }
    fn write(&self, _data: &[u8]) {}
}

// 硬件初始化函数
fn init_hardware() {
    // 这里通常是硬件初始化代码
}

#[entry]
fn main() -> ! {
    loop {}
}

// ADC测试
#[embedded_test]
fn test_adc_basic() {
    let adc = Adc::new();
    let value = adc.read_channel(0);
    assert_within_range!(value, 0..=4095, "ADC值超出有效范围");
}

// PWM测试需要硬件初始化
#[embedded_test(setup = init_hardware)]
fn test_pwm_output() {
    let pwm = Pwm::new();
    pwm.set_duty_cycle(50);
    // 这里通常会检查实际硬件输出
    assert!(true, "PWM测试通过");
}

// 传感器测试带超时
#[embedded_test(timeout_ms = 200)]
fn test_sensor_communication() {
    let sensor = Sensor::new();
    let result = sensor.query();
    assert!(result.is_ok(), "传感器通信失败");
}

// 复杂测试：UART传输
#[embedded_test]
fn test_uart_loopback() {
    let uart = Uart::new();
    let test_data = b"test";
    uart.write(test_data);
    // 这里通常会验证实际接收到的数据
    assert!(true, "UART回环测试通过");
}

// 关键测试标记
#[embedded_test]
#[critical_test]
fn test_system_clock() {
    // 测试系统时钟是否正常运行
    assert!(true, "系统时钟测试通过");
}

这个完整示例展示了：

1. 基本的ADC测试
2. 需要硬件初始化的PWM测试
3. 带超时的传感器测试
4. UART通信测试
5. 标记为关键测试的系统时钟测试

所有测试都可以在嵌入式目标上运行，同时也支持在主机上运行的标准测试框架。