chore: apply rustfmt to all crates (#917)

tokio-timer/tests/deadline.rs

@@ -9,8 +9,8 @@ use support::*;
 
 use tokio_timer::*;
 
-use futures::{future, Future};
 use futures::sync::oneshot;
+use futures::{future, Future};
 
 #[test]
 fn simultaneous_deadline_future_completion() {

tokio-timer/tests/delay.rs

@@ -6,8 +6,8 @@ extern crate tokio_timer;
 mod support;
 use support::*;
 
-use tokio_timer::*;
 use tokio_timer::timer::Handle;
+use tokio_timer::*;
 
 use futures::Future;
 
@@ -52,9 +52,7 @@ fn delayed_delay_level_0() {
 fn sub_ms_delayed_delay() {
     mocked(|timer, time| {
         for _ in 0..5 {
-            let deadline = time.now()
-                + Duration::from_millis(1)
-                + Duration::new(0, 1);
+            let deadline = time.now() + Duration::from_millis(1) + Duration::new(0, 1);
 
             let mut delay = Delay::new(deadline);
 
@@ -282,11 +280,7 @@ fn sorta_long_delay() {
         // The delay has not elapsed.
         assert_not_ready!(delay);
 
-        let cascades = &[
-            262_144,
-            262_144 + 9 * 4096,
-            262_144 + 9 * 4096 + 15 * 64,
-        ];
+        let cascades = &[262_144, 262_144 + 9 * 4096, 262_144 + 9 * 4096 + 15 * 64];
 
         for &elapsed in cascades {
             turn(timer, None);

tokio-timer/tests/hammer.rs

@@ -6,14 +6,14 @@ extern crate tokio_timer;
 use tokio_executor::park::{Park, Unpark, UnparkThread};
 use tokio_timer::*;
 
-use futures::{Future, Stream};
 use futures::stream::FuturesUnordered;
+use futures::{Future, Stream};
 use rand::Rng;
 
 use std::cmp;
-use std::sync::{Arc, Barrier};
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering::SeqCst;
+use std::sync::{Arc, Barrier};
 use std::thread;
 use std::time::{Duration, Instant};
 
@@ -52,23 +52,20 @@ fn hammer_complete() {
                 barrier.wait();
 
                 for _ in 0..PER_THREAD {
-                    let deadline = Instant::now() + Duration::from_millis(
-                        rng.gen_range(MIN_DELAY, MAX_DELAY));
+                    let deadline =
+                        Instant::now() + Duration::from_millis(rng.gen_range(MIN_DELAY, MAX_DELAY));
 
                     exec.push({
-                        handle.delay(deadline)
-                            .and_then(move |_| {
-                                let now = Instant::now();
-                                assert!(now >= deadline, "deadline greater by {:?}", deadline - now);
-                                Ok(())
-                            })
+                        handle.delay(deadline).and_then(move |_| {
+                            let now = Instant::now();
+                            assert!(now >= deadline, "deadline greater by {:?}", deadline - now);
+                            Ok(())
+                        })
                     });
                 }
 
                 // Run the logic
-                exec.for_each(|_| Ok(()))
-                    .wait()
-                    .unwrap();
+                exec.for_each(|_| Ok(())).wait().unwrap();
 
                 if 1 == done.rem.fetch_sub(1, SeqCst) {
                     done.unpark.unpark();
@@ -112,11 +109,11 @@ fn hammer_cancel() {
                 barrier.wait();
 
                 for _ in 0..PER_THREAD {
-                    let deadline1 = Instant::now() + Duration::from_millis(
-                        rng.gen_range(MIN_DELAY, MAX_DELAY));
+                    let deadline1 =
+                        Instant::now() + Duration::from_millis(rng.gen_range(MIN_DELAY, MAX_DELAY));
 
-                    let deadline2 = Instant::now() + Duration::from_millis(
-                        rng.gen_range(MIN_DELAY, MAX_DELAY));
+                    let deadline2 =
+                        Instant::now() + Duration::from_millis(rng.gen_range(MIN_DELAY, MAX_DELAY));
 
                     let deadline = cmp::min(deadline1, deadline2);
 
@@ -124,24 +121,22 @@ fn hammer_cancel() {
                     let join = handle.deadline(delay, deadline2);
 
                     exec.push({
-                        join
-                            .and_then(move |_| {
-                                let now = Instant::now();
-                                assert!(now >= deadline, "deadline greater by {:?}", deadline - now);
-                                Ok(())
-                            })
+                        join.and_then(move |_| {
+                            let now = Instant::now();
+                            assert!(now >= deadline, "deadline greater by {:?}", deadline - now);
+                            Ok(())
+                        })
                     });
                 }
 
                 // Run the logic
-                exec
-                    .or_else(|e| {
-                        assert!(e.is_elapsed());
-                        Ok::<_, ()>(())
-                    })
-                    .for_each(|_| Ok(()))
-                    .wait()
-                    .unwrap();
+                exec.or_else(|e| {
+                    assert!(e.is_elapsed());
+                    Ok::<_, ()>(())
+                })
+                .for_each(|_| Ok(()))
+                .wait()
+                .unwrap();
 
                 if 1 == done.rem.fetch_sub(1, SeqCst) {
                     done.unpark.unpark();
@@ -185,17 +180,18 @@ fn hammer_reset() {
                 barrier.wait();
 
                 for _ in 0..PER_THREAD {
-                    let deadline1 = Instant::now() + Duration::from_millis(
-                        rng.gen_range(MIN_DELAY, MAX_DELAY));
+                    let deadline1 =
+                        Instant::now() + Duration::from_millis(rng.gen_range(MIN_DELAY, MAX_DELAY));
 
-                    let deadline2 = deadline1 + Duration::from_millis(
-                        rng.gen_range(MIN_DELAY, MAX_DELAY));
+                    let deadline2 =
+                        deadline1 + Duration::from_millis(rng.gen_range(MIN_DELAY, MAX_DELAY));
 
-                    let deadline3 = deadline2 + Duration::from_millis(
-                        rng.gen_range(MIN_DELAY, MAX_DELAY));
+                    let deadline3 =
+                        deadline2 + Duration::from_millis(rng.gen_range(MIN_DELAY, MAX_DELAY));
 
                     exec.push({
-                        handle.delay(deadline1)
+                        handle
+                            .delay(deadline1)
                             // Select over a second delay
                             .select2(handle.delay(deadline2))
                             .map_err(|e| panic!("boom; err={:?}", e))
@@ -203,7 +199,11 @@ fn hammer_reset() {
                                 use futures::future::Either::*;
 
                                 let now = Instant::now();
-                                assert!(now >= deadline1, "deadline greater by {:?}", deadline1 - now);
+                                assert!(
+                                    now >= deadline1,
+                                    "deadline greater by {:?}",
+                                    deadline1 - now
+                                );
 
                                 let mut other = match res {
                                     A((_, other)) => other,
@@ -215,17 +215,18 @@ fn hammer_reset() {
                             })
                             .and_then(move |_| {
                                 let now = Instant::now();
-                                assert!(now >= deadline3, "deadline greater by {:?}", deadline3 - now);
+                                assert!(
+                                    now >= deadline3,
+                                    "deadline greater by {:?}",
+                                    deadline3 - now
+                                );
                                 Ok(())
                             })
                     });
                 }
 
                 // Run the logic
-                exec
-                    .for_each(|_| Ok(()))
-                    .wait()
-                    .unwrap();
+                exec.for_each(|_| Ok(())).wait().unwrap();
 
                 if 1 == done.rem.fetch_sub(1, SeqCst) {
                     done.unpark.unpark();

tokio-timer/tests/interval.rs

@@ -8,7 +8,7 @@ use support::*;
 
 use tokio_timer::*;
 
-use futures::{Stream};
+use futures::Stream;
 
 #[test]
 #[should_panic]

tokio-timer/tests/queue.rs

@@ -1,14 +1,14 @@
 extern crate futures;
 extern crate tokio_executor;
-extern crate tokio_timer;
 extern crate tokio_mock_task;
+extern crate tokio_timer;
 
 #[macro_use]
 mod support;
 use support::*;
 
-use tokio_timer::*;
 use tokio_mock_task::MockTask;
+use tokio_timer::*;
 
 use futures::Stream;
 
@@ -286,7 +286,6 @@ fn expires_before_last_insert() {
         let mut queue = DelayQueue::new();
         let mut task = MockTask::new();
 
-
         let epoch = time.now();
 
         queue.insert_at("foo", epoch + ms(10_000));
@@ -308,7 +307,6 @@ fn expires_before_last_insert() {
         assert!(task.is_notified());
         let entry = assert_ready!(queue).unwrap().into_inner();
         assert_eq!(entry, "bar");
-
     })
 }
 
@@ -383,7 +381,6 @@ fn expire_second_key_when_reset_to_expire_earlier() {
     })
 }
 
-
 #[test]
 fn reset_first_expiring_item_to_expire_later() {
     mocked(|timer, time| {

tokio-timer/tests/support/mod.rs

@@ -9,7 +9,7 @@ use futures::future::{lazy, Future};
 use std::marker::PhantomData;
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};
-use std::time::{Instant, Duration};
+use std::time::{Duration, Instant};
 
 macro_rules! assert_ready {
     ($f:expr) => {{
@@ -56,7 +56,7 @@ macro_rules! assert_not_ready {
 macro_rules! assert_elapsed {
     ($f:expr) => {
         assert!($f.poll().unwrap_err().is_elapsed());
-    }
+    };
 }
 
 #[derive(Debug)]
@@ -128,13 +128,15 @@ pub fn advance(timer: &mut Timer<MockPark>, duration: Duration) {
 }
 
 pub fn mocked<F, R>(f: F) -> R
-where F: FnOnce(&mut Timer<MockPark>, &mut MockTime) -> R
+where
+    F: FnOnce(&mut Timer<MockPark>, &mut MockTime) -> R,
 {
     mocked_with_now(Instant::now(), f)
 }
 
 pub fn mocked_with_now<F, R>(now: Instant, f: F) -> R
-where F: FnOnce(&mut Timer<MockPark>, &mut MockTime) -> R
+where
+    F: FnOnce(&mut Timer<MockPark>, &mut MockTime) -> R,
 {
     let mut time = MockTime::new(now);
     let park = time.mock_park();
@@ -147,9 +149,9 @@ where F: FnOnce(&mut Timer<MockPark>, &mut MockTime) -> R
         let handle = timer.handle();
 
         ::tokio_timer::with_default(&handle, enter, |_| {
-            lazy(|| {
-                Ok::<_, ()>(f(&mut timer, &mut time))
-            }).wait().unwrap()
+            lazy(|| Ok::<_, ()>(f(&mut timer, &mut time)))
+                .wait()
+                .unwrap()
         })
     })
 }
@@ -171,9 +173,7 @@ impl MockTime {
 
     pub fn mock_now(&self) -> MockNow {
         let inner = self.inner.clone();
-        MockNow {
-            inner,
-        }
+        MockNow { inner }
     }
 
     pub fn mock_park(&self) -> MockPark {
@@ -217,8 +217,7 @@ impl Park for MockPark {
     fn park(&mut self) -> Result<(), Self::Error> {
         let mut inner = self.inner.lock().map_err(|_| ())?;
 
-        let duration = inner.park_for.take()
-            .expect("call park_for first");
+        let duration = inner.park_for.take().expect("call park_for first");
 
         inner.advance(duration);
         Ok(())

tokio-timer/tests/throttle.rs

@@ -7,18 +7,14 @@ extern crate tokio_timer;
 mod support;
 use support::*;
 
-use futures::{
-    prelude::*,
-    sync::mpsc,
-};
+use futures::{prelude::*, sync::mpsc};
 use tokio::util::StreamExt;
 
 #[test]
 fn throttle() {
     mocked(|timer, _| {
         let (tx, rx) = mpsc::unbounded();
-        let mut stream = rx.throttle(ms(1))
-            .map_err(|e| panic!("{:?}", e));
+        let mut stream = rx.throttle(ms(1)).map_err(|e| panic!("{:?}", e));
 
         assert_not_ready!(stream);
 
@@ -40,8 +36,7 @@ fn throttle() {
 fn throttle_dur_0() {
     mocked(|_, _| {
         let (tx, rx) = mpsc::unbounded();
-        let mut stream = rx.throttle(ms(0))
-            .map_err(|e| panic!("{:?}", e));
+        let mut stream = rx.throttle(ms(0)).map_err(|e| panic!("{:?}", e));
 
         assert_not_ready!(stream);
 

tokio-timer/tests/timeout.rs

@@ -8,8 +8,8 @@ use support::*;
 
 use tokio_timer::*;
 
+use futures::sync::{mpsc, oneshot};
 use futures::{future, Future, Stream};
-use futures::sync::{oneshot, mpsc};
 
 #[test]
 fn simultaneous_deadline_future_completion() {