[thirdparty/linux.git] / lib / test-string_helpers.c

/*
 * Test cases for lib/string_helpers.c module.
 */
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/array_size.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/random.h>
#include <linux/string.h>
#include <linux/string_helpers.h>

static __init bool test_string_check_buf(const char *name, unsigned int flags,
					 char *in, size_t p,
					 char *out_real, size_t q_real,
					 char *out_test, size_t q_test)
{
	if (q_real == q_test && !memcmp(out_test, out_real, q_test))
		return true;

	pr_warn("Test '%s' failed: flags = %#x\n", name, flags);

	print_hex_dump(KERN_WARNING, "Input: ", DUMP_PREFIX_NONE, 16, 1,
		       in, p, true);
	print_hex_dump(KERN_WARNING, "Expected: ", DUMP_PREFIX_NONE, 16, 1,
		       out_test, q_test, true);
	print_hex_dump(KERN_WARNING, "Got: ", DUMP_PREFIX_NONE, 16, 1,
		       out_real, q_real, true);

	return false;
}

struct test_string {
	const char *in;
	const char *out;
	unsigned int flags;
};

static const struct test_string strings[] __initconst = {
	{
		.in = "\\f\\ \\n\\r\\t\\v",
		.out = "\f\\ \n\r\t\v",
		.flags = UNESCAPE_SPACE,
	},
	{
		.in = "\\40\\1\\387\\0064\\05\\040\\8a\\110\\777",
		.out = " \001\00387\0064\005 \\8aH?7",
		.flags = UNESCAPE_OCTAL,
	},
	{
		.in = "\\xv\\xa\\x2c\\xD\\x6f2",
		.out = "\\xv\n,\ro2",
		.flags = UNESCAPE_HEX,
	},
	{
		.in = "\\h\\\\\\\"\\a\\e\\",
		.out = "\\h\\\"\a\e\\",
		.flags = UNESCAPE_SPECIAL,
	},
};

static void __init test_string_unescape(const char *name, unsigned int flags,
					bool inplace)
{
	int q_real = 256;
	char *in = kmalloc(q_real, GFP_KERNEL);
	char *out_test = kmalloc(q_real, GFP_KERNEL);
	char *out_real = kmalloc(q_real, GFP_KERNEL);
	int i, p = 0, q_test = 0;

	if (!in || !out_test || !out_real)
		goto out;

	for (i = 0; i < ARRAY_SIZE(strings); i++) {
		const char *s = strings[i].in;
		int len = strlen(strings[i].in);

		/* Copy string to in buffer */
		memcpy(&in[p], s, len);
		p += len;

		/* Copy expected result for given flags */
		if (flags & strings[i].flags) {
			s = strings[i].out;
			len = strlen(strings[i].out);
		}
		memcpy(&out_test[q_test], s, len);
		q_test += len;
	}
	in[p++] = '\0';

	/* Call string_unescape and compare result */
	if (inplace) {
		memcpy(out_real, in, p);
		if (flags == UNESCAPE_ANY)
			q_real = string_unescape_any_inplace(out_real);
		else
			q_real = string_unescape_inplace(out_real, flags);
	} else if (flags == UNESCAPE_ANY) {
		q_real = string_unescape_any(in, out_real, q_real);
	} else {
		q_real = string_unescape(in, out_real, q_real, flags);
	}

	test_string_check_buf(name, flags, in, p - 1, out_real, q_real,
			      out_test, q_test);
out:
	kfree(out_real);
	kfree(out_test);
	kfree(in);
}

struct test_string_1 {
	const char *out;
	unsigned int flags;
};

#define	TEST_STRING_2_MAX_S1		32
struct test_string_2 {
	const char *in;
	struct test_string_1 s1[TEST_STRING_2_MAX_S1];
};

#define	TEST_STRING_2_DICT_0		NULL
static const struct test_string_2 escape0[] __initconst = {{
	.in = "\f\\ \n\r\t\v",
	.s1 = {{
		.out = "\\f\\ \\n\\r\\t\\v",
		.flags = ESCAPE_SPACE,
	},{
		.out = "\\f\\134\\040\\n\\r\\t\\v",
		.flags = ESCAPE_SPACE | ESCAPE_OCTAL,
	},{
		.out = "\\f\\x5c\\x20\\n\\r\\t\\v",
		.flags = ESCAPE_SPACE | ESCAPE_HEX,
	},{
		/* terminator */
	}}
},{
	.in = "\\h\\\"\a\e\\",
	.s1 = {{
		.out = "\\\\h\\\\\\\"\\a\\e\\\\",
		.flags = ESCAPE_SPECIAL,
	},{
		.out = "\\\\\\150\\\\\\\"\\a\\e\\\\",
		.flags = ESCAPE_SPECIAL | ESCAPE_OCTAL,
	},{
		.out = "\\\\\\x68\\\\\\\"\\a\\e\\\\",
		.flags = ESCAPE_SPECIAL | ESCAPE_HEX,
	},{
		/* terminator */
	}}
},{
	.in = "\eb \\C\007\"\x90\r]",
	.s1 = {{
		.out = "\eb \\C\007\"\x90\\r]",
		.flags = ESCAPE_SPACE,
	},{
		.out = "\\eb \\\\C\\a\\\"\x90\r]",
		.flags = ESCAPE_SPECIAL,
	},{
		.out = "\\eb \\\\C\\a\\\"\x90\\r]",
		.flags = ESCAPE_SPACE | ESCAPE_SPECIAL,
	},{
		.out = "\\033\\142\\040\\134\\103\\007\\042\\220\\015\\135",
		.flags = ESCAPE_OCTAL,
	},{
		.out = "\\033\\142\\040\\134\\103\\007\\042\\220\\r\\135",
		.flags = ESCAPE_SPACE | ESCAPE_OCTAL,
	},{
		.out = "\\e\\142\\040\\\\\\103\\a\\\"\\220\\015\\135",
		.flags = ESCAPE_SPECIAL | ESCAPE_OCTAL,
	},{
		.out = "\\e\\142\\040\\\\\\103\\a\\\"\\220\\r\\135",
		.flags = ESCAPE_SPACE | ESCAPE_SPECIAL | ESCAPE_OCTAL,
	},{
		.out = "\eb \\C\007\"\x90\r]",
		.flags = ESCAPE_NP,
	},{
		.out = "\eb \\C\007\"\x90\\r]",
		.flags = ESCAPE_SPACE | ESCAPE_NP,
	},{
		.out = "\\eb \\C\\a\"\x90\r]",
		.flags = ESCAPE_SPECIAL | ESCAPE_NP,
	},{
		.out = "\\eb \\C\\a\"\x90\\r]",
		.flags = ESCAPE_SPACE | ESCAPE_SPECIAL | ESCAPE_NP,
	},{
		.out = "\\033b \\C\\007\"\\220\\015]",
		.flags = ESCAPE_OCTAL | ESCAPE_NP,
	},{
		.out = "\\033b \\C\\007\"\\220\\r]",
		.flags = ESCAPE_SPACE | ESCAPE_OCTAL | ESCAPE_NP,
	},{
		.out = "\\eb \\C\\a\"\\220\\r]",
		.flags = ESCAPE_SPECIAL | ESCAPE_SPACE | ESCAPE_OCTAL |
			 ESCAPE_NP,
	},{
		.out = "\\x1bb \\C\\x07\"\\x90\\x0d]",
		.flags = ESCAPE_NP | ESCAPE_HEX,
	},{
		/* terminator */
	}}
},{
	.in = "\007 \eb\"\x90\xCF\r",
	.s1 = {{
		.out = "\007 \eb\"\\220\\317\r",
		.flags = ESCAPE_OCTAL | ESCAPE_NA,
	},{
		.out = "\007 \eb\"\\x90\\xcf\r",
		.flags = ESCAPE_HEX | ESCAPE_NA,
	},{
		.out = "\007 \eb\"\x90\xCF\r",
		.flags = ESCAPE_NA,
	},{
		/* terminator */
	}}
},{
	/* terminator */
}};

