Trait quickcheck::Arbitrary

pub trait Arbitrary: Clone + 'static {
    pub fn arbitrary(g: &mut Gen) -> Self;

    pub fn shrink(&self) -> Box<dyn Iterator<Item = Self>> { ... }
}

Arbitrary describes types whose values can be randomly generated and shrunk.

Aside from shrinking, Arbitrary is different from typical RNGs in that it respects Gen::size() for controlling how much memory a particular value uses, for practical purposes. For example, Vec::arbitrary() respects Gen::size() to decide the maximum len() of the vector. This behavior is necessary due to practical speed and size limitations. Conversely, i32::arbitrary() ignores size() since all i32 values require O(1) memory and operations between i32s require O(1) time (with the exception of exponentiation).

Additionally, all types that implement Arbitrary must also implement Clone.

Required methods

pub fn arbitrary(g: &mut Gen) -> Self

Return an arbitrary value.

Implementations should respect Gen::size() when decisions about how big a particular value should be. Implementations should generally defer to other Arbitrary implementations to generate other random values when necessary. The Gen type also offers a few RNG helper routines.

Loading content...

Provided methods

pub fn shrink(&self) -> Box<dyn Iterator<Item = Self>>

Return an iterator of values that are smaller than itself.

The way in which a value is "smaller" is implementation defined. In some cases, the interpretation is obvious: shrinking an integer should produce integers smaller than itself. Others are more complex, for example, shrinking a Vec should both shrink its size and shrink its component values.

The iterator returned should be bounded to some reasonable size.

It is always correct to return an empty iterator, and indeed, this is the default implementation. The downside of this approach is that witnesses to failures in properties will be more inscrutable.

Loading content...

Implementations on Foreign Types

impl Arbitrary for ()

pub fn arbitrary(_: &mut Gen)

impl Arbitrary for bool

pub fn arbitrary(g: &mut Gen) -> bool

pub fn shrink(&self) -> Box<dyn Iterator<Item = bool>>

impl<A: Arbitrary> Arbitrary for Option<A>

pub fn arbitrary(g: &mut Gen) -> Option<A>

pub fn shrink(&self) -> Box<dyn Iterator<Item = Option<A>>>

impl<A: Arbitrary, B: Arbitrary> Arbitrary for Result<A, B>

pub fn arbitrary(g: &mut Gen) -> Result<A, B>

pub fn shrink(&self) -> Box<dyn Iterator<Item = Result<A, B>>>

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

pub fn arbitrary(g: &mut Gen) -> (A,)

pub fn shrink(&self) -> Box<dyn Iterator<Item = (A,)>>

impl<A, B> Arbitrary for (A, B) where
    A: Arbitrary,
    B: Arbitrary, 

pub fn arbitrary(g: &mut Gen) -> (A, B)

pub fn shrink(&self) -> Box<dyn Iterator<Item = (A, B)>>

impl<A, B, C> Arbitrary for (A, B, C) where
    A: Arbitrary,
    B: Arbitrary,
    C: Arbitrary, 

pub fn arbitrary(g: &mut Gen) -> (A, B, C)

pub fn shrink(&self) -> Box<dyn Iterator<Item = (A, B, C)>>

impl<A, B, C, D> Arbitrary for (A, B, C, D) where
    A: Arbitrary,
    B: Arbitrary,
    C: Arbitrary,
    D: Arbitrary, 

pub fn arbitrary(g: &mut Gen) -> (A, B, C, D)

pub fn shrink(&self) -> Box<dyn Iterator<Item = (A, B, C, D)>>

impl<A, B, C, D, E> Arbitrary for (A, B, C, D, E) where
    A: Arbitrary,
    B: Arbitrary,
    C: Arbitrary,
    D: Arbitrary,
    E: Arbitrary, 

pub fn arbitrary(g: &mut Gen) -> (A, B, C, D, E)

pub fn shrink(&self) -> Box<dyn Iterator<Item = (A, B, C, D, E)>>

