Trait suppositions::generators::Generator

pub trait Generator {
    type Item;
    fn generate<I: Iterator<Item = u8>>(&self, src: &mut I) -> Maybe<Self::Item>;

    fn generate_from(&self, src: &InfoPool) -> Maybe<Self::Item> { ... }
    fn filter<F: Fn(&Self::Item) -> bool>(self, pred: F) -> Filtered<Self, F>
    where
        Self: Sized,
    { ... }
    fn filter_map<R, F: Fn(Self::Item) -> Maybe<R>>(
        self, 
        fun: F
    ) -> FilterMapped<Self, F>
    where
        Self: Sized,
    { ... }
    fn map<R, F: Fn(Self::Item) -> R>(self, fun: F) -> Mapped<Self, F>
    where
        Self: Sized,
    { ... }
}

An object that can generate test data from an underlying data source.

In order for shrinking to work correctly; we need to ensure that the output values get smaller as the input bytes get smaller (usually by input value).

Associated Types

type Item

The type of values that we can generate.

Required Methods

fn generate<I: Iterator<Item = u8>>(&self, src: &mut I) -> Maybe<Self::Item>

This consumes a stream of bytes given by source, and generates a value of type Self::Item.

Provided Methods

fn generate_from(&self, src: &InfoPool) -> Maybe<Self::Item>

A convenience function to generate a value directly from an InfoPool.

fn filter<F: Fn(&Self::Item) -> bool>(self, pred: F) -> Filtered<Self, F> where
    Self: Sized, 

Returns a generator that will skip values generated by self when the predicate pred returns false.

fn filter_map<R, F: Fn(Self::Item) -> Maybe<R>>(
    self,
    fun: F
) -> FilterMapped<Self, F> where
    Self: Sized, 

A generator that takes the values generated by self; then allows fun to either Skip them (by returning Err(DataError::SkipItem) or transform (by returning Ok(val)).

fn map<R, F: Fn(Self::Item) -> R>(self, fun: F) -> Mapped<Self, F> where
    Self: Sized, 

A generator that takes the generated values of self and pipes them through fun.

Implementations on Foreign Types

impl<T> Generator for Box<GeneratorObject<Item = T>>

type Item = T

fn generate<I: Iterator<Item = u8>>(&self, src: &mut I) -> Maybe<Self::Item>

fn generate_from(&self, src: &InfoPool) -> Maybe<Self::Item>

fn filter<F: Fn(&Self::Item) -> bool>(self, pred: F) -> Filtered<Self, F> where
    Self: Sized, 

fn filter_map<R, F: Fn(Self::Item) -> Maybe<R>>(
    self,
    fun: F
) -> FilterMapped<Self, F> where
    Self: Sized, 

fn map<R, F: Fn(Self::Item) -> R>(self, fun: F) -> Mapped<Self, F> where
    Self: Sized, 

impl<A: Generator, B: Generator> Generator for (A, B)

type Item = (A::Item, B::Item)

fn generate<In: Iterator<Item = u8>>(&self, src: &mut In) -> Maybe<Self::Item>

fn generate_from(&self, src: &InfoPool) -> Maybe<Self::Item>

fn filter<F: Fn(&Self::Item) -> bool>(self, pred: F) -> Filtered<Self, F> where
    Self: Sized, 

fn filter_map<R, F: Fn(Self::Item) -> Maybe<R>>(
    self,
    fun: F
) -> FilterMapped<Self, F> where
    Self: Sized, 

fn map<R, F: Fn(Self::Item) -> R>(self, fun: F) -> Mapped<Self, F> where
    Self: Sized, 

impl<A: Generator, B: Generator, C: Generator> Generator for (A, B, C)

type Item = (A::Item, B::Item, C::Item)

fn generate<In: Iterator<Item = u8>>(&self, src: &mut In) -> Maybe<Self::Item>

fn generate_from(&self, src: &InfoPool) -> Maybe<Self::Item>

fn filter<F: Fn(&Self::Item) -> bool>(self, pred: F) -> Filtered<Self, F> where
    Self: Sized, 

fn filter_map<R, F: Fn(Self::Item) -> Maybe<R>>(
    self,
    fun: F
) -> FilterMapped<Self, F> where
    Self: Sized, 

fn map<R, F: Fn(Self::Item) -> R>(self, fun: F) -> Mapped<Self, F> where
    Self: Sized, 

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

type Item = (A::Item, B::Item, C::Item, D::Item)

fn generate<In: Iterator<Item = u8>>(&self, src: &mut In) -> Maybe<Self::Item>

fn generate_from(&self, src: &InfoPool) -> Maybe<Self::Item>

fn filter<F: Fn(&Self::Item) -> bool>(self, pred: F) -> Filtered<Self, F> where
    Self: Sized, 

fn filter_map<R, F: Fn(Self::Item) -> Maybe<R>>(
    self,
    fun: F
) -> FilterMapped<Self, F> where
    Self: Sized, 

fn map<R, F: Fn(Self::Item) -> R>(self, fun: F) -> Mapped<Self, F> where
    Self: Sized, 

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

type Item = (A::Item, B::Item, C::Item, D::Item, E::Item)

fn generate<In: Iterator<Item = u8>>(&self, src: &mut In) -> Maybe<Self::Item>

fn generate_from(&self, src: &InfoPool) -> Maybe<Self::Item>

fn filter<F: Fn(&Self::Item) -> bool>(self, pred: F) -> Filtered<Self, F> where
    Self: Sized, 

fn filter_map<R, F: Fn(Self::Item) -> Maybe<R>>(
    self,
    fun: F
) -> FilterMapped<Self, F> where
    Self: Sized, 

fn map<R, F: Fn(Self::Item) -> R>(self, fun: F) -> Mapped<Self, F> where
    Self: Sized, 

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

type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item)

