[rustc.git] / src / jemalloc / test / include / test / test.h

#define	ASSERT_BUFSIZE	256

#define	assert_cmp(t, a, b, cmp, neg_cmp, pri, ...) do {		\
	t a_ = (a);							\
	t b_ = (b);							\
	if (!(a_ cmp b_)) {						\
		char prefix[ASSERT_BUFSIZE];				\
		char message[ASSERT_BUFSIZE];				\
		malloc_snprintf(prefix, sizeof(prefix),			\
		    "%s:%s:%d: Failed assertion: "			\
		    "(%s) "#cmp" (%s) --> "				\
		    "%"pri" "#neg_cmp" %"pri": ",			\
		    __func__, __FILE__, __LINE__,			\
		    #a, #b, a_, b_);					\
		malloc_snprintf(message, sizeof(message), __VA_ARGS__);	\
		p_test_fail(prefix, message);				\
	}								\
} while (0)

#define	assert_ptr_eq(a, b, ...)	assert_cmp(void *, a, b, ==,	\
    !=, "p", __VA_ARGS__)
#define	assert_ptr_ne(a, b, ...)	assert_cmp(void *, a, b, !=,	\
    ==, "p", __VA_ARGS__)
#define	assert_ptr_null(a, ...)		assert_cmp(void *, a, NULL, ==,	\
    !=, "p", __VA_ARGS__)
#define	assert_ptr_not_null(a, ...)	assert_cmp(void *, a, NULL, !=,	\
    ==, "p", __VA_ARGS__)

#define	assert_c_eq(a, b, ...)	assert_cmp(char, a, b, ==, !=, "c", __VA_ARGS__)
#define	assert_c_ne(a, b, ...)	assert_cmp(char, a, b, !=, ==, "c", __VA_ARGS__)
#define	assert_c_lt(a, b, ...)	assert_cmp(char, a, b, <, >=, "c", __VA_ARGS__)
#define	assert_c_le(a, b, ...)	assert_cmp(char, a, b, <=, >, "c", __VA_ARGS__)
#define	assert_c_ge(a, b, ...)	assert_cmp(char, a, b, >=, <, "c", __VA_ARGS__)
#define	assert_c_gt(a, b, ...)	assert_cmp(char, a, b, >, <=, "c", __VA_ARGS__)

#define	assert_x_eq(a, b, ...)	assert_cmp(int, a, b, ==, !=, "#x", __VA_ARGS__)
#define	assert_x_ne(a, b, ...)	assert_cmp(int, a, b, !=, ==, "#x", __VA_ARGS__)
#define	assert_x_lt(a, b, ...)	assert_cmp(int, a, b, <, >=, "#x", __VA_ARGS__)
#define	assert_x_le(a, b, ...)	assert_cmp(int, a, b, <=, >, "#x", __VA_ARGS__)
#define	assert_x_ge(a, b, ...)	assert_cmp(int, a, b, >=, <, "#x", __VA_ARGS__)
#define	assert_x_gt(a, b, ...)	assert_cmp(int, a, b, >, <=, "#x", __VA_ARGS__)

#define	assert_d_eq(a, b, ...)	assert_cmp(int, a, b, ==, !=, "d", __VA_ARGS__)
#define	assert_d_ne(a, b, ...)	assert_cmp(int, a, b, !=, ==, "d", __VA_ARGS__)
#define	assert_d_lt(a, b, ...)	assert_cmp(int, a, b, <, >=, "d", __VA_ARGS__)
#define	assert_d_le(a, b, ...)	assert_cmp(int, a, b, <=, >, "d", __VA_ARGS__)
#define	assert_d_ge(a, b, ...)	assert_cmp(int, a, b, >=, <, "d", __VA_ARGS__)
#define	assert_d_gt(a, b, ...)	assert_cmp(int, a, b, >, <=, "d", __VA_ARGS__)

#define	assert_u_eq(a, b, ...)	assert_cmp(int, a, b, ==, !=, "u", __VA_ARGS__)
#define	assert_u_ne(a, b, ...)	assert_cmp(int, a, b, !=, ==, "u", __VA_ARGS__)
#define	assert_u_lt(a, b, ...)	assert_cmp(int, a, b, <, >=, "u", __VA_ARGS__)
#define	assert_u_le(a, b, ...)	assert_cmp(int, a, b, <=, >, "u", __VA_ARGS__)
#define	assert_u_ge(a, b, ...)	assert_cmp(int, a, b, >=, <, "u", __VA_ARGS__)
#define	assert_u_gt(a, b, ...)	assert_cmp(int, a, b, >, <=, "u", __VA_ARGS__)

#define	assert_ld_eq(a, b, ...)	assert_cmp(long, a, b, ==,	\
    !=, "ld", __VA_ARGS__)
#define	assert_ld_ne(a, b, ...)	assert_cmp(long, a, b, !=,	\
    ==, "ld", __VA_ARGS__)
#define	assert_ld_lt(a, b, ...)	assert_cmp(long, a, b, <,	\
    >=, "ld", __VA_ARGS__)
#define	assert_ld_le(a, b, ...)	assert_cmp(long, a, b, <=,	\
    >, "ld", __VA_ARGS__)
#define	assert_ld_ge(a, b, ...)	assert_cmp(long, a, b, >=,	\
    <, "ld", __VA_ARGS__)
