pub trait ValueGenerator: Sized {
    type Output;

    // Required method
    fn generate<D>(&self, driver: &mut D) -> Option<Self::Output>
       where D: Driver;

    // Provided methods
    fn mutate<D>(&self, driver: &mut D, value: &mut Self::Output) -> Option<()>
       where D: Driver { ... }
    fn map<F, T>(self, map: F) -> MapGenerator<Self, F>
       where F: Fn(Self::Output) -> T { ... }
    fn map_gen<F, T>(self, map: F) -> MapGenerator<Self, F>
       where F: Fn(Self::Output) -> T { ... }
    fn and_then<F, T>(self, and_then: F) -> AndThenGenerator<Self, F>
       where F: Fn(Self::Output) -> T,
             T: ValueGenerator { ... }
    fn and_then_gen<F, T>(self, and_then: F) -> AndThenGenerator<Self, F>
       where F: Fn(Self::Output) -> T,
             T: ValueGenerator { ... }
    fn filter<F>(self, filter: F) -> FilterGenerator<Self, F>
       where F: Fn(&Self::Output) -> bool { ... }
    fn filter_gen<F>(self, filter: F) -> FilterGenerator<Self, F>
       where F: Fn(&Self::Output) -> bool { ... }
    fn filter_map<F, T>(self, filter_map: F) -> FilterMapGenerator<Self, F>
       where F: Fn(Self::Output) -> Option<T> { ... }
    fn filter_map_gen<F, T>(self, filter_map: F) -> FilterMapGenerator<Self, F>
       where F: Fn(Self::Output) -> Option<T> { ... }
}
Expand description

Generate a value with a parameterized generator

Required Associated Types§

Required Methods§

source

fn generate<D>(&self, driver: &mut D) -> Option<Self::Output>where D: Driver,

Generates a value with the given driver

Provided Methods§

source

fn mutate<D>(&self, driver: &mut D, value: &mut Self::Output) -> Option<()>where D: Driver,

Mutates an existing value with the given driver

source

fn map<F, T>(self, map: F) -> MapGenerator<Self, F>where F: Fn(Self::Output) -> T,

Map the value of a generator

source

fn map_gen<F, T>(self, map: F) -> MapGenerator<Self, F>where F: Fn(Self::Output) -> T,

Map the value of a generator, exists to reduce conflicts with other map functions.

source

fn and_then<F, T>(self, and_then: F) -> AndThenGenerator<Self, F>where F: Fn(Self::Output) -> T, T: ValueGenerator,

Map the value of a generator with a new generator

source

fn and_then_gen<F, T>(self, and_then: F) -> AndThenGenerator<Self, F>where F: Fn(Self::Output) -> T, T: ValueGenerator,

Map the value of a generator with a new generator, exists to reduce conflicts with other map functions.

source

fn filter<F>(self, filter: F) -> FilterGenerator<Self, F>where F: Fn(&Self::Output) -> bool,

Filter the value of a generator

source

fn filter_gen<F>(self, filter: F) -> FilterGenerator<Self, F>where F: Fn(&Self::Output) -> bool,

Filter the value of a generator, exists to reduce conflicts with other filter functions.

source

fn filter_map<F, T>(self, filter_map: F) -> FilterMapGenerator<Self, F>where F: Fn(Self::Output) -> Option<T>,

Filter the value of a generator and map it to something else

source

fn filter_map_gen<F, T>(self, filter_map: F) -> FilterMapGenerator<Self, F>where F: Fn(Self::Output) -> Option<T>,

Filter the value of a generator and map it to something else, exists to reduce conflicts with other filter_map functions.

Implementations on Foreign Types§

source§

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

§

type Output = (<A as ValueGenerator>::Output,)

source§

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A,) as ValueGenerator>::Output>where D_: Driver,

source§

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A,) as ValueGenerator>::Output ) -> Option<()>where D_: Driver,

source§

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

source§

impl<'a, T> ValueGenerator for &'a Twhere T: ValueGenerator,

§

type Output = <T as ValueGenerator>::Output

source§

fn generate<D>( &self, driver: &mut D ) -> Option<<&'a T as ValueGenerator>::Output>where D: Driver,

source§