fn generate<In: Iterator<Item = u8>>(&self, src: &mut In) -> Maybe<Self::Item>

fn generate_from(&self, src: &InfoPool) -> Maybe<Self::Item>

fn filter<F: Fn(&Self::Item) -> bool>(self, pred: F) -> Filtered<Self, F> where
    Self: Sized, 

fn filter_map<R, F: Fn(Self::Item) -> Maybe<R>>(
    self,
    fun: F
) -> FilterMapped<Self, F> where
    Self: Sized, 

fn map<R, F: Fn(Self::Item) -> R>(self, fun: F) -> Mapped<Self, F> where
    Self: Sized, 

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

type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item)

fn generate<In: Iterator<Item = u8>>(&self, src: &mut In) -> Maybe<Self::Item>

fn generate_from(&self, src: &InfoPool) -> Maybe<Self::Item>

fn filter<F: Fn(&Self::Item) -> bool>(self, pred: F) -> Filtered<Self, F> where
    Self: Sized, 

fn filter_map<R, F: Fn(Self::Item) -> Maybe<R>>(
    self,
    fun: F
) -> FilterMapped<Self, F> where
    Self: Sized, 

fn map<R, F: Fn(Self::Item) -> R>(self, fun: F) -> Mapped<Self, F> where
    Self: Sized, 

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

type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item)

fn generate<In: Iterator<Item = u8>>(&self, src: &mut In) -> Maybe<Self::Item>

fn generate_from(&self, src: &InfoPool) -> Maybe<Self::Item>

fn filter<F: Fn(&Self::Item) -> bool>(self, pred: F) -> Filtered<Self, F> where
    Self: Sized, 

fn filter_map<R, F: Fn(Self::Item) -> Maybe<R>>(
    self,
    fun: F
) -> FilterMapped<Self, F> where
    Self: Sized, 

fn map<R, F: Fn(Self::Item) -> R>(self, fun: F) -> Mapped<Self, F> where
    Self: Sized, 

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

type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item)

fn generate<In: Iterator<Item = u8>>(&self, src: &mut In) -> Maybe<Self::Item>

fn generate_from(&self, src: &InfoPool) -> Maybe<Self::Item>

fn filter<F: Fn(&Self::Item) -> bool>(self, pred: F) -> Filtered<Self, F> where
    Self: Sized, 

fn filter_map<R, F: Fn(Self::Item) -> Maybe<R>>(
    self,
    fun: F
) -> FilterMapped<Self, F> where
    Self: Sized, 

fn map<R, F: Fn(Self::Item) -> R>(self, fun: F) -> Mapped<Self, F> where
    Self: Sized, 

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

