arbtest

A minimalist property-based testing library based on the arbitrary crate.

Maintainance Status

Arbitrary.

Example

) -> arbitrary::Result<()> {
        let mut xs = u.arbitrary::>()?;
        buggy_sort(&mut xs);
        Ok(())
    }

    #[test]
    fn test() {
        arbtest::builder().budget_ms(50_000)
            .run(|u| prop(u))
    }

    #[test]
    fn reproduce() {
        arbtest::builder().seed(0xde0ad94600000001)
            .run(|u| prop(u))
    }

    #[test]
    fn minimize() {
        arbtest::builder().seed(0x2d5a75df00003e9a).minimize()
            .run(|u| prop(u))
    }
}">
 pub fn buggy_sort(xs: &mut [u8]) {
    for i in 0..xs.len() {
        for j in 0..i {
            if xs[i] == xs[j] {
                panic!("BUG")
            }
        }
    }
    xs.sort()
}

#[cfg(test)]
mod tests {
    use super::*;

    use arbtest::arbitrary::{self, Unstructured};

    fn prop(u: &mut Unstructured<'_>) -> arbitrary::Result<()> {
        let mut xs = u.arbitrary::<Vec<u8>>()?;
        buggy_sort(&mut xs);
        Ok(())
    }

    #[test]
    fn test() {
        arbtest::builder().budget_ms(50_000)
            .run(|u| prop(u))
    }

    #[test]
    fn reproduce() {
        arbtest::builder().seed(0xde0ad94600000001)
            .run(|u| prop(u))
    }

    #[test]
    fn minimize() {
        arbtest::builder().seed(0x2d5a75df00003e9a).minimize()
            .run(|u| prop(u))
    }
}

Rnp - A simple cloud-friendly tool for testing network reachability.

Rnp - A simple cloud-friendly tool for testing network reachability. Release Status Crates.io Github release Nuget packages NOTE: This project is in e

50 Dec 13, 2022

Viceroy provides local testing for developers working with Compute@Edge.

Viceroy provides local testing for developers working with Compute@Edge. It allows you to run services written against the Compute@Edge APIs on your local development machine, and allows you to configure testing backends for your service to communicate with.

99 Jan 7, 2023

Simple goldenfile testing in Rust.

👑 Rust Goldenfile Simple goldenfile testing in Rust. Goldenfile tests generate one or more output files as they run. At the end of the test, the gene

24 Nov 26, 2022

Declarative Testing Framework

Demonstrate allows tests to be written without as a much repetitive code within the demonstrate! macro, which will generate the corresponding full tests.

41 Aug 17, 2022

Cucumber testing framework for Rust. Fully native, no external test runners or dependencies.

An implementation of the Cucumber testing framework for Rust. Fully native, no external test runners or dependencies.

394 Jan 1, 2023

🧵 Generate self-describing strings of a given length to help aid software testing

rust-counter-strings Counter strings generator written in rust to help aid software testing What is a counterstring? "A counterstring is a graduated s

23 Jun 24, 2022

Loom is a concurrency permutation testing tool for Rust.

Loom is a testing tool for concurrent Rust code

1.4k Jan 9, 2023

Drill is an HTTP load testing application written in Rust inspired by Ansible syntax

1.5k Jan 1, 2023

assay - A super powered testing macro for Rust

assay - A super powered testing macro for Rust as·say /ˈaˌsā,aˈsā/ noun - the testing of a metal or ore to determine its ingredients and quality. Rust

105 Dec 4, 2022

Comments

Supporting run with a closure
Hi, thanks for the nice library! I've started using it recently and now expanding it to my work related and private projects.

What's desired

Would it be possible to make builder.run() accept a real closure instead of

pub type Property = fn(u: &mut Unstructured<'_>) -> arbitrary::Result<()>;

In other words, something like:

pub trait Property: FnMut(&mut Unstructured<'_>) -> arbitrary::Result<()> { } pub fn run<P: Property>(mut self, prop: P) { // implementation.. }

Why it would be useful

One of my tests needs to be ran with some predefined IDs, that come from another place (in particular from DB).

Why it's not possible at the moment

I've tried to do the desired change and open a PR, but I see that it narrows down to catch_unwind, which I could not workaround:

fn fails(&mut self, seed: Seed, prop: Property) -> bool { let this = AssertUnwindSafe(self); std::panic::catch_unwind(move || { // <- FnMut cannot be moved here let that = this; that.0.single_run(seed, prop) }) .is_err() }
opened by greyblake 2