lib/string_kunit.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Test cases for string functions.
   4  */
   5
   6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   7
   8 #include <kunit/test.h>
   9 #include <linux/module.h>
  10 #include <linux/printk.h>
  11 #include <linux/slab.h>
  12 #include <linux/string.h>
  13
  14 #define STRCMP_LARGE_BUF_LEN 2048
  15 #define STRCMP_CHANGE_POINT 1337
  16 #define STRCMP_TEST_EXPECT_EQUAL(test, fn, ...) KUNIT_EXPECT_EQ(test, fn(__VA_ARGS__), 0)
  17 #define STRCMP_TEST_EXPECT_LOWER(test, fn, ...) KUNIT_EXPECT_LT(test, fn(__VA_ARGS__), 0)
  18 #define STRCMP_TEST_EXPECT_GREATER(test, fn, ...) KUNIT_EXPECT_GT(test, fn(__VA_ARGS__), 0)
  19
  20 static void string_test_memset16(struct kunit *test)
  21 {
  22         unsigned i, j, k;
  23         u16 v, *p;
  24
  25         p = kunit_kzalloc(test, 256 * 2 * 2, GFP_KERNEL);
  26         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, p);
  27
  28         for (i = 0; i < 256; i++) {
  29                 for (j = 0; j < 256; j++) {
  30                         memset(p, 0xa1, 256 * 2 * sizeof(v));
  31                         memset16(p + i, 0xb1b2, j);
  32                         for (k = 0; k < 512; k++) {
  33                                 v = p[k];
  34                                 if (k < i) {
  35                                         KUNIT_ASSERT_EQ_MSG(test, v, 0xa1a1,
  36                                                 "i:%d j:%d k:%d", i, j, k);
  37                                 } else if (k < i + j) {
  38                                         KUNIT_ASSERT_EQ_MSG(test, v, 0xb1b2,
  39                                                 "i:%d j:%d k:%d", i, j, k);
  40                                 } else {
  41                                         KUNIT_ASSERT_EQ_MSG(test, v, 0xa1a1,
  42                                                 "i:%d j:%d k:%d", i, j, k);
  43                                 }
  44                         }
  45                 }
  46         }
  47 }
  48
  49 static void string_test_memset32(struct kunit *test)
  50 {
  51         unsigned i, j, k;
  52         u32 v, *p;
  53
  54         p = kunit_kzalloc(test, 256 * 2 * 4, GFP_KERNEL);
  55         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, p);
  56
  57         for (i = 0; i < 256; i++) {
  58                 for (j = 0; j < 256; j++) {
  59                         memset(p, 0xa1, 256 * 2 * sizeof(v));
  60                         memset32(p + i, 0xb1b2b3b4, j);
  61                         for (k = 0; k < 512; k++) {
  62                                 v = p[k];
  63                                 if (k < i) {
  64                                         KUNIT_ASSERT_EQ_MSG(test, v, 0xa1a1a1a1,
  65                                                 "i:%d j:%d k:%d", i, j, k);
  66                                 } else if (k < i + j) {
  67                                         KUNIT_ASSERT_EQ_MSG(test, v, 0xb1b2b3b4,
  68                                                 "i:%d j:%d k:%d", i, j, k);
  69                                 } else {
  70                                         KUNIT_ASSERT_EQ_MSG(test, v, 0xa1a1a1a1,
  71                                                 "i:%d j:%d k:%d", i, j, k);
  72                                 }
  73                         }
  74                 }
  75         }
  76 }
  77
  78 static void string_test_memset64(struct kunit *test)
  79 {
  80         unsigned i, j, k;
  81         u64 v, *p;
  82
  83         p = kunit_kzalloc(test, 256 * 2 * 8, GFP_KERNEL);
  84         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, p);
  85
  86         for (i = 0; i < 256; i++) {
  87                 for (j = 0; j < 256; j++) {
  88                         memset(p, 0xa1, 256 * 2 * sizeof(v));
  89                         memset64(p + i, 0xb1b2b3b4b5b6b7b8ULL, j);
  90                         for (k = 0; k < 512; k++) {
  91                                 v = p[k];
  92                                 if (k < i) {
  93                                         KUNIT_ASSERT_EQ_MSG(test, v, 0xa1a1a1a1a1a1a1a1ULL,
  94                                                 "i:%d j:%d k:%d", i, j, k);
  95                                 } else if (k < i + j) {
  96                                         KUNIT_ASSERT_EQ_MSG(test, v, 0xb1b2b3b4b5b6b7b8ULL,
  97                                                 "i:%d j:%d k:%d", i, j, k);
  98                                 } else {
  99                                         KUNIT_ASSERT_EQ_MSG(test, v, 0xa1a1a1a1a1a1a1a1ULL,
 100                                                 "i:%d j:%d k:%d", i, j, k);
 101                                 }
 102                         }
 103                 }
 104         }
 105 }
 106
 107 static void string_test_strchr(struct kunit *test)
 108 {
 109         const char *test_string = "abcdefghijkl";
 110         const char *empty_string = "";
 111         char *result;
 112         int i;
 113
 114         for (i = 0; i < strlen(test_string) + 1; i++) {
 115                 result = strchr(test_string, test_string[i]);
 116                 KUNIT_ASSERT_EQ_MSG(test, result - test_string, i,
 117                                     "char:%c", 'a' + i);
 118         }
 119
 120         result = strchr(empty_string, '\0');
 121         KUNIT_ASSERT_PTR_EQ(test, result, empty_string);
 122
 123         result = strchr(empty_string, 'a');
 124         KUNIT_ASSERT_NULL(test, result);
 125
 126         result = strchr(test_string, 'z');
 127         KUNIT_ASSERT_NULL(test, result);
 128 }
 129
 130 static void string_test_strnchr(struct kunit *test)
 131 {
 132         const char *test_string = "abcdefghijkl";
 133         const char *empty_string = "";
 134         char *result;
 135         int i, j;
 136
 137         for (i = 0; i < strlen(test_string) + 1; i++) {
 138                 for (j = 0; j < strlen(test_string) + 2; j++) {
 139                         result = strnchr(test_string, j, test_string[i]);
 140                         if (j <= i) {
 141                                 KUNIT_ASSERT_NULL_MSG(test, result,
 142                                         "char:%c i:%d j:%d", 'a' + i, i, j);
 143                         } else {
 144                                 KUNIT_ASSERT_EQ_MSG(test, result - test_string, i,
 145                                         "char:%c i:%d j:%d", 'a' + i, i, j);
 146                         }
 147                 }
 148         }
 149
 150         result = strnchr(empty_string, 0, '\0');
 151         KUNIT_ASSERT_NULL(test, result);
 152
 153         result = strnchr(empty_string, 1, '\0');
 154         KUNIT_ASSERT_PTR_EQ(test, result, empty_string);
 155
 156         result = strnchr(empty_string, 1, 'a');
 157         KUNIT_ASSERT_NULL(test, result);
 158
 159         result = strnchr(NULL, 0, '\0');
 160         KUNIT_ASSERT_NULL(test, result);
 161 }
 162
 163 static void string_test_strspn(struct kunit *test)
 164 {
 165         static const struct strspn_test {
 166                 const char str[16];
 167                 const char accept[16];
 168                 const char reject[16];
 169                 unsigned a;
 170                 unsigned r;
 171         } tests[] = {
 172                 { "foobar", "", "", 0, 6 },
 173                 { "abba", "abc", "ABBA", 4, 4 },
 174                 { "abba", "a", "b", 1, 1 },
 175                 { "", "abc", "abc", 0, 0},
 176         };
 177         const struct strspn_test *s = tests;
 178         size_t i;
 179
 180         for (i = 0; i < ARRAY_SIZE(tests); ++i, ++s) {
 181                 KUNIT_ASSERT_EQ_MSG(test, s->a, strspn(s->str, s->accept),
 182                         "i:%zu", i);
 183                 KUNIT_ASSERT_EQ_MSG(test, s->r, strcspn(s->str, s->reject),
 184                         "i:%zu", i);
 185         }
 186 }
 187
 188 static char strcmp_buffer1[STRCMP_LARGE_BUF_LEN];
 189 static char strcmp_buffer2[STRCMP_LARGE_BUF_LEN];
 190
 191 static void strcmp_fill_buffers(char fill1, char fill2)
 192 {
 193         memset(strcmp_buffer1, fill1, STRCMP_LARGE_BUF_LEN);
 194         memset(strcmp_buffer2, fill2, STRCMP_LARGE_BUF_LEN);
 195         strcmp_buffer1[STRCMP_LARGE_BUF_LEN - 1] = 0;
 196         strcmp_buffer2[STRCMP_LARGE_BUF_LEN - 1] = 0;
 197 }
 198
 199 static void string_test_strcmp(struct kunit *test)
 200 {
 201         /* Equal strings */
 202         STRCMP_TEST_EXPECT_EQUAL(test, strcmp, "Hello, Kernel!", "Hello, Kernel!");
 203         /* First string is lexicographically less than the second */
 204         STRCMP_TEST_EXPECT_LOWER(test, strcmp, "Hello, KUnit!", "Hello, Kernel!");
 205         /* First string is lexicographically larger than the second */
 206         STRCMP_TEST_EXPECT_GREATER(test, strcmp, "Hello, Kernel!", "Hello, KUnit!");
 207         /* Empty string is always lexicographically less than any non-empty string */
 208         STRCMP_TEST_EXPECT_LOWER(test, strcmp, "", "Non-empty string");
 209         /* Two empty strings should be equal */
 210         STRCMP_TEST_EXPECT_EQUAL(test, strcmp, "", "");
 211         /* Compare two strings which have only one char difference */
 212         STRCMP_TEST_EXPECT_LOWER(test, strcmp, "Abacaba", "Abadaba");
 213         /* Compare two strings which have the same prefix*/
 214         STRCMP_TEST_EXPECT_LOWER(test, strcmp, "Just a string", "Just a string and something else");
 215 }
 216
 217 static void string_test_strcmp_long_strings(struct kunit *test)
 218 {
 219         strcmp_fill_buffers('B', 'B');
 220         STRCMP_TEST_EXPECT_EQUAL(test, strcmp, strcmp_buffer1, strcmp_buffer2);
 221
 222         strcmp_buffer1[STRCMP_CHANGE_POINT] = 'A';
 223         STRCMP_TEST_EXPECT_LOWER(test, strcmp, strcmp_buffer1, strcmp_buffer2);
 224
 225         strcmp_buffer1[STRCMP_CHANGE_POINT] = 'C';
 226         STRCMP_TEST_EXPECT_GREATER(test, strcmp, strcmp_buffer1, strcmp_buffer2);
 227 }
 228
 229 static void string_test_strncmp(struct kunit *test)
 230 {
 231         /* Equal strings */
 232         STRCMP_TEST_EXPECT_EQUAL(test, strncmp, "Hello, KUnit!", "Hello, KUnit!", 13);
 233         /* First string is lexicographically less than the second */
 234         STRCMP_TEST_EXPECT_LOWER(test, strncmp, "Hello, KUnit!", "Hello, Kernel!", 13);
 235         /* Result is always 'equal' when count = 0 */
 236         STRCMP_TEST_EXPECT_EQUAL(test, strncmp, "Hello, Kernel!", "Hello, KUnit!", 0);
 237         /* Strings with common prefix are equal if count = length of prefix */
 238         STRCMP_TEST_EXPECT_EQUAL(test, strncmp, "Abacaba", "Abadaba", 3);
 239         /* Strings with common prefix are not equal when count = length of prefix + 1 */
 240         STRCMP_TEST_EXPECT_LOWER(test, strncmp, "Abacaba", "Abadaba", 4);
 241         /* If one string is a prefix of another, the shorter string is lexicographically smaller */
 242         STRCMP_TEST_EXPECT_LOWER(test, strncmp, "Just a string", "Just a string and something else",
 243                                  strlen("Just a string and something else"));
 244         /*
 245          * If one string is a prefix of another, and we check first length
 246          * of prefix chars, the result is 'equal'
 247          */
 248         STRCMP_TEST_EXPECT_EQUAL(test, strncmp, "Just a string", "Just a string and something else",
 249                                  strlen("Just a string"));
 250 }
 251
 252 static void string_test_strncmp_long_strings(struct kunit *test)
 253 {
 254         strcmp_fill_buffers('B', 'B');
 255         STRCMP_TEST_EXPECT_EQUAL(test, strncmp, strcmp_buffer1,
 256                                  strcmp_buffer2, STRCMP_LARGE_BUF_LEN);
 257
 258         strcmp_buffer1[STRCMP_CHANGE_POINT] = 'A';
 259         STRCMP_TEST_EXPECT_LOWER(test, strncmp, strcmp_buffer1,
 260                                  strcmp_buffer2, STRCMP_LARGE_BUF_LEN);
 261
 262         strcmp_buffer1[STRCMP_CHANGE_POINT] = 'C';
 263         STRCMP_TEST_EXPECT_GREATER(test, strncmp, strcmp_buffer1,
 264                                    strcmp_buffer2, STRCMP_LARGE_BUF_LEN);
 265         /* the strings are equal up to STRCMP_CHANGE_POINT */
 266         STRCMP_TEST_EXPECT_EQUAL(test, strncmp, strcmp_buffer1,
 267                                  strcmp_buffer2, STRCMP_CHANGE_POINT);
 268         STRCMP_TEST_EXPECT_GREATER(test, strncmp, strcmp_buffer1,
 269                                    strcmp_buffer2, STRCMP_CHANGE_POINT + 1);
 270 }
 271
 272 static void string_test_strcasecmp(struct kunit *test)
 273 {
 274         /* Same strings in different case should be equal */
 275         STRCMP_TEST_EXPECT_EQUAL(test, strcasecmp, "Hello, Kernel!", "HeLLO, KErNeL!");
 276         /* Empty strings should be equal */
 277         STRCMP_TEST_EXPECT_EQUAL(test, strcasecmp, "", "");
 278         /* Despite ascii code for 'a' is larger than ascii code for 'B', 'a' < 'B' */
 279         STRCMP_TEST_EXPECT_LOWER(test, strcasecmp, "a", "B");
 280         STRCMP_TEST_EXPECT_GREATER(test, strcasecmp, "B", "a");
 281         /* Special symbols and numbers should be processed correctly */
 282         STRCMP_TEST_EXPECT_EQUAL(test, strcasecmp, "-+**.1230ghTTT~^", "-+**.1230Ghttt~^");
 283 }
 284
 285 static void string_test_strcasecmp_long_strings(struct kunit *test)
 286 {
 287         strcmp_fill_buffers('b', 'B');
 288         STRCMP_TEST_EXPECT_EQUAL(test, strcasecmp, strcmp_buffer1, strcmp_buffer2);
 289
 290         strcmp_buffer1[STRCMP_CHANGE_POINT] = 'a';
 291         STRCMP_TEST_EXPECT_LOWER(test, strcasecmp, strcmp_buffer1, strcmp_buffer2);
 292
 293         strcmp_buffer1[STRCMP_CHANGE_POINT] = 'C';
 294         STRCMP_TEST_EXPECT_GREATER(test, strcasecmp, strcmp_buffer1, strcmp_buffer2);
 295 }
 296
 297 static void string_test_strncasecmp(struct kunit *test)
 298 {
 299         /* Same strings in different case should be equal */
 300         STRCMP_TEST_EXPECT_EQUAL(test, strncasecmp, "AbAcAbA", "Abacaba", strlen("Abacaba"));
 301         /* strncasecmp should check 'count' chars only */
 302         STRCMP_TEST_EXPECT_EQUAL(test, strncasecmp, "AbaCaBa", "abaCaDa", 5);
 303         STRCMP_TEST_EXPECT_LOWER(test, strncasecmp, "a", "B", 1);
 304         STRCMP_TEST_EXPECT_GREATER(test, strncasecmp, "B", "a", 1);
 305         /* Result is always 'equal' when count = 0 */
 306         STRCMP_TEST_EXPECT_EQUAL(test, strncasecmp, "Abacaba", "Not abacaba", 0);
 307 }
 308
 309 static void string_test_strncasecmp_long_strings(struct kunit *test)
 310 {
 311         strcmp_fill_buffers('b', 'B');
 312         STRCMP_TEST_EXPECT_EQUAL(test, strncasecmp, strcmp_buffer1,
 313                                  strcmp_buffer2, STRCMP_LARGE_BUF_LEN);
 314
 315         strcmp_buffer1[STRCMP_CHANGE_POINT] = 'a';
 316         STRCMP_TEST_EXPECT_LOWER(test, strncasecmp, strcmp_buffer1,
 317                                  strcmp_buffer2, STRCMP_LARGE_BUF_LEN);
 318
 319         strcmp_buffer1[STRCMP_CHANGE_POINT] = 'C';
 320         STRCMP_TEST_EXPECT_GREATER(test, strncasecmp, strcmp_buffer1,
 321                                    strcmp_buffer2, STRCMP_LARGE_BUF_LEN);
 322
 323         STRCMP_TEST_EXPECT_EQUAL(test, strncasecmp, strcmp_buffer1,
 324                                  strcmp_buffer2, STRCMP_CHANGE_POINT);
 325         STRCMP_TEST_EXPECT_GREATER(test, strncasecmp, strcmp_buffer1,
 326                                    strcmp_buffer2, STRCMP_CHANGE_POINT + 1);
 327 }
 328
 329 /**
 330  * strscpy_check() - Run a specific test case.
 331  * @test: KUnit test context pointer
 332  * @src: Source string, argument to strscpy_pad()
 333  * @count: Size of destination buffer, argument to strscpy_pad()
 334  * @expected: Expected return value from call to strscpy_pad()
 335  * @chars: Number of characters from the src string expected to be
 336  *         written to the dst buffer.
 337  * @terminator: 1 if there should be a terminating null byte 0 otherwise.
 338  * @pad: Number of pad characters expected (in the tail of dst buffer).
 339  *       (@pad does not include the null terminator byte.)
 340  *
 341  * Calls strscpy_pad() and verifies the return value and state of the
 342  * destination buffer after the call returns.
 343  */
 344 static void strscpy_check(struct kunit *test, char *src, int count,
 345                           int expected, int chars, int terminator, int pad)
 346 {
 347         int nr_bytes_poison;
 348         int max_expected;
 349         int max_count;
 350         int written;
 351         char buf[6];
 352         int index, i;
 353         const char POISON = 'z';
 354
 355         KUNIT_ASSERT_TRUE_MSG(test, src != NULL,
 356                               "null source string not supported");
 357
 358         memset(buf, POISON, sizeof(buf));
 359         /* Future proofing test suite, validate args */
 360         max_count = sizeof(buf) - 2; /* Space for null and to verify overflow */
 361         max_expected = count - 1;    /* Space for the null */
 362
 363         KUNIT_ASSERT_LE_MSG(test, count, max_count,
 364                 "count (%d) is too big (%d) ... aborting", count, max_count);
 365         KUNIT_EXPECT_LE_MSG(test, expected, max_expected,
 366                 "expected (%d) is bigger than can possibly be returned (%d)",
 367                 expected, max_expected);
 368
 369         written = strscpy_pad(buf, src, count);
 370         KUNIT_ASSERT_EQ(test, written, expected);
 371
 372         if (count && written == -E2BIG) {
 373                 KUNIT_ASSERT_EQ_MSG(test, 0, strncmp(buf, src, count - 1),
 374                         "buffer state invalid for -E2BIG");
 375                 KUNIT_ASSERT_EQ_MSG(test, buf[count - 1], '\0',
 376                         "too big string is not null terminated correctly");
 377         }
 378
 379         for (i = 0; i < chars; i++)
 380                 KUNIT_ASSERT_EQ_MSG(test, buf[i], src[i],
 381                         "buf[i]==%c != src[i]==%c", buf[i], src[i]);
 382
 383         if (terminator)
 384                 KUNIT_ASSERT_EQ_MSG(test, buf[count - 1], '\0',
 385                         "string is not null terminated correctly");
 386
 387         for (i = 0; i < pad; i++) {
 388                 index = chars + terminator + i;
 389                 KUNIT_ASSERT_EQ_MSG(test, buf[index], '\0',
 390                         "padding missing at index: %d", i);
 391         }
 392
 393         nr_bytes_poison = sizeof(buf) - chars - terminator - pad;
 394         for (i = 0; i < nr_bytes_poison; i++) {
 395                 index = sizeof(buf) - 1 - i; /* Check from the end back */
 396                 KUNIT_ASSERT_EQ_MSG(test, buf[index], POISON,
 397                         "poison value missing at index: %d", i);
 398         }
 399 }
 400
 401 static void string_test_strscpy(struct kunit *test)
 402 {
 403         char dest[8];
 404
 405         /*
 406          * strscpy_check() uses a destination buffer of size 6 and needs at
 407          * least 2 characters spare (one for null and one to check for
 408          * overflow).  This means we should only call tc() with
 409          * strings up to a maximum of 4 characters long and 'count'
 410          * should not exceed 4.  To test with longer strings increase
 411          * the buffer size in tc().
 412          */
 413
 414         /* strscpy_check(test, src, count, expected, chars, terminator, pad) */
 415         strscpy_check(test, "a", 0, -E2BIG, 0, 0, 0);
 416         strscpy_check(test, "",  0, -E2BIG, 0, 0, 0);
 417
 418         strscpy_check(test, "a", 1, -E2BIG, 0, 1, 0);
 419         strscpy_check(test, "",  1, 0,   0, 1, 0);
 420
 421         strscpy_check(test, "ab", 2, -E2BIG, 1, 1, 0);
 422         strscpy_check(test, "a",  2, 1,   1, 1, 0);
 423         strscpy_check(test, "",   2, 0,   0, 1, 1);
 424
 425         strscpy_check(test, "abc", 3, -E2BIG, 2, 1, 0);
 426         strscpy_check(test, "ab",  3, 2,           2, 1, 0);
 427         strscpy_check(test, "a",   3, 1,           1, 1, 1);
 428         strscpy_check(test, "",    3, 0,           0, 1, 2);
 429
 430         strscpy_check(test, "abcd", 4, -E2BIG, 3, 1, 0);
 431         strscpy_check(test, "abc",  4, 3,           3, 1, 0);
 432         strscpy_check(test, "ab",   4, 2,           2, 1, 1);
 433         strscpy_check(test, "a",    4, 1,           1, 1, 2);
 434         strscpy_check(test, "",     4, 0,           0, 1, 3);
 435
 436         /* Compile-time-known source strings. */
 437         KUNIT_EXPECT_EQ(test, strscpy(dest, "", ARRAY_SIZE(dest)), 0);
 438         KUNIT_EXPECT_EQ(test, strscpy(dest, "", 3), 0);
 439         KUNIT_EXPECT_EQ(test, strscpy(dest, "", 1), 0);
 440         KUNIT_EXPECT_EQ(test, strscpy(dest, "", 0), -E2BIG);
 441         KUNIT_EXPECT_EQ(test, strscpy(dest, "Fixed", ARRAY_SIZE(dest)), 5);
 442         KUNIT_EXPECT_EQ(test, strscpy(dest, "Fixed", 3), -E2BIG);
 443         KUNIT_EXPECT_EQ(test, strscpy(dest, "Fixed", 1), -E2BIG);
 444         KUNIT_EXPECT_EQ(test, strscpy(dest, "Fixed", 0), -E2BIG);
 445         KUNIT_EXPECT_EQ(test, strscpy(dest, "This is too long", ARRAY_SIZE(dest)), -E2BIG);
 446 }
 447
 448 static volatile int unconst;
 449
 450 static void string_test_strcat(struct kunit *test)
 451 {
 452         char dest[8];
 453
 454         /* Destination is terminated. */
 455         memset(dest, 0, sizeof(dest));
 456         KUNIT_EXPECT_EQ(test, strlen(dest), 0);
 457         /* Empty copy does nothing. */
 458         KUNIT_EXPECT_TRUE(test, strcat(dest, "") == dest);
 459         KUNIT_EXPECT_STREQ(test, dest, "");
 460         /* 4 characters copied in, stops at %NUL. */
 461         KUNIT_EXPECT_TRUE(test, strcat(dest, "four\000123") == dest);
 462         KUNIT_EXPECT_STREQ(test, dest, "four");
 463         KUNIT_EXPECT_EQ(test, dest[5], '\0');
 464         /* 2 more characters copied in okay. */
 465         KUNIT_EXPECT_TRUE(test, strcat(dest, "AB") == dest);
 466         KUNIT_EXPECT_STREQ(test, dest, "fourAB");
 467 }
 468
 469 static void string_test_strncat(struct kunit *test)
 470 {
 471         char dest[8];
 472
 473         /* Destination is terminated. */
 474         memset(dest, 0, sizeof(dest));
 475         KUNIT_EXPECT_EQ(test, strlen(dest), 0);
 476         /* Empty copy of size 0 does nothing. */
 477         KUNIT_EXPECT_TRUE(test, strncat(dest, "", 0 + unconst) == dest);
 478         KUNIT_EXPECT_STREQ(test, dest, "");
 479         /* Empty copy of size 1 does nothing too. */
 480         KUNIT_EXPECT_TRUE(test, strncat(dest, "", 1 + unconst) == dest);
 481         KUNIT_EXPECT_STREQ(test, dest, "");
 482         /* Copy of max 0 characters should do nothing. */
 483         KUNIT_EXPECT_TRUE(test, strncat(dest, "asdf", 0 + unconst) == dest);
 484         KUNIT_EXPECT_STREQ(test, dest, "");
 485
 486         /* 4 characters copied in, even if max is 8. */
 487         KUNIT_EXPECT_TRUE(test, strncat(dest, "four\000123", 8 + unconst) == dest);
 488         KUNIT_EXPECT_STREQ(test, dest, "four");
 489         KUNIT_EXPECT_EQ(test, dest[5], '\0');
 490         KUNIT_EXPECT_EQ(test, dest[6], '\0');
 491         /* 2 characters copied in okay, 2 ignored. */
 492         KUNIT_EXPECT_TRUE(test, strncat(dest, "ABCD", 2 + unconst) == dest);
 493         KUNIT_EXPECT_STREQ(test, dest, "fourAB");
 494 }
 495
 496 static void string_test_strlcat(struct kunit *test)
 497 {
 498         char dest[8] = "";
 499         int len = sizeof(dest) + unconst;
 500
 501         /* Destination is terminated. */
 502         KUNIT_EXPECT_EQ(test, strlen(dest), 0);
 503         /* Empty copy is size 0. */
 504         KUNIT_EXPECT_EQ(test, strlcat(dest, "", len), 0);
 505         KUNIT_EXPECT_STREQ(test, dest, "");
 506         /* Size 1 should keep buffer terminated, report size of source only. */
 507         KUNIT_EXPECT_EQ(test, strlcat(dest, "four", 1 + unconst), 4);
 508         KUNIT_EXPECT_STREQ(test, dest, "");
 509
 510         /* 4 characters copied in. */
 511         KUNIT_EXPECT_EQ(test, strlcat(dest, "four", len), 4);
 512         KUNIT_EXPECT_STREQ(test, dest, "four");
 513         /* 2 characters copied in okay, gets to 6 total. */
 514         KUNIT_EXPECT_EQ(test, strlcat(dest, "AB", len), 6);
 515         KUNIT_EXPECT_STREQ(test, dest, "fourAB");
 516         /* 2 characters ignored if max size (7) reached. */
 517         KUNIT_EXPECT_EQ(test, strlcat(dest, "CD", 7 + unconst), 8);
 518         KUNIT_EXPECT_STREQ(test, dest, "fourAB");
 519         /* 1 of 2 characters skipped, now at true max size. */
 520         KUNIT_EXPECT_EQ(test, strlcat(dest, "EFG", len), 9);
 521         KUNIT_EXPECT_STREQ(test, dest, "fourABE");
 522         /* Everything else ignored, now at full size. */
 523         KUNIT_EXPECT_EQ(test, strlcat(dest, "1234", len), 11);
 524         KUNIT_EXPECT_STREQ(test, dest, "fourABE");
 525 }
 526
 527 static void string_test_strtomem(struct kunit *test)
 528 {
 529         static const char input[sizeof(unsigned long)] = "hi";
 530         static const char truncate[] = "this is too long";
 531         struct {
 532                 unsigned long canary1;
 533                 unsigned char output[sizeof(unsigned long)] __nonstring;
 534                 unsigned long canary2;
 535         } wrap;
 536
 537         memset(&wrap, 0xFF, sizeof(wrap));
 538         KUNIT_EXPECT_EQ_MSG(test, wrap.canary1, ULONG_MAX,
 539                             "bad initial canary value");
 540         KUNIT_EXPECT_EQ_MSG(test, wrap.canary2, ULONG_MAX,
 541                             "bad initial canary value");
 542
 543         /* Check unpadded copy leaves surroundings untouched. */
 544         strtomem(wrap.output, input);
 545         KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
 546         KUNIT_EXPECT_EQ(test, wrap.output[0], input[0]);
 547         KUNIT_EXPECT_EQ(test, wrap.output[1], input[1]);
 548         for (size_t i = 2; i < sizeof(wrap.output); i++)
 549                 KUNIT_EXPECT_EQ(test, wrap.output[i], 0xFF);
 550         KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
 551
 552         /* Check truncated copy leaves surroundings untouched. */
 553         memset(&wrap, 0xFF, sizeof(wrap));
 554         strtomem(wrap.output, truncate);
 555         KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
 556         for (size_t i = 0; i < sizeof(wrap.output); i++)
 557                 KUNIT_EXPECT_EQ(test, wrap.output[i], truncate[i]);
 558         KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
 559
 560         /* Check padded copy leaves only string padded. */
 561         memset(&wrap, 0xFF, sizeof(wrap));
 562         strtomem_pad(wrap.output, input, 0xAA);
 563         KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
 564         KUNIT_EXPECT_EQ(test, wrap.output[0], input[0]);
 565         KUNIT_EXPECT_EQ(test, wrap.output[1], input[1]);
 566         for (size_t i = 2; i < sizeof(wrap.output); i++)
 567                 KUNIT_EXPECT_EQ(test, wrap.output[i], 0xAA);
 568         KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
 569
 570         /* Check truncated padded copy has no padding. */
 571         memset(&wrap, 0xFF, sizeof(wrap));
 572         strtomem(wrap.output, truncate);
 573         KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
 574         for (size_t i = 0; i < sizeof(wrap.output); i++)
 575                 KUNIT_EXPECT_EQ(test, wrap.output[i], truncate[i]);
 576         KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
 577 }
 578
 579
 580 static void string_test_memtostr(struct kunit *test)
 581 {
 582         char nonstring[7] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g' };
 583         char nonstring_small[3] = { 'a', 'b', 'c' };
 584         char dest[sizeof(nonstring) + 1];
 585
 586         /* Copy in a non-NUL-terminated string into exactly right-sized dest. */
 587         KUNIT_EXPECT_EQ(test, sizeof(dest), sizeof(nonstring) + 1);
 588         memset(dest, 'X', sizeof(dest));
 589         memtostr(dest, nonstring);
 590         KUNIT_EXPECT_STREQ(test, dest, "abcdefg");
 591         memset(dest, 'X', sizeof(dest));
 592         memtostr(dest, nonstring_small);
 593         KUNIT_EXPECT_STREQ(test, dest, "abc");
 594         KUNIT_EXPECT_EQ(test, dest[7], 'X');
 595
 596         memset(dest, 'X', sizeof(dest));
 597         memtostr_pad(dest, nonstring);
 598         KUNIT_EXPECT_STREQ(test, dest, "abcdefg");
 599         memset(dest, 'X', sizeof(dest));
 600         memtostr_pad(dest, nonstring_small);
 601         KUNIT_EXPECT_STREQ(test, dest, "abc");
 602         KUNIT_EXPECT_EQ(test, dest[7], '\0');
 603 }
 604
 605 static struct kunit_case string_test_cases[] = {
 606         KUNIT_CASE(string_test_memset16),
 607         KUNIT_CASE(string_test_memset32),
 608         KUNIT_CASE(string_test_memset64),
 609         KUNIT_CASE(string_test_strchr),
 610         KUNIT_CASE(string_test_strnchr),
 611         KUNIT_CASE(string_test_strspn),
 612         KUNIT_CASE(string_test_strcmp),
 613         KUNIT_CASE(string_test_strcmp_long_strings),
 614         KUNIT_CASE(string_test_strncmp),
 615         KUNIT_CASE(string_test_strncmp_long_strings),
 616         KUNIT_CASE(string_test_strcasecmp),
 617         KUNIT_CASE(string_test_strcasecmp_long_strings),
 618         KUNIT_CASE(string_test_strncasecmp),
 619         KUNIT_CASE(string_test_strncasecmp_long_strings),
 620         KUNIT_CASE(string_test_strscpy),
 621         KUNIT_CASE(string_test_strcat),
 622         KUNIT_CASE(string_test_strncat),
 623         KUNIT_CASE(string_test_strlcat),
 624         KUNIT_CASE(string_test_strtomem),
 625         KUNIT_CASE(string_test_memtostr),
 626         {}
 627 };
 628
 629 static struct kunit_suite string_test_suite = {
 630         .name = "string",
 631         .test_cases = string_test_cases,
 632 };
 633
 634 kunit_test_suites(&string_test_suite);
 635
 636 MODULE_DESCRIPTION("Test cases for string functions");
 637 MODULE_LICENSE("GPL v2");