LinuxLists.cc - [PATCH v3 0/3] Introduce KUNIT_EXPECT_MEMEQ and KUNIT_EXPECT

2022-08-03 22:02:39

Subject: [PATCH v3 0/3] Introduce KUNIT_EXPECT_MEMEQ and KUNIT_EXPECT_MEMNEQ macros

2022-08-03 22:03:04

Subject: [PATCH v3 2/3] kunit: Add KUnit memory block assertions to the example_all_expect_macros_test

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 <[email protected]>
Reviewed-by: Daniel Latypov <[email protected]>
---
v1 -> v2:
- Change the macro KUNIT_EXPECT_ARREQ to KUNIT_EXPECT_MEMEQ, in order to make
it easier for users to infer the right size unit (Daniel Latypov).
- Replace a constant number of array elements for ARRAY_SIZE() (André Almeida).
- Rename "array" and "expected" variables to "array1" and "array2" (Daniel Latypov).

v2 -> v3:
- Change "Increament" to "Augment" (Daniel Latypov).
- Use sizeof() for array sizes (Daniel Latypov).
---
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.
--
2.37.1

2022-08-03 22:14:21

by Maira Canal

[permalink] [raw]

Subject: [PATCH v3 3/3] kunit: Use KUNIT_EXPECT_MEMEQ macro

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 <[email protected]>
Acked-by: Daniel Latypov <[email protected]>
---
v1 -> v2:
- Change the macro KUNIT_EXPECT_ARREQ to KUNIT_EXPECT_MEMEQ, in order to make
it easier for users to infer the right size unit (Daniel Latypov).

v2 -> v3: No changes.
---
drivers/gpu/drm/tests/drm_format_helper_test.c | 6 +++---
net/core/dev_addr_lists_test.c | 4 ++--
2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/drivers/gpu/drm/tests/drm_format_helper_test.c b/drivers/gpu/drm/tests/drm_format_helper_test.c
index 26ecf3b4b137..482136282273 100644
--- a/drivers/gpu/drm/tests/drm_format_helper_test.c
+++ b/drivers/gpu/drm/tests/drm_format_helper_test.c
@@ -217,7 +217,7 @@ static void xrgb8888_to_rgb332_test(struct kunit *test)

drm_fb_xrgb8888_to_rgb332(dst, result->dst_pitch, src, &fb,
&params->clip);
- KUNIT_EXPECT_EQ(test, memcmp(dst, result->expected, dst_size), 0);
+ KUNIT_EXPECT_MEMEQ(test, dst, result->expected, dst_size);
}

static void xrgb8888_to_rgb565_test(struct kunit *test)
@@ -245,11 +245,11 @@ static void xrgb8888_to_rgb565_test(struct kunit *test)

drm_fb_xrgb8888_to_rgb565(dst, result->dst_pitch, src, &fb,
&params->clip, false);
- KUNIT_EXPECT_EQ(test, memcmp(dst, result->expected, dst_size), 0);
+ KUNIT_EXPECT_MEMEQ(test, dst, result->expected, dst_size);

drm_fb_xrgb8888_to_rgb565(dst, result->dst_pitch, src, &fb,
&params->clip, true);
- KUNIT_EXPECT_EQ(test, memcmp(dst, result->expected_swab, dst_size), 0);
+ KUNIT_EXPECT_MEMEQ(test, dst, result->expected_swab, 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)
--
2.37.1

2022-08-03 22:14:22

by Maira Canal

[permalink] [raw]

Subject: [PATCH v3 1/3] kunit: Introduce KUNIT_EXPECT_MEMEQ and KUNIT_EXPECT_MEMNEQ macros

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 <[email protected]>
Reviewed-by: Daniel Latypov <[email protected]>
---
v1 -> v2:
- Change "determinated" to "specified" (Daniel Latypov).
- Change the macro KUNIT_EXPECT_ARREQ to KUNIT_EXPECT_MEMEQ, in order to make
it easier for users to infer the right size unit (Daniel Latypov).
- Mark the different bytes on the failure message with a <> (Daniel Latypov).