fn mutate<D>( &self, driver: &mut D, value: &mut <&'a T as ValueGenerator>::Output ) -> Option<()>where D: Driver,

source§

impl ValueGenerator for i64

§

type Output = i64

source§

fn generate<D>(&self, _driver: &mut D) -> Option<i64>where D: Driver,

source§

impl<T, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)where T: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator,

source§

impl<T> ValueGenerator for RangeFrom<T>where T: BoundedValue<T>,

§

type Output = T

source§

fn generate<D>( &self, driver: &mut D ) -> Option<<RangeFrom<T> as ValueGenerator>::Output>where D: Driver,

source§

fn mutate<D>( &self, driver: &mut D, value: &mut <RangeFrom<T> as ValueGenerator>::Output ) -> Option<()>where D: Driver,

source§

impl ValueGenerator for u128

§

type Output = u128

source§

fn generate<D>(&self, _driver: &mut D) -> Option<u128>where D: Driver,

source§

impl ValueGenerator for isize

§

type Output = isize

source§

fn generate<D>(&self, _driver: &mut D) -> Option<isize>where D: Driver,

source§

impl<AA, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA)where AA: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator, Y: ValueGenerator, Z: ValueGenerator,

source§

impl<K, A, B, C, D, E, F, G, H, I, J> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K)where K: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator,

source§

impl<L, A, B, C, D, E, F, G, H, I, J, K> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L)where L: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator,

source§

impl<V> ValueGenerator for HashSet<V, RandomState>where V: ValueGenerator, <V as ValueGenerator>::Output: Sized + Hash + Eq,

§

type Output = HashSet<<V as ValueGenerator>::Output, RandomState>

source§

fn generate<D>( &self, driver: &mut D ) -> Option<<HashSet<V, RandomState> as ValueGenerator>::Output>where D: Driver,

source§

fn mutate<D>( &self, driver: &mut D, value: &mut <HashSet<V, RandomState> as ValueGenerator>::Output ) -> Option<()>where D: Driver,

source§

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

source§

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

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output)

source§

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B) as ValueGenerator>::Output>where D_: Driver,

source§

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B) as ValueGenerator>::Output ) -> Option<()>where D_: Driver,

source§

impl ValueGenerator for f64

§

type Output = f64

source§

fn generate<D>(&self, _driver: &mut D) -> Option<f64>where D: Driver,

source§

impl ValueGenerator for f32

§

type Output = f32

source§

fn generate<D>(&self, _driver: &mut D) -> Option<f32>where D: Driver,

source§

impl<AE, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE)where AE: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator, Y: ValueGenerator, Z: ValueGenerator, AA: ValueGenerator, AB: ValueGenerator, AC: ValueGenerator, AD: ValueGenerator,

source§

impl<S, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)where S: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator,

source§

impl<V> ValueGenerator for Vec<V, Global>where V: ValueGenerator,

§

type Output = Vec<<V as ValueGenerator>::Output, Global>

source§

fn generate<D>( &self, driver: &mut D ) -> Option<<Vec<V, Global> as ValueGenerator>::Output>where D: Driver,

source§

fn mutate<D>( &self, driver: &mut D, value: &mut <Vec<V, Global> as ValueGenerator>::Output ) -> Option<()>where D: Driver,

source§

impl<R, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)where R: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator,

source§

impl<V> ValueGenerator for LinkedList<V, Global>where V: ValueGenerator,

§

type Output = LinkedList<<V as ValueGenerator>::Output, Global>

source§

fn generate<D>( &self, driver: &mut D ) -> Option<<LinkedList<V, Global> as ValueGenerator>::Output>where D: Driver,

source§

fn mutate<D>( &self, driver: &mut D, value: &mut <LinkedList<V, Global> as ValueGenerator>::Output ) -> Option<()>where D: Driver,

source§

impl<Q, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)where Q: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator,

source§

impl<AF, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF)where AF: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator, Y: ValueGenerator, Z: ValueGenerator, AA: ValueGenerator, AB: ValueGenerator, AC: ValueGenerator, AD: ValueGenerator, AE: ValueGenerator,

source§

impl<N, A, B, C, D, E, F, G, H, I, J, K, L, M> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)where N: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator,

source§

impl<T> ValueGenerator for RangeTo<T>where T: BoundedValue<T>,

§

type Output = T

source§

fn generate<D>( &self, driver: &mut D ) -> Option<<RangeTo<T> as ValueGenerator>::Output>where D: Driver,

source§