#define	TEST_STRING_2_DICT_1		"b\\ \t\r\xCF"
static const struct test_string_2 escape1[] __initconst = {{
	.in = "\f\\ \n\r\t\v",
	.s1 = {{
		.out = "\f\\134\\040\n\\015\\011\v",
		.flags = ESCAPE_OCTAL,
	},{
		.out = "\f\\x5c\\x20\n\\x0d\\x09\v",
		.flags = ESCAPE_HEX,
	},{
		.out = "\f\\134\\040\n\\015\\011\v",
		.flags = ESCAPE_ANY | ESCAPE_APPEND,
	},{
		.out = "\\014\\134\\040\\012\\015\\011\\013",
		.flags = ESCAPE_OCTAL | ESCAPE_APPEND | ESCAPE_NAP,
	},{
		.out = "\\x0c\\x5c\\x20\\x0a\\x0d\\x09\\x0b",
		.flags = ESCAPE_HEX | ESCAPE_APPEND | ESCAPE_NAP,
	},{
		.out = "\f\\134\\040\n\\015\\011\v",
		.flags = ESCAPE_OCTAL | ESCAPE_APPEND | ESCAPE_NA,
	},{
		.out = "\f\\x5c\\x20\n\\x0d\\x09\v",
		.flags = ESCAPE_HEX | ESCAPE_APPEND | ESCAPE_NA,
	},{
		/* terminator */
	}}
},{
	.in = "\\h\\\"\a\xCF\e\\",
	.s1 = {{
		.out = "\\134h\\134\"\a\\317\e\\134",
		.flags = ESCAPE_OCTAL,
	},{
		.out = "\\134h\\134\"\a\\317\e\\134",
		.flags = ESCAPE_ANY | ESCAPE_APPEND,
	},{
		.out = "\\134h\\134\"\\007\\317\\033\\134",
		.flags = ESCAPE_OCTAL | ESCAPE_APPEND | ESCAPE_NAP,
	},{
		.out = "\\134h\\134\"\a\\317\e\\134",
		.flags = ESCAPE_OCTAL | ESCAPE_APPEND | ESCAPE_NA,
	},{
		/* terminator */
	}}
},{
	.in = "\eb \\C\007\"\x90\r]",
	.s1 = {{
		.out = "\e\\142\\040\\134C\007\"\x90\\015]",
		.flags = ESCAPE_OCTAL,
	},{
		/* terminator */
	}}
},{
	.in = "\007 \eb\"\x90\xCF\r",
	.s1 = {{
		.out = "\007 \eb\"\x90\xCF\r",
		.flags = ESCAPE_NA,
	},{
		.out = "\007 \eb\"\x90\xCF\r",
		.flags = ESCAPE_SPACE | ESCAPE_NA,
	},{
		.out = "\007 \eb\"\x90\xCF\r",
		.flags = ESCAPE_SPECIAL | ESCAPE_NA,
	},{
		.out = "\007 \eb\"\x90\xCF\r",
		.flags = ESCAPE_SPACE | ESCAPE_SPECIAL | ESCAPE_NA,
	},{
		.out = "\007 \eb\"\x90\\317\r",
		.flags = ESCAPE_OCTAL | ESCAPE_NA,
	},{
		.out = "\007 \eb\"\x90\\317\r",
		.flags = ESCAPE_SPACE | ESCAPE_OCTAL | ESCAPE_NA,
	},{
		.out = "\007 \eb\"\x90\\317\r",
		.flags = ESCAPE_SPECIAL | ESCAPE_OCTAL | ESCAPE_NA,
	},{
		.out = "\007 \eb\"\x90\\317\r",
		.flags = ESCAPE_ANY | ESCAPE_NA,
	},{
		.out = "\007 \eb\"\x90\\xcf\r",
		.flags = ESCAPE_HEX | ESCAPE_NA,
	},{
		.out = "\007 \eb\"\x90\\xcf\r",
		.flags = ESCAPE_SPACE | ESCAPE_HEX | ESCAPE_NA,
	},{
		.out = "\007 \eb\"\x90\\xcf\r",
		.flags = ESCAPE_SPECIAL | ESCAPE_HEX | ESCAPE_NA,
	},{
		.out = "\007 \eb\"\x90\\xcf\r",
		.flags = ESCAPE_SPACE | ESCAPE_SPECIAL | ESCAPE_HEX | ESCAPE_NA,
	},{
		/* terminator */
	}}
},{
	.in = "\007 \eb\"\x90\xCF\r",
	.s1 = {{
		.out = "\007 \eb\"\x90\xCF\r",
		.flags = ESCAPE_NAP,
	},{
		.out = "\007 \eb\"\x90\xCF\\r",
		.flags = ESCAPE_SPACE | ESCAPE_NAP,
	},{
		.out = "\007 \eb\"\x90\xCF\r",
		.flags = ESCAPE_SPECIAL | ESCAPE_NAP,
	},{
		.out = "\007 \eb\"\x90\xCF\\r",
		.flags = ESCAPE_SPACE | ESCAPE_SPECIAL | ESCAPE_NAP,
	},{
		.out = "\007 \eb\"\x90\\317\\015",
		.flags = ESCAPE_OCTAL | ESCAPE_NAP,
	},{
		.out = "\007 \eb\"\x90\\317\\r",
		.flags = ESCAPE_SPACE | ESCAPE_OCTAL | ESCAPE_NAP,
	},{
		.out = "\007 \eb\"\x90\\317\\015",
		.flags = ESCAPE_SPECIAL | ESCAPE_OCTAL | ESCAPE_NAP,
	},{
		.out = "\007 \eb\"\x90\\317\r",
		.flags = ESCAPE_ANY | ESCAPE_NAP,
	},{
		.out = "\007 \eb\"\x90\\xcf\\x0d",
		.flags = ESCAPE_HEX | ESCAPE_NAP,
	},{
		.out = "\007 \eb\"\x90\\xcf\\r",
		.flags = ESCAPE_SPACE | ESCAPE_HEX | ESCAPE_NAP,
	},{
		.out = "\007 \eb\"\x90\\xcf\\x0d",
		.flags = ESCAPE_SPECIAL | ESCAPE_HEX | ESCAPE_NAP,
	},{
		.out = "\007 \eb\"\x90\\xcf\\r",
		.flags = ESCAPE_SPACE | ESCAPE_SPECIAL | ESCAPE_HEX | ESCAPE_NAP,
	},{
		/* terminator */
	}}
},{
	/* terminator */
}};

