Rust
Need help with speculate.rs?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.
utkarshkukreti

Description

An RSpec inspired minimal testing framework for Rust.

216 Stars 15 Forks 149 Commits 11 Opened issues

Services available

Need anything else?

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

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.