Struct quickcheck::QuickCheck

pub struct QuickCheck<G> { /* fields omitted */ }

The main QuickCheck type for setting configuration and running QuickCheck.

Methods

impl QuickCheck<StdThreadGen>

pub fn new() -> QuickCheck<StdThreadGen>

Creates a new QuickCheck value.

This can be used to run QuickCheck on things that implement Testable. You may also adjust the configuration, such as the number of tests to run.

By default, the maximum number of passed tests is set to 100, the max number of overall tests is set to 10000 and the generator is set to a StdThreadGen with a default size of 100.

impl<G: Gen> QuickCheck<G>

pub fn tests(self, tests: u64) -> QuickCheck<G>

Set the number of tests to run.

This actually refers to the maximum number of passed tests that can occur. Namely, if a test causes a failure, future testing on that property stops. Additionally, if tests are discarded, there may be fewer than tests passed.

pub fn with_gen(generator: G) -> QuickCheck<G>

Create a new instance of QuickCheck using the given generator.

pub fn max_tests(self, max_tests: u64) -> QuickCheck<G>

Set the maximum number of tests to run.

The number of invocations of a property will never exceed this number. This is necessary to cap the number of tests because QuickCheck properties can discard tests.

pub fn gen<N: Gen>(self, gen: N) -> QuickCheck<N>

Set the random number generator to be used by QuickCheck.

pub fn min_tests_passed(self, min_tests_passed: u64) -> QuickCheck<G>

Set the minimum number of tests that needs to pass.

This actually refers to the minimum number of valid passed tests that needs to pass for the property to be considered successful.

pub fn quicktest<A>(&mut self, f: A) -> Result<u64, TestResult> where
    A: Testable, 

Tests a property and returns the result.

The result returned is either the number of tests passed or a witness of failure.

(If you're using Rust's unit testing infrastructure, then you'll want to use the quickcheck method, which will panic! on failure.)

pub fn quickcheck<A>(&mut self, f: A) where
    A: Testable, 

Tests a property and calls panic! on failure.

The panic! message will include a (hopefully) minimal witness of failure.

It is appropriate to use this method with Rust's unit testing infrastructure.

Note that if the environment variable RUST_LOG is set to enable info level log messages for the quickcheck crate, then this will include output on how many QuickCheck tests were passed.

Example

use quickcheck::QuickCheck;

fn prop_reverse_reverse() {
    fn revrev(xs: Vec<usize>) -> bool {
        let rev: Vec<_> = xs.clone().into_iter().rev().collect();
        let revrev: Vec<_> = rev.into_iter().rev().collect();
        xs == revrev
    }
    QuickCheck::new().quickcheck(revrev as fn(Vec<usize>) -> bool);
}