小编在去云南疯玩了一周后短暂忘记了自己的责任与价值，导致每周一库没有及时更新，非常抱歉！
这次是Mockall (对象模拟库) 系列的最后一篇。
包含关联类型的特征也可以模拟。与通用特征不同，模拟出的结构型不是通用的，在定义模拟结构型时必须要指定关联的类型，这可以通过#[automock\]属性中的元项目来达成：
#[automock(type Key=u16; type Value=i32;)] pub trait A { type Key; type Value; fn foo(&self, k: Self::Key) -> Self::Value; } let mut mock = MockA::new(); mock.expect_foo() .returning(|x: u16| i32::from(x)); assert_eq!(4, mock.foo(4));在创建一个可以实现多种特征的模拟结构型时，无论有没有继承，都需要使用mock!宏。但在创建之后，模拟对象的使用方法无异。
pub trait A { fn foo(&self); } pub trait B: A { fn bar(&self); } mock! { // 需要模拟的结构型 C {} // C 中需要实现的第一个特征 trait A { fn foo(&self); } // C中需要实现的第二个特征 trait B: A { fn bar(&self); } } let mut mock = MockC::new(); mock.expect_foo().returning(|| ()); mock.expect_bar().returning(|| ()); mock.foo(); mock.bar();Mockall还可以模拟在你控制之外的外部包中定义的特征与结构型，但是必须使用mock! 宏，而不是#[automock\]。你可以这样去模拟一个外部特征：
mock! { MyStruct {} // 模拟结构型的名称, 不需要 "Mock" 前缀 trait Clone { // 需要模拟的特征的定义 fn clone(&self) -> Self; } } let mut mock1 = MockMyStruct::new(); let mock2 = MockMyStruct::new(); mock1.expect_clone() .return_once(move || mock2); let cloned = mock1.clone();Mockall还可以模拟静态的方法，但是需要注意，在模拟静态方法时的”期望“是全局的。如果你需要在多个不同测试中使用一个静态方法，必须要提供专属的同步。普通的方法中，期望是设置在模拟对象之上的。但是静态方法没有对应的模拟对象，所以必须要通过创建一个”语境“对象来设置这些期望：
#[automock] pub trait A { fn foo() -> u32; } let ctx = MockA::foo_context(); ctx.expect().returning(|| 99); assert_eq!(99, MockA::foo());一个常用的模式是用构造方法来模拟一个特征。在这种情况下，你可以利用构造方法来返回一个模拟对象。
struct Foo{} #[automock] impl Foo { fn from_i32(x: i32) -> Self { // ... } fn foo(&self) -> i32 { // ... } } let ctx = MockFoo::from_i32_context(); ctx.expect() .returning(|x| { let mut mock = MockFoo::default(); mock.expect_foo() .return_const(x); mock }); let foo = MockFoo::from_i32(42); assert_eq!(42, foo.foo());模拟通用的结构型或特征的静态方法时，无论方法本身是不是通用的，都能无缝运行。
#[automock] trait Foo<T: 'static> { fn new(t: T) -> MockFoo<T>; } let ctx = MockFoo::<u32>::new_context(); ctx.expect() .returning(|_| MockFoo::default()); let mock = MockFoo::<u32>::new(42u32);当语境对象离开作用域时，所有的期望都会被清空。语境对象与其他模拟对象一样有一个checkpoint 方法。
#[automock] pub trait A { fn foo() -> u32; } let ctx = MockA::foo_context(); ctx.expect() .times(1) .returning(|| 99); ctx.checkpoint(); // Panics!模拟对象的检查点方法不会对静态方法进行检查。这种行为对同时使用多个模拟对象会比较有用，例如：
#[automock] pub trait A { fn build() -> Self; fn bar(&self) -> i32; } let ctx = MockA::build_context(); ctx.expect() .times(2) .returning(|| MockA::default()); let mut mock0 = MockA::build(); mock0.expect_bar().return_const(4); mock0.bar(); mock0.checkpoint(); // 不会对build方法进行checkpoint let mock1 = MockA::build();还有一点值得注意的时：Mockall一般情况下会为每一个模拟结构型创建一个没有参数的new方法。但是在模拟一个已经包含名为new的方法的结构型时，Mockall则不会自动创建。
Mockall还可以模拟外部方程。和静态方法一样，模拟外部方程时的期望是全局的。与模拟结构型时类似，为了使模拟的方程可被访问，需要对导入进行特别的调试。与关联类型一样，需要在#[automock\]属性中提供一些额外的信息模拟外部方程才可正常使用。
mod ffi { use mockall::automock; #[automock(mod mock;)] extern "C" { pub fn foo(x: u32) -> i64; } } cfg_if! { if #[cfg(test)] { use self::ffi::mock::foo; } else { use self::ffi::foo; } } fn do_stuff() -> i64 { unsafe{ foo(42) } } #[cfg(test)] mod t { use super::*; #[test] fn test_foo() { let ctx = ffi::mock::foo_context(); ctx.expect() .returning(|x| i64::from(x + 1)); assert_eq!(43, do_stuff()); } }除了可以模拟外部方程之外，Mockall还可以为所有Rust方程的模块派生出模拟，这个功能需要使用每日构建功能，在你的包中需要启用feature(proc_macro_hygiene)。使用方法与模拟外部功能一样，但是模拟模块的命名是自动生成的。
#![feature(proc_macro_hygiene)] mod outer { use mockall::automock; #[automock()] pub(super) mod inner { pub fn bar(x: u32) -> i64 { // ... } } } cfg_if! { if #[cfg(test)] { use outer::mock_inner as inner; } else { use outer::inner; } } #[cfg(test)] mod t { use super::*; #[test] fn test_foo_bar() { let ctx = inner::bar_context(); ctx.expect() .returning(|x| i64::from(x + 1)); assert_eq!(5, inner::bar(4)); } }