static const struct test_string strings_upper[] __initconst = {
	{
		.in = "abcdefgh1234567890test",
		.out = "ABCDEFGH1234567890TEST",
	},
	{
		.in = "abCdeFgH1234567890TesT",
		.out = "ABCDEFGH1234567890TEST",
	},
};

static const struct test_string strings_lower[] __initconst = {
	{
		.in = "ABCDEFGH1234567890TEST",
		.out = "abcdefgh1234567890test",
	},
	{
		.in = "abCdeFgH1234567890TesT",
		.out = "abcdefgh1234567890test",
	},
};

static __init const char *test_string_find_match(const struct test_string_2 *s2,
						 unsigned int flags)
{
	const struct test_string_1 *s1 = s2->s1;
	unsigned int i;

	if (!flags)
		return s2->in;

	/* Test cases are NULL-aware */
	flags &= ~ESCAPE_NULL;

	/* ESCAPE_OCTAL has a higher priority */
	if (flags & ESCAPE_OCTAL)
		flags &= ~ESCAPE_HEX;

	for (i = 0; i < TEST_STRING_2_MAX_S1 && s1->out; i++, s1++)
		if (s1->flags == flags)
			return s1->out;
	return NULL;
}

static __init void
test_string_escape_overflow(const char *in, int p, unsigned int flags, const char *esc,
			    int q_test, const char *name)
{
	int q_real;

	q_real = string_escape_mem(in, p, NULL, 0, flags, esc);
	if (q_real != q_test)
		pr_warn("Test '%s' failed: flags = %#x, osz = 0, expected %d, got %d\n",
			name, flags, q_test, q_real);
}

static __init void test_string_escape(const char *name,
				      const struct test_string_2 *s2,
				      unsigned int flags, const char *esc)
{
	size_t out_size = 512;
	char *out_test = kmalloc(out_size, GFP_KERNEL);
	char *out_real = kmalloc(out_size, GFP_KERNEL);
	char *in = kmalloc(256, GFP_KERNEL);
	int p = 0, q_test = 0;
	int q_real;

	if (!out_test || !out_real || !in)
		goto out;

	for (; s2->in; s2++) {
		const char *out;
		int len;

		/* NULL injection */
		if (flags & ESCAPE_NULL) {
			in[p++] = '\0';
			/* '\0' passes isascii() test */
			if (flags & ESCAPE_NA && !(flags & ESCAPE_APPEND && esc)) {
				out_test[q_test++] = '\0';
			} else {
				out_test[q_test++] = '\\';
				out_test[q_test++] = '0';
			}
		}

		/* Don't try strings that have no output */
		out = test_string_find_match(s2, flags);
		if (!out)
			continue;

		/* Copy string to in buffer */
		len = strlen(s2->in);
		memcpy(&in[p], s2->in, len);
		p += len;

		/* Copy expected result for given flags */
		len = strlen(out);
		memcpy(&out_test[q_test], out, len);
		q_test += len;
	}

	q_real = string_escape_mem(in, p, out_real, out_size, flags, esc);

	test_string_check_buf(name, flags, in, p, out_real, q_real, out_test,
			      q_test);

	test_string_escape_overflow(in, p, flags, esc, q_test, name);

out:
	kfree(in);
	kfree(out_real);
	kfree(out_test);
}

#define string_get_size_maxbuf 16
#define test_string_get_size_one(size, blk_size, exp_result10, exp_result2)    \
	do {                                                                   \
		BUILD_BUG_ON(sizeof(exp_result10) >= string_get_size_maxbuf);  \
		BUILD_BUG_ON(sizeof(exp_result2) >= string_get_size_maxbuf);   \
		__test_string_get_size((size), (blk_size), (exp_result10),     \
				       (exp_result2));                         \
	} while (0)


static __init void test_string_get_size_check(const char *units,
					      const char *exp,
					      char *res,
					      const u64 size,
					      const u64 blk_size)
{
	if (!memcmp(res, exp, strlen(exp) + 1))
		return;

	res[string_get_size_maxbuf - 1] = '\0';

	pr_warn("Test 'test_string_get_size' failed!\n");
	pr_warn("string_get_size(size = %llu, blk_size = %llu, units = %s)\n",
		size, blk_size, units);
	pr_warn("expected: '%s', got '%s'\n", exp, res);
}

static __init void __strchrcut(char *dst, const char *src, const char *cut)
{
	const char *from = src;
	size_t len;

	do {
		len = strcspn(from, cut);
		memcpy(dst, from, len);
		dst += len;
		from += len;
	} while (*from++);
	*dst = '\0';
}

static __init void __test_string_get_size_one(const u64 size, const u64 blk_size,
					      const char *exp_result10,
					      const char *exp_result2,
					      enum string_size_units units,
					      const char *cut)
{
	char buf10[string_get_size_maxbuf];
	char buf2[string_get_size_maxbuf];
	char exp10[string_get_size_maxbuf];
	char exp2[string_get_size_maxbuf];
	char prefix10[64];
	char prefix2[64];

	sprintf(prefix10, "STRING_UNITS_10 [%s]", cut);
	sprintf(prefix2, "STRING_UNITS_2 [%s]", cut);

	__strchrcut(exp10, exp_result10, cut);
	__strchrcut(exp2, exp_result2, cut);

	string_get_size(size, blk_size, STRING_UNITS_10 | units, buf10, sizeof(buf10));
	string_get_size(size, blk_size, STRING_UNITS_2 | units, buf2, sizeof(buf2));

	test_string_get_size_check(prefix10, exp10, buf10, size, blk_size);
	test_string_get_size_check(prefix2, exp2, buf2, size, blk_size);
}

