From 2d56312b89ba407272b161290d563551efc896a6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= Date: Tue, 20 Aug 2019 17:39:55 +0200 Subject: [PATCH] timer: introduce delay function shortcut (#1440) This commit adds a simple delay shortcut to avoid writing Delay::new everywhere and removes usages of Delay::new. --- tokio-test/src/clock.rs | 5 +- tokio-test/tests/block_on.rs | 8 +- tokio-test/tests/clock.rs | 6 +- tokio-timer/src/delay.rs | 2 +- tokio-timer/src/lib.rs | 7 +- tokio-timer/tests/delay.rs | 182 +++++++++++++------------- tokio/src/timer.rs | 6 +- tokio/tests/clock.rs | 4 +- tokio/tests/runtime_current_thread.rs | 8 +- tokio/tests/runtime_threaded.rs | 5 +- tokio/tests/timer.rs | 10 +- 11 files changed, 122 insertions(+), 121 deletions(-) diff --git a/tokio-test/src/clock.rs b/tokio-test/src/clock.rs index 43f073d95..a5c8b4f2c 100644 --- a/tokio-test/src/clock.rs +++ b/tokio-test/src/clock.rs @@ -7,14 +7,13 @@ //! //! use tokio::clock; //! use tokio_test::{assert_ready, assert_pending, task}; -//! use tokio_timer::Delay; +//! use tokio_timer::delay; //! //! use std::time::Duration; //! //! tokio_test::clock::mock(|handle| { //! let mut task = task::spawn(async { -//! let delay = Delay::new(clock::now() + Duration::from_secs(1)); -//! delay.await +//! delay(clock::now() + Duration::from_secs(1)).await //! }); //! //! assert_pending!(task.poll()); diff --git a/tokio-test/tests/block_on.rs b/tokio-test/tests/block_on.rs index 7d56ec620..f0a90d113 100644 --- a/tokio-test/tests/block_on.rs +++ b/tokio-test/tests/block_on.rs @@ -3,7 +3,7 @@ use std::time::{Duration, Instant}; use tokio_test::block_on; -use tokio_timer::Delay; +use tokio_timer::delay; #[test] fn async_block() { @@ -20,9 +20,7 @@ fn async_fn() { } #[test] -fn delay() { +fn test_delay() { let deadline = Instant::now() + Duration::from_millis(100); - let delay = Delay::new(deadline); - - assert_eq!((), block_on(delay)); + assert_eq!((), block_on(delay(deadline))); } diff --git a/tokio-test/tests/clock.rs b/tokio-test/tests/clock.rs index 915f6899e..344c599b6 100644 --- a/tokio-test/tests/clock.rs +++ b/tokio-test/tests/clock.rs @@ -6,7 +6,7 @@ use std::time::{Duration, Instant}; use tokio_test::clock::MockClock; use tokio_test::task::MockTask; use tokio_test::{assert_not_ready, assert_ready}; -use tokio_timer::Delay; +use tokio_timer::delay; #[test] fn clock() { @@ -14,7 +14,7 @@ fn clock() { mock.enter(|handle| { let deadline = Instant::now() + Duration::from_secs(1); - let mut delay = Delay::new(deadline); + let mut delay = delay(deadline); assert_not_ready!(delay.poll()); @@ -31,7 +31,7 @@ fn notify() { let mut task = MockTask::new(); mock.enter(|handle| { - let mut delay = Delay::new(deadline); + let mut delay = delay(deadline); task.enter(|| assert_not_ready!(delay.poll())); diff --git a/tokio-timer/src/delay.rs b/tokio-timer/src/delay.rs index 7ba8be758..abeda473c 100644 --- a/tokio-timer/src/delay.rs +++ b/tokio-timer/src/delay.rs @@ -33,7 +33,7 @@ impl Delay { /// Only millisecond level resolution is guaranteed. There is no guarantee /// as to how the sub-millisecond portion of `deadline` will be handled. /// `Delay` should not be used for high-resolution timer use cases. - pub fn new(deadline: Instant) -> Delay { + pub(crate) fn new(deadline: Instant) -> Delay { let registration = Registration::new(deadline, Duration::from_millis(0)); Delay { registration } diff --git a/tokio-timer/src/lib.rs b/tokio-timer/src/lib.rs index 9868fcb62..be03d2d17 100644 --- a/tokio-timer/src/lib.rs +++ b/tokio-timer/src/lib.rs @@ -59,9 +59,14 @@ pub use timer::{set_default, Timer}; use std::time::{Duration, Instant}; +/// Create a Future that completes at `deadline`. +pub fn delay(deadline: Instant) -> Delay { + Delay::new(deadline) +} + /// Create a Future that completes in `duration` from now. pub fn sleep(duration: Duration) -> Delay { - Delay::new(Instant::now() + duration) + delay(Instant::now() + duration) } // ===== Internal utils ===== diff --git a/tokio-timer/tests/delay.rs b/tokio-timer/tests/delay.rs index bcfc07133..5758926f0 100644 --- a/tokio-timer/tests/delay.rs +++ b/tokio-timer/tests/delay.rs @@ -1,12 +1,12 @@ #![warn(rust_2018_idioms)] #![feature(async_await)] +use std::time::{Duration, Instant}; + use tokio_test::task::MockTask; use tokio_test::{assert_pending, assert_ready, clock}; +use tokio_timer::delay; use tokio_timer::timer::Handle; -use tokio_timer::Delay; - -use std::time::{Duration, Instant}; #[test] fn immediate_delay() { @@ -14,10 +14,10 @@ fn immediate_delay() { clock::mock(|clock| { // Create `Delay` that elapsed immediately. - let mut delay = Delay::new(clock.now()); + let mut fut = delay(clock.now()); // Ready! - assert_ready!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); // Turn the timer, it runs for the elapsed time clock.turn_for(ms(1000)); @@ -34,15 +34,15 @@ fn delayed_delay_level_0() { for &i in &[1, 10, 60] { clock::mock(|clock| { // Create a `Delay` that elapses in the future - let mut delay = Delay::new(clock.now() + ms(i)); + let mut fut = delay(clock.now() + ms(i)); // The delay has not elapsed. - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); clock.turn(); assert_eq!(clock.advanced(), ms(i)); - assert_ready!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); }); } } @@ -55,12 +55,12 @@ fn sub_ms_delayed_delay() { for _ in 0..5 { let deadline = clock.now() + Duration::from_millis(1) + Duration::new(0, 1); - let mut delay = Delay::new(deadline); + let mut fut = delay(deadline); - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); clock.turn(); - assert_ready!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); assert!(clock.now() >= deadline); @@ -77,18 +77,18 @@ fn delayed_delay_wrapping_level_0() { clock.turn_for(ms(5)); assert_eq!(clock.advanced(), ms(5)); - let mut delay = Delay::new(clock.now() + ms(60)); + let mut fut = delay(clock.now() + ms(60)); - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); clock.turn(); assert_eq!(clock.advanced(), ms(64)); - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); clock.turn(); assert_eq!(clock.advanced(), ms(65)); - assert_ready!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); }); } @@ -98,14 +98,14 @@ fn timer_wrapping_with_higher_levels() { clock::mock(|clock| { // Set delay to hit level 1 - let mut s1 = Delay::new(clock.now() + ms(64)); + let mut s1 = delay(clock.now() + ms(64)); assert_pending!(task.poll(&mut s1)); // Turn a bit clock.turn_for(ms(5)); // Set timeout such that it will hit level 0, but wrap - let mut s2 = Delay::new(clock.now() + ms(60)); + let mut s2 = delay(clock.now() + ms(60)); assert_pending!(task.poll(&mut s2)); // This should result in s1 firing @@ -128,11 +128,11 @@ fn delay_with_deadline_in_past() { clock::mock(|clock| { // Create `Delay` that elapsed immediately. - let mut delay = Delay::new(clock.now() - ms(100)); + let mut fut = delay(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!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); // Turn the timer, it runs for the elapsed time clock.turn_for(ms(1000)); @@ -148,52 +148,52 @@ fn delayed_delay_level_1() { clock::mock(|clock| { // Create a `Delay` that elapses in the future - let mut delay = Delay::new(clock.now() + ms(234)); + let mut fut = delay(clock.now() + ms(234)); // The delay has not elapsed. - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); // Turn the timer, this will wake up to cascade the timer down. clock.turn_for(ms(1000)); assert_eq!(clock.advanced(), ms(192)); // The delay has not elapsed. - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); // Turn the timer again clock.turn_for(ms(1000)); assert_eq!(clock.advanced(), ms(234)); // The delay has elapsed. - assert_ready!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); }); clock::mock(|clock| { // Create a `Delay` that elapses in the future - let mut delay = Delay::new(clock.now() + ms(234)); + let mut fut = delay(clock.now() + ms(234)); // The delay has not elapsed. - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); // Turn the timer with a smaller timeout than the cascade. clock.turn_for(ms(100)); assert_eq!(clock.advanced(), ms(100)); - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); // Turn the timer, this will wake up to cascade the timer down. clock.turn_for(ms(1000)); assert_eq!(clock.advanced(), ms(192)); // The delay has not elapsed. - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); // Turn the timer again clock.turn_for(ms(1000)); assert_eq!(clock.advanced(), ms(234)); // The delay has elapsed. - assert_ready!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); }); } @@ -203,24 +203,24 @@ 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 fut = delay(now + ms(500)); let mut task = MockTask::new(); clock::mock_at(now, |clock| { // This registers the delay with the timer - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); // Wait some time... the timer is cascading clock.turn_for(ms(1000)); assert_eq!(clock.advanced(), ms(448)); - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); clock.turn_for(ms(1000)); assert_eq!(clock.advanced(), ms(500)); // The delay has elapsed - assert_ready!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); }); } @@ -230,12 +230,12 @@ fn concurrently_set_two_timers_second_one_shorter() { 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)); + let mut fut1 = delay(clock.now() + ms(500)); + let mut fut2 = delay(clock.now() + ms(200)); // The delay has not elapsed - assert_pending!(t1.poll(&mut delay1)); - assert_pending!(t2.poll(&mut delay2)); + assert_pending!(t1.poll(&mut fut1)); + assert_pending!(t2.poll(&mut fut2)); // Delay until a cascade clock.turn(); @@ -246,19 +246,19 @@ fn concurrently_set_two_timers_second_one_shorter() { assert_eq!(clock.advanced(), ms(200)); // The shorter delay fires - assert_ready!(t2.poll(&mut delay2)); - assert_pending!(t1.poll(&mut delay1)); + assert_ready!(t2.poll(&mut fut2)); + assert_pending!(t1.poll(&mut fut1)); clock.turn(); assert_eq!(clock.advanced(), ms(448)); - assert_pending!(t1.poll(&mut delay1)); + assert_pending!(t1.poll(&mut fut1)); // Turn again, this time the time will advance to the second delay clock.turn(); assert_eq!(clock.advanced(), ms(500)); - assert_ready!(t1.poll(&mut delay1)); + assert_ready!(t1.poll(&mut fut1)); }) } @@ -268,16 +268,16 @@ fn short_delay() { clock::mock(|clock| { // Create a `Delay` that elapses in the future - let mut delay = Delay::new(clock.now() + ms(1)); + let mut fut = delay(clock.now() + ms(1)); // The delay has not elapsed. - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); // Turn the timer, but not enough time will go by. clock.turn(); // The delay has elapsed. - assert_ready!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); // The time has advanced to the point of the delay elapsing. assert_eq!(clock.advanced(), ms(1)); @@ -292,10 +292,10 @@ fn sorta_long_delay() { clock::mock(|clock| { // Create a `Delay` that elapses in the future - let mut delay = Delay::new(clock.now() + ms(MIN_5)); + let mut fut = delay(clock.now() + ms(MIN_5)); // The delay has not elapsed. - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); let cascades = &[262_144, 262_144 + 9 * 4096, 262_144 + 9 * 4096 + 15 * 64]; @@ -303,14 +303,14 @@ fn sorta_long_delay() { clock.turn(); assert_eq!(clock.advanced(), ms(elapsed)); - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); } clock.turn(); assert_eq!(clock.advanced(), ms(MIN_5)); // The delay has elapsed. - assert_ready!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); }) } @@ -322,10 +322,10 @@ fn very_long_delay() { clock::mock(|clock| { // Create a `Delay` that elapses in the future - let mut delay = Delay::new(clock.now() + ms(MO_5)); + let mut fut = delay(clock.now() + ms(MO_5)); // The delay has not elapsed. - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); let cascades = &[ 12_884_901_888, @@ -338,7 +338,7 @@ fn very_long_delay() { clock.turn(); assert_eq!(clock.advanced(), ms(elapsed)); - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); } // Turn the timer, but not enough time will go by. @@ -348,7 +348,7 @@ fn very_long_delay() { assert_eq!(clock.advanced(), ms(MO_5)); // The delay has elapsed. - assert_ready!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); }) } @@ -361,14 +361,14 @@ fn greater_than_max() { clock::mock(|clock| { // Create a `Delay` that elapses in the future - let mut delay = Delay::new(clock.now() + ms(YR_5)); + let mut fut = delay(clock.now() + ms(YR_5)); - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); clock.turn_for(ms(0)); // boom - let _ = task.poll(&mut delay); + let _ = task.poll(&mut fut); }) } @@ -379,21 +379,21 @@ fn unpark_is_delayed() { let mut t3 = MockTask::new(); 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)); + let mut fut1 = delay(clock.now() + ms(100)); + let mut fut2 = delay(clock.now() + ms(101)); + let mut fut3 = delay(clock.now() + ms(200)); - assert_pending!(t1.poll(&mut delay1)); - assert_pending!(t2.poll(&mut delay2)); - assert_pending!(t3.poll(&mut delay3)); + assert_pending!(t1.poll(&mut fut1)); + assert_pending!(t2.poll(&mut fut2)); + assert_pending!(t3.poll(&mut fut3)); clock.park_for(ms(500)); assert_eq!(clock.advanced(), ms(500)); - assert_ready!(t1.poll(&mut delay1)); - assert_ready!(t2.poll(&mut delay2)); - assert_ready!(t3.poll(&mut delay3)); + assert_ready!(t1.poll(&mut fut1)); + assert_ready!(t2.poll(&mut fut2)); + assert_ready!(t3.poll(&mut fut3)); }) } @@ -409,13 +409,13 @@ fn set_timeout_at_deadline_greater_than_max_timer() { clock.turn_for(ms(YR_1)); } - let mut delay = Delay::new(clock.now() + ms(1)); - assert_pending!(task.poll(&mut delay)); + let mut fut = delay(clock.now() + ms(1)); + assert_pending!(task.poll(&mut fut)); clock.turn_for(ms(1000)); assert_eq!(clock.advanced(), ms(YR_5) + ms(1)); - assert_ready!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); }); } @@ -424,21 +424,21 @@ fn reset_future_delay_before_fire() { let mut task = MockTask::new(); clock::mock(|clock| { - let mut delay = Delay::new(clock.now() + ms(100)); + let mut fut = delay(clock.now() + ms(100)); - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); - delay.reset(clock.now() + ms(200)); + fut.reset(clock.now() + ms(200)); clock.turn(); assert_eq!(clock.advanced(), ms(192)); - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); clock.turn(); assert_eq!(clock.advanced(), ms(200)); - assert_ready!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); }); } @@ -447,21 +447,21 @@ fn reset_past_delay_before_turn() { let mut task = MockTask::new(); clock::mock(|clock| { - let mut delay = Delay::new(clock.now() + ms(100)); + let mut fut = delay(clock.now() + ms(100)); - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); - delay.reset(clock.now() + ms(80)); + fut.reset(clock.now() + ms(80)); clock.turn(); assert_eq!(clock.advanced(), ms(64)); - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); clock.turn(); assert_eq!(clock.advanced(), ms(80)); - assert_ready!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); }); } @@ -470,23 +470,23 @@ fn reset_past_delay_before_fire() { let mut task = MockTask::new(); clock::mock(|clock| { - let mut delay = Delay::new(clock.now() + ms(100)); + let mut fut = delay(clock.now() + ms(100)); - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); clock.turn_for(ms(10)); - assert_pending!(task.poll(&mut delay)); - delay.reset(clock.now() + ms(80)); + assert_pending!(task.poll(&mut fut)); + fut.reset(clock.now() + ms(80)); clock.turn(); assert_eq!(clock.advanced(), ms(64)); - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); clock.turn(); assert_eq!(clock.advanced(), ms(90)); - assert_ready!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); }); } @@ -495,9 +495,9 @@ fn reset_future_delay_after_fire() { let mut task = MockTask::new(); clock::mock(|clock| { - let mut delay = Delay::new(clock.now() + ms(100)); + let mut fut = delay(clock.now() + ms(100)); - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); clock.turn_for(ms(1000)); assert_eq!(clock.advanced(), ms(64)); @@ -505,15 +505,15 @@ fn reset_future_delay_after_fire() { clock.turn(); assert_eq!(clock.advanced(), ms(100)); - assert_ready!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); - delay.reset(clock.now() + ms(10)); - assert_pending!(task.poll(&mut delay)); + fut.reset(clock.now() + ms(10)); + assert_pending!(task.poll(&mut fut)); clock.turn_for(ms(1000)); assert_eq!(clock.advanced(), ms(110)); - assert_ready!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); }); } @@ -523,14 +523,14 @@ fn delay_with_default_handle() { let now = Instant::now(); let mut task = MockTask::new(); - let mut delay = handle.delay(now + ms(1)); + let mut fut = handle.delay(now + ms(1)); clock::mock_at(now, |clock| { - assert_pending!(task.poll(&mut delay)); + assert_pending!(task.poll(&mut fut)); clock.turn_for(ms(1)); - assert_ready!(task.poll(&mut delay)); + assert_ready!(task.poll(&mut fut)); }); } diff --git a/tokio/src/timer.rs b/tokio/src/timer.rs index fd88af0f0..24c4345af 100644 --- a/tokio/src/timer.rs +++ b/tokio/src/timer.rs @@ -33,7 +33,7 @@ //! #![feature(async_await)] //! //! use tokio::prelude::*; -//! use tokio::timer::Delay; +//! use tokio::timer::delay; //! //! use std::time::{Duration, Instant}; //! @@ -41,7 +41,7 @@ //! #[tokio::main] //! async fn main() { //! let when = tokio::clock::now() + Duration::from_millis(100); -//! Delay::new(when).await; +//! delay(when).await; //! println!("100 ms have elapsed"); //! } //! ``` @@ -79,4 +79,4 @@ //! [Interval]: struct.Interval.html //! [`DelayQueue`]: struct.DelayQueue.html -pub use tokio_timer::{delay_queue, timeout, Delay, DelayQueue, Error, Interval, Timeout}; +pub use tokio_timer::{delay, delay_queue, timeout, Delay, DelayQueue, Error, Interval, Timeout}; diff --git a/tokio/tests/clock.rs b/tokio/tests/clock.rs index 621b3ecf6..f7f9e0303 100644 --- a/tokio/tests/clock.rs +++ b/tokio/tests/clock.rs @@ -28,7 +28,7 @@ fn clock_and_timer_concurrent() { let (tx, rx) = mpsc::channel(); rt.spawn(async move { - Delay::new(when).await; + delay(when).await; assert!(Instant::now() < when); tx.send(()).unwrap(); }); @@ -44,7 +44,7 @@ fn clock_and_timer_single_threaded() { let mut rt = current_thread::Builder::new().clock(clock).build().unwrap(); rt.block_on(async move { - Delay::new(when).await; + delay(when).await; assert!(Instant::now() < when); }); } diff --git a/tokio/tests/runtime_current_thread.rs b/tokio/tests/runtime_current_thread.rs index f9eda9972..b4e35f393 100644 --- a/tokio/tests/runtime_current_thread.rs +++ b/tokio/tests/runtime_current_thread.rs @@ -6,12 +6,12 @@ use tokio::io::{AsyncReadExt, AsyncWriteExt}; use tokio::net::{TcpListener, TcpStream}; use tokio::runtime::current_thread::Runtime; use tokio::sync::oneshot; -use tokio::timer::Delay; use tokio_test::{assert_err, assert_ok}; use env_logger; use std::sync::mpsc; use std::time::{Duration, Instant}; +use tokio::timer::delay; async fn client_server(tx: mpsc::Sender<()>) { let addr = assert_ok!("127.0.0.1:0".parse()); @@ -47,7 +47,7 @@ fn spawn_run_spawn_root() { let tx2 = tx.clone(); rt.spawn(async move { - Delay::new(Instant::now() + Duration::from_millis(1000)).await; + delay(Instant::now() + Duration::from_millis(1000)).await; tx2.send(()).unwrap(); }); @@ -68,7 +68,7 @@ fn spawn_run_nested_spawn() { let tx2 = tx.clone(); rt.spawn(async move { tokio::spawn(async move { - Delay::new(Instant::now() + Duration::from_millis(1000)).await; + delay(Instant::now() + Duration::from_millis(1000)).await; tx2.send(()).unwrap(); }); }); @@ -89,7 +89,7 @@ fn block_on() { let tx2 = tx.clone(); rt.spawn(async move { - Delay::new(Instant::now() + Duration::from_millis(1000)).await; + delay(Instant::now() + Duration::from_millis(1000)).await; tx2.send(()).unwrap(); }); diff --git a/tokio/tests/runtime_threaded.rs b/tokio/tests/runtime_threaded.rs index d95920711..9cda2171c 100644 --- a/tokio/tests/runtime_threaded.rs +++ b/tokio/tests/runtime_threaded.rs @@ -7,7 +7,7 @@ use tokio::io::{AsyncReadExt, AsyncWriteExt}; use tokio::net::{TcpListener, TcpStream}; use tokio::runtime::Runtime; use tokio::sync::oneshot; -use tokio::timer::Delay; +use tokio::timer::delay; use tokio_test::{assert_err, assert_ok}; use env_logger; @@ -65,8 +65,7 @@ fn block_on_timer() { let rt = Runtime::new().unwrap(); let v = rt.block_on(async move { - let delay = Delay::new(Instant::now() + Duration::from_millis(100)); - delay.await; + delay(Instant::now() + Duration::from_millis(100)).await; 42 }); diff --git a/tokio/tests/timer.rs b/tokio/tests/timer.rs index 60ce0bbd5..902e21c36 100644 --- a/tokio/tests/timer.rs +++ b/tokio/tests/timer.rs @@ -18,7 +18,7 @@ fn timer_with_threaded_runtime() { rt.spawn(async move { let when = Instant::now() + Duration::from_millis(100); - Delay::new(when).await; + delay(when).await; assert!(Instant::now() >= when); tx.send(()).unwrap(); @@ -39,7 +39,7 @@ fn timer_with_current_thread_runtime() { rt.spawn(async move { let when = Instant::now() + Duration::from_millis(100); - Delay::new(when).await; + tokio::timer::delay(when).await; assert!(Instant::now() >= when); tx.send(()).unwrap(); @@ -55,9 +55,9 @@ async fn starving() { use std::pin::Pin; use std::task::{Context, Poll}; - struct Starve(Delay, u64); + struct Starve + Unpin>(T, u64); - impl Future for Starve { + impl + Unpin> Future for Starve { type Output = u64; fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { @@ -74,7 +74,7 @@ async fn starving() { } let when = Instant::now() + Duration::from_millis(20); - let starve = Starve(Delay::new(when), 0); + let starve = Starve(delay(when), 0); starve.await; assert!(Instant::now() >= when);