fn mutate<D>( &self, driver: &mut D, value: &mut <RangeTo<T> as ValueGenerator>::Output ) -> Option<()>where D: Driver,

source§

impl ValueGenerator for i16

§

type Output = i16

source§

fn generate<D>(&self, _driver: &mut D) -> Option<i16>where D: Driver,

source§

impl ValueGenerator for i8

§

type Output = i8

source§

fn generate<D>(&self, _driver: &mut D) -> Option<i8>where D: Driver,

source§

impl<Y, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)where Y: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator,

source§

impl<V> ValueGenerator for VecDeque<V, Global>where V: ValueGenerator,

§

type Output = VecDeque<<V as ValueGenerator>::Output, Global>

source§

fn generate<D>( &self, driver: &mut D ) -> Option<<VecDeque<V, Global> as ValueGenerator>::Output>where D: Driver,

source§

fn mutate<D>( &self, driver: &mut D, value: &mut <VecDeque<V, Global> as ValueGenerator>::Output ) -> Option<()>where D: Driver,

source§

impl ValueGenerator for u8

§

type Output = u8

source§

fn generate<D>(&self, _driver: &mut D) -> Option<u8>where D: Driver,

source§

impl<O, A, B, C, D, E, F, G, H, I, J, K, L, M, N> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)where O: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator,

source§

impl<T> ValueGenerator for PhantomData<T>

§

type Output = PhantomData<T>

source§

fn generate<D>( &self, _driver: &mut D ) -> Option<<PhantomData<T> as ValueGenerator>::Output>where D: Driver,

source§

impl<V, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)where V: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator,

source§

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

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output)

source§

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E) as ValueGenerator>::Output>where D_: Driver,

source§

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E) as ValueGenerator>::Output ) -> Option<()>where D_: Driver,

source§

impl<V> ValueGenerator for BTreeSet<V, Global>where V: ValueGenerator, <V as ValueGenerator>::Output: Sized + Ord,

§

type Output = BTreeSet<<V as ValueGenerator>::Output, Global>

source§

fn generate<D>( &self, driver: &mut D ) -> Option<<BTreeSet<V, Global> as ValueGenerator>::Output>where D: Driver,

source§

fn mutate<D>( &self, driver: &mut D, value: &mut <BTreeSet<V, Global> as ValueGenerator>::Output ) -> Option<()>where D: Driver,

source§

impl ValueGenerator for i128

§

type Output = i128

source§

fn generate<D>(&self, _driver: &mut D) -> Option<i128>where D: Driver,

source§

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

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output)

source§

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F) as ValueGenerator>::Output>where D_: Driver,

source§

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F) as ValueGenerator>::Output ) -> Option<()>where D_: Driver,

source§

impl<V, K> ValueGenerator for BTreeMap<K, V, Global>where V: ValueGenerator, K: ValueGenerator, <K as ValueGenerator>::Output: Sized + Ord,

§

type Output = BTreeMap<<K as ValueGenerator>::Output, <V as ValueGenerator>::Output, Global>

source§

fn generate<D>( &self, driver: &mut D ) -> Option<<BTreeMap<K, V, Global> as ValueGenerator>::Output>where D: Driver,

source§

impl ValueGenerator for char

§

type Output = char

source§

fn generate<D>(&self, _driver: &mut D) -> Option<char>where D: Driver,

source§

impl<M, A, B, C, D, E, F, G, H, I, J, K, L> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M)where M: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator,

source§

impl<P, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)where P: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator,

source§

impl<T> ValueGenerator for Range<T>where T: BoundedValue<T>,

§

type Output = T

source§

fn generate<D>( &self, driver: &mut D ) -> Option<<Range<T> as ValueGenerator>::Output>where D: Driver,

source§

fn mutate<D>( &self, driver: &mut D, value: &mut <Range<T> as ValueGenerator>::Output ) -> Option<()>where D: Driver,

source§

impl<U, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)where U: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator,

source§

impl<V> ValueGenerator for BinaryHeap<V>where V: ValueGenerator, <V as ValueGenerator>::Output: Sized + Ord,

§

type Output = BinaryHeap<<V as ValueGenerator>::Output>

source§

fn generate<D>( &self, driver: &mut D ) -> Option<<BinaryHeap<V> as ValueGenerator>::Output>where D: Driver,

source§

