diff --git a/util/tests/async_read_taker_test.rs b/util/tests/async_read_taker_test.rs
index 99d184d0d..42a4a47e1 100644
--- a/util/tests/async_read_taker_test.rs
+++ b/util/tests/async_read_taker_test.rs
@@ -1,14 +1,14 @@
 // Copyright 2021 Nathan (Blaise) Bruer.  All rights reserved.
 
-use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
 
 use fast_async_mutex::mutex::Mutex;
-use futures::{FutureExt, poll};
+use futures::{poll, FutureExt};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
 use async_fixed_buffer::AsyncFixedBuf;
-use async_read_taker::{AsyncReadTaker, ArcMutexAsyncRead};
+use async_read_taker::{ArcMutexAsyncRead, AsyncReadTaker};
 use error::{make_err, Code, Error};
 
 #[cfg(test)]
@@ -23,11 +23,13 @@ mod async_read_taker_tests {
 
         let mut taker = AsyncReadTaker::new(Arc::new(Mutex::new(Box::new(rx))), None::<Box<fn()>>, 1024);
         let write_data = vec![97u8; 50];
-        { // Send our data.
+        {
+            // Send our data.
             tx.write_all(&write_data).await?;
             tx.write(&vec![]).await?; // Write EOF.
         }
-        { // Receive and check our data.
+        {
+            // Receive and check our data.
             let mut read_buffer = Vec::new();
             let read_sz = taker.read_to_end(&mut read_buffer).await?;
             assert_eq!(read_sz, 50, "Expected sizes to match");
@@ -46,13 +48,19 @@ mod async_read_taker_tests {
 
         let reader: ArcMutexAsyncRead = Arc::new(Mutex::new(Box::new(rx)));
         let done = Arc::new(AtomicBool::new(false));
-        { // Send our data.
+        {
+            // Send our data.
             tx.write_all(&WRITE_DATA).await?;
             tx.write(&vec![]).await?; // Write EOF.
         }
-        { // Receive first chunk and test our data.
+        {
+            // Receive first chunk and test our data.
             let done_clone = done.clone();
-            let mut taker = AsyncReadTaker::new(reader.clone(), Some(move || done_clone.store(true, Ordering::Relaxed)), READ_AMOUNT);
+            let mut taker = AsyncReadTaker::new(
+                reader.clone(),
+                Some(move || done_clone.store(true, Ordering::Relaxed)),
+                READ_AMOUNT,
+            );
 
             let mut read_buffer = Vec::new();
             let read_sz = taker.read_to_end(&mut read_buffer).await?;
@@ -61,9 +69,14 @@ mod async_read_taker_tests {
             assert_eq!(done.load(Ordering::Relaxed), false, "Should not be done");
             assert_eq!(&read_buffer, &WRITE_DATA[0..READ_AMOUNT]);
         }
-        { // Receive last chunk and test our data.
+        {
+            // Receive last chunk and test our data.
             let done_clone = done.clone();
-            let mut taker = AsyncReadTaker::new(reader.clone(), Some(move || done_clone.store(true, Ordering::Relaxed)), READ_AMOUNT);
+            let mut taker = AsyncReadTaker::new(
+                reader.clone(),
+                Some(move || done_clone.store(true, Ordering::Relaxed)),
+                READ_AMOUNT,
+            );
 
             let mut read_buffer = Vec::new();
             let read_sz = taker.read_to_end(&mut read_buffer).await?;
@@ -91,12 +104,20 @@ mod async_read_taker_tests {
         tx.write_all(&WRITE_DATA).await?;
 
         let done_clone = done.clone();
-        let mut taker = Box::pin(AsyncReadTaker::new(reader.clone(), Some(move || done_clone.store(true, Ordering::Relaxed)), READ_AMOUNT));
+        let mut taker = Box::pin(AsyncReadTaker::new(
+            reader.clone(),
+            Some(move || done_clone.store(true, Ordering::Relaxed)),
+            READ_AMOUNT,
+        ));
 
         let mut read_buffer = Vec::new();
         let mut read_fut = taker.read_to_end(&mut read_buffer).boxed();
-        { // Poll the future to make sure it did start reading. Failing to do this step makes this test useless.
-            assert!(poll!(&mut read_fut).is_pending(), "Should not have received EOF. Should be pending");
+        {
+            // Poll the future to make sure it did start reading. Failing to do this step makes this test useless.
+            assert!(
+                poll!(&mut read_fut).is_pending(),
+                "Should not have received EOF. Should be pending"
+            );
         }
         // Shutdown the sender. This should cause the futures to resolve.
         tx.shutdown().await?;
@@ -104,7 +125,10 @@ mod async_read_taker_tests {
             // Ensure an appropriate error message was returned.
             let err: Error = read_fut.await.unwrap_err().into();
             assert_eq!(err, make_err!(Code::Internal, "Sender disconnected"));
-            assert_eq!(&read_buffer, &WRITE_DATA, "Expected poll!() macro to have processed the data we wrote");
+            assert_eq!(
+                &read_buffer, &WRITE_DATA,
+                "Expected poll!() macro to have processed the data we wrote"
+            );
             assert_eq!(done.load(Ordering::Relaxed), false, "Should not have called done_fn");
         }