Struct mockall::examples::mock_ffi::__ffi_func::Expectation

pub struct Expectation { /* private fields */ }

👎Deprecated since 0.9.0: Using automock directly on an extern block is deprecated. Instead, wrap the extern block in a module, and automock that, like #[automock] mod ffi { extern “C” { fn foo … } }

Expectation type for methods that return a 'static type. This is the type returned by the expect_* methods.

Implementations

impl Expectation

pub fn return_const<MockallOutput>(
    &mut self,
    __mockall_c: MockallOutput
) -> &mut Selfwhere
    MockallOutput: Clone + Into<()> + Send + 'static,

👎Deprecated since 0.9.0: Using automock directly on an extern block is deprecated. Instead, wrap the extern block in a module, and automock that, like #[automock] mod ffi { extern “C” { fn foo … } }

Return a constant value from the Expectation

The output type must be Clone. The compiler can’t always infer the proper type to use with this method; you will usually need to specify it explicitly. i.e. return_const(42i32) instead of return_const(42).

pub fn return_const_st<MockallOutput>(
    &mut self,
    __mockall_c: MockallOutput
) -> &mut Selfwhere
    MockallOutput: Clone + Into<()> + 'static,

👎Deprecated since 0.9.0: Using automock directly on an extern block is deprecated. Instead, wrap the extern block in a module, and automock that, like #[automock] mod ffi { extern “C” { fn foo … } }

Single-threaded version of return_const. This is useful for return types that are not Send.

The output type must be Clone. The compiler can’t always infer the proper type to use with this method; you will usually need to specify it explicitly. i.e. return_const(42i32) instead of return_const(42).

It is a runtime error to call the mock method from a different thread than the one that originally called this method.

pub fn return_once<MockallF>(&mut self, __mockall_f: MockallF) -> &mut Selfwhere
    MockallF: FnOnce() + Send + 'static,

👎Deprecated since 0.9.0: Using automock directly on an extern block is deprecated. Instead, wrap the extern block in a module, and automock that, like #[automock] mod ffi { extern “C” { fn foo … } }

Supply an FnOnce closure that will provide the return value for this Expectation. This is useful for return types that aren’t Clone. It will be an error to call this method multiple times.

pub fn return_once_st<MockallF>(&mut self, __mockall_f: MockallF) -> &mut Selfwhere
    MockallF: FnOnce() + 'static,

👎Deprecated since 0.9.0: Using automock directly on an extern block is deprecated. Instead, wrap the extern block in a module, and automock that, like #[automock] mod ffi { extern “C” { fn foo … } }

Single-threaded version of return_once. This is useful for return types that are neither Send nor Clone.

It is a runtime error to call the mock method from a different thread than the one that originally called this method. It is also a runtime error to call the method more than once.

pub fn returning<MockallF>(&mut self, __mockall_f: MockallF) -> &mut Selfwhere
    MockallF: FnMut() + Send + 'static,

👎Deprecated since 0.9.0: Using automock directly on an extern block is deprecated. Instead, wrap the extern block in a module, and automock that, like #[automock] mod ffi { extern “C” { fn foo … } }

Supply a closure that will provide the return value for this Expectation. The method’s arguments are passed to the closure by value.

pub fn returning_st<MockallF>(&mut self, __mockall_f: MockallF) -> &mut Selfwhere
    MockallF: FnMut() + 'static,

👎Deprecated since 0.9.0: Using automock directly on an extern block is deprecated. Instead, wrap the extern block in a module, and automock that, like #[automock] mod ffi { extern “C” { fn foo … } }

Single-threaded version of returning. Can be used when the argument or return type isn’t Send.

It is a runtime error to call the mock method from a different thread than the one that originally called this method.

pub fn in_sequence(&mut self, __mockall_seq: &mut Sequence) -> &mut Self

👎Deprecated since 0.9.0: Using automock directly on an extern block is deprecated. Instead, wrap the extern block in a module, and automock that, like #[automock] mod ffi { extern “C” { fn foo … } }

Add this expectation to a Sequence.

pub fn never(&mut self) -> &mut Self

👎Deprecated since 0.9.0: Using automock directly on an extern block is deprecated. Instead, wrap the extern block in a module, and automock that, like #[automock] mod ffi { extern “C” { fn foo … } }

Forbid this expectation from ever being called.

pub fn new() -> Self

👎Deprecated since 0.9.0: Using automock directly on an extern block is deprecated. Instead, wrap the extern block in a module, and automock that, like #[automock] mod ffi { extern “C” { fn foo … } }

Create a new, default, Expectation

pub fn once(&mut self) -> &mut Self

👎Deprecated since 0.9.0: Using automock directly on an extern block is deprecated. Instead, wrap the extern block in a module, and automock that, like #[automock] mod ffi { extern “C” { fn foo … } }

Expect this expectation to be called exactly once. Shortcut for times(1).

pub fn times<MockallR>(&mut self, __mockall_r: MockallR) -> &mut Selfwhere
    MockallR: Into<TimesRange>,

👎Deprecated since 0.9.0: Using automock directly on an extern block is deprecated. Instead, wrap the extern block in a module, and automock that, like #[automock] mod ffi { extern “C” { fn foo … } }

Restrict the number of times that that this method may be called.

The argument may be:

• A fixed number: .times(4)
• Various types of range:
  • .times(5..10)
  • .times(..10)
  • .times(5..)
  • .times(5..=10)
  • .times(..=10)
• The wildcard: .times(..)

pub fn with(&mut self) -> &mut Self

👎Deprecated since 0.9.0: Using automock directly on an extern block is deprecated. Instead, wrap the extern block in a module, and automock that, like #[automock] mod ffi { extern “C” { fn foo … } }

Set matching crieteria for this Expectation.

The matching predicate can be anything implemening the Predicate trait. Only one matcher can be set per Expectation at a time.

pub fn withf<MockallF>(&mut self, __mockall_f: MockallF) -> &mut Selfwhere
    MockallF: Fn() -> bool + Send + 'static,

👎Deprecated since 0.9.0: Using automock directly on an extern block is deprecated. Instead, wrap the extern block in a module, and automock that, like #[automock] mod ffi { extern “C” { fn foo … } }

Set a matching function for this Expectation.

This is equivalent to calling with with a function argument, like with(predicate::function(f)).

pub fn withf_st<MockallF>(&mut self, __mockall_f: MockallF) -> &mut Selfwhere
    MockallF: Fn() -> bool + 'static,

👎Deprecated since 0.9.0: Using automock directly on an extern block is deprecated. Instead, wrap the extern block in a module, and automock that, like #[automock] mod ffi { extern “C” { fn foo … } }

Single-threaded version of withf. Can be used when the argument type isn’t Send.

Trait Implementations

impl Default for Expectation

fn default() -> Self

Returns the “default value” for a type.