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(());
 }

src/test/run-pass/drop-flag-skip-sanity-check.rs

@@ -17,8 +17,6 @@
 //
 // See also drop-flag-sanity-check.rs.
 
-#![feature(old_io)]
-
 use std::env;
 use std::process::Command;
 
@@ -28,9 +26,9 @@ fn main() {
         return test();
     }
 
-    let mut p = Command::new(&args[0]).arg("test").spawn().unwrap();
+    let s = Command::new(&args[0]).arg("test").status().unwrap();
     // Invocatinn should succeed as drop-flag sanity check is skipped.
-    assert!(p.wait().unwrap().success());
+    assert!(s.success());
 }
 
 #[derive(Debug)]

src/test/run-pass/issue-4446.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
-
 use std::sync::mpsc::channel;
 use std::thread;
 

src/test/run-pass/issue-9396.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// pretty-expanded FIXME #23616
-
 use std::sync::mpsc::{TryRecvError, channel};
 use std::thread;
 

src/test/run-pass/tcp-stress.rs

@@ -8,65 +8,46 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-linux see joyent/libuv#1189
 // ignore-android needs extra network permissions
 // ignore-openbsd system ulimit (Too many open files)
 // ignore-bitrig system ulimit (Too many open files)
-// exec-env:RUST_LOG=debug
-
-#![feature(rustc_private, libc, old_io, io, std_misc)]
-#![allow(deprecated, unused_must_use)]
-
-#[macro_use]
-extern crate log;
-extern crate libc;
 
+use std::io::prelude::*;
+use std::net::{TcpListener, TcpStream};
+use std::process;
 use std::sync::mpsc::channel;
-use std::old_io::net::tcp::{TcpListener, TcpStream};
-use std::old_io::{Acceptor, Listener, Reader, Writer};
 use std::thread::{self, Builder};
-use std::time::Duration;
 
 fn main() {
     // This test has a chance to time out, try to not let it time out
     thread::spawn(move|| -> () {
-        use std::old_io::timer;
-        timer::sleep(Duration::milliseconds(30 * 1000));
-        println!("timed out!");
-        unsafe { libc::exit(1) }
+        thread::sleep_ms(30 * 1000);
+        process::exit(1);
     });
 
-    let (tx, rx) = channel();
+    let mut listener = TcpListener::bind("127.0.0.1:0").unwrap();
+    let addr = listener.local_addr().unwrap();
     thread::spawn(move || -> () {
-        let mut listener = TcpListener::bind("127.0.0.1:0").unwrap();
-        tx.send(listener.socket_name().unwrap()).unwrap();
-        let mut acceptor = listener.listen();
         loop {
-            let mut stream = match acceptor.accept() {
-                Ok(stream) => stream,
-                Err(error) => {
-                    debug!("accept panicked: {}", error);
-                    continue;
-                }
+            let mut stream = match listener.accept() {
+                Ok(stream) => stream.0,
+                Err(error) => continue,
             };
-            stream.read_byte();
+            stream.read(&mut [0]);
             stream.write(&[2]);
         }
     });
-    let addr = rx.recv().unwrap();
 
     let (tx, rx) = channel();
     for _ in 0..1000 {
         let tx = tx.clone();
         Builder::new().stack_size(64 * 1024).spawn(move|| {
             match TcpStream::connect(addr) {
-                Ok(stream) => {
-                    let mut stream = stream;
+                Ok(mut stream) => {
                     stream.write(&[1]);
-                    let mut buf = [0];
-                    stream.read(&mut buf);
+                    stream.read(&mut [0]);
                 },
-                Err(e) => debug!("{}", e)
+                Err(..) => {}
             }
             tx.send(()).unwrap();
         });
@@ -78,5 +59,5 @@ fn main() {
     for _ in 0..1000 {
         rx.recv().unwrap();
     }
-    unsafe { libc::exit(0) }
+    process::exit(0);
 }