1 /* 2 * Copyright (c) 2011-2017 Scott Vokes <vokes.s@gmail.com> 3 * 4 * Permission to use, copy, modify, and/or distribute this software for any 5 * purpose with or without fee is hereby granted, provided that the above 6 * copyright notice and this permission notice appear in all copies. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 15 */ 16 17 #ifndef GREATEST_H 18 #define GREATEST_H 19 20 #if defined(__cplusplus) && !defined(GREATEST_NO_EXTERN_CPLUSPLUS) 21 extern "C" { 22 #endif 23 24 /* 1.3.1 */ 25 #define GREATEST_VERSION_MAJOR 1 26 #define GREATEST_VERSION_MINOR 3 27 #define GREATEST_VERSION_PATCH 1 28 29 /* A unit testing system for C, contained in 1 file. 30 * It doesn't use dynamic allocation or depend on anything 31 * beyond ANSI C89. 32 * 33 * An up-to-date version can be found at: 34 * https://github.com/silentbicycle/greatest/ 35 */ 36 37 38 /********************************************************************* 39 * Minimal test runner template 40 *********************************************************************/ 41 #if 0 42 43 #include "greatest.h" 44 45 TEST foo_should_foo(void) { 46 PASS(); 47 } 48 49 static void setup_cb(void *data) { 50 printf("setup callback for each test case\n"); 51 } 52 53 static void teardown_cb(void *data) { 54 printf("teardown callback for each test case\n"); 55 } 56 57 SUITE(suite) { 58 /* Optional setup/teardown callbacks which will be run before/after 59 * every test case. If using a test suite, they will be cleared when 60 * the suite finishes. */ 61 SET_SETUP(setup_cb, voidp_to_callback_data); 62 SET_TEARDOWN(teardown_cb, voidp_to_callback_data); 63 64 RUN_TEST(foo_should_foo); 65 } 66 67 /* Add definitions that need to be in the test runner's main file. */ 68 GREATEST_MAIN_DEFS(); 69 70 /* Set up, run suite(s) of tests, report pass/fail/skip stats. */ 71 int run_tests(void) { 72 GREATEST_INIT(); /* init. greatest internals */ 73 /* List of suites to run (if any). */ 74 RUN_SUITE(suite); 75 76 /* Tests can also be run directly, without using test suites. */ 77 RUN_TEST(foo_should_foo); 78 79 GREATEST_PRINT_REPORT(); /* display results */ 80 return greatest_all_passed(); 81 } 82 83 /* main(), for a standalone command-line test runner. 84 * This replaces run_tests above, and adds command line option 85 * handling and exiting with a pass/fail status. */ 86 int main(int argc, char **argv) { 87 GREATEST_MAIN_BEGIN(); /* init & parse command-line args */ 88 RUN_SUITE(suite); 89 GREATEST_MAIN_END(); /* display results */ 90 } 91 92 #endif 93 /*********************************************************************/ 94 95 96 #include <stdlib.h> 97 #include <stdio.h> 98 #include <string.h> 99 #include <ctype.h> 100 101 /*********** 102 * Options * 103 ***********/ 104 105 /* Default column width for non-verbose output. */ 106 #ifndef GREATEST_DEFAULT_WIDTH 107 #define GREATEST_DEFAULT_WIDTH 72 108 #endif 109 110 /* FILE *, for test logging. */ 111 #ifndef GREATEST_STDOUT 112 #define GREATEST_STDOUT stdout 113 #endif 114 115 /* Remove GREATEST_ prefix from most commonly used symbols? */ 116 #ifndef GREATEST_USE_ABBREVS 117 #define GREATEST_USE_ABBREVS 1 118 #endif 119 120 /* Set to 0 to disable all use of setjmp/longjmp. */ 121 #ifndef GREATEST_USE_LONGJMP 122 #define GREATEST_USE_LONGJMP 1 123 #endif 124 125 /* Make it possible to replace fprintf with another 126 * function with the same interface. */ 127 #ifndef GREATEST_FPRINTF 128 #define GREATEST_FPRINTF fprintf 129 #endif 130 131 #if GREATEST_USE_LONGJMP 132 #include <setjmp.h> 133 #endif 134 135 /* Set to 0 to disable all use of time.h / clock(). */ 136 #ifndef GREATEST_USE_TIME 137 #define GREATEST_USE_TIME 1 138 #endif 139 140 #if GREATEST_USE_TIME 141 #include <time.h> 142 #endif 143 144 /* Floating point type, for ASSERT_IN_RANGE. */ 145 #ifndef GREATEST_FLOAT 146 #define GREATEST_FLOAT double 147 #define GREATEST_FLOAT_FMT "%g" 148 #endif 149 150 151 /********* 152 * Types * 153 *********/ 154 155 /* Info for the current running suite. */ 156 typedef struct greatest_suite_info { 157 unsigned int tests_run; 158 unsigned int passed; 159 unsigned int failed; 160 unsigned int skipped; 161 162 #if GREATEST_USE_TIME 163 /* timers, pre/post running suite and individual tests */ 164 clock_t pre_suite; 165 clock_t post_suite; 166 clock_t pre_test; 167 clock_t post_test; 168 #endif 169 } greatest_suite_info; 170 171 /* Type for a suite function. */ 172 typedef void greatest_suite_cb(void); 173 174 /* Types for setup/teardown callbacks. If non-NULL, these will be run 175 * and passed the pointer to their additional data. */ 176 typedef void greatest_setup_cb(void *udata); 177 typedef void greatest_teardown_cb(void *udata); 178 179 /* Type for an equality comparison between two pointers of the same type. 180 * Should return non-0 if equal, otherwise 0. 181 * UDATA is a closure value, passed through from ASSERT_EQUAL_T[m]. */ 182 typedef int greatest_equal_cb(const void *exp, const void *got, void *udata); 183 184 /* Type for a callback that prints a value pointed to by T. 185 * Return value has the same meaning as printf's. 186 * UDATA is a closure value, passed through from ASSERT_EQUAL_T[m]. */ 187 typedef int greatest_printf_cb(const void *t, void *udata); 188 189 /* Callbacks for an arbitrary type; needed for type-specific 190 * comparisons via GREATEST_ASSERT_EQUAL_T[m].*/ 191 typedef struct greatest_type_info { 192 greatest_equal_cb *equal; 193 greatest_printf_cb *print; 194 } greatest_type_info; 195 196 typedef struct greatest_memory_cmp_env { 197 const unsigned char *exp; 198 const unsigned char *got; 199 size_t size; 200 } greatest_memory_cmp_env; 201 202 /* Callbacks for string and raw memory types. */ 203 extern greatest_type_info greatest_type_info_string; 204 extern greatest_type_info greatest_type_info_memory; 205 206 typedef enum { 207 GREATEST_FLAG_FIRST_FAIL = 0x01, 208 GREATEST_FLAG_LIST_ONLY = 0x02 209 } greatest_flag_t; 210 211 /* Internal state for a PRNG, used to shuffle test order. */ 212 struct greatest_prng { 213 unsigned char random_order; /* use random ordering? */ 214 unsigned char initialized; /* is random ordering initialized? */ 215 unsigned char pad_0[2]; 216 unsigned long state; /* PRNG state */ 217 unsigned long count; /* how many tests, this pass */ 218 unsigned long count_ceil; /* total number of tests */ 219 unsigned long count_run; /* total tests run */ 220 unsigned long mod; /* power-of-2 ceiling of count_ceil */ 221 unsigned long a; /* LCG multiplier */ 222 unsigned long c; /* LCG increment */ 223 }; 224 225 /* Struct containing all test runner state. */ 226 typedef struct greatest_run_info { 227 unsigned char flags; 228 unsigned char verbosity; 229 unsigned char pad_0[2]; 230 231 unsigned int tests_run; /* total test count */ 232 233 /* currently running test suite */ 234 greatest_suite_info suite; 235 236 /* overall pass/fail/skip counts */ 237 unsigned int passed; 238 unsigned int failed; 239 unsigned int skipped; 240 unsigned int assertions; 241 242 /* info to print about the most recent failure */ 243 unsigned int fail_line; 244 unsigned int pad_1; 245 const char *fail_file; 246 const char *msg; 247 248 /* current setup/teardown hooks and userdata */ 249 greatest_setup_cb *setup; 250 void *setup_udata; 251 greatest_teardown_cb *teardown; 252 void *teardown_udata; 253 254 /* formatting info for ".....s...F"-style output */ 255 unsigned int col; 256 unsigned int width; 257 258 /* only run a specific suite or test */ 259 const char *suite_filter; 260 const char *test_filter; 261 const char *test_exclude; 262 263 struct greatest_prng prng[2]; /* 0: suites, 1: tests */ 264 265 #if GREATEST_USE_TIME 266 /* overall timers */ 267 clock_t begin; 268 clock_t end; 269 #endif 270 271 #if GREATEST_USE_LONGJMP 272 int pad_jmp_buf; 273 jmp_buf jump_dest; 274 #endif 275 } greatest_run_info; 276 277 struct greatest_report_t { 278 /* overall pass/fail/skip counts */ 279 unsigned int passed; 280 unsigned int failed; 281 unsigned int skipped; 282 unsigned int assertions; 283 }; 284 285 /* Global var for the current testing context. 286 * Initialized by GREATEST_MAIN_DEFS(). */ 287 extern greatest_run_info greatest_info; 288 289 /* Type for ASSERT_ENUM_EQ's ENUM_STR argument. */ 290 typedef const char *greatest_enum_str_fun(int value); 291 292 /********************** 293 * Exported functions * 294 **********************/ 295 296 /* These are used internally by greatest. */ 297 void greatest_do_pass(const char *name); 298 void greatest_do_fail(const char *name); 299 void greatest_do_skip(const char *name); 300 int greatest_suite_pre(const char *suite_name); 301 void greatest_suite_post(void); 302 int greatest_test_pre(const char *name); 303 void greatest_test_post(const char *name, int res); 304 void greatest_usage(const char *name); 305 int greatest_do_assert_equal_t(const void *exp, const void *got, 306 greatest_type_info *type_info, void *udata); 307 void greatest_prng_init_first_pass(int id); 308 int greatest_prng_init_second_pass(int id, unsigned long seed); 309 void greatest_prng_step(int id); 310 311 /* These are part of the public greatest API. */ 312 void GREATEST_SET_SETUP_CB(greatest_setup_cb *cb, void *udata); 313 void GREATEST_SET_TEARDOWN_CB(greatest_teardown_cb *cb, void *udata); 314 int greatest_all_passed(void); 315 void greatest_set_suite_filter(const char *filter); 316 void greatest_set_test_filter(const char *filter); 317 void greatest_set_test_exclude(const char *filter); 318 void greatest_stop_at_first_fail(void); 319 void greatest_get_report(struct greatest_report_t *report); 320 unsigned int greatest_get_verbosity(void); 321 void greatest_set_verbosity(unsigned int verbosity); 322 void greatest_set_flag(greatest_flag_t flag); 323 324 325 /******************** 326 * Language Support * 327 ********************/ 328 329 /* If __VA_ARGS__ (C99) is supported, allow parametric testing 330 * without needing to manually manage the argument struct. */ 331 #if __STDC_VERSION__ >= 19901L || _MSC_VER >= 1800 332 #define GREATEST_VA_ARGS 333 #endif 334 335 336 /********** 337 * Macros * 338 **********/ 339 340 /* Define a suite. */ 341 #define GREATEST_SUITE(NAME) void NAME(void); void NAME(void) 342 343 /* Declare a suite, provided by another compilation unit. */ 344 #define GREATEST_SUITE_EXTERN(NAME) void NAME(void) 345 346 /* Start defining a test function. 347 * The arguments are not included, to allow parametric testing. */ 348 #define GREATEST_TEST static enum greatest_test_res 349 350 /* PASS/FAIL/SKIP result from a test. Used internally. */ 351 typedef enum greatest_test_res { 352 GREATEST_TEST_RES_PASS = 0, 353 GREATEST_TEST_RES_FAIL = -1, 354 GREATEST_TEST_RES_SKIP = 1 355 } greatest_test_res; 356 357 /* Run a suite. */ 358 #define GREATEST_RUN_SUITE(S_NAME) greatest_run_suite(S_NAME, #S_NAME) 359 360 /* Run a test in the current suite. */ 361 #define GREATEST_RUN_TEST(TEST) \ 362 do { \ 363 if (greatest_test_pre(#TEST) == 1) { \ 364 enum greatest_test_res res = GREATEST_SAVE_CONTEXT(); \ 365 if (res == GREATEST_TEST_RES_PASS) { \ 366 res = TEST(); \ 367 } \ 368 greatest_test_post(#TEST, res); \ 369 } \ 370 } while (0) 371 372 /* Ignore a test, don't warn about it being unused. */ 373 #define GREATEST_IGNORE_TEST(TEST) (void)TEST 374 375 /* Run a test in the current suite with one void * argument, 376 * which can be a pointer to a struct with multiple arguments. */ 377 #define GREATEST_RUN_TEST1(TEST, ENV) \ 378 do { \ 379 if (greatest_test_pre(#TEST) == 1) { \ 380 enum greatest_test_res res = GREATEST_SAVE_CONTEXT(); \ 381 if (res == GREATEST_TEST_RES_PASS) { \ 382 res = TEST(ENV); \ 383 } \ 384 greatest_test_post(#TEST, res); \ 385 } \ 386 } while (0) 387 388 #ifdef GREATEST_VA_ARGS 389 #define GREATEST_RUN_TESTp(TEST, ...) \ 390 do { \ 391 if (greatest_test_pre(#TEST) == 1) { \ 392 enum greatest_test_res res = GREATEST_SAVE_CONTEXT(); \ 393 if (res == GREATEST_TEST_RES_PASS) { \ 394 res = TEST(__VA_ARGS__); \ 395 } \ 396 greatest_test_post(#TEST, res); \ 397 } \ 398 } while (0) 399 #endif 400 401 402 /* Check if the test runner is in verbose mode. */ 403 #define GREATEST_IS_VERBOSE() ((greatest_info.verbosity) > 0) 404 #define GREATEST_LIST_ONLY() \ 405 (greatest_info.flags & GREATEST_FLAG_LIST_ONLY) 406 #define GREATEST_FIRST_FAIL() \ 407 (greatest_info.flags & GREATEST_FLAG_FIRST_FAIL) 408 #define GREATEST_FAILURE_ABORT() \ 409 (GREATEST_FIRST_FAIL() && \ 410 (greatest_info.suite.failed > 0 || greatest_info.failed > 0)) 411 412 /* Message-less forms of tests defined below. */ 413 #define GREATEST_PASS() GREATEST_PASSm(NULL) 414 #define GREATEST_FAIL() GREATEST_FAILm(NULL) 415 #define GREATEST_SKIP() GREATEST_SKIPm(NULL) 416 #define GREATEST_ASSERT(COND) \ 417 GREATEST_ASSERTm(#COND, COND) 418 #define GREATEST_ASSERT_OR_LONGJMP(COND) \ 419 GREATEST_ASSERT_OR_LONGJMPm(#COND, COND) 420 #define GREATEST_ASSERT_FALSE(COND) \ 421 GREATEST_ASSERT_FALSEm(#COND, COND) 422 #define GREATEST_ASSERT_EQ(EXP, GOT) \ 423 GREATEST_ASSERT_EQm(#EXP " != " #GOT, EXP, GOT) 424 #define GREATEST_ASSERT_EQ_FMT(EXP, GOT, FMT) \ 425 GREATEST_ASSERT_EQ_FMTm(#EXP " != " #GOT, EXP, GOT, FMT) 426 #define GREATEST_ASSERT_IN_RANGE(EXP, GOT, TOL) \ 427 GREATEST_ASSERT_IN_RANGEm(#EXP " != " #GOT " +/- " #TOL, EXP, GOT, TOL) 428 #define GREATEST_ASSERT_EQUAL_T(EXP, GOT, TYPE_INFO, UDATA) \ 429 GREATEST_ASSERT_EQUAL_Tm(#EXP " != " #GOT, EXP, GOT, TYPE_INFO, UDATA) 430 #define GREATEST_ASSERT_STR_EQ(EXP, GOT) \ 431 GREATEST_ASSERT_STR_EQm(#EXP " != " #GOT, EXP, GOT) 432 #define GREATEST_ASSERT_STRN_EQ(EXP, GOT, SIZE) \ 433 GREATEST_ASSERT_STRN_EQm(#EXP " != " #GOT, EXP, GOT, SIZE) 434 #define GREATEST_ASSERT_MEM_EQ(EXP, GOT, SIZE) \ 435 GREATEST_ASSERT_MEM_EQm(#EXP " != " #GOT, EXP, GOT, SIZE) 436 #define GREATEST_ASSERT_ENUM_EQ(EXP, GOT, ENUM_STR) \ 437 GREATEST_ASSERT_ENUM_EQm(#EXP " != " #GOT, EXP, GOT, ENUM_STR) 438 439 /* The following forms take an additional message argument first, 440 * to be displayed by the test runner. */ 441 442 /* Fail if a condition is not true, with message. */ 443 #define GREATEST_ASSERTm(MSG, COND) \ 444 do { \ 445 greatest_info.assertions++; \ 446 if (!(COND)) { GREATEST_FAILm(MSG); } \ 447 } while (0) 448 449 /* Fail if a condition is not true, longjmping out of test. */ 450 #define GREATEST_ASSERT_OR_LONGJMPm(MSG, COND) \ 451 do { \ 452 greatest_info.assertions++; \ 453 if (!(COND)) { GREATEST_FAIL_WITH_LONGJMPm(MSG); } \ 454 } while (0) 455 456 /* Fail if a condition is not false, with message. */ 457 #define GREATEST_ASSERT_FALSEm(MSG, COND) \ 458 do { \ 459 greatest_info.assertions++; \ 460 if ((COND)) { GREATEST_FAILm(MSG); } \ 461 } while (0) 462 463 /* Fail if EXP != GOT (equality comparison by ==). */ 464 #define GREATEST_ASSERT_EQm(MSG, EXP, GOT) \ 465 do { \ 466 greatest_info.assertions++; \ 467 if ((EXP) != (GOT)) { GREATEST_FAILm(MSG); } \ 468 } while (0) 469 470 /* Fail if EXP != GOT (equality comparison by ==). 471 * Warning: FMT, EXP, and GOT will be evaluated more 472 * than once on failure. */ 473 #define GREATEST_ASSERT_EQ_FMTm(MSG, EXP, GOT, FMT) \ 474 do { \ 475 greatest_info.assertions++; \ 476 if ((EXP) != (GOT)) { \ 477 GREATEST_FPRINTF(GREATEST_STDOUT, "\nExpected: "); \ 478 GREATEST_FPRINTF(GREATEST_STDOUT, FMT, EXP); \ 479 GREATEST_FPRINTF(GREATEST_STDOUT, "\n Got: "); \ 480 GREATEST_FPRINTF(GREATEST_STDOUT, FMT, GOT); \ 481 GREATEST_FPRINTF(GREATEST_STDOUT, "\n"); \ 482 GREATEST_FAILm(MSG); \ 483 } \ 484 } while (0) 485 486 /* Fail if EXP is not equal to GOT, printing enum IDs. */ 487 #define GREATEST_ASSERT_ENUM_EQm(MSG, EXP, GOT, ENUM_STR) \ 488 do { \ 489 int greatest_EXP = (int)(EXP); \ 490 int greatest_GOT = (int)(GOT); \ 491 greatest_enum_str_fun *greatest_ENUM_STR = ENUM_STR; \ 492 if (greatest_EXP != greatest_GOT) { \ 493 GREATEST_FPRINTF(GREATEST_STDOUT, "\nExpected: %s", \ 494 greatest_ENUM_STR(greatest_EXP)); \ 495 GREATEST_FPRINTF(GREATEST_STDOUT, "\n Got: %s\n", \ 496 greatest_ENUM_STR(greatest_GOT)); \ 497 GREATEST_FAILm(MSG); \ 498 } \ 499 } while (0) \ 500 501 /* Fail if GOT not in range of EXP +|- TOL. */ 502 #define GREATEST_ASSERT_IN_RANGEm(MSG, EXP, GOT, TOL) \ 503 do { \ 504 GREATEST_FLOAT greatest_EXP = (EXP); \ 505 GREATEST_FLOAT greatest_GOT = (GOT); \ 506 GREATEST_FLOAT greatest_TOL = (TOL); \ 507 greatest_info.assertions++; \ 508 if ((greatest_EXP > greatest_GOT && \ 509 greatest_EXP - greatest_GOT > greatest_TOL) || \ 510 (greatest_EXP < greatest_GOT && \ 511 greatest_GOT - greatest_EXP > greatest_TOL)) { \ 512 GREATEST_FPRINTF(GREATEST_STDOUT, \ 513 "\nExpected: " GREATEST_FLOAT_FMT \ 514 " +/- " GREATEST_FLOAT_FMT \ 515 "\n Got: " GREATEST_FLOAT_FMT \ 516 "\n", \ 517 greatest_EXP, greatest_TOL, greatest_GOT); \ 518 GREATEST_FAILm(MSG); \ 519 } \ 520 } while (0) 521 522 /* Fail if EXP is not equal to GOT, according to strcmp. */ 523 #define GREATEST_ASSERT_STR_EQm(MSG, EXP, GOT) \ 524 do { \ 525 GREATEST_ASSERT_EQUAL_Tm(MSG, EXP, GOT, \ 526 &greatest_type_info_string, NULL); \ 527 } while (0) \ 528 529 /* Fail if EXP is not equal to GOT, according to strcmp. */ 530 #define GREATEST_ASSERT_STRN_EQm(MSG, EXP, GOT, SIZE) \ 531 do { \ 532 size_t size = SIZE; \ 533 GREATEST_ASSERT_EQUAL_Tm(MSG, EXP, GOT, \ 534 &greatest_type_info_string, &size); \ 535 } while (0) \ 536 537 /* Fail if EXP is not equal to GOT, according to memcmp. */ 538 #define GREATEST_ASSERT_MEM_EQm(MSG, EXP, GOT, SIZE) \ 539 do { \ 540 greatest_memory_cmp_env env; \ 541 env.exp = (const unsigned char *)EXP; \ 542 env.got = (const unsigned char *)GOT; \ 543 env.size = SIZE; \ 544 GREATEST_ASSERT_EQUAL_Tm(MSG, env.exp, env.got, \ 545 &greatest_type_info_memory, &env); \ 546 } while (0) \ 547 548 /* Fail if EXP is not equal to GOT, according to a comparison 549 * callback in TYPE_INFO. If they are not equal, optionally use a 550 * print callback in TYPE_INFO to print them. */ 551 #define GREATEST_ASSERT_EQUAL_Tm(MSG, EXP, GOT, TYPE_INFO, UDATA) \ 552 do { \ 553 greatest_type_info *type_info = (TYPE_INFO); \ 554 greatest_info.assertions++; \ 555 if (!greatest_do_assert_equal_t(EXP, GOT, \ 556 type_info, UDATA)) { \ 557 if (type_info == NULL || type_info->equal == NULL) { \ 558 GREATEST_FAILm("type_info->equal callback missing!"); \ 559 } else { \ 560 GREATEST_FAILm(MSG); \ 561 } \ 562 } \ 563 } while (0) \ 564 565 /* Pass. */ 566 #define GREATEST_PASSm(MSG) \ 567 do { \ 568 greatest_info.msg = MSG; \ 569 return GREATEST_TEST_RES_PASS; \ 570 } while (0) 571 572 /* Fail. */ 573 #define GREATEST_FAILm(MSG) \ 574 do { \ 575 greatest_info.fail_file = __FILE__; \ 576 greatest_info.fail_line = __LINE__; \ 577 greatest_info.msg = MSG; \ 578 return GREATEST_TEST_RES_FAIL; \ 579 } while (0) 580 581 /* Optional GREATEST_FAILm variant that longjmps. */ 582 #if GREATEST_USE_LONGJMP 583 #define GREATEST_FAIL_WITH_LONGJMP() GREATEST_FAIL_WITH_LONGJMPm(NULL) 584 #define GREATEST_FAIL_WITH_LONGJMPm(MSG) \ 585 do { \ 586 greatest_info.fail_file = __FILE__; \ 587 greatest_info.fail_line = __LINE__; \ 588 greatest_info.msg = MSG; \ 589 longjmp(greatest_info.jump_dest, GREATEST_TEST_RES_FAIL); \ 590 } while (0) 591 #endif 592 593 /* Skip the current test. */ 594 #define GREATEST_SKIPm(MSG) \ 595 do { \ 596 greatest_info.msg = MSG; \ 597 return GREATEST_TEST_RES_SKIP; \ 598 } while (0) 599 600 /* Check the result of a subfunction using ASSERT, etc. */ 601 #define GREATEST_CHECK_CALL(RES) \ 602 do { \ 603 enum greatest_test_res greatest_RES = RES; \ 604 if (greatest_RES != GREATEST_TEST_RES_PASS) { \ 605 return greatest_RES; \ 606 } \ 607 } while (0) \ 608 609 #if GREATEST_USE_TIME 610 #define GREATEST_SET_TIME(NAME) \ 611 NAME = clock(); \ 612 if (NAME == (clock_t) -1) { \ 613 GREATEST_FPRINTF(GREATEST_STDOUT, \ 614 "clock error: %s\n", #NAME); \ 615 exit(EXIT_FAILURE); \ 616 } 617 618 #define GREATEST_CLOCK_DIFF(C1, C2) \ 619 GREATEST_FPRINTF(GREATEST_STDOUT, " (%lu ticks, %.3f sec)", \ 620 (long unsigned int) (C2) - (long unsigned int)(C1), \ 621 (double)((C2) - (C1)) / (1.0 * (double)CLOCKS_PER_SEC)) 622 #else 623 #define GREATEST_SET_TIME(UNUSED) 624 #define GREATEST_CLOCK_DIFF(UNUSED1, UNUSED2) 625 #endif 626 627 #if GREATEST_USE_LONGJMP 628 #define GREATEST_SAVE_CONTEXT() \ 629 /* setjmp returns 0 (GREATEST_TEST_RES_PASS) on first call * \ 630 * so the test runs, then RES_FAIL from FAIL_WITH_LONGJMP. */ \ 631 ((enum greatest_test_res)(setjmp(greatest_info.jump_dest))) 632 #else 633 #define GREATEST_SAVE_CONTEXT() \ 634 /*a no-op, since setjmp/longjmp aren't being used */ \ 635 GREATEST_TEST_RES_PASS 636 #endif 637 638 /* Run every suite / test function run within BODY in pseudo-random 639 * order, seeded by SEED. (The top 3 bits of the seed are ignored.) 640 * 641 * This should be called like: 642 * GREATEST_SHUFFLE_TESTS(seed, { 643 * GREATEST_RUN_TEST(some_test); 644 * GREATEST_RUN_TEST(some_other_test); 645 * GREATEST_RUN_TEST(yet_another_test); 646 * }); 647 * 648 * Note that the body of the second argument will be evaluated 649 * multiple times. */ 650 #define GREATEST_SHUFFLE_SUITES(SD, BODY) GREATEST_SHUFFLE(0, SD, BODY) 651 #define GREATEST_SHUFFLE_TESTS(SD, BODY) GREATEST_SHUFFLE(1, SD, BODY) 652 #define GREATEST_SHUFFLE(ID, SD, BODY) \ 653 do { \ 654 struct greatest_prng *prng = &greatest_info.prng[ID]; \ 655 greatest_prng_init_first_pass(ID); \ 656 do { \ 657 prng->count = 0; \ 658 if (prng->initialized) { greatest_prng_step(ID); } \ 659 BODY; \ 660 if (!prng->initialized) { \ 661 if (!greatest_prng_init_second_pass(ID, SD)) { break; } \ 662 } else if (prng->count_run == prng->count_ceil) { \ 663 break; \ 664 } \ 665 } while (!GREATEST_FAILURE_ABORT()); \ 666 prng->count_run = prng->random_order = prng->initialized = 0; \ 667 } while(0) 668 669 /* Include several function definitions in the main test file. */ 670 #define GREATEST_MAIN_DEFS() \ 671 \ 672 /* Is FILTER a subset of NAME? */ \ 673 static int greatest_name_match(const char *name, const char *filter, \ 674 int res_if_none) { \ 675 size_t offset = 0; \ 676 size_t filter_len = filter ? strlen(filter) : 0; \ 677 if (filter_len == 0) { return res_if_none; } /* no filter */ \ 678 while (name[offset] != '\0') { \ 679 if (name[offset] == filter[0]) { \ 680 if (0 == strncmp(&name[offset], filter, filter_len)) { \ 681 return 1; \ 682 } \ 683 } \ 684 offset++; \ 685 } \ 686 \ 687 return 0; \ 688 } \ 689 \ 690 /* Before running a test, check the name filtering and \ 691 * test shuffling state, if applicable, and then call setup hooks. */ \ 692 int greatest_test_pre(const char *name) { \ 693 struct greatest_run_info *g = &greatest_info; \ 694 int match = greatest_name_match(name, g->test_filter, 1) && \ 695 !greatest_name_match(name, g->test_exclude, 0); \ 696 if (GREATEST_LIST_ONLY()) { /* just listing test names */ \ 697 if (match) { fprintf(GREATEST_STDOUT, " %s\n", name); } \ 698 return 0; \ 699 } \ 700 if (match && (!GREATEST_FIRST_FAIL() || g->suite.failed == 0)) { \ 701 struct greatest_prng *p = &g->prng[1]; \ 702 if (p->random_order) { \ 703 p->count++; \ 704 if (!p->initialized || ((p->count - 1) != p->state)) { \ 705 return 0; /* don't run this test yet */ \ 706 } \ 707 } \ 708 GREATEST_SET_TIME(g->suite.pre_test); \ 709 if (g->setup) { g->setup(g->setup_udata); } \ 710 p->count_run++; \ 711 return 1; /* test should be run */ \ 712 } else { \ 713 return 0; /* skipped */ \ 714 } \ 715 } \ 716 \ 717 void greatest_test_post(const char *name, int res) { \ 718 GREATEST_SET_TIME(greatest_info.suite.post_test); \ 719 if (greatest_info.teardown) { \ 720 void *udata = greatest_info.teardown_udata; \ 721 greatest_info.teardown(udata); \ 722 } \ 723 \ 724 if (res <= GREATEST_TEST_RES_FAIL) { \ 725 greatest_do_fail(name); \ 726 } else if (res >= GREATEST_TEST_RES_SKIP) { \ 727 greatest_do_skip(name); \ 728 } else if (res == GREATEST_TEST_RES_PASS) { \ 729 greatest_do_pass(name); \ 730 } \ 731 greatest_info.suite.tests_run++; \ 732 greatest_info.col++; \ 733 if (GREATEST_IS_VERBOSE()) { \ 734 GREATEST_CLOCK_DIFF(greatest_info.suite.pre_test, \ 735 greatest_info.suite.post_test); \ 736 GREATEST_FPRINTF(GREATEST_STDOUT, "\n"); \ 737 } else if (greatest_info.col % greatest_info.width == 0) { \ 738 GREATEST_FPRINTF(GREATEST_STDOUT, "\n"); \ 739 greatest_info.col = 0; \ 740 } \ 741 fflush(GREATEST_STDOUT); \ 742 } \ 743 \ 744 static void report_suite(void) { \ 745 if (greatest_info.suite.tests_run > 0) { \ 746 GREATEST_FPRINTF(GREATEST_STDOUT, \ 747 "\n%u test%s - %u passed, %u failed, %u skipped", \ 748 greatest_info.suite.tests_run, \ 749 greatest_info.suite.tests_run == 1 ? "" : "s", \ 750 greatest_info.suite.passed, \ 751 greatest_info.suite.failed, \ 752 greatest_info.suite.skipped); \ 753 GREATEST_CLOCK_DIFF(greatest_info.suite.pre_suite, \ 754 greatest_info.suite.post_suite); \ 755 GREATEST_FPRINTF(GREATEST_STDOUT, "\n"); \ 756 } \ 757 } \ 758 \ 759 static void update_counts_and_reset_suite(void) { \ 760 greatest_info.setup = NULL; \ 761 greatest_info.setup_udata = NULL; \ 762 greatest_info.teardown = NULL; \ 763 greatest_info.teardown_udata = NULL; \ 764 greatest_info.passed += greatest_info.suite.passed; \ 765 greatest_info.failed += greatest_info.suite.failed; \ 766 greatest_info.skipped += greatest_info.suite.skipped; \ 767 greatest_info.tests_run += greatest_info.suite.tests_run; \ 768 memset(&greatest_info.suite, 0, sizeof(greatest_info.suite)); \ 769 greatest_info.col = 0; \ 770 } \ 771 \ 772 int greatest_suite_pre(const char *suite_name) { \ 773 struct greatest_prng *p = &greatest_info.prng[0]; \ 774 if (!greatest_name_match(suite_name, greatest_info.suite_filter, 1) \ 775 || (GREATEST_FIRST_FAIL() && greatest_info.failed > 0)) { \ 776 return 0; \ 777 } \ 778 if (p->random_order) { \ 779 p->count++; \ 780 if (!p->initialized || ((p->count - 1) != p->state)) { \ 781 return 0; /* don't run this suite yet */ \ 782 } \ 783 } \ 784 p->count_run++; \ 785 update_counts_and_reset_suite(); \ 786 GREATEST_FPRINTF(GREATEST_STDOUT, "\n* Suite %s:\n", suite_name); \ 787 GREATEST_SET_TIME(greatest_info.suite.pre_suite); \ 788 return 1; \ 789 } \ 790 \ 791 void greatest_suite_post(void) { \ 792 GREATEST_SET_TIME(greatest_info.suite.post_suite); \ 793 report_suite(); \ 794 } \ 795 \ 796 static void greatest_run_suite(greatest_suite_cb *suite_cb, \ 797 const char *suite_name) { \ 798 if (greatest_suite_pre(suite_name)) { \ 799 suite_cb(); \ 800 greatest_suite_post(); \ 801 } \ 802 } \ 803 \ 804 void greatest_do_pass(const char *name) { \ 805 if (GREATEST_IS_VERBOSE()) { \ 806 GREATEST_FPRINTF(GREATEST_STDOUT, "PASS %s: %s", \ 807 name, greatest_info.msg ? greatest_info.msg : ""); \ 808 } else { \ 809 GREATEST_FPRINTF(GREATEST_STDOUT, "."); \ 810 } \ 811 greatest_info.suite.passed++; \ 812 } \ 813 \ 814 void greatest_do_fail(const char *name) { \ 815 if (GREATEST_IS_VERBOSE()) { \ 816 GREATEST_FPRINTF(GREATEST_STDOUT, \ 817 "FAIL %s: %s (%s:%u)", \ 818 name, greatest_info.msg ? greatest_info.msg : "", \ 819 greatest_info.fail_file, greatest_info.fail_line); \ 820 } else { \ 821 GREATEST_FPRINTF(GREATEST_STDOUT, "F"); \ 822 greatest_info.col++; \ 823 /* add linebreak if in line of '.'s */ \ 824 if (greatest_info.col != 0) { \ 825 GREATEST_FPRINTF(GREATEST_STDOUT, "\n"); \ 826 greatest_info.col = 0; \ 827 } \ 828 GREATEST_FPRINTF(GREATEST_STDOUT, "FAIL %s: %s (%s:%u)\n", \ 829 name, \ 830 greatest_info.msg ? greatest_info.msg : "", \ 831 greatest_info.fail_file, greatest_info.fail_line); \ 832 } \ 833 greatest_info.suite.failed++; \ 834 } \ 835 \ 836 void greatest_do_skip(const char *name) { \ 837 if (GREATEST_IS_VERBOSE()) { \ 838 GREATEST_FPRINTF(GREATEST_STDOUT, "SKIP %s: %s", \ 839 name, \ 840 greatest_info.msg ? \ 841 greatest_info.msg : "" ); \ 842 } else { \ 843 GREATEST_FPRINTF(GREATEST_STDOUT, "s"); \ 844 } \ 845 greatest_info.suite.skipped++; \ 846 } \ 847 \ 848 int greatest_do_assert_equal_t(const void *exp, const void *got, \ 849 greatest_type_info *type_info, void *udata) { \ 850 int eq = 0; \ 851 if (type_info == NULL || type_info->equal == NULL) { \ 852 return 0; \ 853 } \ 854 eq = type_info->equal(exp, got, udata); \ 855 if (!eq) { \ 856 if (type_info->print != NULL) { \ 857 GREATEST_FPRINTF(GREATEST_STDOUT, "\nExpected: "); \ 858 (void)type_info->print(exp, udata); \ 859 GREATEST_FPRINTF(GREATEST_STDOUT, "\n Got: "); \ 860 (void)type_info->print(got, udata); \ 861 GREATEST_FPRINTF(GREATEST_STDOUT, "\n"); \ 862 } else { \ 863 GREATEST_FPRINTF(GREATEST_STDOUT, \ 864 "GREATEST_ASSERT_EQUAL_T failure at %s:%u\n", \ 865 greatest_info.fail_file, \ 866 greatest_info.fail_line); \ 867 } \ 868 } \ 869 return eq; \ 870 } \ 871 \ 872 void greatest_usage(const char *name) { \ 873 GREATEST_FPRINTF(GREATEST_STDOUT, \ 874 "Usage: %s [--help] [-hlfv] [-s SUITE] [-t TEST]\n" \ 875 " -h, --help print this Help\n" \ 876 " -l List suites and tests, then exit (dry run)\n" \ 877 " -f Stop runner after first failure\n" \ 878 " -v Verbose output\n" \ 879 " -s SUITE only run suites containing string SUITE\n" \ 880 " -t TEST only run tests containing string TEST\n" \ 881 " -x EXCLUDE exclude tests containing string EXCLUDE\n", \ 882 name); \ 883 } \ 884 \ 885 static void greatest_parse_options(int argc, char **argv) { \ 886 int i = 0; \ 887 for (i = 1; i < argc; i++) { \ 888 if (argv[i][0] == '-') { \ 889 char f = argv[i][1]; \ 890 if ((f == 's' || f == 't' || f == 'x') && argc <= i + 1) { \ 891 greatest_usage(argv[0]); exit(EXIT_FAILURE); \ 892 } \ 893 switch (f) { \ 894 case 's': /* suite name filter */ \ 895 greatest_set_suite_filter(argv[i + 1]); i++; break; \ 896 case 't': /* test name filter */ \ 897 greatest_set_test_filter(argv[i + 1]); i++; break; \ 898 case 'x': /* test name exclusion */ \ 899 greatest_set_test_exclude(argv[i + 1]); i++; break; \ 900 case 'f': /* first fail flag */ \ 901 greatest_stop_at_first_fail(); break; \ 902 case 'l': /* list only (dry run) */ \ 903 greatest_info.flags |= GREATEST_FLAG_LIST_ONLY; break; \ 904 case 'v': /* first fail flag */ \ 905 greatest_info.verbosity++; break; \ 906 case 'h': /* help */ \ 907 greatest_usage(argv[0]); exit(EXIT_SUCCESS); \ 908 case '-': \ 909 if (0 == strncmp("--help", argv[i], 6)) { \ 910 greatest_usage(argv[0]); exit(EXIT_SUCCESS); \ 911 } else if (0 == strncmp("--", argv[i], 2)) { \ 912 return; /* ignore following arguments */ \ 913 } /* fall through */ \ 914 default: \ 915 GREATEST_FPRINTF(GREATEST_STDOUT, \ 916 "Unknown argument '%s'\n", argv[i]); \ 917 greatest_usage(argv[0]); \ 918 exit(EXIT_FAILURE); \ 919 } \ 920 } \ 921 } \ 922 } \ 923 \ 924 int greatest_all_passed(void) { return (greatest_info.failed == 0); } \ 925 \ 926 void greatest_set_test_filter(const char *filter) { \ 927 greatest_info.test_filter = filter; \ 928 } \ 929 \ 930 void greatest_set_test_exclude(const char *filter) { \ 931 greatest_info.test_exclude = filter; \ 932 } \ 933 \ 934 void greatest_set_suite_filter(const char *filter) { \ 935 greatest_info.suite_filter = filter; \ 936 } \ 937 \ 938 void greatest_stop_at_first_fail(void) { \ 939 greatest_info.flags |= GREATEST_FLAG_FIRST_FAIL; \ 940 } \ 941 \ 942 void greatest_get_report(struct greatest_report_t *report) { \ 943 if (report) { \ 944 report->passed = greatest_info.passed; \ 945 report->failed = greatest_info.failed; \ 946 report->skipped = greatest_info.skipped; \ 947 report->assertions = greatest_info.assertions; \ 948 } \ 949 } \ 950 \ 951 unsigned int greatest_get_verbosity(void) { \ 952 return greatest_info.verbosity; \ 953 } \ 954 \ 955 void greatest_set_verbosity(unsigned int verbosity) { \ 956 greatest_info.verbosity = (unsigned char)verbosity; \ 957 } \ 958 \ 959 void greatest_set_flag(greatest_flag_t flag) { \ 960 greatest_info.flags |= flag; \ 961 } \ 962 \ 963 void GREATEST_SET_SETUP_CB(greatest_setup_cb *cb, void *udata) { \ 964 greatest_info.setup = cb; \ 965 greatest_info.setup_udata = udata; \ 966 } \ 967 \ 968 void GREATEST_SET_TEARDOWN_CB(greatest_teardown_cb *cb, \ 969 void *udata) { \ 970 greatest_info.teardown = cb; \ 971 greatest_info.teardown_udata = udata; \ 972 } \ 973 \ 974 static int greatest_string_equal_cb(const void *exp, const void *got, \ 975 void *udata) { \ 976 size_t *size = (size_t *)udata; \ 977 return (size != NULL \ 978 ? (0 == strncmp((const char *)exp, (const char *)got, *size)) \ 979 : (0 == strcmp((const char *)exp, (const char *)got))); \ 980 } \ 981 \ 982 static int greatest_string_printf_cb(const void *t, void *udata) { \ 983 (void)udata; /* note: does not check \0 termination. */ \ 984 return GREATEST_FPRINTF(GREATEST_STDOUT, "%s", (const char *)t); \ 985 } \ 986 \ 987 greatest_type_info greatest_type_info_string = { \ 988 greatest_string_equal_cb, \ 989 greatest_string_printf_cb, \ 990 }; \ 991 \ 992 static int greatest_memory_equal_cb(const void *exp, const void *got, \ 993 void *udata) { \ 994 greatest_memory_cmp_env *env = (greatest_memory_cmp_env *)udata; \ 995 return (0 == memcmp(exp, got, env->size)); \ 996 } \ 997 \ 998 /* Hexdump raw memory, with differences highlighted */ \ 999 static int greatest_memory_printf_cb(const void *t, void *udata) { \ 1000 greatest_memory_cmp_env *env = (greatest_memory_cmp_env *)udata; \ 1001 const unsigned char *buf = (const unsigned char *)t; \ 1002 unsigned char diff_mark = ' '; \ 1003 FILE *out = GREATEST_STDOUT; \ 1004 size_t i, line_i, line_len = 0; \ 1005 int len = 0; /* format hexdump with differences highlighted */ \ 1006 for (i = 0; i < env->size; i+= line_len) { \ 1007 diff_mark = ' '; \ 1008 line_len = env->size - i; \ 1009 if (line_len > 16) { line_len = 16; } \ 1010 for (line_i = i; line_i < i + line_len; line_i++) { \ 1011 if (env->exp[line_i] != env->got[line_i]) diff_mark = 'X'; \ 1012 } \ 1013 len += GREATEST_FPRINTF(out, "\n%04x %c ", \ 1014 (unsigned int)i, diff_mark); \ 1015 for (line_i = i; line_i < i + line_len; line_i++) { \ 1016 int m = env->exp[line_i] == env->got[line_i]; /* match? */ \ 1017 len += GREATEST_FPRINTF(out, "%02x%c", \ 1018 buf[line_i], m ? ' ' : '<'); \ 1019 } \ 1020 for (line_i = 0; line_i < 16 - line_len; line_i++) { \ 1021 len += GREATEST_FPRINTF(out, " "); \ 1022 } \ 1023 GREATEST_FPRINTF(out, " "); \ 1024 for (line_i = i; line_i < i + line_len; line_i++) { \ 1025 unsigned char c = buf[line_i]; \ 1026 len += GREATEST_FPRINTF(out, "%c", isprint(c) ? c : '.'); \ 1027 } \ 1028 } \ 1029 len += GREATEST_FPRINTF(out, "\n"); \ 1030 return len; \ 1031 } \ 1032 \ 1033 void greatest_prng_init_first_pass(int id) { \ 1034 greatest_info.prng[id].random_order = 1; \ 1035 greatest_info.prng[id].count_run = 0; \ 1036 } \ 1037 \ 1038 int greatest_prng_init_second_pass(int id, unsigned long seed) { \ 1039 static unsigned long primes[] = { 11, 101, 1009, 10007, \ 1040 100003, 1000003, 10000019, 100000007, 1000000007, \ 1041 1538461, 1865471, 17471, 2147483647 /* 2**32 - 1 */, }; \ 1042 struct greatest_prng *prng = &greatest_info.prng[id]; \ 1043 if (prng->count == 0) { return 0; } \ 1044 prng->mod = 1; \ 1045 prng->count_ceil = prng->count; \ 1046 while (prng->mod < prng->count) { prng->mod <<= 1; } \ 1047 prng->state = seed & 0x1fffffff; /* only use lower 29 bits... */ \ 1048 prng->a = (4LU * prng->state) + 1; /* to avoid overflow */ \ 1049 prng->c = primes[(seed * 16451) % sizeof(primes)/sizeof(primes[0])];\ 1050 prng->initialized = 1; \ 1051 return 1; \ 1052 } \ 1053 \ 1054 /* Step the pseudorandom number generator until its state reaches \ 1055 * another test ID between 0 and the test count. \ 1056 * This use a linear congruential pseudorandom number generator, \ 1057 * with the power-of-two ceiling of the test count as the modulus, the \ 1058 * masked seed as the multiplier, and a prime as the increment. For \ 1059 * each generated value < the test count, run the corresponding test. \ 1060 * This will visit all IDs 0 <= X < mod once before repeating, \ 1061 * with a starting position chosen based on the initial seed. \ 1062 * For details, see: Knuth, The Art of Computer Programming \ 1063 * Volume. 2, section 3.2.1. */ \ 1064 void greatest_prng_step(int id) { \ 1065 struct greatest_prng *p = &greatest_info.prng[id]; \ 1066 do { \ 1067 p->state = ((p->a * p->state) + p->c) & (p->mod - 1); \ 1068 } while (p->state >= p->count_ceil); \ 1069 } \ 1070 \ 1071 greatest_type_info greatest_type_info_memory = { \ 1072 greatest_memory_equal_cb, \ 1073 greatest_memory_printf_cb, \ 1074 }; \ 1075 \ 1076 greatest_run_info greatest_info 1077 1078 /* Init internals. */ 1079 #define GREATEST_INIT() \ 1080 do { \ 1081 /* Suppress unused function warning if features aren't used */ \ 1082 (void)greatest_run_suite; \ 1083 (void)greatest_parse_options; \ 1084 (void)greatest_prng_step; \ 1085 (void)greatest_prng_init_first_pass; \ 1086 (void)greatest_prng_init_second_pass; \ 1087 \ 1088 memset(&greatest_info, 0, sizeof(greatest_info)); \ 1089 greatest_info.width = GREATEST_DEFAULT_WIDTH; \ 1090 GREATEST_SET_TIME(greatest_info.begin); \ 1091 } while (0) \ 1092 1093 /* Handle command-line arguments, etc. */ 1094 #define GREATEST_MAIN_BEGIN() \ 1095 do { \ 1096 GREATEST_INIT(); \ 1097 greatest_parse_options(argc, argv); \ 1098 } while (0) 1099 1100 /* Report passes, failures, skipped tests, the number of 1101 * assertions, and the overall run time. */ 1102 #define GREATEST_PRINT_REPORT() \ 1103 do { \ 1104 if (!GREATEST_LIST_ONLY()) { \ 1105 update_counts_and_reset_suite(); \ 1106 GREATEST_SET_TIME(greatest_info.end); \ 1107 GREATEST_FPRINTF(GREATEST_STDOUT, \ 1108 "\nTotal: %u test%s", \ 1109 greatest_info.tests_run, \ 1110 greatest_info.tests_run == 1 ? "" : "s"); \ 1111 GREATEST_CLOCK_DIFF(greatest_info.begin, \ 1112 greatest_info.end); \ 1113 GREATEST_FPRINTF(GREATEST_STDOUT, ", %u assertion%s\n", \ 1114 greatest_info.assertions, \ 1115 greatest_info.assertions == 1 ? "" : "s"); \ 1116 GREATEST_FPRINTF(GREATEST_STDOUT, \ 1117 "Pass: %u, fail: %u, skip: %u.\n", \ 1118 greatest_info.passed, \ 1119 greatest_info.failed, greatest_info.skipped); \ 1120 } \ 1121 } while (0) 1122 1123 /* Report results, exit with exit status based on results. */ 1124 #define GREATEST_MAIN_END() \ 1125 do { \ 1126 GREATEST_PRINT_REPORT(); \ 1127 return (greatest_all_passed() ? EXIT_SUCCESS : EXIT_FAILURE); \ 1128 } while (0) 1129 1130 /* Make abbreviations without the GREATEST_ prefix for the 1131 * most commonly used symbols. */ 1132 #if GREATEST_USE_ABBREVS 1133 #define TEST GREATEST_TEST 1134 #define SUITE GREATEST_SUITE 1135 #define SUITE_EXTERN GREATEST_SUITE_EXTERN 1136 #define RUN_TEST GREATEST_RUN_TEST 1137 #define RUN_TEST1 GREATEST_RUN_TEST1 1138 #define RUN_SUITE GREATEST_RUN_SUITE 1139 #define IGNORE_TEST GREATEST_IGNORE_TEST 1140 #define ASSERT GREATEST_ASSERT 1141 #define ASSERTm GREATEST_ASSERTm 1142 #define ASSERT_FALSE GREATEST_ASSERT_FALSE 1143 #define ASSERT_EQ GREATEST_ASSERT_EQ 1144 #define ASSERT_EQ_FMT GREATEST_ASSERT_EQ_FMT 1145 #define ASSERT_IN_RANGE GREATEST_ASSERT_IN_RANGE 1146 #define ASSERT_EQUAL_T GREATEST_ASSERT_EQUAL_T 1147 #define ASSERT_STR_EQ GREATEST_ASSERT_STR_EQ 1148 #define ASSERT_STRN_EQ GREATEST_ASSERT_STRN_EQ 1149 #define ASSERT_MEM_EQ GREATEST_ASSERT_MEM_EQ 1150 #define ASSERT_ENUM_EQ GREATEST_ASSERT_ENUM_EQ 1151 #define ASSERT_FALSEm GREATEST_ASSERT_FALSEm 1152 #define ASSERT_EQm GREATEST_ASSERT_EQm 1153 #define ASSERT_EQ_FMTm GREATEST_ASSERT_EQ_FMTm 1154 #define ASSERT_IN_RANGEm GREATEST_ASSERT_IN_RANGEm 1155 #define ASSERT_EQUAL_Tm GREATEST_ASSERT_EQUAL_Tm 1156 #define ASSERT_STR_EQm GREATEST_ASSERT_STR_EQm 1157 #define ASSERT_STRN_EQm GREATEST_ASSERT_STRN_EQm 1158 #define ASSERT_MEM_EQm GREATEST_ASSERT_MEM_EQm 1159 #define ASSERT_ENUM_EQm GREATEST_ASSERT_ENUM_EQm 1160 #define PASS GREATEST_PASS 1161 #define FAIL GREATEST_FAIL 1162 #define SKIP GREATEST_SKIP 1163 #define PASSm GREATEST_PASSm 1164 #define FAILm GREATEST_FAILm 1165 #define SKIPm GREATEST_SKIPm 1166 #define SET_SETUP GREATEST_SET_SETUP_CB 1167 #define SET_TEARDOWN GREATEST_SET_TEARDOWN_CB 1168 #define CHECK_CALL GREATEST_CHECK_CALL 1169 #define SHUFFLE_TESTS GREATEST_SHUFFLE_TESTS 1170 #define SHUFFLE_SUITES GREATEST_SHUFFLE_SUITES 1171 1172 #ifdef GREATEST_VA_ARGS 1173 #define RUN_TESTp GREATEST_RUN_TESTp 1174 #endif 1175 1176 #if GREATEST_USE_LONGJMP 1177 #define ASSERT_OR_LONGJMP GREATEST_ASSERT_OR_LONGJMP 1178 #define ASSERT_OR_LONGJMPm GREATEST_ASSERT_OR_LONGJMPm 1179 #define FAIL_WITH_LONGJMP GREATEST_FAIL_WITH_LONGJMP 1180 #define FAIL_WITH_LONGJMPm GREATEST_FAIL_WITH_LONGJMPm 1181 #endif 1182 1183 #endif /* USE_ABBREVS */ 1184 1185 #if defined(__cplusplus) && !defined(GREATEST_NO_EXTERN_CPLUSPLUS) 1186 } 1187 #endif 1188 1189 #endif 1190