impl<A, B, C, D, E, F> Arbitrary for (A, B, C, D, E, F) where
    A: Arbitrary,
    B: Arbitrary,
    C: Arbitrary,
    D: Arbitrary,
    E: Arbitrary,
    F: Arbitrary, 

pub fn arbitrary(g: &mut Gen) -> (A, B, C, D, E, F)

pub fn shrink(&self) -> Box<dyn Iterator<Item = (A, B, C, D, E, F)>>

impl<A, B, C, D, E, F, G> Arbitrary for (A, B, C, D, E, F, G) where
    A: Arbitrary,
    B: Arbitrary,
    C: Arbitrary,
    D: Arbitrary,
    E: Arbitrary,
    F: Arbitrary,
    G: Arbitrary, 

pub fn arbitrary(g: &mut Gen) -> (A, B, C, D, E, F, G)

pub fn shrink(&self) -> Box<dyn Iterator<Item = (A, B, C, D, E, F, G)>>

impl<A, B, C, D, E, F, G, H> Arbitrary for (A, B, C, D, E, F, G, H) where
    A: Arbitrary,
    B: Arbitrary,
    C: Arbitrary,
    D: Arbitrary,
    E: Arbitrary,
    F: Arbitrary,
    G: Arbitrary,
    H: Arbitrary, 

pub fn arbitrary(g: &mut Gen) -> (A, B, C, D, E, F, G, H)

pub fn shrink(&self) -> Box<dyn Iterator<Item = (A, B, C, D, E, F, G, H)>>

impl<A: Arbitrary> Arbitrary for Vec<A>

pub fn arbitrary(g: &mut Gen) -> Vec<A>

pub fn shrink(&self) -> Box<dyn Iterator<Item = Vec<A>>>

impl<K: Arbitrary + Ord, V: Arbitrary> Arbitrary for BTreeMap<K, V>

pub fn arbitrary(g: &mut Gen) -> BTreeMap<K, V>

pub fn shrink(&self) -> Box<dyn Iterator<Item = BTreeMap<K, V>>>

impl<K: Arbitrary + Eq + Hash, V: Arbitrary, S: BuildHasher + Default + Clone + 'static> Arbitrary for HashMap<K, V, S>

pub fn arbitrary(g: &mut Gen) -> Self

pub fn shrink(&self) -> Box<dyn Iterator<Item = Self>>

impl<T: Arbitrary + Ord> Arbitrary for BTreeSet<T>

pub fn arbitrary(g: &mut Gen) -> BTreeSet<T>

pub fn shrink(&self) -> Box<dyn Iterator<Item = BTreeSet<T>>>

impl<T: Arbitrary + Ord> Arbitrary for BinaryHeap<T>

pub fn arbitrary(g: &mut Gen) -> BinaryHeap<T>

pub fn shrink(&self) -> Box<dyn Iterator<Item = BinaryHeap<T>>>

impl<T: Arbitrary + Eq + Hash, S: BuildHasher + Default + Clone + 'static> Arbitrary for HashSet<T, S>

pub fn arbitrary(g: &mut Gen) -> Self

pub fn shrink(&self) -> Box<dyn Iterator<Item = Self>>

impl<T: Arbitrary> Arbitrary for LinkedList<T>

pub fn arbitrary(g: &mut Gen) -> LinkedList<T>

pub fn shrink(&self) -> Box<dyn Iterator<Item = LinkedList<T>>>

impl<T: Arbitrary> Arbitrary for VecDeque<T>

pub fn arbitrary(g: &mut Gen) -> VecDeque<T>

pub fn shrink(&self) -> Box<dyn Iterator<Item = VecDeque<T>>>

impl Arbitrary for IpAddr

pub fn arbitrary(g: &mut Gen) -> IpAddr

impl Arbitrary for Ipv4Addr

pub fn arbitrary(g: &mut Gen) -> Ipv4Addr

