From 0743ba1f46924a90440da56057fbb8c95d5bea2f Mon Sep 17 00:00:00 2001
From: Atul Bhosale <atul1bhosale@gmail.com>
Date: Tue, 14 Jan 2020 23:06:00 +0530
Subject: [PATCH] Add rustfmt.toml with tab_spaces set to 2 & run cargo fmt

---
 benches/generator.rs | 18 ++++++++++++------
 rustfmt.toml         |  1 +
 tests/fpe.rs         |  8 +++++---
 tests/generator.rs   | 14 +++++++-------
 tests/iterator.rs    | 10 +++++++---
 tests/stack.rs       | 12 ++++++++----
 6 files changed, 40 insertions(+), 23 deletions(-)
 create mode 100644 rustfmt.toml

diff --git a/benches/generator.rs b/benches/generator.rs
index 374a5024..1cf7ee45 100644
--- a/benches/generator.rs
+++ b/benches/generator.rs
@@ -5,18 +5,24 @@
 // http://opensource.org/licenses/MIT>, at your option. This file may not be
 // copied, modified, or distributed except according to those terms.
 #![feature(test)]
-extern crate test;
 extern crate fringe;
+extern crate test;
 
-use fringe::{OsStack, Generator};
+use fringe::{Generator, OsStack};
 
 #[bench]
 fn generate(b: &mut test::Bencher) {
   let stack = OsStack::new(0).unwrap();
-  let mut identity = Generator::new(stack, move |yielder, mut input| {
-    loop { input = yielder.suspend(input) }
+  let mut identity = Generator::new(stack, move |yielder, mut input| loop {
+    input = yielder.suspend(input)
   });
 
-  b.iter(|| for _ in 0..10 { test::black_box(identity.resume(test::black_box(0))); });
-  unsafe { identity.unsafe_unwrap(); }
+  b.iter(|| {
+    for _ in 0..10 {
+      test::black_box(identity.resume(test::black_box(0)));
+    }
+  });
+  unsafe {
+    identity.unsafe_unwrap();
+  }
 }
diff --git a/rustfmt.toml b/rustfmt.toml
new file mode 100644
index 00000000..b196eaa2
--- /dev/null
+++ b/rustfmt.toml
@@ -0,0 +1 @@
+tab_spaces = 2
diff --git a/tests/fpe.rs b/tests/fpe.rs
index b9e97f01..701304f2 100644
--- a/tests/fpe.rs
+++ b/tests/fpe.rs
@@ -11,11 +11,11 @@
 #![feature(asm)]
 extern crate fringe;
 extern crate test;
-use fringe::{OsStack, Generator};
+use fringe::{Generator, OsStack};
 use test::black_box;
 
 const FE_DIVBYZERO: i32 = 0x4;
-extern {
+extern "C" {
   fn feenableexcept(except: i32) -> i32;
 }
 
@@ -27,6 +27,8 @@ fn fpe() {
     yielder.suspend(1.0 / black_box(0.0));
   });
 
-  unsafe { feenableexcept(FE_DIVBYZERO); }
+  unsafe {
+    feenableexcept(FE_DIVBYZERO);
+  }
   println!("{:?}", gen.resume(()));
 }
diff --git a/tests/generator.rs b/tests/generator.rs
index d230153a..95c7509e 100644
--- a/tests/generator.rs
+++ b/tests/generator.rs
@@ -7,12 +7,14 @@
 // copied, modified, or distributed except according to those terms.
 extern crate fringe;
 
-use fringe::{SliceStack, OwnedStack, OsStack};
 use fringe::generator::{Generator, Yielder};
+use fringe::{OsStack, OwnedStack, SliceStack};
 
 fn add_one_fn(yielder: &Yielder<i32, i32>, mut input: i32) {
   loop {
-    if input == 0 { break }
+    if input == 0 {
+      break;
+    }
     input = yielder.suspend(input + 1)
   }
 }
@@ -48,7 +50,7 @@ fn move_after_new() {
 #[should_panic]
 fn panic_safety() {
   struct Wrapper {
-    gen: Generator<'static, (), (), OsStack>
+    gen: Generator<'static, (), (), OsStack>,
   }
 
   impl Drop for Wrapper {
@@ -58,9 +60,7 @@ fn panic_safety() {
   }
 
   let stack = OsStack::new(4 << 20).unwrap();
-  let gen = Generator::new(stack, move |_yielder, ()| {
-    panic!("foo")
-  });
+  let gen = Generator::new(stack, move |_yielder, ()| panic!("foo"));
 
   let mut wrapper = Wrapper { gen: gen };
   wrapper.gen.resume(());
@@ -99,7 +99,7 @@ fn forget_yielded() {
     }
   }
 
-  let stack = fringe::OsStack::new(1<<16).unwrap();
+  let stack = fringe::OsStack::new(1 << 16).unwrap();
   let flag = Cell::new(false);
   let mut generator = Generator::new(stack, |yielder, ()| {
     yielder.suspend(Dropper(&flag));
diff --git a/tests/iterator.rs b/tests/iterator.rs
index 064a3abf..03330c49 100644
--- a/tests/iterator.rs
+++ b/tests/iterator.rs
@@ -6,17 +6,21 @@
 // copied, modified, or distributed except according to those terms.
 extern crate fringe;
 
-use fringe::OsStack;
 use fringe::generator::Generator;
+use fringe::OsStack;
 
 #[test]
 fn producer() {
   let stack = OsStack::new(0).unwrap();
   let mut gen = Generator::new(stack, move |yielder, ()| {
-    for i in 0.. { yielder.suspend(i) }
+    for i in 0.. {
+      yielder.suspend(i)
+    }
   });
   assert_eq!(gen.next(), Some(0));
   assert_eq!(gen.next(), Some(1));
   assert_eq!(gen.next(), Some(2));
-  unsafe { gen.unsafe_unwrap(); }
+  unsafe {
+    gen.unsafe_unwrap();
+  }
 }
diff --git a/tests/stack.rs b/tests/stack.rs
index 17c51b2f..9682fdcd 100644
--- a/tests/stack.rs
+++ b/tests/stack.rs
@@ -6,16 +6,16 @@
 // copied, modified, or distributed except according to those terms.
 #![feature(alloc, allocator_api)]
 
-extern crate core;
 extern crate alloc;
+extern crate core;
 extern crate fringe;
 
 use alloc::alloc::alloc;
 use core::alloc::Layout;
 
 use alloc::boxed::Box;
+use fringe::{OsStack, OwnedStack, SliceStack, Stack, STACK_ALIGNMENT};
 use std::slice;
-use fringe::{STACK_ALIGNMENT, Stack, SliceStack, OwnedStack, OsStack};
 
 unsafe fn heap_allocate(size: usize, align: usize) -> *mut u8 {
   alloc(Layout::from_size_align_unchecked(size, align))
@@ -90,7 +90,9 @@ fn default_os_stack() {
   assert_eq!(stack.limit() as usize & (STACK_ALIGNMENT - 1), 0);
 
   // Make sure the topmost page of the stack, at least, is accessible.
-  unsafe { *(stack.base().offset(-1)) = 0; }
+  unsafe {
+    *(stack.base().offset(-1)) = 0;
+  }
 }
 
 #[test]
@@ -100,5 +102,7 @@ fn one_page_os_stack() {
   assert_eq!(stack.limit() as usize & (STACK_ALIGNMENT - 1), 0);
 
   // Make sure the topmost page of the stack, at least, is accessible.
-  unsafe { *(stack.base().offset(-1)) = 0; }
+  unsafe {
+    *(stack.base().offset(-1)) = 0;
+  }
 }