Struct diem_time_service::mock::MockTimeService

pub struct MockTimeService { /* private fields */ }

A TimeService that simulates time and allows for fine-grained control over advancing time and waking up sleeping tasks.

Auto Advance

MockTimeService has the option to auto advance time when new Sleeps are crated. When we’re auto advancing, new Sleeps are immediately resolved and the simulation time is advanced to the wait deadline. New Sleeps whose deadlines are after the auto advance deadline will be pending and must be manually woken by the MockTimeService::advance_{..} methods.

Implementations

impl MockTimeService

pub fn new() -> Self

Create a new MockTimeService with no auto advance. Time will only advance by manually calling the MockTimeService::advance_{..} methods.

pub fn new_auto_advance() -> Self

Create a new MockTimeService that will auto advance forever.

pub fn new_auto_advance_for(deadline: Duration) -> Self

Create a new MockTimeService that will auto advance until the simulation time passes deadline.

pub fn num_waiters(&self) -> usize

Return the number of pending Sleep waiters.

pub fn advance_next(&self) -> Option<Duration>

Advance time to the next pending waiter, wake it up, and return the wake time, or None if there are no waiters.

pub fn advance(&self, duration: Duration) -> usize

Advance time by duration and wake any pending waiters whose sleep has expired. Return the number of waiters that we woke up.

pub fn advance_secs(&self, duration: u64) -> usize

Advance time by duration seconds. See advance.

pub fn advance_ms(&self, duration: u64) -> usize

Advance time by duration milliseconds. See advance.

pub async fn advance_next_async(&self) -> Option<Duration>

Advance time to the next pending waiter, wake it up, and return the wake time, or None if there are no waiters.

Yields to the executor to run any freshly awoken tasks (which might also create more Sleep futures).

pub async fn advance_async(&self, duration: Duration) -> usize

Advance time by duration and wake any pending waiters whose sleep has expired. Return the number of waiters that we woke up.

Yields to the executor to run any freshly awoken tasks (which might also create more Sleep futures).

pub async fn advance_secs_async(&self, duration: u64) -> usize

Advance time by duration seconds. See advance_async.

pub async fn advance_ms_async(&self, duration: u64) -> usize

Advance time by duration milliseconds. See advance_async.

Trait Implementations

impl Clone for MockTimeService

fn clone(&self) -> MockTimeService

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MockTimeService

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

Formats the value using the given formatter.

impl From<MockTimeService> for TimeService

fn from(v: MockTimeService) -> TimeService

Converts to this type from the input type.

impl TimeServiceTrait for MockTimeService

fn now(&self) -> Instant

Query a monotonically nondecreasing clock. Returns an opaque type that can only be compared to other Instants, i.e., this is a monotonic relative time whereas now_unix_time is a non-monotonic absolute time.

fn now_unix_time(&self) -> Duration

Query the current unix timestamp as a Duration.

fn sleep(&self, duration: Duration) -> Sleep

Return a Future that waits until duration has passed.

fn sleep_blocking(&self, duration: Duration)

Blocks the current thread until duration time has passed.

fn now_secs(&self) -> u64

Query the current unix timestamp in seconds.

fn sleep_until(&self, deadline: Instant) -> Sleep

Return a Future that waits until the deadline.

fn interval(&self, period: Duration) -> Interval

Creates a new Interval that yields with interval of period. The first tick completes immediately. An interval will tick indefinitely.

fn interval_at(&self, start: Instant, period: Duration) -> Interval

Creates a new Interval that yields with interval of period. The first tick completes after the start deadline. An interval will tick indefinitely.

fn timeout<F: Future>(&self, duration: Duration, future: F) -> Timeout<F>

Require a Future to complete before the specified duration has elapsed.

fn timeout_at<F: Future>(&self, deadline: Instant, future: F) -> Timeout<F>

Require a Future to complete before the deadline.

impl TryInto<MockTimeService> for TimeService

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into( self ) -> Result<MockTimeService, <Self as TryInto<MockTimeService>>::Error>

Performs the conversion.