tokio-rs/tokio
1
0
Fork 0
mirror of https://github.com/tokio-rs/tokio.git synced 2026-08-24 00:00:11 +02:00
Code Issues Packages Projects Releases Wiki Activity

timer: finish updating timer (#1222)

Browse Source 
* timer: restructure feature flags
* update timer tests
* Add `async-traits` to CI

This also disables a buggy `threadpool` test. This test should be fixed in the future.

Refs #1225
This commit is contained in:
Carl Lerche
2019-06-30 08:48:53 -07:00
committed by GitHub
parent 8e7d8af588
commit b2c777846e
27 changed files with 786 additions and 755 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tokio-timer/tests/delay.rs
+242 -198
View File
@@ -1,186 +1,199 @@
#![deny(warnings, rust_2018_idioms)]
#![cfg(feature = "broken")]
#![feature(async_await)]
mod support;
use crate::support::*;
use futures::Future;
use std::time::{Duration, Instant};
use tokio_test::task::MockTask;
use tokio_test::{assert_pending, assert_ready, clock};
use tokio_timer::timer::Handle;
use tokio_timer::*;
use tokio_timer::Delay;
use std::time::{Duration, Instant};
#[test]
fn immediate_delay() {
mocked(|timer, time| {
let mut task = MockTask::new();
clock::mock(|clock| {
// Create `Delay` that elapsed immediately.
let mut delay = Delay::new(time.now());
let mut delay = Delay::new(clock.now());
// Ready!
assert_ready!(delay);
assert_ready!(task.poll(&mut delay));
// Turn the timer, it runs for the elapsed time
turn(timer, ms(1000));
clock.turn_for(ms(1000));
// The time has not advanced. The `turn` completed immediately.
assert_eq!(time.advanced(), ms(1000));
assert_eq!(clock.advanced(), ms(1000));
});
}
#[test]
fn delayed_delay_level_0() {
let mut task = MockTask::new();
for &i in &[1, 10, 60] {
mocked(|timer, time| {
clock::mock(|clock| {
// Create a `Delay` that elapses in the future
let mut delay = Delay::new(time.now() + ms(i));
let mut delay = Delay::new(clock.now() + ms(i));
// The delay has not elapsed.
assert_not_ready!(delay);
assert_pending!(task.poll(&mut delay));
turn(timer, ms(1000));
assert_eq!(time.advanced(), ms(i));
clock.turn();
assert_eq!(clock.advanced(), ms(i));
assert_ready!(delay);
assert_ready!(task.poll(&mut delay));
});
}
}
#[test]
fn sub_ms_delayed_delay() {
mocked(|timer, time| {
let mut task = MockTask::new();
clock::mock(|clock| {
for _ in 0..5 {
let deadline = time.now() + Duration::from_millis(1) + Duration::new(0, 1);
let deadline = clock.now() + Duration::from_millis(1) + Duration::new(0, 1);
let mut delay = Delay::new(deadline);
assert_not_ready!(delay);
assert_pending!(task.poll(&mut delay));
turn(timer, None);
assert_ready!(delay);
clock.turn();
assert_ready!(task.poll(&mut delay));
assert!(time.now() >= deadline);
assert!(clock.now() >= deadline);
time.advance(Duration::new(0, 1));
clock.advance(Duration::new(0, 1));
}
});
}
#[test]
fn delayed_delay_wrapping_level_0() {
mocked(|timer, time| {
turn(timer, ms(5));
assert_eq!(time.advanced(), ms(5));
let mut task = MockTask::new();
let mut delay = Delay::new(time.now() + ms(60));
clock::mock(|clock| {
clock.turn_for(ms(5));
assert_eq!(clock.advanced(), ms(5));
assert_not_ready!(delay);
let mut delay = Delay::new(clock.now() + ms(60));
turn(timer, None);
assert_eq!(time.advanced(), ms(64));
assert_not_ready!(delay);
assert_pending!(task.poll(&mut delay));
turn(timer, None);
assert_eq!(time.advanced(), ms(65));
clock.turn();
assert_eq!(clock.advanced(), ms(64));
assert_pending!(task.poll(&mut delay));
assert_ready!(delay);
clock.turn();
assert_eq!(clock.advanced(), ms(65));
assert_ready!(task.poll(&mut delay));
});
}
#[test]
fn timer_wrapping_with_higher_levels() {
mocked(|timer, time| {
let mut task = MockTask::new();
clock::mock(|clock| {
// Set delay to hit level 1
let mut s1 = Delay::new(time.now() + ms(64));
assert_not_ready!(s1);
let mut s1 = Delay::new(clock.now() + ms(64));
assert_pending!(task.poll(&mut s1));
// Turn a bit
turn(timer, ms(5));
clock.turn_for(ms(5));
// Set timeout such that it will hit level 0, but wrap
let mut s2 = Delay::new(time.now() + ms(60));
assert_not_ready!(s2);
let mut s2 = Delay::new(clock.now() + ms(60));
assert_pending!(task.poll(&mut s2));
// This should result in s1 firing
turn(timer, None);
assert_eq!(time.advanced(), ms(64));
clock.turn();
assert_eq!(clock.advanced(), ms(64));
assert_ready!(s1);
assert_not_ready!(s2);
assert_ready!(task.poll(&mut s1));
assert_pending!(task.poll(&mut s2));
turn(timer, None);
assert_eq!(time.advanced(), ms(65));
clock.turn();
assert_eq!(clock.advanced(), ms(65));
assert_ready!(s2);
assert_ready!(task.poll(&mut s2));
});
}
#[test]
fn delay_with_deadline_in_past() {
mocked(|timer, time| {
let mut task = MockTask::new();
clock::mock(|clock| {
// Create `Delay` that elapsed immediately.
let mut delay = Delay::new(time.now() - ms(100));
let mut delay = Delay::new(clock.now() - ms(100));
// Even though the delay expires in the past, it is not ready yet
// because the timer must observe it.
assert_ready!(delay);
assert_ready!(task.poll(&mut delay));
// Turn the timer, it runs for the elapsed time
turn(timer, ms(1000));
clock.turn_for(ms(1000));
// The time has not advanced. The `turn` completed immediately.
assert_eq!(time.advanced(), ms(1000));
assert_eq!(clock.advanced(), ms(1000));
});
}
#[test]
fn delayed_delay_level_1() {
mocked(|timer, time| {
let mut task = MockTask::new();
clock::mock(|clock| {
// Create a `Delay` that elapses in the future
let mut delay = Delay::new(time.now() + ms(234));
let mut delay = Delay::new(clock.now() + ms(234));
// The delay has not elapsed.
assert_not_ready!(delay);
assert_pending!(task.poll(&mut delay));
// Turn the timer, this will wake up to cascade the timer down.
turn(timer, ms(1000));
assert_eq!(time.advanced(), ms(192));
clock.turn_for(ms(1000));
assert_eq!(clock.advanced(), ms(192));
// The delay has not elapsed.
assert_not_ready!(delay);
assert_pending!(task.poll(&mut delay));
// Turn the timer again
turn(timer, ms(1000));
assert_eq!(time.advanced(), ms(234));
clock.turn_for(ms(1000));
assert_eq!(clock.advanced(), ms(234));
// The delay has elapsed.
assert_ready!(delay);
assert_ready!(task.poll(&mut delay));
});
mocked(|timer, time| {
clock::mock(|clock| {
// Create a `Delay` that elapses in the future
let mut delay = Delay::new(time.now() + ms(234));
let mut delay = Delay::new(clock.now() + ms(234));
// The delay has not elapsed.
assert_not_ready!(delay);
assert_pending!(task.poll(&mut delay));
// Turn the timer with a smaller timeout than the cascade.
turn(timer, ms(100));
assert_eq!(time.advanced(), ms(100));
clock.turn_for(ms(100));
assert_eq!(clock.advanced(), ms(100));
assert_not_ready!(delay);
assert_pending!(task.poll(&mut delay));
// Turn the timer, this will wake up to cascade the timer down.
turn(timer, ms(1000));
assert_eq!(time.advanced(), ms(192));
clock.turn_for(ms(1000));
assert_eq!(clock.advanced(), ms(192));
// The delay has not elapsed.
assert_not_ready!(delay);
assert_pending!(task.poll(&mut delay));
// Turn the timer again
turn(timer, ms(1000));
assert_eq!(time.advanced(), ms(234));
clock.turn_for(ms(1000));
assert_eq!(clock.advanced(), ms(234));
// The delay has elapsed.
assert_ready!(delay);
assert_ready!(task.poll(&mut delay));
});
}
@@ -191,77 +204,83 @@ fn creating_delay_outside_of_context() {
// This creates a delay outside of the context of a mock timer. This tests
// that it will still expire.
let mut delay = Delay::new(now + ms(500));
let mut task = MockTask::new();
mocked_with_now(now, |timer, time| {
clock::mock_at(now, |clock| {
// This registers the delay with the timer
assert_not_ready!(delay);
assert_pending!(task.poll(&mut delay));
// Wait some time... the timer is cascading
turn(timer, ms(1000));
assert_eq!(time.advanced(), ms(448));
clock.turn_for(ms(1000));
assert_eq!(clock.advanced(), ms(448));
assert_not_ready!(delay);
assert_pending!(task.poll(&mut delay));
turn(timer, ms(1000));
assert_eq!(time.advanced(), ms(500));
clock.turn_for(ms(1000));
assert_eq!(clock.advanced(), ms(500));
// The delay has elapsed
assert_ready!(delay);
assert_ready!(task.poll(&mut delay));
});
}
#[test]
fn concurrently_set_two_timers_second_one_shorter() {
mocked(|timer, time| {
let mut delay1 = Delay::new(time.now() + ms(500));
let mut delay2 = Delay::new(time.now() + ms(200));
let mut t1 = MockTask::new();
let mut t2 = MockTask::new();
clock::mock(|clock| {
let mut delay1 = Delay::new(clock.now() + ms(500));
let mut delay2 = Delay::new(clock.now() + ms(200));
// The delay has not elapsed
assert_not_ready!(delay1);
assert_not_ready!(delay2);
assert_pending!(t1.poll(&mut delay1));
assert_pending!(t2.poll(&mut delay2));
// Delay until a cascade
turn(timer, None);
assert_eq!(time.advanced(), ms(192));
clock.turn();
assert_eq!(clock.advanced(), ms(192));
// Delay until the second timer.
turn(timer, None);
assert_eq!(time.advanced(), ms(200));
clock.turn();
assert_eq!(clock.advanced(), ms(200));
// The shorter delay fires
assert_ready!(delay2);
assert_not_ready!(delay1);
assert_ready!(t2.poll(&mut delay2));
assert_pending!(t1.poll(&mut delay1));
turn(timer, None);
assert_eq!(time.advanced(), ms(448));
clock.turn();
assert_eq!(clock.advanced(), ms(448));
assert_not_ready!(delay1);
assert_pending!(t1.poll(&mut delay1));
// Turn again, this time the time will advance to the second delay
turn(timer, None);
assert_eq!(time.advanced(), ms(500));
clock.turn();
assert_eq!(clock.advanced(), ms(500));
assert_ready!(delay1);
assert_ready!(t1.poll(&mut delay1));
})
}
#[test]
fn short_delay() {
mocked(|timer, time| {
let mut task = MockTask::new();
clock::mock(|clock| {
// Create a `Delay` that elapses in the future
let mut delay = Delay::new(time.now() + ms(1));
let mut delay = Delay::new(clock.now() + ms(1));
// The delay has not elapsed.
assert_not_ready!(delay);
assert_pending!(task.poll(&mut delay));
// Turn the timer, but not enough time will go by.
turn(timer, None);
clock.turn();
// The delay has elapsed.
assert_ready!(delay);
assert_ready!(task.poll(&mut delay));
// The time has advanced to the point of the delay elapsing.
assert_eq!(time.advanced(), ms(1));
assert_eq!(clock.advanced(), ms(1));
})
}
@@ -269,27 +288,29 @@ fn short_delay() {
fn sorta_long_delay() {
const MIN_5: u64 = 5 * 60 * 1000;
mocked(|timer, time| {
let mut task = MockTask::new();
clock::mock(|clock| {
// Create a `Delay` that elapses in the future
let mut delay = Delay::new(time.now() + ms(MIN_5));
let mut delay = Delay::new(clock.now() + ms(MIN_5));
// The delay has not elapsed.
assert_not_ready!(delay);
assert_pending!(task.poll(&mut delay));
let cascades = &[262_144, 262_144 + 9 * 4096, 262_144 + 9 * 4096 + 15 * 64];
for &elapsed in cascades {
turn(timer, None);
assert_eq!(time.advanced(), ms(elapsed));
clock.turn();
assert_eq!(clock.advanced(), ms(elapsed));
assert_not_ready!(delay);
assert_pending!(task.poll(&mut delay));
}
turn(timer, None);
assert_eq!(time.advanced(), ms(MIN_5));
clock.turn();
assert_eq!(clock.advanced(), ms(MIN_5));
// The delay has elapsed.
assert_ready!(delay);
assert_ready!(task.poll(&mut delay));
})
}
@@ -297,12 +318,14 @@ fn sorta_long_delay() {
fn very_long_delay() {
const MO_5: u64 = 5 * 30 * 24 * 60 * 60 * 1000;
mocked(|timer, time| {
let mut task = MockTask::new();
clock::mock(|clock| {
// Create a `Delay` that elapses in the future
let mut delay = Delay::new(time.now() + ms(MO_5));
let mut delay = Delay::new(clock.now() + ms(MO_5));
// The delay has not elapsed.
assert_not_ready!(delay);
assert_pending!(task.poll(&mut delay));
let cascades = &[
12_884_901_888,
@@ -312,59 +335,65 @@ fn very_long_delay() {
];
for &elapsed in cascades {
turn(timer, None);
assert_eq!(time.advanced(), ms(elapsed));
clock.turn();
assert_eq!(clock.advanced(), ms(elapsed));
assert_not_ready!(delay);
assert_pending!(task.poll(&mut delay));
}
// Turn the timer, but not enough time will go by.
turn(timer, None);
clock.turn();
// The time has advanced to the point of the delay elapsing.
assert_eq!(time.advanced(), ms(MO_5));
assert_eq!(clock.advanced(), ms(MO_5));
// The delay has elapsed.
assert_ready!(delay);
assert_ready!(task.poll(&mut delay));
})
}
#[test]
#[should_panic]
fn greater_than_max() {
const YR_5: u64 = 5 * 365 * 24 * 60 * 60 * 1000;
mocked(|timer, time| {
let mut task = MockTask::new();
clock::mock(|clock| {
// Create a `Delay` that elapses in the future
let mut delay = Delay::new(time.now() + ms(YR_5));
let mut delay = Delay::new(clock.now() + ms(YR_5));
assert_not_ready!(delay);
assert_pending!(task.poll(&mut delay));
turn(timer, ms(0));
clock.turn_for(ms(0));
assert!(delay.poll().is_err());
// boom
let _ = task.poll(&mut delay);
})
}
#[test]
fn unpark_is_delayed() {
mocked(|timer, time| {
let mut delay1 = Delay::new(time.now() + ms(100));
let mut delay2 = Delay::new(time.now() + ms(101));
let mut delay3 = Delay::new(time.now() + ms(200));
let mut t1 = MockTask::new();
let mut t2 = MockTask::new();
let mut t3 = MockTask::new();
assert_not_ready!(delay1);
assert_not_ready!(delay2);
assert_not_ready!(delay3);
clock::mock(|clock| {
let mut delay1 = Delay::new(clock.now() + ms(100));
let mut delay2 = Delay::new(clock.now() + ms(101));
let mut delay3 = Delay::new(clock.now() + ms(200));
time.park_for(ms(500));
assert_pending!(t1.poll(&mut delay1));
assert_pending!(t2.poll(&mut delay2));
assert_pending!(t3.poll(&mut delay3));
turn(timer, None);
clock.park_for(ms(500));
assert_eq!(time.advanced(), ms(500));
assert_eq!(clock.advanced(), ms(500));
assert_ready!(delay1);
assert_ready!(delay2);
assert_ready!(delay3);
assert_ready!(t1.poll(&mut delay1));
assert_ready!(t2.poll(&mut delay2));
assert_ready!(t3.poll(&mut delay3));
})
}
@@ -373,108 +402,118 @@ fn set_timeout_at_deadline_greater_than_max_timer() {
const YR_1: u64 = 365 * 24 * 60 * 60 * 1000;
const YR_5: u64 = 5 * YR_1;
mocked(|timer, time| {
let mut task = MockTask::new();
clock::mock(|clock| {
for _ in 0..5 {
turn(timer, ms(YR_1));
clock.turn_for(ms(YR_1));
}
let mut delay = Delay::new(time.now() + ms(1));
assert_not_ready!(delay);
let mut delay = Delay::new(clock.now() + ms(1));
assert_pending!(task.poll(&mut delay));
turn(timer, ms(1000));
assert_eq!(time.advanced(), Duration::from_millis(YR_5) + ms(1));
clock.turn_for(ms(1000));
assert_eq!(clock.advanced(), ms(YR_5) + ms(1));
assert_ready!(delay);
assert_ready!(task.poll(&mut delay));
});
}
#[test]
fn reset_future_delay_before_fire() {
mocked(|timer, time| {
let mut delay = Delay::new(time.now() + ms(100));
let mut task = MockTask::new();
assert_not_ready!(delay);
clock::mock(|clock| {
let mut delay = Delay::new(clock.now() + ms(100));
delay.reset(time.now() + ms(200));
assert_pending!(task.poll(&mut delay));
turn(timer, None);
assert_eq!(time.advanced(), ms(192));
delay.reset(clock.now() + ms(200));
assert_not_ready!(delay);
clock.turn();
assert_eq!(clock.advanced(), ms(192));
turn(timer, None);
assert_eq!(time.advanced(), ms(200));
assert_pending!(task.poll(&mut delay));
assert_ready!(delay);
clock.turn();
assert_eq!(clock.advanced(), ms(200));
assert_ready!(task.poll(&mut delay));
});
}
#[test]
fn reset_past_delay_before_turn() {
mocked(|timer, time| {
let mut delay = Delay::new(time.now() + ms(100));
let mut task = MockTask::new();
assert_not_ready!(delay);
clock::mock(|clock| {
let mut delay = Delay::new(clock.now() + ms(100));
delay.reset(time.now() + ms(80));
assert_pending!(task.poll(&mut delay));
turn(timer, None);
assert_eq!(time.advanced(), ms(64));
delay.reset(clock.now() + ms(80));
assert_not_ready!(delay);
clock.turn();
assert_eq!(clock.advanced(), ms(64));
turn(timer, None);
assert_eq!(time.advanced(), ms(80));
assert_pending!(task.poll(&mut delay));
assert_ready!(delay);
clock.turn();
assert_eq!(clock.advanced(), ms(80));
assert_ready!(task.poll(&mut delay));
});
}
#[test]
fn reset_past_delay_before_fire() {
mocked(|timer, time| {
let mut delay = Delay::new(time.now() + ms(100));
let mut task = MockTask::new();
assert_not_ready!(delay);
turn(timer, ms(10));
clock::mock(|clock| {
let mut delay = Delay::new(clock.now() + ms(100));
assert_not_ready!(delay);
delay.reset(time.now() + ms(80));
assert_pending!(task.poll(&mut delay));
clock.turn_for(ms(10));
turn(timer, None);
assert_eq!(time.advanced(), ms(64));
assert_pending!(task.poll(&mut delay));
delay.reset(clock.now() + ms(80));
assert_not_ready!(delay);
clock.turn();
assert_eq!(clock.advanced(), ms(64));
turn(timer, None);
assert_eq!(time.advanced(), ms(90));
assert_pending!(task.poll(&mut delay));
assert_ready!(delay);
clock.turn();
assert_eq!(clock.advanced(), ms(90));
assert_ready!(task.poll(&mut delay));
});
}
#[test]
fn reset_future_delay_after_fire() {
mocked(|timer, time| {
let mut delay = Delay::new(time.now() + ms(100));
let mut task = MockTask::new();
assert_not_ready!(delay);
clock::mock(|clock| {
let mut delay = Delay::new(clock.now() + ms(100));
turn(timer, ms(1000));
assert_eq!(time.advanced(), ms(64));
assert_pending!(task.poll(&mut delay));
turn(timer, None);
assert_eq!(time.advanced(), ms(100));
clock.turn_for(ms(1000));
assert_eq!(clock.advanced(), ms(64));
assert_ready!(delay);
clock.turn();
assert_eq!(clock.advanced(), ms(100));
delay.reset(time.now() + ms(10));
assert_not_ready!(delay);
assert_ready!(task.poll(&mut delay));
turn(timer, ms(1000));
assert_eq!(time.advanced(), ms(110));
delay.reset(clock.now() + ms(10));
assert_pending!(task.poll(&mut delay));
assert_ready!(delay);
clock.turn_for(ms(1000));
assert_eq!(clock.advanced(), ms(110));
assert_ready!(task.poll(&mut delay));
});
}
@@ -482,14 +521,19 @@ fn reset_future_delay_after_fire() {
fn delay_with_default_handle() {
let handle = Handle::default();
let now = Instant::now();
let mut task = MockTask::new();
let mut delay = handle.delay(now + ms(1));
mocked_with_now(now, |timer, _time| {
assert_not_ready!(delay);
clock::mock_at(now, |clock| {
assert_pending!(task.poll(&mut delay));
turn(timer, ms(1));
clock.turn_for(ms(1));
assert_ready!(delay);
assert_ready!(task.poll(&mut delay));
});
}
fn ms(n: u64) -> Duration {
Duration::from_millis(n)
}