futures: rework tests/ to work under all --feature combinations

futures/tests/abortable.rs

@@ -1,20 +1,25 @@
-use futures::channel::oneshot;
-use futures::executor::block_on;
-use futures::future::{abortable, Aborted, FutureExt};
-use futures::task::{Context, Poll};
-use futures_test::task::new_count_waker;
-
+#[cfg(all(feature = "alloc", feature = "executor"))]
 #[test]
 fn abortable_works() {
+    use futures::channel::oneshot;
+    use futures::future::{abortable, Aborted};
+    use futures::executor::block_on;
+
     let (_tx, a_rx) = oneshot::channel::<()>();
     let (abortable_rx, abort_handle) = abortable(a_rx);
 
     abort_handle.abort();
     assert_eq!(Err(Aborted), block_on(abortable_rx));
 }
 
+#[cfg(all(feature = "alloc", feature = "executor"))]
 #[test]
 fn abortable_awakens() {
+    use futures::channel::oneshot;
+    use futures::future::{abortable, Aborted, FutureExt};
+    use futures::task::{Context, Poll};
+    use futures_test::task::new_count_waker;
+
     let (_tx, a_rx) = oneshot::channel::<()>();
     let (mut abortable_rx, abort_handle) = abortable(a_rx);
 
@@ -28,8 +33,12 @@ fn abortable_awakens() {
     assert_eq!(Poll::Ready(Err(Aborted)), abortable_rx.poll_unpin(&mut cx));
 }
 
+#[cfg(all(feature = "alloc", feature = "executor"))]
 #[test]
 fn abortable_resolves() {
+    use futures::channel::oneshot;
+    use futures::future::abortable;
+    use futures::executor::block_on;
     let (tx, a_rx) = oneshot::channel::<()>();
     let (abortable_rx, _abort_handle) = abortable(a_rx);
 

futures/tests/arc_wake.rs

@@ -1,60 +1,79 @@
-use futures::task::{self, ArcWake, Waker};
-use std::sync::{Arc, Mutex};
+#[cfg(feature = "alloc")]
+mod countingwaker {
+    use futures::task::{self, ArcWake, Waker};
+    use std::sync::{Arc, Mutex};
 
-struct CountingWaker {
-    nr_wake: Mutex<i32>,
-}
+    struct CountingWaker {
+        nr_wake: Mutex<i32>,
+    }
 
-impl CountingWaker {
-    fn new() -> CountingWaker {
-        CountingWaker {
-            nr_wake: Mutex::new(0),
+    impl CountingWaker {
+        fn new() -> CountingWaker {
+            CountingWaker {
+                nr_wake: Mutex::new(0),
+            }
         }
-    }
 
-    fn wakes(&self) -> i32 {
-        *self.nr_wake.lock().unwrap()
+        fn wakes(&self) -> i32 {
+            *self.nr_wake.lock().unwrap()
+        }
     }
-}
 
-impl ArcWake for CountingWaker {
-    fn wake_by_ref(arc_self: &Arc<Self>) {
-        let mut lock = arc_self.nr_wake.lock().unwrap();
-        *lock += 1;
+    impl ArcWake for CountingWaker {
+        fn wake_by_ref(arc_self: &Arc<Self>) {
+            let mut lock = arc_self.nr_wake.lock().unwrap();
+            *lock += 1;
+        }
     }
-}
 
-#[test]
-fn create_waker_from_arc() {
-    let some_w = Arc::new(CountingWaker::new());
+    #[test]
+    fn create_from_arc() {
+        let some_w = Arc::new(CountingWaker::new());
 
-    let w1: Waker = task::waker(some_w.clone());
-    assert_eq!(2, Arc::strong_count(&some_w));
-    w1.wake_by_ref();
-    assert_eq!(1, some_w.wakes());
+        let w1: Waker = task::waker(some_w.clone());
+        assert_eq!(2, Arc::strong_count(&some_w));
+        w1.wake_by_ref();
+        assert_eq!(1, some_w.wakes());
 
-    let w2 = w1.clone();
-    assert_eq!(3, Arc::strong_count(&some_w));
+        let w2 = w1.clone();
+        assert_eq!(3, Arc::strong_count(&some_w));
 
-    w2.wake_by_ref();
-    assert_eq!(2, some_w.wakes());
+        w2.wake_by_ref();
+        assert_eq!(2, some_w.wakes());
 
-    drop(w2);
-    assert_eq!(2, Arc::strong_count(&some_w));
-    drop(w1);
-    assert_eq!(1, Arc::strong_count(&some_w));
-}
+        drop(w2);
+        assert_eq!(2, Arc::strong_count(&some_w));
+        drop(w1);
+        assert_eq!(1, Arc::strong_count(&some_w));
+    }
 
-struct PanicWaker;
+    #[test]
+    fn ref_wake_same() {
+        let some_w = Arc::new(CountingWaker::new());
 
-impl ArcWake for PanicWaker {
-    fn wake_by_ref(_arc_self: &Arc<Self>) {
-        panic!("WAKE UP");
+        let w1: Waker = task::waker(some_w.clone());
+        let w2 = task::waker_ref(&some_w);
+        let w3 = w2.clone();
+
+        assert!(w1.will_wake(&w2));
+        assert!(w2.will_wake(&w3));
     }
 }
 
+#[cfg(feature = "alloc")]
 #[test]
 fn proper_refcount_on_wake_panic() {
+    use futures::task::{self, ArcWake, Waker};
+    use std::sync::Arc;
+
+    struct PanicWaker;
+
+    impl ArcWake for PanicWaker {
+        fn wake_by_ref(_arc_self: &Arc<Self>) {
+            panic!("WAKE UP");
+        }
+    }
+
     let some_w = Arc::new(PanicWaker);
 
     let w1: Waker = task::waker(some_w.clone());
@@ -63,15 +82,3 @@ fn proper_refcount_on_wake_panic() {
     drop(w1);
     assert_eq!(1, Arc::strong_count(&some_w)); // some_w
 }
-
-#[test]
-fn waker_ref_wake_same() {
-    let some_w = Arc::new(CountingWaker::new());
-
-    let w1: Waker = task::waker(some_w.clone());
-    let w2 = task::waker_ref(&some_w);
-    let w3 = w2.clone();
-
-    assert!(w1.will_wake(&w2));
-    assert!(w2.will_wake(&w3));
-}