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 #[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::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 #[test]
test_backtrace()87 fn test_backtrace() {
88 let error = PlainBacktrace {
89 backtrace: Backtrace::capture(),
90 };
91 assert!(error.backtrace().is_some());
92
93 let error = ExplicitBacktrace {
94 backtrace: Backtrace::capture(),
95 };
96 assert!(error.backtrace().is_some());
97
98 let error = OptBacktrace {
99 backtrace: Some(Backtrace::capture()),
100 };
101 assert!(error.backtrace().is_some());
102
103 let error = ArcBacktrace {
104 backtrace: Arc::new(Backtrace::capture()),
105 };
106 assert!(error.backtrace().is_some());
107
108 let error = BacktraceFrom::from(Inner);
109 assert!(error.backtrace().is_some());
110
111 let error = CombinedBacktraceFrom::from(InnerBacktrace {
112 backtrace: Backtrace::capture(),
113 });
114 assert!(error.backtrace().is_some());
115
116 let error = OptBacktraceFrom::from(Inner);
117 assert!(error.backtrace().is_some());
118
119 let error = ArcBacktraceFrom::from(Inner);
120 assert!(error.backtrace().is_some());
121 }
122 }
123
124 #[cfg(thiserror_nightly_testing)]
125 pub mod enums {
126 use super::{Inner, InnerBacktrace};
127 use std::backtrace::Backtrace;
128 use std::error::Error;
129 use std::sync::Arc;
130 use thiserror::Error;
131
132 #[derive(Error, Debug)]
133 pub enum PlainBacktrace {
134 #[error("...")]
135 Test { backtrace: Backtrace },
136 }
137
138 #[derive(Error, Debug)]
139 pub enum ExplicitBacktrace {
140 #[error("...")]
141 Test {
142 #[backtrace]
143 backtrace: Backtrace,
144 },
145 }
146
147 #[derive(Error, Debug)]
148 pub enum OptBacktrace {
149 #[error("...")]
150 Test {
151 #[backtrace]
152 backtrace: Option<Backtrace>,
153 },
154 }
155
156 #[derive(Error, Debug)]
157 pub enum ArcBacktrace {
158 #[error("...")]
159 Test {
160 #[backtrace]
161 backtrace: Arc<Backtrace>,
162 },
163 }
164
165 #[derive(Error, Debug)]
166 pub enum BacktraceFrom {
167 #[error("...")]
168 Test {
169 #[from]
170 source: Inner,
171 #[backtrace]
172 backtrace: Backtrace,
173 },
174 }
175
176 #[derive(Error, Debug)]
177 pub enum CombinedBacktraceFrom {
178 #[error("...")]
179 Test {
180 #[from]
181 #[backtrace]
182 source: InnerBacktrace,
183 },
184 }
185
186 #[derive(Error, Debug)]
187 pub enum OptBacktraceFrom {
188 #[error("...")]
189 Test {
190 #[from]
191 source: Inner,
192 #[backtrace]
193 backtrace: Option<Backtrace>,
194 },
195 }
196
197 #[derive(Error, Debug)]
198 pub enum ArcBacktraceFrom {
199 #[error("...")]
200 Test {
201 #[from]
202 source: Inner,
203 #[backtrace]
204 backtrace: Arc<Backtrace>,
205 },
206 }
207
208 #[test]
test_backtrace()209 fn test_backtrace() {
210 let error = PlainBacktrace::Test {
211 backtrace: Backtrace::capture(),
212 };
213 assert!(error.backtrace().is_some());
214
215 let error = ExplicitBacktrace::Test {
216 backtrace: Backtrace::capture(),
217 };
218 assert!(error.backtrace().is_some());
219
220 let error = OptBacktrace::Test {
221 backtrace: Some(Backtrace::capture()),
222 };
223 assert!(error.backtrace().is_some());
224
225 let error = ArcBacktrace::Test {
226 backtrace: Arc::new(Backtrace::capture()),
227 };
228 assert!(error.backtrace().is_some());
229
230 let error = BacktraceFrom::from(Inner);
231 assert!(error.backtrace().is_some());
232
233 let error = CombinedBacktraceFrom::from(InnerBacktrace {
234 backtrace: Backtrace::capture(),
235 });
236 assert!(error.backtrace().is_some());
237
238 let error = OptBacktraceFrom::from(Inner);
239 assert!(error.backtrace().is_some());
240
241 let error = ArcBacktraceFrom::from(Inner);
242 assert!(error.backtrace().is_some());
243 }
244 }
245
246 #[test]
247 #[cfg_attr(not(thiserror_nightly_testing), ignore)]
test_backtrace()248 fn test_backtrace() {}
249