Struct shoulda_core::Should

pub struct Should<'a, Inner, Hook: AssertionHook = NoOpAssertionHook, Epsilon: EpsilonProvider = EnvEpsilonProvider> { /* private fields */ }

A wrapper type around a borrowed value to assert things about it for testing

Implementations

impl<'a, T: ShouldaOfType> Should<'a, T>

pub fn of_type<I: Any + 'static>(self) -> Self

impl<'a> Should<'a, bool>

pub fn be_true(self) -> Should<'a, bool, NoOpAssertionHook>

pub fn be_false(self) -> Should<'a, bool, NoOpAssertionHook>

impl<'a> Should<'a, Output>

pub fn succeed(self) -> Should<'a, Output, NoOpAssertionHook>

pub fn code(self, expected: i32) -> Should<'a, Output, NoOpAssertionHook>

pub fn stdout(self, bytes: &[u8]) -> Should<'a, Output, NoOpAssertionHook>

pub fn stderr(self, bytes: &[u8]) -> Should<'a, Output, NoOpAssertionHook>

impl<'a, T, K, Hook, Epsilon> Should<'a, T, Hook, Epsilon>where &'a T: IntoIterator<Item = &'a K>, T: Debug, K: Debug + ShouldaEqual + 'a, Hook: AssertionHook, Epsilon: EpsilonProvider,

pub fn contain<I: Borrow<K>>( self, item: I ) -> Should<'a, T, NoOpAssertionHook, Epsilon>

pub fn contain_sequence<L: Borrow<K>, I: IntoIterator<Item = L>>( self, items: I ) -> Should<'a, T, NoOpAssertionHook, Epsilon>

pub fn contains<I: Fn(&K) -> bool>( self, predicate: I ) -> Should<'a, T, NoOpAssertionHook, Epsilon>

impl<'a, T: Debug> Should<'a, Option<T>>

pub fn none(self) -> Should<'a, Option<T>, NoOpAssertionHook>

pub fn some(self) -> Should<'a, Option<T>>

impl<'a, Inner, Hook, Epsilon> Should<'a, Inner, Hook, Epsilon>where Inner: Debug + RefUnwindSafe, Hook: AssertionHook, Epsilon: EpsilonProvider,

pub fn panic<Expr: Panicable<'a, Inner>>(self, e: Expr) -> Self

pub fn panic_with<Expr: Panicable<'a, Inner>, S: AsRef<str>>( self, e: Expr, message: S ) -> Self

impl<'a, T: Debug, E: Debug> Should<'a, Result<T, E>>

pub fn err(self) -> Should<'a, Result<T, E>>

pub fn ok(self) -> Should<'a, Result<T, E>>

impl<'a, Inner, Hook, Epsilon> Should<'a, Inner, Hook, Epsilon>where Hook: AssertionHook, Epsilon: EpsilonProvider,

pub fn be(self) -> Self

no-op, there to allow you to write english-like sentences

pub fn and(self) -> Self

no-op, there to allow you to write english-like sentences

pub fn float_diff<T: EpsilonProvider>(self) -> Should<'a, Inner, Hook, T>

Changes the generic for which EpsilonProvider to use

impl<'a, Inner, Hook, Epsilon> Should<'a, Inner, Hook, Epsilon>where Inner: ShouldaEqual + Debug, Hook: AssertionHook, Epsilon: EpsilonProvider,

pub fn eq<K: Into<Inner>>(self, other: K) -> Self

Asserts equality

pub fn equal<K: Into<Inner>>(self, other: K) -> Self

alias for eq

impl<'a, Inner, Epsilon> Should<'a, Inner, NoOpAssertionHook, Epsilon>where Epsilon: EpsilonProvider,

pub fn not(self) -> Should<'a, Inner, NotAssertionHook, Epsilon>

Changes the assertion hook to not the next assertion

impl<'a, Inner, Epsilon> Should<'a, Inner, NoOpAssertionHook, Epsilon>where Epsilon: EpsilonProvider,

pub fn or(self) -> Should<'a, Inner, OrAssertionHook, Epsilon>

Changes the assertion hook to or the next assertion with the previous, in case of no previous assertion this will be a no-op

impl<'a, Inner, Epsilon> Should<'a, Inner, NotAssertionHook, Epsilon>where Epsilon: EpsilonProvider,

pub fn not(self) -> Should<'a, Inner, NoOpAssertionHook, Epsilon>

Changes the assertion hook to not the next assertion