1 /*
2 * Copyright (c) 2016 Intel Corporation
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7 /**
8 * @file
9 *
10 * @brief Zephyr testing framework assertion macros
11 */
12
13 #ifndef ZEPHYR_TESTSUITE_ZTEST_ASSERT_H_
14 #define ZEPHYR_TESTSUITE_ZTEST_ASSERT_H_
15
16 #include <stdarg.h>
17 #include <stdbool.h>
18 #include <stdio.h>
19 #include <string.h>
20
21 #include <zephyr/ztest.h>
22
23 #ifdef __cplusplus
24 extern "C" {
25 #endif
26
27 const char *ztest_relative_filename(const char *file);
28 void ztest_test_fail(void);
29 void ztest_test_skip(void);
30 void ztest_test_expect_fail(void);
31 void ztest_skip_failed_assumption(void);
32 #if CONFIG_ZTEST_ASSERT_VERBOSE == 0
33
z_zassert_(bool cond,const char * file,int line)34 static inline bool z_zassert_(bool cond, const char *file, int line)
35 {
36 if (cond == false) {
37 PRINT("\n Assertion failed at %s:%d\n", ztest_relative_filename(file), line);
38 ztest_test_fail();
39 return false;
40 }
41
42 return true;
43 }
44
45 #define z_zassert(cond, default_msg, file, line, func, msg, ...) z_zassert_(cond, file, line)
46
z_zassume_(bool cond,const char * file,int line)47 static inline bool z_zassume_(bool cond, const char *file, int line)
48 {
49 if (cond == false) {
50 PRINT("\n Assumption failed at %s:%d\n", ztest_relative_filename(file), line);
51 ztest_skip_failed_assumption();
52 return false;
53 }
54
55 return true;
56 }
57
58 #define z_zassume(cond, default_msg, file, line, func, msg, ...) z_zassume_(cond, file, line)
59
z_zexpect_(bool cond,const char * file,int line)60 static inline bool z_zexpect_(bool cond, const char *file, int line)
61 {
62 if (cond == false) {
63 PRINT("\n Expectation failed at %s:%d\n", ztest_relative_filename(file), line);
64 ztest_test_expect_fail();
65 return false;
66 }
67
68 return true;
69 }
70
71 #define z_zexpect(cond, default_msg, file, line, func, msg, ...) z_zexpect_(cond, file, line)
72
73 #else /* CONFIG_ZTEST_ASSERT_VERBOSE != 0 */
74
z_zassert(bool cond,const char * default_msg,const char * file,int line,const char * func,const char * msg,...)75 static inline bool z_zassert(bool cond, const char *default_msg, const char *file, int line,
76 const char *func, const char *msg, ...)
77 {
78 if (cond == false) {
79 va_list vargs;
80
81 va_start(vargs, msg);
82 PRINT("\n Assertion failed at %s:%d: %s: %s\n", ztest_relative_filename(file),
83 line, func, default_msg);
84 vprintk(msg, vargs);
85 printk("\n");
86 va_end(vargs);
87 ztest_test_fail();
88 return false;
89 }
90 #if CONFIG_ZTEST_ASSERT_VERBOSE == 2
91 else {
92 PRINT("\n Assertion succeeded at %s:%d (%s)\n", ztest_relative_filename(file),
93 line, func);
94 }
95 #endif
96 return true;
97 }
98
z_zassume(bool cond,const char * default_msg,const char * file,int line,const char * func,const char * msg,...)99 static inline bool z_zassume(bool cond, const char *default_msg, const char *file, int line,
100 const char *func, const char *msg, ...)
101 {
102 if (cond == false) {
103 va_list vargs;
104
105 va_start(vargs, msg);
106 PRINT("\n Assumption failed at %s:%d: %s: %s\n", ztest_relative_filename(file),
107 line, func, default_msg);
108 vprintk(msg, vargs);
109 printk("\n");
110 va_end(vargs);
111 ztest_skip_failed_assumption();
112 return false;
113 }
114 #if CONFIG_ZTEST_ASSERT_VERBOSE == 2
115 else {
116 PRINT("\n Assumption succeeded at %s:%d (%s)\n", ztest_relative_filename(file),
117 line, func);
118 }
119 #endif
120 return true;
121 }
122
z_zexpect(bool cond,const char * default_msg,const char * file,int line,const char * func,const char * msg,...)123 static inline bool z_zexpect(bool cond, const char *default_msg, const char *file, int line,
124 const char *func, const char *msg, ...)
125 {
126 if (cond == false) {
127 va_list vargs;
128
129 va_start(vargs, msg);
130 PRINT("\n Expectation failed at %s:%d: %s: %s\n", ztest_relative_filename(file),
131 line, func, default_msg);
132 vprintk(msg, vargs);
133 printk("\n");
134 va_end(vargs);
135 ztest_test_expect_fail();
136 return false;
137 }
138 #if CONFIG_ZTEST_ASSERT_VERBOSE == 2
139 else {
140 PRINT("\n Expectation succeeded at %s:%d (%s)\n", ztest_relative_filename(file),
141 line, func);
142 }
143 #endif
144 return true;
145 }
146
147 #endif /* CONFIG_ZTEST_ASSERT_VERBOSE */
148
149 /**
150 * @defgroup ztest_assert Ztest assertion macros
151 * @ingroup ztest
152 *
153 * This module provides assertions when using Ztest.
154 *
155 * @{
156 */
157
158 /**
159 * @brief Fail the test, if @a cond is false
160 *
161 * You probably don't need to call this macro directly. You should
162 * instead use zassert_{condition} macros below.
163 *
164 * Note that when CONFIG_MULTITHREADING=n macro returns from the function. It is
165 * then expected that in that case ztest asserts will be used only in the
166 * context of the test function.
167 *
168 * @param cond Condition to check
169 * @param default_msg Message to print if @a cond is false
170 * @param msg Optional, can be NULL. Message to print if @a cond is false.
171 */
172 #define _zassert_base(cond, default_msg, msg, ...) \
173 do { \
174 bool _msg = (msg != NULL); \
175 bool _ret = z_zassert(cond, _msg ? ("(" default_msg ")") : (default_msg), __FILE__,\
176 __LINE__, __func__, _msg ? msg : "", ##__VA_ARGS__); \
177 (void)_msg; \
178 if (!_ret) { \
179 /* If kernel but without multithreading return. */ \
180 COND_CODE_1(KERNEL, (COND_CODE_1(CONFIG_MULTITHREADING, (), (return;))), \
181 ()) \
182 } \
183 } while (0)
184
185 #define _zassert_va(cond, default_msg, msg, ...) \
186 _zassert_base(cond, default_msg, msg, ##__VA_ARGS__)
187
188 #define zassert(cond, default_msg, ...) \
189 _zassert_va(cond, default_msg, COND_CODE_1(__VA_OPT__(1), (__VA_ARGS__), (NULL)))
190
191 /**
192 * @brief Skip the test, if @a cond is false
193 *
194 * You probably don't need to call this macro directly. You should
195 * instead use zassume_{condition} macros below.
196 *
197 * Note that when CONFIG_MULTITHREADING=n macro returns from the function. It's then expected that
198 * in that case ztest assumes will be used only in the context of the test function.
199 *
200 * NOTE: zassume should not be used to replace zassert, the goal of zassume is to skip tests that
201 * would otherwise fail due to a zassert on some other dependent behavior that is *not* under test,
202 * thus reducing what could be tens to hundreds of assertion failures to investigate down to a few
203 * failures only.
204 *
205 * @param cond Condition to check
206 * @param default_msg Message to print if @a cond is false
207 * @param msg Optional, can be NULL. Message to print if @a cond is false.
208 */
209 #define _zassume_base(cond, default_msg, msg, ...) \
210 do { \
211 bool _msg = (msg != NULL); \
212 bool _ret = z_zassume(cond, _msg ? ("(" default_msg ")") : (default_msg), __FILE__,\
213 __LINE__, __func__, _msg ? msg : "", ##__VA_ARGS__); \
214 (void)_msg; \
215 if (!_ret) { \
216 /* If kernel but without multithreading return. */ \
217 COND_CODE_1(KERNEL, (COND_CODE_1(CONFIG_MULTITHREADING, (), (return;))), \
218 ()) \
219 } \
220 } while (0)
221
222 #define _zassume_va(cond, default_msg, msg, ...) \
223 _zassume_base(cond, default_msg, msg, ##__VA_ARGS__)
224
225 #define zassume(cond, default_msg, ...) \
226 _zassume_va(cond, default_msg, COND_CODE_1(__VA_OPT__(1), (__VA_ARGS__), (NULL)))
227
228 /**
229 * @brief If @a cond is false, fail the test but continue its execution.
230 *
231 * You probably don't need to call this macro directly. You should
232 * instead use zexpect_{condition} macros below.
233 *
234 * @param cond Condition to check
235 * @param default_msg Message to print if @a cond is false
236 * @param msg Optional, can be NULL. Message to print if @a cond is false.
237 */
238 #define _zexpect_base(cond, default_msg, msg, ...) \
239 do { \
240 bool _msg = (msg != NULL); \
241 bool _ret = \
242 z_zexpect(cond, _msg ? ("(" default_msg ")") : (default_msg), __FILE__, \
243 __LINE__, __func__, _msg ? msg : "", ##__VA_ARGS__); \
244 (void)_msg; \
245 if (!_ret) { \
246 /* If kernel but without multithreading return. */ \
247 COND_CODE_1(KERNEL, (COND_CODE_1(CONFIG_MULTITHREADING, (), (return;))), \
248 ()) \
249 } \
250 } while (0)
251
252 #define _zexpect_va(cond, default_msg, msg, ...) \
253 _zexpect_base(cond, default_msg, msg, ##__VA_ARGS__)
254
255 #define zexpect(cond, default_msg, ...) \
256 _zexpect_va(cond, default_msg, COND_CODE_1(__VA_OPT__(1), (__VA_ARGS__), (NULL)))
257
258 /**
259 * @brief Assert that this function call won't be reached
260 * @param ... Optional message and variables to print if the assertion fails
261 */
262 #define zassert_unreachable(...) zassert(0, "Reached unreachable code", ##__VA_ARGS__)
263
264 /**
265 * @brief Assert that @a cond is true
266 * @param cond Condition to check
267 * @param ... Optional message and variables to print if the assertion fails
268 */
269 #define zassert_true(cond, ...) zassert(cond, #cond " is false", ##__VA_ARGS__)
270
271 /**
272 * @brief Assert that @a cond is false
273 * @param cond Condition to check
274 * @param ... Optional message and variables to print if the assertion fails
275 */
276 #define zassert_false(cond, ...) zassert(!(cond), #cond " is true", ##__VA_ARGS__)
277
278 /**
279 * @brief Assert that @a cond is 0 (success)
280 * @param cond Condition to check
281 * @param ... Optional message and variables to print if the assertion fails
282 */
283 #define zassert_ok(cond, ...) zassert(!(cond), #cond " is non-zero", ##__VA_ARGS__)
284
285 /**
286 * @brief Assert that @a ptr is NULL
287 * @param ptr Pointer to compare
288 * @param ... Optional message and variables to print if the assertion fails
289 */
290 #define zassert_is_null(ptr, ...) zassert((ptr) == NULL, #ptr " is not NULL", ##__VA_ARGS__)
291
292 /**
293 * @brief Assert that @a ptr is not NULL
294 * @param ptr Pointer to compare
295 * @param ... Optional message and variables to print if the assertion fails
296 */
297 #define zassert_not_null(ptr, ...) zassert((ptr) != NULL, #ptr " is NULL", ##__VA_ARGS__)
298
299 /**
300 * @brief Assert that @a a equals @a b
301 *
302 * @a a and @a b won't be converted and will be compared directly.
303 *
304 * @param a Value to compare
305 * @param b Value to compare
306 * @param ... Optional message and variables to print if the assertion fails
307 */
308 #define zassert_equal(a, b, ...) zassert((a) == (b), #a " not equal to " #b, ##__VA_ARGS__)
309
310 /**
311 * @brief Assert that @a a does not equal @a b
312 *
313 * @a a and @a b won't be converted and will be compared directly.
314 *
315 * @param a Value to compare
316 * @param b Value to compare
317 * @param ... Optional message and variables to print if the assertion fails
318 */
319 #define zassert_not_equal(a, b, ...) zassert((a) != (b), #a " equal to " #b, ##__VA_ARGS__)
320
321 /**
322 * @brief Assert that @a a equals @a b
323 *
324 * @a a and @a b will be converted to `void *` before comparing.
325 *
326 * @param a Value to compare
327 * @param b Value to compare
328 * @param ... Optional message and variables to print if the assertion fails
329 */
330 #define zassert_equal_ptr(a, b, ...) \
331 zassert((void *)(a) == (void *)(b), #a " not equal to " #b, ##__VA_ARGS__)
332
333 /**
334 * @brief Assert that @a a is within @a b with delta @a d
335 *
336 * @param a Value to compare
337 * @param b Value to compare
338 * @param d Delta
339 * @param ... Optional message and variables to print if the assertion fails
340 */
341 #define zassert_within(a, b, d, ...) \
342 zassert(((a) >= ((b) - (d))) && ((a) <= ((b) + (d))), #a " not within " #b " +/- " #d, \
343 ##__VA_ARGS__)
344
345 /**
346 * @brief Assert that @a a is greater than or equal to @a l and less
347 * than or equal to @a u
348 *
349 * @param a Value to compare
350 * @param l Lower limit
351 * @param u Upper limit
352 * @param ... Optional message and variables to print if the assertion fails
353 */
354 #define zassert_between_inclusive(a, l, u, ...) \
355 zassert(((a) >= (l)) && ((a) <= (u)), #a " not between " #l " and " #u " inclusive", \
356 ##__VA_ARGS__)
357
358 /**
359 * @brief Assert that 2 memory buffers have the same contents
360 *
361 * This macro calls the final memory comparison assertion macro.
362 * Using double expansion allows providing some arguments by macros that
363 * would expand to more than one values (ANSI-C99 defines that all the macro
364 * arguments have to be expanded before macro call).
365 *
366 * @param ... Arguments, see @ref zassert_mem_equal__
367 * for real arguments accepted.
368 */
369 #define zassert_mem_equal(...) zassert_mem_equal__(__VA_ARGS__)
370
371 /**
372 * @brief Internal assert that 2 memory buffers have the same contents
373 *
374 * @note This is internal macro, to be used as a second expansion.
375 * See @ref zassert_mem_equal.
376 *
377 * @param buf Buffer to compare
378 * @param exp Buffer with expected contents
379 * @param size Size of buffers
380 * @param ... Optional message and variables to print if the assertion fails
381 */
382 #define zassert_mem_equal__(buf, exp, size, ...) \
383 zassert(memcmp(buf, exp, size) == 0, #buf " not equal to " #exp, ##__VA_ARGS__)
384
385 /**
386 * @}
387 */
388
389 /**
390 * @defgroup ztest_assume Ztest assumption macros
391 * @ingroup ztest
392 *
393 * This module provides assumptions when using Ztest.
394 *
395 * @{
396 */
397
398 /**
399 * @brief Assume that @a cond is true
400 *
401 * If the assumption fails, the test will be marked as "skipped".
402 *
403 * @param cond Condition to check
404 * @param ... Optional message and variables to print if the assumption fails
405 */
406 #define zassume_true(cond, ...) zassume(cond, #cond " is false", ##__VA_ARGS__)
407
408 /**
409 * @brief Assume that @a cond is false
410 *
411 * If the assumption fails, the test will be marked as "skipped".
412 *
413 * @param cond Condition to check
414 * @param ... Optional message and variables to print if the assumption fails
415 */
416 #define zassume_false(cond, ...) zassume(!(cond), #cond " is true", ##__VA_ARGS__)
417
418 /**
419 * @brief Assume that @a cond is 0 (success)
420 *
421 * If the assumption fails, the test will be marked as "skipped".
422 *
423 * @param cond Condition to check
424 * @param ... Optional message and variables to print if the assumption fails
425 */
426 #define zassume_ok(cond, ...) zassume(!(cond), #cond " is non-zero", ##__VA_ARGS__)
427
428 /**
429 * @brief Assume that @a ptr is NULL
430 *
431 * If the assumption fails, the test will be marked as "skipped".
432 *
433 * @param ptr Pointer to compare
434 * @param ... Optional message and variables to print if the assumption fails
435 */
436 #define zassume_is_null(ptr, ...) zassume((ptr) == NULL, #ptr " is not NULL", ##__VA_ARGS__)
437
438 /**
439 * @brief Assume that @a ptr is not NULL
440 *
441 * If the assumption fails, the test will be marked as "skipped".
442 *
443 * @param ptr Pointer to compare
444 * @param ... Optional message and variables to print if the assumption fails
445 */
446 #define zassume_not_null(ptr, ...) zassume((ptr) != NULL, #ptr " is NULL", ##__VA_ARGS__)
447
448 /**
449 * @brief Assume that @a a equals @a b
450 *
451 * @a a and @a b won't be converted and will be compared directly. If the
452 * assumption fails, the test will be marked as "skipped".
453 *
454 * @param a Value to compare
455 * @param b Value to compare
456 * @param ... Optional message and variables to print if the assumption fails
457 */
458 #define zassume_equal(a, b, ...) zassume((a) == (b), #a " not equal to " #b, ##__VA_ARGS__)
459
460 /**
461 * @brief Assume that @a a does not equal @a b
462 *
463 * @a a and @a b won't be converted and will be compared directly. If the
464 * assumption fails, the test will be marked as "skipped".
465 *
466 * @param a Value to compare
467 * @param b Value to compare
468 * @param ... Optional message and variables to print if the assumption fails
469 */
470 #define zassume_not_equal(a, b, ...) zassume((a) != (b), #a " equal to " #b, ##__VA_ARGS__)
471
472 /**
473 * @brief Assume that @a a equals @a b
474 *
475 * @a a and @a b will be converted to `void *` before comparing. If the
476 * assumption fails, the test will be marked as "skipped".
477 *
478 * @param a Value to compare
479 * @param b Value to compare
480 * @param ... Optional message and variables to print if the assumption fails
481 */
482 #define zassume_equal_ptr(a, b, ...) \
483 zassume((void *)(a) == (void *)(b), #a " not equal to " #b, ##__VA_ARGS__)
484
485 /**
486 * @brief Assume that @a a is within @a b with delta @a d
487 *
488 * If the assumption fails, the test will be marked as "skipped".
489 *
490 * @param a Value to compare
491 * @param b Value to compare
492 * @param d Delta
493 * @param ... Optional message and variables to print if the assumption fails
494 */
495 #define zassume_within(a, b, d, ...) \
496 zassume(((a) >= ((b) - (d))) && ((a) <= ((b) + (d))), #a " not within " #b " +/- " #d, \
497 ##__VA_ARGS__)
498
499 /**
500 * @brief Assume that @a a is greater than or equal to @a l and less
501 * than or equal to @a u
502 *
503 * If the assumption fails, the test will be marked as "skipped".
504 *
505 * @param a Value to compare
506 * @param l Lower limit
507 * @param u Upper limit
508 * @param ... Optional message and variables to print if the assumption fails
509 */
510 #define zassume_between_inclusive(a, l, u, ...) \
511 zassume(((a) >= (l)) && ((a) <= (u)), #a " not between " #l " and " #u " inclusive", \
512 ##__VA_ARGS__)
513
514 /**
515 * @brief Assume that 2 memory buffers have the same contents
516 *
517 * This macro calls the final memory comparison assumption macro.
518 * Using double expansion allows providing some arguments by macros that
519 * would expand to more than one values (ANSI-C99 defines that all the macro
520 * arguments have to be expanded before macro call).
521 *
522 * @param ... Arguments, see @ref zassume_mem_equal__
523 * for real arguments accepted.
524 */
525 #define zassume_mem_equal(...) zassume_mem_equal__(__VA_ARGS__)
526
527 /**
528 * @brief Internal assume that 2 memory buffers have the same contents
529 *
530 * If the assumption fails, the test will be marked as "skipped".
531 *
532 * @note This is internal macro, to be used as a second expansion.
533 * See @ref zassume_mem_equal.
534 *
535 * @param buf Buffer to compare
536 * @param exp Buffer with expected contents
537 * @param size Size of buffers
538 * @param ... Optional message and variables to print if the assumption fails
539 */
540 #define zassume_mem_equal__(buf, exp, size, ...) \
541 zassume(memcmp(buf, exp, size) == 0, #buf " not equal to " #exp, ##__VA_ARGS__)
542
543 /**
544 * @}
545 */
546
547 /**
548 * @defgroup ztest_expect Ztest expectation macros
549 * @ingroup ztest
550 *
551 * This module provides expectations when using Ztest.
552 *
553 * @{
554 */
555
556 /**
557 * @brief Expect that @a cond is true, otherwise mark test as failed but continue its execution.
558 *
559 * @param cond Condition to check
560 * @param ... Optional message and variables to print if the expectation fails
561 */
562 #define zexpect_true(cond, ...) zexpect(cond, #cond " is false", ##__VA_ARGS__)
563
564 /**
565 * @brief Expect that @a cond is false, otherwise mark test as failed but continue its execution.
566 *
567 * @param cond Condition to check
568 * @param ... Optional message and variables to print if the expectation fails
569 */
570 #define zexpect_false(cond, ...) zexpect(!(cond), #cond " is true", ##__VA_ARGS__)
571
572 /**
573 * @brief Expect that @a cond is 0 (success), otherwise mark test as failed but continue its
574 * execution.
575 *
576 * @param cond Condition to check
577 * @param ... Optional message and variables to print if the expectation fails
578 */
579 #define zexpect_ok(cond, ...) zexpect(!(cond), #cond " is non-zero", ##__VA_ARGS__)
580
581 /**
582 * @brief Expect that @a ptr is NULL, otherwise mark test as failed but continue its execution.
583 *
584 * @param ptr Pointer to compare
585 * @param ... Optional message and variables to print if the expectation fails
586 */
587 #define zexpect_is_null(ptr, ...) zexpect((ptr) == NULL, #ptr " is not NULL", ##__VA_ARGS__)
588
589 /**
590 * @brief Expect that @a ptr is not NULL, otherwise mark test as failed but continue its execution.
591 *
592 * @param ptr Pointer to compare
593 * @param ... Optional message and variables to print if the expectation fails
594 */
595 #define zexpect_not_null(ptr, ...) zexpect((ptr) != NULL, #ptr " is NULL", ##__VA_ARGS__)
596
597 /**
598 * @brief Expect that @a a equals @a b, otherwise mark test as failed but continue its execution.
599 * expectation fails, the test will be marked as "skipped".
600 *
601 * @param a Value to compare
602 * @param b Value to compare
603 * @param ... Optional message and variables to print if the expectation fails
604 */
605 #define zexpect_equal(a, b, ...) zexpect((a) == (b), #a " not equal to " #b, ##__VA_ARGS__)
606
607 /**
608 * @brief Expect that @a a does not equal @a b, otherwise mark test as failed but continue its
609 * execution.
610 *
611 * @a a and @a b won't be converted and will be compared directly.
612 *
613 * @param a Value to compare
614 * @param b Value to compare
615 * @param ... Optional message and variables to print if the expectation fails
616 */
617 #define zexpect_not_equal(a, b, ...) zexpect((a) != (b), #a " equal to " #b, ##__VA_ARGS__)
618
619 /**
620 * @brief Expect that @a a equals @a b, otherwise mark test as failed but continue its execution.
621 *
622 * @a a and @a b will be converted to `void *` before comparing.
623 *
624 * @param a Value to compare
625 * @param b Value to compare
626 * @param ... Optional message and variables to print if the expectation fails
627 */
628 #define zexpect_equal_ptr(a, b, ...) \
629 zexpect((void *)(a) == (void *)(b), #a " not equal to " #b, ##__VA_ARGS__)
630
631 /**
632 * @brief Expect that @a a is within @a b with delta @a d, otherwise mark test as failed but
633 * continue its execution.
634 *
635 * @param a Value to compare
636 * @param b Value to compare
637 * @param delta Difference between a and b
638 * @param ... Optional message and variables to print if the expectation fails
639 */
640 #define zexpect_within(a, b, delta, ...) \
641 zexpect(((a) >= ((b) - (delta))) && ((a) <= ((b) + (delta))), \
642 #a " not within " #b " +/- " #delta, ##__VA_ARGS__)
643
644 /**
645 * @brief Expect that @a a is greater than or equal to @a l and less
646 * than or equal to @a u, otherwise mark test as failed but continue its execution.
647 *
648 * @param a Value to compare
649 * @param lower Lower limit
650 * @param upper Upper limit
651 * @param ... Optional message and variables to print if the expectation fails
652 */
653 #define zexpect_between_inclusive(a, lower, upper, ...) \
654 zexpect(((a) >= (lower)) && ((a) <= (upper)), \
655 #a " not between " #lower " and " #upper " inclusive", ##__VA_ARGS__)
656
657 /**
658 * @brief Expect that 2 memory buffers have the same contents, otherwise mark test as failed but
659 * continue its execution.
660 *
661 * @param buf Buffer to compare
662 * @param exp Buffer with expected contents
663 * @param size Size of buffers
664 * @param ... Optional message and variables to print if the expectation fails
665 */
666 #define zexpect_mem_equal(buf, exp, size, ...) \
667 zexpect(memcmp(buf, exp, size) == 0, #buf " not equal to " #exp, ##__VA_ARGS__)
668
669 /**
670 * @}
671 */
672
673 #ifdef __cplusplus
674 }
675 #endif
676
677 #endif /* ZEPHYR_TESTSUITE_ZTEST_ASSERT_H_ */
678
