Home | History | Annotate | Download | only in test
      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, ==,	\
    162     !=, PRId32, __VA_ARGS__)
    163 #define	assert_d32_ne(a, b, ...)	assert_cmp(int32_t, a, b, !=,	\
    164     ==, PRId32, __VA_ARGS__)
    165 #define	assert_d32_lt(a, b, ...)	assert_cmp(int32_t, a, b, <,	\
    166     >=, PRId32, __VA_ARGS__)
    167 #define	assert_d32_le(a, b, ...)	assert_cmp(int32_t, a, b, <=,	\
    168     >, PRId32, __VA_ARGS__)
    169 #define	assert_d32_ge(a, b, ...)	assert_cmp(int32_t, a, b, >=,	\
    170     <, PRId32, __VA_ARGS__)
    171 #define	assert_d32_gt(a, b, ...)	assert_cmp(int32_t, a, b, >,	\
    172     <=, PRId32, __VA_ARGS__)
    173 
    174 #define	assert_u32_eq(a, b, ...)	assert_cmp(uint32_t, a, b, ==,	\
    175     !=, PRIu32, __VA_ARGS__)
    176 #define	assert_u32_ne(a, b, ...)	assert_cmp(uint32_t, a, b, !=,	\
    177     ==, PRIu32, __VA_ARGS__)
    178 #define	assert_u32_lt(a, b, ...)	assert_cmp(uint32_t, a, b, <,	\
    179     >=, PRIu32, __VA_ARGS__)
    180 #define	assert_u32_le(a, b, ...)	assert_cmp(uint32_t, a, b, <=,	\
    181     >, PRIu32, __VA_ARGS__)
    182 #define	assert_u32_ge(a, b, ...)	assert_cmp(uint32_t, a, b, >=,	\
    183     <, PRIu32, __VA_ARGS__)
    184 #define	assert_u32_gt(a, b, ...)	assert_cmp(uint32_t, a, b, >,	\
    185     <=, PRIu32, __VA_ARGS__)
    186 
    187 #define	assert_d64_eq(a, b, ...)	assert_cmp(int64_t, a, b, ==,	\
    188     !=, PRId64, __VA_ARGS__)
    189 #define	assert_d64_ne(a, b, ...)	assert_cmp(int64_t, a, b, !=,	\
    190     ==, PRId64, __VA_ARGS__)
    191 #define	assert_d64_lt(a, b, ...)	assert_cmp(int64_t, a, b, <,	\
    192     >=, PRId64, __VA_ARGS__)
    193 #define	assert_d64_le(a, b, ...)	assert_cmp(int64_t, a, b, <=,	\
    194     >, PRId64, __VA_ARGS__)
    195 #define	assert_d64_ge(a, b, ...)	assert_cmp(int64_t, a, b, >=,	\
    196     <, PRId64, __VA_ARGS__)
    197 #define	assert_d64_gt(a, b, ...)	assert_cmp(int64_t, a, b, >,	\
    198     <=, PRId64, __VA_ARGS__)
    199 
    200 #define	assert_u64_eq(a, b, ...)	assert_cmp(uint64_t, a, b, ==,	\
    201     !=, PRIu64, __VA_ARGS__)
    202 #define	assert_u64_ne(a, b, ...)	assert_cmp(uint64_t, a, b, !=,	\
    203     ==, PRIu64, __VA_ARGS__)
    204 #define	assert_u64_lt(a, b, ...)	assert_cmp(uint64_t, a, b, <,	\
    205     >=, PRIu64, __VA_ARGS__)
    206 #define	assert_u64_le(a, b, ...)	assert_cmp(uint64_t, a, b, <=,	\
    207     >, PRIu64, __VA_ARGS__)
    208 #define	assert_u64_ge(a, b, ...)	assert_cmp(uint64_t, a, b, >=,	\
    209     <, PRIu64, __VA_ARGS__)
    210 #define	assert_u64_gt(a, b, ...)	assert_cmp(uint64_t, a, b, >,	\
    211     <=, PRIu64, __VA_ARGS__)
    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 
    322 void	test_skip(const char *format, ...) JEMALLOC_ATTR(format(printf, 1, 2));
    323 void	test_fail(const char *format, ...) JEMALLOC_ATTR(format(printf, 1, 2));
    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);
    330