From 508aa05cb99529b455a5e64ba95b95ff0b3f8789 Mon Sep 17 00:00:00 2001
From: Bradlee Speice <bradlee@speice.io>
Date: Thu, 6 Dec 2018 23:19:37 -0500
Subject: [PATCH] Actually run rustfmt

---
 src/lib.rs            | 22 +++++++++++-----------
 tests/assert_macro.rs |  1 -
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 79d5cd5..85acd04 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,41 +5,41 @@
 //! or code inside an `assert_no_alloc!` macro interacts with the allocator in any way.
 //! Wanton allocations and unforeseen drops no more - this library lets you focus on
 //! writing code without worrying if Rust properly managed to inline the variable into the stack.
-//! 
+//!
 //! Now, an allocator blowing up in production is a scary thought; that's why QADAPT
 //! is designed to strip its own code out whenever you're running with a release build.
 //! Just like the [`debug_assert!` macro](https://doc.rust-lang.org/std/macro.debug_assert.html)
 //! in Rust's standard library, it's safe to use without worrying about a unforeseen
 //! circumstance causing your application to crash.
-//! 
+//!
 //! # Usage
-//! 
+//!
 //! Actually making use of QADAPT is straight-forward. To set up the allocator,
 //! place the following snippet in either your program binaries (main.rs) or tests:
-//! 
+//!
 //! ```rust,ignore
 //! use qadapt::QADAPT;
-//! 
+//!
 //! #[global_allocator]
 //! static Q: QADAPT = QADAPT;
 //! ```
-//! 
+//!
 //! After that, there are two ways of telling QADAPT that it should trigger a panic:
-//! 
+//!
 //! 1. Annotate functions with the `#[no_alloc]` proc macro:
 //! ```rust,no_run
 //! use qadapt::no_alloc;
-//! 
+//!
 //! #[no_alloc]
 //! fn do_math() -> u8 {
 //!     2 + 2
 //! }
 //! ```
-//! 
+//!
 //! 2. Evaluate expressions with the `assert_no_alloc!` macro
 //! ```rust,no_run
 //! use qadapt::assert_no_alloc;
-//! 
+//!
 //! fn do_work() {
 //!     // This code is allowed to trigger an allocation
 //!     let b = Box::new(8);
@@ -119,7 +119,7 @@ pub fn exit_protected() {
 
 /// Get the result of an expression, guaranteeing that no memory accesses occur
 /// during its evaluation.
-/// 
+///
 /// **Warning**: Unexpected behavior may occur when using the `return` keyword.
 /// Because the macro cleanup logic will not be run, QADAPT may trigger a panic
 /// in code that was not specifically intended to be allocation-free.
diff --git a/tests/assert_macro.rs b/tests/assert_macro.rs
index a2935d1..03f98ec 100644
--- a/tests/assert_macro.rs
+++ b/tests/assert_macro.rs
@@ -28,4 +28,3 @@ fn early_return_boxing() {
         panic!("Intentional")
     }
 }
-