Github User Fetcher 1.0.0
C Application with Server and GUI
Loading...
Searching...
No Matches
internal/assert.h
Go to the documentation of this file.
1/*
2 * The MIT License (MIT)
3 *
4 * Copyright © 2015-2016 Franklin "Snaipe" Mathieu <http://snai.pe/>
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24#ifndef CRITERION_INTERNAL_ASSERT_H_
25#define CRITERION_INTERNAL_ASSERT_H_
26
27#include "common.h"
28#include "preprocess.h"
29#include "asprintf-compat.h"
31
32#ifdef __cplusplus
33# include <cstring>
34# include <cstdlib>
35# include <cwchar>
36#else
37# include <string.h>
38# include <stdlib.h>
39# include <stdbool.h>
40# include <wchar.h>
41#endif
42#include "../types.h"
43#include "../stats.h"
44#include "../hooks.h"
45#include "../event.h"
46#include "../abort.h"
47#include "../options.h"
48
50 const char *msg;
52
53#ifdef __cplusplus
54 constexpr criterion_assert_args(const char *msg) : msg(msg), sentinel_(0) {}
55 constexpr criterion_assert_args(const char *msg, int sentinel_) : msg(msg), sentinel_(sentinel_) {}
56#endif
57};
58
59/* Do NOT reorder unless you want to break the ABI */
75
77
78CR_API char *cr_translate_assert_msg(int msg_index, ...);
80
82
83#define CR_GET_CONDITION(Condition, ...) Condition
84#define CR_GET_CONDITION_STR(Condition, ...) #Condition
85#define CR_VA_SKIP(_, ...) __VA_ARGS__
86
87#define CR_TRANSLATE_DEF_MSG__(Arg) \
88 CR_IDENTITY Arg
89
90#define CR_TRANSLATE_DEF_MSG_(...) \
91 CR_EXPAND(cr_translate_assert_msg( \
92 CR_VA_HEAD(__VA_ARGS__), \
93 "" CR_TRANSLATE_DEF_MSG__(CR_VA_HEAD(CR_VA_TAIL(__VA_ARGS__))) \
94 ))
95
96#define CR_INIT_STATS_(MsgVar, Shifted, ...) \
97 CR_EXPAND( \
98 do { \
99 char *cr_def_msg__ = CR_EXPAND(CR_TRANSLATE_DEF_MSG_(__VA_ARGS__)); \
100 char *cr_fmt_msg__ = NULL; \
101 cr_asprintf(&cr_fmt_msg__, "x" CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__))); \
102 if (cr_fmt_msg__ && cr_fmt_msg__[1]) { \
103 MsgVar = cr_fmt_msg__ + 1; \
104 Shifted = 1; \
105 cr_asprintf_free(cr_def_msg__); \
106 } else { \
107 MsgVar = cr_def_msg__; \
108 cr_asprintf_free(cr_fmt_msg__); \
109 } \
110 } while (0))
111
112#define CR_FAIL_ABORT_ criterion_abort_test
113#define CR_FAIL_CONTINUES_ criterion_continue_test
114
115#define cr_assert_impl(Fail, Condition, ...) \
116 do { \
117 bool cr_passed__ = !!(Condition); \
118 char *cr_msg__ = NULL; \
119 int cr_shifted__ = 0; \
120 \
121 if (!cr_passed__ || criterion_options.full_stats) { \
122 CR_EXPAND(CR_INIT_STATS_(cr_msg__, cr_shifted__, \
123 CR_VA_TAIL(__VA_ARGS__))); \
124 struct criterion_assert_stats cr_stat__; \
125 cr_stat__.passed = cr_passed__; \
126 cr_stat__.file = __FILE__; \
127 cr_stat__.line = __LINE__; \
128 cr_stat__.message = cr_msg__; \
129 criterion_send_assert(&cr_stat__); \
130 \
131 cr_asprintf_free(cr_msg__ - cr_shifted__); \
132 } \
133 if (!cr_passed__) \
134 Fail(); \
135 else \
136 cri_asserts_passed_incr(); \
137 } while (0)
138
139#define cr_fail(Fail, ...) \
140 CR_EXPAND(cr_assert_impl( \
141 Fail, \
142 0, \
143 dummy, \
144 CRITERION_ASSERT_MSG_FAIL, \
145 (), \
146 __VA_ARGS__ \
147 ))
148
149#define cr_skip(...) \
150 criterion_skip_test("" __VA_ARGS__)
151
152#define cr_assert_(...) \
153 CR_EXPAND(cr_assert_impl( \
154 CR_FAIL_ABORT_, \
155 CR_VA_HEAD(__VA_ARGS__), \
156 dummy, \
157 CRITERION_ASSERT_MSG_EXPR_FALSE, \
158 (CR_STR(CR_VA_HEAD(__VA_ARGS__))), \
159 CR_VA_TAIL(__VA_ARGS__) \
160 ))
161
162#define cr_expect_(...) \
163 CR_EXPAND(cr_assert_impl( \
164 CR_FAIL_CONTINUES_, \
165 CR_VA_HEAD(__VA_ARGS__), \
166 dummy, \
167 CRITERION_ASSERT_MSG_EXPR_FALSE, \
168 (CR_STR(CR_VA_HEAD(__VA_ARGS__))), \
169 CR_VA_TAIL(__VA_ARGS__) \
170 ))
171
172#define cr_assert_not_(...) \
173 CR_EXPAND(cr_assert_impl( \
174 CR_FAIL_ABORT_, \
175 !(CR_VA_HEAD(__VA_ARGS__)), \
176 dummy, \
177 CRITERION_ASSERT_MSG_EXPR_FALSE, \
178 (CR_STR(!(CR_VA_HEAD(__VA_ARGS__)))), \
179 CR_VA_TAIL(__VA_ARGS__) \
180 ))
181
182#define cr_expect_not_(...) \
183 CR_EXPAND(cr_assert_impl( \
184 CR_FAIL_CONTINUES_, \
185 !(CR_VA_HEAD(__VA_ARGS__)), \
186 dummy, \
187 CRITERION_ASSERT_MSG_EXPR_FALSE, \
188 (CR_STR(!(CR_VA_HEAD(__VA_ARGS__)))), \
189 CR_VA_TAIL(__VA_ARGS__) \
190 ))
191
192/* Binary */
193
194#define cr_assert_op_(Fail, Op, Actual, Expected, ...) \
195 CR_EXPAND(cr_assert_impl( \
196 Fail, \
197 (Actual) Op (Expected), \
198 dummy, \
199 CRITERION_ASSERT_MSG_EXPR_FALSE, \
200 (CR_STR((Actual) Op (Expected))), \
201 __VA_ARGS__ \
202 ))
203
204#define cr_assert_op_va_(Fail, Op, ...) \
205 CR_EXPAND(cr_assert_op_( \
206 Fail, \
207 Op, \
208 CR_VA_HEAD(__VA_ARGS__), \
209 CR_VA_HEAD(CR_VA_TAIL(__VA_ARGS__)), \
210 CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__)) \
211 ))
212
213/* Unary */
214
215#define cr_assert_null_op_(Fail, Op, Msg, Value, ...) \
216 CR_EXPAND(cr_assert_impl( \
217 Fail, \
218 (Value) Op NULL, \
219 dummy, \
220 Msg, \
221 (CR_STR(Value)), \
222 __VA_ARGS__ \
223 ))
224
225#define cr_assert_null_op_va_(Fail, Op, Msg, ...) \
226 CR_EXPAND(cr_assert_null_op_( \
227 Fail, \
228 Op, \
229 Msg, \
230 CR_VA_HEAD(__VA_ARGS__), \
231 CR_VA_TAIL(__VA_ARGS__) \
232 ))
233
234/* Floating point */
235
236#define cr_assert_float_eq_op_(Actual, Expected, Epsilon) \
237 (Expected) - (Actual) <= (Epsilon) && (Actual) - (Expected) <= (Epsilon)
238
239#define cr_assert_float_neq_op_(Actual, Expected, Epsilon) \
240 (Expected) - (Actual) > (Epsilon) || (Actual) - (Expected) > (Epsilon)
241
242#define cr_assert_float_op_(Fail, Op, Actual, Expected, Epsilon, ...) \
243 CR_EXPAND(cr_assert_impl( \
244 Fail, \
245 Op (Actual, Expected, Epsilon), \
246 dummy, \
247 CRITERION_ASSERT_MSG_EXPR_FALSE, \
248 (CR_STR(Op (Actual, Expected, Epsilon))), \
249 __VA_ARGS__ \
250 ))
251
252#define cr_assert_float_op_va_(Fail, Op, ...) \
253 CR_EXPAND(cr_assert_float_op_( \
254 Fail, \
255 Op, \
256 CR_VA_HEAD(__VA_ARGS__), \
257 CR_VA_HEAD(CR_VA_TAIL(__VA_ARGS__)), \
258 CR_VA_HEAD(CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__))), \
259 CR_VA_TAIL(CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__))) \
260 ))
261
262/* String */
263
264#define cr_assert_str_op_empty_(Fail, Op, Msg, Value, ...) \
265 do { \
266 const char *cr_str_value__ = (Value); \
267 CR_EXPAND(cr_assert_impl( \
268 Fail, \
269 ((cr_str_value__) != NULL) && (cr_str_value__)[0] Op '\0', \
270 dummy, \
271 ((cr_str_value__) != NULL) ? Msg : CRITERION_ASSERT_MSG_IS_NULL, \
272 (CR_STR(Value), cr_str_value__), \
273 __VA_ARGS__ \
274 )); \
275 } while (0)
276
277#define cr_assert_str_op_empty_va_(Fail, Op, Msg, ...) \
278 CR_EXPAND(cr_assert_str_op_empty_( \
279 Fail, \
280 Op, \
281 Msg, \
282 CR_VA_HEAD(__VA_ARGS__), \
283 CR_VA_TAIL(__VA_ARGS__) \
284 ))
285
286#define cr_assert_str_op_(Fail, Op, Actual, Expected, ...) \
287 do { \
288 const char *cr_str_actual__ = (Actual); \
289 const char *cr_str_expected__ = (Expected); \
290 CR_EXPAND(cr_assert_impl( \
291 Fail, \
292 ((cr_str_actual__) != NULL) && ((cr_str_expected__) != NULL) \
293 && CR_STDN strcmp((cr_str_actual__), (cr_str_expected__)) Op 0, \
294 dummy, \
295 CRITERION_ASSERT_MSG_EXPR_AS_STRINGS_FALSE, \
296 (CR_STR((Actual) Op (Expected)), cr_str_actual__, cr_str_expected__), \
297 __VA_ARGS__ \
298 )); \
299 } while (0)
300
301#define cr_assert_str_op_va_(Fail, Op, ...) \
302 CR_EXPAND(cr_assert_str_op_( \
303 Fail, \
304 Op, \
305 CR_VA_HEAD(__VA_ARGS__), \
306 CR_VA_HEAD(CR_VA_TAIL(__VA_ARGS__)), \
307 CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__)) \
308 ))
309
310/* Wide String */
311
312#define cr_assert_wcs_op_empty_(Fail, Op, Msg, Value, ...) \
313 do { \
314 const wchar_t *cr_wcs_value__ = (Value); \
315 CR_EXPAND(cr_assert_impl( \
316 Fail, \
317 ((cr_wcs_value__) != NULL) && (cr_wcs_value__)[0] Op L'\0', \
318 dummy, \
319 ((cr_wcs_value__) != NULL) ? Msg : CRITERION_ASSERT_MSG_IS_NULL, \
320 (CR_STR(Value), cr_wcs_value__), \
321 __VA_ARGS__ \
322 )); \
323 } while (0)
324
325#define cr_assert_wcs_op_empty_va_(Fail, Op, Msg, ...) \
326 CR_EXPAND(cr_assert_wcs_op_empty_( \
327 Fail, \
328 Op, \
329 Msg, \
330 CR_VA_HEAD(__VA_ARGS__), \
331 CR_VA_TAIL(__VA_ARGS__) \
332 ))
333
334#define cr_assert_wcs_op_(Fail, Op, Actual, Expected, ...) \
335 do { \
336 const wchar_t *cr_wcs_actual__ = (Actual); \
337 const wchar_t *cr_wcs_expected__ = (Expected); \
338 CR_EXPAND(cr_assert_impl( \
339 Fail, \
340 ((cr_wcs_actual__) != NULL) && ((cr_wcs_expected__) != NULL) \
341 && CR_STDN wcscmp((cr_wcs_actual__), (cr_wcs_expected__)) Op 0, \
342 dummy, \
343 CRITERION_ASSERT_MSG_EXPR_FALSE, \
344 (CR_STR((Actual) Op (Expected))), \
345 __VA_ARGS__ \
346 )); \
347 } while (0)
348
349#define cr_assert_wcs_op_va_(Fail, Op, ...) \
350 CR_EXPAND(cr_assert_wcs_op_( \
351 Fail, \
352 Op, \
353 CR_VA_HEAD(__VA_ARGS__), \
354 CR_VA_HEAD(CR_VA_TAIL(__VA_ARGS__)), \
355 CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__)) \
356 ))
357
358/* Array */
359
360#define cr_assert_mem_op_(Fail, Op, Actual, Expected, Size, ...) \
361 CR_EXPAND(cr_assert_impl( \
362 Fail, \
363 CR_STDN memcmp((Actual), (Expected), (Size)) Op 0, \
364 dummy, \
365 CRITERION_ASSERT_MSG_EXPR_FALSE, \
366 (CR_STR((Actual)[0..Size] Op (Expected)[0..Size])), \
367 __VA_ARGS__ \
368 ))
369
370#define cr_assert_mem_op_va_(Fail, Op, ...) \
371 CR_EXPAND(cr_assert_mem_op_( \
372 Fail, \
373 Op, \
374 CR_VA_HEAD(__VA_ARGS__), \
375 CR_VA_HEAD(CR_VA_TAIL(__VA_ARGS__)), \
376 CR_VA_HEAD(CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__))), \
377 CR_VA_TAIL(CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__))) \
378 ))
379
380/* Array comparisons */
381
382#ifdef __cplusplus
383# define CR_ARR_COMPARE_(A, B, Size, Cmp, Result) \
384 int Result = std::lexicographical_compare((A), (A) + Size, (B), (B) + Size, Cmp)
385#else
386# define CR_ARR_COMPARE_(A, B, Size, Cmp, Result) \
387 __typeof__ (&(A)[0])first = (A); \
388 __typeof__ (&(B)[0])second = (B); \
389 int Result = 0; \
390 size_t i, size; \
391 for (i = 0, size = (Size); !Result && i < size; ++i) \
392 Result = Cmp(first + i, second + i)
393#endif
394
395#define cr_assert_arr_op_cmp_(Fail, Op, Actual, Expected, Size, Cmp, ...) \
396 do { \
397 CR_ARR_COMPARE_(Actual, Expected, Size, Cmp, order); \
398 CR_EXPAND(cr_assert_impl( \
399 Fail, \
400 order Op 0, \
401 dummy, \
402 CRITERION_ASSERT_MSG_EXPR_FALSE, \
403 (CR_STR((Actual)[0..Size] Op (Expected)[0..Size])), \
404 __VA_ARGS__ \
405 )); \
406 } while (0)
407
408#define cr_assert_arr_op_cmp_va_(Fail, Op, ...) \
409 CR_EXPAND(cr_assert_arr_op_cmp_( \
410 Fail, \
411 Op, \
412 CR_VA_HEAD(__VA_ARGS__), \
413 CR_VA_HEAD(CR_VA_TAIL(__VA_ARGS__)), \
414 CR_VA_HEAD(CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__))), \
415 CR_VA_HEAD(CR_VA_TAIL(CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__)))), \
416 CR_VA_TAIL(CR_VA_TAIL(CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__)))) \
417 ))
418
419/* Exceptions */
420
421#define cr_assert_throw_abort_(Fail, Msg, MsgArgs, ...) \
422 CR_EXPAND(cr_assert_impl( \
423 Fail, \
424 0, \
425 dummy, \
426 Msg, \
427 MsgArgs, \
428 CR_VA_TAIL(__VA_ARGS__) \
429 ))
430
431#define cr_assert_throw_(Fail, Statement, Exception, ...) \
432 try { \
433 Statement; \
434 CR_EXPAND(cr_assert_throw_abort_( \
435 Fail, \
436 CRITERION_ASSERT_MSG_NO_THROW, \
437 (CR_STR(Statement), CR_STR(Exception)), \
438 __VA_ARGS__)); \
439 } catch (Exception const &) { \
440 /* pass -- the exception was thrown */ \
441 } catch (...) { \
442 CR_EXPAND(cr_assert_throw_abort_( \
443 Fail, \
444 CRITERION_ASSERT_MSG_NO_THROW, \
445 (CR_STR(Statement), CR_STR(Exception)), \
446 __VA_ARGS__)); \
447 }
448
449#define cr_assert_throw_va_(...) \
450 CR_EXPAND(cr_assert_throw_( \
451 CR_VA_HEAD(__VA_ARGS__), \
452 CR_VA_HEAD(CR_VA_TAIL(__VA_ARGS__)), \
453 CR_VA_HEAD(CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__))), \
454 dummy, \
455 CR_VA_TAIL(CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__))) \
456 ))
457
458#define cr_assert_no_throw_(Fail, Statement, Exception, ...) \
459 try { \
460 Statement; \
461 } catch (Exception const &) { \
462 CR_EXPAND(cr_assert_throw_abort_( \
463 Fail, \
464 CRITERION_ASSERT_MSG_THROW, \
465 (CR_STR(Statement), CR_STR(Exception)), \
466 __VA_ARGS__)); \
467 }
468
469#define cr_assert_no_throw_va_(...) \
470 CR_EXPAND(cr_assert_no_throw_( \
471 CR_VA_HEAD(__VA_ARGS__), \
472 CR_VA_HEAD(CR_VA_TAIL(__VA_ARGS__)), \
473 CR_VA_HEAD(CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__))), \
474 dummy, \
475 CR_VA_TAIL(CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__))) \
476 ))
477
478#define cr_assert_any_throw_(Fail, Statement, ...) \
479 try { \
480 Statement; \
481 CR_EXPAND(cr_assert_throw_abort_( \
482 Fail, \
483 CRITERION_ASSERT_MSG_ANY_THROW, \
484 (CR_STR(Statement)), \
485 __VA_ARGS__)); \
486 } catch (...) {}
487
488#define cr_assert_any_throw_va_(...) \
489 CR_EXPAND(cr_assert_any_throw_( \
490 CR_VA_HEAD(__VA_ARGS__), \
491 CR_VA_HEAD(CR_VA_TAIL(__VA_ARGS__)), \
492 dummy, \
493 CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__)) \
494 ))
495
496#define cr_assert_none_throw_(Fail, Statement, ...) \
497 try { \
498 Statement; \
499 } catch (...) { \
500 CR_EXPAND(cr_assert_throw_abort_( \
501 Fail, \
502 CRITERION_ASSERT_MSG_NONE_THROW, \
503 (CR_STR(Statement)), \
504 __VA_ARGS__)); \
505 }
506
507#define cr_assert_none_throw_va_(...) \
508 CR_EXPAND(cr_assert_none_throw_( \
509 CR_VA_HEAD(__VA_ARGS__), \
510 CR_VA_HEAD(CR_VA_TAIL(__VA_ARGS__)), \
511 dummy, \
512 CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__)) \
513 ))
514
515/* Messages */
516
517#define CRITERION_GNUC_WARN__(Msg) \
518 _Pragma(#Msg)
519
520#define CRITERION_GNUC_WARN_(Name) \
521 CRITERION_GNUC_WARN__( \
522 message \
523 "The `" #Name "` macro is only available on GNU C compilers." \
524 )
525
526/* Actual implementation */
527
528#undef cr_skip_test
529#define cr_skip_test(...) CR_EXPAND(cr_skip(__VA_ARGS__))
530#undef cr_assert_fail
531#define cr_assert_fail(...) CR_EXPAND(cr_fail(CR_FAIL_ABORT_, __VA_ARGS__))
532#undef cr_expect_fail
533#define cr_expect_fail(...) CR_EXPAND(cr_fail(CR_FAIL_CONTINUES_, __VA_ARGS__))
534#undef cr_assert
535#define cr_assert(...) CR_EXPAND(cr_assert_(__VA_ARGS__))
536#undef cr_expect
537#define cr_expect(...) CR_EXPAND(cr_expect_(__VA_ARGS__))
538#undef cr_assert_not
539#define cr_assert_not(...) CR_EXPAND(cr_assert_not_(__VA_ARGS__))
540#undef cr_expect_not
541#define cr_expect_not(...) CR_EXPAND(cr_expect_not_(__VA_ARGS__))
542#undef cr_assert_eq
543#define cr_assert_eq(...) CR_EXPAND(cr_assert_op_va_(CR_FAIL_ABORT_, ==, __VA_ARGS__))
544#undef cr_expect_eq
545#define cr_expect_eq(...) CR_EXPAND(cr_assert_op_va_(CR_FAIL_CONTINUES_, ==, __VA_ARGS__))
546#undef cr_assert_neq
547#define cr_assert_neq(...) CR_EXPAND(cr_assert_op_va_(CR_FAIL_ABORT_, !=, __VA_ARGS__))
548#undef cr_expect_neq
549#define cr_expect_neq(...) CR_EXPAND(cr_assert_op_va_(CR_FAIL_CONTINUES_, !=, __VA_ARGS__))
550#undef cr_assert_lt
551#define cr_assert_lt(...) CR_EXPAND(cr_assert_op_va_(CR_FAIL_ABORT_, <, __VA_ARGS__))
552#undef cr_expect_lt
553#define cr_expect_lt(...) CR_EXPAND(cr_assert_op_va_(CR_FAIL_CONTINUES_, <, __VA_ARGS__))
554#undef cr_assert_leq
555#define cr_assert_leq(...) CR_EXPAND(cr_assert_op_va_(CR_FAIL_ABORT_, <=, __VA_ARGS__))
556#undef cr_expect_leq
557#define cr_expect_leq(...) CR_EXPAND(cr_assert_op_va_(CR_FAIL_CONTINUES_, <=, __VA_ARGS__))
558#undef cr_assert_gt
559#define cr_assert_gt(...) CR_EXPAND(cr_assert_op_va_(CR_FAIL_ABORT_, >, __VA_ARGS__))
560#undef cr_expect_gt
561#define cr_expect_gt(...) CR_EXPAND(cr_assert_op_va_(CR_FAIL_CONTINUES_, >, __VA_ARGS__))
562#undef cr_assert_geq
563#define cr_assert_geq(...) CR_EXPAND(cr_assert_op_va_(CR_FAIL_ABORT_, >=, __VA_ARGS__))
564#undef cr_expect_geq
565#define cr_expect_geq(...) CR_EXPAND(cr_assert_op_va_(CR_FAIL_CONTINUES_, >=, __VA_ARGS__))
566#undef cr_assert_null
567#define cr_assert_null(...) CR_EXPAND(cr_assert_null_op_va_(CR_FAIL_ABORT_, ==, CRITERION_ASSERT_MSG_IS_NOT_NULL, __VA_ARGS__))
568#undef cr_expect_null
569#define cr_expect_null(...) CR_EXPAND(cr_assert_null_op_va_(CR_FAIL_CONTINUES_, ==, CRITERION_ASSERT_MSG_IS_NOT_NULL, __VA_ARGS__))
570#undef cr_assert_not_null
571#define cr_assert_not_null(...) CR_EXPAND(cr_assert_null_op_va_(CR_FAIL_ABORT_, !=, CRITERION_ASSERT_MSG_IS_NULL, __VA_ARGS__))
572#undef cr_expect_not_null
573#define cr_expect_not_null(...) CR_EXPAND(cr_assert_null_op_va_(CR_FAIL_CONTINUES_, !=, CRITERION_ASSERT_MSG_IS_NULL, __VA_ARGS__))
574#undef cr_assert_float_eq
575#define cr_assert_float_eq(...) CR_EXPAND(cr_assert_float_op_va_(CR_FAIL_ABORT_, cr_assert_float_eq_op_, __VA_ARGS__))
576#undef cr_expect_float_eq
577#define cr_expect_float_eq(...) CR_EXPAND(cr_assert_float_op_va_(CR_FAIL_CONTINUES_, cr_assert_float_eq_op_, __VA_ARGS__))
578#undef cr_assert_float_neq
579#define cr_assert_float_neq(...) CR_EXPAND(cr_assert_float_op_va_(CR_FAIL_ABORT_, cr_assert_float_neq_op_, __VA_ARGS__))
580#undef cr_expect_float_neq
581#define cr_expect_float_neq(...) CR_EXPAND(cr_assert_float_op_va_(CR_FAIL_CONTINUES_, cr_assert_float_neq_op_, __VA_ARGS__))
582#undef cr_assert_str_empty
583#define cr_assert_str_empty(...) CR_EXPAND(cr_assert_str_op_empty_va_(CR_FAIL_ABORT_, ==, CRITERION_ASSERT_MSG_IS_NOT_EMPTY, __VA_ARGS__))
584#undef cr_expect_str_empty
585#define cr_expect_str_empty(...) CR_EXPAND(cr_assert_str_op_empty_va_(CR_FAIL_CONTINUES_, ==, CRITERION_ASSERT_MSG_IS_NOT_EMPTY, __VA_ARGS__))
586#undef cr_assert_str_not_empty
587#define cr_assert_str_not_empty(...) CR_EXPAND(cr_assert_str_op_empty_va_(CR_FAIL_ABORT_, !=, CRITERION_ASSERT_MSG_IS_EMPTY, __VA_ARGS__))
588#undef cr_expect_str_not_empty
589#define cr_expect_str_not_empty(...) CR_EXPAND(cr_assert_str_op_empty_va_(CR_FAIL_CONTINUES_, !=, CRITERION_ASSERT_MSG_IS_EMPTY, __VA_ARGS__))
590#undef cr_assert_str_eq
591#define cr_assert_str_eq(...) CR_EXPAND(cr_assert_str_op_va_(CR_FAIL_ABORT_, ==, __VA_ARGS__))
592#undef cr_expect_str_eq
593#define cr_expect_str_eq(...) CR_EXPAND(cr_assert_str_op_va_(CR_FAIL_CONTINUES_, ==, __VA_ARGS__))
594#undef cr_assert_str_neq
595#define cr_assert_str_neq(...) CR_EXPAND(cr_assert_str_op_va_(CR_FAIL_ABORT_, !=, __VA_ARGS__))
596#undef cr_expect_str_neq
597#define cr_expect_str_neq(...) CR_EXPAND(cr_assert_str_op_va_(CR_FAIL_CONTINUES_, !=, __VA_ARGS__))
598#undef cr_assert_str_lt
599#define cr_assert_str_lt(...) CR_EXPAND(cr_assert_str_op_va_(CR_FAIL_ABORT_, <, __VA_ARGS__))
600#undef cr_expect_str_lt
601#define cr_expect_str_lt(...) CR_EXPAND(cr_assert_str_op_va_(CR_FAIL_CONTINUES_, <, __VA_ARGS__))
602#undef cr_assert_str_leq
603#define cr_assert_str_leq(...) CR_EXPAND(cr_assert_str_op_va_(CR_FAIL_ABORT_, <=, __VA_ARGS__))
604#undef cr_expect_str_leq
605#define cr_expect_str_leq(...) CR_EXPAND(cr_assert_str_op_va_(CR_FAIL_CONTINUES_, <=, __VA_ARGS__))
606#undef cr_assert_str_gt
607#define cr_assert_str_gt(...) CR_EXPAND(cr_assert_str_op_va_(CR_FAIL_ABORT_, >, __VA_ARGS__))
608#undef cr_expect_str_gt
609#define cr_expect_str_gt(...) CR_EXPAND(cr_assert_str_op_va_(CR_FAIL_CONTINUES_, >, __VA_ARGS__))
610#undef cr_assert_str_geq
611#define cr_assert_str_geq(...) CR_EXPAND(cr_assert_str_op_va_(CR_FAIL_ABORT_, >=, __VA_ARGS__))
612#undef cr_expect_str_geq
613#define cr_expect_str_geq(...) CR_EXPAND(cr_assert_str_op_va_(CR_FAIL_CONTINUES_, >=, __VA_ARGS__))
614#undef cr_assert_wcs_empty
615#define cr_assert_wcs_empty(...) CR_EXPAND(cr_assert_wcs_op_empty_va_(CR_FAIL_ABORT_, ==, CRITERION_ASSERT_MSG_IS_NOT_EMPTY, __VA_ARGS__))
616#undef cr_expect_wcs_empty
617#define cr_expect_wcs_empty(...) CR_EXPAND(cr_assert_wcs_op_empty_va_(CR_FAIL_CONTINUES_, ==, CRITERION_ASSERT_MSG_IS_NOT_EMPTY, __VA_ARGS__))
618#undef cr_assert_wcs_not_empty
619#define cr_assert_wcs_not_empty(...) CR_EXPAND(cr_assert_wcs_op_empty_va_(CR_FAIL_ABORT_, !=, CRITERION_ASSERT_MSG_IS_EMPTY, __VA_ARGS__))
620#undef cr_expect_wcs_not_empty
621#define cr_expect_wcs_not_empty(...) CR_EXPAND(cr_assert_wcs_op_empty_va_(CR_FAIL_CONTINUES_, !=, CRITERION_ASSERT_MSG_IS_EMPTY, __VA_ARGS__))
622#undef cr_assert_wcs_eq
623#define cr_assert_wcs_eq(...) CR_EXPAND(cr_assert_wcs_op_va_(CR_FAIL_ABORT_, ==, __VA_ARGS__))
624#undef cr_expect_wcs_eq
625#define cr_expect_wcs_eq(...) CR_EXPAND(cr_assert_wcs_op_va_(CR_FAIL_CONTINUES_, ==, __VA_ARGS__))
626#undef cr_assert_wcs_neq
627#define cr_assert_wcs_neq(...) CR_EXPAND(cr_assert_wcs_op_va_(CR_FAIL_ABORT_, !=, __VA_ARGS__))
628#undef cr_expect_wcs_neq
629#define cr_expect_wcs_neq(...) CR_EXPAND(cr_assert_wcs_op_va_(CR_FAIL_CONTINUES_, !=, __VA_ARGS__))
630#undef cr_assert_wcs_lt
631#define cr_assert_wcs_lt(...) CR_EXPAND(cr_assert_wcs_op_va_(CR_FAIL_ABORT_, <, __VA_ARGS__))
632#undef cr_expect_wcs_lt
633#define cr_expect_wcs_lt(...) CR_EXPAND(cr_assert_wcs_op_va_(CR_FAIL_CONTINUES_, <, __VA_ARGS__))
634#undef cr_assert_wcs_leq
635#define cr_assert_wcs_leq(...) CR_EXPAND(cr_assert_wcs_op_va_(CR_FAIL_ABORT_, <=, __VA_ARGS__))
636#undef cr_expect_wcs_leq
637#define cr_expect_wcs_leq(...) CR_EXPAND(cr_assert_wcs_op_va_(CR_FAIL_CONTINUES_, <=, __VA_ARGS__))
638#undef cr_assert_wcs_gt
639#define cr_assert_wcs_gt(...) CR_EXPAND(cr_assert_wcs_op_va_(CR_FAIL_ABORT_, >, __VA_ARGS__))
640#undef cr_expect_wcs_gt
641#define cr_expect_wcs_gt(...) CR_EXPAND(cr_assert_wcs_op_va_(CR_FAIL_CONTINUES_, >, __VA_ARGS__))
642#undef cr_assert_wcs_geq
643#define cr_assert_wcs_geq(...) CR_EXPAND(cr_assert_wcs_op_va_(CR_FAIL_ABORT_, >=, __VA_ARGS__))
644#undef cr_expect_wcs_geq
645#define cr_expect_wcs_geq(...) CR_EXPAND(cr_assert_wcs_op_va_(CR_FAIL_CONTINUES_, >=, __VA_ARGS__))
646#undef cr_assert_arr_eq
647#define cr_assert_arr_eq(...) CR_EXPAND(cr_assert_mem_op_va_(CR_FAIL_ABORT_, ==, __VA_ARGS__))
648#undef cr_expect_arr_eq
649#define cr_expect_arr_eq(...) CR_EXPAND(cr_assert_mem_op_va_(CR_FAIL_CONTINUES_, ==, __VA_ARGS__))
650#undef cr_assert_arr_neq
651#define cr_assert_arr_neq(...) CR_EXPAND(cr_assert_mem_op_va_(CR_FAIL_ABORT_, !=, __VA_ARGS__))
652#undef cr_expect_arr_neq
653#define cr_expect_arr_neq(...) CR_EXPAND(cr_assert_mem_op_va_(CR_FAIL_CONTINUES_, !=, __VA_ARGS__))
654
655#if defined (__GNUC__) || defined (__clang__) || defined (__cplusplus)
656
657# undef cr_assert_arr_eq_cmp
658# define cr_assert_arr_eq_cmp(...) CR_EXPAND(cr_assert_arr_op_cmp_va_(CR_FAIL_ABORT_, ==, __VA_ARGS__))
659# undef cr_expect_arr_eq_cmp
660# define cr_expect_arr_eq_cmp(...) CR_EXPAND(cr_assert_arr_op_cmp_va_(CR_FAIL_CONTINUES_, ==, __VA_ARGS__))
661# undef cr_assert_arr_neq_cmp
662# define cr_assert_arr_neq_cmp(...) CR_EXPAND(cr_assert_arr_op_cmp_va_(CR_FAIL_ABORT_, !=, __VA_ARGS__))
663# undef cr_expect_arr_neq_cmp
664# define cr_expect_arr_neq_cmp(...) CR_EXPAND(cr_assert_arr_op_cmp_va_(CR_FAIL_CONTINUES_, !=, __VA_ARGS__))
665# undef cr_assert_arr_lt_cmp
666# define cr_assert_arr_lt_cmp(...) CR_EXPAND(cr_assert_arr_op_cmp_va_(CR_FAIL_ABORT_, <, __VA_ARGS__))
667# undef cr_expect_arr_lt_cmp
668# define cr_expect_arr_lt_cmp(...) CR_EXPAND(cr_assert_arr_op_cmp_va_(CR_FAIL_CONTINUES_, <, __VA_ARGS__))
669# undef cr_assert_arr_leq_cmp
670# define cr_assert_arr_leq_cmp(...) CR_EXPAND(cr_assert_arr_op_cmp_va_(CR_FAIL_ABORT_, <=, __VA_ARGS__))
671# undef cr_expect_arr_leq_cmp
672# define cr_expect_arr_leq_cmp(...) CR_EXPAND(cr_assert_arr_op_cmp_va_(CR_FAIL_CONTINUES_, <=, __VA_ARGS__))
673# undef cr_assert_arr_gt_cmp
674# define cr_assert_arr_gt_cmp(...) CR_EXPAND(cr_assert_arr_op_cmp_va_(CR_FAIL_ABORT_, >, __VA_ARGS__))
675# undef cr_expect_arr_gt_cmp
676# define cr_expect_arr_gt_cmp(...) CR_EXPAND(cr_assert_arr_op_cmp_va_(CR_FAIL_CONTINUES_, >, __VA_ARGS__))
677# undef cr_assert_arr_geq_cmp
678# define cr_assert_arr_geq_cmp(...) CR_EXPAND(cr_assert_arr_op_cmp_va_(CR_FAIL_ABORT_, >=, __VA_ARGS__))
679# undef cr_expect_arr_geq_cmp
680# define cr_expect_arr_geq_cmp(...) CR_EXPAND(cr_assert_arr_op_cmp_va_(CR_FAIL_CONTINUES_, >=, __VA_ARGS__))
681
682#else
683
684# undef cr_assert_arr_eq_cmp
685# define cr_assert_arr_eq_cmp(...) CRITERION_GNUC_WARN_(cr_assert_arr_eq_cmp) CR_NOOP
686# undef cr_expect_arr_eq_cmp
687# define cr_expect_arr_eq_cmp(...) CRITERION_GNUC_WARN_(cr_expect_arr_eq_cmp) CR_NOOP
688# undef cr_assert_arr_neq_cmp
689# define cr_assert_arr_neq_cmp(...) CRITERION_GNUC_WARN_(cr_assert_arr_neq_cmp) CR_NOOP
690# undef cr_expect_arr_neq_cmp
691# define cr_expect_arr_neq_cmp(...) CRITERION_GNUC_WARN_(cr_expect_arr_neq_cmp) CR_NOOP
692# undef cr_assert_arr_lt_cmp
693# define cr_assert_arr_lt_cmp(...) CRITERION_GNUC_WARN_(cr_assert_arr_lt_cmp) CR_NOOP
694# undef cr_expect_arr_lt_cmp
695# define cr_expect_arr_lt_cmp(...) CRITERION_GNUC_WARN_(cr_expect_arr_lt_cmp) CR_NOOP
696# undef cr_assert_arr_leq_cmp
697# define cr_assert_arr_leq_cmp(...) CRITERION_GNUC_WARN_(cr_assert_arr_leq_cmp) CR_NOOP
698# undef cr_expect_arr_leq_cmp
699# define cr_expect_arr_leq_cmp(...) CRITERION_GNUC_WARN_(cr_expect_arr_leq_cmp) CR_NOOP
700# undef cr_assert_arr_gt_cmp
701# define cr_assert_arr_gt_cmp(...) CRITERION_GNUC_WARN_(cr_assert_arr_gt_cmp) CR_NOOP
702# undef cr_expect_arr_gt_cmp
703# define cr_expect_arr_gt_cmp(...) CRITERION_GNUC_WARN_(cr_expect_arr_gt_cmp) CR_NOOP
704# undef cr_assert_arr_geq_cmp
705# define cr_assert_arr_geq_cmp(...) CRITERION_GNUC_WARN_(cr_assert_arr_geq_cmp) CR_NOOP
706# undef cr_expect_arr_geq_cmp
707# define cr_expect_arr_geq_cmp(...) CRITERION_GNUC_WARN_(cr_expect_arr_geq_cmp) CR_NOOP
708
709#endif
710
711#undef cr_assert_throw
712#define cr_assert_throw(...) CR_EXPAND(cr_assert_throw_va_(CR_FAIL_ABORT_, __VA_ARGS__))
713#undef cr_expect_throw
714#define cr_expect_throw(...) CR_EXPAND(cr_assert_throw_va_(CR_FAIL_CONTINUES_, __VA_ARGS__))
715#undef cr_assert_no_throw
716#define cr_assert_no_throw(...) CR_EXPAND(cr_assert_no_throw_va_(CR_FAIL_ABORT_, __VA_ARGS__))
717#undef cr_expect_no_throw
718#define cr_expect_no_throw(...) CR_EXPAND(cr_assert_no_throw_va_(CR_FAIL_CONTINUES_, __VA_ARGS__))
719#undef cr_assert_any_throw
720#define cr_assert_any_throw(...) CR_EXPAND(cr_assert_any_throw_va_(CR_FAIL_ABORT_, __VA_ARGS__))
721#undef cr_expect_any_throw
722#define cr_expect_any_throw(...) CR_EXPAND(cr_assert_any_throw_va_(CR_FAIL_CONTINUES_, __VA_ARGS__))
723#undef cr_assert_none_throw
724#define cr_assert_none_throw(...) CR_EXPAND(cr_assert_none_throw_va_(CR_FAIL_ABORT_, __VA_ARGS__))
725#undef cr_expect_none_throw
726#define cr_expect_none_throw(...) CR_EXPAND(cr_assert_none_throw_va_(CR_FAIL_CONTINUES_, __VA_ARGS__))
727
728#endif /* !CRITERION_INTERNAL_ASSERT_H_ */
criterion options
Functions to abort and continue tests.
#define CR_BEGIN_C_API
Definition common.h:54
#define CR_API
Definition common.h:128
#define CR_END_C_API
Definition common.h:55
Report hooks.
CR_API void cri_asserts_passed_incr(void)
criterion_assert_messages
@ CRITERION_ASSERT_MSG_NONE_THROW
@ CRITERION_ASSERT_MSG_THROW
@ CRITERION_ASSERT_MSG_FAIL
@ CRITERION_ASSERT_MSG_FILE_MATCH
@ CRITERION_ASSERT_MSG_FILE_STR_MATCH
@ CRITERION_ASSERT_MSG_EXPR_FALSE
@ CRITERION_ASSERT_MSG_IS_NULL
@ CRITERION_ASSERT_MSG_IS_NOT_EMPTY
@ CRITERION_ASSERT_MSG_ANY_THROW
@ CRITERION_ASSERT_MSG_EXPR_AS_STRINGS_FALSE
@ CRITERION_ASSERT_MSG_NO_THROW
@ CRITERION_ASSERT_MSG_IS_NOT_NULL
@ CRITERION_ASSERT_MSG_IS_EMPTY
CR_BEGIN_C_API CR_API char * cr_translate_assert_msg(int msg_index,...)
Test stats.
Types for tests.