From patchwork Tue Oct 25 23:10:41 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Maira Canal X-Patchwork-Id: 11000 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a5d:6687:0:0:0:0:0 with SMTP id l7csp1266041wru; Tue, 25 Oct 2022 16:13:34 -0700 (PDT) X-Google-Smtp-Source: AMsMyM6/33sRl0ioXypx708ABeVnbuQwL1w8rx5YuedwXtq7ZNKbJOYfHRwV2wiY9wqpl3+bGud1 X-Received: by 2002:a17:902:e395:b0:186:9cf7:3147 with SMTP id g21-20020a170902e39500b001869cf73147mr15802947ple.52.1666739614057; Tue, 25 Oct 2022 16:13:34 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1666739614; cv=none; d=google.com; s=arc-20160816; b=wVIOAAwbzj0/DH5E4u66hQYCjW230vNZJ1ODp7oGN2e//1xjnwUe+4yDGfRHU6uSdX HwRvebLTw9F2uTLh2ZcPbzUS3HOkqCRcQaR79hz2AsTfgV/TaMyh8/CCHDvCEooIXBF9 MB+JAQ5lCu1WvnaptwdpGtvLYAbVJFL0f/OdU/LmYwY5jrIniyDVnvvxHInd+axicjmA mrUqPpprT/IdBbX77keG2XSrKWwKHVsHHrcMlovs+dMmG0Iod0Kr9GmlYOQOak7Qt+th j/tdAaehngt6sJc3BMjfqufMdeaHBA8/mzsL92dQb76kJQfQ4vo7QBK1ozOMsJAnLGal YD8A== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=1Eww6VsS2jxfSteH005BHEC4EUAL2J0wN28EtBzyi3c=; b=Js81IosM/61T2d2HY0uJYfyujZrhxlFMGG93Ssz4ovE/8wy6st5rElMzUyAom+mzTW a6RipXJogGBDpQnPPuYyr+XzIe83EekBAOy+UYpcZiHc2G8edUBp1nhNfOBZMFo9tbB2 GxrkdVEkGhIsB0AA1h+ZNE2l/0GVxupphkd7fZjd75BZBxNLYMXgAjMPMeRGnMGrFxpz Ga4GDQlJeNMH5jXO4D9/osOmbq1CK+vt7KQ0CP9h5hDJWl24/zd28F8+Y2GHq6/+AMlj vzHYcytg/N91nDhOvRcyCCri5tTdud+34nQgvLU921dbOHsLr9RLf7xxyhi0BDWaK+wn rE0Q== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@riseup.net header.s=squak header.b=NMLgqt4T; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=riseup.net Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id hg3-20020a17090b300300b0020b07bfc54esi372480pjb.108.2022.10.25.16.12.43; Tue, 25 Oct 2022 16:13:34 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@riseup.net header.s=squak header.b=NMLgqt4T; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=riseup.net Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232117AbiJYXL2 (ORCPT + 99 others); Tue, 25 Oct 2022 19:11:28 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34354 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231877AbiJYXLZ (ORCPT ); Tue, 25 Oct 2022 19:11:25 -0400 Received: from mx1.riseup.net (mx1.riseup.net [198.252.153.129]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2A546D18FA; Tue, 25 Oct 2022 16:11:23 -0700 (PDT) Received: from fews2.riseup.net (fews2-pn.riseup.net [10.0.1.84]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256 client-signature RSA-PSS (2048 bits) client-digest SHA256) (Client CN "mail.riseup.net", Issuer "R3" (not verified)) by mx1.riseup.net (Postfix) with ESMTPS id 4MxnkM1SvszDq8h; Tue, 25 Oct 2022 23:11:23 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=riseup.net; s=squak; t=1666739483; bh=finQVfU1113nTJwkczbf5nMjxzmVG5L0FUY1qZRrKOI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=NMLgqt4Ta+b3GkByEJ2faOJGhg7FSEr06gAS0dtDH1kCsyMkkNYGiMO7Ex2DwzfZQ CJdhobdD0wXcWsC6oDfLkm8QQQA+g7TEgfp8mbiyF6uhIfqTCau33Qh8XYC7nLyQhc 3CDFd9V1eizcHzu/gKCl0yAhFW17F5X38ldPOdDc= X-Riseup-User-ID: C3A9666FF44CDDF4A6F86D0869802BAB88985C51ACCF9A3777BB677C7FC020CD Received: from [127.0.0.1] (localhost [127.0.0.1]) by fews2.riseup.net (Postfix) with ESMTPSA id 4MxnkD6PD6z1yRB; Tue, 25 Oct 2022 23:11:16 +0000 (UTC) From: =?utf-8?q?Ma=C3=ADra_Canal?= To: Brendan Higgins , davidgow@google.com, Daniel Latypov , airlied@gmail.com, daniel@ffwll.ch, davem@davemloft.net, kuba@kernel.org, jose.exposito89@gmail.com, javierm@redhat.com Cc: andrealmeid@riseup.net, melissa.srw@gmail.com, siqueirajordao@riseup.net, Isabella Basso , magalilemes00@gmail.com, tales.aparecida@gmail.com, linux-kselftest@vger.kernel.org, kunit-dev@googlegroups.com, linux-kernel@vger.kernel.org, =?utf-8?q?Ma?= =?utf-8?q?=C3=ADra_Canal?= , Muhammad Usama Anjum Subject: [PATCH v7 1/3] kunit: Introduce KUNIT_EXPECT_MEMEQ and KUNIT_EXPECT_MEMNEQ macros Date: Tue, 25 Oct 2022 20:10:41 -0300 Message-Id: <20221025231043.115295-2-mairacanal@riseup.net> In-Reply-To: <20221025231043.115295-1-mairacanal@riseup.net> References: <20221025231043.115295-1-mairacanal@riseup.net> MIME-Version: 1.0 X-Spam-Status: No, score=-2.8 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H3,RCVD_IN_MSPIKE_WL,SPF_HELO_PASS,SPF_PASS, URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1747703157445340973?= X-GMAIL-MSGID: =?utf-8?q?1747703157445340973?= Currently, in order to compare memory blocks in KUnit, the KUNIT_EXPECT_EQ or KUNIT_EXPECT_FALSE macros are used in conjunction with the memcmp function, such as: KUNIT_EXPECT_EQ(test, memcmp(foo, bar, size), 0); Although this usage produces correct results for the test cases, when the expectation fails, the error message is not very helpful, indicating only the return of the memcmp function. Therefore, create a new set of macros KUNIT_EXPECT_MEMEQ and KUNIT_EXPECT_MEMNEQ that compare memory blocks until a specified size. In case of expectation failure, those macros print the hex dump of the memory blocks, making it easier to debug test failures for memory blocks. That said, the expectation KUNIT_EXPECT_EQ(test, memcmp(foo, bar, size), 0); would translate to the expectation KUNIT_EXPECT_MEMEQ(test, foo, bar, size); Signed-off-by: Maíra Canal Reviewed-by: Daniel Latypov Reviewed-by: Muhammad Usama Anjum Reviewed-by: David Gow --- include/kunit/assert.h | 33 ++++++++++++++++ include/kunit/test.h | 87 ++++++++++++++++++++++++++++++++++++++++++ lib/kunit/assert.c | 56 +++++++++++++++++++++++++++ 3 files changed, 176 insertions(+) diff --git a/include/kunit/assert.h b/include/kunit/assert.h index ace3de8d1ee7..e8a59487fd59 100644 --- a/include/kunit/assert.h +++ b/include/kunit/assert.h @@ -240,4 +240,37 @@ void kunit_binary_str_assert_format(const struct kunit_assert *assert, const struct va_format *message, struct string_stream *stream); +#define KUNIT_INIT_MEM_ASSERT_STRUCT(text_, left_val, right_val, size_) { \ + .text = text_, \ + .left_value = left_val, \ + .right_value = right_val, \ + .size = size_ \ +} + +/** + * struct kunit_mem_assert - An expectation/assertion that compares two + * memory blocks. + * @assert: The parent of this type. + * @text: Holds the textual representations of the operands and comparator. + * @left_value: The actual evaluated value of the expression in the left slot. + * @right_value: The actual evaluated value of the expression in the right slot. + * @size: Size of the memory block analysed in bytes. + * + * Represents an expectation/assertion that compares two memory blocks. For + * example, to expect that the first three bytes of foo is equal to the + * first three bytes of bar, you can use the expectation + * KUNIT_EXPECT_MEMEQ(test, foo, bar, 3); + */ +struct kunit_mem_assert { + struct kunit_assert assert; + const struct kunit_binary_assert_text *text; + const void *left_value; + const void *right_value; + const size_t size; +}; + +void kunit_mem_assert_format(const struct kunit_assert *assert, + const struct va_format *message, + struct string_stream *stream); + #endif /* _KUNIT_ASSERT_H */ diff --git a/include/kunit/test.h b/include/kunit/test.h index b1ab6b32216d..cde97dc4eed5 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -658,6 +658,39 @@ do { \ ##__VA_ARGS__); \ } while (0) +#define KUNIT_MEM_ASSERTION(test, \ + assert_type, \ + left, \ + op, \ + right, \ + size, \ + fmt, \ + ...) \ +do { \ + const void *__left = (left); \ + const void *__right = (right); \ + const size_t __size = (size); \ + static const struct kunit_binary_assert_text __text = { \ + .operation = #op, \ + .left_text = #left, \ + .right_text = #right, \ + }; \ + \ + if (likely(memcmp(__left, __right, __size) op 0)) \ + break; \ + \ + _KUNIT_FAILED(test, \ + assert_type, \ + kunit_mem_assert, \ + kunit_mem_assert_format, \ + KUNIT_INIT_MEM_ASSERT_STRUCT(&__text, \ + __left, \ + __right, \ + __size), \ + fmt, \ + ##__VA_ARGS__); \ +} while (0) + #define KUNIT_PTR_NOT_ERR_OR_NULL_MSG_ASSERTION(test, \ assert_type, \ ptr, \ @@ -928,6 +961,60 @@ do { \ fmt, \ ##__VA_ARGS__) +/** + * KUNIT_EXPECT_MEMEQ() - Expects that the first @size bytes of @left and @right are equal. + * @test: The test context object. + * @left: An arbitrary expression that evaluates to the specified size. + * @right: An arbitrary expression that evaluates to the specified size. + * @size: Number of bytes compared. + * + * Sets an expectation that the values that @left and @right evaluate to are + * equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, !memcmp((@left), (@right), (@size))). See + * KUNIT_EXPECT_TRUE() for more information. + * + * Although this expectation works for any memory block, it is not recommended + * for comparing more structured data, such as structs. This expectation is + * recommended for comparing, for example, data arrays. + */ +#define KUNIT_EXPECT_MEMEQ(test, left, right, size) \ + KUNIT_EXPECT_MEMEQ_MSG(test, left, right, size, NULL) + +#define KUNIT_EXPECT_MEMEQ_MSG(test, left, right, size, fmt, ...) \ + KUNIT_MEM_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, ==, right, \ + size, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_MEMNEQ() - Expects that the first @size bytes of @left and @right are not equal. + * @test: The test context object. + * @left: An arbitrary expression that evaluates to the specified size. + * @right: An arbitrary expression that evaluates to the specified size. + * @size: Number of bytes compared. + * + * Sets an expectation that the values that @left and @right evaluate to are + * not equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, memcmp((@left), (@right), (@size))). See + * KUNIT_EXPECT_TRUE() for more information. + * + * Although this expectation works for any memory block, it is not recommended + * for comparing more structured data, such as structs. This expectation is + * recommended for comparing, for example, data arrays. + */ +#define KUNIT_EXPECT_MEMNEQ(test, left, right, size) \ + KUNIT_EXPECT_MEMNEQ_MSG(test, left, right, size, NULL) + +#define KUNIT_EXPECT_MEMNEQ_MSG(test, left, right, size, fmt, ...) \ + KUNIT_MEM_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, !=, right, \ + size, \ + fmt, \ + ##__VA_ARGS__) + /** * KUNIT_EXPECT_NULL() - Expects that @ptr is null. * @test: The test context object. diff --git a/lib/kunit/assert.c b/lib/kunit/assert.c index d00d6d181ee8..c346a8d7fa6e 100644 --- a/lib/kunit/assert.c +++ b/lib/kunit/assert.c @@ -204,3 +204,59 @@ void kunit_binary_str_assert_format(const struct kunit_assert *assert, kunit_assert_print_msg(message, stream); } EXPORT_SYMBOL_GPL(kunit_binary_str_assert_format); + +/* Adds a hexdump of a buffer to a string_stream comparing it with + * a second buffer. The different bytes are marked with <>. + */ +static void kunit_assert_hexdump(struct string_stream *stream, + const void *buf, + const void *compared_buf, + const size_t len) +{ + size_t i; + const u8 *buf1 = buf; + const u8 *buf2 = compared_buf; + + string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT); + + for (i = 0; i < len; ++i) { + if (!(i % 16) && i) + string_stream_add(stream, "\n" KUNIT_SUBSUBTEST_INDENT); + + if (buf1[i] != buf2[i]) + string_stream_add(stream, "<%02x>", buf1[i]); + else + string_stream_add(stream, " %02x ", buf1[i]); + } +} + +void kunit_mem_assert_format(const struct kunit_assert *assert, + const struct va_format *message, + struct string_stream *stream) +{ + struct kunit_mem_assert *mem_assert; + + mem_assert = container_of(assert, struct kunit_mem_assert, + assert); + + string_stream_add(stream, + KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n", + mem_assert->text->left_text, + mem_assert->text->operation, + mem_assert->text->right_text); + + string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s ==\n", + mem_assert->text->left_text); + kunit_assert_hexdump(stream, mem_assert->left_value, + mem_assert->right_value, mem_assert->size); + + string_stream_add(stream, "\n"); + + string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s ==\n", + mem_assert->text->right_text); + kunit_assert_hexdump(stream, mem_assert->right_value, + mem_assert->left_value, mem_assert->size); + + kunit_assert_print_msg(message, stream); +} +EXPORT_SYMBOL_GPL(kunit_mem_assert_format); From patchwork Tue Oct 25 23:10:42 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Maira Canal X-Patchwork-Id: 11001 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a5d:6687:0:0:0:0:0 with SMTP id l7csp1266155wru; Tue, 25 Oct 2022 16:13:50 -0700 (PDT) X-Google-Smtp-Source: AMsMyM4kBvMUA5+jdVPpJVYZzRMNfK0pwpjfWi+nflmAMpDHGZ75Nmv/deJfvsz9VMvypceyKQYf X-Received: by 2002:a05:6a00:1491:b0:563:8844:3f31 with SMTP id v17-20020a056a00149100b0056388443f31mr40208769pfu.31.1666739629952; Tue, 25 Oct 2022 16:13:49 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1666739629; cv=none; d=google.com; s=arc-20160816; b=aAMlMIUasp7wDMGxaLQvFFibgTqfyIVz238qNzURDOHC+UwqxkesjQB0jcO/NGnrSX 4hT7otJ9CO39aPKp4ZGu2Z/XPrRuMqpTLu/xRgHdd8cu9tCxHOTgUYJgff36Av/GMGQQ rFNHJkDDJeJWkeAiPaX9X9CB4/z4CBULHLcajsjKXiQgDZOBVLS2eeJni1tBJY+Olp9v fC+ytokxOG1Zhvg+EWxyKQlkB+lXLX/ESgCLtRzxsgyD0Y7E1/vW7XQhS/pjfKjIVYA+ +6I29kdEZaA54b9NHpNwuiGJ9tJeNwuRWXvJQL/He4ulb9e3VMR86++7zxETlJuoY/ei ayYg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=oNS2cRYbPwhpQLJT2T21VpVilWkHcFkDX3rXCxR5jbE=; b=yoxQWlaGM752Q9CZt1fEnrsJTyOLLEvttoZehFozaxJFcRJBc9Yu9Y0WdYLHArvH3E 0oXIcnWYayuUoOhyewQn2nrMP83SdND2Rl+gqL8o4VXP4s56QEJokYhbN1lg7jsZBk4X sFmf3tT8PbMYM0vd5mc7XLKnZFakKw0xNdxyvmn2SWcgj3gNw3Y5vLhEDAkHCa51hkhg Jv3an5Sk6Lo6aomgwQiRkOKUUjEQG6VKuwB9GGRpiFWnHHMsIhQuILS6hwdTjXrCRVNR E04nwY6CG8kPDSBOBFow44DsQscdxt5tVHVrrwRQC8Bd42B2lEbqJJ8gmGsJicy/M7Or 3+4w== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@riseup.net header.s=squak header.b=L+97ygHV; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=riseup.net Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id x31-20020a056a00189f00b0056beba0b31dsi5284128pfh.8.2022.10.25.16.13.07; Tue, 25 Oct 2022 16:13:49 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@riseup.net header.s=squak header.b=L+97ygHV; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=riseup.net Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232226AbiJYXLh (ORCPT + 99 others); Tue, 25 Oct 2022 19:11:37 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34570 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231877AbiJYXLd (ORCPT ); Tue, 25 Oct 2022 19:11:33 -0400 Received: from mx1.riseup.net (mx1.riseup.net [198.252.153.129]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 49374F985F; Tue, 25 Oct 2022 16:11:32 -0700 (PDT) Received: from fews2.riseup.net (fews2-pn.riseup.net [10.0.1.84]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256 client-signature RSA-PSS (2048 bits) client-digest SHA256) (Client CN "mail.riseup.net", Issuer "R3" (not verified)) by mx1.riseup.net (Postfix) with ESMTPS id 4MxnkW1xkfzDqXG; Tue, 25 Oct 2022 23:11:31 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=riseup.net; s=squak; t=1666739491; bh=0pG8SvKuzdedA/Y6PPMpy9eA/KJ5S97Kj4xvsRk+czU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=L+97ygHVOrcJgHp+kqYQzkvQainx4kkspCGs6oru6Re7hXqPybXHsNqKkmno28R1h cZgFUyVvsX8m+SWmF9aN0QK10M7m1ZFjiMkI4hZTCKff3SzFewYLkgPRR4WxZPOO+8 cKX1jkY3IBiFoRhqc1w5a6ley5SF+hqam5ffKwlY= X-Riseup-User-ID: BA211A02475AF8302F99CDD671E8C4FFCD96BC6BF9AD6432FBEECEB7D89BC16A Received: from [127.0.0.1] (localhost [127.0.0.1]) by fews2.riseup.net (Postfix) with ESMTPSA id 4MxnkP2mV9z214Q; Tue, 25 Oct 2022 23:11:25 +0000 (UTC) From: =?utf-8?q?Ma=C3=ADra_Canal?= To: Brendan Higgins , davidgow@google.com, Daniel Latypov , airlied@gmail.com, daniel@ffwll.ch, davem@davemloft.net, kuba@kernel.org, jose.exposito89@gmail.com, javierm@redhat.com Cc: andrealmeid@riseup.net, melissa.srw@gmail.com, siqueirajordao@riseup.net, Isabella Basso , magalilemes00@gmail.com, tales.aparecida@gmail.com, linux-kselftest@vger.kernel.org, kunit-dev@googlegroups.com, linux-kernel@vger.kernel.org, =?utf-8?q?Ma?= =?utf-8?q?=C3=ADra_Canal?= Subject: [PATCH v7 2/3] kunit: Add KUnit memory block assertions to the example_all_expect_macros_test Date: Tue, 25 Oct 2022 20:10:42 -0300 Message-Id: <20221025231043.115295-3-mairacanal@riseup.net> In-Reply-To: <20221025231043.115295-1-mairacanal@riseup.net> References: <20221025231043.115295-1-mairacanal@riseup.net> MIME-Version: 1.0 X-Spam-Status: No, score=-2.8 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H3,RCVD_IN_MSPIKE_WL,SPF_HELO_PASS,SPF_PASS, URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1747703174160357463?= X-GMAIL-MSGID: =?utf-8?q?1747703174160357463?= Augment the example_all_expect_macros_test with the KUNIT_EXPECT_MEMEQ and KUNIT_EXPECT_MEMNEQ macros by creating a test with memory block assertions. Signed-off-by: Maíra Canal Reviewed-by: Daniel Latypov Reviewed-by: David Gow --- lib/kunit/kunit-example-test.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/lib/kunit/kunit-example-test.c b/lib/kunit/kunit-example-test.c index f8fe582c9e36..66cc4e2365ec 100644 --- a/lib/kunit/kunit-example-test.c +++ b/lib/kunit/kunit-example-test.c @@ -86,6 +86,9 @@ static void example_mark_skipped_test(struct kunit *test) */ static void example_all_expect_macros_test(struct kunit *test) { + const u32 array1[] = { 0x0F, 0xFF }; + const u32 array2[] = { 0x1F, 0xFF }; + /* Boolean assertions */ KUNIT_EXPECT_TRUE(test, true); KUNIT_EXPECT_FALSE(test, false); @@ -109,6 +112,10 @@ static void example_all_expect_macros_test(struct kunit *test) KUNIT_EXPECT_STREQ(test, "hi", "hi"); KUNIT_EXPECT_STRNEQ(test, "hi", "bye"); + /* Memory block assertions */ + KUNIT_EXPECT_MEMEQ(test, array1, array1, sizeof(array1)); + KUNIT_EXPECT_MEMNEQ(test, array1, array2, sizeof(array1)); + /* * There are also ASSERT variants of all of the above that abort test * execution if they fail. Useful for memory allocations, etc. From patchwork Tue Oct 25 23:10:43 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Maira Canal X-Patchwork-Id: 11002 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a5d:6687:0:0:0:0:0 with SMTP id l7csp1266159wru; Tue, 25 Oct 2022 16:13:50 -0700 (PDT) X-Google-Smtp-Source: AMsMyM4P34mHCqSgh430c/Wf3FYGRaMaHl9cTTlzc7T23pJLJit6Q0Tc6nFORjXnsdSyJjyAQkop X-Received: by 2002:a63:fa4f:0:b0:438:e26d:5ec with SMTP id g15-20020a63fa4f000000b00438e26d05ecmr34921262pgk.361.1666739630269; Tue, 25 Oct 2022 16:13:50 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1666739630; cv=none; d=google.com; s=arc-20160816; b=fT6zX0BUxkMhCIAxTB7W/O2DQ6GwfuR7YsXzTtwWP1hEByXUNDYrd5VFV4tLNwom5C /Vpjbf3CiRkBaxfTVKKxsW4b54YpNMe/K/m77b6NsTDsLTZT9ZjWooFncOG5ksqXGpuA wbzz4qI94YunvobFl14eFvux0L8DVXKAcHw5nme/9tokLzyUsSC5e+IdBzPQgrBxPNl8 0oPdYnX+yg1nTrPq9JAvlrH/fTUttUoEqkFFDu9YvEiDzimNk6/Zx5ja+QuVZeKPyb2N Q1hfn53p99LwDqusZ2L2yPmjy8ePZulOHfm3hS86LmdirznCrEOZInOc1Y0c71FjrL5O 4IPw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=5IzZVMQ2Teadq3mMxTYZsZ/ayxeXTbijvQz9AXwok30=; b=ZUWtnY+K6Taz7K6nZ8NzEFEEDLKkpF2JmpbAoGJfHE+Wrn++j8VUvBcRAQ/g2kv+IJ pk9oV9E3IclvyqXlQX5V68QMvdfm/NAi+G6elK03AOhtBDRac+LshJJIP06Ij5vZv1Un hrzrJqVOuY/ep7IHM7mEzf6WQz/9Oj+a1Q6USGtaWY4MdNTIhyfRFHntd9gxYyagn3gE ZkZni4RpLl8/dxUqstarueK6bKBRVpX8VpmTn0ATY4u/UInz/PXGjDB9zNjuJY+LlBCj WYu1mcy+0kn6YR0BkRRtIKmDOY6SDrI0fvt94LyhHDpoXc6RURg3rjW6smfpiZhmrH94 NLdA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@riseup.net header.s=squak header.b=HRPysWCd; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=riseup.net Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id k1-20020a170902d58100b001867d0e4307si4306087plh.372.2022.10.25.16.13.11; Tue, 25 Oct 2022 16:13:50 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@riseup.net header.s=squak header.b=HRPysWCd; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=riseup.net Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232338AbiJYXL7 (ORCPT + 99 others); Tue, 25 Oct 2022 19:11:59 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34900 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229904AbiJYXLz (ORCPT ); Tue, 25 Oct 2022 19:11:55 -0400 Received: from mx0.riseup.net (mx0.riseup.net [198.252.153.6]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2F6B6E985F; Tue, 25 Oct 2022 16:11:53 -0700 (PDT) Received: from fews2.riseup.net (fews2-pn.riseup.net [10.0.1.84]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256 client-signature RSA-PSS (2048 bits) client-digest SHA256) (Client CN "mail.riseup.net", Issuer "R3" (not verified)) by mx0.riseup.net (Postfix) with ESMTPS id 4Mxnkx15wmz9t3J; Tue, 25 Oct 2022 23:11:53 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=riseup.net; s=squak; t=1666739513; bh=+uZCa63O28kS1jVgRuq7nLZc+fW3SMcazZAt75fp3EA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=HRPysWCdA3I7eZ3MnwlRxQtWgSLk16cNCP8d30YFcE0KMJmdMSPlYUllThfY/+dXB 8+BgxQ0YHmzsFB4blQwf3xIvNONeAPfAL/C1bm6vBpIrLI8eKVJo5u8IqZoo00uexY PADu8WS3uh0xjaxhgyMrDvYzwWoU8xLEIJFC3VXo= X-Riseup-User-ID: 359DA98AD13B92FE6E2A6E2B8ED50878333852437894BD89367A896A3B81C974 Received: from [127.0.0.1] (localhost [127.0.0.1]) by fews2.riseup.net (Postfix) with ESMTPSA id 4Mxnkq6Wb2z1yPb; Tue, 25 Oct 2022 23:11:47 +0000 (UTC) From: =?utf-8?q?Ma=C3=ADra_Canal?= To: Brendan Higgins , davidgow@google.com, Daniel Latypov , airlied@gmail.com, daniel@ffwll.ch, davem@davemloft.net, kuba@kernel.org, jose.exposito89@gmail.com, javierm@redhat.com Cc: andrealmeid@riseup.net, melissa.srw@gmail.com, siqueirajordao@riseup.net, Isabella Basso , magalilemes00@gmail.com, tales.aparecida@gmail.com, linux-kselftest@vger.kernel.org, kunit-dev@googlegroups.com, linux-kernel@vger.kernel.org, =?utf-8?q?Ma?= =?utf-8?q?=C3=ADra_Canal?= Subject: [PATCH v7 3/3] kunit: Use KUNIT_EXPECT_MEMEQ macro Date: Tue, 25 Oct 2022 20:10:43 -0300 Message-Id: <20221025231043.115295-4-mairacanal@riseup.net> In-Reply-To: <20221025231043.115295-1-mairacanal@riseup.net> References: <20221025231043.115295-1-mairacanal@riseup.net> MIME-Version: 1.0 X-Spam-Status: No, score=-2.8 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_LOW,SPF_HELO_PASS, SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1747703174403687447?= X-GMAIL-MSGID: =?utf-8?q?1747703174403687447?= Use KUNIT_EXPECT_MEMEQ to compare memory blocks in replacement of the KUNIT_EXPECT_EQ macro. Therefor, the statement KUNIT_EXPECT_EQ(test, memcmp(foo, bar, size), 0); is replaced by: KUNIT_EXPECT_MEMEQ(test, foo, bar, size); Signed-off-by: Maíra Canal Acked-by: Daniel Latypov Reviewed-by: David Gow --- drivers/gpu/drm/tests/drm_format_helper_test.c | 12 ++++++------ net/core/dev_addr_lists_test.c | 4 ++-- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/drivers/gpu/drm/tests/drm_format_helper_test.c b/drivers/gpu/drm/tests/drm_format_helper_test.c index 2191e57f2297..567c71f95edc 100644 --- a/drivers/gpu/drm/tests/drm_format_helper_test.c +++ b/drivers/gpu/drm/tests/drm_format_helper_test.c @@ -315,7 +315,7 @@ static void drm_test_fb_xrgb8888_to_gray8(struct kunit *test) iosys_map_set_vaddr(&src, xrgb8888); drm_fb_xrgb8888_to_gray8(&dst, &result->dst_pitch, &src, &fb, ¶ms->clip); - KUNIT_EXPECT_EQ(test, memcmp(buf, result->expected, dst_size), 0); + KUNIT_EXPECT_MEMEQ(test, buf, result->expected, dst_size); } static void drm_test_fb_xrgb8888_to_rgb332(struct kunit *test) @@ -345,7 +345,7 @@ static void drm_test_fb_xrgb8888_to_rgb332(struct kunit *test) iosys_map_set_vaddr(&src, xrgb8888); drm_fb_xrgb8888_to_rgb332(&dst, &result->dst_pitch, &src, &fb, ¶ms->clip); - KUNIT_EXPECT_EQ(test, memcmp(buf, result->expected, dst_size), 0); + KUNIT_EXPECT_MEMEQ(test, buf, result->expected, dst_size); } static void drm_test_fb_xrgb8888_to_rgb565(struct kunit *test) @@ -375,10 +375,10 @@ static void drm_test_fb_xrgb8888_to_rgb565(struct kunit *test) iosys_map_set_vaddr(&src, xrgb8888); drm_fb_xrgb8888_to_rgb565(&dst, &result->dst_pitch, &src, &fb, ¶ms->clip, false); - KUNIT_EXPECT_EQ(test, memcmp(buf, result->expected, dst_size), 0); + KUNIT_EXPECT_MEMEQ(test, buf, result->expected, dst_size); drm_fb_xrgb8888_to_rgb565(&dst, &result->dst_pitch, &src, &fb, ¶ms->clip, true); - KUNIT_EXPECT_EQ(test, memcmp(buf, result->expected_swab, dst_size), 0); + KUNIT_EXPECT_MEMEQ(test, buf, result->expected_swab, dst_size); } static void drm_test_fb_xrgb8888_to_rgb888(struct kunit *test) @@ -408,7 +408,7 @@ static void drm_test_fb_xrgb8888_to_rgb888(struct kunit *test) iosys_map_set_vaddr(&src, xrgb8888); drm_fb_xrgb8888_to_rgb888(&dst, &result->dst_pitch, &src, &fb, ¶ms->clip); - KUNIT_EXPECT_EQ(test, memcmp(buf, result->expected, dst_size), 0); + KUNIT_EXPECT_MEMEQ(test, buf, result->expected, dst_size); } static void drm_test_fb_xrgb8888_to_xrgb2101010(struct kunit *test) @@ -439,7 +439,7 @@ static void drm_test_fb_xrgb8888_to_xrgb2101010(struct kunit *test) drm_fb_xrgb8888_to_xrgb2101010(&dst, &result->dst_pitch, &src, &fb, ¶ms->clip); buf = le32buf_to_cpu(test, buf, dst_size / sizeof(u32)); - KUNIT_EXPECT_EQ(test, memcmp(buf, result->expected, dst_size), 0); + KUNIT_EXPECT_MEMEQ(test, buf, result->expected, dst_size); } static struct kunit_case drm_format_helper_test_cases[] = { diff --git a/net/core/dev_addr_lists_test.c b/net/core/dev_addr_lists_test.c index 049cfbc58aa9..90e7e3811ae7 100644 --- a/net/core/dev_addr_lists_test.c +++ b/net/core/dev_addr_lists_test.c @@ -71,11 +71,11 @@ static void dev_addr_test_basic(struct kunit *test) memset(addr, 2, sizeof(addr)); eth_hw_addr_set(netdev, addr); - KUNIT_EXPECT_EQ(test, 0, memcmp(netdev->dev_addr, addr, sizeof(addr))); + KUNIT_EXPECT_MEMEQ(test, netdev->dev_addr, addr, sizeof(addr)); memset(addr, 3, sizeof(addr)); dev_addr_set(netdev, addr); - KUNIT_EXPECT_EQ(test, 0, memcmp(netdev->dev_addr, addr, sizeof(addr))); + KUNIT_EXPECT_MEMEQ(test, netdev->dev_addr, addr, sizeof(addr)); } static void dev_addr_test_sync_one(struct kunit *test)