Struct proptest::strategy::Union

pub struct Union<T: Strategy> { /* private fields */ }

A Strategy which picks from one of several delegate Stragegys.

See Strategy::prop_union().

Implementations

impl<T: Strategy> Union<T>

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

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<W<T>>) -> Self

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) -> Self

Add other as an additional alternate strategy with weight 1.

Trait Implementations

impl<T: Clone + Strategy> Clone for Union<T>

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 + Strategy> Debug for Union<T>

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

Formats the value using the given formatter.

impl<T: Strategy> Strategy for Union<T>

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) -> NewTree<Self>

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(Self::Value) -> O>(self, fun: F) -> Map<Self, F> where
    Self: Sized, 

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

fn prop_map_into<O: Debug>(self) -> MapInto<Self, O> where
    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: Debug, F: Fn(Self::Value, TestRng) -> O>(
    self,
    fun: F
) -> Perturb<Self, F> where
    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: Strategy, F: Fn(Self::Value) -> S>(
    self,
    fun: F
) -> Flatten<Map<Self, F>> where
    Self: Sized, 

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

fn prop_ind_flat_map<S: Strategy, F: Fn(Self::Value) -> S>(
    self,
    fun: F
) -> IndFlatten<Map<Self, F>> where
    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: Strategy, F: Fn(Self::Value) -> S>(
    self,
    fun: F
) -> IndFlattenMap<Self, F> where
    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: Into<Reason>, F: Fn(&Self::Value) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F: Fn(Self::Value) -> Option<O>, O: Debug>(
    self,
    whence: impl Into<Reason>,
    fun: F
) -> FilterMap<Self, F> where
    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: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<Self::Value, F> where
    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.