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");
638
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.