diff --git a/tests/test_generics.rs b/tests/test_generics.rs
index 822d22d..0cdce4e 100644
--- a/tests/test_generics.rs
+++ b/tests/test_generics.rs
@@ -8,42 +8,32 @@
 fn test_split_for_impl() {
     // <'a, 'b: 'a, #[may_dangle] T: 'a = ()> where T: Debug
     let generics = Generics {
-        lifetimes: vec![
-            LifetimeDef {
-                attrs: Vec::new(),
-                lifetime: Lifetime::new("'a"),
-                bounds: Vec::new(),
-            },
-            LifetimeDef {
-                attrs: Vec::new(),
-                lifetime: Lifetime::new("'b"),
-                bounds: vec![
-                    Lifetime::new("'a"),
-                ],
-            },
-        ],
-        ty_params: vec![
-            TyParam {
-                attrs: vec![
-                    Attribute {
-                        style: AttrStyle::Outer,
-                        value: MetaItem::Word("may_dangle".into()),
-                        is_sugared_doc: false,
-                    },
-                ],
-                ident: Ident::new("T"),
-                bounds: vec![
-                    TyParamBound::Region(Lifetime::new("'a")),
-                ],
-                default: Some(Ty::Tup(Vec::new())),
-            },
-        ],
+        lifetimes: vec![LifetimeDef {
+                            attrs: Vec::new(),
+                            lifetime: Lifetime::new("'a"),
+                            bounds: Vec::new(),
+                        },
+                        LifetimeDef {
+                            attrs: Vec::new(),
+                            lifetime: Lifetime::new("'b"),
+                            bounds: vec![Lifetime::new("'a")],
+                        }],
+        ty_params: vec![TyParam {
+                            attrs: vec![Attribute {
+                                            style: AttrStyle::Outer,
+                                            value: MetaItem::Word("may_dangle".into()),
+                                            is_sugared_doc: false,
+                                        }],
+                            ident: Ident::new("T"),
+                            bounds: vec![TyParamBound::Region(Lifetime::new("'a"))],
+                            default: Some(Ty::Tup(Vec::new())),
+                        }],
         where_clause: WhereClause {
-            predicates: vec![
-                WherePredicate::BoundPredicate(WhereBoundPredicate {
-                    bound_lifetimes: Vec::new(),
-                    bounded_ty: Ty::Path(None, "T".into()),
-                    bounds: vec![
+            predicates: vec![WherePredicate::BoundPredicate(WhereBoundPredicate {
+                                                                bound_lifetimes: Vec::new(),
+                                                                bounded_ty:
+                                                                    Ty::Path(None, "T".into()),
+                                                                bounds: vec![
                         TyParamBound::Trait(
                             PolyTraitRef {
                                 bound_lifetimes: Vec::new(),
@@ -52,8 +42,7 @@
                             TraitBoundModifier::None,
                         ),
                     ],
-                }),
-            ],
+                                                            })],
         },
     };
 
@@ -81,22 +70,18 @@
     assert_eq!(expected, parse_ty_param_bound(tokens.as_str()).unwrap());
 
     let tokens = quote!(Debug);
-    let expected = TyParamBound::Trait(
-        PolyTraitRef {
-            bound_lifetimes: Vec::new(),
-            trait_ref: "Debug".into(),
-        },
-        TraitBoundModifier::None,
-    );
+    let expected = TyParamBound::Trait(PolyTraitRef {
+                                           bound_lifetimes: Vec::new(),
+                                           trait_ref: "Debug".into(),
+                                       },
+                                       TraitBoundModifier::None);
     assert_eq!(expected, parse_ty_param_bound(tokens.as_str()).unwrap());
 
     let tokens = quote!(?Sized);
-    let expected = TyParamBound::Trait(
-        PolyTraitRef {
-            bound_lifetimes: Vec::new(),
-            trait_ref: "Sized".into(),
-        },
-        TraitBoundModifier::Maybe,
-    );
+    let expected = TyParamBound::Trait(PolyTraitRef {
+                                           bound_lifetimes: Vec::new(),
+                                           trait_ref: "Sized".into(),
+                                       },
+                                       TraitBoundModifier::Maybe);
     assert_eq!(expected, parse_ty_param_bound(tokens.as_str()).unwrap());
 }
diff --git a/tests/test_macro_input.rs b/tests/test_macro_input.rs
index 00314fe..b209bc6 100644
--- a/tests/test_macro_input.rs
+++ b/tests/test_macro_input.rs
@@ -29,31 +29,30 @@
     let expected = MacroInput {
         ident: "Item".into(),
         vis: Visibility::Public,
-        attrs: vec![
-            Attribute {
-                style: AttrStyle::Outer,
-                value: MetaItem::List("derive".into(), vec![
+        attrs: vec![Attribute {
+                        style: AttrStyle::Outer,
+                        value: MetaItem::List("derive".into(),
+                                              vec![
                     NestedMetaItem::MetaItem(MetaItem::Word("Debug".into())),
                     NestedMetaItem::MetaItem(MetaItem::Word("Clone".into())),
                 ]),
-                is_sugared_doc: false,
-            },
-        ],
+                        is_sugared_doc: false,
+                    }],
         generics: Generics::default(),
-        body: Body::Struct(VariantData::Struct(vec![
-            Field {
-                ident: Some("ident".into()),
-                vis: Visibility::Public,
-                attrs: Vec::new(),
-                ty: Ty::Path(None, "Ident".into()),
-            },
-            Field {
-                ident: Some("attrs".into()),
-                vis: Visibility::Public,
-                attrs: Vec::new(),
-                ty: Ty::Path(None, Path {
-                    global: false,
-                    segments: vec![
+        body: Body::Struct(VariantData::Struct(vec![Field {
+                                                        ident: Some("ident".into()),
+                                                        vis: Visibility::Public,
+                                                        attrs: Vec::new(),
+                                                        ty: Ty::Path(None, "Ident".into()),
+                                                    },
+                                                    Field {
+                                                        ident: Some("attrs".into()),
+                                                        vis: Visibility::Public,
+                                                        attrs: Vec::new(),
+                                                        ty: Ty::Path(None,
+                                                                     Path {
+                                                                         global: false,
+                                                                         segments: vec![
                         PathSegment {
                             ident: "Vec".into(),
                             parameters: PathParameters::AngleBracketed(
@@ -65,9 +64,8 @@
                             ),
                         }
                     ],
-                }),
-            },
-        ])),
+                                                                     }),
+                                                    }])),
     };
 
     assert_eq!(expected, parse_macro_input(raw).unwrap());
@@ -113,20 +111,18 @@
         ],
         generics: Generics {
             lifetimes: Vec::new(),
-            ty_params: vec![
-                TyParam {
-                    attrs: Vec::new(),
-                    ident: "T".into(),
-                    bounds: Vec::new(),
-                    default: None,
-                },
-                TyParam {
-                    attrs: Vec::new(),
-                    ident: "E".into(),
-                    bounds: Vec::new(),
-                    default: None,
-                },
-            ],
+            ty_params: vec![TyParam {
+                                attrs: Vec::new(),
+                                ident: "T".into(),
+                                bounds: Vec::new(),
+                                default: None,
+                            },
+                            TyParam {
+                                attrs: Vec::new(),
+                                ident: "E".into(),
+                                bounds: Vec::new(),
+                                default: None,
+                            }],
             where_clause: WhereClause { predicates: Vec::new() },
         },
         body: Body::Enum(vec![
diff --git a/tests/test_round_trip.rs b/tests/test_round_trip.rs
index f9b5c01..028ac44 100644
--- a/tests/test_round_trip.rs
+++ b/tests/test_round_trip.rs
@@ -110,7 +110,8 @@
             };
 
             if before == after {
-                errorf!("pass in {}ms\n", elapsed.as_secs() * 1000 + elapsed.subsec_nanos() as u64 / 1_000_000);
+                errorf!("pass in {}ms\n",
+                        elapsed.as_secs() * 1000 + elapsed.subsec_nanos() as u64 / 1_000_000);
                 true
             } else {
                 errorf!("FAIL\nbefore: {}\nafter: {}\n",
@@ -121,7 +122,7 @@
         });
         match equal {
             Err(_) => errorf!("ignoring syntex panic\n"),
-            Ok(true) => {},
+            Ok(true) => {}
             Ok(false) => failed += 1,
         }
     }
@@ -258,35 +259,35 @@
         fn fold_trait_item(&mut self, i: TraitItem) -> SmallVector<TraitItem> {
             let noop = fold::noop_fold_trait_item(i, self).expect_one("");
             SmallVector::one(TraitItem {
-                node: match noop.node {
-                    TraitItemKind::Method(sig, body) => {
+                                 node: match noop.node {
+                                     TraitItemKind::Method(sig, body) => {
                         TraitItemKind::Method(MethodSig {
                                                   constness: self.fold_spanned(sig.constness),
                                                   ..sig
                                               },
                                               body)
                     }
-                    node => node,
-                },
-                ..noop
-            })
+                                     node => node,
+                                 },
+                                 ..noop
+                             })
         }
 
         fn fold_impl_item(&mut self, i: ImplItem) -> SmallVector<ImplItem> {
             let noop = fold::noop_fold_impl_item(i, self).expect_one("");
             SmallVector::one(ImplItem {
-                node: match noop.node {
-                    ImplItemKind::Method(sig, body) => {
+                                 node: match noop.node {
+                                     ImplItemKind::Method(sig, body) => {
                         ImplItemKind::Method(MethodSig {
                                                  constness: self.fold_spanned(sig.constness),
                                                  ..sig
                                              },
                                              body)
                     }
-                    node => node,
-                },
-                ..noop
-            })
+                                     node => node,
+                                 },
+                                 ..noop
+                             })
         }
 
         fn fold_attribute(&mut self, mut at: Attribute) -> Option<Attribute> {
@@ -304,9 +305,7 @@
                         MetaItemKind::List(nested.move_map(|e| self.fold_meta_list_item(e)))
                     }
                     // default fold_meta_item does not fold the value span
-                    MetaItemKind::NameValue(lit) => {
-                        MetaItemKind::NameValue(self.fold_spanned(lit))
-                    }
+                    MetaItemKind::NameValue(lit) => MetaItemKind::NameValue(self.fold_spanned(lit)),
                 },
                 span: self.new_span(span),
             }
