Debian Codegraph @

test/unit/tracing/try_catch.cpp

raw
1 #include <algorithm>
2 #include <exception>
3 #include <stdexcept>
4 #include <string>
5
6 #include <gtest/gtest.h>
7 #include <gtest/gtest-matchers.h>
8 #include <gmock/gmock.h>
9 #include <gmock/gmock-matchers.h>
10
11 #include "common.hpp"
12
13 #ifdef TEST_MODULE
14 import cpptrace;
15
16 #include <cpptrace/exceptions_macros.hpp>
17 #else
18 #include <cpptrace/cpptrace.hpp>
19 #include <cpptrace/from_current.hpp>
20 #include "cpptrace/basic.hpp"
21 #endif
22
23
24 namespace {
25 template<typename E, typename... Args>
26 CPPTRACE_FORCE_NO_INLINE
27 void do_throw(Args&&... args) {
28 throw E(std::forward<Args>(args)...);
29 }
30
31 void check_trace(const cpptrace::stacktrace& trace, std::string file, int line) {
32 (void)trace;
33 (void)file;
34 (void)line;
35 #ifndef CPPTRACE_BUILD_NO_SYMBOLS
36 for(const auto& frame : trace) {
37 if(frame.filename.find(file) != std::string::npos && frame.line == line) {
38 SUCCEED();
39 return;
40 }
41 }
42 FAIL() << "Trace does not contain "<<file<<":"<<line<<"\n"<<trace.to_string();
43 #endif
44 }
45
46 void check_trace(const cpptrace::stacktrace& trace, std::string try_name) {
47 EXPECT_NE(
48 std::find_if(
49 trace.begin(),
50 trace.end(),
51 [&] (const cpptrace::stacktrace_frame& frame) {
52 return frame.symbol.find(try_name) != std::string::npos;
53 }
54 ),
55 trace.end()
56 ) << trace;
57 EXPECT_NE(
58 std::find_if(
59 trace.begin(),
60 trace.end(),
61 [&] (const cpptrace::stacktrace_frame& frame) {
62 return frame.symbol.find("do_throw") != std::string::npos;
63 }
64 ),
65 trace.end()
66 ) << trace;
67 }
68 }
69
70 TEST(TryCatch, Basic) {
71 std::string test_name = __func__;
72 int line = 0;
73 bool did_catch = false;
74 cpptrace::try_catch(
75 [&] {
76 line = __LINE__ + 1;
77 do_throw<std::runtime_error>("foobar");
78 },
79 [&] (const std::runtime_error& e) {
80 did_catch = true;
81 EXPECT_EQ(e.what(), std::string("foobar"));
82 check_trace(cpptrace::from_current_exception(), "try_catch.cpp", line);
83 check_trace(cpptrace::from_current_exception(), test_name);
84 }
85 );
86 EXPECT_TRUE(did_catch);
87 }
88
89 TEST(TryCatch, NoException) {
90 bool did_try = false;
91 cpptrace::try_catch(
92 [&] {
93 did_try = true;
94 },
95 [&] (const std::runtime_error&) {
96 FAIL();
97 }
98 );
99 EXPECT_TRUE(did_try);
100 }
101
102 TEST(TryCatch, Upcast) {
103 std::string test_name = __func__;
104 int line = 0;
105 bool did_catch = false;
106 cpptrace::try_catch(
107 [&] {
108 line = __LINE__ + 1;
109 do_throw<std::runtime_error>("foobar");
110 },
111 [&] (const std::exception& e) {
112 did_catch = true;
113 EXPECT_EQ(e.what(), std::string("foobar"));
114 check_trace(cpptrace::from_current_exception(), "try_catch.cpp", line);
115 check_trace(cpptrace::from_current_exception(), test_name);
116 }
117 );
118 EXPECT_TRUE(did_catch);
119 }
120
121 TEST(TryCatch, NoHandler) {
122 int line = 0;
123 bool did_catch = false;
124 try {
125 cpptrace::try_catch(
126 [&] {
127 line = __LINE__ + 1;
128 do_throw<std::exception>();
129 },
130 [&] (const std::runtime_error&) {
131 FAIL();
132 }
133 );
134 FAIL();
135 } catch(...) {
136 did_catch = true;
137 }
138 EXPECT_TRUE(did_catch);
139 }
140
141 TEST(TryCatch, NoMatchingHandler) {
142 int line = 0;
143 bool did_catch = false;
144 try {
145 cpptrace::try_catch(
146 [&] {
147 line = __LINE__ + 1;
148 do_throw<std::exception>();
149 }
150 );
151 FAIL();
152 } catch(...) {
153 did_catch = true;
154 }
155 EXPECT_TRUE(did_catch);
156 }
157
158 TEST(TryCatch, CorrectHandler) {
159 std::string test_name = __func__;
160 int line = 0;
161 bool did_catch = false;
162 cpptrace::try_catch(
163 [&] {
164 line = __LINE__ + 1;
165 do_throw<std::runtime_error>("foobar");
166 },
167 [&] (int) {
168 FAIL();
169 },
170 [&] (const std::logic_error&) {
171 FAIL();
172 },
173 [&] (const std::runtime_error& e) {
174 did_catch = true;
175 EXPECT_EQ(e.what(), std::string("foobar"));
176 check_trace(cpptrace::from_current_exception(), "try_catch.cpp", line);
177 check_trace(cpptrace::from_current_exception(), test_name);
178 },
179 [&] (const std::exception&) {
180 FAIL();
181 }
182 );
183 EXPECT_TRUE(did_catch);
184 }
185
186 TEST(TryCatch, BlanketHandler) {
187 std::string test_name = __func__;
188 int line = 0;
189 bool did_catch = false;
190 cpptrace::try_catch(
191 [&] {
192 line = __LINE__ + 1;
193 do_throw<std::exception>();
194 },
195 [&] (int) {
196 FAIL();
197 },
198 [&] (const std::logic_error&) {
199 FAIL();
200 },
201 [&] (const std::runtime_error&) {
202 FAIL();
203 },
204 [&] () {
205 did_catch = true;
206 check_trace(cpptrace::from_current_exception(), "try_catch.cpp", line);
207 check_trace(cpptrace::from_current_exception(), test_name);
208 }
209 );
210 EXPECT_TRUE(did_catch);
211 }
212
213 TEST(TryCatch, CatchOrdering) {
214 std::string test_name = __func__;
215 int line = 0;
216 bool did_catch = false;
217 cpptrace::try_catch(
218 [&] {
219 line = __LINE__ + 1;
220 do_throw<std::runtime_error>("foobar");
221 },
222 [&] (int) {
223 FAIL();
224 },
225 [&] (const std::logic_error&) {
226 FAIL();
227 },
228 [&] () {
229 did_catch = true;
230 check_trace(cpptrace::from_current_exception(), "try_catch.cpp", line);
231 check_trace(cpptrace::from_current_exception(), test_name);
232 },
233 [&] (const std::runtime_error&) {
234 FAIL();
235 }
236 );
237 EXPECT_TRUE(did_catch);
238 }
239
240 namespace {
241 struct copy_move_tracker {
242 static int copy;
243 static int move;
244 copy_move_tracker() = default;
245 copy_move_tracker(const copy_move_tracker&) {
246 copy++;
247 }
248 copy_move_tracker(copy_move_tracker&&) {
249 move++;
250 }
251 copy_move_tracker& operator=(const copy_move_tracker&) {
252 copy++;
253 return *this;
254 }
255 copy_move_tracker& operator=(copy_move_tracker&&) {
256 move++;
257 return *this;
258 }
259 static void reset() {
260 copy = 0;
261 move = 0;
262 }
263 };
264 int copy_move_tracker::copy = 0;
265 int copy_move_tracker::move = 0;
266 }
267
268 TEST(TryCatch, Value) {
269 bool did_catch = false;
270 copy_move_tracker::reset();
271 cpptrace::try_catch(
272 [&] {
273 do_throw<copy_move_tracker>();
274 },
275 [&] (copy_move_tracker) {
276 did_catch = true;
277 }
278 );
279 EXPECT_TRUE(did_catch);
280 EXPECT_EQ(copy_move_tracker::copy, 1); // from the catch
281 EXPECT_EQ(copy_move_tracker::move, 1); // from the forward to the catcher
282 }
283
284 TEST(TryCatch, Ref) {
285 bool did_catch = false;
286 copy_move_tracker::reset();
287 cpptrace::try_catch(
288 [&] {
289 do_throw<copy_move_tracker>();
290 },
291 [&] (copy_move_tracker&) {
292 did_catch = true;
293 }
294 );
295 EXPECT_TRUE(did_catch);
296 EXPECT_EQ(copy_move_tracker::copy, 0);
297 EXPECT_EQ(copy_move_tracker::move, 0);
298 }
299
300 TEST(TryCatch, ConstRef) {
301 bool did_catch = false;
302 copy_move_tracker::reset();
303 cpptrace::try_catch(
304 [&] {
305 do_throw<copy_move_tracker>();
306 },
307 [&] (const copy_move_tracker&) {
308 did_catch = true;
309 }
310 );
311 EXPECT_TRUE(did_catch);
312 EXPECT_EQ(copy_move_tracker::copy, 0);
313 EXPECT_EQ(copy_move_tracker::move, 0);
314 }
315
316 namespace {
317 struct copy_move_tracker_callable {
318 static int copy;
319 static int move;
320 copy_move_tracker_callable() = default;
321 copy_move_tracker_callable(const copy_move_tracker&) {
322 copy++;
323 }
324 copy_move_tracker_callable(copy_move_tracker&&) {
325 move++;
326 }
327 copy_move_tracker_callable& operator=(const copy_move_tracker&) {
328 copy++;
329 return *this;
330 }
331 copy_move_tracker_callable& operator=(copy_move_tracker&&) {
332 move++;
333 return *this;
334 }
335 static void reset() {
336 copy = 0;
337 move = 0;
338 }
339 void operator()() const {}
340 };
341 int copy_move_tracker_callable::copy;
342 int copy_move_tracker_callable::move;
343 }
344
345 TEST(TryCatch, LvalueCallable) {
346 copy_move_tracker_callable::reset();
347 copy_move_tracker_callable c;
348 cpptrace::try_catch(
349 c,
350 c
351 );
352 EXPECT_EQ(copy_move_tracker_callable::copy, 0);
353 EXPECT_EQ(copy_move_tracker_callable::move, 0);
354 }
355
356 TEST(TryCatch, RvalueCallable) {
357 copy_move_tracker_callable::reset();
358 cpptrace::try_catch(
359 copy_move_tracker_callable{},
360 copy_move_tracker_callable{}
361 );
362 EXPECT_EQ(copy_move_tracker_callable::copy, 0);
363 EXPECT_EQ(copy_move_tracker_callable::move, 0);
364 }
365
366 TEST(TryCatch, ClvalueCallable) {
367 copy_move_tracker_callable::reset();
368 const copy_move_tracker_callable c;
369 cpptrace::try_catch(
370 c,
371 c
372 );
373 EXPECT_EQ(copy_move_tracker_callable::copy, 0);
374 EXPECT_EQ(copy_move_tracker_callable::move, 0);
375 }
376
377 TEST(TryCatch, CrvalueCallable) {
378 copy_move_tracker_callable::reset();
379 cpptrace::try_catch(
380 static_cast<const copy_move_tracker_callable&&>(copy_move_tracker_callable{}),
381 static_cast<const copy_move_tracker_callable&&>(copy_move_tracker_callable{})
382 );
383 EXPECT_EQ(copy_move_tracker_callable::copy, 0);
384 EXPECT_EQ(copy_move_tracker_callable::move, 0);
385 }