Struct un_algebra::tests::config::prop::bits::BitSetStrategy

#[must_use = "strategies do nothing unless used"]
pub struct BitSetStrategy<T> where
    T: BitSetLike,  { /* fields omitted */ }

Generates values as a set of bits between the two bounds.

Values are generated by uniformly setting individual bits to 0 or 1 between the bounds. Shrinking iteratively clears bits.

Methods

impl<T> BitSetStrategy<T> where
    T: BitSetLike, 

pub fn new(min: usize, max: usize) -> BitSetStrategy<T>

Create a strategy which generates values where bits between min (inclusive) and max (exclusive) may be set.

Due to the generics, the functions in the typed submodules are usually preferable to calling this directly.

pub fn masked(mask: T) -> BitSetStrategy<T>

Create a strategy which generates values where any bits set (and only those bits) in mask may be set.

Trait Implementations

impl<T> Debug for BitSetStrategy<T> where
    T: BitSetLike + Debug, 

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

Formats the value using the given formatter.

impl<T> Strategy for BitSetStrategy<T> where
    T: BitSetLike, 

type Tree = BitSetValueTree<T>

The value tree generated by this Strategy.

type Value = T

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

fn new_tree(
    &self,
    runner: &mut TestRunner
) -> Result<<BitSetStrategy<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
    F: Fn(Self::Value) -> O,
    O: Debug, 

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

fn prop_map_into<O>(self) -> MapInto<Self, O> where
    O: Debug,
    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
    F: Fn(Self::Value, TestRng) -> O,
    O: Debug, 

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
    F: Fn(Self::Value) -> S,
    S: Strategy, 

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
    F: Fn(Self::Value) -> S,
    S: Strategy, 

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
    F: Fn(Self::Value) -> S,
    S: Strategy, 

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
    F: Fn(&Self::Value) -> bool,
    R: Into<Reason>, 

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, 

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>

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
    F: Fn(BoxedStrategy<Self::Value>) -> R,
    R: 'static + Strategy<Value = Self::Value>,
    Self: 'static, 

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self> where
    Self::Value: Shuffleable, 

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value> where
    Self: '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: 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>

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

impl<T> Copy for BitSetStrategy<T> where
    T: BitSetLike + Copy, 

impl<T> Clone for BitSetStrategy<T> where
    T: BitSetLike + Clone, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.