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 // compile-flags:-Cstrip=none
   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 #[cfg(not(panic = "abort"))]
  48 fn contains_verbose_expected(s: &str, fn_name: &str) -> bool {
  49     // HACK(eddyb) work around the fact that verbosely demangled stack traces
  50     // (from `RUST_BACKTRACE=full`, or, as is the case here, panic-in-panic)
  51     // may contain symbols with hashes in them, i.e. `backtrace[...]::`.
  52     let prefix = " backtrace";
  53     let suffix = &format!("::{}", fn_name);
  54     s.match_indices(prefix).any(|(i, _)| {
  55         s[i + prefix.len()..]
  56             .trim_start_matches('[')
  57             .trim_start_matches(char::is_alphanumeric)
  58             .trim_start_matches(']')
  59             .starts_with(suffix)
  60     })
  61 }
  62
  63 fn runtest(me: &str) {
  64     // Make sure that the stack trace is printed
  65     let p = template(me).arg("fail").env("RUST_BACKTRACE", "1").spawn().unwrap();
  66     let out = p.wait_with_output().unwrap();
  67     assert!(!out.status.success());
  68     let s = str::from_utf8(&out.stderr).unwrap();
  69     assert!(s.contains("stack backtrace") && s.contains(&expected("foo")),
  70             "bad output: {}", s);
  71     assert!(s.contains(" 0:"), "the frame number should start at 0");
  72
  73     // Make sure the stack trace is *not* printed
  74     // (Remove RUST_BACKTRACE from our own environment, in case developer
  75     // is running `make check` with it on.)
  76     let p = template(me).arg("fail").env_remove("RUST_BACKTRACE").spawn().unwrap();
  77     let out = p.wait_with_output().unwrap();
  78     assert!(!out.status.success());
  79     let s = str::from_utf8(&out.stderr).unwrap();
  80     assert!(!s.contains("stack backtrace") && !s.contains(&expected("foo")),
  81             "bad output2: {}", s);
  82
  83     // Make sure the stack trace is *not* printed
  84     // (RUST_BACKTRACE=0 acts as if it were unset from our own environment,
  85     // in case developer is running `make check` with it set.)
  86     let p = template(me).arg("fail").env("RUST_BACKTRACE","0").spawn().unwrap();
  87     let out = p.wait_with_output().unwrap();
  88     assert!(!out.status.success());
  89     let s = str::from_utf8(&out.stderr).unwrap();
  90     assert!(!s.contains("stack backtrace") && !s.contains(" - foo"),
  91             "bad output3: {}", s);
  92
  93     #[cfg(not(panic = "abort"))]
  94     {
  95         // Make sure a stack trace is printed
  96         let p = template(me).arg("double-fail").spawn().unwrap();
  97         let out = p.wait_with_output().unwrap();
  98         assert!(!out.status.success());
  99         let s = str::from_utf8(&out.stderr).unwrap();
 100         // loosened the following from double::h to double:: due to
 101         // spurious failures on mac, 32bit, optimized
 102         assert!(s.contains("stack backtrace") && contains_verbose_expected(s, "double"),
 103                 "bad output3: {}", s);
 104
 105         // Make sure a stack trace isn't printed too many times
 106         let p = template(me).arg("double-fail")
 107                                     .env("RUST_BACKTRACE", "1").spawn().unwrap();
 108         let out = p.wait_with_output().unwrap();
 109         assert!(!out.status.success());
 110         let s = str::from_utf8(&out.stderr).unwrap();
 111         let mut i = 0;
 112         for _ in 0..2 {
 113             i += s[i + 10..].find("stack backtrace").unwrap() + 10;
 114         }
 115         assert!(s[i + 10..].find("stack backtrace").is_none(),
 116                 "bad output4: {}", s);
 117     }
 118 }
 119
 120 fn main() {
 121     let args: Vec<String> = env::args().collect();
 122     if args.len() >= 2 && args[1] == "fail" {
 123         foo();
 124     } else if args.len() >= 2 && args[1] == "double-fail" {
 125         double();
 126     } else {
 127         runtest(&args[0]);
 128     }
 129 }