More test fixes

Author: alexcrichton

src/compiletest/compiletest.rs

@@ -17,9 +17,11 @@
 #![feature(test)]
 #![feature(path_ext)]
 #![feature(str_char)]
+#![feature(libc)]
 
 #![deny(warnings)]
 
+extern crate libc;
 extern crate test;
 extern crate getopts;
 
@@ -244,7 +246,7 @@ pub fn run_tests(config: &Config) {
     // sadly osx needs some file descriptor limits raised for running tests in
     // parallel (especially when we have lots and lots of child processes).
     // For context, see #8904
-    raise_fd_limit::raise_fd_limit();
+    unsafe { raise_fd_limit::raise_fd_limit(); }
     // Prevent issue #21352 UAC blocking .exe containing 'patch' etc. on Windows
     // If #11207 is resolved (adding manifest to .exe) this becomes unnecessary
     env::set_var("__COMPAT_LAYER", "RunAsInvoker");

src/compiletest/raise_fd_limit.rs

@@ -1,3 +1,13 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
 /// darwin_fd_limit exists to work around an issue where launchctl on Mac OS X
 /// defaults the rlimit maxfiles to 256/unlimited. The default soft limit of 256
 /// ends up being far too low for our multithreaded scheduler testing, depending
@@ -6,10 +16,15 @@
 /// This fixes issue #7772.
 #[cfg(any(target_os = "macos", target_os = "ios"))]
 #[allow(non_camel_case_types)]
-pub fn raise_fd_limit() {
+pub unsafe fn raise_fd_limit() {
     use libc;
+    use std::cmp;
+    use std::io;
+    use std::mem::size_of_val;
+    use std::ptr::null_mut;
 
     type rlim_t = libc::uint64_t;
+
     #[repr(C)]
     struct rlimit {
         rlim_cur: rlim_t,
@@ -31,9 +46,6 @@ pub fn raise_fd_limit() {
     // The strategy here is to fetch the current resource limits, read the
     // kern.maxfilesperproc sysctl value, and bump the soft resource limit for
     // maxfiles up to the sysctl value.
-    use ptr::null_mut;
-    use mem::size_of_val;
-    use io;
 
     // Fetch the kern.maxfilesperproc value
     let mut mib: [libc::c_int; 2] = [CTL_KERN, KERN_MAXFILESPERPROC];
@@ -54,7 +66,7 @@ pub fn raise_fd_limit() {
 
     // Bump the soft limit to the smaller of kern.maxfilesperproc and the hard
     // limit
-    rlim.rlim_cur = ::cmp::min(maxfiles as rlim_t, rlim.rlim_max);
+    rlim.rlim_cur = cmp::min(maxfiles as rlim_t, rlim.rlim_max);
 
     // Set our newly-increased resource limit
     if setrlimit(RLIMIT_NOFILE, &rlim) != 0 {
@@ -64,4 +76,4 @@ pub fn raise_fd_limit() {
 }
 
 #[cfg(not(any(target_os = "macos", target_os = "ios")))]
-pub fn raise_fd_limit() {}
+pub unsafe fn raise_fd_limit() {}

src/libcollectionstest/bench.rs

@@ -74,7 +74,7 @@ macro_rules! map_find_rand_bench {
             let n: usize = $n;
 
             // setup
-            let mut rng = rand::thread_rng();
+            let mut rng = thread_rng();
             let mut keys: Vec<_> = (0..n).map(|_| rng.gen::<usize>() % n).collect();
 
             for &k in &keys {

src/libcollectionstest/bit/set.rs

@@ -389,16 +389,15 @@ fn test_bit_vec_clone() {
 
 mod bench {
     use std::collections::{BitSet, BitVec};
-    use std::rand::{Rng, self};
+    use std::__rand::{Rng, thread_rng, ThreadRng};
     use std::u32;
 
     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/bit/vec.rs

@@ -633,7 +633,7 @@ fn test_bit_vec_extend() {
 mod bench {
     use std::collections::BitVec;
     use std::u32;
-    use std::__rand::{Rng, thread_rng};
+    use std::__rand::{Rng, thread_rng, ThreadRng};
 
     use test::{Bencher, black_box};
 

src/libcollectionstest/btree/map.rs

@@ -251,7 +251,7 @@ fn test_entry(){
 
 mod bench {
     use std::collections::BTreeMap;
-    use std::rand::{Rng, thread_rng};
+    use std::__rand::{Rng, thread_rng};
 
     use test::{Bencher, black_box};
 

src/libcollectionstest/slice.rs

@@ -12,7 +12,7 @@ use std::cmp::Ordering::{Equal, Greater, Less};
 use std::default::Default;
 use std::iter::RandomAccessIterator;
 use std::mem;
-use std::rand::{Rng, thread_rng};
+use std::__rand::{Rng, thread_rng};
 use std::rc::Rc;
 use std::slice::ElementSwaps;
 
@@ -1296,7 +1296,7 @@ fn test_to_vec() {
 mod bench {
     use std::iter::repeat;
     use std::{mem, ptr};
-    use std::rand::{Rng, thread_rng};
+    use std::__rand::{Rng, thread_rng};
 
     use test::{Bencher, black_box};
 

src/librand/lib.rs

@@ -379,7 +379,7 @@ pub struct Closed01<F>(pub F);
 mod test {
     use std::__rand as rand;
 
-    pub struct MyRng { inner: Box<rand::Rng> }
+    pub struct MyRng<R> { inner: R }
 
     impl<R: rand::Rng> ::Rng for MyRng<R> {
         fn next_u32(&mut self) -> u32 {
@@ -388,10 +388,10 @@ mod test {
     }
 
     pub fn rng() -> MyRng<rand::ThreadRng> {
-        MyRng { inner: Box::new(rand::thread_rng()) }
+        MyRng { inner: rand::thread_rng() }
     }
 
     pub fn weak_rng() -> MyRng<rand::ThreadRng> {
-        MyRng { inner: Box::new(rand::thread_rng()) }
+        MyRng { inner: rand::thread_rng() }
     }
 }

src/librustc_back/fs.rs

@@ -8,43 +8,19 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use libc;
 use std::io;
 use std::path::{Path, PathBuf};
 
 #[cfg(windows)]
 pub fn realpath(original: &Path) -> io::Result<PathBuf> {
-    use std::fs::File;
-    use std::ffi::OsString;
-    use std::os::windows::prelude::*;
-
-    extern "system" {
-        fn GetFinalPathNameByHandleW(hFile: libc::HANDLE,
-                                     lpszFilePath: libc::LPCWSTR,
-                                     cchFilePath: libc::DWORD,
-                                     dwFlags: libc::DWORD) -> libc::DWORD;
-    }
-
-    let mut v = Vec::with_capacity(16 * 1024);
-    let f = try!(File::open(original));
-    unsafe {
-        let ret = GetFinalPathNameByHandleW(f.as_raw_handle(),
-                                            v.as_mut_ptr(),
-                                            v.capacity() as libc::DWORD,
-                                            libc::VOLUME_NAME_DOS);
-        if ret == 0 {
-            return Err(io::Error::last_os_error())
-        }
-        assert!((ret as usize) < v.capacity());
-        v.set_len(ret);
-    }
-    Ok(PathBuf::from(OsString::from_wide(&v)))
+    Ok(original.to_path_buf())
 }
 
 #[cfg(unix)]
 pub fn realpath(original: &Path) -> io::Result<PathBuf> {
-    use std::os::unix::prelude::*;
+    use libc;
     use std::ffi::{OsString, CString};
+    use std::os::unix::prelude::*;
 
     extern {
         fn realpath(pathname: *const libc::c_char, resolved: *mut libc::c_char)

src/test/run-pass/core-run-destroy.rs

@@ -20,7 +20,7 @@
 
 extern crate libc;
 
-use std::process::{self, Command, Child, Output};
+use std::process::{self, Command, Child, Output, Stdio};
 use std::str;
 use std::sync::mpsc::channel;
 use std::thread;
@@ -68,7 +68,9 @@ fn test_destroy_actually_kills() {
     static BLOCK_COMMAND: &'static str = "cmd";
 
     // this process will stay alive indefinitely trying to read from stdin
-    let mut p = Command::new(BLOCK_COMMAND).spawn().unwrap();
+    let mut p = Command::new(BLOCK_COMMAND)
+                        .stdin(Stdio::piped())
+                        .spawn().unwrap();
 
     p.kill().unwrap();
 
@@ -80,6 +82,11 @@ fn test_destroy_actually_kills() {
             process::exit(1);
         }
     });
-    assert!(p.wait().unwrap().code().is_none());
+    let code = p.wait().unwrap().code();
+    if cfg!(windows) {
+        assert!(code.is_some());
+    } else {
+        assert!(code.is_none());
+    }
     tx.send(());
 }