Make ui test that are run-pass and do not test the compiler itself library tests

38 files changed, 812 insertions, 820 deletions

diff --git a/library/alloc/tests/str.rs b/library/alloc/tests/str.rs
index 834dd4656ff..b1301914656 100644
--- a/library/alloc/tests/str.rs
+++ b/library/alloc/tests/str.rs
@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 use std::cmp::Ordering::{Equal, Greater, Less};
-use std::str::from_utf8;
+use std::str::{from_utf8, from_utf8_unchecked};
 
 #[test]
 fn test_le() {
@@ -1971,3 +1971,97 @@ fn test_str_escapes() {
     ";
     assert_eq!(x, r"\\"); // extraneous whitespace stripped
 }
+
+#[test]
+fn const_str_ptr() {
+    const A: [u8; 2] = ['h' as u8, 'i' as u8];
+    const B: &'static [u8; 2] = &A;
+    const C: *const u8 = B as *const u8;
+
+    unsafe {
+        let foo = &A as *const u8;
+        assert_eq!(foo, C);
+        assert_eq!(from_utf8_unchecked(&A), "hi");
+        assert_eq!(*C, A[0]);
+        assert_eq!(*(&B[0] as *const u8), A[0]);
+    }
+}
+
+#[test]
+fn utf8() {
+    let yen: char = '¥'; // 0xa5
+    let c_cedilla: char = 'ç'; // 0xe7
+    let thorn: char = 'þ'; // 0xfe
+    let y_diaeresis: char = 'ÿ'; // 0xff
+    let pi: char = 'Π'; // 0x3a0
+
+    assert_eq!(yen as isize, 0xa5);
+    assert_eq!(c_cedilla as isize, 0xe7);
+    assert_eq!(thorn as isize, 0xfe);
+    assert_eq!(y_diaeresis as isize, 0xff);
+    assert_eq!(pi as isize, 0x3a0);
+
+    assert_eq!(pi as isize, '\u{3a0}' as isize);
+    assert_eq!('\x0a' as isize, '\n' as isize);
+
+    let bhutan: String = "འབྲུག་ཡུལ།".to_string();
+    let japan: String = "日本".to_string();
+    let uzbekistan: String = "Ўзбекистон".to_string();
+    let austria: String = "Österreich".to_string();
+
+    let bhutan_e: String =
+        "\u{f60}\u{f56}\u{fb2}\u{f74}\u{f42}\u{f0b}\u{f61}\u{f74}\u{f63}\u{f0d}".to_string();
+    let japan_e: String = "\u{65e5}\u{672c}".to_string();
+    let uzbekistan_e: String =
+        "\u{40e}\u{437}\u{431}\u{435}\u{43a}\u{438}\u{441}\u{442}\u{43e}\u{43d}".to_string();
+    let austria_e: String = "\u{d6}sterreich".to_string();
+
+    let oo: char = 'Ö';
+    assert_eq!(oo as isize, 0xd6);
+
+    fn check_str_eq(a: String, b: String) {
+        let mut i: isize = 0;
+        for ab in a.bytes() {
+            println!("{}", i);
+            println!("{}", ab);
+            let bb: u8 = b.as_bytes()[i as usize];
+            println!("{}", bb);
+            assert_eq!(ab, bb);
+            i += 1;
+        }
+    }
+
+    check_str_eq(bhutan, bhutan_e);
+    check_str_eq(japan, japan_e);
+    check_str_eq(uzbekistan, uzbekistan_e);
+    check_str_eq(austria, austria_e);
+}
+
+#[test]
+fn utf8_chars() {
+    // Chars of 1, 2, 3, and 4 bytes
+    let chs: Vec<char> = vec!['e', 'é', '€', '\u{10000}'];
+    let s: String = chs.iter().cloned().collect();
+    let schs: Vec<char> = s.chars().collect();
+
+    assert_eq!(s.len(), 10);
+    assert_eq!(s.chars().count(), 4);
+    assert_eq!(schs.len(), 4);
+    assert_eq!(schs.iter().cloned().collect::<String>(), s);
+
+    assert!((from_utf8(s.as_bytes()).is_ok()));
+    // invalid prefix
+    assert!((!from_utf8(&[0x80]).is_ok()));
+    // invalid 2 byte prefix
+    assert!((!from_utf8(&[0xc0]).is_ok()));
+    assert!((!from_utf8(&[0xc0, 0x10]).is_ok()));
+    // invalid 3 byte prefix
+    assert!((!from_utf8(&[0xe0]).is_ok()));
+    assert!((!from_utf8(&[0xe0, 0x10]).is_ok()));
+    assert!((!from_utf8(&[0xe0, 0xff, 0x10]).is_ok()));
+    // invalid 4 byte prefix
+    assert!((!from_utf8(&[0xf0]).is_ok()));
+    assert!((!from_utf8(&[0xf0, 0x10]).is_ok()));
+    assert!((!from_utf8(&[0xf0, 0xff, 0x10]).is_ok()));
+    assert!((!from_utf8(&[0xf0, 0xff, 0xff, 0x10]).is_ok()));
+}
diff --git a/library/core/tests/ascii.rs b/library/core/tests/ascii.rs
index 3244bbc2d67..66c25e449df 100644
--- a/library/core/tests/ascii.rs
+++ b/library/core/tests/ascii.rs
@@ -408,3 +408,56 @@ fn ascii_const() {
     const BYTE_IS_ASCII: bool = 97u8.is_ascii();
     assert!(BYTE_IS_ASCII);
 }
+
+#[test]
+fn ascii_ctype_const() {
+    macro_rules! suite {
+        ( $( $fn:ident => [$a:ident, $A:ident, $nine:ident, $dot:ident, $space:ident]; )* ) => {
+            $(
+                mod $fn {
+                    const CHAR_A_LOWER: bool = 'a'.$fn();
+                    const CHAR_A_UPPER: bool = 'A'.$fn();
+                    const CHAR_NINE: bool = '9'.$fn();
+                    const CHAR_DOT: bool = '.'.$fn();
+                    const CHAR_SPACE: bool = ' '.$fn();
+
+                    const U8_A_LOWER: bool = b'a'.$fn();
+                    const U8_A_UPPER: bool = b'A'.$fn();
+                    const U8_NINE: bool = b'9'.$fn();
+                    const U8_DOT: bool = b'.'.$fn();
+                    const U8_SPACE: bool = b' '.$fn();
+
+                    pub fn run() {
+                        assert_eq!(CHAR_A_LOWER, $a);
+                        assert_eq!(CHAR_A_UPPER, $A);
+                        assert_eq!(CHAR_NINE, $nine);
+                        assert_eq!(CHAR_DOT, $dot);
+                        assert_eq!(CHAR_SPACE, $space);
+
+                        assert_eq!(U8_A_LOWER, $a);
+                        assert_eq!(U8_A_UPPER, $A);
+                        assert_eq!(U8_NINE, $nine);
+                        assert_eq!(U8_DOT, $dot);
+                        assert_eq!(U8_SPACE, $space);
+                    }
+                }
+            )*
+
+            $( $fn::run(); )*
+        }
+    }
+
+    suite! {
+        //                        'a'    'A'    '9'    '.'    ' '
+        is_ascii_alphabetic   => [true,  true,  false, false, false];
+        is_ascii_uppercase    => [false, true,  false, false, false];
+        is_ascii_lowercase    => [true,  false, false, false, false];
+        is_ascii_alphanumeric => [true,  true,  true,  false, false];
+        is_ascii_digit        => [false, false, true,  false, false];
+        is_ascii_hexdigit     => [true,  true,  true,  false, false];
+        is_ascii_punctuation  => [false, false, false, true,  false];
+        is_ascii_graphic      => [true,  true,  true,  true,  false];
+        is_ascii_whitespace   => [false, false, false, false, true];
+        is_ascii_control      => [false, false, false, false, false];
+    }
+}
diff --git a/library/core/tests/atomic.rs b/library/core/tests/atomic.rs
index acbd913982c..75528ebb54e 100644
--- a/library/core/tests/atomic.rs
+++ b/library/core/tests/atomic.rs
@@ -101,3 +101,82 @@ fn static_init() {
     assert!(S_INT.fetch_add(1, SeqCst) == 0);
     assert!(S_UINT.fetch_add(1, SeqCst) == 0);
 }
+
+#[test]
+fn atomic_access_bool() {
+    static mut ATOMIC: AtomicBool = AtomicBool::new(false);
+
+    unsafe {
+        assert_eq!(*ATOMIC.get_mut(), false);
+        ATOMIC.store(true, SeqCst);
+        assert_eq!(*ATOMIC.get_mut(), true);
+        ATOMIC.fetch_or(false, SeqCst);
+        assert_eq!(*ATOMIC.get_mut(), true);
+        ATOMIC.fetch_and(false, SeqCst);
+        assert_eq!(*ATOMIC.get_mut(), false);
+        ATOMIC.fetch_nand(true, SeqCst);
+        assert_eq!(*ATOMIC.get_mut(), true);
+        ATOMIC.fetch_xor(true, SeqCst);
+        assert_eq!(*ATOMIC.get_mut(), false);
+    }
+}
+
+#[test]
+fn atomic_alignment() {
+    use std::mem::{align_of, size_of};
+
+    #[cfg(target_has_atomic = "8")]
+    assert_eq!(align_of::<AtomicBool>(), size_of::<AtomicBool>());
+    #[cfg(target_has_atomic = "ptr")]
+    assert_eq!(align_of::<AtomicPtr<u8>>(), size_of::<AtomicPtr<u8>>());
+    #[cfg(target_has_atomic = "8")]
+    assert_eq!(align_of::<AtomicU8>(), size_of::<AtomicU8>());
+    #[cfg(target_has_atomic = "8")]
+    assert_eq!(align_of::<AtomicI8>(), size_of::<AtomicI8>());
+    #[cfg(target_has_atomic = "16")]
+    assert_eq!(align_of::<AtomicU16>(), size_of::<AtomicU16>());
+    #[cfg(target_has_atomic = "16")]
+    assert_eq!(align_of::<AtomicI16>(), size_of::<AtomicI16>());
+    #[cfg(target_has_atomic = "32")]
+    assert_eq!(align_of::<AtomicU32>(), size_of::<AtomicU32>());
+    #[cfg(target_has_atomic = "32")]
+    assert_eq!(align_of::<AtomicI32>(), size_of::<AtomicI32>());
+    #[cfg(target_has_atomic = "64")]
+    assert_eq!(align_of::<AtomicU64>(), size_of::<AtomicU64>());
+    #[cfg(target_has_atomic = "64")]
+    assert_eq!(align_of::<AtomicI64>(), size_of::<AtomicI64>());
+    #[cfg(target_has_atomic = "128")]
+    assert_eq!(align_of::<AtomicU128>(), size_of::<AtomicU128>());
+    #[cfg(target_has_atomic = "128")]
+    assert_eq!(align_of::<AtomicI128>(), size_of::<AtomicI128>());
+    #[cfg(target_has_atomic = "ptr")]
+    assert_eq!(align_of::<AtomicUsize>(), size_of::<AtomicUsize>());
+    #[cfg(target_has_atomic = "ptr")]
+    assert_eq!(align_of::<AtomicIsize>(), size_of::<AtomicIsize>());
+}
+
+#[test]
+fn atomic_compare_exchange() {
+    use Ordering::*;
+
+    static ATOMIC: AtomicIsize = AtomicIsize::new(0);
+
+    ATOMIC.compare_exchange(0, 1, Relaxed, Relaxed).ok();
+    ATOMIC.compare_exchange(0, 1, Acquire, Relaxed).ok();
+    ATOMIC.compare_exchange(0, 1, Release, Relaxed).ok();
+    ATOMIC.compare_exchange(0, 1, AcqRel, Relaxed).ok();
+    ATOMIC.compare_exchange(0, 1, SeqCst, Relaxed).ok();
+    ATOMIC.compare_exchange(0, 1, Acquire, Acquire).ok();
+    ATOMIC.compare_exchange(0, 1, AcqRel, Acquire).ok();
+    ATOMIC.compare_exchange(0, 1, SeqCst, Acquire).ok();
+    ATOMIC.compare_exchange(0, 1, SeqCst, SeqCst).ok();
+    ATOMIC.compare_exchange_weak(0, 1, Relaxed, Relaxed).ok();
+    ATOMIC.compare_exchange_weak(0, 1, Acquire, Relaxed).ok();
+    ATOMIC.compare_exchange_weak(0, 1, Release, Relaxed).ok();
+    ATOMIC.compare_exchange_weak(0, 1, AcqRel, Relaxed).ok();
+    ATOMIC.compare_exchange_weak(0, 1, SeqCst, Relaxed).ok();
+    ATOMIC.compare_exchange_weak(0, 1, Acquire, Acquire).ok();
+    ATOMIC.compare_exchange_weak(0, 1, AcqRel, Acquire).ok();
+    ATOMIC.compare_exchange_weak(0, 1, SeqCst, Acquire).ok();
+    ATOMIC.compare_exchange_weak(0, 1, SeqCst, SeqCst).ok();
+}
diff --git a/library/core/tests/bool.rs b/library/core/tests/bool.rs
index e89eb2c7f94..e40f0482aee 100644
--- a/library/core/tests/bool.rs
+++ b/library/core/tests/bool.rs
@@ -1,3 +1,87 @@
+use core::cmp::Ordering::{Equal, Greater, Less};
+use core::ops::{BitAnd, BitOr, BitXor};
+
+#[test]
+fn test_bool() {
+    assert_eq!(false.eq(&true), false);
+    assert_eq!(false == false, true);
+    assert_eq!(false != true, true);
+    assert_eq!(false.ne(&false), false);
+
+    assert_eq!(false.bitand(false), false);
+    assert_eq!(true.bitand(false), false);
+    assert_eq!(false.bitand(true), false);
+    assert_eq!(true.bitand(true), true);
+
+    assert_eq!(false & false, false);
+    assert_eq!(true & false, false);
+    assert_eq!(false & true, false);
+    assert_eq!(true & true, true);
+
+    assert_eq!(false.bitor(false), false);
+    assert_eq!(true.bitor(false), true);
+    assert_eq!(false.bitor(true), true);
+    assert_eq!(true.bitor(true), true);
+
+    assert_eq!(false | false, false);
+    assert_eq!(true | false, true);
+    assert_eq!(false | true, true);
+    assert_eq!(true | true, true);
+
+    assert_eq!(false.bitxor(false), false);
+    assert_eq!(true.bitxor(false), true);
+    assert_eq!(false.bitxor(true), true);
+    assert_eq!(true.bitxor(true), false);
+
+    assert_eq!(false ^ false, false);
+    assert_eq!(true ^ false, true);
+    assert_eq!(false ^ true, true);
+    assert_eq!(true ^ true, false);
+
+    assert_eq!(!true, false);
+    assert_eq!(!false, true);
+
+    let s = false.to_string();
+    assert_eq!(s, "false");
+    let s = true.to_string();
+    assert_eq!(s, "true");
+
+    assert!(true > false);
+    assert!(!(false > true));
+
+    assert!(false < true);
+    assert!(!(true < false));
+
+    assert!(false <= false);
+    assert!(false >= false);
+    assert!(true <= true);
+    assert!(true >= true);
+
+    assert!(false <= true);
+    assert!(!(false >= true));
+    assert!(true >= false);
+    assert!(!(true <= false));
+
+    assert_eq!(true.cmp(&true), Equal);
+    assert_eq!(false.cmp(&false), Equal);
+    assert_eq!(true.cmp(&false), Greater);
+    assert_eq!(false.cmp(&true), Less);
+}
+
+#[test]
+pub fn test_bool_not() {
+    if !false {
+        assert!((true));
+    } else {
+        assert!((false));
+    }
+    if !true {
+        assert!((false));
+    } else {
+        assert!((true));
+    }
+}
+
 #[test]
 fn test_bool_to_option() {
     assert_eq!(false.then_some(0), None);
diff --git a/library/core/tests/cmp.rs b/library/core/tests/cmp.rs
index 835289daf71..11cf7add07a 100644
--- a/library/core/tests/cmp.rs
+++ b/library/core/tests/cmp.rs
@@ -132,3 +132,74 @@ fn ordering_const() {
     const THEN: Ordering = Equal.then(ORDERING);
     assert_eq!(THEN, Greater);
 }
+
+#[test]
+fn cmp_default() {
+    // Test default methods in PartialOrd and PartialEq
+
+    #[derive(Debug)]
+    struct Fool(bool);
+
+    impl PartialEq for Fool {
+        fn eq(&self, other: &Fool) -> bool {
+            let Fool(this) = *self;
+            let Fool(other) = *other;
+            this != other
+        }
+    }
+
+    struct Int(isize);
+
+    impl PartialEq for Int {
+        fn eq(&self, other: &Int) -> bool {
+            let Int(this) = *self;
+            let Int(other) = *other;
+            this == other
+        }
+    }
+
+    impl PartialOrd for Int {
+        fn partial_cmp(&self, other: &Int) -> Option<Ordering> {
+            let Int(this) = *self;
+            let Int(other) = *other;
+            this.partial_cmp(&other)
+        }
+    }
+
+    struct RevInt(isize);
+
+    impl PartialEq for RevInt {
+        fn eq(&self, other: &RevInt) -> bool {
+            let RevInt(this) = *self;
+            let RevInt(other) = *other;
+            this == other
+        }
+    }
+
+    impl PartialOrd for RevInt {
+        fn partial_cmp(&self, other: &RevInt) -> Option<Ordering> {
+            let RevInt(this) = *self;
+            let RevInt(other) = *other;
+            other.partial_cmp(&this)
+        }
+    }
+
+    assert!(Int(2) > Int(1));
+    assert!(Int(2) >= Int(1));
+    assert!(Int(1) >= Int(1));
+    assert!(Int(1) < Int(2));
+    assert!(Int(1) <= Int(2));
+    assert!(Int(1) <= Int(1));
+
+    assert!(RevInt(2) < RevInt(1));
+    assert!(RevInt(2) <= RevInt(1));
+    assert!(RevInt(1) <= RevInt(1));
+    assert!(RevInt(1) > RevInt(2));
+    assert!(RevInt(1) >= RevInt(2));
+    assert!(RevInt(1) >= RevInt(1));
+
+    assert_eq!(Fool(true), Fool(false));
+    assert!(Fool(true) != Fool(true));
+    assert!(Fool(false) != Fool(false));
+    assert_eq!(Fool(false), Fool(true));
+}
diff --git a/library/core/tests/iter.rs b/library/core/tests/iter.rs
index 6b8a989fa42..ec4b49da384 100644
--- a/library/core/tests/iter.rs
+++ b/library/core/tests/iter.rs
@@ -3493,3 +3493,15 @@ fn test_flatten_non_fused_inner() {
     assert_eq!(iter.next(), Some(1));
     assert_eq!(iter.next(), None);
 }
+
+#[test]
+pub fn extend_for_unit() {
+    let mut x = 0;
+    {
+        let iter = (0..5).map(|_| {
+            x += 1;
+        });
+        ().extend(iter);
+    }
+    assert_eq!(x, 5);
+}
diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs
index 1efb3b74118..106c9fe5da3 100644
--- a/library/core/tests/lib.rs
+++ b/library/core/tests/lib.rs
@@ -8,6 +8,7 @@
 #![feature(bound_cloned)]
 #![feature(box_syntax)]
 #![feature(cell_update)]
+#![feature(cfg_target_has_atomic)]
 #![feature(const_assume)]
 #![feature(const_cell_into_inner)]
 #![feature(core_intrinsics)]
@@ -63,6 +64,7 @@
 #![feature(int_bits_const)]
 #![feature(nonzero_leading_trailing_zeros)]
 #![feature(const_option)]
+#![feature(integer_atomics)]
 #![deny(unsafe_op_in_unsafe_fn)]
 
 extern crate test;
@@ -82,6 +84,7 @@ mod hash;
 mod intrinsics;
 mod iter;
 mod lazy;
+mod macros;
 mod manually_drop;
 mod mem;
 mod nonzero;
@@ -98,3 +101,4 @@ mod str_lossy;
 mod task;
 mod time;
 mod tuple;
+mod unicode;
diff --git a/library/core/tests/macros.rs b/library/core/tests/macros.rs
new file mode 100644
index 00000000000..482f3c1c998
--- /dev/null
+++ b/library/core/tests/macros.rs
@@ -0,0 +1,14 @@
+#[test]
+fn assert_eq_trailing_comma() {
+    assert_eq!(1, 1,);
+}
+
+#[test]
+fn assert_escape() {
+    assert!(r#"☃\backslash"#.contains("\\"));
+}
+
+#[test]
+fn assert_ne_trailing_comma() {
+    assert_ne!(1, 2,);
+}
diff --git a/library/core/tests/num/wrapping.rs b/library/core/tests/num/wrapping.rs
index 5d4ecb2669a..01defab2b38 100644
--- a/library/core/tests/num/wrapping.rs
+++ b/library/core/tests/num/wrapping.rs
@@ -74,3 +74,236 @@ wrapping_test!(u64, u64::MIN, u64::MAX);
 #[cfg(not(target_os = "emscripten"))]
 wrapping_test!(u128, u128::MIN, u128::MAX);
 wrapping_test!(usize, usize::MIN, usize::MAX);
+
+// Don't warn about overflowing ops on 32-bit platforms
+#[cfg_attr(target_pointer_width = "32", allow(const_err))]
+fn wrapping_int_api() {
+    assert_eq!(i8::MAX.wrapping_add(1), i8::MIN);
+    assert_eq!(i16::MAX.wrapping_add(1), i16::MIN);
+    assert_eq!(i32::MAX.wrapping_add(1), i32::MIN);
+    assert_eq!(i64::MAX.wrapping_add(1), i64::MIN);
+    assert_eq!(isize::MAX.wrapping_add(1), isize::MIN);
+
+    assert_eq!(i8::MIN.wrapping_sub(1), i8::MAX);
+    assert_eq!(i16::MIN.wrapping_sub(1), i16::MAX);
+    assert_eq!(i32::MIN.wrapping_sub(1), i32::MAX);
+    assert_eq!(i64::MIN.wrapping_sub(1), i64::MAX);
+    assert_eq!(isize::MIN.wrapping_sub(1), isize::MAX);
+
+    assert_eq!(u8::MAX.wrapping_add(1), u8::MIN);
+    assert_eq!(u16::MAX.wrapping_add(1), u16::MIN);
+    assert_eq!(u32::MAX.wrapping_add(1), u32::MIN);
+    assert_eq!(u64::MAX.wrapping_add(1), u64::MIN);
+    assert_eq!(usize::MAX.wrapping_add(1), usize::MIN);
+
+    assert_eq!(u8::MIN.wrapping_sub(1), u8::MAX);
+    assert_eq!(u16::MIN.wrapping_sub(1), u16::MAX);
+    assert_eq!(u32::MIN.wrapping_sub(1), u32::MAX);
+    assert_eq!(u64::MIN.wrapping_sub(1), u64::MAX);
+    assert_eq!(usize::MIN.wrapping_sub(1), usize::MAX);
+
+    assert_eq!((0xfe_u8 as i8).wrapping_mul(16), (0xe0_u8 as i8));
+    assert_eq!((0xfedc_u16 as i16).wrapping_mul(16), (0xedc0_u16 as i16));
+    assert_eq!((0xfedc_ba98_u32 as i32).wrapping_mul(16), (0xedcb_a980_u32 as i32));
+    assert_eq!(
+        (0xfedc_ba98_7654_3217_u64 as i64).wrapping_mul(16),
+        (0xedcb_a987_6543_2170_u64 as i64)
+    );
+
+    match () {
+        #[cfg(target_pointer_width = "32")]
+        () => {
+            assert_eq!((0xfedc_ba98_u32 as isize).wrapping_mul(16), (0xedcb_a980_u32 as isize));
+        }
+        #[cfg(target_pointer_width = "64")]
+        () => {
+            assert_eq!(
+                (0xfedc_ba98_7654_3217_u64 as isize).wrapping_mul(16),
+                (0xedcb_a987_6543_2170_u64 as isize)
+            );
+        }
+    }
+
+    assert_eq!((0xfe as u8).wrapping_mul(16), (0xe0 as u8));
+    assert_eq!((0xfedc as u16).wrapping_mul(16), (0xedc0 as u16));
+    assert_eq!((0xfedc_ba98 as u32).wrapping_mul(16), (0xedcb_a980 as u32));
+    assert_eq!((0xfedc_ba98_7654_3217 as u64).wrapping_mul(16), (0xedcb_a987_6543_2170 as u64));
+
+    match () {
+        #[cfg(target_pointer_width = "32")]
+        () => {
+            assert_eq!((0xfedc_ba98 as usize).wrapping_mul(16), (0xedcb_a980 as usize));
+        }
+        #[cfg(target_pointer_width = "64")]
+        () => {
+            assert_eq!(
+                (0xfedc_ba98_7654_3217 as usize).wrapping_mul(16),
+                (0xedcb_a987_6543_2170 as usize)
+            );
+        }
+    }
+
+    macro_rules! check_mul_no_wrap {
+        ($e:expr, $f:expr) => {
+            assert_eq!(($e).wrapping_mul($f), ($e) * $f);
+        };
+    }
+    macro_rules! check_mul_wraps {
+        ($e:expr, $f:expr) => {
+            assert_eq!(($e).wrapping_mul($f), $e);
+        };
+    }
+
+    check_mul_no_wrap!(0xfe_u8 as i8, -1);
+    check_mul_no_wrap!(0xfedc_u16 as i16, -1);
+    check_mul_no_wrap!(0xfedc_ba98_u32 as i32, -1);
+    check_mul_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -1);
+    check_mul_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -1);
+
+    check_mul_no_wrap!(0xfe_u8 as i8, -2);
+    check_mul_no_wrap!(0xfedc_u16 as i16, -2);
+    check_mul_no_wrap!(0xfedc_ba98_u32 as i32, -2);
+    check_mul_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -2);
+    check_mul_no_wrap!(0xfedc_ba98_fedc_ba98_u64 as u64 as isize, -2);
+
+    check_mul_no_wrap!(0xfe_u8 as i8, 2);
+    check_mul_no_wrap!(0xfedc_u16 as i16, 2);
+    check_mul_no_wrap!(0xfedc_ba98_u32 as i32, 2);
+    check_mul_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, 2);
+    check_mul_no_wrap!(0xfedc_ba98_fedc_ba98_u64 as u64 as isize, 2);
+
+    check_mul_wraps!(0x80_u8 as i8, -1);
+    check_mul_wraps!(0x8000_u16 as i16, -1);
+    check_mul_wraps!(0x8000_0000_u32 as i32, -1);
+    check_mul_wraps!(0x8000_0000_0000_0000_u64 as i64, -1);
+    match () {
+        #[cfg(target_pointer_width = "32")]
+        () => {
+            check_mul_wraps!(0x8000_0000_u32 as isize, -1);
+        }
+        #[cfg(target_pointer_width = "64")]
+        () => {
+            check_mul_wraps!(0x8000_0000_0000_0000_u64 as isize, -1);
+        }
+    }
+
+    macro_rules! check_div_no_wrap {
+        ($e:expr, $f:expr) => {
+            assert_eq!(($e).wrapping_div($f), ($e) / $f);
+        };
+    }
+    macro_rules! check_div_wraps {
+        ($e:expr, $f:expr) => {
+            assert_eq!(($e).wrapping_div($f), $e);
+        };
+    }
+
+    check_div_no_wrap!(0xfe_u8 as i8, -1);
+    check_div_no_wrap!(0xfedc_u16 as i16, -1);
+    check_div_no_wrap!(0xfedc_ba98_u32 as i32, -1);
+    check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -1);
+    check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -1);
+
+    check_div_no_wrap!(0xfe_u8 as i8, -2);
+    check_div_no_wrap!(0xfedc_u16 as i16, -2);
+    check_div_no_wrap!(0xfedc_ba98_u32 as i32, -2);
+    check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -2);
+    check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -2);
+
+    check_div_no_wrap!(0xfe_u8 as i8, 2);
+    check_div_no_wrap!(0xfedc_u16 as i16, 2);
+    check_div_no_wrap!(0xfedc_ba98_u32 as i32, 2);
+    check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, 2);
+    check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, 2);
+
+    check_div_wraps!(-128 as i8, -1);
+    check_div_wraps!(0x8000_u16 as i16, -1);
+    check_div_wraps!(0x8000_0000_u32 as i32, -1);
+    check_div_wraps!(0x8000_0000_0000_0000_u64 as i64, -1);
+    match () {
+        #[cfg(target_pointer_width = "32")]
+        () => {
+            check_div_wraps!(0x8000_0000_u32 as isize, -1);
+        }
+        #[cfg(target_pointer_width = "64")]
+        () => {
+            check_div_wraps!(0x8000_0000_0000_0000_u64 as isize, -1);
+        }
+    }
+
+    macro_rules! check_rem_no_wrap {
+        ($e:expr, $f:expr) => {
+            assert_eq!(($e).wrapping_rem($f), ($e) % $f);
+        };
+    }
+    macro_rules! check_rem_wraps {
+        ($e:expr, $f:expr) => {
+            assert_eq!(($e).wrapping_rem($f), 0);
+        };
+    }
+
+    check_rem_no_wrap!(0xfe_u8 as i8, -1);
+    check_rem_no_wrap!(0xfedc_u16 as i16, -1);
+    check_rem_no_wrap!(0xfedc_ba98_u32 as i32, -1);
+    check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -1);
+    check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -1);
+
+    check_rem_no_wrap!(0xfe_u8 as i8, -2);
+    check_rem_no_wrap!(0xfedc_u16 as i16, -2);
+    check_rem_no_wrap!(0xfedc_ba98_u32 as i32, -2);
+    check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -2);
+    check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -2);
+
+    check_rem_no_wrap!(0xfe_u8 as i8, 2);
+    check_rem_no_wrap!(0xfedc_u16 as i16, 2);
+    check_rem_no_wrap!(0xfedc_ba98_u32 as i32, 2);
+    check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, 2);
+    check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, 2);
+
+    check_rem_wraps!(0x80_u8 as i8, -1);
+    check_rem_wraps!(0x8000_u16 as i16, -1);
+    check_rem_wraps!(0x8000_0000_u32 as i32, -1);
+    check_rem_wraps!(0x8000_0000_0000_0000_u64 as i64, -1);
+    match () {
+        #[cfg(target_pointer_width = "32")]
+        () => {
+            check_rem_wraps!(0x8000_0000_u32 as isize, -1);
+        }
+        #[cfg(target_pointer_width = "64")]
+        () => {
+            check_rem_wraps!(0x8000_0000_0000_0000_u64 as isize, -1);
+        }
+    }
+
+    macro_rules! check_neg_no_wrap {
+        ($e:expr) => {
+            assert_eq!(($e).wrapping_neg(), -($e));
+        };
+    }
+    macro_rules! check_neg_wraps {
+        ($e:expr) => {
+            assert_eq!(($e).wrapping_neg(), ($e));
+        };
+    }
+
+    check_neg_no_wrap!(0xfe_u8 as i8);
+    check_neg_no_wrap!(0xfedc_u16 as i16);
+    check_neg_no_wrap!(0xfedc_ba98_u32 as i32);
+    check_neg_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64);
+    check_neg_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize);
+
+    check_neg_wraps!(0x80_u8 as i8);
+    check_neg_wraps!(0x8000_u16 as i16);
+    check_neg_wraps!(0x8000_0000_u32 as i32);
+    check_neg_wraps!(0x8000_0000_0000_0000_u64 as i64);
+    match () {
+        #[cfg(target_pointer_width = "32")]
+        () => {
+            check_neg_wraps!(0x8000_0000_u32 as isize);
+        }
+        #[cfg(target_pointer_width = "64")]
+        () => {
+            check_neg_wraps!(0x8000_0000_0000_0000_u64 as isize);
+        }
+    }
+}
diff --git a/library/core/tests/ops.rs b/library/core/tests/ops.rs
index e9d595e65e2..53e5539fad9 100644
--- a/library/core/tests/ops.rs
+++ b/library/core/tests/ops.rs
@@ -1,4 +1,5 @@
 use core::ops::{Bound, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive};