@@ -339,9 +338,9 @@
                 TokenTree::Delimited(span, ref delimed) => {
                     TokenTree::Delimited(self.new_span(span),
                                          Rc::new(Delimited {
-                                             delim: delimed.delim,
-                                             tts: self.fold_tts(&delimed.tts),
-                                         }))
+                                                     delim: delimed.delim,
+                                                     tts: self.fold_tts(&delimed.tts),
+                                                 }))
                 }
                 TokenTree::Sequence(span, ref seq) => {
                     TokenTree::Sequence(self.new_span(span),
diff --git a/tests/test_token_trees.rs b/tests/test_token_trees.rs
index 8ec2c2f..8351f54 100644
--- a/tests/test_token_trees.rs
+++ b/tests/test_token_trees.rs
@@ -13,36 +13,29 @@
         }
     ";
 
-    let expected = vec![
-        Token(Pound),
-        delimited(Bracket, vec![
-            ident("derive"),
-            delimited(Paren, vec![
-                ident("Debug"),
-                Token(Comma),
-                ident("Clone"),
-            ]),
-        ]),
-        ident("pub"),
-        ident("struct"),
-        ident("Item"),
-        delimited(Brace, vec![
-            ident("pub"),
-            ident("ident"),
-            Token(Colon),
-            ident("Ident"),
-            Token(Comma),
+    let expected =
+        vec![Token(Pound),
+             delimited(Bracket,
+                       vec![ident("derive"),
+                            delimited(Paren, vec![ident("Debug"), Token(Comma), ident("Clone")])]),
+             ident("pub"),
+             ident("struct"),
+             ident("Item"),
+             delimited(Brace,
+                       vec![ident("pub"),
+                            ident("ident"),
+                            Token(Colon),
+                            ident("Ident"),
+                            Token(Comma),
 
-            ident("pub"),
-            ident("attrs"),
-            Token(Colon),
-            ident("Vec"),
-            Token(Lt),
-            ident("Attribute"),
-            Token(Gt),
-            Token(Comma),
-        ]),
-    ];
+                            ident("pub"),
+                            ident("attrs"),
+                            Token(Colon),
+                            ident("Vec"),
+                            Token(Lt),
+                            ident("Attribute"),
+                            Token(Gt),
+                            Token(Comma)])];
 
     let result = syn::parse_token_trees(raw).unwrap();
     if result != expected {
@@ -52,9 +45,9 @@
 
 fn delimited(delim: syn::DelimToken, tts: Vec<TokenTree>) -> TokenTree {
     TokenTree::Delimited(syn::Delimited {
-        delim: delim,
-        tts: tts,
-    })
+                             delim: delim,
+                             tts: tts,
+                         })
 }
 
 fn ident(s: &str) -> TokenTree {