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_no_malloc_init(...)                                        \
 315         p_test_no_malloc_init(__VA_ARGS__, NULL)
 316
 317 #define test_skip_if(e) do {                                            \
 318         if (e) {                                                        \
 319                 test_skip("%s:%s:%d: Test skipped: (%s)",               \
 320                     __func__, __FILE__, __LINE__, #e);                  \
 321                 goto label_test_end;                                    \
 322         }                                                               \
 323 } while (0)
 324
 325 void    test_skip(const char *format, ...) JEMALLOC_FORMAT_PRINTF(1, 2);
 326 void    test_fail(const char *format, ...) JEMALLOC_FORMAT_PRINTF(1, 2);
 327
 328 /* For private use by macros. */
 329 test_status_t   p_test(test_t *t, ...);
 330 test_status_t   p_test_no_malloc_init(test_t *t, ...);
 331 void    p_test_init(const char *name);
 332 void    p_test_fini(void);
 333 void    p_test_fail(const char *prefix, const char *message);