#define	assert_ld_gt(a, b, ...)	assert_cmp(long, a, b, >,	\
    <=, "ld", __VA_ARGS__)

#define	assert_lu_eq(a, b, ...)	assert_cmp(unsigned long,	\
    a, b, ==, !=, "lu", __VA_ARGS__)
#define	assert_lu_ne(a, b, ...)	assert_cmp(unsigned long,	\
    a, b, !=, ==, "lu", __VA_ARGS__)
#define	assert_lu_lt(a, b, ...)	assert_cmp(unsigned long,	\
    a, b, <, >=, "lu", __VA_ARGS__)
#define	assert_lu_le(a, b, ...)	assert_cmp(unsigned long,	\
    a, b, <=, >, "lu", __VA_ARGS__)
#define	assert_lu_ge(a, b, ...)	assert_cmp(unsigned long,	\
    a, b, >=, <, "lu", __VA_ARGS__)
#define	assert_lu_gt(a, b, ...)	assert_cmp(unsigned long,	\
    a, b, >, <=, "lu", __VA_ARGS__)

#define	assert_qd_eq(a, b, ...)	assert_cmp(long long, a, b, ==,	\
    !=, "qd", __VA_ARGS__)
#define	assert_qd_ne(a, b, ...)	assert_cmp(long long, a, b, !=,	\
    ==, "qd", __VA_ARGS__)
#define	assert_qd_lt(a, b, ...)	assert_cmp(long long, a, b, <,	\
    >=, "qd", __VA_ARGS__)
#define	assert_qd_le(a, b, ...)	assert_cmp(long long, a, b, <=,	\
    >, "qd", __VA_ARGS__)
#define	assert_qd_ge(a, b, ...)	assert_cmp(long long, a, b, >=,	\
    <, "qd", __VA_ARGS__)
#define	assert_qd_gt(a, b, ...)	assert_cmp(long long, a, b, >,	\
    <=, "qd", __VA_ARGS__)

#define	assert_qu_eq(a, b, ...)	assert_cmp(unsigned long long,	\
    a, b, ==, !=, "qu", __VA_ARGS__)
#define	assert_qu_ne(a, b, ...)	assert_cmp(unsigned long long,	\
    a, b, !=, ==, "qu", __VA_ARGS__)
#define	assert_qu_lt(a, b, ...)	assert_cmp(unsigned long long,	\
    a, b, <, >=, "qu", __VA_ARGS__)
#define	assert_qu_le(a, b, ...)	assert_cmp(unsigned long long,	\
    a, b, <=, >, "qu", __VA_ARGS__)
#define	assert_qu_ge(a, b, ...)	assert_cmp(unsigned long long,	\
    a, b, >=, <, "qu", __VA_ARGS__)
#define	assert_qu_gt(a, b, ...)	assert_cmp(unsigned long long,	\
    a, b, >, <=, "qu", __VA_ARGS__)

#define	assert_jd_eq(a, b, ...)	assert_cmp(intmax_t, a, b, ==,	\
    !=, "jd", __VA_ARGS__)
#define	assert_jd_ne(a, b, ...)	assert_cmp(intmax_t, a, b, !=,	\
    ==, "jd", __VA_ARGS__)
#define	assert_jd_lt(a, b, ...)	assert_cmp(intmax_t, a, b, <,	\
    >=, "jd", __VA_ARGS__)
#define	assert_jd_le(a, b, ...)	assert_cmp(intmax_t, a, b, <=,	\
    >, "jd", __VA_ARGS__)
#define	assert_jd_ge(a, b, ...)	assert_cmp(intmax_t, a, b, >=,	\
    <, "jd", __VA_ARGS__)
#define	assert_jd_gt(a, b, ...)	assert_cmp(intmax_t, a, b, >,	\
    <=, "jd", __VA_ARGS__)

#define	assert_ju_eq(a, b, ...)	assert_cmp(uintmax_t, a, b, ==,	\
    !=, "ju", __VA_ARGS__)
#define	assert_ju_ne(a, b, ...)	assert_cmp(uintmax_t, a, b, !=,	\
    ==, "ju", __VA_ARGS__)
#define	assert_ju_lt(a, b, ...)	assert_cmp(uintmax_t, a, b, <,	\
    >=, "ju", __VA_ARGS__)
#define	assert_ju_le(a, b, ...)	assert_cmp(uintmax_t, a, b, <=,	\
    >, "ju", __VA_ARGS__)
#define	assert_ju_ge(a, b, ...)	assert_cmp(uintmax_t, a, b, >=,	\
    <, "ju", __VA_ARGS__)
#define	assert_ju_gt(a, b, ...)	assert_cmp(uintmax_t, a, b, >,	\
    <=, "ju", __VA_ARGS__)

#define	assert_zd_eq(a, b, ...)	assert_cmp(ssize_t, a, b, ==,	\
    !=, "zd", __VA_ARGS__)
#define	assert_zd_ne(a, b, ...)	assert_cmp(ssize_t, a, b, !=,	\
    ==, "zd", __VA_ARGS__)
#define	assert_zd_lt(a, b, ...)	assert_cmp(ssize_t, a, b, <,	\
    >=, "zd", __VA_ARGS__)
#define	assert_zd_le(a, b, ...)	assert_cmp(ssize_t, a, b, <=,	\
    >, "zd", __VA_ARGS__)
