Auto merge of #2247 - dtolnay-contrib:rustfmt2, r=RalfJung

Format tests with rustfmt (101-150 of 300)

Extracted from #2097.

Like #2244, these are "easy" cases that do not involve moving around comments.

Author: bors

tests/pass/generator.rs

@@ -1,15 +1,19 @@
 #![feature(generators, generator_trait, never_type)]
 
-use std::ops::{GeneratorState::{self, *}, Generator};
-use std::pin::Pin;
-use std::sync::atomic::{AtomicUsize, Ordering};
 use std::fmt::Debug;
 use std::mem::ManuallyDrop;
+use std::ops::{
+    Generator,
+    GeneratorState::{self, *},
+};
+use std::pin::Pin;
 use std::ptr;
+use std::sync::atomic::{AtomicUsize, Ordering};
 
 fn basic() {
     fn finish<T>(mut amt: usize, mut t: T) -> T::Return
-        where T: Generator<Yield = usize>
+    where
+        T: Generator<Yield = usize>,
     {
         // We are not moving the `t` around until it gets dropped, so this is okay.
         let mut t = unsafe { Pin::new_unchecked(&mut t) };
@@ -23,7 +27,7 @@ fn basic() {
                 }
                 GeneratorState::Complete(ret) => {
                     assert_eq!(amt, 0);
-                    return ret
+                    return ret;
                 }
             }
         }
@@ -46,7 +50,7 @@ fn basic() {
         assert_eq!(x, 2);
     });
 
