Struct assertor::Subject

pub struct Subject<'a, Sub, Opt, Ret> { /* private fields */ }

Data structure that contains a value to be tested (actual value) with auxiliary data (ex. line pos, description).

Implementations

impl<'a, Sub, Opt, Ret> Subject<'a, Sub, Opt, Ret>

pub fn new( actual: &'a Sub, expr: String, description: Option<String>, option: Opt, location: Option<Location>, return_type: PhantomData<Ret>, ) -> Self

Creates a new subject with a referenced actual value.

Trait Implementations

impl<R> BooleanAssertion<R> for Subject<'_, bool, (), R>

where AssertionResult: AssertionStrategy<R>,

fn is_true(&self) -> R

Checks that the subject is equal to true.

fn is_false(&self) -> R

Checks that the subject is equal to false.

impl<'a, R> CheckThatResultAssertion<'a, R> for Subject<'a, CheckThatResult, (), R>

where AssertionResult: AssertionStrategy<R>,

fn facts_are<B: Borrow<Vec<Fact>>>(&self, expected: B) -> R

Checks that the assertion result contains elements of facts in order.

fn facts_are_at_least<B: Borrow<Vec<Fact>>>(&self, facts: B) -> R

Checks that the assertion result contains elements of facts in order.

fn fact_value_for_key<I: Into<String>>( &self, key: I, ) -> Subject<'_, String, (), R>

Returns the first fact value whose key is equal to key.

fn fact_keys(&self) -> Subject<'_, HashSet<&String>, (), R>

Returns keys of the assertion messages.

impl<S: PartialOrd + Debug, R> ComparableAssertion<S, R> for Subject<'_, S, (), R>

where AssertionResult: AssertionStrategy<R>,

fn is_at_least<B: Borrow<S>>(&self, expected: B) -> R

Checks that the subject is greater than or equal to expected.

fn is_at_most<B: Borrow<S>>(&self, expected: B) -> R

Checks that the subject is less than or equal to expected.

fn is_greater_than<B: Borrow<S>>(&self, expected: B) -> R

Checks that the subject is greater than expected.

fn is_less_than<B: Borrow<S>>(&self, expected: B) -> R

Checks that the subject is less than expected.

impl<'a, T, Y, R> CowAssertion<T, Y, R> for Subject<'a, Cow<'a, T>, (), R>

where T: ToOwned<Owned = Y> + ?Sized, AssertionResult: AssertionStrategy<R>,

fn is_borrowed(&self) -> R

Checks that the subject is Cow::Borrowed(_).

fn is_owned(&self) -> R

Checks that the subject is Cow::Owned(_).

fn deref(&self) -> Subject<'_, Y, (), R>

Returns a new subject which is the dereferenced value of the subject.

impl<S: PartialEq + Debug, R> EqualityAssertion<S, R> for Subject<'_, S, (), R>

where AssertionResult: AssertionStrategy<R>,

fn is_equal_to<B: Borrow<S>>(&self, expected: B) -> R

Checks if the subject is equal to expected.

fn is_not_equal_to<B: Borrow<S>>(&self, expected: B) -> R

Checks if the subject value is NOT equal to expected.

impl<'a, S, R: 'a> FloatAssertion<'a, S, R> for Subject<'a, S, (), R>

where S: Float + Debug, AssertionResult: AssertionStrategy<R>,

fn with_rel_tol(self, rel_tol: S) -> Subject<'a, S, FloatTolerance<S>, R>

Set the relative tolerance.

fn with_abs_tol(self, abs_tol: S) -> Subject<'a, S, FloatTolerance<S>, R>

Set the absolute tolerance.

fn is_approx_equal_to<B: Borrow<S>>(&self, expected: B) -> R

where FloatTolerance<S>: Default,

Checks the subject is equal to expected with tolerance.

impl<'a, S, R> FloatAssertion<'a, S, R> for Subject<'a, S, FloatTolerance<S>, R>

where S: Float + Debug, AssertionResult: AssertionStrategy<R>,

fn with_rel_tol(self, rel_tol: S) -> Subject<'a, S, FloatTolerance<S>, R>

Set the relative tolerance.

fn with_abs_tol(self, abs_tol: S) -> Subject<'a, S, FloatTolerance<S>, R>

Set the absolute tolerance.

fn is_approx_equal_to<B: Borrow<S>>(&self, expected: B) -> R

Checks the subject is equal to expected with tolerance.

impl<'a, S, T, R> IteratorAssertion<'a, S, T, R> for Subject<'a, S, (), R>

where S: Iterator<Item = T> + Clone, AssertionResult: AssertionStrategy<R>,

fn contains<B>(&self, element: B) -> R

where B: Borrow<T>, T: PartialEq + Debug,

Checks that the subject iterator contains the element expected.

fn does_not_contain<B>(&self, element: B) -> R

where B: Borrow<T>, T: PartialEq + Debug,

Checks that the subject iterator does not contains the element expected.

fn contains_exactly<EI: Iterator<Item = T> + Clone>( self, expected_iter: EI, ) -> R

where T: PartialEq + Debug,

Checks that the subject exactly contains elements of expected_iter.

fn contains_exactly_in_order<EI: Iterator<Item = T> + Clone>( self, expected_iter: EI, ) -> R

where T: PartialEq + Debug,

Checks that the subject exactly contains elements of expected_iter in the same order.

fn contains_all_of<EI: Iterator<Item = T> + Clone>(self, expected_iter: EI) -> R

where T: PartialEq + Debug,

Checks that the subject contains at least all elements of expected_iter.

fn does_not_contain_any<EI: Iterator<Item = T> + Clone>( &self, elements: EI, ) -> R

where T: PartialEq + Debug,

Checks that the subject does not contains any elements of elements.

fn contains_all_of_in_order<EI: Iterator<Item = T> + Clone>( self, expected_iter: EI, ) -> R

where T: PartialEq + Debug,

Checks that the subject contains at least all elements of expected_iter in the same order.

fn is_empty(&self) -> R

where T: Debug,

Checks that the subject is empty.

fn is_not_empty(&self) -> R

where T: Debug,

Checks that the subject is not empty.

fn has_length(&self, length: usize) -> R

where T: Debug,

Checks that the subject has the given length.

impl<'a, K, V, ML, R> MapAssertion<'a, K, V, ML, R> for Subject<'a, ML, (), R>

where AssertionResult: AssertionStrategy<R>, K: 'a + Eq, ML: MapLike<K, V>,

fn has_length(&self, length: usize) -> R

Checks that the subject has the given length.

fn is_empty(&self) -> R

where K: Debug,

Checks that the subject is empty.

fn is_not_empty(&self) -> R

where K: Debug,

Checks that the subject is not empty.

fn contains_key<BK>(&self, key: BK) -> R

where BK: Borrow<K>, K: Eq + Hash + Debug,

Checks that the subject has the given key.

fn does_not_contain_key<BK>(&self, key: BK) -> R

where BK: Borrow<K>, K: Eq + Hash + Debug,

Checks that the subject does not have the given key.

fn contains_entry<BK, BV>(&self, key: BK, value: BV) -> R

where BK: Borrow<K>, BV: Borrow<V>, K: Eq + Hash + Debug, V: Eq + Debug,

Checks that the subject has entry with the given key and value.

fn does_not_contain_entry<BK, BV>(&self, key: BK, value: BV) -> R

where BK: Borrow<K>, BV: Borrow<V>, K: Eq + Hash + Debug, V: Eq + Debug,

Checks that the subject does not contain entry with the given key and value.

fn contains_at_least<BM, OML>(&self, expected: BM) -> R

where K: Eq + Hash + Debug, V: Eq + Debug, OML: MapLike<K, V> + 'a, BM: Borrow<OML> + 'a,

Checks that the subject contains all entries from expected.

fn does_not_contain_any<BM, OML>(&self, expected: BM) -> R

where K: Eq + Hash + Debug, V: Eq + Debug, OML: MapLike<K, V> + 'a, BM: Borrow<OML> + 'a,

Checks that the subject does not contain any entries from expected.

fn contains_exactly<BM, OML>(&self, expected: BM) -> R

where K: Eq + Hash + Debug, V: Eq + Debug, OML: MapLike<K, V> + 'a, BM: Borrow<OML> + 'a,

Checks that the subject contains only entries from expected.

fn key_set<'b>(&'b self) -> Subject<'_, ML::It<'b>, (), R>

