tests: Add variants of cross-process test, using spawn()

Since `fork()` isn't available on Windows, we need to do the tests using
`spawn()` instead.

The `spawn()` variants work both on Windows and on Unix platforms
(including MacOS), making the `fork()` variants pretty redundant.
However, it doesn't really hurt to keep them around, just in case. (It
might help narrowing down any problems coming up, for example; or we
might need support in the future for some platform that only works with
`fork()`...)

Author: vvuk

src/platform/test.rs

@@ -10,16 +10,35 @@
 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;
 use platform::{OsIpcSender, OsIpcOneShotServer};
 #[cfg(not(any(feature = "force-inprocess", target_os = "windows", target_os = "android")))]
 use libc::{kill, SIGSTOP, SIGCONT};
 #[cfg(not(any(feature = "force-inprocess", target_os = "windows", target_os = "android")))]
 use test::{fork, Wait};
 
+// 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 = "android")))]
+fn get_channel_name_arg() -> Option<String> {
+    for arg in env::args() {
+        let arg_str = "channel_name:";
+        if arg.starts_with(arg_str) {
+            return Some(arg[arg_str.len()..].to_owned());
+        }
+    }
+    None
+}
+
 #[test]
 fn simple() {
     let (tx, rx) = platform::channel().unwrap();
@@ -644,9 +663,52 @@ fn server_connect_first() {
                (data, vec![], vec![]));
 }
 
+// Note! This test is actually used by the cross_process_spawn() test
+// below as a second process.  Running it by itself is meaningless, but
+// passes.
+#[cfg(not(any(feature = "force-inprocess", target_os = "windows", target_os = "android")))]
+#[test]
+#[ignore]
+fn cross_process_server()
+{
+    let data: &[u8] = b"1234567";
+    let channel_name = get_channel_name_arg();
+    if channel_name.is_none() {
+        return;
+    }
+
+    let tx = OsIpcSender::connect(channel_name.unwrap()).unwrap();
+    tx.send(data, vec![], vec![]).unwrap();
+    unsafe { libc::exit(0); }
+}
+
+#[cfg(not(any(feature = "force-inprocess", target_os = "windows", target_os = "android")))]
+#[test]
+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:{}", name))
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn()
+        .expect("failed to execute server process");
+
+    let (_, mut received_data, received_channels, received_shared_memory_regions) =
+        server.accept().unwrap();
+    child_pid.wait().expect("failed to wait on child");
+    received_data.truncate(7);
+    assert_eq!((&received_data[..], received_channels, received_shared_memory_regions),
+               (data, vec![], vec![]));
+}
+
 #[cfg(not(any(feature = "force-inprocess", target_os = "windows", target_os = "android")))]
 #[test]
-fn cross_process() {
+fn cross_process_fork() {
     let (server, name) = OsIpcOneShotServer::new().unwrap();
     let data: &[u8] = b"1234567";
 
@@ -662,9 +724,62 @@ fn cross_process() {
                (data, vec![], vec![]));
 }
 
+// Note! This test is actually used by the cross_process_sender_transfer_spawn() test
+// below as a second process.  Running it by itself is meaningless, but
+// passes.
+#[cfg(not(any(feature = "force-inprocess", target_os = "windows", target_os = "android")))]
+#[test]
+#[ignore]
+fn cross_process_sender_transfer_server()
+{
+    let channel_name = get_channel_name_arg();
+    if channel_name.is_none() {
+        return;
+    }
+
+    let super_tx = OsIpcSender::connect(channel_name.unwrap()).unwrap();
+    let (sub_tx, sub_rx) = platform::channel().unwrap();
+    let data: &[u8] = b"foo";
+    super_tx.send(data, vec![OsIpcChannel::Sender(sub_tx)], vec![]).unwrap();
+    sub_rx.recv().unwrap();
+    let data: &[u8] = b"bar";
+    super_tx.send(data, vec![], vec![]).unwrap();
+    unsafe { libc::exit(0); }
+}
+
+#[cfg(not(any(feature = "force-inprocess", target_os = "windows", target_os = "android")))]
+#[test]
+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:{}", name))
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn()
+        .expect("failed to execute server process");
+
+    let (super_rx, _, mut received_channels, _) = server.accept().unwrap();
+    assert_eq!(received_channels.len(), 1);
+    let sub_tx = received_channels[0].to_sender();
+    let data: &[u8] = b"baz";
+    sub_tx.send(data, vec![], vec![]).unwrap();
+
+    let data: &[u8] = b"bar";
+    let (mut received_data, received_channels, received_shared_memory_regions) =
+        super_rx.recv().unwrap();
+    child_pid.wait().expect("failed to wait on child");
+    received_data.truncate(3);
+    assert_eq!((&received_data[..], received_channels, received_shared_memory_regions),
+               (data, vec![], vec![]));
+}
+
 #[cfg(not(any(feature = "force-inprocess", target_os = "windows", target_os = "android")))]
 #[test]
-fn cross_process_sender_transfer() {
+fn cross_process_sender_transfer_fork() {
     let (server, name) = OsIpcOneShotServer::new().unwrap();
 
     let child_pid = unsafe { fork(|| {