Struct FakeClockControlProxy

pub struct FakeClockControlProxy { /* private fields */ }

Implementations

impl FakeClockControlProxy

pub fn new(channel: AsyncChannel) -> Self

Create a new Proxy for fuchsia.testing/FakeClockControl.

pub fn take_event_stream(&self) -> FakeClockControlEventStream

Get a Stream of events from the remote end of the protocol.

Panics

Panics if the event stream was already taken.

pub fn advance( &self, increment: &Increment, ) -> QueryResponseFut<FakeClockControlAdvanceResult, DefaultFuchsiaResourceDialect>

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, ) -> QueryResponseFut<FakeClockControlResumeWithIncrementsResult, DefaultFuchsiaResourceDialect>

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, ) -> QueryResponseFut<FakeClockControlAddStopPointResult, DefaultFuchsiaResourceDialect>

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) -> QueryResponseFut<(), DefaultFuchsiaResourceDialect>

Pauses free-running increments on the fake clock.

pub fn ignore_named_deadline( &self, deadline_id: &DeadlineId, ) -> QueryResponseFut<(), DefaultFuchsiaResourceDialect>

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 Clone for FakeClockControlProxy

fn clone(&self) -> FakeClockControlProxy

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for FakeClockControlProxy

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

Formats the value using the given formatter.

impl FakeClockControlProxyInterface for FakeClockControlProxy

type AdvanceResponseFut = QueryResponseFut<Result<(), i32>>

type ResumeWithIncrementsResponseFut = QueryResponseFut<Result<(), i32>>

type AddStopPointResponseFut = QueryResponseFut<Result<(), i32>>

type PauseResponseFut = QueryResponseFut<()>

type IgnoreNamedDeadlineResponseFut = QueryResponseFut<()>

fn advance(&self, increment: &Increment) -> Self::AdvanceResponseFut

fn resume_with_increments( &self, real: i64, increment: &Increment, ) -> Self::ResumeWithIncrementsResponseFut

fn add_stop_point( &self, deadline_id: &DeadlineId, event_type: DeadlineEventType, on_stop: EventPair, ) -> Self::AddStopPointResponseFut

fn pause(&self) -> Self::PauseResponseFut

fn ignore_named_deadline( &self, deadline_id: &DeadlineId, ) -> Self::IgnoreNamedDeadlineResponseFut

impl Proxy for FakeClockControlProxy

type Protocol = FakeClockControlMarker

The protocol which this Proxy controls.

fn from_channel(inner: AsyncChannel) -> Self

Create a proxy over the given channel.

fn into_channel(self) -> Result<AsyncChannel, Self>

Attempt to convert the proxy back into a channel.

fn as_channel(&self) -> &AsyncChannel

Get a reference to the proxy’s underlying channel.

fn into_client_end(self) -> Result<ClientEnd<Self::Protocol>, Self>

Attempt to convert the proxy back into a client end.

fn is_closed(&self) -> bool

Returns true if the proxy has received the PEER_CLOSED signal.

fn on_closed(&self) -> OnSignals<'_, Unowned<'_, Handle>>

Returns a future that completes when the proxy receives the PEER_CLOSED signal.