Struct Case 

pub struct Case { /* private fields */ }

One test: what it proves, what it needs, the page it shows and the body that drives it. Built by a #[day::test] function each time the test runs, so the signals a page and its drive share are fresh per run; the registry names it after that function.

Implementations

impl Case

pub fn new() -> Self

A GUI case: a page the app’s test host shows while the case runs, and a drive against it.

pub fn headless() -> Self

A test with no page: app logic run inside the app’s own environment.

pub fn timeout(self, secs: f64) -> Self

How long the case may take, page and drive together, before it fails as timed out. Unset, the run’s default applies (30 s, or what day test --case-timeout says).

pub fn proves(self, kind: &str) -> Self

The piece kind this case is the proof of (kinds::BUTTON); a pass marks the kind on this toolkit in the coverage tables.

pub fn proves_cap(self, cap: Cap) -> Self

The capability this case proves.

pub fn proves_modifier(self, modifier: &str) -> Self

The Decorate modifier this case proves ("padding").

pub fn proves_duty(self, duty: &str) -> Self

The toolkit duty this case proves ("set_input_traits").

pub fn requires(self, cap: Cap) -> Self

A capability the case needs; where the toolkit answers Unsupported the case is skipped with that reason rather than failed. The one way a case adapts to a toolkit.

pub fn requires_support(self, what: &str, support: fn() -> Support) -> Self

A piece’s own support the case needs (day_piece_map::support), named for the skip reason: where it answers Unsupported the case is skipped, as for Case::requires. For a piece realized only where its platform ships the widget.

pub fn missing_support(&self) -> Option<String>

The first support this case needs that the running toolkit lacks, named.

pub fn page<P: Piece>(self, page: impl Fn() -> P + 'static) -> Self

The page the app shows for this case; any piece.

pub fn shot(self, name: &str) -> Self

A capture taken before the drive runs, once the page is shown.

pub fn drive<F>(self, body: impl Fn(Drive) -> F + 'static) -> Self

where F: Future<Output = TestResult> + 'static,

The drive: an async body over a Drive, awaiting each step so the app’s main loop runs between them (a transition settles, a capture paints) as it does between a script’s steps.

pub fn run<F>(self, body: impl Fn(Drive) -> F + 'static) -> Self

where F: Future<Output = TestResult> + 'static,

Case::drive under the name a headless test reads better with.

pub fn name(&self) -> &str

The name the registry gave the case: its function’s, hyphenated. Empty for a case built outside the registry.

pub fn timeout_secs(&self) -> Option<f64>

The case’s own time limit, if it set one.

pub fn kind(&self) -> TestKind

pub fn proves_keys(&self) -> &[String]

The kind:, cap: and duty: keys this case proves, in the matrices’ own spelling.

pub fn requirements(&self) -> &[Cap]

pub fn shots(&self) -> &[String]

The captures to take before the drive.

pub fn build_page(&self) -> Option<AnyPiece>

Build the case’s page, if it has one.

pub fn run_body( &self, drive: Drive, ) -> Pin<Box<dyn Future<Output = TestResult>>>

Run the body over drive; a case with no body passes once its page showed.

Trait Implementations

impl Clone for Case

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Case

fn default() -> Self

Returns the “default value” for a type.