Enum Outcome 

pub enum Outcome {
    Pass,
    Fail,
    Skip,
    Timeout,
    Error,
}

What a run said about one test.

NotRun is deliberately absent: it is the absence of an execution, not an outcome one had. Encoding it here would let a recorder write “this did not run” and have it counted among the things that did.

use majordomus_cli::evidence::Outcome;

assert!(Outcome::parse("ok").proves());
assert!(!Outcome::parse("timeout").proves());
// exactly one of the five is evidence of anything; the other four are reasons there
// is none, kept apart because "it declined" and "the harness broke" are different bugs
assert_eq!(Outcome::parse("skipped"), Outcome::Skip);
assert_eq!(Outcome::parse("nonsense"), Outcome::Error);

Example

use majordomus_cli::evidence::Outcome;
assert!(Outcome::parse("ok").proves());
assert_eq!(Outcome::parse("wat"), Outcome::Error);

Variants

Pass

It passed.

Fail

It failed.

Skip

It declined to run and said so (an unmet precondition the case reports itself).

Timeout

The bound fired before it finished.

Error

The harness could not run it at all.

Implementations

impl Outcome

pub fn proves(self) -> bool

Did this run prove the behaviour it was about? Only a pass does.

A skip is a test that declined, and a timeout or an error is a test whose verdict nobody has; none of the three is a weaker kind of success, and every derivation in this module asks this question rather than matching on the variants itself.

use majordomus_cli::evidence::Outcome;
assert!(Outcome::Pass.proves());
assert!(!Outcome::Skip.proves(), "a test that declined to run proved nothing");
assert!(!Outcome::Timeout.proves());
assert!(!Outcome::Error.proves());

pub fn parse(word: &str) -> Outcome

The word the runner writes, read back. Anything unrecognised is Outcome::Error: a result nobody can classify is not a pass.

Case and surrounding space are the runner’s business, not the ledger’s, so both are normalised away. The fallback is the whole point: a truncated line, a renamed status word or a new runner’s vocabulary fails loudly instead of widening into a green.

use majordomus_cli::evidence::Outcome;
assert_eq!(Outcome::parse("PASSED"), Outcome::Pass);
assert_eq!(Outcome::parse("  skip  "), Outcome::Skip);
// near-misses included: nothing here guesses at what was meant
assert_eq!(Outcome::parse("okay"), Outcome::Error);
assert!(!Outcome::parse("").proves());

Trait Implementations

impl Clone for Outcome

fn clone(&self) -> Outcome

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Outcome

impl Debug for Outcome

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Outcome

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Outcome

impl JsonSchema for Outcome

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Ord for Outcome

fn cmp(&self, other: &Outcome) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Outcome

fn eq(&self, other: &Outcome) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Outcome

fn partial_cmp(&self, other: &Outcome) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Outcome

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Outcome