src/test/ui/backtrace.rs

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