diff --git a/test_suite/tests/test_de.rs b/test_suite/tests/test_de.rs
index 0de449fd..c381213b 100644
--- a/test_suite/tests/test_de.rs
+++ b/test_suite/tests/test_de.rs
@@ -311,24 +311,27 @@ fn test_string() {
 fn test_option() {
     test(None::<i32>, &[Token::Unit]);
     test(None::<i32>, &[Token::None]);
-    test(Some(1), &[
-        Token::Some,
-        Token::I32(1),
-    ]);
+    test(Some(1), &[Token::Some, Token::I32(1)]);
 }
 
 #[test]
 fn test_result() {
-    test(Ok::<i32, i32>(0), &[
-        Token::Enum { name: "Result" },
-        Token::Str("Ok"),
-        Token::I32(0),
-    ]);
-    test(Err::<i32, i32>(1), &[
-        Token::Enum { name: "Result" },
-        Token::Str("Err"),
-        Token::I32(1),
-    ]);
+    test(
+        Ok::<i32, i32>(0),
+        &[
+            Token::Enum { name: "Result" },
+            Token::Str("Ok"),
+            Token::I32(0),
+        ],
+    );
+    test(
+        Err::<i32, i32>(1),
+        &[
+            Token::Enum { name: "Result" },
+            Token::Str("Err"),
+            Token::I32(1),
+        ],
+    );
 }
 
 #[test]
@@ -339,650 +342,862 @@ fn test_unit() {
 #[test]
 fn test_unit_struct() {
     test(UnitStruct, &[Token::Unit]);
-    test(UnitStruct, &[
-        Token::UnitStruct { name: "UnitStruct" },
-    ]);
+    test(UnitStruct, &[Token::UnitStruct { name: "UnitStruct" }]);
 }
 
 #[test]
 fn test_newtype_struct() {
-    test(NewtypeStruct(1), &[
-        Token::NewtypeStruct { name: "NewtypeStruct" },
-        Token::I32(1),
-    ]);
+    test(
+        NewtypeStruct(1),
+        &[
+            Token::NewtypeStruct {
+                name: "NewtypeStruct",
+            },
+            Token::I32(1),
+        ],
+    );
 }
 
 #[test]
 fn test_tuple_struct() {
-    test(TupleStruct(1, 2, 3), &[
-        Token::Seq { len: Some(3) },
+    test(
+        TupleStruct(1, 2, 3),
+        &[
+            Token::Seq { len: Some(3) },
             Token::I32(1),
             Token::I32(2),
             Token::I32(3),
-        Token::SeqEnd,
-    ]);
-    test(TupleStruct(1, 2, 3), &[
-        Token::Seq { len: None },
+            Token::SeqEnd,
+        ],
+    );
+    test(
+        TupleStruct(1, 2, 3),
+        &[
+            Token::Seq { len: None },
             Token::I32(1),
             Token::I32(2),
             Token::I32(3),
-        Token::SeqEnd,
-    ]);
-    test(TupleStruct(1, 2, 3), &[
-        Token::TupleStruct { name: "TupleStruct", len: 3 },
+            Token::SeqEnd,
+        ],
+    );
+    test(
+        TupleStruct(1, 2, 3),
+        &[
+            Token::TupleStruct {
+                name: "TupleStruct",
+                len: 3,
+            },
             Token::I32(1),
             Token::I32(2),
             Token::I32(3),
-        Token::TupleStructEnd,
-    ]);
-    test(TupleStruct(1, 2, 3), &[
-        Token::TupleStruct { name: "TupleStruct", len: 3 },
+            Token::TupleStructEnd,
+        ],
+    );
+    test(
+        TupleStruct(1, 2, 3),
+        &[
+            Token::TupleStruct {
+                name: "TupleStruct",
+                len: 3,
+            },
             Token::I32(1),
             Token::I32(2),
             Token::I32(3),
-        Token::TupleStructEnd,
-    ]);
+            Token::TupleStructEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_btreeset() {
-    test(BTreeSet::<isize>::new(), &[
-        Token::Seq { len: Some(0) },
-        Token::SeqEnd,
-    ]);
-    test(btreeset![btreeset![], btreeset![1], btreeset![2, 3]], &[
-        Token::Seq { len: Some(3) },
+    test(
+        BTreeSet::<isize>::new(),
+        &[Token::Seq { len: Some(0) }, Token::SeqEnd],
+    );
+    test(
+        btreeset![btreeset![], btreeset![1], btreeset![2, 3]],
+        &[
+            Token::Seq { len: Some(3) },
             Token::Seq { len: Some(0) },
             Token::SeqEnd,
-
             Token::Seq { len: Some(1) },
-                Token::I32(1),
+            Token::I32(1),
             Token::SeqEnd,
-
             Token::Seq { len: Some(2) },
-                Token::I32(2),
-                Token::I32(3),
+            Token::I32(2),
+            Token::I32(3),
             Token::SeqEnd,
-        Token::SeqEnd,
-    ]);
-    test(BTreeSet::<isize>::new(), &[
-        Token::TupleStruct { name: "Anything", len: 0 },
-        Token::TupleStructEnd,
-    ]);
+            Token::SeqEnd,
+        ],
+    );
+    test(
+        BTreeSet::<isize>::new(),
+        &[
+            Token::TupleStruct {
+                name: "Anything",
+                len: 0,
+            },
+            Token::TupleStructEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_hashset() {
-    test(HashSet::<isize>::new(), &[
-        Token::Seq { len: Some(0) },
-        Token::SeqEnd,
-    ]);
-    test(hashset![1, 2, 3], &[
-        Token::Seq { len: Some(3) },
+    test(
+        HashSet::<isize>::new(),
+        &[Token::Seq { len: Some(0) }, Token::SeqEnd],
+    );
+    test(
+        hashset![1, 2, 3],
+        &[
+            Token::Seq { len: Some(3) },
             Token::I32(1),
             Token::I32(2),
             Token::I32(3),
-        Token::SeqEnd,
-    ]);
-    test(HashSet::<isize>::new(), &[
-        Token::TupleStruct { name: "Anything", len: 0 },
-        Token::TupleStructEnd,
-    ]);
-    test(hashset![FnvHasher @ 1, 2, 3], &[
-        Token::Seq { len: Some(3) },
+            Token::SeqEnd,
+        ],
+    );
+    test(
+        HashSet::<isize>::new(),
+        &[
+            Token::TupleStruct {
+                name: "Anything",
+                len: 0,
+            },
+            Token::TupleStructEnd,
+        ],
+    );
+    test(
+        hashset![FnvHasher @ 1, 2, 3],
+        &[
+            Token::Seq { len: Some(3) },
             Token::I32(1),
             Token::I32(2),
             Token::I32(3),
-        Token::SeqEnd,
-    ]);
+            Token::SeqEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_vec() {
-    test(Vec::<isize>::new(), &[
-        Token::Seq { len: Some(0) },
-        Token::SeqEnd,
-    ]);
+    test(
+        Vec::<isize>::new(),
+        &[Token::Seq { len: Some(0) }, Token::SeqEnd],
+    );
 
-    test(vec![vec![], vec![1], vec![2, 3]], &[
-        Token::Seq { len: Some(3) },
+    test(
+        vec![vec![], vec![1], vec![2, 3]],
+        &[
+            Token::Seq { len: Some(3) },
             Token::Seq { len: Some(0) },
             Token::SeqEnd,
-
             Token::Seq { len: Some(1) },
-                Token::I32(1),
+            Token::I32(1),
             Token::SeqEnd,
-
             Token::Seq { len: Some(2) },
-                Token::I32(2),
-                Token::I32(3),
+            Token::I32(2),
+            Token::I32(3),
             Token::SeqEnd,
-        Token::SeqEnd,
-    ]);
-    test(Vec::<isize>::new(), &[
-        Token::TupleStruct { name: "Anything", len: 0 },
-        Token::TupleStructEnd,
-    ]);
+            Token::SeqEnd,
+        ],
+    );
+    test(
+        Vec::<isize>::new(),
+        &[
+            Token::TupleStruct {
+                name: "Anything",
+                len: 0,
+            },
+            Token::TupleStructEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_array() {
-    test([0; 0], &[
-        Token::Seq { len: Some(0) },
-        Token::SeqEnd,
-    ]);
-    test([0; 0], &[
-        Token::Tuple { len: 0 },
-        Token::TupleEnd,
-    ]);
-    test(([0; 0], [1], [2, 3]), &[
-        Token::Seq { len: Some(3) },
+    test([0; 0], &[Token::Seq { len: Some(0) }, Token::SeqEnd]);
+    test([0; 0], &[Token::Tuple { len: 0 }, Token::TupleEnd]);
+    test(
+        ([0; 0], [1], [2, 3]),
+        &[
+            Token::Seq { len: Some(3) },
             Token::Seq { len: Some(0) },
             Token::SeqEnd,
-
             Token::Seq { len: Some(1) },
-                Token::I32(1),
+            Token::I32(1),
             Token::SeqEnd,
-
             Token::Seq { len: Some(2) },
-                Token::I32(2),
-                Token::I32(3),
+            Token::I32(2),
+            Token::I32(3),
             Token::SeqEnd,
-        Token::SeqEnd,
-    ]);
-    test(([0; 0], [1], [2, 3]), &[
-        Token::Tuple { len: 3 },
+            Token::SeqEnd,
+        ],
+    );
+    test(
+        ([0; 0], [1], [2, 3]),
+        &[
+            Token::Tuple { len: 3 },
             Token::Tuple { len: 0 },
             Token::TupleEnd,
-
             Token::Tuple { len: 1 },
-                Token::I32(1),
+            Token::I32(1),
             Token::TupleEnd,
-
             Token::Tuple { len: 2 },
-                Token::I32(2),
-                Token::I32(3),
+            Token::I32(2),
+            Token::I32(3),
             Token::TupleEnd,
-        Token::TupleEnd,
-    ]);
-    test([0; 0], &[
-        Token::TupleStruct { name: "Anything", len: 0 },
-        Token::TupleStructEnd,
-    ]);
+            Token::TupleEnd,
+        ],
+    );
+    test(
+        [0; 0],
+        &[
+            Token::TupleStruct {
+                name: "Anything",
+                len: 0,
+            },
+            Token::TupleStructEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_tuple() {
-    test((1,), &[
-        Token::Seq { len: Some(1) },
-            Token::I32(1),
-        Token::SeqEnd,
-    ]);
-    test((1, 2, 3), &[
-        Token::Seq { len: Some(3) },
+    test(
+        (1,),
+        &[Token::Seq { len: Some(1) }, Token::I32(1), Token::SeqEnd],
+    );
+    test(
+        (1, 2, 3),
+        &[
+            Token::Seq { len: Some(3) },
             Token::I32(1),
             Token::I32(2),
             Token::I32(3),
-        Token::SeqEnd,
-    ]);
-    test((1,), &[
-        Token::Tuple { len: 1 },
-            Token::I32(1),
-        Token::TupleEnd,
-    ]);
-    test((1, 2, 3), &[
-        Token::Tuple { len: 3 },
+            Token::SeqEnd,
+        ],
+    );
+    test(
+        (1,),
+        &[Token::Tuple { len: 1 }, Token::I32(1), Token::TupleEnd],
+    );
+    test(
+        (1, 2, 3),
+        &[
+            Token::Tuple { len: 3 },
             Token::I32(1),
             Token::I32(2),
             Token::I32(3),
-        Token::TupleEnd,
-    ]);
+            Token::TupleEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_btreemap() {
-    test(BTreeMap::<isize, isize>::new(), &[
-        Token::Map { len: Some(0) },
-        Token::MapEnd,
-    ]);
-    test(btreemap![1 => 2], &[
-        Token::Map { len: Some(1) },
+    test(
+        BTreeMap::<isize, isize>::new(),
+        &[Token::Map { len: Some(0) }, Token::MapEnd],
+    );
+    test(
+        btreemap![1 => 2],
+        &[
+            Token::Map { len: Some(1) },
             Token::I32(1),
             Token::I32(2),
-        Token::MapEnd,
-    ]);
-    test(btreemap![1 => 2, 3 => 4], &[
-        Token::Map { len: Some(2) },
+            Token::MapEnd,
+        ],
+    );
+    test(
+        btreemap![1 => 2, 3 => 4],
+        &[
+            Token::Map { len: Some(2) },
             Token::I32(1),
             Token::I32(2),
-
             Token::I32(3),
             Token::I32(4),
-        Token::MapEnd,
-    ]);
-    test(btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]], &[
-        Token::Map { len: Some(2) },
+            Token::MapEnd,
+        ],
+    );
+    test(
+        btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]],
+        &[
+            Token::Map { len: Some(2) },
             Token::I32(1),
             Token::Map { len: Some(0) },
             Token::MapEnd,
-
             Token::I32(2),
             Token::Map { len: Some(2) },
-                Token::I32(3),
-                Token::I32(4),
-
-                Token::I32(5),
-                Token::I32(6),
+            Token::I32(3),
+            Token::I32(4),
+            Token::I32(5),
+            Token::I32(6),
             Token::MapEnd,
-        Token::MapEnd,
-    ]);
-    test(BTreeMap::<isize, isize>::new(), &[
-        Token::Struct { name: "Anything", len: 0 },
-        Token::StructEnd,
-    ]);
+            Token::MapEnd,
+        ],
+    );
+    test(
+        BTreeMap::<isize, isize>::new(),
+        &[
+            Token::Struct {
+                name: "Anything",
+                len: 0,
+            },
+            Token::StructEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_hashmap() {
-    test(HashMap::<isize, isize>::new(), &[
-        Token::Map { len: Some(0) },
-        Token::MapEnd,
-    ]);
-    test(hashmap![1 => 2], &[
-        Token::Map { len: Some(1) },
+    test(
+        HashMap::<isize, isize>::new(),
+        &[Token::Map { len: Some(0) }, Token::MapEnd],
+    );
+    test(
+        hashmap![1 => 2],
+        &[
+            Token::Map { len: Some(1) },
             Token::I32(1),
             Token::I32(2),
-        Token::MapEnd,
-    ]);
-    test(hashmap![1 => 2, 3 => 4], &[
-        Token::Map { len: Some(2) },
+            Token::MapEnd,
+        ],
+    );
+    test(
+        hashmap![1 => 2, 3 => 4],
+        &[
+            Token::Map { len: Some(2) },
             Token::I32(1),
             Token::I32(2),
-
             Token::I32(3),
             Token::I32(4),
-        Token::MapEnd,
-    ]);
-    test(hashmap![1 => hashmap![], 2 => hashmap![3 => 4, 5 => 6]], &[
-        Token::Map { len: Some(2) },
+            Token::MapEnd,
+        ],
+    );
+    test(
+        hashmap![1 => hashmap![], 2 => hashmap![3 => 4, 5 => 6]],
+        &[
+            Token::Map { len: Some(2) },
             Token::I32(1),
             Token::Map { len: Some(0) },
             Token::MapEnd,
-
             Token::I32(2),
             Token::Map { len: Some(2) },
-                Token::I32(3),
-                Token::I32(4),
-
-                Token::I32(5),
-                Token::I32(6),
-            Token::MapEnd,
-        Token::MapEnd,
-    ]);
-    test(HashMap::<isize, isize>::new(), &[
-        Token::Struct { name: "Anything", len: 0 },
-        Token::StructEnd,
-    ]);
-    test(hashmap![FnvHasher @ 1 => 2, 3 => 4], &[
-        Token::Map { len: Some(2) },
-            Token::I32(1),
-            Token::I32(2),
-
             Token::I32(3),
             Token::I32(4),
-        Token::MapEnd,
-    ]);
+            Token::I32(5),
+            Token::I32(6),
+            Token::MapEnd,
+            Token::MapEnd,
+        ],
+    );
+    test(
+        HashMap::<isize, isize>::new(),
+        &[
+            Token::Struct {
+                name: "Anything",
+                len: 0,
+            },
+            Token::StructEnd,
+        ],
+    );
+    test(
+        hashmap![FnvHasher @ 1 => 2, 3 => 4],
+        &[
+            Token::Map { len: Some(2) },
+            Token::I32(1),
+            Token::I32(2),
+            Token::I32(3),
+            Token::I32(4),
+            Token::MapEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_struct() {
-    test(Struct { a: 1, b: 2, c: 0 }, &[
-        Token::Map { len: Some(3) },
+    test(
+        Struct { a: 1, b: 2, c: 0 },
+        &[
+            Token::Map { len: Some(3) },
             Token::Str("a"),
             Token::I32(1),
-
             Token::Str("b"),
             Token::I32(2),
-        Token::MapEnd,
-    ]);
-    test(Struct { a: 1, b: 2, c: 0 }, &[
-        Token::Map { len: Some(3) },
+            Token::MapEnd,
+        ],
+    );
+    test(
+        Struct { a: 1, b: 2, c: 0 },
+        &[
+            Token::Map { len: Some(3) },
             Token::U8(0),
             Token::I32(1),
-
             Token::U8(1),
             Token::I32(2),
-        Token::MapEnd,
-    ]);
-    test(Struct { a: 1, b: 2, c: 0 }, &[
-        Token::Map { len: Some(3) },
+            Token::MapEnd,
+        ],
+    );
+    test(
+        Struct { a: 1, b: 2, c: 0 },
+        &[
+            Token::Map { len: Some(3) },
             Token::U16(0),
             Token::I32(1),
-
             Token::U16(1),
             Token::I32(2),
-        Token::MapEnd,
-    ]);
-    test(Struct { a: 1, b: 2, c: 0 }, &[
-        Token::Map { len: Some(3) },
+            Token::MapEnd,
+        ],
+    );
+    test(
+        Struct { a: 1, b: 2, c: 0 },
+        &[
+            Token::Map { len: Some(3) },
             Token::U32(0),
             Token::I32(1),
-
             Token::U32(1),
             Token::I32(2),
-        Token::MapEnd,
-    ]);
-    test(Struct { a: 1, b: 2, c: 0 }, &[
-        Token::Map { len: Some(3) },
+            Token::MapEnd,
+        ],
+    );
+    test(
+        Struct { a: 1, b: 2, c: 0 },
+        &[
+            Token::Map { len: Some(3) },
             Token::U64(0),
             Token::I32(1),
-
             Token::U64(1),
             Token::I32(2),
-        Token::MapEnd,
-    ]);
+            Token::MapEnd,
+        ],
+    );
     // Mixed key types
-    test(Struct { a: 1, b: 2, c: 0 }, &[
-        Token::Map { len: Some(3) },
+    test(
+        Struct { a: 1, b: 2, c: 0 },
+        &[
+            Token::Map { len: Some(3) },
             Token::U8(0),
             Token::I32(1),
-
             Token::U64(1),
             Token::I32(2),
-        Token::MapEnd,
-    ]);
-    test(Struct { a: 1, b: 2, c: 0 }, &[
-        Token::Map { len: Some(3) },
+            Token::MapEnd,
+        ],
+    );
+    test(
+        Struct { a: 1, b: 2, c: 0 },
+        &[
+            Token::Map { len: Some(3) },
             Token::U8(0),
             Token::I32(1),
-
             Token::Str("b"),
             Token::I32(2),
-        Token::MapEnd,
-    ]);
-    test(Struct { a: 1, b: 2, c: 0 }, &[
-        Token::Struct { name: "Struct", len: 2 },
+            Token::MapEnd,
+        ],
+    );
+    test(
+        Struct { a: 1, b: 2, c: 0 },
+        &[
+            Token::Struct {
+                name: "Struct",
+                len: 2,
+            },
             Token::Str("a"),
             Token::I32(1),
-
             Token::Str("b"),
             Token::I32(2),
-        Token::StructEnd,
-    ]);
-    test(Struct { a: 1, b: 2, c: 0 }, &[
-        Token::Seq { len: Some(3) },
+            Token::StructEnd,
+        ],
+    );
+    test(
+        Struct { a: 1, b: 2, c: 0 },
+        &[
+            Token::Seq { len: Some(3) },
             Token::I32(1),
             Token::I32(2),
-        Token::SeqEnd,
-    ]);
+            Token::SeqEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_struct_borrowed_keys() {
-    test(Struct { a: 1, b: 2, c: 0 }, &[
-        Token::Map { len: Some(3) },
+    test(
+        Struct { a: 1, b: 2, c: 0 },
+        &[
+            Token::Map { len: Some(3) },
             Token::BorrowedStr("a"),
             Token::I32(1),
-
             Token::BorrowedStr("b"),
             Token::I32(2),
-        Token::MapEnd,
-    ]);
-    test(Struct { a: 1, b: 2, c: 0 }, &[
-        Token::Struct { name: "Struct", len: 2 },
+            Token::MapEnd,
+        ],
+    );
+    test(
+        Struct { a: 1, b: 2, c: 0 },
+        &[
+            Token::Struct {
+                name: "Struct",
+                len: 2,
+            },
             Token::BorrowedStr("a"),
             Token::I32(1),
-
             Token::BorrowedStr("b"),
             Token::I32(2),
-        Token::StructEnd,
-    ]);
+            Token::StructEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_struct_owned_keys() {
-    test(Struct { a: 1, b: 2, c: 0 }, &[
-        Token::Map { len: Some(3) },
+    test(
+        Struct { a: 1, b: 2, c: 0 },
+        &[
+            Token::Map { len: Some(3) },
             Token::String("a"),
             Token::I32(1),
-
             Token::String("b"),
             Token::I32(2),
-        Token::MapEnd,
-    ]);
-    test(Struct { a: 1, b: 2, c: 0 }, &[
-        Token::Struct { name: "Struct", len: 2 },
+            Token::MapEnd,
+        ],
+    );
+    test(
+        Struct { a: 1, b: 2, c: 0 },
+        &[
+            Token::Struct {
+                name: "Struct",
+                len: 2,
+            },
             Token::String("a"),
             Token::I32(1),
-
             Token::String("b"),
             Token::I32(2),
-        Token::StructEnd,
-    ]);
+            Token::StructEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_struct_with_skip() {
-    test(Struct { a: 1, b: 2, c: 0 }, &[
-        Token::Map { len: Some(3) },
+    test(
+        Struct { a: 1, b: 2, c: 0 },
+        &[
+            Token::Map { len: Some(3) },
             Token::Str("a"),
             Token::I32(1),
-
             Token::Str("b"),
             Token::I32(2),
-
             Token::Str("c"),
             Token::I32(3),
-
             Token::Str("d"),
             Token::I32(4),
-        Token::MapEnd,
-    ]);
-    test(Struct { a: 1, b: 2, c: 0 }, &[
-        Token::Map { len: Some(3) },
+            Token::MapEnd,
+        ],
+    );
+    test(
+        Struct { a: 1, b: 2, c: 0 },
+        &[
+            Token::Map { len: Some(3) },
             Token::U8(0),
             Token::I32(1),
-
             Token::U16(1),
             Token::I32(2),
-
             Token::U32(2),
             Token::I32(3),
-
             Token::U64(3),
             Token::I32(4),
-        Token::MapEnd,
-    ]);
-    test(Struct { a: 1, b: 2, c: 0 }, &[
-        Token::Struct { name: "Struct", len: 2 },
+            Token::MapEnd,
+        ],
+    );
+    test(
+        Struct { a: 1, b: 2, c: 0 },
+        &[
+            Token::Struct {
+                name: "Struct",
+                len: 2,
+            },
             Token::Str("a"),
             Token::I32(1),
-
             Token::Str("b"),
             Token::I32(2),
-
             Token::Str("c"),
             Token::I32(3),
-
             Token::Str("d"),
             Token::I32(4),
-        Token::StructEnd,
-    ]);
+            Token::StructEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_struct_skip_all() {
-    test(StructSkipAll { a: 0 }, &[
-        Token::Struct { name: "StructSkipAll", len: 0 },
-        Token::StructEnd,
-    ]);
-    test(StructSkipAll { a: 0 }, &[
-        Token::Struct { name: "StructSkipAll", len: 0 },
+    test(
+        StructSkipAll { a: 0 },
+        &[
+            Token::Struct {
+                name: "StructSkipAll",
+                len: 0,
+            },
+            Token::StructEnd,
+        ],
+    );
+    test(
+        StructSkipAll { a: 0 },
+        &[
+            Token::Struct {
+                name: "StructSkipAll",
+                len: 0,
+            },
             Token::Str("a"),
             Token::I32(1),
-
             Token::Str("b"),
             Token::I32(2),
-        Token::StructEnd,
-    ]);
+            Token::StructEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_struct_skip_default() {
-    test(StructSkipDefault { a: 16 }, &[
-        Token::Struct { name: "StructSkipDefault", len: 0 },
-        Token::StructEnd,
-    ]);
+    test(
+        StructSkipDefault { a: 16 },
+        &[
+            Token::Struct {
+                name: "StructSkipDefault",
+                len: 0,
+            },
+            Token::StructEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_struct_skip_all_deny_unknown() {
-    test(StructSkipAllDenyUnknown { a: 0 }, &[
-        Token::Struct { name: "StructSkipAllDenyUnknown", len: 0 },
-        Token::StructEnd,
-    ]);
+    test(
+        StructSkipAllDenyUnknown { a: 0 },
+        &[
+            Token::Struct {
+                name: "StructSkipAllDenyUnknown",
+                len: 0,
+            },
+            Token::StructEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_struct_default() {
-    test(StructDefault { a: 50, b: "overwritten".to_string() }, &[
-        Token::Struct { name: "StructDefault", len: 2 },
+    test(
+        StructDefault {
+            a: 50,
+            b: "overwritten".to_string(),
+        },
+        &[
+            Token::Struct {
+                name: "StructDefault",
+                len: 2,
+            },
             Token::Str("a"),
             Token::I32(50),
-
             Token::Str("b"),
             Token::String("overwritten"),
-        Token::StructEnd,
-    ]);
-    test(StructDefault { a: 100, b: "default".to_string() }, &[
-        Token::Struct { name: "StructDefault",  len: 2 },
-        Token::StructEnd,
-    ]);
+            Token::StructEnd,
+        ],
+    );
+    test(
+        StructDefault {
+            a: 100,
+            b: "default".to_string(),
+        },
+        &[
+            Token::Struct {
+                name: "StructDefault",
+                len: 2,
+            },
+            Token::StructEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_enum_unit() {
-    test(Enum::Unit, &[
-        Token::UnitVariant { name: "Enum", variant: "Unit" },
-    ]);
+    test(
+        Enum::Unit,
+        &[Token::UnitVariant {
+            name: "Enum",
+            variant: "Unit",
+        }],
+    );
 }
 
 #[test]
 fn test_enum_simple() {
-    test(Enum::Simple(1), &[
-        Token::NewtypeVariant { name: "Enum", variant: "Simple" },
-        Token::I32(1),
-    ]);
+    test(
+        Enum::Simple(1),
+        &[
+            Token::NewtypeVariant {
+                name: "Enum",
+                variant: "Simple",
+            },
+            Token::I32(1),
+        ],
+    );
 }
 
 #[test]
 fn test_enum_simple_with_skipped() {
-    test(Enum::SimpleWithSkipped(NotDeserializable), &[
-        Token::UnitVariant { name: "Enum", variant: "SimpleWithSkipped" },
-    ]);
+    test(
+        Enum::SimpleWithSkipped(NotDeserializable),
+        &[Token::UnitVariant {
+            name: "Enum",
+            variant: "SimpleWithSkipped",
+        }],
+    );
 }
 
 #[test]
 fn test_enum_seq() {
-    test(Enum::Seq(1, 2, 3), &[
-        Token::TupleVariant { name: "Enum", variant: "Seq", len: 3 },
+    test(
+        Enum::Seq(1, 2, 3),
+        &[
+            Token::TupleVariant {
+                name: "Enum",
+                variant: "Seq",
+                len: 3,
+            },
             Token::I32(1),
             Token::I32(2),
             Token::I32(3),
-        Token::TupleVariantEnd,
-    ]);
+            Token::TupleVariantEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_enum_map() {
-    test(Enum::Map { a: 1, b: 2, c: 3 }, &[
-        Token::StructVariant { name: "Enum", variant: "Map", len: 3 },
+    test(
+        Enum::Map { a: 1, b: 2, c: 3 },
+        &[
+            Token::StructVariant {
+                name: "Enum",
+                variant: "Map",
+                len: 3,
+            },
             Token::Str("a"),
             Token::I32(1),
-
             Token::Str("b"),
             Token::I32(2),
-
             Token::Str("c"),
             Token::I32(3),
-        Token::StructVariantEnd,
-    ]);
+            Token::StructVariantEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_enum_unit_usize() {
-    test(Enum::Unit, &[
-        Token::Enum { name: "Enum" },
-        Token::U32(0),
-        Token::Unit,
-    ]);
+    test(
+        Enum::Unit,
+        &[Token::Enum { name: "Enum" }, Token::U32(0), Token::Unit],
+    );
 }
 
 #[test]
 fn test_enum_unit_bytes() {
-    test(Enum::Unit, &[
-        Token::Enum { name: "Enum" },
-        Token::Bytes(b"Unit"),
-        Token::Unit,
-    ]);
+    test(
+        Enum::Unit,
+        &[
+            Token::Enum { name: "Enum" },
+            Token::Bytes(b"Unit"),
+            Token::Unit,
+        ],
+    );
 }
 
 #[test]
 fn test_enum_other_unit() {
-    test(EnumOther::Unit, &[
-        Token::Enum { name: "EnumOther" },
-        Token::Str("Unit"),
-        Token::Unit,
-    ]);
-    test(EnumOther::Unit, &[
-        Token::Enum { name: "EnumOther" },
-        Token::U8(0),
-        Token::Unit,
-    ]);
-    test(EnumOther::Unit, &[
-        Token::Enum { name: "EnumOther" },
-        Token::U16(0),
-        Token::Unit,
-    ]);
-    test(EnumOther::Unit, &[
-        Token::Enum { name: "EnumOther" },
-        Token::U32(0),
-        Token::Unit,
-    ]);
-    test(EnumOther::Unit, &[
-        Token::Enum { name: "EnumOther" },
-        Token::U64(0),
-        Token::Unit,
-    ]);
+    test(
+        EnumOther::Unit,
+        &[
+            Token::Enum { name: "EnumOther" },
+            Token::Str("Unit"),
+            Token::Unit,
+        ],
+    );
+    test(
+        EnumOther::Unit,
+        &[Token::Enum { name: "EnumOther" }, Token::U8(0), Token::Unit],
+    );
+    test(
+        EnumOther::Unit,
+        &[
+            Token::Enum { name: "EnumOther" },
+            Token::U16(0),
+            Token::Unit,
+        ],
+    );
+    test(
+        EnumOther::Unit,
+        &[
+            Token::Enum { name: "EnumOther" },
+            Token::U32(0),
+            Token::Unit,
+        ],
+    );
+    test(
+        EnumOther::Unit,
+        &[
+            Token::Enum { name: "EnumOther" },
+            Token::U64(0),
+            Token::Unit,
+        ],
+    );
 }
 
 #[test]
 fn test_enum_other() {
-    test(EnumOther::Other, &[
-        Token::Enum { name: "EnumOther" },
-        Token::Str("Foo"),
-        Token::Unit,
-    ]);
-    test(EnumOther::Other, &[
-        Token::Enum { name: "EnumOther" },
-        Token::U8(42),
-        Token::Unit,
-    ]);
-    test(EnumOther::Other, &[
-        Token::Enum { name: "EnumOther" },
-        Token::U16(42),
-        Token::Unit,
-    ]);
-    test(EnumOther::Other, &[
-        Token::Enum { name: "EnumOther" },
-        Token::U32(42),
-        Token::Unit,
-    ]);
-    test(EnumOther::Other, &[
-        Token::Enum { name: "EnumOther" },
-        Token::U64(42),
-        Token::Unit,
-    ]);
+    test(
+        EnumOther::Other,
+        &[
+            Token::Enum { name: "EnumOther" },
+            Token::Str("Foo"),
+            Token::Unit,
+        ],
+    );
+    test(
+        EnumOther::Other,
+        &[
+            Token::Enum { name: "EnumOther" },
+            Token::U8(42),
+            Token::Unit,
+        ],
+    );
+    test(
+        EnumOther::Other,
+        &[
+            Token::Enum { name: "EnumOther" },
+            Token::U16(42),
+            Token::Unit,
+        ],
+    );
+    test(
+        EnumOther::Other,
+        &[
+            Token::Enum { name: "EnumOther" },
+            Token::U32(42),
+            Token::Unit,
+        ],
+    );
+    test(
+        EnumOther::Other,
+        &[
+            Token::Enum { name: "EnumOther" },
+            Token::U64(42),
+            Token::Unit,
+        ],
+    );
 }
 
 #[test]
@@ -992,360 +1207,456 @@ fn test_box() {
 
 #[test]
 fn test_boxed_slice() {
-    test(Box::new([0, 1, 2]), &[
-        Token::Seq { len: Some(3) },
-        Token::I32(0),
-        Token::I32(1),
-        Token::I32(2),
-        Token::SeqEnd,
-    ]);
+    test(
+        Box::new([0, 1, 2]),
+        &[
+            Token::Seq { len: Some(3) },
+            Token::I32(0),
+            Token::I32(1),
+            Token::I32(2),
+            Token::SeqEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_duration() {
-    test(Duration::new(1, 2), &[
-        Token::Struct { name: "Duration", len: 2 },
+    test(
+        Duration::new(1, 2),
+        &[
+            Token::Struct {
+                name: "Duration",
+                len: 2,
+            },
             Token::Str("secs"),
             Token::U64(1),
-
             Token::Str("nanos"),
             Token::U32(2),
-        Token::StructEnd,
-    ]);
-    test(Duration::new(1, 2), &[
-        Token::Seq { len: Some(2) },
+            Token::StructEnd,
+        ],
+    );
+    test(
+        Duration::new(1, 2),
+        &[
+            Token::Seq { len: Some(2) },
             Token::I64(1),
             Token::I64(2),
-        Token::SeqEnd,
-    ]);
+            Token::SeqEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_system_time() {
-    test(UNIX_EPOCH + Duration::new(1, 2), &[
-        Token::Struct { name: "SystemTime", len: 2 },
+    test(
+        UNIX_EPOCH + Duration::new(1, 2),
+        &[
+            Token::Struct {
+                name: "SystemTime",
+                len: 2,
+            },
             Token::Str("secs_since_epoch"),
             Token::U64(1),
-
             Token::Str("nanos_since_epoch"),
             Token::U32(2),
-        Token::StructEnd,
-    ]);
-    test(UNIX_EPOCH + Duration::new(1, 2), &[
-        Token::Seq { len: Some(2) },
+            Token::StructEnd,
+        ],
+    );
+    test(
+        UNIX_EPOCH + Duration::new(1, 2),
+        &[
+            Token::Seq { len: Some(2) },
             Token::I64(1),
             Token::I64(2),
-        Token::SeqEnd,
-    ]);
+            Token::SeqEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_range() {
-    test(1u32..2u32, &[
-        Token::Struct { name: "Range", len: 2 },
+    test(
+        1u32..2u32,
+        &[
+            Token::Struct {
+                name: "Range",
+                len: 2,
+            },
             Token::Str("start"),
             Token::U32(1),
-
             Token::Str("end"),
             Token::U32(2),
-        Token::StructEnd,
-    ]);
-    test(1u32..2u32, &[
-        Token::Seq { len: Some(2) },
+            Token::StructEnd,
+        ],
+    );
+    test(
+        1u32..2u32,
+        &[
+            Token::Seq { len: Some(2) },
             Token::U64(1),
             Token::U64(2),
-        Token::SeqEnd,
-    ]);
+            Token::SeqEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_range_inclusive() {
-    test(1u32..=2u32, &[
-        Token::Struct { name: "RangeInclusive", len: 2 },
+    test(
+        1u32..=2u32,
+        &[
+            Token::Struct {
+                name: "RangeInclusive",
+                len: 2,
+            },
             Token::Str("start"),
             Token::U32(1),
-
             Token::Str("end"),
             Token::U32(2),
-        Token::StructEnd,
-    ]);
-    test(1u32..=2u32, &[
-        Token::Seq { len: Some(2) },
+            Token::StructEnd,
+        ],
+    );
+    test(
+        1u32..=2u32,
+        &[
+            Token::Seq { len: Some(2) },
             Token::U64(1),
             Token::U64(2),
-        Token::SeqEnd,
-    ]);
+            Token::SeqEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_bound() {
-    test(Bound::Unbounded::<()>, &[
-        Token::Enum { name: "Bound" },
-        Token::Str("Unbounded"),
-        Token::Unit,
-    ]);
-    test(Bound::Included(0), &[
-        Token::Enum { name: "Bound" },
-        Token::Str("Included"),
-        Token::U8(0),
-    ]);
-    test(Bound::Excluded(0), &[
-        Token::Enum { name: "Bound" },
-        Token::Str("Excluded"),
-        Token::U8(0),
-    ]);
+    test(
+        Bound::Unbounded::<()>,
+        &[
+            Token::Enum { name: "Bound" },
+            Token::Str("Unbounded"),
+            Token::Unit,
+        ],
+    );
+    test(
+        Bound::Included(0),
+        &[
+            Token::Enum { name: "Bound" },
+            Token::Str("Included"),
+            Token::U8(0),
+        ],
+    );
+    test(
+        Bound::Excluded(0),
+        &[
+            Token::Enum { name: "Bound" },
+            Token::Str("Excluded"),
+            Token::U8(0),
+        ],
+    );
 }
 
 #[test]
 fn test_path() {
-    test(Path::new("/usr/local/lib"), &[
-        Token::BorrowedStr("/usr/local/lib"),
-    ]);
-    test(Path::new("/usr/local/lib"), &[
-        Token::BorrowedBytes(b"/usr/local/lib"),
-    ]);
+    test(
+        Path::new("/usr/local/lib"),
+        &[Token::BorrowedStr("/usr/local/lib")],
+    );
+    test(
+        Path::new("/usr/local/lib"),
+        &[Token::BorrowedBytes(b"/usr/local/lib")],
+    );
 }
 
 #[test]
 fn test_path_buf() {
-    test(PathBuf::from("/usr/local/lib"), &[
-        Token::Str("/usr/local/lib"),
-    ]);
-    test(PathBuf::from("/usr/local/lib"), &[
-        Token::String("/usr/local/lib"),
-    ]);
-    test(PathBuf::from("/usr/local/lib"), &[
-        Token::Bytes(b"/usr/local/lib"),
-    ]);
-    test(PathBuf::from("/usr/local/lib"), &[
-        Token::ByteBuf(b"/usr/local/lib"),
-    ]);
+    test(
+        PathBuf::from("/usr/local/lib"),
+        &[Token::Str("/usr/local/lib")],
+    );
+    test(
+        PathBuf::from("/usr/local/lib"),
+        &[Token::String("/usr/local/lib")],
+    );
+    test(
+        PathBuf::from("/usr/local/lib"),
+        &[Token::Bytes(b"/usr/local/lib")],
+    );
+    test(
+        PathBuf::from("/usr/local/lib"),
+        &[Token::ByteBuf(b"/usr/local/lib")],
+    );
 }
 
 #[test]
 fn test_boxed_path() {
-    test(PathBuf::from("/usr/local/lib").into_boxed_path(), &[
-        Token::Str("/usr/local/lib"),
-    ]);
-    test(PathBuf::from("/usr/local/lib").into_boxed_path(), &[
-        Token::String("/usr/local/lib"),
-    ]);
-    test(PathBuf::from("/usr/local/lib").into_boxed_path(), &[
-        Token::Bytes(b"/usr/local/lib"),
-    ]);
-    test(PathBuf::from("/usr/local/lib").into_boxed_path(), &[
-        Token::ByteBuf(b"/usr/local/lib"),
-    ]);
+    test(
+        PathBuf::from("/usr/local/lib").into_boxed_path(),
+        &[Token::Str("/usr/local/lib")],
+    );
+    test(
+        PathBuf::from("/usr/local/lib").into_boxed_path(),
+        &[Token::String("/usr/local/lib")],
+    );
+    test(
+        PathBuf::from("/usr/local/lib").into_boxed_path(),
+        &[Token::Bytes(b"/usr/local/lib")],
+    );
+    test(
+        PathBuf::from("/usr/local/lib").into_boxed_path(),
+        &[Token::ByteBuf(b"/usr/local/lib")],
+    );
 }
 
 #[test]
 fn test_cstring() {
-    test(CString::new("abc").unwrap(), &[
-        Token::Bytes(b"abc"),
-    ]);
+    test(CString::new("abc").unwrap(), &[Token::Bytes(b"abc")]);
 }
 
 #[test]
 fn test_rc() {
-    test(Rc::new(true), &[
-        Token::Bool(true),
-    ]);
+    test(Rc::new(true), &[Token::Bool(true)]);
 }
 
 #[test]
 fn test_rc_weak_some() {
-    test(SkipPartialEq(RcWeak::<bool>::new()), &[
-        Token::Some,
-        Token::Bool(true),
-    ]);
+    test(
+        SkipPartialEq(RcWeak::<bool>::new()),
+        &[Token::Some, Token::Bool(true)],
+    );
 }
 
 #[test]
 fn test_rc_weak_none() {
-    test(SkipPartialEq(RcWeak::<bool>::new()), &[
-        Token::None,
-    ]);
+    test(SkipPartialEq(RcWeak::<bool>::new()), &[Token::None]);
 }
 
 #[test]
 fn test_arc() {
-    test(Arc::new(true), &[
-        Token::Bool(true),
-    ]);
+    test(Arc::new(true), &[Token::Bool(true)]);
 }
 
 #[test]
 fn test_arc_weak_some() {
-    test(SkipPartialEq(ArcWeak::<bool>::new()), &[
-        Token::Some,
-        Token::Bool(true),
-    ]);
+    test(
+        SkipPartialEq(ArcWeak::<bool>::new()),
+        &[Token::Some, Token::Bool(true)],
+    );
 }
 
 #[test]
 fn test_arc_weak_none() {
-    test(SkipPartialEq(ArcWeak::<bool>::new()), &[
-        Token::None,
-    ]);
+    test(SkipPartialEq(ArcWeak::<bool>::new()), &[Token::None]);
 }
 
 #[test]
 fn test_wrapping() {
-    test(Wrapping(1usize), &[
-        Token::U32(1),
-    ]);
-    test(Wrapping(1usize), &[
-        Token::U64(1),
-    ]);
+    test(Wrapping(1usize), &[Token::U32(1)]);
+    test(Wrapping(1usize), &[Token::U64(1)]);
 }
 
 #[test]
 fn test_rc_dst() {
-    test(Rc::<str>::from("s"), &[
-        Token::Str("s"),
-    ]);
-    test(Rc::<[bool]>::from(&[true][..]), &[
-        Token::Seq { len: Some(1) },
-        Token::Bool(true),
-        Token::SeqEnd,
-    ]);
+    test(Rc::<str>::from("s"), &[Token::Str("s")]);
+    test(
+        Rc::<[bool]>::from(&[true][..]),
+        &[
+            Token::Seq { len: Some(1) },
+            Token::Bool(true),
+            Token::SeqEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_arc_dst() {
-    test(Arc::<str>::from("s"), &[
-        Token::Str("s"),
-    ]);
-    test(Arc::<[bool]>::from(&[true][..]), &[
-        Token::Seq { len: Some(1) },
-        Token::Bool(true),
-        Token::SeqEnd,
-    ]);
+    test(Arc::<str>::from("s"), &[Token::Str("s")]);
+    test(
+        Arc::<[bool]>::from(&[true][..]),
+        &[
+            Token::Seq { len: Some(1) },
+            Token::Bool(true),
+            Token::SeqEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_ignored_any() {
-    test(IgnoredAny, &[
-        Token::Str("s"),
-    ]);
-    test(IgnoredAny, &[
-        Token::Seq { len: Some(1) },
-        Token::Bool(true),
-        Token::SeqEnd,
-    ]);
-    test(IgnoredAny, &[
-        Token::Enum { name: "E" },
-        Token::Str("Rust"),
-        Token::Unit,
-    ]);
+    test(IgnoredAny, &[Token::Str("s")]);
+    test(
+        IgnoredAny,
+        &[
+            Token::Seq { len: Some(1) },
+            Token::Bool(true),
+            Token::SeqEnd,
+        ],
+    );
+    test(
+        IgnoredAny,
+        &[Token::Enum { name: "E" }, Token::Str("Rust"), Token::Unit],
+    );
 }
 
 #[test]
 fn test_net_ipv4addr_readable() {
-    test("1.2.3.4".parse::<net::Ipv4Addr>().unwrap().readable(), &[Token::Str("1.2.3.4")]);
+    test(
+        "1.2.3.4".parse::<net::Ipv4Addr>().unwrap().readable(),
+        &[Token::Str("1.2.3.4")],
+    );
 }
 
 #[test]
 fn test_net_ipv6addr_readable() {
-    test("::1".parse::<net::Ipv6Addr>().unwrap().readable(), &[Token::Str("::1")]);
+    test(
+        "::1".parse::<net::Ipv6Addr>().unwrap().readable(),
+        &[Token::Str("::1")],
+    );
 }
 
 #[test]
 fn test_net_ipaddr_readable() {
-    test("1.2.3.4".parse::<net::IpAddr>().unwrap().readable(), &[Token::Str("1.2.3.4")]);
+    test(
+        "1.2.3.4".parse::<net::IpAddr>().unwrap().readable(),
+        &[Token::Str("1.2.3.4")],
+    );
 }
 
 #[test]
 fn test_net_socketaddr_readable() {
-    test("1.2.3.4:1234".parse::<net::SocketAddr>().unwrap().readable(), &[Token::Str("1.2.3.4:1234")]);
-    test("1.2.3.4:1234".parse::<net::SocketAddrV4>().unwrap().readable(), &[Token::Str("1.2.3.4:1234")]);
-    test("[::1]:1234".parse::<net::SocketAddrV6>().unwrap().readable(), &[Token::Str("[::1]:1234")]);
+    test(
+        "1.2.3.4:1234"
+            .parse::<net::SocketAddr>()
+            .unwrap()
+            .readable(),
+        &[Token::Str("1.2.3.4:1234")],
+    );
+    test(
+        "1.2.3.4:1234"
+            .parse::<net::SocketAddrV4>()
+            .unwrap()
+            .readable(),
+        &[Token::Str("1.2.3.4:1234")],
+    );
+    test(
+        "[::1]:1234"
+            .parse::<net::SocketAddrV6>()
+            .unwrap()
+            .readable(),
+        &[Token::Str("[::1]:1234")],
+    );
 }
 
 #[test]
 fn test_net_ipv4addr_compact() {
-    test(net::Ipv4Addr::from(*b"1234").compact(), &seq![
-        Token::Tuple { len: 4 },
-        seq b"1234".iter().map(|&b| Token::U8(b)),
-        Token::TupleEnd
-    ]);
+    test(
+        net::Ipv4Addr::from(*b"1234").compact(),
+        &seq![
+            Token::Tuple { len: 4 },
+            seq b"1234".iter().map(|&b| Token::U8(b)),
+            Token::TupleEnd
+        ],
+    );
 }
 
 #[test]
 fn test_net_ipv6addr_compact() {
-    test(net::Ipv6Addr::from(*b"1234567890123456").compact(), &seq![
-        Token::Tuple { len: 4 },
-        seq b"1234567890123456".iter().map(|&b| Token::U8(b)),
-        Token::TupleEnd
-    ]);
+    test(
+        net::Ipv6Addr::from(*b"1234567890123456").compact(),
+        &seq![
+            Token::Tuple { len: 4 },
+            seq b"1234567890123456".iter().map(|&b| Token::U8(b)),
+            Token::TupleEnd
+        ],
+    );
 }
 
 #[test]
 fn test_net_ipaddr_compact() {
-    test(net::IpAddr::from(*b"1234").compact(), &seq![
-        Token::NewtypeVariant { name: "IpAddr", variant: "V4" },
+    test(
+        net::IpAddr::from(*b"1234").compact(),
+        &seq![
+            Token::NewtypeVariant { name: "IpAddr", variant: "V4" },
 
-        Token::Tuple { len: 4 },
-        seq b"1234".iter().map(|&b| Token::U8(b)),
-        Token::TupleEnd
-    ]);
+            Token::Tuple { len: 4 },
+            seq b"1234".iter().map(|&b| Token::U8(b)),
+            Token::TupleEnd
+        ],
+    );
 }
 
 #[test]
 fn test_net_socketaddr_compact() {
-    test(net::SocketAddr::from((*b"1234567890123456", 1234)).compact(), &seq![
-        Token::NewtypeVariant { name: "SocketAddr", variant: "V6" },
+    test(
+        net::SocketAddr::from((*b"1234567890123456", 1234)).compact(),
+        &seq![
+            Token::NewtypeVariant { name: "SocketAddr", variant: "V6" },
 
-        Token::Tuple { len: 2 },
+            Token::Tuple { len: 2 },
 
-        Token::Tuple { len: 16 },
-        seq b"1234567890123456".iter().map(|&b| Token::U8(b)),
-        Token::TupleEnd,
+            Token::Tuple { len: 16 },
+            seq b"1234567890123456".iter().map(|&b| Token::U8(b)),
+            Token::TupleEnd,
 
-        Token::U16(1234),
-        Token::TupleEnd
-    ]);
-    test(net::SocketAddr::from((*b"1234", 1234)).compact(), &seq![
-        Token::NewtypeVariant { name: "SocketAddr", variant: "V4" },
+            Token::U16(1234),
+            Token::TupleEnd
+        ],
+    );
+    test(
+        net::SocketAddr::from((*b"1234", 1234)).compact(),
+        &seq![
+            Token::NewtypeVariant { name: "SocketAddr", variant: "V4" },
 
-        Token::Tuple { len: 2 },
+            Token::Tuple { len: 2 },
 
-        Token::Tuple { len: 4 },
-        seq b"1234".iter().map(|&b| Token::U8(b)),
-        Token::TupleEnd,
+            Token::Tuple { len: 4 },
+            seq b"1234".iter().map(|&b| Token::U8(b)),
+            Token::TupleEnd,
 
-        Token::U16(1234),
-        Token::TupleEnd
-    ]);
-    test(net::SocketAddrV4::new(net::Ipv4Addr::from(*b"1234"), 1234).compact(), &seq![
-        Token::Tuple { len: 2 },
+            Token::U16(1234),
+            Token::TupleEnd
+        ],
+    );
+    test(
+        net::SocketAddrV4::new(net::Ipv4Addr::from(*b"1234"), 1234).compact(),
+        &seq![
+            Token::Tuple { len: 2 },
 
-        Token::Tuple { len: 4 },
-        seq b"1234".iter().map(|&b| Token::U8(b)),
-        Token::TupleEnd,
+            Token::Tuple { len: 4 },
+            seq b"1234".iter().map(|&b| Token::U8(b)),
+            Token::TupleEnd,
 
-        Token::U16(1234),
-        Token::TupleEnd
-    ]);
-    test(net::SocketAddrV6::new(net::Ipv6Addr::from(*b"1234567890123456"), 1234, 0, 0).compact(), &seq![
-        Token::Tuple { len: 2 },
+            Token::U16(1234),
+            Token::TupleEnd
+        ],
+    );
+    test(
+        net::SocketAddrV6::new(net::Ipv6Addr::from(*b"1234567890123456"), 1234, 0, 0).compact(),
+        &seq![
+            Token::Tuple { len: 2 },
 
-        Token::Tuple { len: 16 },
-        seq b"1234567890123456".iter().map(|&b| Token::U8(b)),
-        Token::TupleEnd,
+            Token::Tuple { len: 16 },
+            seq b"1234567890123456".iter().map(|&b| Token::U8(b)),
+            Token::TupleEnd,
 
-        Token::U16(1234),
-        Token::TupleEnd
-    ]);
+            Token::U16(1234),
+            Token::TupleEnd
+        ],
+    );
 }
 
 #[cfg(feature = "unstable")]
 #[test]
 fn test_never_result() {
-    test(Ok::<u8, !>(0), &[
-        Token::NewtypeVariant { name: "Result", variant: "Ok" },
-        Token::U8(0),
-    ]);
+    test(
+        Ok::<u8, !>(0),
+        &[
+            Token::NewtypeVariant {
+                name: "Result",
+                variant: "Ok",
+            },
+            Token::U8(0),
+        ],
+    );
 }
 
 #[cfg(unix)]