例如

// `Result` does not implement the `Default` trait. Trying to mock `UserStore`
// using the `mock_trait!` macro will fail. We use `mock_trait_no_default!`
// instead.
pub trait UserStore {
    fn get_username(&self, id: i32) -> Result<String, String>;
}

mock_trait_no_default!(
    MockUserStore,
    get_username(i32) -> Result<String, String>);

impl UserStore for MockUserStore {
    mock_method!(get_username(&self, id: i32) -> Result<String, String>);
}

fn test_manually_setting_default_retval() {
    // GIVEN:
    // Construct instance of the mock, manually specifying the default
    // return value for `get_username()`.
    let mock = MockUserStore::new(
        Ok("default_user_name".to_owned()));  // get_username() default retval
    // WHEN:
    let result = mock.get_username(10001);
    // THEN:
    assert_eq!(Ok("default_username".to_owned()), result);
}

模拟接受 &str 引用的方法

&str 是一个常见的参数类型。然而，double 不支持使用额外的样板代码模拟接受 &str 参数的方法。

这是因为在模拟中不能存储接收到的 &str 参数。模拟需要拥有给定的参数，而 &str 是一个非拥有引用。因此，模拟特徵必须像这样指定

trait TextStreamWriter {
    fn write(&mut self, text: &str);
}

mock_trait!(
    MockTextStreamWriter,
    // have to use `String`, not `&str` here, since `&str` is a reference
    write(String) -> ()
);

impl TextStreamWriter for MockTextStreamWriter {
    mock_method!(write(&mut self, text: &str), self, {
        // manually convert the reference to an owned `String` before passing
        // it to the underlying mock object
        self.write.call(text.to_owned())
    });
}

上面使用的 mock_method 变体允许您手动指定生成的函数的主体。自定义主体只是将 &str 参数转换为拥有字符串，并手动传递到底层的 write Mock 对象。（通常自动生成的主体会为您完成这项工作）。

注意：底层模拟对象的名字总是与模拟方法的名称相同。因此，在自定义 write 主体中，您应该将参数传递到 self.write。

&str 参数很常见。我们理解，每次它们出现时手动指定主体都很不方便。有计划添加一个宏来自动生成调用 to_owned() 的主体。当它发布时，本节将进行更新。

使用泛型类型参数模拟方法

使用泛型类型参数模拟方法需要额外的努力。例如，假设有一个负责在程序中比较任意两个值的 Comparator 特征。它可能看起来像这样

trait Comparator {
   fn is_equal<T: Eq>(&self, a: &T, b: &T) -> bool;
}

T 可以是多种类型。目前，我们无法在底层的 Mock 对象中存储具有泛型的调用参数。因此，必须将泛型类型转换为不同的、通用的表示。一种绕过这种限制的方法是将每个泛型类型转换为 String。例如，对于 Comparator 特征

# #[macro_use] extern crate double;

use std::string::ToString;

trait Comparator {
   fn is_equal<T: Eq + ToString>(&self, a: &T, b: &T) -> bool;
}

mock_trait!(
    MockComparator,
    // store all passed in call args as strings
    is_equal((String, String)) -> bool
);

impl Comparator for MockComparator {
    mock_method!(is_equal<(T: Eq + ToString)>(&self, a: &T, b: &T) -> bool, self, {
        // Convert both arguments to strings and manually pass to underlying
        // mock object.
        // Notice how the both arguments as passed as a single tuple. The
        // underlying mock object always expects a single tuple.
        self.is_equal.call((a.to_string(), b.to_string()))
    });
}

如果所有 T 的 to_string 转换都不是有损的，那么我们的模拟期望可以非常精确。如果 to_string 转换 是 有损的，那么这个机制仍然可以用来捕获所有传递对象的属性，保存在结果 String 中。

这种方法要求编写者确保要测试的代码将 ToString 特征添加到特征的类型参数约束中。这种限制迫使测试编写者修改生产代码以使用 double 进行模拟。

尽管如此，使用 double 模拟具有类型参数的泛型方法仍然有价值。尽管它会给生产代码添加样板代码，手动实现模拟方法主体也很麻烦，但增值在于所有参数匹配、期望、调用测试函数等都是由 double 处理的。

double 的作者认为，重新实现上述功能比模拟具有类型参数的方法所需的小量样板代码更繁琐。

使用 double 模拟自由函数

double::Mock 对象也可以用于自由函数。考虑以下函数

fn generate_sequence(func: &dyn Fn(i32) -> i32, min: i32, max: i32) -> Vec<i32> {
    // exclusive range
    (min..max).map(func).collect()
}

此函数遍历一系列整数，使用提供的转换函数 func 将每个整数映射到另一个整数。

在测试 generate_sequence 时，无需自己生成模拟转换函数的样板代码，可以使用宏 mock_func!。此宏为您生成一个 double::Mock 对象和一个封装它的闭包。例如

#[macro_use]
extern crate double;

fn generate_sequence(func: &dyn Fn(i32) -> i32, min: i32, max: i32) -> Vec<i32> {
    // exclusive range
    (min..max).map(func).collect()
}

fn test_function_used_correctly() {
    // GIVEN:
    mock_func!(
        mock,     // name of variable that stores mock object
        mock_fn,  // name of variable that stores closure wrapper
        i32,      // return value type
        i32);     // argument1 type
    mock.use_closure(Box::new(|x| x * 2));

    // WHEN:
    let sequence = generate_sequence(&mock_fn, 1, 5);

    // THEN:
    assert_eq!(vec!(2, 4, 6, 8), sequence);
    assert!(mock.has_calls_exactly(vec!(
      1, 2, 3, 4
    )));
}

fn main() {
    test_function_used_correctly();
}

您可以在 mock_func! 宏的前两个参数中指定应存储生成的模拟对象和闭包的变量名。

如果函数的返回类型没有实现 Default，则必须使用 mock_func_no_default! 宏，如下所示

// ...

fn test_function_with_custom_defaults() {
    // GIVEN:
    mock_func_no_default!(
        mock,
        mock_fn,
        i32,   // return value type
        42,    // default return value
        i32);  // argument1 type
    mock.use_closure_for((3), Box::new(|x| x * 2));

    // WHEN:
    let sequence = generate_sequence(&mock_fn, 1, 5);

    // THEN:
    assert_eq!(vec!(42, 42, 6, 42), sequence);
    assert!(mock.has_calls_exactly(vec!(
      1, 2, 3, 4
    )));
}

fn main() {
    test_function_with_custom_defaults();
}