src/test/run-pass/backtrace.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 // ignore-android FIXME #17520
  12 // ignore-emscripten spawning processes is not supported
  13 // ignore-openbsd no support for libbacktrace without filename
  14 // compile-flags:-g
  15
  16 use std::env;
  17 use std::process::{Command, Stdio};
  18 use std::str;
  19
  20 #[inline(never)]
  21 fn foo() {
  22     let _v = vec![1, 2, 3];
  23     if env::var_os("IS_TEST").is_some() {
  24         panic!()
  25     }
  26 }
  27
  28 #[inline(never)]
  29 fn double() {
  30     struct Double;
  31
  32     impl Drop for Double {
  33         fn drop(&mut self) { panic!("twice") }
  34     }
  35
  36     let _d = Double;
  37
  38     panic!("once");
  39 }
  40
  41 fn template(me: &str) -> Command {
  42     let mut m = Command::new(me);
  43     m.env("IS_TEST", "1")
  44      .stdout(Stdio::piped())
  45      .stderr(Stdio::piped());
  46     return m;
  47 }
  48
  49 fn expected(fn_name: &str) -> String {
  50     format!(" backtrace::{}", fn_name)
  51 }
  52
  53 fn runtest(me: &str) {
  54     // Make sure that the stack trace is printed
  55     let p = template(me).arg("fail").env("RUST_BACKTRACE", "1").spawn().unwrap();
  56     let out = p.wait_with_output().unwrap();
  57     assert!(!out.status.success());
  58     let s = str::from_utf8(&out.stderr).unwrap();
  59     assert!(s.contains("stack backtrace") && s.contains(&expected("foo")),
  60             "bad output: {}", s);
  61     assert!(s.contains(" 0:"), "the frame number should start at 0");
  62
  63     // Make sure the stack trace is *not* printed
  64     // (Remove RUST_BACKTRACE from our own environment, in case developer
  65     // is running `make check` with it on.)
  66     let p = template(me).arg("fail").env_remove("RUST_BACKTRACE").spawn().unwrap();
  67     let out = p.wait_with_output().unwrap();
  68     assert!(!out.status.success());
  69     let s = str::from_utf8(&out.stderr).unwrap();
  70     assert!(!s.contains("stack backtrace") && !s.contains(&expected("foo")),
  71             "bad output2: {}", s);
  72
  73     // Make sure the stack trace is *not* printed
  74     // (RUST_BACKTRACE=0 acts as if it were unset from our own environment,
  75     // in case developer is running `make check` with it set.)
  76     let p = template(me).arg("fail").env("RUST_BACKTRACE","0").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(" - foo"),
  81             "bad output3: {}", s);
  82
  83     // Make sure a stack trace is printed
  84     let p = template(me).arg("double-fail").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     // loosened the following from double::h to double:: due to
  89     // spurious failures on mac, 32bit, optimized
  90     assert!(s.contains("stack backtrace") && s.contains(&expected("double")),
  91             "bad output3: {}", s);
  92
  93     // Make sure a stack trace isn't printed too many times
  94     let p = template(me).arg("double-fail")
  95                                 .env("RUST_BACKTRACE", "1").spawn().unwrap();
  96     let out = p.wait_with_output().unwrap();
  97     assert!(!out.status.success());
  98     let s = str::from_utf8(&out.stderr).unwrap();
  99     let mut i = 0;
 100     for _ in 0..2 {
 101         i += s[i + 10..].find("stack backtrace").unwrap() + 10;
 102     }
 103     assert!(s[i + 10..].find("stack backtrace").is_none(),
 104             "bad output4: {}", s);
 105 }
 106
 107 fn main() {
 108     let args: Vec<String> = env::args().collect();
 109     if args.len() >= 2 && args[1] == "fail" {
 110         foo();
 111     } else if args.len() >= 2 && args[1] == "double-fail" {
 112         double();
 113     } else {
 114         runtest(&args[0]);
 115     }
 116 }