// 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/module.h>#include <linux/printk.h>#include <linux/slab.h>#include <linux/string.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) 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_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_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; Lines 1–500 of 650. Load more
// 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/module.h> #include <linux/printk.h> #include <linux/slab.h> #include <linux/string.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) 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_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_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;