Upgrade rust/crates/futures-executor to 0.3.15

Test: make
Change-Id: Ie80aa03594b8b783d2aadcd04c44ba626764600a
diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index f3ad3ab..ec6442e 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,5 +1,5 @@
 {
   "git": {
-    "sha1": "c91f8691672c7401b1923ab00bf138975c99391a"
+    "sha1": "fc080d153bc7bf00429ec5e2b91e2f21f2243846"
   }
 }
diff --git a/Android.bp b/Android.bp
index f7f51d6..59ce04f 100644
--- a/Android.bp
+++ b/Android.bp
@@ -63,9 +63,10 @@
 }
 
 // dependent_library ["feature_list"]
-//   futures-core-0.3.14 "alloc,std"
-//   futures-task-0.3.14 "alloc,std"
-//   futures-util-0.3.14 "alloc,slab,std"
+//   autocfg-1.0.1
+//   futures-core-0.3.15 "alloc,std"
+//   futures-task-0.3.15 "alloc,std"
+//   futures-util-0.3.15 "alloc,slab,std"
 //   libc-0.2.94 "default,std"
 //   num_cpus-1.13.0
 //   pin-project-lite-0.2.6
diff --git a/Cargo.toml b/Cargo.toml
index 62cb740..17383a4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,7 @@
 [package]
 edition = "2018"
 name = "futures-executor"
-version = "0.3.13"
+version = "0.3.15"
 authors = ["Alex Crichton <alex@alexcrichton.com>"]
 description = "Executors for asynchronous tasks based on the futures-rs library.\n"
 homepage = "https://rust-lang.github.io/futures-rs"
@@ -24,15 +24,15 @@
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 [dependencies.futures-core]
-version = "0.3.13"
+version = "0.3.15"
 default-features = false
 
 [dependencies.futures-task]
-version = "0.3.13"
+version = "0.3.15"
 default-features = false
 
 [dependencies.futures-util]
-version = "0.3.13"
+version = "0.3.15"
 default-features = false
 
 [dependencies.num_cpus]
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index bc1853b..55c69e3 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,7 +1,7 @@
 [package]
 name = "futures-executor"
 edition = "2018"
-version = "0.3.13"
+version = "0.3.15"
 authors = ["Alex Crichton <alex@alexcrichton.com>"]
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/rust-lang/futures-rs"
@@ -17,9 +17,9 @@
 thread-pool = ["std", "num_cpus"]
 
 [dependencies]
-futures-core = { path = "../futures-core", version = "0.3.13", default-features = false }
-futures-task = { path = "../futures-task", version = "0.3.13", default-features = false }
-futures-util = { path = "../futures-util", version = "0.3.13", default-features = false }
+futures-core = { path = "../futures-core", version = "0.3.15", default-features = false }
+futures-task = { path = "../futures-task", version = "0.3.15", default-features = false }
+futures-util = { path = "../futures-util", version = "0.3.15", default-features = false }
 num_cpus = { version = "1.8.0", optional = true }
 
 [dev-dependencies]
diff --git a/METADATA b/METADATA
index 75a29b9..ac9c274 100644
--- a/METADATA
+++ b/METADATA
@@ -7,13 +7,13 @@
   }
   url {
     type: ARCHIVE
-    value: "https://static.crates.io/crates/futures-executor/futures-executor-0.3.13.crate"
+    value: "https://static.crates.io/crates/futures-executor/futures-executor-0.3.15.crate"
   }
-  version: "0.3.13"
+  version: "0.3.15"
   license_type: NOTICE
   last_upgrade_date {
     year: 2021
-    month: 4
-    day: 1
+    month: 5
+    day: 19
   }
 }
