Struct unimock::build::Match

pub struct Match<'p, F: MockFn, O: Ordering> { /* private fields */ }

A matched call pattern, ready for setting up a response.

Implementations

impl<'p, F, O> Match<'p, F, O> where
    F: MockFn + 'static,
    O: Ordering, 

pub fn returns(self, value: impl Into<F::Output>) -> QuantifyResponse<'p, F, O> where
    F::Output: Send + Sync + Clone + 'static, 

Specify the output of the call pattern by providing a value. The output type must implement Clone and cannot contain non-static references. It must also be Send and Sync because unimock needs to store it.

pub fn returns_default(self) -> QuantifyResponse<'p, F, O> where
    F::Output: Default, 

Specify the output of the call pattern by calling Default::default().

pub fn returns_ref<T>(self, value: T) -> QuantifyResponse<'p, F, O> where
    T: Borrow<F::Output> + Sized + Send + Sync + 'static, 

Specify the output of the call to be a borrow of the provided value. This works well when the lifetime of the returned reference is the same as self. Using this for 'static references will produce a runtime error. For static references, use Match::returns_static.

pub fn returns_static(
    self,
    value: &'static F::Output
) -> QuantifyResponse<'p, F, O> where
    F::Output: Send + Sync + 'static, 

Specify the output of the call to be a reference to static value. This must be used when the returned reference in the mocked trait is 'static.

pub fn answers<A, R>(self, func: A) -> QuantifyResponse<'p, F, O> where
    A: for<'i> Fn(<F as MockInputs<'i>>::Inputs) -> R + Send + Sync + 'static,
    R: Into<F::Output>,
    F::Output: Sized, 

Specify the output of the call pattern by invoking the given closure that can then compute it based on input parameters.

pub fn answers_leaked_ref<A, R>(self, func: A) -> QuantifyResponse<'p, F, O> where
    A: for<'i> Fn(<F as MockInputs<'i>>::Inputs) -> R + Send + Sync + 'static,
    R: Borrow<F::Output> + 'static,
    F::Output: Sized, 

Specify the output of the call pattern to be a static reference to leaked memory.

The value may be based on the value of input parameters.

This version will produce a new memory leak for every invocation of the answer function.

This method should only be used when computing a reference based on input parameters is necessary, which should not be a common use case.

pub fn panics(self, message: impl Into<String>) -> QuantifyResponse<'p, F, O>

Prevent this call pattern from succeeding by explicitly panicking with a custom message.

pub fn unmocked(self) -> QuantifyResponse<'p, F, O> where
    F: Unmock, 

Instruct this call pattern to invoke the Unmocked function.