Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925// SPDX-License-Identifier: GPL-2.0-only/* * Test cases for string functions. */
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <kunit/test.h>#include <linux/ktime.h>#include <linux/math64.h>#include <linux/minmax.h>#include <linux/mm.h>#include <linux/module.h>#include <linux/prandom.h>#include <linux/printk.h>#include <linux/slab.h>#include <linux/string.h>#include <linux/time64.h>#include <linux/units.h>#include <linux/vmalloc.h>
#define STRCMP_LARGE_BUF_LEN 2048#define STRCMP_CHANGE_POINT 1337#define STRCMP_TEST_EXPECT_EQUAL(test, fn, ...) KUNIT_EXPECT_EQ(test, fn(__VA_ARGS__), 0)#define STRCMP_TEST_EXPECT_LOWER(test, fn, ...) KUNIT_EXPECT_LT(test, fn(__VA_ARGS__), 0)#define STRCMP_TEST_EXPECT_GREATER(test, fn, ...) KUNIT_EXPECT_GT(test, fn(__VA_ARGS__), 0)
#define STRING_TEST_MAX_LEN 128#define STRING_TEST_MAX_OFFSET 16
#define STRING_BENCH_SEED 888#define STRING_BENCH_WORKLOAD (1 * MEGA)
static void string_test_memset16(struct kunit *test){ unsigned i, j, k; u16 v, *p;
p = kunit_kzalloc(test, 256 * 2 * 2, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, p);
for (i = 0; i < 256; i++) { for (j = 0; j < 256; j++) { memset(p, 0xa1, 256 * 2 * sizeof(v)); memset16(p + i, 0xb1b2, j); for (k = 0; k < 512; k++) { v = p[k]; if (k < i) { KUNIT_ASSERT_EQ_MSG(test, v, 0xa1a1, "i:%d j:%d k:%d", i, j, k); } else if (k < i + j) { KUNIT_ASSERT_EQ_MSG(test, v, 0xb1b2, "i:%d j:%d k:%d", i, j, k); } else { KUNIT_ASSERT_EQ_MSG(test, v, 0xa1a1, "i:%d j:%d k:%d", i, j, k); } } } }}
static void string_test_memset32(struct kunit *test){ unsigned i, j, k; u32 v, *p;
p = kunit_kzalloc(test, 256 * 2 * 4, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, p);
for (i = 0; i < 256; i++) { for (j = 0; j < 256; j++) { memset(p, 0xa1, 256 * 2 * sizeof(v)); memset32(p + i, 0xb1b2b3b4, j); for (k = 0; k < 512; k++) { v = p[k]; if (k < i) { KUNIT_ASSERT_EQ_MSG(test, v, 0xa1a1a1a1, "i:%d j:%d k:%d", i, j, k); } else if (k < i + j) { KUNIT_ASSERT_EQ_MSG(test, v, 0xb1b2b3b4, "i:%d j:%d k:%d", i, j, k); } else { KUNIT_ASSERT_EQ_MSG(test, v, 0xa1a1a1a1, "i:%d j:%d k:%d", i, j, k); } } } }}
static void string_test_memset64(struct kunit *test){ unsigned i, j, k; u64 v, *p;
p = kunit_kzalloc(test, 256 * 2 * 8, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, p);
for (i = 0; i < 256; i++) { for (j = 0; j < 256; j++) { memset(p, 0xa1, 256 * 2 * sizeof(v)); memset64(p + i, 0xb1b2b3b4b5b6b7b8ULL, j); for (k = 0; k < 512; k++) { v = p[k]; if (k < i) { KUNIT_ASSERT_EQ_MSG(test, v, 0xa1a1a1a1a1a1a1a1ULL, "i:%d j:%d k:%d", i, j, k); } else if (k < i + j) { KUNIT_ASSERT_EQ_MSG(test, v, 0xb1b2b3b4b5b6b7b8ULL, "i:%d j:%d k:%d", i, j, k); } else { KUNIT_ASSERT_EQ_MSG(test, v, 0xa1a1a1a1a1a1a1a1ULL, "i:%d j:%d k:%d", i, j, k); } } } }}
static void string_test_strlen(struct kunit *test){ size_t buf_size; char *buf, *s;
buf_size = PAGE_ALIGN(STRING_TEST_MAX_LEN + STRING_TEST_MAX_OFFSET + 1); buf = vmalloc(buf_size); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
memset(buf, 'A', buf_size);
for (size_t offset = 0; offset < STRING_TEST_MAX_OFFSET; offset++) { for (size_t len = 0; len <= STRING_TEST_MAX_LEN; len++) { s = buf + buf_size - 1 - offset - len; s[len] = '\0'; KUNIT_EXPECT_EQ_MSG(test, strlen(s), len, "offset:%zu len:%zu", offset, len); s[len] = 'A'; } }
vfree(buf);}
static void string_test_strnlen(struct kunit *test){ size_t buf_size; char *buf, *s;
buf_size = PAGE_ALIGN(STRING_TEST_MAX_LEN + STRING_TEST_MAX_OFFSET + 1); buf = vmalloc(buf_size); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
memset(buf, 'A', buf_size);
for (size_t offset = 0; offset < STRING_TEST_MAX_OFFSET; offset++) { for (size_t len = 0; len <= STRING_TEST_MAX_LEN; len++) { s = buf + buf_size - 1 - offset - len; s[len] = '\0';
if (len > 0) KUNIT_EXPECT_EQ(test, strnlen(s, len - 1), len - 1); if (len > 1) KUNIT_EXPECT_EQ(test, strnlen(s, len - 2), len - 2);
KUNIT_EXPECT_EQ(test, strnlen(s, len), len);
KUNIT_EXPECT_EQ(test, strnlen(s, len + 1), len); KUNIT_EXPECT_EQ(test, strnlen(s, len + 2), len); KUNIT_EXPECT_EQ(test, strnlen(s, len + 10), len);
s[len] = 'A'; } }
vfree(buf);}
static void string_test_strchr(struct kunit *test){ const char *test_string = "abcdefghijkl"; const char *empty_string = ""; char *result; int i;
for (i = 0; i < strlen(test_string) + 1; i++) { result = strchr(test_string, test_string[i]); KUNIT_ASSERT_EQ_MSG(test, result - test_string, i, "char:%c", 'a' + i); }
result = strchr(empty_string, '\0'); KUNIT_ASSERT_PTR_EQ(test, result, empty_string);
result = strchr(empty_string, 'a'); KUNIT_ASSERT_NULL(test, result);
result = strchr(test_string, 'z'); KUNIT_ASSERT_NULL(test, result);}
static void string_test_strrchr(struct kunit *test){ size_t buf_size; char *buf, *s;
buf_size = PAGE_ALIGN(STRING_TEST_MAX_LEN + STRING_TEST_MAX_OFFSET + 1); buf = vmalloc(buf_size); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf);
memset(buf, 'A', buf_size);
for (size_t offset = 0; offset < STRING_TEST_MAX_OFFSET; offset++) { for (size_t len = 0; len <= STRING_TEST_MAX_LEN; len++) { s = buf + buf_size - 1 - offset - len; s[len] = '\0';
KUNIT_EXPECT_PTR_EQ(test, strrchr(s, 'Z'), NULL);
if (len > 0) KUNIT_EXPECT_PTR_EQ(test, strrchr(s, 'A'), s + len - 1); else KUNIT_EXPECT_PTR_EQ(test, strrchr(s, 'A'), NULL);
s[len] = 'A'; } }
vfree(buf);}
static void string_test_strnchr(struct kunit *test){ const char *test_string = "abcdefghijkl"; const char *empty_string = ""; char *result; int i, j;
for (i = 0; i < strlen(test_string) + 1; i++) { for (j = 0; j < strlen(test_string) + 2; j++) { result = strnchr(test_string, j, test_string[i]); if (j <= i) { KUNIT_ASSERT_NULL_MSG(test, result, "char:%c i:%d j:%d", 'a' + i, i, j); } else { KUNIT_ASSERT_EQ_MSG(test, result - test_string, i, "char:%c i:%d j:%d", 'a' + i, i, j); } } }
result = strnchr(empty_string, 0, '\0'); KUNIT_ASSERT_NULL(test, result);
result = strnchr(empty_string, 1, '\0'); KUNIT_ASSERT_PTR_EQ(test, result, empty_string);
result = strnchr(empty_string, 1, 'a'); KUNIT_ASSERT_NULL(test, result);
result = strnchr(NULL, 0, '\0'); KUNIT_ASSERT_NULL(test, result);}
static void string_test_strspn(struct kunit *test){ static const struct strspn_test { const char str[16]; const char accept[16]; const char reject[16]; unsigned a; unsigned r; } tests[] = { { "foobar", "", "", 0, 6 }, { "abba", "abc", "ABBA", 4, 4 }, { "abba", "a", "b", 1, 1 }, { "", "abc", "abc", 0, 0}, }; const struct strspn_test *s = tests; size_t i;
for (i = 0; i < ARRAY_SIZE(tests); ++i, ++s) { KUNIT_ASSERT_EQ_MSG(test, s->a, strspn(s->str, s->accept), "i:%zu", i); KUNIT_ASSERT_EQ_MSG(test, s->r, strcspn(s->str, s->reject), "i:%zu", i); }}
static char strcmp_buffer1[STRCMP_LARGE_BUF_LEN];static char strcmp_buffer2[STRCMP_LARGE_BUF_LEN];
static void strcmp_fill_buffers(char fill1, char fill2){ memset(strcmp_buffer1, fill1, STRCMP_LARGE_BUF_LEN); memset(strcmp_buffer2, fill2, STRCMP_LARGE_BUF_LEN); strcmp_buffer1[STRCMP_LARGE_BUF_LEN - 1] = 0; strcmp_buffer2[STRCMP_LARGE_BUF_LEN - 1] = 0;}
static void string_test_strcmp(struct kunit *test){ /* Equal strings */ STRCMP_TEST_EXPECT_EQUAL(test, strcmp, "Hello, Kernel!", "Hello, Kernel!"); /* First string is lexicographically less than the second */ STRCMP_TEST_EXPECT_LOWER(test, strcmp, "Hello, KUnit!", "Hello, Kernel!"); /* First string is lexicographically larger than the second */ STRCMP_TEST_EXPECT_GREATER(test, strcmp, "Hello, Kernel!", "Hello, KUnit!"); /* Empty string is always lexicographically less than any non-empty string */ STRCMP_TEST_EXPECT_LOWER(test, strcmp, "", "Non-empty string"); /* Two empty strings should be equal */ STRCMP_TEST_EXPECT_EQUAL(test, strcmp, "", ""); /* Compare two strings which have only one char difference */ STRCMP_TEST_EXPECT_LOWER(test, strcmp, "Abacaba", "Abadaba"); /* Compare two strings which have the same prefix*/ STRCMP_TEST_EXPECT_LOWER(test, strcmp, "Just a string", "Just a string and something else");}
static void string_test_strcmp_long_strings(struct kunit *test){ strcmp_fill_buffers('B', 'B'); STRCMP_TEST_EXPECT_EQUAL(test, strcmp, strcmp_buffer1, strcmp_buffer2);
strcmp_buffer1[STRCMP_CHANGE_POINT] = 'A'; STRCMP_TEST_EXPECT_LOWER(test, strcmp, strcmp_buffer1, strcmp_buffer2);
strcmp_buffer1[STRCMP_CHANGE_POINT] = 'C'; STRCMP_TEST_EXPECT_GREATER(test, strcmp, strcmp_buffer1, strcmp_buffer2);}
static void string_test_strncmp(struct kunit *test){ /* Equal strings */ STRCMP_TEST_EXPECT_EQUAL(test, strncmp, "Hello, KUnit!", "Hello, KUnit!", 13); /* First string is lexicographically less than the second */ STRCMP_TEST_EXPECT_LOWER(test, strncmp, "Hello, KUnit!", "Hello, Kernel!", 13); /* Result is always 'equal' when count = 0 */ STRCMP_TEST_EXPECT_EQUAL(test, strncmp, "Hello, Kernel!", "Hello, KUnit!", 0); /* Strings with common prefix are equal if count = length of prefix */ STRCMP_TEST_EXPECT_EQUAL(test, strncmp, "Abacaba", "Abadaba", 3); /* Strings with common prefix are not equal when count = length of prefix + 1 */ STRCMP_TEST_EXPECT_LOWER(test, strncmp, "Abacaba", "Abadaba", 4); /* If one string is a prefix of another, the shorter string is lexicographically smaller */ STRCMP_TEST_EXPECT_LOWER(test, strncmp, "Just a string", "Just a string and something else", strlen("Just a string and something else")); /* * If one string is a prefix of another, and we check first length * of prefix chars, the result is 'equal' */ STRCMP_TEST_EXPECT_EQUAL(test, strncmp, "Just a string", "Just a string and something else", strlen("Just a string"));}
static void string_test_strncmp_long_strings(struct kunit *test){ strcmp_fill_buffers('B', 'B'); STRCMP_TEST_EXPECT_EQUAL(test, strncmp, strcmp_buffer1, strcmp_buffer2, STRCMP_LARGE_BUF_LEN);
strcmp_buffer1[STRCMP_CHANGE_POINT] = 'A'; STRCMP_TEST_EXPECT_LOWER(test, strncmp, strcmp_buffer1, strcmp_buffer2, STRCMP_LARGE_BUF_LEN);
strcmp_buffer1[STRCMP_CHANGE_POINT] = 'C'; STRCMP_TEST_EXPECT_GREATER(test, strncmp, strcmp_buffer1, strcmp_buffer2, STRCMP_LARGE_BUF_LEN); /* the strings are equal up to STRCMP_CHANGE_POINT */ STRCMP_TEST_EXPECT_EQUAL(test, strncmp, strcmp_buffer1, strcmp_buffer2, STRCMP_CHANGE_POINT); STRCMP_TEST_EXPECT_GREATER(test, strncmp, strcmp_buffer1, strcmp_buffer2, STRCMP_CHANGE_POINT + 1);}
static void string_test_strcasecmp(struct kunit *test){ /* Same strings in different case should be equal */ STRCMP_TEST_EXPECT_EQUAL(test, strcasecmp, "Hello, Kernel!", "HeLLO, KErNeL!"); /* Empty strings should be equal */ STRCMP_TEST_EXPECT_EQUAL(test, strcasecmp, "", ""); /* Despite ascii code for 'a' is larger than ascii code for 'B', 'a' < 'B' */ STRCMP_TEST_EXPECT_LOWER(test, strcasecmp, "a", "B"); STRCMP_TEST_EXPECT_GREATER(test, strcasecmp, "B", "a"); /* Special symbols and numbers should be processed correctly */ STRCMP_TEST_EXPECT_EQUAL(test, strcasecmp, "-+**.1230ghTTT~^", "-+**.1230Ghttt~^");}
static void string_test_strcasecmp_long_strings(struct kunit *test){ strcmp_fill_buffers('b', 'B'); STRCMP_TEST_EXPECT_EQUAL(test, strcasecmp, strcmp_buffer1, strcmp_buffer2);
strcmp_buffer1[STRCMP_CHANGE_POINT] = 'a'; STRCMP_TEST_EXPECT_LOWER(test, strcasecmp, strcmp_buffer1, strcmp_buffer2);
strcmp_buffer1[STRCMP_CHANGE_POINT] = 'C'; STRCMP_TEST_EXPECT_GREATER(test, strcasecmp, strcmp_buffer1, strcmp_buffer2);}
static void string_test_strncasecmp(struct kunit *test){ /* Same strings in different case should be equal */ STRCMP_TEST_EXPECT_EQUAL(test, strncasecmp, "AbAcAbA", "Abacaba", strlen("Abacaba")); /* strncasecmp should check 'count' chars only */ STRCMP_TEST_EXPECT_EQUAL(test, strncasecmp, "AbaCaBa", "abaCaDa", 5); STRCMP_TEST_EXPECT_LOWER(test, strncasecmp, "a", "B", 1); STRCMP_TEST_EXPECT_GREATER(test, strncasecmp, "B", "a", 1); /* Result is always 'equal' when count = 0 */ STRCMP_TEST_EXPECT_EQUAL(test, strncasecmp, "Abacaba", "Not abacaba", 0);}
static void string_test_strncasecmp_long_strings(struct kunit *test){ strcmp_fill_buffers('b', 'B'); STRCMP_TEST_EXPECT_EQUAL(test, strncasecmp, strcmp_buffer1, strcmp_buffer2, STRCMP_LARGE_BUF_LEN);
strcmp_buffer1[STRCMP_CHANGE_POINT] = 'a'; STRCMP_TEST_EXPECT_LOWER(test, strncasecmp, strcmp_buffer1, strcmp_buffer2, STRCMP_LARGE_BUF_LEN);
strcmp_buffer1[STRCMP_CHANGE_POINT] = 'C'; STRCMP_TEST_EXPECT_GREATER(test, strncasecmp, strcmp_buffer1, strcmp_buffer2, STRCMP_LARGE_BUF_LEN);
STRCMP_TEST_EXPECT_EQUAL(test, strncasecmp, strcmp_buffer1, strcmp_buffer2, STRCMP_CHANGE_POINT); STRCMP_TEST_EXPECT_GREATER(test, strncasecmp, strcmp_buffer1, strcmp_buffer2, STRCMP_CHANGE_POINT + 1);}
/** * strscpy_check() - Run a specific test case. * @test: KUnit test context pointer * @src: Source string, argument to strscpy_pad() * @count: Size of destination buffer, argument to strscpy_pad() * @expected: Expected return value from call to strscpy_pad() * @chars: Number of characters from the src string expected to be * written to the dst buffer. * @terminator: 1 if there should be a terminating null byte 0 otherwise. * @pad: Number of pad characters expected (in the tail of dst buffer). * (@pad does not include the null terminator byte.) * * Calls strscpy_pad() and verifies the return value and state of the * destination buffer after the call returns. */static void strscpy_check(struct kunit *test, char *src, int count, int expected, int chars, int terminator, int pad){ int nr_bytes_poison; int max_expected; int max_count; int written; char buf[6]; int index, i; const char POISON = 'z';
KUNIT_ASSERT_TRUE_MSG(test, src != NULL, "null source string not supported");
memset(buf, POISON, sizeof(buf)); /* Future proofing test suite, validate args */ max_count = sizeof(buf) - 2; /* Space for null and to verify overflow */ max_expected = count - 1; /* Space for the null */
KUNIT_ASSERT_LE_MSG(test, count, max_count, "count (%d) is too big (%d) ... aborting", count, max_count); KUNIT_EXPECT_LE_MSG(test, expected, max_expected, "expected (%d) is bigger than can possibly be returned (%d)", expected, max_expected);
written = strscpy_pad(buf, src, count); KUNIT_ASSERT_EQ(test, written, expected);
if (count && written == -E2BIG) { KUNIT_ASSERT_EQ_MSG(test, 0, strncmp(buf, src, count - 1), "buffer state invalid for -E2BIG"); KUNIT_ASSERT_EQ_MSG(test, buf[count - 1], '\0', "too big string is not null terminated correctly"); }
for (i = 0; i < chars; i++) KUNIT_ASSERT_EQ_MSG(test, buf[i], src[i], "buf[i]==%c != src[i]==%c", buf[i], src[i]);
if (terminator) KUNIT_ASSERT_EQ_MSG(test, buf[count - 1], '\0', "string is not null terminated correctly");
for (i = 0; i < pad; i++) { index = chars + terminator + i; KUNIT_ASSERT_EQ_MSG(test, buf[index], '\0', "padding missing at index: %d", i); }
nr_bytes_poison = sizeof(buf) - chars - terminator - pad; for (i = 0; i < nr_bytes_poison; i++) { index = sizeof(buf) - 1 - i; /* Check from the end back */ KUNIT_ASSERT_EQ_MSG(test, buf[index], POISON, "poison value missing at index: %d", i); }}
static void string_test_strscpy(struct kunit *test){ char dest[8];
/* * strscpy_check() uses a destination buffer of size 6 and needs at * least 2 characters spare (one for null and one to check for * overflow). This means we should only call tc() with * strings up to a maximum of 4 characters long and 'count' * should not exceed 4. To test with longer strings increase * the buffer size in tc(). */
/* strscpy_check(test, src, count, expected, chars, terminator, pad) */ strscpy_check(test, "a", 0, -E2BIG, 0, 0, 0); strscpy_check(test, "", 0, -E2BIG, 0, 0, 0);
strscpy_check(test, "a", 1, -E2BIG, 0, 1, 0); strscpy_check(test, "", 1, 0, 0, 1, 0);
strscpy_check(test, "ab", 2, -E2BIG, 1, 1, 0); strscpy_check(test, "a", 2, 1, 1, 1, 0); strscpy_check(test, "", 2, 0, 0, 1, 1);
strscpy_check(test, "abc", 3, -E2BIG, 2, 1, 0); strscpy_check(test, "ab", 3, 2, 2, 1, 0); strscpy_check(test, "a", 3, 1, 1, 1, 1); strscpy_check(test, "", 3, 0, 0, 1, 2);
strscpy_check(test, "abcd", 4, -E2BIG, 3, 1, 0); strscpy_check(test, "abc", 4, 3, 3, 1, 0); strscpy_check(test, "ab", 4, 2, 2, 1, 1); strscpy_check(test, "a", 4, 1, 1, 1, 2); strscpy_check(test, "", 4, 0, 0, 1, 3);
/* Compile-time-known source strings. */ KUNIT_EXPECT_EQ(test, strscpy(dest, "", ARRAY_SIZE(dest)), 0); KUNIT_EXPECT_EQ(test, strscpy(dest, "", 3), 0); KUNIT_EXPECT_EQ(test, strscpy(dest, "", 1), 0); KUNIT_EXPECT_EQ(test, strscpy(dest, "", 0), -E2BIG); KUNIT_EXPECT_EQ(test, strscpy(dest, "Fixed", ARRAY_SIZE(dest)), 5); KUNIT_EXPECT_EQ(test, strscpy(dest, "Fixed", 3), -E2BIG); KUNIT_EXPECT_EQ(test, strscpy(dest, "Fixed", 1), -E2BIG); KUNIT_EXPECT_EQ(test, strscpy(dest, "Fixed", 0), -E2BIG); KUNIT_EXPECT_EQ(test, strscpy(dest, "This is too long", ARRAY_SIZE(dest)), -E2BIG);}
static volatile int unconst;
static void string_test_strcat(struct kunit *test){ char dest[8];
/* Destination is terminated. */ memset(dest, 0, sizeof(dest)); KUNIT_EXPECT_EQ(test, strlen(dest), 0); /* Empty copy does nothing. */ KUNIT_EXPECT_TRUE(test, strcat(dest, "") == dest); KUNIT_EXPECT_STREQ(test, dest, ""); /* 4 characters copied in, stops at %NUL. */ KUNIT_EXPECT_TRUE(test, strcat(dest, "four\000123") == dest); KUNIT_EXPECT_STREQ(test, dest, "four"); KUNIT_EXPECT_EQ(test, dest[5], '\0'); /* 2 more characters copied in okay. */ KUNIT_EXPECT_TRUE(test, strcat(dest, "AB") == dest); KUNIT_EXPECT_STREQ(test, dest, "fourAB");}
static void string_test_strncat(struct kunit *test){ char dest[8];
/* Destination is terminated. */ memset(dest, 0, sizeof(dest)); KUNIT_EXPECT_EQ(test, strlen(dest), 0); /* Empty copy of size 0 does nothing. */ KUNIT_EXPECT_TRUE(test, strncat(dest, "", 0 + unconst) == dest); KUNIT_EXPECT_STREQ(test, dest, ""); /* Empty copy of size 1 does nothing too. */ KUNIT_EXPECT_TRUE(test, strncat(dest, "", 1 + unconst) == dest); KUNIT_EXPECT_STREQ(test, dest, ""); /* Copy of max 0 characters should do nothing. */ KUNIT_EXPECT_TRUE(test, strncat(dest, "asdf", 0 + unconst) == dest); KUNIT_EXPECT_STREQ(test, dest, "");
/* 4 characters copied in, even if max is 8. */ KUNIT_EXPECT_TRUE(test, strncat(dest, "four\000123", 8 + unconst) == dest); KUNIT_EXPECT_STREQ(test, dest, "four"); KUNIT_EXPECT_EQ(test, dest[5], '\0'); KUNIT_EXPECT_EQ(test, dest[6], '\0'); /* 2 characters copied in okay, 2 ignored. */ KUNIT_EXPECT_TRUE(test, strncat(dest, "ABCD", 2 + unconst) == dest); KUNIT_EXPECT_STREQ(test, dest, "fourAB");}
static void string_test_strlcat(struct kunit *test){ char dest[8] = ""; int len = sizeof(dest) + unconst;
/* Destination is terminated. */ KUNIT_EXPECT_EQ(test, strlen(dest), 0); /* Empty copy is size 0. */ KUNIT_EXPECT_EQ(test, strlcat(dest, "", len), 0); KUNIT_EXPECT_STREQ(test, dest, ""); /* Size 1 should keep buffer terminated, report size of source only. */ KUNIT_EXPECT_EQ(test, strlcat(dest, "four", 1 + unconst), 4); KUNIT_EXPECT_STREQ(test, dest, "");
/* 4 characters copied in. */ KUNIT_EXPECT_EQ(test, strlcat(dest, "four", len), 4); KUNIT_EXPECT_STREQ(test, dest, "four"); /* 2 characters copied in okay, gets to 6 total. */ KUNIT_EXPECT_EQ(test, strlcat(dest, "AB", len), 6); KUNIT_EXPECT_STREQ(test, dest, "fourAB"); /* 2 characters ignored if max size (7) reached. */ KUNIT_EXPECT_EQ(test, strlcat(dest, "CD", 7 + unconst), 8); KUNIT_EXPECT_STREQ(test, dest, "fourAB"); /* 1 of 2 characters skipped, now at true max size. */ KUNIT_EXPECT_EQ(test, strlcat(dest, "EFG", len), 9); KUNIT_EXPECT_STREQ(test, dest, "fourABE"); /* Everything else ignored, now at full size. */ KUNIT_EXPECT_EQ(test, strlcat(dest, "1234", len), 11); KUNIT_EXPECT_STREQ(test, dest, "fourABE");}
static void string_test_strtomem(struct kunit *test){ static const char input[sizeof(unsigned long)] = "hi"; static const char truncate[] = "this is too long"; struct { unsigned long canary1; unsigned char output[sizeof(unsigned long)] __nonstring; unsigned long canary2; } wrap;
memset(&wrap, 0xFF, sizeof(wrap)); KUNIT_EXPECT_EQ_MSG(test, wrap.canary1, ULONG_MAX, "bad initial canary value"); KUNIT_EXPECT_EQ_MSG(test, wrap.canary2, ULONG_MAX, "bad initial canary value");
/* Check unpadded copy leaves surroundings untouched. */ strtomem(wrap.output, input); KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX); KUNIT_EXPECT_EQ(test, wrap.output[0], input[0]); KUNIT_EXPECT_EQ(test, wrap.output[1], input[1]); for (size_t i = 2; i < sizeof(wrap.output); i++) KUNIT_EXPECT_EQ(test, wrap.output[i], 0xFF); KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
/* Check truncated copy leaves surroundings untouched. */ memset(&wrap, 0xFF, sizeof(wrap)); strtomem(wrap.output, truncate); KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX); for (size_t i = 0; i < sizeof(wrap.output); i++) KUNIT_EXPECT_EQ(test, wrap.output[i], truncate[i]); KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
/* Check padded copy leaves only string padded. */ memset(&wrap, 0xFF, sizeof(wrap)); strtomem_pad(wrap.output, input, 0xAA); KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX); KUNIT_EXPECT_EQ(test, wrap.output[0], input[0]); KUNIT_EXPECT_EQ(test, wrap.output[1], input[1]); for (size_t i = 2; i < sizeof(wrap.output); i++) KUNIT_EXPECT_EQ(test, wrap.output[i], 0xAA); KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
/* Check truncated padded copy has no padding. */ memset(&wrap, 0xFF, sizeof(wrap)); strtomem(wrap.output, truncate); KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX); for (size_t i = 0; i < sizeof(wrap.output); i++) KUNIT_EXPECT_EQ(test, wrap.output[i], truncate[i]); KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);}
static void string_test_memtostr(struct kunit *test){ char nonstring[7] __nonstring = { 'a', 'b', 'c', 'd', 'e', 'f', 'g' }; char nonstring_small[3] __nonstring = { 'a', 'b', 'c' }; char dest[sizeof(nonstring) + 1];
/* Copy in a non-NUL-terminated string into exactly right-sized dest. */ KUNIT_EXPECT_EQ(test, sizeof(dest), sizeof(nonstring) + 1); memset(dest, 'X', sizeof(dest)); memtostr(dest, nonstring); KUNIT_EXPECT_STREQ(test, dest, "abcdefg"); memset(dest, 'X', sizeof(dest)); memtostr(dest, nonstring_small); KUNIT_EXPECT_STREQ(test, dest, "abc"); KUNIT_EXPECT_EQ(test, dest[7], 'X');
memset(dest, 'X', sizeof(dest)); memtostr_pad(dest, nonstring); KUNIT_EXPECT_STREQ(test, dest, "abcdefg"); memset(dest, 'X', sizeof(dest)); memtostr_pad(dest, nonstring_small); KUNIT_EXPECT_STREQ(test, dest, "abc"); KUNIT_EXPECT_EQ(test, dest[7], '\0');}
static void string_test_strends(struct kunit *test){ KUNIT_EXPECT_TRUE(test, strends("foo-bar", "bar")); KUNIT_EXPECT_TRUE(test, strends("foo-bar", "-bar")); KUNIT_EXPECT_TRUE(test, strends("foobar", "foobar")); KUNIT_EXPECT_TRUE(test, strends("foobar", "")); KUNIT_EXPECT_FALSE(test, strends("bar", "foobar")); KUNIT_EXPECT_FALSE(test, strends("", "foo")); KUNIT_EXPECT_FALSE(test, strends("foobar", "ba")); KUNIT_EXPECT_TRUE(test, strends("", ""));}
#if IS_ENABLED(CONFIG_STRING_KUNIT_BENCH)/* Target string lengths for benchmarking */static const size_t bench_lens[] = { 0, 1, 7, 8, 16, 31, 64, 127, 512, 1024, 3173, 4096,};
/** * alloc_max_bench_buffer() - Allocate buffer for the max test case. * @test: KUnit context for managed allocation. * @lens: Array of lengths used in the benchmark cases. * @count: Number of elements in the @lens array. * @buf_len: [out] Pointer to store the actually allocated buffer * size (including NUL character). * * Return: Pointer to the allocated memory, or NULL on failure. */static void *alloc_max_bench_buffer(struct kunit *test, const size_t *lens, size_t count, size_t *buf_len){ size_t max_len = 0; void *buf;
for (size_t i = 0; i < count; i++) max_len = max(lens[i], max_len);
/* Add space for NUL character */ max_len += 1;
buf = kunit_kzalloc(test, max_len, GFP_KERNEL); if (!buf) return NULL;
if (buf_len) *buf_len = max_len;
return buf;}
/** * fill_random_string() - Populate a buffer with a random NUL-terminated string. * @buf: Buffer to fill. * @len: Length of the buffer in bytes. * * Fills the buffer with random non-NUL bytes and ensures the string is * properly NUL-terminated. */static void fill_random_string(char *buf, size_t len){ struct rnd_state state;
if (!buf || !len) return;
/* Use a fixed seed to ensure deterministic benchmark results */ prandom_seed_state(&state, STRING_BENCH_SEED); prandom_bytes_state(&state, buf, len);
/* Replace NUL characters to avoid early string termination */ for (size_t i = 0; i < len; i++) { if (buf[i] == '\0') buf[i] = 0x01; }
buf[len - 1] = '\0';}
/** * STRING_BENCH() - Benchmark string functions. * @iters: Number of iterations to run. * @func: Function to benchmark. * @...: Variable arguments passed to @func. * * Disables preemption and measures the total time in nanoseconds to execute * @func(@__VA_ARGS__) for @iters times, including a small warm-up phase. * * Context: Disables preemption during measurement. * Return: Total execution time in nanoseconds (u64). */#define STRING_BENCH(iters, func, ...) \({ \ /* Volatile function pointer prevents dead code elimination */ \ typeof(func) (* volatile __func) = (func); \ size_t __bn_iters = (iters); \ size_t __bn_warm_iters; \ u64 __bn_t; \ \ /* Use 10% of the given iterations (maximum 50) to warm up */ \ __bn_warm_iters = max(__bn_iters / 10, 50U); \ \ for (size_t __bn_i = 0; __bn_i < __bn_warm_iters; __bn_i++) \ (void)__func(__VA_ARGS__); \ \ preempt_disable(); \ __bn_t = ktime_get_ns(); \ for (size_t __bn_i = 0; __bn_i < __bn_iters; __bn_i++) \ (void)__func(__VA_ARGS__); \ __bn_t = ktime_get_ns() - __bn_t; \ preempt_enable(); \ __bn_t; \})
/** * STRING_BENCH_BUF() - Benchmark harness for single-buffer functions. * @test: KUnit context. * @buf_name: Local char * variable name to be defined. * @buf_size: Local size_t variable name to be defined. * @func: Function to benchmark. * @...: Extra arguments for @func. * * Prepares a randomized, NUL-terminated buffer and iterates through lengths * in bench_lens, defining @buf_name and @buf_size in each loop. */#define STRING_BENCH_BUF(test, buf_name, buf_size, func, ...) \do { \ size_t _bn_i, _bn_iters, _bn_size = 0; \ u64 _bn_t, _bn_mbps = 0, _bn_lat = 0; \ char *_bn_buf; \ \ _bn_buf = alloc_max_bench_buffer(test, bench_lens, \ ARRAY_SIZE(bench_lens), &_bn_size); \ KUNIT_ASSERT_NOT_ERR_OR_NULL(test, _bn_buf); \ \ fill_random_string(_bn_buf, _bn_size); \ \ for (_bn_i = 0; _bn_i < ARRAY_SIZE(bench_lens); _bn_i++) { \ size_t buf_size = bench_lens[_bn_i]; \ char *buf_name = _bn_buf + _bn_size - buf_size - 1; \ _bn_iters = STRING_BENCH_WORKLOAD / max(buf_size, 1U); \ \ _bn_t = STRING_BENCH(_bn_iters, func, ##__VA_ARGS__); \ if (_bn_t > 0) { \ _bn_mbps = (u64)(buf_size) * _bn_iters * \ (NSEC_PER_SEC / MEGA); \ _bn_mbps = div64_u64(_bn_mbps, _bn_t); \ _bn_lat = div64_u64(_bn_t, _bn_iters); \ } \ kunit_info(test, "len=%zu: %llu MB/s (%llu ns/call)\n", \ buf_size, _bn_mbps, _bn_lat); \ } \} while (0)#else#define STRING_BENCH_BUF(test, buf_name, buf_size, func, ...) \ kunit_skip(test, "not enabled")#endif /* IS_ENABLED(CONFIG_STRING_KUNIT_BENCH) */
static void string_bench_strlen(struct kunit *test){ STRING_BENCH_BUF(test, buf, len, strlen, buf);}
static void string_bench_strnlen(struct kunit *test){ STRING_BENCH_BUF(test, buf, len, strnlen, buf, len);}
static void string_bench_strchr(struct kunit *test){ STRING_BENCH_BUF(test, buf, len, strchr, buf, '\0');}
static void string_bench_strrchr(struct kunit *test){ STRING_BENCH_BUF(test, buf, len, strrchr, buf, '\0');}
static struct kunit_case string_test_cases[] = { KUNIT_CASE(string_test_memset16), KUNIT_CASE(string_test_memset32), KUNIT_CASE(string_test_memset64), KUNIT_CASE(string_test_strlen), KUNIT_CASE(string_test_strnlen), KUNIT_CASE(string_test_strchr), KUNIT_CASE(string_test_strnchr), KUNIT_CASE(string_test_strrchr), KUNIT_CASE(string_test_strspn), KUNIT_CASE(string_test_strcmp), KUNIT_CASE(string_test_strcmp_long_strings), KUNIT_CASE(string_test_strncmp), KUNIT_CASE(string_test_strncmp_long_strings), KUNIT_CASE(string_test_strcasecmp), KUNIT_CASE(string_test_strcasecmp_long_strings), KUNIT_CASE(string_test_strncasecmp), KUNIT_CASE(string_test_strncasecmp_long_strings), KUNIT_CASE(string_test_strscpy), KUNIT_CASE(string_test_strcat), KUNIT_CASE(string_test_strncat), KUNIT_CASE(string_test_strlcat), KUNIT_CASE(string_test_strtomem), KUNIT_CASE(string_test_memtostr), KUNIT_CASE(string_test_strends), KUNIT_CASE(string_bench_strlen), KUNIT_CASE(string_bench_strnlen), KUNIT_CASE(string_bench_strchr), KUNIT_CASE(string_bench_strrchr), {}};
static struct kunit_suite string_test_suite = { .name = "string", .test_cases = string_test_cases,};
kunit_test_suites(&string_test_suite);
MODULE_DESCRIPTION("Test cases for string functions");MODULE_LICENSE("GPL v2");