Struct Check 

pub struct Check {
    pub platform: String,
    pub baseline_found: bool,
    pub lines: Vec<CheckLine>,
    pub new_targets: Vec<String>,
    pub stale_baseline_targets: Vec<String>,
    pub registry_changed: bool,
    pub baseline_host: String,
    pub current_host: String,
    pub current_load: String,
    pub baseline_load: String,
    pub comparable: bool,
    pub budgets: Vec<BudgetLine>,
}

The outcome of a check.

Fields

platform: String

The platform compared.

baseline_found: bool

Was a baseline for this platform found?

lines: Vec<CheckLine>

Every comparison.

new_targets: Vec<String>

Targets the run measured and the baseline lacks.

stale_baseline_targets: Vec<String>

Targets the baseline has and the run did not measure (renamed, removed, or filtered).

registry_changed: bool

Did the registry fingerprint change since the baseline?

baseline_host: String

The host the baseline was recorded on (empty when unknown).

current_host: String

The host this run measured on.

current_load: String

The 1-minute load average this run was measured under (empty when unknown).

baseline_load: String

The 1-minute load average the baseline was recorded under (empty when unknown).

comparable: bool

Was the baseline recorded on this host? When not, every line is reported and none fails: wall-clock numbers of two machines are not a regression of either.

budgets: Vec<BudgetLine>

Every measurement a budget of the policy bounds, with its verdict. Judged with or without a baseline, and on every host: a bound is absolute.

Implementations

impl Check

pub fn compare( run: &ResultDocument, baseline: Option<&ResultDocument>, policy: &Policy, ) -> Self

Compare a run with its platform’s baseline under the policy.

pub fn over_budget(&self) -> bool

Is any measurement over its budget? Unlike a regression, this needs no comparable baseline.

use majordomus_cli::bench::baseline::{Check, Policy};
use majordomus_cli::bench::results::{Provenance, ResultDocument};

// a run that measured nothing a budget bounds is over none, with or without a baseline
let run = ResultDocument {
    schema: majordomus_cli::bench::RESULT_SCHEMA.into(),
    finished_at: "2026-10-12T00:00:00Z".into(),
    profile: "ci".into(),
    provenance: Provenance {
        commit: None,
        dirty: false,
        build_profile: "debug".into(),
        os: "os".into(),
        arch: "arch".into(),
        version: "0".into(),
        registry_fingerprint: "f".into(),
        host: "host/1".into(),
        load: String::new(),
    },
    results: Vec::new(),
};
let check = Check::compare(&run, None, &Policy::default());
assert!(check.budgets.is_empty());
assert!(!check.over_budget() && !check.failed());

pub fn measured_under(&self) -> String

What every verdict of this check was measured under: the runner and its 1-minute load average, and the baseline’s when there is one. A timing verdict is a statement about a machine as much as about a change, so the report never gives one without it.

use majordomus_cli::bench::baseline::{Check, Policy};
use majordomus_cli::bench::results::{Provenance, ResultDocument};

let run = ResultDocument {
    schema: majordomus_cli::bench::RESULT_SCHEMA.into(),
    finished_at: "2026-10-16T00:00:00Z".into(),
    profile: "ci".into(),
    provenance: Provenance {
        commit: None,
        dirty: false,
        build_profile: "debug".into(),
        os: "os".into(),
        arch: "arch".into(),
        version: "0".into(),
        registry_fingerprint: "f".into(),
        host: "runner/4".into(),
        load: "31.70".into(),
    },
    results: Vec::new(),
};
let check = Check::compare(&run, None, &Policy::default());
assert_eq!(check.measured_under(), "runner runner/4, load 31.70");

pub fn failed(&self) -> bool

Anything over its budget, or any FAIL on a comparable baseline? A baseline from another host never fails a run: its lines are reported only. A budget is absolute, and fails on any host.

pub fn render(&self) -> String

The human report.

Trait Implementations

impl Clone for Check

fn clone(&self) -> Check

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Check

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Check

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Check

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 PartialEq for Check

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

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 Check