src/test/ui/command-pre-exec.rs

   1 // run-pass
   2
   3 #![allow(stable_features)]
   4 // ignore-windows - this is a unix-specific test
   5 // ignore-cloudabi no processes
   6 // ignore-emscripten no processes
   7 // ignore-sgx no processes
   8 #![feature(process_exec, rustc_private)]
   9
  10 extern crate libc;
  11
  12 use std::env;
  13 use std::io::Error;
  14 use std::os::unix::process::CommandExt;
  15 use std::process::Command;
  16 use std::sync::atomic::{AtomicUsize, Ordering};
  17 use std::sync::Arc;
  18
  19 fn main() {
  20     if let Some(arg) = env::args().nth(1) {
  21         match &arg[..] {
  22             "test1" => println!("hello2"),
  23             "test2" => assert_eq!(env::var("FOO").unwrap(), "BAR"),
  24             "test3" => assert_eq!(env::current_dir().unwrap().to_str().unwrap(), "/"),
  25             "empty" => {}
  26             _ => panic!("unknown argument: {}", arg),
  27         }
  28         return;
  29     }
  30
  31     let me = env::current_exe().unwrap();
  32
  33     let output = unsafe {
  34         Command::new(&me)
  35             .arg("test1")
  36             .pre_exec(|| {
  37                 println!("hello");
  38                 Ok(())
  39             })
  40             .output()
  41             .unwrap()
  42     };
  43     assert!(output.status.success());
  44     assert!(output.stderr.is_empty());
  45     assert_eq!(output.stdout, b"hello\nhello2\n");
  46
  47     let output = unsafe {
  48         Command::new(&me)
  49             .arg("test2")
  50             .pre_exec(|| {
  51                 env::set_var("FOO", "BAR");
  52                 Ok(())
  53             })
  54             .output()
  55             .unwrap()
  56     };
  57     assert!(output.status.success());
  58     assert!(output.stderr.is_empty());
  59     assert!(output.stdout.is_empty());
  60
  61     let output = unsafe {
  62         Command::new(&me)
  63             .arg("test3")
  64             .pre_exec(|| {
  65                 env::set_current_dir("/").unwrap();
  66                 Ok(())
  67             })
  68             .output()
  69             .unwrap()
  70     };
  71     assert!(output.status.success());
  72     assert!(output.stderr.is_empty());
  73     assert!(output.stdout.is_empty());
  74
  75     let output = unsafe {
  76         Command::new(&me)
  77             .arg("bad")
  78             .pre_exec(|| Err(Error::from_raw_os_error(102)))
  79             .output()
  80             .unwrap_err()
  81     };
  82     assert_eq!(output.raw_os_error(), Some(102));
  83
  84     let pid = unsafe { libc::getpid() };
  85     assert!(pid >= 0);
  86     let output = unsafe {
  87         Command::new(&me)
  88             .arg("empty")
  89             .pre_exec(move || {
  90                 let child = libc::getpid();
  91                 assert!(child >= 0);
  92                 assert!(pid != child);
  93                 Ok(())
  94             })
  95             .output()
  96             .unwrap()
  97     };
  98     assert!(output.status.success());
  99     assert!(output.stderr.is_empty());
 100     assert!(output.stdout.is_empty());
 101
 102     let mem = Arc::new(AtomicUsize::new(0));
 103     let mem2 = mem.clone();
 104     let output = unsafe {
 105         Command::new(&me)
 106             .arg("empty")
 107             .pre_exec(move || {
 108                 assert_eq!(mem2.fetch_add(1, Ordering::SeqCst), 0);
 109                 Ok(())
 110             })
 111             .output()
 112             .unwrap()
 113     };
 114     assert!(output.status.success());
 115     assert!(output.stderr.is_empty());
 116     assert!(output.stdout.is_empty());
 117     assert_eq!(mem.load(Ordering::SeqCst), 0);
 118 }