#define	assert_zd_ge(a, b, ...)	assert_cmp(ssize_t, a, b, >=,	\
    <, "zd", __VA_ARGS__)
#define	assert_zd_gt(a, b, ...)	assert_cmp(ssize_t, a, b, >,	\
    <=, "zd", __VA_ARGS__)

#define	assert_zu_eq(a, b, ...)	assert_cmp(size_t, a, b, ==,	\
    !=, "zu", __VA_ARGS__)
#define	assert_zu_ne(a, b, ...)	assert_cmp(size_t, a, b, !=,	\
    ==, "zu", __VA_ARGS__)
#define	assert_zu_lt(a, b, ...)	assert_cmp(size_t, a, b, <,	\
    >=, "zu", __VA_ARGS__)
#define	assert_zu_le(a, b, ...)	assert_cmp(size_t, a, b, <=,	\
    >, "zu", __VA_ARGS__)
#define	assert_zu_ge(a, b, ...)	assert_cmp(size_t, a, b, >=,	\
    <, "zu", __VA_ARGS__)
#define	assert_zu_gt(a, b, ...)	assert_cmp(size_t, a, b, >,	\
    <=, "zu", __VA_ARGS__)

#define	assert_d32_eq(a, b, ...)	assert_cmp(int32_t, a, b, ==,	\
    !=, FMTd32, __VA_ARGS__)
#define	assert_d32_ne(a, b, ...)	assert_cmp(int32_t, a, b, !=,	\
    ==, FMTd32, __VA_ARGS__)
#define	assert_d32_lt(a, b, ...)	assert_cmp(int32_t, a, b, <,	\
    >=, FMTd32, __VA_ARGS__)
#define	assert_d32_le(a, b, ...)	assert_cmp(int32_t, a, b, <=,	\
    >, FMTd32, __VA_ARGS__)
#define	assert_d32_ge(a, b, ...)	assert_cmp(int32_t, a, b, >=,	\
    <, FMTd32, __VA_ARGS__)
#define	assert_d32_gt(a, b, ...)	assert_cmp(int32_t, a, b, >,	\
    <=, FMTd32, __VA_ARGS__)

#define	assert_u32_eq(a, b, ...)	assert_cmp(uint32_t, a, b, ==,	\
    !=, FMTu32, __VA_ARGS__)
#define	assert_u32_ne(a, b, ...)	assert_cmp(uint32_t, a, b, !=,	\
    ==, FMTu32, __VA_ARGS__)
#define	assert_u32_lt(a, b, ...)	assert_cmp(uint32_t, a, b, <,	\
    >=, FMTu32, __VA_ARGS__)
#define	assert_u32_le(a, b, ...)	assert_cmp(uint32_t, a, b, <=,	\
    >, FMTu32, __VA_ARGS__)
#define	assert_u32_ge(a, b, ...)	assert_cmp(uint32_t, a, b, >=,	\
    <, FMTu32, __VA_ARGS__)
#define	assert_u32_gt(a, b, ...)	assert_cmp(uint32_t, a, b, >,	\
    <=, FMTu32, __VA_ARGS__)

#define	assert_d64_eq(a, b, ...)	assert_cmp(int64_t, a, b, ==,	\
    !=, FMTd64, __VA_ARGS__)
#define	assert_d64_ne(a, b, ...)	assert_cmp(int64_t, a, b, !=,	\
    ==, FMTd64, __VA_ARGS__)
#define	assert_d64_lt(a, b, ...)	assert_cmp(int64_t, a, b, <,	\
    >=, FMTd64, __VA_ARGS__)
#define	assert_d64_le(a, b, ...)	assert_cmp(int64_t, a, b, <=,	\
    >, FMTd64, __VA_ARGS__)
#define	assert_d64_ge(a, b, ...)	assert_cmp(int64_t, a, b, >=,	\
    <, FMTd64, __VA_ARGS__)
#define	assert_d64_gt(a, b, ...)	assert_cmp(int64_t, a, b, >,	\
    <=, FMTd64, __VA_ARGS__)

#define	assert_u64_eq(a, b, ...)	assert_cmp(uint64_t, a, b, ==,	\
    !=, FMTu64, __VA_ARGS__)
#define	assert_u64_ne(a, b, ...)	assert_cmp(uint64_t, a, b, !=,	\
    ==, FMTu64, __VA_ARGS__)
#define	assert_u64_lt(a, b, ...)	assert_cmp(uint64_t, a, b, <,	\
    >=, FMTu64, __VA_ARGS__)
#define	assert_u64_le(a, b, ...)	assert_cmp(uint64_t, a, b, <=,	\
    >, FMTu64, __VA_ARGS__)
#define	assert_u64_ge(a, b, ...)	assert_cmp(uint64_t, a, b, >=,	\
    <, FMTu64, __VA_ARGS__)
#define	assert_u64_gt(a, b, ...)	assert_cmp(uint64_t, a, b, >,	\
    <=, FMTu64, __VA_ARGS__)

