tests: Cleanup: introduce a common spawn_server() helper function

Author: antrik

src/platform/test.rs

@@ -10,13 +10,9 @@
 use platform::{self, OsIpcChannel, OsIpcReceiverSet};
 use platform::{OsIpcSharedMemory};
 use std::collections::HashMap;
-#[cfg(not(any(feature = "force-inprocess", target_os = "windows", target_os = "android")))]
-use std::process::{Command, Stdio};
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 use std::thread;
-#[cfg(not(any(feature = "force-inprocess", target_os = "windows", target_os = "android")))]
-use std::env;
 
 #[cfg(not(any(feature = "force-inprocess", target_os = "windows", target_os = "android")))]
 use libc;
@@ -26,7 +22,7 @@ use libc::{kill, SIGSTOP, SIGCONT};
 #[cfg(not(any(feature = "force-inprocess", target_os = "windows", target_os = "android")))]
 use test::{fork, Wait};
 #[cfg(not(any(feature = "force-inprocess", target_os = "windows", target_os = "android")))]
-use test::get_channel_name_arg;
+use test::{get_channel_name_arg, spawn_server};
 
 #[test]
 fn simple() {
@@ -676,15 +672,7 @@ fn cross_process_spawn() {
     let (server, name) = OsIpcOneShotServer::new().unwrap();
     let data: &[u8] = b"1234567";
 
-    let mut child_pid = Command::new(env::current_exe().unwrap())
-        .arg("--ignored")
-        .arg("cross_process_server")
-        .arg(format!("channel_name-server:{}", name))
-        .stdin(Stdio::null())
-        .stdout(Stdio::null())
-        .stderr(Stdio::null())
-        .spawn()
-        .expect("failed to execute server process");
+    let mut child_pid = spawn_server("cross_process_server", &[("server", &*name)]);
 
     let (_, received_data, received_channels, received_shared_memory_regions) =
         server.accept().unwrap();
@@ -738,15 +726,8 @@ fn cross_process_sender_transfer_server()
 fn cross_process_sender_transfer_spawn() {
     let (server, name) = OsIpcOneShotServer::new().unwrap();
 
-    let mut child_pid = Command::new(env::current_exe().unwrap())
-        .arg("--ignored")
-        .arg("cross_process_sender_transfer_server")
-        .arg(format!("channel_name-server:{}", name))
-        .stdin(Stdio::null())
-        .stdout(Stdio::null())
-        .stderr(Stdio::null())
-        .spawn()
-        .expect("failed to execute server process");
+    let mut child_pid = spawn_server("cross_process_sender_transfer_server",
+                                     &[("server", &*name)]);
 
     let (super_rx, _, mut received_channels, _) = server.accept().unwrap();
     assert_eq!(received_channels.len(), 1);
@@ -1018,15 +999,8 @@ fn cross_process_two_step_transfer_spawn() {
 
     // create a one-shot server, and spawn another process
     let (server, name) = OsIpcOneShotServer::new().unwrap();
-    let mut child_pid = Command::new(env::current_exe().unwrap())
-        .arg("--ignored")
-        .arg("cross_process_two_step_transfer_server")
-        .arg(format!("channel_name-server:{}", name))
-        .stdin(Stdio::null())
-        .stdout(Stdio::null())
-        .stderr(Stdio::null())
-        .spawn()
-        .expect("failed to execute server process");
+    let mut child_pid = spawn_server("cross_process_two_step_transfer_server",
+                                     &[("server", &*name)]);
 
     // The other process will have sent us a transmit channel in received channels
     let (super_rx, _, mut received_channels, _) = server.accept().unwrap();

src/test.rs

@@ -19,7 +19,7 @@ use std::cell::RefCell;
 use std::env;
 use std::iter;
 #[cfg(not(any(feature = "force-inprocess", target_os = "windows", target_os = "android")))]
-use std::process::{Command, Stdio};
+use std::process::{self, Command, Stdio};
 #[cfg(not(windows))]
 use std::ptr;
 use std::sync::Arc;
@@ -72,6 +72,22 @@ pub fn get_channel_name_arg(which: &str) -> Option<String> {
     None
 }
 
+// Helper to get a channel_name argument passed in; used for the
+// cross-process spawn server tests.
+#[cfg(not(any(feature = "force-inprocess", target_os = "windows", target_os = "android")))]
+pub fn spawn_server(test_name: &str, server_args: &[(&str, &str)]) -> process::Child {
+    Command::new(env::current_exe().unwrap())
+        .arg("--ignored")
+        .arg(test_name)
+        .args(server_args.iter()
+                         .map(|&(ref name, ref val)| format!("channel_name-{}:{}", name, val)))
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn()
+        .expect("failed to execute server process")
+}
+
 type Person = (String, u32);
 
 #[test]
@@ -185,16 +201,8 @@ fn cross_process_embedded_senders_spawn() {
     let (server0, server0_name) = IpcOneShotServer::new().unwrap();
     let (server2, server2_name) = IpcOneShotServer::new().unwrap();
 
-    let mut child_pid = Command::new(env::current_exe().unwrap())
-        .arg("--ignored")
-        .arg("cross_process_embedded_senders_server")
-        .arg(format!("channel_name-server0:{}", server0_name))
-        .arg(format!("channel_name-server2:{}", server2_name))
-        .stdin(Stdio::null())
-        .stdout(Stdio::null())
-        .stderr(Stdio::null())
-        .spawn()
-        .expect("failed to execute server process");
+    let mut child_pid = spawn_server("cross_process_embedded_senders_server",
+                                     &[("server0", &*server0_name), ("server2", &*server2_name)]);
 
     let (_, tx1): (_, IpcSender<Person>) = server0.accept().unwrap();
     tx1.send(person.clone()).unwrap();