Struct quickcheck::QuickCheck [] [src]

pub struct QuickCheck<G> {
    // some fields omitted

The main QuickCheck type for setting configuration and running QuickCheck.


impl QuickCheck<StdGen<ThreadRng>>

fn new() -> QuickCheck<StdGen<ThreadRng>>

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 StdGen with a default size of 100.

impl<G: Gen> QuickCheck<G>

fn tests(self, tests: usize) -> 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.

fn max_tests(self, max_tests: usize) -> 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.

fn gen(self, gen: G) -> QuickCheck<G>

Set the random number generator to be used by QuickCheck.

fn quicktest<A>(&mut self, f: A) -> Result<usize, 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.)

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.


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);