static __init void __test_string_get_size(const u64 size, const u64 blk_size,
					  const char *exp_result10,
					  const char *exp_result2)
{
	struct {
		enum string_size_units units;
		const char *cut;
	} get_size_test_cases[] = {
		{ 0, "" },
		{ STRING_UNITS_NO_SPACE, " " },
		{ STRING_UNITS_NO_SPACE | STRING_UNITS_NO_BYTES, " B" },
		{ STRING_UNITS_NO_BYTES, "B" },
	};
	int i;

	for (i = 0; i < ARRAY_SIZE(get_size_test_cases); i++)
		__test_string_get_size_one(size, blk_size, exp_result10, exp_result2,
					   get_size_test_cases[i].units,
					   get_size_test_cases[i].cut);
}

static __init void test_string_get_size(void)
{
	/* small values */
	test_string_get_size_one(0, 512, "0 B", "0 B");
	test_string_get_size_one(1, 512, "512 B", "512 B");
	test_string_get_size_one(1100, 1, "1.10 kB", "1.07 KiB");

	/* normal values */
	test_string_get_size_one(16384, 512, "8.39 MB", "8.00 MiB");
	test_string_get_size_one(500118192, 512, "256 GB", "238 GiB");
	test_string_get_size_one(8192, 4096, "33.6 MB", "32.0 MiB");

	/* weird block sizes */
	test_string_get_size_one(3000, 1900, "5.70 MB", "5.44 MiB");

	/* huge values */
	test_string_get_size_one(U64_MAX, 4096, "75.6 ZB", "64.0 ZiB");
	test_string_get_size_one(4096, U64_MAX, "75.6 ZB", "64.0 ZiB");
}

static void __init test_string_upper_lower(void)
{
	char *dst;
	int i;

	for (i = 0; i < ARRAY_SIZE(strings_upper); i++) {
		const char *s = strings_upper[i].in;
		int len = strlen(strings_upper[i].in) + 1;

		dst = kmalloc(len, GFP_KERNEL);
		if (!dst)
			return;

		string_upper(dst, s);
		if (memcmp(dst, strings_upper[i].out, len)) {
			pr_warn("Test 'string_upper' failed : expected %s, got %s!\n",
				strings_upper[i].out, dst);
			kfree(dst);
			return;
		}
		kfree(dst);
	}

	for (i = 0; i < ARRAY_SIZE(strings_lower); i++) {
		const char *s = strings_lower[i].in;
		int len = strlen(strings_lower[i].in) + 1;

		dst = kmalloc(len, GFP_KERNEL);
		if (!dst)
			return;

		string_lower(dst, s);
		if (memcmp(dst, strings_lower[i].out, len)) {
			pr_warn("Test 'string_lower failed : : expected %s, got %s!\n",
				strings_lower[i].out, dst);
			kfree(dst);
			return;
		}
		kfree(dst);
	}
}

static int __init test_string_helpers_init(void)
{
	unsigned int i;

	pr_info("Running tests...\n");
	for (i = 0; i < UNESCAPE_ALL_MASK + 1; i++)
		test_string_unescape("unescape", i, false);
	test_string_unescape("unescape inplace",
			     get_random_u32_below(UNESCAPE_ALL_MASK + 1), true);

	/* Without dictionary */
	for (i = 0; i < ESCAPE_ALL_MASK + 1; i++)
		test_string_escape("escape 0", escape0, i, TEST_STRING_2_DICT_0);

	/* With dictionary */
	for (i = 0; i < ESCAPE_ALL_MASK + 1; i++)
		test_string_escape("escape 1", escape1, i, TEST_STRING_2_DICT_1);

	/* Test string_get_size() */
	test_string_get_size();

	/* Test string upper(), string_lower() */
	test_string_upper_lower();

	return -EINVAL;
}
module_init(test_string_helpers_init);
MODULE_LICENSE("Dual BSD/GPL");
Commit	Line	Data
16c7fa05 AS	1	/*
	2	* Test cases for lib/string_helpers.c module.
	3	*/
	4	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	5
f0b7f8ad	6	#include <linux/array_size.h>
16c7fa05 AS	7	#include <linux/init.h>
16c7fa05 AS	8	#include <linux/kernel.h>
c8250381	9	#include <linux/slab.h>
16c7fa05 AS	10	#include <linux/module.h>
	11	#include <linux/random.h>
	12	#include <linux/string.h>
	13	#include <linux/string_helpers.h>
	14
45ff337a AS	15	static __init bool test_string_check_buf(const char *name, unsigned int flags,
	16	char *in, size_t p,
	17	char *out_real, size_t q_real,
	18	char *out_test, size_t q_test)
	19	{
	20	if (q_real == q_test && !memcmp(out_test, out_real, q_test))
	21	return true;
	22
229563b1	23	pr_warn("Test '%s' failed: flags = %#x\n", name, flags);
45ff337a AS	24
	25	print_hex_dump(KERN_WARNING, "Input: ", DUMP_PREFIX_NONE, 16, 1,
	26	in, p, true);
	27	print_hex_dump(KERN_WARNING, "Expected: ", DUMP_PREFIX_NONE, 16, 1,
	28	out_test, q_test, true);
	29	print_hex_dump(KERN_WARNING, "Got: ", DUMP_PREFIX_NONE, 16, 1,
	30	out_real, q_real, true);
	31
	32	return false;
	33	}
	34
16c7fa05 AS	35	struct test_string {
	36	const char *in;
	37	const char *out;
	38	unsigned int flags;
	39	};
	40
	41	static const struct test_string strings[] __initconst = {
	42	{
	43	.in = "\\f\\ \\n\\r\\t\\v",
	44	.out = "\f\\ \n\r\t\v",
	45	.flags = UNESCAPE_SPACE,
	46	},
	47	{
	48	.in = "\\40\\1\\387\\0064\\05\\040\\8a\\110\\777",
	49	.out = " \001\00387\0064\005 \\8aH?7",
	50	.flags = UNESCAPE_OCTAL,
	51	},
	52	{
	53	.in = "\\xv\\xa\\x2c\\xD\\x6f2",
	54	.out = "\\xv\n,\ro2",
	55	.flags = UNESCAPE_HEX,
	56	},
	57	{
	58	.in = "\\h\\\\\\\"\\a\\e\\",
	59	.out = "\\h\\\"\a\e\\",
	60	.flags = UNESCAPE_SPECIAL,
	61	},
	62	};
	63
