Enum Finding 

#[non_exhaustive]
pub enum Finding {
    Survived,
    Lost {
        violations: Vec<Violation>,
    },
    NotMeasured {
        why: String,
    },
    HarnessBroken {
        why: String,
        violations: Vec<Violation>,
    },
}

The outcome with its evidence attached.

let f = Finding::NotMeasured { why: "the engine syncs where we cannot see".into() };
assert_eq!(f.verdict(), Verdict::NotMeasured);

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Survived

The durable set honoured the ack.

Lost

The durable set did not honour the ack, and coverage was complete enough for that to mean something.

Fields

violations: Vec<Violation>

What was missing or different.

NotMeasured

Never a silent pass, never a false accusation. The check ran but its result is not sound — most often because the witness admitted it cannot see all of the store’s sync activity, so an unobserved sync might have saved the data.

Fields

why: String

Why this could not be measured, in one sentence.

HarnessBroken

The harness is broken: the captured copy was not a usable store, or the teeth control — the run that must pass — did not.

Fields

why: String

What is wrong with the harness.

violations: Vec<Violation>

The violations that proved it.

Implementations

impl Finding

pub fn verdict(&self) -> Verdict

The matching Verdict.

assert_eq!(Finding::Survived.verdict(), Verdict::Survived);

pub fn violations(&self) -> &[Violation]

The violations behind this finding, if any.

assert!(Finding::Survived.violations().is_empty());

Trait Implementations

impl Clone for Finding

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Finding

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

Formats the value using the given formatter.