impl Arbitrary for Ipv6Addr

pub fn arbitrary(g: &mut Gen) -> Ipv6Addr

impl Arbitrary for SocketAddr

pub fn arbitrary(g: &mut Gen) -> SocketAddr

impl Arbitrary for SocketAddrV4

pub fn arbitrary(g: &mut Gen) -> SocketAddrV4

impl Arbitrary for SocketAddrV6

pub fn arbitrary(g: &mut Gen) -> SocketAddrV6

impl Arbitrary for PathBuf

pub fn arbitrary(g: &mut Gen) -> PathBuf

pub fn shrink(&self) -> Box<dyn Iterator<Item = PathBuf>>

impl Arbitrary for OsString

pub fn arbitrary(g: &mut Gen) -> OsString

pub fn shrink(&self) -> Box<dyn Iterator<Item = OsString>>

impl Arbitrary for String

pub fn arbitrary(g: &mut Gen) -> String

pub fn shrink(&self) -> Box<dyn Iterator<Item = String>>

impl Arbitrary for CString

pub fn arbitrary(g: &mut Gen) -> Self

pub fn shrink(&self) -> Box<dyn Iterator<Item = CString>>

impl Arbitrary for char

pub fn arbitrary(g: &mut Gen) -> char

pub fn shrink(&self) -> Box<dyn Iterator<Item = char>>

impl Arbitrary for usize

pub fn arbitrary(g: &mut Gen) -> usize

pub fn shrink(&self) -> Box<dyn Iterator<Item = usize>>

impl Arbitrary for u8

pub fn arbitrary(g: &mut Gen) -> u8

pub fn shrink(&self) -> Box<dyn Iterator<Item = u8>>

impl Arbitrary for u16

pub fn arbitrary(g: &mut Gen) -> u16

pub fn shrink(&self) -> Box<dyn Iterator<Item = u16>>

impl Arbitrary for u32

pub fn arbitrary(g: &mut Gen) -> u32

pub fn shrink(&self) -> Box<dyn Iterator<Item = u32>>

impl Arbitrary for u64

pub fn arbitrary(g: &mut Gen) -> u64

pub fn shrink(&self) -> Box<dyn Iterator<Item = u64>>

impl Arbitrary for u128

pub fn arbitrary(g: &mut Gen) -> u128

pub fn shrink(&self) -> Box<dyn Iterator<Item = u128>>

impl Arbitrary for isize

pub fn arbitrary(g: &mut Gen) -> isize

pub fn shrink(&self) -> Box<dyn Iterator<Item = isize>>

impl Arbitrary for i8

pub fn arbitrary(g: &mut Gen) -> i8

pub fn shrink(&self) -> Box<dyn Iterator<Item = i8>>

impl Arbitrary for i16

pub fn arbitrary(g: &mut Gen) -> i16

pub fn shrink(&self) -> Box<dyn Iterator<Item = i16>>

impl Arbitrary for i32

pub fn arbitrary(g: &mut Gen) -> i32

pub fn shrink(&self) -> Box<dyn Iterator<Item = i32>>

impl Arbitrary for i64

pub fn arbitrary(g: &mut Gen) -> i64

pub fn shrink(&self) -> Box<dyn Iterator<Item = i64>>

impl Arbitrary for i128

pub fn arbitrary(g: &mut Gen) -> i128

pub fn shrink(&self) -> Box<dyn Iterator<Item = i128>>

impl Arbitrary for f32

pub fn arbitrary(g: &mut Gen) -> f32

pub fn shrink(&self) -> Box<dyn Iterator<Item = f32>>

impl Arbitrary for f64

pub fn arbitrary(g: &mut Gen) -> f64

pub fn shrink(&self) -> Box<dyn Iterator<Item = f64>>

impl Arbitrary for NonZeroUsize

pub fn arbitrary(g: &mut Gen) -> NonZeroUsize