diff --git a/TEST_MAPPING b/TEST_MAPPING
new file mode 100644
index 0000000..d940add
--- /dev/null
+++ b/TEST_MAPPING
@@ -0,0 +1,143 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+  "presubmit": [
+    {
+      "name": "ZipFuseTest"
+    },
+    {
+      "name": "anyhow_device_test_src_lib"
+    },
+    {
+      "name": "anyhow_device_test_tests_test_autotrait"
+    },
+    {
+      "name": "anyhow_device_test_tests_test_boxed"
+    },
+    {
+      "name": "anyhow_device_test_tests_test_chain"
+    },
+    {
+      "name": "anyhow_device_test_tests_test_context"
+    },
+    {
+      "name": "anyhow_device_test_tests_test_convert"
+    },
+    {
+      "name": "anyhow_device_test_tests_test_downcast"
+    },
+    {
+      "name": "anyhow_device_test_tests_test_ffi"
+    },
+    {
+      "name": "anyhow_device_test_tests_test_fmt"
+    },
+    {
+      "name": "anyhow_device_test_tests_test_macros"
+    },
+    {
+      "name": "anyhow_device_test_tests_test_repr"
+    },
+    {
+      "name": "anyhow_device_test_tests_test_source"
+    },
+    {
+      "name": "authfs_device_test_src_lib"
+    },
+    {
+      "name": "tokio_device_test_tests_buffered"
+    },
+    {
+      "name": "tokio_device_test_tests_io_async_read"
+    },
+    {
+      "name": "tokio_device_test_tests_io_copy_bidirectional"
+    },
+    {
+      "name": "tokio_device_test_tests_io_lines"
+    },
+    {
+      "name": "tokio_device_test_tests_io_mem_stream"
+    },
+    {
+      "name": "tokio_device_test_tests_io_read"
+    },
+    {
+      "name": "tokio_device_test_tests_io_read_buf"
+    },
+    {
+      "name": "tokio_device_test_tests_io_read_to_end"
+    },
+    {
+      "name": "tokio_device_test_tests_io_take"
+    },
+    {
+      "name": "tokio_device_test_tests_io_write"
+    },
+    {
+      "name": "tokio_device_test_tests_io_write_all"
+    },
+    {
+      "name": "tokio_device_test_tests_io_write_buf"
+    },
+    {
+      "name": "tokio_device_test_tests_io_write_int"
+    },
+    {
+      "name": "tokio_device_test_tests_macros_join"
+    },
+    {
+      "name": "tokio_device_test_tests_no_rt"
+    },
+    {
+      "name": "tokio_device_test_tests_rt_basic"
+    },
+    {
+      "name": "tokio_device_test_tests_rt_threaded"
+    },
+    {
+      "name": "tokio_device_test_tests_sync_barrier"
+    },
+    {
+      "name": "tokio_device_test_tests_sync_broadcast"
+    },
+    {
+      "name": "tokio_device_test_tests_sync_errors"
+    },
+    {
+      "name": "tokio_device_test_tests_sync_mpsc"
+    },
+    {
+      "name": "tokio_device_test_tests_sync_mutex_owned"
+    },
+    {
+      "name": "tokio_device_test_tests_sync_rwlock"
+    },
+    {
+      "name": "tokio_device_test_tests_sync_watch"
+    },
+    {
+      "name": "tokio_device_test_tests_task_local"
+    },
+    {
+      "name": "tokio_device_test_tests_task_local_set"
+    },
+    {
+      "name": "tokio_device_test_tests_tcp_accept"
+    },
+    {
+      "name": "tokio_device_test_tests_tcp_echo"
+    },
+    {
+      "name": "tokio_device_test_tests_tcp_into_std"
+    },
+    {
+      "name": "tokio_device_test_tests_tcp_shutdown"
+    },
+    {
+      "name": "tokio_device_test_tests_time_rt"
+    },
+    {
+      "name": "tokio_device_test_tests_uds_split"
+    }
+  ]
+}
diff --git a/benches/thread_notify.rs b/benches/thread_notify.rs
index d8fbec4..88d0447 100644
--- a/benches/thread_notify.rs
+++ b/benches/thread_notify.rs
@@ -102,10 +102,7 @@
     });
 
     b.iter(move || {
-        let y = Yield {
-            rem: NUM,
-            tx: tx.clone(),
-        };
+        let y = Yield { rem: NUM, tx: tx.clone() };
 
         block_on(y);
     });
