Trait Arbitrary

Source

pub trait Arbitrary<'a>: Sized + Debug {
    type Parameters: Default;
    type Strategy: Strategy<Value = Self::ValueTree>;
    type ValueTree: ValueTree<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 function arbitrary which generates a Strategy for producing arbitrary values of the implementing type (Self).

This trait is the equivalent of Haskell QuickCheck’s implementation of Arbitrary. In this interpretation of Arbitray, Strategy is the equivalent of the Gen monad.

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.

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::ValueTree>

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

Source

type ValueTree: ValueTree<Value = Self>

The type of ValueTree used for Self’s Strategy.

NOTE: This type should NOT be relied upon outside of this crate other than for implementing Arbitrary for other types.

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()).

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 Arbitrary Copy item path

Required Associated Types§

type Parameters: Default

type Strategy: Strategy<Value = Self::ValueTree>

type ValueTree: ValueTree<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<'a> Arbitrary<'a> for Ordering

type ValueTree = <<Ordering as Arbitrary<'a>>::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<((u32, Just<Ordering>), (u32, Just<Ordering>), (u32, Just<Ordering>))>

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

impl<'a> Arbitrary<'a> for FromBytesWithNulError

type ValueTree = <<FromBytesWithNulError as Arbitrary<'a>>::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Map<<Option<u16> as Arbitrary<'a>>::Strategy, SFnMap<Option<u16>, FromBytesWithNulError>>

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

impl<'a> Arbitrary<'a> for IpAddr

type ValueTree = <<IpAddr as Arbitrary<'a>>::Strategy as Strategy>::Value

type Parameters = ()

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

impl<'a> Arbitrary<'a> for SocketAddr

type ValueTree = <<SocketAddr as Arbitrary<'a>>::Strategy as Strategy>::Value

type Parameters = ()

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

impl<'a> Arbitrary<'a> for FpCategory

type ValueTree = <<FpCategory as Arbitrary<'a>>::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<((u32, Just<FpCategory>), (u32, Just<FpCategory>), (u32, Just<FpCategory>), (u32, Just<FpCategory>), (u32, Just<FpCategory>))>

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

impl<'a> Arbitrary<'a> for Ordering

type ValueTree = <<Ordering as Arbitrary<'a>>::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<((u32, Just<Ordering>), (u32, Just<Ordering>), (u32, Just<Ordering>), (u32, Just<Ordering>), (u32, Just<Ordering>))>

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

impl<'a> Arbitrary<'a> for VarError

type ValueTree = <<VarError as Arbitrary<'a>>::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<((u32, Just<VarError>), (u32, Map<Box<dyn Strategy<Value = Box<dyn ValueTree<Value = OsString>>>>, SFnMap<<<Box<dyn Strategy<Value = Box<dyn ValueTree<Value = OsString>>>> as Strategy>::Value as ValueTree>::Value, VarError>>))>

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

impl<'a> Arbitrary<'a> for SeekFrom

type ValueTree = <<SeekFrom as Arbitrary<'a>>::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<((u32, Map<<u64 as Arbitrary<'a>>::Strategy, SFnMap<u64, SeekFrom>>), (u32, Map<<i64 as Arbitrary<'a>>::Strategy, SFnMap<i64, SeekFrom>>), (u32, Map<<i64 as Arbitrary<'a>>::Strategy, SFnMap<i64, SeekFrom>>))>

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

impl<'a> Arbitrary<'a> for ErrorKind

type ValueTree = <<ErrorKind as Arbitrary<'a>>::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Union<Just<ErrorKind>>

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

impl<'a> Arbitrary<'a> for Shutdown

type ValueTree = <<Shutdown as Arbitrary<'a>>::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<((u32, Just<Shutdown>), (u32, Just<Shutdown>), (u32, Just<Shutdown>))>

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

impl<'a> Arbitrary<'a> for RecvTimeoutError

type ValueTree = <<RecvTimeoutError as Arbitrary<'a>>::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<((u32, Just<RecvTimeoutError>), (u32, Just<RecvTimeoutError>))>

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

impl<'a> Arbitrary<'a> for TryRecvError

type ValueTree = <<TryRecvError as Arbitrary<'a>>::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = TupleUnion<((u32, Just<TryRecvError>), (u32, Just<TryRecvError>))>

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

impl<'a> Arbitrary<'a> for bool

type ValueTree = <<bool as Arbitrary<'a>>::Strategy as Strategy>::Value

type Parameters = ()

type Strategy = Any

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

impl<'a> Arbitrary<'a> for char

type ValueTree = <<char as Arbitrary<'a>>::Strategy as Strategy>::Value

type Parameters = CharParam<'a>

type Strategy = CharStrategy<'a>

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

impl<'a> Arbitrary<'a> for f32

Trait Arbitrary