---

yaml
---
r: 114170
b: refs/heads/master
c: b7676f2
h: refs/heads/master
v: v3

Author: hannobraun

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: ba5f53009aab826d8bb8fa97f3213b2fee803e29
+refs/heads/master: b7676f2df5e1ff97e0baa3f7e70936d4bd4dacb5
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ec0258a381b88b5574e3f8ce72ae553ac3a574b7
 refs/heads/try: 7c6c492fb2af9a85f21ff952942df3523b22fd17

trunk/mk/crates.mk

@@ -80,7 +80,7 @@ DEPS_collections := std rand
 DEPS_fourcc := syntax std
 DEPS_hexfloat := syntax std
 DEPS_num := std rand
-DEPS_test := std collections getopts serialize term time regex
+DEPS_test := std collections getopts serialize term time
 DEPS_time := std serialize
 DEPS_rand := std
 DEPS_url := std collections

trunk/src/compiletest/common.rs

@@ -10,7 +10,6 @@
 
 use std::from_str::FromStr;
 use std::fmt;
-use regex::Regex;
 
 #[deriving(Clone, Eq)]
 pub enum Mode {
@@ -89,7 +88,7 @@ pub struct Config {
     pub run_ignored: bool,
 
     // Only run tests that match this filter
-    pub filter: Option<Regex>,
+    pub filter: Option<~str>,
 
     // Write out a parseable log of tests that were run
     pub logfile: Option<Path>,

trunk/src/compiletest/compiletest.rs

@@ -23,8 +23,6 @@ extern crate log;
 extern crate green;
 extern crate rustuv;
 
-extern crate regex;
-
 use std::os;
 use std::io;
 use std::io::fs;
@@ -115,19 +113,6 @@ pub fn parse_config(args: Vec<~str> ) -> Config {
         Path::new(m.opt_str(nm).unwrap())
     }
 
-    let filter = if !matches.free.is_empty() {
-        let s = matches.free.get(0).as_slice();
-        match regex::Regex::new(s) {
-            Ok(re) => Some(re),
-            Err(e) => {
-                println!("failed to parse filter /{}/: {}", s, e);
-                fail!()
-            }
-        }
-    } else {
-        None
-    };
-
     Config {
         compile_lib_path: matches.opt_str("compile-lib-path").unwrap(),
         run_lib_path: matches.opt_str("run-lib-path").unwrap(),
@@ -140,7 +125,12 @@ pub fn parse_config(args: Vec<~str> ) -> Config {
         stage_id: matches.opt_str("stage-id").unwrap(),
         mode: FromStr::from_str(matches.opt_str("mode").unwrap()).expect("invalid mode"),
         run_ignored: matches.opt_present("ignored"),
-        filter: filter,
+        filter:
+            if !matches.free.is_empty() {
+                 Some((*matches.free.get(0)).clone())
+            } else {
+                None
+            },
         logfile: matches.opt_str("logfile").map(|s| Path::new(s)),
         save_metrics: matches.opt_str("save-metrics").map(|s| Path::new(s)),
         ratchet_metrics:
@@ -179,7 +169,7 @@ pub fn log_config(config: &Config) {
     logv(c, format!("stage_id: {}", config.stage_id));
     logv(c, format!("mode: {}", config.mode));
     logv(c, format!("run_ignored: {}", config.run_ignored));
-    logv(c, format!("filter: {}", opt_str(&config.filter.as_ref().map(|re| re.to_str()))));
+    logv(c, format!("filter: {}", opt_str(&config.filter)));
     logv(c, format!("runtool: {}", opt_str(&config.runtool)));
     logv(c, format!("host-rustcflags: {}", opt_str(&config.host_rustcflags)));
     logv(c, format!("target-rustcflags: {}", opt_str(&config.target_rustcflags)));
@@ -248,7 +238,7 @@ pub fn test_opts(config: &Config) -> test::TestOpts {
     test::TestOpts {
         filter: match config.filter {
             None => None,
-            Some(ref filter) => Some(filter.clone()),
+            Some(ref filter) => Some(filter.to_strbuf()),
         },
         run_ignored: config.run_ignored,
         logfile: config.logfile.clone(),

trunk/src/compiletest/procsrv.rs

@@ -10,7 +10,7 @@
 
 use std::os;
 use std::str;
-use std::io::process::{ProcessExit, Command, Process, ProcessOutput};
+use std::io::process::{ProcessExit, Process, ProcessConfig, ProcessOutput};
 
 #[cfg(target_os = "win32")]
 fn target_env(lib_path: &str, prog: &str) -> Vec<(~str, ~str)> {
@@ -68,7 +68,14 @@ pub fn run(lib_path: &str,
            input: Option<~str>) -> Option<Result> {
 
     let env = env.clone().append(target_env(lib_path, prog).as_slice());
-    match Command::new(prog).args(args).env(env.as_slice()).spawn() {
+    let opt_process = Process::configure(ProcessConfig {
+        program: prog,
+        args: args,
+        env: Some(env.as_slice()),
+        .. ProcessConfig::new()
+    });
+
+    match opt_process {
         Ok(mut process) => {
             for input in input.iter() {
                 process.stdin.get_mut_ref().write(input.as_bytes()).unwrap();
@@ -93,7 +100,14 @@ pub fn run_background(lib_path: &str,
            input: Option<~str>) -> Option<Process> {
 
     let env = env.clone().append(target_env(lib_path, prog).as_slice());
-    match Command::new(prog).args(args).env(env.as_slice()).spawn() {
+    let opt_process = Process::configure(ProcessConfig {
+        program: prog,
+        args: args,
+        env: Some(env.as_slice()),
+        .. ProcessConfig::new()
+    });
+
+    match opt_process {
         Ok(mut process) => {
             for input in input.iter() {
                 process.stdin.get_mut_ref().write(input.as_bytes()).unwrap();

trunk/src/compiletest/runtest.rs

@@ -420,7 +420,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
 }
 
 fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path) {
-    use std::io::process::{Command, ProcessOutput};
+    use std::io::process::{Process, ProcessConfig, ProcessOutput};
 
     if config.lldb_python_dir.is_none() {
         fatal("Can't run LLDB test because LLDB's python path is not set.".to_owned());
@@ -483,13 +483,25 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
 
     fn run_lldb(config: &Config, test_executable: &Path, debugger_script: &Path) -> ProcRes {
         // Prepare the lldb_batchmode which executes the debugger script
-        let mut cmd = Command::new("python");
-        cmd.arg("./src/etc/lldb_batchmode.py")
-           .arg(test_executable)
-           .arg(debugger_script)
-           .env([("PYTHONPATH", config.lldb_python_dir.clone().unwrap().as_slice())]);
-
-        let (status, out, err) = match cmd.spawn() {
+        let lldb_batchmode_script = "./src/etc/lldb_batchmode.py".to_owned();
+        let test_executable_str = test_executable.as_str().unwrap().to_owned();
+        let debugger_script_str = debugger_script.as_str().unwrap().to_owned();
+        let commandline = format!("python {} {} {}",
+                                  lldb_batchmode_script.as_slice(),
+                                  test_executable_str.as_slice(),
+                                  debugger_script_str.as_slice());
+
+        let args = &[lldb_batchmode_script, test_executable_str, debugger_script_str];
+        let env = &[("PYTHONPATH".to_owned(), config.lldb_python_dir.clone().unwrap())];
+
+        let opt_process = Process::configure(ProcessConfig {
+            program: "python",
+            args: args,
+            env: Some(env),
+            .. ProcessConfig::new()
+        });
+
+        let (status, out, err) = match opt_process {
             Ok(process) => {
                 let ProcessOutput { status, output, error } =
                     process.wait_with_output().unwrap();
@@ -508,7 +520,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
             status: status,
             stdout: out,
             stderr: err,
-            cmdline: format!("{}", cmd)
+            cmdline: commandline
         };
     }
 }

trunk/src/doc/guide-testing.md

@@ -90,15 +90,10 @@ fn test_out_of_bounds_failure() {
 ~~~
 
 A test runner built with the `--test` flag supports a limited set of
-arguments to control which tests are run:
-
-- the first free argument passed to a test runner is interpreted as a
-  regular expression
-  ([syntax reference](regex/index.html#syntax))
-  and is used to narrow down the set of tests being run. Note: a plain
-  string is a valid regular expression that matches itself.
-- the `--ignored` flag tells the test runner to run only tests with the
-  `ignore` attribute.
+arguments to control which tests are run: the first free argument
+passed to a test runner specifies a filter used to narrow down the set
+of tests being run; the `--ignored` flag tells the test runner to run
+only tests with the `ignore` attribute.
 
 ## Parallelism
 
@@ -151,31 +146,16 @@ result: FAILED. 1 passed; 1 failed; 0 ignored
 
 ### Running a subset of tests
 
-Using a plain string:
-
-~~~ {.notrust}
-$ mytests mytest23
-
-running 1 tests
-running driver::tests::mytest23 ... ok
-
-result: ok. 1 passed; 0 failed; 0 ignored
-~~~
-
-Using some regular expression features:
-
 ~~~ {.notrust}
-$ mytests 'mytest[145]'
+$ mytests mytest1
 
-running 13 tests
+running 11 tests
 running driver::tests::mytest1 ... ok
-running driver::tests::mytest4 ... ok
-running driver::tests::mytest5 ... ok
 running driver::tests::mytest10 ... ignored
 ... snip ...
 running driver::tests::mytest19 ... ok
 
-result: ok. 13 passed; 0 failed; 1 ignored
+result: ok. 11 passed; 0 failed; 1 ignored
 ~~~
 
 # Microbenchmarking

trunk/src/libnative/io/mod.rs

@@ -27,12 +27,13 @@ use std::c_str::CString;
 use std::io;
 use std::io::IoError;
 use std::io::net::ip::SocketAddr;
+use std::io::process::ProcessConfig;
 use std::io::signal::Signum;
 use std::os;
 use std::rt::rtio;
 use std::rt::rtio::{RtioTcpStream, RtioTcpListener, RtioUdpSocket};
 use std::rt::rtio::{RtioUnixListener, RtioPipe, RtioFileStream, RtioProcess};
-use std::rt::rtio::{RtioSignal, RtioTTY, CloseBehavior, RtioTimer, ProcessConfig};
+use std::rt::rtio::{RtioSignal, RtioTTY, CloseBehavior, RtioTimer};
 use ai = std::io::net::addrinfo;
 
 // Local re-exports
@@ -257,10 +258,10 @@ impl rtio::IoFactory for IoFactory {
     fn timer_init(&mut self) -> IoResult<Box<RtioTimer:Send>> {
         timer::Timer::new().map(|t| box t as Box<RtioTimer:Send>)
     }
-    fn spawn(&mut self, cfg: ProcessConfig)
+    fn spawn(&mut self, config: ProcessConfig)
             -> IoResult<(Box<RtioProcess:Send>,
                          Vec<Option<Box<RtioPipe:Send>>>)> {
-        process::Process::spawn(cfg).map(|(p, io)| {
+        process::Process::spawn(config).map(|(p, io)| {
             (box p as Box<RtioProcess:Send>,
              io.move_iter().map(|p| p.map(|p| {
                  box p as Box<RtioPipe:Send>