Struct sample_test::tester::SampleTest

pub struct SampleTest { /* private fields */ }

The main SampleTest type for setting configuration and running sample-based testing.

Implementations

impl SampleTest

pub fn new() -> SampleTest

Creates a new SampleTest value.

This can be used to run SampleTest 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 created with a size of 100.

pub fn tests(self, tests: u64) -> SampleTest

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 max_tests(self, max_tests: u64) -> SampleTest

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 SampleTest properties can discard tests.

pub fn min_tests_passed(self, min_tests_passed: u64) -> SampleTest

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 sample_test_count<S, A>(&mut self, s: S, f: A) -> Result<u64, TestResult>where A: Testable<S>, S: Sample, S::Output: Clone + Debug,

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 sample_test method, which will panic! on failure.)

pub fn sample_test<S, A>(&mut self, s: S, f: A)where A: Testable<S>, S: Sample, S::Output: Clone + Debug,

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 sample_test crate, then this will include output on how many SampleTest tests were passed.

Example

use sample_test::{SampleTest};
use sample_std::VecSampler;

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
    }
    let sampler = (VecSampler { length: (0..20), el: (0..100usize) },);
    SampleTest::new().sample_test(sampler, revrev as fn(Vec<usize>) -> bool);
}