tests/ui: A New Order [15/N]

tests/ui/compiletest-self-test/ui-test-missing-annotations-detection.rs

@@ -0,0 +1,9 @@
+//! Regression test checks UI tests without error annotations are detected as failing.
+//!
+//! This tests that when we forget to use any `//~ ERROR` comments whatsoever,
+//! the test doesn't succeed
+//! Originally created in https://github.com/rust-lang/rust/pull/56244
+
+//@ should-fail
+
+fn main() {}

tests/ui/derives/derive-Debug-enum-variants.rs

@@ -0,0 +1,30 @@
+//! Test that `#[derive(Debug)]` for enums correctly formats variant names.
+
+//@ run-pass
+
+#[derive(Debug)]
+enum Foo {
+    A(usize),
+    C,
+}
+
+#[derive(Debug)]
+enum Bar {
+    D,
+}
+
+pub fn main() {
+    // Test variant with data
+    let foo_a = Foo::A(22);
+    assert_eq!("A(22)".to_string(), format!("{:?}", foo_a));
+
+    if let Foo::A(value) = foo_a {
+        println!("Value: {}", value); // This needs to remove #[allow(dead_code)]
+    }
+
+    // Test unit variant
+    assert_eq!("C".to_string(), format!("{:?}", Foo::C));
+
+    // Test unit variant from different enum
+    assert_eq!("D".to_string(), format!("{:?}", Bar::D));
+}

tests/ui/logging-only-prints-once.rs → tests/ui/fmt/debug-single-call.rs

@@ -1,9 +1,12 @@
+//! Test that Debug::fmt is called exactly once during formatting.
+//!
+//! This is a regression test for PR https://github.com/rust-lang/rust/pull/10715
+
 //@ run-pass
 //@ needs-threads
 
 use std::cell::Cell;
-use std::fmt;
-use std::thread;
+use std::{fmt, thread};
 
 struct Foo(Cell<isize>);
 

tests/ui/link-section.rs → tests/ui/linkage-attr/link-section-placement.rs

@@ -1,8 +1,9 @@
+//! Test placement of functions and statics in custom link sections
+
 //@ run-pass
 
 // FIXME(static_mut_refs): Do not allow `static_mut_refs` lint
 #![allow(static_mut_refs)]
-
 #![allow(non_upper_case_globals)]
 #[cfg(not(target_vendor = "apple"))]
 #[link_section = ".moretext"]

tests/ui/max-min-classes.rs → tests/ui/resolve/struct-function-same-name.rs

@@ -1,3 +1,5 @@
+//! Test that a struct and function can have the same name
+//!
 //@ run-pass
 
 #![allow(non_snake_case)]
@@ -23,7 +25,7 @@ impl Product for Foo {
 }
 
 fn Foo(x: isize, y: isize) -> Foo {
-    Foo { x: x, y: y }
+    Foo { x, y }
 }
 
 pub fn main() {

tests/ui/lexical-scoping.rs → tests/ui/resolve/type-param-local-var-shadowing.rs

@@ -1,8 +1,13 @@
+//! Test that items in subscopes correctly shadow type parameters and local variables
+//!
+//! Regression test for https://github.com/rust-lang/rust/issues/23880
+
 //@ run-pass
-// Tests that items in subscopes can shadow type parameters and local variables (see issue #23880).
 
 #![allow(unused)]
-struct Foo<X> { x: Box<X> }
+struct Foo<X> {
+    x: Box<X>,
+}
 impl<Bar> Foo<Bar> {
     fn foo(&self) {
         type Bar = i32;