| Message ID | 20241029092422.2884505-1-davidgow@google.com |
|---|---|
| Headers | show |
| Series | rust: kunit: Support KUnit tests with a user-space like syntax | expand |
On Wed, Oct 30, 2024 at 5:59 AM David Gow <davidgow@google.com> wrote: > > On Tue, 29 Oct 2024 at 20:08, Alice Ryhl <aliceryhl@google.com> wrote: > > > > On Tue, Oct 29, 2024 at 10:24 AM David Gow <davidgow@google.com> wrote: > > > > > > From: José Expósito <jose.exposito89@gmail.com> > > > > > > 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. > > > > > > Signed-off-by: José Expósito <jose.exposito89@gmail.com> > > > Co-developed-by: Matt Gilbride <mattgilbride@google.com> > > > Signed-off-by: Matt Gilbride <mattgilbride@google.com> > > > Co-developed-by: David Gow <davidgow@google.com> > > > Signed-off-by: David Gow <davidgow@google.com> > > > --- > > > > > > Changes since v1: > > > https://lore.kernel.org/lkml/20230720-rustbind-v1-1-c80db349e3b5@google.com/ > > > - 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 | 108 +++++++++++++++++++++++++++++++++++++++++++ > > > rust/kernel/lib.rs | 1 + > > > 2 files changed, 109 insertions(+) > > > > > > diff --git a/rust/kernel/kunit.rs b/rust/kernel/kunit.rs > > > index 824da0e9738a..fc2d259db458 100644 > > > --- a/rust/kernel/kunit.rs > > > +++ b/rust/kernel/kunit.rs > > > @@ -161,3 +161,111 @@ macro_rules! kunit_assert_eq { > > > $crate::kunit_assert!($name, $file, $diff, $left == $right); > > > }}; > > > } > > > + > > > +/// Represents an individual test case. > > > +/// > > > +/// The test case should have the signature > > > +/// `unsafe extern "C" fn test_case(test: *mut crate::bindings::kunit)`. > > > +/// > > > +/// The `kunit_unsafe_test_suite!` macro expects a NULL-terminated list of test cases. > > > +/// Use `kunit_case_null` to generate such a delimeter. > > > +const fn kunit_case(name: &kernel::str::CStr, run_case: unsafe extern "C" fn(*mut kernel::bindings::kunit)) -> kernel::bindings::kunit_case { > > > > This should probably say `name: &'static CStr` to require that the > > name lives forever. > > Fixed in v3, thanks. > > > > +/// Registers a KUnit test suite. > > > +/// > > > +/// # Safety > > > +/// > > > +/// `test_cases` must be a NULL terminated array of test cases. > > > +/// > > > +/// # Examples > > > +/// > > > +/// ```ignore > > > +/// unsafe extern "C" fn test_fn(_test: *mut crate::bindings::kunit) { > > > +/// let actual = 1 + 1; > > > +/// let expected = 2; > > > +/// assert_eq!(actual, expected); > > > +/// } > > > +/// > > > +/// static mut KUNIT_TEST_CASE: crate::bindings::kunit_case = crate::kunit_case(name, test_fn); > > > +/// static mut KUNIT_NULL_CASE: crate::bindings::kunit_case = crate::kunit_case_null(); > > > +/// static mut KUNIT_TEST_CASES: &mut[crate::bindings::kunit_case] = unsafe { > > > +/// &mut[KUNIT_TEST_CASE, KUNIT_NULL_CASE] > > > +/// }; > > > +/// crate::kunit_unsafe_test_suite!(suite_name, KUNIT_TEST_CASES); > > > +/// ``` > > > +#[macro_export] > > > +macro_rules! kunit_unsafe_test_suite { > > > + ($name:ident, $test_cases:ident) => { > > > + const _: () = { > > > + static KUNIT_TEST_SUITE_NAME: [i8; 256] = { > > > + let name_u8 = core::stringify!($name).as_bytes(); > > > + let mut ret = [0; 256]; > > > + > > > + let mut i = 0; > > > + while i < name_u8.len() { > > > + ret[i] = name_u8[i] as i8; > > > + i += 1; > > > + } > > > > I assume the name must be zero-terminated? If so, you probably need to > > enforce that somehow, e.g. by failing if `name_u8` is longer than 255 > > bytes. > > Nice catch. I'm not sure how to nicely throw a compile time error in > this function, so I'm truncating it here and doing a compile error in > the macro in patch #2. This isn't ideal, but seems to work. You should be able to just panic! if it happens. Also, I believe it should be i < 255 instead of 256? Alice
This series was originally written by José Expósito, and has been modified and updated by Matt Gilbride 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 v1: https://lore.kernel.org/lkml/20230720-rustbind-v1-0-c80db349e3b5@google.com/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/20230503090708.2524310-6-nmi@metaspace.dk/ - 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 | 191 +++++++++++++++++++++++++++++++++++++++++++ rust/kernel/lib.rs | 1 + rust/macros/lib.rs | 29 +++++++ 4 files changed, 222 insertions(+)