about summary refs log tree commit diff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--rustfmt.toml1
-rw-r--r--tests/run-pass-valgrind/cast-enum-with-dtor.rs6
-rw-r--r--tests/run-pass-valgrind/cleanup-auto-borrow-obj.rs9
-rw-r--r--tests/run-pass-valgrind/coerce-match-calls.rs10
-rw-r--r--tests/run-pass-valgrind/coerce-match.rs15
-rw-r--r--tests/run-pass-valgrind/down-with-thread-dtors.rs8
-rw-r--r--tests/run-pass-valgrind/dst-dtor-1.rs10
-rw-r--r--tests/run-pass-valgrind/dst-dtor-2.rs6
-rw-r--r--tests/run-pass-valgrind/dst-dtor-3.rs8
-rw-r--r--tests/run-pass-valgrind/dst-dtor-4.rs4
-rw-r--r--tests/run-pass-valgrind/unsized-locals/by-value-trait-objects-rust-call.rs1
-rw-r--r--tests/run-pass-valgrind/unsized-locals/by-value-trait-objects-rust-call2.rs5
-rw-r--r--tests/run-pass-valgrind/unsized-locals/by-value-trait-objects.rs1
13 files changed, 57 insertions, 27 deletions
diff --git a/rustfmt.toml b/rustfmt.toml
index 91abd35d748..0e788e92455 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -17,7 +17,6 @@ ignore = [
     "/tests/incremental/",            # These tests are somewhat sensitive to source code layout.
     "/tests/pretty/",                 # These tests are very sensitive to source code layout.
     "/tests/run-make/translation/test.rs", # This test contains syntax errors.
-    "/tests/run-pass-valgrind/",
     "/tests/rustdoc/",
     "/tests/rustdoc-gui/",
     "/tests/rustdoc-js/",
diff --git a/tests/run-pass-valgrind/cast-enum-with-dtor.rs b/tests/run-pass-valgrind/cast-enum-with-dtor.rs
index f7ef92df8fb..a57dc373478 100644
--- a/tests/run-pass-valgrind/cast-enum-with-dtor.rs
+++ b/tests/run-pass-valgrind/cast-enum-with-dtor.rs
@@ -2,14 +2,14 @@
 
 // check dtor calling order when casting enums.
 
+use std::mem;
 use std::sync::atomic;
 use std::sync::atomic::Ordering;
-use std::mem;
 
 enum E {
     A = 0,
     B = 1,
-    C = 2
+    C = 2,
 }
 
 static FLAG: atomic::AtomicUsize = atomic::AtomicUsize::new(0);
@@ -19,7 +19,7 @@ impl Drop for E {
         // avoid dtor loop
         unsafe { mem::forget(mem::replace(self, E::B)) };
 
-        FLAG.store(FLAG.load(Ordering::SeqCst)+1, Ordering::SeqCst);
+        FLAG.store(FLAG.load(Ordering::SeqCst) + 1, Ordering::SeqCst);
     }
 }
 
diff --git a/tests/run-pass-valgrind/cleanup-auto-borrow-obj.rs b/tests/run-pass-valgrind/cleanup-auto-borrow-obj.rs
index dfc094abeb9..e4ce80b3305 100644
--- a/tests/run-pass-valgrind/cleanup-auto-borrow-obj.rs
+++ b/tests/run-pass-valgrind/cleanup-auto-borrow-obj.rs
@@ -7,12 +7,15 @@ static mut DROP_RAN: bool = false;
 struct Foo;
 impl Drop for Foo {
     fn drop(&mut self) {
-        unsafe { DROP_RAN = true; }
+        unsafe {
+            DROP_RAN = true;
+        }
     }
 }
 
