Struct fidl_fuchsia_blackout_test::ControllerSynchronousProxy

pub struct ControllerSynchronousProxy { /* private fields */ }

Implementations

impl ControllerSynchronousProxy

pub fn new(channel: Channel) -> Self

pub fn into_channel(self) -> Channel

pub fn wait_for_event(&self, deadline: Time) -> Result<ControllerEvent, Error>

Waits until an event arrives and returns it. It is safe for other threads to make concurrent requests while waiting for an event.

pub fn setup( &self, device_label: &str, device_path: Option<&str>, seed: u64, ___deadline: Time ) -> Result<ControllerSetupResult, Error>

Run the setup step for this test. Often, this involves formatting the filesystem of choice onto the block device, and perhaps setting up a base of files to work with.

pub fn test( &self, device_label: &str, device_path: Option<&str>, seed: u64, duration: u64, ___deadline: Time ) -> Result<ControllerTestResult, Error>

Run the test step for this test. This kicks off the load generation algorithm for this test, which will run indefinitely. It’s expected that this load will be interrupted by a power cycle. If the provided duration is non-zero, this protocol will return after approximately that amount of time, but the load will continue to run. If the duration provided is zero, then the test will return when it’s done, which for a lot of normal blackout tests might be never.

pub fn verify( &self, device_label: &str, device_path: Option<&str>, seed: u64, ___deadline: Time ) -> Result<ControllerVerifyResult, Error>

Run the verify step for this test. Most of the time it involves running fsck on the block device and returning the result.

Trait Implementations

impl Debug for ControllerSynchronousProxy

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

Formats the value using the given formatter.

impl SynchronousProxy for ControllerSynchronousProxy

type Proxy = ControllerProxy

The async proxy for the same protocol.

type Protocol = ControllerMarker

The protocol which this Proxy controls.

fn from_channel(inner: Channel) -> Self

Create a proxy over the given channel.

fn into_channel(self) -> Channel

Convert the proxy back into a channel.

fn as_channel(&self) -> &Channel

Get a reference to the proxy’s underlying channel.