where K: 'b,

Returns a new subject which is an key set of the subject and which implements crate::IteratorAssertion.

impl<T, R> OptionAssertion<T, R> for Subject<'_, Option<T>, (), R>

where AssertionResult: AssertionStrategy<R>,

fn is_none(&self) -> R

where T: PartialEq + Debug,

Checks the subject is Option::None.

fn is_some(&self) -> R

where T: PartialEq + Debug,

Checks the subject is Option::Some(_).

fn has_value<B>(&self, expected: B) -> R

where B: Borrow<T>, T: PartialEq + Debug,

Checks the subject is Option::Some(expected).

fn some(&self) -> Subject<'_, T, (), R>

where T: PartialEq + Debug,

Returns a new subject which is the value of the subject if the subject is Option::Some(_). Otherwise, it fails.

impl<'a, K, V, ML, R> OrderedMapAssertion<'a, K, V, ML, R> for Subject<'a, ML, (), R>

where AssertionResult: AssertionStrategy<R>, K: 'a + Eq + Ord, ML: OrderedMapLike<K, V>,

fn contains_exactly_in_order<BM, OML>(&self, expected: BM) -> R

where K: Eq + Ord + Debug, V: Eq + Debug, OML: OrderedMapLike<K, V> + 'a, BM: Borrow<OML> + 'a,

Checks that the subject exactly contains expected in the same order.

fn contains_all_of_in_order<BM, OML>(&self, expected: BM) -> R

where K: Eq + Ord + Debug, V: Eq + Debug, OML: OrderedMapLike<K, V> + 'a, BM: Borrow<OML> + 'a,

Checks that the subject contains at least all elements of expected in the same order.

impl<'a, T, R, ST> OrderedSetAssertion<'a, ST, T, R> for Subject<'a, ST, (), R>