+use core::ops::{Deref, DerefMut};
 
 // Test the Range structs and syntax.
 
@@ -197,3 +198,35 @@ fn range_structural_match() {
         _ => unreachable!(),
     }
 }
+
+// Test Deref implementations
+
+#[test]
+fn deref_mut_on_ref() {
+    // Test that `&mut T` implements `DerefMut<T>`
+
+    fn inc<T: Deref<Target = isize> + DerefMut>(mut t: T) {
+        *t += 1;
+    }
+
+    let mut x: isize = 5;
+    inc(&mut x);
+    assert_eq!(x, 6);
+}
+
+#[test]
+fn deref_on_ref() {
+    // Test that `&T` and `&mut T` implement `Deref<T>`
+
+    fn deref<U: Copy, T: Deref<Target = U>>(t: T) -> U {
+        *t
+    }
+
+    let x: isize = 3;
+    let y = deref(&x);
+    assert_eq!(y, 3);
+
+    let mut x: isize = 4;
+    let y = deref(&mut x);
+    assert_eq!(y, 4);
+}
diff --git a/library/core/tests/option.rs b/library/core/tests/option.rs
index ae814efec20..5388b475624 100644
--- a/library/core/tests/option.rs
+++ b/library/core/tests/option.rs
@@ -402,3 +402,13 @@ fn test_unwrap_drop() {
 
     assert_eq!(x.get(), 0);
 }
