Struct zebra_test::prelude::prop::strategy::Union

pub struct Union<T>
where
    T: Strategy,
{
    options: Vec<(u32, Arc<T>)>,
}

A Strategy which picks from one of several delegate Stragegys.

See Strategy::prop_union().

Fields

options: Vec<(u32, Arc<T>)>

Implementations

impl<T> Union<T>

where T: Strategy,

pub fn new(options: impl IntoIterator<Item = T>) -> Union<T>

Create a strategy which selects uniformly from the given delegate strategies.

When shrinking, after maximal simplification of the chosen element, the strategy will move to earlier options and continue simplification with those.

Panics

Panics if options is empty.

pub fn new_weighted(options: Vec<(u32, T)>) -> Union<T>

Create a strategy which selects from the given delegate strategies.

Each strategy is assigned a non-zero weight which determines how frequently that strategy is chosen. For example, a strategy with a weight of 2 will be chosen twice as frequently as one with a weight of 1.

Panics

Panics if options is empty or any element has a weight of 0.

Panics if the sum of the weights overflows a u32.

pub fn or(self, other: T) -> Union<T>

Add other as an additional alternate strategy with weight 1.

Trait Implementations

impl<T> Clone for Union<T>

where T: Clone + Strategy,

fn clone(&self) -> Union<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Union<T>

where T: Debug + Strategy,

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

Formats the value using the given formatter.

impl<T> Strategy for Union<T>

where T: Strategy,

type Tree = UnionValueTree<T>

The value tree generated by this Strategy.

type Value = <T as Strategy>::Value

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

fn new_tree( &self, runner: &mut TestRunner ) -> Result<<Union<T> as Strategy>::Tree, Reason>

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 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 no_shrink(self) -> NoShrink<Self>

where Self: Sized,

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