ztest_assert.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_TESTSUITE_ZTEST_ASSERT_H_
#define ZEPHYR_TESTSUITE_ZTEST_ASSERT_H_
 
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
 
#include <zephyr/ztest.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
const char *ztest_relative_filename(const char *file);
void ztest_test_fail(void);
void ztest_test_skip(void);
void ztest_test_expect_fail(void);
void ztest_skip_failed_assumption(void);
#if CONFIG_ZTEST_ASSERT_VERBOSE == 0
 
static inline bool z_zassert_(bool cond, const char *file, int line)
{
 if (cond == false) {
 PRINT("\n Assertion failed at %s:%d\n", ztest_relative_filename(file), line);
 ztest_test_fail();
 return false;
 }
 
 return true;
}
 
#define z_zassert(cond, default_msg, file, line, func, msg, ...) z_zassert_(cond, file, line)
 
static inline bool z_zassume_(bool cond, const char *file, int line)
{
 if (cond == false) {
 PRINT("\n Assumption failed at %s:%d\n", ztest_relative_filename(file), line);
 ztest_skip_failed_assumption();
 return false;
 }
 
 return true;
}
 
#define z_zassume(cond, default_msg, file, line, func, msg, ...) z_zassume_(cond, file, line)
 
static inline bool z_zexpect_(bool cond, const char *file, int line)
{
 if (cond == false) {
 PRINT("\n Expectation failed at %s:%d\n", ztest_relative_filename(file), line);
 ztest_test_expect_fail();
 return false;
 }
 
 return true;
}
 
#define z_zexpect(cond, default_msg, file, line, func, msg, ...) z_zexpect_(cond, file, line)
 
#else /* CONFIG_ZTEST_ASSERT_VERBOSE != 0 */
 
static inline bool z_zassert(bool cond, const char *default_msg, const char *file, int line,
 const char *func, const char *msg, ...)
{
 if (cond == false) {
 va_list vargs;
 
 va_start(vargs, msg);
 PRINT("\n Assertion failed at %s:%d: %s: %s\n", ztest_relative_filename(file),
 line, func, default_msg);
 vprintk(msg, vargs);
 printk("\n");
 va_end(vargs);
 ztest_test_fail();
 return false;
 }
#if CONFIG_ZTEST_ASSERT_VERBOSE == 2
 else {
 PRINT("\n Assertion succeeded at %s:%d (%s)\n", ztest_relative_filename(file),
 line, func);
 }
#endif
 return true;
}
 
static inline bool z_zassume(bool cond, const char *default_msg, const char *file, int line,
 const char *func, const char *msg, ...)
{
 if (cond == false) {
 va_list vargs;
 
 va_start(vargs, msg);
 PRINT("\n Assumption failed at %s:%d: %s: %s\n", ztest_relative_filename(file),
 line, func, default_msg);
 vprintk(msg, vargs);
 printk("\n");
 va_end(vargs);
 ztest_skip_failed_assumption();
 return false;
 }
#if CONFIG_ZTEST_ASSERT_VERBOSE == 2
 else {
 PRINT("\n Assumption succeeded at %s:%d (%s)\n", ztest_relative_filename(file),
 line, func);
 }
#endif
 return true;
}
 
static inline bool z_zexpect(bool cond, const char *default_msg, const char *file, int line,
 const char *func, const char *msg, ...)
{
 if (cond == false) {
 va_list vargs;
 
 va_start(vargs, msg);
 PRINT("\n Expectation failed at %s:%d: %s: %s\n", ztest_relative_filename(file),
 line, func, default_msg);
 vprintk(msg, vargs);
 printk("\n");
 va_end(vargs);
 ztest_test_expect_fail();
 return false;
 }
#if CONFIG_ZTEST_ASSERT_VERBOSE == 2
 else {
 PRINT("\n Expectation succeeded at %s:%d (%s)\n", ztest_relative_filename(file),
 line, func);
 }
#endif
 return true;
}
 
#endif /* CONFIG_ZTEST_ASSERT_VERBOSE */
 
