cleaned up some tests

19 files changed, 126 insertions, 68 deletions

diff --git a/tests/ui/attributes/reexport-test-harness-entry-point.rs b/tests/ui/attributes/reexport-test-harness-entry-point.rs
index f79828fc7d6..95765a719ed 100644
--- a/tests/ui/attributes/reexport-test-harness-entry-point.rs
+++ b/tests/ui/attributes/reexport-test-harness-entry-point.rs
@@ -1,3 +1,6 @@
+//! Check that `#[reexport_test_harness_main]` correctly reexports the test harness entry point
+//! and allows it to be called from within the code.
+
 //@ run-pass
 //@ compile-flags:--test
 
diff --git a/tests/ui/const-ptr/pointer-address-stability.rs b/tests/ui/const-ptr/pointer-address-stability.rs
index e330a4853ce..84a36e1ddf5 100644
--- a/tests/ui/const-ptr/pointer-address-stability.rs
+++ b/tests/ui/const-ptr/pointer-address-stability.rs
@@ -1,6 +1,9 @@
-//@ run-pass
-// Issue #2040
+//! Check that taking the address of a stack variable with `&`
+//! yields a stable and comparable pointer.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/2040>.
 
+//@ run-pass
 
 pub fn main() {
     let foo: isize = 1;
diff --git a/tests/ui/diagnostic-flags/error-format-short.rs b/tests/ui/diagnostic-flags/error-format-short.rs
index 719870a04fb..4c793cd1b18 100644
--- a/tests/ui/diagnostic-flags/error-format-short.rs
+++ b/tests/ui/diagnostic-flags/error-format-short.rs
@@ -1,3 +1,6 @@
+//! Check that compile errors are formatted in the "short" style
+//! when `--error-format=short` is used.
+
 //@ compile-flags: --error-format=short
 
 fn foo(_: u32) {}
diff --git a/tests/ui/diagnostic-flags/error-format-short.stderr b/tests/ui/diagnostic-flags/error-format-short.stderr
index 1a4a6d4df88..0a097e2f623 100644
--- a/tests/ui/diagnostic-flags/error-format-short.stderr
+++ b/tests/ui/diagnostic-flags/error-format-short.stderr
@@ -1,3 +1,3 @@
-$DIR/short-error-format.rs:6:9: error[E0308]: mismatched types: expected `u32`, found `String`
-$DIR/short-error-format.rs:8:7: error[E0599]: no method named `salut` found for type `u32` in the current scope: method not found in `u32`
+$DIR/error-format-short.rs:9:9: error[E0308]: mismatched types: expected `u32`, found `String`
+$DIR/error-format-short.rs:11:7: error[E0599]: no method named `salut` found for type `u32` in the current scope: method not found in `u32`
 error: aborting due to 2 previous errors
diff --git a/tests/ui/drop/drop-once-on-move.rs b/tests/ui/drop/drop-once-on-move.rs
index ab426016901..da018058076 100644
--- a/tests/ui/drop/drop-once-on-move.rs
+++ b/tests/ui/drop/drop-once-on-move.rs
@@ -1,3 +1,7 @@
+//! Check that types not implementing `Copy` are moved, not copied, during assignment
+//! operations, and their `Drop` implementation is called exactly once when the
+//! value goes out of scope.
+
 //@ run-pass
 
 #![allow(non_camel_case_types)]
@@ -15,9 +19,7 @@ impl<'a> Drop for r<'a> {
 }
 
 fn r(i: &Cell<isize>) -> r<'_> {
-    r {
-        i: i
-    }
+    r { i }
 }
 
 pub fn main() {
diff --git a/tests/ui/drop/drop-scope-exit.rs b/tests/ui/drop/drop-scope-exit.rs
index 480cbe091a7..4d003fec712 100644
--- a/tests/ui/drop/drop-scope-exit.rs
+++ b/tests/ui/drop/drop-scope-exit.rs
@@ -1,31 +1,37 @@
+//! Check that the `Drop` implementation is called when a value goes out of scope.
+
 //@ run-pass
 
 #![allow(non_camel_case_types)]
 use std::cell::Cell;
 
 struct shrinky_pointer<'a> {
-  i: &'a Cell<isize>,
+    i: &'a Cell<isize>,
 }
 
 impl<'a> Drop for shrinky_pointer<'a> {
     fn drop(&mut self) {
-        println!("Hello!"); self.i.set(self.i.get() - 1);
+        println!("Hello!");
+        self.i.set(self.i.get() - 1);
     }
 }
 
 impl<'a> shrinky_pointer<'a> {
-    pub fn look_at(&self) -> isize { return self.i.get(); }
+    pub fn look_at(&self) -> isize {
+        return self.i.get();
+    }
 }
 
 fn shrinky_pointer(i: &Cell<isize>) -> shrinky_pointer<'_> {
