Skip to contentSkip to conversation

seq_buf: Introduce KUnit tests

PATCH In review Kees Cook 3 participants 3 messages Jul 17, 2025 – Jul 26, 2025 Library code

lore
Share & tools
lore

Kees Cook

author
#0 lore raw

PATCH 1/1 seq_buf: Introduce KUnit tests

Add KUnit tests for the seq_buf API to ensure its correctness and prevent future regressions.

The tests cover the following functions:
- seq_buf_init()
- DECLARE_SEQ_BUF()
- seq_buf_clear()
- seq_buf_puts()
- seq_buf_putc()
- seq_buf_printf()
- seq_buf_get_buf()
- seq_buf_commit()

$ tools/testing/kunit/kunit.py run seq_buf
=================== seq_buf (9 subtests) ===================
[PASSED] seq_buf_init_test
[PASSED] seq_buf_declare_test
[PASSED] seq_buf_clear_test
[PASSED] seq_buf_puts_test
[PASSED] seq_buf_puts_overflow_test
[PASSED] seq_buf_putc_test
[PASSED] seq_buf_printf_test
[PASSED] seq_buf_printf_overflow_test
[PASSED] seq_buf_get_buf_commit_test
===================== [PASSED] seq_buf =====================

---
I used an LLM to produce this; it did pretty well, but I had to help it get the Kconfig and make targets in the right places, and I tweaked some of the edge cases and added a bit more (perhaps redundant) state checking.

Cc David Gow <[email protected]>
Cc Rae Moar <[email protected]>
Cc Tamir Duberstein <[email protected]>
Cc Eric Biggers <[email protected]>
Cc "Steven Rostedt (Google)" <[email protected]>
Cc Andy Shevchenko <[email protected]>
Cc Petr Mladek <[email protected]>
Cc "Matthew Wilcox (Oracle)" <[email protected]>
---
 lib/Kconfig.debug         |   9 ++
 lib/tests/Makefile        |   1 +
 lib/tests/seq_buf_kunit.c | 205 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 215 insertions(+)
 create mode 100644 lib/tests/seq_buf_kunit.c
lib/Kconfig.debug +9 -0
index cf05bf1df983..048efc3183d5 100644
@@ -2470,6 +2470,15 @@ config SCANF_KUNIT_TEST
 
 	  If unsure, say N.
 
+config SEQ_BUF_KUNIT_TEST
+	tristate "KUnit test for seq_buf" if !KUNIT_ALL_TESTS
+	depends on KUNIT
+	default KUNIT_ALL_TESTS
+	help
+	  This builds unit tests for the seq_buf library.
+
+	  If unsure, say N.
+
 config STRING_KUNIT_TEST
 	tristate "KUnit test string functions at runtime" if !KUNIT_ALL_TESTS
 	depends on KUNIT
lib/tests/Makefile +1 -0
index 84b15c986b8c..fa6d728a8b5b 100644
@@ -36,6 +36,7 @@ obj-$(CONFIG_OVERFLOW_KUNIT_TEST) += overflow_kunit.o
 obj-$(CONFIG_PRINTF_KUNIT_TEST) += printf_kunit.o
 obj-$(CONFIG_RANDSTRUCT_KUNIT_TEST) += randstruct_kunit.o
 obj-$(CONFIG_SCANF_KUNIT_TEST) += scanf_kunit.o
+obj-$(CONFIG_SEQ_BUF_KUNIT_TEST) += seq_buf_kunit.o
 obj-$(CONFIG_SIPHASH_KUNIT_TEST) += siphash_kunit.o
 obj-$(CONFIG_SLUB_KUNIT_TEST) += slub_kunit.o
 obj-$(CONFIG_TEST_SORT) += test_sort.o
lib/tests/seq_buf_kunit.c new file +205 -0

205 lines not on this page · raw message

Signature · 1 line
2.34.1
#1 lore raw
Quoted 3 lines · On Thu, 17 Jul 2025 01:52:12 -0700 Kees Cook <[email protected]> wrote:

I used an LLM to produce this; it did pretty well, but I had to help it get the Kconfig and make targets in the right places, and I tweaked some of the edge cases and added a bit more (perhaps redundant) state checking.

This is actually something I think LLMs are good for.

-- Steve

Reviewed-by on v1 1/1
#2 lore raw
In reply to Kees Cook
Quoted 27 lines · Kees Cook

Add KUnit tests for the seq_buf API to ensure its correctness and prevent future regressions.

The tests cover the following functions:
- seq_buf_init()
- DECLARE_SEQ_BUF()
- seq_buf_clear()
- seq_buf_puts()
- seq_buf_putc()
- seq_buf_printf()
- seq_buf_get_buf()
- seq_buf_commit()

$ tools/testing/kunit/kunit.py run seq_buf
=================== seq_buf (9 subtests) ===================
[PASSED] seq_buf_init_test
[PASSED] seq_buf_declare_test
[PASSED] seq_buf_clear_test
[PASSED] seq_buf_puts_test
[PASSED] seq_buf_puts_overflow_test
[PASSED] seq_buf_putc_test
[PASSED] seq_buf_printf_test
[PASSED] seq_buf_printf_overflow_test
[PASSED] seq_buf_get_buf_commit_test
===================== [PASSED] seq_buf =====================
Quoted 6 lines

