timer: introduce delay function shortcut

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());

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)));
 }

tokio-test/tests/clock.rs

@@ -6,15 +6,15 @@ 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() {
  let mut mock = MockClock::new();
 
  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()));
 

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 }

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 =====