Trait Arbitrary

Source

pub trait Arbitrary: Sized + Debug {
    type Parameters: Default;
    type Strategy: Strategy<Value = Self>;

    // Required method
    fn arbitrary_with(args: Self::Parameters) -> Self::Strategy;

    // Provided method
    fn arbitrary() -> Self::Strategy { ... }
}

Expand description

Arbitrary determines a canonical Strategy for the implementing type.

It provides the method arbitrary_with which generates a Strategy for producing arbitrary values of the implementing type (Self). In general, these strategies will produce the entire set of values possible for the type, up to some size limitation or constraints set by their parameters. When this is not desired, strategies to produce the desired values can be built by combining Strategys as described in the crate documentation.

This trait analogous to Haskell QuickCheck’s implementation of Arbitrary. In this interpretation of Arbitrary, Strategy is the equivalent of the Gen monad. Unlike in QuickCheck, Arbitrary is not a core component; types do not need to implement Arbitrary unless one wants to use any or other free functions in this module.

Arbitrary currently only works for types which represent owned data as opposed to borrowed data. This is a fundamental restriction of proptest which may be lifted in the future as the generic associated types (GAT) feature of Rust is implemented and stabilized.

If you do not have unique constraints on how to generate the data for your custom types, consider using the derive macro to implement Arbitrary

Required Associated Types§

Source

type Parameters: Default

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

Source

type Strategy: Strategy<Value = Self>

The type of Strategy used to generate values of type Self.

Required Methods§

Source

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

If you wish to use the default() arguments, use arbitrary instead.

Provided Methods§

Source

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

Calling this for the type X is the equivalent of using X::arbitrary_with(Default::default()).

This method is defined in the trait for optimization for the default if you want to do that. It is a logic error to not preserve the semantics when overriding.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Trait ArbitraryCopy item path

Required Associated Types§

type Parameters: Default

type Strategy: Strategy<Value = Self>

Required Methods§

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

Provided Methods§

fn arbitrary() -> Self::Strategy

Dyn Compatibility§

Implementations on Foreign Types§

impl Arbitrary for bool

type Parameters = ()

type Strategy = Any

fn arbitrary_with( _args: <bool as Arbitrary>::Parameters, ) -> <bool as Arbitrary>::Strategy

impl Arbitrary for char

type Parameters = ()

type Strategy = CharStrategy<'static>

fn arbitrary_with( _args: <char as Arbitrary>::Parameters, ) -> <char as Arbitrary>::Strategy

impl Arbitrary for f32

type Parameters = ()

type Strategy = Any

fn arbitrary_with( _args: <f32 as Arbitrary>::Parameters, ) -> <f32 as Arbitrary>::Strategy

impl Arbitrary for f64

type Parameters = ()

type Strategy = Any

fn arbitrary_with( _args: <f64 as Arbitrary>::Parameters, ) -> <f64 as Arbitrary>::Strategy

impl Arbitrary for i8

type Parameters = ()

type Strategy = Any

fn arbitrary_with( _args: <i8 as Arbitrary>::Parameters, ) -> <i8 as Arbitrary>::Strategy

impl Arbitrary for i16

type Parameters = ()

type Strategy = Any

fn arbitrary_with( _args: <i16 as Arbitrary>::Parameters, ) -> <i16 as Arbitrary>::Strategy

impl Arbitrary for i32

type Parameters = ()

type Strategy = Any

fn arbitrary_with( _args: <i32 as Arbitrary>::Parameters, ) -> <i32 as Arbitrary>::Strategy

impl Arbitrary for i64

type Parameters = ()

type Strategy = Any

fn arbitrary_with( _args: <i64 as Arbitrary>::Parameters, ) -> <i64 as Arbitrary>::Strategy

impl Arbitrary for i128

type Parameters = ()

type Strategy = Any

fn arbitrary_with( _args: <i128 as Arbitrary>::Parameters, ) -> <i128 as Arbitrary>::Strategy

impl Arbitrary for isize

type Parameters = ()

type Strategy = Any

fn arbitrary_with( _args: <isize as Arbitrary>::Parameters, ) -> <isize as Arbitrary>::Strategy