fn mutate<D>( &self, driver: &mut D, value: &mut <BinaryHeap<V> as ValueGenerator>::Output ) -> Option<()>where D: Driver,

source§

impl ValueGenerator for ()

§

type Output = ()

source§

fn generate<D>(&self, _driver: &mut D) -> Option<()>where D: Driver,

source§

impl ValueGenerator for u32

§

type Output = u32

source§

fn generate<D>(&self, _driver: &mut D) -> Option<u32>where D: Driver,

source§

impl ValueGenerator for String

§

type Output = String

source§

fn generate<D>(&self, _driver: &mut D) -> Option<String>where D: Driver,

source§

impl ValueGenerator for i32

§

type Output = i32

source§

fn generate<D>(&self, _driver: &mut D) -> Option<i32>where D: Driver,

source§

impl<AB, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB)where AB: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator, Y: ValueGenerator, Z: ValueGenerator, AA: ValueGenerator,

source§

impl ValueGenerator for u16

§

type Output = u16

source§

fn generate<D>(&self, _driver: &mut D) -> Option<u16>where D: Driver,

source§

impl<W, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)where W: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator,

source§

impl ValueGenerator for u64

§

type Output = u64

source§

fn generate<D>(&self, _driver: &mut D) -> Option<u64>where D: Driver,

source§

impl ValueGenerator for bool

§

type Output = bool

source§

fn generate<D>( &self, _driver: &mut D ) -> Option<<bool as ValueGenerator>::Output>where D: Driver,

source§

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

source§

impl<T> ValueGenerator for RangeInclusive<T>where T: BoundedValue<T>,

§

type Output = T

source§

fn generate<D>( &self, driver: &mut D ) -> Option<<RangeInclusive<T> as ValueGenerator>::Output>where D: Driver,

source§

fn mutate<D>( &self, driver: &mut D, value: &mut <RangeInclusive<T> as ValueGenerator>::Output ) -> Option<()>where D: Driver,

source§

impl<V, K> ValueGenerator for HashMap<K, V, RandomState>where V: ValueGenerator, K: ValueGenerator, <K as ValueGenerator>::Output: Sized + Hash + Eq,

source§

impl<T> ValueGenerator for RangeToInclusive<T>where T: BoundedValue<T>,

§

type Output = T

source§

fn generate<D>( &self, driver: &mut D ) -> Option<<RangeToInclusive<T> as ValueGenerator>::Output>where D: Driver,

source§

fn mutate<D>( &self, driver: &mut D, value: &mut <RangeToInclusive<T> as ValueGenerator>::Output ) -> Option<()>where D: Driver,

source§

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

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output)

source§

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C) as ValueGenerator>::Output>where D_: Driver,

source§

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C) as ValueGenerator>::Output ) -> Option<()>where D_: Driver,

source§

impl<AD, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD)where AD: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator, Y: ValueGenerator, Z: ValueGenerator, AA: ValueGenerator, AB: ValueGenerator, AC: ValueGenerator,

source§

impl<AG, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG)where AG: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator, Y: ValueGenerator, Z: ValueGenerator, AA: ValueGenerator, AB: ValueGenerator, AC: ValueGenerator, AD: ValueGenerator, AE: ValueGenerator, AF: ValueGenerator,

source§

impl ValueGenerator for usize

§

type Output = usize

source§

fn generate<D>(&self, _driver: &mut D) -> Option<usize>where D: Driver,

source§

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

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output)

source§

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G) as ValueGenerator>::Output>where D_: Driver,

source§

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G) as ValueGenerator>::Output ) -> Option<()>where D_: Driver,

source§

impl<X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)where X: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator,

source§

impl<Z, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)where Z: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator, Y: ValueGenerator,

source§

impl<AC, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC)where AC: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator, Y: ValueGenerator, Z: ValueGenerator, AA: ValueGenerator, AB: ValueGenerator,

source§

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

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output)

source§

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D) as ValueGenerator>::Output>where D_: Driver,

source§

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D) as ValueGenerator>::Output ) -> Option<()>where D_: Driver,

source§

impl<G, const LEN: usize> ValueGenerator for [G; LEN]where G: ValueGenerator,

§

type Output = [<G as ValueGenerator>::Output; LEN]

source§

fn generate<D>( &self, driver: &mut D ) -> Option<<[G; LEN] as ValueGenerator>::Output>where D: Driver,