45ff337a AS	64	static void __init test_string_unescape(const char *name, unsigned int flags,
45ff337a AS	65	bool inplace)
16c7fa05	66	{
c8250381 AS	67	int q_real = 256;
	68	char *in = kmalloc(q_real, GFP_KERNEL);
	69	char *out_test = kmalloc(q_real, GFP_KERNEL);
	70	char *out_real = kmalloc(q_real, GFP_KERNEL);
	71	int i, p = 0, q_test = 0;
	72
	73	if (!in \|\| !out_test \|\| !out_real)
	74	goto out;
16c7fa05 AS	75
	76	for (i = 0; i < ARRAY_SIZE(strings); i++) {
	77	const char *s = strings[i].in;
	78	int len = strlen(strings[i].in);
	79
	80	/* Copy string to in buffer */
	81	memcpy(&in[p], s, len);
	82	p += len;
	83
	84	/* Copy expected result for given flags */
	85	if (flags & strings[i].flags) {
	86	s = strings[i].out;
	87	len = strlen(strings[i].out);
	88	}
	89	memcpy(&out_test[q_test], s, len);
	90	q_test += len;
	91	}
	92	in[p++] = '\0';
	93
	94	/* Call string_unescape and compare result */
	95	if (inplace) {
	96	memcpy(out_real, in, p);
	97	if (flags == UNESCAPE_ANY)
	98	q_real = string_unescape_any_inplace(out_real);
	99	else
	100	q_real = string_unescape_inplace(out_real, flags);
	101	} else if (flags == UNESCAPE_ANY) {
	102	q_real = string_unescape_any(in, out_real, q_real);
	103	} else {
	104	q_real = string_unescape(in, out_real, q_real, flags);
	105	}
	106
45ff337a AS	107	test_string_check_buf(name, flags, in, p - 1, out_real, q_real,
45ff337a AS	108	out_test, q_test);
c8250381 AS	109	out:
	110	kfree(out_real);
	111	kfree(out_test);
	112	kfree(in);
	113	}
	114
	115	struct test_string_1 {
	116	const char *out;
	117	unsigned int flags;
	118	};
	119
	120	#define TEST_STRING_2_MAX_S1 32
	121	struct test_string_2 {
	122	const char *in;
	123	struct test_string_1 s1[TEST_STRING_2_MAX_S1];
	124	};
	125
	126	#define TEST_STRING_2_DICT_0 NULL
	127	static const struct test_string_2 escape0[] __initconst = {{
	128	.in = "\f\\ \n\r\t\v",
	129	.s1 = {{
	130	.out = "\\f\\ \\n\\r\\t\\v",
	131	.flags = ESCAPE_SPACE,
	132	},{
	133	.out = "\\f\\134\\040\\n\\r\\t\\v",
	134	.flags = ESCAPE_SPACE \| ESCAPE_OCTAL,
	135	},{
	136	.out = "\\f\\x5c\\x20\\n\\r\\t\\v",
	137	.flags = ESCAPE_SPACE \| ESCAPE_HEX,
	138	},{
	139	/* terminator */
69325698	140	}}
c8250381 AS	141	},{
	142	.in = "\\h\\\"\a\e\\",
	143	.s1 = {{
91027d0a	144	.out = "\\\\h\\\\\\\"\\a\\e\\\\",
c8250381 AS	145	.flags = ESCAPE_SPECIAL,
c8250381 AS	146	},{
91027d0a	147	.out = "\\\\\\150\\\\\\\"\\a\\e\\\\",
c8250381 AS	148	.flags = ESCAPE_SPECIAL \| ESCAPE_OCTAL,
c8250381 AS	149	},{
91027d0a	150	.out = "\\\\\\x68\\\\\\\"\\a\\e\\\\",
c8250381 AS	151	.flags = ESCAPE_SPECIAL \| ESCAPE_HEX,
	152	},{
	153	/* terminator */
69325698	154	}}
c8250381 AS	155	},{
	156	.in = "\eb \\C\007\"\x90\r]",
	157	.s1 = {{
	158	.out = "\eb \\C\007\"\x90\\r]",
	159	.flags = ESCAPE_SPACE,
	160	},{
91027d0a	161	.out = "\\eb \\\\C\\a\\\"\x90\r]",
c8250381 AS	162	.flags = ESCAPE_SPECIAL,
c8250381 AS	163	},{
91027d0a	164	.out = "\\eb \\\\C\\a\\\"\x90\\r]",
c8250381 AS	165	.flags = ESCAPE_SPACE \| ESCAPE_SPECIAL,
	166	},{
	167	.out = "\\033\\142\\040\\134\\103\\007\\042\\220\\015\\135",
	168	.flags = ESCAPE_OCTAL,
	169	},{
	170	.out = "\\033\\142\\040\\134\\103\\007\\042\\220\\r\\135",
	171	.flags = ESCAPE_SPACE \| ESCAPE_OCTAL,
	172	},{
91027d0a	173	.out = "\\e\\142\\040\\\\\\103\\a\\\"\\220\\015\\135",
c8250381 AS	174	.flags = ESCAPE_SPECIAL \| ESCAPE_OCTAL,
c8250381 AS	175	},{
91027d0a	176	.out = "\\e\\142\\040\\\\\\103\\a\\\"\\220\\r\\135",
c8250381 AS	177	.flags = ESCAPE_SPACE \| ESCAPE_SPECIAL \| ESCAPE_OCTAL,
	178	},{
	179	.out = "\eb \\C\007\"\x90\r]",
	180	.flags = ESCAPE_NP,
	181	},{
	182	.out = "\eb \\C\007\"\x90\\r]",
	183	.flags = ESCAPE_SPACE \| ESCAPE_NP,
	184	},{
	185	.out = "\\eb \\C\\a\"\x90\r]",
	186	.flags = ESCAPE_SPECIAL \| ESCAPE_NP,
	187	},{
	188	.out = "\\eb \\C\\a\"\x90\\r]",
	189	.flags = ESCAPE_SPACE \| ESCAPE_SPECIAL \| ESCAPE_NP,
	190	},{
	191	.out = "\\033b \\C\\007\"\\220\\015]",
	192	.flags = ESCAPE_OCTAL \| ESCAPE_NP,
	193	},{
	194	.out = "\\033b \\C\\007\"\\220\\r]",
	195	.flags = ESCAPE_SPACE \| ESCAPE_OCTAL \| ESCAPE_NP,
	196	},{
	197	.out = "\\eb \\C\\a\"\\220\\r]",
	198	.flags = ESCAPE_SPECIAL \| ESCAPE_SPACE \| ESCAPE_OCTAL \|
	199	ESCAPE_NP,
	200	},{
	201	.out = "\\x1bb \\C\\x07\"\\x90\\x0d]",
	202	.flags = ESCAPE_NP \| ESCAPE_HEX,
	203	},{
	204	/* terminator */
69325698	205	}}
259fa5d7 AS	206	},{
	207	.in = "\007 \eb\"\x90\xCF\r",
	208	.s1 = {{
	209	.out = "\007 \eb\"\\220\\317\r",
	210	.flags = ESCAPE_OCTAL \| ESCAPE_NA,
	211	},{
	212	.out = "\007 \eb\"\\x90\\xcf\r",
	213	.flags = ESCAPE_HEX \| ESCAPE_NA,
	214	},{
	215	.out = "\007 \eb\"\x90\xCF\r",
	216	.flags = ESCAPE_NA,
	217	},{
	218	/* terminator */
	219	}}
c8250381 AS	220	},{
	221	/* terminator */
	222	}};
	223
