library/std/src/backtrace/tests.rs

   1 use super::*;
   2
   3 fn generate_fake_frames() -> Vec<BacktraceFrame> {
   4     vec![
   5         BacktraceFrame {
   6             frame: RawFrame::Fake,
   7             symbols: vec![BacktraceSymbol {
   8                 name: Some(b"std::backtrace::Backtrace::create".to_vec()),
   9                 filename: Some(BytesOrWide::Bytes(b"rust/backtrace.rs".to_vec())),
  10                 lineno: Some(100),
  11                 colno: None,
  12             }],
  13         },
  14         BacktraceFrame {
  15             frame: RawFrame::Fake,
  16             symbols: vec![BacktraceSymbol {
  17                 name: Some(b"__rust_maybe_catch_panic".to_vec()),
  18                 filename: None,
  19                 lineno: None,
  20                 colno: None,
  21             }],
  22         },
  23         BacktraceFrame {
  24             frame: RawFrame::Fake,
  25             symbols: vec![
  26                 BacktraceSymbol {
  27                     name: Some(b"std::rt::lang_start_internal".to_vec()),
  28                     filename: Some(BytesOrWide::Bytes(b"rust/rt.rs".to_vec())),
  29                     lineno: Some(300),
  30                     colno: Some(5),
  31                 },
  32                 BacktraceSymbol {
  33                     name: Some(b"std::rt::lang_start".to_vec()),
  34                     filename: Some(BytesOrWide::Bytes(b"rust/rt.rs".to_vec())),
  35                     lineno: Some(400),
  36                     colno: None,
  37                 },
  38             ],
  39         },
  40     ]
  41 }
  42
  43 #[test]
  44 fn test_debug() {
  45     let backtrace = Backtrace {
  46         inner: Inner::Captured(LazilyResolvedCapture::new(Capture {
  47             actual_start: 1,
  48             resolved: true,
  49             frames: generate_fake_frames(),
  50         })),
  51     };
  52
  53     #[rustfmt::skip]
  54     let expected = "Backtrace [\
  55     \n    { fn: \"__rust_maybe_catch_panic\" },\
  56     \n    { fn: \"std::rt::lang_start_internal\", file: \"rust/rt.rs\", line: 300 },\
  57     \n    { fn: \"std::rt::lang_start\", file: \"rust/rt.rs\", line: 400 },\
  58     \n]";
  59
  60     assert_eq!(format!("{backtrace:#?}"), expected);
  61
  62     // Format the backtrace a second time, just to make sure lazily resolved state is stable
  63     assert_eq!(format!("{backtrace:#?}"), expected);
  64 }
  65
  66 #[test]
  67 fn test_frames() {
  68     let backtrace = Backtrace {
  69         inner: Inner::Captured(LazilyResolvedCapture::new(Capture {
  70             actual_start: 1,
  71             resolved: true,
  72             frames: generate_fake_frames(),
  73         })),
  74     };
  75
  76     let frames = backtrace.frames();
  77
  78     #[rustfmt::skip]
  79     let expected = vec![
  80         "[
  81     { fn: \"std::backtrace::Backtrace::create\", file: \"rust/backtrace.rs\", line: 100 },
  82 ]",
  83         "[
  84     { fn: \"__rust_maybe_catch_panic\" },
  85 ]",
  86         "[
  87     { fn: \"std::rt::lang_start_internal\", file: \"rust/rt.rs\", line: 300 },
  88     { fn: \"std::rt::lang_start\", file: \"rust/rt.rs\", line: 400 },
  89 ]"
  90     ];
  91
  92     let mut iter = frames.iter().zip(expected.iter());
  93
  94     assert!(iter.all(|(f, e)| format!("{f:#?}") == *e));
  95 }