+
+#[test]
+pub fn option_ext() {
+    let thing = "{{ f }}";
+    let f = thing.find("{{");
+
+    if f.is_none() {
+        println!("None!");
+    }
+}
diff --git a/library/core/tests/ptr.rs b/library/core/tests/ptr.rs
index 1970b17e267..57c2fb06c16 100644
--- a/library/core/tests/ptr.rs
+++ b/library/core/tests/ptr.rs
@@ -400,3 +400,16 @@ fn align_offset_weird_strides() {
     }
     assert!(!x);
 }
+
+#[test]
+fn offset_from() {
+    let mut a = [0; 5];
+    let ptr1: *mut i32 = &mut a[1];
+    let ptr2: *mut i32 = &mut a[3];
+    unsafe {
+        assert_eq!(ptr2.offset_from(ptr1), 2);
+        assert_eq!(ptr1.offset_from(ptr2), -2);
+        assert_eq!(ptr1.offset(2), ptr2);
+        assert_eq!(ptr2.offset(-2), ptr1);
+    }
+}
diff --git a/library/core/tests/result.rs b/library/core/tests/result.rs
index 39ea4831b9b..81660870e95 100644
--- a/library/core/tests/result.rs
+++ b/library/core/tests/result.rs
@@ -320,3 +320,41 @@ fn result_const() {
     const IS_ERR: bool = RESULT.is_err();
     assert!(!IS_ERR)
 }
