]> git.proxmox.com Git - rustc.git/blob - src/jemalloc/test/include/test/test.h
Imported Upstream version 1.9.0+dfsg1
[rustc.git] / src / jemalloc / test / include / test / test.h
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 !=, FMTd32, __VA_ARGS__)
163 #define assert_d32_ne(a, b, ...) assert_cmp(int32_t, a, b, !=, \
164 ==, FMTd32, __VA_ARGS__)
165 #define assert_d32_lt(a, b, ...) assert_cmp(int32_t, a, b, <, \
166 >=, FMTd32, __VA_ARGS__)
167 #define assert_d32_le(a, b, ...) assert_cmp(int32_t, a, b, <=, \
168 >, FMTd32, __VA_ARGS__)
169 #define assert_d32_ge(a, b, ...) assert_cmp(int32_t, a, b, >=, \
170 <, FMTd32, __VA_ARGS__)
171 #define assert_d32_gt(a, b, ...) assert_cmp(int32_t, a, b, >, \
172 <=, FMTd32, __VA_ARGS__)
173
174 #define assert_u32_eq(a, b, ...) assert_cmp(uint32_t, a, b, ==, \
175 !=, FMTu32, __VA_ARGS__)
176 #define assert_u32_ne(a, b, ...) assert_cmp(uint32_t, a, b, !=, \
177 ==, FMTu32, __VA_ARGS__)
178 #define assert_u32_lt(a, b, ...) assert_cmp(uint32_t, a, b, <, \
179 >=, FMTu32, __VA_ARGS__)
180 #define assert_u32_le(a, b, ...) assert_cmp(uint32_t, a, b, <=, \
181 >, FMTu32, __VA_ARGS__)
182 #define assert_u32_ge(a, b, ...) assert_cmp(uint32_t, a, b, >=, \
183 <, FMTu32, __VA_ARGS__)
184 #define assert_u32_gt(a, b, ...) assert_cmp(uint32_t, a, b, >, \
185 <=, FMTu32, __VA_ARGS__)
186
187 #define assert_d64_eq(a, b, ...) assert_cmp(int64_t, a, b, ==, \
188 !=, FMTd64, __VA_ARGS__)
189 #define assert_d64_ne(a, b, ...) assert_cmp(int64_t, a, b, !=, \
190 ==, FMTd64, __VA_ARGS__)
191 #define assert_d64_lt(a, b, ...) assert_cmp(int64_t, a, b, <, \
192 >=, FMTd64, __VA_ARGS__)
193 #define assert_d64_le(a, b, ...) assert_cmp(int64_t, a, b, <=, \
194 >, FMTd64, __VA_ARGS__)
195 #define assert_d64_ge(a, b, ...) assert_cmp(int64_t, a, b, >=, \
196 <, FMTd64, __VA_ARGS__)
197 #define assert_d64_gt(a, b, ...) assert_cmp(int64_t, a, b, >, \
198 <=, FMTd64, __VA_ARGS__)
199
200 #define assert_u64_eq(a, b, ...) assert_cmp(uint64_t, a, b, ==, \
201 !=, FMTu64, __VA_ARGS__)
202 #define assert_u64_ne(a, b, ...) assert_cmp(uint64_t, a, b, !=, \
203 ==, FMTu64, __VA_ARGS__)
204 #define assert_u64_lt(a, b, ...) assert_cmp(uint64_t, a, b, <, \
205 >=, FMTu64, __VA_ARGS__)
206 #define assert_u64_le(a, b, ...) assert_cmp(uint64_t, a, b, <=, \
207 >, FMTu64, __VA_ARGS__)
208 #define assert_u64_ge(a, b, ...) assert_cmp(uint64_t, a, b, >=, \
209 <, FMTu64, __VA_ARGS__)
210 #define assert_u64_gt(a, b, ...) assert_cmp(uint64_t, a, b, >, \
211 <=, FMTu64, __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_FORMAT_PRINTF(1, 2);
323 void test_fail(const char *format, ...) JEMALLOC_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);