impl Arbitrary for u8

type Parameters = ()

type Strategy = Any

fn arbitrary_with( _args: <u8 as Arbitrary>::Parameters, ) -> <u8 as Arbitrary>::Strategy

impl Arbitrary for u16

type Parameters = ()

type Strategy = Any

fn arbitrary_with( _args: <u16 as Arbitrary>::Parameters, ) -> <u16 as Arbitrary>::Strategy

impl Arbitrary for u32

type Parameters = ()

type Strategy = Any

fn arbitrary_with( _args: <u32 as Arbitrary>::Parameters, ) -> <u32 as Arbitrary>::Strategy

impl Arbitrary for u64

type Parameters = ()

type Strategy = Any

fn arbitrary_with( _args: <u64 as Arbitrary>::Parameters, ) -> <u64 as Arbitrary>::Strategy

impl Arbitrary for u128

type Parameters = ()

type Strategy = Any

fn arbitrary_with( _args: <u128 as Arbitrary>::Parameters, ) -> <u128 as Arbitrary>::Strategy

impl Arbitrary for ()

type Parameters = ()

type Strategy = Just<()>

fn arbitrary_with( _args: <() as Arbitrary>::Parameters, ) -> <() as Arbitrary>::Strategy

impl Arbitrary for usize

type Parameters = ()

type Strategy = Any

fn arbitrary_with( _args: <usize as Arbitrary>::Parameters, ) -> <usize as Arbitrary>::Strategy

impl<A> Arbitrary for (Sender<A>, IntoIter<A>)where A: Debug,

type Parameters = ()

Trait Arbitrary

impl<A> Arbitrary for (Sender<A>, IntoIter<A>)
where A: Debug,

impl<A> Arbitrary for (SyncSender<A>, IntoIter<A>)
where A: Debug,

impl<A, const N: usize> Arbitrary for [A; N]
where A: Arbitrary,

impl<T0> Arbitrary for (T0,)
where T0: Arbitrary,

impl<T0, T1> Arbitrary for (T0, T1)
where T0: Arbitrary, T1: Arbitrary,

impl<T0, T1, T2> Arbitrary for (T0, T1, T2)
where T0: Arbitrary, T1: Arbitrary, T2: Arbitrary,

impl<T0, T1, T2, T3> Arbitrary for (T0, T1, T2, T3)
where T0: Arbitrary, T1: Arbitrary, T2: Arbitrary, T3: Arbitrary,

impl<T0, T1, T2, T3, T4> Arbitrary for (T0, T1, T2, T3, T4)
where T0: Arbitrary, T1: Arbitrary, T2: Arbitrary, T3: Arbitrary, T4: Arbitrary,

impl<T0, T1, T2, T3, T4, T5> Arbitrary for (T0, T1, T2, T3, T4, T5)
where T0: Arbitrary, T1: Arbitrary, T2: Arbitrary, T3: Arbitrary, T4: Arbitrary, T5: Arbitrary,

impl<T0, T1, T2, T3, T4, T5, T6> Arbitrary for (T0, T1, T2, T3, T4, T5, T6)
where T0: Arbitrary, T1: Arbitrary, T2: Arbitrary, T3: Arbitrary, T4: Arbitrary, T5: Arbitrary, T6: Arbitrary,

impl<T0, T1, T2, T3, T4, T5, T6, T7> Arbitrary for (T0, T1, T2, T3, T4, T5, T6, T7)
where T0: Arbitrary, T1: Arbitrary, T2: Arbitrary, T3: Arbitrary, T4: Arbitrary, T5: Arbitrary, T6: Arbitrary, T7: Arbitrary,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Arbitrary for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
where T0: Arbitrary, T1: Arbitrary, T2: Arbitrary, T3: Arbitrary, T4: Arbitrary, T5: Arbitrary, T6: Arbitrary, T7: Arbitrary, T8: Arbitrary,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Arbitrary for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
where T0: Arbitrary, T1: Arbitrary, T2: Arbitrary, T3: Arbitrary, T4: Arbitrary, T5: Arbitrary, T6: Arbitrary, T7: Arbitrary, T8: Arbitrary, T9: Arbitrary,