-
-trait Trait { fn dummy(&self) { } }
+trait Trait {
+    fn dummy(&self) {}
+}
 impl Trait for Foo {}
 
 pub fn main() {
diff --git a/tests/run-pass-valgrind/coerce-match-calls.rs b/tests/run-pass-valgrind/coerce-match-calls.rs
index f6c7151ff10..8c7375610dd 100644
--- a/tests/run-pass-valgrind/coerce-match-calls.rs
+++ b/tests/run-pass-valgrind/coerce-match-calls.rs
@@ -7,9 +7,15 @@ use std::boxed::Box;
 pub fn main() {
     let _: Box<[isize]> = if true { Box::new([1, 2, 3]) } else { Box::new([1]) };
 
-    let _: Box<[isize]> = match true { true => Box::new([1, 2, 3]), false => Box::new([1]) };
+    let _: Box<[isize]> = match true {
+        true => Box::new([1, 2, 3]),
+        false => Box::new([1]),
+    };
 
     // Check we don't get over-keen at propagating coercions in the case of casts.
     let x = if true { 42 } else { 42u8 } as u16;
-    let x = match true { true => 42, false => 42u8 } as u16;
+    let x = match true {
+        true => 42,
+        false => 42u8,
+    } as u16;
 }
diff --git a/tests/run-pass-valgrind/coerce-match.rs b/tests/run-pass-valgrind/coerce-match.rs
index 3f33264c5a8..95f16a8cc89 100644
--- a/tests/run-pass-valgrind/coerce-match.rs
+++ b/tests/run-pass-valgrind/coerce-match.rs
@@ -12,11 +12,20 @@ pub fn main() {
     };
 
     let _: Box<[isize]> = match true {
-        true => { let b: Box<_> = Box::new([1, 2, 3]); b }
-        false => { let b: Box<_> = Box::new([1]); b }
+        true => {
+            let b: Box<_> = Box::new([1, 2, 3]);
+            b
+        }
+        false => {
+            let b: Box<_> = Box::new([1]);
+            b
+        }
     };
 
     // Check we don't get over-keen at propagating coercions in the case of casts.
     let x = if true { 42 } else { 42u8 } as u16;
-    let x = match true { true => 42, false => 42u8 } as u16;
+    let x = match true {
+        true => 42,
+        false => 42u8,
+    } as u16;
 }
diff --git a/tests/run-pass-valgrind/down-with-thread-dtors.rs b/tests/run-pass-valgrind/down-with-thread-dtors.rs
index 15aeac98c66..0d3745bba5b 100644
--- a/tests/run-pass-valgrind/down-with-thread-dtors.rs
+++ b/tests/run-pass-valgrind/down-with-thread-dtors.rs
@@ -27,13 +27,17 @@ impl Drop for Bar {
 
 impl Drop for Baz {
     fn drop(&mut self) {
-        unsafe { HIT = true; }
+        unsafe {
+            HIT = true;
+        }
     }
 }
 
 fn main() {
     std::thread::spawn(|| {
         FOO.with(|_| {});
-    }).join().unwrap();
+    })
+    .join()
+    .unwrap();
     assert!(unsafe { HIT });
 }
diff --git a/tests/run-pass-valgrind/dst-dtor-1.rs b/tests/run-pass-valgrind/dst-dtor-1.rs
index 5b8433f6145..47065151a03 100644
--- a/tests/run-pass-valgrind/dst-dtor-1.rs
+++ b/tests/run-pass-valgrind/dst-dtor-1.rs
@@ -3,15 +3,19 @@ static mut DROP_RAN: bool = false;
 struct Foo;
 impl Drop for Foo {
     fn drop(&mut self) {
-        unsafe { DROP_RAN = true; }
+        unsafe {
+            DROP_RAN = true;
+        }
     }
 }
 