259fa5d7	224	#define TEST_STRING_2_DICT_1 "b\\ \t\r\xCF"
c8250381 AS	225	static const struct test_string_2 escape1[] __initconst = {{
	226	.in = "\f\\ \n\r\t\v",
	227	.s1 = {{
	228	.out = "\f\\134\\040\n\\015\\011\v",
	229	.flags = ESCAPE_OCTAL,
	230	},{
	231	.out = "\f\\x5c\\x20\n\\x0d\\x09\v",
	232	.flags = ESCAPE_HEX,
259fa5d7 AS	233	},{
	234	.out = "\f\\134\\040\n\\015\\011\v",
	235	.flags = ESCAPE_ANY \| ESCAPE_APPEND,
	236	},{
	237	.out = "\\014\\134\\040\\012\\015\\011\\013",
	238	.flags = ESCAPE_OCTAL \| ESCAPE_APPEND \| ESCAPE_NAP,
	239	},{
	240	.out = "\\x0c\\x5c\\x20\\x0a\\x0d\\x09\\x0b",
	241	.flags = ESCAPE_HEX \| ESCAPE_APPEND \| ESCAPE_NAP,
	242	},{
	243	.out = "\f\\134\\040\n\\015\\011\v",
	244	.flags = ESCAPE_OCTAL \| ESCAPE_APPEND \| ESCAPE_NA,
	245	},{
	246	.out = "\f\\x5c\\x20\n\\x0d\\x09\v",
	247	.flags = ESCAPE_HEX \| ESCAPE_APPEND \| ESCAPE_NA,
c8250381 AS	248	},{
c8250381 AS	249	/* terminator */
69325698	250	}}
c8250381	251	},{
259fa5d7	252	.in = "\\h\\\"\a\xCF\e\\",
c8250381	253	.s1 = {{
259fa5d7	254	.out = "\\134h\\134\"\a\\317\e\\134",
c8250381	255	.flags = ESCAPE_OCTAL,
259fa5d7 AS	256	},{
	257	.out = "\\134h\\134\"\a\\317\e\\134",
	258	.flags = ESCAPE_ANY \| ESCAPE_APPEND,
	259	},{
	260	.out = "\\134h\\134\"\\007\\317\\033\\134",
	261	.flags = ESCAPE_OCTAL \| ESCAPE_APPEND \| ESCAPE_NAP,
	262	},{
	263	.out = "\\134h\\134\"\a\\317\e\\134",
	264	.flags = ESCAPE_OCTAL \| ESCAPE_APPEND \| ESCAPE_NA,
c8250381 AS	265	},{
c8250381 AS	266	/* terminator */
69325698	267	}}
c8250381 AS	268	},{
	269	.in = "\eb \\C\007\"\x90\r]",
	270	.s1 = {{
	271	.out = "\e\\142\\040\\134C\007\"\x90\\015]",
	272	.flags = ESCAPE_OCTAL,
	273	},{
	274	/* terminator */
69325698	275	}}
259fa5d7 AS	276	},{
	277	.in = "\007 \eb\"\x90\xCF\r",
	278	.s1 = {{
	279	.out = "\007 \eb\"\x90\xCF\r",
	280	.flags = ESCAPE_NA,
	281	},{
	282	.out = "\007 \eb\"\x90\xCF\r",
	283	.flags = ESCAPE_SPACE \| ESCAPE_NA,
	284	},{
	285	.out = "\007 \eb\"\x90\xCF\r",
	286	.flags = ESCAPE_SPECIAL \| ESCAPE_NA,
	287	},{
	288	.out = "\007 \eb\"\x90\xCF\r",
	289	.flags = ESCAPE_SPACE \| ESCAPE_SPECIAL \| ESCAPE_NA,
	290	},{
	291	.out = "\007 \eb\"\x90\\317\r",
	292	.flags = ESCAPE_OCTAL \| ESCAPE_NA,
	293	},{
	294	.out = "\007 \eb\"\x90\\317\r",
	295	.flags = ESCAPE_SPACE \| ESCAPE_OCTAL \| ESCAPE_NA,
	296	},{
	297	.out = "\007 \eb\"\x90\\317\r",
	298	.flags = ESCAPE_SPECIAL \| ESCAPE_OCTAL \| ESCAPE_NA,
	299	},{
	300	.out = "\007 \eb\"\x90\\317\r",
	301	.flags = ESCAPE_ANY \| ESCAPE_NA,
	302	},{
	303	.out = "\007 \eb\"\x90\\xcf\r",
	304	.flags = ESCAPE_HEX \| ESCAPE_NA,
	305	},{
	306	.out = "\007 \eb\"\x90\\xcf\r",
	307	.flags = ESCAPE_SPACE \| ESCAPE_HEX \| ESCAPE_NA,
	308	},{
	309	.out = "\007 \eb\"\x90\\xcf\r",
	310	.flags = ESCAPE_SPECIAL \| ESCAPE_HEX \| ESCAPE_NA,
	311	},{
	312	.out = "\007 \eb\"\x90\\xcf\r",
	313	.flags = ESCAPE_SPACE \| ESCAPE_SPECIAL \| ESCAPE_HEX \| ESCAPE_NA,
	314	},{
	315	/* terminator */
	316	}}
	317	},{
	318	.in = "\007 \eb\"\x90\xCF\r",
	319	.s1 = {{
	320	.out = "\007 \eb\"\x90\xCF\r",
	321	.flags = ESCAPE_NAP,
	322	},{
	323	.out = "\007 \eb\"\x90\xCF\\r",
	324	.flags = ESCAPE_SPACE \| ESCAPE_NAP,
	325	},{
	326	.out = "\007 \eb\"\x90\xCF\r",
	327	.flags = ESCAPE_SPECIAL \| ESCAPE_NAP,
	328	},{
	329	.out = "\007 \eb\"\x90\xCF\\r",
	330	.flags = ESCAPE_SPACE \| ESCAPE_SPECIAL \| ESCAPE_NAP,
	331	},{
	332	.out = "\007 \eb\"\x90\\317\\015",
	333	.flags = ESCAPE_OCTAL \| ESCAPE_NAP,
	334	},{
	335	.out = "\007 \eb\"\x90\\317\\r",
	336	.flags = ESCAPE_SPACE \| ESCAPE_OCTAL \| ESCAPE_NAP,
	337	},{
	338	.out = "\007 \eb\"\x90\\317\\015",
	339	.flags = ESCAPE_SPECIAL \| ESCAPE_OCTAL \| ESCAPE_NAP,
340	},{
341	.out = "\007 \eb\"\x90\\317\r",
342	.flags = ESCAPE_ANY \| ESCAPE_NAP,
343	},{
344	.out = "\007 \eb\"\x90\\xcf\\x0d",
345	.flags = ESCAPE_HEX \| ESCAPE_NAP,
346	},{
347	.out = "\007 \eb\"\x90\\xcf\\r",
348	.flags = ESCAPE_SPACE \| ESCAPE_HEX \| ESCAPE_NAP,
349	},{
350	.out = "\007 \eb\"\x90\\xcf\\x0d",
351	.flags = ESCAPE_SPECIAL \| ESCAPE_HEX \| ESCAPE_NAP,
352	},{
353	.out = "\007 \eb\"\x90\\xcf\\r",
354	.flags = ESCAPE_SPACE \| ESCAPE_SPECIAL \| ESCAPE_HEX \| ESCAPE_NAP,
355	},{
356	/* terminator */
357	}}
c8250381 AS	358	},{
	359	/* terminator */
	360	}};
	361