---
I used an LLM to produce this; it did pretty well, but I had to help it get the Kconfig and make targets in the right places, and I tweaked some of the edge cases and added a bit more (perhaps redundant) state checking.

This patch looks good to me. A couple of very minor notes below, but nothing I think is a big issue.

I don't have much to say on the LLM use -- it definitely looks better than the last time I tried it. If something like Sasha's suggestion for how to tag LLM contributions[1] goes through, I do think noting what was used could be a useful thing to have.

-- David

[1] https://lore.kernel.org/all/[email protected]/

Quoted 22 lines
Cc David Gow <[email protected]>
Cc Rae Moar <[email protected]>
Cc Tamir Duberstein <[email protected]>
Cc Eric Biggers <[email protected]>
Cc "Steven Rostedt (Google)" <[email protected]>
Cc Andy Shevchenko <[email protected]>
Cc Petr Mladek <[email protected]>
Cc "Matthew Wilcox (Oracle)" <[email protected]>
---
 lib/Kconfig.debug         |   9 ++
 lib/tests/Makefile        |   1 +
 lib/tests/seq_buf_kunit.c | 205 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 215 insertions(+)
 create mode 100644 lib/tests/seq_buf_kunit.c
lib/Kconfig.debug +0 -0
index cf05bf1df983..048efc3183d5 100644
@@ -2470,6 +2470,15 @@ config SCANF_KUNIT_TEST
 
          If unsure, say N.

lib/Kconfig.debug config SCANF_KUNIT_TEST · line 2481

Quoted 10 lines
lib/Kconfig.debug +9 -0
 
+config SEQ_BUF_KUNIT_TEST
+       tristate "KUnit test for seq_buf" if !KUNIT_ALL_TESTS
+       depends on KUNIT
+       default KUNIT_ALL_TESTS
+       help
+         This builds unit tests for the seq_buf library.
+
+         If unsure, say N.
+

FYI: Checkpatch complains a bit that this is too short a description. It doesn't bother me much, though:
WARNING: please write a help paragraph that fully describes the config symbol with at least 4 lines

Quoted 55 lines
lib/Kconfig.debug +0 -0
 config STRING_KUNIT_TEST
        tristate "KUnit test string functions at runtime" if !KUNIT_ALL_TESTS
        depends on KUNIT
lib/tests/Makefile +1 -0
index 84b15c986b8c..fa6d728a8b5b 100644
@@ -36,6 +36,7 @@ obj-$(CONFIG_OVERFLOW_KUNIT_TEST) += overflow_kunit.o
 obj-$(CONFIG_PRINTF_KUNIT_TEST) += printf_kunit.o
 obj-$(CONFIG_RANDSTRUCT_KUNIT_TEST) += randstruct_kunit.o
 obj-$(CONFIG_SCANF_KUNIT_TEST) += scanf_kunit.o
+obj-$(CONFIG_SEQ_BUF_KUNIT_TEST) += seq_buf_kunit.o
 obj-$(CONFIG_SIPHASH_KUNIT_TEST) += siphash_kunit.o
 obj-$(CONFIG_SLUB_KUNIT_TEST) += slub_kunit.o
 obj-$(CONFIG_TEST_SORT) += test_sort.o
lib/tests/seq_buf_kunit.c new file +34 -0
new file mode 100644
index 000000000000..74648dbda13f
@@ -0,0 +1,205 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * KUnit tests for the seq_buf API
+ *
+ * Copyright (C) 2025, Google LLC.
+ */
+
+#include <kunit/test.h>
+#include <linux/seq_buf.h>
+
+static void seq_buf_init_test(struct kunit *test)
+{
+       char buf[32];
+       struct seq_buf s;
+
+       seq_buf_init(&s, buf, sizeof(buf));
+
+       KUNIT_EXPECT_EQ(test, s.size, 32);
+       KUNIT_EXPECT_EQ(test, s.len, 0);
+       KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_EQ(test, seq_buf_buffer_left(&s), 32);
+       KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 0);
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "");
+}
+
+static void seq_buf_declare_test(struct kunit *test)
+{
+       DECLARE_SEQ_BUF(s, 24);
+
+       KUNIT_EXPECT_EQ(test, s.size, 24);
+       KUNIT_EXPECT_EQ(test, s.len, 0);
+       KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_EQ(test, seq_buf_buffer_left(&s), 24);
+       KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 0);

lib/tests/seq_buf_kunit.c line 44

Quoted 10 lines
lib/tests/seq_buf_kunit.c new file +10 -0
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "");
+}
+
+static void seq_buf_clear_test(struct kunit *test)
+{
+       DECLARE_SEQ_BUF(s, 128);
+
+       seq_buf_puts(&s, "hello");
+       KUNIT_EXPECT_EQ(test, s.len, 5);
+       KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));

My gut feeling seeing this was that we should test that seq_buf_clear() also clears the overflow flag, though the separate overflow tests below all do seem to test that, so it's probably redundant.

