Struct FakeClockControlSynchronousProxy

pub struct FakeClockControlSynchronousProxy { /* private fields */ }

Implementations

impl FakeClockControlSynchronousProxy

pub fn new(channel: Channel) -> Self

pub fn into_channel(self) -> Channel

pub fn wait_for_event( &self, deadline: MonotonicInstant, ) -> Result<FakeClockControlEvent, 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 advance( &self, increment: &Increment, ___deadline: MonotonicInstant, ) -> Result<FakeClockControlAdvanceResult, Error>

Advances the fake clock increment once. Returns ZX_ERR_INVALID_ARGS if the provided increment is invalid (such as a badly formed RandomRange). Returns ZX_ERR_ACCESS_DENIED if called while the FakeClock is free-running.

pub fn resume_with_increments( &self, real: i64, increment: &Increment, ___deadline: MonotonicInstant, ) -> Result<FakeClockControlResumeWithIncrementsResult, Error>

Resumes free-running increments on the fake clock. real is the period based on the real monotonic clock over which increment is going to be applied. Returns ZX_ERR_INVALID_ARGS if the provided increment is invalid (such as a badly formed RandomRange).

pub fn add_stop_point( &self, deadline_id: &DeadlineId, event_type: DeadlineEventType, on_stop: EventPair, ___deadline: MonotonicInstant, ) -> Result<FakeClockControlAddStopPointResult, Error>

Registers interest in a deadline event. deadline_id and event_type identify the named deadline and the event associated with the deadline. When the event occurs, FakeClock will signal EVENTPAIR_SIGNALED on on_stop. If time is free-running, the clock is stopped. Closing the eventpair cancels interest in the deadline. If the eventpair is closed when a deadline is reached, time is not stopped. Note that only events that occur after AddStopPoint is called are matched. In addition, the EXPIRED event is always reported, even if the component that created the deadline does not act on the deadline expiration.

The intended use is to set a stop point using AddStopPoint, resume running time with ResumeWithIncrements, then wait for the stop point to occur using the on_stop eventpair. Setting a stop point is only allowed while time is stopped. If time is free running when this method is invoked ZX_ERR_ACCESS_DENIED is returned. If a stop point is already registered for the same event, ZX_ALREADY_BOUND is returned.

pub fn pause(&self, ___deadline: MonotonicInstant) -> Result<(), Error>

Pauses free-running increments on the fake clock.

pub fn ignore_named_deadline( &self, deadline_id: &DeadlineId, ___deadline: MonotonicInstant, ) -> Result<(), Error>

Instructs the fake clock to make deadlines named deadline_id never expire. This is a no-op if deadline_id is already in the ignored set.

Trait Implementations

impl Debug for FakeClockControlSynchronousProxy

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

Formats the value using the given formatter.

impl SynchronousProxy for FakeClockControlSynchronousProxy

type Proxy = FakeClockControlProxy

The async proxy for the same protocol.

type Protocol = FakeClockControlMarker

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.

fn is_closed(&self) -> Result<bool, Status>

Returns true if the proxy has received the PEER_CLOSED signal.