Struct CrateBinary 

pub struct CrateBinary {
    pub name: String,
    pub outcome: Outcome,
    pub seconds: u64,
    pub passed: u64,
    pub failed: u64,
    pub ignored: u64,
    pub filtered_out: u64,
}

One integration test binary of a cargo test run, as its result line stated it.

name is the binary’s source under tests/ without the extension, never the hashed file cargo built, which changes between builds. The counts are the result line’s own (a count the line did not carry is 0), and outcome is decided from them by the rule read_crate_output states: a binary that ran nothing is not a pass.

use majordomus_cli::evidence::{read_crate_output, CrateBinary, Outcome};

let read = read_crate_output(
    "     Running tests/why.rs (target/debug/deps/why-1)\n\
     test result: ok. 1 passed; 0 failed; 2 ignored; 0 measured; 4 filtered out; \
     finished in 0.60s\n",
);
let why: &CrateBinary = &read.binaries[0];
assert_eq!(why.name, "why");
assert_eq!((why.passed, why.failed, why.ignored, why.filtered_out), (1, 0, 2, 4));
assert_eq!(why.seconds, 1, "0.60s rounds to the nearest second");
assert_eq!(why.outcome, Outcome::Skip, "a filtered subset is not the binary's proof");

Fields

name: String

The binary’s name: tests/<name>.rs without the directory and the extension.

outcome: Outcome

What the binary’s result line, read by its counts, says happened.

seconds: u64

finished in rounded to whole seconds; 0 when the line carried none.

passed: u64

Tests that ran and passed.

failed: u64

Tests that ran and failed.

ignored: u64

Tests that were compiled in and not run.

filtered_out: u64

Tests a name filter left out of this run.

Trait Implementations

impl Clone for CrateBinary

fn clone(&self) -> CrateBinary

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CrateBinary

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

Formats the value using the given formatter.

impl Eq for CrateBinary

impl PartialEq for CrateBinary

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