-    shrinky_pointer {
-        i: i
-    }
+    shrinky_pointer { i }
 }
 
 pub fn main() {
     let my_total = &Cell::new(10);
-    { let pt = shrinky_pointer(my_total); assert_eq!(pt.look_at(), 10); }
+    {
+        let pt = shrinky_pointer(my_total);
+        assert_eq!(pt.look_at(), 10);
+    }
     println!("my_total = {}", my_total.get());
     assert_eq!(my_total.get(), 9);
 }
diff --git a/tests/ui/generics/trait-incorrect-generic-args.rs b/tests/ui/generics/trait-incorrect-generic-args.rs
index 627dfcc3198..9715100b19c 100644
--- a/tests/ui/generics/trait-incorrect-generic-args.rs
+++ b/tests/ui/generics/trait-incorrect-generic-args.rs
@@ -1,5 +1,7 @@
+//! Check for compilation errors when a trait is used with an incorrect number of generic arguments.
+
 fn main() {
-    trait Seq { }
+    trait Seq {}
 
     impl<T> Seq<T> for Vec<T> {
         //~^ ERROR trait takes 0 generic arguments but 1 generic argument
diff --git a/tests/ui/generics/trait-incorrect-generic-args.stderr b/tests/ui/generics/trait-incorrect-generic-args.stderr
index 6e0d484d013..afc4ff03d94 100644
--- a/tests/ui/generics/trait-incorrect-generic-args.stderr
+++ b/tests/ui/generics/trait-incorrect-generic-args.stderr
@@ -1,5 +1,5 @@
 error[E0107]: trait takes 0 generic arguments but 1 generic argument was supplied
-  --> $DIR/seq-args.rs:4:13
+  --> $DIR/trait-incorrect-generic-args.rs:6:13
    |
 LL |     impl<T> Seq<T> for Vec<T> {
    |             ^^^--- help: remove the unnecessary generics
@@ -7,13 +7,13 @@ LL |     impl<T> Seq<T> for Vec<T> {
    |             expected 0 generic arguments
    |
 note: trait defined here, with 0 generic parameters
-  --> $DIR/seq-args.rs:2:11
+  --> $DIR/trait-incorrect-generic-args.rs:4:11
    |
-LL |     trait Seq { }
+LL |     trait Seq {}
    |           ^^^
 
 error[E0107]: trait takes 0 generic arguments but 1 generic argument was supplied
-  --> $DIR/seq-args.rs:9:10
+  --> $DIR/trait-incorrect-generic-args.rs:11:10
    |
 LL |     impl Seq<bool> for u32 {
    |          ^^^------ help: remove the unnecessary generics
@@ -21,9 +21,9 @@ LL |     impl Seq<bool> for u32 {
    |          expected 0 generic arguments
    |
 note: trait defined here, with 0 generic parameters
-  --> $DIR/seq-args.rs:2:11
+  --> $DIR/trait-incorrect-generic-args.rs:4:11
    |
-LL |     trait Seq { }
+LL |     trait Seq {}
    |           ^^^
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/io-checks/io-stdout-blocking-writes.rs b/tests/ui/io-checks/io-stdout-blocking-writes.rs
index 615530dcd47..1197b7f43be 100644
--- a/tests/ui/io-checks/io-stdout-blocking-writes.rs
+++ b/tests/ui/io-checks/io-stdout-blocking-writes.rs
@@ -1,10 +1,12 @@
+//! Check that writes to standard output are blocking, avoiding interleaving
+//! even with concurrent writes from multiple threads.
+
 //@ run-pass
 //@ needs-subprocess
 
-use std::env;
 use std::io::prelude::*;
 use std::process::Command;
-use std::thread;
+use std::{env, thread};
 
 const THREADS: usize = 20;
 const WRITES: usize = 100;
@@ -33,14 +35,16 @@ fn parent() {
 }
 
 fn child() {
-    let threads = (0..THREADS).map(|_| {
-        thread::spawn(|| {
-            let buf = [b'a'; WRITE_SIZE];
-            for _ in 0..WRITES {
-                write_all(&buf);
-            }
+    let threads = (0..THREADS)
+        .map(|_| {
+            thread::spawn(|| {
+                let buf = [b'a'; WRITE_SIZE];
+                for _ in 0..WRITES {
+                    write_all(&buf);
+                }
+            })
         })
-    }).collect::<Vec<_>>();
+        .collect::<Vec<_>>();
 
     for thread in threads {
         thread.join().unwrap();
@@ -63,8 +67,8 @@ fn write_all(buf: &[u8]) {
 fn write_all(buf: &[u8]) {
     use std::fs::File;
     use std::mem;
-    use std::os::windows::raw::*;
     use std::os::windows::prelude::*;
+    use std::os::windows::raw::*;
 
     const STD_OUTPUT_HANDLE: u32 = (-11i32) as u32;
 
diff --git a/tests/ui/shadowed/primitive-type-shadowing.rs b/tests/ui/shadowed/primitive-type-shadowing.rs
index 8cba2c1710b..fdcb4246a82 100644
--- a/tests/ui/shadowed/primitive-type-shadowing.rs
+++ b/tests/ui/shadowed/primitive-type-shadowing.rs
@@ -1,3 +1,6 @@
+//! Check that a primitive type can be shadowed by a user-defined type, and the primitive type
+//! can still be referenced using its fully qualified path (e.g., `core::primitive::bool`).
+
 //@ check-pass
 
 mod bar {
diff --git a/tests/ui/shadowed/use-shadows-reexport.rs b/tests/ui/shadowed/use-shadows-reexport.rs
index 5ce4103b559..d220e4b406b 100644
--- a/tests/ui/shadowed/use-shadows-reexport.rs
+++ b/tests/ui/shadowed/use-shadows-reexport.rs
@@ -1,3 +1,5 @@
+//! Check that a local `use` declaration can shadow a re-exported item within the same module.
+
 //@ run-pass
 
 #![allow(unused_imports)]
diff --git a/tests/ui/sized/recursive-type-infinite-size.rs b/tests/ui/sized/recursive-type-infinite-size.rs
index 766a5fa0de3..5cd8e895573 100644
--- a/tests/ui/sized/recursive-type-infinite-size.rs
+++ b/tests/ui/sized/recursive-type-infinite-size.rs
@@ -1,7 +1,16 @@
-struct Baz { q: Option<Foo> }
-//~^ ERROR recursive types `Baz` and `Foo` have infinite size
-struct Foo { q: Option<Baz> }
+//! Check for compilation errors when recursive types are defined in a way
+//! that leads to an infinite size.
 
-impl Foo { fn bar(&self) {} }
+struct Baz {
+    //~^ ERROR recursive types `Baz` and `Foo` have infinite size
+    q: Option<Foo>,
+}
+struct Foo {
+    q: Option<Baz>,
+}
+
+impl Foo {
+    fn bar(&self) {}
+}
 
 fn main() {}
diff --git a/tests/ui/sized/recursive-type-infinite-size.stderr b/tests/ui/sized/recursive-type-infinite-size.stderr
index 21e54c12fed..98ac36c4bb6 100644
--- a/tests/ui/sized/recursive-type-infinite-size.stderr
+++ b/tests/ui/sized/recursive-type-infinite-size.stderr
@@ -1,17 +1,23 @@
 error[E0072]: recursive types `Baz` and `Foo` have infinite size
-  --> $DIR/sized-cycle-note.rs:1:1
+  --> $DIR/recursive-type-infinite-size.rs:4:1
    |
-LL | struct Baz { q: Option<Foo> }
-   | ^^^^^^^^^^             --- recursive without indirection
+LL | struct Baz {
+   | ^^^^^^^^^^
 LL |
-LL | struct Foo { q: Option<Baz> }
-   | ^^^^^^^^^^             --- recursive without indirection
+LL |     q: Option<Foo>,
+   |               --- recursive without indirection
+LL | }
+LL | struct Foo {
+   | ^^^^^^^^^^
+LL |     q: Option<Baz>,
+   |               --- recursive without indirection
    |
 help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
    |
-LL ~ struct Baz { q: Option<Box<Foo>> }
-LL |
-LL ~ struct Foo { q: Option<Box<Baz>> }
+LL ~     q: Option<Box<Foo>>,
+LL | }
+LL | struct Foo {
+LL ~     q: Option<Box<Baz>>,
    |
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/sized/sized-box-unsized-content.rs b/tests/ui/sized/sized-box-unsized-content.rs
index b35c0f91abd..9cc202a1582 100644
--- a/tests/ui/sized/sized-box-unsized-content.rs
+++ b/tests/ui/sized/sized-box-unsized-content.rs
@@ -1,10 +1,11 @@
+//! Check that `Box<T>` is `Sized`, even when `T` is a dynamically sized type.
+
 //@ run-pass
 
 #![allow(dead_code)]
-// Possibly-dynamic size of typaram should be cleared at pointer boundary.
-
-
 
-fn bar<T: Sized>() { }
-fn foo<T>() { bar::<Box<T>>() }
-pub fn main() { }
+fn bar<T: Sized>() {}
+fn foo<T>() {
+    bar::<Box<T>>()
+}
+pub fn main() {}
diff --git a/tests/ui/sized/sized-reference-to-unsized.rs b/tests/ui/sized/sized-reference-to-unsized.rs
index bd213c067db..ac2934d8fe6 100644
--- a/tests/ui/sized/sized-reference-to-unsized.rs
+++ b/tests/ui/sized/sized-reference-to-unsized.rs
@@ -1,9 +1,11 @@
+//! Check that a reference to a potentially unsized type (`&T`) is itself considered `Sized`.
+
 //@ run-pass
 
 #![allow(dead_code)]
-// Possibly-dynamic size of typaram should be cleared at pointer boundary.
-
 
-fn bar<T: Sized>() { }
-fn foo<T>() { bar::<&T>() }
-pub fn main() { }
+fn bar<T: Sized>() {}
+fn foo<T>() {
+    bar::<&T>()
+}
+pub fn main() {}
diff --git a/tests/ui/sync/atomic-types-not-copyable.rs b/tests/ui/sync/atomic-types-not-copyable.rs
index d85864ecac2..d96414676ee 100644
--- a/tests/ui/sync/atomic-types-not-copyable.rs
+++ b/tests/ui/sync/atomic-types-not-copyable.rs
@@ -1,8 +1,10 @@
-// Issue #8380
+//! Check that atomic types from `std::sync::atomic` are not `Copy`
+//! and cannot be moved out of a shared reference.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/8380>.
 
-
-use std::sync::atomic::*;
 use std::ptr;
+use std::sync::atomic::*;
 
 fn main() {
     let x = AtomicBool::new(false);
diff --git a/tests/ui/sync/atomic-types-not-copyable.stderr b/tests/ui/sync/atomic-types-not-copyable.stderr
index 8c5d0b96096..05103f5d8f2 100644
--- a/tests/ui/sync/atomic-types-not-copyable.stderr
+++ b/tests/ui/sync/atomic-types-not-copyable.stderr
@@ -1,5 +1,5 @@
 error[E0507]: cannot move out of a shared reference
-  --> $DIR/std-uncopyable-atomics.rs:9:13
+  --> $DIR/atomic-types-not-copyable.rs:11:13
    |
 LL |     let x = *&x;
    |             ^^^ move occurs because value has type `std::sync::atomic::AtomicBool`, which does not implement the `Copy` trait
@@ -11,7 +11,7 @@ LL +     let x = &x;
    |
 
 error[E0507]: cannot move out of a shared reference
-  --> $DIR/std-uncopyable-atomics.rs:11:13
+  --> $DIR/atomic-types-not-copyable.rs:13:13
    |
 LL |     let x = *&x;
    |             ^^^ move occurs because value has type `std::sync::atomic::AtomicIsize`, which does not implement the `Copy` trait
@@ -23,7 +23,7 @@ LL +     let x = &x;
    |
 
 error[E0507]: cannot move out of a shared reference
-  --> $DIR/std-uncopyable-atomics.rs:13:13
+  --> $DIR/atomic-types-not-copyable.rs:15:13
    |
 LL |     let x = *&x;
    |             ^^^ move occurs because value has type `std::sync::atomic::AtomicUsize`, which does not implement the `Copy` trait
@@ -35,7 +35,7 @@ LL +     let x = &x;
    |
 
 error[E0507]: cannot move out of a shared reference
-  --> $DIR/std-uncopyable-atomics.rs:15:13
+  --> $DIR/atomic-types-not-copyable.rs:17:13
    |
 LL |     let x = *&x;
    |             ^^^ move occurs because value has type `std::sync::atomic::AtomicPtr<usize>`, which does not implement the `Copy` trait
diff --git a/tests/ui/target-feature/target-feature-detection.rs b/tests/ui/target-feature/target-feature-detection.rs
index a1894cc03db..3404bfbe782 100644
--- a/tests/ui/target-feature/target-feature-detection.rs
+++ b/tests/ui/target-feature/target-feature-detection.rs
@@ -1,3 +1,6 @@
+//! Check that `cfg!(target_feature = "...")` correctly detects available CPU features,
+//! specifically `sse2` on x86/x86_64 platforms, and correctly reports absent features.
+
 //@ run-pass
 
 #![allow(stable_features)]
@@ -10,17 +13,23 @@ fn main() {
         Ok(s) => {
             // Skip this tests on i586-unknown-linux-gnu where sse2 is disabled
             if s.contains("i586") {
-                return
+                return;
             }
         }
         Err(_) => return,
     }
     if cfg!(any(target_arch = "x86", target_arch = "x86_64")) {
-        assert!(cfg!(target_feature = "sse2"),
-                "SSE2 was not detected as available on an x86 platform");
+        assert!(
+            cfg!(target_feature = "sse2"),
+            "SSE2 was not detected as available on an x86 platform"
+        );
     }
     // check a negative case too -- certainly not enabled by default
     #[expect(unexpected_cfgs)]
-    { assert!(cfg!(not(target_feature = "ferris_wheel")),
-            "🎡 shouldn't be detected as available by default on any platform") };
+    {
+        assert!(
+            cfg!(not(target_feature = "ferris_wheel")),
+            "🎡 shouldn't be detected as available by default on any platform"
+        )
+    };
 }
diff --git a/tests/ui/traits/error-trait-object-from-string.rs b/tests/ui/traits/error-trait-object-from-string.rs
index 9a7cd81ee04..896f164a04d 100644
--- a/tests/ui/traits/error-trait-object-from-string.rs
+++ b/tests/ui/traits/error-trait-object-from-string.rs
@@ -1,6 +1,7 @@
+//! Check that `String` and `&str` can be converted into `Box<dyn Error>` and
+//! `Box<dyn Error + Send + Sync>` trait objects
+
 //@ run-pass
-// Ensure that both `Box<dyn Error + Send + Sync>` and `Box<dyn Error>` can be
-// obtained from `String`.
 
 use std::error::Error;