type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item)

fn generate<In: Iterator<Item = u8>>(&self, src: &mut In) -> Maybe<Self::Item>

fn generate_from(&self, src: &InfoPool) -> Maybe<Self::Item>

fn filter<F: Fn(&Self::Item) -> bool>(self, pred: F) -> Filtered<Self, F> where
    Self: Sized, 

fn filter_map<R, F: Fn(Self::Item) -> Maybe<R>>(
    self,
    fun: F
) -> FilterMapped<Self, F> where
    Self: Sized, 

fn map<R, F: Fn(Self::Item) -> R>(self, fun: F) -> Mapped<Self, F> where
    Self: Sized, 

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

type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item, K::Item)

fn generate<In: Iterator<Item = u8>>(&self, src: &mut In) -> Maybe<Self::Item>

fn generate_from(&self, src: &InfoPool) -> Maybe<Self::Item>

fn filter<F: Fn(&Self::Item) -> bool>(self, pred: F) -> Filtered<Self, F> where
    Self: Sized, 

fn filter_map<R, F: Fn(Self::Item) -> Maybe<R>>(
    self,
    fun: F
) -> FilterMapped<Self, F> where
    Self: Sized, 

fn map<R, F: Fn(Self::Item) -> R>(self, fun: F) -> Mapped<Self, F> where
    Self: Sized, 

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

type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item, K::Item, L::Item)

fn generate<In: Iterator<Item = u8>>(&self, src: &mut In) -> Maybe<Self::Item>

fn generate_from(&self, src: &InfoPool) -> Maybe<Self::Item>

fn filter<F: Fn(&Self::Item) -> bool>(self, pred: F) -> Filtered<Self, F> where
    Self: Sized, 

fn filter_map<R, F: Fn(Self::Item) -> Maybe<R>>(
    self,
    fun: F
) -> FilterMapped<Self, F> where
    Self: Sized, 

fn map<R, F: Fn(Self::Item) -> R>(self, fun: F) -> Mapped<Self, F> where
    Self: Sized, 

Implementors

• impl<G: Generator> Generator for VecGenerator<G> type Item = Vec<G::Item>;
• impl Generator for InfoPoolGenerator type Item = InfoPool;
• impl Generator for BoolGenerator type Item = bool;
• impl Generator for IntGenerator<u8> type Item = u8;
• impl Generator for IntGenerator<u16> type Item = u16;
• impl Generator for IntGenerator<u32> type Item = u32;
• impl Generator for IntGenerator<u64> type Item = u64;
• impl Generator for IntGenerator<usize> type Item = usize;
• impl Generator for IntGenerator<i8> type Item = i8;
• impl Generator for IntGenerator<i16> type Item = i16;
• impl Generator for IntGenerator<i32> type Item = i32;
• impl Generator for IntGenerator<i64> type Item = i64;
• impl Generator for IntGenerator<isize> type Item = isize;
• impl Generator for FloatGenerator<f32> type Item = f32;
• impl Generator for FloatGenerator<f64> type Item = f64;
• impl Generator for UniformFloatGenerator<f32> type Item = f32;
• impl Generator for UniformFloatGenerator<f64> type Item = f64;
• impl Generator for WeightedCoinGenerator type Item = bool;
• impl<G: Generator> Generator for OptionalGenerator<G> type Item = Option<G::Item>;
• impl<G: Generator, H: Generator> Generator for ResultGenerator<G, H> type Item = Result<G::Item, H::Item>;
• impl<G: Generator, C: Default + Extend<G::Item>> Generator for CollectionGenerator<C, G> type Item = C;
• impl<G: Generator, F: Fn(&G::Item) -> bool> Generator for Filtered<G, F> type Item = G::Item;
• impl<G: Generator, R, F: Fn(G::Item) -> Maybe<R>> Generator for FilterMapped<G, F> type Item = R;
• impl<G: Generator, R, F: Fn(G::Item) -> R> Generator for Mapped<G, F> type Item = R;
• impl<V: Clone> Generator for Const<V> type Item = V;
• impl<F: Fn() -> G, G: Generator> Generator for LazyGenerator<F> type Item = G::Item;
• impl<GS: OneOfItem> Generator for OneOfGenerator<GS> type Item = GS::Item;