+
+#[test]
+fn result_opt_conversions() {
+    #[derive(Copy, Clone, Debug, PartialEq)]
+    struct BadNumErr;
+
+    fn try_num(x: i32) -> Result<i32, BadNumErr> {
+        if x <= 5 { Ok(x + 1) } else { Err(BadNumErr) }
+    }
+
+    type ResOpt = Result<Option<i32>, BadNumErr>;
+    type OptRes = Option<Result<i32, BadNumErr>>;
+
+    let mut x: ResOpt = Ok(Some(5));
+    let mut y: OptRes = Some(Ok(5));
+    assert_eq!(x, y.transpose());
+    assert_eq!(x.transpose(), y);
+
+    x = Ok(None);
+    y = None;
+    assert_eq!(x, y.transpose());
+    assert_eq!(x.transpose(), y);
+
+    x = Err(BadNumErr);
+    y = Some(Err(BadNumErr));
+    assert_eq!(x, y.transpose());
+    assert_eq!(x.transpose(), y);
+
+    let res: Result<Vec<i32>, BadNumErr> = (0..10)
+        .map(|x| {
+            let y = try_num(x)?;
+            Ok(if y % 2 == 0 { Some(y - 1) } else { None })
+        })
+        .filter_map(Result::transpose)
+        .collect();
+
+    assert_eq!(res, Err(BadNumErr))
+}
diff --git a/library/core/tests/unicode.rs b/library/core/tests/unicode.rs
new file mode 100644
index 00000000000..c28ea859115
--- /dev/null
+++ b/library/core/tests/unicode.rs
@@ -0,0 +1,5 @@
+#[test]
+pub fn version() {
+    let (major, _minor, _update) = core::unicode::UNICODE_VERSION;
+    assert!(major >= 10);
+}
diff --git a/library/std/tests/env.rs b/library/std/tests/env.rs
index c94fc41178d..0e55ec648c9 100644
--- a/library/std/tests/env.rs
+++ b/library/std/tests/env.rs
@@ -1,5 +1,6 @@
 use std::env::*;
 use std::ffi::{OsStr, OsString};
+use std::path::PathBuf;
 
 use rand::distributions::Alphanumeric;
 use rand::{thread_rng, Rng};
@@ -76,3 +77,63 @@ fn test_env_set_var() {
 
     assert!(vars_os().any(|(k, v)| { &*k == &*n && &*v == "VALUE" }));
 }
+
+#[test]
+#[cfg_attr(any(target_os = "emscripten", target_env = "sgx"), ignore)]
+#[allow(deprecated)]
+fn env_home_dir() {
+    fn var_to_os_string(var: Result<String, VarError>) -> Option<OsString> {
+        match var {
+            Ok(var) => Some(OsString::from(var)),
+            Err(VarError::NotUnicode(var)) => Some(var),
+            _ => None,
+        }
+    }
+
+    cfg_if::cfg_if! {
+        if #[cfg(unix)] {
+            let oldhome = var_to_os_string(var("HOME"));
+
+            set_var("HOME", "/home/MountainView");
+            assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
+
+            remove_var("HOME");
+            if cfg!(target_os = "android") {
+                assert!(home_dir().is_none());
+            } else {
+                // When HOME is not set, some platforms return `None`,
+                // but others return `Some` with a default.
+                // Just check that it is not "/home/MountainView".
+                assert_ne!(home_dir(), Some(PathBuf::from("/home/MountainView")));
+            }
+
+            if let Some(oldhome) = oldhome { set_var("HOME", oldhome); }
+        } else if #[cfg(windows)] {
+            let oldhome = var_to_os_string(var("HOME"));
+            let olduserprofile = var_to_os_string(var("USERPROFILE"));
+
+            remove_var("HOME");
+            remove_var("USERPROFILE");
+
+            assert!(home_dir().is_some());
+
+            set_var("HOME", "/home/MountainView");
+            assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
+
+            remove_var("HOME");
+
+            set_var("USERPROFILE", "/home/MountainView");
+            assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
+
+            set_var("HOME", "/home/MountainView");
+            set_var("USERPROFILE", "/home/PaloAlto");
+            assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
+
+            remove_var("HOME");
+            remove_var("USERPROFILE");
+
+            if let Some(oldhome) = oldhome { set_var("HOME", oldhome); }
+            if let Some(olduserprofile) = olduserprofile { set_var("USERPROFILE", olduserprofile); }
+        }
+    }
+}
diff --git a/src/test/ui/sleep.rs b/library/std/tests/thread.rs
index f3f8d7259c4..754b264c6ad 100644
--- a/src/test/ui/sleep.rs
+++ b/library/std/tests/thread.rs
@@ -1,17 +1,16 @@
-// run-pass
-// ignore-emscripten no threads support
-
-use std::thread::{self, sleep};
-use std::time::Duration;
 use std::sync::{Arc, Mutex};
