Struct TestTarget 

pub struct TestTarget<Generator, Engine, InputOwnership> { /* private fields */ }

Configuration for a test target

Implementations

impl<Engine> TestTarget<ByteSliceGenerator, Engine, BorrowedInput>

pub fn new( engine: Engine, ) -> TestTarget<ByteSliceGenerator, Engine, BorrowedInput>

Create a TestTarget with the given Engine

impl<G, Engine, InputOwnership> TestTarget<G, Engine, InputOwnership>

pub fn with_generator<Generator: ValueGenerator>( self, generator: Generator, ) -> TestTarget<Generator, Engine, InputOwnership>

where Generator::Output: Debug,

Set the value generator for the TestTarget

The function with_generator::<Generator>(generator) will use the provided Generator, which implements generator::ValueGenerator, to generate input values of type Generator::Output.

This mode is used for testing an implementation that requires structured input with specific constraints applied to the type.

pub fn with_type<T: Debug + TypeGenerator>( self, ) -> TestTarget<TypeValueGenerator<T>, Engine, InputOwnership>

Set the type generator for the TestTarget

Calling with_type::<Type>() will generate random values of Type to be tested. Type is required to implement generator::TypeGenerator in order to use this method.

This mode is used for testing an implementation that requires structured input.

pub fn with_shrink_time(self, shrink_time: Duration) -> Self

Set the amount of time that will be spent shrinking an input on failure

Engines can optionally shrink inputs on failures to make it easier to debug and identify the failure. Increasing this time can potentially lead to smaller values.

pub fn exhaustive(self) -> Self

Exhaustively iterates over all of the possible inputs

Note that if the search space is large this can take a long time.

impl<G: ValueGenerator, Engine, InputOwnership> TestTarget<G, Engine, InputOwnership>

pub fn map<F: Fn(G::Output) -> T, T: Debug>( self, map: F, ) -> TestTarget<MapGenerator<G, F>, Engine, InputOwnership>

Map the value of the generator

pub fn and_then<F: Fn(G::Output) -> T, T: ValueGenerator>( self, map: F, ) -> TestTarget<AndThenGenerator<G, F>, Engine, InputOwnership>

where T::Output: Debug,

Map the value of the generator with a new generator

pub fn filter<F: Fn(&G::Output) -> bool>( self, filter: F, ) -> TestTarget<FilterGenerator<G, F>, Engine, InputOwnership>

Filter the value of the generator

pub fn filter_map<F: Fn(G::Output) -> Option<T>, T>( self, filter_map: F, ) -> TestTarget<FilterMapGenerator<G, F>, Engine, InputOwnership>

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

pub fn with_driver_mode(self, mode: DriverMode) -> Self

👎Deprecated: Driver mode is no longer being used by generator implementations

Set the driver mode for the test target

pub fn with_max_depth(self, max_depth: usize) -> Self

Set the maximum number of recursive types that can be generated.

The default value is 5.

impl<G, InputOwnership> TestTarget<G, TestEngine, InputOwnership>

pub fn with_test_time(self, test_time: Duration) -> Self

Set the maximum runtime of the tests

pub fn with_iterations(self, iterations: usize) -> Self

Set the number of iterations executed

pub fn with_max_len(self, max_len: usize) -> Self

Set the maximum length of the generated bytes

impl<G, Engine> TestTarget<G, Engine, BorrowedInput>

where G: ValueGenerator, <G as ValueGenerator>::Output: Clone,

pub fn cloned(self) -> TestTarget<G, Engine, ClonedInput>

Use a cloned value for the test input

Cloning the test inputs will force a call to Clone::clone on each input value, and therefore, will be less efficient than using a reference.

impl<G, E> TestTarget<G, E, BorrowedInput>

where G: ValueGenerator,

pub fn for_each<F>(self, test: F) -> E::Output

where E: Engine<BorrowedGeneratorTest<F, G, G::Output>>, BorrowedGeneratorTest<F, G, G::Output>: Test,

Iterate over all of the inputs and check the TestTarget

impl<G, E> TestTarget<G, E, ClonedInput>

where G: ValueGenerator,

pub fn for_each<F>(self, test: F) -> E::Output

where E: Engine<ClonedGeneratorTest<F, G, G::Output>>, ClonedGeneratorTest<F, G, G::Output>: Test,

Iterate over all of the inputs and check the TestTarget

impl<E> TestTarget<ByteSliceGenerator, E, BorrowedInput>

pub fn for_each<T>(self, test: T) -> E::Output

where E: Engine<BorrowedSliceTest<T>>, BorrowedSliceTest<T>: Test,

Iterate over all of the inputs and check the TestTarget

pub fn run<T, R>(self, test: T) -> E::Output

where T: FnMut() -> R + RefUnwindSafe, R: IntoResult, E: ScopedEngine,

Iterate over all of the inputs and check the TestTarget

pub fn run_with_replay<T, R>(self, test: T) -> E::Output

where T: FnMut(bool) -> R + RefUnwindSafe, R: IntoResult, E: ScopedEngine,

impl<E> TestTarget<ByteSliceGenerator, E, ClonedInput>

pub fn for_each<T>(self, test: T) -> E::Output

where E: Engine<ClonedSliceTest<T>>, ClonedSliceTest<T>: Test,

Iterate over all of the inputs and check the TestTarget