#define _zassert_base(cond, default_msg, msg, ...) \
 do { \
 bool _msg = (msg != NULL); \
 bool _ret = z_zassert(cond, _msg ? ("(" default_msg ")") : (default_msg), __FILE__,\
 __LINE__, __func__, _msg ? msg : "", ##__VA_ARGS__); \
 (void)_msg; \
 if (!_ret) { \
 /* If kernel but without multithreading return. */ \
 COND_CODE_1(KERNEL, (COND_CODE_1(CONFIG_MULTITHREADING, (), (return;))), \
 ()) \
 } \
 } while (0)
 
#define _zassert_va(cond, default_msg, msg, ...) \
 _zassert_base(cond, default_msg, msg, ##__VA_ARGS__)
 
#define zassert(cond, default_msg, ...) \
 _zassert_va(cond, default_msg, COND_CODE_1(__VA_OPT__(1), (__VA_ARGS__), (NULL)))
 
#define _zassume_base(cond, default_msg, msg, ...) \
 do { \
 bool _msg = (msg != NULL); \
 bool _ret = z_zassume(cond, _msg ? ("(" default_msg ")") : (default_msg), __FILE__,\
 __LINE__, __func__, _msg ? msg : "", ##__VA_ARGS__); \
 (void)_msg; \
 if (!_ret) { \
 /* If kernel but without multithreading return. */ \
 COND_CODE_1(KERNEL, (COND_CODE_1(CONFIG_MULTITHREADING, (), (return;))), \
 ()) \
 } \
 } while (0)
 
#define _zassume_va(cond, default_msg, msg, ...) \
 _zassume_base(cond, default_msg, msg, ##__VA_ARGS__)
 
#define zassume(cond, default_msg, ...) \
 _zassume_va(cond, default_msg, COND_CODE_1(__VA_OPT__(1), (__VA_ARGS__), (NULL)))
 
#define _zexpect_base(cond, default_msg, msg, ...) \
 do { \
 bool _msg = (msg != NULL); \
 bool _ret = \
 z_zexpect(cond, _msg ? ("(" default_msg ")") : (default_msg), __FILE__, \
 __LINE__, __func__, _msg ? msg : "", ##__VA_ARGS__); \
 (void)_msg; \
 if (!_ret) { \
 /* If kernel but without multithreading return. */ \
 COND_CODE_1(KERNEL, (COND_CODE_1(CONFIG_MULTITHREADING, (), (return;))), \
 ()) \
 } \
 } while (0)
 
#define _zexpect_va(cond, default_msg, msg, ...) \
 _zexpect_base(cond, default_msg, msg, ##__VA_ARGS__)
 
#define zexpect(cond, default_msg, ...) \
 _zexpect_va(cond, default_msg, COND_CODE_1(__VA_OPT__(1), (__VA_ARGS__), (NULL)))
 
#define zassert_unreachable(...) zassert(0, "Reached unreachable code", ##__VA_ARGS__)
 
#define zassert_true(cond, ...) zassert(cond, #cond " is false", ##__VA_ARGS__)
 
#define zassert_false(cond, ...) zassert(!(cond), #cond " is true", ##__VA_ARGS__)
 
#define zassert_ok(cond, ...) zassert(!(cond), #cond " is non-zero", ##__VA_ARGS__)
 
#define zassert_not_ok(cond, ...) zassert(!!(cond), #cond " is zero", ##__VA_ARGS__)
 
#define zassert_is_null(ptr, ...) zassert((ptr) == NULL, #ptr " is not NULL", ##__VA_ARGS__)
 
#define zassert_not_null(ptr, ...) zassert((ptr) != NULL, #ptr " is NULL", ##__VA_ARGS__)
 
#define zassert_equal(a, b, ...) zassert((a) == (b), #a " not equal to " #b, ##__VA_ARGS__)
 
#define zassert_not_equal(a, b, ...) zassert((a) != (b), #a " equal to " #b, ##__VA_ARGS__)
 
#define zassert_equal_ptr(a, b, ...) \
 zassert((void *)(a) == (void *)(b), #a " not equal to " #b, ##__VA_ARGS__)
 
#define zassert_within(a, b, d, ...) \
 zassert(((a) >= ((b) - (d))) && ((a) <= ((b) + (d))), #a " not within " #b " +/- " #d, \
 ##__VA_ARGS__)
 
#define zassert_between_inclusive(a, l, u, ...) \
 zassert(((a) >= (l)) && ((a) <= (u)), #a " not between " #l " and " #u " inclusive", \
 ##__VA_ARGS__)
 
#define zassert_mem_equal(...) zassert_mem_equal__(__VA_ARGS__)
 
#define zassert_mem_equal__(buf, exp, size, ...) \
 zassert(memcmp(buf, exp, size) == 0, #buf " not equal to " #exp, ##__VA_ARGS__)
 
#define zassert_str_equal(s1, s2, ...) \
 zassert(strcmp(s1, s2) == 0, #s1 " not equal to " #s2, ##__VA_ARGS__)
 
#define zassume_true(cond, ...) zassume(cond, #cond " is false", ##__VA_ARGS__)
 
#define zassume_false(cond, ...) zassume(!(cond), #cond " is true", ##__VA_ARGS__)
 
#define zassume_ok(cond, ...) zassume(!(cond), #cond " is non-zero", ##__VA_ARGS__)
 
#define zassume_not_ok(cond, ...) zassume(!!(cond), #cond " is zero", ##__VA_ARGS__)
 
#define zassume_is_null(ptr, ...) zassume((ptr) == NULL, #ptr " is not NULL", ##__VA_ARGS__)
 
#define zassume_not_null(ptr, ...) zassume((ptr) != NULL, #ptr " is NULL", ##__VA_ARGS__)
 
#define zassume_equal(a, b, ...) zassume((a) == (b), #a " not equal to " #b, ##__VA_ARGS__)
 
#define zassume_not_equal(a, b, ...) zassume((a) != (b), #a " equal to " #b, ##__VA_ARGS__)
 
#define zassume_equal_ptr(a, b, ...) \
 zassume((void *)(a) == (void *)(b), #a " not equal to " #b, ##__VA_ARGS__)
 
#define zassume_within(a, b, d, ...) \
 zassume(((a) >= ((b) - (d))) && ((a) <= ((b) + (d))), #a " not within " #b " +/- " #d, \
 ##__VA_ARGS__)
 
#define zassume_between_inclusive(a, l, u, ...) \
 zassume(((a) >= (l)) && ((a) <= (u)), #a " not between " #l " and " #u " inclusive", \
 ##__VA_ARGS__)
 
#define zassume_mem_equal(...) zassume_mem_equal__(__VA_ARGS__)
 
#define zassume_mem_equal__(buf, exp, size, ...) \
 zassume(memcmp(buf, exp, size) == 0, #buf " not equal to " #exp, ##__VA_ARGS__)
 
#define zassume_str_equal(s1, s2, ...) \
 zassume(strcmp(s1, s2) == 0, #s1 " not equal to " #s2, ##__VA_ARGS__)
 
#define zexpect_true(cond, ...) zexpect(cond, #cond " is false", ##__VA_ARGS__)
 
#define zexpect_false(cond, ...) zexpect(!(cond), #cond " is true", ##__VA_ARGS__)
 
#define zexpect_ok(cond, ...) zexpect(!(cond), #cond " is non-zero", ##__VA_ARGS__)
 
#define zexpect_not_ok(cond, ...) zexpect(!!(cond), #cond " is zero", ##__VA_ARGS__)
 
#define zexpect_is_null(ptr, ...) zexpect((ptr) == NULL, #ptr " is not NULL", ##__VA_ARGS__)
 
#define zexpect_not_null(ptr, ...) zexpect((ptr) != NULL, #ptr " is NULL", ##__VA_ARGS__)
 
#define zexpect_equal(a, b, ...) zexpect((a) == (b), #a " not equal to " #b, ##__VA_ARGS__)
 
#define zexpect_not_equal(a, b, ...) zexpect((a) != (b), #a " equal to " #b, ##__VA_ARGS__)
 
#define zexpect_equal_ptr(a, b, ...) \
 zexpect((void *)(a) == (void *)(b), #a " not equal to " #b, ##__VA_ARGS__)
 
#define zexpect_within(a, b, delta, ...) \
 zexpect(((a) >= ((b) - (delta))) && ((a) <= ((b) + (delta))), \
 #a " not within " #b " +/- " #delta, ##__VA_ARGS__)
 
#define zexpect_between_inclusive(a, lower, upper, ...) \
 zexpect(((a) >= (lower)) && ((a) <= (upper)), \
 #a " not between " #lower " and " #upper " inclusive", ##__VA_ARGS__)
 
#define zexpect_mem_equal(buf, exp, size, ...) \
 zexpect(memcmp(buf, exp, size) == 0, #buf " not equal to " #exp, ##__VA_ARGS__)
 
#define zexpect_str_equal(s1, s2, ...) \
 zexpect(strcmp(s1, s2) == 0, #s1 " not equal to " #s2, ##__VA_ARGS__)
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_TESTSUITE_ZTEST_ASSERT_H_ */