Linux Audio

Check our new training course

Loading...
Note: File does not exist in v5.14.15.
  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
 20static 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
 49static 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
 78static 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
107static 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
130static 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
163static 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
188static char strcmp_buffer1[STRCMP_LARGE_BUF_LEN];
189static char strcmp_buffer2[STRCMP_LARGE_BUF_LEN];
190
191static 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
199static 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
217static 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
229static 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
252static 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
272static 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
285static 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
297static 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
309static 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 */
344static 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
401static 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
448static volatile int unconst;
449
450static 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
469static 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
496static 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
527static 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
580static 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
605static 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
629static struct kunit_suite string_test_suite = {
630	.name = "string",
631	.test_cases = string_test_cases,
632};
633
634kunit_test_suites(&string_test_suite);
635
636MODULE_DESCRIPTION("Test cases for string functions");
637MODULE_LICENSE("GPL v2");