source§

fn mutate<D>( &self, driver: &mut D, value: &mut <[G; LEN] as ValueGenerator>::Output ) -> Option<()>where D: Driver,

Implementors§

source§

impl ValueGenerator for BooleanGenerator

§

type Output = bool

source§

impl<G, F> ValueGenerator for FilterGenerator<G, F>where G: ValueGenerator, F: Fn(&<G as ValueGenerator>::Output) -> bool,

source§

impl<G, F, T> ValueGenerator for FilterMapGenerator<G, F>where G: ValueGenerator, F: Fn(<G as ValueGenerator>::Output) -> Option<T>,

§

type Output = T

source§

impl<G, H, F> ValueGenerator for AndThenGenerator<G, F>where G: ValueGenerator, H: ValueGenerator, F: Fn(<G as ValueGenerator>::Output) -> H,

source§

impl<G, L, Len> ValueGenerator for StringGenerator<G, L>where G: ValueGenerator<Output = char>, L: ValueGenerator<Output = Len>, Len: Into<usize>,

source§

impl<G, M, T> ValueGenerator for MapGenerator<G, M>where G: ValueGenerator, M: Fn(<G as ValueGenerator>::Output) -> T,

§

type Output = T

source§

impl<K, V, L, Len> ValueGenerator for BTreeMapGenerator<K, V, L>where K: ValueGenerator, V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>, <K as ValueGenerator>::Output: Sized + Ord,

source§

impl<K, V, L, Len> ValueGenerator for HashMapGenerator<K, V, L>where K: ValueGenerator, V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>, <K as ValueGenerator>::Output: Sized + Hash + Eq,

source§

impl<Left, Right, Selector> ValueGenerator for EitherGenerator<Left, Right, Selector>where Left: ValueGenerator, Right: ValueGenerator, Selector: ValueGenerator<Output = bool>,

§

type Output = Either<<Left as ValueGenerator>::Output, <Right as ValueGenerator>::Output>

source§

impl<O> ValueGenerator for OneOf<O>where O: OneOfGenerator,

source§

impl<O> ValueGenerator for OneValueOf<O>where O: OneValueOfGenerator,

source§

impl<Ok, Err, Selector> ValueGenerator for ResultGenerator<Ok, Err, Selector>where Ok: ValueGenerator, Err: ValueGenerator, Selector: ValueGenerator<Output = bool>,

source§

impl<Seconds, Nanos> ValueGenerator for DurationGenerator<Seconds, Nanos>where Seconds: ValueGenerator<Output = u64>, Nanos: ValueGenerator<Output = u32>,

source§

impl<Start, End, T> ValueGenerator for RangeGenerator<Start, End>where Start: ValueGenerator<Output = T>, End: ValueGenerator<Output = T>,

§

type Output = Range<T>

source§

impl<Start, End, T> ValueGenerator for RangeInclusiveGenerator<Start, End>where Start: ValueGenerator<Output = T>, End: ValueGenerator<Output = T>,

source§

impl<T> ValueGenerator for Constant<T>where T: Clone,

§

type Output = T

source§

impl<T> ValueGenerator for TypeValueGenerator<T>where T: TypeGenerator,

§

type Output = T

source§

impl<T, B> ValueGenerator for BoundedGenerator<T, B>where T: BoundedValue<T>, B: RangeBounds<T>,

§

type Output = T

source§

impl<V, L, Len> ValueGenerator for BTreeSetGenerator<V, L>where V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>, <V as ValueGenerator>::Output: Sized + Ord,

source§

impl<V, L, Len> ValueGenerator for BinaryHeapGenerator<V, L>where V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>, <V as ValueGenerator>::Output: Sized + Ord,

source§

impl<V, L, Len> ValueGenerator for LinkedListGenerator<V, L>where V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>,

source§

impl<V, L, Len> ValueGenerator for VecDequeGenerator<V, L>where V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>,

source§

impl<V, L, Len> ValueGenerator for VecGenerator<V, L>where V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>,

source§

impl<V, L, Len> ValueGenerator for HashSetGenerator<V, L>where V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>, <V as ValueGenerator>::Output: Sized + Hash + Eq,

source§

impl<V, Selector> ValueGenerator for OptionGenerator<V, Selector>where V: ValueGenerator, Selector: ValueGenerator<Output = bool>,