Struct fluid::core::should::Should

#[must_use]
pub struct Should<L>(_)
 where
    L: Debug;

Main data structure used to create assertions. See its methods for more information about the existing assertions.

Methods

impl<L: Debug> Should<L>

pub fn be_equal_to<R: Debug>(self, right: R) -> ChainableAssert<BeEqualTo<L, R>> where
    L: PartialEq<R>, 

Checks if the left field is equal to the right field.

Example

fn the_answer() -> i32 {
    42
}

the_answer().should().be_equal_to(42);

impl Should<bool>

pub fn be_true(self) -> ChainableAssert<Boolean>

Checks if a bool is true.

Example

let is_ok = true;
is_ok.should().be_true();

pub fn be_false(self) -> ChainableAssert<Boolean>

Checks if a bool is false.

Example

let is_ok = false;
is_ok.should().be_false();

impl<L: Debug> Should<L>

pub fn have_the_property<F>(
    self,
    closure: F
) -> ChainableAssert<HaveProperty<L, F>> where
    F: FnOnce(&L) -> bool, 

Checks if a user-defined property is satisfied.

Example

fn an_even_number() -> i32 { 2 }

an_even_number().should().have_the_property(|&n| n % 2 == 0);

impl<I: Debug> Should<I> where
    I: IntoIterator,
    I::Item: PartialEq<I::Item> + Debug,
    I::IntoIter: Debug, 

pub fn yield_the_item(
    self,
    right: I::Item
) -> ConsumingAssert<ContainIterator<I::IntoIter>>

Checks if an iterator contains the right field.

Example

let it = vec![1, 2, 3, 4].into_iter();

it.should().not().yield_the_item(0);

impl<O: Debug, E: Debug> Should<Result<O, E>>

pub fn be_an_error(self) -> ChainableAssert<BeAnError<O, E>>

Checks if a result is an error.

Example

let result = "two".parse::<i32>();
result.should().be_an_error().because("“two“ is not a valid number");

impl<O: Debug, E: Debug> Should<Result<O, E>>

pub fn be_ok(self) -> ChainableAssert<BeOk<O, E>>

Checks if a result is an error.

Example

let result = "2".parse::<i32>();
result.should().be_ok();

Trait Implementations

impl<C: Debug> ShouldCollection<C> for Should<C> where
    C: Collection, 

fn contain<P>(self, right: P) -> ChainableAssert<ContainCollection<C, P>> where
    P: CollectionPattern<C>, 

Checks that a collection contains a pattern:

fn be_empty(self) -> ChainableAssert<BeEmptyCollection<C>>

Checks that a collection is empty:

impl<S: Debug> ShouldString<S> for Should<S> where
    S: AsRef<str>, 

fn contain<P>(self, right: P) -> ChainableAssert<ContainString<S, P>> where
    P: StringPattern, 

Checks that a string contains a pattern.

fn start_with<P>(self, right: P) -> ChainableAssert<StartWithString<S, P>> where
    P: StringPattern, 

Checks that a string begins with a pattern.

fn end_with<P>(self, right: P) -> ChainableAssert<EndWithString<S, P>> where
    P: StringPattern, 

Checks that a string ends with a pattern.

fn be_empty(self) -> ChainableAssert<BeEmptyString<S>>

Checks that a string is empty.

impl<L> Default for Should<L> where
    L: Debug, 

fn default() -> Self

Returns the "default value" for a type.

impl<L> From<ShouldImpl<L>> for Should<L> where
    L: Debug, 

fn from(implem: ShouldImpl<L>) -> Self

Performs the conversion.

impl<L> From<Should<L>> for ShouldImpl<L> where
    L: Debug, 

fn from(should: Should<L>) -> Self

Performs the conversion.

impl<'a, L> From<&'a mut Should<L>> for &'a mut ShouldImpl<L> where
    L: Debug, 

fn from(should: &'a mut Should<L>) -> Self

Performs the conversion.

impl<L: Debug> Debug for Should<L> where
    L: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<L> Not for Should<L> where
    L: Debug, 

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.