1 files changed, 65 insertions, 13 deletions

diff --git a/tests/futures_unordered.rs b/tests/futures_unordered.rs
index 57eb98f..3285903 100644
--- a/tests/futures_unordered.rs
+++ b/tests/futures_unordered.rs
@@ -1,18 +1,11 @@
-use std::marker::Unpin;
-use std::pin::Pin;
-use std::sync::atomic::{AtomicBool, Ordering};
-
-use futures::channel::oneshot;
-use futures::executor::{block_on, block_on_stream};
-use futures::future::{self, join, Future, FutureExt};
-use futures::stream::{FusedStream, FuturesUnordered, StreamExt};
-use futures::task::{Context, Poll};
-use futures_test::future::FutureTestExt;
-use futures_test::task::noop_context;
-use futures_test::{assert_stream_done, assert_stream_next};
-
+#[cfg(feature = "alloc")]
 #[test]
 fn is_terminated() {
+    use futures::future;
+    use futures::stream::{FusedStream, FuturesUnordered, StreamExt};
+    use futures::task::Poll;
+    use futures_test::task::noop_context;
+
     let mut cx = noop_context();
     let mut tasks = FuturesUnordered::new();
 
@@ -38,8 +31,13 @@ fn is_terminated() {
     assert_eq!(tasks.is_terminated(), true);
 }
 
+#[cfg(all(feature = "alloc", feature = "executor"))]
 #[test]
 fn works_1() {
+    use futures::channel::oneshot;
+    use futures::executor::block_on_stream;
+    use futures::stream::FuturesUnordered;
+
     let (a_tx, a_rx) = oneshot::channel::<i32>();
     let (b_tx, b_rx) = oneshot::channel::<i32>();
     let (c_tx, c_rx) = oneshot::channel::<i32>();
@@ -60,8 +58,15 @@ fn works_1() {
     assert_eq!(None, iter.next());
 }
 
+#[cfg(feature = "alloc")]
 #[test]
 fn works_2() {
+    use futures::channel::oneshot;
+    use futures::future::{join, FutureExt};
+    use futures::stream::{FuturesUnordered, StreamExt};
+    use futures::task::Poll;
+    use futures_test::task::noop_context;
+
     let (a_tx, a_rx) = oneshot::channel::<i32>();
     let (b_tx, b_rx) = oneshot::channel::<i32>();
     let (c_tx, c_rx) = oneshot::channel::<i32>();
@@ -83,8 +88,13 @@ fn works_2() {
     assert_eq!(stream.poll_next_unpin(&mut cx), Poll::Ready(None));
 }
 
+#[cfg(feature = "executor")]
 #[test]
 fn from_iterator() {
+    use futures::executor::block_on;
+    use futures::future;
+    use futures::stream::{FuturesUnordered, StreamExt};
+
     let stream = vec![
         future::ready::<i32>(1),
         future::ready::<i32>(2),
@@ -96,8 +106,15 @@ fn from_iterator() {
     assert_eq!(block_on(stream.collect::<Vec<_>>()), vec![1, 2, 3]);
 }
 
+#[cfg(feature = "alloc")]
 #[test]
 fn finished_future() {
+    use std::marker::Unpin;
+    use futures::channel::oneshot;
+    use futures::future::{self, Future, FutureExt};
+    use futures::stream::{FuturesUnordered, StreamExt};
+    use futures_test::task::noop_context;
+
     let (_a_tx, a_rx) = oneshot::channel::<i32>();
     let (b_tx, b_rx) = oneshot::channel::<i32>();
     let (c_tx, c_rx) = oneshot::channel::<i32>();
@@ -121,8 +138,13 @@ fn finished_future() {
     assert!(stream.poll_next_unpin(cx).is_pending());
 }
 
+#[cfg(all(feature = "alloc", feature = "executor"))]
 #[test]
 fn iter_mut_cancel() {
+    use futures::channel::oneshot;
+    use futures::executor::block_on_stream;
+    use futures::stream::FuturesUnordered;
+
     let (a_tx, a_rx) = oneshot::channel::<i32>();
     let (b_tx, b_rx) = oneshot::channel::<i32>();
     let (c_tx, c_rx) = oneshot::channel::<i32>();
@@ -147,8 +169,12 @@ fn iter_mut_cancel() {
     assert_eq!(iter.next(), None);
 }
 
+#[cfg(feature = "alloc")]
 #[test]
 fn iter_mut_len() {
+    use futures::future;
+    use futures::stream::FuturesUnordered;
+
     let mut stream = vec![
         future::pending::<()>(),
         future::pending::<()>(),
@@ -168,8 +194,18 @@ fn iter_mut_len() {
     assert!(iter_mut.next().is_none());
 }
 
+#[cfg(feature = "executor")]
 #[test]
 fn iter_cancel() {
+    use std::marker::Unpin;
+    use std::pin::Pin;
+    use std::sync::atomic::{AtomicBool, Ordering};
+
+    use futures::executor::block_on_stream;
+    use futures::future::{self, Future, FutureExt};
+    use futures::stream::FuturesUnordered;
+    use futures::task::{Context, Poll};
+
     struct AtomicCancel<F> {
         future: F,
         cancel: AtomicBool,
@@ -213,8 +249,12 @@ fn iter_cancel() {
     assert_eq!(iter.next(), None);
 }
 
+#[cfg(feature = "alloc")]
 #[test]
 fn iter_len() {
+    use futures::future;
+    use futures::stream::FuturesUnordered;
+
     let stream = vec![
         future::pending::<()>(),
         future::pending::<()>(),
@@ -234,8 +274,14 @@ fn iter_len() {
     assert!(iter.next().is_none());
 }
 
+#[cfg(feature = "alloc")]
 #[test]
 fn futures_not_moved_after_poll() {
+    use futures::future;
+    use futures::stream::FuturesUnordered;
+    use futures_test::future::FutureTestExt;
+    use futures_test::{assert_stream_done, assert_stream_next};
+
     // Future that will be ready after being polled twice,
     // asserting that it does not move.
     let fut = future::ready(()).pending_once().assert_unmoved();
@@ -246,8 +292,14 @@ fn futures_not_moved_after_poll() {
     assert_stream_done!(stream);
 }
 
+#[cfg(feature = "alloc")]
 #[test]
 fn len_valid_during_out_of_order_completion() {
+    use futures::channel::oneshot;
+    use futures::stream::{FuturesUnordered, StreamExt};
+    use futures::task::Poll;
+    use futures_test::task::noop_context;
+
     // Complete futures out-of-order and add new futures afterwards to ensure
     // length values remain correct.
     let (a_tx, a_rx) = oneshot::channel::<i32>();