include/kunit/test.h

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