Skip to content

utkarshkukreti/speculate.rs

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

speculate.rs Build Status speculate at crates.io

An RSpec inspired minimal testing framework for Rust.

Installation

Add speculate to the dev-dependencies section of your Cargo.toml:

[dev-dependencies]
speculate = "0.1"

And add the following to the top of the Rust file you want to add tests for:

#[cfg(test)]
extern crate speculate;

#[cfg(test)]
use speculate::speculate;  // Must be imported into the current scope.

Usage

Speculate provides the speculate! syntax extension. Inside speculate! { ... }, you can have any "Item", like static, const, fn, etc, and 5 special types of blocks:

  • describe (or its alias context) - to group tests in a hierarchy, for readability. Can be arbitrarily nested.

  • before - contains setup code that's inserted before every sibling and nested it and bench blocks.

  • after - contains teardown code that's inserted after every sibling and nested it and bench blocks.

  • it (or its alias test) - contains tests.

    For example:

    it "can add 1 and 2" {
        assert_eq!(1 + 2, 3);
    }

    You can optionally add attributes to this block:

    #[ignore]
    test "ignore" {
        assert_eq!(1, 2);
    }
    
    #[should_panic]
    test "should panic" {
        assert_eq!(1, 2);
    }
    
    #[should_panic(expected = "foo")]
    test "should panic with foo" {
        panic!("foo");
    }
  • bench - contains benchmarks.

    For example:

    bench "xor 1 to 1000" |b| {
        b.iter(|| (0..1000).fold(0, |a, b| a ^ b));
    }

Complete Example (from tests/example.rs)

extern crate speculate;

use speculate::speculate;

speculate! {
    const ZERO: i32 = 0;

    fn add(a: i32, b: i32) -> i32 {
        a + b
    }

    describe "math" {
        const ONE: i32 = 1;

        fn sub(a: i32, b: i32) -> i32 {
            a - b
        }

        before {
            let two = ONE + ONE;
        }

        it "can add stuff" {
            assert_eq!(ONE, add(ZERO, ONE));
            assert_eq!(two, add(ONE, ONE));
        }

        it "can subtract stuff" {
            assert_eq!(ZERO, sub(ONE, ONE));
            assert_eq!(ONE, sub(two, ONE));
        }
    }
}

License

MIT

About

An RSpec inspired minimal testing framework for Rust.

Resources

Stars

Watchers

Forks

Packages

No packages published

Languages