diff --git a/src/lib.rs b/src/lib.rs
index b679649..873ac7a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -37,13 +37,11 @@
 //! [`spawn_local_obj`]: https://docs.rs/futures/0.3/futures/task/trait.LocalSpawn.html#tymethod.spawn_local_obj
 
 #![cfg_attr(not(feature = "std"), no_std)]
-
 #![warn(missing_docs, missing_debug_implementations, rust_2018_idioms, unreachable_pub)]
 // It cannot be included in the published code because this lints have false positives in the minimum required version.
 #![cfg_attr(test, warn(single_use_lifetimes))]
 #![warn(clippy::all)]
 #![doc(test(attr(deny(warnings), allow(dead_code, unused_assignments, unused_variables))))]
-
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
 #[cfg(feature = "std")]
@@ -52,13 +50,13 @@
 pub use crate::local_pool::{block_on, block_on_stream, BlockingStream, LocalPool, LocalSpawner};
 
 #[cfg(feature = "thread-pool")]
-#[cfg(feature = "std")]
-mod unpark_mutex;
-#[cfg(feature = "thread-pool")]
 #[cfg_attr(docsrs, doc(cfg(feature = "thread-pool")))]
 #[cfg(feature = "std")]
 mod thread_pool;
 #[cfg(feature = "thread-pool")]
+#[cfg(feature = "std")]
+mod unpark_mutex;
+#[cfg(feature = "thread-pool")]
 #[cfg_attr(docsrs, doc(cfg(feature = "thread-pool")))]
 #[cfg(feature = "std")]
 pub use crate::thread_pool::{ThreadPool, ThreadPoolBuilder};
diff --git a/src/local_pool.rs b/src/local_pool.rs
index 156d5cc..bee96d8 100644
--- a/src/local_pool.rs
+++ b/src/local_pool.rs
@@ -10,7 +10,10 @@
 use std::cell::RefCell;
 use std::ops::{Deref, DerefMut};
 use std::rc::{Rc, Weak};
-use std::sync::{Arc, atomic::{AtomicBool, Ordering}};
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};
 use std::thread::{self, Thread};
 
 /// A single-threaded task pool for polling futures to completion.
@@ -119,17 +122,12 @@
 impl LocalPool {
     /// Create a new, empty pool of tasks.
     pub fn new() -> Self {
-        Self {
-            pool: FuturesUnordered::new(),
-            incoming: Default::default(),
-        }
+        Self { pool: FuturesUnordered::new(), incoming: Default::default() }
     }
 
     /// Get a clonable handle to the pool as a [`Spawn`].
     pub fn spawner(&self) -> LocalSpawner {
-        LocalSpawner {
-            incoming: Rc::downgrade(&self.incoming),
-        }
+        LocalSpawner { incoming: Rc::downgrade(&self.incoming) }
     }
 
     /// Run all tasks in the pool to completion.
diff --git a/src/thread_pool.rs b/src/thread_pool.rs
index 741e6d9..f2347db 100644
--- a/src/thread_pool.rs
+++ b/src/thread_pool.rs
@@ -2,8 +2,8 @@
 use crate::unpark_mutex::UnparkMutex;
 use futures_core::future::Future;
 use futures_core::task::{Context, Poll};
+use futures_task::{waker_ref, ArcWake};
 use futures_task::{FutureObj, Spawn, SpawnError};
-use futures_task::{ArcWake, waker_ref};
 use futures_util::future::FutureExt;
 use std::cmp;
 use std::fmt;
@@ -54,9 +54,7 @@
 
 impl fmt::Debug for ThreadPool {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("ThreadPool")
-            .field("size", &self.state.size)
-            .finish()
+        f.debug_struct("ThreadPool").field("size", &self.state.size).finish()
     }
 }
 
