src/test/ui/backtrace.rs

   1 // run-pass
   2 // ignore-android FIXME #17520
   3 // ignore-cloudabi spawning processes is not supported
   4 // ignore-emscripten spawning processes is not supported
   5 // ignore-openbsd no support for libbacktrace without filename
   6 // ignore-sgx no processes
   7 // ignore-msvc see #62897 and `backtrace-debuginfo.rs` test
   8 // compile-flags:-g
   9
  10 use std::env;
  11 use std::process::{Command, Stdio};
  12 use std::str;
  13
  14 #[inline(never)]
  15 fn foo() {
  16     let _v = vec![1, 2, 3];
  17     if env::var_os("IS_TEST").is_some() {
  18         panic!()
  19     }
  20 }
  21
  22 #[inline(never)]
  23 fn double() {
  24     struct Double;
  25
  26     impl Drop for Double {
  27         fn drop(&mut self) { panic!("twice") }
  28     }
  29
  30     let _d = Double;
  31
  32     panic!("once");
  33 }
  34
  35 fn template(me: &str) -> Command {
  36     let mut m = Command::new(me);
  37     m.env("IS_TEST", "1")
  38      .stdout(Stdio::piped())
  39      .stderr(Stdio::piped());
  40     return m;
  41 }
  42
  43 fn expected(fn_name: &str) -> String {
  44     format!(" backtrace::{}", fn_name)
  45 }
  46
  47 fn contains_verbose_expected(s: &str, fn_name: &str) -> bool {
  48     // HACK(eddyb) work around the fact that verbosely demangled stack traces
  49     // (from `RUST_BACKTRACE=full`, or, as is the case here, panic-in-panic)
  50     // may contain symbols with hashes in them, i.e. `backtrace[...]::`.
  51     let prefix = " backtrace";
  52     let suffix = &format!("::{}", fn_name);
  53     s.match_indices(prefix).any(|(i, _)| {
  54         s[i + prefix.len()..]
  55             .trim_start_matches('[')
  56             .trim_start_matches(char::is_alphanumeric)
  57             .trim_start_matches(']')
  58             .starts_with(suffix)
  59     })
  60 }
  61
  62 fn runtest(me: &str) {
  63     // Make sure that the stack trace is printed
  64     let p = template(me).arg("fail").env("RUST_BACKTRACE", "1").spawn().unwrap();
  65     let out = p.wait_with_output().unwrap();
  66     assert!(!out.status.success());
  67     let s = str::from_utf8(&out.stderr).unwrap();
  68     assert!(s.contains("stack backtrace") && s.contains(&expected("foo")),
  69             "bad output: {}", s);
  70     assert!(s.contains(" 0:"), "the frame number should start at 0");
  71
  72     // Make sure the stack trace is *not* printed
  73     // (Remove RUST_BACKTRACE from our own environment, in case developer
  74     // is running `make check` with it on.)
  75     let p = template(me).arg("fail").env_remove("RUST_BACKTRACE").spawn().unwrap();
  76     let out = p.wait_with_output().unwrap();
  77     assert!(!out.status.success());
  78     let s = str::from_utf8(&out.stderr).unwrap();
  79     assert!(!s.contains("stack backtrace") && !s.contains(&expected("foo")),
  80             "bad output2: {}", s);
  81
  82     // Make sure the stack trace is *not* printed
  83     // (RUST_BACKTRACE=0 acts as if it were unset from our own environment,
  84     // in case developer is running `make check` with it set.)
  85     let p = template(me).arg("fail").env("RUST_BACKTRACE","0").spawn().unwrap();
  86     let out = p.wait_with_output().unwrap();
  87     assert!(!out.status.success());
  88     let s = str::from_utf8(&out.stderr).unwrap();
  89     assert!(!s.contains("stack backtrace") && !s.contains(" - foo"),
  90             "bad output3: {}", s);
  91
  92     // Make sure a stack trace is printed
  93     let p = template(me).arg("double-fail").spawn().unwrap();
  94     let out = p.wait_with_output().unwrap();
  95     assert!(!out.status.success());
  96     let s = str::from_utf8(&out.stderr).unwrap();
  97     // loosened the following from double::h to double:: due to
  98     // spurious failures on mac, 32bit, optimized
  99     assert!(s.contains("stack backtrace") && contains_verbose_expected(s, "double"),
 100             "bad output3: {}", s);
 101
 102     // Make sure a stack trace isn't printed too many times
 103     let p = template(me).arg("double-fail")
 104                                 .env("RUST_BACKTRACE", "1").spawn().unwrap();
 105     let out = p.wait_with_output().unwrap();
 106     assert!(!out.status.success());
 107     let s = str::from_utf8(&out.stderr).unwrap();
 108     let mut i = 0;
 109     for _ in 0..2 {
 110         i += s[i + 10..].find("stack backtrace").unwrap() + 10;
 111     }
 112     assert!(s[i + 10..].find("stack backtrace").is_none(),
 113             "bad output4: {}", s);
 114 }
 115
 116 fn main() {
 117     let args: Vec<String> = env::args().collect();
 118     if args.len() >= 2 && args[1] == "fail" {
 119         foo();
 120     } else if args.len() >= 2 && args[1] == "double-fail" {
 121         double();
 122     } else {
 123         runtest(&args[0]);
 124     }
 125 }