Fix tests, cargo fmt

Author: expenses

src/delay.rs

@@ -3,6 +3,7 @@
 //! This module contains the `Delay` type which is a future that will resolve
 //! at a particular point in the future.
 
+use crate::Instant;
 use std::fmt;
 use std::future::Future;
 use std::pin::Pin;
@@ -11,7 +12,6 @@ use std::sync::atomic::Ordering::SeqCst;
 use std::sync::{Arc, Mutex};
 use std::task::{Context, Poll};
 use std::time::Duration;
-use crate::Instant;
 
 use crate::arc_list::Node;
 use crate::AtomicWaker;

src/global_native.rs

@@ -1,3 +1,4 @@
+use crate::Instant;
 use std::future::Future;
 use std::io;
 use std::mem::{self, ManuallyDrop};
@@ -7,7 +8,6 @@ use std::sync::Arc;
 use std::task::{Context, RawWaker, RawWakerVTable, Waker};
 use std::thread;
 use std::thread::Thread;
-use crate::Instant;
 
 use crate::{Timer, TimerHandle};
 

src/global_wasm.rs

@@ -6,7 +6,7 @@ use std::pin::Pin;
 use std::sync::Arc;
 use std::task::Context;
 use std::time::Duration;
-use wasm_bindgen::{JsCast, closure::Closure};
+use wasm_bindgen::{closure::Closure, JsCast};
 
 use crate::{Instant, Timer, TimerHandle};
 
@@ -16,62 +16,67 @@ use crate::{Instant, Timer, TimerHandle};
 /// >           any `forget()` method, as the task is automatically considered
 /// >           as "forgotten".
 pub(crate) fn run() -> TimerHandle {
-	let timer = Timer::new();
-	let handle = timer.handle();
-	schedule_callback(Arc::new(Mutex::new(timer)), Duration::new(0, 0));
-	handle
+    let timer = Timer::new();
+    let handle = timer.handle();
+    schedule_callback(Arc::new(Mutex::new(timer)), Duration::new(0, 0));
+    handle
 }
 
 /// Calls `Window::setTimeout` with the given `Duration`. The callback wakes up the timer and
 /// processes everything.
 fn schedule_callback(timer: Arc<Mutex<Timer>>, when: Duration) {
-	let window = web_sys::window().expect("Unable to access Window");
-	let _ = window.set_timeout_with_callback_and_timeout_and_arguments_0(
-		&Closure::once_into_js(move || {
-			let mut timer_lock = timer.lock();
+    let window = web_sys::window().expect("Unable to access Window");
+    let _ = window
+        .set_timeout_with_callback_and_timeout_and_arguments_0(
+            &Closure::once_into_js(move || {
+                let mut timer_lock = timer.lock();
 
-			// We start by polling the timer. If any new `Delay` is created, the waker will be used
-			// to wake up this task pre-emptively. As such, we pass a `Waker` that calls
-			// `schedule_callback` with a delay of `0`.
-			let waker = task::waker(Arc::new(Waker { timer: timer.clone() }));
-			let _ = Future::poll(Pin::new(&mut *timer_lock), &mut Context::from_waker(&waker));
+                // We start by polling the timer. If any new `Delay` is created, the waker will be used
+                // to wake up this task pre-emptively. As such, we pass a `Waker` that calls
+                // `schedule_callback` with a delay of `0`.
+                let waker = task::waker(Arc::new(Waker {
+                    timer: timer.clone(),
+                }));
+                let _ = Future::poll(Pin::new(&mut *timer_lock), &mut Context::from_waker(&waker));
 
-			// Notify the timers that are ready.
-			let now = Instant::now();
-			timer_lock.advance_to(now);
+                // Notify the timers that are ready.
+                let now = Instant::now();
+                timer_lock.advance_to(now);
 
-			// Each call to `schedule_callback` calls `schedule_callback` again, but also leaves
-			// the possibility for `schedule_callback` to be called in parallel. Since we don't
-			// want too many useless callbacks, we...
-			// TODO: ugh, that's a hack
-			if Arc::strong_count(&timer) > 20 {
-				return;
-			}
+                // Each call to `schedule_callback` calls `schedule_callback` again, but also leaves
+                // the possibility for `schedule_callback` to be called in parallel. Since we don't
+                // want too many useless callbacks, we...
+                // TODO: ugh, that's a hack
+                if Arc::strong_count(&timer) > 20 {
+                    return;
+                }
 
-			// We call `schedule_callback` again for the next event.
-			let sleep_dur = timer_lock.next_event()
-				.map(|next_event| {
-					if next_event > now {
-						next_event - now
-					} else {
-						Duration::new(0, 0)
-					}
-				})
-				.unwrap_or(Duration::from_secs(5));
-			drop(timer_lock);
-			schedule_callback(timer, sleep_dur);
-
-		}).unchecked_ref(),
-		i32::try_from(when.as_millis()).unwrap_or(0)
-	).unwrap();
+                // We call `schedule_callback` again for the next event.
+                let sleep_dur = timer_lock
+                    .next_event()
+                    .map(|next_event| {
+                        if next_event > now {
+                            next_event - now
+                        } else {
+                            Duration::new(0, 0)
+                        }
+                    })
+                    .unwrap_or(Duration::from_secs(5));
+                drop(timer_lock);
+                schedule_callback(timer, sleep_dur);
+            })
+            .unchecked_ref(),
+            i32::try_from(when.as_millis()).unwrap_or(0),
+        )
+        .unwrap();
 }
 
 struct Waker {
-	timer: Arc<Mutex<Timer>>,
+    timer: Arc<Mutex<Timer>>,
 }
 
 impl ArcWake for Waker {
-	fn wake_by_ref(arc_self: &Arc<Self>) {
-		schedule_callback(arc_self.timer.clone(), Duration::new(0, 0));
-	}
+    fn wake_by_ref(arc_self: &Arc<Self>) {
+        schedule_callback(arc_self.timer.clone(), Duration::new(0, 0));
+    }
 }

