kunit: introduce KUnit, the Linux kernel unit testing framework
Subsystems (9)
cover kunit: introduce KUnit, the Linux kernel unit testing framework
This patch set proposes KUnit, a lightweight unit testing and mocking framework for the Linux kernel.
Unlike Autotest and kselftest, KUnit is a true unit testing framework; it does not require installing the kernel on a test machine or in a VM and does not require tests to be written in userspace running on a host kernel. Additionally, KUnit is fast: From invocation to completion KUnit can run several dozen tests in under a second. Currently, the entire KUnit test suite for KUnit runs in under a second from the initial invocation (build time excluded).
KUnit is heavily inspired by JUnit, Python's unittest.mock, and Googletest/Googlemock for C++. KUnit provides facilities for defining unit test cases, grouping related test cases into test suites, providing common infrastructure for running tests, mocking, spying, and much more.
## What's so special about unit testing?
A unit test is supposed to test a single unit of code in isolation, hence the name. There should be no dependencies outside the control of the test; this means no external dependencies, which makes tests orders of magnitudes faster. Likewise, since there are no external dependencies, there are no hoops to jump through to run the tests. Additionally, this makes unit tests deterministic: a failing unit test always indicates a problem. Finally, because unit tests necessarily have finer granularity, they are able to test all code paths easily solving the classic problem of difficulty in exercising error handling code.
## Is KUnit trying to replace other testing frameworks for the kernel?
No. Most existing tests for the Linux kernel are end-to-end tests, which have their place. A well tested system has lots of unit tests, a reasonable number of integration tests, and some end-to-end tests. KUnit is just trying to address the unit test space which is currently not being addressed.
## More information on KUnit
There is a bunch of documentation near the end of this patch set that describes how to use KUnit and best practices for writing unit tests. For convenience I am hosting the compiled docs here:
https://google.github.io/kunit-docs/third_party/kernel/docs/
Additionally for convenience, I have applied these patches to a branch:
https://kunit.googlesource.com/linux/+/kunit/rfc/v5.1-rc2/v1
The repo may be cloned with:
git clone https://kunit.googlesource.com/linux
This patchset is on the kunit/rfc/v5.1-rc2/v1 branch.
## Changes Since Last Version
Last version was RFC v4. It seemed we were pretty much done with the RFC phase, so I started the numbering over again. Sorry if anyone finds that confusing.
- Reduced usage of object oriented style of member functions as suggested by Frank.
- Did a bunch of heavy clean up of the kunit_abort stuff as suggested by Frank and Stephen:
- Biggest change was to reduce the usage of direct calls of member functions.
- Added a better explanation of what abort is for and further explained the rationale for KUNIT_ASSERT_* vs. KUNIT_EXPECT_*
- Dropped BUG() usage
- Also moved try_catch interface to a new file since it seemed obscured by being mixed in with the code that used it.
- Fixed some other minor issues pointed out by Stephen.
- Updated email address of one of the contributors.
- Dropped DT unittest port since it seemed like there was a lot more discussion to be had: it wasn't ready to leave the RFC phase. Instead, I added a KUnit test written by Iurii for PROC SYSCTL that was requested by Luis some time ago.
For reference, RFC v4 can be found here:
https://lkml.org/lkml/2019/2/14/1144
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH 1/17 kunit: test: add KUnit test runner core
Add core facilities for defining unit tests; this provides a common way to define test cases, functions that execute code which is under test and determine whether the code under test behaves as expected; this also provides a way to group together related test cases in test suites (here we call them test_modules).
Just define test cases and how to execute them for now; setting expectations on code will be defined later.
--- include/kunit/test.h | 165 ++++++++++++++++++++++++++++++++++++++++++ kunit/Kconfig | 16 +++++ kunit/Makefile | 1 + kunit/test.c | 168 +++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 350 insertions(+) create mode 100644 include/kunit/test.h create mode 100644 kunit/Kconfig create mode 100644 kunit/Makefile create mode 100644 kunit/test.c
include/kunit/test.h new file +165 -0
@@ -0,0 +1,165 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Base unit test (KUnit) API. + * + * Copyright (C) 2019, Google LLC. + * Author: Brendan Higgins <[email protected]> + */ + +#ifndef _KUNIT_TEST_H +#define _KUNIT_TEST_H + +#include <linux/types.h> +#include <linux/slab.h> + +struct kunit; + +/** + * struct kunit_case - represents an individual test case. + * @run_case: the function representing the actual test case. + * @name: the name of the test case. + * + * A test case is a function with the signature, ``void (*)(struct kunit *)`` + * that makes expectations (see KUNIT_EXPECT_TRUE()) about code under test. Each + * test case is associated with a &struct kunit_module and will be run after the + * module's init function and followed by the module's exit function. + * + * A test case should be static and should only be created with the KUNIT_CASE() + * macro; additionally, every array of test cases should be terminated with an + * empty test case. + * + * Example: + * + * .. code-block:: c + * + * void add_test_basic(struct kunit *test) + * { + * KUNIT_EXPECT_EQ(test, 1, add(1, 0)); + * KUNIT_EXPECT_EQ(test, 2, add(1, 1)); + * KUNIT_EXPECT_EQ(test, 0, add(-1, 1)); + * KUNIT_EXPECT_EQ(test, INT_MAX, add(0, INT_MAX)); + * KUNIT_EXPECT_EQ(test, -1, add(INT_MAX, INT_MIN)); + * } + * + * static struct kunit_case example_test_cases[] = { + * KUNIT_CASE(add_test_basic), + * {}, + * }; + * + */ +struct kunit_case { + void (*run_case)(struct kunit *test); + const char name[256]; + + /* private: internal use only. */ + bool success; +}; + +/** + * KUNIT_CASE - A helper for creating a &struct kunit_case + * @test_name: a reference to a test case function. + * + * Takes a symbol for a function representing a test case and creates a + * &struct kunit_case object from it. See the documentation for + * &struct kunit_case for an example on how to use it. + */ +#define KUNIT_CASE(test_name) { .run_case = test_name, .name = #test_name } + +/** + * struct kunit_module - describes a related collection of &struct kunit_case s. + * @name: the name of the test. Purely informational. + * @init: called before every test case. + * @exit: called after every test case. + * @test_cases: a null terminated array of test cases. + * + * A kunit_module is a collection of related &struct kunit_case s, such that + * @init is called before every test case and @exit is called after every test + * case, similar to the notion of a *test fixture* or a *test class* in other + * unit testing frameworks like JUnit or Googletest. + * + * Every &struct kunit_case must be associated with a kunit_module for KUnit to + * run it. + */ +struct kunit_module { + const char name[256]; + int (*init)(struct kunit *test); + void (*exit)(struct kunit *test); + struct kunit_case *test_cases; +}; + +/** + * struct kunit - represents a running instance of a test. + * @priv: for user to store arbitrary data. Commonly used to pass data created + * in the init function (see &struct kunit_module). + * + * Used to store information about the current context under which the test is + * running. Most of this data is private and should only be accessed indirectly + * via public functions; the one exception is @priv which can be used by the + * test writer to store arbitrary data. + */ +struct kunit { + void *priv; + + /* private: internal use only. */ + const char *name; /* Read only after initialization! */ + spinlock_t lock; /* Gaurds all mutable test state. */ + bool success; /* Protected by lock. */ + void (*vprintk)(const struct kunit *test, + const char *level, + struct va_format *vaf); +}; + +int kunit_init_test(struct kunit *test, const char *name); + +int kunit_run_tests(struct kunit_module *module); + +/** + * module_test() - used to register a &struct kunit_module with KUnit. + * @module: a statically allocated &struct kunit_module. + * + * Registers @module with the test framework. See &struct kunit_module for more + * information. + */ +#define module_test(module) \ + static int module_kunit_init##module(void) \ + { \ + return kunit_run_tests(&module); \ + } \ + late_initcall(module_kunit_init##module) + +void __printf(3, 4) kunit_printk(const char *level, + const struct kunit *test, + const char *fmt, ...); + +/** + * kunit_info() - Prints an INFO level message associated with the current test. + * @test: The test context object. + * @fmt: A printk() style format string. + * + * Prints an info level message associated with the test module being run. Takes + * a variable number of format parameters just like printk(). + */ +#define kunit_info(test, fmt, ...) \ + kunit_printk(KERN_INFO, test, fmt, ##__VA_ARGS__) + +/** + * kunit_warn() - Prints a WARN level message associated with the current test. + * @test: The test context object. + * @fmt: A printk() style format string. + * + * See kunit_info(). + */ +#define kunit_warn(test, fmt, ...) \ + kunit_printk(KERN_WARNING, test, fmt, ##__VA_ARGS__) + +/** + * kunit_err() - Prints an ERROR level message associated with the current test. + * @test: The test context object. + * @fmt: A printk() style format string. + * + * See kunit_info(). + */ +#define kunit_err(test, fmt, ...) \ + kunit_printk(KERN_ERR, test, fmt, ##__VA_ARGS__) + +#endif /* _KUNIT_TEST_H */
kunit/Kconfig new file +16 -0
@@ -0,0 +1,16 @@ +# +# KUnit base configuration +# + +menu "KUnit support" + +config KUNIT + bool "Enable support for unit tests (KUnit)" + help + Enables support for kernel unit tests (KUnit), a lightweight unit + testing and mocking framework for the Linux kernel. These tests are + able to be run locally on a developer's workstation without a VM or + special hardware. For more information, please see + Documentation/kunit/ + +endmenu
kunit/Makefile new file +1 -0
@@ -0,0 +1 @@ +obj-$(CONFIG_KUNIT) += test.o
kunit/test.c new file +168 -0
168 lines not on this page · raw message
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH 2/17 kunit: test: add test resource management API
In reply to Brendan HigginsCreate a common API for test managed resources like memory and test objects. A lot of times a test will want to set up infrastructure to be used in test cases; this could be anything from just wanting to allocate some memory to setting up a driver stack; this defines facilities for creating "test resources" which are managed by the test infrastructure and are automatically cleaned up at the conclusion of the test.
--- include/kunit/test.h | 109 +++++++++++++++++++++++++++++++++++++++++++ kunit/test.c | 95 +++++++++++++++++++++++++++++++++++++ 2 files changed, 204 insertions(+)
include/kunit/test.h +109 -0
@@ -12,6 +12,69 @@#include <linux/types.h> #include <linux/slab.h> +struct kunit_resource ; + +typedef int (*kunit_resource_init_t )(struct kunit_resource *,void *); +typedef void (*kunit_resource_free_t )(struct kunit_resource *); + +/** +* struct kunit_resource - represents a *test managed resource* +* @allocation: for the user to store arbitrary data. +* @free: a user supplied function to free the resource. Populated by +* kunit_alloc_resource(). +* +* Represents a *test managed resource*, a resource which will automatically be +* cleaned up at the end of a test case. +* +* Example: +* +* .. code-block:: c +* +* struct kunit_kmalloc_params { +* size_t size; +* gfp_t gfp; +* }; +* +* static int kunit_kmalloc_init(struct kunit_resource *res, void *context) +* { +* struct kunit_kmalloc_params *params = context; +* res->allocation = kmalloc(params->size, params->gfp); +* +* if (!res->allocation) +* return -ENOMEM; +* +* return 0; +* } +* +* static void kunit_kmalloc_free(struct kunit_resource *res) +* { +* kfree(res->allocation); +* } +* +* void *kunit_kmalloc(struct kunit *test, size_t size, gfp_t gfp) +* { +* struct kunit_kmalloc_params params; +* struct kunit_resource *res; +* +* params.size = size; +* params.gfp = gfp; +* +* res = kunit_alloc_resource(test, kunit_kmalloc_init, +* kunit_kmalloc_free, ¶ms); +* if (res) +* return res->allocation; +* else +* return NULL; +* } +*/ +struct kunit_resource { +void *allocation; +kunit_resource_free_t free; + +/* private: internal use only. */ +struct list_head node; +}; +struct kunit ;/**
@@ -104,6 +167,7 @@ struct kunit {const char *name;/* Read only after initialization! */ spinlock_t lock;/* Gaurds all mutable test state. */ bool success;/* Protected by lock. */ +struct list_head resources;/* Protected by lock. */ void (*vprintk)(const struct kunit *test,const char *level,struct va_format *vaf);
@@ -127,6 +191,51 @@ int kunit_run_tests(struct kunit_module *module); } \ late_initcall(module_kunit_init##module) +/** +* kunit_alloc_resource() - Allocates a *test managed resource*. +* @test: The test context object. +* @init: a user supplied function to initialize the resource. +* @free: a user supplied function to free the resource. +* @context: for the user to pass in arbitrary data to the init function. +* +* Allocates a *test managed resource*, a resource which will automatically be +* cleaned up at the end of a test case. See &struct kunit_resource for an +* example. +*/ +struct kunit_resource *kunit_alloc_resource (struct kunit *test, +kunit_resource_init_t init, +kunit_resource_free_t free, +void *context); + +void kunit_free_resource (struct kunit *test,struct kunit_resource *res); + +/** +* kunit_kmalloc() - Like kmalloc() except the allocation is *test managed*. +* @test: The test context object. +* @size: The size in bytes of the desired memory. +* @gfp: flags passed to underlying kmalloc(). +* +* Just like `kmalloc(...)`, except the allocation is managed by the test case +* and is automatically cleaned up after the test case concludes. See &struct +* kunit_resource for more information. +*/ +void *kunit_kmalloc (struct kunit *test,size_t size,gfp_t gfp); + +/** +* kunit_kzalloc() - Just like kunit_kmalloc(), but zeroes the allocation. +* @test: The test context object. +* @size: The size in bytes of the desired memory. +* @gfp: flags passed to underlying kmalloc(). +* +* See kzalloc() and kunit_kmalloc() for more information. +*/ +static inline void *kunit_kzalloc (struct kunit *test,size_t size,gfp_t gfp) +{ +return kunit_kmalloc (test, size, gfp | __GFP_ZERO); +} + +void kunit_cleanup (struct kunit *test); + void __printf(3, 4) kunit_printk(const char *level, const struct kunit *test, const char *fmt, ...);
kunit/test.c +95 -0
119 lines not on this page · raw message
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH 3/17 kunit: test: add string_stream a std::stream like string builder
In reply to Brendan HigginsA number of test features need to do pretty complicated string printing where it may not be possible to rely on a single preallocated string with parameters.
So provide a library for constructing the string as you go similar to C++'s std::string.
--- include/kunit/string-stream.h | 51 ++++++++++++ kunit/Makefile | 3 +- kunit/string-stream.c | 144 ++++++++++++++++++++++++++++++++++ 3 files changed, 197 insertions(+), 1 deletion(-) create mode 100644 include/kunit/string-stream.h create mode 100644 kunit/string-stream.c
include/kunit/string-stream.h new file +51 -0
@@ -0,0 +1,51 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* C++ stream style string builder used in KUnit for building messages. +* +* Copyright (C) 2019, Google LLC. +* Author: Brendan Higgins <[email protected]> +*/ + +#ifndef _KUNIT_STRING_STREAM_H +#define _KUNIT_STRING_STREAM_H + +#include <linux/types.h> +#include <linux/spinlock.h> +#include <linux/kref.h> +#include <stdarg.h> + +struct string_stream_fragment { +struct list_head node; +char *fragment; +}; + +struct string_stream { +size_t length; +struct list_head fragments; + +/* length and fragments are protected by this lock */ +spinlock_t lock; +struct kref refcount; +}; + +struct string_stream *new_string_stream (void ); + +void destroy_string_stream (struct string_stream *stream); + +void string_stream_get (struct string_stream *stream); + +int string_stream_put (struct string_stream *stream); + +int string_stream_add (struct string_stream *this,const char *fmt, ...); + +int string_stream_vadd (struct string_stream *this, +const char *fmt, +va_list args); + +char *string_stream_get_string (struct string_stream *this); + +void string_stream_clear (struct string_stream *this); + +bool string_stream_is_empty (struct string_stream *this); + +#endif /* _KUNIT_STRING_STREAM_H */
kunit/Makefile +2 -1
@@ -1 +1,2 @@ -obj-$(CONFIG_KUNIT) += test.o +obj-$(CONFIG_KUNIT) += test.o \ + string-stream.o
kunit/string-stream.c new file +144 -0
144 lines not on this page · raw message
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH 4/17 kunit: test: add kunit_stream a std::stream like logger
In reply to Brendan HigginsA lot of the expectation and assertion infrastructure prints out fairly complicated test failure messages, so add a C++ style log library for for logging test results.
--- include/kunit/kunit-stream.h | 85 ++++++++++++++++++++ include/kunit/test.h | 2 + kunit/Makefile | 3 +- kunit/kunit-stream.c | 149 +++++++++++++++++++++++++++++++++++ kunit/test.c | 8 ++ 5 files changed, 246 insertions(+), 1 deletion(-) create mode 100644 include/kunit/kunit-stream.h create mode 100644 kunit/kunit-stream.c
include/kunit/kunit-stream.h new file +85 -0
@@ -0,0 +1,85 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* C++ stream style string formatter and printer used in KUnit for outputting +* KUnit messages. +* +* Copyright (C) 2019, Google LLC. +* Author: Brendan Higgins <[email protected]> +*/ + +#ifndef _KUNIT_KUNIT_STREAM_H +#define _KUNIT_KUNIT_STREAM_H + +#include <linux/types.h> +#include <kunit/string-stream.h> + +struct kunit ; + +/** +* struct kunit_stream - a std::stream style string builder. +* +* A std::stream style string builder. Allows messages to be built up and +* printed all at once. +*/ +struct kunit_stream { +/* private: internal use only. */ +struct kunit *test; +spinlock_t lock;/* Guards level. */ +const char *level; +struct string_stream *internal_stream; +}; + +/** +* kunit_new_stream() - constructs a new &struct kunit_stream. +* @test: The test context object. +* +* Constructs a new test managed &struct kunit_stream. +*/ +struct kunit_stream *kunit_new_stream (struct kunit *test); + +/** +* kunit_stream_set_level(): sets the level that string should be printed at. +* @this: the stream being operated on. +* @level: the print level the stream is set to output to. +* +* Sets the print level at which the stream outputs. +*/ +void kunit_stream_set_level (struct kunit_stream *this,const char *level); + +/** +* kunit_stream_add(): adds the formatted input to the internal buffer. +* @this: the stream being operated on. +* @fmt: printf style format string to append to stream. +* +* Appends the formatted string, @fmt, to the internal buffer. +*/ +void __printf(2, 3) kunit_stream_add(struct kunit_stream *this, + const char *fmt, ...); + +/** + * kunit_stream_append(): appends the contents of @other to @this. + * @this: the stream to which @other is appended. + * @other: the stream whose contents are appended to @this. + * + * Appends the contents of @other to @this. + */ +void kunit_stream_append(struct kunit_stream *this, struct kunit_stream *other); + +/** + * kunit_stream_commit(): prints out the internal buffer to the user. + * @this: the stream being operated on. + * + * Outputs the contents of the internal buffer as a kunit_printk formatted + * output. + */ +void kunit_stream_commit(struct kunit_stream *this); + +/** + * kunit_stream_clear(): clears the internal buffer. + * @this: the stream being operated on. + * + * Clears the contents of the internal buffer. + */ +void kunit_stream_clear(struct kunit_stream *this); + +#endif /* _KUNIT_KUNIT_STREAM_H */
include/kunit/test.h +2 -0
@@ -11,6 +11,7 @@#include <linux/types.h> #include <linux/slab.h> +#include <kunit/kunit-stream.h> struct kunit_resource ;
@@ -171,6 +172,7 @@ struct kunit {void (*vprintk)(const struct kunit *test,const char *level,struct va_format *vaf); +void (*fail)(struct kunit *test,struct kunit_stream *stream); };int kunit_init_test (struct kunit *test,const char *name);
kunit/Makefile +2 -1
@@ -1,2 +1,3 @@ obj-$(CONFIG_KUNIT) += test.o \ - string-stream.o + string-stream.o \ + kunit-stream.o
kunit/kunit-stream.c new file +149 -0
149 lines not on this page · raw message
kunit/test.c +8 -0
@@ -63,12 +63,20 @@ static void kunit_vprintk(const struct kunit *test, "kunit %s: %pV", test->name, vaf); } +static void kunit_fail (struct kunit *test,struct kunit_stream *stream) +{ +kunit_set_success (test, false); +kunit_stream_set_level (stream,KERN_ERR ); +kunit_stream_commit (stream); +} +int kunit_init_test (struct kunit *test,const char *name) {spin_lock_init (&test->lock);INIT_LIST_HEAD (&test->resources); test->name = name; test->vprintk = kunit_vprintk; + test->fail = kunit_fail;return 0 ; }
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH 5/17 kunit: test: add the concept of expectations
In reply to Brendan HigginsAdd support for expectations, which allow properties to be specified and then verified in tests.
--- include/kunit/test.h | 419 +++++++++++++++++++++++++++++++++++++++++++ kunit/test.c | 34 ++++ 2 files changed, 453 insertions(+)
include/kunit/test.h +419 -0
@@ -273,4 +273,423 @@ void __printf(3, 4) kunit_printk(const char *level,#define kunit_err (test, fmt, ...) \ kunit_printk(KERN_ERR, test, fmt, ##__VA_ARGS__) +static inline struct kunit_stream *kunit_expect_start (struct kunit *test, +const char *file, +const char *line) +{ +struct kunit_stream *stream =kunit_new_stream (test); + +kunit_stream_add (stream,"EXPECTATION FAILED at %s:%s\n\t" , file, line); + +return stream; +} + +static inline void kunit_expect_end (struct kunit *test, +bool success, +struct kunit_stream *stream) +{ +if (!success) + test->fail (test, stream); +else +kunit_stream_clear (stream); +} + +#define KUNIT_EXPECT_START (test) \ + kunit_expect_start(test, __FILE__, __stringify(__LINE__)) + +#define KUNIT_EXPECT_END (test, success, stream) \ + kunit_expect_end(test, success, stream) + +#define KUNIT_EXPECT_MSG (test, success, message, fmt, ...) do { \ + struct kunit_stream *__stream = KUNIT_EXPECT_START(test); \ + \ + kunit_stream_add(__stream, message); \ + kunit_stream_add(__stream, fmt, ##__VA_ARGS__); \ + KUNIT_EXPECT_END(test, success, __stream); \ +} while (0) + +#define KUNIT_EXPECT (test, success, message) do { \ + struct kunit_stream *__stream = KUNIT_EXPECT_START(test); \ + \ + kunit_stream_add(__stream, message); \ + KUNIT_EXPECT_END(test, success, __stream); \ +} while (0) + +/** +* KUNIT_SUCCEED() - A no-op expectation. Only exists for code clarity. +* @test: The test context object. +* +* The opposite of KUNIT_FAIL(), it is an expectation that cannot fail. In other +* words, it does nothing and only exists for code clarity. See +* KUNIT_EXPECT_TRUE() for more information. +*/ +#define KUNIT_SUCCEED (test) do {} while (0) + +/** +* KUNIT_FAIL() - Always causes a test to fail when evaluated. +* @test: The test context object. +* @fmt: an informational message to be printed when the assertion is made. +* @...: string format arguments. +* +* The opposite of KUNIT_SUCCEED(), it is an expectation that always fails. In +* other words, it always results in a failed expectation, and consequently +* always causes the test case to fail when evaluated. See KUNIT_EXPECT_TRUE() +* for more information. +*/ +#define KUNIT_FAIL (test, fmt, ...) do { \ + struct kunit_stream *__stream = KUNIT_EXPECT_START(test); \ + \ + kunit_stream_add(__stream, fmt, ##__VA_ARGS__); \ + KUNIT_EXPECT_END(test, false, __stream); \ +} while (0) + +/** +* KUNIT_EXPECT_TRUE() - Causes a test failure when the expression is not true. +* @test: The test context object. +* @condition: an arbitrary boolean expression. The test fails when this does +* not evaluate to true. +* +* This and expectations of the form `KUNIT_EXPECT_*` will cause the test case +* to fail when the specified condition is not met; however, it will not prevent +* the test case from continuing to run; this is otherwise known as an +* *expectation failure*. +*/ +#define KUNIT_EXPECT_TRUE (test, condition) \ + KUNIT_EXPECT(test, (condition), \ + "Expected " #condition " is true, but is false.\n") + +#define KUNIT_EXPECT_TRUE_MSG (test, condition, fmt, ...) \ + KUNIT_EXPECT_MSG(test, (condition), \ + "Expected " #condition " is true, but is false.\n",\ + fmt, ##__VA_ARGS__) + +/** +* KUNIT_EXPECT_FALSE() - Makes a test failure when the expression is not false. +* @test: The test context object. +* @condition: an arbitrary boolean expression. The test fails when this does +* not evaluate to false. +* +* Sets an expectation that @condition evaluates to false. See +* KUNIT_EXPECT_TRUE() for more information. +*/ +#define KUNIT_EXPECT_FALSE (test, condition) \ + KUNIT_EXPECT(test, !(condition), \ + "Expected " #condition " is false, but is true.") + +#define KUNIT_EXPECT_FALSE_MSG (test, condition, fmt, ...) \ + KUNIT_EXPECT_MSG(test, !(condition), \ + "Expected " #condition " is false, but is true.\n",\ + fmt, ##__VA_ARGS__) + +void kunit_expect_binary_msg (struct kunit *test, +long long left,const char *left_name, +long long right,const char *right_name, +bool compare_result, +const char *compare_name, +const char *file, +const char *line, +const char *fmt, ...); + +static inline void kunit_expect_binary (struct kunit *test, +long long left,const char *left_name, +long long right,const char *right_name, +bool compare_result, +const char *compare_name, +const char *file, +const char *line) +{ +struct kunit_stream *stream =kunit_expect_start (test, file, line); + +kunit_stream_add (stream, +"Expected %s %s %s, but\n" , + left_name, compare_name, right_name); +kunit_stream_add (stream,"\t\t%s == %lld\n" , left_name, left); +kunit_stream_add (stream,"\t\t%s == %lld\n" , right_name, right); + +kunit_expect_end (test, compare_result, stream); +} + +/* +* A factory macro for defining the expectations for the basic comparisons +* defined for the built in types. +* +* Unfortunately, there is no common type that all types can be promoted to for +* which all the binary operators behave the same way as for the actual types +* (for example, there is no type that long long and unsigned long long can +* both be cast to where the comparison result is preserved for all values). So +* the best we can do is do the comparison in the original types and then coerce +* everything to long long for printing; this way, the comparison behaves +* correctly and the printed out value usually makes sense without +* interpretation, but can always be interpretted to figure out the actual +* value. +*/ +#define KUNIT_EXPECT_BINARY (test, left, condition, right) do { \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + kunit_expect_binary(test, \ + (long long) __left, #left, \ + (long long) __right, #right, \ + __left condition __right, #condition, \ + __FILE__, __stringify(__LINE__)); \ +} while (0) + +#define KUNIT_EXPECT_BINARY_MSG (test, left, condition, right, fmt, ...) do { \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + kunit_expect_binary_msg(test, \ + (long long) __left, #left, \ + (long long) __right, #right, \ + __left condition __right, #condition, \ + __FILE__, __stringify(__LINE__), \ + fmt, ##__VA_ARGS__); \ +} while (0) + +/** +* KUNIT_EXPECT_EQ() - Sets an expectation that @left and @right are equal. +* @test: The test context object. +* @left: an arbitrary expression that evaluates to a primitive C type. +* @right: an arbitrary expression that evaluates to a primitive C type. +* +* Sets an expectation that the values that @left and @right evaluate to are +* equal. This is semantically equivalent to +* KUNIT_EXPECT_TRUE(@test, (@left) == (@right)). See KUNIT_EXPECT_TRUE() for +* more information. +*/ +#define KUNIT_EXPECT_EQ (test, left, right) \ + KUNIT_EXPECT_BINARY(test, left, ==, right) + +#define KUNIT_EXPECT_EQ_MSG (test, left, right, fmt, ...) \ + KUNIT_EXPECT_BINARY_MSG(test, \ + left, \ + ==, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** +* KUNIT_EXPECT_NE() - An expectation that @left and @right are not equal. +* @test: The test context object. +* @left: an arbitrary expression that evaluates to a primitive C type. +* @right: an arbitrary expression that evaluates to a primitive C type. +* +* Sets an expectation that the values that @left and @right evaluate to are not +* equal. This is semantically equivalent to +* KUNIT_EXPECT_TRUE(@test, (@left) != (@right)). See KUNIT_EXPECT_TRUE() for +* more information. +*/ +#define KUNIT_EXPECT_NE (test, left, right) \ + KUNIT_EXPECT_BINARY(test, left, !=, right) + +#define KUNIT_EXPECT_NE_MSG (test, left, right, fmt, ...) \ + KUNIT_EXPECT_BINARY_MSG(test, \ + left, \ + !=, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** +* KUNIT_EXPECT_LT() - An expectation that @left is less than @right. +* @test: The test context object. +* @left: an arbitrary expression that evaluates to a primitive C type. +* @right: an arbitrary expression that evaluates to a primitive C type. +* +* Sets an expectation that the value that @left evaluates to is less than the +* value that @right evaluates to. This is semantically equivalent to +* KUNIT_EXPECT_TRUE(@test, (@left) < (@right)). See KUNIT_EXPECT_TRUE() for +* more information. +*/ +#define KUNIT_EXPECT_LT (test, left, right) \ + KUNIT_EXPECT_BINARY(test, left, <, right) + +#define KUNIT_EXPECT_LT_MSG (test, left, right, fmt, ...) \ + KUNIT_EXPECT_BINARY_MSG(test, \ + left, \ + <, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** +* KUNIT_EXPECT_LE() - Expects that @left is less than or equal to @right. +* @test: The test context object. +* @left: an arbitrary expression that evaluates to a primitive C type. +* @right: an arbitrary expression that evaluates to a primitive C type. +* +* Sets an expectation that the value that @left evaluates to is less than or +* equal to the value that @right evaluates to. Semantically this is equivalent +* to KUNIT_EXPECT_TRUE(@test, (@left) <= (@right)). See KUNIT_EXPECT_TRUE() for +* more information. +*/ +#define KUNIT_EXPECT_LE (test, left, right) \ + KUNIT_EXPECT_BINARY(test, left, <=, right) + +#define KUNIT_EXPECT_LE_MSG (test, left, right, fmt, ...) \ + KUNIT_EXPECT_BINARY_MSG(test, \ + left, \ + <=, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** +* KUNIT_EXPECT_GT() - An expectation that @left is greater than @right. +* @test: The test context object. +* @left: an arbitrary expression that evaluates to a primitive C type. +* @right: an arbitrary expression that evaluates to a primitive C type. +* +* Sets an expectation that the value that @left evaluates to is greater than +* the value that @right evaluates to. This is semantically equivalent to +* KUNIT_EXPECT_TRUE(@test, (@left) > (@right)). See KUNIT_EXPECT_TRUE() for +* more information. +*/ +#define KUNIT_EXPECT_GT (test, left, right) \ + KUNIT_EXPECT_BINARY(test, left, >, right) + +#define KUNIT_EXPECT_GT_MSG (test, left, right, fmt, ...) \ + KUNIT_EXPECT_BINARY_MSG(test, \ + left, \ + >, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** +* KUNIT_EXPECT_GE() - Expects that @left is greater than or equal to @right. +* @test: The test context object. +* @left: an arbitrary expression that evaluates to a primitive C type. +* @right: an arbitrary expression that evaluates to a primitive C type. +* +* Sets an expectation that the value that @left evaluates to is greater than +* the value that @right evaluates to. This is semantically equivalent to +* KUNIT_EXPECT_TRUE(@test, (@left) >= (@right)). See KUNIT_EXPECT_TRUE() for +* more information. +*/ +#define KUNIT_EXPECT_GE (test, left, right) \ + KUNIT_EXPECT_BINARY(test, left, >=, right) + +#define KUNIT_EXPECT_GE_MSG (test, left, right, fmt, ...) \ + KUNIT_EXPECT_BINARY_MSG(test, \ + left, \ + >=, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** +* KUNIT_EXPECT_STREQ() - Expects that strings @left and @right are equal. +* @test: The test context object. +* @left: an arbitrary expression that evaluates to a null terminated string. +* @right: an arbitrary expression that evaluates to a null terminated string. +* +* Sets an expectation that the values that @left and @right evaluate to are +* equal. This is semantically equivalent to +* KUNIT_EXPECT_TRUE(@test, !strcmp((@left), (@right))). See KUNIT_EXPECT_TRUE() +* for more information. +*/ +#define KUNIT_EXPECT_STREQ (test, left, right) do { \ + struct kunit_stream *__stream = KUNIT_EXPECT_START(test); \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + \ + kunit_stream_add(__stream, "Expected " #left " == " #right ", but\n"); \ + kunit_stream_add(__stream, "\t\t%s == %s\n", #left, __left); \ + kunit_stream_add(__stream, "\t\t%s == %s\n", #right, __right); \ + \ + KUNIT_EXPECT_END(test, !strcmp(left, right), __stream); \ +} while (0) + +#define KUNIT_EXPECT_STREQ_MSG (test, left, right, fmt, ...) do { \ + struct kunit_stream *__stream = KUNIT_EXPECT_START(test); \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + \ + kunit_stream_add(__stream, "Expected " #left " == " #right ", but\n"); \ + kunit_stream_add(__stream, "\t\t%s == %s\n", #left, __left); \ + kunit_stream_add(__stream, "\t\t%s == %s\n", #right, __right); \ + kunit_stream_add(__stream, fmt, ##__VA_ARGS__); \ + \ + KUNIT_EXPECT_END(test, !strcmp(left, right), __stream); \ +} while (0) + +/** +* KUNIT_EXPECT_STRNEQ() - Expects that strings @left and @right are not equal. +* @test: The test context object. +* @left: an arbitrary expression that evaluates to a null terminated string. +* @right: an arbitrary expression that evaluates to a null terminated string. +* +* Sets an expectation that the values that @left and @right evaluate to are +* not equal. This is semantically equivalent to +* KUNIT_EXPECT_TRUE(@test, strcmp((@left), (@right))). See KUNIT_EXPECT_TRUE() +* for more information. +*/ +#define KUNIT_EXPECT_STRNEQ (test, left, right) do { \ + struct kunit_stream *__stream = KUNIT_EXPECT_START(test); \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + \ + kunit_stream_add(__stream, "Expected " #left " != " #right ", but\n"); \ + kunit_stream_add(__stream, "\t\t%s == %s\n", #left, __left); \ + kunit_stream_add(__stream, "\t\t%s == %s\n", #right, __right); \ + \ + KUNIT_EXPECT_END(test, strcmp(left, right), __stream); \ +} while (0) + +#define KUNIT_EXPECT_STRNEQ_MSG (test, left, right, fmt, ...) do { \ + struct kunit_stream *__stream = KUNIT_EXPECT_START(test); \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + \ + kunit_stream_add(__stream, "Expected " #left " != " #right ", but\n"); \ + kunit_stream_add(__stream, "\t\t%s == %s\n", #left, __left); \ + kunit_stream_add(__stream, "\t\t%s == %s\n", #right, __right); \ + kunit_stream_add(__stream, fmt, ##__VA_ARGS__); \ + \ + KUNIT_EXPECT_END(test, strcmp(left, right), __stream); \ +} while (0) + +/** +* KUNIT_EXPECT_NOT_ERR_OR_NULL() - Expects that @ptr is not null and not err. +* @test: The test context object. +* @ptr: an arbitrary pointer. +* +* Sets an expectation that the value that @ptr evaluates to is not null and not +* an errno stored in a pointer. This is semantically equivalent to +* KUNIT_EXPECT_TRUE(@test, !IS_ERR_OR_NULL(@ptr)). See KUNIT_EXPECT_TRUE() for +* more information. +*/ +#define KUNIT_EXPECT_NOT_ERR_OR_NULL (test, ptr) do { \ + struct kunit_stream *__stream = KUNIT_EXPECT_START(test); \ + typeof(ptr) __ptr = (ptr); \ + \ + if (!__ptr) \ + kunit_stream_add(__stream, \ + "Expected " #ptr " is not null, but is."); \ + if (IS_ERR(__ptr)) \ + kunit_stream_add(__stream, \ + "Expected " #ptr " is not error, but is: %ld", \ + PTR_ERR(__ptr)); \ + \ + KUNIT_EXPECT_END(test, !IS_ERR_OR_NULL(__ptr), __stream); \ +} while (0) + +#define KUNIT_EXPECT_NOT_ERR_OR_NULL_MSG (test, ptr, fmt, ...) do { \ + struct kunit_stream *__stream = KUNIT_EXPECT_START(test); \ + typeof(ptr) __ptr = (ptr); \ + \ + if (!__ptr) { \ + kunit_stream_add(__stream, \ + "Expected " #ptr " is not null, but is."); \ + kunit_stream_add(__stream, fmt, ##__VA_ARGS__); \ + } \ + if (IS_ERR(__ptr)) { \ + kunit_stream_add(__stream, \ + "Expected " #ptr " is not error, but is: %ld", \ + PTR_ERR(__ptr)); \ + \ + kunit_stream_add(__stream, fmt, ##__VA_ARGS__); \ + } \ + KUNIT_EXPECT_END(test, !IS_ERR_OR_NULL(__ptr), __stream); \ +} while (0) +#endif /* _KUNIT_TEST_H */
kunit/test.c +34 -0
@@ -269,3 +269,37 @@ void kunit_printk(const char *level,va_end (args); } + +void kunit_expect_binary_msg (struct kunit *test, +long long left,const char *left_name, +long long right,const char *right_name, +bool compare_result, +const char *compare_name, +const char *file, +const char *line, +const char *fmt, ...) +{ +struct kunit_stream *stream =kunit_expect_start (test, file, line); +struct va_format vaf; +va_list args; + +kunit_stream_add (stream, +"Expected %s %s %s, but\n" , + left_name, compare_name, right_name); +kunit_stream_add (stream,"\t\t%s == %lld\n" , left_name, left); +kunit_stream_add (stream,"\t\t%s == %lld" , right_name, right); + +if (fmt) { +va_start (args, fmt); + + vaf.fmt = fmt; + vaf.va = &args; + +kunit_stream_add (stream,"\n%pV" , &vaf); + +va_end (args); + } + +kunit_expect_end (test, compare_result, stream); +} +
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH 6/17 kbuild: enable building KUnit
In reply to Brendan HigginsAdd KUnit to root Kconfig and Makefile allowing it to actually be built.
--- Kconfig | 2 ++ Makefile | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-)
Kconfig +2 -0
@@ -30,3 +30,5 @@ source "crypto/Kconfig" source "lib/Kconfig" source "lib/Kconfig.debug" + +source "kunit/Kconfig"
Makefile +1 -1
@@ -964,7 +964,7 @@ endif PHONY += prepare0 ifeq ($(KBUILD_EXTMOD),) -core-y += kernel/ certs/ mm/ fs/ ipc/ security/ crypto/ block/ +core-y += kernel/ certs/ mm/ fs/ ipc/ security/ crypto/ block/ kunit/ vmlinux-dirs := $(patsubst %/,%,$(filter %/, $(init-y) $(init-m) \ $(core-y) $(core-m) $(drivers-y) $(drivers-m) \
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH 7/17 kunit: test: add initial tests
In reply to Brendan HigginsAdd a test for string stream along with a simpler example.
--- kunit/Kconfig | 12 ++++++ kunit/Makefile | 4 ++ kunit/example-test.c | 88 ++++++++++++++++++++++++++++++++++++++ kunit/string-stream-test.c | 61 ++++++++++++++++++++++++++ 4 files changed, 165 insertions(+) create mode 100644 kunit/example-test.c create mode 100644 kunit/string-stream-test.c
kunit/Kconfig +12 -0
@@ -13,4 +13,16 @@ config KUNIT special hardware. For more information, please see Documentation/kunit/ +config KUNIT_TEST + bool "KUnit test for KUnit" + depends on KUNIT + help + Enables KUnit test to test KUnit. + +config KUNIT_EXAMPLE_TEST + bool "Example test for KUnit" + depends on KUNIT + help + Enables example KUnit test to demo features of KUnit. + endmenu
kunit/Makefile +4 -0
@@ -1,3 +1,7 @@ obj-$(CONFIG_KUNIT) += test.o \ string-stream.o \ kunit-stream.o + +obj-$(CONFIG_KUNIT_TEST) += string-stream-test.o + +obj-$(CONFIG_KUNIT_EXAMPLE_TEST) += example-test.o
kunit/example-test.c new file +88 -0
88 lines not on this page · raw message
kunit/string-stream-test.c new file +61 -0
61 lines not on this page · raw message
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH 8/17 kunit: test: add support for test abort
In reply to Brendan HigginsAdd support for aborting/bailing out of test cases, which is needed for implementing assertions.
An assertion is like an expectation, but bails out of the test case early if the assertion is not met. The idea with assertions is that you use them to state all the preconditions for your test. Logically speaking, these are the premises of the test case, so if a premise isn't true, there is no point in continuing the test case because there are no conclusions that can be drawn without the premises. Whereas, the expectation is the thing you are trying to prove.
--- include/kunit/test.h | 13 ++++ include/kunit/try-catch.h | 91 +++++++++++++++++++++++++ kunit/Makefile | 3 +- kunit/test.c | 138 +++++++++++++++++++++++++++++++++++--- kunit/try-catch.c | 96 ++++++++++++++++++++++++++ 5 files changed, 332 insertions(+), 9 deletions(-) create mode 100644 include/kunit/try-catch.h create mode 100644 kunit/try-catch.c
include/kunit/test.h +13 -0
@@ -12,6 +12,7 @@#include <linux/types.h> #include <linux/slab.h> #include <kunit/kunit-stream.h> +#include <kunit/try-catch.h> struct kunit_resource ;
@@ -166,15 +167,27 @@ struct kunit {/* private: internal use only. */ const char *name;/* Read only after initialization! */ +struct kunit_try_catch try_catch;spinlock_t lock;/* Gaurds all mutable test state. */ bool success;/* Protected by lock. */ +bool death_test;/* Protected by lock. */ struct list_head resources;/* Protected by lock. */ void (*vprintk)(const struct kunit *test,const char *level,struct va_format *vaf);void (*fail)(struct kunit *test,struct kunit_stream *stream); +void (*abort)(struct kunit *test); }; +static inline void kunit_set_death_test (struct kunit *test,bool death_test) +{ +unsigned long flags; + +spin_lock_irqsave (&test->lock, flags); + test->death_test = death_test; +spin_unlock_irqrestore (&test->lock, flags); +} +int kunit_init_test (struct kunit *test,const char *name);int kunit_run_tests (struct kunit_module *module);
include/kunit/try-catch.h new file +91 -0
91 lines not on this page · raw message
kunit/Makefile +2 -1
@@ -1,6 +1,7 @@ obj-$(CONFIG_KUNIT) += test.o \ string-stream.o \ - kunit-stream.o + kunit-stream.o \ + try-catch.o obj-$(CONFIG_KUNIT_TEST) += string-stream-test.o
kunit/test.c +130 -8
181 lines not on this page · raw message
kunit/try-catch.c new file +96 -0
96 lines not on this page · raw message
Signature · 6 lines
2.21.0.392.gf8f6787159e-goog _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH 9/17 kunit: test: add tests for kunit test abort
In reply to Brendan HigginsAdd KUnit tests for the KUnit test abort mechanism (see preceding commit). Add tests both for general try catch mechanism as well as non-architecture specific mechanism.
--- kunit/Makefile | 3 +- kunit/test-test.c | 135 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 137 insertions(+), 1 deletion(-) create mode 100644 kunit/test-test.c
kunit/Makefile +2 -1
@@ -3,6 +3,7 @@ obj-$(CONFIG_KUNIT) += test.o \ kunit-stream.o \ try-catch.o -obj-$(CONFIG_KUNIT_TEST) += string-stream-test.o +obj-$(CONFIG_KUNIT_TEST) += test-test.o \ + string-stream-test.o obj-$(CONFIG_KUNIT_EXAMPLE_TEST) += example-test.o
kunit/test-test.c new file +135 -0
135 lines not on this page · raw message
Signature · 6 lines
2.21.0.392.gf8f6787159e-goog _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH 10/17 kunit: test: add the concept of assertions
In reply to Brendan HigginsAdd support for assertions which are like expectations except the test terminates if the assertion is not satisfied.
The idea with assertions is that you use them to state all the preconditions for your test. Logically speaking, these are the premises of the test case, so if a premise isn't true, there is no point in continuing the test case because there are no conclusions that can be drawn without the premises. Whereas, the expectation is the thing you are trying to prove. It is not used universally in x-unit style test frameworks, but I really like it as a convention. You could still express the idea of a premise using the above idiom, but I think KUNIT_ASSERT_* states the intended idea perfectly.
--- include/kunit/test.h | 401 ++++++++++++++++++++++++++++++++++++- kunit/string-stream-test.c | 12 +- kunit/test-test.c | 2 + kunit/test.c | 33 +++ 4 files changed, 439 insertions(+), 9 deletions(-)
include/kunit/test.h +398 -3
@@ -85,9 +85,10 @@ struct kunit;* @name: the name of the test case. * * A test case is a function with the signature, ``void (*)(struct kunit *)`` -* that makes expectations (see KUNIT_EXPECT_TRUE()) about code under test. Each -* test case is associated with a &struct kunit_module and will be run after the -* module's init function and followed by the module's exit function. +* that makes expectations and assertions (see KUNIT_EXPECT_TRUE() and +* KUNIT_ASSERT_TRUE()) about code under test. Each test case is associated with +* a &struct kunit_module and will be run after the module's init function and +* followed by the module's exit function. * * A test case should be static and should only be created with the KUNIT_CASE() * macro; additionally, every array of test cases should be terminated with an
@@ -705,4 +706,398 @@ static inline void kunit_expect_binary(struct kunit *test,KUNIT_EXPECT_END (test, !IS_ERR_OR_NULL (__ptr), __stream); \ } while (0) +static inline struct kunit_stream *kunit_assert_start(struct kunit *test, +const char *file, +const char *line) +{ +struct kunit_stream *stream =kunit_new_stream (test); + +kunit_stream_add (stream,"ASSERTION FAILED at %s:%s\n\t" , file, line); + +return stream; +} + +static inline void kunit_assert_end (struct kunit *test, +bool success, +struct kunit_stream *stream) +{ +if (!success) { + test->fail (test, stream); + test->abort (test); + }else { +kunit_stream_clear (stream); + } +} + +#define KUNIT_ASSERT_START (test) \ + kunit_assert_start(test, __FILE__, __stringify(__LINE__)) + +#define KUNIT_ASSERT_END (test, success, stream) \ + kunit_assert_end(test, success, stream) + +#define KUNIT_ASSERT (test, success, message) do { \ + struct kunit_stream *__stream = KUNIT_ASSERT_START(test); \ + \ + kunit_stream_add(__stream, message); \ + KUNIT_ASSERT_END(test, success, __stream); \ +} while (0) + +#define KUNIT_ASSERT_MSG (test, success, message, fmt, ...) do { \ + struct kunit_stream *__stream = KUNIT_ASSERT_START(test); \ + \ + kunit_stream_add(__stream, message); \ + kunit_stream_add(__stream, fmt, ##__VA_ARGS__); \ + KUNIT_ASSERT_END(test, success, __stream); \ +} while (0) + +#define KUNIT_ASSERT_FAILURE (test, fmt, ...) do { \ + struct kunit_stream *__stream = KUNIT_ASSERT_START(test); \ + \ + kunit_stream_add(__stream, fmt, ##__VA_ARGS__); \ + KUNIT_ASSERT_END(test, false, __stream); \ +} while (0) + +/** +* KUNIT_ASSERT_TRUE() - Sets an assertion that @condition is true. +* @test: The test context object. +* @condition: an arbitrary boolean expression. The test fails and aborts when +* this does not evaluate to true. +* +* This and assertions of the form `KUNIT_ASSERT_*` will cause the test case to +* fail *and immediately abort* when the specified condition is not met. Unlike +* an expectation failure, it will prevent the test case from continuing to run; +* this is otherwise known as an *assertion failure*. +*/ +#define KUNIT_ASSERT_TRUE (test, condition) \ + KUNIT_ASSERT(test, (condition), \ + "Asserted " #condition " is true, but is false.\n") + +#define KUNIT_ASSERT_TRUE_MSG (test, condition, fmt, ...) \ + KUNIT_ASSERT_MSG(test, (condition), \ + "Asserted " #condition " is true, but is false.\n",\ + fmt, ##__VA_ARGS__) + +/** +* KUNIT_ASSERT_FALSE() - Sets an assertion that @condition is false. +* @test: The test context object. +* @condition: an arbitrary boolean expression. +* +* Sets an assertion that the value that @condition evaluates to is false. This +* is the same as KUNIT_EXPECT_FALSE(), except it causes an assertion failure +* (see KUNIT_ASSERT_TRUE()) when the assertion is not met. +*/ +#define KUNIT_ASSERT_FALSE (test, condition) \ + KUNIT_ASSERT(test, !(condition), \ + "Asserted " #condition " is false, but is true.\n") + +#define KUNIT_ASSERT_FALSE_MSG (test, condition, fmt, ...) \ + KUNIT_ASSERT_MSG(test, !(condition), \ + "Asserted " #condition " is false, but is true.\n",\ + fmt, ##__VA_ARGS__) + +void kunit_assert_binary_msg (struct kunit *test, +long long left,const char *left_name, +long long right,const char *right_name, +bool compare_result, +const char *compare_name, +const char *file, +const char *line, +const char *fmt, ...); + +static inline void kunit_assert_binary (struct kunit *test, +long long left,const char *left_name, +long long right,const char *right_name, +bool compare_result, +const char *compare_name, +const char *file, +const char *line) +{ +kunit_assert_binary_msg (test, + left, left_name, + right, right_name, + compare_result, + compare_name, + file, + line, +NULL ); +} + +/* +* A factory macro for defining the expectations for the basic comparisons +* defined for the built in types. +* +* Unfortunately, there is no common type that all types can be promoted to for +* which all the binary operators behave the same way as for the actual types +* (for example, there is no type that long long and unsigned long long can +* both be cast to where the comparison result is preserved for all values). So +* the best we can do is do the comparison in the original types and then coerce +* everything to long long for printing; this way, the comparison behaves +* correctly and the printed out value usually makes sense without +* interpretation, but can always be interpretted to figure out the actual +* value. +*/ +#define KUNIT_ASSERT_BINARY (test, left, condition, right) do { \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + kunit_assert_binary(test, \ + (long long) __left, #left, \ + (long long) __right, #right, \ + __left condition __right, #condition, \ + __FILE__, __stringify(__LINE__)); \ +} while (0) + +#define KUNIT_ASSERT_BINARY_MSG (test, left, condition, right, fmt, ...) do { \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + kunit_assert_binary_msg(test, \ + (long long) __left, #left, \ + (long long) __right, #right, \ + __left condition __right, #condition, \ + __FILE__, __stringify(__LINE__), \ + fmt, ##__VA_ARGS__); \ +} while (0) + +/** +* KUNIT_ASSERT_EQ() - Sets an assertion that @left and @right are equal. +* @test: The test context object. +* @left: an arbitrary expression that evaluates to a primitive C type. +* @right: an arbitrary expression that evaluates to a primitive C type. +* +* Sets an assertion that the values that @left and @right evaluate to are +* equal. This is the same as KUNIT_EXPECT_EQ(), except it causes an assertion +* failure (see KUNIT_ASSERT_TRUE()) when the assertion is not met. +*/ +#define KUNIT_ASSERT_EQ (test, left, right) \ + KUNIT_ASSERT_BINARY(test, left, ==, right) + +#define KUNIT_ASSERT_EQ_MSG (test, left, right, fmt, ...) \ + KUNIT_ASSERT_BINARY_MSG(test, \ + left, \ + ==, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** +* KUNIT_ASSERT_NE() - An assertion that @left and @right are not equal. +* @test: The test context object. +* @left: an arbitrary expression that evaluates to a primitive C type. +* @right: an arbitrary expression that evaluates to a primitive C type. +* +* Sets an assertion that the values that @left and @right evaluate to are not +* equal. This is the same as KUNIT_EXPECT_NE(), except it causes an assertion +* failure (see KUNIT_ASSERT_TRUE()) when the assertion is not met. +*/ +#define KUNIT_ASSERT_NE (test, left, right) \ + KUNIT_ASSERT_BINARY(test, left, !=, right) + +#define KUNIT_ASSERT_NE_MSG (test, left, right, fmt, ...) \ + KUNIT_ASSERT_BINARY_MSG(test, \ + left, \ + !=, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** +* KUNIT_ASSERT_LT() - An assertion that @left is less than @right. +* @test: The test context object. +* @left: an arbitrary expression that evaluates to a primitive C type. +* @right: an arbitrary expression that evaluates to a primitive C type. +* +* Sets an assertion that the value that @left evaluates to is less than the +* value that @right evaluates to. This is the same as KUNIT_EXPECT_LT(), except +* it causes an assertion failure (see KUNIT_ASSERT_TRUE()) when the assertion +* is not met. +*/ +#define KUNIT_ASSERT_LT (test, left, right) \ + KUNIT_ASSERT_BINARY(test, left, <, right) + +#define KUNIT_ASSERT_LT_MSG (test, left, right, fmt, ...) \ + KUNIT_ASSERT_BINARY_MSG(test, \ + left, \ + <, \ + right, \ + fmt, \ + ##__VA_ARGS__) +/** +* KUNIT_ASSERT_LE() - An assertion that @left is less than or equal to @right. +* @test: The test context object. +* @left: an arbitrary expression that evaluates to a primitive C type. +* @right: an arbitrary expression that evaluates to a primitive C type. +* +* Sets an assertion that the value that @left evaluates to is less than or +* equal to the value that @right evaluates to. This is the same as +* KUNIT_EXPECT_LE(), except it causes an assertion failure (see +* KUNIT_ASSERT_TRUE()) when the assertion is not met. +*/ +#define KUNIT_ASSERT_LE (test, left, right) \ + KUNIT_ASSERT_BINARY(test, left, <=, right) + +#define KUNIT_ASSERT_LE_MSG (test, left, right, fmt, ...) \ + KUNIT_ASSERT_BINARY_MSG(test, \ + left, \ + <=, \ + right, \ + fmt, \ + ##__VA_ARGS__) +/** +* KUNIT_ASSERT_GT() - An assertion that @left is greater than @right. +* @test: The test context object. +* @left: an arbitrary expression that evaluates to a primitive C type. +* @right: an arbitrary expression that evaluates to a primitive C type. +* +* Sets an assertion that the value that @left evaluates to is greater than the +* value that @right evaluates to. This is the same as KUNIT_EXPECT_GT(), except +* it causes an assertion failure (see KUNIT_ASSERT_TRUE()) when the assertion +* is not met. +*/ +#define KUNIT_ASSERT_GT (test, left, right) \ + KUNIT_ASSERT_BINARY(test, left, >, right) + +#define KUNIT_ASSERT_GT_MSG (test, left, right, fmt, ...) \ + KUNIT_ASSERT_BINARY_MSG(test, \ + left, \ + >, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** +* KUNIT_ASSERT_GE() - Assertion that @left is greater than or equal to @right. +* @test: The test context object. +* @left: an arbitrary expression that evaluates to a primitive C type. +* @right: an arbitrary expression that evaluates to a primitive C type. +* +* Sets an assertion that the value that @left evaluates to is greater than the +* value that @right evaluates to. This is the same as KUNIT_EXPECT_GE(), except +* it causes an assertion failure (see KUNIT_ASSERT_TRUE()) when the assertion +* is not met. +*/ +#define KUNIT_ASSERT_GE (test, left, right) \ + KUNIT_ASSERT_BINARY(test, left, >=, right) + +#define KUNIT_ASSERT_GE_MSG (test, left, right, fmt, ...) \ + KUNIT_ASSERT_BINARY_MSG(test, \ + left, \ + >=, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** +* KUNIT_ASSERT_STREQ() - An assertion that strings @left and @right are equal. +* @test: The test context object. +* @left: an arbitrary expression that evaluates to a null terminated string. +* @right: an arbitrary expression that evaluates to a null terminated string. +* +* Sets an assertion that the values that @left and @right evaluate to are +* equal. This is the same as KUNIT_EXPECT_STREQ(), except it causes an +* assertion failure (see KUNIT_ASSERT_TRUE()) when the assertion is not met. +*/ +#define KUNIT_ASSERT_STREQ (test, left, right) do { \ + struct kunit_stream *__stream = KUNIT_ASSERT_START(test); \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + \ + kunit_stream_add(__stream, "Asserted " #left " == " #right ", but\n"); \ + kunit_stream_add(__stream, "\t\t%s == %s\n", #left, __left); \ + kunit_stream_add(__stream, "\t\t%s == %s\n", #right, __right); \ + \ + KUNIT_ASSERT_END(test, !strcmp(left, right), __stream); \ +} while (0) + +#define KUNIT_ASSERT_STREQ_MSG (test, left, right, fmt, ...) do { \ + struct kunit_stream *__stream = KUNIT_ASSERT_START(test); \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + \ + kunit_stream_add(__stream, "Asserted " #left " == " #right ", but\n"); \ + kunit_stream_add(__stream, "\t\t%s == %s\n", #left, __left); \ + kunit_stream_add(__stream, "\t\t%s == %s\n", #right, __right); \ + kunit_stream_add(__stream, fmt, ##__VA_ARGS__); \ + \ + KUNIT_ASSERT_END(test, !strcmp(left, right), __stream); \ +} while (0) + +/** +* KUNIT_ASSERT_STRNEQ() - Expects that strings @left and @right are not equal. +* @test: The test context object. +* @left: an arbitrary expression that evaluates to a null terminated string. +* @right: an arbitrary expression that evaluates to a null terminated string. +* +* Sets an expectation that the values that @left and @right evaluate to are +* not equal. This is semantically equivalent to +* KUNIT_ASSERT_TRUE(@test, strcmp((@left), (@right))). See KUNIT_ASSERT_TRUE() +* for more information. +*/ +#define KUNIT_ASSERT_STRNEQ (test, left, right) do { \ + struct kunit_stream *__stream = KUNIT_ASSERT_START(test); \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + \ + kunit_stream_add(__stream, "Asserted " #left " == " #right ", but\n"); \ + kunit_stream_add(__stream, "\t\t%s == %s\n", #left, __left); \ + kunit_stream_add(__stream, "\t\t%s == %s\n", #right, __right); \ + \ + KUNIT_ASSERT_END(test, strcmp(left, right), __stream); \ +} while (0) + +#define KUNIT_ASSERT_STRNEQ_MSG (test, left, right, fmt, ...) do { \ + struct kunit_stream *__stream = KUNIT_ASSERT_START(test); \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + \ + kunit_stream_add(__stream, "Asserted " #left " == " #right ", but\n"); \ + kunit_stream_add(__stream, "\t\t%s == %s\n", #left, __left); \ + kunit_stream_add(__stream, "\t\t%s == %s\n", #right, __right); \ + kunit_stream_add(__stream, fmt, ##__VA_ARGS__); \ + \ + KUNIT_ASSERT_END(test, strcmp(left, right), __stream); \ +} while (0) + +/** +* KUNIT_ASSERT_NOT_ERR_OR_NULL() - Assertion that @ptr is not null and not err. +* @test: The test context object. +* @ptr: an arbitrary pointer. +* +* Sets an assertion that the value that @ptr evaluates to is not null and not +* an errno stored in a pointer. This is the same as +* KUNIT_EXPECT_NOT_ERR_OR_NULL(), except it causes an assertion failure (see +* KUNIT_ASSERT_TRUE()) when the assertion is not met. +*/ +#define KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ptr) do { \ + struct kunit_stream *__stream = KUNIT_ASSERT_START(test); \ + typeof(ptr) __ptr = (ptr); \ + \ + if (!__ptr) \ + kunit_stream_add(__stream, \ + "Asserted " #ptr " is not null, but is.\n"); \ + if (IS_ERR(__ptr)) \ + kunit_stream_add(__stream, \ + "Asserted " #ptr " is not error, but is: %ld\n",\ + PTR_ERR(__ptr)); \ + \ + KUNIT_ASSERT_END(test, !IS_ERR_OR_NULL(__ptr), __stream); \ +} while (0) + +#define KUNIT_ASSERT_NOT_ERR_OR_NULL_MSG (test, ptr, fmt, ...) do { \ + struct kunit_stream *__stream = KUNIT_ASSERT_START(test); \ + typeof(ptr) __ptr = (ptr); \ + \ + if (!__ptr) { \ + kunit_stream_add(__stream, \ + "Asserted " #ptr " is not null, but is.\n"); \ + kunit_stream_add(__stream, fmt, ##__VA_ARGS__); \ + } \ + if (IS_ERR(__ptr)) { \ + kunit_stream_add(__stream, \ + "Asserted " #ptr " is not error, but is: %ld\n",\ + PTR_ERR(__ptr)); \ + \ + kunit_stream_add(__stream, fmt, ##__VA_ARGS__); \ + } \ + KUNIT_ASSERT_END(test, !IS_ERR_OR_NULL(__ptr), __stream); \ +} while (0) +#endif /* _KUNIT_TEST_H */
kunit/string-stream-test.c +6 -6
@@ -19,7 +19,7 @@ static void string_stream_test_get_string(struct kunit *test)string_stream_add (stream," %s" ,"bar" ); output =string_stream_get_string (stream); -KUNIT_EXPECT_STREQ (test, output,"Foo bar" ); +KUNIT_ASSERT_STREQ (test, output,"Foo bar" );kfree (output);destroy_string_stream (stream); }
@@ -34,16 +34,16 @@ static void string_stream_test_add_and_clear(struct kunit *test)string_stream_add (stream,"A" ); output =string_stream_get_string (stream); -KUNIT_EXPECT_STREQ (test, output,"AAAAAAAAAA" ); -KUNIT_EXPECT_EQ (test, stream->length,10 ); -KUNIT_EXPECT_FALSE (test,string_stream_is_empty (stream)); +KUNIT_ASSERT_STREQ (test, output,"AAAAAAAAAA" ); +KUNIT_ASSERT_EQ (test, stream->length,10 ); +KUNIT_ASSERT_FALSE (test,string_stream_is_empty (stream));kfree (output);string_stream_clear (stream); output =string_stream_get_string (stream); -KUNIT_EXPECT_STREQ (test, output,"" ); -KUNIT_EXPECT_TRUE (test,string_stream_is_empty (stream)); +KUNIT_ASSERT_STREQ (test, output,"" ); +KUNIT_ASSERT_TRUE (test,string_stream_is_empty (stream));destroy_string_stream (stream); }
kunit/test-test.c +2 -0
@@ -110,11 +110,13 @@ static int kunit_try_catch_test_init(struct kunit *test)struct kunit_try_catch_test_context *ctx; ctx =kunit_kzalloc (test,sizeof (*ctx),GFP_KERNEL ); +KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ctx); test->priv = ctx; ctx->try_catch =kunit_kmalloc (test,sizeof (*ctx->try_catch),GFP_KERNEL ); +KUNIT_ASSERT_NOT_ERR_OR_NULL (test, ctx->try_catch);return 0 ; }
kunit/test.c +33 -0
@@ -425,3 +425,36 @@ void kunit_expect_binary_msg(struct kunit *test,kunit_expect_end (test, compare_result, stream); } +void kunit_assert_binary_msg (struct kunit *test, +long long left,const char *left_name, +long long right,const char *right_name, +bool compare_result, +const char *compare_name, +const char *file, +const char *line, +const char *fmt, ...) +{ +struct kunit_stream *stream =kunit_assert_start (test, file, line); +struct va_format vaf; +va_list args; + +kunit_stream_add (stream, +"Asserted %s %s %s, but\n" , + left_name, compare_name, right_name); +kunit_stream_add (stream,"\t\t%s == %lld\n" , left_name, left); +kunit_stream_add (stream,"\t\t%s == %lld\n" , right_name, right); + +if (fmt) { +va_start (args, fmt); + + vaf.fmt = fmt; + vaf.va = &args; + +kunit_stream_add (stream,"\n%pV" , &vaf); + +va_end (args); + } + +kunit_assert_end (test, compare_result, stream); +} +
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH 11/17 kunit: test: add test managed resource tests
In reply to Brendan HigginsFrom: Avinash Kondareddy <[email protected]>
Tests how tests interact with test managed resources in their lifetime.
--- kunit/test-test.c | 122 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 122 insertions(+)
kunit/test-test.c +122 -0
@@ -135,3 +135,125 @@ static struct kunit_module kunit_try_catch_test_module = { .test_cases = kunit_try_catch_test_cases, };module_test (kunit_try_catch_test_module); + +/* +* Context for testing test managed resources +* is_resource_initialized is used to test arbitrary resources +*/ +struct kunit_test_resource_context { +struct kunit test; +bool is_resource_initialized; +}; + +static int fake_resource_init (struct kunit_resource *res,void *context) +{ +struct kunit_test_resource_context *ctx = context; + + res->allocation = &ctx->is_resource_initialized; + ctx->is_resource_initialized = true; +return 0 ; +} + +static void fake_resource_free (struct kunit_resource *res) +{ +bool *is_resource_initialized = res->allocation; + + *is_resource_initialized = false; +} + +static void kunit_resource_test_init_resources (struct kunit *test) +{ +struct kunit_test_resource_context *ctx = test->priv; + +kunit_init_test (&ctx->test,"testing_test_init_test" ); + +KUNIT_EXPECT_TRUE (test,list_empty (&ctx->test.resources)); +} + +static void kunit_resource_test_alloc_resource (struct kunit *test) +{ +struct kunit_test_resource_context *ctx = test->priv; +struct kunit_resource *res; +kunit_resource_free_t free = fake_resource_free; + + res =kunit_alloc_resource (&ctx->test, + fake_resource_init, + fake_resource_free, + ctx); + +KUNIT_ASSERT_NOT_ERR_OR_NULL (test, res); +KUNIT_EXPECT_EQ (test, &ctx->is_resource_initialized, res->allocation); +KUNIT_EXPECT_TRUE (test,list_is_last (&res->node, &ctx->test.resources)); +KUNIT_EXPECT_EQ (test, free, res->free); +} + +static void kunit_resource_test_free_resource (struct kunit *test) +{ +struct kunit_test_resource_context *ctx = test->priv; +struct kunit_resource *res =kunit_alloc_resource (&ctx->test, + fake_resource_init, + fake_resource_free, + ctx); + +kunit_free_resource (&ctx->test, res); + +KUNIT_EXPECT_EQ (test, false, ctx->is_resource_initialized); +KUNIT_EXPECT_TRUE (test,list_empty (&ctx->test.resources)); +} + +static void kunit_resource_test_cleanup_resources (struct kunit *test) +{ +int i; +struct kunit_test_resource_context *ctx = test->priv; +struct kunit_resource *resources[5 ]; + +for (i =0 ; i <ARRAY_SIZE (resources); i++) { + resources[i] =kunit_alloc_resource (&ctx->test, + fake_resource_init, + fake_resource_free, + ctx); + } + +kunit_cleanup (&ctx->test); + +KUNIT_EXPECT_TRUE (test,list_empty (&ctx->test.resources)); +} + +static int kunit_resource_test_init (struct kunit *test) +{ +struct kunit_test_resource_context *ctx = +kzalloc (sizeof (*ctx),GFP_KERNEL ); + +if (!ctx) +return -ENOMEM ; + + test->priv = ctx; + +kunit_init_test (&ctx->test,"test_test_context" ); + +return 0 ; +} + +static void kunit_resource_test_exit (struct kunit *test) +{ +struct kunit_test_resource_context *ctx = test->priv; + +kunit_cleanup (&ctx->test); +kfree (ctx); +} + +static struct kunit_case kunit_resource_test_cases[] = { +KUNIT_CASE (kunit_resource_test_init_resources), +KUNIT_CASE (kunit_resource_test_alloc_resource), +KUNIT_CASE (kunit_resource_test_free_resource), +KUNIT_CASE (kunit_resource_test_cleanup_resources), + {}, +}; + +static struct kunit_module kunit_resource_test_module = { + .name ="kunit-resource-test" , + .init = kunit_resource_test_init, + .exit = kunit_resource_test_exit, + .test_cases = kunit_resource_test_cases, +}; +module_test (kunit_resource_test_module);
Signature · 6 lines
2.21.0.392.gf8f6787159e-goog _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Re: [PATCH v1 11/17] kunit: test: add test managed resource tests
Quoted 56 lines · Brendan Higgins
From: Avinash Kondareddy <[email protected]>
Tests how tests interact with test managed resources in their lifetime.
Signed-off-by Avinash Kondareddy <[email protected]>Signed-off-by Brendan Higgins <[email protected]>--- kunit/test-test.c | 122 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 122 insertions(+)kunit/test-test.c +38
-0@@ -135,3 +135,125 @@ static struct kunit_module kunit_try_catch_test_module = { .test_cases = kunit_try_catch_test_cases, };module_test (kunit_try_catch_test_module); + +/* +* Context for testing test managed resources +* is_resource_initialized is used to test arbitrary resources +*/ +struct kunit_test_resource_context { +struct kunit test; +bool is_resource_initialized; +}; + +static int fake_resource_init (struct kunit_resource *res,void *context) +{ +struct kunit_test_resource_context *ctx = context; + + res->allocation = &ctx->is_resource_initialized; + ctx->is_resource_initialized = true; +return 0 ; +} + +static void fake_resource_free (struct kunit_resource *res) +{ +bool *is_resource_initialized = res->allocation; + + *is_resource_initialized = false; +} + +static void kunit_resource_test_init_resources (struct kunit *test) +{ +struct kunit_test_resource_context *ctx = test->priv; + +kunit_init_test (&ctx->test,"testing_test_init_test" ); + +KUNIT_EXPECT_TRUE (test,list_empty (&ctx->test.resources)); +} + +static void kunit_resource_test_alloc_resource (struct kunit *test) +{ +struct kunit_test_resource_context *ctx = test->priv;
kunit/test-test.c static struct kunit_module kunit_try_catch_test_module = { · line 184
Quoted 10 lines
kunit/test-test.c +9
-0+struct kunit_resource *res; +kunit_resource_free_t free = fake_resource_free; + + res =kunit_alloc_resource (&ctx->test, + fake_resource_init, + fake_resource_free, + ctx); + +KUNIT_ASSERT_NOT_ERR_OR_NULL (test, res);
KUNIT_EXPECT_NOT_ERR_OR_NULL(test, res);
Thanks!
Masa
Re: [PATCH v1 11/17] kunit: test: add test managed resource tests
Quoted 67 lines · Masayoshi Mizuma
Quoted 64 lines · Brendan Higgins
From: Avinash Kondareddy <[email protected]>
Tests how tests interact with test managed resources in their lifetime.
Signed-off-by Avinash Kondareddy <[email protected]>Signed-off-by Brendan Higgins <[email protected]>--- kunit/test-test.c | 122 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 122 insertions(+)kunit/test-test.c +46
-0@@ -135,3 +135,125 @@ static struct kunit_module kunit_try_catch_test_module = { .test_cases = kunit_try_catch_test_cases, };module_test (kunit_try_catch_test_module); + +/* +* Context for testing test managed resources +* is_resource_initialized is used to test arbitrary resources +*/ +struct kunit_test_resource_context { +struct kunit test; +bool is_resource_initialized; +}; + +static int fake_resource_init (struct kunit_resource *res,void *context) +{ +struct kunit_test_resource_context *ctx = context; + + res->allocation = &ctx->is_resource_initialized; + ctx->is_resource_initialized = true; +return 0 ; +} + +static void fake_resource_free (struct kunit_resource *res) +{ +bool *is_resource_initialized = res->allocation; + + *is_resource_initialized = false; +} + +static void kunit_resource_test_init_resources (struct kunit *test) +{ +struct kunit_test_resource_context *ctx = test->priv; + +kunit_init_test (&ctx->test,"testing_test_init_test" ); + +KUNIT_EXPECT_TRUE (test,list_empty (&ctx->test.resources)); +} + +static void kunit_resource_test_alloc_resource (struct kunit *test) +{ +struct kunit_test_resource_context *ctx = test->priv; +struct kunit_resource *res; +kunit_resource_free_t free = fake_resource_free; + + res =kunit_alloc_resource (&ctx->test, + fake_resource_init, + fake_resource_free, + ctx); +
Quoted 3 lines
kunit/test-test.c static struct kunit_module kunit_try_catch_test_module = { · line 184
Quoted 1 line
kunit/test-test.c +1
-0+KUNIT_ASSERT_NOT_ERR_OR_NULL (test, res);KUNIT_EXPECT_NOT_ERR_OR_NULL(test, res);
See my reply to your email on the 14/17 patch.
PATCH 12/17 kunit: tool: add Python wrappers for running KUnit tests
In reply to Brendan HigginsFrom: Felix Guo <[email protected]>
The ultimate goal is to create minimal isolated test binaries; in the meantime we are using UML to provide the infrastructure to run tests, so define an abstract way to configure and run tests that allow us to change the context in which tests are built without affecting the user. This also makes pretty and dynamic error reporting, and a lot of other nice features easier.
kunit_config.py:
- parse .config and Kconfig files.
kunit_kernel.py: provides helper functions to:
- configure the kernel using kunitconfig.
- build the kernel with the appropriate configuration.
- provide function to invoke the kernel and stream the output back.
--- tools/testing/kunit/.gitignore | 3 + tools/testing/kunit/kunit.py | 78 +++++++++++++++ tools/testing/kunit/kunit_config.py | 66 +++++++++++++ tools/testing/kunit/kunit_kernel.py | 148 ++++++++++++++++++++++++++++ tools/testing/kunit/kunit_parser.py | 119 ++++++++++++++++++++++ 5 files changed, 414 insertions(+) create mode 100644 tools/testing/kunit/.gitignore create mode 100755 tools/testing/kunit/kunit.py create mode 100644 tools/testing/kunit/kunit_config.py create mode 100644 tools/testing/kunit/kunit_kernel.py create mode 100644 tools/testing/kunit/kunit_parser.py
tools/testing/kunit/.gitignore new file +3 -0
@@ -0,0 +1,3 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod]
tools/testing/kunit/kunit.py new file +78 -0
78 lines not on this page · raw message
tools/testing/kunit/kunit_config.py new file +66 -0
66 lines not on this page · raw message
tools/testing/kunit/kunit_kernel.py new file +148 -0
148 lines not on this page · raw message
tools/testing/kunit/kunit_parser.py new file +119 -0
119 lines not on this page · raw message
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH 13/17 kunit: defconfig: add defconfigs for building KUnit tests
In reply to Brendan HigginsAdd defconfig for UML and a fragment that can be used to configure other architectures for building KUnit tests. Add option to kunit_tool to use a defconfig to create the kunitconfig.
--- arch/um/configs/kunit_defconfig | 8 ++++++++ tools/testing/kunit/configs/all_tests.config | 8 ++++++++ tools/testing/kunit/kunit.py | 17 +++++++++++++++-- tools/testing/kunit/kunit_kernel.py | 3 ++- 4 files changed, 33 insertions(+), 3 deletions(-) create mode 100644 arch/um/configs/kunit_defconfig create mode 100644 tools/testing/kunit/configs/all_tests.config
arch/um/configs/kunit_defconfig new file +8 -0
@@ -0,0 +1,8 @@ +CONFIG_OF=y +CONFIG_OF_UNITTEST=y +CONFIG_OF_OVERLAY=y +CONFIG_I2C=y +CONFIG_I2C_MUX=y +CONFIG_KUNIT=y +CONFIG_KUNIT_TEST=y +CONFIG_KUNIT_EXAMPLE_TEST=y
tools/testing/kunit/configs/all_tests.config new file +8 -0
@@ -0,0 +1,8 @@ +CONFIG_OF=y +CONFIG_OF_UNITTEST=y +CONFIG_OF_OVERLAY=y +CONFIG_I2C=y +CONFIG_I2C_MUX=y +CONFIG_KUNIT=y +CONFIG_KUNIT_TEST=y +CONFIG_KUNIT_EXAMPLE_TEST=y
tools/testing/kunit/kunit.py +15 -2
@@ -11,6 +11,7 @@ import argparse import sys import os import time +import shutil import kunit_config import kunit_kernel
@@ -36,14 +37,26 @@ parser.add_argument('--build_dir', 'directory.', type=str, default=None, metavar='build_dir') -cli_args = parser.parse_args() +parser.add_argument('--defconfig', + help='Uses a default kunitconfig.', + action='store_true') -linux = kunit_kernel.LinuxSourceTree() +def create_default_kunitconfig(): + if not os.path.exists(kunit_kernel.KUNITCONFIG_PATH): + shutil.copyfile('arch/um/configs/kunit_defconfig', + kunit_kernel.KUNITCONFIG_PATH) + +cli_args = parser.parse_args() build_dir = None if cli_args.build_dir: build_dir = cli_args.build_dir +if cli_args.defconfig: + create_default_kunitconfig() + +linux = kunit_kernel.LinuxSourceTree() + config_start = time.time() success = linux.build_reconfig(build_dir) config_end = time.time()
tools/testing/kunit/kunit_kernel.py +2 -1
@@ -14,6 +14,7 @@ import os import kunit_config KCONFIG_PATH = '.config' +KUNITCONFIG_PATH = 'kunitconfig' class ConfigError(Exception): """Represents an error trying to configure the Linux kernel."""
@@ -81,7 +82,7 @@ class LinuxSourceTree(object): def __init__(self): self._kconfig = kunit_config.Kconfig() - self._kconfig.read_from_file('kunitconfig') + self._kconfig.read_from_file(KUNITCONFIG_PATH) self._ops = LinuxSourceTreeOperations() def clean(self):
Signature · 6 lines
2.21.0.392.gf8f6787159e-goog _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH 14/17 Documentation: kunit: add documentation for KUnit
In reply to Brendan HigginsAdd documentation for KUnit, the Linux kernel unit testing framework.
- Add intro and usage guide for KUnit
- Add API reference
--- Documentation/index.rst | 1 + Documentation/kunit/api/index.rst | 16 ++ Documentation/kunit/api/test.rst | 15 + Documentation/kunit/faq.rst | 46 +++ Documentation/kunit/index.rst | 80 ++++++ Documentation/kunit/start.rst | 180 ++++++++++++ Documentation/kunit/usage.rst | 447 ++++++++++++++++++++++++++++++ 7 files changed, 785 insertions(+) create mode 100644 Documentation/kunit/api/index.rst create mode 100644 Documentation/kunit/api/test.rst create mode 100644 Documentation/kunit/faq.rst create mode 100644 Documentation/kunit/index.rst create mode 100644 Documentation/kunit/start.rst create mode 100644 Documentation/kunit/usage.rst
Documentation/index.rst +1 -0
@@ -65,6 +65,7 @@ merged much easier. kernel-hacking/index trace/index maintainer/index + kunit/index Kernel API documentation ------------------------
Documentation/kunit/api/index.rst new file +16 -0
@@ -0,0 +1,16 @@ +.. SPDX-License-Identifier: GPL-2.0 + +============= +API Reference +============= +.. toctree:: + + test + +This section documents the KUnit kernel testing API. It is divided into 3 +sections: + +================================= ============================================== +:doc:`test` documents all of the standard testing API + excluding mocking or mocking related features. +================================= ==============================================
Documentation/kunit/api/test.rst new file +15 -0
@@ -0,0 +1,15 @@ +.. SPDX-License-Identifier: GPL-2.0 + +======== +Test API +======== + +This file documents all of the standard testing API excluding mocking or mocking +related features. + +.. kernel-doc:: include/kunit/test.h + :internal: + +.. kernel-doc:: include/kunit/kunit-stream.h + :internal: +
Documentation/kunit/faq.rst new file +46 -0
46 lines not on this page · raw message
Documentation/kunit/index.rst new file +80 -0
80 lines not on this page · raw message
Documentation/kunit/start.rst new file +180 -0
180 lines not on this page · raw message
Documentation/kunit/usage.rst new file +447 -0
447 lines not on this page · raw message
Signature · 6 lines
2.21.0.392.gf8f6787159e-goog _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Re: [PATCH v1 14/17] Documentation: kunit: add documentation for KUnit
Hi Brendan,
KUNIT_ASSERT_NOT_ERR_OR_NULL() should be replaced to KUNIT_EXPECT_NOT_ERR_OR_NULL(), right?
Quoted 7 lines · Brendan Higgins
Add documentation for KUnit, the Linux kernel unit testing framework.
- Add intro and usage guide for KUnit
- Add API referenceSigned-off-by Felix Guo <[email protected]>Signed-off-by Brendan Higgins <[email protected]>---
<snip>
Quoted 5 lines
Documentation/kunit/start.rst new file +0
-0
<snip>
Quoted 16 lines
Documentation/kunit/start.rst new file +16
-0+Assertions +~~~~~~~~~~ + +KUnit also has the concept of an *assertion*. An assertion is just like an +expectation except the assertion immediately terminates the test case if it is +not satisfied. + +For example: + +.. code-block:: c + + static void mock_test_do_expect_default_return(struct kunit *test) + { + struct mock_test_context *ctx = test->priv; + struct mock *mock = ctx->mock; + int param0 = 5, param1 = -5;
Documentation/kunit/start.rst
Quoted 10 lines
Documentation/kunit/start.rst new file +9
-0+ const char *two_param_types[] = {"int", "int"}; + const void *two_params[] = {¶m0, ¶m1}; + const void *ret; + + ret = mock->do_expect(mock, + "test_printk", test_printk, + two_param_types, two_params, + ARRAY_SIZE(two_params)); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ret);
KUNIT_EXPECT_NOT_ERR_OR_NULL(test, ret);
Documentation/kunit/start.rst
Quoted 8 lines
Documentation/kunit/start.rst new file +7
-0+ KUNIT_EXPECT_EQ(test, -4, *((int *) ret)); + } + +In this example, the method under test should return a pointer to a value, so +if the pointer returned by the method is null or an errno, we don't want to +bother continuing the test since the following expectation could crash the test +case. `ASSERT_NOT_ERR_OR_NULL(...)` allows us to bail out of the test case if
+case. KUNIT_EXPECT_NOT_ERR_OR_NULL(...) allows us to bail out of the test case if
Thanks!
Masa
Re: [PATCH v1 14/17] Documentation: kunit: add documentation for KUnit
Quoted 5 lines · Masayoshi Mizuma
Hi Brendan,
KUNIT_ASSERT_NOT_ERR_OR_NULL()should be replaced toKUNIT_EXPECT_NOT_ERR_OR_NULL(), right?
Generally speaking, no.
There may be places that I have used it improperly, but I think it is generally okay to use.
If you are refering to the discussion with Frank and Stephen in RFC v4, my take was that the resolution was that there were some things I needed to fix in its implementation, but it is conceptually okay, and that Frank doesn't want me to use it in drivers/of/unittest.c. Consequently, I fixed the implementation issues that Frank and Stephen pointed out, and I am holding off on drivers/of/unittest.c for this patchset. The usage in this file should be fine.
Quoted 11 lines · Brendan Higgins
Quoted 7 lines
Add documentation for KUnit, the Linux kernel unit testing framework.
- Add intro and usage guide for KUnit
- Add API referenceSigned-off-by Felix Guo <[email protected]>Signed-off-by Brendan Higgins <[email protected]>---
<snip>
<snip>
Cheers
PATCH 15/17 MAINTAINERS: add entry for KUnit the unit testing framework
In reply to Brendan HigginsAdd myself as maintainer of KUnit, the Linux kernel's unit testing framework.
--- MAINTAINERS | 10 ++++++++++ 1 file changed, 10 insertions(+)
MAINTAINERS +10 -0
@@ -8448,6 +8448,16 @@ S: Maintained F: tools/testing/selftests/ F: Documentation/dev-tools/kselftest* +KERNEL UNIT TESTING FRAMEWORK (KUnit) +M: Brendan Higgins <[email protected]> +L: kunit-dev-/[email protected] +W: https://google.github.io/kunit-docs/third_party/kernel/docs/ +S: Maintained +F: Documentation/kunit/ +F: include/kunit/ +F: kunit/ +F: tools/testing/kunit/ + KERNEL USERMODE HELPER M: Luis Chamberlain <[email protected]> L: [email protected]
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH 16/17 kernel/sysctl-test: Add null pointer test for sysctl.c:proc_dointvec()
In reply to Brendan HigginsFrom: Iurii Zaikin <[email protected]>
KUnit tests for initialized data behavior of proc_dointvec that is explicitly checked in the code. Includes basic parsing tests including int min/max overflow.
--- kernel/Makefile | 2 + kernel/sysctl-test.c | 292 +++++++++++++++++++++++++++++++++++++++++++ lib/Kconfig.debug | 6 + 3 files changed, 300 insertions(+) create mode 100644 kernel/sysctl-test.c
kernel/Makefile +2 -0
@@ -112,6 +112,8 @@ obj-$(CONFIG_HAS_IOMEM) += iomem.o obj-$(CONFIG_ZONE_DEVICE) += memremap.o obj-$(CONFIG_RSEQ) += rseq.o +obj-$(CONFIG_SYSCTL_KUNIT_TEST) += sysctl-test.o + obj-$(CONFIG_GCC_PLUGIN_STACKLEAK) += stackleak.o KASAN_SANITIZE_stackleak.o := n KCOV_INSTRUMENT_stackleak.o := n
kernel/sysctl-test.c new file +292 -0
292 lines not on this page · raw message
lib/Kconfig.debug +6 -0
@@ -1908,6 +1908,12 @@ config TEST_SYSCTL If unsure, say N. +config SYSCTL_KUNIT_TEST + bool "KUnit test for sysctl" + depends on KUNIT + help + Enables KUnit sysctl test. + config TEST_UDELAY tristate "udelay test driver" help
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH 17/17 MAINTAINERS: add proc sysctl KUnit test to PROC SYSCTL section
In reply to Brendan HigginsAdd entry for the new proc sysctl KUnit test to the PROC SYSCTL section.
--- MAINTAINERS | 1 + 1 file changed, 1 insertion(+)
MAINTAINERS +1 -0
@@ -12523,6 +12523,7 @@ S: Maintained F: fs/proc/proc_sysctl.c F: include/linux/sysctl.h F: kernel/sysctl.c +F: kernel/sysctl-test.c F: tools/testing/selftests/sysctl/ PS3 NETWORK SUPPORT
Signature · 6 lines
2.21.0.392.gf8f6787159e-goog _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel