如何为同一Trait的两个实现编写单元测试？

你的核心需求是用黑盒测试验证同一Trait的两个实现，同时避免代码重复，且不使用动态分发。原代码编译失败是因为dyn Searchable<T>是未大小类型（DST），不能直接作为返回值，而你又不想用动态分发（比如Box<dyn Searchable<T>>），所以最佳方案是用泛型静态分发来复用测试逻辑。

实现思路 #

把通用的测试逻辑抽象成一个泛型函数，该函数对所有实现Searchable<Item>的类型生效，然后分别针对结构体A和B调用这个泛型函数，即可完成两套实现的测试，全程是静态分发，符合你的需求。

修改后的完整代码 #

pub trait Searchable<T> {
    fn search(&self, item: &T, radius: f32) -> Vec<T>;
}

#[derive(Debug, PartialEq)]
struct Item { x: u32, y: u32 }

struct A { some_field: u32 }

impl Searchable<Item> for A {
    fn search(&self, item: &Item, radius: f32) -> Vec<Item> {
        // 这里是A的实际实现，示例返回空向量
        vec![]
    }
}

struct B {}

impl Searchable<Item> for B {
    fn search(&self, item: &Item, radius: f32) -> Vec<Item> {
        // 这里是B的实际实现，示例返回空向量
        vec![]
    }
}

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

    // 通用测试逻辑：所有实现Searchable<Item>的类型都能跑这套测试
    fn run_search_tests<S: Searchable<Item>>() {
        // 1. 准备测试数据（替代原setup函数的逻辑）
        let test_items = vec![
            Item { x: 10, y: 10 },
            Item { x: 20, y: 20 },
        ];
        let searcher = create_searcher::<S>();

        // 2. 执行测试用例
        let result = searcher.search(&test_items[0], 5.0);
        // 根据实际需求写断言，示例断言返回空向量
        assert_eq!(result, vec![]);

        // 可以添加更多测试场景，比如不同radius、不同item的情况
        let result2 = searcher.search(&test_items[1], 10.0);
        assert_eq!(result2, vec![]);
    }

    // 针对不同实现创建实例的辅助函数（可选，也可以直接在测试里创建）
    fn create_searcher<S: Searchable<Item>>() -> S {
        if std::any::TypeId::of::<S>() == std::any::TypeId::of::<A>() {
            // 强制类型转换，因为我们只在测试里调用，确保类型匹配
            A { some_field: 42 } as S
        } else {
            B {} as S
        }
    }

    // 测试A的实现
    #[test]
    fn test_search_a() {
        run_search_tests::<A>();
    }

    // 测试B的实现
    #[test]
    fn test_search_b() {
        run_search_tests::<B>();
    }
}

fn main() {}

关键要点说明 #

1. 泛型测试函数：run_search_tests<S: Searchable<Item>>()是核心，里面包含所有通用的测试步骤（准备数据、调用方法、断言结果），所有实现了Searchable<Item>的类型都能复用这套逻辑。
2. 静态分发：Rust会在编译时为A和B分别生成run_search_tests的实例，完全是静态分发，没有动态分发的开销，符合你生产环境只选一个实现的需求。
3. 避免代码重复：所有测试逻辑只写一次，两个测试入口test_search_a和test_search_b只需要调用泛型函数并指定类型参数即可。
4. 类型安全：泛型约束确保只有实现了目标Trait的类型才能调用测试函数，编译时就能发现错误。

如果你的setup逻辑比较复杂，也可以把它抽象成泛型的setup函数，返回对应类型的实例和测试数据，比如：

fn setup<S: Searchable<Item>>() -> (S, Vec<Item>) {
    let items = vec![Item {x:10,y:10}, Item {x:20,y:20}];
    let searcher = create_searcher::<S>();
    (searcher, items)
}

然后在run_search_tests里调用这个setup函数即可。

内容的提问来源于stack exchange，提问作者noam cohen