* [PATCH v2 2/2] lib/tests: add KUnit test for parser number helpers
2026-09-26 1:27 [PATCH v2 1/2] lib: parser: reject out-of-range values in match_number() Shashank Mohan Jain
@ 2026-09-26 1:27 ` Shashank Mohan Jain
0 siblings, 0 replies; 2+ messages in thread
From: Shashank Mohan Jain @ 2026-09-26 1:27 UTC (permalink / raw)
To: Andrew Morton; +Cc: Alex Elder, David Gow, linux-kernel
Add a small KUnit suite for match_int(), match_octal() and match_hex(),
covering values at and just beyond the int range, values that overflow
64 bits, and a match_token() round trip with an out-of-range argument.
Assisted-by: LLM
Signed-off-by: Shashank Mohan Jain <jain.sm@gmail.com>
---
lib/Kconfig.debug | 12 ++++
lib/tests/Makefile | 1 +
lib/tests/parser_kunit.c | 131 +++++++++++++++++++++++++++++++++++++++
3 files changed, 144 insertions(+)
create mode 100644 lib/tests/parser_kunit.c
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 134b15a44625..905ccec61868 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -2918,6 +2918,18 @@ config CMDLINE_KUNIT_TEST
If unsure, say N.
+config PARSER_KUNIT_TEST
+ tristate "KUnit test for parser number helpers" if !KUNIT_ALL_TESTS
+ depends on KUNIT
+ default KUNIT_ALL_TESTS
+ help
+ This builds the unit test for the number parsing helpers in
+ lib/parser.c (match_int(), match_octal(), match_hex()).
+ For more information on KUnit and unit tests in general please refer
+ to the KUnit documentation in Documentation/dev-tools/kunit/.
+
+ If unsure, say N.
+
config BASE64_KUNIT
tristate "KUnit test for base64 decoding and encoding" if !KUNIT_ALL_TESTS
depends on KUNIT
diff --git a/lib/tests/Makefile b/lib/tests/Makefile
index 3cac3b63a752..cbabf4939ce8 100644
--- a/lib/tests/Makefile
+++ b/lib/tests/Makefile
@@ -41,6 +41,7 @@ obj-$(CONFIG_MEMCPY_KUNIT_TEST) += memcpy_kunit.o
obj-$(CONFIG_MIN_HEAP_KUNIT_TEST) += min_heap_kunit.o
CFLAGS_overflow_kunit.o = $(call cc-disable-warning, tautological-constant-out-of-range-compare)
obj-$(CONFIG_OVERFLOW_KUNIT_TEST) += overflow_kunit.o
+obj-$(CONFIG_PARSER_KUNIT_TEST) += parser_kunit.o
obj-$(CONFIG_PRANDOM_KUNIT_TEST) += random32_kunit.o
obj-$(CONFIG_PRINTF_KUNIT_TEST) += printf_kunit.o
obj-$(CONFIG_RANDSTRUCT_KUNIT_TEST) += randstruct_kunit.o
diff --git a/lib/tests/parser_kunit.c b/lib/tests/parser_kunit.c
new file mode 100644
index 000000000000..b92476cf711f
--- /dev/null
+++ b/lib/tests/parser_kunit.c
@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * KUnit tests for the number helpers in lib/parser.c
+ */
+
+#include <kunit/test.h>
+#include <linux/limits.h>
+#include <linux/parser.h>
+#include <linux/string.h>
+
+struct parser_number_case {
+ const char *in;
+ int ret;
+ int val;
+};
+
+typedef int (*match_fn_t)(substring_t *s, int *result);
+
+static void parser_check(struct kunit *test, match_fn_t fn, const char *name,
+ const struct parser_number_case *c, size_t n)
+{
+ size_t i;
+
+ for (i = 0; i < n; i++) {
+ char buf[64];
+ substring_t s;
+ int val = 0x5a5a5a5a;
+ int ret;
+
+ strscpy(buf, c[i].in, sizeof(buf));
+ s.from = buf;
+ s.to = buf + strlen(buf);
+
+ ret = fn(&s, &val);
+ KUNIT_EXPECT_EQ_MSG(test, ret, c[i].ret, "%s(\"%s\")",
+ name, c[i].in);
+ if (!c[i].ret)
+ KUNIT_EXPECT_EQ_MSG(test, val, c[i].val, "%s(\"%s\")",
+ name, c[i].in);
+ }
+}
+
+static const struct parser_number_case match_int_cases[] = {
+ { "0", 0, 0 },
+ { "42", 0, 42 },
+ { "-42", 0, -42 },
+ { "0x10", 0, 16 },
+ { "010", 0, 8 },
+ { "2147483647", 0, INT_MAX },
+ { "-2147483648", 0, INT_MIN },
+ { "2147483648", -ERANGE, 0 },
+ { "-2147483649", -ERANGE, 0 },
+ { "4294967295", -ERANGE, 0 },
+ { "9223372036854775808", -ERANGE, 0 },
+ { "18446744073709551615", -ERANGE, 0 },
+ { "-18446744073709551615", -ERANGE, 0 },
+ { "99999999999999999999", -ERANGE, 0 },
+ { "0xffffffffffffffff", -ERANGE, 0 },
+ { "abc", -EINVAL, 0 },
+};
+
+static const struct parser_number_case match_octal_cases[] = {
+ { "755", 0, 0755 },
+ { "17777777777", 0, INT_MAX },
+ { "20000000000", -ERANGE, 0 },
+ { "1777777777777777777777", -ERANGE, 0 },
+ { "8", -EINVAL, 0 },
+};
+
+static const struct parser_number_case match_hex_cases[] = {
+ { "ff", 0, 0xff },
+ { "7fffffff", 0, INT_MAX },
+ { "80000000", -ERANGE, 0 },
+ { "ffffffffffffffff", -ERANGE, 0 },
+ { "10000000000000000", -ERANGE, 0 },
+ { "g", -EINVAL, 0 },
+};
+
+static void parser_test_match_int(struct kunit *test)
+{
+ parser_check(test, match_int, "match_int", match_int_cases,
+ ARRAY_SIZE(match_int_cases));
+}
+
+static void parser_test_match_octal(struct kunit *test)
+{
+ parser_check(test, match_octal, "match_octal", match_octal_cases,
+ ARRAY_SIZE(match_octal_cases));
+}
+
+static void parser_test_match_hex(struct kunit *test)
+{
+ parser_check(test, match_hex, "match_hex", match_hex_cases,
+ ARRAY_SIZE(match_hex_cases));
+}
+
+enum { PARSER_TEST_OPT_SIZE, PARSER_TEST_OPT_ERR };
+
+static const match_table_t parser_test_tokens = {
+ { PARSER_TEST_OPT_SIZE, "size=%d" },
+ { PARSER_TEST_OPT_ERR, NULL },
+};
+
+static void parser_test_match_token_int(struct kunit *test)
+{
+ char opt[] = "size=18446744073709551615";
+ substring_t args[MAX_OPT_ARGS];
+ int val = 0;
+
+ KUNIT_ASSERT_EQ(test, match_token(opt, parser_test_tokens, args),
+ PARSER_TEST_OPT_SIZE);
+ KUNIT_EXPECT_EQ(test, match_int(&args[0], &val), -ERANGE);
+}
+
+static struct kunit_case parser_test_cases[] = {
+ KUNIT_CASE(parser_test_match_int),
+ KUNIT_CASE(parser_test_match_octal),
+ KUNIT_CASE(parser_test_match_hex),
+ KUNIT_CASE(parser_test_match_token_int),
+ {}
+};
+
+static struct kunit_suite parser_test_suite = {
+ .name = "parser",
+ .test_cases = parser_test_cases,
+};
+
+kunit_test_suite(parser_test_suite);
+
+MODULE_DESCRIPTION("KUnit tests for lib/parser.c number helpers");
+MODULE_LICENSE("GPL");
--
2.43.0
^ permalink raw reply [flat|nested] 2+ messages in thread