Move various stdlib tests to library/std/tests

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.
@@ -18,7 +17,8 @@ fn clone(&self) -> Self {
     }
 }
 
-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));

library/std/tests/eq-multidispatch.rs

@@ -1,5 +1,3 @@
-//@ run-pass
-
 #[derive(PartialEq, Debug)]
 struct Bar;
 #[derive(Debug)]
@@ -17,7 +15,8 @@ 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 } }
 
-fn main() {
+#[test]
+fn eq_multidispatch() {
     assert!(Bar != Foo);
     assert!(Foo != Bar);
 

library/std/tests/issue-21058.rs

@@ -1,4 +1,3 @@
-//@ run-pass
 #![allow(dead_code)]
 
 use std::fmt::Debug;
@@ -15,7 +14,8 @@ macro_rules! check {
     };
 }
 
-fn main() {
+#[test]
+fn issue_21058() {
     // type_name should support unsized types
     check!([u8], "[u8]");
     check!(str, "str");
@@ -31,7 +31,7 @@ fn main() {
         <Foo as Debug>::fmt,
         "<issue_21058::Foo as core::fmt::Debug>::fmt"
     );
-    check!(val: || {}, "issue_21058::main::{{closure}}");
+    check!(val: || {}, "issue_21058::issue_21058::{{closure}}");
     bar::<i32>();
 }
 

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,10 @@ fn test_stack_assign() {
     assert!((s != u));
 }
 
+#[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 +20,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 +44,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();
-}

library/std/tests/log-knows-the-names-of-variants-in-std.rs

@@ -1,7 +1,6 @@
-//@ run-pass
-
 #![allow(non_camel_case_types)]
 #![allow(dead_code)]
+
 #[derive(Clone, Debug)]
 enum foo {
   a(usize),
@@ -12,7 +11,8 @@ 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);

library/std/tests/minmax-stability-issue-23687.rs

@@ -1,5 +1,3 @@
-//@ run-pass
-
 use std::fmt::Debug;
 use std::cmp::{self, Ordering};
 
@@ -21,7 +19,8 @@ fn cmp(&self, other: &Foo) -> Ordering {
     }
 }
 
-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" };

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()));

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(&[]);
 }

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);