test: Fixup many library unit tests

8 files changed, 29 insertions, 329 deletions

diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs
index 54a3a055768..d0d71a128b6 100644
--- a/src/libstd/collections/hash/map.rs
+++ b/src/libstd/collections/hash/map.rs
@@ -1631,7 +1631,7 @@ mod test_map {
     use super::Entry::{Occupied, Vacant};
     use iter::{range_inclusive, range_step_inclusive, repeat};
     use cell::RefCell;
-    use rand::{weak_rng, Rng};
+    use rand::{thread_rng, Rng};
 
     #[test]
     fn test_create_capacity_zero() {
@@ -2290,7 +2290,7 @@ mod test_map {
         }
 
         let mut m = HashMap::new();
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
 
         // Populate the map with some items.
         for _ in 0..50 {
diff --git a/src/libstd/fs.rs b/src/libstd/fs.rs
index 914830d9dcf..d519e1df13b 100644
--- a/src/libstd/fs.rs
+++ b/src/libstd/fs.rs
@@ -123,7 +123,7 @@ pub struct WalkDir {
 /// Opening a file for both reading and writing, as well as creating it if it
 /// doesn't exist:
 ///
-/// ```
+/// ```no_run
 /// use std::fs::OpenOptions;
 ///
 /// let file = OpenOptions::new()
@@ -1195,7 +1195,8 @@ mod tests {
 
     pub fn tmpdir() -> TempDir {
         let p = env::temp_dir();
-        let ret = p.join(&format!("rust-{}", rand::random::<u32>()));
+        let mut r = rand::thread_rng();
+        let ret = p.join(&format!("rust-{}", r.next_u32()));
         check!(fs::create_dir(&ret));
         TempDir(ret)
     }
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index d613fbe4d42..b2bcbaa7b1c 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -288,7 +288,7 @@ mod rand;
 #[doc(hidden)]
 #[unstable(feature = "rand")]
 pub mod __rand {
-    pub use rand::{thread_rng, Rng};
+    pub use rand::{thread_rng, ThreadRng, Rng};
 }
 
 // Modules that exist purely to document + host impl docs for primitive types
diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs
index ea869ebae10..8ab66f2328f 100644
--- a/src/libstd/num/strconv.rs
+++ b/src/libstd/num/strconv.rs
@@ -464,7 +464,7 @@ mod bench {
 
     mod usize {
         use super::test::Bencher;
-        use rand::{weak_rng, Rng};
+        use rand::{thread_rng, Rng};
         use std::fmt;
 
         #[inline]
@@ -474,38 +474,38 @@ mod bench {
 
         #[bench]
         fn to_str_bin(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = thread_rng();
             b.iter(|| { to_string(rng.gen::<usize>(), 2); })
         }
 
         #[bench]
         fn to_str_oct(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = thread_rng();
             b.iter(|| { to_string(rng.gen::<usize>(), 8); })
         }
 
         #[bench]
         fn to_str_dec(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = thread_rng();
             b.iter(|| { to_string(rng.gen::<usize>(), 10); })
         }
 
         #[bench]
         fn to_str_hex(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = thread_rng();
             b.iter(|| { to_string(rng.gen::<usize>(), 16); })
         }
 
         #[bench]
         fn to_str_base_36(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = thread_rng();
             b.iter(|| { to_string(rng.gen::<usize>(), 36); })
         }
     }
 
     mod isize {
         use super::test::Bencher;
-        use rand::{weak_rng, Rng};
+        use rand::{thread_rng, Rng};
         use std::fmt;
 
         #[inline]
@@ -515,43 +515,43 @@ mod bench {
 
         #[bench]
         fn to_str_bin(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = thread_rng();
             b.iter(|| { to_string(rng.gen::<isize>(), 2); })
         }
 
         #[bench]
         fn to_str_oct(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = thread_rng();
             b.iter(|| { to_string(rng.gen::<isize>(), 8); })
         }
 
         #[bench]
         fn to_str_dec(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = thread_rng();
             b.iter(|| { to_string(rng.gen::<isize>(), 10); })
         }
 
         #[bench]
         fn to_str_hex(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = thread_rng();
             b.iter(|| { to_string(rng.gen::<isize>(), 16); })
         }
 
         #[bench]
         fn to_str_base_36(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = thread_rng();
             b.iter(|| { to_string(rng.gen::<isize>(), 36); })
         }
     }
 
     mod f64 {
         use super::test::Bencher;
-        use rand::{weak_rng, Rng};
+        use rand::{thread_rng, Rng};
         use f64;
 
         #[bench]
         fn float_to_string(b: &mut Bencher) {
-            let mut rng = weak_rng();
+            let mut rng = thread_rng();
             b.iter(|| { f64::to_string(rng.gen()); })
         }
     }
diff --git a/src/libstd/process.rs b/src/libstd/process.rs
index cac1540d0ec..a92c6318c32 100644
--- a/src/libstd/process.rs
+++ b/src/libstd/process.rs
@@ -534,8 +534,6 @@ mod tests {
     use io::prelude::*;
 
     use io::ErrorKind;
-    use old_path::{self, GenericPath};
-    use old_io::fs::PathExtensions;
     use rt::running_on_valgrind;
     use str;
     use super::{Command, Output, Stdio};
@@ -748,43 +746,6 @@ mod tests {
         cmd
     }
 
-    #[cfg(not(target_arch = "aarch64"))]
-    #[test]
-    fn test_keep_current_working_dir() {
-        use os;
-        let prog = pwd_cmd().spawn().unwrap();
-
-        let output = String::from_utf8(prog.wait_with_output().unwrap().stdout).unwrap();
-        let parent_dir = ::env::current_dir().unwrap().to_str().unwrap().to_string();
-        let parent_dir = old_path::Path::new(parent_dir);
-        let child_dir = old_path::Path::new(output.trim());
-
-        let parent_stat = parent_dir.stat().unwrap();
-        let child_stat = child_dir.stat().unwrap();
-
-        assert_eq!(parent_stat.unstable.device, child_stat.unstable.device);
-        assert_eq!(parent_stat.unstable.inode, child_stat.unstable.inode);
-    }
-
-    #[test]
-    fn test_change_working_directory() {
-        use os;
-        // test changing to the parent of os::getcwd() because we know
-        // the path exists (and os::getcwd() is not expected to be root)
-        let parent_dir = ::env::current_dir().unwrap().to_str().unwrap().to_string();
-        let parent_dir = old_path::Path::new(parent_dir).dir_path();
-        let result = pwd_cmd().current_dir(parent_dir.as_str().unwrap()).output().unwrap();
-
-        let output = String::from_utf8(result.stdout).unwrap();
-        let child_dir = old_path::Path::new(output.trim());
-
-        let parent_stat = parent_dir.stat().unwrap();
-        let child_stat = child_dir.stat().unwrap();
-
-        assert_eq!(parent_stat.unstable.device, child_stat.unstable.device);
-        assert_eq!(parent_stat.unstable.inode, child_stat.unstable.inode);
-    }
-
     #[cfg(all(unix, not(target_os="android")))]
     pub fn env_cmd() -> Command {
         Command::new("env")
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index 9800a252777..ca5a50f289a 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -354,261 +354,3 @@ impl Rng for ThreadRng {
         self.rng.borrow_mut().fill_bytes(bytes)
     }
 }
-
-#[cfg(test)]
-mod test {
-    use prelude::v1::*;
-    use super::{Rng, thread_rng, random, SeedableRng, StdRng, sample};
-    use iter::{order, repeat};
-
-    struct ConstRng { i: u64 }
-    impl Rng for ConstRng {
-        fn next_u32(&mut self) -> u32 { self.i as u32 }
-        fn next_u64(&mut self) -> u64 { self.i }
-
-        // no fill_bytes on purpose
-    }
-
-    #[test]
-    fn test_fill_bytes_default() {
-        let mut r = ConstRng { i: 0x11_22_33_44_55_66_77_88 };
-
-        // check every remainder mod 8, both in small and big vectors.
-        let lengths = [0, 1, 2, 3, 4, 5, 6, 7,
-                       80, 81, 82, 83, 84, 85, 86, 87];
-        for &n in &lengths {
-            let mut v = repeat(0).take(n).collect::<Vec<_>>();
-            r.fill_bytes(&mut v);
-
-            // use this to get nicer error messages.
-            for (i, &byte) in v.iter().enumerate() {
-                if byte == 0 {
-                    panic!("byte {} of {} is zero", i, n)
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn test_gen_range() {
-        let mut r = thread_rng();
-        for _ in 0..1000 {
-            let a = r.gen_range(-3, 42);
-            assert!(a >= -3 && a < 42);
-            assert_eq!(r.gen_range(0, 1), 0);
-            assert_eq!(r.gen_range(-12, -11), -12);
-        }
-
-        for _ in 0..1000 {
-            let a = r.gen_range(10, 42);
-            assert!(a >= 10 && a < 42);
-            assert_eq!(r.gen_range(0, 1), 0);
-            assert_eq!(r.gen_range(3_000_000, 3_000_001), 3_000_000);
-        }
-
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_gen_range_panic_int() {
-        let mut r = thread_rng();
-        r.gen_range(5, -2);
-    }
-
-    #[test]
-    #[should_panic]
-    fn test_gen_range_panic_uint() {
-        let mut r = thread_rng();
-        r.gen_range(5, 2);
-    }
-
-    #[test]
-    fn test_gen_f64() {
-        let mut r = thread_rng();
-        let a = r.gen::<f64>();
-        let b = r.gen::<f64>();
-        debug!("{:?}", (a, b));
-    }
-
-    #[test]
-    fn test_gen_weighted_bool() {
-        let mut r = thread_rng();
-        assert_eq!(r.gen_weighted_bool(0), true);
-        assert_eq!(r.gen_weighted_bool(1), true);
-    }
-
-    #[test]
-    fn test_gen_ascii_str() {
-        let mut r = thread_rng();
-        assert_eq!(r.gen_ascii_chars().take(0).count(), 0);
-        assert_eq!(r.gen_ascii_chars().take(10).count(), 10);
-        assert_eq!(r.gen_ascii_chars().take(16).count(), 16);
-    }
-
-    #[test]
-    fn test_gen_vec() {
-        let mut r = thread_rng();
-        assert_eq!(r.gen_iter::<u8>().take(0).count(), 0);
-        assert_eq!(r.gen_iter::<u8>().take(10).count(), 10);
-        assert_eq!(r.gen_iter::<f64>().take(16).count(), 16);
-    }
-
-    #[test]
-    fn test_choose() {
-        let mut r = thread_rng();
-        assert_eq!(r.choose(&[1, 1, 1]).cloned(), Some(1));
-
-        let v: &[isize] = &[];
-        assert_eq!(r.choose(v), None);
-    }
-
-    #[test]
-    fn test_shuffle() {
-        let mut r = thread_rng();
-        let empty: &mut [isize] = &mut [];
-        r.shuffle(empty);
-        let mut one = [1];
-        r.shuffle(&mut one);
-        let b: &[_] = &[1];
-        assert_eq!(one, b);
-
-        let mut two = [1, 2];
-        r.shuffle(&mut two);
-        assert!(two == [1, 2] || two == [2, 1]);
-
-        let mut x = [1, 1, 1];
-        r.shuffle(&mut x);
-        let b: &[_] = &[1, 1, 1];
-        assert_eq!(x, b);
-    }
-
-    #[test]
-    fn test_thread_rng() {
-        let mut r = thread_rng();
-        r.gen::<isize>();
-        let mut v = [1, 1, 1];
-        r.shuffle(&mut v);
-        let b: &[_] = &[1, 1, 1];
-        assert_eq!(v, b);
-        assert_eq!(r.gen_range(0, 1), 0);
-    }
-
-    #[test]
-    fn test_random() {
-        // not sure how to test this aside from just getting some values
-        let _n : usize = random();
-        let _f : f32 = random();
-        let _o : Option<Option<i8>> = random();
-        let _many : ((),
-                     (usize,
-                      isize,
-                      Option<(u32, (bool,))>),
-                     (u8, i8, u16, i16, u32, i32, u64, i64),
-                     (f32, (f64, (f64,)))) = random();
-    }
-
-    #[test]
-    fn test_sample() {
-        let min_val = 1;
-        let max_val = 100;
-
-        let mut r = thread_rng();
-        let vals = (min_val..max_val).collect::<Vec<isize>>();
-        let small_sample = sample(&mut r, vals.iter(), 5);
-        let large_sample = sample(&mut r, vals.iter(), vals.len() + 5);
-
-        assert_eq!(small_sample.len(), 5);
-        assert_eq!(large_sample.len(), vals.len());
-
-        assert!(small_sample.iter().all(|e| {
-            **e >= min_val && **e <= max_val
-        }));
-    }
-
-    #[test]
-    fn test_std_rng_seeded() {
-        let s = thread_rng().gen_iter::<usize>().take(256).collect::<Vec<usize>>();
-        let mut ra: StdRng = SeedableRng::from_seed(&*s);
-        let mut rb: StdRng = SeedableRng::from_seed(&*s);
-        assert!(order::equals(ra.gen_ascii_chars().take(100),
-                              rb.gen_ascii_chars().take(100)));
-    }
-
-    #[test]
-    fn test_std_rng_reseed() {
-        let s = thread_rng().gen_iter::<usize>().take(256).collect::<Vec<usize>>();
-        let mut r: StdRng = SeedableRng::from_seed(&*s);
-        let string1 = r.gen_ascii_chars().take(100).collect::<String>();
-
-        r.reseed(&s);
-
-        let string2 = r.gen_ascii_chars().take(100).collect::<String>();
-        assert_eq!(string1, string2);
-    }
-}
-
-#[cfg(test)]
-mod bench {
-    extern crate test;
-    use prelude::v1::*;
-
-    use self::test::Bencher;
-    use super::{XorShiftRng, StdRng, IsaacRng, Isaac64Rng, Rng};
-    use super::{OsRng, weak_rng};
-    use mem::size_of;
-
-    const RAND_BENCH_N: u64 = 100;
-
-    #[bench]
-    fn rand_xorshift(b: &mut Bencher) {
-        let mut rng: XorShiftRng = OsRng::new().unwrap().gen();
-        b.iter(|| {
-            for _ in 0..RAND_BENCH_N {
-                rng.gen::<usize>();
-            }
-        });
-        b.bytes = size_of::<usize>() as u64 * RAND_BENCH_N;
-    }
-
-    #[bench]
-    fn rand_isaac(b: &mut Bencher) {
-        let mut rng: IsaacRng = OsRng::new().unwrap().gen();
-        b.iter(|| {
-            for _ in 0..RAND_BENCH_N {
-                rng.gen::<usize>();
-            }
-        });
-        b.bytes = size_of::<usize>() as u64 * RAND_BENCH_N;
-    }
-
-    #[bench]
-    fn rand_isaac64(b: &mut Bencher) {
-        let mut rng: Isaac64Rng = OsRng::new().unwrap().gen();
-        b.iter(|| {
-            for _ in 0..RAND_BENCH_N {
-                rng.gen::<usize>();
-            }
-        });
-        b.bytes = size_of::<usize>() as u64 * RAND_BENCH_N;
-    }
-
-    #[bench]
-    fn rand_std(b: &mut Bencher) {
-        let mut rng = StdRng::new().unwrap();
-        b.iter(|| {
-            for _ in 0..RAND_BENCH_N {
-                rng.gen::<usize>();
-            }
-        });
-        b.bytes = size_of::<usize>() as u64 * RAND_BENCH_N;
-    }
-
-    #[bench]
-    fn rand_shuffle_100(b: &mut Bencher) {
-        let mut rng = weak_rng();
-        let x : &mut[usize] = &mut [1; 100];
-        b.iter(|| {
-            rng.shuffle(x);
-        })
-    }
-}
diff --git a/src/libstd/rand/reader.rs b/src/libstd/rand/reader.rs
index 3d0055b43c7..60645707c6a 100644
--- a/src/libstd/rand/reader.rs
+++ b/src/libstd/rand/reader.rs
@@ -67,17 +67,16 @@ mod test {
     use prelude::v1::*;
 
     use super::ReaderRng;
-    use old_io::MemReader;
     use num::Int;
     use rand::Rng;
 
     #[test]
     fn test_reader_rng_u64() {
         // transmute from the target to avoid endianness concerns.
-        let v = vec![0, 0, 0, 0, 0, 0, 0, 1,
-                     0  , 0, 0, 0, 0, 0, 0, 2,
-                     0,   0, 0, 0, 0, 0, 0, 3];
-        let mut rng = ReaderRng::new(MemReader::new(v));
+        let v = &[0, 0, 0, 0, 0, 0, 0, 1,
+                  0  , 0, 0, 0, 0, 0, 0, 2,
+                  0,   0, 0, 0, 0, 0, 0, 3][..];
+        let mut rng = ReaderRng::new(v);
 
         assert_eq!(rng.next_u64(), 1.to_be());
         assert_eq!(rng.next_u64(), 2.to_be());
@@ -85,8 +84,8 @@ mod test {
     }
     #[test]
     fn test_reader_rng_u32() {
-        let v = vec![0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3];
-        let mut rng = ReaderRng::new(MemReader::new(v));
+        let v = &[0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3][..];
+        let mut rng = ReaderRng::new(v);
 
         assert_eq!(rng.next_u32(), 1.to_be());
         assert_eq!(rng.next_u32(), 2.to_be());
@@ -97,7 +96,7 @@ mod test {
         let v = [1, 2, 3, 4, 5, 6, 7, 8];
         let mut w = [0; 8];
 
-        let mut rng = ReaderRng::new(MemReader::new(v.to_vec()));
+        let mut rng = ReaderRng::new(&v[..]);
         rng.fill_bytes(&mut w);
 
         assert!(v == w);
@@ -106,7 +105,7 @@ mod test {
     #[test]
     #[should_panic]
     fn test_reader_rng_insufficient_bytes() {
-        let mut rng = ReaderRng::new(MemReader::new(vec!()));
+        let mut rng = ReaderRng::new(&[][..]);
         let mut v = [0; 3];
         rng.fill_bytes(&mut v);
     }
diff --git a/src/libstd/thread/mod.rs b/src/libstd/thread/mod.rs
index 0e5fee27ffe..c47e2389432 100644
--- a/src/libstd/thread/mod.rs
+++ b/src/libstd/thread/mod.rs
@@ -728,7 +728,6 @@ mod test {
     use any::Any;
     use sync::mpsc::{channel, Sender};
     use result;
-    use std::old_io::{ChanReader, ChanWriter};
     use super::{Builder};
     use thread;
     use thunk::Thunk;
@@ -967,13 +966,11 @@ mod test {
 
     #[test]
     fn test_park_timeout_unpark_called_other_thread() {
-        use std::old_io;
-
         for _ in 0..10 {
             let th = thread::current();
 
             let _guard = thread::spawn(move || {
-                old_io::timer::sleep(Duration::milliseconds(50));
+                super::sleep_ms(50);
                 th.unpark();
             });