Struct RunMetadata 

pub struct RunMetadata {

    pub id: String,
    pub started_at: String,
    pub duration_ms: f64,
    pub command: Vec<String>,
    pub test_exit_code: Option<i32>,
    pub integrity: RunIntegrity,
    pub raw_evidence: RawEvidenceMetadata,
    pub isolated_build: Option<bool>,
    pub instrumented_build_cache: Option<InstrumentedBuildCache>,
    pub timings: Option<RunTimings>,
    pub merged: Option<bool>,
    pub parents: Option<Vec<String>>,
    pub source_roots: Option<Vec<String>>,
    pub copy: Option<usize>,
    pub merged_across: Option<Vec<String>>,
}

Fields

id: String

started_at: String

duration_ms: f64

command: Vec<String>

test_exit_code: Option<i32>

integrity: RunIntegrity

raw_evidence: RawEvidenceMetadata

isolated_build: Option<bool>

instrumented_build_cache: Option<InstrumentedBuildCache>

timings: Option<RunTimings>

merged: Option<bool>

parents: Option<Vec<String>>

source_roots: Option<Vec<String>>

The SUPERCOV_SOURCE_ROOTS the run was measured under. It decides what the run measures, so it is part of what the run is, replayed like the command when a later query asks whether the checkout has moved on. The environment of that later query is no guide: it is usually a different shell, and a run judged against roots it was not measured under read as stale the moment it was recorded.

copy: Option<usize>

Which copy of the project the command ran in, where it ran in one: 1 for a run alone, 2 for one started while that copy was in use. It is where what the command wrote is to be found.

merged_across: Option<Vec<String>>

For a merge made with --allow-changed: what differed between the runs merged, files the tests load and configuration. The merge is of tests that ran against those as they were then.

Trait Implementations

impl Clone for RunMetadata

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 RunMetadata

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RunMetadata

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RunMetadata

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RunMetadata

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 RunMetadata