test: Fix fallout in run-pass tests

Author: alexcrichton

src/test/run-pass-valgrind/cleanup-stdin.rs

@@ -8,9 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(old_io, io)]
-
 fn main() {
-    let _ = std::old_io::stdin();
     let _ = std::io::stdin();
+    let _ = std::io::stdout();
+    let _ = std::io::stderr();
 }

src/test/run-pass/backtrace.rs

@@ -11,11 +11,8 @@
 // no-pretty-expanded FIXME #15189
 // ignore-windows FIXME #13259
 
-#![feature(unboxed_closures)]
-#![feature(unsafe_destructor, old_io, collections)]
-
 use std::env;
-use std::old_io::process::Command;
+use std::process::{Command, Stdio};
 use std::str;
 use std::ops::{Drop, FnMut, FnOnce};
 
@@ -40,44 +37,49 @@ fn double() {
     panic!("once");
 }
 
-fn runtest(me: &str) {
-    let mut template = Command::new(me);
-    template.env("IS_TEST", "1");
+fn template(me: &str) -> Command {
+    let mut m = Command::new(me);
+    m.env("IS_TEST", "1")
+     .stdout(Stdio::piped())
+     .stderr(Stdio::piped());
+    return m;
+}
 
+fn runtest(me: &str) {
     // Make sure that the stack trace is printed
-    let p = template.clone().arg("fail").env("RUST_BACKTRACE", "1").spawn().unwrap();
+    let p = template(me).arg("fail").env("RUST_BACKTRACE", "1").spawn().unwrap();
     let out = p.wait_with_output().unwrap();
     assert!(!out.status.success());
-    let s = str::from_utf8(&out.error).unwrap();
+    let s = str::from_utf8(&out.stderr).unwrap();
     assert!(s.contains("stack backtrace") && s.contains("foo::h"),
             "bad output: {}", s);
 
     // Make sure the stack trace is *not* printed
     // (Remove RUST_BACKTRACE from our own environment, in case developer
     // is running `make check` with it on.)
-    let p = template.clone().arg("fail").env_remove("RUST_BACKTRACE").spawn().unwrap();
+    let p = template(me).arg("fail").env_remove("RUST_BACKTRACE").spawn().unwrap();
     let out = p.wait_with_output().unwrap();
     assert!(!out.status.success());
-    let s = str::from_utf8(&out.error).unwrap();
+    let s = str::from_utf8(&out.stderr).unwrap();
     assert!(!s.contains("stack backtrace") && !s.contains("foo::h"),
             "bad output2: {}", s);
 
     // Make sure a stack trace is printed
-    let p = template.clone().arg("double-fail").spawn().unwrap();
+    let p = template(me).arg("double-fail").spawn().unwrap();
     let out = p.wait_with_output().unwrap();
     assert!(!out.status.success());
-    let s = str::from_utf8(&out.error).unwrap();
+    let s = str::from_utf8(&out.stderr).unwrap();
     // loosened the following from double::h to double:: due to
     // spurious failures on mac, 32bit, optimized
     assert!(s.contains("stack backtrace") && s.contains("double::"),
             "bad output3: {}", s);
 
     // Make sure a stack trace isn't printed too many times
-    let p = template.clone().arg("double-fail")
+    let p = template(me).arg("double-fail")
                                 .env("RUST_BACKTRACE", "1").spawn().unwrap();
     let out = p.wait_with_output().unwrap();
     assert!(!out.status.success());
-    let s = str::from_utf8(&out.error).unwrap();
+    let s = str::from_utf8(&out.stderr).unwrap();
     let mut i = 0;
     for _ in 0..2 {
         i += s[i + 10..].find("stack backtrace").unwrap() + 10;

src/test/run-pass/capturing-logging.rs

@@ -14,7 +14,6 @@
 #![feature(unboxed_closures, old_io)]
 
 use std::mem;
-use std::old_io::stdio::println;
 
 fn call_it<F>(f: F)
     where F : FnOnce(String) -> String
@@ -62,7 +61,8 @@ pub fn main() {
 
     // External functions
 
-    call_bare(println);
+    fn foo(s: &str) {}
+    call_bare(foo);
 
-    call_bare_again(println);
+    call_bare_again(foo);
 }

src/test/run-pass/closure-reform.rs

@@ -16,34 +16,34 @@
 // instead of in std.
 
 #![reexport_test_harness_main = "test_main"]
-#![feature(old_io, libc, std_misc)]
+#![feature(libc, std_misc)]
 
 extern crate libc;
 
-use std::old_io::{Process, Command, timer};
-use std::time::Duration;
+use std::process::{self, Command, Child, Output};
 use std::str;
 use std::sync::mpsc::channel;
 use std::thread;
+use std::time::Duration;
 
-macro_rules! succeed { ($e:expr) => (
-    match $e { Ok(..) => {}, Err(e) => panic!("panic: {}", e) }
-) }
+macro_rules! t {
+    ($e:expr) => (match $e { Ok(e) => e, Err(e) => panic!("error: {}", e) })
+}
 
 fn test_destroy_once() {
     let mut p = sleeper();
-    match p.signal_exit() {
+    match p.kill() {
         Ok(()) => {}
         Err(e) => panic!("error: {}", e),
     }
 }
 
 #[cfg(unix)]
-pub fn sleeper() -> Process {
+pub fn sleeper() -> Child {
     Command::new("sleep").arg("1000").spawn().unwrap()
 }
 #[cfg(windows)]
-pub fn sleeper() -> Process {
+pub fn sleeper() -> Child {
     // There's a `timeout` command on windows, but it doesn't like having
     // its output piped, so instead just ping ourselves a few times with
     // gaps in between so we're sure this process is alive for awhile
@@ -52,16 +52,12 @@ pub fn sleeper() -> Process {
 
 fn test_destroy_twice() {
     let mut p = sleeper();
-    succeed!(p.signal_exit()); // this shouldn't crash...
-    let _ = p.signal_exit(); // ...and nor should this (and nor should the destructor)
+    t!(p.kill()); // this shouldn't crash...
+    let _ = p.kill(); // ...and nor should this (and nor should the destructor)
 }
 
-pub fn test_destroy_actually_kills(force: bool) {
-    use std::old_io::process::{Command, ProcessOutput, ExitStatus, ExitSignal};
-    use std::old_io::timer;
-    use libc;
-    use std::str;
-
+#[test]
+fn test_destroy_actually_kills() {
     #[cfg(all(unix,not(target_os="android")))]
     static BLOCK_COMMAND: &'static str = "cat";
 
@@ -74,34 +70,16 @@ pub fn test_destroy_actually_kills(force: bool) {
     // this process will stay alive indefinitely trying to read from stdin
     let mut p = Command::new(BLOCK_COMMAND).spawn().unwrap();
 
-    assert!(p.signal(0).is_ok());
-
-    if force {
-        p.signal_kill().unwrap();
-    } else {
-        p.signal_exit().unwrap();
-    }
+    p.kill().unwrap();
 
     // Don't let this test time out, this should be quick
-    let (tx, rx1) = channel();
-    let mut t = timer::Timer::new().unwrap();
-    let rx2 = t.oneshot(Duration::milliseconds(1000));
+    let (tx, rx) = channel();
     thread::spawn(move|| {
-        select! {
-            _ = rx2.recv() => unsafe { libc::exit(1) },
-            _ = rx1.recv() => {}
+        thread::sleep_ms(1000);
+        if rx.try_recv().is_err() {
+            process::exit(1);
         }
     });
-    match p.wait().unwrap() {
-        ExitStatus(..) => panic!("expected a signal"),
-        ExitSignal(..) => tx.send(()).unwrap(),
-    }
-}
-
-fn test_unforced_destroy_actually_kills() {
-    test_destroy_actually_kills(false);
-}
-
-fn test_forced_destroy_actually_kills() {
-    test_destroy_actually_kills(true);
+    assert!(p.wait().unwrap().code().is_none());
+    tx.send(());
 }

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

@@ -11,7 +11,6 @@
 #![feature(rand, rustc_private)]
 
 extern crate serialize;
-extern crate rand;
 
 mod submod {
     // if any of these are implemented without global calls for any
@@ -20,21 +19,21 @@ mod submod {
     #[derive(PartialEq, PartialOrd, Eq, Ord,
                Hash,
                Clone,
-               Debug, Rand,
+               Debug,
                Encodable, Decodable)]
     enum A { A1(usize), A2(isize) }
 
     #[derive(PartialEq, PartialOrd, Eq, Ord,
                Hash,
                Clone,
-               Debug, Rand,
+               Debug,
                Encodable, Decodable)]
     struct B { x: usize, y: isize }
 
     #[derive(PartialEq, PartialOrd, Eq, Ord,
                Hash,
                Clone,
-               Debug, Rand,
+               Debug,
                Encodable, Decodable)]
     struct C(usize, isize);
 

src/test/run-pass/deriving-global.rs

@@ -17,10 +17,8 @@
 //
 // See also drop-flag-skip-sanity-check.rs.
 
-#![feature(old_io)]
-
 use std::env;
-use std::old_io::process::{Command, ExitSignal, ExitStatus};
+use std::process::Command;
 
 fn main() {
     let args: Vec<String> = env::args().collect();

src/test/run-pass/deriving-rand.rs

@@ -20,7 +20,7 @@
 #![feature(old_io)]
 
 use std::env;
-use std::old_io::process::{Command, ExitSignal, ExitStatus};
+use std::process::Command;
 
 fn main() {
     let args: Vec<String> = env::args().collect();

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

@@ -15,7 +15,7 @@
 #![feature(old_io)]
 
 use std::env;
-use std::old_io::process;
+use std::process::{Command, Stdio};
 
 pub fn main () {
     let args: Vec<String> = env::args().collect();
@@ -29,7 +29,7 @@ pub fn main () {
         return;
     }
 
-    let mut p = process::Command::new(&args[0]);
-    p.arg("child").stdout(process::Ignored).stderr(process::Ignored);
+    let mut p = Command::new(&args[0]);
+    p.arg("child").stdout(Stdio::null()).stderr(Stdio::null());
     println!("{:?}", p.spawn().unwrap().wait());
 }