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

23 files changed, 0 insertions, 828 deletions

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/sleep.rs b/src/test/ui/sleep.rs
deleted file mode 100644
index f3f8d7259c4..00000000000
--- a/src/test/ui/sleep.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-// run-pass
-// ignore-emscripten no threads support
-
-use std::thread::{self, sleep};
-use std::time::Duration;
-use std::sync::{Arc, Mutex};
-
-fn main() {
-    let finished = Arc::new(Mutex::new(false));
-    let t_finished = finished.clone();
-    thread::spawn(move || {
-        sleep(Duration::new(u64::MAX, 0));
-        *t_finished.lock().unwrap() = true;
-    });
-    sleep(Duration::from_millis(100));
-    assert_eq!(*finished.lock().unwrap(), false);
-}
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);
-        }
-    }
-
-}