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