Crate proptest_arbitrary [−] [src]

NOTE: This version is still WIP; don't use yet, just reserving at crates.io.

Proptest is a property testing framework (i.e., the QuickCheck family) inspired by the Hypothesis framework for Python.

This crate, proptest-arbitrary, additionally provides an Arbitrary trait which allows you to have a canonical Strategy per type. This is the equivalent of Haskell QuickCheck's implementation of Arbitrary. In this interpretation of Arbitrary, Strategy is the equivalent of the Gen monad.

Arbitrary is currently implemented as:

/// Arbitrary determines a canonical Strategy [..]
pub trait Arbitrary<'a> : Sized + Debug {
   fn arbitrary() -> Self::Strategy {
       Self::arbitrary_with(Default::default())
   }

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

   type Parameters: Default;

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

    /// NOTE:
    /// This type should NOT be relied upon outside of this crate
    /// other than for implementing `Arbitrary` for other types.
    type ValueTree: ValueTree<Value = Self>;

}

Modules

bits	Arbitrary implementations for integral types as bit patterns.

Structs

ArrayParamMod	A function taking `ParamsFor<A>` and transforming it. Allows callers of `arbitrary_with` for arrays to mutate the parameters for each element.
CharParameters	Parameters to pass to `proptest::char::CharStrategy::new(..)`.
Probability	A probability in the range `[0.0, 1.0]` with a default of `0.5`.
SizeBounds	The minimum and maximum bounds on the size of a collection. The interval must form a subset of `[0, std::usize::MAX)`.
StringParameter	Wraps the regex that forms the `Strategy` for `String` so that a sensible `Default` can be given. The default is a string of non-control characters.

Traits

Arbitrary

Arbitrary determines a canonical Strategy for the implementing type.

Functions

any	Generates a `Strategy` producing `Arbitrary` values of `A`. Unlike `arbitrary`, it should be used for being explicit on what `A` is. For clarity, this may be a good idea.
any_with	Generates a `Strategy` producing `Arbitrary` values of `A` with the given configuration arguments passed in `args`. Unlike `arbitrary_with`, it should be used for being explicit on what `A` is. For clarity, this may be a good idea.
arbitrary	Generates a `Strategy` producing `Arbitrary` values of `A`. Works better with type inference than `any::<A>()`.
arbitrary_with	Generates a `Strategy` producing `Arbitrary` values of `A` with the given configuration arguments passed in `args`. Works better with type inference than `any_with::<A>(args)`.
box_any	Generates a `Strategy` producing `Arbitrary` values of `A`. This version boxes the `Strategy`, and thus you needn't specify `A`.
box_any_with	Generates a `Strategy` producing `Arbitrary` values of `A` with the given configuration arguments passed in `args`. This version boxes the `Strategy`, and thus you needn't specify `A`.
prob	Creates a `Probability` from some value that is convertible into it.
sbox_any	Generates a `Strategy` producing `Arbitrary` values of `A`. This version boxes the `Strategy`, and thus you needn't specify `A`.
sbox_any_with	Generates a `Strategy` producing `Arbitrary` values of `A` with the given configuration arguments passed in `args`. This version boxes the `Strategy`, and thus you needn't specify `A`.
size_bounds	Creates a `SizeBounds` from some value that is convertible into it.

Type Definitions

Mapped	A normal map from a strategy of `I` to `O`.
MappedF	A map from a strategy of `I` to `O` using the `From` trait for conversion.
MappedS	A static map from a strategy of `I` to `O`.
ParamsFor	`ParamsFor` allows you to mention the type of `Parameters` for the input type `A` without directly using associated types or without resorting to existential types. This way, if implementation of `Arbitrary` changes, your tests should not break. Additionally, if you have a custom `Arbitrary::Parameters` type, or use a `Arbitrary::Parameters` type with generics in it where you've provided a custom type for the type parameter, you need not export your type if `A` is `Arbitrary` as the `Parameters` type is still reachable from `ParamsFor`.
ParamsType	`ParamsType` allows you to mention the type of `Parameters` for the input type `A` without directly using associated types or without resorting to existential types. This way, if implementation of `Arbitrary` changes, your tests should not break. Additionally, if you have a custom `Arbitrary::Parameters` type, or use a `Arbitrary::Parameters` type with generics in it where you've provided a custom type for the type parameter, you need not export your type if `A` is `Arbitrary` as the `Parameters` type is still reachable from `ParamsType`.
StrategyFor	`StrategyFor` allows you to mention the type of `Strategy` for the input type `A` without directly using associated types or without resorting to existential types. This way, if implementation of `Arbitrary` changes, your tests should not break. This can be especially beneficial when the type of `Strategy` that you are dealing with is very long in name (the case with generics). Additionally, if you have a custom `Strategy` type, or use a `Strategy` type with generics in it where you've provided a custom type for the type parameter, you need not export your type if `A` is `Arbitrary` as the `Strategy` type is still reachable from `StrategyFor`.
StrategyType	`StrategyType` allows you to mention the type of `Strategy` for the input type `A` without directly using associated types or without resorting to existential types. This way, if implementation of `Arbitrary` changes, your tests should not break. This can be especially beneficial when the type of `Strategy` that you are dealing with is very long in name (the case with generics). Additionally, if you have a custom `Strategy` type, or use a `Strategy` type with generics in it where you've provided a custom type for the type parameter, you need not export your type if `A` is `Arbitrary` as the `Strategy` type is still reachable from `StrategyType`.