futures: separate std-future tests into submodule that is only run on the nightly toolchain

Author: mbilker

.travis.yml

@@ -28,6 +28,6 @@ jobs:
   - script: cargo test --features=doctest-readme --all
     name: "doctest readme"
     rust: nightly
-  - script: (cd tracing-futures && cargo test --all-features)
-    name: "futures all features"
+  - script: (cd tracing-futures/test_std_futures && cargo test)
+    name: "futures nightly"
     rust: nightly

tracing-futures/Cargo.toml

@@ -18,6 +18,5 @@ tokio-executor = { version = "0.1", optional = true }
 
 [dev-dependencies]
 tokio = "0.1.22"
-tokio-test = { git = "https://github.com/tokio-rs/tokio.git" }
 tracing-fmt = { path = "../tracing-fmt" }
 tracing-core = "0.1.2"

tracing-futures/src/lib.rs

@@ -194,8 +194,6 @@ mod tests {
 
     #[cfg(feature = "futures-01")]
     use futures::{future, stream, task, Async, Future};
-    #[cfg(feature = "std-future")]
-    use tokio_test::task::MockTask;
     use tracing::{subscriber::with_default, Level};
 
     struct PollN<T, E> {
@@ -204,28 +202,6 @@ mod tests {
         polls: usize,
     }
 
-    #[cfg(feature = "std-future")]
-    impl<T, E> std::future::Future for PollN<T, E>
-    where
-        T: Unpin,
-        E: Unpin,
-    {
-        type Output = Result<T, E>;
-        fn poll(self: Pin<&mut Self>, lw: &mut Context) -> std::task::Poll<Self::Output> {
-            let this = self.get_mut();
-
-            this.polls += 1;
-            if this.polls == this.finish_at {
-                let value = this.and_return.take().expect("polled after ready");
-
-                std::task::Poll::Ready(value)
-            } else {
-                lw.waker().wake_by_ref();
-                std::task::Poll::Pending
-            }
-        }
-    }
-
     #[cfg(feature = "futures-01")]
     impl<T, E> futures::Future for PollN<T, E> {
         type Item = T;
@@ -372,42 +348,4 @@ mod tests {
         });
         handle.assert_finished();
     }
-
-    #[cfg(feature = "std-future")]
-    #[test]
-    fn std_future_enter_exit_is_reasonable() {
-        let (subscriber, handle) = subscriber::mock()
-            .enter(span::mock().named("foo"))
-            .exit(span::mock().named("foo"))
-            .enter(span::mock().named("foo"))
-            .exit(span::mock().named("foo"))
-            .drop_span(span::mock().named("foo"))
-            .done()
-            .run_with_handle();
-        let mut task = MockTask::new();
-        with_default(subscriber, || {
-            let future = PollN::new_ok(2).instrument(span!(Level::TRACE, "foo"));
-            block_on_future(&mut task, future).unwrap();
-        });
-        handle.assert_finished();
-    }
-
-    #[cfg(feature = "std-future")]
-    #[test]
-    fn std_future_error_ends_span() {
-        let (subscriber, handle) = subscriber::mock()
-            .enter(span::mock().named("foo"))
-            .exit(span::mock().named("foo"))
-            .enter(span::mock().named("foo"))
-            .exit(span::mock().named("foo"))
-            .drop_span(span::mock().named("foo"))
-            .done()
-            .run_with_handle();
-        let mut task = MockTask::new();
-        with_default(subscriber, || {
-            let future = PollN::new_err(2).instrument(span!(Level::TRACE, "foo"));
-            block_on_future(&mut task, future).unwrap_err();
-        });
-        handle.assert_finished();
-    }
 }

tracing-futures/test_std_future/Cargo.toml

@@ -0,0 +1,18 @@
+# Note: these tests depend on crates that use nightly features which do not
+# run under stable and beta toolchains.
+#
+# Do not add these tests to the other tracing-futures tests unless the
+# minimum Rust version is at least 1.36.
+[workspace]
+
+[package]
+name = "test_std_future"
+version = "0.1.0"
+publish = false
+edition = "2018"
+
+[dependencies]
+tokio-test = { git = "https://github.com/tokio-rs/tokio.git" }
+tracing = "0.1"
+tracing-core = "0.1.2"
+tracing-futures = { path = "..", features = ["std-future"] }

tracing-futures/test_std_future/tests/test.rs

@@ -0,0 +1,111 @@
+#[macro_use]
+extern crate tracing;
+extern crate tracing_core;
+
+pub use self::support as test_support;
+// This has to have the same name as the module in `tracing`.
+#[path = "../../../tracing/tests/support/mod.rs"]
+pub mod support;
+
+use std::pin::Pin;
+use std::task::Context;
+
+use support::*;
+use tokio_test::task::MockTask;
+use tracing::{subscriber::with_default, Level};
+use tracing_futures::Instrument;
+
+struct PollN<T, E> {
+    and_return: Option<Result<T, E>>,
+    finish_at: usize,
+    polls: usize,
+}
+
+impl<T, E> std::future::Future for PollN<T, E>
+where
+    T: Unpin,
+    E: Unpin,
+{
+    type Output = Result<T, E>;
+    fn poll(self: Pin<&mut Self>, lw: &mut Context) -> std::task::Poll<Self::Output> {
+        let this = self.get_mut();
+
+        this.polls += 1;
+        if this.polls == this.finish_at {
+            let value = this.and_return.take().expect("polled after ready");
+
+            std::task::Poll::Ready(value)
+        } else {
+            lw.waker().wake_by_ref();
+            std::task::Poll::Pending
+        }
+    }
+}
+
+impl PollN<(), ()> {
+    fn new_ok(finish_at: usize) -> Self {
+        Self {
+            and_return: Some(Ok(())),
+            finish_at,
+            polls: 0,
+        }
+    }
+
+    fn new_err(finish_at: usize) -> Self {
+        Self {
+            and_return: Some(Err(())),
+            finish_at,
+            polls: 0,
+        }
+    }
+}
+
+fn block_on_future<F>(task: &mut MockTask, future: F) -> F::Output
+where
+    F: std::future::Future,
+{
+    let mut future = Box::pin(future);
+
+    loop {
+        match task.poll(&mut future) {
+            std::task::Poll::Ready(v) => break v,
+            _ => {}
+        }
+    }
+}
+
+#[test]
+fn std_future_enter_exit_is_reasonable() {
+    let (subscriber, handle) = subscriber::mock()
+        .enter(span::mock().named("foo"))
+        .exit(span::mock().named("foo"))
+        .enter(span::mock().named("foo"))
+        .exit(span::mock().named("foo"))
+        .drop_span(span::mock().named("foo"))
+        .done()
+        .run_with_handle();
+    let mut task = MockTask::new();
+    with_default(subscriber, || {
+        let future = PollN::new_ok(2).instrument(span!(Level::TRACE, "foo"));
+        block_on_future(&mut task, future).unwrap();
+    });
+    handle.assert_finished();
+}
+
+#[test]
+fn std_future_error_ends_span() {
+    let (subscriber, handle) = subscriber::mock()
+        .enter(span::mock().named("foo"))
+        .exit(span::mock().named("foo"))
+        .enter(span::mock().named("foo"))
+        .exit(span::mock().named("foo"))
+        .drop_span(span::mock().named("foo"))
+        .done()
+        .run_with_handle();
+    let mut task = MockTask::new();
+    with_default(subscriber, || {
+        let future = PollN::new_err(2).instrument(span!(Level::TRACE, "foo"));
+        block_on_future(&mut task, future).unwrap_err();
+    });
+    handle.assert_finished();
+}