Replace futures::future::ready with our implementation in tests

Author: kpp

src/future.rs

@@ -88,7 +88,7 @@ pub async fn inspect<Fut, F>(future: Fut, f: F) -> Fut::Output
 
 #[cfg(test)]
 mod tests {
-    use futures::{future, executor};
+    use futures::executor;
     use crate::future::*;
 
     #[test]
@@ -102,7 +102,7 @@ mod tests {
     #[test]
     fn test_map() {
         executor::block_on(async {
-            let future = future::ready(1);
+            let future = ready(1);
             let new_future = map(future, |x| x + 3);
             assert_eq!(await!(new_future), 4);
         });
@@ -111,34 +111,34 @@ mod tests {
     #[test]
     fn test_then() {
         executor::block_on(async {
-            let future = future::ready(1);
-            let new_future = then(future, |x| future::ready(x + 3));
+            let future = ready(1);
+            let new_future = then(future, |x| ready(x + 3));
             assert_eq!(await!(new_future), 4);
         });
     }
 
     #[test]
     fn test_and_then() {
         executor::block_on(async {
-            let future = future::ready(Ok::<i32, i32>(1));
-            let new_future = and_then(future, |x| future::ready(Ok::<i32, i32>(x + 3)));
+            let future = ready(Ok::<i32, i32>(1));
+            let new_future = and_then(future, |x| ready(Ok::<i32, i32>(x + 3)));
             assert_eq!(await!(new_future), Ok(4));
         });
     }
 
     #[test]
     fn test_or_else() {
         executor::block_on(async {
-            let future = future::ready(Err::<i32, i32>(1));
-            let new_future = or_else(future, |x| future::ready(Err::<i32, i32>(x + 3)));
+            let future = ready(Err::<i32, i32>(1));
+            let new_future = or_else(future, |x| ready(Err::<i32, i32>(x + 3)));
             assert_eq!(await!(new_future), Err(4));
         });
     }
 
     #[test]
     fn test_map_ok() {
         executor::block_on(async {
-            let future = future::ready(Ok::<i32, i32>(1));
+            let future = ready(Ok::<i32, i32>(1));
             let new_future = map_ok(future, |x| x + 3);
             assert_eq!(await!(new_future), Ok(4));
         });
@@ -147,7 +147,7 @@ mod tests {
     #[test]
     fn test_map_err() {
         executor::block_on(async {
-            let future = future::ready(Err::<i32, i32>(1));
+            let future = ready(Err::<i32, i32>(1));
             let new_future = map_err(future, |x| x + 3);
             assert_eq!(await!(new_future), Err(4));
         });
@@ -156,7 +156,7 @@ mod tests {
     #[test]
     fn test_flatten() {
         executor::block_on(async {
-            let nested_future = future::ready(future::ready(1));
+            let nested_future = ready(ready(1));
             let future = flatten(nested_future);
             assert_eq!(await!(future), 1);
         });
@@ -165,7 +165,7 @@ mod tests {
     #[test]
     fn test_inspect() {
         executor::block_on(async {
-            let future = future::ready(1);
+            let future = ready(1);
             let new_future = inspect(future, |&x| assert_eq!(x, 1));
             assert_eq!(await!(new_future), 1);
         });

src/stream.rs

@@ -74,8 +74,9 @@ pub fn filter_map<St, Fut, F, U>(stream: St, f: F) -> impl Stream<Item = U>
 
 #[cfg(test)]
 mod tests {
-    use futures::{executor, future, stream};
+    use futures::{executor, stream};
     use crate::stream::*;
+    use crate::future::ready;
 
     #[test]
     fn test_next() {
@@ -106,7 +107,7 @@ mod tests {
     #[test]
     fn test_filter() {
         let stream = stream::iter(1..=10);
-        let evens = filter(stream, |x| future::ready(x % 2 == 0));
+        let evens = filter(stream, |x| ready(x % 2 == 0));
 
         assert_eq!(vec![2, 4, 6, 8, 10], executor::block_on(collect::<_, Vec<_>>(evens)));
     }
@@ -116,7 +117,7 @@ mod tests {
         let stream = stream::iter(1..=10);
         let evens = filter_map(stream, |x| {
             let ret = if x % 2 == 0 { Some(x + 1) } else { None };
-            future::ready(ret)
+            ready(ret)
         });
 
         assert_eq!(vec![3, 5, 7, 9, 11], executor::block_on(collect::<_, Vec<_>>(evens)));