Struct Report 

pub struct Report {
    pub harness_version: String,
    pub fast: bool,
    pub cases: Vec<String>,
    pub skipped: Vec<String>,
    pub comparisons: Vec<Comparison>,
    pub gaps: Vec<Gap>,
    pub sources: Vec<Source>,
}

A whole run: every comparison, and what it adds up to.

Fields

harness_version: String

The harness’s version.

fast: bool

Whether the run was --fast.

cases: Vec<String>

The cases it covered, in report order.

skipped: Vec<String>

The locked cases it left out, which only a fast run has.

comparisons: Vec<Comparison>

Every metric compared.

gaps: Vec<Gap>

The cases that ran into a limit of hpr’s they declare, in case order.

sources: Vec<Source>

Where each case’s reference came from, in case order.

Implementations

impl Report

pub fn passed(&self) -> bool

Whether every scored comparison passed.

pub fn failures(&self) -> Vec<&Comparison>

The comparisons that failed.

pub fn not_scored(&self) -> Vec<&Comparison>

The comparisons that were measured but held to no tolerance.

pub fn worst_scored(&self) -> Option<(&Comparison, f64)>

The largest relative difference among the scored comparisons, as a fraction.

pub fn reproduces( &self, committed_markdown: &str, committed_json: &str, ) -> Result<(), NotReproduced>

Whether this run reproduces a committed report, given the text of its latest.md and latest.json.

hpr is bit-identical on one platform, not across three (ADR-015, the validation harness’s decisions), so the numbers are compared at full precision from the JSON, where hpr’s value and the reference’s may each differ from the committed one by 2e-6 or by 1e-7 of itself, whichever is larger. Everything else is compared exactly: the harness version, the cases, what was left out, the sources, each comparison’s case, metric, source, tolerance, verdict and note, and each gap but for the Mach number the integrator narrowed onto 1. The two committed files come from one run on one platform, so latest.md must be latest.json‘s rendering letter for letter, and each committed difference must be its own two values’ difference. A tighter check would assert a cross-platform bit-identity hpr does not claim; comparing the rendered Markdown instead would fail on a platform whose last digit rounds a printed percentage the other way.

Errors

NotReproduced, naming the first difference found, or why the committed JSON does not parse.

pub fn to_markdown(&self) -> String

The report as Markdown: a summary, one table row per gated or not-scored metric, then predicted mode’s rows in their own table.

It carries no date, so a run that changes nothing changes no bytes and the committed report only moves when a number does.

Trait Implementations

impl Clone for Report

fn clone(&self) -> Report

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Report

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Report

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Report

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

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 Report