v2 -> v3:
- Make the bytes aligned at output.
- Add KUNIT_SUBSUBTEST_INDENT to the output for the indentation (Daniel Latypov).
- Line up the trailing \ at macros using tabs (Daniel Latypov).
- Line up the params to the functions (Daniel Latypov).
---
include/kunit/assert.h | 34 +++++++++++++++++++
include/kunit/test.h | 76 ++++++++++++++++++++++++++++++++++++++++++
lib/kunit/assert.c | 56 +++++++++++++++++++++++++++++++
3 files changed, 166 insertions(+)

diff --git a/include/kunit/assert.h b/include/kunit/assert.h
index 4b52e12c2ae8..4b817a8eb619 100644
--- a/include/kunit/assert.h
+++ b/include/kunit/assert.h
@@ -256,4 +256,38 @@ 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_) \
+ { \
+ .assert = { .format = kunit_mem_assert_format }, \
+ .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 8ffcd7de9607..02eeaff1c58e 100644
--- a/include/kunit/test.h
+++ b/include/kunit/test.h
@@ -684,6 +684,36 @@ 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, \
+ }; \
+ \
+ KUNIT_ASSERTION(test, \
+ assert_type, \
+ memcmp(__left, __right, __size) op 0, \
+ kunit_mem_assert, \
+ 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, \
@@ -952,6 +982,52 @@ 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.
+ */
+#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.
+ */
+#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);
--
2.37.1

2022-08-05 04:56:39

by David Gow

[permalink] [raw]

Subject: Re: [PATCH v3 0/3] Introduce KUNIT_EXPECT_MEMEQ and KUNIT_EXPECT_MEMNEQ macros

On Thu, Aug 4, 2022 at 5:59 AM Maíra Canal <[email protected]> wrote:
>
> 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, if 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 determined 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.
>
> Other than the style changes, this v3 brings alignment to the bytes, making
> it easier to identify the faulty bytes. So, on the previous version, the
> output from a failure would be:
> [14:27:42] # xrgb8888_to_rgb565_test: EXPECTATION FAILED at drivers/gpu/drm/tests/drm_format_helper_test.c:248
> [14:27:42] Expected dst == result->expected, but
> [14:27:42] dst ==
> [14:27:42] 33 0a <60> 12 00 a8 00 00 <00> 00 8e 6b <33> 0a 60 12
> [14:27:42] 00 00 <00> 00 00 a8 <8e> 6b 33 0a 00 00 <00> 00
> [14:27:42] result->expected ==
> [14:27:42] 33 0a <61> 12 00 a8 00 00 <01> 00 8e 6b <31> 0a 60 12
> [14:27:42] 00 00 <01> 00 00 a8 <81> 6b 33 0a 00 00 <01> 00
>
> Now, with the alignment, the output is:
> [14:27:42] # xrgb8888_to_rgb565_test: EXPECTATION FAILED at drivers/gpu/drm/tests/drm_format_helper_test.c:248
> [14:27:42] Expected dst == result->expected, but
> [14:27:42] dst ==
> [14:27:42] 33 0a <60> 12 00 a8 00 00 <00> 00 8e 6b <33> 0a 60 12
> [14:27:42] 00 00 <00> 00 00 a8 <8e> 6b 33 0a 00 00 <00> 00
> [14:27:42] result->expected ==
> [14:27:42] 33 0a <61> 12 00 a8 00 00 <01> 00 8e 6b <31> 0a 60 12
> [14:27:42] 00 00 <01> 00 00 a8 <81> 6b 33 0a 00 00 <01> 00
>
> Moreover, on the raw output, there were some indentation problems. Those
> problems were solved with the use of KUNIT_SUBSUBTEST_INDENT.
>
> The first patch of the series introduces the KUNIT_EXPECT_MEMEQ and
> KUNIT_EXPECT_MEMNEQ. The second patch adds an example of memory block
> expectations on the kunit-example-test.c. And the last patch replaces the
> KUNIT_EXPECT_EQ for KUNIT_EXPECT_MEMEQ on the existing occurrences.
>
> Best Regards,
> - Maíra Canal
>
> v1 -> v2: https://lore.kernel.org/linux-kselftest/[email protected]/T/#m402cc72eb01fb3b88d6706cf7d1705fdd51e5da2
>
> - Change "determinated" to "specified" (Daniel Latypov).
> - Change the macro KUNIT_EXPECT_ARREQ to KUNIT_EXPECT_MEMEQ, in order to make
> it easier for users to infer the right size unit (Daniel Latypov).
> - Mark the different bytes on the failure message with a <> (Daniel Latypov).
> - Replace a constant number of array elements for ARRAY_SIZE() (André Almeida).
> - Rename "array" and "expected" variables to "array1" and "array2" (Daniel Latypov).
>
> v2 -> v3: https://lore.kernel.org/linux-kselftest/[email protected]/T/#t
>
> - Make the bytes aligned at output.
> - Add KUNIT_SUBSUBTEST_INDENT to the output for the indentation (Daniel Latypov).
> - Line up the trailing \ at macros using tabs (Daniel Latypov).
> - Line up the params to the functions (Daniel Latypov).
> - Change "Increament" to "Augment" (Daniel Latypov).
> - Use sizeof() for array sizes (Daniel Latypov).
>
> Maíra Canal (3):
> kunit: Introduce KUNIT_EXPECT_MEMEQ and KUNIT_EXPECT_MEMNEQ macros
> kunit: Add KUnit memory block assertions to the example_all_expect_macros_test
> kunit: Use KUNIT_EXPECT_MEMEQ macro
>
> .../gpu/drm/tests/drm_format_helper_test.c | 6 +-
> include/kunit/assert.h | 34 +++++++++
> include/kunit/test.h | 76 +++++++++++++++++++
> lib/kunit/assert.c | 56 ++++++++++++++
> lib/kunit/kunit-example-test.c | 7 ++
> net/core/dev_addr_lists_test.c | 4 +-
> 6 files changed, 178 insertions(+), 5 deletions(-)
>
> --
> 2.37.1
>
> --
> You received this message because you are subscribed to the Google Groups "KUnit Development" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to [email protected].
> To view this discussion on the web visit https://groups.google.com/d/msgid/kunit-dev/20220803215855.258704-1-mairacanal%40riseup.net.

These patches look pretty good to me overall, but I was unable to
apply v3 to test -- it looks like the mail client has wrapped some
lines or something...

davidgow@slicestar:~/linux-kselftest$ git am
./v3_20220803_mairacanal_introduce_kunit_expect_memeq_and_kunit_expect_memneq_macros.mbx
Applying: kunit: Introduce KUNIT_EXPECT_MEMEQ and KUNIT_EXPECT_MEMNEQ macros
error: corrupt patch at line 24
Patch failed at 0001 kunit: Introduce KUNIT_EXPECT_MEMEQ and
KUNIT_EXPECT_MEMNEQ macros

Checkpatch also picks up an issue:
ERROR: patch seems to be corrupt (line wrapped?)
#62: FILE: include/kunit/assert.h:255:
const struct va_format *message,

v2 applied clearnly, so it seems to be specific to v3.

In general, I like the patches, though. While I think there are a few
places it'd be slightly suboptimale if it's being used to compare more
structured data, such as the prospect of comparing padding between
elements, as well as the output formatting not being ideal. It's
perfect for the cases where memcmp() otherwise would be used, though.

Cheers,
-- David

Attachments:

smime.p7s (3.91 kB)
S/MIME Cryptographic Signature

2022-08-05 12:21:45

by Maira Canal

[permalink] [raw]

Subject: Re: [PATCH v3 0/3] Introduce KUNIT_EXPECT_MEMEQ and KUNIT_EXPECT_MEMNEQ macros

On 8/5/22 01:44, David Gow wrote:
> On Thu, Aug 4, 2022 at 5:59 AM Maíra Canal <[email protected]> wrote:
>>
>> 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, if 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 determined 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.
>>
>> Other than the style changes, this v3 brings alignment to the bytes, making
>> it easier to identify the faulty bytes. So, on the previous version, the
>> output from a failure would be:
>> [14:27:42] # xrgb8888_to_rgb565_test: EXPECTATION FAILED at drivers/gpu/drm/tests/drm_format_helper_test.c:248
>> [14:27:42] Expected dst == result->expected, but
>> [14:27:42] dst ==
>> [14:27:42] 33 0a <60> 12 00 a8 00 00 <00> 00 8e 6b <33> 0a 60 12
>> [14:27:42] 00 00 <00> 00 00 a8 <8e> 6b 33 0a 00 00 <00> 00
>> [14:27:42] result->expected ==
>> [14:27:42] 33 0a <61> 12 00 a8 00 00 <01> 00 8e 6b <31> 0a 60 12
>> [14:27:42] 00 00 <01> 00 00 a8 <81> 6b 33 0a 00 00 <01> 00
>>
>> Now, with the alignment, the output is:
>> [14:27:42] # xrgb8888_to_rgb565_test: EXPECTATION FAILED at drivers/gpu/drm/tests/drm_format_helper_test.c:248
>> [14:27:42] Expected dst == result->expected, but
>> [14:27:42] dst ==
>> [14:27:42] 33 0a <60> 12 00 a8 00 00 <00> 00 8e 6b <33> 0a 60 12
>> [14:27:42] 00 00 <00> 00 00 a8 <8e> 6b 33 0a 00 00 <00> 00
>> [14:27:42] result->expected ==
>> [14:27:42] 33 0a <61> 12 00 a8 00 00 <01> 00 8e 6b <31> 0a 60 12
>> [14:27:42] 00 00 <01> 00 00 a8 <81> 6b 33 0a 00 00 <01> 00
>>
>> Moreover, on the raw output, there were some indentation problems. Those
>> problems were solved with the use of KUNIT_SUBSUBTEST_INDENT.
>>
>> The first patch of the series introduces the KUNIT_EXPECT_MEMEQ and
>> KUNIT_EXPECT_MEMNEQ. The second patch adds an example of memory block
>> expectations on the kunit-example-test.c. And the last patch replaces the
>> KUNIT_EXPECT_EQ for KUNIT_EXPECT_MEMEQ on the existing occurrences.
>>
>> Best Regards,
>> - Maíra Canal
>>
>> v1 -> v2: https://lore.kernel.org/linux-kselftest/[email protected]/T/#m402cc72eb01fb3b88d6706cf7d1705fdd51e5da2
>>
>> - Change "determinated" to "specified" (Daniel Latypov).
>> - Change the macro KUNIT_EXPECT_ARREQ to KUNIT_EXPECT_MEMEQ, in order to make
>> it easier for users to infer the right size unit (Daniel Latypov).
>> - Mark the different bytes on the failure message with a <> (Daniel Latypov).
>> - Replace a constant number of array elements for ARRAY_SIZE() (André Almeida).
>> - Rename "array" and "expected" variables to "array1" and "array2" (Daniel Latypov).
>>
>> v2 -> v3: https://lore.kernel.org/linux-kselftest/[email protected]/T/#t
>>
>> - Make the bytes aligned at output.
>> - Add KUNIT_SUBSUBTEST_INDENT to the output for the indentation (Daniel Latypov).
>> - Line up the trailing \ at macros using tabs (Daniel Latypov).
>> - Line up the params to the functions (Daniel Latypov).
>> - Change "Increament" to "Augment" (Daniel Latypov).
>> - Use sizeof() for array sizes (Daniel Latypov).
>>
>> Maíra Canal (3):
>> kunit: Introduce KUNIT_EXPECT_MEMEQ and KUNIT_EXPECT_MEMNEQ macros
>> kunit: Add KUnit memory block assertions to the example_all_expect_macros_test
>> kunit: Use KUNIT_EXPECT_MEMEQ macro
>>
>> .../gpu/drm/tests/drm_format_helper_test.c | 6 +-
>> include/kunit/assert.h | 34 +++++++++
>> include/kunit/test.h | 76 +++++++++++++++++++
>> lib/kunit/assert.c | 56 ++++++++++++++
>> lib/kunit/kunit-example-test.c | 7 ++
>> net/core/dev_addr_lists_test.c | 4 +-
>> 6 files changed, 178 insertions(+), 5 deletions(-)
>>
>> --
>> 2.37.1
>>
>> --
>> You received this message because you are subscribed to the Google Groups "KUnit Development" group.
>> To unsubscribe from this group and stop receiving emails from it, send an email to [email protected].
>> To view this discussion on the web visit https://groups.google.com/d/msgid/kunit-dev/20220803215855.258704-1-mairacanal%40riseup.net.
>
> These patches look pretty good to me overall, but I was unable to
> apply v3 to test -- it looks like the mail client has wrapped some
> lines or something...
>
> davidgow@slicestar:~/linux-kselftest$ git am
> ./v3_20220803_mairacanal_introduce_kunit_expect_memeq_and_kunit_expect_memneq_macros.mbx
> Applying: kunit: Introduce KUNIT_EXPECT_MEMEQ and KUNIT_EXPECT_MEMNEQ macros
> error: corrupt patch at line 24
> Patch failed at 0001 kunit: Introduce KUNIT_EXPECT_MEMEQ and
> KUNIT_EXPECT_MEMNEQ macros
>
> Checkpatch also picks up an issue:
> ERROR: patch seems to be corrupt (line wrapped?)
> #62: FILE: include/kunit/assert.h:255:
> const struct va_format *message,
>
> v2 applied clearnly, so it seems to be specific to v3.

I'll check this issue and submit a v4. Thank you!

>
> In general, I like the patches, though. While I think there are a few
> places it'd be slightly suboptimale if it's being used to compare more
> structured data, such as the prospect of comparing padding between
> elements, as well as the output formatting not being ideal. It's
> perfect for the cases where memcmp() otherwise would be used, though.

Do you any take on how to make the output formatting more ideal?

Best Regards,
- Maíra Canal

>
> Cheers,
> -- David

2022-08-05 22:50:25

by David Gow

[permalink] [raw]

Subject: Re: [PATCH v3 0/3] Introduce KUNIT_EXPECT_MEMEQ and KUNIT_EXPECT_MEMNEQ macros

On Fri, Aug 5, 2022 at 8:18 PM Maíra Canal <[email protected]> wrote:
>
> On 8/5/22 01:44, David Gow wrote:
> > On Thu, Aug 4, 2022 at 5:59 AM Maíra Canal <[email protected]> wrote:
> >>
> >> 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, if 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 determined 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.
> >>
> >> Other than the style changes, this v3 brings alignment to the bytes, making
> >> it easier to identify the faulty bytes. So, on the previous version, the
> >> output from a failure would be:
> >> [14:27:42] # xrgb8888_to_rgb565_test: EXPECTATION FAILED at drivers/gpu/drm/tests/drm_format_helper_test.c:248
> >> [14:27:42] Expected dst == result->expected, but
> >> [14:27:42] dst ==
> >> [14:27:42] 33 0a <60> 12 00 a8 00 00 <00> 00 8e 6b <33> 0a 60 12
> >> [14:27:42] 00 00 <00> 00 00 a8 <8e> 6b 33 0a 00 00 <00> 00
> >> [14:27:42] result->expected ==
> >> [14:27:42] 33 0a <61> 12 00 a8 00 00 <01> 00 8e 6b <31> 0a 60 12
> >> [14:27:42] 00 00 <01> 00 00 a8 <81> 6b 33 0a 00 00 <01> 00
> >>
> >> Now, with the alignment, the output is:
> >> [14:27:42] # xrgb8888_to_rgb565_test: EXPECTATION FAILED at drivers/gpu/drm/tests/drm_format_helper_test.c:248
> >> [14:27:42] Expected dst == result->expected, but
> >> [14:27:42] dst ==
> >> [14:27:42] 33 0a <60> 12 00 a8 00 00 <00> 00 8e 6b <33> 0a 60 12
> >> [14:27:42] 00 00 <00> 00 00 a8 <8e> 6b 33 0a 00 00 <00> 00
> >> [14:27:42] result->expected ==
> >> [14:27:42] 33 0a <61> 12 00 a8 00 00 <01> 00 8e 6b <31> 0a 60 12
> >> [14:27:42] 00 00 <01> 00 00 a8 <81> 6b 33 0a 00 00 <01> 00
> >>
> >> Moreover, on the raw output, there were some indentation problems. Those
> >> problems were solved with the use of KUNIT_SUBSUBTEST_INDENT.
> >>
> >> The first patch of the series introduces the KUNIT_EXPECT_MEMEQ and
> >> KUNIT_EXPECT_MEMNEQ. The second patch adds an example of memory block
> >> expectations on the kunit-example-test.c. And the last patch replaces the
> >> KUNIT_EXPECT_EQ for KUNIT_EXPECT_MEMEQ on the existing occurrences.
> >>
> >> Best Regards,
> >> - Maíra Canal
> >>
> >> v1 -> v2: https://lore.kernel.org/linux-kselftest/[email protected]/T/#m402cc72eb01fb3b88d6706cf7d1705fdd51e5da2
> >>
> >> - Change "determinated" to "specified" (Daniel Latypov).
> >> - Change the macro KUNIT_EXPECT_ARREQ to KUNIT_EXPECT_MEMEQ, in order to make
> >> it easier for users to infer the right size unit (Daniel Latypov).
> >> - Mark the different bytes on the failure message with a <> (Daniel Latypov).
> >> - Replace a constant number of array elements for ARRAY_SIZE() (André Almeida).
> >> - Rename "array" and "expected" variables to "array1" and "array2" (Daniel Latypov).
> >>
> >> v2 -> v3: https://lore.kernel.org/linux-kselftest/[email protected]/T/#t
> >>
> >> - Make the bytes aligned at output.
> >> - Add KUNIT_SUBSUBTEST_INDENT to the output for the indentation (Daniel Latypov).
> >> - Line up the trailing \ at macros using tabs (Daniel Latypov).
> >> - Line up the params to the functions (Daniel Latypov).
> >> - Change "Increament" to "Augment" (Daniel Latypov).
> >> - Use sizeof() for array sizes (Daniel Latypov).
> >>
> >> Maíra Canal (3):
> >> kunit: Introduce KUNIT_EXPECT_MEMEQ and KUNIT_EXPECT_MEMNEQ macros
> >> kunit: Add KUnit memory block assertions to the example_all_expect_macros_test
> >> kunit: Use KUNIT_EXPECT_MEMEQ macro
> >>
> >> .../gpu/drm/tests/drm_format_helper_test.c | 6 +-
> >> include/kunit/assert.h | 34 +++++++++
> >> include/kunit/test.h | 76 +++++++++++++++++++
> >> lib/kunit/assert.c | 56 ++++++++++++++
> >> lib/kunit/kunit-example-test.c | 7 ++
> >> net/core/dev_addr_lists_test.c | 4 +-
> >> 6 files changed, 178 insertions(+), 5 deletions(-)
> >>
> >> --
> >> 2.37.1
> >>
> >> --
> >> You received this message because you are subscribed to the Google Groups "KUnit Development" group.
> >> To unsubscribe from this group and stop receiving emails from it, send an email to [email protected].
> >> To view this discussion on the web visit https://groups.google.com/d/msgid/kunit-dev/20220803215855.258704-1-mairacanal%40riseup.net.
> >
> > These patches look pretty good to me overall, but I was unable to
> > apply v3 to test -- it looks like the mail client has wrapped some
> > lines or something...
> >
> > davidgow@slicestar:~/linux-kselftest$ git am
> > ./v3_20220803_mairacanal_introduce_kunit_expect_memeq_and_kunit_expect_memneq_macros.mbx
> > Applying: kunit: Introduce KUNIT_EXPECT_MEMEQ and KUNIT_EXPECT_MEMNEQ macros
> > error: corrupt patch at line 24
> > Patch failed at 0001 kunit: Introduce KUNIT_EXPECT_MEMEQ and
> > KUNIT_EXPECT_MEMNEQ macros
> >
> > Checkpatch also picks up an issue:
> > ERROR: patch seems to be corrupt (line wrapped?)
> > #62: FILE: include/kunit/assert.h:255:
> > const struct va_format *message,
> >
> > v2 applied clearnly, so it seems to be specific to v3.
>
> I'll check this issue and submit a v4. Thank you!
>

Thanks!

> >
> > In general, I like the patches, though. While I think there are a few
> > places it'd be slightly suboptimale if it's being used to compare more
> > structured data, such as the prospect of comparing padding between
> > elements, as well as the output formatting not being ideal. It's
> > perfect for the cases where memcmp() otherwise would be used, though.
>
> Do you any take on how to make the output formatting more ideal?
>

I don't actually think we need to change any of the formatting in this
patch, I'm just noting that usinng MEMEQ()/MEMNEQ() might not be the
best choice for comparing, e.g., structs (and that comparing their
members individually might be better there).
_Maybe_ that's something that could be mentioned in the documentation,
but I wouldn't change the code at all.

Cheers,
-- David

Attachments:

smime.p7s (3.91 kB)
S/MIME Cryptographic Signature

2022-08-06 14:35:45

by Muhammad Usama Anjum

[permalink] [raw]

Subject: Re: [PATCH v3 1/3] kunit: Introduce KUNIT_EXPECT_MEMEQ and KUNIT_EXPECT_MEMNEQ macros

On 8/4/22 2:58 AM, Maíra Canal wrote:
> 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 <[email protected]>
> Reviewed-by: Daniel Latypov <[email protected]>
Reviewed-by: Muhammad Usama Anjum <[email protected]>

> ---
> v1 -> v2:
> - Change "determinated" to "specified" (Daniel Latypov).
> - Change the macro KUNIT_EXPECT_ARREQ to KUNIT_EXPECT_MEMEQ, in order to make
> it easier for users to infer the right size unit (Daniel Latypov).
> - Mark the different bytes on the failure message with a <> (Daniel Latypov).
>
> v2 -> v3:
> - Make the bytes aligned at output.
> - Add KUNIT_SUBSUBTEST_INDENT to the output for the indentation (Daniel Latypov).
> - Line up the trailing \ at macros using tabs (Daniel Latypov).
> - Line up the params to the functions (Daniel Latypov).
> ---
> include/kunit/assert.h | 34 +++++++++++++++++++
> include/kunit/test.h | 76 ++++++++++++++++++++++++++++++++++++++++++
> lib/kunit/assert.c | 56 +++++++++++++++++++++++++++++++
> 3 files changed, 166 insertions(+)
>
> diff --git a/include/kunit/assert.h b/include/kunit/assert.h
> index 4b52e12c2ae8..4b817a8eb619 100644
> --- a/include/kunit/assert.h
> +++ b/include/kunit/assert.h
> @@ -256,4 +256,38 @@ 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_) \
> + { \
> + .assert = { .format = kunit_mem_assert_format }, \
> + .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 8ffcd7de9607..02eeaff1c58e 100644
> --- a/include/kunit/test.h
> +++ b/include/kunit/test.h
> @@ -684,6 +684,36 @@ 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, \
> + }; \
> + \
> + KUNIT_ASSERTION(test, \
> + assert_type, \
> + memcmp(__left, __right, __size) op 0, \
> + kunit_mem_assert, \
> + 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, \
> @@ -952,6 +982,52 @@ 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.
> + */
> +#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.
> + */
> +#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);
> --
> 2.37.1
>

--
Muhammad Usama Anjum