Auto merge of rust-lang#124497 - rytheo:move-std-tests-to-library, r=workingjubilee

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

Related to rust-lang#99417

Author: bors

Diff for: std/tests/builtin-clone.rs

@@ -0,0 +1,33 @@
+// 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.
+
+fn test_clone<T: Clone>(arg: T) {
+    let _ = arg.clone();
+}
+
+fn foo() {}
+
+#[derive(Debug, PartialEq, Eq)]
+struct S(i32);
+
+impl Clone for S {
+    fn clone(&self) -> Self {
+        S(self.0 + 1)
+    }
+}
+
+#[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));
+
+    let a = [S(0), S(1), S(2)];
+    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)));
+    assert_eq!(b, a.clone());
+}

Diff for: 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);
+}

Diff for: std/tests/istr.rs

@@ -0,0 +1,48 @@
+#[test]
+fn test_stack_assign() {
+    let s: String = "a".to_string();
+    println!("{}", s.clone());
+    let t: String = "a".to_string();
+    assert_eq!(s, t);
+    let u: String = "b".to_string();
+    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();
+    assert_eq!(s, t);
+    let u: String = "a bad ol' string".to_string();
+    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");
+    assert_eq!(s, "a");
+
+    let mut s = String::from("a");
+    s.push_str("b");
+    println!("{}", s.clone());
+    assert_eq!(s, "ab");
+
+    let mut s = String::from("c");
+    s.push_str("offee");
+    assert_eq!(s, "coffee");
+
+    s.push_str("&tea");
+    assert_eq!(s, "coffee&tea");
+}

Diff for: std/tests/log-knows-the-names-of-variants-in-std.rs

@@ -0,0 +1,27 @@
+#![allow(non_camel_case_types)]
+#![allow(dead_code)]
+
+#[derive(Clone, Debug)]
+enum foo {
+    a(usize),
+    b(String),
+}
+
+fn check_log<T: std::fmt::Debug>(exp: String, v: T) {
+    assert_eq!(exp, format!("{:?}", v));
+}
+
+#[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);
+    assert_eq!(act, exp);
+    check_log(exp, x);
+
+    x = None;
+    let exp = "None".to_string();
+    let act = format!("{:?}", x);
+    assert_eq!(act, exp);
+    check_log(exp, x);
+}

Diff for: std/tests/minmax-stability-issue-23687.rs

@@ -0,0 +1,63 @@
+use std::cmp::{self, Ordering};
+use std::fmt::Debug;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+struct Foo {
+    n: u8,
+    name: &'static str,
+}
+
+impl PartialOrd for Foo {
+    fn partial_cmp(&self, other: &Foo) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Foo {
+    fn cmp(&self, other: &Foo) -> Ordering {
+        self.n.cmp(&other.n)
+    }
+}
+
+#[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" };
+    let d = Foo { n: 8, name: "d" };
+    let e = Foo { n: 22, name: "e" };
+    let f = Foo { n: 22, name: "f" };
+
+    let data = [a, b, c, d, e, f];
+
+    // `min` should return the left when the values are equal
+    assert_eq!(data.iter().min(), Some(&a));
+    assert_eq!(data.iter().min_by_key(|a| a.n), Some(&a));
+    assert_eq!(cmp::min(a, b), a);
+    assert_eq!(cmp::min(b, a), b);
+
+    // `max` should return the right when the values are equal
+    assert_eq!(data.iter().max(), Some(&f));
+    assert_eq!(data.iter().max_by_key(|a| a.n), Some(&f));
+    assert_eq!(cmp::max(e, f), f);
+    assert_eq!(cmp::max(f, e), e);
+
+    let mut presorted = data.to_vec();
+    presorted.sort();
+    assert_stable(&presorted);
+
+    let mut presorted = data.to_vec();
+    presorted.sort_by(|a, b| a.cmp(b));
+    assert_stable(&presorted);
+
+    // Assert that sorted and min/max are the same
+    fn assert_stable<T: Ord + Debug>(presorted: &[T]) {
+        for slice in presorted.windows(2) {
+            let a = &slice[0];
+            let b = &slice[1];
+
+            assert_eq!(a, cmp::min(a, b));
+            assert_eq!(b, cmp::max(a, b));
+        }
+    }
+}

Diff for: std/tests/seq-compare.rs

@@ -0,0 +1,15 @@
+#[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()));
+    assert!((vec![1, 2, 3, 4] > vec![1, 2, 3]));
+    assert!((vec![1, 2, 3] < vec![1, 2, 3, 4]));
+    assert!((vec![1, 2, 4, 4] > vec![1, 2, 3, 4]));
+    assert!((vec![1, 2, 3, 4] < vec![1, 2, 4, 4]));
+    assert!((vec![1, 2, 3] <= vec![1, 2, 3]));
+    assert!((vec![1, 2, 3] <= vec![1, 2, 3, 3]));
+    assert!((vec![1, 2, 3, 4] > vec![1, 2, 3]));
+    assert_eq!(vec![1, 2, 3], vec![1, 2, 3]);
+    assert!((vec![1, 2, 3] != vec![1, 1, 3]));
+}

Diff for: std/tests/slice-from-array-issue-113238.rs

@@ -0,0 +1,8 @@
+// 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.
+#[test]
+fn slice_from_array() {
+    let _ = <&[u8]>::from(&[]);
+}

Diff for: std/tests/type-name-unsized.rs

@@ -0,0 +1,70 @@
+#![allow(dead_code)]
+
+use std::fmt::Debug;
+
+struct NT(str);
+
+struct DST {
+    a: u32,
+    b: str,
+}
+
+macro_rules! check {
+    (val: $ty_of:expr, $expected:expr) => {
+        assert_eq!(type_name_of_val($ty_of), $expected);
+    };
+    ($ty:ty, $expected:expr) => {
+        assert_eq!(std::any::type_name::<$ty>(), $expected);
+    };
+}
+
+/// 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, "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(), "type_name_unsized::Foo");
+    check!(val: Foo::new, "type_name_unsized::Foo::new");
+    check!(val:
+        <Foo as Debug>::fmt,
+        "<type_name_unsized::Foo as core::fmt::Debug>::fmt"
+    );
+    check!(val: || {}, "type_name_unsized::type_name_unsized::{{closure}}");
+    bar::<i32>();
+}
+
+trait Trait {
+    type Assoc;
+}
+
+impl Trait for i32 {
+    type Assoc = String;
+}
+
+fn bar<T: Trait>() {
+    check!(T::Assoc, "alloc::string::String");
+    check!(T, "i32");
+}
+
+fn type_name_of_val<T>(_: T) -> &'static str {
+    std::any::type_name::<T>()
+}
+
+#[derive(Debug)]
+struct Foo;
+
+impl Foo {
+    fn new() -> Self {
+        Foo
+    }
+}
+
+fn foo() -> impl Debug {
+    Foo
+}

Diff for: std/tests/volatile-fat-ptr.rs

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