1 /* ---------------------------------------------------------------------------- 2 tinytest - A tiny C unit-testing library 3 Copyright (C) 2010-2018 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 #define TT_SUITE_NUM_FAILURES(S) \ 536 __suite__ ## S->num_failures 537 538 #endif // __tinytest_h 539