Trait proptest::strategy::Strategy [−] [src]

pub trait Strategy {
    type Value: ValueTree;
    fn new_value(&self, runner: &mut TestRunner) -> Result<Self::Value, String>;

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

    fn prop_filter<F: Fn(&<Self::Value as ValueTree>::Value) -> bool>(
        self, 
        whence: String, 
        fun: F
    ) -> Filter<Self, F>
    where
        Self: Sized,
    { ... }

    fn prop_union(self, other: Self) -> Union<Self>
    where
        Self: Sized,
    { ... }

    fn boxed(self) -> BoxedStrategy<<Self::Value as ValueTree>::Value>
    where
        Self: Sized + 'static,
    { ... }

    fn no_shrink(self) -> NoShrink<Self>
    where
        Self: Sized,
    { ... }
}

A strategy for producing arbitrary values of a given type.

Associated Types

The value tree generated by this Strategy.

This also implicitly describes the ultimate value type governed by the Strategy.

Required Methods

Generate a new value tree from the given runner.

This may fail if there are constraints on the generated value and the generator is unable to produce anything that satisfies them. Any failure is wrapped in TestError::Abort.

Provided Methods

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

There is no need (or possibility, for that matter) to define how the output is to be shrunken. Shrinking continues to take place in terms of the source value.

Returns a strategy which only produces values accepted by fun.

This results in a very naïve form of rejection sampling and should only be used if (a) relatively few values will actually be rejected; (b) it isn't easy to express what you want by using another strategy and/or map().

There are a lot of downsides to this form of filtering. It slows testing down, since values must be generated but then discarded. Proptest only allows a limited number of rejects this way (across the entire TestRunner). Rejection can interfere with shrinking; particularly, complex filters may largely or entirely prevent shrinking from substantially altering the original value.

Local rejection sampling is still preferable to rejecting the entire input to a test (via TestCaseError::Reject), however, and the default number of local rejections allowed is much higher than the number of whole-input rejections.

whence is used to record where and why the rejection occurred.

Returns a strategy which picks uniformly from self and other.

When shrinking, if a value from other was originally chosen but that value can be shrunken no further, it switches to a value from self and starts shrinking that.

Be aware that chaining prop_union calls will result in a very right-skewed distribution. If this is not what you want, you can call the .or() method on the Union to add more values to the same union, or directly call Union::new().

Both self and other must be of the same type. To combine heterogeneous strategies, call the boxed() method on both self and other to erase the type differences before calling prop_union().

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

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

Suppressing shrinking is useful when testing things like linear approximation functions. Ordinarily, proptest will tend to shrink the input to the function until the result is just barely outside the acceptable range whereas the original input may have produced a result far outside of it. Since this makes it harder to see what the actual problem is, making the input NoShrink allows learning about inputs that produce more incorrect results.

Implementors