Struct Expectations

pub struct Expectations { /* private fields */ }

Implementations

impl Expectations

pub fn new() -> Expectations

Create a new Expectations instance. Call this when your mock object is created.

Examples found in repository

examples/manual.rs (line 38)

    pub fn new() -> Self {
        Self {
            e: Expectations::new()
        }
    }

pub fn expect<I, O>(&mut self, name: &'static str) -> Method<'_, I, O>

where I: 'static, O: 'static,

Returns a Method struct which you can use to add expectations for the method with the given name.

Examples found in repository

examples/manual.rs (line 48)

    pub fn expect_foo(&mut self) -> Method<(), ()> {
        self.e.expect::<(), ()>("foo")
    }

    pub fn expect_bar(&mut self) -> Method<(), ()> {
        self.e.expect::<(), ()>("bar")
    }

    pub fn expect_goop(&mut self) -> Method<bool, u32> {
        self.e.expect::<bool, u32>("goop")
    }

    pub fn expect_zing(&mut self) -> Method<(i32, bool), ()> {
        self.e.expect::<(i32, bool), ()>("zing")
    }

    pub fn expect_boop(&mut self) -> Method<&'static str, ()> {
        self.e.expect::<&'static str, ()>("boop")
    }

    pub fn expect_store(&mut self) -> Method<*const i64, ()> {
        self.e.expect::<*const i64, ()>("store")
    }

    pub fn expect_toggle(&mut self) -> Method<*mut bool, ()> {
        self.e.expect::<*mut bool, ()>("toggle")
    }

pub fn then(&mut self) -> &mut Expectations

Begin a new Era. Expectations in one Era must be met before expectations in future eras will be evaluated.

Note that Eras are evaluated eagerly. This means that Eras may advance more quickly than you’d intuitively expect in certain situations. For example, called_any() is marked as complete after the first call is received. This menas that, for the purposes of telling if an Era should be advanced or not, called_any() and called_once() are the same.

Examples found in repository

examples/manual.rs (line 43)

    pub fn then(&mut self) -> &mut Self {
        self.e.then();
        self
    }

pub fn was_called<I, O>(&self, name: &'static str, params: I)

where I: 'static, O: 'static,

When a tracked method is called on the mock object, call this with the method’s name in order to tell the Expectations that the method was called.

Unlike was_called_returning, this method does not return a value.

Examples found in repository

examples/manual.rs (line 78)

    fn foo(&self) {
        self.e.was_called::<(), ()>("foo", ())
    }

    fn bar(&mut self) {
        self.e.was_called::<(), ()>("bar", ())
    }

    fn goop(&mut self, flag: bool) -> u32 {
        self.e.was_called_returning::<bool, u32>("goop", flag)
    }

    fn zing(&self, first: i32, second: bool) {
        self.e.was_called::<(i32, bool), ()>("zing", (first, second))
    }

    fn boop(&self, name: &'static str) {
        self.e.was_called::<&'static str, ()>("boop", name)
    }

    fn store(&self, val: &i64) {
        self.e.was_called::<*const i64, ()>("store", val)
    }

    fn toggle(&self, bit: &mut bool) {
        self.e.was_called::<*mut bool, ()>("toggle", bit)
    }

pub fn was_called_returning<I, O>(&self, name: &'static str, params: I) -> O

where I: 'static, O: 'static,

Same as the was_called method, but also returns the result.

Examples found in repository

examples/manual.rs (line 86)

    fn goop(&mut self, flag: bool) -> u32 {
        self.e.was_called_returning::<bool, u32>("goop", flag)
    }

Trait Implementations

impl Drop for Expectations

fn drop(&mut self)

All expectations will be verified when the mock object is dropped, panicking if any of them are unmet.

In the case where the Expectations object is being dropped because the thread is already panicking, the Expectations object is not verified.