tox 0.0.5

Implementation of toxcore in pure Rust - P2P, distributed, encrypted, easy to use DHT-based network.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

//! Functions to work with time

use std::time::{Duration, SystemTime, Instant, UNIX_EPOCH};

#[cfg(test)]
use tokio_timer::clock;
#[cfg(test)]
use tokio_timer::clock::Now;

/// Return number of seconds that have elapsed since Unix epoch.
pub fn unix_time(time: SystemTime) -> u64 {
    let since_the_epoch = time.duration_since(UNIX_EPOCH)
        .expect("Current time is earlier than Unix epoch");
    since_the_epoch.as_secs()
}

/// Returns an `Instant` corresponding to "now". Should be used instead of
/// `tokio_timer::clock::now()` to have zero cost mocked time.
#[cfg(test)]
pub fn clock_now() -> Instant {
    clock::now()
}

/// Returns an `Instant` corresponding to "now". Should be used instead of
/// `tokio_timer::clock::now()` to have zero cost mocked time.
#[cfg(not(test))]
pub fn clock_now() -> Instant {
    Instant::now()
}

/// Returns the amount of time elapsed since this instant was created. Should be
/// used instead of `Instant::elapsed` in order to work with mocked
/// `tokio_timer::clock::now()`.
pub fn clock_elapsed(time: Instant) -> Duration {
    clock_now() - time
}

/// Constant time mock for `tokio_timer::clock::now()`
#[cfg(test)]
pub struct ConstNow(pub Instant);

#[cfg(test)]
impl Now for ConstNow {
    fn now(&self) -> Instant {
        self.0
    }
}

#[cfg(test)]
pub mod tests {
    use super::*;

    use tokio_executor;
    use tokio_timer::clock::*;

    #[test]
    fn const_elapsed() {
        let now = clock_now();
        let duration = Duration::from_secs(42);

        let clock = Clock::new_with_now(ConstNow(now + duration));
        let mut enter = tokio_executor::enter().unwrap();

        with_default(&clock, &mut enter, |_| {
            let elapsed = clock_elapsed(now);
            assert_eq!(elapsed, duration);
        });
    }
}