time: rename `Delay` future to `Sleep` (#2932)

4 files changed, 44 insertions, 44 deletions

diff --git a/tokio/tests/macros_select.rs b/tokio/tests/macros_select.rs
index f77f3f01..cc214bbb 100644
--- a/tokio/tests/macros_select.rs
+++ b/tokio/tests/macros_select.rs
@@ -359,10 +359,10 @@ async fn join_with_select() {
 async fn use_future_in_if_condition() {
     use tokio::time::{self, Duration};
 
-    let mut delay = time::sleep(Duration::from_millis(50));
+    let mut sleep = time::sleep(Duration::from_millis(50));
 
     tokio::select! {
-        _ = &mut delay, if !delay.is_elapsed() => {
+        _ = &mut sleep, if !sleep.is_elapsed() => {
         }
         _ = async { 1 } => {
         }
diff --git a/tokio/tests/rt_common.rs b/tokio/tests/rt_common.rs
index 56ab840d..1273593f 100644
--- a/tokio/tests/rt_common.rs
+++ b/tokio/tests/rt_common.rs
@@ -430,7 +430,7 @@ rt_test! {
     }
 
     #[test]
-    fn delay_at_root() {
+    fn sleep_at_root() {
         let rt = rt();
 
         let now = Instant::now();
@@ -444,7 +444,7 @@ rt_test! {
     }
 
     #[test]
-    fn delay_in_spawn() {
+    fn sleep_in_spawn() {
         let rt = rt();
 
         let now = Instant::now();
@@ -515,7 +515,7 @@ rt_test! {
     }
 
     #[test]
-    fn delay_from_blocking() {
+    fn sleep_from_blocking() {
         let rt = rt();
 
         rt.block_on(async move {
diff --git a/tokio/tests/stream_timeout.rs b/tokio/tests/stream_timeout.rs
index 698c1d39..a787bba3 100644
--- a/tokio/tests/stream_timeout.rs
+++ b/tokio/tests/stream_timeout.rs
@@ -6,7 +6,7 @@ use tokio_test::*;
 
 use futures::StreamExt as _;
 
-async fn maybe_delay(idx: i32) -> i32 {
+async fn maybe_sleep(idx: i32) -> i32 {
     if idx % 2 == 0 {
         sleep(ms(200)).await;
     }
@@ -26,7 +26,7 @@ async fn basic_usage() {
     //
     // [Ok(1), Err(Elapsed), Ok(2), Ok(3), Err(Elapsed), Ok(4)]
 
-    let stream = stream::iter(1..=4).then(maybe_delay).timeout(ms(100));
+    let stream = stream::iter(1..=4).then(maybe_sleep).timeout(ms(100));
     let mut stream = task::spawn(stream);
 
     // First item completes immediately
@@ -68,7 +68,7 @@ async fn basic_usage() {
 async fn return_elapsed_errors_only_once() {
     time::pause();
 
-    let stream = stream::iter(1..=3).then(maybe_delay).timeout(ms(50));
+    let stream = stream::iter(1..=3).then(maybe_sleep).timeout(ms(50));
     let mut stream = task::spawn(stream);
 
     // First item completes immediately
@@ -97,7 +97,7 @@ async fn return_elapsed_errors_only_once() {
 #[tokio::test]
 async fn no_timeouts() {
     let stream = stream::iter(vec![1, 3, 5])
-        .then(maybe_delay)
+        .then(maybe_sleep)
         .timeout(ms(100));
 
     let mut stream = task::spawn(stream);
diff --git a/tokio/tests/time_delay.rs b/tokio/tests/time_sleep.rs
index 559c18c8..87d69dee 100644
--- a/tokio/tests/time_delay.rs
+++ b/tokio/tests/time_sleep.rs
@@ -20,7 +20,7 @@ macro_rules! assert_elapsed {
 }
 
 #[tokio::test]
-async fn immediate_delay() {
+async fn immediate_sleep() {
     time::pause();
 
     let now = Instant::now();
@@ -31,7 +31,7 @@ async fn immediate_delay() {
 }
 
 #[tokio::test]
-async fn delayed_delay_level_0() {
+async fn delayed_sleep_level_0() {
     time::pause();
 
     for &i in &[1, 10, 60] {
@@ -44,7 +44,7 @@ async fn delayed_delay_level_0() {
 }
 
 #[tokio::test]
-async fn sub_ms_delayed_delay() {
+async fn sub_ms_delayed_sleep() {
     time::pause();
 
     for _ in 0..5 {
@@ -58,7 +58,7 @@ async fn sub_ms_delayed_delay() {
 }
 
 #[tokio::test]
-async fn delayed_delay_wrapping_level_0() {
+async fn delayed_sleep_wrapping_level_0() {
     time::pause();
 
     time::sleep(ms(5)).await;
@@ -70,96 +70,96 @@ async fn delayed_delay_wrapping_level_0() {
 }
 
 #[tokio::test]
-async fn reset_future_delay_before_fire() {
+async fn reset_future_sleep_before_fire() {
     time::pause();
 
     let now = Instant::now();
 
-    let mut delay = task::spawn(time::sleep_until(now + ms(100)));
-    assert_pending!(delay.poll());
+    let mut sleep = task::spawn(time::sleep_until(now + ms(100)));
+    assert_pending!(sleep.poll());
 
-    let mut delay = delay.into_inner();
+    let mut sleep = sleep.into_inner();
 
-    delay.reset(Instant::now() + ms(200));
-    delay.await;
+    sleep.reset(Instant::now() + ms(200));
+    sleep.await;
 
     assert_elapsed!(now, 200);
 }
 
 #[tokio::test]
-async fn reset_past_delay_before_turn() {
+async fn reset_past_sleep_before_turn() {
     time::pause();
 
     let now = Instant::now();
 
-    let mut delay = task::spawn(time::sleep_until(now + ms(100)));
-    assert_pending!(delay.poll());
+    let mut sleep = task::spawn(time::sleep_until(now + ms(100)));
+    assert_pending!(sleep.poll());
 
-    let mut delay = delay.into_inner();
+    let mut sleep = sleep.into_inner();
 
-    delay.reset(now + ms(80));
-    delay.await;
+    sleep.reset(now + ms(80));
+    sleep.await;
 
     assert_elapsed!(now, 80);
 }
 
 #[tokio::test]
-async fn reset_past_delay_before_fire() {
+async fn reset_past_sleep_before_fire() {
     time::pause();
 
     let now = Instant::now();
 
-    let mut delay = task::spawn(time::sleep_until(now + ms(100)));
-    assert_pending!(delay.poll());
+    let mut sleep = task::spawn(time::sleep_until(now + ms(100)));
+    assert_pending!(sleep.poll());
 
-    let mut delay = delay.into_inner();
+    let mut sleep = sleep.into_inner();
 
     time::sleep(ms(10)).await;
 
-    delay.reset(now + ms(80));
-    delay.await;
+    sleep.reset(now + ms(80));
+    sleep.await;
 
     assert_elapsed!(now, 80);
 }
 
 #[tokio::test]
-async fn reset_future_delay_after_fire() {
+async fn reset_future_sleep_after_fire() {
     time::pause();
 
     let now = Instant::now();
-    let mut delay = time::sleep_until(now + ms(100));
+    let mut sleep = time::sleep_until(now + ms(100));
 
-    (&mut delay).await;
+    (&mut sleep).await;
     assert_elapsed!(now, 100);
 
-    delay.reset(now + ms(110));
-    delay.await;
+    sleep.reset(now + ms(110));
+    sleep.await;
     assert_elapsed!(now, 110);
 }
 
 #[tokio::test]
-async fn reset_delay_to_past() {
+async fn reset_sleep_to_past() {
     time::pause();
 
     let now = Instant::now();
 
-    let mut delay = task::spawn(time::sleep_until(now + ms(100)));
-    assert_pending!(delay.poll());
+    let mut sleep = task::spawn(time::sleep_until(now + ms(100)));
+    assert_pending!(sleep.poll());
 
     time::sleep(ms(50)).await;
 
-    assert!(!delay.is_woken());
+    assert!(!sleep.is_woken());
 
-    delay.reset(now + ms(40));
+    sleep.reset(now + ms(40));
 
-    assert!(delay.is_woken());
+    assert!(sleep.is_woken());
 
-    assert_ready!(delay.poll());
+    assert_ready!(sleep.poll());
 }
 
 #[test]
 #[should_panic]
-fn creating_delay_outside_of_context() {
+fn creating_sleep_outside_of_context() {
     let now = Instant::now();
 
     // This creates a delay outside of the context of a mock timer. This tests