Struct Scenario 

pub struct Scenario<C> {
    pub config: Config,
    pub nodes: Vec<NodeId>,
    pub steps: Vec<(Duration, Step<C>)>,
    pub horizon: Duration,
}

A whole run, as data.

Executing one twice produces the same trace, by the determinism the simulator already guarantees: the configuration carries the seed, and nothing else in a run is drawn from anywhere but the generator that seed starts.

Fields

config: Config

Network conditions and the seed. The seed lives here rather than beside it, because it is what the simulator already treats as part of a configuration.

nodes: Vec<NodeId>

The processes in the run.

steps: Vec<(Duration, Step<C>)>

What happens, and when — each time measured from the start of the run, in non-decreasing order. Two steps at the same time happen in the order given, with nothing dispatched between them.

horizon: Duration

How long to run after the last step.

Implementations

impl<C> Scenario<C>

pub fn new(config: Config, nodes: impl IntoIterator<Item = NodeId>) -> Self

An empty run over nodes with no steps and no horizon.

pub fn at(self, at: Duration, step: Step<C>) -> Self

Add a step at at, measured from the start of the run.

Panics

If at precedes the last step already added. A description is executed in the order it is written, and the clock does not go backwards, so an out-of-order step would silently happen at the wrong moment rather than where it reads.

pub fn horizon(self, horizon: Duration) -> Self

Run until horizon after the start.

pub fn end(&self) -> Duration

The time the run ends: the horizon, or the last step if that is later.

impl<C: Clone> Scenario<C>

pub fn is_well_formed(&self) -> bool

where C: PartialEq,

Whether every Resume has a Suspend and every Restart a Crash, in order.

A scenario written by hand can be wrong; one produced by a reduction cannot, because every reduction repairs. Exposed so a test can say which it is holding.

impl<C: Debug> Scenario<C>

pub fn to_rust(&self, name: &str) -> String

Render as Rust that reconstructs this scenario, as a function named name.

The end of a reduction should be something to paste, not something to transcribe. The command is rendered with its Debug, which is valid Rust for the derived implementations this repository’s commands all use, provided their variants are in scope where the output is pasted.

Trait Implementations

impl<C: Clone> Clone for Scenario<C>

fn clone(&self) -> Scenario<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Debug> Debug for Scenario<C>

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

Formats the value using the given formatter.

impl<C: PartialEq> PartialEq for Scenario<C>

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