Deleted vendor folder

2 files changed, 0 insertions, 801 deletions

diff --git a/vendor/backtrace-ext/src/lib.rs b/vendor/backtrace-ext/src/lib.rs
deleted file mode 100644
index b04c59d..0000000
--- a/vendor/backtrace-ext/src/lib.rs
+++ /dev/null
@@ -1,277 +0,0 @@
-//! Minor conveniences on top of the backtrace crate
-//!
-//! See [`short_frames_strict`][] for details.
-use backtrace::*;
-use std::ops::Range;
-
-#[cfg(test)]
-mod test;
-
-/// Gets an iterator over the frames that are part of Rust's "short backtrace" range.
-/// If no such range is found, the full stack is yielded.
-///
-/// Rust generally tries to include special frames on the stack called `rust_end_short_backtrace`
-/// and `rust_begin_short_backtrace` which delimit the "real" stackframes from "gunk" stackframes
-/// like setting up main and invoking the panic runtime. This yields all the "real" frames between
-/// those two (which theoretically can be nothing with enough optimization, although that's unlikely
-/// for any non-trivial program).
-///
-/// If only one of the special frames is present we will only clamp one side of the stack
-/// (similar to `a..` or `..a`). If the special frames are in the wrong order we will discard
-/// them and produce the full stack. If multiple versions of a special frame are found
-/// (I've seen it in the wild), we will pick the "innermost" ones, producing the smallest
-/// possible backtrace (and excluding all special frames from the output).
-///
-/// Each element of the iterator includes a Range which you should use to slice
-/// the frame's `symbols()` array. This handles the theoretical situation where "real" frames
-/// got inlined together with the special marker frames. I want to believe this can't happen
-/// but you can never trust backtraces to be reasonable! We will never yield a Frame to you
-/// with an empty Range.
-///
-/// Note that some "gunk" frames may still be found within the short backtrace, as there is still some
-/// platform-specific and optimization-specific glue around the edges because compilers are
-/// complicated and nothing's perfect. This can include:
-///
-/// * `core::ops::function::FnOnce::call_once`
-/// * `std::panicking::begin_panic_handler`
-/// * `core::panicking::panic_fmt`
-/// * `rust_begin_unwind`
-///
-/// In the future we may introduce a non-strict short_frames which heuristically filters
-/// those frames out too. Until then, the strict approach is safe.
-///
-/// # Example
-///
-/// Here's an example simple "short backtrace" implementation.
-/// Note the use of `sub_frames` for the inner loop to restrict `symbols`!
-///
-/// This example is based off of code found in `miette` (Apache-2.0), which itself
-/// copied the logic from `human-panic` (MIT/Apache-2.0).
-///
-/// FIXME: it would be nice if this example consulted `RUST_BACKTRACE=full`,
-/// and maybe other vars used by rust's builtin panic handler..?
-///
-/// ```
-/// fn backtrace() -> String {
-///     use std::fmt::Write;
-///     if let Ok(var) = std::env::var("RUST_BACKTRACE") {
-///         if !var.is_empty() && var != "0" {
-///             const HEX_WIDTH: usize = std::mem::size_of::<usize>() + 2;
-///             // Padding for next lines after frame's address
-///             const NEXT_SYMBOL_PADDING: usize = HEX_WIDTH + 6;
-///             let mut backtrace = String::new();
-///             let trace = backtrace::Backtrace::new();
-///             let frames = backtrace_ext::short_frames_strict(&trace).enumerate();
-///             for (idx, (frame, subframes)) in frames {
-///                 let ip = frame.ip();
-///                 let _ = write!(backtrace, "\n{:4}: {:2$?}", idx, ip, HEX_WIDTH);
-///     
-///                 let symbols = frame.symbols();
-///                 if symbols.is_empty() {
-///                     let _ = write!(backtrace, " - <unresolved>");
-///                     continue;
-///                 }
-///     
-///                 for (idx, symbol) in symbols[subframes].iter().enumerate() {
-///                     // Print symbols from this address,
-///                     // if there are several addresses
-///                     // we need to put it on next line
-///                     if idx != 0 {
-///                         let _ = write!(backtrace, "\n{:1$}", "", NEXT_SYMBOL_PADDING);
-///                     }
-///     
-///                     if let Some(name) = symbol.name() {
-///                         let _ = write!(backtrace, " - {}", name);
-///                     } else {
-///                         let _ = write!(backtrace, " - <unknown>");
-///                     }
-///     
-///                     // See if there is debug information with file name and line
-///                     if let (Some(file), Some(line)) = (symbol.filename(), symbol.lineno()) {
-///                         let _ = write!(
-///                             backtrace,
-///                             "\n{:3$}at {}:{}",
-///                             "",
-///                             file.display(),
-///                             line,
-///                             NEXT_SYMBOL_PADDING
-///                         );
-///                     }
-///                 }
-///             }
-///             return backtrace;
-///         }
-///     }
-///     "".into()
-/// }
-/// ```
-pub fn short_frames_strict(
-    backtrace: &Backtrace,
-) -> impl Iterator<Item = (&BacktraceFrame, Range<usize>)> {
-    short_frames_strict_impl(backtrace)
-}
-
-pub(crate) fn short_frames_strict_impl<B: Backtraceish>(
-    backtrace: &B,
-) -> impl Iterator<Item = (&B::Frame, Range<usize>)> {
-    // Search for the special frames
-    let mut short_start = None;
-    let mut short_end = None;
-    let frames = backtrace.frames();
-    for (frame_idx, frame) in frames.iter().enumerate() {
-        let symbols = frame.symbols();
-        for (subframe_idx, frame) in symbols.iter().enumerate() {
-            if let Some(name) = frame.name_str() {
-                // Yes these ARE backwards, and that's intentional! We want to print the frames from
-                // "newest to oldest" (show what panicked first), and that's the order that Backtrace
-                // gives us, but these magic labels view the stack in the opposite order. So we just
-                // swap it once here and forget about that weirdness.
-                //
-                // Note that due to platform/optimization wobblyness you can end up with multiple frames
-                // that contain these names in sequence. If that happens we just want to pick the two
-                // that are closest together. For the start that means just using the last one we found,
-                // and for the end that means taking the first one we find.
-                if name.contains("rust_end_short_backtrace") {
-                    short_start = Some((frame_idx, subframe_idx));
-                }
-                if name.contains("rust_begin_short_backtrace") && short_end.is_none() {
-                    short_end = Some((frame_idx, subframe_idx));
-                }
-            }
-        }
-    }
-
-    // Check if these are in the right order, if they aren't, discard them
-    // This also handles the mega-cursed case of "someone made a symbol with both names
-    // so actually they're the exact same subframe".
-    if let (Some(start), Some(end)) = (short_start, short_end) {
-        if start >= end {
-            short_start = None;
-            short_end = None;
-        }
-    }
-
-    // By default we want to produce a full stack trace and now we'll try to clamp it.
-    let mut first_frame = 0usize;
-    let mut first_subframe = 0usize;
-    // NOTE: this is INCLUSIVE
-    let mut last_frame = frames.len().saturating_sub(1);
-    // NOTE: this is EXCLUSIVE
-    let mut last_subframe_excl = backtrace
-        .frames()
-        .last()
-        .map(|frame| frame.symbols().len())
-        .unwrap_or(0);
-
-    // This code tries to be really paranoid about boundary conditions although in practice
-    // most of them are impossible because there's always going to be gunk on either side
-    // of the short backtrace to smooth out the boundaries, and panic_fmt is basically
-    // impossible to optimize out. Still, don't trust backtracers!!!
-    //
-    // This library has a fuckton of tests to try to catch all the little corner cases here.
-
-    // If we found the start bound...
-    if let Some((idx, sub_idx)) = short_start {
-        if frames[idx].symbols().len() == sub_idx + 1 {
-            // If it was the last subframe of this frame, we want to just
-            // use the whole next frame! It's ok if this takes us to `first_frame = len`,
-            // that will be properly handled as an empty output
-            first_frame = idx + 1;
-            first_subframe = 0;
-        } else {
-            // Otherwise use this frame, and all the subframes after it
-            first_frame = idx;
-            first_subframe = sub_idx + 1;
-        }
-    }
-
-    // If we found the end bound...
-    if let Some((idx, sub_idx)) = short_end {
-        if sub_idx == 0 {
-            // If it was the first subframe of this frame, we want to just
-            // use the whole previous frame!
-            if idx == 0 {
-                // If we were *also* on the first frame, set subframe_excl
-                // to 0, indicating an empty output
-                last_frame = 0;
-                last_subframe_excl = 0;
-            } else {
-                last_frame = idx - 1;
-                last_subframe_excl = frames[last_frame].symbols().len();
-            }
-        } else {
-            // Otherwise use this frame (no need subframe math, exclusive bound!)
-            last_frame = idx;
-            last_subframe_excl = sub_idx;
-        }
-    }
-
-    // If the two subframes managed to perfectly line up with eachother, just
-    // throw everything out and yield an empty range. We don't need to fix any
-    // other values at this point as they won't be used for anything with an
-    // empty iterator
-    let final_frames = {
-        let start = (first_frame, first_subframe);
-        let end = (last_frame, last_subframe_excl);
-        if start == end {
-            &frames[0..0]
-        } else {
-            &frames[first_frame..=last_frame]
-        }
-    };
-
-    // Get the index of the last frame when starting from the first frame
-    let adjusted_last_frame = last_frame.saturating_sub(first_frame);
-
-    // finally do the iteration
-    final_frames.iter().enumerate().map(move |(idx, frame)| {
-        // Default to all subframes being yielded
-        let mut sub_start = 0;
-        let mut sub_end_excl = frame.symbols().len();
-        // If we're on first frame, apply its subframe clamp
-        if idx == 0 {
-            sub_start = first_subframe;
-        }
-        // If we're on the last frame, apply its subframe clamp
-        if idx == adjusted_last_frame {
-            sub_end_excl = last_subframe_excl;
-        }
-        (frame, sub_start..sub_end_excl)
-    })
-}
-
-pub(crate) trait Backtraceish {
-    type Frame: Frameish;
-    fn frames(&self) -> &[Self::Frame];
-}
-
-pub(crate) trait Frameish {
-    type Symbol: Symbolish;
-    fn symbols(&self) -> &[Self::Symbol];
-}
-
-pub(crate) trait Symbolish {
-    fn name_str(&self) -> Option<&str>;
-}
-
-impl Backtraceish for Backtrace {
-    type Frame = BacktraceFrame;
-    fn frames(&self) -> &[Self::Frame] {
-        self.frames()
-    }
-}
-
-impl Frameish for BacktraceFrame {
-    type Symbol = BacktraceSymbol;
-    fn symbols(&self) -> &[Self::Symbol] {
-        self.symbols()
-    }
-}
-
-impl Symbolish for BacktraceSymbol {
-    // We need to shortcut SymbolName here because
-    // HRTB isn't in our msrv
-    fn name_str(&self) -> Option<&str> {
-        self.name().and_then(|n| n.as_str())
-    }
-}
diff --git a/vendor/backtrace-ext/src/test.rs b/vendor/backtrace-ext/src/test.rs
deleted file mode 100644
index d4d4112..0000000
--- a/vendor/backtrace-ext/src/test.rs
+++ /dev/null
@@ -1,524 +0,0 @@
-use super::*;
-
-type BT = &'static [&'static [&'static str]];
-
-impl Backtraceish for BT {
-    type Frame = &'static [&'static str];
-    fn frames(&self) -> &[Self::Frame] {
-        self
-    }
-}
-
-impl Frameish for &'static [&'static str] {
-    type Symbol = &'static str;
-    fn symbols(&self) -> &[Self::Symbol] {
-        self
-    }
-}
-
-impl Symbolish for &'static str {
-    fn name_str(&self) -> Option<&str> {
-        Some(self)
-    }
-}
-
-fn process(bt: BT) -> Vec<&'static str> {
-    let mut result = vec![];
-    for (frame, subframes) in short_frames_strict_impl(&bt) {
-        let symbols = &frame.symbols()[subframes];
-        assert!(!symbols.is_empty());
-        for symbol in symbols {
-            result.push(*symbol);
-        }
-    }
-    result
-}
-
-#[test]
-fn test_full() {
-    let bt: BT = &[&["hello"], &["there", "simple"], &["case"]];
-    let expected = vec!["hello", "there", "simple", "case"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_empty() {
-    let bt: BT = &[];
-    let expected: Vec<&str> = vec![];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_cursed_one_true_symbol1() {
-    let bt: BT = &[
-        &["hello"],
-        &["__rust_end_short_backtrace_rust_begin_short_backtrace"],
-        &["there"],
-    ];
-    let expected = vec![
-        "hello",
-        "__rust_end_short_backtrace_rust_begin_short_backtrace",
-        "there",
-    ];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_cursed_one_true_symbol2() {
-    let bt: BT = &[
-        &["hello"],
-        &["__rust_begin_short_backtrace_rust_end_short_backtrace"],
-        &["there"],
-    ];
-    let expected: Vec<&str> = vec![
-        "hello",
-        "__rust_begin_short_backtrace_rust_end_short_backtrace",
-        "there",
-    ];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_backwards1() {
-    let bt: BT = &[
-        &["hello"],
-        &["__rust_begin_short_backtrace"],
-        &["real"],
-        &["frames"],
-        &["rust_end_short_backtrace"],
-        &["case"],
-    ];
-    let expected = vec![
-        "hello",
-        "__rust_begin_short_backtrace",
-        "real",
-        "frames",
-        "rust_end_short_backtrace",
-        "case",
-    ];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_backwards2() {
-    let bt: BT = &[
-        &["hello"],
-        &["__rust_begin_short_backtrace", "real", "frames"],
-        &["rust_end_short_backtrace"],
-        &["case"],
-    ];
-    let expected = vec![
-        "hello",
-        "__rust_begin_short_backtrace",
-        "real",
-        "frames",
-        "rust_end_short_backtrace",
-        "case",
-    ];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_backwards3() {
-    let bt: BT = &[
-        &["hello"],
-        &["__rust_begin_short_backtrace"],
-        &["real", "frames", "rust_end_short_backtrace"],
-        &["case"],
-    ];
-    let expected = vec![
-        "hello",
-        "__rust_begin_short_backtrace",
-        "real",
-        "frames",
-        "rust_end_short_backtrace",
-        "case",
-    ];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_backwards4() {
-    let bt: BT = &[
-        &["hello"],
-        &[
-            "__rust_begin_short_backtrace",
-            "real",
-            "frames",
-            "rust_end_short_backtrace",
-        ],
-        &["case"],
-    ];
-    let expected = vec![
-        "hello",
-        "__rust_begin_short_backtrace",
-        "real",
-        "frames",
-        "rust_end_short_backtrace",
-        "case",
-    ];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_begin_clamp_simple() {
-    let bt: BT = &[&["hello"], &["__rust_begin_short_backtrace"], &["case"]];
-    let expected = vec!["hello"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_begin_clamp_left_edge() {
-    let bt: BT = &[&["__rust_begin_short_backtrace"], &["case"]];
-    let expected: Vec<&str> = vec![];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_begin_clamp_right_edge() {
-    let bt: BT = &[&["hello"], &["__rust_begin_short_backtrace"]];
-    let expected = vec!["hello"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_begin_clamp_empty() {
-    let bt: BT = &[&["__rust_begin_short_backtrace"]];
-    let expected: Vec<&str> = vec![];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_begin_clamp_sub() {
-    let bt: BT = &[
-        &["real"],
-        &["frames", "core::rust_begin_short_backtrace", "junk"],
-        &["junk"],
-    ];
-    let expected = vec!["real", "frames"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_end_clamp_simple() {
-    let bt: BT = &[&["hello"], &["__rust_end_short_backtrace"], &["case"]];
-    let expected = vec!["case"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_end_clamp_left_edge() {
-    let bt: BT = &[&["_rust_end_short_backtrace"], &["case"]];
-    let expected = vec!["case"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_end_clamp_right_edge() {
-    let bt: BT = &[&["hello"], &["__rust_end_short_backtrace"]];
-    let expected: Vec<&str> = vec![];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_end_clamp_empty() {
-    let bt: BT = &[&["__rust_end_short_backtrace"]];
-    let expected: Vec<&str> = vec![];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_end_clamp_sub() {
-    let bt: BT = &[
-        &["junk"],
-        &["junk", "__rust_end_short_backtrace", "real"],
-        &["frames"],
-    ];
-    let expected = vec!["real", "frames"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_both_simple() {
-    let bt: BT = &[
-        &["hello"],
-        &["__rust_end_short_backtrace"],
-        &["real"],
-        &["frames"],
-        &["rust_begin_short_backtrace"],
-        &["case"],
-    ];
-    let expected = vec!["real", "frames"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_both_multiball_various() {
-    let bt: BT = &[
-        &["hello"],
-        &["__rust_end_short_backtrace"],
-        &["core::rust_end_short_backtrace"],
-        &["junk"],
-        &["rust_end_short_backtrace"],
-        &["real"],
-        &["frames"],
-        &["rust_begin_short_backtrace"],
-        &["_rust_begin_short_backtrace"],
-        &["junk"],
-        &["core::rust_begin_short_backtrace"],
-        &["case"],
-    ];
-    let expected = vec!["real", "frames"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_both_multiball_identical() {
-    let bt: BT = &[
-        &["hello"],
-        &["rust_end_short_backtrace"],
-        &["rust_end_short_backtrace"],
-        &["real"],
-        &["frames"],
-        &["rust_begin_short_backtrace"],
-        &["rust_begin_short_backtrace"],
-        &["case"],
-    ];
-    let expected = vec!["real", "frames"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_both_multiball_invert1() {
-    let bt: BT = &[
-        &["hello"],
-        &["rust_end_short_backtrace"],
-        &["real"],
-        &["frames"],
-        &["rust_begin_short_backtrace"],
-        &["junk"],
-        &["rust_end_short_backtrace"],
-        &["case"],
-    ];
-    let expected = vec![
-        "hello",
-        "rust_end_short_backtrace",
-        "real",
-        "frames",
-        "rust_begin_short_backtrace",
-        "junk",
-        "rust_end_short_backtrace",
-        "case",
-    ];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_both_multiball_invert2() {
-    let bt: BT = &[
-        &["hello"],
-        &["rust_begin_short_backtrace"],
-        &["junk"],
-        &["rust_end_short_backtrace"],
-        &["real"],
-        &["frames"],
-        &["rust_begin_short_backtrace"],
-        &["case"],
-    ];
-    let expected = vec![
-        "hello",
-        "rust_begin_short_backtrace",
-        "junk",
-        "rust_end_short_backtrace",
-        "real",
-        "frames",
-        "rust_begin_short_backtrace",
-        "case",
-    ];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_both_adjacent() {
-    let bt: BT = &[
-        &["hello"],
-        &["__rust_end_short_backtrace"],
-        &["rust_begin_short_backtrace"],
-        &["case"],
-    ];
-    let expected: Vec<&str> = vec![];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_both_left_edge() {
-    let bt: BT = &[
-        &["__rust_end_short_backtrace"],
-        &["real"],
-        &["frames"],
-        &["rust_begin_short_backtrace"],
-        &["case"],
-    ];
-    let expected = vec!["real", "frames"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_both_right_edge() {
-    let bt: BT = &[
-        &["hello"],
-        &["__rust_end_short_backtrace"],
-        &["real"],
-        &["frames"],
-        &["rust_begin_short_backtrace"],
-    ];
-    let expected = vec!["real", "frames"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_both_spanned() {
-    let bt: BT = &[
-        &["__rust_end_short_backtrace"],
-        &["real"],
-        &["frames"],
-        &["__rust_begin_short_backtrace"],
-    ];
-    let expected = vec!["real", "frames"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_both_spanned_empty() {
-    let bt: BT = &[
-        &["rust_end_short_backtrace"],
-        &["rust_begin_short_backtrace"],
-    ];
-    let expected: Vec<&str> = vec![];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_one_super_frame_2() {
-    let bt: BT = &[&[
-        "rust_end_short_backtrace",
-        "real",
-        "frames",
-        "rust_begin_short_backtrace",
-    ]];
-    let expected = vec!["real", "frames"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_one_super_frame_1() {
-    let bt: BT = &[&[
-        "rust_end_short_backtrace",
-        "real",
-        "rust_begin_short_backtrace",
-    ]];
-    let expected = vec!["real"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_one_super_frame_0() {
-    let bt: BT = &[&["rust_end_short_backtrace", "rust_begin_short_backtrace"]];
-    let expected: Vec<&str> = vec![];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_complex1() {
-    let bt: BT = &[
-        &["junk"],
-        &["junk", "__rust_end_short_backtrace", "real"],
-        &["frames"],
-        &["here", "__rust_begin_short_backtrace", "junk"],
-        &["junk"],
-    ];
-    let expected = vec!["real", "frames", "here"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_complex2() {
-    let bt: BT = &[
-        &["junk"],
-        &["__rust_end_short_backtrace", "real"],
-        &["frames"],
-        &["here", "__rust_begin_short_backtrace", "junk"],
-        &["junk"],
-    ];
-    let expected = vec!["real", "frames", "here"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_complex3() {
-    let bt: BT = &[
-        &["junk"],
-        &["junk", "__rust_end_short_backtrace", "real"],
-        &["frames"],
-        &["here", "__rust_begin_short_backtrace"],
-        &["junk"],
-    ];
-    let expected = vec!["real", "frames", "here"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_complex4() {
-    let bt: BT = &[
-        &["junk"],
-        &["junk", "__rust_end_short_backtrace"],
-        &["real", "frames"],
-        &["here", "__rust_begin_short_backtrace"],
-        &["junk"],
-    ];
-    let expected = vec!["real", "frames", "here"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_complex5() {
-    let bt: BT = &[
-        &["junk"],
-        &["junk", "__rust_end_short_backtrace", "real"],
-        &["frames", "here"],
-        &["__rust_begin_short_backtrace"],
-        &["junk"],
-    ];
-    let expected = vec!["real", "frames", "here"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_complex6() {
-    let bt: BT = &[
-        &["junk"],
-        &[
-            "junk",
-            "__rust_end_short_backtrace",
-            "real",
-            "frames",
-            "here",
-        ],
-        &["__rust_begin_short_backtrace"],
-        &["junk"],
-    ];
-    let expected = vec!["real", "frames", "here"];
-    assert_eq!(process(bt), expected);
-}
-
-#[test]
-fn test_complex7() {
-    let bt: BT = &[
-        &["junk"],
-        &["junk", "__rust_end_short_backtrace"],
-        &["real", "frames", "here", "__rust_begin_short_backtrace"],
-        &["junk"],
-    ];
-    let expected = vec!["real", "frames", "here"];
-    assert_eq!(process(bt), expected);
-}