-trait Trait { fn dummy(&self) { } }
+trait Trait {
+    fn dummy(&self) {}
+}
 impl Trait for Foo {}
 
 struct Fat<T: ?Sized> {
-    f: T
+    f: T,
 }
 
 pub fn main() {
diff --git a/tests/run-pass-valgrind/dst-dtor-2.rs b/tests/run-pass-valgrind/dst-dtor-2.rs
index 991fe00950b..d8abebfb447 100644
--- a/tests/run-pass-valgrind/dst-dtor-2.rs
+++ b/tests/run-pass-valgrind/dst-dtor-2.rs
@@ -3,12 +3,14 @@ static mut DROP_RAN: isize = 0;
 struct Foo;
 impl Drop for Foo {
     fn drop(&mut self) {
-        unsafe { DROP_RAN += 1; }
+        unsafe {
+            DROP_RAN += 1;
+        }
     }
 }
 
 struct Fat<T: ?Sized> {
-    f: T
+    f: T,
 }
 
 pub fn main() {
diff --git a/tests/run-pass-valgrind/dst-dtor-3.rs b/tests/run-pass-valgrind/dst-dtor-3.rs
index f0c2dda5ab0..09adaca21c7 100644
--- a/tests/run-pass-valgrind/dst-dtor-3.rs
+++ b/tests/run-pass-valgrind/dst-dtor-3.rs
@@ -5,11 +5,15 @@ static mut DROP_RAN: bool = false;
 struct Foo;
 impl Drop for Foo {
     fn drop(&mut self) {
-        unsafe { DROP_RAN = true; }
+        unsafe {
+            DROP_RAN = true;
+        }
     }
 }
 
-trait Trait { fn dummy(&self) { } }
+trait Trait {
+    fn dummy(&self) {}
+}
 impl Trait for Foo {}
 
 pub fn main() {
diff --git a/tests/run-pass-valgrind/dst-dtor-4.rs b/tests/run-pass-valgrind/dst-dtor-4.rs
index ad6d46f7c08..a66ac8e3cfc 100644
--- a/tests/run-pass-valgrind/dst-dtor-4.rs
+++ b/tests/run-pass-valgrind/dst-dtor-4.rs
@@ -5,7 +5,9 @@ static mut DROP_RAN: isize = 0;
 struct Foo;
 impl Drop for Foo {
     fn drop(&mut self) {
-        unsafe { DROP_RAN += 1; }
+        unsafe {
+            DROP_RAN += 1;
+        }
     }
 }
 
diff --git a/tests/run-pass-valgrind/unsized-locals/by-value-trait-objects-rust-call.rs b/tests/run-pass-valgrind/unsized-locals/by-value-trait-objects-rust-call.rs
index ece4dea9aaf..5d3f558a63a 100644
--- a/tests/run-pass-valgrind/unsized-locals/by-value-trait-objects-rust-call.rs
+++ b/tests/run-pass-valgrind/unsized-locals/by-value-trait-objects-rust-call.rs
@@ -43,7 +43,6 @@ impl FnOnce<()> for D {
     }
 }
 
-
 fn main() {
     let x = *(Box::new(A) as Box<dyn FnOnce<(), Output = String>>);
     assert_eq!(x.call_once(()), format!("hello"));
diff --git a/tests/run-pass-valgrind/unsized-locals/by-value-trait-objects-rust-call2.rs b/tests/run-pass-valgrind/unsized-locals/by-value-trait-objects-rust-call2.rs
index 94df2b0b83f..9b6648f2e27 100644
--- a/tests/run-pass-valgrind/unsized-locals/by-value-trait-objects-rust-call2.rs
+++ b/tests/run-pass-valgrind/unsized-locals/by-value-trait-objects-rust-call2.rs
@@ -51,7 +51,6 @@ impl FnOnce<(String, Box<str>)> for D {
     }
 }
 
-
 fn main() {
     let (s1, s2) = (format!("s1"), format!("s2").into_boxed_str());
     let x = *(Box::new(A) as Box<dyn FnOnce<(String, Box<str>), Output = String>>);
@@ -61,10 +60,10 @@ fn main() {
     assert_eq!(x.call_once((s1, s2)), format!("42"));
     let (s1, s2) = (format!("s1"), format!("s2").into_boxed_str());
     let x = *(Box::new(C(format!("jumping fox")))
-              as Box<dyn FnOnce<(String, Box<str>), Output = String>>);
+        as Box<dyn FnOnce<(String, Box<str>), Output = String>>);
     assert_eq!(x.call_once((s1, s2)), format!("jumping fox"));
     let (s1, s2) = (format!("s1"), format!("s2").into_boxed_str());
     let x = *(Box::new(D(Box::new(format!("lazy dog"))))
-              as Box<dyn FnOnce<(String, Box<str>), Output = String>>);
+        as Box<dyn FnOnce<(String, Box<str>), Output = String>>);
     assert_eq!(x.call_once((s1, s2)), format!("lazy dog"));
 }
diff --git a/tests/run-pass-valgrind/unsized-locals/by-value-trait-objects.rs b/tests/run-pass-valgrind/unsized-locals/by-value-trait-objects.rs
index 3d67101e734..3f6b6d262b5 100644
--- a/tests/run-pass-valgrind/unsized-locals/by-value-trait-objects.rs
+++ b/tests/run-pass-valgrind/unsized-locals/by-value-trait-objects.rs
@@ -36,7 +36,6 @@ impl Foo for D {
     }
 }
 
-
 fn main() {
     let x = *(Box::new(A) as Box<dyn Foo>);
     assert_eq!(x.foo(), format!("hello"));
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2025-10-27 06:29:00 +0000