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