+use std::thread;
+use std::time::Duration;
 
-fn main() {
+#[test]
+#[cfg_attr(target_os = "emscripten", ignore)]
+fn sleep() {
     let finished = Arc::new(Mutex::new(false));
     let t_finished = finished.clone();
     thread::spawn(move || {
-        sleep(Duration::new(u64::MAX, 0));
+        thread::sleep(Duration::new(u64::MAX, 0));
         *t_finished.lock().unwrap() = true;
     });
-    sleep(Duration::from_millis(100));
+    thread::sleep(Duration::from_millis(100));
     assert_eq!(*finished.lock().unwrap(), false);
 }
diff --git a/src/test/ui/assert-eq-trailing-comma.rs b/src/test/ui/assert-eq-trailing-comma.rs
deleted file mode 100644
index 7071f80d7f7..00000000000
--- a/src/test/ui/assert-eq-trailing-comma.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-// run-pass
-
-fn main() {
-    assert_eq!(1, 1,);
-}
diff --git a/src/test/ui/assert-escape.rs b/src/test/ui/assert-escape.rs
deleted file mode 100644
index 00e51d42cab..00000000000
--- a/src/test/ui/assert-escape.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-// run-pass
-
-fn main() {
-    assert!(r#"☃\backslash"#.contains("\\"));
-}
diff --git a/src/test/ui/assert-ne-trailing-comma.rs b/src/test/ui/assert-ne-trailing-comma.rs
deleted file mode 100644
index 03308db9a1f..00000000000
--- a/src/test/ui/assert-ne-trailing-comma.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-// run-pass
-
-fn main() {
-    assert_ne!(1, 2,);
-}
diff --git a/src/test/ui/atomic-access-bool.rs b/src/test/ui/atomic-access-bool.rs
deleted file mode 100644
index e9d48bb3b43..00000000000
--- a/src/test/ui/atomic-access-bool.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-// run-pass
-
-#![allow(stable_features)]
-#![feature(atomic_access)]
-use std::sync::atomic::AtomicBool;
-use std::sync::atomic::Ordering::*;
-
-static mut ATOMIC: AtomicBool = AtomicBool::new(false);
-
-fn main() {
-    unsafe {
-        assert_eq!(*ATOMIC.get_mut(), false);
-        ATOMIC.store(true, SeqCst);
-        assert_eq!(*ATOMIC.get_mut(), true);
-        ATOMIC.fetch_or(false, SeqCst);
-        assert_eq!(*ATOMIC.get_mut(), true);
-        ATOMIC.fetch_and(false, SeqCst);
-        assert_eq!(*ATOMIC.get_mut(), false);
-        ATOMIC.fetch_nand(true, SeqCst);
-        assert_eq!(*ATOMIC.get_mut(), true);
-        ATOMIC.fetch_xor(true, SeqCst);
-        assert_eq!(*ATOMIC.get_mut(), false);
-    }
-}
diff --git a/src/test/ui/atomic-alignment.rs b/src/test/ui/atomic-alignment.rs
deleted file mode 100644
index 5bda90d2eab..00000000000
--- a/src/test/ui/atomic-alignment.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-// run-pass
-
-#![feature(cfg_target_has_atomic)]
-#![feature(integer_atomics)]
-
-use std::mem::{align_of, size_of};
-use std::sync::atomic::*;
-
-fn main() {
-    #[cfg(target_has_atomic = "8")]
-    assert_eq!(align_of::<AtomicBool>(), size_of::<AtomicBool>());
-    #[cfg(target_has_atomic = "ptr")]
-    assert_eq!(align_of::<AtomicPtr<u8>>(), size_of::<AtomicPtr<u8>>());
-    #[cfg(target_has_atomic = "8")]
-    assert_eq!(align_of::<AtomicU8>(), size_of::<AtomicU8>());
-    #[cfg(target_has_atomic = "8")]
-    assert_eq!(align_of::<AtomicI8>(), size_of::<AtomicI8>());
-    #[cfg(target_has_atomic = "16")]
-    assert_eq!(align_of::<AtomicU16>(), size_of::<AtomicU16>());
-    #[cfg(target_has_atomic = "16")]
-    assert_eq!(align_of::<AtomicI16>(), size_of::<AtomicI16>());
-    #[cfg(target_has_atomic = "32")]
-    assert_eq!(align_of::<AtomicU32>(), size_of::<AtomicU32>());
-    #[cfg(target_has_atomic = "32")]
-    assert_eq!(align_of::<AtomicI32>(), size_of::<AtomicI32>());
-    #[cfg(target_has_atomic = "64")]
-    assert_eq!(align_of::<AtomicU64>(), size_of::<AtomicU64>());
-    #[cfg(target_has_atomic = "64")]
-    assert_eq!(align_of::<AtomicI64>(), size_of::<AtomicI64>());
-    #[cfg(target_has_atomic = "128")]
-    assert_eq!(align_of::<AtomicU128>(), size_of::<AtomicU128>());
-    #[cfg(target_has_atomic = "128")]
-    assert_eq!(align_of::<AtomicI128>(), size_of::<AtomicI128>());
-    #[cfg(target_has_atomic = "ptr")]
-    assert_eq!(align_of::<AtomicUsize>(), size_of::<AtomicUsize>());
-    #[cfg(target_has_atomic = "ptr")]
-    assert_eq!(align_of::<AtomicIsize>(), size_of::<AtomicIsize>());
-}
diff --git a/src/test/ui/atomic-compare_exchange.rs b/src/test/ui/atomic-compare_exchange.rs
deleted file mode 100644
index 9b327eef3c8..00000000000
--- a/src/test/ui/atomic-compare_exchange.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-// run-pass
-
-#![allow(stable_features)]
-
-#![feature(extended_compare_and_swap)]
-use std::sync::atomic::AtomicIsize;
-use std::sync::atomic::Ordering::*;
-
-static ATOMIC: AtomicIsize = AtomicIsize::new(0);
-
-fn main() {
-    // Make sure codegen can emit all the intrinsics correctly
-    ATOMIC.compare_exchange(0, 1, Relaxed, Relaxed).ok();
-    ATOMIC.compare_exchange(0, 1, Acquire, Relaxed).ok();
-    ATOMIC.compare_exchange(0, 1, Release, Relaxed).ok();
-    ATOMIC.compare_exchange(0, 1, AcqRel, Relaxed).ok();
-    ATOMIC.compare_exchange(0, 1, SeqCst, Relaxed).ok();
-    ATOMIC.compare_exchange(0, 1, Acquire, Acquire).ok();
-    ATOMIC.compare_exchange(0, 1, AcqRel, Acquire).ok();
-    ATOMIC.compare_exchange(0, 1, SeqCst, Acquire).ok();
-    ATOMIC.compare_exchange(0, 1, SeqCst, SeqCst).ok();
-    ATOMIC.compare_exchange_weak(0, 1, Relaxed, Relaxed).ok();
-    ATOMIC.compare_exchange_weak(0, 1, Acquire, Relaxed).ok();
-    ATOMIC.compare_exchange_weak(0, 1, Release, Relaxed).ok();
-    ATOMIC.compare_exchange_weak(0, 1, AcqRel, Relaxed).ok();
-    ATOMIC.compare_exchange_weak(0, 1, SeqCst, Relaxed).ok();
-    ATOMIC.compare_exchange_weak(0, 1, Acquire, Acquire).ok();
-    ATOMIC.compare_exchange_weak(0, 1, AcqRel, Acquire).ok();
-    ATOMIC.compare_exchange_weak(0, 1, SeqCst, Acquire).ok();
-    ATOMIC.compare_exchange_weak(0, 1, SeqCst, SeqCst).ok();
-}
diff --git a/src/test/ui/bool-not.rs b/src/test/ui/bool-not.rs
deleted file mode 100644
index 84713d6818a..00000000000
--- a/src/test/ui/bool-not.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-// run-pass
-
-pub fn main() {
-    if !false { assert!((true)); } else { assert!((false)); }
-    if !true { assert!((false)); } else { assert!((true)); }
-}
diff --git a/src/test/ui/bool.rs b/src/test/ui/bool.rs
deleted file mode 100644
index 92f36c8fd25..00000000000
--- a/src/test/ui/bool.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-// run-pass
-// Basic boolean tests
-
-
-use std::cmp::Ordering::{Equal, Greater, Less};
-use std::ops::{BitAnd, BitOr, BitXor};
-
-fn main() {
-    assert_eq!(false.eq(&true), false);
-    assert_eq!(false == false, true);
-    assert_eq!(false != true, true);
-    assert_eq!(false.ne(&false), false);
-
-    assert_eq!(false.bitand(false), false);
-    assert_eq!(true.bitand(false), false);
-    assert_eq!(false.bitand(true), false);
-    assert_eq!(true.bitand(true), true);
-
-    assert_eq!(false & false, false);
-    assert_eq!(true & false, false);
-    assert_eq!(false & true, false);
-    assert_eq!(true & true, true);
-
-    assert_eq!(false.bitor(false), false);
-    assert_eq!(true.bitor(false), true);
-    assert_eq!(false.bitor(true), true);
-    assert_eq!(true.bitor(true), true);
-
-    assert_eq!(false | false, false);
-    assert_eq!(true | false, true);
-    assert_eq!(false | true, true);
-    assert_eq!(true | true, true);
-
-    assert_eq!(false.bitxor(false), false);
-    assert_eq!(true.bitxor(false), true);
-    assert_eq!(false.bitxor(true), true);
-    assert_eq!(true.bitxor(true), false);
-
-    assert_eq!(false ^ false, false);
-    assert_eq!(true ^ false, true);
-    assert_eq!(false ^ true, true);
-    assert_eq!(true ^ true, false);
-
-    assert_eq!(!true, false);
-    assert_eq!(!false, true);
-
-    let s = false.to_string();
-    assert_eq!(s, "false");
-    let s = true.to_string();
-    assert_eq!(s, "true");
-
-    assert!(true > false);
-    assert!(!(false > true));
-
-    assert!(false < true);
-    assert!(!(true < false));
-
-    assert!(false <= false);
-    assert!(false >= false);
-    assert!(true <= true);
-    assert!(true >= true);
-
-    assert!(false <= true);
-    assert!(!(false >= true));
-    assert!(true >= false);
-    assert!(!(true <= false));
-
-    assert_eq!(true.cmp(&true), Equal);
-    assert_eq!(false.cmp(&false), Equal);
-    assert_eq!(true.cmp(&false), Greater);
-    assert_eq!(false.cmp(&true), Less);
-}
diff --git a/src/test/ui/char_unicode.rs b/src/test/ui/char_unicode.rs
deleted file mode 100644
index 65dda47066f..00000000000
--- a/src/test/ui/char_unicode.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-// run-pass
-
-/// Tests access to the Unicode version constant.
-pub fn main() {
-    check(std::char::UNICODE_VERSION);
-}
-
-pub fn check(unicode_version: (u8, u8, u8)) {
-    assert!(unicode_version.0 >= 10);
-}
diff --git a/src/test/ui/cmp-default.rs b/src/test/ui/cmp-default.rs
deleted file mode 100644
index bb5c39f5cde..00000000000
--- a/src/test/ui/cmp-default.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-// run-pass
-
-use std::cmp::Ordering;
-
-// Test default methods in PartialOrd and PartialEq
-//
-#[derive(Debug)]
-struct Fool(bool);
-
-impl PartialEq for Fool {
-    fn eq(&self, other: &Fool) -> bool {
-        let Fool(this) = *self;
-        let Fool(other) = *other;
-        this != other
-    }
-}
-
-struct Int(isize);
-
-impl PartialEq for Int {
-    fn eq(&self, other: &Int) -> bool {
-        let Int(this) = *self;
-        let Int(other) = *other;
-        this == other
-    }
-}
-
-impl PartialOrd for Int {
-    fn partial_cmp(&self, other: &Int) -> Option<Ordering> {
-        let Int(this) = *self;
-        let Int(other) = *other;
-        this.partial_cmp(&other)
-    }
-}
-
-struct RevInt(isize);
-
-impl PartialEq for RevInt {
-    fn eq(&self, other: &RevInt) -> bool {
-        let RevInt(this) = *self;
-        let RevInt(other) = *other;
-        this == other
-    }
-}
-
-impl PartialOrd for RevInt {
-    fn partial_cmp(&self, other: &RevInt) -> Option<Ordering> {
-        let RevInt(this) = *self;
-        let RevInt(other) = *other;
-        other.partial_cmp(&this)
-    }
-}
-
-pub fn main() {
-    assert!(Int(2) >  Int(1));
-    assert!(Int(2) >= Int(1));
-    assert!(Int(1) >= Int(1));
-    assert!(Int(1) <  Int(2));
-    assert!(Int(1) <= Int(2));
-    assert!(Int(1) <= Int(1));
-
-    assert!(RevInt(2) <  RevInt(1));
-    assert!(RevInt(2) <= RevInt(1));
-    assert!(RevInt(1) <= RevInt(1));
-    assert!(RevInt(1) >  RevInt(2));
-    assert!(RevInt(1) >= RevInt(2));
-    assert!(RevInt(1) >= RevInt(1));
-
-    assert_eq!(Fool(true), Fool(false));
-    assert!(Fool(true)  != Fool(true));
-    assert!(Fool(false) != Fool(false));
-    assert_eq!(Fool(false), Fool(true));
-}
diff --git a/src/test/ui/consts/ascii_ctype.rs b/src/test/ui/consts/ascii_ctype.rs
deleted file mode 100644
index ef2f7322f27..00000000000
--- a/src/test/ui/consts/ascii_ctype.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-// run-pass
-
-macro_rules! suite {
-    ( $( $fn:ident => [$a:ident, $A:ident, $nine:ident, $dot:ident, $space:ident]; )* ) => {
-        $(
-            mod $fn {
-                const CHAR_A_LOWER: bool = 'a'.$fn();
-                const CHAR_A_UPPER: bool = 'A'.$fn();
-                const CHAR_NINE: bool = '9'.$fn();
-                const CHAR_DOT: bool = '.'.$fn();
-                const CHAR_SPACE: bool = ' '.$fn();
-
-                const U8_A_LOWER: bool = b'a'.$fn();
-                const U8_A_UPPER: bool = b'A'.$fn();
-                const U8_NINE: bool = b'9'.$fn();
-                const U8_DOT: bool = b'.'.$fn();
-                const U8_SPACE: bool = b' '.$fn();
-
-                pub fn run() {
-                    assert_eq!(CHAR_A_LOWER, $a);
-                    assert_eq!(CHAR_A_UPPER, $A);
-                    assert_eq!(CHAR_NINE, $nine);
-                    assert_eq!(CHAR_DOT, $dot);
-                    assert_eq!(CHAR_SPACE, $space);
-
-                    assert_eq!(U8_A_LOWER, $a);
-                    assert_eq!(U8_A_UPPER, $A);
-                    assert_eq!(U8_NINE, $nine);
-                    assert_eq!(U8_DOT, $dot);
-                    assert_eq!(U8_SPACE, $space);
-                }
-            }
-        )*
-
-        fn main() {
-            $( $fn::run(); )*
-        }
-    }
-}
-
-suite! {
-    //                        'a'    'A'    '9'    '.'    ' '
-    is_ascii_alphabetic   => [true,  true,  false, false, false];
-    is_ascii_uppercase    => [false, true,  false, false, false];
-    is_ascii_lowercase    => [true,  false, false, false, false];
-    is_ascii_alphanumeric => [true,  true,  true,  false, false];
-    is_ascii_digit        => [false, false, true,  false, false];
-    is_ascii_hexdigit     => [true,  true,  true,  false, false];
-    is_ascii_punctuation  => [false, false, false, true,  false];
-    is_ascii_graphic      => [true,  true,  true,  true,  false];
-    is_ascii_whitespace   => [false, false, false, false, true];
-    is_ascii_control      => [false, false, false, false, false];
-}
diff --git a/src/test/ui/consts/const-str-ptr.rs b/src/test/ui/consts/const-str-ptr.rs
deleted file mode 100644
index 56fd9d9f55f..00000000000
--- a/src/test/ui/consts/const-str-ptr.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-// run-pass
-#![allow(unused_imports)]
-use std::{str, string};
-
-const A: [u8; 2] = ['h' as u8, 'i' as u8];
-const B: &'static [u8; 2] = &A;
-const C: *const u8 = B as *const u8;
-
-pub fn main() {
-    unsafe {
-        let foo = &A as *const u8;
-        assert_eq!(foo, C);
-        assert_eq!(str::from_utf8_unchecked(&A), "hi");
-        assert_eq!(*C, A[0]);
-        assert_eq!(*(&B[0] as *const u8), A[0]);
-    }
-}
diff --git a/src/test/ui/deref-mut-on-ref.rs b/src/test/ui/deref-mut-on-ref.rs
deleted file mode 100644
index a6df5495a27..00000000000
--- a/src/test/ui/deref-mut-on-ref.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-// run-pass
-// Test that `&mut T` implements `DerefMut<T>`
-
-
-use std::ops::{Deref, DerefMut};
-
-fn inc<T: Deref<Target=isize> + DerefMut>(mut t: T) {
-    *t += 1;
-}
-
-fn main() {
-    let mut x: isize = 5;
-    inc(&mut x);
-    assert_eq!(x, 6);
-}
diff --git a/src/test/ui/deref-on-ref.rs b/src/test/ui/deref-on-ref.rs
deleted file mode 100644
index 973e61c9d59..00000000000
--- a/src/test/ui/deref-on-ref.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-// run-pass
-// Test that `&T` and `&mut T` implement `Deref<T>`
-
-
-use std::ops::Deref;
-
-fn deref<U:Copy,T:Deref<Target=U>>(t: T) -> U {
-    *t
-}
-
-fn main() {
-    let x: isize = 3;
-    let y = deref(&x);
-    assert_eq!(y, 3);
-
-    let mut x: isize = 4;
-    let y = deref(&mut x);
-    assert_eq!(y, 4);
-}
diff --git a/src/test/ui/env-home-dir.rs b/src/test/ui/env-home-dir.rs
deleted file mode 100644
index c597b4732d1..00000000000
--- a/src/test/ui/env-home-dir.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-// run-pass
-
-#![allow(unused_variables)]
-#![allow(deprecated)]
-// ignore-emscripten env vars don't work?
-// ignore-sgx env vars cannot be modified
-
-use std::env::*;
-use std::path::PathBuf;
-
-#[cfg(unix)]
-fn main() {
-    let oldhome = var("HOME");
-
-    set_var("HOME", "/home/MountainView");
-    assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
-
-    remove_var("HOME");
-    if cfg!(target_os = "android") {
-        assert!(home_dir().is_none());
-    } else {
-        // When HOME is not set, some platforms return `None`,
-        // but others return `Some` with a default.
-        // Just check that it is not "/home/MountainView".
-        assert_ne!(home_dir(), Some(PathBuf::from("/home/MountainView")));
-    }
-}
-
-#[cfg(windows)]
-fn main() {
-    let oldhome = var("HOME");
-    let olduserprofile = var("USERPROFILE");
-
-    remove_var("HOME");
-    remove_var("USERPROFILE");
-
-    assert!(home_dir().is_some());
-
-    set_var("HOME", "/home/MountainView");
-    assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
-
-    remove_var("HOME");
-
-    set_var("USERPROFILE", "/home/MountainView");
-    assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
-
-    set_var("HOME", "/home/MountainView");
-    set_var("USERPROFILE", "/home/PaloAlto");
-    assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
-}
diff --git a/src/test/ui/extend-for-unit.rs b/src/test/ui/extend-for-unit.rs
deleted file mode 100644
index 01d743f70bc..00000000000
--- a/src/test/ui/extend-for-unit.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-// run-pass
-
-pub fn main() {
-    let mut x = 0;
-    {
-        let iter = (0..5).map(|_| {
-            x += 1;
-        });
-        ().extend(iter);
-    }
-    assert_eq!(x, 5);
-}
diff --git a/src/test/ui/offset_from.rs b/src/test/ui/offset_from.rs
deleted file mode 100644
index aa59c119706..00000000000
--- a/src/test/ui/offset_from.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// run-pass
-
-fn main() {
-    let mut a = [0; 5];
-    let ptr1: *mut i32 = &mut a[1];
-    let ptr2: *mut i32 = &mut a[3];
-    unsafe {
-        assert_eq!(ptr2.offset_from(ptr1), 2);
-        assert_eq!(ptr1.offset_from(ptr2), -2);
-        assert_eq!(ptr1.offset(2), ptr2);
-        assert_eq!(ptr2.offset(-2), ptr1);
-    }
-}
diff --git a/src/test/ui/option-ext.rs b/src/test/ui/option-ext.rs
deleted file mode 100644
index 76d0cf43984..00000000000
--- a/src/test/ui/option-ext.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-// run-pass
-
-pub fn main() {
-    let thing = "{{ f }}";
-    let f = thing.find("{{");
-
-    if f.is_none() {
-        println!("None!");
-    }
-}
diff --git a/src/test/ui/result-opt-conversions.rs b/src/test/ui/result-opt-conversions.rs
deleted file mode 100644
index 57f258aab65..00000000000
--- a/src/test/ui/result-opt-conversions.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-// run-pass
-
-#[derive(Copy, Clone, Debug, PartialEq)]
-struct BadNumErr;
-
-fn try_num(x: i32) -> Result<i32, BadNumErr> {
-    if x <= 5 {
-        Ok(x + 1)
-    } else {
-        Err(BadNumErr)
-    }
-}
-
-type ResOpt = Result<Option<i32>, BadNumErr>;
-type OptRes = Option<Result<i32, BadNumErr>>;
-
-fn main() {
-    let mut x: ResOpt = Ok(Some(5));
-    let mut y: OptRes = Some(Ok(5));
-    assert_eq!(x, y.transpose());
-    assert_eq!(x.transpose(), y);
-
-    x = Ok(None);
-    y = None;
-    assert_eq!(x, y.transpose());
-    assert_eq!(x.transpose(), y);
-
-    x = Err(BadNumErr);
-    y = Some(Err(BadNumErr));
-    assert_eq!(x, y.transpose());
-    assert_eq!(x.transpose(), y);
-
-    let res: Result<Vec<i32>, BadNumErr> =
-        (0..10)
-            .map(|x| {
-                let y = try_num(x)?;
-                Ok(if y % 2 == 0 {
-                    Some(y - 1)
-                } else {
-                    None
-                })
-            })
-            .filter_map(Result::transpose)
-            .collect();
-
-    assert_eq!(res, Err(BadNumErr))
-}
diff --git a/src/test/ui/utf8.rs b/src/test/ui/utf8.rs
deleted file mode 100644
index 75b6ddf7895..00000000000
--- a/src/test/ui/utf8.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-// run-pass
-
-pub fn main() {
-    let yen: char = '¥'; // 0xa5
-    let c_cedilla: char = 'ç'; // 0xe7
-    let thorn: char = 'þ'; // 0xfe
-    let y_diaeresis: char = 'ÿ'; // 0xff
-    let pi: char = 'Π'; // 0x3a0
-
-    assert_eq!(yen as isize, 0xa5);
-    assert_eq!(c_cedilla as isize, 0xe7);
-    assert_eq!(thorn as isize, 0xfe);
-    assert_eq!(y_diaeresis as isize, 0xff);
-    assert_eq!(pi as isize, 0x3a0);
-
-    assert_eq!(pi as isize, '\u{3a0}' as isize);
-    assert_eq!('\x0a' as isize, '\n' as isize);
-
-    let bhutan: String = "འབྲུག་ཡུལ།".to_string();
-    let japan: String = "日本".to_string();
-    let uzbekistan: String = "Ўзбекистон".to_string();
-    let austria: String = "Österreich".to_string();
-
-    let bhutan_e: String =
-        "\u{f60}\u{f56}\u{fb2}\u{f74}\u{f42}\u{f0b}\u{f61}\u{f74}\u{f63}\u{f0d}".to_string();
-    let japan_e: String = "\u{65e5}\u{672c}".to_string();
-    let uzbekistan_e: String =
-        "\u{40e}\u{437}\u{431}\u{435}\u{43a}\u{438}\u{441}\u{442}\u{43e}\u{43d}".to_string();
-    let austria_e: String = "\u{d6}sterreich".to_string();
-
-    let oo: char = 'Ö';
-    assert_eq!(oo as isize, 0xd6);
-
-    fn check_str_eq(a: String, b: String) {
-        let mut i: isize = 0;
-        for ab in a.bytes() {
-            println!("{}", i);
-            println!("{}", ab);
-            let bb: u8 = b.as_bytes()[i as usize];
-            println!("{}", bb);
-            assert_eq!(ab, bb);
-            i += 1;
-        }
-    }
-
-    check_str_eq(bhutan, bhutan_e);
-    check_str_eq(japan, japan_e);
-    check_str_eq(uzbekistan, uzbekistan_e);
-    check_str_eq(austria, austria_e);
-}
diff --git a/src/test/ui/utf8_chars.rs b/src/test/ui/utf8_chars.rs
deleted file mode 100644
index d764509813d..00000000000
--- a/src/test/ui/utf8_chars.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-// run-pass
-
-use std::str;
-
-pub fn main() {
-    // Chars of 1, 2, 3, and 4 bytes
-    let chs: Vec<char> = vec!['e', 'é', '€', '\u{10000}'];
-    let s: String = chs.iter().cloned().collect();
-    let schs: Vec<char> = s.chars().collect();
-
-    assert_eq!(s.len(), 10);
-    assert_eq!(s.chars().count(), 4);
-    assert_eq!(schs.len(), 4);
-    assert_eq!(schs.iter().cloned().collect::<String>(), s);
-
-    assert!((str::from_utf8(s.as_bytes()).is_ok()));
-    // invalid prefix
-    assert!((!str::from_utf8(&[0x80]).is_ok()));
-    // invalid 2 byte prefix
-    assert!((!str::from_utf8(&[0xc0]).is_ok()));
-    assert!((!str::from_utf8(&[0xc0, 0x10]).is_ok()));
-    // invalid 3 byte prefix
-    assert!((!str::from_utf8(&[0xe0]).is_ok()));
-    assert!((!str::from_utf8(&[0xe0, 0x10]).is_ok()));
-    assert!((!str::from_utf8(&[0xe0, 0xff, 0x10]).is_ok()));
-    // invalid 4 byte prefix
-    assert!((!str::from_utf8(&[0xf0]).is_ok()));
-    assert!((!str::from_utf8(&[0xf0, 0x10]).is_ok()));
-    assert!((!str::from_utf8(&[0xf0, 0xff, 0x10]).is_ok()));
-    assert!((!str::from_utf8(&[0xf0, 0xff, 0xff, 0x10]).is_ok()));
-}
diff --git a/src/test/ui/wrapping-int-api.rs b/src/test/ui/wrapping-int-api.rs
deleted file mode 100644
index 6e2fc7f80b9..00000000000
--- a/src/test/ui/wrapping-int-api.rs
+++ /dev/null
@@ -1,225 +0,0 @@
-// run-pass
-// Test inherent wrapping_* methods for {i,u}{size,8,16,32,64}.
-
-// Don't warn about overflowing ops on 32-bit platforms
-#![cfg_attr(target_pointer_width = "32", allow(const_err))]
-
-fn main() {
-    assert_eq!(   i8::MAX.wrapping_add(1),    i8::MIN);
-    assert_eq!(  i16::MAX.wrapping_add(1),   i16::MIN);
-    assert_eq!(  i32::MAX.wrapping_add(1),   i32::MIN);
-    assert_eq!(  i64::MAX.wrapping_add(1),   i64::MIN);
-    assert_eq!(isize::MAX.wrapping_add(1), isize::MIN);
-
-    assert_eq!(   i8::MIN.wrapping_sub(1),    i8::MAX);
-    assert_eq!(  i16::MIN.wrapping_sub(1),   i16::MAX);
-    assert_eq!(  i32::MIN.wrapping_sub(1),   i32::MAX);
-    assert_eq!(  i64::MIN.wrapping_sub(1),   i64::MAX);
-    assert_eq!(isize::MIN.wrapping_sub(1), isize::MAX);
-
-    assert_eq!(   u8::MAX.wrapping_add(1),    u8::MIN);
-    assert_eq!(  u16::MAX.wrapping_add(1),   u16::MIN);
-    assert_eq!(  u32::MAX.wrapping_add(1),   u32::MIN);
-    assert_eq!(  u64::MAX.wrapping_add(1),   u64::MIN);
-    assert_eq!(usize::MAX.wrapping_add(1), usize::MIN);
-
-    assert_eq!(   u8::MIN.wrapping_sub(1),    u8::MAX);
-    assert_eq!(  u16::MIN.wrapping_sub(1),   u16::MAX);
-    assert_eq!(  u32::MIN.wrapping_sub(1),   u32::MAX);
-    assert_eq!(  u64::MIN.wrapping_sub(1),   u64::MAX);
-    assert_eq!(usize::MIN.wrapping_sub(1), usize::MAX);
-
-    assert_eq!((0xfe_u8 as i8).wrapping_mul(16),
-               (0xe0_u8 as i8));
-    assert_eq!((0xfedc_u16 as i16).wrapping_mul(16),
-               (0xedc0_u16 as i16));
-    assert_eq!((0xfedc_ba98_u32 as i32).wrapping_mul(16),
-               (0xedcb_a980_u32 as i32));
-    assert_eq!((0xfedc_ba98_7654_3217_u64 as i64).wrapping_mul(16),
-               (0xedcb_a987_6543_2170_u64 as i64));
-
-    match () {
-        #[cfg(target_pointer_width = "32")]
-        () => {
-            assert_eq!((0xfedc_ba98_u32 as isize).wrapping_mul(16),
-                       (0xedcb_a980_u32 as isize));
-        }
-        #[cfg(target_pointer_width = "64")]
-        () => {
-            assert_eq!((0xfedc_ba98_7654_3217_u64 as isize).wrapping_mul(16),
-                       (0xedcb_a987_6543_2170_u64 as isize));
-        }
-    }
-
-    assert_eq!((0xfe as u8).wrapping_mul(16),
-               (0xe0 as u8));
-    assert_eq!((0xfedc as u16).wrapping_mul(16),
-               (0xedc0 as u16));
-    assert_eq!((0xfedc_ba98 as u32).wrapping_mul(16),
-               (0xedcb_a980 as u32));
-    assert_eq!((0xfedc_ba98_7654_3217 as u64).wrapping_mul(16),
-               (0xedcb_a987_6543_2170 as u64));
-
-    match () {
-        #[cfg(target_pointer_width = "32")]
-        () => {
-            assert_eq!((0xfedc_ba98 as usize).wrapping_mul(16),
-                       (0xedcb_a980 as usize));
-        }
-        #[cfg(target_pointer_width = "64")]
-        () => {
-            assert_eq!((0xfedc_ba98_7654_3217 as usize).wrapping_mul(16),
-                       (0xedcb_a987_6543_2170 as usize));
-        }
-    }
-
-    macro_rules! check_mul_no_wrap {
-        ($e:expr, $f:expr) => { assert_eq!(($e).wrapping_mul($f), ($e) * $f); }
-    }
-    macro_rules! check_mul_wraps {
-        ($e:expr, $f:expr) => { assert_eq!(($e).wrapping_mul($f), $e); }
-    }
-
-    check_mul_no_wrap!(0xfe_u8 as i8, -1);
-    check_mul_no_wrap!(0xfedc_u16 as i16, -1);
-    check_mul_no_wrap!(0xfedc_ba98_u32 as i32, -1);
-    check_mul_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -1);
-    check_mul_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -1);
-
-    check_mul_no_wrap!(0xfe_u8 as i8, -2);
-    check_mul_no_wrap!(0xfedc_u16 as i16, -2);
-    check_mul_no_wrap!(0xfedc_ba98_u32 as i32, -2);
-    check_mul_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -2);
-    check_mul_no_wrap!(0xfedc_ba98_fedc_ba98_u64 as u64 as isize, -2);
-
-    check_mul_no_wrap!(0xfe_u8 as i8, 2);
-    check_mul_no_wrap!(0xfedc_u16 as i16, 2);
-    check_mul_no_wrap!(0xfedc_ba98_u32 as i32, 2);
-    check_mul_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, 2);
-    check_mul_no_wrap!(0xfedc_ba98_fedc_ba98_u64 as u64 as isize, 2);
-
-    check_mul_wraps!(0x80_u8 as i8, -1);
-    check_mul_wraps!(0x8000_u16 as i16, -1);
-    check_mul_wraps!(0x8000_0000_u32 as i32, -1);
-    check_mul_wraps!(0x8000_0000_0000_0000_u64 as i64, -1);
-    match () {
-        #[cfg(target_pointer_width = "32")]
-        () => {
-            check_mul_wraps!(0x8000_0000_u32 as isize, -1);
-        }
-        #[cfg(target_pointer_width = "64")]
-        () => {
-            check_mul_wraps!(0x8000_0000_0000_0000_u64 as isize, -1);
-        }
-    }
-
-    macro_rules! check_div_no_wrap {
-        ($e:expr, $f:expr) => { assert_eq!(($e).wrapping_div($f), ($e) / $f); }
-    }
-    macro_rules! check_div_wraps {
-        ($e:expr, $f:expr) => { assert_eq!(($e).wrapping_div($f), $e); }
-    }
-
-    check_div_no_wrap!(0xfe_u8 as i8, -1);
-    check_div_no_wrap!(0xfedc_u16 as i16, -1);
-    check_div_no_wrap!(0xfedc_ba98_u32 as i32, -1);
-    check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -1);
-    check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -1);
-
-    check_div_no_wrap!(0xfe_u8 as i8, -2);
-    check_div_no_wrap!(0xfedc_u16 as i16, -2);
-    check_div_no_wrap!(0xfedc_ba98_u32 as i32, -2);
-    check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -2);
-    check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -2);
-
-    check_div_no_wrap!(0xfe_u8 as i8, 2);
-    check_div_no_wrap!(0xfedc_u16 as i16, 2);
-    check_div_no_wrap!(0xfedc_ba98_u32 as i32, 2);
-    check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, 2);
-    check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, 2);
-
-    check_div_wraps!(-128 as i8, -1);
-    check_div_wraps!(0x8000_u16 as i16, -1);
-    check_div_wraps!(0x8000_0000_u32 as i32, -1);
-    check_div_wraps!(0x8000_0000_0000_0000_u64 as i64, -1);
-    match () {
-        #[cfg(target_pointer_width = "32")]
-        () => {
-            check_div_wraps!(0x8000_0000_u32 as isize, -1);
-        }
-        #[cfg(target_pointer_width = "64")]
-        () => {
-            check_div_wraps!(0x8000_0000_0000_0000_u64 as isize, -1);
-        }
-    }
-
-
-    macro_rules! check_rem_no_wrap {
-        ($e:expr, $f:expr) => { assert_eq!(($e).wrapping_rem($f), ($e) % $f); }
-    }
-    macro_rules! check_rem_wraps {
-        ($e:expr, $f:expr) => { assert_eq!(($e).wrapping_rem($f), 0); }
-    }
-
-    check_rem_no_wrap!(0xfe_u8 as i8, -1);
-    check_rem_no_wrap!(0xfedc_u16 as i16, -1);
-    check_rem_no_wrap!(0xfedc_ba98_u32 as i32, -1);
-    check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -1);
-    check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -1);
-
-    check_rem_no_wrap!(0xfe_u8 as i8, -2);
-    check_rem_no_wrap!(0xfedc_u16 as i16, -2);
-    check_rem_no_wrap!(0xfedc_ba98_u32 as i32, -2);
-    check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -2);
-    check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -2);
-
-    check_rem_no_wrap!(0xfe_u8 as i8, 2);
-    check_rem_no_wrap!(0xfedc_u16 as i16, 2);
-    check_rem_no_wrap!(0xfedc_ba98_u32 as i32, 2);
-    check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, 2);
-    check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, 2);
-
-    check_rem_wraps!(0x80_u8 as i8, -1);
-    check_rem_wraps!(0x8000_u16 as i16, -1);
-    check_rem_wraps!(0x8000_0000_u32 as i32, -1);
-    check_rem_wraps!(0x8000_0000_0000_0000_u64 as i64, -1);
-    match () {
-        #[cfg(target_pointer_width = "32")]
-        () => {
-            check_rem_wraps!(0x8000_0000_u32 as isize, -1);
-        }
-        #[cfg(target_pointer_width = "64")]
-        () => {
-            check_rem_wraps!(0x8000_0000_0000_0000_u64 as isize, -1);
-        }
-    }
-
-    macro_rules! check_neg_no_wrap {
-        ($e:expr) => { assert_eq!(($e).wrapping_neg(), -($e)); }
-    }
-    macro_rules! check_neg_wraps {
-        ($e:expr) => { assert_eq!(($e).wrapping_neg(),  ($e)); }
-    }
-
-    check_neg_no_wrap!(0xfe_u8 as i8);
-    check_neg_no_wrap!(0xfedc_u16 as i16);
-    check_neg_no_wrap!(0xfedc_ba98_u32 as i32);
-    check_neg_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64);
-    check_neg_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize);
-
-    check_neg_wraps!(0x80_u8 as i8);
-    check_neg_wraps!(0x8000_u16 as i16);
-    check_neg_wraps!(0x8000_0000_u32 as i32);
-    check_neg_wraps!(0x8000_0000_0000_0000_u64 as i64);
-    match () {
-        #[cfg(target_pointer_width = "32")]
-        () => {
-            check_neg_wraps!(0x8000_0000_u32 as isize);
-        }
-        #[cfg(target_pointer_width = "64")]
-        () => {
-            check_neg_wraps!(0x8000_0000_0000_0000_u64 as isize);
-        }
-    }
-
-}