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.

This testing library is highly influenced by speculate.rs and ruspec which both take inspiration from RSpec.

The following new block definitions are utilized by Demonstrate:

before/after — A block of source code that will be included at the start or end of each test respectively in the current and nested describe/context blocks.
describe/context — describe and context are aliases for eachother. Specifies a new scope of tests which can contain a before and/or after block, nested describe/context blocks, and it/test blocks. These translate to Rust mod blocks, but also allow for shared test properties to be defined such as tests having outer attributes, being async, and having Return<()> types.
it/test — it and test are aliases for eachother. Represents one test that translate to a Rust unit test.

Example

```rust use demonstrate::demonstrate;

fn is_4() -> u8 { 4 }

demonstrate! { describe module { use super::is_4;

    before {
        let four = 4;
    }

    #[should_panic]
    it can_fail {
        assert!(four != 4)
    }

    test is_returnable -> Result<(), &'static str> {
        if is_4() == four {
            Ok(())
        } else {
            Err("It isn't 4! :o")
        }
    }

    #[async_attributes::test]
    async context asynchronous {
        before {
            let is_4_task = async_std::task::spawn(async {
                is_4()
            });
        }

        it awaits {
            assert_eq!(four, is_4_task.await)
        }
    }
}

} ```

License

^{Licensed under MIT license.}