1 #![cfg_attr(thiserror_nightly_testing, feature(error_generic_member_access))]
2 
3 use thiserror::Error;
4 
5 #[derive(Error, Debug)]
6 #[error("...")]
7 pub struct Inner;
8 
9 #[cfg(thiserror_nightly_testing)]
10 #[derive(Error, Debug)]
11 #[error("...")]
12 pub struct InnerBacktrace {
13     backtrace: std::backtrace::Backtrace,
14 }
15 
16 #[cfg(thiserror_nightly_testing)]
17 pub mod structs {
18     use super::{Inner, InnerBacktrace};
19     use std::backtrace::Backtrace;
20     use std::error::{self, Error};
21     use std::sync::Arc;
22     use thiserror::Error;
23 
24     #[derive(Error, Debug)]
25     #[error("...")]
26     pub struct PlainBacktrace {
27         backtrace: Backtrace,
28     }
29 
30     #[derive(Error, Debug)]
31     #[error("...")]
32     pub struct ExplicitBacktrace {
33         #[backtrace]
34         backtrace: Backtrace,
35     }
36 
37     #[derive(Error, Debug)]
38     #[error("...")]
39     pub struct OptBacktrace {
40         #[backtrace]
41         backtrace: Option<Backtrace>,
42     }
43 
44     #[derive(Error, Debug)]
45     #[error("...")]
46     pub struct ArcBacktrace {
47         #[backtrace]
48         backtrace: Arc<Backtrace>,
49     }
50 
51     #[derive(Error, Debug)]
52     #[error("...")]
53     pub struct BacktraceFrom {
54         #[from]
55         source: Inner,
56         #[backtrace]
57         backtrace: Backtrace,
58     }
59 
60     #[derive(Error, Debug)]
61     #[error("...")]
62     pub struct CombinedBacktraceFrom {
63         #[from]
64         #[backtrace]
65         source: InnerBacktrace,
66     }
67 
68     #[derive(Error, Debug)]
69     #[error("...")]
70     pub struct OptBacktraceFrom {
71         #[from]
72         source: Inner,
73         #[backtrace]
74         backtrace: Option<Backtrace>,
75     }
76 
77     #[derive(Error, Debug)]
78     #[error("...")]
79     pub struct ArcBacktraceFrom {
80         #[from]
81         source: Inner,
82         #[backtrace]
83         backtrace: Arc<Backtrace>,
84     }
85 
86     #[derive(Error, Debug)]
87     #[error("...")]
88     pub struct AnyhowBacktrace {
89         #[backtrace]
90         source: anyhow::Error,
91     }
92 
93     #[derive(Error, Debug)]
94     #[error("...")]
95     pub struct BoxDynErrorBacktrace {
96         #[backtrace]
97         source: Box<dyn Error>,
98     }
99 
100     #[test]
test_backtrace()101     fn test_backtrace() {
102         let error = PlainBacktrace {
103             backtrace: Backtrace::capture(),
104         };
105         assert!(error::request_ref::<Backtrace>(&error).is_some());
106 
107         let error = ExplicitBacktrace {
108             backtrace: Backtrace::capture(),
109         };
110         assert!(error::request_ref::<Backtrace>(&error).is_some());
111 
112         let error = OptBacktrace {
113             backtrace: Some(Backtrace::capture()),
114         };
115         assert!(error::request_ref::<Backtrace>(&error).is_some());
116 
117         let error = ArcBacktrace {
118             backtrace: Arc::new(Backtrace::capture()),
119         };
120         assert!(error::request_ref::<Backtrace>(&error).is_some());
121 
122         let error = BacktraceFrom::from(Inner);
123         assert!(error::request_ref::<Backtrace>(&error).is_some());
124 
125         let error = CombinedBacktraceFrom::from(InnerBacktrace {
126             backtrace: Backtrace::capture(),
127         });
128         assert!(error::request_ref::<Backtrace>(&error).is_some());
129 
130         let error = OptBacktraceFrom::from(Inner);
131         assert!(error::request_ref::<Backtrace>(&error).is_some());
132 
133         let error = ArcBacktraceFrom::from(Inner);
134         assert!(error::request_ref::<Backtrace>(&error).is_some());
135 
136         let error = AnyhowBacktrace {
137             source: anyhow::Error::msg("..."),
138         };
139         assert!(error::request_ref::<Backtrace>(&error).is_some());
140 
141         let error = BoxDynErrorBacktrace {
142             source: Box::new(PlainBacktrace {
143                 backtrace: Backtrace::capture(),
144             }),
145         };
146         assert!(error::request_ref::<Backtrace>(&error).is_some());
147     }
148 }
149 
150 #[cfg(thiserror_nightly_testing)]
151 pub mod enums {
152     use super::{Inner, InnerBacktrace};
153     use std::backtrace::Backtrace;
154     use std::error;
155     use std::sync::Arc;
156     use thiserror::Error;
157 
158     #[derive(Error, Debug)]
159     pub enum PlainBacktrace {
160         #[error("...")]
161         Test { backtrace: Backtrace },
162     }
163 
164     #[derive(Error, Debug)]
165     pub enum ExplicitBacktrace {
166         #[error("...")]
167         Test {
168             #[backtrace]
169             backtrace: Backtrace,
170         },
171     }
172 
173     #[derive(Error, Debug)]
174     pub enum OptBacktrace {
175         #[error("...")]
176         Test {
177             #[backtrace]
178             backtrace: Option<Backtrace>,
179         },
180     }
181 
182     #[derive(Error, Debug)]
183     pub enum ArcBacktrace {
184         #[error("...")]
185         Test {
186             #[backtrace]
187             backtrace: Arc<Backtrace>,
188         },
189     }
190 
191     #[derive(Error, Debug)]
192     pub enum BacktraceFrom {
193         #[error("...")]
194         Test {
195             #[from]
196             source: Inner,
197             #[backtrace]
198             backtrace: Backtrace,
199         },
200     }
201 
202     #[derive(Error, Debug)]
203     pub enum CombinedBacktraceFrom {
204         #[error("...")]
205         Test {
206             #[from]
207             #[backtrace]
208             source: InnerBacktrace,
209         },
210     }
211 
212     #[derive(Error, Debug)]
213     pub enum OptBacktraceFrom {
214         #[error("...")]
215         Test {
216             #[from]
217             source: Inner,
218             #[backtrace]
219             backtrace: Option<Backtrace>,
220         },
221     }
222 
223     #[derive(Error, Debug)]
224     pub enum ArcBacktraceFrom {
225         #[error("...")]
226         Test {
227             #[from]
228             source: Inner,
229             #[backtrace]
230             backtrace: Arc<Backtrace>,
231         },
232     }
233 
234     #[test]
test_backtrace()235     fn test_backtrace() {
236         let error = PlainBacktrace::Test {
237             backtrace: Backtrace::capture(),
238         };
239         assert!(error::request_ref::<Backtrace>(&error).is_some());
240 
241         let error = ExplicitBacktrace::Test {
242             backtrace: Backtrace::capture(),
243         };
244         assert!(error::request_ref::<Backtrace>(&error).is_some());
245 
246         let error = OptBacktrace::Test {
247             backtrace: Some(Backtrace::capture()),
248         };
249         assert!(error::request_ref::<Backtrace>(&error).is_some());
250 
251         let error = ArcBacktrace::Test {
252             backtrace: Arc::new(Backtrace::capture()),
253         };
254         assert!(error::request_ref::<Backtrace>(&error).is_some());
255 
256         let error = BacktraceFrom::from(Inner);
257         assert!(error::request_ref::<Backtrace>(&error).is_some());
258 
259         let error = CombinedBacktraceFrom::from(InnerBacktrace {
260             backtrace: Backtrace::capture(),
261         });
262         assert!(error::request_ref::<Backtrace>(&error).is_some());
263 
264         let error = OptBacktraceFrom::from(Inner);
265         assert!(error::request_ref::<Backtrace>(&error).is_some());
266 
267         let error = ArcBacktraceFrom::from(Inner);
268         assert!(error::request_ref::<Backtrace>(&error).is_some());
269     }
270 }
271 
272 #[test]
273 #[cfg_attr(not(thiserror_nightly_testing), ignore)]
test_backtrace()274 fn test_backtrace() {}
275