#define	assert_b_eq(a, b, ...) do {					\
	bool a_ = (a);							\
	bool b_ = (b);							\
	if (!(a_ == b_)) {						\
		char prefix[ASSERT_BUFSIZE];				\
		char message[ASSERT_BUFSIZE];				\
		malloc_snprintf(prefix, sizeof(prefix),			\
		    "%s:%s:%d: Failed assertion: "			\
		    "(%s) == (%s) --> %s != %s: ",			\
		    __func__, __FILE__, __LINE__,			\
		    #a, #b, a_ ? "true" : "false",			\
		    b_ ? "true" : "false");				\
		malloc_snprintf(message, sizeof(message), __VA_ARGS__);	\
		p_test_fail(prefix, message);				\
	}								\
} while (0)
#define	assert_b_ne(a, b, ...) do {					\
	bool a_ = (a);							\
	bool b_ = (b);							\
	if (!(a_ != b_)) {						\
		char prefix[ASSERT_BUFSIZE];				\
		char message[ASSERT_BUFSIZE];				\
		malloc_snprintf(prefix, sizeof(prefix),			\
		    "%s:%s:%d: Failed assertion: "			\
		    "(%s) != (%s) --> %s == %s: ",			\
		    __func__, __FILE__, __LINE__,			\
		    #a, #b, a_ ? "true" : "false",			\
		    b_ ? "true" : "false");				\
		malloc_snprintf(message, sizeof(message), __VA_ARGS__);	\
		p_test_fail(prefix, message);				\
	}								\
} while (0)
#define	assert_true(a, ...)	assert_b_eq(a, true, __VA_ARGS__)
#define	assert_false(a, ...)	assert_b_eq(a, false, __VA_ARGS__)

#define	assert_str_eq(a, b, ...) do {				\
	if (strcmp((a), (b))) {						\
		char prefix[ASSERT_BUFSIZE];				\
		char message[ASSERT_BUFSIZE];				\
		malloc_snprintf(prefix, sizeof(prefix),			\
		    "%s:%s:%d: Failed assertion: "			\
		    "(%s) same as (%s) --> "				\
		    "\"%s\" differs from \"%s\": ",			\
		    __func__, __FILE__, __LINE__, #a, #b, a, b);	\
		malloc_snprintf(message, sizeof(message), __VA_ARGS__);	\
		p_test_fail(prefix, message);				\
	}								\
} while (0)
#define	assert_str_ne(a, b, ...) do {				\
	if (!strcmp((a), (b))) {					\
		char prefix[ASSERT_BUFSIZE];				\
		char message[ASSERT_BUFSIZE];				\
		malloc_snprintf(prefix, sizeof(prefix),			\
		    "%s:%s:%d: Failed assertion: "			\
		    "(%s) differs from (%s) --> "			\
		    "\"%s\" same as \"%s\": ",				\
		    __func__, __FILE__, __LINE__, #a, #b, a, b);	\
		malloc_snprintf(message, sizeof(message), __VA_ARGS__);	\
		p_test_fail(prefix, message);				\
	}								\
} while (0)

#define	assert_not_reached(...) do {					\
	char prefix[ASSERT_BUFSIZE];					\
	char message[ASSERT_BUFSIZE];					\
	malloc_snprintf(prefix, sizeof(prefix),				\
	    "%s:%s:%d: Unreachable code reached: ",			\
	    __func__, __FILE__, __LINE__);				\
	malloc_snprintf(message, sizeof(message), __VA_ARGS__);		\
	p_test_fail(prefix, message);					\
} while (0)

/*
 * If this enum changes, corresponding changes in test/test.sh.in are also
 * necessary.
 */
typedef enum {
	test_status_pass = 0,
	test_status_skip = 1,
	test_status_fail = 2,

	test_status_count = 3
} test_status_t;

typedef void (test_t)(void);

