Enum BenchmarkPolicy 

pub enum BenchmarkPolicy {
    Required,
    RequiredWhen {
        precondition: BenchmarkPrecondition,
    },
    Waived {
        reason: WaiverReason,
    },
}

Whether the capability is a benchmark target. Required is the default and the norm: every executable capability is timed directly and through every transport it is exposed on, with the cases its input type provides.

Variants

Required

Timed directly and through every exposure; coverage fails without a case.

RequiredWhen

Required exactly like Required in a repository where the precondition holds, and reported as inapplicable — never covered, never waived — where it does not. Not a waiver: with the precondition met and no case, the requirement is missing.

Fields

precondition: BenchmarkPrecondition

What the repository must hold.

Waived

Not timed, for the typed reason; coverage reports it as waived, never as covered.

Fields

reason: WaiverReason

Why.

Implementations

impl BenchmarkPolicy

pub fn is_target(self) -> bool

Is the capability a benchmark target at all — required, unconditionally or on a precondition? Only a waiver says no.

A conditional requirement is a target even where its precondition does not hold: being inapplicable to one repository is not the same as being waived, and coverage only decides applicability after this has said the capability is timed at all.

use majordomus_cli::capability::{BenchmarkPolicy, BenchmarkPrecondition, WaiverReason};

assert!(BenchmarkPolicy::Required.is_target());

// conditional, and still a target: the precondition decides applicability, not this
let conditional = BenchmarkPolicy::RequiredWhen {
    precondition: BenchmarkPrecondition::PlanHoldsAnIssue,
};
assert!(conditional.is_target());

// only a waiver takes a capability out of the benchmark set
let waived = BenchmarkPolicy::Waived { reason: WaiverReason::PublishedHistory };
assert!(!waived.is_target());

Trait Implementations

impl Clone for BenchmarkPolicy

fn clone(&self) -> BenchmarkPolicy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for BenchmarkPolicy

impl Debug for BenchmarkPolicy

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BenchmarkPolicy

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for BenchmarkPolicy

impl JsonSchema for BenchmarkPolicy

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 BenchmarkPolicy

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

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 BenchmarkPolicy