rust: kunit: Support KUnit tests with a user-space like syntax
v7 cover rust: kunit: Support KUnit tests with a user-space like syntax
Hi all,
This is v7 of the Rust/KUnit integration patch. I think all of the suggestions have at least been responded to (even if there are a few I'm leaving as either future projects or matters of taste). Hopefully this is good-to-go for 6.15, so we can start using it concurrently with making any additional improvements we may wish.
This series was originally written by José Expósito, and has been modified and updated by Matt Gilbride, Miguel Ojeda, and myself. The original version can be found here:
https://github.com/Rust-for-Linux/linux/pull/950
Add support for writing KUnit tests in Rust. While Rust doctests are already converted to KUnit tests and run, they're really better suited for examples, rather than as first-class unit tests.
This series implements a series of direct Rust bindings for KUnit tests, as well as a new macro which allows KUnit tests to be written using a close variant of normal Rust unit test syntax. The only change required is replacing '#[cfg(test)]' with '#[kunit_tests(kunit_test_suite_name)]'
An example test would look like:
#[kunit_tests(rust_kernel_hid_driver)]
mod tests {
use super::*;
use crate::{c_str, driver, hid, prelude::*};
use core::ptr;
struct SimpleTestDriver;
impl Driver for SimpleTestDriver {
type Data = ();
}
#[test]
fn rust_test_hid_driver_adapter() {
let mut hid = bindings::hid_driver::default();
let name = c_str!("SimpleTestDriver");
static MODULE: ThisModule = unsafe { ThisModule::from_ptr(ptr::null_mut()) };
let res = unsafe {
<hid::Adapter<SimpleTestDriver> as driver::DriverOps>::register(&mut hid, name, &MODULE)
};
assert_eq!(res, Err(ENODEV)); // The mock returns -19
}
}Please give this a go, and make sure I haven't broken it! There's almost certainly a lot of improvements which can be made -- and there's a fair case to be made for replacing some of this with generated C code which can use the C macros -- but this is hopefully an adequate implementation for now, and the interface can (with luck) remain the same even if the implementation changes.
A few small notable missing features:
- Attributes (like the speed of a test) are hardcoded to the default value.
- Similarly, the module name attribute is hardcoded to NULL. In C, we use the KBUILD_MODNAME macro, but I couldn't find a way to use this from Rust which wasn't more ugly than just disabling it.
- Assertions are not automatically rewritten to use KUnit assertions.
---
Changes since v6:
https://lore.kernel.org/rust-for-linux/[email protected]/
- Fixed an [allow(unused_unsafe)] which ended up in patch 2 instead of patch 1. (Thanks, Tamir!)
- Doc comments now have several useful links. (Thanks, Tamir!)
- Fix a potential compile error under macos. (Thanks, Tamir!)
- Several small tidy-ups to limit unsafe usage. (Thanks, Tamir!)
Changes since v5:
https://lore.kernel.org/all/[email protected]/
- Rebased against 6.14-rc1
- Fixed a bunch of warnings / clippy lints introduced in Rust 1.83 and 1.84.
- No longer needs static_mut_refs / const_mut_refs, and is much cleaned up as a result. (Thanks, Miguel)
- Major documentation and example fixes. (Thanks, Miguel)
Changes since v4:
https://lore.kernel.org/linux-kselftest/[email protected]/
- Rebased against 6.13-rc1
- Allowed an unused_unsafe warning after the behaviour of addr_of_mut!() changed in Rust 1.82. (Thanks Boqun, Miguel)
- "Expect" that the sample assert_eq!(1+1, 2) produces a clippy warning due to a redundant assertion. (Thanks Boqun, Miguel)
- Fix some missing safety comments, and remove some unneeded 'unsafe' blocks. (Thanks Boqun)
- Fix a couple of minor rustfmt issues which were triggering checkpatch warnings.
Changes since v3:
https://lore.kernel.org/linux-kselftest/[email protected]/T/
- The kunit_unsafe_test_suite!() macro now panic!s if the suite name is too long, triggering a compile error. (Thanks, Alice!)
- The #[kunit_tests()] macro now preserves span information, so errors can be better reported. (Thanks, Boqun!)
- The example tests have been updated to no longer use assert_eq!() with a constant bool argument (which triggered a clippy warning now we have the span info).
Changes since v2:
https://lore.kernel.org/linux-kselftest/[email protected]/T/
- Include missing rust/macros/kunit.rs file from v2. (Thanks Boqun!)
- The kunit_unsafe_test_suite!() macro will truncate the name of the suite if it is too long. (Thanks Alice!)
- The proc macro now emits an error if the suite name is too long.
- We no longer needlessly use UnsafeCell<> in kunit_unsafe_test_suite!(). (Thanks Alice!)
Changes since v1:
https://lore.kernel.org/lkml/[email protected]/T/
- Rebase on top of the latest rust-next (commit 718c4069896c)
- Make kunit_case a const fn, rather than a macro (Thanks Boqun)
- As a result, the null terminator is now created with kernel::kunit::kunit_case_null()
- Use the C kunit_get_current_test() function to implement in_kunit_test(), rather than re-implementing it (less efficiently) ourselves.
Changes since the GitHub PR:
- Rebased on top of kselftest/kunit
- Add const_mut_refs feature
This may conflict with https://lore.kernel.org/lkml/[email protected]/
- Add rust/macros/kunit.rs to the KUnit MAINTAINERS entry
---
José Expósito (3):
rust: kunit: add KUnit case and suite macros
rust: macros: add macro to easily run KUnit tests
rust: kunit: allow to know if we are in a test
MAINTAINERS | 1 + rust/kernel/kunit.rs | 199 +++++++++++++++++++++++++++++++++++++++++++ rust/macros/kunit.rs | 161 ++++++++++++++++++++++++++++++++++ rust/macros/lib.rs | 29 +++++++ 4 files changed, 390 insertions(+) create mode 100644 rust/macros/kunit.rs
Signature · 1 line
2.48.1.601.g30ceb7b040-goog
PATCH v7 1/3 rust: kunit: add KUnit case and suite macros
From: José Expósito <[email protected]>
Add a couple of Rust const functions and macros to allow to develop KUnit tests without relying on generated C code:
- The kunit_unsafe_test_suite! Rust macro is similar to the kunit_test_suite C macro. It requires a NULL-terminated array of test cases (see below).
- The kunit_case Rust function is similar to the KUNIT_CASE C macro. It generates as case from the name and function.
- The kunit_case_null Rust function generates a NULL test case, which is to be used as delimiter in kunit_test_suite!.
While these functions and macros can be used on their own, a future patch will introduce another macro to create KUnit tests using a user-space like syntax.
---
Changes since v6:
https://lore.kernel.org/rust-for-linux/[email protected]/
- Fixed an [allow(unused_unsafe)] which ended up in patch 2 instead of patch 1. (Thanks, Tamir!)
- Doc comments now have several useful links. (Thanks, Tamir!)
- Fix a potential compile error under macos. (Thanks, Tamir!)
- Several small tidy-ups to limit unsafe usage. (Thanks, Tamir!)
Changes since v5:
https://lore.kernel.org/all/[email protected]/
- Rebased against 6.14-rc1
- Several documentation touch-ups, including noting that the example test function need not be unsafe. (Thanks, Miguel)
- Remove the need for static_mut_refs, by using core::addr_of_mut!() combined with a cast. (Thanks, Miguel)
- While this should also avoid the need for const_mut_refs, it seems to have been enabled for other users anyway.
- Use ::kernel::ffi::c_char for C strings, rather than i8 directly. (Thanks, Miguel)
Changes since v4:
https://lore.kernel.org/linux-kselftest/[email protected]/
- Rebased against 6.13-rc1
- Allowed an unused_unsafe warning after the behaviour of addr_of_mut!() changed in Rust 1.82. (Thanks Boqun, Miguel)
- Fix a couple of minor rustfmt issues which were triggering checkpatch warnings.
Changes since v3:
https://lore.kernel.org/linux-kselftest/[email protected]/
- The kunit_unsafe_test_suite!() macro now panic!s if the suite name is too long, triggering a compile error. (Thanks, Alice!)
Changes since v2:
https://lore.kernel.org/linux-kselftest/[email protected]/
- The kunit_unsafe_test_suite!() macro will truncate the name of the suite if it is too long. (Thanks Alice!)
- We no longer needlessly use UnsafeCell<> in kunit_unsafe_test_suite!(). (Thanks Alice!)
Changes since v1:
https://lore.kernel.org/lkml/[email protected]/
- Rebase on top of rust-next
- As a result, KUnit attributes are new set. These are hardcoded to the defaults of "normal" speed and no module name.
- Split the kunit_case!() macro into two const functions, kunit_case() and kunit_case_null() (for the NULL terminator).
--- rust/kernel/kunit.rs | 122 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 122 insertions(+)
rust/kernel/kunit.rs +122 -0
@@ -161,3 +161,125 @@ macro_rules! kunit_assert_eq { $crate::kunit_assert!($name, $file, $diff, $left == $right); }}; } + +/// Represents an individual test case. +/// +/// The [`kunit_unsafe_test_suite!`] macro expects a NULL-terminated list of valid test cases. +/// Use [`kunit_case_null`] to generate such a delimiter. +#[doc(hidden)] +pub const fn kunit_case ( + name: &'static kernel::str::CStr , + run_case:unsafe extern "C" fn (*mut kernel::bindings::kunit ), +) -> kernel::bindings::kunit_case { + kernel::bindings::kunit_case { + run_case:Some (run_case), + name: name.as_char_ptr (), + attr: kernel::bindings::kunit_attributes { + speed: kernel::bindings::kunit_speed_KUNIT_SPEED_NORMAL, + }, + generate_params:None , + status: kernel::bindings::kunit_status_KUNIT_SUCCESS, + module_name: core::ptr::null_mut (), + log: core::ptr::null_mut (), + } +} + +/// Represents the NULL test case delimiter. +/// +/// The [`kunit_unsafe_test_suite!`] macro expects a NULL-terminated list of test cases. This +/// function returns such a delimiter. +#[doc(hidden)] +pub const fn kunit_case_null () -> kernel::bindings::kunit_case { + kernel::bindings::kunit_case { + run_case:None , + name: core::ptr::null_mut (), + generate_params:None , + attr: kernel::bindings::kunit_attributes { + speed: kernel::bindings::kunit_speed_KUNIT_SPEED_NORMAL, + }, + status: kernel::bindings::kunit_status_KUNIT_SUCCESS, + module_name: core::ptr::null_mut (), + log: core::ptr::null_mut (), + } +} + +/// Registers a KUnit test suite. +/// +/// # Safety +/// +/// `test_cases` must be a NULL terminated array of valid test cases. +/// +/// # Examples +/// +/// ```ignore +/// extern "C" fn test_fn(_test: *mut kernel::bindings::kunit) { +/// let actual = 1 + 1; +/// let expected = 2; +/// assert_eq!(actual, expected); +/// } +/// +/// static mut KUNIT_TEST_CASES: [kernel::bindings::kunit_case; 2] = [ +/// kernel::kunit::kunit_case(kernel::c_str!("name"), test_fn), +/// kernel::kunit::kunit_case_null(), +/// ]; +/// kernel::kunit_unsafe_test_suite!(suite_name, KUNIT_TEST_CASES); +/// ``` +#[doc(hidden)] +#[macro_export] +macro_rules! kunit_unsafe_test_suite { + ($name:ident, $test_cases:ident) => { +const _: () = { +const KUNIT_TEST_SUITE_NAME : [::kernel::ffi::c_char ;256 ] = { +let name_u8 = ::core::stringify!($name).as_bytes (); +let mut ret = [0 ;256 ]; + +if name_u8.len () >255 { +panic! (concat! ( +"The test suite name `" , + ::core::stringify!($name), +"` exceeds the maximum length of 255 bytes." + )); + } + +let mut i =0 ; +while i < name_u8.len () { + ret[i] = name_u8[i]as ::kernel::ffi::c_char ; + i +=1 ; + } + + ret + }; + +static mut KUNIT_TEST_SUITE : ::kernel::bindings::kunit_suite = + ::kernel::bindings::kunit_suite { + name:KUNIT_TEST_SUITE_NAME , +#[allow(unused_unsafe)] +// SAFETY: User is expected to pass a correct `test_cases`, given the safety +// precondition; hence this macro named `unsafe`. + test_cases:unsafe { + ::core::ptr::addr_of_mut!($test_cases) + .cast ::<::kernel::bindings::kunit_case >() + }, + suite_init:None , + suite_exit:None , + init:None , + exit:None , + attr: ::kernel::bindings::kunit_attributes { + speed: ::kernel::bindings::kunit_speed_KUNIT_SPEED_NORMAL, + }, + status_comment: [0 ;256usize ], + debugfs: ::core::ptr::null_mut (), + log: ::core::ptr::null_mut (), + suite_init_err:0 , + is_init:false , + }; + +#[used] +#[allow(unused_unsafe)] +#[cfg_attr(not(target_os = "macos" ), link_section = ".kunit_test_suites" )] +static mut KUNIT_TEST_SUITE_ENTRY : *const ::kernel::bindings::kunit_suite = +// SAFETY: `KUNIT_TEST_SUITE` is static. +unsafe { ::core::ptr::addr_of_mut!(KUNIT_TEST_SUITE ) }; + }; + }; +}
Signature · 1 line
2.48.1.601.g30ceb7b040-goog
PATCH v7 2/3 rust: macros: add macro to easily run KUnit tests
In reply to David GowFrom: José Expósito <[email protected]>
Add a new procedural macro (#[kunit_tests(kunit_test_suit_name)]) to run KUnit tests using a user-space like syntax.
The macro, that should be used on modules, transforms every #[test] in a kunit_case! and adds a kunit_unsafe_test_suite! registering all of them.
The only difference with user-space tests is that instead of using #[cfg(test)], #[kunit_tests(kunit_test_suit_name)] is used.
Note that #[cfg(CONFIG_KUNIT)] is added so the test module is not compiled when CONFIG_KUNIT is set to n.
---
Changes since v6:
https://lore.kernel.org/rust-for-linux/[email protected]/
- Fixed an [allow(unused_unsafe)] which ended up in patch 2 instead of patch 1. (Thanks, Tamir!)
- Add Tamir's Reviewed-by tag.
Changes since v5:
https://lore.kernel.org/all/[email protected]/
- Fix some rustfmt-related formatting shenanigans. (Thanks, Miguel)
- Fix some documentation comment formatting as well. (Thanks, Miguel)
- Tidy up the generated code to avoid unneeded &mut[] everywhere. (Thanks, Miguel)
- Fix a new clippy warning for using .as_bytes().len() instead of .len() directly.
Changes since v4:
https://lore.kernel.org/linux-kselftest/[email protected]/
- Rebased against 6.13-rc1
- "Expect" that the sample assert_eq!(1+1, 2) produces a clippy warning due to a redundant assertion. (Thanks Boqun, Miguel)
Changes since v3:
https://lore.kernel.org/linux-kselftest/[email protected]/
- The #[kunit_tests()] macro now preserves span information, so errors can be better reported. (Thanks, Boqun!)
- The example test has been replaced to no longer use assert_eq!() with a constant bool argument (which triggered a clippy warning now we have the span info). It now checks 1 + 1 == 2, to match the C example.
- (The in_kunit_test() test in the next patch uses assert!() to check a bool, so having something different here seemed to make a better example.)
Changes since v2:
https://lore.kernel.org/linux-kselftest/[email protected]/
- Include missing rust/macros/kunit.rs file from v2. (Thanks Boqun!)
- The proc macro now emits an error if the suite name is too long.
Changes since v1:
https://lore.kernel.org/lkml/[email protected]/
- Rebased on top of rust-next
- Make use of the new const functions, rather than the kunit_case!() macro.
--- MAINTAINERS | 1 + rust/kernel/kunit.rs | 11 +++ rust/macros/kunit.rs | 161 +++++++++++++++++++++++++++++++++++++++++++ rust/macros/lib.rs | 29 ++++++++ 4 files changed, 202 insertions(+) create mode 100644 rust/macros/kunit.rs
MAINTAINERS +1 -0
@@ -12677,6 +12677,7 @@ F: Documentation/dev-tools/kunit/ F: include/kunit/ F: lib/kunit/ F: rust/kernel/kunit.rs +F: rust/macros/kunit.rs F: scripts/rustdoc_test_* F: tools/testing/kunit/
rust/kernel/kunit.rs +11 -0
@@ -40,6 +40,8 @@ pub fn info(args: fmt::Arguments<'_>) { } } +use macros::kunit_tests; +/// Asserts that a boolean expression is `true` at runtime. /// /// Public but hidden since it should only be used from generated tests.
@@ -283,3 +285,12 @@ macro_rules! kunit_unsafe_test_suite { }; }; } + +#[kunit_tests(rust_kernel_kunit)] +mod tests { +#[test] +fn rust_test_kunit_example_test () { +#![expect(clippy::eq_op)] +assert_eq! (1 +1 ,2 ); + } +}
rust/macros/kunit.rs new file +161 -0
161 lines not on this page · raw message
rust/macros/lib.rs +29 -0
@@ -10,6 +10,7 @@mod quote;mod concat_idents;mod helpers; +mod kunit;mod module;mod paste;mod pin_data;
@@ -492,3 +493,31 @@ pub fn paste(input: TokenStream) -> TokenStream {pub fn derive_zeroable (input:TokenStream ) ->TokenStream { zeroable::derive (input) } + +/// Registers a KUnit test suite and its test cases using a user-space like syntax. +/// +/// This macro should be used on modules. If `CONFIG_KUNIT` (in `.config`) is `n`, the target module +/// is ignored. +/// +/// # Examples +/// +/// ```ignore +/// # use macros::kunit_tests; +/// +/// #[kunit_tests(kunit_test_suit_name)] +/// mod tests { +/// #[test] +/// fn foo() { +/// assert_eq!(1, 1); +/// } +/// +/// #[test] +/// fn bar() { +/// assert_eq!(2, 2); +/// } +/// } +/// ``` +#[proc_macro_attribute] +pub fn kunit_tests (attr:TokenStream , ts:TokenStream ) ->TokenStream { + kunit::kunit_tests (attr, ts) +}
Signature · 1 line
2.48.1.601.g30ceb7b040-goog
PATCH v7 3/3 rust: kunit: allow to know if we are in a test
In reply to David GowFrom: José Expósito <[email protected]>
In some cases, we need to call test-only code from outside the test case, for example, to mock a function or a module.
In order to check whether we are in a test or not, we need to test if CONFIG_KUNIT is set.
Unfortunately, we cannot rely only on this condition because:
- a test could be running in another thread,
- some distros compile KUnit in production kernels, so checking at runtime that current->kunit_test != NULL is required.
Forturately, KUnit provides an optimised check in kunit_get_current_test(), which checks CONFIG_KUNIT, a global static key, and then the current thread's running KUnit test.
Add a safe wrapper function around this to know whether or not we are in a KUnit test and examples showing how to mock a function and a module.
---
Changes since v6:
https://lore.kernel.org/rust-for-linux/[email protected]/
- Doc comments now have a useful link. (Thanks, Tamir!)
- A small tidy-up to limit unsafe usage. (Thanks, Tamir!)
Changes since v5:
https://lore.kernel.org/all/[email protected]/
- Greatly improved documentation, which is both clearer and better matches the rustdoc norm. (Thanks, Miguel)
- The examples and safety comments are also both more idiomatic an cleaner. (Thanks, Miguel)
- More things sit appropriately behind CONFIG_KUNIT (Thanks, Miguel)
Changes since v4:
https://lore.kernel.org/linux-kselftest/[email protected]/
- Rebased against 6.13-rc1
- Fix some missing safety comments, and remove some unneeded 'unsafe' blocks. (Thanks Boqun)
Changes since v3:
https://lore.kernel.org/linux-kselftest/[email protected]/
- The example test has been updated to no longer use assert_eq!() with a constant bool argument (fixes a clippy warning).
No changes since v2:
https://lore.kernel.org/linux-kselftest/[email protected]/
Changes since v1:
https://lore.kernel.org/lkml/[email protected]/
- Rebased on top of rust-next.
- Use the kunit_get_current_test() C function, which wasn't previously available, instead of rolling our own.
- (Thanks also to Boqun for suggesting a nicer way of implementing this, which I tried, but the kunit_get_current_test() version obsoleted.)
--- rust/kernel/kunit.rs | 66 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+)
rust/kernel/kunit.rs +66 -0
@@ -286,11 +286,77 @@ macro_rules! kunit_unsafe_test_suite { }; } +/// Returns whether we are currently running a KUnit test. +/// +/// In some cases, you need to call test-only code from outside the test case, for example, to +/// create a function mock. This function allows to change behavior depending on whether we are +/// currently running a KUnit test or not. +/// +/// # Examples +/// +/// This example shows how a function can be mocked to return a well-known value while testing: +/// +/// ``` +/// # use kernel::kunit::in_kunit_test; +/// fn fn_mock_example(n: i32) -> i32 { +/// if in_kunit_test() { +/// return 100; +/// } +/// +/// n + 1 +/// } +/// +/// let mock_res = fn_mock_example(5); +/// assert_eq!(mock_res, 100); +/// ``` +/// +/// Sometimes, you don't control the code that needs to be mocked. This example shows how the +/// [`bindings`] module can be mocked: +/// +/// ``` +/// // Import our mock naming it as the real module. +/// #[cfg(CONFIG_KUNIT)] +/// use bindings_mock_example as bindings; +/// #[cfg(not(CONFIG_KUNIT))] +/// use kernel::bindings; +/// +/// // This module mocks `bindings`. +/// #[cfg(CONFIG_KUNIT)] +/// mod bindings_mock_example { +/// /// Mock `ktime_get_boot_fast_ns` to return a well-known value when running a KUnit test. +/// pub(crate) fn ktime_get_boot_fast_ns() -> u64 { +/// 1234 +/// } +/// } +/// +/// // This is the function we want to test. Since `bindings` has been mocked, we can use its +/// // functions seamlessly. +/// fn get_boot_ns() -> u64 { +/// // SAFETY: `ktime_get_boot_fast_ns()` is always safe to call. +/// unsafe { bindings::ktime_get_boot_fast_ns() } +/// } +/// +/// let time = get_boot_ns(); +/// assert_eq!(time, 1234); +/// ``` +pub fn in_kunit_test () ->bool { +// SAFETY: `kunit_get_current_test()` is always safe to call (it has fallbacks for +// when KUnit is not enabled). + !unsafe { bindings::kunit_get_current_test () }.is_null () +} +#[kunit_tests(rust_kernel_kunit)] mod tests { +use super ::*; +#[test] fn rust_test_kunit_example_test () {#![expect(clippy::eq_op)] assert_eq! (1 +1 ,2 ); } + +#[test] +fn rust_test_kunit_in_kunit_test () { +assert! (in_kunit_test ()); + } }
Signature · 1 line
2.48.1.601.g30ceb7b040-goog