Format tests with rustfmt (288-299 of 299)

Author: dtolnay

tests/fail/unaligned_pointers/dyn_alignment.rs

@@ -6,15 +6,18 @@
 struct MuchAlign;
 
 fn main() {
-    for _ in 0..10 { // Try many times as this might work by chance.
+    for _ in 0..10 {
+        // Try many times as this might work by chance.
         let buf = [0u32; 256];
         // `buf` is sufficiently aligned for `layout.align` on a `dyn Debug`, but not
         // for the actual alignment required by `MuchAlign`.
         // We craft a wide reference `&dyn Debug` with the vtable for `MuchAlign`. That should be UB,
         // as the reference is not aligned to its dynamic alignment requirements.
         let mut ptr = &MuchAlign as &dyn std::fmt::Debug;
         // Overwrite the data part of `ptr` so it points to `buf`.
-        unsafe { (&mut ptr as *mut _ as *mut *const u8).write(&buf as *const _ as *const u8); }
+        unsafe {
+            (&mut ptr as *mut _ as *mut *const u8).write(&buf as *const _ as *const u8);
+        }
         // Re-borrow that. This should be UB.
         let _ptr = &*ptr; //~ERROR alignment 256 is required
     }

tests/fail/unaligned_pointers/reference_to_packed.rs

@@ -10,11 +10,9 @@ struct Foo {
 }
 
 fn main() {
-    for _ in 0..10 { // Try many times as this might work by chance.
-        let foo = Foo {
-            x: 42,
-            y: 99,
-        };
+    for _ in 0..10 {
+        // Try many times as this might work by chance.
+        let foo = Foo { x: 42, y: 99 };
         let p = &foo.x;
         let i = *p; //~ERROR alignment 4 is required
     }

tests/fail/unaligned_pointers/unaligned_ptr1.rs

@@ -2,7 +2,8 @@
 // compile-flags: -Zmiri-disable-validation -Zmiri-disable-stacked-borrows
 
 fn main() {
-    for _ in 0..10 { // Try many times as this might work by chance.
+    for _ in 0..10 {
+        // Try many times as this might work by chance.
         let x = [2u16, 3, 4]; // Make it big enough so we don't get an out-of-bounds error.
         let x = &x[0] as *const _ as *const u32;
         // This must fail because alignment is violated: the allocation's base is not sufficiently aligned.

tests/fail/unaligned_pointers/unaligned_ptr3.rs

@@ -2,7 +2,8 @@
 // compile-flags: -Zmiri-disable-validation -Zmiri-disable-stacked-borrows
 
 fn main() {
-    for _ in 0..10 { // Try many times as this might work by chance.
+    for _ in 0..10 {
+        // Try many times as this might work by chance.
         let x = [2u16, 3, 4, 5]; // Make it big enough so we don't get an out-of-bounds error.
         let x = &x[0] as *const _ as *const *const u8; // cast to ptr-to-ptr, so that we load a ptr
         // This must fail because alignment is violated. Test specifically for loading pointers,

tests/fail/unaligned_pointers/unaligned_ptr4.rs

@@ -4,7 +4,8 @@
 fn main() {
     // Make sure we notice when a u16 is loaded at offset 1 into a u8 allocation.
     // (This would be missed if u8 allocations are *always* at odd addresses.)
-    for _ in 0..10 { // Try many times as this might work by chance.
+    for _ in 0..10 {
+        // Try many times as this might work by chance.
         let x = [0u8; 4];
         let ptr = x.as_ptr().wrapping_offset(1).cast::<u16>();
         let _val = unsafe { *ptr }; //~ERROR but alignment

tests/fail/unaligned_pointers/unaligned_ptr_addr_of.rs

@@ -3,7 +3,8 @@
 use std::ptr;
 
 fn main() {
-    for _ in 0..10 { // Try many times as this might work by chance.
+    for _ in 0..10 {
+        // Try many times as this might work by chance.
         let x = [2u16, 3, 4]; // Make it big enough so we don't get an out-of-bounds error.
         let x = &x[0] as *const _ as *const u32;
         // This must fail because alignment is violated: the allocation's base is not sufficiently aligned.

tests/fail/unaligned_pointers/unaligned_ptr_zst.rs

@@ -3,7 +3,8 @@
 // compile-flags: -Zmir-opt-level=0 -Zmiri-disable-validation
 
 fn main() {
-    for i in 0..10 { // Try many times as this might work by chance.
+    for i in 0..10 {
+        // Try many times as this might work by chance.
         let x = i as u8;
         let x = &x as *const _ as *const [u32; 0];
         // This must fail because alignment is violated. Test specifically for loading ZST.