vendor/thiserror/tests/test_backtrace.rs

   1 #![cfg_attr(thiserror_nightly_testing, feature(backtrace))]
   2
   3 use thiserror::Error;
   4
   5 #[derive(Error, Debug)]
   6 #[error("...")]
   7 pub struct Inner;
   8
   9 #[cfg(thiserror_nightly_testing)]
  10 pub mod structs {
  11     use super::Inner;
  12     use std::backtrace::Backtrace;
  13     use std::error::Error;
  14     use std::sync::Arc;
  15     use thiserror::Error;
  16
  17     #[derive(Error, Debug)]
  18     #[error("...")]
  19     pub struct PlainBacktrace {
  20         backtrace: Backtrace,
  21     }
  22
  23     #[derive(Error, Debug)]
  24     #[error("...")]
  25     pub struct ExplicitBacktrace {
  26         #[backtrace]
  27         backtrace: Backtrace,
  28     }
  29
  30     #[derive(Error, Debug)]
  31     #[error("...")]
  32     pub struct OptBacktrace {
  33         #[backtrace]
  34         backtrace: Option<Backtrace>,
  35     }
  36
  37     #[derive(Error, Debug)]
  38     #[error("...")]
  39     pub struct ArcBacktrace {
  40         #[backtrace]
  41         backtrace: Arc<Backtrace>,
  42     }
  43
  44     #[derive(Error, Debug)]
  45     #[error("...")]
  46     pub struct BacktraceFrom {
  47         #[from]
  48         source: Inner,
  49         #[backtrace]
  50         backtrace: Backtrace,
  51     }
  52
  53     #[derive(Error, Debug)]
  54     #[error("...")]
  55     pub struct OptBacktraceFrom {
  56         #[from]
  57         source: Inner,
  58         #[backtrace]
  59         backtrace: Option<Backtrace>,
  60     }
  61
  62     #[derive(Error, Debug)]
  63     #[error("...")]
  64     pub struct ArcBacktraceFrom {
  65         #[from]
  66         source: Inner,
  67         #[backtrace]
  68         backtrace: Arc<Backtrace>,
  69     }
  70
  71     #[test]
  72     fn test_backtrace() {
  73         let error = PlainBacktrace {
  74             backtrace: Backtrace::capture(),
  75         };
  76         assert!(error.backtrace().is_some());
  77
  78         let error = ExplicitBacktrace {
  79             backtrace: Backtrace::capture(),
  80         };
  81         assert!(error.backtrace().is_some());
  82
  83         let error = OptBacktrace {
  84             backtrace: Some(Backtrace::capture()),
  85         };
  86         assert!(error.backtrace().is_some());
  87
  88         let error = ArcBacktrace {
  89             backtrace: Arc::new(Backtrace::capture()),
  90         };
  91         assert!(error.backtrace().is_some());
  92
  93         let error = BacktraceFrom::from(Inner);
  94         assert!(error.backtrace().is_some());
  95
  96         let error = OptBacktraceFrom::from(Inner);
  97         assert!(error.backtrace().is_some());
  98
  99         let error = ArcBacktraceFrom::from(Inner);
 100         assert!(error.backtrace().is_some());
 101     }
 102 }
 103
 104 #[cfg(thiserror_nightly_testing)]
 105 pub mod enums {
 106     use super::Inner;
 107     use std::backtrace::Backtrace;
 108     use std::error::Error;
 109     use std::sync::Arc;
 110     use thiserror::Error;
 111
 112     #[derive(Error, Debug)]
 113     pub enum PlainBacktrace {
 114         #[error("...")]
 115         Test { backtrace: Backtrace },
 116     }
 117
 118     #[derive(Error, Debug)]
 119     pub enum ExplicitBacktrace {
 120         #[error("...")]
 121         Test {
 122             #[backtrace]
 123             backtrace: Backtrace,
 124         },
 125     }
 126
 127     #[derive(Error, Debug)]
 128     pub enum OptBacktrace {
 129         #[error("...")]
 130         Test {
 131             #[backtrace]
 132             backtrace: Option<Backtrace>,
 133         },
 134     }
 135
 136     #[derive(Error, Debug)]
 137     pub enum ArcBacktrace {
 138         #[error("...")]
 139         Test {
 140             #[backtrace]
 141             backtrace: Arc<Backtrace>,
 142         },
 143     }
 144
 145     #[derive(Error, Debug)]
 146     pub enum BacktraceFrom {
 147         #[error("...")]
 148         Test {
 149             #[from]
 150             source: Inner,
 151             #[backtrace]
 152             backtrace: Backtrace,
 153         },
 154     }
 155
 156     #[derive(Error, Debug)]
 157     pub enum OptBacktraceFrom {
 158         #[error("...")]
 159         Test {
 160             #[from]
 161             source: Inner,
 162             #[backtrace]
 163             backtrace: Option<Backtrace>,
 164         },
 165     }
 166
 167     #[derive(Error, Debug)]
 168     pub enum ArcBacktraceFrom {
 169         #[error("...")]
 170         Test {
 171             #[from]
 172             source: Inner,
 173             #[backtrace]
 174             backtrace: Arc<Backtrace>,
 175         },
 176     }
 177
 178     #[test]
 179     fn test_backtrace() {
 180         let error = PlainBacktrace::Test {
 181             backtrace: Backtrace::capture(),
 182         };
 183         assert!(error.backtrace().is_some());
 184
 185         let error = ExplicitBacktrace::Test {
 186             backtrace: Backtrace::capture(),
 187         };
 188         assert!(error.backtrace().is_some());
 189
 190         let error = OptBacktrace::Test {
 191             backtrace: Some(Backtrace::capture()),
 192         };
 193         assert!(error.backtrace().is_some());
 194
 195         let error = ArcBacktrace::Test {
 196             backtrace: Arc::new(Backtrace::capture()),
 197         };
 198         assert!(error.backtrace().is_some());
 199
 200         let error = BacktraceFrom::from(Inner);
 201         assert!(error.backtrace().is_some());
 202
 203         let error = OptBacktraceFrom::from(Inner);
 204         assert!(error.backtrace().is_some());
 205
 206         let error = ArcBacktraceFrom::from(Inner);
 207         assert!(error.backtrace().is_some());
 208     }
 209 }
 210
 211 #[test]
 212 #[cfg_attr(not(thiserror_nightly_testing), ignore)]
 213 fn test_backtrace() {}