Struct Sequential 

pub struct Sequential<State, Transition, StateStrategy, TransitionStrategy> { /* private fields */ }

In a sequential state machine strategy, we first generate an acceptable sequence of transitions. That is a sequence that satisfies the given pre-conditions. The acceptability of each transition in the sequence depends on the current state of the state machine, which is updated by the transitions with the next function.

The shrinking strategy is to iteratively apply Shrink::InitialState, Shrink::DeleteTransition and Shrink::Transition.

1. We start by trying to delete transitions from the back of the list that were never seen by the test, if any. Note that because proptest expects deterministic results in for reproducible issues, unlike the following steps this step will not be undone on complicate. If there were any unseen transitions, then the next step will start at trying to delete the transition before the last one seen as we know that the last transition cannot be deleted as it’s the one that has failed.
2. Then, we keep trying to delete transitions from the back of the list, until we can do so no further (reached the beginning of the list)..
3. Then, we again iteratively attempt to shrink the individual transitions, but this time starting from the front of the list - i.e. from the first transition to be applied.
4. Finally, we try to shrink the initial state until it’s not possible to shrink it any further.

For complicate, we attempt to undo the last shrink operation, if there was any.

Implementations

impl<State, Transition, StateStrategy, TransitionStrategy> Sequential<State, Transition, StateStrategy, TransitionStrategy>

where State: 'static, Transition: 'static, StateStrategy: 'static, TransitionStrategy: 'static,

pub fn new( size: SizeRange, init_state: impl Fn() -> StateStrategy + 'static + Send + Sync, preconditions: impl Fn(&State, &Transition) -> bool + 'static + Send + Sync, transitions: impl Fn(&State) -> TransitionStrategy + 'static + Send + Sync, next: impl Fn(State, &Transition) -> State + 'static + Send + Sync, ) -> Self

Trait Implementations

impl<State, Transition, StateStrategy, TransitionStrategy> Debug for Sequential<State, Transition, StateStrategy, TransitionStrategy>

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

Formats the value using the given formatter.

impl<State: Clone + Debug, Transition: Clone + Debug, StateStrategy: Strategy<Value = State>, TransitionStrategy: Strategy<Value = Transition>> Strategy for Sequential<State, Transition, StateStrategy, TransitionStrategy>

type Tree = SequentialValueTree<State, Transition, <StateStrategy as Strategy>::Tree, <TransitionStrategy as Strategy>::Tree>

The value tree generated by this Strategy.

type Value = (State, Vec<Transition>, Option<Arc<Atomic<usize>>>)

The type of value used by functions under test generated by this Strategy.

fn new_tree(&self, runner: &mut TestRunner) -> NewTree<Self>

Generate a new value tree from the given runner.

fn prop_map<O, F>(self, fun: F) -> Map<Self, F>

where O: Debug, F: Fn(Self::Value) -> O, Self: Sized,

Returns a strategy which produces values transformed by the function fun.

fn prop_map_into<O>(self) -> MapInto<Self, O>

where O: Debug, Self: Sized, Self::Value: Into<O>,

Returns a strategy which produces values of type O by transforming Self with Into<O>.

fn prop_perturb<O, F>(self, fun: F) -> Perturb<Self, F>

where O: Debug, F: Fn(Self::Value, TestRng) -> O, Self: Sized,

Returns a strategy which produces values transformed by the function fun, which is additionally given a random number generator.

fn prop_flat_map<S, F>(self, fun: F) -> Flatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

Maps values produced by this strategy into new strategies and picks values from those strategies.

fn prop_ind_flat_map<S, F>(self, fun: F) -> IndFlatten<Map<Self, F>>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

Maps values produced by this strategy into new strategies and picks values from those strategies while considering the new strategies to be independent.

fn prop_ind_flat_map2<S, F>(self, fun: F) -> IndFlattenMap<Self, F>

where S: Strategy, F: Fn(Self::Value) -> S, Self: Sized,

Similar to prop_ind_flat_map(), but produces 2-tuples with the input generated from self in slot 0 and the derived strategy in slot 1.

fn prop_filter<R, F>(self, whence: R, fun: F) -> Filter<Self, F>

where R: Into<Reason>, F: Fn(&Self::Value) -> bool, Self: Sized,

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F, O>( self, whence: impl Into<Reason>, fun: F, ) -> FilterMap<Self, F>

where F: Fn(Self::Value) -> Option<O>, O: Debug, Self: Sized,

Returns a strategy which only produces transformed values where fun returns Some(value) and rejects those where fun returns None.

fn prop_union(self, other: Self) -> Union<Self>

where Self: Sized,

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R, F>( self, depth: u32, desired_size: u32, expected_branch_size: u32, recurse: F, ) -> Recursive<Self::Value, F>

where R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R, Self: Sized + 'static,

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self>

where Self: Sized, Self::Value: Shuffleable,

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value>

where Self: Sized + 'static,

Erases the type of this Strategy so it can be passed around as a simple trait object.

fn sboxed(self) -> SBoxedStrategy<Self::Value>

where Self: Sized + Send + Sync + 'static,

Erases the type of this Strategy so it can be passed around as a simple trait object.

fn no_shrink(self) -> NoShrink<Self>

where Self: Sized,

Wraps this strategy to prevent values from being subject to shrinking.