2014-02-07 13:08:32 -06:00
|
|
|
// Copyright 2012-2013-2014 The Rust Project Developers. See the COPYRIGHT
|
2013-05-03 18:08:43 -05:00
|
|
|
// 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.
|
|
|
|
|
2014-02-07 13:08:32 -06:00
|
|
|
// ignore-fast
|
2014-03-11 15:38:36 -05:00
|
|
|
// ignore-pretty
|
2013-05-03 18:08:43 -05:00
|
|
|
// compile-flags:--test
|
|
|
|
|
|
|
|
// NB: These tests kill child processes. Valgrind sees these children as leaking
|
|
|
|
// memory, which makes for some *confusing* logs. That's why these are here
|
2013-05-20 19:07:24 -05:00
|
|
|
// instead of in std.
|
2013-05-03 18:08:43 -05:00
|
|
|
|
2014-03-11 15:38:36 -05:00
|
|
|
#[feature(macro_rules)];
|
2013-05-03 18:08:43 -05:00
|
|
|
|
2014-03-11 15:38:36 -05:00
|
|
|
extern crate native;
|
|
|
|
extern crate green;
|
|
|
|
extern crate rustuv;
|
|
|
|
|
2014-03-25 10:44:40 -05:00
|
|
|
use std::io::Process;
|
|
|
|
|
|
|
|
macro_rules! succeed( ($e:expr) => (
|
|
|
|
match $e { Ok(..) => {}, Err(e) => fail!("failure: {}", e) }
|
|
|
|
) )
|
|
|
|
|
2014-03-11 15:38:36 -05:00
|
|
|
macro_rules! iotest (
|
|
|
|
{ fn $name:ident() $b:block $($a:attr)* } => (
|
|
|
|
mod $name {
|
|
|
|
#[allow(unused_imports)];
|
|
|
|
|
|
|
|
use std::io::timer;
|
|
|
|
use std::libc;
|
|
|
|
use std::str;
|
|
|
|
use std::io::process::{Process, ProcessOutput};
|
|
|
|
use native;
|
|
|
|
use super::*;
|
|
|
|
|
|
|
|
fn f() $b
|
|
|
|
|
|
|
|
$($a)* #[test] fn green() { f() }
|
|
|
|
$($a)* #[test] fn native() {
|
|
|
|
use native;
|
|
|
|
let (tx, rx) = channel();
|
|
|
|
native::task::spawn(proc() { tx.send(f()) });
|
|
|
|
rx.recv();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
#[cfg(test)] #[start]
|
|
|
|
fn start(argc: int, argv: **u8) -> int {
|
2014-03-24 12:40:36 -05:00
|
|
|
green::start(argc, argv, rustuv::event_loop, __test::main)
|
2014-03-11 15:38:36 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
iotest!(fn test_destroy_once() {
|
2014-03-25 10:44:40 -05:00
|
|
|
let mut p = sleeper();
|
|
|
|
match p.signal_exit() {
|
|
|
|
Ok(()) => {}
|
|
|
|
Err(e) => fail!("error: {}", e),
|
|
|
|
}
|
2014-03-11 15:38:36 -05:00
|
|
|
})
|
2013-05-03 18:08:43 -05:00
|
|
|
|
2014-03-25 10:44:40 -05:00
|
|
|
#[cfg(unix)]
|
|
|
|
pub fn sleeper() -> Process {
|
|
|
|
Process::new("sleep", [~"1000"]).unwrap()
|
|
|
|
}
|
|
|
|
#[cfg(windows)]
|
|
|
|
pub fn sleeper() -> Process {
|
|
|
|
// 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 inbetweeen so we're sure this process is alive for awhile
|
|
|
|
Process::new("ping", [~"127.0.0.1", ~"-n", ~"1000"]).unwrap()
|
|
|
|
}
|
|
|
|
|
2014-03-11 15:38:36 -05:00
|
|
|
iotest!(fn test_destroy_twice() {
|
2014-03-25 10:44:40 -05:00
|
|
|
let mut p = sleeper();
|
|
|
|
succeed!(p.signal_exit()); // this shouldnt crash...
|
|
|
|
let _ = p.signal_exit(); // ...and nor should this (and nor should the destructor)
|
2014-03-11 15:38:36 -05:00
|
|
|
})
|
2013-05-03 18:08:43 -05:00
|
|
|
|
2014-03-11 15:38:36 -05:00
|
|
|
pub fn test_destroy_actually_kills(force: bool) {
|
|
|
|
use std::io::process::{Process, ProcessOutput, ExitStatus, ExitSignal};
|
|
|
|
use std::io::timer;
|
|
|
|
use std::libc;
|
|
|
|
use std::str;
|
2013-05-03 18:08:43 -05:00
|
|
|
|
2013-11-07 04:22:18 -06:00
|
|
|
#[cfg(unix,not(target_os="android"))]
|
2014-03-11 15:38:36 -05:00
|
|
|
static BLOCK_COMMAND: &'static str = "cat";
|
2013-05-03 18:08:43 -05:00
|
|
|
|
2013-11-07 04:22:18 -06:00
|
|
|
#[cfg(unix,target_os="android")]
|
2014-03-11 15:38:36 -05:00
|
|
|
static BLOCK_COMMAND: &'static str = "/system/bin/cat";
|
2013-11-07 04:22:18 -06:00
|
|
|
|
2013-05-03 18:08:43 -05:00
|
|
|
#[cfg(windows)]
|
2014-03-11 15:38:36 -05:00
|
|
|
static BLOCK_COMMAND: &'static str = "cmd";
|
2013-05-03 18:08:43 -05:00
|
|
|
|
2013-05-12 07:58:00 -05:00
|
|
|
// this process will stay alive indefinitely trying to read from stdin
|
2014-03-11 15:38:36 -05:00
|
|
|
let mut p = Process::new(BLOCK_COMMAND, []).unwrap();
|
2013-05-03 18:08:43 -05:00
|
|
|
|
2014-03-11 15:38:36 -05:00
|
|
|
assert!(p.signal(0).is_ok());
|
2013-05-03 18:08:43 -05:00
|
|
|
|
|
|
|
if force {
|
2014-02-18 14:04:51 -06:00
|
|
|
p.signal_kill().unwrap();
|
2013-05-03 18:08:43 -05:00
|
|
|
} else {
|
2014-02-18 14:04:51 -06:00
|
|
|
p.signal_exit().unwrap();
|
2013-05-03 18:08:43 -05:00
|
|
|
}
|
|
|
|
|
2014-03-11 15:38:36 -05:00
|
|
|
// 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(1000);
|
|
|
|
spawn(proc() {
|
|
|
|
select! {
|
|
|
|
() = rx2.recv() => unsafe { libc::exit(1) },
|
|
|
|
() = rx1.recv() => {}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
match p.wait() {
|
|
|
|
ExitStatus(..) => fail!("expected a signal"),
|
|
|
|
ExitSignal(..) => tx.send(()),
|
2014-02-18 14:04:51 -06:00
|
|
|
}
|
2013-05-03 18:08:43 -05:00
|
|
|
}
|
|
|
|
|
2014-03-11 15:38:36 -05:00
|
|
|
iotest!(fn test_unforced_destroy_actually_kills() {
|
2013-05-03 18:08:43 -05:00
|
|
|
test_destroy_actually_kills(false);
|
2014-03-11 15:38:36 -05:00
|
|
|
})
|
2013-05-03 18:08:43 -05:00
|
|
|
|
2014-03-11 15:38:36 -05:00
|
|
|
iotest!(fn test_forced_destroy_actually_kills() {
|
2013-05-03 18:08:43 -05:00
|
|
|
test_destroy_actually_kills(true);
|
2014-03-11 15:38:36 -05:00
|
|
|
})
|