pub fn shrink(&self) -> Box<dyn Iterator<Item = NonZeroUsize>>

impl Arbitrary for NonZeroU8

pub fn arbitrary(g: &mut Gen) -> NonZeroU8

pub fn shrink(&self) -> Box<dyn Iterator<Item = NonZeroU8>>

impl Arbitrary for NonZeroU16

pub fn arbitrary(g: &mut Gen) -> NonZeroU16

pub fn shrink(&self) -> Box<dyn Iterator<Item = NonZeroU16>>

impl Arbitrary for NonZeroU32

pub fn arbitrary(g: &mut Gen) -> NonZeroU32

pub fn shrink(&self) -> Box<dyn Iterator<Item = NonZeroU32>>

impl Arbitrary for NonZeroU64

pub fn arbitrary(g: &mut Gen) -> NonZeroU64

pub fn shrink(&self) -> Box<dyn Iterator<Item = NonZeroU64>>

impl Arbitrary for NonZeroU128

pub fn arbitrary(g: &mut Gen) -> NonZeroU128

pub fn shrink(&self) -> Box<dyn Iterator<Item = NonZeroU128>>

impl<T: Arbitrary> Arbitrary for Wrapping<T>

pub fn arbitrary(g: &mut Gen) -> Wrapping<T>

pub fn shrink(&self) -> Box<dyn Iterator<Item = Wrapping<T>>>

impl<T: Arbitrary> Arbitrary for Bound<T>

pub fn arbitrary(g: &mut Gen) -> Bound<T>

pub fn shrink(&self) -> Box<dyn Iterator<Item = Bound<T>>>

impl<T: Arbitrary + Clone + PartialOrd> Arbitrary for Range<T>

pub fn arbitrary(g: &mut Gen) -> Range<T>

pub fn shrink(&self) -> Box<dyn Iterator<Item = Range<T>>>

impl<T: Arbitrary + Clone + PartialOrd> Arbitrary for RangeInclusive<T>

pub fn arbitrary(g: &mut Gen) -> RangeInclusive<T>

pub fn shrink(&self) -> Box<dyn Iterator<Item = RangeInclusive<T>>>

impl<T: Arbitrary + Clone + PartialOrd> Arbitrary for RangeFrom<T>

pub fn arbitrary(g: &mut Gen) -> RangeFrom<T>

pub fn shrink(&self) -> Box<dyn Iterator<Item = RangeFrom<T>>>

impl<T: Arbitrary + Clone + PartialOrd> Arbitrary for RangeTo<T>

pub fn arbitrary(g: &mut Gen) -> RangeTo<T>

pub fn shrink(&self) -> Box<dyn Iterator<Item = RangeTo<T>>>

impl<T: Arbitrary + Clone + PartialOrd> Arbitrary for RangeToInclusive<T>

pub fn arbitrary(g: &mut Gen) -> RangeToInclusive<T>

pub fn shrink(&self) -> Box<dyn Iterator<Item = RangeToInclusive<T>>>

impl Arbitrary for RangeFull

pub fn arbitrary(_: &mut Gen) -> RangeFull

impl Arbitrary for Duration

pub fn arbitrary(gen: &mut Gen) -> Self

pub fn shrink(&self) -> Box<dyn Iterator<Item = Self>>

impl<A: Arbitrary> Arbitrary for Box<A>

pub fn arbitrary(g: &mut Gen) -> Box<A>

pub fn shrink(&self) -> Box<dyn Iterator<Item = Box<A>>>

impl<A: Arbitrary + Sync> Arbitrary for Arc<A>

pub fn arbitrary(g: &mut Gen) -> Arc<A>

pub fn shrink(&self) -> Box<dyn Iterator<Item = Arc<A>>>

impl Arbitrary for SystemTime

pub fn arbitrary(gen: &mut Gen) -> Self

pub fn shrink(&self) -> Box<dyn Iterator<Item = Self>>

Loading content...

Implementors

Loading content...