Enum fuchsia_bluetooth::expectation::Predicate

pub enum Predicate<T> {
    Equal(Arc<T>, Arc<dyn Fn(&T, &T) -> bool + Send + Sync + 'static>, Arc<dyn Fn(&T) -> String + Send + Sync + 'static>),
    And(Box<Predicate<T>>, Box<Predicate<T>>),
    Or(Box<Predicate<T>>, Box<Predicate<T>>),
    Not(Box<Predicate<T>>),
    Predicate(Arc<dyn Fn(&T) -> bool + Send + Sync>, String),
    Over(Arc<dyn IsOver<T> + Send + Sync>),
    Any(Arc<dyn IsAny<T> + Send + Sync + 'static>),
    All(Arc<dyn IsAll<T> + Send + Sync + 'static>),
}

A Boolean predicate on type T. Predicate functions are a boolean algebra just as raw boolean values are; they an be ANDed, ORed, NOTed. This allows a clear and concise language for declaring test expectations.

Variants

Equal(Arc<T>, Arc<dyn Fn(&T, &T) -> bool + Send + Sync + 'static>, Arc<dyn Fn(&T) -> String + Send + Sync + 'static>)

And(Box<Predicate<T>>, Box<Predicate<T>>)

Or(Box<Predicate<T>>, Box<Predicate<T>>)

Not(Box<Predicate<T>>)

Predicate(Arc<dyn Fn(&T) -> bool + Send + Sync>, String)

Over(Arc<dyn IsOver<T> + Send + Sync>)

Any(Arc<dyn IsAny<T> + Send + Sync + 'static>)

All(Arc<dyn IsAll<T> + Send + Sync + 'static>)

Implementations

impl<T> Predicate<T>

pub fn describe<'a>( &self, doc: &'a BoxAllocator ) -> DocBuilder<'a, BoxAllocator>

pub fn falsify<'d>( &self, t: &T, doc: &'d BoxAllocator ) -> Option<DocBuilder<'d, BoxAllocator>>

Provide a minimized falsification of the predicate, if possible

pub fn satisfied<'t>(&self, t: &'t T) -> bool

pub fn assert_satisfied(&self, t: &T) -> Result<(), DebugString>

pub fn and(self, rhs: Predicate<T>) -> Predicate<T>

pub fn or(self, rhs: Predicate<T>) -> Predicate<T>

pub fn not(self) -> Predicate<T>

pub fn predicate<F, S>(f: F, label: S) -> Predicate<T>

where F: for<'t> Fn(&'t T) -> bool + Send + Sync + 'static, S: Into<String>,

Construct a simple predicate function

impl<T: PartialEq + Debug + 'static> Predicate<T>

Convenient implementations that rely on Debug to provide output on falsification, and PartialEq to provide equality. If you wish to create predicates for ?Debug types, use the Predicate or Equal constructors directly.

pub fn equal(t: T) -> Predicate<T>

Construct a Predicate that expects two Ts to be equal

pub fn not_equal(t: T) -> Predicate<T>

Construct a Predicate that expects two Ts to be non-equal

impl<Elem, T> Predicate<T>

where T: Send + Sync + 'static, for<'a> &'a T: IntoIterator<Item = &'a Elem>, Elem: Debug + Send + Sync + 'static,

Predicates on iterable types, those convertible into iterators via IntoIterator (e.g. Vec<_>)

pub fn all(pred: Predicate<Elem>) -> Predicate<T>

Construct a predicate that all elements of an iterable type match a given predicate If the iterable is empty, the predicate will succeed

pub fn any(pred: Predicate<Elem>) -> Predicate<T>

Construct a predicate that at least one element of an iterable type match a given predicate If the iterable is empty, the predicate will fail

impl<'e, Elem, Iter> Predicate<Iter>

where Iter: Iterator<Item = &'e Elem> + Clone, Elem: Debug + Send + Sync + 'static,

Predicates on types which are an Iterator

pub fn iter_all(pred: Predicate<Elem>) -> Predicate<Iter>

Construct a predicate that all elements of an Iterator match a given predicate If the Iterator is empty, the predicate will succeed

pub fn iter_any(pred: Predicate<Elem>) -> Predicate<Iter>

Construct a predicate that at least one element of an Iterator match a given predicate If the iterator is empty, the predicate will fail

impl<U: Send + Sync + 'static> Predicate<U>

pub fn over<F, T, P>(self, project: F, path: P) -> Predicate<T>

where F: Fn(&T) -> &U + Send + Sync + 'static, P: Into<String>, T: 'static,

Lift a predicate over a projection from T -> &U. This constructs a Predicate from a predicate on some field (or arbitrary projection) of type U.

This allows:

• Creating a Predicate on a struct from a predicate on a field (or field of a field) of that struct.
• Creating a Predicate on a type from a predicate on some value computable from that type

Compared to writing an arbitrary function using the predicate() method, an over projection allows for more minimal falsification and better error reporting in failure cases.

Use over when your projection function returns a reference. If you need to return a value (for example, a temporary whose reference lifetime would not escape the function), use over_value.

pub fn over_value<F, T, P>(self, project: F, path: P) -> Predicate<T>

where F: Fn(&T) -> U + Send + Sync + 'static, P: Into<String>, T: 'static,

Lift a predicate over a projection from T -> U. This constructs a Predicate from a predicate on some field (or arbitrary projection) of type U.

This allows:

• Creating a Predicate on a struct from a predicate on a field (or field of a field) of that struct.
• Creating a Predicate on a type from a predicate on some value computable from that type

Compared to writing an arbitrary function using the predicate() method, an over projection allows for more minimal falsification and better error reporting in failure cases.

Use over_value when your projection function needs to return a value. If you can return a reference, use over.

Trait Implementations

impl<T> Clone for Predicate<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Predicate<T>

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

Formats the value using the given formatter.

impl<T: 'static, Elem: Debug + 'static> IsAll<T> for Predicate<Elem>

where for<'a> &'a T: IntoIterator<Item = &'a Elem>,

fn describe<'d>(&self, doc: &'d BoxAllocator) -> DocBuilder<'d, BoxAllocator>

fn falsify_all<'d>( &self, t: &T, doc: &'d BoxAllocator ) -> Option<DocBuilder<'d, BoxAllocator>>

impl<T: 'static, Elem: Debug + 'static> IsAny<T> for Predicate<Elem>

where for<'a> &'a T: IntoIterator<Item = &'a Elem>,

fn describe<'d>(&self, doc: &'d BoxAllocator) -> DocBuilder<'d, BoxAllocator>

fn falsify_any<'d>( &self, t: &T, doc: &'d BoxAllocator ) -> Option<DocBuilder<'d, BoxAllocator>>