Struct ConfigurationBuilder

pub struct ConfigurationBuilder { /* private fields */ }

Builder for Configuration.

Implementations

impl ConfigurationBuilder

pub fn parallel(&mut self, value: bool) -> &mut Self

Whether the runner executes tests in parallel

pub fn exit_on_failure(&mut self, value: bool) -> &mut Self

Whether the runner exits the procees upon encountering failures

pub fn build(&self) -> Result<Configuration, String>

Builds a new Configuration.

Errors

If a required field has not been initialized.

Examples found in repository

examples/multi.rs (line 11)

pub fn main() {
    let logger = Arc::new(rspec::Logger::new(io::stdout()));
    let configuration = rspec::ConfigurationBuilder::default().build().unwrap();
    let runner = rspec::Runner::new(configuration, vec![logger]);

    // A test suite using the `suite`, `context`, `example` syntax family:
    runner.run(&rspec::suite("an value of ten", 10, |ctx| {
        ctx.context("adding 5 to it", |ctx| {
            ctx.example("results in fifteen", |num| {
                assert_eq!(*num, 15);
            });
        });
    }));

    // A test suite using the `describe`, `specify`, `it` syntax family:
    runner.run(&rspec::describe("an value of ten", 10, |ctx| {
        ctx.specify("adding 5 to it", |ctx| {
            ctx.it("results in fifteen", |num| {
                assert_eq!(*num, 15);
            });
        });
    }));

    // A test suite using the `given`, `when`, `then` syntax family:
    runner.run(&rspec::given("an value of ten", 10, |ctx| {
        ctx.when("adding 5 to it", |ctx| {
            ctx.then("results in fifteen", |num| {
                assert_eq!(*num, 15);
            });
        });
    }));
}

Trait Implementations

impl Clone for ConfigurationBuilder

fn clone(&self) -> ConfigurationBuilder

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for ConfigurationBuilder

fn default() -> ConfigurationBuilder

Returns the “default value” for a type.