From patchwork Thu Jul 20 06:38:52 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: David Gow X-Patchwork-Id: 704779 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id A5181EB64DA for ; Thu, 20 Jul 2023 06:40:59 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230516AbjGTGk7 (ORCPT ); Thu, 20 Jul 2023 02:40:59 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48270 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231234AbjGTGkn (ORCPT ); Thu, 20 Jul 2023 02:40:43 -0400 Received: from mail-yw1-x114a.google.com (mail-yw1-x114a.google.com [IPv6:2607:f8b0:4864:20::114a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id AA1053594 for ; Wed, 19 Jul 2023 23:40:06 -0700 (PDT) Received: by mail-yw1-x114a.google.com with SMTP id 00721157ae682-57704aace46so5101437b3.2 for ; Wed, 19 Jul 2023 23:40:06 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20221208; t=1689835200; x=1690440000; h=content-transfer-encoding:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:from:to:cc:subject:date:message-id :reply-to; bh=EPm0nt3jgFstVkuP2L4I35/ImZIIIbkQiLEGJDnMhOQ=; b=68FGNx3i914y2L8NGEkfyE+WJUK8YVUoYjjrHxNQrhrZIS5NkcY4CsAhDke0igeMZq lqjYx2csTSo+bHRoVhMFJu7BQZhHOwmsLJCXdBV264iGosUApSlREqcy4sHpzdlKj4Po Wxq/0PhkHH4a3epUVcE6b8NK3sR3Vpm/TwFf/25FmBGvknU3Fm6pMZDQQxeuj3mMa/6e wo9Wz0HQFTnTM+ZeIzLa5c9iBam6dxhVY2sPT/RCU1lAPVaoLuEFK2YXLcQdF/6fpn1p LevtoOgLMWrWL/nIN+VGRpCMG3P8cPAXLf02SCcDM/PMG9Vc7OrfxQWokQUkg8xmiaZM OdSg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1689835200; x=1690440000; h=content-transfer-encoding:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:x-gm-message-state:from:to:cc:subject :date:message-id:reply-to; bh=EPm0nt3jgFstVkuP2L4I35/ImZIIIbkQiLEGJDnMhOQ=; b=jzOHlUFktXY00W8S20YRbcoSeTNB6OSwQEPjknx4tSSt/ORfHZEDlESVzsEoCvdSi5 r9muz+jjRT47d9v0HpI6vOFYmdp804W1A9ph0kjgDKkp2XAM46tqGTorSPSF7AEtj++H g/f8fwY3h9s4xJk8ZCqHSClyK2KwTX/pBZnSmX/Fze1ZqcVxn886rRA3ZHF8juaTUziq 8DKnNx18H2o7BDIXs1tNzg3+xf8lJIBWCPcUp5HJtuv5knbFPJ7uIcVOYQKxMTrIVK6a qQCMU0KTYnESxlnsvp9LpAm9HfHxD/TWlmCNTyzTT4Ey/pZTe/+ASBOfNeqAcVPf922I 3gOg== X-Gm-Message-State: ABy/qLba6mJkjVDd8ZzS4jfNu2bpNiB4JQbIxR06IWLkicKmi8chgg2k vmNmGvA4sme6aXy1bu3PcmBEC7F6BVGnQw== X-Google-Smtp-Source: APBJJlEYtOGTyGW4H6yu13iwVeXqAIY5pd2NT3yxl3I7xNQAl6xpuQJ70UqwBpQ/xc2eQZIsIITWEtYoegc0Fw== X-Received: from slicestar.c.googlers.com ([fda3:e722:ac3:cc00:4f:4b78:c0a8:20a1]) (user=davidgow job=sendgmr) by 2002:a81:c50a:0:b0:55a:3133:86fa with SMTP id k10-20020a81c50a000000b0055a313386famr199503ywi.3.1689835200553; Wed, 19 Jul 2023 23:40:00 -0700 (PDT) Date: Thu, 20 Jul 2023 14:38:52 +0800 In-Reply-To: <20230720-rustbind-v1-0-c80db349e3b5@google.com> Mime-Version: 1.0 References: <20230720-rustbind-v1-0-c80db349e3b5@google.com> X-Mailer: b4 0.13-dev-099c9 Message-ID: <20230720-rustbind-v1-1-c80db349e3b5@google.com> Subject: [PATCH 1/3] rust: kunit: add KUnit case and suite macros From: David Gow To: Brendan Higgins , Miguel Ojeda , Alex Gaynor , Wedson Almeida Filho , Boqun Feng , Gary Guo , Benno Lossin Cc: David Gow , " =?utf-8?b?Sm9zw6kgRXhww7NzaXRv?= " , " =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= " , linux-kselftest@vger.kernel.org, kunit-dev@googlegroups.com, rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kselftest@vger.kernel.org From: José Expósito Add a couple of Rust 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. - The `kunit_case!` Rust macro is similar to the `KUNIT_CASE` C macro. It can be used with parameters to generate a test case or without parameters to be used as delimiter in `kunit_test_suite!`. While these macros can be used on their own, a future patch will introduce another macro to create KUnit tests using a user-space like syntax. Co-developed-by: David Gow Signed-off-by: David Gow Signed-off-by: José Expósito --- rust/kernel/kunit.rs | 92 ++++++++++++++++++++++++++++++++++++++++++++++++++++ rust/kernel/lib.rs | 1 + 2 files changed, 93 insertions(+) diff --git a/rust/kernel/kunit.rs b/rust/kernel/kunit.rs index 722655b2d62d..4cffc71e463b 100644 --- a/rust/kernel/kunit.rs +++ b/rust/kernel/kunit.rs @@ -161,3 +161,95 @@ 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. This macro +/// can be invoked without parameters to generate the delimiter. +#[macro_export] +macro_rules! kunit_case { + () => { + $crate::bindings::kunit_case { + run_case: None, + name: core::ptr::null_mut(), + generate_params: None, + status: $crate::bindings::kunit_status_KUNIT_SUCCESS, + log: core::ptr::null_mut(), + } + }; + ($name:ident, $run_case:ident) => { + $crate::bindings::kunit_case { + run_case: Some($run_case), + name: $crate::c_str!(core::stringify!($name)).as_char_ptr(), + generate_params: None, + status: $crate::bindings::kunit_status_KUNIT_SUCCESS, + log: core::ptr::null_mut(), + } + }; +} + +/// 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!(); +/// 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; + } + + ret + }; + + // SAFETY: `test_cases` is valid as it should be static. + static mut KUNIT_TEST_SUITE: core::cell::UnsafeCell<$crate::bindings::kunit_suite> = + core::cell::UnsafeCell::new($crate::bindings::kunit_suite { + name: KUNIT_TEST_SUITE_NAME, + test_cases: unsafe { $test_cases.as_mut_ptr() }, + suite_init: None, + suite_exit: None, + init: None, + exit: None, + status_comment: [0; 256usize], + debugfs: core::ptr::null_mut(), + log: core::ptr::null_mut(), + suite_init_err: 0, + }); + + // SAFETY: `KUNIT_TEST_SUITE` is static. + #[used] + #[link_section = ".kunit_test_suites"] + static mut KUNIT_TEST_SUITE_ENTRY: *const $crate::bindings::kunit_suite = + unsafe { KUNIT_TEST_SUITE.get() }; + }; + }; +} diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index 3642cadc34b1..ec81fd28d71a 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -18,6 +18,7 @@ #![feature(new_uninit)] #![feature(receiver_trait)] #![feature(unsize)] +#![feature(const_mut_refs)] // Ensure conditional compilation based on the kernel configuration works; // otherwise we may silently break things like initcall handling. From patchwork Thu Jul 20 06:38:54 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: David Gow X-Patchwork-Id: 704778 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id E7788EB64DD for ; Thu, 20 Jul 2023 06:41:20 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231360AbjGTGlU (ORCPT ); Thu, 20 Jul 2023 02:41:20 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48258 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231334AbjGTGk6 (ORCPT ); Thu, 20 Jul 2023 02:40:58 -0400 Received: from mail-yb1-xb49.google.com (mail-yb1-xb49.google.com [IPv6:2607:f8b0:4864:20::b49]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id BBD2B35A6 for ; Wed, 19 Jul 2023 23:40:22 -0700 (PDT) Received: by mail-yb1-xb49.google.com with SMTP id 3f1490d57ef6-c5cea5773e8so445963276.1 for ; Wed, 19 Jul 2023 23:40:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20221208; t=1689835209; x=1690440009; h=content-transfer-encoding:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:from:to:cc:subject:date:message-id :reply-to; bh=i3Gim78LlW0ImU8Nf7KfkXlFKv0mM0hU/1p3btyr4nM=; b=5f9C5eFXQp0hGJsDoxGCFRckc7Px3DcrknxoAjktifh5StDa+zVV6XWxRyWl4wpUPD 2biiL+iilf0AgDI5sxpf7W8VW2o0Ux3ZuggzoLmM7PLy8Z3I7GtxySWk8m0rZZelUNRE b5/PlSp8f59mHceQUG85M8pnRcVcV4A8ywL9iY1GwLH8GJZ7rvmTDJSt7644yc1aLCaA ZhyM3Rj69OEIFlI4947vSLvC36fFxWnjkMCqrdbw/aScWuf6p3TgnB15frSw0eE8uYlm /9lOVmJGVLAqX/jHl5ozL85NB1xCDQNkvCsYR2J83zbZ+G9ODeeKJ8pYFrPrxCvliuaF uocQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1689835209; x=1690440009; h=content-transfer-encoding:cc:to:from:subject:message-id:references :mime-version:in-reply-to:date:x-gm-message-state:from:to:cc:subject :date:message-id:reply-to; bh=i3Gim78LlW0ImU8Nf7KfkXlFKv0mM0hU/1p3btyr4nM=; b=ZJoXcz+tV9A0LxCaTTmRUnzuOW6p+FBtKomrmxTWEMeY+8bvyf60/rPcOeJdttCYbe ZDamR0zpq4NxUBJJpGC4fLjQot22gGj2LFZT1i8HdxfvZ1zIhc4MctQXnJjRMpDPwkFS HNQ0vLB6ri5gRlX2XND+qv6XxaOqFkgLMqHCAyHjnNA4mTKtdVvb3xmoxeXGOddWaACk 8FZPyIUcrmn30dewLr0I/teyur0J6NNI+zL14RgMwGKixGnmnY9KCNypQumNe3F1t1Rm Ymi7Fd2PEi8tnTMoEZi9Nrf5HUBRhIBeiaO85FmQenCsDS1mQikl40jKs0UQ8dJoZAn0 kQvA== X-Gm-Message-State: ABy/qLZVRnytmlFtHY+ja5jUOxidz6llvvIa3htclzIVeGxVygh/663i J/AbWtInrdtFuYphFtIUALJjDaaT4El9Qw== X-Google-Smtp-Source: APBJJlHksrDL5l4lPhnUlz0GtDMHq3IdfMTmcbYys5NVadOWYhr90nEPMgb/oWaI2BQLgYCE4qQc7zXkQFJhtw== X-Received: from slicestar.c.googlers.com ([fda3:e722:ac3:cc00:4f:4b78:c0a8:20a1]) (user=davidgow job=sendgmr) by 2002:a05:6902:1709:b0:ccf:6bfa:2a03 with SMTP id by9-20020a056902170900b00ccf6bfa2a03mr37240ybb.7.1689835209388; Wed, 19 Jul 2023 23:40:09 -0700 (PDT) Date: Thu, 20 Jul 2023 14:38:54 +0800 In-Reply-To: <20230720-rustbind-v1-0-c80db349e3b5@google.com> Mime-Version: 1.0 References: <20230720-rustbind-v1-0-c80db349e3b5@google.com> X-Mailer: b4 0.13-dev-099c9 Message-ID: <20230720-rustbind-v1-3-c80db349e3b5@google.com> Subject: [PATCH 3/3] rust: kunit: allow to know if we are in a test From: David Gow To: Brendan Higgins , Miguel Ojeda , Alex Gaynor , Wedson Almeida Filho , Boqun Feng , Gary Guo , Benno Lossin Cc: David Gow , " =?utf-8?b?Sm9zw6kgRXhww7NzaXRv?= " , " =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= " , linux-kselftest@vger.kernel.org, kunit-dev@googlegroups.com, rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kselftest@vger.kernel.org From: José Expósito In some cases, you 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 some distros compile KUnit in production kernels, so checking at runtime that `current->kunit_test != NULL` is required. Note that the C function `kunit_get_current_test()` can not be used because it is not present in the current Rust tree yet. Once it is available we might want to change our Rust wrapper to use it. This patch adds a function to know whether we are in a KUnit test or not and examples showing how to mock a function and a module. Reviewed-by: David Gow Signed-off-by: José Expósito --- rust/kernel/kunit.rs | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) diff --git a/rust/kernel/kunit.rs b/rust/kernel/kunit.rs index 44ea67028316..dcaac19bb108 100644 --- a/rust/kernel/kunit.rs +++ b/rust/kernel/kunit.rs @@ -40,6 +40,8 @@ pub fn info(args: fmt::Arguments<'_>) { } } +use crate::task::Task; +use core::ops::Deref; use macros::kunit_tests; /// Asserts that a boolean expression is `true` at runtime. @@ -256,11 +258,87 @@ macro_rules! kunit_unsafe_test_suite { }; } +/// In some cases, you need to call test-only code from outside the test case, for example, to +/// create a function mock. This function can be invoked to know 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() { +/// 100 +/// } else { +/// 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; +/// +/// // This module mocks `bindings`. +/// mod bindings_mock_example { +/// use kernel::kunit::in_kunit_test; +/// use kernel::bindings::u64_; +/// +/// // Make the other binding functions available. +/// pub(crate) use kernel::bindings::*; +/// +/// // Mock `ktime_get_boot_fast_ns` to return a well-known value when running a KUnit test. +/// pub(crate) unsafe fn ktime_get_boot_fast_ns() -> u64_ { +/// if in_kunit_test() { +/// 1234 +/// } else { +/// unsafe { kernel::bindings::ktime_get_boot_fast_ns() } +/// } +/// } +/// } +/// +/// // This is the function we want to test. Since `bindings` has been mocked, we can use its +/// // functions seamlessly. +/// fn get_boot_ns() -> u64 { +/// unsafe { bindings::ktime_get_boot_fast_ns() } +/// } +/// +/// let time = get_boot_ns(); +/// assert_eq!(time, 1234); +/// ``` +pub fn in_kunit_test() -> bool { + if cfg!(CONFIG_KUNIT) { + // SAFETY: By the type invariant, we know that `*Task::current().deref().0` is valid. + let test = unsafe { (*Task::current().deref().0.get()).kunit_test }; + !test.is_null() + } else { + false + } +} + #[kunit_tests(rust_kernel_kunit)] mod tests { + use super::*; + #[test] fn rust_test_kunit_kunit_tests() { let running = true; assert_eq!(running, true); } + + #[test] + fn rust_test_kunit_in_kunit_test() { + let in_kunit = in_kunit_test(); + assert_eq!(in_kunit, true); + } }