[−][src]Trait quickcheck::Arbitrary

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

    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 the std::Rand trait in that it uses a Gen to control the distribution of random values.

As of now, all types that implement Arbitrary must also implement Clone. (I'm not sure if this is a permanent restriction.)

They must also be sendable and static since every test is run in its own thread using thread::Builder::spawn, which requires the Send + 'static bounds.

Required methods

`fn arbitrary<G: Gen>(g: &mut G) -> Self`

Loading content...

Provided methods

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

Loading content...

Implementations on Foreign Types

`impl Arbitrary for ()`[src]

`fn arbitrary<G: Gen>(_: &mut G)`[src]

`impl Arbitrary for bool`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> bool`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = bool>>`[src]

`impl<A: Arbitrary> Arbitrary for Option<A>`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> Option<A>`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = Option<A>>>`[src]

`impl<A: Arbitrary, B: Arbitrary> Arbitrary for Result<A, B>`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> Result<A, B>`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = Result<A, B>>>`[src]

`impl<A> Arbitrary for (A,) where A: Arbitrary,` [src]

`fn arbitrary<GEN: Gen>(g: &mut GEN) -> (A,)`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = (A,)>>`[src]

`impl<A, B> Arbitrary for (A, B) where A: Arbitrary, B: Arbitrary,` [src]

`fn arbitrary<GEN: Gen>(g: &mut GEN) -> (A, B)`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = (A, B)>>`[src]

`impl<A, B, C> Arbitrary for (A, B, C) where A: Arbitrary, B: Arbitrary, C: Arbitrary,` [src]

`fn arbitrary<GEN: Gen>(g: &mut GEN) -> (A, B, C)`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = (A, B, C)>>`[src]

`impl<A, B, C, D> Arbitrary for (A, B, C, D) where A: Arbitrary, B: Arbitrary, C: Arbitrary, D: Arbitrary,` [src]

`fn arbitrary<GEN: Gen>(g: &mut GEN) -> (A, B, C, D)`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = (A, B, C, D)>>`[src]

`impl<A, B, C, D, E> Arbitrary for (A, B, C, D, E) where A: Arbitrary, B: Arbitrary, C: Arbitrary, D: Arbitrary, E: Arbitrary,` [src]

`fn arbitrary<GEN: Gen>(g: &mut GEN) -> (A, B, C, D, E)`[src]

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

`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,` [src]

`fn arbitrary<GEN: Gen>(g: &mut GEN) -> (A, B, C, D, E, F)`[src]

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

`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,` [src]

`fn arbitrary<GEN: Gen>(g: &mut GEN) -> (A, B, C, D, E, F, G)`[src]

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

`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,` [src]

`fn arbitrary<GEN: Gen>(g: &mut GEN) -> (A, B, C, D, E, F, G, H)`[src]

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

`impl<A: Arbitrary> Arbitrary for Vec<A>`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> Vec<A>`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = Vec<A>>>`[src]

`impl<K: Arbitrary + Ord, V: Arbitrary> Arbitrary for BTreeMap<K, V>`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> BTreeMap<K, V>`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = BTreeMap<K, V>>>`[src]

`impl<K: Arbitrary + Eq + Hash, V: Arbitrary, S: BuildHasher + Default + Clone + Send + 'static> Arbitrary for HashMap<K, V, S>`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> Self`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = Self>>`[src]

`impl<T: Arbitrary + Ord> Arbitrary for BTreeSet<T>`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> BTreeSet<T>`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = BTreeSet<T>>>`[src]

`impl<T: Arbitrary + Ord> Arbitrary for BinaryHeap<T>`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> BinaryHeap<T>`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = BinaryHeap<T>>>`[src]

`impl<T: Arbitrary + Eq + Hash, S: BuildHasher + Default + Clone + Send + 'static> Arbitrary for HashSet<T, S>`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> Self`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = Self>>`[src]

`impl<T: Arbitrary> Arbitrary for LinkedList<T>`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> LinkedList<T>`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = LinkedList<T>>>`[src]

`impl<T: Arbitrary> Arbitrary for VecDeque<T>`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> VecDeque<T>`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = VecDeque<T>>>`[src]

`impl Arbitrary for IpAddr`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> IpAddr`[src]

`impl Arbitrary for Ipv4Addr`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> Ipv4Addr`[src]

`impl Arbitrary for Ipv6Addr`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> Ipv6Addr`[src]

`impl Arbitrary for SocketAddr`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> SocketAddr`[src]

`impl Arbitrary for SocketAddrV4`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> SocketAddrV4`[src]

`impl Arbitrary for SocketAddrV6`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> SocketAddrV6`[src]

`impl Arbitrary for PathBuf`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> PathBuf`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = PathBuf>>`[src]

`impl Arbitrary for OsString`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> OsString`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = OsString>>`[src]

`impl Arbitrary for String`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> String`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = String>>`[src]

`impl Arbitrary for char`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> char`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = char>>`[src]

`impl Arbitrary for usize`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> usize`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = usize>>`[src]

`impl Arbitrary for u8`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> u8`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = u8>>`[src]

`impl Arbitrary for u16`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> u16`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = u16>>`[src]

`impl Arbitrary for u32`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> u32`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = u32>>`[src]

`impl Arbitrary for u64`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> u64`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = u64>>`[src]

`impl Arbitrary for u128`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> u128`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = u128>>`[src]

`impl Arbitrary for isize`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> isize`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = isize>>`[src]

`impl Arbitrary for i8`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> i8`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = i8>>`[src]

`impl Arbitrary for i16`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> i16`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = i16>>`[src]

`impl Arbitrary for i32`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> i32`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = i32>>`[src]

`impl Arbitrary for i64`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> i64`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = i64>>`[src]

`impl Arbitrary for i128`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> i128`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = i128>>`[src]

`impl Arbitrary for f32`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> f32`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = f32>>`[src]

`impl Arbitrary for f64`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> f64`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = f64>>`[src]

`impl<T: Arbitrary> Arbitrary for Wrapping<T>`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> Wrapping<T>`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = Wrapping<T>>>`[src]

`impl<T: Arbitrary> Arbitrary for Bound<T>`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> Bound<T>`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = Bound<T>>>`[src]

`impl<T: Arbitrary + Clone + PartialOrd> Arbitrary for Range<T>`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> Range<T>`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = Range<T>>>`[src]

`impl<T: Arbitrary + Clone + PartialOrd> Arbitrary for RangeFrom<T>`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> RangeFrom<T>`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = RangeFrom<T>>>`[src]

`impl<T: Arbitrary + Clone + PartialOrd> Arbitrary for RangeTo<T>`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> RangeTo<T>`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = RangeTo<T>>>`[src]

`impl Arbitrary for RangeFull`[src]

`fn arbitrary<G: Gen>(_: &mut G) -> RangeFull`[src]

`impl Arbitrary for Duration`[src]

`fn arbitrary<G: Gen>(gen: &mut G) -> Self`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = Self>>`[src]

`impl<A: Arbitrary> Arbitrary for Box<A>`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> Box<A>`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = Box<A>>>`[src]

`impl<A: Arbitrary + Sync> Arbitrary for Arc<A>`[src]

`fn arbitrary<G: Gen>(g: &mut G) -> Arc<A>`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = Arc<A>>>`[src]

`impl Arbitrary for SystemTime`[src]

`fn arbitrary<G: Gen>(gen: &mut G) -> Self`[src]

`fn shrink(&self) -> Box<dyn Iterator<Item = Self>>`[src]

Loading content...

Implementors

Loading content...