where AssertionResult: AssertionStrategy<R>, T: Eq + PartialOrd + Debug, ST: OrderedSetLike<T>,

fn contains_all_of_in_order<OSA, OS>(&self, expected: OSA) -> R

where T: PartialOrd + Eq + Debug, OS: OrderedSetLike<T>, OSA: Borrow<OS>,

Checks that the subject contains at least all elements of expected in the same order.

fn contains_exactly_in_order<OSA, OS>(&self, expected: OSA) -> R

where T: PartialOrd + Eq + Debug, OS: OrderedSetLike<T>, OSA: Borrow<OS>,

Checks that the subject exactly contains elements of expected in the same order.

impl<R, OK: Debug, ERR: Debug> ResultAssertion<R, OK, ERR> for Subject<'_, Result<OK, ERR>, (), R>

where AssertionResult: AssertionStrategy<R>,

fn is_ok(&self) -> R

Checks that the subject is Result::Ok(_).

fn is_err(&self) -> R

Checks that the subject is Result::Err(_).

fn has_ok<B: Borrow<OK>>(&self, expected: B) -> R

where OK: PartialEq,

Checks that the subject is Result::Ok(expected).

fn has_err<B: Borrow<ERR>>(&self, expected: B) -> R

where ERR: PartialEq,

Checks that the subject is Result::Err(expected).

fn ok(&self) -> Subject<'_, OK, (), R>

Returns a new subject which is the ok value of the subject if the subject has ok value. Otherwise, it fails.

fn err(&self) -> Subject<'_, ERR, (), R>

Returns a new subject which is the error value of the subject if the subject has error value. Otherwise, it fails.

impl<'a, T, R, ST> SetAssertion<'a, ST, T, R> for Subject<'a, ST, (), R>

where AssertionResult: AssertionStrategy<R>, T: Eq + Debug, ST: SetLike<T>,

fn has_length(&self, length: usize) -> R

Checks that the subject has the given length.

fn is_empty(&self) -> R

where T: Debug,

Checks that the subject is empty.

fn contains<B: Borrow<T>>(&self, expected: B) -> R

where T: PartialEq + Eq + Debug + Hash,

Checks that the subject has expected.

fn does_not_contain<B>(&self, element: B) -> R

where B: Borrow<T>, T: PartialEq + Debug,

Checks that the subject does not contain element.

fn does_not_contain_any<B: Borrow<Vec<T>>>(&self, elements: B) -> R

where T: PartialEq + Debug,

Checks that the subject does not contain any element of elements.

impl<R> StringAssertion<R> for Subject<'_, &str, (), R>

where AssertionResult: AssertionStrategy<R>,

fn is_same_string_to<E: Into<String>>(&self, expected: E) -> R

Checks that the subject is same string to expected.

fn contains<E: Into<String>>(&self, expected: E) -> R

Checks that the subject contains expected.

fn does_not_contain<E: Into<String>>(&self, value: E) -> R

Checks that the subject does not contains value.

fn starts_with<E: Into<String>>(&self, expected: E) -> R

Checks that the subject starts with expected.

fn ends_with<E: Into<String>>(&self, expected: E) -> R

Checks that the subject ends with expected.

impl<R> StringAssertion<R> for Subject<'_, String, (), R>

where AssertionResult: AssertionStrategy<R>,

fn is_same_string_to<E: Into<String>>(&self, expected: E) -> R

Checks that the subject is same string to expected.

fn contains<E: Into<String>>(&self, expected: E) -> R

Checks that the subject contains expected.

fn does_not_contain<E: Into<String>>(&self, value: E) -> R

Checks that the subject does not contains value.

fn starts_with<E: Into<String>>(&self, expected: E) -> R

Checks that the subject starts with expected.

fn ends_with<E: Into<String>>(&self, expected: E) -> R

Checks that the subject ends with expected.

impl<'a, T, R> VecAssertion<'a, Vec<T>, T, R> for Subject<'a, Vec<T>, (), R>

where AssertionResult: AssertionStrategy<R>,

fn contains<B>(&self, element: B) -> R

where B: Borrow<T>, T: PartialEq + Debug,

Checks that the subject contains the element expected.

fn does_not_contain<B>(&self, element: B) -> R

where B: Borrow<T>, T: PartialEq + Debug,

Checks that the subject does not contains the element.

fn contains_exactly<B: Borrow<Vec<T>>>(self, expected_iter: B) -> R

where T: PartialEq + Debug,

Checks that the subject exactly contains elements of expected_vec.

fn contains_exactly_in_order<B: Borrow<Vec<T>>>(self, expected_iter: B) -> R

where T: PartialEq + Debug,

Checks that the subject exactly contains expected_vec in the same order.

fn does_not_contain_any<B: Borrow<Vec<T>>>(&self, elements: B) -> R

where T: PartialEq + Debug,

Checks that the subject does not contain any element of elements.

fn is_empty(&self) -> R

where T: Debug,

Checks that the subject is empty.

fn is_not_empty(&self) -> R

where T: Debug,

Checks that the subject is not empty.

fn has_length(&self, length: usize) -> R

Checks that the subject is the given length.