#define	TEST_BEGIN(f)							\
static void								\
f(void)									\
{									\
	p_test_init(#f);

#define	TEST_END							\
	goto label_test_end;						\
label_test_end:								\
	p_test_fini();							\
}

#define	test(...)							\
	p_test(__VA_ARGS__, NULL)

#define	test_skip_if(e) do {						\
	if (e) {							\
		test_skip("%s:%s:%d: Test skipped: (%s)",		\
		    __func__, __FILE__, __LINE__, #e);			\
		goto label_test_end;					\
	}								\
} while (0)

void	test_skip(const char *format, ...) JEMALLOC_FORMAT_PRINTF(1, 2);
void	test_fail(const char *format, ...) JEMALLOC_FORMAT_PRINTF(1, 2);

/* For private use by macros. */
test_status_t	p_test(test_t *t, ...);
void	p_test_init(const char *name);
void	p_test_fini(void);
void	p_test_fail(const char *prefix, const char *message);
Commit	Line	Data
1a4d82fc JJ	1	#define ASSERT_BUFSIZE 256
	2
	3	#define assert_cmp(t, a, b, cmp, neg_cmp, pri, ...) do { \
	4	t a_ = (a); \
	5	t b_ = (b); \
	6	if (!(a_ cmp b_)) { \
	7	char prefix[ASSERT_BUFSIZE]; \
	8	char message[ASSERT_BUFSIZE]; \
	9	malloc_snprintf(prefix, sizeof(prefix), \
	10	"%s:%s:%d: Failed assertion: " \
	11	"(%s) "#cmp" (%s) --> " \
	12	"%"pri" "#neg_cmp" %"pri": ", \
	13	__func__, __FILE__, __LINE__, \
	14	#a, #b, a_, b_); \
	15	malloc_snprintf(message, sizeof(message), __VA_ARGS__); \
	16	p_test_fail(prefix, message); \
	17	} \
	18	} while (0)
	19
	20	#define assert_ptr_eq(a, b, ...) assert_cmp(void *, a, b, ==, \
	21	!=, "p", __VA_ARGS__)
	22	#define assert_ptr_ne(a, b, ...) assert_cmp(void *, a, b, !=, \
	23	==, "p", __VA_ARGS__)
	24	#define assert_ptr_null(a, ...) assert_cmp(void *, a, NULL, ==, \
	25	!=, "p", __VA_ARGS__)
	26	#define assert_ptr_not_null(a, ...) assert_cmp(void *, a, NULL, !=, \
	27	==, "p", __VA_ARGS__)
	28
	29	#define assert_c_eq(a, b, ...) assert_cmp(char, a, b, ==, !=, "c", __VA_ARGS__)
	30	#define assert_c_ne(a, b, ...) assert_cmp(char, a, b, !=, ==, "c", __VA_ARGS__)
	31	#define assert_c_lt(a, b, ...) assert_cmp(char, a, b, <, >=, "c", __VA_ARGS__)
	32	#define assert_c_le(a, b, ...) assert_cmp(char, a, b, <=, >, "c", __VA_ARGS__)
	33	#define assert_c_ge(a, b, ...) assert_cmp(char, a, b, >=, <, "c", __VA_ARGS__)
	34	#define assert_c_gt(a, b, ...) assert_cmp(char, a, b, >, <=, "c", __VA_ARGS__)
	35
	36	#define assert_x_eq(a, b, ...) assert_cmp(int, a, b, ==, !=, "#x", __VA_ARGS__)
	37	#define assert_x_ne(a, b, ...) assert_cmp(int, a, b, !=, ==, "#x", __VA_ARGS__)
	38	#define assert_x_lt(a, b, ...) assert_cmp(int, a, b, <, >=, "#x", __VA_ARGS__)
	39	#define assert_x_le(a, b, ...) assert_cmp(int, a, b, <=, >, "#x", __VA_ARGS__)
	40	#define assert_x_ge(a, b, ...) assert_cmp(int, a, b, >=, <, "#x", __VA_ARGS__)
	41	#define assert_x_gt(a, b, ...) assert_cmp(int, a, b, >, <=, "#x", __VA_ARGS__)
	42
	43	#define assert_d_eq(a, b, ...) assert_cmp(int, a, b, ==, !=, "d", __VA_ARGS__)
	44	#define assert_d_ne(a, b, ...) assert_cmp(int, a, b, !=, ==, "d", __VA_ARGS__)
	45	#define assert_d_lt(a, b, ...) assert_cmp(int, a, b, <, >=, "d", __VA_ARGS__)
	46	#define assert_d_le(a, b, ...) assert_cmp(int, a, b, <=, >, "d", __VA_ARGS__)
	47	#define assert_d_ge(a, b, ...) assert_cmp(int, a, b, >=, <, "d", __VA_ARGS__)
	48	#define assert_d_gt(a, b, ...) assert_cmp(int, a, b, >, <=, "d", __VA_ARGS__)
	49
	50	#define assert_u_eq(a, b, ...) assert_cmp(int, a, b, ==, !=, "u", __VA_ARGS__)
	51	#define assert_u_ne(a, b, ...) assert_cmp(int, a, b, !=, ==, "u", __VA_ARGS__)
	52	#define assert_u_lt(a, b, ...) assert_cmp(int, a, b, <, >=, "u", __VA_ARGS__)
	53	#define assert_u_le(a, b, ...) assert_cmp(int, a, b, <=, >, "u", __VA_ARGS__)
	54	#define assert_u_ge(a, b, ...) assert_cmp(int, a, b, >=, <, "u", __VA_ARGS__)
	55	#define assert_u_gt(a, b, ...) assert_cmp(int, a, b, >, <=, "u", __VA_ARGS__)
	56
	57	#define assert_ld_eq(a, b, ...) assert_cmp(long, a, b, ==, \
	58	!=, "ld", __VA_ARGS__)
	59	#define assert_ld_ne(a, b, ...) assert_cmp(long, a, b, !=, \
	60	==, "ld", __VA_ARGS__)
	61	#define assert_ld_lt(a, b, ...) assert_cmp(long, a, b, <, \
	62	>=, "ld", __VA_ARGS__)
	63	#define assert_ld_le(a, b, ...) assert_cmp(long, a, b, <=, \
	64	>, "ld", __VA_ARGS__)
