tinytest/tinytest.h

   1 /* ----------------------------------------------------------------------------
   2    tinytest - A tiny C unit-testing library
   3    Copyright (C) 2010  Mark A Lindner
   4
   5    This file is part of tinytest.
   6
   7    This library is free software; you can redistribute it and/or
   8    modify it under the terms of the GNU Lesser General Public License
   9    as published by the Free Software Foundation; either version 2.1 of
  10    the License, or (at your option) any later version.
  11
  12    This library is distributed in the hope that it will be useful, but
  13    WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    Lesser General Public License for more details.
  16
  17    You should have received a copy of the GNU Library General Public
  18    License along with this library; if not, see
  19    <http://www.gnu.org/licenses/>.
  20    ----------------------------------------------------------------------------
  21 */
  22
  23 #ifndef __tinytest_h
  24 #define __tinytest_h
  25
  26 #include <setjmp.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29
  30 typedef int tt_bool_t;
  31
  32 #define TT_TRUE (1)
  33 #define TT_FALSE (0)
  34
  35 typedef struct tt_test_t
  36 {
  37   const char *name;
  38   void (*function)(void);
  39   tt_bool_t failed;
  40   struct tt_test_t *next;
  41 } tt_test_t;
  42
  43 typedef struct tt_testsuite_t
  44 {
  45   const char *name;
  46   tt_test_t *first_test;
  47   tt_test_t *last_test;
  48   tt_test_t *current_test;
  49   int num_tests;
  50   int num_failures;
  51   jmp_buf jump_buf;
  52 } tt_testsuite_t;
  53
  54 typedef enum { TT_VAL_INT, TT_VAL_UINT, TT_VAL_INT64, TT_VAL_UINT64,
  55                TT_VAL_DOUBLE, TT_VAL_STR, TT_VAL_PTR } tt_valtype_t;
  56
  57 typedef enum { TT_OP_INT_EQ, TT_OP_INT_NE, TT_OP_INT_LT, TT_OP_INT_LE,
  58                TT_OP_INT_GT, TT_OP_INT_GE, TT_OP_UINT_EQ, TT_OP_UINT_NE,
  59                TT_OP_UINT_LT, TT_OP_UINT_LE, TT_OP_UINT_GT, TT_OP_UINT_GE,
  60                TT_OP_INT64_EQ, TT_OP_INT64_NE, TT_OP_INT64_LT, TT_OP_INT64_LE,
  61                TT_OP_INT64_GT, TT_OP_INT64_GE, TT_OP_UINT64_EQ,
  62                TT_OP_UINT64_NE, TT_OP_UINT64_LT, TT_OP_UINT64_LE,
  63                TT_OP_UINT64_GT, TT_OP_UINT64_GE, TT_OP_DOUBLE_EQ,
  64                TT_OP_DOUBLE_NE, TT_OP_DOUBLE_LT, TT_OP_DOUBLE_LE,
  65                TT_OP_DOUBLE_GT, TT_OP_DOUBLE_GE, TT_OP_STR_EQ, TT_OP_STR_NE,
  66                TT_OP_STR_LT, TT_OP_STR_LE, TT_OP_STR_GT, TT_OP_STR_GE,
  67                TT_OP_PTR_EQ, TT_OP_PTR_NE, TT_OP_TRUE, TT_OP_FALSE,
  68                TT_OP_FILE_EQ, TT_OP_FILE_NE, TT_OP_TXTFILE_EQ,
  69                TT_OP_TXTFILE_NE } tt_op_t;
  70
  71 typedef struct tt_val_t
  72 {
  73   tt_valtype_t type;
  74   union {
  75     int int_val;
  76     unsigned int uint_val;
  77     long long int64_val;
  78     unsigned long long uint64_val;
  79     double double_val;
  80     const char *str_val;
  81     const void *ptr_val;
  82   } value;
  83 } tt_val_t;
  84
  85
  86 extern tt_testsuite_t *tt_suite_create(const char *name);
  87
  88 extern void tt_suite_destroy(tt_testsuite_t *suite);
  89
  90 extern void tt_suite_add_test(tt_testsuite_t *suite, const char *name,
  91                               void (*function)(void));
  92
  93 extern void tt_suite_run(tt_testsuite_t *suite);
  94
  95 extern void tt_expect(const char *file, int line, const char *aexpr,
  96                       tt_op_t op, const char *bexpr,
  97                       const tt_val_t a, const tt_val_t b,
  98                       tt_bool_t fatal);
  99
 100 extern void tt_expect_bool(const char *file, int line, const char *expr,
 101                            tt_op_t op, int val, tt_bool_t fatal);
 102
 103 extern void tt_fail(const char *file, int line, const char *message, ...);
 104
 105 extern tt_bool_t tt_file_exists(const char *file);
 106
 107 #ifdef _MSC_VER
 108
 109 extern void tt_test_int(const char *file, int line, const char *aexpr,
 110                         tt_op_t op, const char *bexpr, int a, int b,
 111                         tt_bool_t fatal);
 112
 113 #define TT_TEST_INT_(A, OP, B, F)                               \
 114   tt_test_int(__FILE__, __LINE__, #A, (OP), #B, (A), (B), (F))
 115
 116 #else
 117
 118 #define TT_TEST_INT_(A, OP, B, F)                                       \
 119   tt_expect(__FILE__, __LINE__, #A, (OP), #B,                           \
 120             (tt_val_t){ TT_VAL_INT, .value.int_val = (A) },             \
 121             (tt_val_t){ TT_VAL_INT, .value.int_val = (B) },             \
 122             (F))
 123
 124 #endif
 125
 126 #define TT_EXPECT_INT_EQ(A, B)                          \
 127   TT_TEST_INT_((A), TT_OP_INT_EQ, (B), TT_FALSE)
 128
 129 #define TT_ASSERT_INT_EQ(A, B)                  \
 130   TT_TEST_INT_((A), TT_OP_INT_EQ, (B), TT_TRUE)
 131
 132 #define TT_EXPECT_INT_NE(A, B)                          \
 133   TT_TEST_INT_((A), TT_OP_INT_NE, (B), TT_FALSE)
 134
 135 #define TT_ASSERT_INT_NE(A, B)                  \
 136   TT_TEST_INT_((A), TT_OP_INT_NE, (B), TT_TRUE)
 137
 138 #define TT_EXPECT_INT_LT(A, B)                  \
 139   TT_TEST_INT_((A), TT_OP_INT_LT, (B), TT_FALSE)
 140
 141 #define TT_ASSERT_INT_LT(A, B)                  \
 142   TT_TEST_INT_((A), TT_OP_INT_LT, (B), TT_TRUE)
 143
 144 #define TT_EXPECT_INT_LE(A, B)                  \
 145   TT_TEST_INT_((A), TT_OP_INT_LE, (B), TT_FALSE)
 146
 147 #define TT_ASSERT_INT_LE(A, B)                  \
 148   TT_TEST_INT_((A), TT_OP_INT_LE, (B), TT_TRUE)
 149
 150 #define TT_EXPECT_INT_GT(A, B)                  \
 151   TT_TEST_INT_((A), TT_OP_INT_GT, (B), TT_FALSE)
 152
 153 #define TT_ASSERT_INT_GT(A, B)                  \
 154   TT_TEST_INT_((A), TT_OP_INT_GT, (B), TT_TRUE)
 155
 156 #define TT_EXPECT_INT_GE(A, B)                  \
 157   TT_TEST_INT_((A), TT_OP_INT_GE, (B), TT_FALSE)
 158
 159 #define TT_ASSERT_INT_GE(A, B)                  \
 160   TT_TEST_INT_((A), TT_OP_INT_GE, (B), TT_TRUE)
 161
 162 #ifdef _MSC_VER
 163
 164 extern void tt_test_uint(const char *file, int line, const char *aexpr,
 165                          tt_op_t op, const char *bexpr, unsigned int a,
 166                          unsigned int b, tt_bool_t fatal);
 167
 168 #define TT_TEST_UINT_(A, OP, B, F)                              \
 169   tt_test_uint(__FILE__, __LINE__, #A, (OP), #B, (A), (B), (F))
 170
 171 #else
 172
 173 #define TT_TEST_UINT_(A, OP, B, F)                                      \
 174   tt_expect(__FILE__, __LINE__, #A, OP, #B,                             \
 175             (tt_val_t){ TT_VAL_UINT, .value.uint_val = (A) },           \
 176             (tt_val_t){ TT_VAL_UINT, .value.uint_val = (B) },           \
 177             (F))
 178
 179 #endif
 180
 181 #define TT_EXPECT_UINT_EQ(A, B)                  \
 182   TT_TEST_UINT_((A), TT_OP_UINT_EQ, (B), TT_FALSE)
 183
 184 #define TT_ASSERT_UINT_EQ(A, B)                  \
 185   TT_TEST_UINT_((A), TT_OP_UINT_EQ, (B), TT_TRUE)
 186
 187 #define TT_EXPECT_UINT_NE(A, B)                  \
 188   TT_TEST_UINT_((A), TT_OP_UINT_NE, (B), TT_FALSE)
 189
 190 #define TT_ASSERT_UINT_NE(A, B)                  \
 191   TT_TEST_UINT_((A), TT_OP_UINT_NE, (B), TT_TRUE)
 192
 193 #define TT_EXPECT_UINT_LT(A, B)                  \
 194   TT_TEST_UINT_((A), TT_OP_UINT_LT, (B), TT_FALSE)
 195
 196 #define TT_ASSERT_UINT_LT(A, B)                  \
 197   TT_TEST_UINT_((A), TT_OP_UINT_LT, (B), TT_TRUE)
 198
 199 #define TT_EXPECT_UINT_LE(A, B)                  \
 200   TT_TEST_UINT_((A), TT_OP_UINT_LE, (B), TT_FALSE)
 201
 202 #define TT_ASSERT_UINT_LE(A, B)                  \
 203   TT_TEST_UINT_((A), TT_OP_UINT_LE, (B), TT_TRUE)
 204
 205 #define TT_EXPECT_UINT_GT(A, B)                  \
 206   TT_TEST_UINT_((A), TT_OP_UINT_GT, (B), TT_FALSE)
 207
 208 #define TT_ASSERT_UINT_GT(A, B)                  \
 209   TT_TEST_UINT_((A), TT_OP_UINT_GT, (B), TT_TRUE)
 210
 211 #define TT_EXPECT_UINT_GE(A, B)                  \
 212   TT_TEST_UINT_((A), TT_OP_UINT_GE, (B), TT_FALSE)
 213
 214 #define TT_ASSERT_UINT_GE(A, B)                  \
 215   TT_TEST_UINT_((A), TT_OP_UINT_GE, (B), TT_TRUE)
 216
 217 #ifdef _MSC_VER
 218
 219 extern void tt_test_int64(const char *file, int line, const char *aexpr,
 220                           tt_op_t op, const char *bexpr, long long a,
 221                           long long b, tt_bool_t fatal);
 222
 223 #define TT_TEST_INT64_(A, OP, B, F)                                      \
 224   tt_test_int64(__FILE__, __LINE__, #A, (OP), #B, (A), (B), (F))
 225
 226 #else
 227
 228 #define TT_TEST_INT64_(A, OP, B, F)                                     \
 229   tt_expect(__FILE__, __LINE__, #A, OP, #B,                             \
 230             (tt_val_t){ TT_VAL_INT64, .value.int64_val = (A) },         \
 231             (tt_val_t){ TT_VAL_INT64, .value.int64_val = (B) },         \
 232             (F))
 233
 234 #endif
 235
 236 #define TT_EXPECT_INT64_EQ(A, B)                        \
 237   TT_TEST_INT64_((A), TT_OP_INT64_EQ, (B), TT_FALSE)
 238
 239 #define TT_ASSERT_INT64_EQ(A, B)                \
 240   TT_TEST_INT64_((A), TT_OP_INT64_EQ, (B), TT_TRUE)
 241
 242 #define TT_EXPECT_INT64_NE(A, B)                        \
 243   TT_TEST_INT64_((A), TT_OP_INT64_NE, (B), TT_FALSE)
 244
 245 #define TT_ASSERT_INT64_NE(A, B)                \
 246   TT_TEST_INT64_((A), TT_OP_INT64_NE, (B), TT_TRUE)
 247
 248 #define TT_EXPECT_INT64_LT(A, B)                        \
 249   TT_TEST_INT64_((A), TT_OP_INT64_LT, (B), TT_FALSE)
 250
 251 #define TT_ASSERT_INT64_LT(A, B)                \
 252   TT_TEST_INT64_((A), TT_OP_INT64_LT, (B), TT_TRUE)
 253
 254 #define TT_EXPECT_INT64_LE(A, B)                        \
 255   TT_TEST_INT64_((A), TT_OP_INT64_LE, (B), TT_FALSE)
 256
 257 #define TT_ASSERT_INT64_LE(A, B)                \
 258   TT_TEST_INT64_((A), TT_OP_INT64_LE, (B), TT_TRUE)
 259
 260 #define TT_EXPECT_INT64_GT(A, B)                        \
 261   TT_TEST_INT64_((A), TT_OP_INT64_GT, (B), TT_FALSE)
 262
 263 #define TT_ASSERT_INT64_GT(A, B)                \
 264   TT_TEST_INT64_((A), TT_OP_INT64_GT, (B), TT_TRUE)
 265
 266 #define TT_EXPECT_INT64_GE(A, B)                        \
 267   TT_TEST_INT64_((A), TT_OP_INT64_GE, (B), TT_FALSE)
 268
 269 #define TT_ASSERT_INT64_GE(A, B)                \
 270   TT_TEST_INT64_((A), TT_OP_INT64_GE, (B), TT_TRUE)
 271
 272 #ifdef _MSC_VER
 273
 274 extern void tt_test_uint64(const char *file, int line, const char *aexpr,
 275                            tt_op_t op, const char *bexpr,
 276                            unsigned long long a, unsigned long long b,
 277                            tt_bool_t fatal);
 278
 279 #define TT_TEST_UINT64_(A, OP, B, F)                                      \
 280   tt_test_uint64(__FILE__, __LINE__, #A, (OP), #B, (A), (B), (F))
 281
 282 #else
 283
 284 #define TT_TEST_UINT64_(A, OP, B, F)                                    \
 285   tt_expect(__FILE__, __LINE__, #A, OP, #B,                             \
 286             (tt_val_t){ TT_VAL_UINT64, .value.uint64_val = (A) },       \
 287             (tt_val_t){ TT_VAL_UINT64, .value.uint64_val = (B) },       \
 288             (F))
 289
 290 #endif
 291
 292 #define TT_EXPECT_UINT64_EQ(A, B)                        \
 293   TT_TEST_UINT64_((A), TT_OP_UINT64_EQ, (B), TT_FALSE)
 294
 295 #define TT_ASSERT_UINT64_EQ(A, B)                \
 296   TT_TEST_UINT64_((A), TT_OP_UINT64_EQ, (B), TT_TRUE)
 297
 298 #define TT_EXPECT_UINT64_NE(A, B)                        \
 299   TT_TEST_UINT64_((A), TT_OP_UINT64_NE, (B), TT_FALSE)
 300
 301 #define TT_ASSERT_UINT64_NE(A, B)                \
 302   TT_TEST_UINT64_((A), TT_OP_UINT64_NE, (B), TT_TRUE)
 303
 304 #define TT_EXPECT_UINT64_LT(A, B)                        \
 305   TT_TEST_UINT64_((A), TT_OP_UINT64_LT, (B), TT_FALSE)
 306
 307 #define TT_ASSERT_UINT64_LT(A, B)                \
 308   TT_TEST_UINT64_((A), TT_OP_UINT64_LT, (B), TT_TRUE)
 309
 310 #define TT_EXPECT_UINT64_LE(A, B)                        \
 311   TT_TEST_UINT64_((A), TT_OP_UINT64_LE, (B), TT_FALSE)
 312
 313 #define TT_ASSERT_UINT64_LE(A, B)                \
 314   TT_TEST_UINT64_((A), TT_OP_UINT64_LE, (B), TT_TRUE)
 315
 316 #define TT_EXPECT_UINT64_GT(A, B)                        \
 317   TT_TEST_UINT64_((A), TT_OP_UINT64_GT, (B), TT_FALSE)
 318
 319 #define TT_ASSERT_UINT64_GT(A, B)                \
 320   TT_TEST_UINT64_((A), TT_OP_UINT64_GT, (B), TT_TRUE)
 321
 322 #define TT_EXPECT_UINT64_GE(A, B)                        \
 323   TT_TEST_UINT64_((A), TT_OP_UINT64_GE, (B), TT_FALSE)
 324
 325 #define TT_ASSERT_UINT64_GE(A, B)                \
 326   TT_TEST_UINT64_((A), TT_OP_UINT64_GE, (B), TT_TRUE)
 327
 328 #ifdef _MSC_VER
 329
 330 extern void tt_test_double(const char *file, int line, const char *aexpr,
 331                            tt_op_t op, const char *bexpr, double a,
 332                            double b, tt_bool_t fatal);
 333
 334 #define TT_TEST_DOUBLE_(A, OP, B, F)                                    \
 335   tt_test_double(__FILE__, __LINE__, #A, (OP), #B, (A), (B), (F))
 336
 337 #else
 338
 339 #define TT_TEST_DOUBLE_(A, OP, B, F)                                    \
 340   tt_expect(__FILE__, __LINE__, #A, OP, #B,                             \
 341             (tt_val_t){ TT_VAL_DOUBLE, .value.double_val = (A) },       \
 342             (tt_val_t){ TT_VAL_DOUBLE, .value.double_val = (B) },       \
 343             (F))
 344
 345 #endif
 346
 347 #define TT_EXPECT_DOUBLE_EQ(A, B)                       \
 348   TT_TEST_DOUBLE_((A), TT_OP_DOUBLE_EQ, (B), TT_FALSE)
 349
 350 #define TT_ASSERT_DOUBLE_EQ(A, B)                       \
 351   TT_TEST_DOUBLE_((A), TT_OP_DOUBLE_EQ, (B), TT_TRUE)
 352
 353 #define TT_EXPECT_DOUBLE_NE(A, B)                       \
 354   TT_TEST_DOUBLE_((A), TT_OP_DOUBLE_NE, (B), TT_FALSE)
 355
 356 #define TT_ASSERT_DOUBLE_NE(A, B)                       \
 357   TT_TEST_DOUBLE_((A), TT_OP_DOUBLE_NE, (B), TT_TRUE)
 358
 359 #define TT_EXPECT_DOUBLE_LT(A, B)                       \
 360   TT_TEST_DOUBLE_((A), TT_OP_DOUBLE_LT, (B), TT_FALSE)
 361
 362 #define TT_ASSERT_DOUBLE_LT(A, B)                       \
 363   TT_TEST_DOUBLE_((A), TT_OP_DOUBLE_LT, (B), TT_TRUE)
 364
 365 #define TT_EXPECT_DOUBLE_LE(A, B)                       \
 366   TT_TEST_DOUBLE_((A), TT_OP_DOUBLE_LE, (B), TT_FALSE)
 367
 368 #define TT_ASSERT_DOUBLE_LE(A, B)                       \
 369   TT_TEST_DOUBLE_((A), TT_OP_DOUBLE_LE, (B), TT_TRUE)
 370
 371 #define TT_EXPECT_DOUBLE_GT(A, B)                       \
 372   TT_TEST_DOUBLE_((A), TT_OP_DOUBLE_GT, (B), TT_FALSE)
 373
 374 #define TT_ASSERT_DOUBLE_GT(A, B)                       \
 375   TT_TEST_DOUBLE_((A), TT_OP_DOUBLE_GT, (B), TT_TRUE)
 376
 377 #define TT_EXPECT_DOUBLE_GE(A, B)                       \
 378   TT_TEST_DOUBLE_((A), TT_OP_DOUBLE_GE, (B), TT_FALSE)
 379
 380 #define TT_ASSERT_DOUBLE_GE(A, B)                       \
 381   TT_TEST_DOUBLE_((A), TT_OP_DOUBLE_GE, (B), TT_TRUE)
 382
 383 #ifdef _MSC_VER
 384
 385 extern void tt_test_str(const char *file, int line, const char *aexpr,
 386                         tt_op_t op, const char *bexpr, const char *a,
 387                         const char *b, tt_bool_t fatal);
 388
 389 #define TT_TEST_STR_(A, OP, B, F)                               \
 390   tt_test_str(__FILE__, __LINE__, #A, (OP), #B, (A), (B), (F))
 391
 392 #else
 393
 394 #define TT_TEST_STR_(A, OP, B, F)                                       \
 395   tt_expect(__FILE__, __LINE__, #A, OP, #B,                             \
 396             (tt_val_t){ TT_VAL_STR, .value.str_val = (A) },             \
 397             (tt_val_t){ TT_VAL_STR, .value.str_val = (B) },             \
 398             (F))
 399
 400 #endif
 401
 402 #define TT_EXPECT_STR_EQ(A, B)                  \
 403   TT_TEST_STR_((A), TT_OP_STR_EQ, (B), TT_FALSE)
 404
 405 #define TT_ASSERT_STR_EQ(A, B)                  \
 406   TT_TEST_STR_((A), TT_OP_STR_EQ, (B), TT_TRUE)
 407
 408 #define TT_EXPECT_STR_NE(A, B)                  \
 409   TT_TEST_STR_((A), TT_OP_STR_NE, (B), TT_FALSE)
 410
 411 #define TT_ASSERT_STR_NE(A, B)                  \
 412   TT_TEST_STR_((A), TT_OP_STR_NE, (B), TT_TRUE)
 413
 414 #define TT_EXPECT_STR_LT(A, B)                  \
 415   TT_TEST_STR_((A), TT_OP_STR_LT, (B), TT_FALSE)
 416
 417 #define TT_ASSERT_STR_LT(A, B)                  \
 418   TT_TEST_STR_((A), TT_OP_STR_LT, (B), TT_TRUE)
 419
 420 #define TT_EXPECT_STR_LE(A, B)                  \
 421   TT_TEST_STR_((A), TT_OP_STR_LE, (B), TT_FALSE)
 422
 423 #define TT_ASSERT_STR_LE(A, B)                  \
 424   TT_TEST_STR_((A), TT_OP_STR_LE, (B), TT_TRUE)
 425
 426 #define TT_EXPECT_STR_GT(A, B)                  \
 427   TT_TEST_STR_((A), TT_OP_STR_GT, (B), TT_FALSE)
 428
 429 #define TT_ASSERT_STR_GT(A, B)                  \
 430   TT_TEST_STR_((A), TT_OP_STR_GT, (B), TT_TRUE)
 431
 432 #define TT_EXPECT_STR_GE(A, B)                  \
 433   TT_TEST_STR_((A), TT_OP_STR_GE, (B), TT_FALSE)
 434
 435 #define TT_ASSERT_STR_GE(A, B)                  \
 436   TT_TEST_STR_((A), TT_OP_STR_GE, (B), TT_TRUE)
 437
 438 #ifdef _MSC_VER
 439
 440 extern void tt_test_ptr(const char *file, int line, const char *aexpr,
 441                         tt_op_t op, const char *bexpr, const void *a,
 442                         const void *b, tt_bool_t fatal);
 443
 444 #define TT_TEST_PTR_(A, OP, B, F)                               \
 445   tt_test_ptr(__FILE__, __LINE__, #A, (OP), #B, (A), (B), (F))
 446
 447 #else
 448
 449 #define TT_TEST_PTR_(A, OP, B, F)                                       \
 450   tt_expect(__FILE__, __LINE__, #A, OP, #B,                             \
 451             (tt_val_t){ TT_VAL_PTR, .value.ptr_val = (A) },             \
 452             (tt_val_t){ TT_VAL_PTR, .value.ptr_val = (B) },             \
 453             (F))
 454
 455 #endif
 456
 457 #define TT_EXPECT_PTR_EQ(A, B)                  \
 458   TT_TEST_PTR_((A), TT_OP_PTR_EQ, (B), TT_FALSE)
 459
 460 #define TT_ASSERT_PTR_EQ(A, B)                  \
 461   TT_TEST_PTR_((A), TT_OP_PTR_EQ, (B), TT_TRUE)
 462
 463 #define TT_EXPECT_PTR_NE(A, B)                  \
 464   TT_TEST_PTR_((A), TT_OP_PTR_NE, (B), TT_FALSE)
 465
 466 #define TT_ASSERT_PTR_NE(A, B)                  \
 467   TT_TEST_PTR_((A), TT_OP_PTR_NE, (B), TT_TRUE)
 468
 469 #define TT_EXPECT_PTR_NOTNULL(A)                \
 470   TT_TEST_PTR_((A), TT_OP_PTR_NE, NULL, TT_FALSE)
 471
 472 #define TT_ASSERT_PTR_NOTNULL(A)                \
 473   TT_TEST_PTR_((A), TT_OP_PTR_NE, NULL, TT_TRUE)
 474
 475 #define TT_EXPECT_PTR_NULL(A)                   \
 476   TT_TEST_PTR_((A), TT_OP_PTR_EQ, NULL, TT_FALSE)
 477
 478 #define TT_ASSERT_PTR_NULL(A)                   \
 479   TT_TEST_PTR_((A), TT_OP_PTR_EQ, NULL, TT_TRUE)
 480
 481 #define TT_EXPECT_TRUE(A)                                               \
 482   tt_expect_bool(__FILE__, __LINE__, #A, TT_OP_TRUE, (A), TT_FALSE)
 483
 484 #define TT_ASSERT_TRUE(A)                                               \
 485   tt_expect_bool(__FILE__, __LINE__, #A, TT_OP_TRUE, (A), TT_TRUE)
 486
 487 #define TT_EXPECT_FALSE(A)                                              \
 488   tt_expect_bool(__FILE__, __LINE__, #A, TT_OP_FALSE, (A), TT_FALSE)
 489
 490 #define TT_ASSERT_FALSE(A)                                               \
 491   tt_expect_bool(__FILE__, __LINE__, #A, TT_OP_FALSE, (A), TT_TRUE)
 492
 493 #define TT_EXPECT_FILE_EQ(A, B)                         \
 494   TT_TEST_STR_((A), TT_OP_FILE_EQ, (B), TT_FALSE)
 495
 496 #define TT_ASSERT_FILE_EQ(A, B)                         \
 497   TT_TEST_STR_((A), TT_OP_FILE_EQ, (B), TT_TRUE)
 498
 499 #define TT_EXPECT_FILE_NE(A, B)                         \
 500   TT_TEST_STR_((A), TT_OP_FILE_NE, (B), TT_FALSE)
 501
 502 #define TT_ASSERT_FILE_NE(A, B)                         \
 503   TT_TEST_STR_((A), TT_OP_FILE_NE, (B), TT_TRUE)
 504
 505 #define TT_EXPECT_TXTFILE_EQ(A, B)                      \
 506   TT_TEST_STR_((A), TT_OP_TXTFILE_EQ, (B), TT_FALSE)
 507
 508 #define TT_ASSERT_TXTFILE_EQ(A, B)                      \
 509   TT_TEST_STR_((A), TT_OP_TXTFILE_EQ, (B), TT_TRUE)
 510
 511 #define TT_EXPECT_TXTFILE_NE(A, B)                      \
 512   TT_TEST_STR_((A), TT_OP_TXTFILE_NE, (B), TT_FALSE)
 513
 514 #define TT_ASSERT_TXTFILE_NE(A, B)                      \
 515   TT_TEST_STR_((A), TT_OP_TXTFILE_NE, (B), TT_TRUE)
 516
 517 #define TT_FAIL(M, ...)                         \
 518   tt_fail(__FILE__, __LINE__, (M), __VA_ARGS__)
 519
 520 #define TT_SUITE_START(S)                               \
 521   tt_testsuite_t *__suite__ ## S = tt_suite_create(#S)
 522
 523 #define TT_SUITE_TEST(S, F)                     \
 524   tt_suite_add_test(__suite__ ## S, #F, F);
 525
 526 #define TT_TEST(F)                              \
 527   static void F(void)
 528
 529 #define TT_SUITE_END(S)                         \
 530   tt_suite_destroy(__suite__ ## S)
 531
 532 #define TT_SUITE_RUN(S)                         \
 533   tt_suite_run(__suite__ ## S)
 534
 535
 536 #endif // __tinytest_h