@@ -100,10 +98,7 @@
     pub fn spawn_obj_ok(&self, future: FutureObj<'static, ()>) {
         let task = Task {
             future,
-            wake_handle: Arc::new(WakeHandle {
-                exec: self.clone(),
-                mutex: UnparkMutex::new(),
-            }),
+            wake_handle: Arc::new(WakeHandle { exec: self.clone(), mutex: UnparkMutex::new() }),
             exec: self.clone(),
         };
         self.state.send(Message::Run(task));
@@ -132,10 +127,7 @@
 }
 
 impl Spawn for ThreadPool {
-    fn spawn_obj(
-        &self,
-        future: FutureObj<'static, ()>,
-    ) -> Result<(), SpawnError> {
+    fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError> {
         self.spawn_obj_ok(future);
         Ok(())
     }
@@ -146,10 +138,12 @@
         self.tx.lock().unwrap().send(msg).unwrap();
     }
 
-    fn work(&self,
-            idx: usize,
-            after_start: Option<Arc<dyn Fn(usize) + Send + Sync>>,
-            before_stop: Option<Arc<dyn Fn(usize) + Send + Sync>>) {
+    fn work(
+        &self,
+        idx: usize,
+        after_start: Option<Arc<dyn Fn(usize) + Send + Sync>>,
+        before_stop: Option<Arc<dyn Fn(usize) + Send + Sync>>,
+    ) {
         let _scope = enter().unwrap();
         if let Some(after_start) = after_start {
             after_start(idx);
@@ -241,7 +235,8 @@
     /// The closure provided will receive an index corresponding to the worker
     /// thread it's running on.
     pub fn after_start<F>(&mut self, f: F) -> &mut Self
-        where F: Fn(usize) + Send + Sync + 'static
+    where
+        F: Fn(usize) + Send + Sync + 'static,
     {
         self.after_start = Some(Arc::new(f));
         self
@@ -256,7 +251,8 @@
     /// The closure provided will receive an index corresponding to the worker
     /// thread it's running on.
     pub fn before_stop<F>(&mut self, f: F) -> &mut Self
-        where F: Fn(usize) + Send + Sync + 'static
+    where
+        F: Fn(usize) + Send + Sync + 'static,
     {
         self.before_stop = Some(Arc::new(f));
         self
@@ -328,14 +324,11 @@
                     Poll::Pending => {}
                     Poll::Ready(()) => return wake_handle.mutex.complete(),
                 }
-                let task = Self {
-                    future,
-                    wake_handle: wake_handle.clone(),
-                    exec,
-                };
+                let task = Self { future, wake_handle: wake_handle.clone(), exec };
                 match wake_handle.mutex.wait(task) {
                     Ok(()) => return, // we've waited
-                    Err(task) => { // someone's notified us
+                    Err(task) => {
+                        // someone's notified us
                         future = task.future;
                         exec = task.exec;
                     }
@@ -347,9 +340,7 @@
 
 impl fmt::Debug for Task {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Task")
-            .field("contents", &"...")
-            .finish()
+        f.debug_struct("Task").field("contents", &"...").finish()
     }
 }
 
@@ -372,7 +363,9 @@
         let (tx, rx) = mpsc::sync_channel(2);
         let _cpu_pool = ThreadPoolBuilder::new()
             .pool_size(2)
-            .after_start(move |_| tx.send(1).unwrap()).create().unwrap();
+            .after_start(move |_| tx.send(1).unwrap())
+            .create()
+            .unwrap();
 
         // After ThreadPoolBuilder is deconstructed, the tx should be droped
         // so that we can use rx as an iterator.
diff --git a/src/unpark_mutex.rs b/src/unpark_mutex.rs
index c49c64c..ac5112c 100644
--- a/src/unpark_mutex.rs
+++ b/src/unpark_mutex.rs
@@ -29,25 +29,22 @@
 // transitions:
 
 // The task is blocked, waiting on an event
-const WAITING: usize = 0;       // --> POLLING
+const WAITING: usize = 0; // --> POLLING
 
 // The task is actively being polled by a thread; arrival of additional events
 // of interest should move it to the REPOLL state
-const POLLING: usize = 1;       // --> WAITING, REPOLL, or COMPLETE
+const POLLING: usize = 1; // --> WAITING, REPOLL, or COMPLETE
 
 // The task is actively being polled, but will need to be re-polled upon
 // completion to ensure that all events were observed.
-const REPOLL: usize = 2;        // --> POLLING
+const REPOLL: usize = 2; // --> POLLING
 
 // The task has finished executing (either successfully or with an error/panic)
-const COMPLETE: usize = 3;      // No transitions out
+const COMPLETE: usize = 3; // No transitions out
 
 impl<D> UnparkMutex<D> {
     pub(crate) fn new() -> Self {
-        Self {
-            status: AtomicUsize::new(WAITING),
-            inner: UnsafeCell::new(None),
-        }
+        Self { status: AtomicUsize::new(WAITING), inner: UnsafeCell::new(None) }
     }
 
     /// Attempt to "notify" the mutex that a poll should occur.
@@ -62,8 +59,7 @@
             match status {
                 // The task is idle, so try to run it immediately.
                 WAITING => {
-                    match self.status.compare_exchange(WAITING, POLLING,
-                                                       SeqCst, SeqCst) {
+                    match self.status.compare_exchange(WAITING, POLLING, SeqCst, SeqCst) {
                         Ok(_) => {
                             let data = unsafe {
                                 // SAFETY: we've ensured mutual exclusion via
@@ -82,13 +78,10 @@
 
                 // The task is being polled, so we need to record that it should
                 // be *repolled* when complete.
-                POLLING => {
-                    match self.status.compare_exchange(POLLING, REPOLL,
-                                                       SeqCst, SeqCst) {
-                        Ok(_) => return Err(()),
-                        Err(cur) => status = cur,
-                    }
-                }
+                POLLING => match self.status.compare_exchange(POLLING, REPOLL, SeqCst, SeqCst) {
+                    Ok(_) => return Err(()),
+                    Err(cur) => status = cur,
+                },
 
                 // The task is already scheduled for polling, or is complete, so
                 // we've got nothing to do.
diff --git a/tests/local_pool.rs b/tests/local_pool.rs
index b31f103..56e6daa 100644
--- a/tests/local_pool.rs
+++ b/tests/local_pool.rs
@@ -1,14 +1,14 @@
 use futures::channel::oneshot;
 use futures::executor::LocalPool;
-use futures::future::{self, Future, lazy, poll_fn};
-use futures::task::{Context, Poll, Spawn, LocalSpawn, Waker};
+use futures::future::{self, lazy, poll_fn, Future};
+use futures::task::{Context, LocalSpawn, Poll, Spawn, Waker};
 use std::cell::{Cell, RefCell};
 use std::pin::Pin;
 use std::rc::Rc;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
 use std::thread;
 use std::time::Duration;
-use std::sync::Arc;
-use std::sync::atomic::{Ordering, AtomicBool};
 
 struct Pending(Rc<()>);
 
@@ -52,9 +52,14 @@
     let (tx, rx) = oneshot::channel();
     let mut pool = LocalPool::new();
     let spawn = pool.spawner();
-    spawn.spawn_local_obj(Box::pin(lazy(move |_| {
-        tx.send(()).unwrap();
-    })).into()).unwrap();
+    spawn
+        .spawn_local_obj(
+            Box::pin(lazy(move |_| {
+                tx.send(()).unwrap();
+            }))
+            .into(),
+        )
+        .unwrap();
     pool.run_until(rx).unwrap();
 }
 
@@ -74,18 +79,27 @@
     let spawn = pool.spawner();
     let spawn2 = pool.spawner();
 
-    spawn.spawn_local_obj(Box::pin(lazy(move |_| {
-        spawn2.spawn_local_obj(Box::pin(lazy(move |_| {
-            cnt2.set(cnt2.get() + 1);
-        })).into()).unwrap();
-    })).into()).unwrap();
+    spawn
+        .spawn_local_obj(
+            Box::pin(lazy(move |_| {
+                spawn2
+                    .spawn_local_obj(
+                        Box::pin(lazy(move |_| {
+                            cnt2.set(cnt2.get() + 1);
+                        }))
+                        .into(),
+                    )
+                    .unwrap();
+            }))
+            .into(),
+        )
+        .unwrap();
 
     pool.run();
 
     assert_eq!(cnt.get(), 1);
 }
 
-
 #[test]
 fn run_spawn_many() {
     const ITER: usize = 200;
@@ -97,9 +111,14 @@
 
     for _ in 0..ITER {
         let cnt = cnt.clone();
-        spawn.spawn_local_obj(Box::pin(lazy(move |_| {
-            cnt.set(cnt.get() + 1);
-        })).into()).unwrap();
+        spawn
+            .spawn_local_obj(
+                Box::pin(lazy(move |_| {
+                    cnt.set(cnt.get() + 1);
+                }))
+                .into(),
+            )
+            .unwrap();
     }
 
     pool.run();
@@ -126,9 +145,14 @@
         spawn.spawn_local_obj(Box::pin(pending()).into()).unwrap();
 
         let cnt = cnt.clone();
-        spawn.spawn_local_obj(Box::pin(lazy(move |_| {
-            cnt.set(cnt.get() + 1);
-        })).into()).unwrap();
+        spawn
+            .spawn_local_obj(
+                Box::pin(lazy(move |_| {
+                    cnt.set(cnt.get() + 1);
+                }))
+                .into(),
+            )
+            .unwrap();
 
         spawn.spawn_local_obj(Box::pin(pending()).into()).unwrap();
     }
@@ -154,15 +178,20 @@
     {
         let cnt = cnt.clone();
         let waker = waker.clone();
-        spawn.spawn_local_obj(Box::pin(poll_fn(move |ctx| {
-            cnt.set(cnt.get() + 1);
-            waker.set(Some(ctx.waker().clone()));
-            if cnt.get() == ITER {
-                Poll::Ready(())
-            } else {
-                Poll::Pending
-            }
-        })).into()).unwrap();
+        spawn
+            .spawn_local_obj(
+                Box::pin(poll_fn(move |ctx| {
+                    cnt.set(cnt.get() + 1);
+                    waker.set(Some(ctx.waker().clone()));
+                    if cnt.get() == ITER {
+                        Poll::Ready(())
+                    } else {
+                        Poll::Pending
+                    }
+                }))
+                .into(),
+            )
+            .unwrap();
     }
 
     for i in 0..ITER - 1 {
@@ -185,16 +214,21 @@
 
     let inner_spawner = spawn.clone();
     let cnt1 = cnt.clone();
-    spawn.spawn_local_obj(Box::pin(poll_fn(move |_| {
-        cnt1.set(cnt1.get() + 1);
-        
-        let cnt2 = cnt1.clone();
-        inner_spawner.spawn_local_obj(Box::pin(lazy(move |_|{
-            cnt2.set(cnt2.get() + 1)
-        })).into()).unwrap();
+    spawn
+        .spawn_local_obj(
+            Box::pin(poll_fn(move |_| {
+                cnt1.set(cnt1.get() + 1);
 
-        Poll::Pending
-    })).into()).unwrap();
+                let cnt2 = cnt1.clone();
+                inner_spawner
+                    .spawn_local_obj(Box::pin(lazy(move |_| cnt2.set(cnt2.get() + 1))).into())
+                    .unwrap();
+
+                Poll::Pending
+            }))
+            .into(),
+        )
+        .unwrap();
 
     pool.try_run_one();
     assert_eq!(cnt.get(), 2);
@@ -214,12 +248,12 @@
     let cnt = Rc::new(Cell::new(0));
 
     let cnt1 = cnt.clone();
-    spawn.spawn_local_obj(Box::pin(lazy(move |_|{ cnt1.set(cnt1.get() + 1) })).into()).unwrap();
+    spawn.spawn_local_obj(Box::pin(lazy(move |_| cnt1.set(cnt1.get() + 1))).into()).unwrap();
     pool.run_until_stalled();
     assert_eq!(cnt.get(), 1);
 
     let cnt2 = cnt.clone();
-    spawn.spawn_local_obj(Box::pin(lazy(move |_|{ cnt2.set(cnt2.get() + 1) })).into()).unwrap();
+    spawn.spawn_local_obj(Box::pin(lazy(move |_| cnt2.set(cnt2.get() + 1))).into()).unwrap();
     pool.run_until_stalled();
     assert_eq!(cnt.get(), 2);
 }
@@ -232,16 +266,21 @@
 
     let inner_spawner = spawn.clone();
     let cnt1 = cnt.clone();
-    spawn.spawn_local_obj(Box::pin(poll_fn(move |_| {
-        cnt1.set(cnt1.get() + 1);
-        
-        let cnt2 = cnt1.clone();
-        inner_spawner.spawn_local_obj(Box::pin(lazy(move |_|{
-            cnt2.set(cnt2.get() + 1)
-        })).into()).unwrap();
+    spawn
+        .spawn_local_obj(
+            Box::pin(poll_fn(move |_| {
+                cnt1.set(cnt1.get() + 1);
 
-        Poll::Pending
-    })).into()).unwrap();
+                let cnt2 = cnt1.clone();
+                inner_spawner
+                    .spawn_local_obj(Box::pin(lazy(move |_| cnt2.set(cnt2.get() + 1))).into())
+                    .unwrap();
+
+                Poll::Pending
+            }))
+            .into(),
+        )
+        .unwrap();
 
     pool.run_until_stalled();
     assert_eq!(cnt.get(), 2);
@@ -262,9 +301,14 @@
             spawn.spawn_local_obj(Box::pin(pending()).into()).unwrap();
 
             let cnt = cnt.clone();
-            spawn.spawn_local_obj(Box::pin(lazy(move |_| {
-                cnt.set(cnt.get() + 1);
-            })).into()).unwrap();
+            spawn
+                .spawn_local_obj(
+                    Box::pin(lazy(move |_| {
+                        cnt.set(cnt.get() + 1);
+                    }))
+                    .into(),
+                )
+                .unwrap();
 
             // also add some pending tasks to test if they are ignored
             spawn.spawn_local_obj(Box::pin(pending()).into()).unwrap();
@@ -281,10 +325,15 @@
     let mut pool = LocalPool::new();
     let spawn = pool.spawner();
 
-    spawn.spawn_obj(Box::pin(lazy(|_| {
-        let mut pool = LocalPool::new();
-        pool.run();
-    })).into()).unwrap();
+    spawn
+        .spawn_obj(
+            Box::pin(lazy(|_| {
+                let mut pool = LocalPool::new();
+                pool.run();
+            }))
+            .into(),
+        )
+        .unwrap();
 
     pool.run();
 }
@@ -295,10 +344,15 @@
     let mut pool = LocalPool::new();
     let spawn = pool.spawner();
 
-    spawn.spawn_obj(Box::pin(lazy(|_| {
-        let mut pool = LocalPool::new();
-        pool.run_until_stalled();
-    })).into()).unwrap();
+    spawn
+        .spawn_obj(
+            Box::pin(lazy(|_| {
+                let mut pool = LocalPool::new();
+                pool.run_until_stalled();
+            }))
+            .into(),
+        )
+        .unwrap();
 
     pool.run();
 }
@@ -342,15 +396,9 @@
     let mut pool = LocalPool::new();
     let spawn = pool.spawner();
 
-    spawn.spawn_local_obj(Box::pin(Spin {
-        state: state.clone(),
-        idx: 0,
-    }).into()).unwrap();
+    spawn.spawn_local_obj(Box::pin(Spin { state: state.clone(), idx: 0 }).into()).unwrap();
 
-    spawn.spawn_local_obj(Box::pin(Spin {
-        state,
-        idx: 1,
-    }).into()).unwrap();
+    spawn.spawn_local_obj(Box::pin(Spin { state, idx: 1 }).into()).unwrap();
 
     pool.run();
 }
@@ -363,11 +411,11 @@
 
     let future = future::poll_fn(move |cx| {
         if done {
-            return Poll::Ready(())
+            return Poll::Ready(());
         }
         done = true;
         cx.waker().clone().wake(); // (*)
-        // some user-code that temporarily parks the thread
+                                   // some user-code that temporarily parks the thread
         let test = thread::current();
         let latch = Arc::new(AtomicBool::new(false));
         let signal = latch.clone();
@@ -384,4 +432,3 @@
 
     futures::executor::block_on(future)
 }
-