65	#define assert_ld_ge(a, b, ...) assert_cmp(long, a, b, >=, \
66	<, "ld", __VA_ARGS__)
67	#define assert_ld_gt(a, b, ...) assert_cmp(long, a, b, >, \
68	<=, "ld", __VA_ARGS__)
69
70	#define assert_lu_eq(a, b, ...) assert_cmp(unsigned long, \
71	a, b, ==, !=, "lu", __VA_ARGS__)
72	#define assert_lu_ne(a, b, ...) assert_cmp(unsigned long, \
73	a, b, !=, ==, "lu", __VA_ARGS__)
74	#define assert_lu_lt(a, b, ...) assert_cmp(unsigned long, \
75	a, b, <, >=, "lu", __VA_ARGS__)
76	#define assert_lu_le(a, b, ...) assert_cmp(unsigned long, \
77	a, b, <=, >, "lu", __VA_ARGS__)
78	#define assert_lu_ge(a, b, ...) assert_cmp(unsigned long, \
79	a, b, >=, <, "lu", __VA_ARGS__)
80	#define assert_lu_gt(a, b, ...) assert_cmp(unsigned long, \
81	a, b, >, <=, "lu", __VA_ARGS__)
82
83	#define assert_qd_eq(a, b, ...) assert_cmp(long long, a, b, ==, \
84	!=, "qd", __VA_ARGS__)
85	#define assert_qd_ne(a, b, ...) assert_cmp(long long, a, b, !=, \
86	==, "qd", __VA_ARGS__)
87	#define assert_qd_lt(a, b, ...) assert_cmp(long long, a, b, <, \
88	>=, "qd", __VA_ARGS__)
89	#define assert_qd_le(a, b, ...) assert_cmp(long long, a, b, <=, \
90	>, "qd", __VA_ARGS__)
91	#define assert_qd_ge(a, b, ...) assert_cmp(long long, a, b, >=, \
92	<, "qd", __VA_ARGS__)
93	#define assert_qd_gt(a, b, ...) assert_cmp(long long, a, b, >, \
94	<=, "qd", __VA_ARGS__)
95
96	#define assert_qu_eq(a, b, ...) assert_cmp(unsigned long long, \
97	a, b, ==, !=, "qu", __VA_ARGS__)
98	#define assert_qu_ne(a, b, ...) assert_cmp(unsigned long long, \
99	a, b, !=, ==, "qu", __VA_ARGS__)
100	#define assert_qu_lt(a, b, ...) assert_cmp(unsigned long long, \
101	a, b, <, >=, "qu", __VA_ARGS__)
102	#define assert_qu_le(a, b, ...) assert_cmp(unsigned long long, \
103	a, b, <=, >, "qu", __VA_ARGS__)
104	#define assert_qu_ge(a, b, ...) assert_cmp(unsigned long long, \
105	a, b, >=, <, "qu", __VA_ARGS__)
106	#define assert_qu_gt(a, b, ...) assert_cmp(unsigned long long, \
107	a, b, >, <=, "qu", __VA_ARGS__)
108
109	#define assert_jd_eq(a, b, ...) assert_cmp(intmax_t, a, b, ==, \
110	!=, "jd", __VA_ARGS__)
111	#define assert_jd_ne(a, b, ...) assert_cmp(intmax_t, a, b, !=, \
112	==, "jd", __VA_ARGS__)
113	#define assert_jd_lt(a, b, ...) assert_cmp(intmax_t, a, b, <, \
114	>=, "jd", __VA_ARGS__)
115	#define assert_jd_le(a, b, ...) assert_cmp(intmax_t, a, b, <=, \
116	>, "jd", __VA_ARGS__)
117	#define assert_jd_ge(a, b, ...) assert_cmp(intmax_t, a, b, >=, \
118	<, "jd", __VA_ARGS__)
119	#define assert_jd_gt(a, b, ...) assert_cmp(intmax_t, a, b, >, \
120	<=, "jd", __VA_ARGS__)
121
122	#define assert_ju_eq(a, b, ...) assert_cmp(uintmax_t, a, b, ==, \
123	!=, "ju", __VA_ARGS__)
124	#define assert_ju_ne(a, b, ...) assert_cmp(uintmax_t, a, b, !=, \
125	==, "ju", __VA_ARGS__)
126	#define assert_ju_lt(a, b, ...) assert_cmp(uintmax_t, a, b, <, \
127	>=, "ju", __VA_ARGS__)
128	#define assert_ju_le(a, b, ...) assert_cmp(uintmax_t, a, b, <=, \
129	>, "ju", __VA_ARGS__)
130	#define assert_ju_ge(a, b, ...) assert_cmp(uintmax_t, a, b, >=, \
131	<, "ju", __VA_ARGS__)
132	#define assert_ju_gt(a, b, ...) assert_cmp(uintmax_t, a, b, >, \
133	<=, "ju", __VA_ARGS__)
134
135	#define assert_zd_eq(a, b, ...) assert_cmp(ssize_t, a, b, ==, \
136	!=, "zd", __VA_ARGS__)
137	#define assert_zd_ne(a, b, ...) assert_cmp(ssize_t, a, b, !=, \
138	==, "zd", __VA_ARGS__)
139	#define assert_zd_lt(a, b, ...) assert_cmp(ssize_t, a, b, <, \
140	>=, "zd", __VA_ARGS__)
141	#define assert_zd_le(a, b, ...) assert_cmp(ssize_t, a, b, <=, \
142	>, "zd", __VA_ARGS__)
143	#define assert_zd_ge(a, b, ...) assert_cmp(ssize_t, a, b, >=, \
144	<, "zd", __VA_ARGS__)
145	#define assert_zd_gt(a, b, ...) assert_cmp(ssize_t, a, b, >, \
146	<=, "zd", __VA_ARGS__)
147
148	#define assert_zu_eq(a, b, ...) assert_cmp(size_t, a, b, ==, \
149	!=, "zu", __VA_ARGS__)
150	#define assert_zu_ne(a, b, ...) assert_cmp(size_t, a, b, !=, \
151	==, "zu", __VA_ARGS__)
152	#define assert_zu_lt(a, b, ...) assert_cmp(size_t, a, b, <, \
153	>=, "zu", __VA_ARGS__)
154	#define assert_zu_le(a, b, ...) assert_cmp(size_t, a, b, <=, \
155	>, "zu", __VA_ARGS__)
156	#define assert_zu_ge(a, b, ...) assert_cmp(size_t, a, b, >=, \
157	<, "zu", __VA_ARGS__)
158	#define assert_zu_gt(a, b, ...) assert_cmp(size_t, a, b, >, \
159	<=, "zu", __VA_ARGS__)
160
161	#define assert_d32_eq(a, b, ...) assert_cmp(int32_t, a, b, ==, \
54a0048b	162	!=, FMTd32, __VA_ARGS__)
1a4d82fc	163	#define assert_d32_ne(a, b, ...) assert_cmp(int32_t, a, b, !=, \
54a0048b	164	==, FMTd32, __VA_ARGS__)
1a4d82fc	165	#define assert_d32_lt(a, b, ...) assert_cmp(int32_t, a, b, <, \
54a0048b	166	>=, FMTd32, __VA_ARGS__)
1a4d82fc	167	#define assert_d32_le(a, b, ...) assert_cmp(int32_t, a, b, <=, \
54a0048b	168	>, FMTd32, __VA_ARGS__)
1a4d82fc	169	#define assert_d32_ge(a, b, ...) assert_cmp(int32_t, a, b, >=, \
54a0048b	170	<, FMTd32, __VA_ARGS__)
1a4d82fc	171	#define assert_d32_gt(a, b, ...) assert_cmp(int32_t, a, b, >, \
54a0048b	172	<=, FMTd32, __VA_ARGS__)
1a4d82fc JJ	173
1a4d82fc JJ	174	#define assert_u32_eq(a, b, ...) assert_cmp(uint32_t, a, b, ==, \
54a0048b	175	!=, FMTu32, __VA_ARGS__)
1a4d82fc	176	#define assert_u32_ne(a, b, ...) assert_cmp(uint32_t, a, b, !=, \
54a0048b	177	==, FMTu32, __VA_ARGS__)
1a4d82fc	178	#define assert_u32_lt(a, b, ...) assert_cmp(uint32_t, a, b, <, \
54a0048b	179	>=, FMTu32, __VA_ARGS__)
1a4d82fc	180	#define assert_u32_le(a, b, ...) assert_cmp(uint32_t, a, b, <=, \
54a0048b	181	>, FMTu32, __VA_ARGS__)
1a4d82fc	182	#define assert_u32_ge(a, b, ...) assert_cmp(uint32_t, a, b, >=, \
54a0048b	183	<, FMTu32, __VA_ARGS__)
1a4d82fc	184	#define assert_u32_gt(a, b, ...) assert_cmp(uint32_t, a, b, >, \
54a0048b	185	<=, FMTu32, __VA_ARGS__)
1a4d82fc JJ	186
1a4d82fc JJ	187	#define assert_d64_eq(a, b, ...) assert_cmp(int64_t, a, b, ==, \
54a0048b	188	!=, FMTd64, __VA_ARGS__)
1a4d82fc	189	#define assert_d64_ne(a, b, ...) assert_cmp(int64_t, a, b, !=, \
54a0048b	190	==, FMTd64, __VA_ARGS__)
1a4d82fc	191	#define assert_d64_lt(a, b, ...) assert_cmp(int64_t, a, b, <, \
54a0048b	192	>=, FMTd64, __VA_ARGS__)
1a4d82fc	193	#define assert_d64_le(a, b, ...) assert_cmp(int64_t, a, b, <=, \
54a0048b	194	>, FMTd64, __VA_ARGS__)
1a4d82fc	195	#define assert_d64_ge(a, b, ...) assert_cmp(int64_t, a, b, >=, \
54a0048b	196	<, FMTd64, __VA_ARGS__)
1a4d82fc	197	#define assert_d64_gt(a, b, ...) assert_cmp(int64_t, a, b, >, \
54a0048b	198	<=, FMTd64, __VA_ARGS__)
1a4d82fc JJ	199
1a4d82fc JJ	200	#define assert_u64_eq(a, b, ...) assert_cmp(uint64_t, a, b, ==, \
54a0048b	201	!=, FMTu64, __VA_ARGS__)
1a4d82fc	202	#define assert_u64_ne(a, b, ...) assert_cmp(uint64_t, a, b, !=, \
54a0048b	203	==, FMTu64, __VA_ARGS__)
1a4d82fc	204	#define assert_u64_lt(a, b, ...) assert_cmp(uint64_t, a, b, <, \
54a0048b	205	>=, FMTu64, __VA_ARGS__)
1a4d82fc	206	#define assert_u64_le(a, b, ...) assert_cmp(uint64_t, a, b, <=, \
54a0048b	207	>, FMTu64, __VA_ARGS__)
1a4d82fc	208	#define assert_u64_ge(a, b, ...) assert_cmp(uint64_t, a, b, >=, \
54a0048b	209	<, FMTu64, __VA_ARGS__)
1a4d82fc	210	#define assert_u64_gt(a, b, ...) assert_cmp(uint64_t, a, b, >, \
54a0048b	211	<=, FMTu64, __VA_ARGS__)
1a4d82fc JJ	212
	213	#define assert_b_eq(a, b, ...) do { \
	214	bool a_ = (a); \
	215	bool b_ = (b); \
	216	if (!(a_ == b_)) { \
	217	char prefix[ASSERT_BUFSIZE]; \
	218	char message[ASSERT_BUFSIZE]; \
	219	malloc_snprintf(prefix, sizeof(prefix), \
	220	"%s:%s:%d: Failed assertion: " \
	221	"(%s) == (%s) --> %s != %s: ", \
	222	__func__, __FILE__, __LINE__, \
	223	#a, #b, a_ ? "true" : "false", \
	224	b_ ? "true" : "false"); \
	225	malloc_snprintf(message, sizeof(message), __VA_ARGS__); \
	226	p_test_fail(prefix, message); \
	227	} \
	228	} while (0)
	229	#define assert_b_ne(a, b, ...) do { \
	230	bool a_ = (a); \
	231	bool b_ = (b); \
	232	if (!(a_ != b_)) { \
	233	char prefix[ASSERT_BUFSIZE]; \
	234	char message[ASSERT_BUFSIZE]; \
	235	malloc_snprintf(prefix, sizeof(prefix), \
	236	"%s:%s:%d: Failed assertion: " \
	237	"(%s) != (%s) --> %s == %s: ", \
	238	__func__, __FILE__, __LINE__, \
	239	#a, #b, a_ ? "true" : "false", \
	240	b_ ? "true" : "false"); \
	241	malloc_snprintf(message, sizeof(message), __VA_ARGS__); \
	242	p_test_fail(prefix, message); \
	243	} \
	244	} while (0)
	245	#define assert_true(a, ...) assert_b_eq(a, true, __VA_ARGS__)
	246	#define assert_false(a, ...) assert_b_eq(a, false, __VA_ARGS__)
	247
	248	#define assert_str_eq(a, b, ...) do { \
	249	if (strcmp((a), (b))) { \
	250	char prefix[ASSERT_BUFSIZE]; \
	251	char message[ASSERT_BUFSIZE]; \
	252	malloc_snprintf(prefix, sizeof(prefix), \
	253	"%s:%s:%d: Failed assertion: " \
	254	"(%s) same as (%s) --> " \
	255	"\"%s\" differs from \"%s\": ", \
	256	__func__, __FILE__, __LINE__, #a, #b, a, b); \
	257	malloc_snprintf(message, sizeof(message), __VA_ARGS__); \
	258	p_test_fail(prefix, message); \
	259	} \
	260	} while (0)
	261	#define assert_str_ne(a, b, ...) do { \
	262	if (!strcmp((a), (b))) { \
	263	char prefix[ASSERT_BUFSIZE]; \
	264	char message[ASSERT_BUFSIZE]; \
	265	malloc_snprintf(prefix, sizeof(prefix), \
	266	"%s:%s:%d: Failed assertion: " \
	267	"(%s) differs from (%s) --> " \
	268	"\"%s\" same as \"%s\": ", \
	269	__func__, __FILE__, __LINE__, #a, #b, a, b); \
	270	malloc_snprintf(message, sizeof(message), __VA_ARGS__); \
	271	p_test_fail(prefix, message); \
	272	} \
	273	} while (0)
	274
	275	#define assert_not_reached(...) do { \
