Enum Divergence 

pub enum Divergence {
    Tool {
        index: usize,
        expected: String,
        actual: String,
    },
    Arguments {
        index: usize,
        tool: String,
        expected: Value,
        actual: Value,
    },
    Extra {
        index: usize,
        actual: String,
    },
    Missing {
        index: usize,
        expected: String,
    },
}

How a replayed run departed from its recording.

Variants

Tool

A different tool entirely. The strongest signal there is.

Fields

index: usize

expected: String

actual: String

Arguments

The right tool, different arguments. Worth reporting separately: a model that reads the same file by a different path spelling has not regressed, and grading it as though it had makes replay useless inside a week.

Fields

index: usize

tool: String

expected: Value

actual: Value

Extra

The replay kept going after the recording ran out.

Fields

index: usize

actual: String

Missing

The replay stopped early.

Fields

index: usize

expected: String

Implementations

impl Divergence

pub fn index(&self) -> usize

Where in the call sequence it happened.

pub fn is_structural(&self) -> bool

Whether this changes what the model did rather than how it spelled it.

Only argument differences are ever cosmetic, and only the caller knows whether they are — hence a predicate rather than a filter applied here.

Trait Implementations

impl Clone for Divergence

fn clone(&self) -> Divergence

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Divergence

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Divergence

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Divergence

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Divergence

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 Divergence