test: Fixup many library unit tests

Author: alexcrichton

src/libcollections/linked_list.rs

@@ -943,7 +943,7 @@ mod test {
     use std::clone::Clone;
     use std::iter::Iterator;
     use std::option::Option::{Some, None, self};
-    use std::rand;
+    use std::__rand::{thread_rng, Rng};
     use std::thread;
     use std::vec::Vec;
 
@@ -1095,7 +1095,7 @@ mod test {
         let mut v = vec![];
         for i in 0..sz {
             check_links(&m);
-            let r: u8 = rand::random();
+            let r: u8 = thread_rng().next_u32() as u8;
             match r % 6 {
                 0 => {
                     m.pop_back();

src/libcollectionstest/bench.rs

@@ -12,14 +12,13 @@ macro_rules! map_insert_rand_bench {
     ($name: ident, $n: expr, $map: ident) => (
         #[bench]
         pub fn $name(b: &mut ::test::Bencher) {
-            use std::rand;
-            use std::rand::Rng;
+            use std::__rand::{thread_rng, Rng};
             use test::black_box;
 
             let n: usize = $n;
             let mut map = $map::new();
             // setup
-            let mut rng = rand::weak_rng();
+            let mut rng = thread_rng();
 
             for _ in 0..n {
                 let i = rng.gen::<usize>() % n;
@@ -67,16 +66,15 @@ macro_rules! map_find_rand_bench {
         #[bench]
         pub fn $name(b: &mut ::test::Bencher) {
             use std::iter::Iterator;
-            use std::rand::Rng;
-            use std::rand;
+            use std::__rand::{thread_rng, Rng};
             use std::vec::Vec;
             use test::black_box;
 
             let mut map = $map::new();
             let n: usize = $n;
 
             // setup
-            let mut rng = rand::weak_rng();
+            let mut rng = rand::thread_rng();
             let mut keys: Vec<_> = (0..n).map(|_| rng.gen::<usize>() % n).collect();
 
             for &k in &keys {

src/libcollectionstest/bit/vec.rs

@@ -633,15 +633,14 @@ fn test_bit_vec_extend() {
 mod bench {
     use std::collections::BitVec;
     use std::u32;
-    use std::rand::{Rng, self};
+    use std::__rand::{Rng, thread_rng};
 
     use test::{Bencher, black_box};
 
     const BENCH_BITS : usize = 1 << 14;
 
-    fn rng() -> rand::IsaacRng {
-        let seed: &[_] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
-        rand::SeedableRng::from_seed(seed)
+    fn rng() -> ThreadRng {
+        thread_rng()
     }
 
     #[bench]

src/libcollectionstest/btree/map.rs

@@ -251,7 +251,7 @@ fn test_entry(){
 
 mod bench {
     use std::collections::BTreeMap;
-    use std::rand::{Rng, weak_rng};
+    use std::rand::{Rng, thread_rng};
 
     use test::{Bencher, black_box};
 
@@ -269,7 +269,7 @@ mod bench {
 
     fn bench_iter(b: &mut Bencher, size: i32) {
         let mut map = BTreeMap::<i32, i32>::new();
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
 
         for _ in 0..size {
             map.insert(rng.gen(), rng.gen());

src/libcollectionstest/slice.rs

@@ -1296,7 +1296,7 @@ fn test_to_vec() {
 mod bench {
     use std::iter::repeat;
     use std::{mem, ptr};
-    use std::rand::{Rng, weak_rng};
+    use std::rand::{Rng, thread_rng};
 
     use test::{Bencher, black_box};
 
@@ -1465,7 +1465,7 @@ mod bench {
 
     #[bench]
     fn random_inserts(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| {
             let mut v: Vec<_> = repeat((0, 0)).take(30).collect();
             for _ in 0..100 {
@@ -1477,7 +1477,7 @@ mod bench {
     }
     #[bench]
     fn random_removes(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| {
             let mut v: Vec<_> = repeat((0, 0)).take(130).collect();
             for _ in 0..100 {
@@ -1489,7 +1489,7 @@ mod bench {
 
     #[bench]
     fn sort_random_small(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| {
             let mut v: Vec<_> = rng.gen_iter::<u64>().take(5).collect();
             v.sort();
@@ -1499,7 +1499,7 @@ mod bench {
 
     #[bench]
     fn sort_random_medium(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| {
             let mut v: Vec<_> = rng.gen_iter::<u64>().take(100).collect();
             v.sort();
@@ -1509,7 +1509,7 @@ mod bench {
 
     #[bench]
     fn sort_random_large(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| {
             let mut v: Vec<_> = rng.gen_iter::<u64>().take(10000).collect();
             v.sort();
@@ -1530,7 +1530,7 @@ mod bench {
 
     #[bench]
     fn sort_big_random_small(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| {
             let mut v = rng.gen_iter::<BigSortable>().take(5)
                            .collect::<Vec<BigSortable>>();
@@ -1541,7 +1541,7 @@ mod bench {
 
     #[bench]
     fn sort_big_random_medium(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| {
             let mut v = rng.gen_iter::<BigSortable>().take(100)
                            .collect::<Vec<BigSortable>>();
@@ -1552,7 +1552,7 @@ mod bench {
 
     #[bench]
     fn sort_big_random_large(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| {
             let mut v = rng.gen_iter::<BigSortable>().take(10000)
                            .collect::<Vec<BigSortable>>();

src/libcoretest/fmt/num.rs

@@ -169,85 +169,85 @@ fn test_radix_base_too_large() {
 mod u32 {
     use test::Bencher;
     use core::fmt::radix;
-    use std::rand::{weak_rng, Rng};
+    use std::__rand::{thread_rng, Rng};
     use std::io::{Write, sink};
 
     #[bench]
     fn format_bin(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| { write!(&mut sink(), "{:b}", rng.gen::<u32>()) })
     }
 
     #[bench]
     fn format_oct(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| { write!(&mut sink(), "{:o}", rng.gen::<u32>()) })
     }
 
     #[bench]
     fn format_dec(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| { write!(&mut sink(), "{}", rng.gen::<u32>()) })
     }
 
     #[bench]
     fn format_hex(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| { write!(&mut sink(), "{:x}", rng.gen::<u32>()) })
     }
 
     #[bench]
     fn format_show(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| { write!(&mut sink(), "{:?}", rng.gen::<u32>()) })
     }
 
     #[bench]
     fn format_base_36(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| { write!(&mut sink(), "{}", radix(rng.gen::<u32>(), 36)) })
     }
 }
 
 mod i32 {
     use test::Bencher;
     use core::fmt::radix;
-    use std::rand::{weak_rng, Rng};
+    use std::__rand::{thread_rng, Rng};
     use std::io::{Write, sink};
 
     #[bench]
     fn format_bin(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| { write!(&mut sink(), "{:b}", rng.gen::<i32>()) })
     }
 
     #[bench]
     fn format_oct(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| { write!(&mut sink(), "{:o}", rng.gen::<i32>()) })
     }
 
     #[bench]
     fn format_dec(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| { write!(&mut sink(), "{}", rng.gen::<i32>()) })
     }
 
     #[bench]
     fn format_hex(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| { write!(&mut sink(), "{:x}", rng.gen::<i32>()) })
     }
 
     #[bench]
     fn format_show(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| { write!(&mut sink(), "{:?}", rng.gen::<i32>()) })
     }
 
     #[bench]
     fn format_base_36(b: &mut Bencher) {
-        let mut rng = weak_rng();
+        let mut rng = thread_rng();
         b.iter(|| { write!(&mut sink(), "{}", radix(rng.gen::<i32>(), 36)) })
     }
 }

src/libflate/lib.rs

@@ -155,12 +155,11 @@ pub fn inflate_bytes_zlib(bytes: &[u8]) -> Result<Bytes,Error> {
 mod tests {
     #![allow(deprecated)]
     use super::{inflate_bytes, deflate_bytes};
-    use std::rand;
-    use std::rand::Rng;
+    use std::__rand::{thread_rng, Rng};
 
     #[test]
     fn test_flate_round_trip() {
-        let mut r = rand::thread_rng();
+        let mut r = thread_rng();
         let mut words = vec![];
         for _ in 0..20 {
             let range = r.gen_range(1, 10);

src/librand/lib.rs

@@ -516,25 +516,21 @@ pub struct Closed01<F>(pub F);
 
 #[cfg(test)]
 mod test {
-    use std::rand;
+    use std::__rand as rand;
 
-    pub struct MyRng<R> { inner: R }
+    pub struct MyRng { inner: Box<rand::Rng> }
 
     impl<R: rand::Rng> ::Rng for MyRng<R> {
         fn next_u32(&mut self) -> u32 {
-            fn next<T: rand::Rng>(t: &mut T) -> u32 {
-                use std::rand::Rng;
-                t.next_u32()
-            }
-            next(&mut self.inner)
+            rand::Rng::next_u32(&mut self.inner)
         }
     }
 
     pub fn rng() -> MyRng<rand::ThreadRng> {
-        MyRng { inner: rand::thread_rng() }
+        MyRng { inner: Box::new(rand::thread_rng()) }
     }
 
-    pub fn weak_rng() -> MyRng<rand::XorShiftRng> {
-        MyRng { inner: rand::weak_rng() }
+    pub fn weak_rng() -> MyRng<rand::ThreadRng> {
+        MyRng { inner: Box::new(rand::thread_rng()) }
     }
 }

src/librand/rand_impls.rs

@@ -211,55 +211,3 @@ impl<T:Rand> Rand for Option<T> {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use std::rand::{Rng, thread_rng, Open01, Closed01};
-
-    struct ConstantRng(u64);
-    impl Rng for ConstantRng {
-        fn next_u32(&mut self) -> u32 {
-            let ConstantRng(v) = *self;
-            v as u32
-        }
-        fn next_u64(&mut self) -> u64 {
-            let ConstantRng(v) = *self;
-            v
-        }
-    }
-
-    #[test]
-    fn floating_point_edge_cases() {
-        // the test for exact equality is correct here.
-        assert!(ConstantRng(0xffff_ffff).gen::<f32>() != 1.0);
-        assert!(ConstantRng(0xffff_ffff_ffff_ffff).gen::<f64>() != 1.0);
-    }
-
-    #[test]
-    fn rand_open() {
-        // this is unlikely to catch an incorrect implementation that
-        // generates exactly 0 or 1, but it keeps it sane.
-        let mut rng = thread_rng();
-        for _ in 0..1_000 {
-            // strict inequalities
-            let Open01(f) = rng.gen::<Open01<f64>>();
-            assert!(0.0 < f && f < 1.0);
-
-            let Open01(f) = rng.gen::<Open01<f32>>();
-            assert!(0.0 < f && f < 1.0);
-        }
-    }
-
-    #[test]
-    fn rand_closed() {
-        let mut rng = thread_rng();
-        for _ in 0..1_000 {
-            // strict inequalities
-            let Closed01(f) = rng.gen::<Closed01<f64>>();
-            assert!(0.0 <= f && f <= 1.0);
-
-            let Closed01(f) = rng.gen::<Closed01<f32>>();
-            assert!(0.0 <= f && f <= 1.0);
-        }
-    }
-}

src/librustc_back/fs.rs

@@ -68,7 +68,7 @@ pub fn realpath(original: &Path) -> io::Result<PathBuf> {
 mod test {
     use tempdir::TempDir;
     use std::fs::{self, File};
-    use std::path::{Path, PathBuf};
+    use super::realpath;
 
     #[test]
     fn realpath_works() {