-    finish(7*8/2, || {
+    finish(7 * 8 / 2, || {
         for i in 0..8 {
             yield i;
         }
@@ -67,7 +71,10 @@ fn basic() {
     });
 
     finish(2, || {
-        if { yield 1; false } {
+        if {
+            yield 1;
+            false
+        } {
             yield 1;
             panic!()
         }
@@ -90,7 +97,9 @@ fn basic() {
     let b = true;
     finish(1, || {
         yield 1;
-        if b { return; }
+        if b {
+            return;
+        }
         #[allow(unused)]
         let x = never();
         #[allow(unreachable_code)]
@@ -101,7 +110,10 @@ fn basic() {
     finish(3, || {
         yield 1;
         #[allow(unreachable_code)]
-        let _x: (String, !) = (String::new(), { yield 2; return });
+        let _x: (String, !) = (String::new(), {
+            yield 2;
+            return;
+        });
     });
 }
 

tests/pass/hashmap.rs

@@ -17,19 +17,19 @@ fn test_all_refs<'a, T: 'a>(dummy: &mut T, iter: impl Iterator<Item = &'a mut T>
 
 fn smoketest_map<S: BuildHasher>(mut map: HashMap<i32, i32, S>) {
     map.insert(0, 0);
-    assert_eq!(map.values().fold(0, |x, y| x+y), 0);
+    assert_eq!(map.values().fold(0, |x, y| x + y), 0);
 
     let num = 25;
     for i in 1..num {
         map.insert(i, i);
     }
-    assert_eq!(map.values().fold(0, |x, y| x+y), num*(num-1)/2); // check the right things are in the table now
+    assert_eq!(map.values().fold(0, |x, y| x + y), num * (num - 1) / 2); // check the right things are in the table now
 
     // Inserting again replaces the existing entries
     for i in 0..num {
-        map.insert(i, num-1-i);
+        map.insert(i, num - 1 - i);
     }
-    assert_eq!(map.values().fold(0, |x, y| x+y), num*(num-1)/2);
+    assert_eq!(map.values().fold(0, |x, y| x + y), num * (num - 1) / 2);
 
     test_all_refs(&mut 13, map.values_mut());
 }

tests/pass/integer-ops.rs

@@ -42,7 +42,7 @@ pub fn main() {
     let m = -0xFEDCBA987654322i64;
     assert_eq!(n.rotate_right(4), m);
 
-    let n =  0x0123456789ABCDEFi64;
+    let n = 0x0123456789ABCDEFi64;
     let m = -0x1032547698BADCFFi64;
     assert_eq!(n.swap_bytes(), m);
 
@@ -169,9 +169,9 @@ pub fn main() {
     assert_eq!(0x10i32.overflowing_shr(4), (0x1, false));
     assert_eq!(0x10i32.overflowing_shr(36), (0x1, true));
 
-    assert_eq!(10i8.overflowing_abs(), (10,false));
-    assert_eq!((-10i8).overflowing_abs(), (10,false));
-    assert_eq!((-128i8).overflowing_abs(), (-128,true));
+    assert_eq!(10i8.overflowing_abs(), (10, false));
+    assert_eq!((-10i8).overflowing_abs(), (10, false));
+    assert_eq!((-128i8).overflowing_abs(), (-128, true));
 
     // Logarithms
     macro_rules! test_log {
@@ -180,7 +180,7 @@ pub fn main() {
             assert_eq!($type::MIN.checked_log10(), None);
             assert_eq!($type::MAX.checked_log2(), Some($max_log2));
             assert_eq!($type::MAX.checked_log10(), Some($max_log10));
-        }
+        };
     }
 
     test_log!(i8, 6, 2);

tests/pass/intrinsics-math.rs

@@ -9,15 +9,14 @@
 // except according to those terms.
 
 macro_rules! assert_approx_eq {
-    ($a:expr, $b:expr) => ({
+    ($a:expr, $b:expr) => {{
         let (a, b) = (&$a, &$b);
-        assert!((*a - *b).abs() < 1.0e-6,
-                "{} is not approximately equal to {}", *a, *b);
-    })
+        assert!((*a - *b).abs() < 1.0e-6, "{} is not approximately equal to {}", *a, *b);
+    }};
 }
 
 fn ldexp(a: f64, b: i32) -> f64 {
-    extern {
+    extern "C" {
         fn ldexp(x: f64, n: i32) -> f64;
     }
     unsafe { ldexp(a, b) }

tests/pass/intrinsics.rs

@@ -20,8 +20,12 @@ fn main() {
     assert_eq!(size_of_val(&[1, 2, 3] as &[i32]), 12);
     assert_eq!(size_of_val("foobar"), 6);
 
-    unsafe { assert_eq!(size_of_val_raw(&[1] as &[i32] as *const [i32]), 4); }
-    unsafe { assert_eq!(size_of_val_raw(0x100 as *const i32), 4); }
+    unsafe {
+        assert_eq!(size_of_val_raw(&[1] as &[i32] as *const [i32]), 4);
+    }
+    unsafe {
+        assert_eq!(size_of_val_raw(0x100 as *const i32), 4);
+    }
 
     assert_eq!(intrinsics::type_name::<Option<i32>>(), "core::option::Option<i32>");
 
@@ -33,7 +37,7 @@ fn main() {
     let _v = intrinsics::discriminant_value(&Some(()));
     let _v = intrinsics::discriminant_value(&0);
     let _v = intrinsics::discriminant_value(&true);
-    let _v = intrinsics::discriminant_value(&vec![1,2,3]);
+    let _v = intrinsics::discriminant_value(&vec![1, 2, 3]);
 
     let addr = &13 as *const i32;
     let addr2 = (addr as usize).wrapping_add(usize::MAX).wrapping_add(1);

tests/pass/ints.rs

@@ -17,7 +17,7 @@ fn indirect_add() -> i64 {
 }
 
 fn arith() -> i32 {
-    3*3 + 4*4
+    3 * 3 + 4 * 4
 }
 
 fn match_int() -> i16 {
@@ -48,7 +48,7 @@ fn main() {
     assert_eq!(neg(), -1);
     assert_eq!(add(), 3);
     assert_eq!(indirect_add(), 3);
-    assert_eq!(arith(), 5*5);
+    assert_eq!(arith(), 5 * 5);
     assert_eq!(match_int(), 20);
     assert_eq!(match_int_range(), 4);
     assert_eq!(i64::MIN.overflowing_mul(-1), (i64::MIN, true));

tests/pass/issues/issue-15063.rs

@@ -1,8 +1,10 @@
 #[allow(dead_code)]
-enum Two { A, B }
+enum Two {
+    A,
+    B,
+}
 impl Drop for Two {
-    fn drop(&mut self) {
-    }
+    fn drop(&mut self) {}
 }
 fn main() {
     let _k = Two::A;

tests/pass/issues/issue-15080.rs

@@ -1,7 +1,7 @@
 fn main() {
     let mut x: &[_] = &[1, 2, 3, 4];
 
-    let mut result = vec!();
+    let mut result = vec![];
     loop {
         x = match *x {
             [1, n, 3, ref rest @ ..] => {
@@ -12,8 +12,7 @@ fn main() {
                 result.push(n);
                 rest
             }
-            [] =>
-                break
+            [] => break,
         }
     }
     assert_eq!(result, [2, 4]);

tests/pass/issues/issue-15523-big.rs

@@ -27,7 +27,6 @@ fn main() {
     assert!(Eu64::Pos2 < Eu64::PosMax);
     assert!(Eu64::Pos1 < Eu64::PosMax);
 
-
     assert!(Ei64::Pos2 > Ei64::Pos1);
     assert!(Ei64::Pos2 > Ei64::Neg1);
     assert!(Ei64::Pos1 > Ei64::Neg1);

tests/pass/issues/issue-17877.rs

@@ -1,11 +1,17 @@
 fn main() {
-    assert_eq!(match [0u8; 16*1024] {
-        _ => 42_usize,
-    }, 42_usize);
+    assert_eq!(
+        match [0u8; 16 * 1024] {
+            _ => 42_usize,
+        },
+        42_usize,
+    );
 
-    assert_eq!(match [0u8; 16*1024] {
-        [1, ..] => 0_usize,
-        [0, ..] => 1_usize,
-        _ => 2_usize
-    }, 1_usize);
+    assert_eq!(
+        match [0u8; 16 * 1024] {
+            [1, ..] => 0_usize,
+            [0, ..] => 1_usize,
+            _ => 2_usize,
+        },
+        1_usize,
+    );
 }