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