1e0f548b VP	362	static const struct test_string strings_upper[] __initconst = {
	363	{
	364	.in = "abcdefgh1234567890test",
	365	.out = "ABCDEFGH1234567890TEST",
	366	},
	367	{
	368	.in = "abCdeFgH1234567890TesT",
	369	.out = "ABCDEFGH1234567890TEST",
	370	},
	371	};
	372
	373	static const struct test_string strings_lower[] __initconst = {
	374	{
	375	.in = "ABCDEFGH1234567890TEST",
	376	.out = "abcdefgh1234567890test",
	377	},
	378	{
	379	.in = "abCdeFgH1234567890TesT",
	380	.out = "abcdefgh1234567890test",
	381	},
	382	};
	383
c8250381 AS	384	static __init const char test_string_find_match(const struct test_string_2 s2,
	385	unsigned int flags)
	386	{
	387	const struct test_string_1 *s1 = s2->s1;
	388	unsigned int i;
	389
	390	if (!flags)
	391	return s2->in;
	392
	393	/* Test cases are NULL-aware */
	394	flags &= ~ESCAPE_NULL;
	395
	396	/* ESCAPE_OCTAL has a higher priority */
	397	if (flags & ESCAPE_OCTAL)
	398	flags &= ~ESCAPE_HEX;
	399
	400	for (i = 0; i < TEST_STRING_2_MAX_S1 && s1->out; i++, s1++)
	401	if (s1->flags == flags)
	402	return s1->out;
	403	return NULL;
	404	}
	405
41416f23 RV	406	static __init void
	407	test_string_escape_overflow(const char in, int p, unsigned int flags, const char esc,
	408	int q_test, const char *name)
	409	{
	410	int q_real;
	411
	412	q_real = string_escape_mem(in, p, NULL, 0, flags, esc);
	413	if (q_real != q_test)
229563b1	414	pr_warn("Test '%s' failed: flags = %#x, osz = 0, expected %d, got %d\n",
41416f23 RV	415	name, flags, q_test, q_real);
	416	}
	417
c8250381 AS	418	static __init void test_string_escape(const char *name,
	419	const struct test_string_2 *s2,
	420	unsigned int flags, const char *esc)
	421	{
41416f23 RV	422	size_t out_size = 512;
	423	char *out_test = kmalloc(out_size, GFP_KERNEL);
	424	char *out_real = kmalloc(out_size, GFP_KERNEL);
c8250381	425	char *in = kmalloc(256, GFP_KERNEL);
c8250381	426	int p = 0, q_test = 0;
41416f23	427	int q_real;
c8250381 AS	428
	429	if (!out_test \|\| !out_real \|\| !in)
	430	goto out;
	431
	432	for (; s2->in; s2++) {
	433	const char *out;
	434	int len;
	435
	436	/* NULL injection */
	437	if (flags & ESCAPE_NULL) {
	438	in[p++] = '\0';
259fa5d7 AS	439	/* '\0' passes isascii() test */
	440	if (flags & ESCAPE_NA && !(flags & ESCAPE_APPEND && esc)) {
	441	out_test[q_test++] = '\0';
	442	} else {
	443	out_test[q_test++] = '\\';
	444	out_test[q_test++] = '0';
	445	}
c8250381 AS	446	}
	447
	448	/* Don't try strings that have no output */
	449	out = test_string_find_match(s2, flags);
	450	if (!out)
	451	continue;
	452
	453	/* Copy string to in buffer */
	454	len = strlen(s2->in);
	455	memcpy(&in[p], s2->in, len);
	456	p += len;
	457
	458	/* Copy expected result for given flags */
	459	len = strlen(out);
	460	memcpy(&out_test[q_test], out, len);
	461	q_test += len;
	462	}
	463
41416f23	464	q_real = string_escape_mem(in, p, out_real, out_size, flags, esc);
c8250381 AS	465
	466	test_string_check_buf(name, flags, in, p, out_real, q_real, out_test,
	467	q_test);
41416f23 RV	468
	469	test_string_escape_overflow(in, p, flags, esc, q_test, name);
	470
c8250381 AS	471	out:
	472	kfree(in);
	473	kfree(out_real);
	474	kfree(out_test);
	475	}
	476
943ba650	477	#define string_get_size_maxbuf 16
72676bb5	478	#define test_string_get_size_one(size, blk_size, exp_result10, exp_result2) \
943ba650	479	do { \
72676bb5 VK	480	BUILD_BUG_ON(sizeof(exp_result10) >= string_get_size_maxbuf); \
	481	BUILD_BUG_ON(sizeof(exp_result2) >= string_get_size_maxbuf); \
	482	__test_string_get_size((size), (blk_size), (exp_result10), \
	483	(exp_result2)); \
943ba650 VK	484	} while (0)
	485
	486
72676bb5 VK	487	static __init void test_string_get_size_check(const char *units,
	488	const char *exp,
	489	char *res,
	490	const u64 size,
	491	const u64 blk_size)
943ba650	492	{
72676bb5	493	if (!memcmp(res, exp, strlen(exp) + 1))
943ba650 VK	494	return;
943ba650 VK	495
72676bb5 VK	496	res[string_get_size_maxbuf - 1] = '\0';
	497
	498	pr_warn("Test 'test_string_get_size' failed!\n");
	499	pr_warn("string_get_size(size = %llu, blk_size = %llu, units = %s)\n",
943ba650	500	size, blk_size, units);
72676bb5 VK	501	pr_warn("expected: '%s', got '%s'\n", exp, res);
	502	}
	503
