Fix some (clippy) warnings

Author: ishitatsuyuki

tests/all.rs

@@ -27,10 +27,10 @@ fn result_smoke() {
 
     is_future_v::<i32, u32, _>(f_ok(1).map(|a| a + 1));
     is_future_v::<i32, u32, _>(f_ok(1).map_err(|a| a + 1));
-    is_future_v::<i32, u32, _>(f_ok(1).and_then(|a| Ok(a)));
-    is_future_v::<i32, u32, _>(f_ok(1).or_else(|a| Err(a)));
+    is_future_v::<i32, u32, _>(f_ok(1).and_then(Ok));
+    is_future_v::<i32, u32, _>(f_ok(1).or_else(Err));
     is_future_v::<(i32, i32), u32, _>(f_ok(1).join(Err(3)));
-    is_future_v::<i32, u32, _>(f_ok(1).map(move |a| f_ok(a)).flatten());
+    is_future_v::<i32, u32, _>(f_ok(1).map(f_ok).flatten());
 
     assert_done(|| f_ok(1), r_ok(1));
     assert_done(|| f_err(1), r_err(1));

tests/mpsc-close.rs

@@ -10,11 +10,8 @@ fn smoke() {
     let (mut sender, receiver) = channel(1);
 
     let t = thread::spawn(move ||{
-        loop {
-            match sender.send(42).wait() {
-                Ok(s) => sender = s,
-                Err(_) => break,
-            }
+        while let Ok(s) = sender.send(42).wait() {
+            sender = s;
         }
     });
 

tests/mpsc.rs

@@ -151,11 +151,11 @@ fn stress_shared_unbounded() {
     });
 
     for _ in 0..NTHREADS {
-        let mut tx = tx.clone();
+        let tx = tx.clone();
 
         thread::spawn(move|| {
             for _ in 0..AMT {
-                mpsc::UnboundedSender::send(&mut tx, 1).unwrap();
+                mpsc::UnboundedSender::send(&tx, 1).unwrap();
             }
         });
     }

tests/select_all.rs

@@ -22,5 +22,5 @@ fn smoke() {
     assert_eq!(i, 3);
     assert_eq!(idx, 0);
 
-    assert!(v.len() == 0);
+    assert!(v.is_empty());
 }

tests/select_ok.rs

@@ -14,12 +14,12 @@ fn ignore_err() {
     let (i, v) = select_ok(v).wait().ok().unwrap();
     assert_eq!(i, 3);
 
-    assert!(v.len() == 1);
+    assert_eq!(v.len(), 1);
 
     let (i, v) = select_ok(v).wait().ok().unwrap();
     assert_eq!(i, 4);
 
-    assert!(v.len() == 0);
+    assert!(v.is_empty());
 }
 
 #[test]
@@ -33,7 +33,7 @@ fn last_err() {
     let (i, v) = select_ok(v).wait().ok().unwrap();
     assert_eq!(i, 1);
 
-    assert!(v.len() == 2);
+    assert_eq!(v.len(), 2);
 
     let i = select_ok(v).wait().err().unwrap();
     assert_eq!(i, 3);

tests/shared.rs

@@ -16,11 +16,11 @@ fn send_shared_oneshot_and_wait_on_multiple_threads(threads_number: u32) {
     let threads = (0..threads_number).map(|_| {
         let cloned_future = f.clone();
         thread::spawn(move || {
-            assert!(*cloned_future.wait().unwrap() == 6);
+            assert_eq!(*cloned_future.wait().unwrap(), 6);
         })
     }).collect::<Vec<_>>();
     tx.send(6).unwrap();
-    assert!(*f.wait().unwrap() == 6);
+    assert_eq!(*f.wait().unwrap(), 6);
     for f in threads {
         f.join().unwrap();
     }
@@ -57,7 +57,7 @@ fn drop_on_one_task_ok() {
     let (tx3, rx3) = oneshot::channel::<u32>();
 
     let t2 = thread::spawn(|| {
-        drop(f2.map(|x| tx3.send(*x).unwrap()).map_err(|_| ()).wait());
+        let _ = f2.map(|x| tx3.send(*x).unwrap()).map_err(|_| ()).wait();
     });
 
     tx2.send(11).unwrap(); // cancel `f1`

tests/support/local_executor.rs

@@ -74,8 +74,7 @@ impl Core {
         let mut task = if let hash_map::Entry::Occupied(x) = self.live.entry(task) { x } else { return };
         let result = task.get_mut().poll_future_notify(&notify, 0);
         match result {
-            Ok(Async::Ready(())) => { task.remove(); }
-            Err(()) => { task.remove(); }
+            Ok(Async::Ready(())) | Err(()) => { task.remove(); }
             Ok(Async::NotReady) => {}
         }
     }

tests/support/mod.rs

@@ -125,7 +125,7 @@ impl<F: Future> Future for DelayFuture<F> {
     }
 }
 
-/// Introduces one Ok(Async::NotReady) before polling the given future
+/// Introduces one `Ok(Async::NotReady)` before polling the given future
 pub fn delay_future<F>(f: F) -> DelayFuture<F::Future>
     where F: IntoFuture,
 {

tests/unsync.rs

@@ -69,7 +69,7 @@ fn mpsc_backpressure() {
             .forward(tx)
             .map_err(|e: SendError<i32>| panic!("{}", e))
             .join(rx.take(3).collect().map(|xs| {
-                assert!(xs == [1, 2, 3]);
+                assert_eq!(xs, [1, 2, 3]);
             }))
     }).wait().unwrap();
 }
@@ -82,7 +82,7 @@ fn mpsc_unbounded() {
             .forward(tx)
             .map_err(|e: SendError<i32>| panic!("{}", e))
             .join(rx.take(3).collect().map(|xs| {
-                assert!(xs == [1, 2, 3]);
+                assert_eq!(xs, [1, 2, 3]);
             }))
     }).wait().unwrap();
 }
@@ -92,7 +92,7 @@ fn mpsc_recv_unpark() {
     let mut core = Core::new();
     let (tx, rx) = mpsc::channel::<i32>(1);
     let tx2 = tx.clone();
-    core.spawn(rx.collect().map(|xs| assert!(xs == [1, 2])));
+    core.spawn(rx.collect().map(|xs| assert_eq!(xs, [1, 2])));
     core.spawn(lazy(move || tx.send(1).map(|_| ()).map_err(|e| panic!("{}", e))));
     core.run(lazy(move || tx2.send(2))).unwrap();
 }