Re-add task/context.rs to futures-test

Author: taiki-e

futures-channel/benches/sync_mpsc.rs

@@ -11,14 +11,14 @@ use {
         sink::Sink,
         task::{Context, Poll},
     },
-    futures_test::task::noop_waker_ref,
+    futures_test::task::noop_context,
     std::pin::Pin,
 };
 
 /// Single producer, single consumer
 #[bench]
 fn unbounded_1_tx(b: &mut Bencher) {
-    let mut cx = Context::from_waker(noop_waker_ref());
+    let mut cx = noop_context();
     b.iter(|| {
         let (tx, mut rx) = mpsc::unbounded();
 
@@ -40,7 +40,7 @@ fn unbounded_1_tx(b: &mut Bencher) {
 /// 100 producers, single consumer
 #[bench]
 fn unbounded_100_tx(b: &mut Bencher) {
-    let mut cx = Context::from_waker(noop_waker_ref());
+    let mut cx = noop_context();
     b.iter(|| {
         let (tx, mut rx) = mpsc::unbounded();
 
@@ -61,7 +61,7 @@ fn unbounded_100_tx(b: &mut Bencher) {
 
 #[bench]
 fn unbounded_uncontended(b: &mut Bencher) {
-    let mut cx = Context::from_waker(noop_waker_ref());
+    let mut cx = noop_context();
     b.iter(|| {
         let (tx, mut rx) = mpsc::unbounded();
 
@@ -101,7 +101,7 @@ impl Stream for TestSender {
 /// Single producers, single consumer
 #[bench]
 fn bounded_1_tx(b: &mut Bencher) {
-    let mut cx = Context::from_waker(noop_waker_ref());
+    let mut cx = noop_context();
     b.iter(|| {
         let (tx, mut rx) = mpsc::channel(0);
 
@@ -118,7 +118,7 @@ fn bounded_1_tx(b: &mut Bencher) {
 /// 100 producers, single consumer
 #[bench]
 fn bounded_100_tx(b: &mut Bencher) {
-    let mut cx = Context::from_waker(noop_waker_ref());
+    let mut cx = noop_context();
     b.iter(|| {
         // Each sender can send one item after specified capacity
         let (tx, mut rx) = mpsc::channel(0);

futures-channel/tests/mpsc.rs

@@ -5,8 +5,8 @@ use futures::executor::{block_on, block_on_stream};
 use futures::future::{join, poll_fn};
 use futures::stream::{Stream, StreamExt};
 use futures::sink::{Sink, SinkExt};
-use futures::task::{Context, Poll};
-use futures_test::task::noop_waker_ref;
+use futures::task::Poll;
+use futures_test::task::noop_context;
 use pin_utils::pin_mut;
 use std::sync::{Arc, Mutex};
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -304,7 +304,7 @@ fn stress_receiver_multi_task_bounded_hard() {
                     } else {
                         // Just poll
                         let n = n.clone();
-                        match rx.poll_next_unpin(&mut Context::from_waker(noop_waker_ref())) {
+                        match rx.poll_next_unpin(&mut noop_context()) {
                             Poll::Ready(Some(_)) => {
                                 n.fetch_add(1, Ordering::Relaxed);
                             }

futures-test/src/assert.rs

@@ -30,7 +30,7 @@ macro_rules! assert_stream_pending {
         let mut stream = &mut $stream;
         $crate::assert::assert_is_unpin_stream(stream);
         let stream = $crate::std_reexport::pin::Pin::new(stream);
-        let mut cx = $crate::std_reexport::task::Context::from_waker($crate::task::noop_waker_ref());
+        let mut cx = $crate::task::noop_context();
         let poll = $crate::futures_core_reexport::stream::Stream::poll_next(
             stream, &mut cx,
         );
@@ -67,7 +67,7 @@ macro_rules! assert_stream_next {
         let mut stream = &mut $stream;
         $crate::assert::assert_is_unpin_stream(stream);
         let stream = $crate::std_reexport::pin::Pin::new(stream);
-        let mut cx = $crate::std_reexport::task::Context::from_waker($crate::task::noop_waker_ref());
+        let mut cx = $crate::task::noop_context();
         match $crate::futures_core_reexport::stream::Stream::poll_next(stream, &mut cx) {
             $crate::futures_core_reexport::task::Poll::Ready(Some(x)) => {
                 assert_eq!(x, $item);
@@ -110,7 +110,7 @@ macro_rules! assert_stream_done {
         let mut stream = &mut $stream;
         $crate::assert::assert_is_unpin_stream(stream);
         let stream = $crate::std_reexport::pin::Pin::new(stream);
-        let mut cx = $crate::std_reexport::task::Context::from_waker($crate::task::noop_waker_ref());
+        let mut cx = $crate::task::noop_context();
         match $crate::futures_core_reexport::stream::Stream::poll_next(stream, &mut cx) {
             $crate::futures_core_reexport::task::Poll::Ready(Some(_)) => {
                 panic!("assertion failed: expected stream to be done but had more elements");

futures-test/src/future/mod.rs

@@ -34,16 +34,16 @@ pub trait FutureTestExt: Future {
     ///
     /// ```
     /// #![feature(async_await, futures_api)]
-    /// use futures::task::{Context, Poll};
+    /// use futures::task::Poll;
     /// use futures::future::FutureExt;
-    /// use futures_test::task;
+    /// use futures_test::task::noop_context;
     /// use futures_test::future::FutureTestExt;
     /// use pin_utils::pin_mut;
     ///
     /// let future = (async { 5 }).pending_once();
     /// pin_mut!(future);
     ///
-    /// let mut cx = Context::from_waker(task::noop_waker_ref());
+    /// let mut cx = noop_context();
     ///
     /// assert_eq!(future.poll_unpin(&mut cx), Poll::Pending);
     /// assert_eq!(future.poll_unpin(&mut cx), Poll::Ready(5));

futures-test/src/task/context.rs

@@ -0,0 +1,39 @@
+use crate::task::{panic_waker_ref, noop_waker_ref};
+use futures_core::task::Context;
+
+/// Create a new [`Context`](core::task::Context) where the
+/// [waker](core::task::Context::waker) will panic if used.
+///
+/// # Examples
+///
+/// ```should_panic
+/// #![feature(futures_api)]
+/// use futures_test::task::panic_context;
+///
+/// let cx = panic_context();
+/// cx.waker().wake_by_ref(); // Will panic
+/// ```
+pub fn panic_context() -> Context<'static> {
+    Context::from_waker(panic_waker_ref())
+}
+
+/// Create a new [`Context`](core::task::Context) where the
+/// [waker](core::task::Context::waker) will ignore any uses.
+///
+/// # Examples
+///
+/// ```
+/// #![feature(async_await, futures_api)]
+/// use futures::future::Future;
+/// use futures::task::Poll;
+/// use futures_test::task::noop_context;
+/// use pin_utils::pin_mut;
+///
+/// let mut future = async { 5 };
+/// pin_mut!(future);
+///
+/// assert_eq!(future.poll(&mut noop_context()), Poll::Ready(5));
+/// ```
+pub fn noop_context() -> Context<'static> {
+    Context::from_waker(noop_waker_ref())
+}

futures-test/src/task/mod.rs

@@ -1,9 +1,16 @@
 //! Task related testing utilities.
 //!
 //! This module provides utilities for creating test
+//! [`Context`](futures_core::task::Context)s,
 //! [`Waker`](futures_core::task::Waker)s and
 //! [`Spawn`](futures_core::task::Spawn) implementations.
 //!
+//! Test contexts:
+//! - [`noop_context`] creates a context that ignores calls to
+//!   [`cx.waker().wake_by_ref()`](futures_core::task::Waker).
+//! - [`panic_context`] creates a context that panics when
+//!   [`cx.waker().wake_by_ref()`](futures_core::task::Waker) is called.
+//!
 //! Test wakers:
 //! - [`noop_waker`] creates a waker that ignores calls to
 //!   [`wake`](futures_core::task::Waker).
@@ -23,6 +30,9 @@
 //! return waker/spawner references: [`noop_waker_ref`],
 //! [`panic_waker_ref`], [`noop_spawner_mut`] and [`panic_spawner_mut`].
 
+mod context;
+pub use self::context::{noop_context, panic_context};
+
 mod noop_spawner;
 pub use self::noop_spawner::{noop_spawner_mut, NoopSpawner};
 

futures-util/src/try_stream/into_async_read.rs

@@ -103,11 +103,11 @@ mod tests {
     use super::*;
     use futures::stream::{self, StreamExt, TryStreamExt};
     use futures_io::AsyncRead;
-    use futures_test::task::noop_waker_ref;
+    use futures_test::task::noop_context;
 
     macro_rules! assert_read {
         ($reader:expr, $buf:expr, $item:expr) => {
-            let mut cx = Context::from_waker(noop_waker_ref());
+            let mut cx = noop_context();
             match Pin::new(&mut $reader).poll_read(&mut cx, $buf) {
                 Poll::Ready(Ok(x)) => {
                     assert_eq!(x, $item);

futures-util/tests/futures_unordered.rs

@@ -1,13 +1,13 @@
 #![feature(async_await, await_macro, futures_api)]
 
 use futures::future;
-use futures::task::{Context, Poll};
+use futures::task::Poll;
 use futures::stream::{FusedStream, FuturesUnordered, StreamExt};
-use futures_test::task::noop_waker_ref;
+use futures_test::task::noop_context;
 
 #[test]
 fn is_terminated() {
-    let mut cx = Context::from_waker(noop_waker_ref());
+    let mut cx = noop_context();
     let mut tasks = FuturesUnordered::new();
 
     assert_eq!(tasks.is_terminated(), false);

futures-util/tests/mutex.rs

@@ -6,22 +6,22 @@ use futures::lock::Mutex;
 use futures::stream::StreamExt;
 use futures::task::{Context, SpawnExt};
 use futures_test::future::FutureTestExt;
-use futures_test::task::{panic_waker_ref, new_count_waker};
+use futures_test::task::{panic_context, new_count_waker};
 use std::sync::Arc;
 
 #[test]
 fn mutex_acquire_uncontested() {
     let mutex = Mutex::new(());
     for _ in 0..10 {
-        assert!(mutex.lock().poll_unpin(&mut Context::from_waker(panic_waker_ref())).is_ready());
+        assert!(mutex.lock().poll_unpin(&mut panic_context()).is_ready());
     }
 }
 
 #[test]
 fn mutex_wakes_waiters() {
     let mutex = Mutex::new(());
     let (waker, counter) = new_count_waker();
-    let lock = mutex.lock().poll_unpin(&mut Context::from_waker(panic_waker_ref()));
+    let lock = mutex.lock().poll_unpin(&mut panic_context());
     assert!(lock.is_ready());
 
     let mut cx = Context::from_waker(&waker);
@@ -32,7 +32,7 @@ fn mutex_wakes_waiters() {
     drop(lock);
 
     assert_eq!(counter, 1);
-    assert!(waiter.poll_unpin(&mut Context::from_waker(panic_waker_ref())).is_ready());
+    assert!(waiter.poll_unpin(&mut panic_context()).is_ready());
 }
 
 #[test]

futures-util/tests/select_all.rs

@@ -2,14 +2,14 @@
 
 use futures::future;
 use futures::FutureExt;
-use futures::task::{Context, Poll};
+use futures::task::Poll;
 use futures::stream::FusedStream;
 use futures::stream::{SelectAll, StreamExt};
-use futures_test::task::noop_waker_ref;
+use futures_test::task::noop_context;
 
 #[test]
 fn is_terminated() {
-    let mut cx = Context::from_waker(noop_waker_ref());
+    let mut cx = noop_context();
     let mut tasks = SelectAll::new();
 
     assert_eq!(tasks.is_terminated(), false);