Crate uncover[][src]


A library that makes tests easier to maintain by using instrumentation to answer these two questions:

  • Which code is exercised by this test?
  • Which test covers this bit of code?

Here's a short example:

extern crate uncover;

// This defines two macros, `covers!` and `covered_by!`.
// They will be no-ops unless `cfg!(debug_assertions)` is true.

fn parse_date(s: &str) -> Option<(u32, u32, u32)> {
    if 10 != s.len() {
        // By using `covered_by!("unique_name")`
        // we signal which test exercises this code.
        covered_by!("short date");
        return None;

    if "-" != &s[4..5] || "-" != &s[7..8] {
        covered_by!("wrong dashes");
        return None;
    // ...

fn test_parse_date() {
        // `covers!("unique_name")` creates a guard object
        // that verifies that by the end of the scope we've
        // executed the corresponding `covered_by!("unique_name")`.
        covers!("short date");

//  This will fail. Although the test looks like
//  it exercises the second condition, it does not.
//  The call to `covers!` call catches this bug in the test.
//  {
//      covers!("wrong dashes");
//      assert!(parse_date("27.2.2013").is_none());
//  }

        covers!("wrong dashes");

Notes on concurrency

Coverage is tracked via shared mutable state, so the following caveat applies:

  • A covers! from one test might be covered by thread of another test. As a result, a test might pass when it should have failed.

The error in the opposite direction never happens: if your code covers everything with a single thread, it will do it with several threads as well.



Define covered_by! and covers! macros.