Struct Case 

pub struct Case {
    pub id: String,
    pub title: String,
    pub flight: Flight,
    pub reference: PathBuf,
    pub reference_case: Option<String>,
    pub metrics: BTreeMap<String, Metric>,
    pub known_gap: Option<String>,
}

One validation case, read from a TOML file under validation/cases/.

Every metric it reports has to name a tolerance (Loft lesson L79) or say in writing why it is not scored, and the reference it compares against has to carry provenance (L77). The harness checks both before it flies anything.

Fields

id: String

The case’s id, which is also its file name without the extension.

title: String

What the case is for, in one line.

flight: Flight

What is flown and how (Flight).

reference: PathBuf

The reference to compare against, relative to the repository root.

reference_case: Option<String>

Which case of that reference file, when it holds several.

metrics: BTreeMap<String, Metric>

The metrics to compare, each with its tolerance.

known_gap: Option<String>

A limit of hpr’s that this case is known to reach, in writing. The case still runs, and its metrics keep the tolerances they will be held to once the limit is lifted, but nothing is scored: the report shows the case as a gap, with this reason and hpr’s own refusal.

The one gap the harness accepts is hpr’s refusal of a Mach number past its models’ range, which ends at Mach 5 for the normal force and the drag buildup alike (until M1.8b1 the buildup stopped at Mach 1, and Prometheus on its own drag was such a gap). It is checked, not trusted: the reference must itself reach that Mach number, and hpr must refuse the flight with exactly that error. A gap that starts flying fails the run, so it cannot stay excused after it is fixed (Loft lesson L85). No committed case declares one.

Trait Implementations

impl Clone for Case

fn clone(&self) -> Case

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Case

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Case

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Case

fn eq(&self, other: &Case) -> 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 Serialize for Case

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 Case