From nobody Tue Jun 30 15:33:12 2026 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 18FB9C433FE for ; Thu, 13 Jan 2022 16:59:53 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236967AbiAMQ7v (ORCPT ); Thu, 13 Jan 2022 11:59:51 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42580 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236940AbiAMQ7u (ORCPT ); Thu, 13 Jan 2022 11:59:50 -0500 Received: from mail-yb1-xb4a.google.com (mail-yb1-xb4a.google.com [IPv6:2607:f8b0:4864:20::b4a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6BF51C06161C for ; Thu, 13 Jan 2022 08:59:50 -0800 (PST) Received: by mail-yb1-xb4a.google.com with SMTP id a84-20020a251a57000000b0061171f19f8dso12428992yba.13 for ; Thu, 13 Jan 2022 08:59:50 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=56DWaENCHRMghpIV1icK93qpW14DeDvo1W7ZsO3A1B8=; b=I5pIXTSreNu/k26AmGVwEGt4v2BG9gVUdimQLEIzP2yDG+po2TLOs8+n4YOx7yafNx E8KY4MlzJmUK98afez6V5EOJ6cg9vnJZEpzFozgu3RpBLLKFL2ZAMyEQ5Ybv2FC6rx01 gHNbsI8qIatOXJzxeophN43v6akkKvTXePv4lo166QpDR3qW5S77cfKrR5YrqIf+7ETL c5kcdJ7XDmEG4h43G8IEjhBQgcLU3mXJPRG1qZKsXCbpmGWRaMBNYfomH0oBzuU+LI2k c6fvCz6kcKq0rJfAKNKVa8NDqdeHuhFdPL24YobQJeVRfJbziWiEVjpf7SDlJ9+xxFbX KmYw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=56DWaENCHRMghpIV1icK93qpW14DeDvo1W7ZsO3A1B8=; b=p9MNoEye9Id7vBsPu8zCXWcplS6TIzMNkgp151yjw9blgeJUL5wVjMp8NN2zRz3No6 m/GVy656H68SgMbJjlu/lvxOVkT/MaSPnbslpvAHU6y3v6tToQY54awkQEmAJfzUd9NK eB6j9bLP9FWfRQsc200lBQiTb4t6cOkPiihvjlfkclpQRJCOzZfk1DqJccZYKp7f6uHs HQR8AaLJ6p1R9TuUYdBCsCTxTTioQTyfaeJr1d/fp3MvKKTD0lCAc4lR2Q0Uy2qPgfXa ZYzVAh1ZJQvjBC28Knoif942dlKRh5FITjjCrLim7i+N8d9a6JP+pr4Md4uKUbyrBimR xu9g== X-Gm-Message-State: AOAM533b6YmeZxxXHF0MkSIzBTMA+YYsvJ0tJd3wIyp7QLu0expdbPru SjG6jj8uYroEccg0PV3tns7sgcTWwMUwSg== X-Google-Smtp-Source: ABdhPJxDCZZzIiLvvsZPEjr3S2+pReXde9HWQEBJ9XM+CW88mx/JVvUESeOutwQOk0fo1RWu6+F2h/2Em9LB7Q== X-Received: from dlatypov.svl.corp.google.com ([2620:15c:2cd:202:1a70:cede:4191:24bc]) (user=dlatypov job=sendgmr) by 2002:a25:c8c3:: with SMTP id y186mr7255985ybf.20.1642093189705; Thu, 13 Jan 2022 08:59:49 -0800 (PST) Date: Thu, 13 Jan 2022 08:59:26 -0800 In-Reply-To: <20220113165931.451305-1-dlatypov@google.com> Message-Id: <20220113165931.451305-2-dlatypov@google.com> Mime-Version: 1.0 References: <20220113165931.451305-1-dlatypov@google.com> X-Mailer: git-send-email 2.34.1.703.g22d0c6ccf7-goog Subject: [PATCH v3 1/6] kunit: add example test case showing off all the expect macros From: Daniel Latypov To: brendanhiggins@google.com, davidgow@google.com Cc: linux-kernel@vger.kernel.org, kunit-dev@googlegroups.com, linux-kselftest@vger.kernel.org, skhan@linuxfoundation.org, torvalds@linux-foundation.org, Daniel Latypov Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Currently, these macros are only really documented near the bottom of https://www.kernel.org/doc/html/latest/dev-tools/kunit/api/test.html#c.KUNI= T_FAIL. E.g. it's likely someone might just not realize that KUNIT_EXPECT_STREQ() exists and instead use KUNIT_EXPECT_FALSE(strcmp()) or similar. This can also serve as a basic smoketest that the KUnit assert machinery still works for all the macros. Signed-off-by: Daniel Latypov Reviewed-by: Brendan Higgins Reviewed-by: David Gow --- lib/kunit/kunit-example-test.c | 42 ++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/lib/kunit/kunit-example-test.c b/lib/kunit/kunit-example-test.c index 51099b0ca29c..4bbf37c04eba 100644 --- a/lib/kunit/kunit-example-test.c +++ b/lib/kunit/kunit-example-test.c @@ -69,6 +69,47 @@ static void example_mark_skipped_test(struct kunit *test) /* This line should run */ kunit_info(test, "You should see this line."); } + +/* + * This test shows off all the types of KUNIT_EXPECT macros. + */ +static void example_all_expect_macros_test(struct kunit *test) +{ + /* Boolean assertions */ + KUNIT_EXPECT_TRUE(test, true); + KUNIT_EXPECT_FALSE(test, false); + + /* Integer assertions */ + KUNIT_EXPECT_EQ(test, 1, 1); /* check =3D=3D */ + KUNIT_EXPECT_GE(test, 1, 1); /* check >=3D */ + KUNIT_EXPECT_LE(test, 1, 1); /* check <=3D */ + KUNIT_EXPECT_NE(test, 1, 0); /* check !=3D */ + KUNIT_EXPECT_GT(test, 1, 0); /* check > */ + KUNIT_EXPECT_LT(test, 0, 1); /* check < */ + + /* Pointer assertions */ + KUNIT_EXPECT_NOT_ERR_OR_NULL(test, test); + KUNIT_EXPECT_PTR_EQ(test, NULL, NULL); + KUNIT_EXPECT_PTR_NE(test, test, NULL); + + /* String assertions */ + KUNIT_EXPECT_STREQ(test, "hi", "hi"); + KUNIT_EXPECT_STRNEQ(test, "hi", "bye"); + + /* + * There are also ASSERT variants of all of the above that abort test + * execution if they fail. Useful for memory allocations, etc. + */ + KUNIT_ASSERT_GT(test, sizeof(char), 0); + + /* + * There are also _MSG variants of all of the above that let you include + * additional text on failure. + */ + KUNIT_EXPECT_GT_MSG(test, sizeof(int), 0, "Your ints are 0-bit?!"); + KUNIT_ASSERT_GT_MSG(test, sizeof(int), 0, "Your ints are 0-bit?!"); +} + /* * Here we make a list of all the test cases we want to add to the test su= ite * below. @@ -83,6 +124,7 @@ static struct kunit_case example_test_cases[] =3D { KUNIT_CASE(example_simple_test), KUNIT_CASE(example_skip_test), KUNIT_CASE(example_mark_skipped_test), + KUNIT_CASE(example_all_expect_macros_test), {} }; =20 --=20 2.34.1.703.g22d0c6ccf7-goog From nobody Tue Jun 30 15:33:12 2026 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 C6EC0C433FE for ; Thu, 13 Jan 2022 16:59:59 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236984AbiAMQ76 (ORCPT ); Thu, 13 Jan 2022 11:59:58 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42592 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236940AbiAMQ7x (ORCPT ); Thu, 13 Jan 2022 11:59:53 -0500 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 CFAF3C061574 for ; Thu, 13 Jan 2022 08:59:52 -0800 (PST) Received: by mail-yb1-xb49.google.com with SMTP id y4-20020a5b0f44000000b00611862e546dso12529514ybr.7 for ; Thu, 13 Jan 2022 08:59:52 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=htEX0Gdel3WvnrwFTzCEywKa/by6HkwGkboy+SVwZjU=; b=r7xgrNXBkpxtb7Btc/Pz6rcxRHSntWOpNorE3R65+0/RZnrxZXubCJJGjB31cnpeFZ Bcjo0klWnDqTpZ5XDvmK+DhXWVbjW/iPbvoSLjZW4tsIrccSaKNTCyQLOgG3Grx43DQH X2j68HQV4XqPHVyIbPguwq4Wwbja8tpKvd+DWXb+NBX1X8l15HpiRL2DWK1hNp3EhfBI s7ISRX6gWiHeP12kFV3cN2JczdCRbFcry7x+YwCtEyU2F6us6yh+z0tc1D9RDafTZY0v CecQO0UlwUgfomVNMXBQqp/WR6VqQYKmObtYHGEqh0Or4eYDEpOam7lGlSCKh3epsTyV /6Mg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=htEX0Gdel3WvnrwFTzCEywKa/by6HkwGkboy+SVwZjU=; b=wnjI4uq9eXEqHrzkE7H5ejIJKm+VyCalzKTEBVhvijmkjg8epNhZ12YGIKI9VaDdYK Rhac0NoU68P53seEAOXlU1vFugYWrFw4FHgtkP5EWLYaazVYTMotKFBSdP34M+8+cjGh ZnHnTK4nVMLK2gvW15IsU4Sd8s9fxb0231CMc9TcfN02niKWm2I+J2AIrw5HzmFxaGI+ yip9GKg8GXvEnattXNqTWaOXuYpfK5VZL+95IN9tWmWmIalYY4Ir61qZ3uLWl8yrhSWR TDwUgoiPg1PakYXzckuLtAJehVQF+CKDaDFvX27eOR3/5dvMPbVgjB+wqqAI562Qh7cS byTw== X-Gm-Message-State: AOAM530A4059wNYBswCmkuKNJQx8esjWZrN4yZZnx0PLSMfHpTSYO1E/ YzYg1vrvX0tCC545UadGr+KPu3FwSBerBQ== X-Google-Smtp-Source: ABdhPJz2nhkjoOiJJsfBgAHqSQN3NqBVfT3Ry0IvLR7NIibiZ4/nhxW/IvzTIS4nUbhmF3d+ndZvUdPhsjPQgw== X-Received: from dlatypov.svl.corp.google.com ([2620:15c:2cd:202:1a70:cede:4191:24bc]) (user=dlatypov job=sendgmr) by 2002:a5b:b8f:: with SMTP id l15mr7287490ybq.433.1642093192096; Thu, 13 Jan 2022 08:59:52 -0800 (PST) Date: Thu, 13 Jan 2022 08:59:27 -0800 In-Reply-To: <20220113165931.451305-1-dlatypov@google.com> Message-Id: <20220113165931.451305-3-dlatypov@google.com> Mime-Version: 1.0 References: <20220113165931.451305-1-dlatypov@google.com> X-Mailer: git-send-email 2.34.1.703.g22d0c6ccf7-goog Subject: [PATCH v3 2/6] kunit: move check if assertion passed into the macros From: Daniel Latypov To: brendanhiggins@google.com, davidgow@google.com Cc: linux-kernel@vger.kernel.org, kunit-dev@googlegroups.com, linux-kselftest@vger.kernel.org, skhan@linuxfoundation.org, torvalds@linux-foundation.org, Daniel Latypov Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Currently the code always calls kunit_do_assertion() even though it does nothing when `pass` is true. This change moves the `if(!(pass))` check into the macro instead and renames the function to kunit_do_failed_assertion(). I feel this a bit easier to read and understand. This has the potential upside of avoiding a function call that does nothing most of the time (assuming your tests are passing) but comes with the downside of generating a bit more code and branches. We try to mitigate the branches by tagging them with `unlikely()`. This also means we don't have to initialize structs that we don't need, which will become a tiny bit more expensive if we switch over to using static variables to try and reduce stack usage. (There's runtime code to check if the variable has been initialized yet or not). Signed-off-by: Daniel Latypov Reviewed-by: Brendan Higgins Reviewed-by: David Gow --- include/kunit/test.h | 21 +++++++++++---------- lib/kunit/test.c | 13 ++++--------- 2 files changed, 15 insertions(+), 19 deletions(-) diff --git a/include/kunit/test.h b/include/kunit/test.h index b26400731c02..12cabd15449a 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -12,6 +12,7 @@ #include #include =20 +#include #include #include #include @@ -770,18 +771,18 @@ void __printf(2, 3) kunit_log_append(char *log, const= char *fmt, ...); */ #define KUNIT_SUCCEED(test) do {} while (0) =20 -void kunit_do_assertion(struct kunit *test, - struct kunit_assert *assert, - bool pass, - const char *fmt, ...); +void kunit_do_failed_assertion(struct kunit *test, + struct kunit_assert *assert, + const char *fmt, ...); =20 #define KUNIT_ASSERTION(test, pass, assert_class, INITIALIZER, fmt, ...) d= o { \ - struct assert_class __assertion =3D INITIALIZER; \ - kunit_do_assertion(test, \ - &__assertion.assert, \ - pass, \ - fmt, \ - ##__VA_ARGS__); \ + if (unlikely(!(pass))) { \ + struct assert_class __assertion =3D INITIALIZER; \ + kunit_do_failed_assertion(test, \ + &__assertion.assert, \ + fmt, \ + ##__VA_ARGS__); \ + } \ } while (0) =20 =20 diff --git a/lib/kunit/test.c b/lib/kunit/test.c index c7ed4aabec04..3a52c321c280 100644 --- a/lib/kunit/test.c +++ b/lib/kunit/test.c @@ -275,16 +275,11 @@ static void __noreturn kunit_abort(struct kunit *test) WARN_ONCE(true, "Throw could not abort from test!\n"); } =20 -void kunit_do_assertion(struct kunit *test, - struct kunit_assert *assert, - bool pass, - const char *fmt, ...) +void kunit_do_failed_assertion(struct kunit *test, + struct kunit_assert *assert, + const char *fmt, ...) { va_list args; - - if (pass) - return; - va_start(args, fmt); =20 assert->message.fmt =3D fmt; @@ -297,7 +292,7 @@ void kunit_do_assertion(struct kunit *test, if (assert->type =3D=3D KUNIT_ASSERTION) kunit_abort(test); } -EXPORT_SYMBOL_GPL(kunit_do_assertion); +EXPORT_SYMBOL_GPL(kunit_do_failed_assertion); =20 void kunit_init_test(struct kunit *test, const char *name, char *log) { --=20 2.34.1.703.g22d0c6ccf7-goog From nobody Tue Jun 30 15:33:12 2026 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 B4EC2C4321E for ; Thu, 13 Jan 2022 17:00:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236974AbiAMRAB (ORCPT ); Thu, 13 Jan 2022 12:00:01 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42616 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236983AbiAMQ74 (ORCPT ); Thu, 13 Jan 2022 11:59:56 -0500 Received: from mail-yb1-xb4a.google.com (mail-yb1-xb4a.google.com [IPv6:2607:f8b0:4864:20::b4a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 39C2FC06174E for ; Thu, 13 Jan 2022 08:59:55 -0800 (PST) Received: by mail-yb1-xb4a.google.com with SMTP id g7-20020a25bdc7000000b00611c616bc76so3388830ybk.5 for ; Thu, 13 Jan 2022 08:59:55 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=u4iAc9gxAQq/r0G2vgHfEGvHHBUUDic9BlUPFK7FeNE=; b=QFu38UvAcduik7BsqUfeSvJQC/Zf/AuZTjCeiybRqdTFHor74oJVX+V1Ckhk26iswf 2AMKdtlm8csJx8QesnejwviFRn5dkgolqX5LLlry2KZ+FGLGZyiYaKjiaKgLRVyPoZZr 0CEiha/OobMP2UciWgHzvP4Vf2aHHTXIl+mUqa+ypPSTh3pU+JhJa93AQPMNCkqJeORX cftGWRKDekWtEvqgBkoGHISoocIcQVBOaDBcA9ueasFoPAdlTX/flklZ+T5kZmVbBan3 3HOlqmcK4or75UfXXk7dpIcDgUvhiazPqzZpwU82lCY7YNl8qbr5DQ22kOKpezAXbHEt ReKg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=u4iAc9gxAQq/r0G2vgHfEGvHHBUUDic9BlUPFK7FeNE=; b=GZFowrnNZNkz9LmFz8pI/a1j/Z37b+hiXQsyYLgck8PoSL8HAOWNTbUAveIH20lJEM qAwCKldHeElspn108k6AqF8yiPMZO+QT52usniTUDAgU0q1SVyPPzJSaOCqkfh1c9xNx W9rFYybF2KBTUax+az4cfIx9D/scqJNRPLqp3vr1qmw4xUvr8mJjx3fVJDr1Ip8FAr4D 2Sag2/oC+lkIaEhIYiNgR7oM4fXMfOAHoqXGzdcWO5kEexqNf/PvCtnB7Q0uoMaD4X3Y bUlMMCgMjW0qAkyRuWk7zeTVetHSEsoWROMhDhqnHXSiA/Vy8v7gZi4Ih0gBK+U1RSX+ ZyIg== X-Gm-Message-State: AOAM5319nFGe/Farvrfb4Vfj0rUYhee38d8mGvPCaxY5MpK++HpGrebG GKaiUkFlxo21zF1sHbaruC6hEMFicxuBZA== X-Google-Smtp-Source: ABdhPJzS6F2bz7aHdaq54vjO4kf7bFMJORVsFWAkU3830zaH9WcRJF6e/+6zU3+IWu5wlfcaPA5tTPgqTt0wtg== X-Received: from dlatypov.svl.corp.google.com ([2620:15c:2cd:202:1a70:cede:4191:24bc]) (user=dlatypov job=sendgmr) by 2002:a5b:3ce:: with SMTP id t14mr6700833ybp.361.1642093194530; Thu, 13 Jan 2022 08:59:54 -0800 (PST) Date: Thu, 13 Jan 2022 08:59:28 -0800 In-Reply-To: <20220113165931.451305-1-dlatypov@google.com> Message-Id: <20220113165931.451305-4-dlatypov@google.com> Mime-Version: 1.0 References: <20220113165931.451305-1-dlatypov@google.com> X-Mailer: git-send-email 2.34.1.703.g22d0c6ccf7-goog Subject: [PATCH v3 3/6] kunit: drop unused kunit* field in kunit_assert From: Daniel Latypov To: brendanhiggins@google.com, davidgow@google.com Cc: linux-kernel@vger.kernel.org, kunit-dev@googlegroups.com, linux-kselftest@vger.kernel.org, skhan@linuxfoundation.org, torvalds@linux-foundation.org, Daniel Latypov Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" The `struct kunit* test` field in kunit_assert is unused. Note: string_stream needs it, but it has its own `test` field. I assume `test` in `kunit_assert` predates this and was leftover after some refactoring. This patch removes the field and cleans up the macros to avoid needlessly passing around `test`. Signed-off-by: Daniel Latypov Reviewed-by: Brendan Higgins Reviewed-by: David Gow --- include/kunit/assert.h | 45 ++++++++++++------------------------------ include/kunit/test.h | 14 +++++-------- 2 files changed, 18 insertions(+), 41 deletions(-) diff --git a/include/kunit/assert.h b/include/kunit/assert.h index ad889b539ab3..3da6c792496c 100644 --- a/include/kunit/assert.h +++ b/include/kunit/assert.h @@ -30,7 +30,6 @@ enum kunit_assert_type { =20 /** * struct kunit_assert - Data for printing a failed assertion or expectati= on. - * @test: the test case this expectation/assertion is associated with. * @type: the type (either an expectation or an assertion) of this kunit_a= ssert. * @line: the source code line number that the expectation/assertion is at. * @file: the file path of the source file that the expectation/assertion = is in. @@ -41,7 +40,6 @@ enum kunit_assert_type { * format a string to a user reporting the failure. */ struct kunit_assert { - struct kunit *test; enum kunit_assert_type type; int line; const char *file; @@ -60,14 +58,12 @@ struct kunit_assert { =20 /** * KUNIT_INIT_ASSERT_STRUCT() - Initializer for a &struct kunit_assert. - * @kunit: The test case that this expectation/assertion is associated wit= h. * @assert_type: The type (assertion or expectation) of this kunit_assert. * @fmt: The formatting function which builds a string out of this kunit_a= ssert. * * The base initializer for a &struct kunit_assert. */ -#define KUNIT_INIT_ASSERT_STRUCT(kunit, assert_type, fmt) { \ - .test =3D kunit, \ +#define KUNIT_INIT_ASSERT_STRUCT(assert_type, fmt) { \ .type =3D assert_type, \ .file =3D __FILE__, \ .line =3D __LINE__, \ @@ -96,15 +92,13 @@ void kunit_fail_assert_format(const struct kunit_assert= *assert, =20 /** * KUNIT_INIT_FAIL_ASSERT_STRUCT() - Initializer for &struct kunit_fail_as= sert. - * @test: The test case that this expectation/assertion is associated with. * @type: The type (assertion or expectation) of this kunit_assert. * * Initializes a &struct kunit_fail_assert. Intended to be used in * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros. */ -#define KUNIT_INIT_FAIL_ASSERT_STRUCT(test, type) { \ - .assert =3D KUNIT_INIT_ASSERT_STRUCT(test, \ - type, \ +#define KUNIT_INIT_FAIL_ASSERT_STRUCT(type) { \ + .assert =3D KUNIT_INIT_ASSERT_STRUCT(type, \ kunit_fail_assert_format) \ } =20 @@ -129,7 +123,6 @@ void kunit_unary_assert_format(const struct kunit_asser= t *assert, =20 /** * KUNIT_INIT_UNARY_ASSERT_STRUCT() - Initializes &struct kunit_unary_asse= rt. - * @test: The test case that this expectation/assertion is associated with. * @type: The type (assertion or expectation) of this kunit_assert. * @cond: A string representation of the expression asserted true or false. * @expect_true: True if of type KUNIT_{EXPECT|ASSERT}_TRUE, false otherwi= se. @@ -137,9 +130,8 @@ void kunit_unary_assert_format(const struct kunit_asser= t *assert, * Initializes a &struct kunit_unary_assert. Intended to be used in * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros. */ -#define KUNIT_INIT_UNARY_ASSERT_STRUCT(test, type, cond, expect_true) { = \ - .assert =3D KUNIT_INIT_ASSERT_STRUCT(test, \ - type, \ +#define KUNIT_INIT_UNARY_ASSERT_STRUCT(type, cond, expect_true) { \ + .assert =3D KUNIT_INIT_ASSERT_STRUCT(type, \ kunit_unary_assert_format), \ .condition =3D cond, \ .expected_true =3D expect_true \ @@ -167,7 +159,6 @@ void kunit_ptr_not_err_assert_format(const struct kunit= _assert *assert, /** * KUNIT_INIT_PTR_NOT_ERR_ASSERT_STRUCT() - Initializes a * &struct kunit_ptr_not_err_assert. - * @test: The test case that this expectation/assertion is associated with. * @type: The type (assertion or expectation) of this kunit_assert. * @txt: A string representation of the expression passed to the expectati= on. * @val: The actual evaluated pointer value of the expression. @@ -175,9 +166,8 @@ void kunit_ptr_not_err_assert_format(const struct kunit= _assert *assert, * Initializes a &struct kunit_ptr_not_err_assert. Intended to be used in * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros. */ -#define KUNIT_INIT_PTR_NOT_ERR_STRUCT(test, type, txt, val) { \ - .assert =3D KUNIT_INIT_ASSERT_STRUCT(test, \ - type, \ +#define KUNIT_INIT_PTR_NOT_ERR_STRUCT(type, txt, val) { \ + .assert =3D KUNIT_INIT_ASSERT_STRUCT(type, \ kunit_ptr_not_err_assert_format), \ .text =3D txt, \ .value =3D val \ @@ -212,7 +202,6 @@ void kunit_binary_assert_format(const struct kunit_asse= rt *assert, /** * KUNIT_INIT_BINARY_ASSERT_STRUCT() - Initializes a * &struct kunit_binary_assert. - * @test: The test case that this expectation/assertion is associated with. * @type: The type (assertion or expectation) of this kunit_assert. * @op_str: A string representation of the comparison operator (e.g. "=3D= =3D"). * @left_str: A string representation of the expression in the left slot. @@ -223,15 +212,13 @@ void kunit_binary_assert_format(const struct kunit_as= sert *assert, * Initializes a &struct kunit_binary_assert. Intended to be used in * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros. */ -#define KUNIT_INIT_BINARY_ASSERT_STRUCT(test, \ - type, \ +#define KUNIT_INIT_BINARY_ASSERT_STRUCT(type, \ op_str, \ left_str, \ left_val, \ right_str, \ right_val) { \ - .assert =3D KUNIT_INIT_ASSERT_STRUCT(test, \ - type, \ + .assert =3D KUNIT_INIT_ASSERT_STRUCT(type, \ kunit_binary_assert_format), \ .operation =3D op_str, \ .left_text =3D left_str, \ @@ -269,7 +256,6 @@ void kunit_binary_ptr_assert_format(const struct kunit_= assert *assert, /** * KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT() - Initializes a * &struct kunit_binary_ptr_assert. - * @test: The test case that this expectation/assertion is associated with. * @type: The type (assertion or expectation) of this kunit_assert. * @op_str: A string representation of the comparison operator (e.g. "=3D= =3D"). * @left_str: A string representation of the expression in the left slot. @@ -280,15 +266,13 @@ void kunit_binary_ptr_assert_format(const struct kuni= t_assert *assert, * Initializes a &struct kunit_binary_ptr_assert. Intended to be used in * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros. */ -#define KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT(test, \ - type, \ +#define KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT(type, \ op_str, \ left_str, \ left_val, \ right_str, \ right_val) { \ - .assert =3D KUNIT_INIT_ASSERT_STRUCT(test, \ - type, \ + .assert =3D KUNIT_INIT_ASSERT_STRUCT(type, \ kunit_binary_ptr_assert_format), \ .operation =3D op_str, \ .left_text =3D left_str, \ @@ -326,7 +310,6 @@ void kunit_binary_str_assert_format(const struct kunit_= assert *assert, /** * KUNIT_INIT_BINARY_STR_ASSERT_STRUCT() - Initializes a * &struct kunit_binary_str_assert. - * @test: The test case that this expectation/assertion is associated with. * @type: The type (assertion or expectation) of this kunit_assert. * @op_str: A string representation of the comparison operator (e.g. "=3D= =3D"). * @left_str: A string representation of the expression in the left slot. @@ -337,15 +320,13 @@ void kunit_binary_str_assert_format(const struct kuni= t_assert *assert, * Initializes a &struct kunit_binary_str_assert. Intended to be used in * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros. */ -#define KUNIT_INIT_BINARY_STR_ASSERT_STRUCT(test, \ - type, \ +#define KUNIT_INIT_BINARY_STR_ASSERT_STRUCT(type, \ op_str, \ left_str, \ left_val, \ right_str, \ right_val) { \ - .assert =3D KUNIT_INIT_ASSERT_STRUCT(test, \ - type, \ + .assert =3D KUNIT_INIT_ASSERT_STRUCT(type, \ kunit_binary_str_assert_format), \ .operation =3D op_str, \ .left_text =3D left_str, \ diff --git a/include/kunit/test.h b/include/kunit/test.h index 12cabd15449a..25ea3bce6663 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -790,7 +790,7 @@ void kunit_do_failed_assertion(struct kunit *test, KUNIT_ASSERTION(test, \ false, \ kunit_fail_assert, \ - KUNIT_INIT_FAIL_ASSERT_STRUCT(test, assert_type), \ + KUNIT_INIT_FAIL_ASSERT_STRUCT(assert_type), \ fmt, \ ##__VA_ARGS__) =20 @@ -820,8 +820,7 @@ void kunit_do_failed_assertion(struct kunit *test, KUNIT_ASSERTION(test, \ !!(condition) =3D=3D !!expected_true, \ kunit_unary_assert, \ - KUNIT_INIT_UNARY_ASSERT_STRUCT(test, \ - assert_type, \ + KUNIT_INIT_UNARY_ASSERT_STRUCT(assert_type, \ #condition, \ expected_true), \ fmt, \ @@ -879,8 +878,7 @@ do { \ KUNIT_ASSERTION(test, \ __left op __right, \ assert_class, \ - ASSERT_CLASS_INIT(test, \ - assert_type, \ + ASSERT_CLASS_INIT(assert_type, \ #op, \ #left, \ __left, \ @@ -1234,8 +1232,7 @@ do { \ KUNIT_ASSERTION(test, \ strcmp(__left, __right) op 0, \ kunit_binary_str_assert, \ - KUNIT_INIT_BINARY_STR_ASSERT_STRUCT(test, \ - assert_type, \ + KUNIT_INIT_BINARY_STR_ASSERT_STRUCT(assert_type, \ #op, \ #left, \ __left, \ @@ -1294,8 +1291,7 @@ do { \ KUNIT_ASSERTION(test, \ !IS_ERR_OR_NULL(__ptr), \ kunit_ptr_not_err_assert, \ - KUNIT_INIT_PTR_NOT_ERR_STRUCT(test, \ - assert_type, \ + KUNIT_INIT_PTR_NOT_ERR_STRUCT(assert_type, \ #ptr, \ __ptr), \ fmt, \ --=20 2.34.1.703.g22d0c6ccf7-goog From nobody Tue Jun 30 15:33:12 2026 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 3F4D1C433EF for ; Thu, 13 Jan 2022 17:00:05 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236999AbiAMRAD (ORCPT ); Thu, 13 Jan 2022 12:00:03 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42628 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236971AbiAMQ75 (ORCPT ); Thu, 13 Jan 2022 11:59:57 -0500 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 98B54C06161C for ; Thu, 13 Jan 2022 08:59:57 -0800 (PST) Received: by mail-yb1-xb49.google.com with SMTP id e18-20020a255012000000b00611b9fa7078so5465586ybb.4 for ; Thu, 13 Jan 2022 08:59:57 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=v3PPhP3uVEfd/KOYr8YIKy5+IlECtDSlMkBa+ZKkSZU=; b=Wa/obs6dUVxI/f3FfSJi9Q/YYpyuA8jddW6ibazM0YOF2eBNVHnyCbGHWCuEK+BLPz iCHH6Ak2ziyApjtUmmpAnrXxosl4OIRoAp0yzbSuQ3r7rvviWVhGX3lK6dx37FUH/Zz/ +qyVR0NP/zahjaA+7Y7hSpgx0fhy1jdNRS0vduPjeOeIOVTp6AGlha0v8LO1X95uGVch Oj5eEylp+hrKh9fH6tuyIfCkOCl5KqtqCTae7F1wYmi84zOmZLyDRxSIIVYaJkY/zAwM ayZtzJibBr0MrQjEwwZg7Nxc5eIzHBeH0UV8SMQ0hmDRbdS9V3fZw8H+EjrBgWeoNwQk wZfg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=v3PPhP3uVEfd/KOYr8YIKy5+IlECtDSlMkBa+ZKkSZU=; b=otIGrLVb4uT4TyO8vaaAzXeLxYdt7vAu2g+3i36UKYeLCEVKxldnvkaTv5kD/7xSin Kwym/c4DYHM6Yg+wGT3jiYPQdk4duuoAG+PxVVHJ6zHkX6BChR7sj8mkzs/jhAUt1DO0 F/n0o421wJwAR0yYufqpwLzPv0pxQMNrs9NBjsQp+o78tzyZeysUhIvC0Bvn1fjpfejD 3fSoJxJmnpnB8inexrRE77DMzrJ0Nedk63mcz2qdzYUSvBlTQgxeHi9JzoB7WvlqD32W K/ieOqNZ7oBkWJZNnkE3X/+cujC/1BmYTS4dK8a0CLIwVat68Q7Lwp2Ur66ommNHMyWF AAMA== X-Gm-Message-State: AOAM533FcUrHnJn38FfL5Ae1XjfN3Ny4/t3Gq899Hlq/ZHfjTHJsGf9Y KjnuLF9CGjrkGFhNRNWobxINzYBh259+KA== X-Google-Smtp-Source: ABdhPJxBopUg1Hwoxwgo+gBUXiZUekN4GiscGmHN1IuLUcLuznNT+y5jLXnaGb/yF65YxsEJgSR34MtdvLAH7Q== X-Received: from dlatypov.svl.corp.google.com ([2620:15c:2cd:202:1a70:cede:4191:24bc]) (user=dlatypov job=sendgmr) by 2002:a25:5686:: with SMTP id k128mr6389419ybb.14.1642093196899; Thu, 13 Jan 2022 08:59:56 -0800 (PST) Date: Thu, 13 Jan 2022 08:59:29 -0800 In-Reply-To: <20220113165931.451305-1-dlatypov@google.com> Message-Id: <20220113165931.451305-5-dlatypov@google.com> Mime-Version: 1.0 References: <20220113165931.451305-1-dlatypov@google.com> X-Mailer: git-send-email 2.34.1.703.g22d0c6ccf7-goog Subject: [PATCH v3 4/6] kunit: factor out kunit_base_assert_format() call into kunit_fail() From: Daniel Latypov To: brendanhiggins@google.com, davidgow@google.com Cc: linux-kernel@vger.kernel.org, kunit-dev@googlegroups.com, linux-kselftest@vger.kernel.org, skhan@linuxfoundation.org, torvalds@linux-foundation.org, Daniel Latypov Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" We call this function first thing for all the assertion `format()` functions. This is the part that prints the file and line number and assertion type (EXPECTATION, ASSERTION). Having it as part of the format functions lets us have the flexibility to not print that information (or print it differently) for new assertion types, but I think this we don't need that. And in the future, we'd like to consider factoring that data (file, line#, type) out of the kunit_assert struct and into a `static` variable, as Linus suggested [1], so we'd need to extract it anyways. [1] https://groups.google.com/g/kunit-dev/c/i3fZXgvBrfA/m/VULQg1z6BAAJ Signed-off-by: Daniel Latypov Reviewed-by: David Gow --- lib/kunit/assert.c | 6 ------ lib/kunit/test.c | 1 + 2 files changed, 1 insertion(+), 6 deletions(-) diff --git a/lib/kunit/assert.c b/lib/kunit/assert.c index b972bda61c0c..4d9a1295efc7 100644 --- a/lib/kunit/assert.c +++ b/lib/kunit/assert.c @@ -40,7 +40,6 @@ EXPORT_SYMBOL_GPL(kunit_assert_print_msg); void kunit_fail_assert_format(const struct kunit_assert *assert, struct string_stream *stream) { - kunit_base_assert_format(assert, stream); string_stream_add(stream, "%pV", &assert->message); } EXPORT_SYMBOL_GPL(kunit_fail_assert_format); @@ -52,7 +51,6 @@ void kunit_unary_assert_format(const struct kunit_assert = *assert, =20 unary_assert =3D container_of(assert, struct kunit_unary_assert, assert); =20 - kunit_base_assert_format(assert, stream); if (unary_assert->expected_true) string_stream_add(stream, KUNIT_SUBTEST_INDENT "Expected %s to be true, but is false\n", @@ -73,7 +71,6 @@ void kunit_ptr_not_err_assert_format(const struct kunit_a= ssert *assert, ptr_assert =3D container_of(assert, struct kunit_ptr_not_err_assert, assert); =20 - kunit_base_assert_format(assert, stream); if (!ptr_assert->value) { string_stream_add(stream, KUNIT_SUBTEST_INDENT "Expected %s is not null, but is\n", @@ -119,7 +116,6 @@ void kunit_binary_assert_format(const struct kunit_asse= rt *assert, binary_assert =3D container_of(assert, struct kunit_binary_assert, assert); =20 - kunit_base_assert_format(assert, stream); string_stream_add(stream, KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n", binary_assert->left_text, @@ -147,7 +143,6 @@ void kunit_binary_ptr_assert_format(const struct kunit_= assert *assert, binary_assert =3D container_of(assert, struct kunit_binary_ptr_assert, assert); =20 - kunit_base_assert_format(assert, stream); string_stream_add(stream, KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n", binary_assert->left_text, @@ -187,7 +182,6 @@ void kunit_binary_str_assert_format(const struct kunit_= assert *assert, binary_assert =3D container_of(assert, struct kunit_binary_str_assert, assert); =20 - kunit_base_assert_format(assert, stream); string_stream_add(stream, KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n", binary_assert->left_text, diff --git a/lib/kunit/test.c b/lib/kunit/test.c index 3a52c321c280..345a9dd88c27 100644 --- a/lib/kunit/test.c +++ b/lib/kunit/test.c @@ -255,6 +255,7 @@ static void kunit_fail(struct kunit *test, struct kunit= _assert *assert) return; } =20 + kunit_base_assert_format(assert, stream); assert->format(assert, stream); =20 kunit_print_string_stream(test, stream); --=20 2.34.1.703.g22d0c6ccf7-goog From nobody Tue Jun 30 15:33:12 2026 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 3E46CC433FE for ; Thu, 13 Jan 2022 17:00:08 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236996AbiAMRAF (ORCPT ); Thu, 13 Jan 2022 12:00:05 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42642 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236976AbiAMRAA (ORCPT ); Thu, 13 Jan 2022 12:00:00 -0500 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 118BBC061574 for ; Thu, 13 Jan 2022 09:00:00 -0800 (PST) Received: by mail-yb1-xb49.google.com with SMTP id p8-20020a25bd48000000b00611be5dd7eeso4541096ybm.19 for ; Thu, 13 Jan 2022 09:00:00 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=Hsd9GWWf+k+Xx3lW6j09zwf/kgDDR7QNNbaWN+mKOkQ=; b=emWLtylm6iWJS+LojlK8OZ/zsDh2W1bJ+t510rYGD2Iv4yQGzcGHc4S53XyNh69cbM s4RZgZQfhaYPdjvVVwQ4iFyO2pSHbxTyhcjcCNg/fteJPTiRktGY+p38pr1cyj0mRRIB Ide1+pBV+zR78xjANG0ZdL1OhrX+pPyeEyLsZFr8ac32oY0Q5Qez+qIy95knzXKI3QiN RqE2hDQYQhKceknT8FrADd5Dl6jsf4o/HEOZIpJsde1nrTTDwHalAIVnwHCSrhWLsBzZ aOeK3ubq3pjps1MCsRCdN4uOGNXh6ql4mGs0oNVwAttbfoAsisk/KfeBreV0qdYDvkJn U8jw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=Hsd9GWWf+k+Xx3lW6j09zwf/kgDDR7QNNbaWN+mKOkQ=; b=kDMOsJbVHzE4x9aVlIjXkA7LRutd7vkLlg5zsUr/fTYgR42GJBDBEvDBt3Wz24YNmx j9G35LZgIZoImfoKVD2s+xy3M1LYN+In1yBMLacB5m0rAg3TVzprLQz0lcLiGtfTb68s dgMUMsc6bT3fmVbDqaA4GfLhW65OTk60nQ69Rcb2gkDdsmWORzBanb1VxO7u0pBrWb4A 0YZhscRlSWvVLrTeSvBSTtokVm9mw+Tu8xFR5zHjBG56tI1ftJ746hiNjPKWhkEPeiQ6 KkYB/1HpV3Sk37XBUo/19V0/nxq/wQEpvDhHrW564MKEpPkRT+kU2sj8MSSxesWOnOjG IbQg== X-Gm-Message-State: AOAM530+iOOqUYyI5tFklvXs2DcBEtsudYikHCEjqeDJlZNAG4HG3Vuz AfLUyuO4qzwUa1IfiNhYbsQ3SWAWfKneCg== X-Google-Smtp-Source: ABdhPJz9EaA3XuG17LkqyR2ioaWvveoZdM9ZLa1iJ63I7O66t7e2QtcYZzHVZcWP1Q8Jg0hS0/DvneayFCBRDg== X-Received: from dlatypov.svl.corp.google.com ([2620:15c:2cd:202:1a70:cede:4191:24bc]) (user=dlatypov job=sendgmr) by 2002:a25:bc2:: with SMTP id 185mr7452893ybl.94.1642093199350; Thu, 13 Jan 2022 08:59:59 -0800 (PST) Date: Thu, 13 Jan 2022 08:59:30 -0800 In-Reply-To: <20220113165931.451305-1-dlatypov@google.com> Message-Id: <20220113165931.451305-6-dlatypov@google.com> Mime-Version: 1.0 References: <20220113165931.451305-1-dlatypov@google.com> X-Mailer: git-send-email 2.34.1.703.g22d0c6ccf7-goog Subject: [PATCH v3 5/6] kunit: split out part of kunit_assert into a static const From: Daniel Latypov To: brendanhiggins@google.com, davidgow@google.com Cc: linux-kernel@vger.kernel.org, kunit-dev@googlegroups.com, linux-kselftest@vger.kernel.org, skhan@linuxfoundation.org, torvalds@linux-foundation.org, Daniel Latypov Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This is per Linus's suggestion in [1]. The issue there is that every KUNIT_EXPECT/KUNIT_ASSERT puts a kunit_assert object onto the stack. Normally we rely on compilers to elide this, but when that doesn't work out, this blows up the stack usage of kunit test functions. We can move some data off the stack by making it static. This change introduces a new `struct kunit_loc` to hold the file and line number and then just passing assert_type (EXPECT or ASSERT) as an argument. In [1], it was suggested to also move out the format string as well, but users could theoretically craft a format string at runtime, so we can't. This change leaves a copy of `assert_type` in kunit_assert for now because cleaning up all the macros to not pass it around is a bit more involved. Here's an example of the expanded code for KUNIT_FAIL(): if (__builtin_expect(!!(!(false)), 0)) { static const struct kunit_loc loc =3D { .file =3D ... }; struct kunit_fail_assert __assertion =3D { .assert =3D { .type ... }; kunit_do_failed_assertion(test, &loc, KUNIT_EXPECTATION, &__assertion.ass= ert, ...); }; [1] https://groups.google.com/g/kunit-dev/c/i3fZXgvBrfA/m/VULQg1z6BAAJ Signed-off-by: Daniel Latypov Suggested-by: Linus Torvalds Reviewed-by: David Gow Reviewed-by: Brendan Higgins --- include/kunit/assert.h | 25 +++++++++++++++++-------- include/kunit/test.h | 12 +++++++++++- lib/kunit/assert.c | 9 +++++---- lib/kunit/test.c | 15 +++++++++------ 4 files changed, 42 insertions(+), 19 deletions(-) diff --git a/include/kunit/assert.h b/include/kunit/assert.h index 3da6c792496c..3d7e46901478 100644 --- a/include/kunit/assert.h +++ b/include/kunit/assert.h @@ -28,11 +28,21 @@ enum kunit_assert_type { KUNIT_EXPECTATION, }; =20 +/** + * struct kunit_loc - Identifies the source location of a line of code. + * @line: the line number in the file. + * @file: the file name. + */ +struct kunit_loc { + int line; + const char *file; +}; + +#define KUNIT_CURRENT_LOC { .file =3D __FILE__, .line =3D __LINE__ } + /** * struct kunit_assert - Data for printing a failed assertion or expectati= on. * @type: the type (either an expectation or an assertion) of this kunit_a= ssert. - * @line: the source code line number that the expectation/assertion is at. - * @file: the file path of the source file that the expectation/assertion = is in. * @message: an optional message to provide additional context. * @format: a function which formats the data in this kunit_assert to a st= ring. * @@ -40,9 +50,9 @@ enum kunit_assert_type { * format a string to a user reporting the failure. */ struct kunit_assert { + // TODO(dlatypov@google.com): delete this unused field when we've + // updated all the related KUNIT_INIT_ASSERT* macros. enum kunit_assert_type type; - int line; - const char *file; struct va_format message; void (*format)(const struct kunit_assert *assert, struct string_stream *stream); @@ -65,14 +75,13 @@ struct kunit_assert { */ #define KUNIT_INIT_ASSERT_STRUCT(assert_type, fmt) { \ .type =3D assert_type, \ - .file =3D __FILE__, \ - .line =3D __LINE__, \ .message =3D KUNIT_INIT_VA_FMT_NULL, \ .format =3D fmt \ } =20 -void kunit_base_assert_format(const struct kunit_assert *assert, - struct string_stream *stream); +void kunit_assert_prologue(const struct kunit_loc *loc, + enum kunit_assert_type type, + struct string_stream *stream); =20 void kunit_assert_print_msg(const struct kunit_assert *assert, struct string_stream *stream); diff --git a/include/kunit/test.h b/include/kunit/test.h index 25ea3bce6663..7b752175e614 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -772,13 +772,18 @@ void __printf(2, 3) kunit_log_append(char *log, const= char *fmt, ...); #define KUNIT_SUCCEED(test) do {} while (0) =20 void kunit_do_failed_assertion(struct kunit *test, + const struct kunit_loc *loc, + enum kunit_assert_type type, struct kunit_assert *assert, const char *fmt, ...); =20 -#define KUNIT_ASSERTION(test, pass, assert_class, INITIALIZER, fmt, ...) d= o { \ +#define KUNIT_ASSERTION(test, assert_type, pass, assert_class, INITIALIZER= , fmt, ...) do { \ if (unlikely(!(pass))) { \ + static const struct kunit_loc loc =3D KUNIT_CURRENT_LOC; \ struct assert_class __assertion =3D INITIALIZER; \ kunit_do_failed_assertion(test, \ + &loc, \ + assert_type, \ &__assertion.assert, \ fmt, \ ##__VA_ARGS__); \ @@ -788,6 +793,7 @@ void kunit_do_failed_assertion(struct kunit *test, =20 #define KUNIT_FAIL_ASSERTION(test, assert_type, fmt, ...) \ KUNIT_ASSERTION(test, \ + assert_type, \ false, \ kunit_fail_assert, \ KUNIT_INIT_FAIL_ASSERT_STRUCT(assert_type), \ @@ -818,6 +824,7 @@ void kunit_do_failed_assertion(struct kunit *test, fmt, \ ...) \ KUNIT_ASSERTION(test, \ + assert_type, \ !!(condition) =3D=3D !!expected_true, \ kunit_unary_assert, \ KUNIT_INIT_UNARY_ASSERT_STRUCT(assert_type, \ @@ -876,6 +883,7 @@ do { \ typeof(right) __right =3D (right); \ \ KUNIT_ASSERTION(test, \ + assert_type, \ __left op __right, \ assert_class, \ ASSERT_CLASS_INIT(assert_type, \ @@ -1230,6 +1238,7 @@ do { \ const char *__right =3D (right); \ \ KUNIT_ASSERTION(test, \ + assert_type, \ strcmp(__left, __right) op 0, \ kunit_binary_str_assert, \ KUNIT_INIT_BINARY_STR_ASSERT_STRUCT(assert_type, \ @@ -1289,6 +1298,7 @@ do { \ typeof(ptr) __ptr =3D (ptr); \ \ KUNIT_ASSERTION(test, \ + assert_type, \ !IS_ERR_OR_NULL(__ptr), \ kunit_ptr_not_err_assert, \ KUNIT_INIT_PTR_NOT_ERR_STRUCT(assert_type, \ diff --git a/lib/kunit/assert.c b/lib/kunit/assert.c index 4d9a1295efc7..9f4492a8e24e 100644 --- a/lib/kunit/assert.c +++ b/lib/kunit/assert.c @@ -10,12 +10,13 @@ =20 #include "string-stream.h" =20 -void kunit_base_assert_format(const struct kunit_assert *assert, +void kunit_assert_prologue(const struct kunit_loc *loc, + enum kunit_assert_type type, struct string_stream *stream) { const char *expect_or_assert =3D NULL; =20 - switch (assert->type) { + switch (type) { case KUNIT_EXPECTATION: expect_or_assert =3D "EXPECTATION"; break; @@ -25,9 +26,9 @@ void kunit_base_assert_format(const struct kunit_assert *= assert, } =20 string_stream_add(stream, "%s FAILED at %s:%d\n", - expect_or_assert, assert->file, assert->line); + expect_or_assert, loc->file, loc->line); } -EXPORT_SYMBOL_GPL(kunit_base_assert_format); +EXPORT_SYMBOL_GPL(kunit_assert_prologue); =20 void kunit_assert_print_msg(const struct kunit_assert *assert, struct string_stream *stream) diff --git a/lib/kunit/test.c b/lib/kunit/test.c index 345a9dd88c27..7dec3248562f 100644 --- a/lib/kunit/test.c +++ b/lib/kunit/test.c @@ -240,7 +240,8 @@ static void kunit_print_string_stream(struct kunit *tes= t, } } =20 -static void kunit_fail(struct kunit *test, struct kunit_assert *assert) +static void kunit_fail(struct kunit *test, const struct kunit_loc *loc, + enum kunit_assert_type type, struct kunit_assert *assert) { struct string_stream *stream; =20 @@ -250,12 +251,12 @@ static void kunit_fail(struct kunit *test, struct kun= it_assert *assert) if (!stream) { WARN(true, "Could not allocate stream to print failed assertion in %s:%d\n", - assert->file, - assert->line); + loc->file, + loc->line); return; } =20 - kunit_base_assert_format(assert, stream); + kunit_assert_prologue(loc, type, stream); assert->format(assert, stream); =20 kunit_print_string_stream(test, stream); @@ -277,6 +278,8 @@ static void __noreturn kunit_abort(struct kunit *test) } =20 void kunit_do_failed_assertion(struct kunit *test, + const struct kunit_loc *loc, + enum kunit_assert_type type, struct kunit_assert *assert, const char *fmt, ...) { @@ -286,11 +289,11 @@ void kunit_do_failed_assertion(struct kunit *test, assert->message.fmt =3D fmt; assert->message.va =3D &args; =20 - kunit_fail(test, assert); + kunit_fail(test, loc, type, assert); =20 va_end(args); =20 - if (assert->type =3D=3D KUNIT_ASSERTION) + if (type =3D=3D KUNIT_ASSERTION) kunit_abort(test); } EXPORT_SYMBOL_GPL(kunit_do_failed_assertion); --=20 2.34.1.703.g22d0c6ccf7-goog From nobody Tue Jun 30 15:33:12 2026 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 A7F00C433EF for ; Thu, 13 Jan 2022 17:00:13 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237007AbiAMRAL (ORCPT ); Thu, 13 Jan 2022 12:00:11 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42658 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237017AbiAMRAD (ORCPT ); Thu, 13 Jan 2022 12:00:03 -0500 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 24C43C061749 for ; Thu, 13 Jan 2022 09:00:02 -0800 (PST) Received: by mail-yb1-xb49.google.com with SMTP id s13-20020a252c0d000000b00611786a6925so12551148ybs.8 for ; Thu, 13 Jan 2022 09:00:02 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=0bSkrcDseCcepTlbkkVY4WyOT+vh8pWdvwaC0weZr8k=; b=SRNkewrPCE3hhhgkfSpyZ1krbT2ltJgY0MCWbi/p19A0XttAR1PPeCq7fshKk3LE3k +Csn8rVgcCHlbWMs6Lez95tknhJKYr5L5OWiXZ3+IrE6sH7NSOV4Tw3E+hcqGRqPCeE+ OFdJ/iMW51H3Rgx2+87J1oRNHmFsVOKUNPxPO75Csd90uRO14LAH7Re7jzwcLNw0Z1VJ DxAfUqWLWnwMGYWTCQQD+ylGICx6WOF7wAO62B+uiOwUeB5OqXOpxHcj0Nj/yMHaNEhB AaMwdAe4HC8OCvd0v8IOSL1kjZN6Bkdtj2k78nlNgNO4MQTLJ6aiz/NsgEmWRR6sTCo+ rZog== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=0bSkrcDseCcepTlbkkVY4WyOT+vh8pWdvwaC0weZr8k=; b=yNw3hB8qOOGOqnL7fVTBy3kgGdwC/0FVlYb6C+rUGXoOgx2X3YbNR7cmCDtiVpj39M 6Yg+PqqYxfNYHkstxjTDmldI4TYLWEYSuOkzWgxeMTu0OcfFxYgwlEMW4pU0HyHGPPqy G/4wQewGiweCgylF8OtPatmREPFNanT5fmvVhX9UVAAMmCzaMnHfzpdbQl/QSpUBqqy9 OqfbyG23NTTajt8RLa0Zlj/1Yg5doq/3/hVayjuAxfYMKBEdMzf0Ip9O5tg3nLTWEXI3 B6kTJ7Rmrk47+kCiIK6gmy5SDaaNk2eOVQQEj7wkBQH6Tc3pDRVYJ2+/+TrDckSn2iST r81A== X-Gm-Message-State: AOAM530eEJaPDUHCO2akS3XKpSvbxjoFnBePxRMApDCBJAs51WRpMUzJ RkQDa+ydQQNNSaVIc4598Hd0MoTyU/CmxQ== X-Google-Smtp-Source: ABdhPJytMkIwXFVdejHx594HPVb/wCwE1vSNjB2mnuNJno8qwjNEAq1n33F0hODqJJDSJt50KAaVqwzdAU5N9g== X-Received: from dlatypov.svl.corp.google.com ([2620:15c:2cd:202:1a70:cede:4191:24bc]) (user=dlatypov job=sendgmr) by 2002:a25:9881:: with SMTP id l1mr6676467ybo.262.1642093201398; Thu, 13 Jan 2022 09:00:01 -0800 (PST) Date: Thu, 13 Jan 2022 08:59:31 -0800 In-Reply-To: <20220113165931.451305-1-dlatypov@google.com> Message-Id: <20220113165931.451305-7-dlatypov@google.com> Mime-Version: 1.0 References: <20220113165931.451305-1-dlatypov@google.com> X-Mailer: git-send-email 2.34.1.703.g22d0c6ccf7-goog Subject: [PATCH v3 6/6] kunit: drop unused assert_type from kunit_assert and clean up macros From: Daniel Latypov To: brendanhiggins@google.com, davidgow@google.com Cc: linux-kernel@vger.kernel.org, kunit-dev@googlegroups.com, linux-kselftest@vger.kernel.org, skhan@linuxfoundation.org, torvalds@linux-foundation.org, Daniel Latypov Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This field has been split out from kunit_assert to make the struct less heavy along with the filename and line number. This change drops the assert_type field and cleans up all the macros that were plumbing assert_type into kunit_assert. Signed-off-by: Daniel Latypov Reviewed-by: David Gow Reviewed-by: Brendan Higgins --- include/kunit/assert.h | 48 ++++++++++++------------------------------ include/kunit/test.h | 14 +++++------- 2 files changed, 19 insertions(+), 43 deletions(-) diff --git a/include/kunit/assert.h b/include/kunit/assert.h index 3d7e46901478..21299232c120 100644 --- a/include/kunit/assert.h +++ b/include/kunit/assert.h @@ -42,7 +42,6 @@ struct kunit_loc { =20 /** * struct kunit_assert - Data for printing a failed assertion or expectati= on. - * @type: the type (either an expectation or an assertion) of this kunit_a= ssert. * @message: an optional message to provide additional context. * @format: a function which formats the data in this kunit_assert to a st= ring. * @@ -50,9 +49,6 @@ struct kunit_loc { * format a string to a user reporting the failure. */ struct kunit_assert { - // TODO(dlatypov@google.com): delete this unused field when we've - // updated all the related KUNIT_INIT_ASSERT* macros. - enum kunit_assert_type type; struct va_format message; void (*format)(const struct kunit_assert *assert, struct string_stream *stream); @@ -68,13 +64,11 @@ struct kunit_assert { =20 /** * KUNIT_INIT_ASSERT_STRUCT() - Initializer for a &struct kunit_assert. - * @assert_type: The type (assertion or expectation) of this kunit_assert. * @fmt: The formatting function which builds a string out of this kunit_a= ssert. * * The base initializer for a &struct kunit_assert. */ -#define KUNIT_INIT_ASSERT_STRUCT(assert_type, fmt) { \ - .type =3D assert_type, \ +#define KUNIT_INIT_ASSERT_STRUCT(fmt) { \ .message =3D KUNIT_INIT_VA_FMT_NULL, \ .format =3D fmt \ } @@ -100,15 +94,13 @@ void kunit_fail_assert_format(const struct kunit_asser= t *assert, struct string_stream *stream); =20 /** - * KUNIT_INIT_FAIL_ASSERT_STRUCT() - Initializer for &struct kunit_fail_as= sert. - * @type: The type (assertion or expectation) of this kunit_assert. + * KUNIT_INIT_FAIL_ASSERT_STRUCT - Initializer for &struct kunit_fail_asse= rt. * * Initializes a &struct kunit_fail_assert. Intended to be used in * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros. */ -#define KUNIT_INIT_FAIL_ASSERT_STRUCT(type) { \ - .assert =3D KUNIT_INIT_ASSERT_STRUCT(type, \ - kunit_fail_assert_format) \ +#define KUNIT_INIT_FAIL_ASSERT_STRUCT { \ + .assert =3D KUNIT_INIT_ASSERT_STRUCT(kunit_fail_assert_format) \ } =20 /** @@ -132,16 +124,14 @@ void kunit_unary_assert_format(const struct kunit_ass= ert *assert, =20 /** * KUNIT_INIT_UNARY_ASSERT_STRUCT() - Initializes &struct kunit_unary_asse= rt. - * @type: The type (assertion or expectation) of this kunit_assert. * @cond: A string representation of the expression asserted true or false. * @expect_true: True if of type KUNIT_{EXPECT|ASSERT}_TRUE, false otherwi= se. * * Initializes a &struct kunit_unary_assert. Intended to be used in * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros. */ -#define KUNIT_INIT_UNARY_ASSERT_STRUCT(type, cond, expect_true) { \ - .assert =3D KUNIT_INIT_ASSERT_STRUCT(type, \ - kunit_unary_assert_format), \ +#define KUNIT_INIT_UNARY_ASSERT_STRUCT(cond, expect_true) { \ + .assert =3D KUNIT_INIT_ASSERT_STRUCT(kunit_unary_assert_format), \ .condition =3D cond, \ .expected_true =3D expect_true \ } @@ -168,16 +158,14 @@ void kunit_ptr_not_err_assert_format(const struct kun= it_assert *assert, /** * KUNIT_INIT_PTR_NOT_ERR_ASSERT_STRUCT() - Initializes a * &struct kunit_ptr_not_err_assert. - * @type: The type (assertion or expectation) of this kunit_assert. * @txt: A string representation of the expression passed to the expectati= on. * @val: The actual evaluated pointer value of the expression. * * Initializes a &struct kunit_ptr_not_err_assert. Intended to be used in * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros. */ -#define KUNIT_INIT_PTR_NOT_ERR_STRUCT(type, txt, val) { \ - .assert =3D KUNIT_INIT_ASSERT_STRUCT(type, \ - kunit_ptr_not_err_assert_format), \ +#define KUNIT_INIT_PTR_NOT_ERR_STRUCT(txt, val) { \ + .assert =3D KUNIT_INIT_ASSERT_STRUCT(kunit_ptr_not_err_assert_format), \ .text =3D txt, \ .value =3D val \ } @@ -211,7 +199,6 @@ void kunit_binary_assert_format(const struct kunit_asse= rt *assert, /** * KUNIT_INIT_BINARY_ASSERT_STRUCT() - Initializes a * &struct kunit_binary_assert. - * @type: The type (assertion or expectation) of this kunit_assert. * @op_str: A string representation of the comparison operator (e.g. "=3D= =3D"). * @left_str: A string representation of the expression in the left slot. * @left_val: The actual evaluated value of the expression in the left slo= t. @@ -221,14 +208,12 @@ void kunit_binary_assert_format(const struct kunit_as= sert *assert, * Initializes a &struct kunit_binary_assert. Intended to be used in * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros. */ -#define KUNIT_INIT_BINARY_ASSERT_STRUCT(type, \ - op_str, \ +#define KUNIT_INIT_BINARY_ASSERT_STRUCT(op_str, \ left_str, \ left_val, \ right_str, \ right_val) { \ - .assert =3D KUNIT_INIT_ASSERT_STRUCT(type, \ - kunit_binary_assert_format), \ + .assert =3D KUNIT_INIT_ASSERT_STRUCT(kunit_binary_assert_format), \ .operation =3D op_str, \ .left_text =3D left_str, \ .left_value =3D left_val, \ @@ -275,14 +260,12 @@ void kunit_binary_ptr_assert_format(const struct kuni= t_assert *assert, * Initializes a &struct kunit_binary_ptr_assert. Intended to be used in * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros. */ -#define KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT(type, \ - op_str, \ +#define KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT(op_str, \ left_str, \ left_val, \ right_str, \ right_val) { \ - .assert =3D KUNIT_INIT_ASSERT_STRUCT(type, \ - kunit_binary_ptr_assert_format), \ + .assert =3D KUNIT_INIT_ASSERT_STRUCT(kunit_binary_ptr_assert_format), \ .operation =3D op_str, \ .left_text =3D left_str, \ .left_value =3D left_val, \ @@ -319,7 +302,6 @@ void kunit_binary_str_assert_format(const struct kunit_= assert *assert, /** * KUNIT_INIT_BINARY_STR_ASSERT_STRUCT() - Initializes a * &struct kunit_binary_str_assert. - * @type: The type (assertion or expectation) of this kunit_assert. * @op_str: A string representation of the comparison operator (e.g. "=3D= =3D"). * @left_str: A string representation of the expression in the left slot. * @left_val: The actual evaluated value of the expression in the left slo= t. @@ -329,14 +311,12 @@ void kunit_binary_str_assert_format(const struct kuni= t_assert *assert, * Initializes a &struct kunit_binary_str_assert. Intended to be used in * KUNIT_EXPECT_* and KUNIT_ASSERT_* macros. */ -#define KUNIT_INIT_BINARY_STR_ASSERT_STRUCT(type, \ - op_str, \ +#define KUNIT_INIT_BINARY_STR_ASSERT_STRUCT(op_str, \ left_str, \ left_val, \ right_str, \ right_val) { \ - .assert =3D KUNIT_INIT_ASSERT_STRUCT(type, \ - kunit_binary_str_assert_format), \ + .assert =3D KUNIT_INIT_ASSERT_STRUCT(kunit_binary_str_assert_format), \ .operation =3D op_str, \ .left_text =3D left_str, \ .left_value =3D left_val, \ diff --git a/include/kunit/test.h b/include/kunit/test.h index 7b752175e614..5964af750d93 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -796,7 +796,7 @@ void kunit_do_failed_assertion(struct kunit *test, assert_type, \ false, \ kunit_fail_assert, \ - KUNIT_INIT_FAIL_ASSERT_STRUCT(assert_type), \ + KUNIT_INIT_FAIL_ASSERT_STRUCT, \ fmt, \ ##__VA_ARGS__) =20 @@ -827,8 +827,7 @@ void kunit_do_failed_assertion(struct kunit *test, assert_type, \ !!(condition) =3D=3D !!expected_true, \ kunit_unary_assert, \ - KUNIT_INIT_UNARY_ASSERT_STRUCT(assert_type, \ - #condition, \ + KUNIT_INIT_UNARY_ASSERT_STRUCT(#condition, \ expected_true), \ fmt, \ ##__VA_ARGS__) @@ -886,8 +885,7 @@ do { \ assert_type, \ __left op __right, \ assert_class, \ - ASSERT_CLASS_INIT(assert_type, \ - #op, \ + ASSERT_CLASS_INIT(#op, \ #left, \ __left, \ #right, \ @@ -1241,8 +1239,7 @@ do { \ assert_type, \ strcmp(__left, __right) op 0, \ kunit_binary_str_assert, \ - KUNIT_INIT_BINARY_STR_ASSERT_STRUCT(assert_type, \ - #op, \ + KUNIT_INIT_BINARY_STR_ASSERT_STRUCT(#op, \ #left, \ __left, \ #right, \ @@ -1301,8 +1298,7 @@ do { \ assert_type, \ !IS_ERR_OR_NULL(__ptr), \ kunit_ptr_not_err_assert, \ - KUNIT_INIT_PTR_NOT_ERR_STRUCT(assert_type, \ - #ptr, \ + KUNIT_INIT_PTR_NOT_ERR_STRUCT(#ptr, \ __ptr), \ fmt, \ ##__VA_ARGS__); \ --=20 2.34.1.703.g22d0c6ccf7-goog