Module asynchronous

Asynchronous extensions to Expectation Predicates This module defines a framework for using the crate::expectations module in asynchronous situations, where you wish you detect the satisfiability of the expectations at some undetermined point in the future.

An ExpectationFuture implements Future and will complete when the underlying state satisfies the predicate. Failure can be detected by wrapping the future in a timeout, as is implemented by the method when_satisfied.

To use ExpectationFutures, you must implement ExpectableState for the type of state you wish to track, which defines how the state will update and notify tasks that are waiting on state changes.

A common pattern is to await the expectation of a given state, and then check further predicate expectations to determine success or failure at that point in time.

e.g.

// Wait for the action to have completed one way or the other
let state = state.when_satisfied(action_complete, timeout).await?;
// Then check that the action completed successfully
action_success.satisfied(state)

Structs

• ExpectableInner
  Inner state for the Expectable helper type
• ExpectationFuture
  Future that completes once a Predicate is satisfied for the T::State type where T is some type that allows monitoring of State updates

Traits

• ExpectableExt
  A trait to provide convenience methods on Expectable types held within wrapping harnesses
• ExpectableState
  Trait for objects that allow futures to trigger based on state changes
• ExpectableStateExt

Functions

• expectable

Type Aliases

• Expectable
  Expectable<S,A> is an easy way to build an implementation of ExpectableState to await upon. The Aux type A is commonly used to hold a FIDL Proxy to drive the behavior under test.