Quoted 164 lines
lib/tests/seq_buf_kunit.c new file +161 -1
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "hello");
+
+       seq_buf_clear(&s);
+
+       KUNIT_EXPECT_EQ(test, s.len, 0);
+       KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "");
+}
+
+static void seq_buf_puts_test(struct kunit *test)
+{
+       DECLARE_SEQ_BUF(s, 16);
+
+       seq_buf_puts(&s, "hello");
+       KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 5);
+       KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "hello");
+
+       seq_buf_puts(&s, " world");
+       KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 11);
+       KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "hello world");
+}
+
+static void seq_buf_puts_overflow_test(struct kunit *test)
+{
+       DECLARE_SEQ_BUF(s, 10);
+
+       seq_buf_puts(&s, "123456789");
+       KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 9);
+
+       seq_buf_puts(&s, "0");
+       KUNIT_EXPECT_TRUE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 10);
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "123456789");
+
+       seq_buf_clear(&s);
+       KUNIT_EXPECT_EQ(test, s.len, 0);
+       KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "");
+}
+
+static void seq_buf_putc_test(struct kunit *test)
+{
+       DECLARE_SEQ_BUF(s, 4);
+
+       seq_buf_putc(&s, 'a');
+       seq_buf_putc(&s, 'b');
+       seq_buf_putc(&s, 'c');
+
+       KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 3);
+       KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "abc");
+
+       seq_buf_putc(&s, 'd');
+       KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 4);
+       KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "abc");
+
+       seq_buf_putc(&s, 'e');
+       KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 4);
+       KUNIT_EXPECT_TRUE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "abc");
+
+       seq_buf_clear(&s);
+       KUNIT_EXPECT_EQ(test, s.len, 0);
+       KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "");
+}
+
+static void seq_buf_printf_test(struct kunit *test)
+{
+       DECLARE_SEQ_BUF(s, 32);
+
+       seq_buf_printf(&s, "hello %s", "world");
+       KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 11);
+       KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "hello world");
+
+       seq_buf_printf(&s, " %d", 123);
+       KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 15);
+       KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "hello world 123");
+}
+
+static void seq_buf_printf_overflow_test(struct kunit *test)
+{
+       DECLARE_SEQ_BUF(s, 16);
+
+       seq_buf_printf(&s, "%lu", 1234567890UL);
+       KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 10);
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "1234567890");
+
+       seq_buf_printf(&s, "%s", "abcdefghij");
+       KUNIT_EXPECT_TRUE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 16);
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "1234567890abcde");
+
+       seq_buf_clear(&s);
+       KUNIT_EXPECT_EQ(test, s.len, 0);
+       KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "");
+}
+
+static void seq_buf_get_buf_commit_test(struct kunit *test)
+{
+       DECLARE_SEQ_BUF(s, 16);
+       char *buf;
+       size_t len;
+
+       len = seq_buf_get_buf(&s, &buf);
+       KUNIT_EXPECT_EQ(test, len, 16);
+       KUNIT_EXPECT_PTR_NE(test, buf, NULL);
+
+       memcpy(buf, "hello", 5);
+       seq_buf_commit(&s, 5);
+
+       KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 5);
+       KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "hello");
+
+       len = seq_buf_get_buf(&s, &buf);
+       KUNIT_EXPECT_EQ(test, len, 11);
+       KUNIT_EXPECT_PTR_NE(test, buf, NULL);
+
+       memcpy(buf, " worlds!", 8);
+       seq_buf_commit(&s, 6);
+
+       KUNIT_EXPECT_EQ(test, seq_buf_used(&s), 11);
+       KUNIT_EXPECT_FALSE(test, seq_buf_has_overflowed(&s));
+       KUNIT_EXPECT_STREQ(test, seq_buf_str(&s), "hello world");
+
+       len = seq_buf_get_buf(&s, &buf);
+       KUNIT_EXPECT_EQ(test, len, 5);
+       KUNIT_EXPECT_PTR_NE(test, buf, NULL);
+
+       seq_buf_commit(&s, -1);
+       KUNIT_EXPECT_TRUE(test, seq_buf_has_overflowed(&s));
+}
+
+static struct kunit_case seq_buf_test_cases[] = {
+       KUNIT_CASE(seq_buf_init_test),
+       KUNIT_CASE(seq_buf_declare_test),
+       KUNIT_CASE(seq_buf_clear_test),
+       KUNIT_CASE(seq_buf_puts_test),
+       KUNIT_CASE(seq_buf_puts_overflow_test),
+       KUNIT_CASE(seq_buf_putc_test),
+       KUNIT_CASE(seq_buf_printf_test),
+       KUNIT_CASE(seq_buf_printf_overflow_test),
+       KUNIT_CASE(seq_buf_get_buf_commit_test),
+       {}
+};
+
+static struct kunit_suite seq_buf_test_suite = {
+       .name = "seq_buf",
+       .test_cases = seq_buf_test_cases,
+};
+
+kunit_test_suite(seq_buf_test_suite);
--

2.34.1