Move some stdlib tests from tests/ui to library/std/tests

tests/ui/stdlib-unit-tests/builtin-clone.rs → library/std/tests/builtin-clone.rs

@@ -1,4 +1,3 @@
-//@ run-pass
 // Test that `Clone` is correctly implemented for builtin types.
 // Also test that cloning an array or a tuple is done right, i.e.
 // each component is cloned.
@@ -7,7 +6,7 @@ fn test_clone<T: Clone>(arg: T) {
     let _ = arg.clone();
 }
 
-fn foo() { }
+fn foo() {}
 
 #[derive(Debug, PartialEq, Eq)]
 struct S(i32);
@@ -18,7 +17,8 @@ impl Clone for S {
     }
 }
 
-fn main() {
+#[test]
+fn builtin_clone() {
     test_clone(foo);
     test_clone([1; 56]);
     test_clone((1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1));
@@ -27,19 +27,7 @@ fn main() {
     let b = [S(1), S(2), S(3)];
     assert_eq!(b, a.clone());
 
-    let a = (
-        (S(1), S(0)),
-        (
-            (S(0), S(0), S(1)),
-            S(0)
-        )
-    );
-    let b = (
-        (S(2), S(1)),
-        (
-            (S(1), S(1), S(2)),
-            S(1)
-        )
-    );
+    let a = ((S(1), S(0)), ((S(0), S(0), S(1)), S(0)));
+    let b = ((S(2), S(1)), ((S(1), S(1), S(2)), S(1)));
     assert_eq!(b, a.clone());
 }

library/std/tests/eq-multidispatch.rs

@@ -0,0 +1,51 @@
+#[derive(PartialEq, Debug)]
+struct Bar;
+#[derive(Debug)]
+struct Baz;
+#[derive(Debug)]
+struct Foo;
+#[derive(Debug)]
+struct Fu;
+
+impl PartialEq for Baz {
+    fn eq(&self, _: &Baz) -> bool {
+        true
+    }
+}
+
+impl PartialEq<Fu> for Foo {
+    fn eq(&self, _: &Fu) -> bool {
+        true
+    }
+}
+
+impl PartialEq<Foo> for Fu {
+    fn eq(&self, _: &Foo) -> bool {
+        true
+    }
+}
+
+impl PartialEq<Bar> for Foo {
+    fn eq(&self, _: &Bar) -> bool {
+        false
+    }
+}
+
+impl PartialEq<Foo> for Bar {
+    fn eq(&self, _: &Foo) -> bool {
+        false
+    }
+}
+
+#[test]
+fn eq_multidispatch() {
+    assert!(Bar != Foo);
+    assert!(Foo != Bar);
+
+    assert_eq!(Bar, Bar);
+
+    assert_eq!(Baz, Baz);
+
+    assert_eq!(Foo, Fu);
+    assert_eq!(Fu, Foo);
+}

tests/ui/stdlib-unit-tests/istr.rs → library/std/tests/istr.rs

@@ -1,5 +1,4 @@
-//@ run-pass
-
+#[test]
 fn test_stack_assign() {
     let s: String = "a".to_string();
     println!("{}", s.clone());
@@ -9,8 +8,12 @@ fn test_stack_assign() {
     assert!((s != u));
 }
 
-fn test_heap_lit() { "a big string".to_string(); }
+#[test]
+fn test_heap_lit() {
+    "a big string".to_string();
+}
 
+#[test]
 fn test_heap_assign() {
     let s: String = "a big ol' string".to_string();
     let t: String = "a big ol' string".to_string();
@@ -19,11 +22,13 @@ fn test_heap_assign() {
     assert!((s != u));
 }
 
+#[test]
 fn test_heap_log() {
     let s = "a big ol' string".to_string();
     println!("{}", s);
 }
 
+#[test]
 fn test_append() {
     let mut s = String::new();
     s.push_str("a");
@@ -41,11 +46,3 @@ fn test_append() {
     s.push_str("&tea");
     assert_eq!(s, "coffee&tea");
 }
-
-pub fn main() {
-    test_stack_assign();
-    test_heap_lit();
-    test_heap_assign();
-    test_heap_log();
-    test_append();
-}

tests/ui/stdlib-unit-tests/log-knows-the-names-of-variants-in-std.rs → library/std/tests/log-knows-the-names-of-variants-in-std.rs

@@ -1,18 +1,18 @@
-//@ run-pass
-
 #![allow(non_camel_case_types)]
 #![allow(dead_code)]
+
 #[derive(Clone, Debug)]
 enum foo {
-  a(usize),
-  b(String),
+    a(usize),
+    b(String),
 }
 
 fn check_log<T: std::fmt::Debug>(exp: String, v: T) {
     assert_eq!(exp, format!("{:?}", v));
 }
 
-pub fn main() {
+#[test]
+fn log_knows_the_names_of_variants_in_std() {
     let mut x = Some(foo::a(22));
     let exp = "Some(a(22))".to_string();
     let act = format!("{:?}", x);

tests/ui/stdlib-unit-tests/minmax-stability-issue-23687.rs → library/std/tests/minmax-stability-issue-23687.rs

@@ -1,12 +1,10 @@
-//@ run-pass
-
-use std::fmt::Debug;
 use std::cmp::{self, Ordering};
+use std::fmt::Debug;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 struct Foo {
     n: u8,
-    name: &'static str
+    name: &'static str,
 }
 
 impl PartialOrd for Foo {
@@ -21,7 +19,8 @@ impl Ord for Foo {
     }
 }
 
-fn main() {
+#[test]
+fn minmax_stability() {
     let a = Foo { n: 4, name: "a" };
     let b = Foo { n: 4, name: "b" };
     let c = Foo { n: 8, name: "c" };

tests/ui/stdlib-unit-tests/seq-compare.rs → library/std/tests/seq-compare.rs

@@ -1,6 +1,5 @@
-//@ run-pass
-
-pub fn main() {
+#[test]
+fn seq_compare() {
     assert!(("hello".to_string() < "hellr".to_string()));
     assert!(("hello ".to_string() > "hello".to_string()));
     assert!(("hello".to_string() != "there".to_string()));

tests/ui/std/slice-from-array-issue-113238.rs → library/std/tests/slice-from-array-issue-113238.rs

@@ -1,9 +1,8 @@
-//@ check-pass
-
 // This intends to use the unsizing coercion from array to slice, but it only
 // works if we resolve `<&[u8]>::from` as the reflexive `From<T> for T`. In
 // #113238, we found that gimli had added its own `From<EndianSlice> for &[u8]`
 // that affected all `std/backtrace` users.
-fn main() {
+#[test]
+fn slice_from_array() {
     let _ = <&[u8]>::from(&[]);
 }

tests/ui/stdlib-unit-tests/issue-21058.rs → library/std/tests/type-name-unsized.rs

@@ -1,10 +1,13 @@
-//@ run-pass
 #![allow(dead_code)]
 
 use std::fmt::Debug;
 
 struct NT(str);
-struct DST { a: u32, b: str }
+
+struct DST {
+    a: u32,
+    b: str,
+}
 
 macro_rules! check {
     (val: $ty_of:expr, $expected:expr) => {
@@ -15,23 +18,24 @@ macro_rules! check {
     };
 }
 
-fn main() {
-    // type_name should support unsized types
+/// Tests that [`std::any::type_name`] supports unsized types.
+#[test]
+fn type_name_unsized() {
     check!([u8], "[u8]");
     check!(str, "str");
     check!(dyn Send, "dyn core::marker::Send");
-    check!(NT, "issue_21058::NT");
-    check!(DST, "issue_21058::DST");
+    check!(NT, "type_name_unsized::NT");
+    check!(DST, "type_name_unsized::DST");
     check!(&i32, "&i32");
     check!(&'static i32, "&i32");
     check!((i32, u32), "(i32, u32)");
-    check!(val: foo(), "issue_21058::Foo");
-    check!(val: Foo::new, "issue_21058::Foo::new");
+    check!(val: foo(), "type_name_unsized::Foo");
+    check!(val: Foo::new, "type_name_unsized::Foo::new");
     check!(val:
         <Foo as Debug>::fmt,
-        "<issue_21058::Foo as core::fmt::Debug>::fmt"
+        "<type_name_unsized::Foo as core::fmt::Debug>::fmt"
     );
-    check!(val: || {}, "issue_21058::main::{{closure}}");
+    check!(val: || {}, "type_name_unsized::type_name_unsized::{{closure}}");
     bar::<i32>();
 }
 
@@ -56,7 +60,9 @@ fn type_name_of_val<T>(_: T) -> &'static str {
 struct Foo;
 
 impl Foo {
-    fn new() -> Self { Foo }
+    fn new() -> Self {
+        Foo
+    }
 }
 
 fn foo() -> impl Debug {

tests/ui/stdlib-unit-tests/volatile-fat-ptr.rs → library/std/tests/volatile-fat-ptr.rs

@@ -1,10 +1,10 @@
-//@ run-pass
-
 #![allow(stable_features)]
 #![feature(volatile)]
+
 use std::ptr::{read_volatile, write_volatile};
 
-fn main() {
+#[test]
+fn volatile_fat_ptr() {
     let mut x: &'static str = "test";
     unsafe {
         let a = read_volatile(&x);

src/tools/tidy/src/issues.txt

@@ -3862,7 +3862,6 @@ ui/statics/issue-91050-1.rs
 ui/statics/issue-91050-2.rs
 ui/std/issue-3563-3.rs
 ui/std/issue-81357-unsound-file-methods.rs
-ui/stdlib-unit-tests/issue-21058.rs
 ui/structs-enums/enum-rec/issue-17431-6.rs
 ui/structs-enums/enum-rec/issue-17431-7.rs
 ui/structs-enums/issue-103869.rs