Struct async_speed_limit::clock::ManualClock

pub struct ManualClock(_);

A Clock where the passage of time can be manually controlled.

This type is mainly used for testing behavior of speed limiter only.

This clock only supports up to 2⁶⁴ ns (about 584.5 years).

Examples

use async_speed_limit::clock::{Clock, ManualClock, Nanoseconds};

let clock = ManualClock::new();
assert_eq!(clock.now(), Nanoseconds(0));
clock.set_time(Nanoseconds(1_000_000_000));
assert_eq!(clock.now(), Nanoseconds(1_000_000_000));

Implementations

impl ManualClock

pub fn new() -> Self

Creates a new clock with time set to 0.

pub fn set_time(&self, time: Nanoseconds)

Set the current time of this clock to the given value.

Panics

Since now() must be monotonically increasing, if the new time is less than the previous time, this function will panic.

Trait Implementations

impl Clock for ManualClock

type Instant = Nanoseconds

Type to represent a point of time.

type Delay = ManualDelay

Future type returned by sleep().

fn now(&self) -> Self::Instant

Returns the current time instant. It should be monotonically increasing, but not necessarily high-precision or steady.

fn sleep(&self, dur: Duration) -> Self::Delay

Asynchronously sleeps the current task for the given duration.

impl Clone for ManualClock

fn clone(&self) -> ManualClock

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ManualClock

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

Formats the value using the given formatter.

impl Default for ManualClock

fn default() -> ManualClock

Returns the “default value” for a type.