src/heap_timer.rs

@@ -1,6 +1,6 @@
+use crate::Instant;
 use std::cmp::Ordering;
 use std::sync::Arc;
-use crate::Instant;
 
 use crate::{Node, ScheduledTimer};
 

src/lib.rs

@@ -19,13 +19,13 @@
 mod arc_list;
 mod atomic_waker;
 mod delay;
-mod heap;
-mod heap_timer;
-mod timer;
 #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 mod global_native;
 #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
 mod global_wasm;
+mod heap;
+mod heap_timer;
+mod timer;
 
 use arc_list::{ArcList, Node};
 use atomic_waker::AtomicWaker;

src/timer.rs

@@ -1,12 +1,12 @@
+use crate::Instant;
 use std::fmt;
+use std::future::Future;
 use std::mem;
 use std::pin::Pin;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering::SeqCst;
 use std::sync::{Arc, Mutex, Weak};
 use std::task::{Context, Poll};
-use crate::Instant;
-use std::future::Future;
 
 use crate::AtomicWaker;
 use crate::{ArcList, Heap, HeapTimer, Node, Slot};
@@ -284,7 +284,6 @@ impl Default for TimerHandle {
                     Err(_) => return TimerHandle { inner: Weak::new() },
                 };
 
-
                 // If we successfully set ourselves as the actual fallback then we
                 // want to `forget` the helper thread to ensure that it persists
                 // globally. If we fail to set ourselves as the fallback that means

tests/smoke.rs

@@ -1,7 +1,6 @@
 use std::error::Error;
 use std::pin::Pin;
-use std::time::Duration;
-use crate::Instant;
+use std::time::{Duration, Instant};
 
 use futures_timer::Delay;
 

tests/timeout.rs

@@ -1,6 +1,5 @@
 use std::error::Error;
-use std::time::Duration;
-use crate::Instant;
+use std::time::{Duration, Instant};
 
 use futures_timer::Delay;