f0b7f8ad AS	504	static __init void __strchrcut(char dst, const char src, const char *cut)
	505	{
	506	const char *from = src;
	507	size_t len;
	508
	509	do {
	510	len = strcspn(from, cut);
	511	memcpy(dst, from, len);
	512	dst += len;
	513	from += len;
	514	} while (*from++);
	515	*dst = '\0';
	516	}
	517
	518	static __init void __test_string_get_size_one(const u64 size, const u64 blk_size,
	519	const char *exp_result10,
	520	const char *exp_result2,
	521	enum string_size_units units,
	522	const char *cut)
72676bb5 VK	523	{
	524	char buf10[string_get_size_maxbuf];
	525	char buf2[string_get_size_maxbuf];
f0b7f8ad AS	526	char exp10[string_get_size_maxbuf];
	527	char exp2[string_get_size_maxbuf];
	528	char prefix10[64];
	529	char prefix2[64];
	530
	531	sprintf(prefix10, "STRING_UNITS_10 [%s]", cut);
	532	sprintf(prefix2, "STRING_UNITS_2 [%s]", cut);
72676bb5	533
f0b7f8ad AS	534	__strchrcut(exp10, exp_result10, cut);
f0b7f8ad AS	535	__strchrcut(exp2, exp_result2, cut);
72676bb5	536
f0b7f8ad AS	537	string_get_size(size, blk_size, STRING_UNITS_10 \| units, buf10, sizeof(buf10));
f0b7f8ad AS	538	string_get_size(size, blk_size, STRING_UNITS_2 \| units, buf2, sizeof(buf2));
72676bb5	539
f0b7f8ad AS	540	test_string_get_size_check(prefix10, exp10, buf10, size, blk_size);
	541	test_string_get_size_check(prefix2, exp2, buf2, size, blk_size);
	542	}
	543
	544	static __init void __test_string_get_size(const u64 size, const u64 blk_size,
	545	const char *exp_result10,
	546	const char *exp_result2)
	547	{
	548	struct {
	549	enum string_size_units units;
	550	const char *cut;
	551	} get_size_test_cases[] = {
	552	{ 0, "" },
	553	{ STRING_UNITS_NO_SPACE, " " },
	554	{ STRING_UNITS_NO_SPACE \| STRING_UNITS_NO_BYTES, " B" },
	555	{ STRING_UNITS_NO_BYTES, "B" },
	556	};
	557	int i;
	558
	559	for (i = 0; i < ARRAY_SIZE(get_size_test_cases); i++)
	560	__test_string_get_size_one(size, blk_size, exp_result10, exp_result2,
	561	get_size_test_cases[i].units,
	562	get_size_test_cases[i].cut);
943ba650 VK	563	}
	564
	565	static __init void test_string_get_size(void)
	566	{
72676bb5 VK	567	/* small values */
	568	test_string_get_size_one(0, 512, "0 B", "0 B");
	569	test_string_get_size_one(1, 512, "512 B", "512 B");
	570	test_string_get_size_one(1100, 1, "1.10 kB", "1.07 KiB");
	571
	572	/* normal values */
	573	test_string_get_size_one(16384, 512, "8.39 MB", "8.00 MiB");
	574	test_string_get_size_one(500118192, 512, "256 GB", "238 GiB");
	575	test_string_get_size_one(8192, 4096, "33.6 MB", "32.0 MiB");
	576
	577	/* weird block sizes */
	578	test_string_get_size_one(3000, 1900, "5.70 MB", "5.44 MiB");
	579
	580	/* huge values */
	581	test_string_get_size_one(U64_MAX, 4096, "75.6 ZB", "64.0 ZiB");
	582	test_string_get_size_one(4096, U64_MAX, "75.6 ZB", "64.0 ZiB");
943ba650 VK	583	}
943ba650 VK	584
1e0f548b VP	585	static void __init test_string_upper_lower(void)
	586	{
	587	char *dst;
	588	int i;
	589
	590	for (i = 0; i < ARRAY_SIZE(strings_upper); i++) {
	591	const char *s = strings_upper[i].in;
	592	int len = strlen(strings_upper[i].in) + 1;
	593
	594	dst = kmalloc(len, GFP_KERNEL);
	595	if (!dst)
	596	return;
	597
	598	string_upper(dst, s);
	599	if (memcmp(dst, strings_upper[i].out, len)) {
	600	pr_warn("Test 'string_upper' failed : expected %s, got %s!\n",
	601	strings_upper[i].out, dst);
	602	kfree(dst);
	603	return;
	604	}
	605	kfree(dst);
	606	}
	607
	608	for (i = 0; i < ARRAY_SIZE(strings_lower); i++) {
	609	const char *s = strings_lower[i].in;
	610	int len = strlen(strings_lower[i].in) + 1;
	611
	612	dst = kmalloc(len, GFP_KERNEL);
	613	if (!dst)
	614	return;
	615
	616	string_lower(dst, s);
	617	if (memcmp(dst, strings_lower[i].out, len)) {
	618	pr_warn("Test 'string_lower failed : : expected %s, got %s!\n",
	619	strings_lower[i].out, dst);
	620	kfree(dst);
	621	return;
	622	}
	623	kfree(dst);
	624	}
	625	}
	626
16c7fa05 AS	627	static int __init test_string_helpers_init(void)
	628	{
	629	unsigned int i;
	630
	631	pr_info("Running tests...\n");
259fa5d7	632	for (i = 0; i < UNESCAPE_ALL_MASK + 1; i++)
45ff337a AS	633	test_string_unescape("unescape", i, false);
45ff337a AS	634	test_string_unescape("unescape inplace",
ef55ef3e	635	get_random_u32_below(UNESCAPE_ALL_MASK + 1), true);
16c7fa05	636
c8250381	637	/* Without dictionary */
259fa5d7	638	for (i = 0; i < ESCAPE_ALL_MASK + 1; i++)
c8250381 AS	639	test_string_escape("escape 0", escape0, i, TEST_STRING_2_DICT_0);
	640
	641	/* With dictionary */
259fa5d7	642	for (i = 0; i < ESCAPE_ALL_MASK + 1; i++)
c8250381 AS	643	test_string_escape("escape 1", escape1, i, TEST_STRING_2_DICT_1);
c8250381 AS	644
943ba650 VK	645	/* Test string_get_size() */
	646	test_string_get_size();
	647
1e0f548b VP	648	/* Test string upper(), string_lower() */
	649	test_string_upper_lower();
	650
16c7fa05 AS	651	return -EINVAL;
	652	}
	653	module_init(test_string_helpers_init);
	654	MODULE_LICENSE("Dual BSD/GPL");