Struct Spec 

pub struct Spec<'a, S, R> { /* private fields */ }

Data of an actual assertion.

It holds the data needed to execute an assertion such as the subject, the name of the subject or expression, an optional description of the current assertion, and the location of the assertion in the source code respectively test code.

It also holds the concrete FailingStrategy on how to behave in case an assertion fails.

In case of the CollectFailures failing strategy, the AssertFailures are collected in this struct.

Implementations

impl<S, R> Spec<'_, S, R>

pub fn subject(&self) -> &S

Returns the subject.

pub fn expression(&self) -> &Expression<'_>

Returns the expression (or subject name) if one has been set.

pub fn description(&self) -> Option<&str>

Returns the description or the assertion if it has been set.

pub const fn diff_format(&self) -> &DiffFormat

Returns the diff format used with this assertion.

pub fn failing_strategy(&self) -> &R

Returns the failing strategy used in case an assertion fails.

impl<'a, S, R> Spec<'a, S, R>

pub fn new(subject: S, failing_strategy: R) -> Self

Constructs a new Spec for the given subject and with the specified failing strategy.

The diff format is set to “no highlighting”. Failure messages will not highlight differences between the actual and the expected value.

pub fn named(self, subject_name: impl Into<Cow<'a, str>>) -> Self

Sets the subject name or expression for this assertion.

pub fn described_as(self, description: impl Into<Cow<'a, str>>) -> Self

Sets a custom description about what is being asserted.

pub const fn located_at(self, location: Location<'a>) -> Self

Sets the location of the assertion in the source code respectively test code.

pub const fn with_diff_format(self, diff_format: DiffFormat) -> Self

Sets the diff format used to highlight differences between the actual value and the expected value.

Note: This method must be called before an assertion method is called to affect the failure message of the assertion as failure messages are formatted immediately when an assertion is executed.

pub fn with_configured_diff_format(self) -> Self

Available on crate feature colored only.

Sets the diff format used to highlight differences between the actual value and the expected value according to the configured mode.

The mode is configured via environment variables as described in the module colored.

pub fn using_recursive_comparison(self) -> RecursiveComparison<'a, S, R>

Available on crate feature recursive only.

Switches this Spec to the “field-by-field recursive comparison mode”.

It returns a RecursiveComparison which is a specialized Spec that provides extra configuration options for the recursive comparison and the special is_equivalent_to/is_not_equivalent_to assertions of the AssertEquivalence trait.

See the documentation of the recursive_comparison module for details about field-by-field recursive comparison.

pub fn extracting_ref<F, B, U>( self, property_name: impl Into<Cow<'a, str>>, extract: F, ) -> DerivedSpec<'a, Self, U>

where F: FnOnce(&S) -> &B, B: ToOwned<Owned = U> + ?Sized,

Extracts a property from the current subject.

The extracting closure gets a reference to the current subject as an argument and should return a reference to the extracted property. The given property name is used in failure reports for referencing the property for which an assertion fails.

Use this method if you want to extract multiple properties from the same subject for individual assertions on each of these properties. To extract another property from the original subject, call the and method to switch back to the original subject before calling extracting_ref for the other property.

The expression for failure reports is built from the expression of the original subject, a dot as a separator, and the given property name. The resulting expression is equal to format!("{original_expression}.{property_name}").

If you do not like the default built expression, it can be overwritten by calling the named method after the call to the extract method.

Arguments

• property_name - A name describing the extracted property used for referencing this property in failure reports.
• extract - A closure that returns a reference to the property to be extracted.

Examples

use asserting::prelude::*;

#[derive(Debug, Clone, Copy, PartialEq)]
enum Gender {
    Male,
    Female,
    NonBinary,
    PreferNotToSay,
}

struct Person {
    name: String,
    age: u8,
    gender: Gender,
}

impl Person {
    fn name(&self) -> &str {
        &self.name
    }
}

let my_friend = Person {
    name: "Silvia".into(),
    age: 27,
    gender: Gender::Female,
};

assert_that!(my_friend)
    .extracting_ref("name", Person::name)
    .is_equal_to("Silvia")
    .and()
    .extracting_ref("age", |p| &p.age)
    .is_at_least(18)
    .and()
    .extracting_ref("gender", |p| &p.gender)
    .is_equal_to(Gender::Female);

pub fn extracting<F, U>( self, property_name: impl Into<Cow<'a, str>>, extract: F, ) -> Spec<'a, U, R>

where F: FnOnce(S) -> U,

Maps the current subject to some other value.

It takes a closure that maps the current subject to a new subject and returns a new Spec with the value returned by the closure as the new subject. The new subject may have a different type than the original subject. All other data like description, location, and diff format are taken over from this Spec into the returned Spec.

This method is useful when having a custom type, and one specific property of this type shall be asserted only. If you want to assert multiple properties of the same subject, use the extracting_ref method instead.

This method is similar to the mapping method. In contrast to mapping, this method does not copy the subject’s name (or expression) but builds a new expression from the given property_name and the expression of the original subject. The idea is that the “extracted” property is most likely a different subject than the original one.

The expression for failure reports is built from the expression of the original subject, a dot as a separator, and the given property name. The resulting expression is equal to format!("{original_expression}.{property_name}").

If you do not like the default built expression, it can be overwritten by calling the named method after the call to the extract method.

Arguments

• property_name - A name describing the extracted property used for referencing this property in failure reports.
• extract - A closure that returns the property to be extracted.

Example

use asserting::prelude::*;

struct MyStruct {
    important_property: String,
    other_property: f64,
}

let some_thing = MyStruct {
    important_property: "imperdiet aliqua zzril eiusmod".into(),
    other_property: 99.9,
};

assert_that!(some_thing)
    .extracting("important_property", |s| s.important_property)
    .is_equal_to("imperdiet aliqua zzril eiusmod");

In this example the resulting expression used in failure reports to reference the asserted subject is "some_thing.important_property".

To overwrite the default built expression for failure reports, we can call the named method, like so:

assert_that!(some_thing)
    .extracting("important_property", |s| s.important_property)
    .is_equal_to("imperdiet aliqua zzril eiusmod")
    .named("my_struct's important property");

pub fn mapping<F, U>(self, map: F) -> Spec<'a, U, R>

where F: FnOnce(S) -> U,

Maps the current subject to some other value.

It takes a closure that maps the current subject to a new subject and returns a new Spec with the value returned by the closure as the new subject. The new subject may have a different type than the original subject. All other data like expression, description, and location are taken over from this Spec into the returned Spec.

This method is useful if some type does not implement a trait required for an assertion.

Spec also provides the extracting() method, which is similar to this method. In contrast to this method, extracting() does not copy the subject’s name (or expression) but builds a new expression from the expression of the original subject and the given property name.

Example

use asserting::prelude::*;

struct Point {
    x: i64,
    y: i64,
}

let target = Point { x: 12, y: -64 };

assert_that!(target).mapping(|s| (s.x, s.y)).is_equal_to((12, -64));

The custom type Point does not implement the PartialEq trait nor the Debug trait, which are both required for an is_equal_to assertion. So we map the subject of the type Point to a tuple of its fields.

Trait Implementations

impl<S, R> And for Spec<'_, S, R>

type Output = Spec<'_, S, R>

The return type of the and() method.

fn and(self) -> Self::Output

Express explicitly that another assertion must be met to pass the overall assertion.

impl<R> AssertBoolean for Spec<'_, bool, R>

where R: FailingStrategy,

fn is_true(self) -> Self

Verifies that the subject is true.

fn is_false(self) -> Self

Verifies that the subject is false.

impl<R> AssertChar for Spec<'_, char, R>

where R: FailingStrategy,

fn is_lowercase(self) -> Self

Verify that a character is lowercase.

fn is_uppercase(self) -> Self

Verify that a character is uppercase.

fn is_ascii(self) -> Self

Verify that a character is an ASCII character.

fn is_alphabetic(self) -> Self

Verify that a character is an alphabetic character.

fn is_alphanumeric(self) -> Self

Verify that a character is an alphabetic character or a digit.

fn is_control_char(self) -> Self

Verify that a character is a control character.

fn is_digit(self, radix: u32) -> Self

Verify that a character is a digit within the given radix.

fn is_whitespace(self) -> Self

Verify that a character is whitespace.

impl<R> AssertChar for Spec<'_, &char, R>

where R: FailingStrategy,

fn is_lowercase(self) -> Self

Verify that a character is lowercase.

fn is_uppercase(self) -> Self

Verify that a character is uppercase.

fn is_ascii(self) -> Self

Verify that a character is an ASCII character.

fn is_alphabetic(self) -> Self

Verify that a character is an alphabetic character.

fn is_alphanumeric(self) -> Self

Verify that a character is an alphabetic character or a digit.

fn is_control_char(self) -> Self

Verify that a character is a control character.

fn is_digit(self, radix: u32) -> Self

Verify that a character is a digit within the given radix.

fn is_whitespace(self) -> Self

Verify that a character is whitespace.

impl<'a, S, R> AssertCodePanics for Spec<'a, Code<S>, R>

where S: FnOnce(), R: FailingStrategy,

Available on crate feature panic only.

type Mapped = Spec<'a, (), R>

A spec-like type that contains the mapped type as subject, which is returned by mapping assertion methods.

fn does_not_panic(self) -> Self::Mapped

Verifies that the actual code under test does not panic.

fn panics(self) -> Self::Mapped

Verifies that the actual code under test panics with any message.

fn panics_with_message(self, message: impl Into<String>) -> Self::Mapped

Verifies that the actual code under test panics with the given message.

impl<'a, S, R> AssertDebugString for Spec<'a, S, R>

where S: Debug, R: FailingStrategy,

type DebugString = Spec<'a, String, R>

A spec-like type that contains the debug string as the subject, which is returned by the mapping assertion method.

fn debug_string(self) -> Self::DebugString

Maps the subject into its debug string representation to do assertions on its debug string.

impl<S, R> AssertDecimalNumber for Spec<'_, S, R>

where S: DecimalProperties + Debug, R: FailingStrategy,

fn has_scale_of(self, expected_scale: i64) -> Self

Verifies the scale of a decimal number.

fn has_precision_of(self, expected_precision: u64) -> Self

Verifies the precision of a decimal number.

fn is_integer(self) -> Self

Verifies that a decimal number has zero fractional digits (is equivalent to an integer).

impl<'a, S, R> AssertDisplayString for Spec<'a, S, R>

where S: Display, R: FailingStrategy,

type DisplayString = Spec<'a, String, R>

A spec-like type that contains the display string as the subject, which is returned by the mapping assertion method.

fn display_string(self) -> Self::DisplayString

Maps the subject into its display string representation to do assertions on its display string.

impl<'a, I, R> AssertElements<'a, I> for Spec<'a, I, R>

where I: IntoIterator,

type Output = Spec<'a, (), R>

A spec-like type that is returned by the methods of this trait.

fn each_element<A, B>(self, assert: A) -> Self::Output

where A: Fn(Spec<'a, <I as IntoIterator>::Item, CollectFailures>) -> B, B: GetFailures,

Iterates over the elements of a collection or an iterator and executes the given assertions for each of those elements. If all elements are asserted successfully, the whole assertion succeeds.

fn any_element<A, B>(self, assert: A) -> Self::Output

where A: Fn(Spec<'a, <I as IntoIterator>::Item, CollectFailures>) -> B, B: GetFailures,

Iterates over the elements of a collection or an iterator and executes the given assertions for each of those elements. If the assertion of any element is successful, the iteration stops and the whole assertion succeeds.

impl<S, R> AssertEmptiness for Spec<'_, S, R>

where S: IsEmptyProperty + Debug, R: FailingStrategy,

fn is_empty(self) -> Self

Verifies that the subject is empty.

fn is_not_empty(self) -> Self

Verifies that the subject is not empty.

impl<S, E, R> AssertEquality<E> for Spec<'_, S, R>

where S: PartialEq<E> + Debug, E: Debug, R: FailingStrategy,

fn is_equal_to(self, expected: E) -> Self

Verifies that the subject is equal to some other value.

fn is_not_equal_to(self, expected: E) -> Self

Verifies that the subject is not equal to some other value.

impl<'a, S, R> AssertErrorHasSource for Spec<'a, S, R>

where S: Error, R: FailingStrategy,

type SourceMessage = Spec<'a, Option<String>, R>

A spec-like type that contains the source message as the subject, which is returned by the mapping assertion method.

fn has_no_source(self) -> Self

Verifies that an error has no source.

fn has_source(self) -> Self

Verifies that an error has some source.

fn has_source_message( self, expected_source_message: impl Into<String>, ) -> Self::SourceMessage

Verifies that an error has some source which converted to a string equals the expected message.

impl<'a, S, T, R> AssertFilteredElements<T> for Spec<'a, S, R>

where S: IntoIterator<Item = T>, T: Debug, R: FailingStrategy,

type SingleElement = Spec<'a, T, R>

A spec-like type that contains a single element as the subject that is extracted from the iterator.

type MultipleElements = Spec<'a, Vec<T>, R>

A spec-like type that contains multiple or all elements of an iterator as the subject.

fn single_element(self) -> Self::SingleElement

Verify that the iterator contains exactly one element and return a Spec for that single element.

fn filtered_on<C>(self, condition: C) -> Self::MultipleElements

where C: FnMut(&T) -> bool,

Filter the elements of a collection or an iterator on a condition and return a Spec only containing the elements that match the condition.

fn any_satisfies<P>(self, predicate: P) -> Self::MultipleElements

where P: FnMut(&T) -> bool,

Verify that any element of a collection or an iterator satisfies a given predicate.

fn all_satisfy<P>(self, predicate: P) -> Self::MultipleElements

where P: FnMut(&T) -> bool,

Verify that all elements of a collection or an iterator satisfy a given predicate.

fn none_satisfies<P>(self, predicate: P) -> Self::MultipleElements

where P: FnMut(&T) -> bool,

Verify that none of the elements of a collection or an iterator satisfies a given predicate.

impl<S, R> AssertHasCharCount<usize> for Spec<'_, S, R>

where S: CharCountProperty + Debug, R: FailingStrategy,

fn has_char_count(self, expected_char_count: usize) -> Self

Verifies that the subject contains the expected number of characters.

fn has_char_count_in_range<U>(self, expected_range: U) -> Self

where U: RangeBounds<usize> + Debug,

Verifies that the subject contains a number of characters that is in the expected range.

fn has_char_count_less_than(self, expected_char_count: usize) -> Self

Verifies that the subject contains less than the expected number of characters.

fn has_char_count_greater_than(self, expected_char_count: usize) -> Self

Verifies that the subject contains more than the expected number of characters.

fn has_at_most_char_count(self, expected_char_count: usize) -> Self

Verifies that the subject contains at least the expected number of characters.

fn has_at_least_char_count(self, expected_char_count: usize) -> Self

Verifies that the subject contains at least the expected number of characters.

impl<S, E, R> AssertHasDebugString<E> for Spec<'_, S, R>

where S: Debug, E: AsRef<str>, R: FailingStrategy,

fn has_debug_string(self, expected: E) -> Self

Verifies that a subject formatted for debugging results in the expected string.

fn does_not_have_debug_string(self, expected: E) -> Self

Verifies that a subject formatted for debugging does not result in the expected string.

impl<S, E, R> AssertHasDisplayString<E> for Spec<'_, S, R>

where S: Display, E: AsRef<str>, R: FailingStrategy,

fn has_display_string(self, expected: E) -> Self

Verifies that a subject formatted for display results in the expected string.

fn does_not_have_display_string(self, expected: E) -> Self

Verifies that a subject formatted for display does not result in the expected string.

impl<T, E, X, R> AssertHasError<X> for Spec<'_, Result<T, E>, R>

where T: Debug, E: PartialEq<X> + Debug, X: Debug, R: FailingStrategy,

fn has_error(self, expected: X) -> Self

Verifies that the subject holds an error value that is equal to the expected one.

impl<T, E, X, R> AssertHasError<X> for Spec<'_, &Result<T, E>, R>

where T: Debug, E: PartialEq<X> + Debug, X: Debug, R: FailingStrategy,

fn has_error(self, expected: X) -> Self

Verifies that the subject holds an error value that is equal to the expected one.

impl<'a, T, E, X, R> AssertHasErrorMessage<X> for Spec<'a, Result<T, E>, R>

where T: Debug, E: Display, X: Debug, String: PartialEq<X>, R: FailingStrategy,

type ErrorMessage = Spec<'a, String, R>

A spec-like type that contains the error message as the subject, which is returned by the mapping assertion method.

fn has_error_message(self, expected: X) -> Self::ErrorMessage

Verifies that the subject is an error value with the expected message.

impl<'a, T, E, X, R> AssertHasErrorMessage<X> for Spec<'a, &Result<T, E>, R>

where T: Debug, E: Display, X: Debug, String: PartialEq<X>, R: FailingStrategy,

type ErrorMessage = Spec<'a, String, R>

A spec-like type that contains the error message as the subject, which is returned by the mapping assertion method.

fn has_error_message(self, expected: X) -> Self::ErrorMessage

Verifies that the subject is an error value with the expected message.

impl<S, R> AssertHasLength<usize> for Spec<'_, S, R>

where S: LengthProperty + Debug, R: FailingStrategy,

fn has_length(self, expected_length: usize) -> Self

Verifies that the subject has the expected length.

fn has_length_in_range<U>(self, expected_range: U) -> Self

where U: RangeBounds<usize> + Debug,

Verifies that the subject has a length in the expected range.

fn has_length_less_than(self, expected_length: usize) -> Self

Verifies that the subject has a length that is less than the expected length.

fn has_length_greater_than(self, expected_length: usize) -> Self

Verifies that the subject has a length that is greater than the expected length.

fn has_at_most_length(self, expected_length: usize) -> Self

Verifies that the subject has a length that is at most the expected length.

fn has_at_least_length(self, expected_length: usize) -> Self

Verifies that the subject has a length that is at least the expected length.

impl<S, E, R> AssertHasValue<E> for Spec<'_, Option<S>, R>

where S: PartialEq<E> + Debug, E: Debug, R: FailingStrategy,

fn has_value(self, expected: E) -> Self

Verifies that the subject holds a value that is equal to the expected one.

impl<S, E, R> AssertHasValue<E> for Spec<'_, &Option<S>, R>

where S: PartialEq<E> + Debug, E: Debug, R: FailingStrategy,

fn has_value(self, expected: E) -> Self

Verifies that the subject holds a value that is equal to the expected one.

impl<T, E, X, R> AssertHasValue<X> for Spec<'_, Result<T, E>, R>

where T: PartialEq<X> + Debug, E: Debug, X: Debug, R: FailingStrategy,

fn has_value(self, expected: X) -> Self

Verifies that the subject holds a value that is equal to the expected one.

impl<T, E, X, R> AssertHasValue<X> for Spec<'_, &Result<T, E>, R>

where T: PartialEq<X> + Debug, E: Debug, X: Debug, R: FailingStrategy,

fn has_value(self, expected: X) -> Self

Verifies that the subject holds a value that is equal to the expected one.

impl<S, E, R> AssertInRange<E> for Spec<'_, S, R>

where S: PartialOrd<E> + Debug, E: PartialOrd<S> + Debug, R: FailingStrategy,

fn is_in_range<U>(self, range: U) -> Self

where U: RangeBounds<E> + Debug,

Verifies that the subject is within the expected range.

fn is_not_in_range<U>(self, range: U) -> Self

where U: RangeBounds<E> + Debug,

Verifies that the subject is not within the expected range.

impl<S, R> AssertInfinity for Spec<'_, S, R>

where S: InfinityProperty + Debug, R: FailingStrategy,

fn is_infinite(self) -> Self

Verifies that the subject is an infinite number.

fn is_finite(self) -> Self

Verifies that the subject is a finite number.

impl<R> AssertIsCloseToWithDefaultMargin<f32> for Spec<'_, f32, R>

where R: FailingStrategy,

Available on crate feature float-cmp only.

fn is_close_to(self, expected: f32) -> Self

Verifies that the actual value is approximately equal to the expected value.

fn is_not_close_to(self, expected: f32) -> Self

Verifies that the actual value is not approximately equal to the expected value.

impl<R> AssertIsCloseToWithDefaultMargin<f64> for Spec<'_, f64, R>

where R: FailingStrategy,

Available on crate feature float-cmp only.

fn is_close_to(self, expected: f64) -> Self

Verifies that the actual value is approximately equal to the expected value.

fn is_not_close_to(self, expected: f64) -> Self

Verifies that the actual value is not approximately equal to the expected value.

impl<R> AssertIsCloseToWithinMargin<f32, F32Margin> for Spec<'_, f32, R>

where R: FailingStrategy,

Available on crate feature float-cmp only.

fn is_close_to_with_margin( self, expected: f32, margin: impl Into<F32Margin>, ) -> Self

Verifies that the actual value is approximately equal to the expected value.

fn is_not_close_to_with_margin( self, expected: f32, margin: impl Into<F32Margin>, ) -> Self

Verifies that the actual value not approximately equals to the expected value.

impl<R> AssertIsCloseToWithinMargin<f64, F64Margin> for Spec<'_, f64, R>

where R: FailingStrategy,

Available on crate feature float-cmp only.

fn is_close_to_with_margin( self, expected: f64, margin: impl Into<F64Margin>, ) -> Self

Verifies that the actual value is approximately equal to the expected value.

fn is_not_close_to_with_margin( self, expected: f64, margin: impl Into<F64Margin>, ) -> Self

Verifies that the actual value not approximately equals to the expected value.

impl<'a, S, T, E, R> AssertIteratorContains<E> for Spec<'a, S, R>

where S: IntoIterator<Item = T>, T: PartialEq<E> + Debug, E: Debug, R: FailingStrategy,

type Sequence = Spec<'a, Vec<T>, R>

A spec-like type that contains the collected values from the iterator as the subject, which is returned by the mapping assertion methods.

fn contains(self, expected: E) -> Self::Sequence

Verifies that the actual collection/iterator contains at least one element that is equal to the expected value.

fn does_not_contain(self, expected: E) -> Self::Sequence

Verifies that the actual collection/iterator does not contain an element that is equal to the expected value.

impl<'a, S, T, E, R> AssertIteratorContainsInAnyOrder<E> for Spec<'a, S, R>

where S: IntoIterator<Item = T>, T: PartialEq<<E as IntoIterator>::Item> + Debug, E: IntoIterator, <E as IntoIterator>::Item: Debug, R: FailingStrategy,

type Sequence = Spec<'a, Vec<T>, R>

A spec-like type that contains the collected values from the iterator as the subject, which is returned by the mapping assertion methods.

fn contains_exactly_in_any_order(self, expected: E) -> Self::Sequence

Verifies that the actual collection/iterator contains exactly the given values and nothing else in any order.

fn contains_any_of(self, expected: E) -> Spec<'a, Vec<T>, R>

Verifies that the actual collection/iterator contains at least one of the specified values.

fn does_not_contain_any_of(self, expected: E) -> Spec<'a, Vec<T>, R>

Verifies that the actual collection/iterator does not contain any of the specified values.

fn contains_all_of(self, expected: E) -> Spec<'a, Vec<T>, R>

Verifies that the actual collection/iterator contains the given values in any order.

fn contains_only(self, expected: E) -> Spec<'a, Vec<T>, R>

Verifies that the actual collection/iterator contains only the given values and nothing else in any order and ignoring duplicates.

fn contains_only_once(self, expected: E) -> Spec<'a, Vec<T>, R>

Verifies that the actual collection/iterator contains only the given values in any order and each of them only once.

impl<'a, S, T, E, R> AssertIteratorContainsInOrder<E> for Spec<'a, S, R>

where S: IntoIterator<Item = T>, <S as IntoIterator>::IntoIter: DefinedOrderProperty, E: IntoIterator, <E as IntoIterator>::IntoIter: DefinedOrderProperty, <E as IntoIterator>::Item: Debug, T: PartialEq<<E as IntoIterator>::Item> + Debug, R: FailingStrategy,

type Sequence = Spec<'a, Vec<T>, R>

A spec-like type that contains the collected values from the iterator as the subject, which is returned by the mapping assertion methods.

fn contains_exactly(self, expected: E) -> Self::Sequence

Verifies that the actual collection/iterator contains exactly the given values and nothing else in the given order.

fn contains_sequence(self, expected: E) -> Self::Sequence

Verifies that the actual collection/iterator contains the given sequence of values in the given order and without extra values between the sequence values.

fn contains_all_in_order(self, expected: E) -> Self::Sequence

Verifies that the actual collection/iterator contains all the given values and in the given order, possibly with other values between them.

fn starts_with(self, expected: E) -> Self::Sequence

Verifies that the actual collection/iterator contains the given values as the first elements in order.

fn ends_with(self, expected: E) -> Self::Sequence

Verifies that the actual collection/iterator contains the given values as the last elements in order.

impl<S, E, R> AssertMapContainsKey<E> for Spec<'_, S, R>

where S: MapProperties + Debug, <S as MapProperties>::Key: PartialEq<E> + Debug, <S as MapProperties>::Value: Debug, E: Debug, R: FailingStrategy,

fn contains_key(self, expected_key: E) -> Self

Verify that the actual map contains a mapping for the given key.

fn does_not_contain_key(self, expected_key: E) -> Self

Verify that the actual map does not contain any mapping for the given key.

fn contains_keys(self, expected_keys: impl IntoIterator<Item = E>) -> Self

Verify that the actual map contains a mapping for each of the given keys.

fn does_not_contain_keys( self, expected_keys: impl IntoIterator<Item = E>, ) -> Self

Verify that the actual map does not contain any mapping for one of the given keys.

fn contains_exactly_keys( self, expected_keys: impl IntoIterator<Item = E>, ) -> Self

Verifies that the actual map contains a mapping for each of the expected keys but no more.

impl<S, E, R> AssertMapContainsValue<E> for Spec<'_, S, R>

where S: MapProperties, <S as MapProperties>::Key: Debug, <S as MapProperties>::Value: PartialEq<E> + Debug, E: Debug, R: FailingStrategy,

fn contains_value(self, expected_value: E) -> Self

Verify that the actual map contains at least one mapping where the value is equal to the expected one.

fn does_not_contain_value(self, expected_value: E) -> Self

Verify that the actual map does not contain any mapping where the value is equal to the expected one.

fn contains_values(self, expected_values: impl IntoIterator<Item = E>) -> Self

Verify that the actual map contains at least one mapping for each of the given values, where the mapping contains one of the expected values.

fn does_not_contain_values( self, expected_values: impl IntoIterator<Item = E>, ) -> Self

Verify that the actual map does not contain any mapping where the value is one of the given values.

impl<S, R> AssertNotANumber for Spec<'_, S, R>

where S: IsNanProperty + Debug, R: FailingStrategy,

fn is_not_a_number(self) -> Self

Verifies that the subject is not a number.

fn is_a_number(self) -> Self

Verifies that the subject is a number.

impl<S, R> AssertNumericIdentity for Spec<'_, S, R>

where S: AdditiveIdentityProperty + MultiplicativeIdentityProperty + PartialEq + Debug, R: FailingStrategy,

fn is_zero(self) -> Self

Verifies whether the subject is the additive identity (zero).

fn is_one(self) -> Self

Verifies whether the subject is the multiplicative identity (one).

impl<S, R> AssertOption for Spec<'_, Option<S>, R>

where S: Debug, R: FailingStrategy,

fn is_some(self) -> Self

Verifies that the subject has some value.

fn is_none(self) -> Self

Verifies that the subject has no value.

impl<S, R> AssertOption for Spec<'_, &Option<S>, R>

where S: Debug, R: FailingStrategy,

fn is_some(self) -> Self

Verifies that the subject has some value.

fn is_none(self) -> Self

Verifies that the subject has no value.

impl<'a, T, R> AssertOptionValue for Spec<'a, Option<T>, R>

where R: FailingStrategy,

type Some = Spec<'a, T, R>

A spec-like type that contains the option’s value as the subject, which is returned by the mapping assertion method.

fn some(self) -> Self::Some

Maps the subject to the option’s value if it has some. Otherwise, this assertion fails.

impl<'a, T, R> AssertOptionValue for Spec<'a, &'a Option<T>, R>

where R: FailingStrategy,

type Some = Spec<'a, &'a T, R>

A spec-like type that contains the option’s value as the subject, which is returned by the mapping assertion method.

fn some(self) -> Self::Some

Maps the subject to the option’s value if it has some. Otherwise, this assertion fails.

impl<S, E, R> AssertOrder<E> for Spec<'_, S, R>

where S: PartialOrd<E> + Debug, E: Debug, R: FailingStrategy,

fn is_less_than(self, expected: E) -> Self

Verifies that the subject is less than some expected value.

fn is_greater_than(self, expected: E) -> Self

Verifies that the subject is greater than some expected value.

fn is_at_most(self, expected: E) -> Self

Verifies that the subject is less than or equal to some expected value.

fn is_at_least(self, expected: E) -> Self

Verifies that the subject is greater than or equal to some expected value.

fn is_before(self, expected: E) -> Self

Verifies that the subject is before some expected value.

fn is_after(self, expected: E) -> Self

Verifies that the subject is after some expected value.

fn is_between(self, min: E, max: E) -> Self

Verifies that the subject is between a min value and a max value.

impl<'a, S, T, R> AssertOrderedElements for Spec<'a, S, R>

where S: IntoIterator<Item = T>, <S as IntoIterator>::IntoIter: DefinedOrderProperty, T: Debug, R: FailingStrategy,

type SingleElement = Spec<'a, T, R>

A spec-like type that contains a single element as the subject that is extracted from the iterator.

type MultipleElements = Spec<'a, Vec<T>, R>

A spec-like type that contains multiple or all elements of an iterator as the subject.

fn first_element(self) -> Self::SingleElement

Verify that a collection or an iterator contains at least one element and return a Spec for the first element.

fn last_element(self) -> Self::SingleElement

Verify that a collection or an iterator contains at least one element and return a Spec for the last element.

fn nth_element(self, n: usize) -> Self::SingleElement

Verify that a collection or an iterator contains at least n + 1 elements and return a Spec for the nth element.

fn elements_at( self, indices: impl IntoIterator<Item = usize>, ) -> Self::MultipleElements

Pick the elements of a collection or an iterator at the given positions and return a Spec only containing the selected elements.

impl<'a, S, T, U, R> AssertOrderedElementsRef for Spec<'a, S, R>

where S: IntoIterator<Item = T>, <S as IntoIterator>::IntoIter: DefinedOrderProperty, T: 'a + ToOwned<Owned = U> + Debug, U: Clone, R: FailingStrategy,

type SingleElement = DerivedSpec<'a, Spec<'a, Vec<T>, R>, U>

A spec-like type that contains a single element as the subject that is extracted from the iterator.

type MultipleElements = DerivedSpec<'a, Spec<'a, Vec<T>, R>, Vec<U>>

A spec-like type that contains multiple or all elements of an iterator as the subject.

fn first_element_ref(self) -> Self::SingleElement

Verify that a collection or an iterator contains at least one element and return a Spec for the first element.

fn last_element_ref(self) -> Self::SingleElement

Verify that a collection or an iterator contains at least one element and return a Spec for the last element.

fn nth_element_ref(self, n: usize) -> Self::SingleElement

Verify that a collection or an iterator contains at least n + 1 elements and return a Spec for the nth element.

fn elements_ref_at( self, indices: impl IntoIterator<Item = usize>, ) -> Self::MultipleElements

Pick the elements of a collection or an iterator at the given positions and return a Spec only containing the selected elements.

impl<T, E, R> AssertResult for Spec<'_, Result<T, E>, R>

where T: Debug, E: Debug, R: FailingStrategy,

fn is_ok(self) -> Self

Verifies that the subject has an ok value.

fn is_err(self) -> Self

Verifies that the subject has an err value.

impl<T, E, R> AssertResult for Spec<'_, &Result<T, E>, R>

where T: Debug, E: Debug, R: FailingStrategy,

fn is_ok(self) -> Self

Verifies that the subject has an ok value.

fn is_err(self) -> Self

Verifies that the subject has an err value.

impl<'a, T, E, R> AssertResultValue for Spec<'a, Result<T, E>, R>

where T: Debug, E: Debug,

type Ok = Spec<'a, T, R>

A spec-like type that contains the result’s ok value as the subject, which is returned by the mapping assertion method.

type Err = Spec<'a, E, R>

A spec-like type that contains the result’s error value as the subject, which is returned by the mapping assertion method.

fn ok(self) -> Self::Ok

Maps the subject to the result’s ok value.

fn err(self) -> Self::Err

Maps the subject to the result’s err value.

impl<'a, T, E, R> AssertResultValue for Spec<'a, &'a Result<T, E>, R>

where T: Debug, E: Debug,

type Ok = Spec<'a, &'a T, R>

A spec-like type that contains the result’s ok value as the subject, which is returned by the mapping assertion method.

type Err = Spec<'a, &'a E, R>

A spec-like type that contains the result’s error value as the subject, which is returned by the mapping assertion method.

fn ok(self) -> Self::Ok

Maps the subject to the result’s ok value.

fn err(self) -> Self::Err

Maps the subject to the result’s err value.

impl<S, R> AssertSameAs<S> for Spec<'_, S, R>

where S: PartialEq + Debug, R: FailingStrategy,

fn is_same_as(self, expected: S) -> Self

Verifies that the subject is of the same type and has the same value as some other value.

fn is_not_same_as(self, expected: S) -> Self

Verifies that the subject is of the same type but has a different value as some other value.

impl<S, R> AssertSignum for Spec<'_, S, R>

where S: SignumProperty + Debug, R: FailingStrategy,

fn is_negative(self) -> Self

Verifies that the subject is a negative number.

fn is_not_negative(self) -> Self

Verifies that the subject is a non-negative number.

fn is_positive(self) -> Self

Verifies that the subject is a positive number.

fn is_not_positive(self) -> Self

Verifies that the subject is a non-positive number.

impl<'a, S, R, const N: usize> AssertStringContainsAnyOf<&'a [char; N]> for Spec<'a, S, R>

where S: 'a + AsRef<str> + Debug, R: FailingStrategy,

fn contains_any_of(self, expected: &'a [char; N]) -> Self

Verifies that a string contains any char from a collection of characters.

fn does_not_contain_any_of(self, expected: &'a [char; N]) -> Self

Verifies that a string does not contain any char from a collection of characters.

impl<'a, S, R> AssertStringContainsAnyOf<&'a [char]> for Spec<'a, S, R>

where S: 'a + AsRef<str> + Debug, R: FailingStrategy,

fn contains_any_of(self, expected: &'a [char]) -> Self

Verifies that a string contains any char from a collection of characters.

fn does_not_contain_any_of(self, expected: &'a [char]) -> Self

Verifies that a string does not contain any char from a collection of characters.

impl<'a, S, R, const N: usize> AssertStringContainsAnyOf<[char; N]> for Spec<'a, S, R>

where S: 'a + AsRef<str> + Debug, R: FailingStrategy,

fn contains_any_of(self, expected: [char; N]) -> Self

Verifies that a string contains any char from a collection of characters.

fn does_not_contain_any_of(self, expected: [char; N]) -> Self

Verifies that a string does not contain any char from a collection of characters.

impl<S, R> AssertStringMatches for Spec<'_, S, R>

where S: AsRef<str> + Debug, R: FailingStrategy,

Available on crate feature regex only.

fn matches(self, regex_pattern: &str) -> Self

Verifies that a string matches a regex pattern.

fn does_not_match(self, regex_pattern: &str) -> Self

Verifies that a string does not match a regex pattern.

impl<'a, S, R> AssertStringPattern<&'a str> for Spec<'a, S, R>

where S: 'a + AsRef<str> + Debug, R: FailingStrategy,

fn contains(self, pattern: &'a str) -> Self

Verifies that a string contains a substring or character.

fn does_not_contain(self, pattern: &'a str) -> Self

Verifies that a string does not contain a substring or character.

fn starts_with(self, pattern: &str) -> Self

Verifies that a string starts with a substring or character.

fn does_not_start_with(self, pattern: &'a str) -> Self

Verifies that a string does not start with a substring or character.

fn ends_with(self, pattern: &str) -> Self

Verifies that a string ends with a substring or character.

fn does_not_end_with(self, pattern: &'a str) -> Self

Verifies that a string does not end with a substring or character.

impl<'a, S, R> AssertStringPattern<String> for Spec<'a, S, R>

where S: 'a + AsRef<str> + Debug, R: FailingStrategy,

fn contains(self, pattern: String) -> Self

Verifies that a string contains a substring or character.

fn does_not_contain(self, pattern: String) -> Self

Verifies that a string does not contain a substring or character.

fn starts_with(self, pattern: String) -> Self

Verifies that a string starts with a substring or character.

fn does_not_start_with(self, pattern: String) -> Self

Verifies that a string does not start with a substring or character.

fn ends_with(self, pattern: String) -> Self

Verifies that a string ends with a substring or character.

fn does_not_end_with(self, pattern: String) -> Self

Verifies that a string does not end with a substring or character.

impl<'a, S, R> AssertStringPattern<char> for Spec<'a, S, R>

where S: 'a + AsRef<str> + Debug, R: FailingStrategy,

fn contains(self, expected: char) -> Self

Verifies that a string contains a substring or character.

fn does_not_contain(self, pattern: char) -> Self

Verifies that a string does not contain a substring or character.

fn starts_with(self, expected: char) -> Self

Verifies that a string starts with a substring or character.

fn does_not_start_with(self, pattern: char) -> Self

Verifies that a string does not start with a substring or character.

fn ends_with(self, pattern: char) -> Self

Verifies that a string ends with a substring or character.

fn does_not_end_with(self, pattern: char) -> Self

Verifies that a string does not end with a substring or character.

impl<S, R> DoFail for Spec<'_, S, R>

where R: FailingStrategy,

fn do_fail_with(&mut self, failures: impl IntoIterator<Item = AssertFailure>)

Fails the assertion with the given AssertFailures according to the current failing strategy of the Spec or other implementing spec-like struct.

fn do_fail_with_message(&mut self, message: impl Into<String>)

Fails the assertion with the given failure message according to the current failing strategy of the Spec or other implementing spec-like struct.

impl<S, R> Expecting<S> for Spec<'_, S, R>

where R: FailingStrategy,

fn expecting(self, expectation: impl Expectation<S>) -> Self

Asserts the given expectation.

impl<S, R> GetFailures for Spec<'_, S, R>

fn has_failures(&self) -> bool

Returns whether there are assertion failures collected so far.

fn failures(&self) -> Vec<AssertFailure>

Returns the assertion failures that have been collected so far.

fn display_failures(&self) -> Vec<String>

Returns the assertion failures collected so far as formatted text.

impl<'a, S, R> GetLocation<'a> for Spec<'a, S, R>

fn location(&self) -> Option<Location<'a>>

Returns the location in source code or test code if it has been set.

impl<S, R> Satisfies<S> for Spec<'_, S, R>

where R: FailingStrategy,

fn satisfies<P>(self, predicate: P) -> Self

where P: Fn(&S) -> bool,

Asserts whether the given predicate is meet.

fn satisfies_with_message<P>( self, message: impl Into<String>, predicate: P, ) -> Self

where P: Fn(&S) -> bool,

Asserts whether the given predicate is meet.

impl<S> SoftPanic for Spec<'_, S, CollectFailures>

fn soft_panic(&self)

Turns assertions into “soft assertions”.