Format the world

2 files changed, 53 insertions, 55 deletions

diff --git a/src/liballoc/tests/btree/map.rs b/src/liballoc/tests/btree/map.rs
index 27843aeaeb0..3177f19927e 100644
--- a/src/liballoc/tests/btree/map.rs
+++ b/src/liballoc/tests/btree/map.rs
@@ -1,8 +1,8 @@
-use std::collections::BTreeMap;
 use std::collections::btree_map::Entry::{Occupied, Vacant};
+use std::collections::BTreeMap;
+use std::iter::FromIterator;
 use std::ops::Bound::{self, Excluded, Included, Unbounded};
 use std::rc::Rc;
-use std::iter::FromIterator;
 
 use super::DeterministicRng;
 
@@ -101,7 +101,8 @@ fn test_iter() {
     let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
 
     fn test<T>(size: usize, mut iter: T)
-        where T: Iterator<Item = (usize, usize)>
+    where
+        T: Iterator<Item = (usize, usize)>,
     {
         for i in 0..size {
             assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
@@ -126,7 +127,8 @@ fn test_iter_rev() {
     let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
 
     fn test<T>(size: usize, mut iter: T)
-        where T: Iterator<Item = (usize, usize)>
+    where
+        T: Iterator<Item = (usize, usize)>,
     {
         for i in 0..size {
             assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
@@ -165,7 +167,8 @@ fn test_iter_mixed() {
     let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
 
     fn test<T>(size: usize, mut iter: T)
-        where T: Iterator<Item = (usize, usize)> + DoubleEndedIterator
+    where
+        T: Iterator<Item = (usize, usize)> + DoubleEndedIterator,
     {
         for i in 0..size / 4 {
             assert_eq!(iter.size_hint(), (size - i * 2, Some(size - i * 2)));
@@ -207,8 +210,9 @@ fn test_range_inclusive() {
     let map: BTreeMap<_, _> = (0..=size).map(|i| (i, i)).collect();
 
     fn check<'a, L, R>(lhs: L, rhs: R)
-        where L: IntoIterator<Item=(&'a i32, &'a i32)>,
-              R: IntoIterator<Item=(&'a i32, &'a i32)>,
+    where
+        L: IntoIterator<Item = (&'a i32, &'a i32)>,
+        R: IntoIterator<Item = (&'a i32, &'a i32)>,
     {
         let lhs: Vec<_> = lhs.into_iter().collect();
         let rhs: Vec<_> = rhs.into_iter().collect();
@@ -313,7 +317,7 @@ fn test_range_borrowed_key() {
     map.insert("coyote".to_string(), 3);
     map.insert("dingo".to_string(), 4);
     // NOTE: would like to use simply "b".."d" here...
-    let mut iter = map.range::<str, _>((Included("b"),Excluded("d")));
+    let mut iter = map.range::<str, _>((Included("b"), Excluded("d")));
     assert_eq!(iter.next(), Some((&"baboon".to_string(), &2)));
     assert_eq!(iter.next(), Some((&"coyote".to_string(), &3)));
     assert_eq!(iter.next(), None);
@@ -408,7 +412,6 @@ fn test_entry() {
     assert_eq!(map.get(&1).unwrap(), &100);
     assert_eq!(map.len(), 6);
 
-
     // Existing key (update)
     match map.entry(2) {
         Vacant(_) => unreachable!(),
@@ -430,7 +433,6 @@ fn test_entry() {
     assert_eq!(map.get(&3), None);
     assert_eq!(map.len(), 5);
 
-
     // Inexistent key (insert)
     match map.entry(10) {
         Occupied(_) => unreachable!(),
@@ -555,7 +557,7 @@ fn test_clone() {
 #[test]
 #[allow(dead_code)]
 fn test_variance() {
-    use std::collections::btree_map::{Iter, IntoIter, Range, Keys, Values};
+    use std::collections::btree_map::{IntoIter, Iter, Keys, Range, Values};
 
     fn map_key<'new>(v: BTreeMap<&'static str, ()>) -> BTreeMap<&'new str, ()> {
         v
@@ -649,7 +651,6 @@ fn test_first_last_entry() {
     assert_eq!(a.last_entry().unwrap().key(), &1);
 }
 
-
 macro_rules! create_append_test {
     ($name:ident, $len:expr) => {
         #[test]
@@ -661,7 +662,7 @@ macro_rules! create_append_test {
 
             let mut b = BTreeMap::new();
             for i in 5..$len {
-                b.insert(i, 2*i);
+                b.insert(i, 2 * i);
             }
 
             a.append(&mut b);
@@ -673,12 +674,12 @@ macro_rules! create_append_test {
                 if i < 5 {
                     assert_eq!(a[&i], i);
                 } else {
-                    assert_eq!(a[&i], 2*i);
+                    assert_eq!(a[&i], 2 * i);
                 }
             }
 
-            assert_eq!(a.remove(&($len-1)), Some(2*($len-1)));
-            assert_eq!(a.insert($len-1, 20), None);
+            assert_eq!(a.remove(&($len - 1)), Some(2 * ($len - 1)));
+            assert_eq!(a.insert($len - 1, 20), None);
         }
     };
 }
diff --git a/src/liballoc/tests/btree/set.rs b/src/liballoc/tests/btree/set.rs
index 13cd2628022..ed29ed62b1b 100644
--- a/src/liballoc/tests/btree/set.rs
+++ b/src/liballoc/tests/btree/set.rs
@@ -32,7 +32,8 @@ fn test_hash() {
 }
 
 fn check<F>(a: &[i32], b: &[i32], expected: &[i32], f: F)
-    where F: FnOnce(&BTreeSet<i32>, &BTreeSet<i32>, &mut dyn FnMut(&i32) -> bool) -> bool
+where
+    F: FnOnce(&BTreeSet<i32>, &BTreeSet<i32>, &mut dyn FnMut(&i32) -> bool) -> bool,
 {
     let mut set_a = BTreeSet::new();
     let mut set_b = BTreeSet::new();
@@ -45,15 +46,13 @@ fn check<F>(a: &[i32], b: &[i32], expected: &[i32], f: F)
     }
 
     let mut i = 0;
-    f(&set_a,
-      &set_b,
-      &mut |&x| {
-          if i < expected.len() {
-              assert_eq!(x, expected[i]);
-          }
-          i += 1;
-          true
-      });
+    f(&set_a, &set_b, &mut |&x| {
+        if i < expected.len() {
+            assert_eq!(x, expected[i]);
+        }
+        i += 1;
+        true
+    });
     assert_eq!(i, expected.len());
 }
 
@@ -68,11 +67,10 @@ fn test_intersection() {
     check_intersection(&[], &[1, 2, 3], &[]);
     check_intersection(&[2], &[1, 2, 3], &[2]);
     check_intersection(&[1, 2, 3], &[2], &[2]);
-    check_intersection(&[11, 1, 3, 77, 103, 5, -5],
-                       &[2, 11, 77, -9, -42, 5, 3],
-                       &[3, 5, 11, 77]);
+    check_intersection(&[11, 1, 3, 77, 103, 5, -5], &[2, 11, 77, -9, -42, 5, 3], &[3, 5, 11, 77]);
 
-    if cfg!(miri) { // Miri is too slow
+    if cfg!(miri) {
+        // Miri is too slow
         return;
     }
 
@@ -87,9 +85,7 @@ fn test_intersection() {
     check_intersection(&large, &[99], &[99]);
     check_intersection(&[100], &large, &[]);
     check_intersection(&large, &[100], &[]);
-    check_intersection(&[11, 5000, 1, 3, 77, 8924],
-                       &large,
-                       &[1, 3, 11, 77]);
+    check_intersection(&[11, 5000, 1, 3, 77, 8924], &large, &[1, 3, 11, 77]);
 }
 
 #[test]
@@ -121,11 +117,14 @@ fn test_difference() {
     check_difference(&[1, 3, 5, 9, 11], &[3, 6, 9], &[1, 5, 11]);
     check_difference(&[1, 3, 5, 9, 11], &[0, 1], &[3, 5, 9, 11]);
     check_difference(&[1, 3, 5, 9, 11], &[11, 12], &[1, 3, 5, 9]);
-    check_difference(&[-5, 11, 22, 33, 40, 42],
-                     &[-12, -5, 14, 23, 34, 38, 39, 50],
-                     &[11, 22, 33, 40, 42]);
-
-    if cfg!(miri) { // Miri is too slow
+    check_difference(
+        &[-5, 11, 22, 33, 40, 42],
+        &[-12, -5, 14, 23, 34, 38, 39, 50],
+        &[11, 22, 33, 40, 42],
+    );
+
+    if cfg!(miri) {
+        // Miri is too slow
         return;
     }
 
@@ -135,9 +134,7 @@ fn test_difference() {
     check_difference(&[0], &large, &[]);
     check_difference(&[99], &large, &[]);
     check_difference(&[100], &large, &[100]);
-    check_difference(&[11, 5000, 1, 3, 77, 8924],
-                     &large,
-                     &[5000, 8924]);
+    check_difference(&[11, 5000, 1, 3, 77, 8924], &large, &[5000, 8924]);
     check_difference(&large, &[], &large);
     check_difference(&large, &[-1], &large);
     check_difference(&large, &[100], &large);
@@ -216,9 +213,7 @@ fn test_symmetric_difference() {
     check_symmetric_difference(&[], &[], &[]);
     check_symmetric_difference(&[1, 2, 3], &[2], &[1, 3]);
     check_symmetric_difference(&[2], &[1, 2, 3], &[1, 3]);
-    check_symmetric_difference(&[1, 3, 5, 9, 11],
-                               &[-2, 3, 9, 14, 22],
-                               &[-2, 1, 5, 11, 14, 22]);
+    check_symmetric_difference(&[1, 3, 5, 9, 11], &[-2, 3, 9, 14, 22], &[-2, 1, 5, 11, 14, 22]);
 }
 
 #[test]
@@ -242,9 +237,11 @@ fn test_union() {
     check_union(&[], &[], &[]);
     check_union(&[1, 2, 3], &[2], &[1, 2, 3]);
     check_union(&[2], &[1, 2, 3], &[1, 2, 3]);
-    check_union(&[1, 3, 5, 9, 11, 16, 19, 24],
-                &[-2, 1, 5, 9, 13, 19],
-                &[-2, 1, 3, 5, 9, 11, 13, 16, 19, 24]);
+    check_union(
+        &[1, 3, 5, 9, 11, 16, 19, 24],
+        &[-2, 1, 5, 9, 13, 19],
+        &[-2, 1, 3, 5, 9, 11, 13, 16, 19, 24],
+    );
 }
 
 #[test]
@@ -285,14 +282,14 @@ fn test_is_subset() {
     assert_eq!(is_subset(&[1, 2], &[1]), false);
     assert_eq!(is_subset(&[1, 2], &[1, 2]), true);
     assert_eq!(is_subset(&[1, 2], &[2, 3]), false);
-    assert_eq!(is_subset(&[-5, 11, 22, 33, 40, 42],
-                         &[-12, -5, 11, 14, 22, 23, 33, 34, 38, 39, 40, 42]),
-               true);
-    assert_eq!(is_subset(&[-5, 11, 22, 33, 40, 42],
-                         &[-12, -5, 11, 14, 22, 23, 34, 38]),
-               false);
-
-    if cfg!(miri) { // Miri is too slow
+    assert_eq!(
+        is_subset(&[-5, 11, 22, 33, 40, 42], &[-12, -5, 11, 14, 22, 23, 33, 34, 38, 39, 40, 42]),
+        true
+    );
+    assert_eq!(is_subset(&[-5, 11, 22, 33, 40, 42], &[-12, -5, 11, 14, 22, 23, 34, 38]), false);
+
+    if cfg!(miri) {
+        // Miri is too slow
         return;
     }