---

yaml
---
r: 59373
b: refs/heads/snap-stage3
c: d2f0235
h: refs/heads/master
i:
  59371: 393188d
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: c081ffbd1e845687202a975ea2e698b623e5722f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 4b6864f2195250d34cbedf92ffaf23a400c71b9e
+refs/heads/snap-stage3: d2f0235a2c887e425b2c06b8df359b1400b8dd4d
 refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libcore/run.rs

@@ -855,74 +855,4 @@ mod tests {
     fn waitpid_non_existant_pid() {
         run::waitpid(123456789); // assume that this pid doesn't exist
     }
-
-    #[test]
-    fn test_destroy_once() {
-        let mut p = run::start_program("echo", []);
-        p.destroy(); // this shouldn't crash (and nor should the destructor)
-    }
-
-    #[test]
-    fn test_destroy_twice() {
-        let mut p = run::start_program("echo", []);
-        p.destroy(); // this shouldnt crash...
-        p.destroy(); // ...and nor should this (and nor should the destructor)
-    }
-
-    fn test_destroy_actually_kills(force: bool) {
-
-        #[cfg(unix)]
-        static BLOCK_COMMAND: &'static str = "cat";
-
-        #[cfg(windows)]
-        static BLOCK_COMMAND: &'static str = "cmd";
-
-        #[cfg(unix)]
-        fn process_exists(pid: libc::pid_t) -> bool {
-            run::program_output("ps", [~"-p", pid.to_str()]).out.contains(pid.to_str())
-        }
-
-        #[cfg(windows)]
-        fn process_exists(pid: libc::pid_t) -> bool {
-
-            use libc::types::os::arch::extra::DWORD;
-            use libc::funcs::extra::kernel32::{CloseHandle, GetExitCodeProcess, OpenProcess};
-            use libc::consts::os::extra::{FALSE, PROCESS_QUERY_INFORMATION, STILL_ACTIVE };
-
-            unsafe {
-                let proc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid as DWORD);
-                if proc.is_null() {
-                    return false;
-                }
-                // proc will be non-null if the process is alive, or if it died recently
-                let mut status = 0;
-                GetExitCodeProcess(proc, &mut status);
-                CloseHandle(proc);
-                return status == STILL_ACTIVE;
-            }
-        }
-
-        // this program will stay alive indefinitely trying to read from stdin
-        let mut p = run::start_program(BLOCK_COMMAND, []);
-
-        assert!(process_exists(p.get_id()));
-
-        if force {
-            p.force_destroy();
-        } else {
-            p.destroy();
-        }
-
-        assert!(!process_exists(p.get_id()));
-    }
-
-    #[test]
-    fn test_unforced_destroy_actually_kills() {
-        test_destroy_actually_kills(false);
-    }
-
-    #[test]
-    fn test_forced_destroy_actually_kills() {
-        test_destroy_actually_kills(true);
-    }
 }

branches/snap-stage3/src/test/run-pass/core-run-destroy.rs

@@ -0,0 +1,89 @@
+// Copyright 2012-2013 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.
+
+// xfail-fast
+// 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
+// instead of in core.
+
+use core::run;
+use core::run::*;
+
+#[test]
+fn test_destroy_once() {
+    let mut p = run::start_program("echo", []);
+    p.destroy(); // this shouldn't crash (and nor should the destructor)
+}
+
+#[test]
+fn test_destroy_twice() {
+    let mut p = run::start_program("echo", []);
+    p.destroy(); // this shouldnt crash...
+    p.destroy(); // ...and nor should this (and nor should the destructor)
+}
+
+fn test_destroy_actually_kills(force: bool) {
+
+    #[cfg(unix)]
+    static BLOCK_COMMAND: &'static str = "cat";
+
+    #[cfg(windows)]
+    static BLOCK_COMMAND: &'static str = "cmd";
+
+    #[cfg(unix)]
+    fn process_exists(pid: libc::pid_t) -> bool {
+        run::program_output("ps", [~"-p", pid.to_str()]).out.contains(pid.to_str())
+    }
+
+    #[cfg(windows)]
+    fn process_exists(pid: libc::pid_t) -> bool {
+
+        use core::libc::types::os::arch::extra::DWORD;
+        use core::libc::funcs::extra::kernel32::{CloseHandle, GetExitCodeProcess, OpenProcess};
+        use core::libc::consts::os::extra::{FALSE, PROCESS_QUERY_INFORMATION, STILL_ACTIVE };
+
+        unsafe {
+            let proc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid as DWORD);
+            if proc.is_null() {
+                return false;
+            }
+            // proc will be non-null if the process is alive, or if it died recently
+            let mut status = 0;
+            GetExitCodeProcess(proc, &mut status);
+            CloseHandle(proc);
+            return status == STILL_ACTIVE;
+        }
+    }
+
+    // this program will stay alive indefinitely trying to read from stdin
+    let mut p = run::start_program(BLOCK_COMMAND, []);
+
+    assert!(process_exists(p.get_id()));
+
+    if force {
+        p.force_destroy();
+    } else {
+        p.destroy();
+    }
+
+    assert!(!process_exists(p.get_id()));
+}
+
+#[test]
+fn test_unforced_destroy_actually_kills() {
+    test_destroy_actually_kills(false);
+}
+
+#[test]
+fn test_forced_destroy_actually_kills() {
+    test_destroy_actually_kills(true);
+}