1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Base unit test (KUnit) API. 4 * 5 * Copyright (C) 2019, Google LLC. 6 * Author: Brendan Higgins <brendanhiggins@google.com> 7 */ 8 9 #ifndef _KUNIT_TEST_H 10 #define _KUNIT_TEST_H 11 12 #include <kunit/assert.h> 13 #include <kunit/try-catch.h> 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/slab.h> 17 #include <linux/types.h> 18 19 struct kunit_resource; 20 21 typedef int (*kunit_resource_init_t)(struct kunit_resource *, void *); 22 typedef void (*kunit_resource_free_t)(struct kunit_resource *); 23 24 /** 25 * struct kunit_resource - represents a *test managed resource* 26 * @allocation: for the user to store arbitrary data. 27 * @free: a user supplied function to free the resource. Populated by 28 * kunit_alloc_resource(). 29 * 30 * Represents a *test managed resource*, a resource which will automatically be 31 * cleaned up at the end of a test case. 32 * 33 * Example: 34 * 35 * .. code-block:: c 36 * 37 * struct kunit_kmalloc_params { 38 * size_t size; 39 * gfp_t gfp; 40 * }; 41 * 42 * static int kunit_kmalloc_init(struct kunit_resource *res, void *context) 43 * { 44 * struct kunit_kmalloc_params *params = context; 45 * res->allocation = kmalloc(params->size, params->gfp); 46 * 47 * if (!res->allocation) 48 * return -ENOMEM; 49 * 50 * return 0; 51 * } 52 * 53 * static void kunit_kmalloc_free(struct kunit_resource *res) 54 * { 55 * kfree(res->allocation); 56 * } 57 * 58 * void *kunit_kmalloc(struct kunit *test, size_t size, gfp_t gfp) 59 * { 60 * struct kunit_kmalloc_params params; 61 * struct kunit_resource *res; 62 * 63 * params.size = size; 64 * params.gfp = gfp; 65 * 66 * res = kunit_alloc_resource(test, kunit_kmalloc_init, 67 * kunit_kmalloc_free, ¶ms); 68 * if (res) 69 * return res->allocation; 70 * 71 * return NULL; 72 * } 73 */ 74 struct kunit_resource { 75 void *allocation; 76 kunit_resource_free_t free; 77 78 /* private: internal use only. */ 79 struct list_head node; 80 }; 81 82 struct kunit; 83 84 /* Size of log associated with test. */ 85 #define KUNIT_LOG_SIZE 512 86 87 /* 88 * TAP specifies subtest stream indentation of 4 spaces, 8 spaces for a 89 * sub-subtest. See the "Subtests" section in 90 * https://node-tap.org/tap-protocol/ 91 */ 92 #define KUNIT_SUBTEST_INDENT " " 93 #define KUNIT_SUBSUBTEST_INDENT " " 94 95 /** 96 * struct kunit_case - represents an individual test case. 97 * 98 * @run_case: the function representing the actual test case. 99 * @name: the name of the test case. 100 * 101 * A test case is a function with the signature, 102 * ``void (*)(struct kunit *)`` 103 * that makes expectations and assertions (see KUNIT_EXPECT_TRUE() and 104 * KUNIT_ASSERT_TRUE()) about code under test. Each test case is associated 105 * with a &struct kunit_suite and will be run after the suite's init 106 * function and followed by the suite's exit function. 107 * 108 * A test case should be static and should only be created with the 109 * KUNIT_CASE() macro; additionally, every array of test cases should be 110 * terminated with an empty test case. 111 * 112 * Example: 113 * 114 * .. code-block:: c 115 * 116 * void add_test_basic(struct kunit *test) 117 * { 118 * KUNIT_EXPECT_EQ(test, 1, add(1, 0)); 119 * KUNIT_EXPECT_EQ(test, 2, add(1, 1)); 120 * KUNIT_EXPECT_EQ(test, 0, add(-1, 1)); 121 * KUNIT_EXPECT_EQ(test, INT_MAX, add(0, INT_MAX)); 122 * KUNIT_EXPECT_EQ(test, -1, add(INT_MAX, INT_MIN)); 123 * } 124 * 125 * static struct kunit_case example_test_cases[] = { 126 * KUNIT_CASE(add_test_basic), 127 * {} 128 * }; 129 * 130 */ 131 struct kunit_case { 132 void (*run_case)(struct kunit *test); 133 const char *name; 134 135 /* private: internal use only. */ 136 bool success; 137 char *log; 138 }; 139 140 static inline char *kunit_status_to_string(bool status) 141 { 142 return status ? "ok" : "not ok"; 143 } 144 145 /** 146 * KUNIT_CASE - A helper for creating a &struct kunit_case 147 * 148 * @test_name: a reference to a test case function. 149 * 150 * Takes a symbol for a function representing a test case and creates a 151 * &struct kunit_case object from it. See the documentation for 152 * &struct kunit_case for an example on how to use it. 153 */ 154 #define KUNIT_CASE(test_name) { .run_case = test_name, .name = #test_name } 155 156 /** 157 * struct kunit_suite - describes a related collection of &struct kunit_case 158 * 159 * @name: the name of the test. Purely informational. 160 * @init: called before every test case. 161 * @exit: called after every test case. 162 * @test_cases: a null terminated array of test cases. 163 * 164 * A kunit_suite is a collection of related &struct kunit_case s, such that 165 * @init is called before every test case and @exit is called after every 166 * test case, similar to the notion of a *test fixture* or a *test class* 167 * in other unit testing frameworks like JUnit or Googletest. 168 * 169 * Every &struct kunit_case must be associated with a kunit_suite for KUnit 170 * to run it. 171 */ 172 struct kunit_suite { 173 const char name[256]; 174 int (*init)(struct kunit *test); 175 void (*exit)(struct kunit *test); 176 struct kunit_case *test_cases; 177 178 /* private: internal use only */ 179 struct dentry *debugfs; 180 char *log; 181 }; 182 183 /** 184 * struct kunit - represents a running instance of a test. 185 * 186 * @priv: for user to store arbitrary data. Commonly used to pass data 187 * created in the init function (see &struct kunit_suite). 188 * 189 * Used to store information about the current context under which the test 190 * is running. Most of this data is private and should only be accessed 191 * indirectly via public functions; the one exception is @priv which can be 192 * used by the test writer to store arbitrary data. 193 */ 194 struct kunit { 195 void *priv; 196 197 /* private: internal use only. */ 198 const char *name; /* Read only after initialization! */ 199 char *log; /* Points at case log after initialization */ 200 struct kunit_try_catch try_catch; 201 /* 202 * success starts as true, and may only be set to false during a 203 * test case; thus, it is safe to update this across multiple 204 * threads using WRITE_ONCE; however, as a consequence, it may only 205 * be read after the test case finishes once all threads associated 206 * with the test case have terminated. 207 */ 208 bool success; /* Read only after test_case finishes! */ 209 spinlock_t lock; /* Guards all mutable test state. */ 210 /* 211 * Because resources is a list that may be updated multiple times (with 212 * new resources) from any thread associated with a test case, we must 213 * protect it with some type of lock. 214 */ 215 struct list_head resources; /* Protected by lock. */ 216 }; 217 218 void kunit_init_test(struct kunit *test, const char *name, char *log); 219 220 int kunit_run_tests(struct kunit_suite *suite); 221 222 size_t kunit_suite_num_test_cases(struct kunit_suite *suite); 223 224 unsigned int kunit_test_case_num(struct kunit_suite *suite, 225 struct kunit_case *test_case); 226 227 int __kunit_test_suites_init(struct kunit_suite **suites); 228 229 void __kunit_test_suites_exit(struct kunit_suite **suites); 230 231 /** 232 * kunit_test_suites() - used to register one or more &struct kunit_suite 233 * with KUnit. 234 * 235 * @suites_list...: a statically allocated list of &struct kunit_suite. 236 * 237 * Registers @suites_list with the test framework. See &struct kunit_suite for 238 * more information. 239 * 240 * When builtin, KUnit tests are all run as late_initcalls; this means 241 * that they cannot test anything where tests must run at a different init 242 * phase. One significant restriction resulting from this is that KUnit 243 * cannot reliably test anything that is initialize in the late_init phase; 244 * another is that KUnit is useless to test things that need to be run in 245 * an earlier init phase. 246 * 247 * An alternative is to build the tests as a module. Because modules 248 * do not support multiple late_initcall()s, we need to initialize an 249 * array of suites for a module. 250 * 251 * TODO(brendanhiggins@google.com): Don't run all KUnit tests as 252 * late_initcalls. I have some future work planned to dispatch all KUnit 253 * tests from the same place, and at the very least to do so after 254 * everything else is definitely initialized. 255 */ 256 #define kunit_test_suites(suites_list...) \ 257 static struct kunit_suite *suites[] = {suites_list, NULL}; \ 258 static int kunit_test_suites_init(void) \ 259 { \ 260 return __kunit_test_suites_init(suites); \ 261 } \ 262 late_initcall(kunit_test_suites_init); \ 263 static void __exit kunit_test_suites_exit(void) \ 264 { \ 265 return __kunit_test_suites_exit(suites); \ 266 } \ 267 module_exit(kunit_test_suites_exit) 268 269 #define kunit_test_suite(suite) kunit_test_suites(&suite) 270 271 #define kunit_suite_for_each_test_case(suite, test_case) \ 272 for (test_case = suite->test_cases; test_case->run_case; test_case++) 273 274 bool kunit_suite_has_succeeded(struct kunit_suite *suite); 275 276 /* 277 * Like kunit_alloc_resource() below, but returns the struct kunit_resource 278 * object that contains the allocation. This is mostly for testing purposes. 279 */ 280 struct kunit_resource *kunit_alloc_and_get_resource(struct kunit *test, 281 kunit_resource_init_t init, 282 kunit_resource_free_t free, 283 gfp_t internal_gfp, 284 void *context); 285 286 /** 287 * kunit_alloc_resource() - Allocates a *test managed resource*. 288 * @test: The test context object. 289 * @init: a user supplied function to initialize the resource. 290 * @free: a user supplied function to free the resource. 291 * @internal_gfp: gfp to use for internal allocations, if unsure, use GFP_KERNEL 292 * @context: for the user to pass in arbitrary data to the init function. 293 * 294 * Allocates a *test managed resource*, a resource which will automatically be 295 * cleaned up at the end of a test case. See &struct kunit_resource for an 296 * example. 297 * 298 * NOTE: KUnit needs to allocate memory for each kunit_resource object. You must 299 * specify an @internal_gfp that is compatible with the use context of your 300 * resource. 301 */ 302 static inline void *kunit_alloc_resource(struct kunit *test, 303 kunit_resource_init_t init, 304 kunit_resource_free_t free, 305 gfp_t internal_gfp, 306 void *context) 307 { 308 struct kunit_resource *res; 309 310 res = kunit_alloc_and_get_resource(test, init, free, internal_gfp, 311 context); 312 313 if (res) 314 return res->allocation; 315 316 return NULL; 317 } 318 319 typedef bool (*kunit_resource_match_t)(struct kunit *test, 320 const void *res, 321 void *match_data); 322 323 /** 324 * kunit_resource_instance_match() - Match a resource with the same instance. 325 * @test: Test case to which the resource belongs. 326 * @res: The data stored in kunit_resource->allocation. 327 * @match_data: The resource pointer to match against. 328 * 329 * An instance of kunit_resource_match_t that matches a resource whose 330 * allocation matches @match_data. 331 */ 332 static inline bool kunit_resource_instance_match(struct kunit *test, 333 const void *res, 334 void *match_data) 335 { 336 return res == match_data; 337 } 338 339 /** 340 * kunit_resource_destroy() - Find a kunit_resource and destroy it. 341 * @test: Test case to which the resource belongs. 342 * @match: Match function. Returns whether a given resource matches @match_data. 343 * @free: Must match free on the kunit_resource to free. 344 * @match_data: Data passed into @match. 345 * 346 * Free the latest kunit_resource of @test for which @free matches the 347 * kunit_resource_free_t associated with the resource and for which @match 348 * returns true. 349 * 350 * RETURNS: 351 * 0 if kunit_resource is found and freed, -ENOENT if not found. 352 */ 353 int kunit_resource_destroy(struct kunit *test, 354 kunit_resource_match_t match, 355 kunit_resource_free_t free, 356 void *match_data); 357 358 /** 359 * kunit_kmalloc() - Like kmalloc() except the allocation is *test managed*. 360 * @test: The test context object. 361 * @size: The size in bytes of the desired memory. 362 * @gfp: flags passed to underlying kmalloc(). 363 * 364 * Just like `kmalloc(...)`, except the allocation is managed by the test case 365 * and is automatically cleaned up after the test case concludes. See &struct 366 * kunit_resource for more information. 367 */ 368 void *kunit_kmalloc(struct kunit *test, size_t size, gfp_t gfp); 369 370 /** 371 * kunit_kfree() - Like kfree except for allocations managed by KUnit. 372 * @test: The test case to which the resource belongs. 373 * @ptr: The memory allocation to free. 374 */ 375 void kunit_kfree(struct kunit *test, const void *ptr); 376 377 /** 378 * kunit_kzalloc() - Just like kunit_kmalloc(), but zeroes the allocation. 379 * @test: The test context object. 380 * @size: The size in bytes of the desired memory. 381 * @gfp: flags passed to underlying kmalloc(). 382 * 383 * See kzalloc() and kunit_kmalloc() for more information. 384 */ 385 static inline void *kunit_kzalloc(struct kunit *test, size_t size, gfp_t gfp) 386 { 387 return kunit_kmalloc(test, size, gfp | __GFP_ZERO); 388 } 389 390 void kunit_cleanup(struct kunit *test); 391 392 void kunit_log_append(char *log, const char *fmt, ...); 393 394 /* 395 * printk and log to per-test or per-suite log buffer. Logging only done 396 * if CONFIG_KUNIT_DEBUGFS is 'y'; if it is 'n', no log is allocated/used. 397 */ 398 #define kunit_log(lvl, test_or_suite, fmt, ...) \ 399 do { \ 400 printk(lvl fmt, ##__VA_ARGS__); \ 401 kunit_log_append((test_or_suite)->log, fmt "\n", \ 402 ##__VA_ARGS__); \ 403 } while (0) 404 405 #define kunit_printk(lvl, test, fmt, ...) \ 406 kunit_log(lvl, test, KUNIT_SUBTEST_INDENT "# %s: " fmt, \ 407 (test)->name, ##__VA_ARGS__) 408 409 /** 410 * kunit_info() - Prints an INFO level message associated with @test. 411 * 412 * @test: The test context object. 413 * @fmt: A printk() style format string. 414 * 415 * Prints an info level message associated with the test suite being run. 416 * Takes a variable number of format parameters just like printk(). 417 */ 418 #define kunit_info(test, fmt, ...) \ 419 kunit_printk(KERN_INFO, test, fmt, ##__VA_ARGS__) 420 421 /** 422 * kunit_warn() - Prints a WARN level message associated with @test. 423 * 424 * @test: The test context object. 425 * @fmt: A printk() style format string. 426 * 427 * Prints a warning level message. 428 */ 429 #define kunit_warn(test, fmt, ...) \ 430 kunit_printk(KERN_WARNING, test, fmt, ##__VA_ARGS__) 431 432 /** 433 * kunit_err() - Prints an ERROR level message associated with @test. 434 * 435 * @test: The test context object. 436 * @fmt: A printk() style format string. 437 * 438 * Prints an error level message. 439 */ 440 #define kunit_err(test, fmt, ...) \ 441 kunit_printk(KERN_ERR, test, fmt, ##__VA_ARGS__) 442 443 /** 444 * KUNIT_SUCCEED() - A no-op expectation. Only exists for code clarity. 445 * @test: The test context object. 446 * 447 * The opposite of KUNIT_FAIL(), it is an expectation that cannot fail. In other 448 * words, it does nothing and only exists for code clarity. See 449 * KUNIT_EXPECT_TRUE() for more information. 450 */ 451 #define KUNIT_SUCCEED(test) do {} while (0) 452 453 void kunit_do_assertion(struct kunit *test, 454 struct kunit_assert *assert, 455 bool pass, 456 const char *fmt, ...); 457 458 #define KUNIT_ASSERTION(test, pass, assert_class, INITIALIZER, fmt, ...) do { \ 459 struct assert_class __assertion = INITIALIZER; \ 460 kunit_do_assertion(test, \ 461 &__assertion.assert, \ 462 pass, \ 463 fmt, \ 464 ##__VA_ARGS__); \ 465 } while (0) 466 467 468 #define KUNIT_FAIL_ASSERTION(test, assert_type, fmt, ...) \ 469 KUNIT_ASSERTION(test, \ 470 false, \ 471 kunit_fail_assert, \ 472 KUNIT_INIT_FAIL_ASSERT_STRUCT(test, assert_type), \ 473 fmt, \ 474 ##__VA_ARGS__) 475 476 /** 477 * KUNIT_FAIL() - Always causes a test to fail when evaluated. 478 * @test: The test context object. 479 * @fmt: an informational message to be printed when the assertion is made. 480 * @...: string format arguments. 481 * 482 * The opposite of KUNIT_SUCCEED(), it is an expectation that always fails. In 483 * other words, it always results in a failed expectation, and consequently 484 * always causes the test case to fail when evaluated. See KUNIT_EXPECT_TRUE() 485 * for more information. 486 */ 487 #define KUNIT_FAIL(test, fmt, ...) \ 488 KUNIT_FAIL_ASSERTION(test, \ 489 KUNIT_EXPECTATION, \ 490 fmt, \ 491 ##__VA_ARGS__) 492 493 #define KUNIT_UNARY_ASSERTION(test, \ 494 assert_type, \ 495 condition, \ 496 expected_true, \ 497 fmt, \ 498 ...) \ 499 KUNIT_ASSERTION(test, \ 500 !!(condition) == !!expected_true, \ 501 kunit_unary_assert, \ 502 KUNIT_INIT_UNARY_ASSERT_STRUCT(test, \ 503 assert_type, \ 504 #condition, \ 505 expected_true), \ 506 fmt, \ 507 ##__VA_ARGS__) 508 509 #define KUNIT_TRUE_MSG_ASSERTION(test, assert_type, condition, fmt, ...) \ 510 KUNIT_UNARY_ASSERTION(test, \ 511 assert_type, \ 512 condition, \ 513 true, \ 514 fmt, \ 515 ##__VA_ARGS__) 516 517 #define KUNIT_TRUE_ASSERTION(test, assert_type, condition) \ 518 KUNIT_TRUE_MSG_ASSERTION(test, assert_type, condition, NULL) 519 520 #define KUNIT_FALSE_MSG_ASSERTION(test, assert_type, condition, fmt, ...) \ 521 KUNIT_UNARY_ASSERTION(test, \ 522 assert_type, \ 523 condition, \ 524 false, \ 525 fmt, \ 526 ##__VA_ARGS__) 527 528 #define KUNIT_FALSE_ASSERTION(test, assert_type, condition) \ 529 KUNIT_FALSE_MSG_ASSERTION(test, assert_type, condition, NULL) 530 531 /* 532 * A factory macro for defining the assertions and expectations for the basic 533 * comparisons defined for the built in types. 534 * 535 * Unfortunately, there is no common type that all types can be promoted to for 536 * which all the binary operators behave the same way as for the actual types 537 * (for example, there is no type that long long and unsigned long long can 538 * both be cast to where the comparison result is preserved for all values). So 539 * the best we can do is do the comparison in the original types and then coerce 540 * everything to long long for printing; this way, the comparison behaves 541 * correctly and the printed out value usually makes sense without 542 * interpretation, but can always be interpreted to figure out the actual 543 * value. 544 */ 545 #define KUNIT_BASE_BINARY_ASSERTION(test, \ 546 assert_class, \ 547 ASSERT_CLASS_INIT, \ 548 assert_type, \ 549 left, \ 550 op, \ 551 right, \ 552 fmt, \ 553 ...) \ 554 do { \ 555 typeof(left) __left = (left); \ 556 typeof(right) __right = (right); \ 557 ((void)__typecheck(__left, __right)); \ 558 \ 559 KUNIT_ASSERTION(test, \ 560 __left op __right, \ 561 assert_class, \ 562 ASSERT_CLASS_INIT(test, \ 563 assert_type, \ 564 #op, \ 565 #left, \ 566 __left, \ 567 #right, \ 568 __right), \ 569 fmt, \ 570 ##__VA_ARGS__); \ 571 } while (0) 572 573 #define KUNIT_BASE_EQ_MSG_ASSERTION(test, \ 574 assert_class, \ 575 ASSERT_CLASS_INIT, \ 576 assert_type, \ 577 left, \ 578 right, \ 579 fmt, \ 580 ...) \ 581 KUNIT_BASE_BINARY_ASSERTION(test, \ 582 assert_class, \ 583 ASSERT_CLASS_INIT, \ 584 assert_type, \ 585 left, ==, right, \ 586 fmt, \ 587 ##__VA_ARGS__) 588 589 #define KUNIT_BASE_NE_MSG_ASSERTION(test, \ 590 assert_class, \ 591 ASSERT_CLASS_INIT, \ 592 assert_type, \ 593 left, \ 594 right, \ 595 fmt, \ 596 ...) \ 597 KUNIT_BASE_BINARY_ASSERTION(test, \ 598 assert_class, \ 599 ASSERT_CLASS_INIT, \ 600 assert_type, \ 601 left, !=, right, \ 602 fmt, \ 603 ##__VA_ARGS__) 604 605 #define KUNIT_BASE_LT_MSG_ASSERTION(test, \ 606 assert_class, \ 607 ASSERT_CLASS_INIT, \ 608 assert_type, \ 609 left, \ 610 right, \ 611 fmt, \ 612 ...) \ 613 KUNIT_BASE_BINARY_ASSERTION(test, \ 614 assert_class, \ 615 ASSERT_CLASS_INIT, \ 616 assert_type, \ 617 left, <, right, \ 618 fmt, \ 619 ##__VA_ARGS__) 620 621 #define KUNIT_BASE_LE_MSG_ASSERTION(test, \ 622 assert_class, \ 623 ASSERT_CLASS_INIT, \ 624 assert_type, \ 625 left, \ 626 right, \ 627 fmt, \ 628 ...) \ 629 KUNIT_BASE_BINARY_ASSERTION(test, \ 630 assert_class, \ 631 ASSERT_CLASS_INIT, \ 632 assert_type, \ 633 left, <=, right, \ 634 fmt, \ 635 ##__VA_ARGS__) 636 637 #define KUNIT_BASE_GT_MSG_ASSERTION(test, \ 638 assert_class, \ 639 ASSERT_CLASS_INIT, \ 640 assert_type, \ 641 left, \ 642 right, \ 643 fmt, \ 644 ...) \ 645 KUNIT_BASE_BINARY_ASSERTION(test, \ 646 assert_class, \ 647 ASSERT_CLASS_INIT, \ 648 assert_type, \ 649 left, >, right, \ 650 fmt, \ 651 ##__VA_ARGS__) 652 653 #define KUNIT_BASE_GE_MSG_ASSERTION(test, \ 654 assert_class, \ 655 ASSERT_CLASS_INIT, \ 656 assert_type, \ 657 left, \ 658 right, \ 659 fmt, \ 660 ...) \ 661 KUNIT_BASE_BINARY_ASSERTION(test, \ 662 assert_class, \ 663 ASSERT_CLASS_INIT, \ 664 assert_type, \ 665 left, >=, right, \ 666 fmt, \ 667 ##__VA_ARGS__) 668 669 #define KUNIT_BINARY_EQ_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ 670 KUNIT_BASE_EQ_MSG_ASSERTION(test, \ 671 kunit_binary_assert, \ 672 KUNIT_INIT_BINARY_ASSERT_STRUCT, \ 673 assert_type, \ 674 left, \ 675 right, \ 676 fmt, \ 677 ##__VA_ARGS__) 678 679 #define KUNIT_BINARY_EQ_ASSERTION(test, assert_type, left, right) \ 680 KUNIT_BINARY_EQ_MSG_ASSERTION(test, \ 681 assert_type, \ 682 left, \ 683 right, \ 684 NULL) 685 686 #define KUNIT_BINARY_PTR_EQ_MSG_ASSERTION(test, \ 687 assert_type, \ 688 left, \ 689 right, \ 690 fmt, \ 691 ...) \ 692 KUNIT_BASE_EQ_MSG_ASSERTION(test, \ 693 kunit_binary_ptr_assert, \ 694 KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ 695 assert_type, \ 696 left, \ 697 right, \ 698 fmt, \ 699 ##__VA_ARGS__) 700 701 #define KUNIT_BINARY_PTR_EQ_ASSERTION(test, assert_type, left, right) \ 702 KUNIT_BINARY_PTR_EQ_MSG_ASSERTION(test, \ 703 assert_type, \ 704 left, \ 705 right, \ 706 NULL) 707 708 #define KUNIT_BINARY_NE_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ 709 KUNIT_BASE_NE_MSG_ASSERTION(test, \ 710 kunit_binary_assert, \ 711 KUNIT_INIT_BINARY_ASSERT_STRUCT, \ 712 assert_type, \ 713 left, \ 714 right, \ 715 fmt, \ 716 ##__VA_ARGS__) 717 718 #define KUNIT_BINARY_NE_ASSERTION(test, assert_type, left, right) \ 719 KUNIT_BINARY_NE_MSG_ASSERTION(test, \ 720 assert_type, \ 721 left, \ 722 right, \ 723 NULL) 724 725 #define KUNIT_BINARY_PTR_NE_MSG_ASSERTION(test, \ 726 assert_type, \ 727 left, \ 728 right, \ 729 fmt, \ 730 ...) \ 731 KUNIT_BASE_NE_MSG_ASSERTION(test, \ 732 kunit_binary_ptr_assert, \ 733 KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ 734 assert_type, \ 735 left, \ 736 right, \ 737 fmt, \ 738 ##__VA_ARGS__) 739 740 #define KUNIT_BINARY_PTR_NE_ASSERTION(test, assert_type, left, right) \ 741 KUNIT_BINARY_PTR_NE_MSG_ASSERTION(test, \ 742 assert_type, \ 743 left, \ 744 right, \ 745 NULL) 746 747 #define KUNIT_BINARY_LT_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ 748 KUNIT_BASE_LT_MSG_ASSERTION(test, \ 749 kunit_binary_assert, \ 750 KUNIT_INIT_BINARY_ASSERT_STRUCT, \ 751 assert_type, \ 752 left, \ 753 right, \ 754 fmt, \ 755 ##__VA_ARGS__) 756 757 #define KUNIT_BINARY_LT_ASSERTION(test, assert_type, left, right) \ 758 KUNIT_BINARY_LT_MSG_ASSERTION(test, \ 759 assert_type, \ 760 left, \ 761 right, \ 762 NULL) 763 764 #define KUNIT_BINARY_PTR_LT_MSG_ASSERTION(test, \ 765 assert_type, \ 766 left, \ 767 right, \ 768 fmt, \ 769 ...) \ 770 KUNIT_BASE_LT_MSG_ASSERTION(test, \ 771 kunit_binary_ptr_assert, \ 772 KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ 773 assert_type, \ 774 left, \ 775 right, \ 776 fmt, \ 777 ##__VA_ARGS__) 778 779 #define KUNIT_BINARY_PTR_LT_ASSERTION(test, assert_type, left, right) \ 780 KUNIT_BINARY_PTR_LT_MSG_ASSERTION(test, \ 781 assert_type, \ 782 left, \ 783 right, \ 784 NULL) 785 786 #define KUNIT_BINARY_LE_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ 787 KUNIT_BASE_LE_MSG_ASSERTION(test, \ 788 kunit_binary_assert, \ 789 KUNIT_INIT_BINARY_ASSERT_STRUCT, \ 790 assert_type, \ 791 left, \ 792 right, \ 793 fmt, \ 794 ##__VA_ARGS__) 795 796 #define KUNIT_BINARY_LE_ASSERTION(test, assert_type, left, right) \ 797 KUNIT_BINARY_LE_MSG_ASSERTION(test, \ 798 assert_type, \ 799 left, \ 800 right, \ 801 NULL) 802 803 #define KUNIT_BINARY_PTR_LE_MSG_ASSERTION(test, \ 804 assert_type, \ 805 left, \ 806 right, \ 807 fmt, \ 808 ...) \ 809 KUNIT_BASE_LE_MSG_ASSERTION(test, \ 810 kunit_binary_ptr_assert, \ 811 KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ 812 assert_type, \ 813 left, \ 814 right, \ 815 fmt, \ 816 ##__VA_ARGS__) 817 818 #define KUNIT_BINARY_PTR_LE_ASSERTION(test, assert_type, left, right) \ 819 KUNIT_BINARY_PTR_LE_MSG_ASSERTION(test, \ 820 assert_type, \ 821 left, \ 822 right, \ 823 NULL) 824 825 #define KUNIT_BINARY_GT_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ 826 KUNIT_BASE_GT_MSG_ASSERTION(test, \ 827 kunit_binary_assert, \ 828 KUNIT_INIT_BINARY_ASSERT_STRUCT, \ 829 assert_type, \ 830 left, \ 831 right, \ 832 fmt, \ 833 ##__VA_ARGS__) 834 835 #define KUNIT_BINARY_GT_ASSERTION(test, assert_type, left, right) \ 836 KUNIT_BINARY_GT_MSG_ASSERTION(test, \ 837 assert_type, \ 838 left, \ 839 right, \ 840 NULL) 841 842 #define KUNIT_BINARY_PTR_GT_MSG_ASSERTION(test, \ 843 assert_type, \ 844 left, \ 845 right, \ 846 fmt, \ 847 ...) \ 848 KUNIT_BASE_GT_MSG_ASSERTION(test, \ 849 kunit_binary_ptr_assert, \ 850 KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ 851 assert_type, \ 852 left, \ 853 right, \ 854 fmt, \ 855 ##__VA_ARGS__) 856 857 #define KUNIT_BINARY_PTR_GT_ASSERTION(test, assert_type, left, right) \ 858 KUNIT_BINARY_PTR_GT_MSG_ASSERTION(test, \ 859 assert_type, \ 860 left, \ 861 right, \ 862 NULL) 863 864 #define KUNIT_BINARY_GE_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ 865 KUNIT_BASE_GE_MSG_ASSERTION(test, \ 866 kunit_binary_assert, \ 867 KUNIT_INIT_BINARY_ASSERT_STRUCT, \ 868 assert_type, \ 869 left, \ 870 right, \ 871 fmt, \ 872 ##__VA_ARGS__) 873 874 #define KUNIT_BINARY_GE_ASSERTION(test, assert_type, left, right) \ 875 KUNIT_BINARY_GE_MSG_ASSERTION(test, \ 876 assert_type, \ 877 left, \ 878 right, \ 879 NULL) 880 881 #define KUNIT_BINARY_PTR_GE_MSG_ASSERTION(test, \ 882 assert_type, \ 883 left, \ 884 right, \ 885 fmt, \ 886 ...) \ 887 KUNIT_BASE_GE_MSG_ASSERTION(test, \ 888 kunit_binary_ptr_assert, \ 889 KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ 890 assert_type, \ 891 left, \ 892 right, \ 893 fmt, \ 894 ##__VA_ARGS__) 895 896 #define KUNIT_BINARY_PTR_GE_ASSERTION(test, assert_type, left, right) \ 897 KUNIT_BINARY_PTR_GE_MSG_ASSERTION(test, \ 898 assert_type, \ 899 left, \ 900 right, \ 901 NULL) 902 903 #define KUNIT_BINARY_STR_ASSERTION(test, \ 904 assert_type, \ 905 left, \ 906 op, \ 907 right, \ 908 fmt, \ 909 ...) \ 910 do { \ 911 typeof(left) __left = (left); \ 912 typeof(right) __right = (right); \ 913 \ 914 KUNIT_ASSERTION(test, \ 915 strcmp(__left, __right) op 0, \ 916 kunit_binary_str_assert, \ 917 KUNIT_INIT_BINARY_ASSERT_STRUCT(test, \ 918 assert_type, \ 919 #op, \ 920 #left, \ 921 __left, \ 922 #right, \ 923 __right), \ 924 fmt, \ 925 ##__VA_ARGS__); \ 926 } while (0) 927 928 #define KUNIT_BINARY_STR_EQ_MSG_ASSERTION(test, \ 929 assert_type, \ 930 left, \ 931 right, \ 932 fmt, \ 933 ...) \ 934 KUNIT_BINARY_STR_ASSERTION(test, \ 935 assert_type, \ 936 left, ==, right, \ 937 fmt, \ 938 ##__VA_ARGS__) 939 940 #define KUNIT_BINARY_STR_EQ_ASSERTION(test, assert_type, left, right) \ 941 KUNIT_BINARY_STR_EQ_MSG_ASSERTION(test, \ 942 assert_type, \ 943 left, \ 944 right, \ 945 NULL) 946 947 #define KUNIT_BINARY_STR_NE_MSG_ASSERTION(test, \ 948 assert_type, \ 949 left, \ 950 right, \ 951 fmt, \ 952 ...) \ 953 KUNIT_BINARY_STR_ASSERTION(test, \ 954 assert_type, \ 955 left, !=, right, \ 956 fmt, \ 957 ##__VA_ARGS__) 958 959 #define KUNIT_BINARY_STR_NE_ASSERTION(test, assert_type, left, right) \ 960 KUNIT_BINARY_STR_NE_MSG_ASSERTION(test, \ 961 assert_type, \ 962 left, \ 963 right, \ 964 NULL) 965 966 #define KUNIT_PTR_NOT_ERR_OR_NULL_MSG_ASSERTION(test, \ 967 assert_type, \ 968 ptr, \ 969 fmt, \ 970 ...) \ 971 do { \ 972 typeof(ptr) __ptr = (ptr); \ 973 \ 974 KUNIT_ASSERTION(test, \ 975 !IS_ERR_OR_NULL(__ptr), \ 976 kunit_ptr_not_err_assert, \ 977 KUNIT_INIT_PTR_NOT_ERR_STRUCT(test, \ 978 assert_type, \ 979 #ptr, \ 980 __ptr), \ 981 fmt, \ 982 ##__VA_ARGS__); \ 983 } while (0) 984 985 #define KUNIT_PTR_NOT_ERR_OR_NULL_ASSERTION(test, assert_type, ptr) \ 986 KUNIT_PTR_NOT_ERR_OR_NULL_MSG_ASSERTION(test, \ 987 assert_type, \ 988 ptr, \ 989 NULL) 990 991 /** 992 * KUNIT_EXPECT_TRUE() - Causes a test failure when the expression is not true. 993 * @test: The test context object. 994 * @condition: an arbitrary boolean expression. The test fails when this does 995 * not evaluate to true. 996 * 997 * This and expectations of the form `KUNIT_EXPECT_*` will cause the test case 998 * to fail when the specified condition is not met; however, it will not prevent 999 * the test case from continuing to run; this is otherwise known as an 1000 * *expectation failure*. 1001 */ 1002 #define KUNIT_EXPECT_TRUE(test, condition) \ 1003 KUNIT_TRUE_ASSERTION(test, KUNIT_EXPECTATION, condition) 1004 1005 #define KUNIT_EXPECT_TRUE_MSG(test, condition, fmt, ...) \ 1006 KUNIT_TRUE_MSG_ASSERTION(test, \ 1007 KUNIT_EXPECTATION, \ 1008 condition, \ 1009 fmt, \ 1010 ##__VA_ARGS__) 1011 1012 /** 1013 * KUNIT_EXPECT_FALSE() - Makes a test failure when the expression is not false. 1014 * @test: The test context object. 1015 * @condition: an arbitrary boolean expression. The test fails when this does 1016 * not evaluate to false. 1017 * 1018 * Sets an expectation that @condition evaluates to false. See 1019 * KUNIT_EXPECT_TRUE() for more information. 1020 */ 1021 #define KUNIT_EXPECT_FALSE(test, condition) \ 1022 KUNIT_FALSE_ASSERTION(test, KUNIT_EXPECTATION, condition) 1023 1024 #define KUNIT_EXPECT_FALSE_MSG(test, condition, fmt, ...) \ 1025 KUNIT_FALSE_MSG_ASSERTION(test, \ 1026 KUNIT_EXPECTATION, \ 1027 condition, \ 1028 fmt, \ 1029 ##__VA_ARGS__) 1030 1031 /** 1032 * KUNIT_EXPECT_EQ() - Sets an expectation that @left and @right are equal. 1033 * @test: The test context object. 1034 * @left: an arbitrary expression that evaluates to a primitive C type. 1035 * @right: an arbitrary expression that evaluates to a primitive C type. 1036 * 1037 * Sets an expectation that the values that @left and @right evaluate to are 1038 * equal. This is semantically equivalent to 1039 * KUNIT_EXPECT_TRUE(@test, (@left) == (@right)). See KUNIT_EXPECT_TRUE() for 1040 * more information. 1041 */ 1042 #define KUNIT_EXPECT_EQ(test, left, right) \ 1043 KUNIT_BINARY_EQ_ASSERTION(test, KUNIT_EXPECTATION, left, right) 1044 1045 #define KUNIT_EXPECT_EQ_MSG(test, left, right, fmt, ...) \ 1046 KUNIT_BINARY_EQ_MSG_ASSERTION(test, \ 1047 KUNIT_EXPECTATION, \ 1048 left, \ 1049 right, \ 1050 fmt, \ 1051 ##__VA_ARGS__) 1052 1053 /** 1054 * KUNIT_EXPECT_PTR_EQ() - Expects that pointers @left and @right are equal. 1055 * @test: The test context object. 1056 * @left: an arbitrary expression that evaluates to a pointer. 1057 * @right: an arbitrary expression that evaluates to a pointer. 1058 * 1059 * Sets an expectation that the values that @left and @right evaluate to are 1060 * equal. This is semantically equivalent to 1061 * KUNIT_EXPECT_TRUE(@test, (@left) == (@right)). See KUNIT_EXPECT_TRUE() for 1062 * more information. 1063 */ 1064 #define KUNIT_EXPECT_PTR_EQ(test, left, right) \ 1065 KUNIT_BINARY_PTR_EQ_ASSERTION(test, \ 1066 KUNIT_EXPECTATION, \ 1067 left, \ 1068 right) 1069 1070 #define KUNIT_EXPECT_PTR_EQ_MSG(test, left, right, fmt, ...) \ 1071 KUNIT_BINARY_PTR_EQ_MSG_ASSERTION(test, \ 1072 KUNIT_EXPECTATION, \ 1073 left, \ 1074 right, \ 1075 fmt, \ 1076 ##__VA_ARGS__) 1077 1078 /** 1079 * KUNIT_EXPECT_NE() - An expectation that @left and @right are not equal. 1080 * @test: The test context object. 1081 * @left: an arbitrary expression that evaluates to a primitive C type. 1082 * @right: an arbitrary expression that evaluates to a primitive C type. 1083 * 1084 * Sets an expectation that the values that @left and @right evaluate to are not 1085 * equal. This is semantically equivalent to 1086 * KUNIT_EXPECT_TRUE(@test, (@left) != (@right)). See KUNIT_EXPECT_TRUE() for 1087 * more information. 1088 */ 1089 #define KUNIT_EXPECT_NE(test, left, right) \ 1090 KUNIT_BINARY_NE_ASSERTION(test, KUNIT_EXPECTATION, left, right) 1091 1092 #define KUNIT_EXPECT_NE_MSG(test, left, right, fmt, ...) \ 1093 KUNIT_BINARY_NE_MSG_ASSERTION(test, \ 1094 KUNIT_EXPECTATION, \ 1095 left, \ 1096 right, \ 1097 fmt, \ 1098 ##__VA_ARGS__) 1099 1100 /** 1101 * KUNIT_EXPECT_PTR_NE() - Expects that pointers @left and @right are not equal. 1102 * @test: The test context object. 1103 * @left: an arbitrary expression that evaluates to a pointer. 1104 * @right: an arbitrary expression that evaluates to a pointer. 1105 * 1106 * Sets an expectation that the values that @left and @right evaluate to are not 1107 * equal. This is semantically equivalent to 1108 * KUNIT_EXPECT_TRUE(@test, (@left) != (@right)). See KUNIT_EXPECT_TRUE() for 1109 * more information. 1110 */ 1111 #define KUNIT_EXPECT_PTR_NE(test, left, right) \ 1112 KUNIT_BINARY_PTR_NE_ASSERTION(test, \ 1113 KUNIT_EXPECTATION, \ 1114 left, \ 1115 right) 1116 1117 #define KUNIT_EXPECT_PTR_NE_MSG(test, left, right, fmt, ...) \ 1118 KUNIT_BINARY_PTR_NE_MSG_ASSERTION(test, \ 1119 KUNIT_EXPECTATION, \ 1120 left, \ 1121 right, \ 1122 fmt, \ 1123 ##__VA_ARGS__) 1124 1125 /** 1126 * KUNIT_EXPECT_LT() - An expectation that @left is less than @right. 1127 * @test: The test context object. 1128 * @left: an arbitrary expression that evaluates to a primitive C type. 1129 * @right: an arbitrary expression that evaluates to a primitive C type. 1130 * 1131 * Sets an expectation that the value that @left evaluates to is less than the 1132 * value that @right evaluates to. This is semantically equivalent to 1133 * KUNIT_EXPECT_TRUE(@test, (@left) < (@right)). See KUNIT_EXPECT_TRUE() for 1134 * more information. 1135 */ 1136 #define KUNIT_EXPECT_LT(test, left, right) \ 1137 KUNIT_BINARY_LT_ASSERTION(test, KUNIT_EXPECTATION, left, right) 1138 1139 #define KUNIT_EXPECT_LT_MSG(test, left, right, fmt, ...) \ 1140 KUNIT_BINARY_LT_MSG_ASSERTION(test, \ 1141 KUNIT_EXPECTATION, \ 1142 left, \ 1143 right, \ 1144 fmt, \ 1145 ##__VA_ARGS__) 1146 1147 /** 1148 * KUNIT_EXPECT_LE() - Expects that @left is less than or equal to @right. 1149 * @test: The test context object. 1150 * @left: an arbitrary expression that evaluates to a primitive C type. 1151 * @right: an arbitrary expression that evaluates to a primitive C type. 1152 * 1153 * Sets an expectation that the value that @left evaluates to is less than or 1154 * equal to the value that @right evaluates to. Semantically this is equivalent 1155 * to KUNIT_EXPECT_TRUE(@test, (@left) <= (@right)). See KUNIT_EXPECT_TRUE() for 1156 * more information. 1157 */ 1158 #define KUNIT_EXPECT_LE(test, left, right) \ 1159 KUNIT_BINARY_LE_ASSERTION(test, KUNIT_EXPECTATION, left, right) 1160 1161 #define KUNIT_EXPECT_LE_MSG(test, left, right, fmt, ...) \ 1162 KUNIT_BINARY_LE_MSG_ASSERTION(test, \ 1163 KUNIT_EXPECTATION, \ 1164 left, \ 1165 right, \ 1166 fmt, \ 1167 ##__VA_ARGS__) 1168 1169 /** 1170 * KUNIT_EXPECT_GT() - An expectation that @left is greater than @right. 1171 * @test: The test context object. 1172 * @left: an arbitrary expression that evaluates to a primitive C type. 1173 * @right: an arbitrary expression that evaluates to a primitive C type. 1174 * 1175 * Sets an expectation that the value that @left evaluates to is greater than 1176 * the value that @right evaluates to. This is semantically equivalent to 1177 * KUNIT_EXPECT_TRUE(@test, (@left) > (@right)). See KUNIT_EXPECT_TRUE() for 1178 * more information. 1179 */ 1180 #define KUNIT_EXPECT_GT(test, left, right) \ 1181 KUNIT_BINARY_GT_ASSERTION(test, KUNIT_EXPECTATION, left, right) 1182 1183 #define KUNIT_EXPECT_GT_MSG(test, left, right, fmt, ...) \ 1184 KUNIT_BINARY_GT_MSG_ASSERTION(test, \ 1185 KUNIT_EXPECTATION, \ 1186 left, \ 1187 right, \ 1188 fmt, \ 1189 ##__VA_ARGS__) 1190 1191 /** 1192 * KUNIT_EXPECT_GE() - Expects that @left is greater than or equal to @right. 1193 * @test: The test context object. 1194 * @left: an arbitrary expression that evaluates to a primitive C type. 1195 * @right: an arbitrary expression that evaluates to a primitive C type. 1196 * 1197 * Sets an expectation that the value that @left evaluates to is greater than 1198 * the value that @right evaluates to. This is semantically equivalent to 1199 * KUNIT_EXPECT_TRUE(@test, (@left) >= (@right)). See KUNIT_EXPECT_TRUE() for 1200 * more information. 1201 */ 1202 #define KUNIT_EXPECT_GE(test, left, right) \ 1203 KUNIT_BINARY_GE_ASSERTION(test, KUNIT_EXPECTATION, left, right) 1204 1205 #define KUNIT_EXPECT_GE_MSG(test, left, right, fmt, ...) \ 1206 KUNIT_BINARY_GE_MSG_ASSERTION(test, \ 1207 KUNIT_EXPECTATION, \ 1208 left, \ 1209 right, \ 1210 fmt, \ 1211 ##__VA_ARGS__) 1212 1213 /** 1214 * KUNIT_EXPECT_STREQ() - Expects that strings @left and @right are equal. 1215 * @test: The test context object. 1216 * @left: an arbitrary expression that evaluates to a null terminated string. 1217 * @right: an arbitrary expression that evaluates to a null terminated string. 1218 * 1219 * Sets an expectation that the values that @left and @right evaluate to are 1220 * equal. This is semantically equivalent to 1221 * KUNIT_EXPECT_TRUE(@test, !strcmp((@left), (@right))). See KUNIT_EXPECT_TRUE() 1222 * for more information. 1223 */ 1224 #define KUNIT_EXPECT_STREQ(test, left, right) \ 1225 KUNIT_BINARY_STR_EQ_ASSERTION(test, KUNIT_EXPECTATION, left, right) 1226 1227 #define KUNIT_EXPECT_STREQ_MSG(test, left, right, fmt, ...) \ 1228 KUNIT_BINARY_STR_EQ_MSG_ASSERTION(test, \ 1229 KUNIT_EXPECTATION, \ 1230 left, \ 1231 right, \ 1232 fmt, \ 1233 ##__VA_ARGS__) 1234 1235 /** 1236 * KUNIT_EXPECT_STRNEQ() - Expects that strings @left and @right are not equal. 1237 * @test: The test context object. 1238 * @left: an arbitrary expression that evaluates to a null terminated string. 1239 * @right: an arbitrary expression that evaluates to a null terminated string. 1240 * 1241 * Sets an expectation that the values that @left and @right evaluate to are 1242 * not equal. This is semantically equivalent to 1243 * KUNIT_EXPECT_TRUE(@test, strcmp((@left), (@right))). See KUNIT_EXPECT_TRUE() 1244 * for more information. 1245 */ 1246 #define KUNIT_EXPECT_STRNEQ(test, left, right) \ 1247 KUNIT_BINARY_STR_NE_ASSERTION(test, KUNIT_EXPECTATION, left, right) 1248 1249 #define KUNIT_EXPECT_STRNEQ_MSG(test, left, right, fmt, ...) \ 1250 KUNIT_BINARY_STR_NE_MSG_ASSERTION(test, \ 1251 KUNIT_EXPECTATION, \ 1252 left, \ 1253 right, \ 1254 fmt, \ 1255 ##__VA_ARGS__) 1256 1257 /** 1258 * KUNIT_EXPECT_NOT_ERR_OR_NULL() - Expects that @ptr is not null and not err. 1259 * @test: The test context object. 1260 * @ptr: an arbitrary pointer. 1261 * 1262 * Sets an expectation that the value that @ptr evaluates to is not null and not 1263 * an errno stored in a pointer. This is semantically equivalent to 1264 * KUNIT_EXPECT_TRUE(@test, !IS_ERR_OR_NULL(@ptr)). See KUNIT_EXPECT_TRUE() for 1265 * more information. 1266 */ 1267 #define KUNIT_EXPECT_NOT_ERR_OR_NULL(test, ptr) \ 1268 KUNIT_PTR_NOT_ERR_OR_NULL_ASSERTION(test, KUNIT_EXPECTATION, ptr) 1269 1270 #define KUNIT_EXPECT_NOT_ERR_OR_NULL_MSG(test, ptr, fmt, ...) \ 1271 KUNIT_PTR_NOT_ERR_OR_NULL_MSG_ASSERTION(test, \ 1272 KUNIT_EXPECTATION, \ 1273 ptr, \ 1274 fmt, \ 1275 ##__VA_ARGS__) 1276 1277 #define KUNIT_ASSERT_FAILURE(test, fmt, ...) \ 1278 KUNIT_FAIL_ASSERTION(test, KUNIT_ASSERTION, fmt, ##__VA_ARGS__) 1279 1280 /** 1281 * KUNIT_ASSERT_TRUE() - Sets an assertion that @condition is true. 1282 * @test: The test context object. 1283 * @condition: an arbitrary boolean expression. The test fails and aborts when 1284 * this does not evaluate to true. 1285 * 1286 * This and assertions of the form `KUNIT_ASSERT_*` will cause the test case to 1287 * fail *and immediately abort* when the specified condition is not met. Unlike 1288 * an expectation failure, it will prevent the test case from continuing to run; 1289 * this is otherwise known as an *assertion failure*. 1290 */ 1291 #define KUNIT_ASSERT_TRUE(test, condition) \ 1292 KUNIT_TRUE_ASSERTION(test, KUNIT_ASSERTION, condition) 1293 1294 #define KUNIT_ASSERT_TRUE_MSG(test, condition, fmt, ...) \ 1295 KUNIT_TRUE_MSG_ASSERTION(test, \ 1296 KUNIT_ASSERTION, \ 1297 condition, \ 1298 fmt, \ 1299 ##__VA_ARGS__) 1300 1301 /** 1302 * KUNIT_ASSERT_FALSE() - Sets an assertion that @condition is false. 1303 * @test: The test context object. 1304 * @condition: an arbitrary boolean expression. 1305 * 1306 * Sets an assertion that the value that @condition evaluates to is false. This 1307 * is the same as KUNIT_EXPECT_FALSE(), except it causes an assertion failure 1308 * (see KUNIT_ASSERT_TRUE()) when the assertion is not met. 1309 */ 1310 #define KUNIT_ASSERT_FALSE(test, condition) \ 1311 KUNIT_FALSE_ASSERTION(test, KUNIT_ASSERTION, condition) 1312 1313 #define KUNIT_ASSERT_FALSE_MSG(test, condition, fmt, ...) \ 1314 KUNIT_FALSE_MSG_ASSERTION(test, \ 1315 KUNIT_ASSERTION, \ 1316 condition, \ 1317 fmt, \ 1318 ##__VA_ARGS__) 1319 1320 /** 1321 * KUNIT_ASSERT_EQ() - Sets an assertion that @left and @right are equal. 1322 * @test: The test context object. 1323 * @left: an arbitrary expression that evaluates to a primitive C type. 1324 * @right: an arbitrary expression that evaluates to a primitive C type. 1325 * 1326 * Sets an assertion that the values that @left and @right evaluate to are 1327 * equal. This is the same as KUNIT_EXPECT_EQ(), except it causes an assertion 1328 * failure (see KUNIT_ASSERT_TRUE()) when the assertion is not met. 1329 */ 1330 #define KUNIT_ASSERT_EQ(test, left, right) \ 1331 KUNIT_BINARY_EQ_ASSERTION(test, KUNIT_ASSERTION, left, right) 1332 1333 #define KUNIT_ASSERT_EQ_MSG(test, left, right, fmt, ...) \ 1334 KUNIT_BINARY_EQ_MSG_ASSERTION(test, \ 1335 KUNIT_ASSERTION, \ 1336 left, \ 1337 right, \ 1338 fmt, \ 1339 ##__VA_ARGS__) 1340 1341 /** 1342 * KUNIT_ASSERT_PTR_EQ() - Asserts that pointers @left and @right are equal. 1343 * @test: The test context object. 1344 * @left: an arbitrary expression that evaluates to a pointer. 1345 * @right: an arbitrary expression that evaluates to a pointer. 1346 * 1347 * Sets an assertion that the values that @left and @right evaluate to are 1348 * equal. This is the same as KUNIT_EXPECT_EQ(), except it causes an assertion 1349 * failure (see KUNIT_ASSERT_TRUE()) when the assertion is not met. 1350 */ 1351 #define KUNIT_ASSERT_PTR_EQ(test, left, right) \ 1352 KUNIT_BINARY_PTR_EQ_ASSERTION(test, KUNIT_ASSERTION, left, right) 1353 1354 #define KUNIT_ASSERT_PTR_EQ_MSG(test, left, right, fmt, ...) \ 1355 KUNIT_BINARY_PTR_EQ_MSG_ASSERTION(test, \ 1356 KUNIT_ASSERTION, \ 1357 left, \ 1358 right, \ 1359 fmt, \ 1360 ##__VA_ARGS__) 1361 1362 /** 1363 * KUNIT_ASSERT_NE() - An assertion that @left and @right are not equal. 1364 * @test: The test context object. 1365 * @left: an arbitrary expression that evaluates to a primitive C type. 1366 * @right: an arbitrary expression that evaluates to a primitive C type. 1367 * 1368 * Sets an assertion that the values that @left and @right evaluate to are not 1369 * equal. This is the same as KUNIT_EXPECT_NE(), except it causes an assertion 1370 * failure (see KUNIT_ASSERT_TRUE()) when the assertion is not met. 1371 */ 1372 #define KUNIT_ASSERT_NE(test, left, right) \ 1373 KUNIT_BINARY_NE_ASSERTION(test, KUNIT_ASSERTION, left, right) 1374 1375 #define KUNIT_ASSERT_NE_MSG(test, left, right, fmt, ...) \ 1376 KUNIT_BINARY_NE_MSG_ASSERTION(test, \ 1377 KUNIT_ASSERTION, \ 1378 left, \ 1379 right, \ 1380 fmt, \ 1381 ##__VA_ARGS__) 1382 1383 /** 1384 * KUNIT_ASSERT_PTR_NE() - Asserts that pointers @left and @right are not equal. 1385 * KUNIT_ASSERT_PTR_EQ() - Asserts that pointers @left and @right are equal. 1386 * @test: The test context object. 1387 * @left: an arbitrary expression that evaluates to a pointer. 1388 * @right: an arbitrary expression that evaluates to a pointer. 1389 * 1390 * Sets an assertion that the values that @left and @right evaluate to are not 1391 * equal. This is the same as KUNIT_EXPECT_NE(), except it causes an assertion 1392 * failure (see KUNIT_ASSERT_TRUE()) when the assertion is not met. 1393 */ 1394 #define KUNIT_ASSERT_PTR_NE(test, left, right) \ 1395 KUNIT_BINARY_PTR_NE_ASSERTION(test, KUNIT_ASSERTION, left, right) 1396 1397 #define KUNIT_ASSERT_PTR_NE_MSG(test, left, right, fmt, ...) \ 1398 KUNIT_BINARY_PTR_NE_MSG_ASSERTION(test, \ 1399 KUNIT_ASSERTION, \ 1400 left, \ 1401 right, \ 1402 fmt, \ 1403 ##__VA_ARGS__) 1404 /** 1405 * KUNIT_ASSERT_LT() - An assertion that @left is less than @right. 1406 * @test: The test context object. 1407 * @left: an arbitrary expression that evaluates to a primitive C type. 1408 * @right: an arbitrary expression that evaluates to a primitive C type. 1409 * 1410 * Sets an assertion that the value that @left evaluates to is less than the 1411 * value that @right evaluates to. This is the same as KUNIT_EXPECT_LT(), except 1412 * it causes an assertion failure (see KUNIT_ASSERT_TRUE()) when the assertion 1413 * is not met. 1414 */ 1415 #define KUNIT_ASSERT_LT(test, left, right) \ 1416 KUNIT_BINARY_LT_ASSERTION(test, KUNIT_ASSERTION, left, right) 1417 1418 #define KUNIT_ASSERT_LT_MSG(test, left, right, fmt, ...) \ 1419 KUNIT_BINARY_LT_MSG_ASSERTION(test, \ 1420 KUNIT_ASSERTION, \ 1421 left, \ 1422 right, \ 1423 fmt, \ 1424 ##__VA_ARGS__) 1425 /** 1426 * KUNIT_ASSERT_LE() - An assertion that @left is less than or equal to @right. 1427 * @test: The test context object. 1428 * @left: an arbitrary expression that evaluates to a primitive C type. 1429 * @right: an arbitrary expression that evaluates to a primitive C type. 1430 * 1431 * Sets an assertion that the value that @left evaluates to is less than or 1432 * equal to the value that @right evaluates to. This is the same as 1433 * KUNIT_EXPECT_LE(), except it causes an assertion failure (see 1434 * KUNIT_ASSERT_TRUE()) when the assertion is not met. 1435 */ 1436 #define KUNIT_ASSERT_LE(test, left, right) \ 1437 KUNIT_BINARY_LE_ASSERTION(test, KUNIT_ASSERTION, left, right) 1438 1439 #define KUNIT_ASSERT_LE_MSG(test, left, right, fmt, ...) \ 1440 KUNIT_BINARY_LE_MSG_ASSERTION(test, \ 1441 KUNIT_ASSERTION, \ 1442 left, \ 1443 right, \ 1444 fmt, \ 1445 ##__VA_ARGS__) 1446 1447 /** 1448 * KUNIT_ASSERT_GT() - An assertion that @left is greater than @right. 1449 * @test: The test context object. 1450 * @left: an arbitrary expression that evaluates to a primitive C type. 1451 * @right: an arbitrary expression that evaluates to a primitive C type. 1452 * 1453 * Sets an assertion that the value that @left evaluates to is greater than the 1454 * value that @right evaluates to. This is the same as KUNIT_EXPECT_GT(), except 1455 * it causes an assertion failure (see KUNIT_ASSERT_TRUE()) when the assertion 1456 * is not met. 1457 */ 1458 #define KUNIT_ASSERT_GT(test, left, right) \ 1459 KUNIT_BINARY_GT_ASSERTION(test, KUNIT_ASSERTION, left, right) 1460 1461 #define KUNIT_ASSERT_GT_MSG(test, left, right, fmt, ...) \ 1462 KUNIT_BINARY_GT_MSG_ASSERTION(test, \ 1463 KUNIT_ASSERTION, \ 1464 left, \ 1465 right, \ 1466 fmt, \ 1467 ##__VA_ARGS__) 1468 1469 /** 1470 * KUNIT_ASSERT_GE() - Assertion that @left is greater than or equal to @right. 1471 * @test: The test context object. 1472 * @left: an arbitrary expression that evaluates to a primitive C type. 1473 * @right: an arbitrary expression that evaluates to a primitive C type. 1474 * 1475 * Sets an assertion that the value that @left evaluates to is greater than the 1476 * value that @right evaluates to. This is the same as KUNIT_EXPECT_GE(), except 1477 * it causes an assertion failure (see KUNIT_ASSERT_TRUE()) when the assertion 1478 * is not met. 1479 */ 1480 #define KUNIT_ASSERT_GE(test, left, right) \ 1481 KUNIT_BINARY_GE_ASSERTION(test, KUNIT_ASSERTION, left, right) 1482 1483 #define KUNIT_ASSERT_GE_MSG(test, left, right, fmt, ...) \ 1484 KUNIT_BINARY_GE_MSG_ASSERTION(test, \ 1485 KUNIT_ASSERTION, \ 1486 left, \ 1487 right, \ 1488 fmt, \ 1489 ##__VA_ARGS__) 1490 1491 /** 1492 * KUNIT_ASSERT_STREQ() - An assertion that strings @left and @right are equal. 1493 * @test: The test context object. 1494 * @left: an arbitrary expression that evaluates to a null terminated string. 1495 * @right: an arbitrary expression that evaluates to a null terminated string. 1496 * 1497 * Sets an assertion that the values that @left and @right evaluate to are 1498 * equal. This is the same as KUNIT_EXPECT_STREQ(), except it causes an 1499 * assertion failure (see KUNIT_ASSERT_TRUE()) when the assertion is not met. 1500 */ 1501 #define KUNIT_ASSERT_STREQ(test, left, right) \ 1502 KUNIT_BINARY_STR_EQ_ASSERTION(test, KUNIT_ASSERTION, left, right) 1503 1504 #define KUNIT_ASSERT_STREQ_MSG(test, left, right, fmt, ...) \ 1505 KUNIT_BINARY_STR_EQ_MSG_ASSERTION(test, \ 1506 KUNIT_ASSERTION, \ 1507 left, \ 1508 right, \ 1509 fmt, \ 1510 ##__VA_ARGS__) 1511 1512 /** 1513 * KUNIT_ASSERT_STRNEQ() - Expects that strings @left and @right are not equal. 1514 * @test: The test context object. 1515 * @left: an arbitrary expression that evaluates to a null terminated string. 1516 * @right: an arbitrary expression that evaluates to a null terminated string. 1517 * 1518 * Sets an expectation that the values that @left and @right evaluate to are 1519 * not equal. This is semantically equivalent to 1520 * KUNIT_ASSERT_TRUE(@test, strcmp((@left), (@right))). See KUNIT_ASSERT_TRUE() 1521 * for more information. 1522 */ 1523 #define KUNIT_ASSERT_STRNEQ(test, left, right) \ 1524 KUNIT_BINARY_STR_NE_ASSERTION(test, KUNIT_ASSERTION, left, right) 1525 1526 #define KUNIT_ASSERT_STRNEQ_MSG(test, left, right, fmt, ...) \ 1527 KUNIT_BINARY_STR_NE_MSG_ASSERTION(test, \ 1528 KUNIT_ASSERTION, \ 1529 left, \ 1530 right, \ 1531 fmt, \ 1532 ##__VA_ARGS__) 1533 1534 /** 1535 * KUNIT_ASSERT_NOT_ERR_OR_NULL() - Assertion that @ptr is not null and not err. 1536 * @test: The test context object. 1537 * @ptr: an arbitrary pointer. 1538 * 1539 * Sets an assertion that the value that @ptr evaluates to is not null and not 1540 * an errno stored in a pointer. This is the same as 1541 * KUNIT_EXPECT_NOT_ERR_OR_NULL(), except it causes an assertion failure (see 1542 * KUNIT_ASSERT_TRUE()) when the assertion is not met. 1543 */ 1544 #define KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr) \ 1545 KUNIT_PTR_NOT_ERR_OR_NULL_ASSERTION(test, KUNIT_ASSERTION, ptr) 1546 1547 #define KUNIT_ASSERT_NOT_ERR_OR_NULL_MSG(test, ptr, fmt, ...) \ 1548 KUNIT_PTR_NOT_ERR_OR_NULL_MSG_ASSERTION(test, \ 1549 KUNIT_ASSERTION, \ 1550 ptr, \ 1551 fmt, \ 1552 ##__VA_ARGS__) 1553 1554 #endif /* _KUNIT_TEST_H */ 1555