276	char prefix[ASSERT_BUFSIZE]; \
277	char message[ASSERT_BUFSIZE]; \
278	malloc_snprintf(prefix, sizeof(prefix), \
279	"%s:%s:%d: Unreachable code reached: ", \
280	__func__, __FILE__, __LINE__); \
281	malloc_snprintf(message, sizeof(message), __VA_ARGS__); \
282	p_test_fail(prefix, message); \
283	} while (0)
284
285	/*
286	* If this enum changes, corresponding changes in test/test.sh.in are also
287	* necessary.
288	*/
289	typedef enum {
290	test_status_pass = 0,
291	test_status_skip = 1,
292	test_status_fail = 2,
293
294	test_status_count = 3
295	} test_status_t;
296
297	typedef void (test_t)(void);
298
299	#define TEST_BEGIN(f) \
300	static void \
301	f(void) \
302	{ \
303	p_test_init(#f);
304
305	#define TEST_END \
306	goto label_test_end; \
307	label_test_end: \
308	p_test_fini(); \
309	}
310
311	#define test(...) \
312	p_test(__VA_ARGS__, NULL)
313
314	#define test_skip_if(e) do { \
315	if (e) { \
316	test_skip("%s:%s:%d: Test skipped: (%s)", \
317	__func__, __FILE__, __LINE__, #e); \
318	goto label_test_end; \
319	} \
320	} while (0)
321
54a0048b SL	322	void test_skip(const char *format, ...) JEMALLOC_FORMAT_PRINTF(1, 2);
54a0048b SL	323	void test_fail(const char *format, ...) JEMALLOC_FORMAT_PRINTF(1, 2);
1a4d82fc JJ	324
	325	/* For private use by macros. */
	326	test_status_t p_test(test_t *t, ...);
	327	void p_test_init(const char *name);
	328	void p_test_fini(void);
	329	void p_test_fail(const char prefix, const char message);