[GitHub/mt8127/android_kernel_alcatel_ttab.git] / lib / test-kstrtox.c

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>

#define for_each_test(i, test)	\
	for (i = 0; i < sizeof(test) / sizeof(test[0]); i++)

struct test_fail {
	const char *str;
	unsigned int base;
};

#define DEFINE_TEST_FAIL(test)	\
	const struct test_fail test[] __initconst

#define DECLARE_TEST_OK(type, test_type)	\
	test_type {				\
		const char *str;		\
		unsigned int base;		\
		type expected_res;		\
	}

#define DEFINE_TEST_OK(type, test)	\
	const type test[] __initconst

#define TEST_FAIL(fn, type, fmt, test)					\
{									\
	unsigned int i;							\
									\
	for_each_test(i, test) {					\
		const struct test_fail *t = &test[i];			\
		type tmp;						\
		int rv;							\
									\
		tmp = 0;						\
		rv = fn(t->str, t->base, &tmp);				\
		if (rv >= 0) {						\
			WARN(1, "str '%s', base %u, expected -E, got %d/" fmt "\n",	\
				t->str, t->base, rv, tmp);		\
			continue;					\
		}							\
	}								\
}

#define TEST_OK(fn, type, fmt, test)					\
{									\
	unsigned int i;							\
									\
	for_each_test(i, test) {					\
		const typeof(test[0]) *t = &test[i];			\
		type res;						\
		int rv;							\
									\
		rv = fn(t->str, t->base, &res);				\
		if (rv != 0) {						\
			WARN(1, "str '%s', base %u, expected 0/" fmt ", got %d\n",	\
				t->str, t->base, t->expected_res, rv);	\
			continue;					\
		}							\
		if (res != t->expected_res) {				\
			WARN(1, "str '%s', base %u, expected " fmt ", got " fmt "\n",	\
				t->str, t->base, t->expected_res, res);	\
			continue;					\
		}							\
	}								\
}

static void __init test_kstrtoull_ok(void)
{
	DECLARE_TEST_OK(unsigned long long, struct test_ull);
	static DEFINE_TEST_OK(struct test_ull, test_ull_ok) = {
		{"0",	10,	0ULL},
		{"1",	10,	1ULL},
		{"127",	10,	127ULL},
		{"128",	10,	128ULL},
		{"129",	10,	129ULL},
		{"255",	10,	255ULL},
		{"256",	10,	256ULL},
		{"257",	10,	257ULL},
		{"32767",	10,	32767ULL},
		{"32768",	10,	32768ULL},
		{"32769",	10,	32769ULL},
		{"65535",	10,	65535ULL},
		{"65536",	10,	65536ULL},
		{"65537",	10,	65537ULL},
		{"2147483647",	10,	2147483647ULL},
		{"2147483648",	10,	2147483648ULL},
		{"2147483649",	10,	2147483649ULL},
		{"4294967295",	10,	4294967295ULL},
		{"4294967296",	10,	4294967296ULL},
		{"4294967297",	10,	4294967297ULL},
		{"9223372036854775807",	10,	9223372036854775807ULL},
		{"9223372036854775808",	10,	9223372036854775808ULL},
		{"9223372036854775809",	10,	9223372036854775809ULL},
		{"18446744073709551614",	10,	18446744073709551614ULL},
		{"18446744073709551615",	10,	18446744073709551615ULL},

		{"00",		8,	00ULL},
		{"01",		8,	01ULL},
		{"0177",	8,	0177ULL},
		{"0200",	8,	0200ULL},
		{"0201",	8,	0201ULL},
		{"0377",	8,	0377ULL},
		{"0400",	8,	0400ULL},
		{"0401",	8,	0401ULL},
		{"077777",	8,	077777ULL},
		{"0100000",	8,	0100000ULL},
		{"0100001",	8,	0100001ULL},
		{"0177777",	8,	0177777ULL},
		{"0200000",	8,	0200000ULL},
		{"0200001",	8,	0200001ULL},
		{"017777777777",	8,	017777777777ULL},
		{"020000000000",	8,	020000000000ULL},
		{"020000000001",	8,	020000000001ULL},
		{"037777777777",	8,	037777777777ULL},
		{"040000000000",	8,	040000000000ULL},
		{"040000000001",	8,	040000000001ULL},
		{"0777777777777777777777",	8,	0777777777777777777777ULL},
		{"01000000000000000000000",	8,	01000000000000000000000ULL},
		{"01000000000000000000001",	8,	01000000000000000000001ULL},
		{"01777777777777777777776",	8,	01777777777777777777776ULL},
		{"01777777777777777777777",	8,	01777777777777777777777ULL},

		{"0x0",		16,	0x0ULL},
		{"0x1",		16,	0x1ULL},
		{"0x7f",	16,	0x7fULL},
		{"0x80",	16,	0x80ULL},
		{"0x81",	16,	0x81ULL},
		{"0xff",	16,	0xffULL},
		{"0x100",	16,	0x100ULL},
		{"0x101",	16,	0x101ULL},
		{"0x7fff",	16,	0x7fffULL},
		{"0x8000",	16,	0x8000ULL},
		{"0x8001",	16,	0x8001ULL},
		{"0xffff",	16,	0xffffULL},
		{"0x10000",	16,	0x10000ULL},
		{"0x10001",	16,	0x10001ULL},
		{"0x7fffffff",	16,	0x7fffffffULL},
		{"0x80000000",	16,	0x80000000ULL},
		{"0x80000001",	16,	0x80000001ULL},
		{"0xffffffff",	16,	0xffffffffULL},
		{"0x100000000",	16,	0x100000000ULL},
		{"0x100000001",	16,	0x100000001ULL},
		{"0x7fffffffffffffff",	16,	0x7fffffffffffffffULL},
		{"0x8000000000000000",	16,	0x8000000000000000ULL},
		{"0x8000000000000001",	16,	0x8000000000000001ULL},
		{"0xfffffffffffffffe",	16,	0xfffffffffffffffeULL},
		{"0xffffffffffffffff",	16,	0xffffffffffffffffULL},

		{"0\n",	0,	0ULL},
	};
	TEST_OK(kstrtoull, unsigned long long, "%llu", test_ull_ok);
}

static void __init test_kstrtoull_fail(void)
{
	static DEFINE_TEST_FAIL(test_ull_fail) = {
		{"",	0},
		{"",	8},
		{"",	10},
		{"",	16},
		{"\n",	0},
		{"\n",	8},
		{"\n",	10},
		{"\n",	16},
		{"\n0",	0},
		{"\n0",	8},
		{"\n0",	10},
		{"\n0",	16},
		{"+",	0},
		{"+",	8},
		{"+",	10},
		{"+",	16},
		{"-",	0},
		{"-",	8},
		{"-",	10},
		{"-",	16},
		{"0x",	0},
		{"0x",	16},
		{"0X",	0},
		{"0X",	16},
		{"0 ",	0},
		{"1+",	0},
		{"1-",	0},
		{" 2",	0},
		/* base autodetection */
		{"0x0z",	0},
		{"0z",		0},
		{"a",		0},
		/* digit >= base */
		{"2",	2},
		{"8",	8},
		{"a",	10},
		{"A",	10},
		{"g",	16},
		{"G",	16},
		/* overflow */
		{"10000000000000000000000000000000000000000000000000000000000000000",	2},
		{"2000000000000000000000",	8},
		{"18446744073709551616",	10},
		{"10000000000000000",	16},
		/* negative */
		{"-0", 0},
		{"-0", 8},
		{"-0", 10},
		{"-0", 16},
		{"-1", 0},
		{"-1", 8},
		{"-1", 10},
		{"-1", 16},
		/* sign is first character if any */
		{"-+1", 0},
		{"-+1", 8},
		{"-+1", 10},
		{"-+1", 16},
		/* nothing after \n */
		{"0\n0", 0},
		{"0\n0", 8},
		{"0\n0", 10},
		{"0\n0", 16},
		{"0\n+", 0},
		{"0\n+", 8},
		{"0\n+", 10},
		{"0\n+", 16},
		{"0\n-", 0},
		{"0\n-", 8},
		{"0\n-", 10},
		{"0\n-", 16},
		{"0\n ", 0},
		{"0\n ", 8},
		{"0\n ", 10},
		{"0\n ", 16},
	};
	TEST_FAIL(kstrtoull, unsigned long long, "%llu", test_ull_fail);
}

static void __init test_kstrtoll_ok(void)
{
	DECLARE_TEST_OK(long long, struct test_ll);
	static DEFINE_TEST_OK(struct test_ll, test_ll_ok) = {
		{"0",	10,	0LL},
		{"1",	10,	1LL},
		{"127",	10,	127LL},
		{"128",	10,	128LL},
		{"129",	10,	129LL},
		{"255",	10,	255LL},
		{"256",	10,	256LL},
		{"257",	10,	257LL},
		{"32767",	10,	32767LL},
		{"32768",	10,	32768LL},
		{"32769",	10,	32769LL},
		{"65535",	10,	65535LL},
		{"65536",	10,	65536LL},
		{"65537",	10,	65537LL},
		{"2147483647",	10,	2147483647LL},
		{"2147483648",	10,	2147483648LL},
		{"2147483649",	10,	2147483649LL},
		{"4294967295",	10,	4294967295LL},
		{"4294967296",	10,	4294967296LL},
		{"4294967297",	10,	4294967297LL},
		{"9223372036854775807",	10,	9223372036854775807LL},

		{"-1",	10,	-1LL},
		{"-2",	10,	-2LL},
		{"-9223372036854775808",	10,	LLONG_MIN},
	};
	TEST_OK(kstrtoll, long long, "%lld", test_ll_ok);
}

static void __init test_kstrtoll_fail(void)
{
	static DEFINE_TEST_FAIL(test_ll_fail) = {
		{"9223372036854775808",	10},
		{"9223372036854775809",	10},
		{"18446744073709551614",	10},
		{"18446744073709551615",	10},
		{"-9223372036854775809",	10},
		{"-18446744073709551614",	10},
		{"-18446744073709551615",	10},
		/* negative zero isn't an integer in Linux */
		{"-0",	0},
		{"-0",	8},
		{"-0",	10},
		{"-0",	16},
		/* sign is first character if any */
		{"-+1", 0},
		{"-+1", 8},
		{"-+1", 10},
		{"-+1", 16},
	};
	TEST_FAIL(kstrtoll, long long, "%lld", test_ll_fail);
}

static void __init test_kstrtou64_ok(void)
{
	DECLARE_TEST_OK(u64, struct test_u64);
	static DEFINE_TEST_OK(struct test_u64, test_u64_ok) = {
		{"0",	10,	0},
		{"1",	10,	1},
		{"126",	10,	126},
		{"127",	10,	127},
		{"128",	10,	128},
		{"129",	10,	129},
		{"254",	10,	254},
		{"255",	10,	255},
		{"256",	10,	256},
		{"257",	10,	257},
		{"32766",	10,	32766},
		{"32767",	10,	32767},
		{"32768",	10,	32768},
		{"32769",	10,	32769},
		{"65534",	10,	65534},
		{"65535",	10,	65535},
		{"65536",	10,	65536},
		{"65537",	10,	65537},
		{"2147483646",	10,	2147483646},
		{"2147483647",	10,	2147483647},
		{"2147483648",	10,	2147483648ULL},
		{"2147483649",	10,	2147483649ULL},
		{"4294967294",	10,	4294967294ULL},
		{"4294967295",	10,	4294967295ULL},
		{"4294967296",	10,	4294967296ULL},
		{"4294967297",	10,	4294967297ULL},
		{"9223372036854775806",	10,	9223372036854775806ULL},
		{"9223372036854775807",	10,	9223372036854775807ULL},
		{"9223372036854775808",	10,	9223372036854775808ULL},
		{"9223372036854775809",	10,	9223372036854775809ULL},
		{"18446744073709551614",	10,	18446744073709551614ULL},
		{"18446744073709551615",	10,	18446744073709551615ULL},
	};
	TEST_OK(kstrtou64, u64, "%llu", test_u64_ok);
}

static void __init test_kstrtou64_fail(void)
{
	static DEFINE_TEST_FAIL(test_u64_fail) = {
		{"-2",	10},
		{"-1",	10},
		{"18446744073709551616",	10},
		{"18446744073709551617",	10},
	};
	TEST_FAIL(kstrtou64, u64, "%llu", test_u64_fail);
}

static void __init test_kstrtos64_ok(void)
{
	DECLARE_TEST_OK(s64, struct test_s64);
	static DEFINE_TEST_OK(struct test_s64, test_s64_ok) = {
		{"-128",	10,	-128},
		{"-127",	10,	-127},
		{"-1",	10,	-1},
		{"0",	10,	0},
		{"1",	10,	1},
		{"126",	10,	126},
		{"127",	10,	127},
		{"128",	10,	128},
		{"129",	10,	129},
		{"254",	10,	254},
		{"255",	10,	255},
		{"256",	10,	256},
		{"257",	10,	257},
		{"32766",	10,	32766},
		{"32767",	10,	32767},
		{"32768",	10,	32768},
		{"32769",	10,	32769},
		{"65534",	10,	65534},
		{"65535",	10,	65535},
		{"65536",	10,	65536},
		{"65537",	10,	65537},
		{"2147483646",	10,	2147483646},
		{"2147483647",	10,	2147483647},
		{"2147483648",	10,	2147483648LL},
		{"2147483649",	10,	2147483649LL},
		{"4294967294",	10,	4294967294LL},
		{"4294967295",	10,	4294967295LL},
		{"4294967296",	10,	4294967296LL},
		{"4294967297",	10,	4294967297LL},
		{"9223372036854775806",	10,	9223372036854775806LL},
		{"9223372036854775807",	10,	9223372036854775807LL},
	};
	TEST_OK(kstrtos64, s64, "%lld", test_s64_ok);
}

static void __init test_kstrtos64_fail(void)
{
	static DEFINE_TEST_FAIL(test_s64_fail) = {
		{"9223372036854775808",	10},
		{"9223372036854775809",	10},
		{"18446744073709551614",	10},
		{"18446744073709551615",	10},
		{"18446744073709551616",	10},
		{"18446744073709551617",	10},
	};
	TEST_FAIL(kstrtos64, s64, "%lld", test_s64_fail);
}

static void __init test_kstrtou32_ok(void)
{
	DECLARE_TEST_OK(u32, struct test_u32);
	static DEFINE_TEST_OK(struct test_u32, test_u32_ok) = {
		{"0",	10,	0},
		{"1",	10,	1},
		{"126",	10,	126},
		{"127",	10,	127},
		{"128",	10,	128},
		{"129",	10,	129},
		{"254",	10,	254},
		{"255",	10,	255},
		{"256",	10,	256},
		{"257",	10,	257},
		{"32766",	10,	32766},
		{"32767",	10,	32767},
		{"32768",	10,	32768},
		{"32769",	10,	32769},
		{"65534",	10,	65534},
		{"65535",	10,	65535},
		{"65536",	10,	65536},
		{"65537",	10,	65537},
		{"2147483646",	10,	2147483646},
		{"2147483647",	10,	2147483647},
		{"2147483648",	10,	2147483648U},
		{"2147483649",	10,	2147483649U},
		{"4294967294",	10,	4294967294U},
		{"4294967295",	10,	4294967295U},
	};
	TEST_OK(kstrtou32, u32, "%u", test_u32_ok);
}

static void __init test_kstrtou32_fail(void)
{
	static DEFINE_TEST_FAIL(test_u32_fail) = {
		{"-2",	10},
		{"-1",	10},
		{"4294967296",	10},
		{"4294967297",	10},
		{"9223372036854775806",	10},
		{"9223372036854775807",	10},
		{"9223372036854775808",	10},
		{"9223372036854775809",	10},
		{"18446744073709551614",	10},
		{"18446744073709551615",	10},
		{"18446744073709551616",	10},
		{"18446744073709551617",	10},
	};
	TEST_FAIL(kstrtou32, u32, "%u", test_u32_fail);
}

static void __init test_kstrtos32_ok(void)
{
	DECLARE_TEST_OK(s32, struct test_s32);
	static DEFINE_TEST_OK(struct test_s32, test_s32_ok) = {
		{"-128",	10,	-128},
		{"-127",	10,	-127},
		{"-1",	10,	-1},
		{"0",	10,	0},
		{"1",	10,	1},
		{"126",	10,	126},
		{"127",	10,	127},
		{"128",	10,	128},
		{"129",	10,	129},
		{"254",	10,	254},
		{"255",	10,	255},
		{"256",	10,	256},
		{"257",	10,	257},
		{"32766",	10,	32766},
		{"32767",	10,	32767},
		{"32768",	10,	32768},
		{"32769",	10,	32769},
		{"65534",	10,	65534},
		{"65535",	10,	65535},
		{"65536",	10,	65536},
		{"65537",	10,	65537},
		{"2147483646",	10,	2147483646},
		{"2147483647",	10,	2147483647},
	};
	TEST_OK(kstrtos32, s32, "%d", test_s32_ok);
}

static void __init test_kstrtos32_fail(void)
{
	static DEFINE_TEST_FAIL(test_s32_fail) = {
		{"2147483648",	10},
		{"2147483649",	10},
		{"4294967294",	10},
		{"4294967295",	10},
		{"4294967296",	10},
		{"4294967297",	10},
		{"9223372036854775806",	10},
		{"9223372036854775807",	10},
		{"9223372036854775808",	10},
		{"9223372036854775809",	10},
		{"18446744073709551614",	10},
		{"18446744073709551615",	10},
		{"18446744073709551616",	10},
		{"18446744073709551617",	10},
	};
	TEST_FAIL(kstrtos32, s32, "%d", test_s32_fail);
}

static void __init test_kstrtou16_ok(void)
{
	DECLARE_TEST_OK(u16, struct test_u16);
	static DEFINE_TEST_OK(struct test_u16, test_u16_ok) = {
		{"0",	10,	0},
		{"1",	10,	1},
		{"126",	10,	126},
		{"127",	10,	127},
		{"128",	10,	128},
		{"129",	10,	129},
		{"254",	10,	254},
		{"255",	10,	255},
		{"256",	10,	256},
		{"257",	10,	257},
		{"32766",	10,	32766},
		{"32767",	10,	32767},
		{"32768",	10,	32768},
		{"32769",	10,	32769},
		{"65534",	10,	65534},
		{"65535",	10,	65535},
	};
	TEST_OK(kstrtou16, u16, "%hu", test_u16_ok);
}

static void __init test_kstrtou16_fail(void)
{
	static DEFINE_TEST_FAIL(test_u16_fail) = {
		{"-2",	10},
		{"-1",	10},
		{"65536",	10},
		{"65537",	10},
		{"2147483646",	10},
		{"2147483647",	10},
		{"2147483648",	10},
		{"2147483649",	10},
		{"4294967294",	10},
		{"4294967295",	10},
		{"4294967296",	10},
		{"4294967297",	10},
		{"9223372036854775806",	10},
		{"9223372036854775807",	10},
		{"9223372036854775808",	10},
		{"9223372036854775809",	10},
		{"18446744073709551614",	10},
		{"18446744073709551615",	10},
		{"18446744073709551616",	10},
		{"18446744073709551617",	10},
	};
	TEST_FAIL(kstrtou16, u16, "%hu", test_u16_fail);
}

static void __init test_kstrtos16_ok(void)
{
	DECLARE_TEST_OK(s16, struct test_s16);
	static DEFINE_TEST_OK(struct test_s16, test_s16_ok) = {
		{"-130",	10,	-130},
		{"-129",	10,	-129},
		{"-128",	10,	-128},
		{"-127",	10,	-127},
		{"-1",	10,	-1},
		{"0",	10,	0},
		{"1",	10,	1},
		{"126",	10,	126},
		{"127",	10,	127},
		{"128",	10,	128},
		{"129",	10,	129},
		{"254",	10,	254},
		{"255",	10,	255},
		{"256",	10,	256},
		{"257",	10,	257},
		{"32766",	10,	32766},
		{"32767",	10,	32767},
	};
	TEST_OK(kstrtos16, s16, "%hd", test_s16_ok);
}

static void __init test_kstrtos16_fail(void)
{
	static DEFINE_TEST_FAIL(test_s16_fail) = {
		{"32768",	10},
		{"32769",	10},
		{"65534",	10},
		{"65535",	10},
		{"65536",	10},
		{"65537",	10},
		{"2147483646",	10},
		{"2147483647",	10},
		{"2147483648",	10},
		{"2147483649",	10},
		{"4294967294",	10},
		{"4294967295",	10},
		{"4294967296",	10},
		{"4294967297",	10},
		{"9223372036854775806",	10},
		{"9223372036854775807",	10},
		{"9223372036854775808",	10},
		{"9223372036854775809",	10},
		{"18446744073709551614",	10},
		{"18446744073709551615",	10},
		{"18446744073709551616",	10},
		{"18446744073709551617",	10},
	};
	TEST_FAIL(kstrtos16, s16, "%hd", test_s16_fail);
}

static void __init test_kstrtou8_ok(void)
{
	DECLARE_TEST_OK(u8, struct test_u8);
	static DEFINE_TEST_OK(struct test_u8, test_u8_ok) = {
		{"0",	10,	0},
		{"1",	10,	1},
		{"126",	10,	126},
		{"127",	10,	127},
		{"128",	10,	128},
		{"129",	10,	129},
		{"254",	10,	254},
		{"255",	10,	255},
	};
	TEST_OK(kstrtou8, u8, "%hhu", test_u8_ok);
}

static void __init test_kstrtou8_fail(void)
{
	static DEFINE_TEST_FAIL(test_u8_fail) = {
		{"-2",	10},
		{"-1",	10},
		{"256",	10},
		{"257",	10},
		{"32766",	10},
		{"32767",	10},
		{"32768",	10},
		{"32769",	10},
		{"65534",	10},
		{"65535",	10},
		{"65536",	10},
		{"65537",	10},
		{"2147483646",	10},
		{"2147483647",	10},
		{"2147483648",	10},
		{"2147483649",	10},
		{"4294967294",	10},
		{"4294967295",	10},
		{"4294967296",	10},
		{"4294967297",	10},
		{"9223372036854775806",	10},
		{"9223372036854775807",	10},
		{"9223372036854775808",	10},
		{"9223372036854775809",	10},
		{"18446744073709551614",	10},
		{"18446744073709551615",	10},
		{"18446744073709551616",	10},
		{"18446744073709551617",	10},
	};
	TEST_FAIL(kstrtou8, u8, "%hhu", test_u8_fail);
}

static void __init test_kstrtos8_ok(void)
{
	DECLARE_TEST_OK(s8, struct test_s8);
	static DEFINE_TEST_OK(struct test_s8, test_s8_ok) = {
		{"-128",	10,	-128},
		{"-127",	10,	-127},
		{"-1",	10,	-1},
		{"0",	10,	0},
		{"1",	10,	1},
		{"126",	10,	126},
		{"127",	10,	127},
	};
	TEST_OK(kstrtos8, s8, "%hhd", test_s8_ok);
}

static void __init test_kstrtos8_fail(void)
{
	static DEFINE_TEST_FAIL(test_s8_fail) = {
		{"-130",	10},
		{"-129",	10},
		{"128",	10},
		{"129",	10},
		{"254",	10},
		{"255",	10},
		{"256",	10},
		{"257",	10},
		{"32766",	10},
		{"32767",	10},
		{"32768",	10},
		{"32769",	10},
		{"65534",	10},
		{"65535",	10},
		{"65536",	10},
		{"65537",	10},
		{"2147483646",	10},
		{"2147483647",	10},
		{"2147483648",	10},
		{"2147483649",	10},
		{"4294967294",	10},
		{"4294967295",	10},
		{"4294967296",	10},
		{"4294967297",	10},
		{"9223372036854775806",	10},
		{"9223372036854775807",	10},
		{"9223372036854775808",	10},
		{"9223372036854775809",	10},
		{"18446744073709551614",	10},
		{"18446744073709551615",	10},
		{"18446744073709551616",	10},
		{"18446744073709551617",	10},
	};
	TEST_FAIL(kstrtos8, s8, "%hhd", test_s8_fail);
}

static int __init test_kstrtox_init(void)
{
	test_kstrtoull_ok();
	test_kstrtoull_fail();
	test_kstrtoll_ok();
	test_kstrtoll_fail();

	test_kstrtou64_ok();
	test_kstrtou64_fail();
	test_kstrtos64_ok();
	test_kstrtos64_fail();

	test_kstrtou32_ok();
	test_kstrtou32_fail();
	test_kstrtos32_ok();
	test_kstrtos32_fail();

	test_kstrtou16_ok();
	test_kstrtou16_fail();
	test_kstrtos16_ok();
	test_kstrtos16_fail();

	test_kstrtou8_ok();
	test_kstrtou8_fail();
	test_kstrtos8_ok();
	test_kstrtos8_fail();
	return -EINVAL;
}
module_init(test_kstrtox_init);
MODULE_LICENSE("Dual BSD/GPL");
Commit	Line	Data
33ee3b2e AD	1	#include <linux/init.h>
	2	#include <linux/kernel.h>
	3	#include <linux/module.h>
	4
	5	#define for_each_test(i, test) \
	6	for (i = 0; i < sizeof(test) / sizeof(test[0]); i++)
	7
	8	struct test_fail {
	9	const char *str;
	10	unsigned int base;
	11	};
	12
	13	#define DEFINE_TEST_FAIL(test) \
26d7b99b	14	const struct test_fail test[] __initconst
33ee3b2e AD	15
	16	#define DECLARE_TEST_OK(type, test_type) \
	17	test_type { \
	18	const char *str; \
	19	unsigned int base; \
	20	type expected_res; \
	21	}
	22
	23	#define DEFINE_TEST_OK(type, test) \
26d7b99b	24	const type test[] __initconst
33ee3b2e AD	25
	26	#define TEST_FAIL(fn, type, fmt, test) \
	27	{ \
	28	unsigned int i; \
	29	\
	30	for_each_test(i, test) { \
	31	const struct test_fail *t = &test[i]; \
	32	type tmp; \
	33	int rv; \
	34	\
	35	tmp = 0; \
	36	rv = fn(t->str, t->base, &tmp); \
	37	if (rv >= 0) { \
	38	WARN(1, "str '%s', base %u, expected -E, got %d/" fmt "\n", \
	39	t->str, t->base, rv, tmp); \
	40	continue; \
	41	} \
	42	} \
	43	}
	44
	45	#define TEST_OK(fn, type, fmt, test) \
	46	{ \
	47	unsigned int i; \
	48	\
	49	for_each_test(i, test) { \
	50	const typeof(test[0]) *t = &test[i]; \
	51	type res; \
	52	int rv; \
	53	\
	54	rv = fn(t->str, t->base, &res); \
	55	if (rv != 0) { \
	56	WARN(1, "str '%s', base %u, expected 0/" fmt ", got %d\n", \
	57	t->str, t->base, t->expected_res, rv); \
	58	continue; \
	59	} \
	60	if (res != t->expected_res) { \
	61	WARN(1, "str '%s', base %u, expected " fmt ", got " fmt "\n", \
	62	t->str, t->base, t->expected_res, res); \
	63	continue; \
	64	} \
	65	} \
	66	}
	67
	68	static void __init test_kstrtoull_ok(void)
	69	{
	70	DECLARE_TEST_OK(unsigned long long, struct test_ull);
	71	static DEFINE_TEST_OK(struct test_ull, test_ull_ok) = {
	72	{"0", 10, 0ULL},
	73	{"1", 10, 1ULL},
	74	{"127", 10, 127ULL},
	75	{"128", 10, 128ULL},
	76	{"129", 10, 129ULL},
	77	{"255", 10, 255ULL},
	78	{"256", 10, 256ULL},
	79	{"257", 10, 257ULL},
	80	{"32767", 10, 32767ULL},
	81	{"32768", 10, 32768ULL},
	82	{"32769", 10, 32769ULL},
	83	{"65535", 10, 65535ULL},
	84	{"65536", 10, 65536ULL},
	85	{"65537", 10, 65537ULL},
	86	{"2147483647", 10, 2147483647ULL},
	87	{"2147483648", 10, 2147483648ULL},
	88	{"2147483649", 10, 2147483649ULL},
89	{"4294967295", 10, 4294967295ULL},
90	{"4294967296", 10, 4294967296ULL},
91	{"4294967297", 10, 4294967297ULL},
92	{"9223372036854775807", 10, 9223372036854775807ULL},
93	{"9223372036854775808", 10, 9223372036854775808ULL},
94	{"9223372036854775809", 10, 9223372036854775809ULL},
95	{"18446744073709551614", 10, 18446744073709551614ULL},
96	{"18446744073709551615", 10, 18446744073709551615ULL},
97
98	{"00", 8, 00ULL},
99	{"01", 8, 01ULL},
100	{"0177", 8, 0177ULL},
101	{"0200", 8, 0200ULL},
102	{"0201", 8, 0201ULL},
103	{"0377", 8, 0377ULL},
104	{"0400", 8, 0400ULL},
105	{"0401", 8, 0401ULL},
106	{"077777", 8, 077777ULL},
107	{"0100000", 8, 0100000ULL},
108	{"0100001", 8, 0100001ULL},
109	{"0177777", 8, 0177777ULL},
110	{"0200000", 8, 0200000ULL},
111	{"0200001", 8, 0200001ULL},
112	{"017777777777", 8, 017777777777ULL},
113	{"020000000000", 8, 020000000000ULL},
114	{"020000000001", 8, 020000000001ULL},
115	{"037777777777", 8, 037777777777ULL},
116	{"040000000000", 8, 040000000000ULL},
117	{"040000000001", 8, 040000000001ULL},
118	{"0777777777777777777777", 8, 0777777777777777777777ULL},
119	{"01000000000000000000000", 8, 01000000000000000000000ULL},
120	{"01000000000000000000001", 8, 01000000000000000000001ULL},
121	{"01777777777777777777776", 8, 01777777777777777777776ULL},
122	{"01777777777777777777777", 8, 01777777777777777777777ULL},
123
124	{"0x0", 16, 0x0ULL},
125	{"0x1", 16, 0x1ULL},
126	{"0x7f", 16, 0x7fULL},
127	{"0x80", 16, 0x80ULL},
128	{"0x81", 16, 0x81ULL},
129	{"0xff", 16, 0xffULL},
130	{"0x100", 16, 0x100ULL},
131	{"0x101", 16, 0x101ULL},
132	{"0x7fff", 16, 0x7fffULL},
133	{"0x8000", 16, 0x8000ULL},
134	{"0x8001", 16, 0x8001ULL},
135	{"0xffff", 16, 0xffffULL},
136	{"0x10000", 16, 0x10000ULL},
137	{"0x10001", 16, 0x10001ULL},
138	{"0x7fffffff", 16, 0x7fffffffULL},
139	{"0x80000000", 16, 0x80000000ULL},
140	{"0x80000001", 16, 0x80000001ULL},
141	{"0xffffffff", 16, 0xffffffffULL},
142	{"0x100000000", 16, 0x100000000ULL},
143	{"0x100000001", 16, 0x100000001ULL},
144	{"0x7fffffffffffffff", 16, 0x7fffffffffffffffULL},
145	{"0x8000000000000000", 16, 0x8000000000000000ULL},
146	{"0x8000000000000001", 16, 0x8000000000000001ULL},
147	{"0xfffffffffffffffe", 16, 0xfffffffffffffffeULL},
148	{"0xffffffffffffffff", 16, 0xffffffffffffffffULL},
149
150	{"0\n", 0, 0ULL},
151	};
152	TEST_OK(kstrtoull, unsigned long long, "%llu", test_ull_ok);
153	}
154
155	static void __init test_kstrtoull_fail(void)
156	{
157	static DEFINE_TEST_FAIL(test_ull_fail) = {
158	{"", 0},
159	{"", 8},
160	{"", 10},
161	{"", 16},
162	{"\n", 0},
163	{"\n", 8},
164	{"\n", 10},
165	{"\n", 16},
166	{"\n0", 0},
167	{"\n0", 8},
168	{"\n0", 10},
169	{"\n0", 16},
170	{"+", 0},
171	{"+", 8},
172	{"+", 10},
173	{"+", 16},
174	{"-", 0},
175	{"-", 8},
176	{"-", 10},
177	{"-", 16},
178	{"0x", 0},
179	{"0x", 16},
180	{"0X", 0},
181	{"0X", 16},
182	{"0 ", 0},
183	{"1+", 0},
184	{"1-", 0},
185	{" 2", 0},
186	/* base autodetection */
187	{"0x0z", 0},
188	{"0z", 0},
189	{"a", 0},
190	/* digit >= base */
191	{"2", 2},
192	{"8", 8},
193	{"a", 10},
194	{"A", 10},
195	{"g", 16},
196	{"G", 16},
197	/* overflow */
198	{"10000000000000000000000000000000000000000000000000000000000000000", 2},
199	{"2000000000000000000000", 8},
200	{"18446744073709551616", 10},
201	{"10000000000000000", 16},
202	/* negative */
203	{"-0", 0},
204	{"-0", 8},
205	{"-0", 10},
206	{"-0", 16},
207	{"-1", 0},
208	{"-1", 8},
209	{"-1", 10},
210	{"-1", 16},
211	/* sign is first character if any */
212	{"-+1", 0},
213	{"-+1", 8},
214	{"-+1", 10},
215	{"-+1", 16},
216	/* nothing after \n */
217	{"0\n0", 0},
218	{"0\n0", 8},
219	{"0\n0", 10},
220	{"0\n0", 16},
221	{"0\n+", 0},
222	{"0\n+", 8},
223	{"0\n+", 10},
224	{"0\n+", 16},
225	{"0\n-", 0},
226	{"0\n-", 8},
227	{"0\n-", 10},
228	{"0\n-", 16},
229	{"0\n ", 0},
230	{"0\n ", 8},
231	{"0\n ", 10},
232	{"0\n ", 16},
233	};
234	TEST_FAIL(kstrtoull, unsigned long long, "%llu", test_ull_fail);
235	}
236
237	static void __init test_kstrtoll_ok(void)
238	{
239	DECLARE_TEST_OK(long long, struct test_ll);
240	static DEFINE_TEST_OK(struct test_ll, test_ll_ok) = {
241	{"0", 10, 0LL},
242	{"1", 10, 1LL},
243	{"127", 10, 127LL},
244	{"128", 10, 128LL},
245	{"129", 10, 129LL},
246	{"255", 10, 255LL},
247	{"256", 10, 256LL},
248	{"257", 10, 257LL},
249	{"32767", 10, 32767LL},
250	{"32768", 10, 32768LL},
251	{"32769", 10, 32769LL},
252	{"65535", 10, 65535LL},
253	{"65536", 10, 65536LL},
254	{"65537", 10, 65537LL},
255	{"2147483647", 10, 2147483647LL},
256	{"2147483648", 10, 2147483648LL},
257	{"2147483649", 10, 2147483649LL},
258	{"4294967295", 10, 4294967295LL},
259	{"4294967296", 10, 4294967296LL},
260	{"4294967297", 10, 4294967297LL},
261	{"9223372036854775807", 10, 9223372036854775807LL},
262
263	{"-1", 10, -1LL},
264	{"-2", 10, -2LL},
265	{"-9223372036854775808", 10, LLONG_MIN},
266	};
267	TEST_OK(kstrtoll, long long, "%lld", test_ll_ok);
268	}
269
270	static void __init test_kstrtoll_fail(void)
271	{
272	static DEFINE_TEST_FAIL(test_ll_fail) = {
273	{"9223372036854775808", 10},
274	{"9223372036854775809", 10},
275	{"18446744073709551614", 10},
276	{"18446744073709551615", 10},
277	{"-9223372036854775809", 10},
278	{"-18446744073709551614", 10},
279	{"-18446744073709551615", 10},
280	/* negative zero isn't an integer in Linux */
281	{"-0", 0},
282	{"-0", 8},
283	{"-0", 10},
284	{"-0", 16},
285	/* sign is first character if any */
286	{"-+1", 0},
287	{"-+1", 8},
288	{"-+1", 10},
289	{"-+1", 16},
290	};
291	TEST_FAIL(kstrtoll, long long, "%lld", test_ll_fail);
292	}
293
294	static void __init test_kstrtou64_ok(void)
295	{
296	DECLARE_TEST_OK(u64, struct test_u64);
297	static DEFINE_TEST_OK(struct test_u64, test_u64_ok) = {
298	{"0", 10, 0},
299	{"1", 10, 1},
300	{"126", 10, 126},
301	{"127", 10, 127},
302	{"128", 10, 128},
303	{"129", 10, 129},
304	{"254", 10, 254},
305	{"255", 10, 255},
306	{"256", 10, 256},
307	{"257", 10, 257},
308	{"32766", 10, 32766},
309	{"32767", 10, 32767},
310	{"32768", 10, 32768},
311	{"32769", 10, 32769},
312	{"65534", 10, 65534},
313	{"65535", 10, 65535},
314	{"65536", 10, 65536},
315	{"65537", 10, 65537},
316	{"2147483646", 10, 2147483646},
317	{"2147483647", 10, 2147483647},
01eda2e0 AD	318	{"2147483648", 10, 2147483648ULL},
	319	{"2147483649", 10, 2147483649ULL},
	320	{"4294967294", 10, 4294967294ULL},
	321	{"4294967295", 10, 4294967295ULL},
	322	{"4294967296", 10, 4294967296ULL},
	323	{"4294967297", 10, 4294967297ULL},
33ee3b2e AD	324	{"9223372036854775806", 10, 9223372036854775806ULL},
	325	{"9223372036854775807", 10, 9223372036854775807ULL},
	326	{"9223372036854775808", 10, 9223372036854775808ULL},
	327	{"9223372036854775809", 10, 9223372036854775809ULL},
	328	{"18446744073709551614", 10, 18446744073709551614ULL},
	329	{"18446744073709551615", 10, 18446744073709551615ULL},
	330	};
	331	TEST_OK(kstrtou64, u64, "%llu", test_u64_ok);
	332	}
	333
	334	static void __init test_kstrtou64_fail(void)
	335	{
	336	static DEFINE_TEST_FAIL(test_u64_fail) = {
	337	{"-2", 10},
	338	{"-1", 10},
	339	{"18446744073709551616", 10},
	340	{"18446744073709551617", 10},
	341	};
	342	TEST_FAIL(kstrtou64, u64, "%llu", test_u64_fail);
	343	}
	344
	345	static void __init test_kstrtos64_ok(void)
	346	{
	347	DECLARE_TEST_OK(s64, struct test_s64);
	348	static DEFINE_TEST_OK(struct test_s64, test_s64_ok) = {
	349	{"-128", 10, -128},
	350	{"-127", 10, -127},
	351	{"-1", 10, -1},
	352	{"0", 10, 0},
	353	{"1", 10, 1},
	354	{"126", 10, 126},
	355	{"127", 10, 127},
	356	{"128", 10, 128},
	357	{"129", 10, 129},
	358	{"254", 10, 254},
	359	{"255", 10, 255},
	360	{"256", 10, 256},
	361	{"257", 10, 257},
	362	{"32766", 10, 32766},
	363	{"32767", 10, 32767},
	364	{"32768", 10, 32768},
	365	{"32769", 10, 32769},
	366	{"65534", 10, 65534},
	367	{"65535", 10, 65535},
	368	{"65536", 10, 65536},
	369	{"65537", 10, 65537},
	370	{"2147483646", 10, 2147483646},
	371	{"2147483647", 10, 2147483647},
01eda2e0 AD	372	{"2147483648", 10, 2147483648LL},
	373	{"2147483649", 10, 2147483649LL},
	374	{"4294967294", 10, 4294967294LL},
	375	{"4294967295", 10, 4294967295LL},
	376	{"4294967296", 10, 4294967296LL},
	377	{"4294967297", 10, 4294967297LL},
33ee3b2e AD	378	{"9223372036854775806", 10, 9223372036854775806LL},
	379	{"9223372036854775807", 10, 9223372036854775807LL},
	380	};
	381	TEST_OK(kstrtos64, s64, "%lld", test_s64_ok);
	382	}
	383
	384	static void __init test_kstrtos64_fail(void)
	385	{
	386	static DEFINE_TEST_FAIL(test_s64_fail) = {
	387	{"9223372036854775808", 10},
	388	{"9223372036854775809", 10},
	389	{"18446744073709551614", 10},
	390	{"18446744073709551615", 10},
	391	{"18446744073709551616", 10},
	392	{"18446744073709551617", 10},
	393	};
	394	TEST_FAIL(kstrtos64, s64, "%lld", test_s64_fail);
	395	}
	396
	397	static void __init test_kstrtou32_ok(void)
	398	{
	399	DECLARE_TEST_OK(u32, struct test_u32);
	400	static DEFINE_TEST_OK(struct test_u32, test_u32_ok) = {
	401	{"0", 10, 0},
	402	{"1", 10, 1},
	403	{"126", 10, 126},
	404	{"127", 10, 127},
	405	{"128", 10, 128},
	406	{"129", 10, 129},
	407	{"254", 10, 254},
	408	{"255", 10, 255},
	409	{"256", 10, 256},
	410	{"257", 10, 257},
	411	{"32766", 10, 32766},
	412	{"32767", 10, 32767},
	413	{"32768", 10, 32768},
	414	{"32769", 10, 32769},
	415	{"65534", 10, 65534},
	416	{"65535", 10, 65535},
	417	{"65536", 10, 65536},
	418	{"65537", 10, 65537},
	419	{"2147483646", 10, 2147483646},
	420	{"2147483647", 10, 2147483647},
01eda2e0 AD	421	{"2147483648", 10, 2147483648U},
	422	{"2147483649", 10, 2147483649U},
	423	{"4294967294", 10, 4294967294U},
	424	{"4294967295", 10, 4294967295U},
33ee3b2e AD	425	};
	426	TEST_OK(kstrtou32, u32, "%u", test_u32_ok);
	427	}
	428
	429	static void __init test_kstrtou32_fail(void)
	430	{
	431	static DEFINE_TEST_FAIL(test_u32_fail) = {
	432	{"-2", 10},
	433	{"-1", 10},
	434	{"4294967296", 10},
	435	{"4294967297", 10},
	436	{"9223372036854775806", 10},
	437	{"9223372036854775807", 10},
	438	{"9223372036854775808", 10},
	439	{"9223372036854775809", 10},
	440	{"18446744073709551614", 10},
	441	{"18446744073709551615", 10},
	442	{"18446744073709551616", 10},
	443	{"18446744073709551617", 10},
	444	};
	445	TEST_FAIL(kstrtou32, u32, "%u", test_u32_fail);
	446	}
	447
	448	static void __init test_kstrtos32_ok(void)
	449	{
	450	DECLARE_TEST_OK(s32, struct test_s32);
	451	static DEFINE_TEST_OK(struct test_s32, test_s32_ok) = {
	452	{"-128", 10, -128},
	453	{"-127", 10, -127},
	454	{"-1", 10, -1},
	455	{"0", 10, 0},
	456	{"1", 10, 1},
	457	{"126", 10, 126},
	458	{"127", 10, 127},
	459	{"128", 10, 128},
	460	{"129", 10, 129},
	461	{"254", 10, 254},
	462	{"255", 10, 255},
	463	{"256", 10, 256},
	464	{"257", 10, 257},
	465	{"32766", 10, 32766},
	466	{"32767", 10, 32767},
	467	{"32768", 10, 32768},
	468	{"32769", 10, 32769},
	469	{"65534", 10, 65534},
	470	{"65535", 10, 65535},
	471	{"65536", 10, 65536},
	472	{"65537", 10, 65537},
	473	{"2147483646", 10, 2147483646},
	474	{"2147483647", 10, 2147483647},
	475	};
	476	TEST_OK(kstrtos32, s32, "%d", test_s32_ok);
	477	}
	478
	479	static void __init test_kstrtos32_fail(void)
	480	{
	481	static DEFINE_TEST_FAIL(test_s32_fail) = {
	482	{"2147483648", 10},
	483	{"2147483649", 10},
	484	{"4294967294", 10},
	485	{"4294967295", 10},
	486	{"4294967296", 10},
	487	{"4294967297", 10},
	488	{"9223372036854775806", 10},
489	{"9223372036854775807", 10},
490	{"9223372036854775808", 10},
491	{"9223372036854775809", 10},
492	{"18446744073709551614", 10},
493	{"18446744073709551615", 10},
494	{"18446744073709551616", 10},
495	{"18446744073709551617", 10},
496	};
497	TEST_FAIL(kstrtos32, s32, "%d", test_s32_fail);
498	}
499
500	static void __init test_kstrtou16_ok(void)
501	{
502	DECLARE_TEST_OK(u16, struct test_u16);
503	static DEFINE_TEST_OK(struct test_u16, test_u16_ok) = {
504	{"0", 10, 0},
505	{"1", 10, 1},
506	{"126", 10, 126},
507	{"127", 10, 127},
508	{"128", 10, 128},
509	{"129", 10, 129},
510	{"254", 10, 254},
511	{"255", 10, 255},
512	{"256", 10, 256},
513	{"257", 10, 257},
514	{"32766", 10, 32766},
515	{"32767", 10, 32767},
516	{"32768", 10, 32768},
517	{"32769", 10, 32769},
518	{"65534", 10, 65534},
519	{"65535", 10, 65535},
520	};
521	TEST_OK(kstrtou16, u16, "%hu", test_u16_ok);
522	}
523
524	static void __init test_kstrtou16_fail(void)
525	{
526	static DEFINE_TEST_FAIL(test_u16_fail) = {
527	{"-2", 10},
528	{"-1", 10},
529	{"65536", 10},
530	{"65537", 10},
531	{"2147483646", 10},
532	{"2147483647", 10},
533	{"2147483648", 10},
534	{"2147483649", 10},
535	{"4294967294", 10},
536	{"4294967295", 10},
537	{"4294967296", 10},
538	{"4294967297", 10},
539	{"9223372036854775806", 10},
540	{"9223372036854775807", 10},
541	{"9223372036854775808", 10},
542	{"9223372036854775809", 10},
543	{"18446744073709551614", 10},
544	{"18446744073709551615", 10},
545	{"18446744073709551616", 10},
546	{"18446744073709551617", 10},
547	};
548	TEST_FAIL(kstrtou16, u16, "%hu", test_u16_fail);
549	}
550
551	static void __init test_kstrtos16_ok(void)
552	{
553	DECLARE_TEST_OK(s16, struct test_s16);
554	static DEFINE_TEST_OK(struct test_s16, test_s16_ok) = {
555	{"-130", 10, -130},
556	{"-129", 10, -129},
557	{"-128", 10, -128},
558	{"-127", 10, -127},
559	{"-1", 10, -1},
560	{"0", 10, 0},
561	{"1", 10, 1},
562	{"126", 10, 126},
563	{"127", 10, 127},
564	{"128", 10, 128},
565	{"129", 10, 129},
566	{"254", 10, 254},
567	{"255", 10, 255},
568	{"256", 10, 256},
569	{"257", 10, 257},
570	{"32766", 10, 32766},
571	{"32767", 10, 32767},
572	};
573	TEST_OK(kstrtos16, s16, "%hd", test_s16_ok);
574	}
575
576	static void __init test_kstrtos16_fail(void)
577	{
578	static DEFINE_TEST_FAIL(test_s16_fail) = {
579	{"32768", 10},
580	{"32769", 10},
581	{"65534", 10},
582	{"65535", 10},
583	{"65536", 10},
584	{"65537", 10},
585	{"2147483646", 10},
586	{"2147483647", 10},
587	{"2147483648", 10},
588	{"2147483649", 10},
589	{"4294967294", 10},
590	{"4294967295", 10},
591	{"4294967296", 10},
592	{"4294967297", 10},
593	{"9223372036854775806", 10},
594	{"9223372036854775807", 10},
595	{"9223372036854775808", 10},
596	{"9223372036854775809", 10},
597	{"18446744073709551614", 10},
598	{"18446744073709551615", 10},
599	{"18446744073709551616", 10},
600	{"18446744073709551617", 10},
601	};
602	TEST_FAIL(kstrtos16, s16, "%hd", test_s16_fail);
603	}
604
605	static void __init test_kstrtou8_ok(void)
606	{
607	DECLARE_TEST_OK(u8, struct test_u8);
608	static DEFINE_TEST_OK(struct test_u8, test_u8_ok) = {
609	{"0", 10, 0},
610	{"1", 10, 1},
611	{"126", 10, 126},
612	{"127", 10, 127},
613	{"128", 10, 128},
614	{"129", 10, 129},
615	{"254", 10, 254},
616	{"255", 10, 255},
617	};
618	TEST_OK(kstrtou8, u8, "%hhu", test_u8_ok);
619	}
620
621	static void __init test_kstrtou8_fail(void)
622	{
623	static DEFINE_TEST_FAIL(test_u8_fail) = {
624	{"-2", 10},
625	{"-1", 10},
626	{"256", 10},
627	{"257", 10},
628	{"32766", 10},
629	{"32767", 10},
630	{"32768", 10},
631	{"32769", 10},
632	{"65534", 10},
633	{"65535", 10},
634	{"65536", 10},
635	{"65537", 10},
636	{"2147483646", 10},
637	{"2147483647", 10},
638	{"2147483648", 10},
639	{"2147483649", 10},
640	{"4294967294", 10},
641	{"4294967295", 10},
642	{"4294967296", 10},
643	{"4294967297", 10},
644	{"9223372036854775806", 10},
645	{"9223372036854775807", 10},
646	{"9223372036854775808", 10},
647	{"9223372036854775809", 10},
648	{"18446744073709551614", 10},
649	{"18446744073709551615", 10},
650	{"18446744073709551616", 10},
651	{"18446744073709551617", 10},
652	};
653	TEST_FAIL(kstrtou8, u8, "%hhu", test_u8_fail);
654	}
655
656	static void __init test_kstrtos8_ok(void)
657	{
658	DECLARE_TEST_OK(s8, struct test_s8);
659	static DEFINE_TEST_OK(struct test_s8, test_s8_ok) = {
660	{"-128", 10, -128},
661	{"-127", 10, -127},
662	{"-1", 10, -1},
663	{"0", 10, 0},
664	{"1", 10, 1},
665	{"126", 10, 126},
666	{"127", 10, 127},
667	};
668	TEST_OK(kstrtos8, s8, "%hhd", test_s8_ok);
669	}
670
671	static void __init test_kstrtos8_fail(void)
672	{
673	static DEFINE_TEST_FAIL(test_s8_fail) = {
674	{"-130", 10},
675	{"-129", 10},
676	{"128", 10},
677	{"129", 10},
678	{"254", 10},
679	{"255", 10},
680	{"256", 10},
681	{"257", 10},
682	{"32766", 10},
683	{"32767", 10},
684	{"32768", 10},
685	{"32769", 10},
686	{"65534", 10},
687	{"65535", 10},
688	{"65536", 10},
689	{"65537", 10},
690	{"2147483646", 10},
691	{"2147483647", 10},
692	{"2147483648", 10},
693	{"2147483649", 10},
694	{"4294967294", 10},
695	{"4294967295", 10},
696	{"4294967296", 10},
697	{"4294967297", 10},
698	{"9223372036854775806", 10},
699	{"9223372036854775807", 10},
700	{"9223372036854775808", 10},
701	{"9223372036854775809", 10},
702	{"18446744073709551614", 10},
703	{"18446744073709551615", 10},
704	{"18446744073709551616", 10},
705	{"18446744073709551617", 10},
706	};
707	TEST_FAIL(kstrtos8, s8, "%hhd", test_s8_fail);
708	}
709
710	static int __init test_kstrtox_init(void)
711	{
712	test_kstrtoull_ok();
713	test_kstrtoull_fail();
714	test_kstrtoll_ok();
715	test_kstrtoll_fail();
716
717	test_kstrtou64_ok();
718	test_kstrtou64_fail();
719	test_kstrtos64_ok();
720	test_kstrtos64_fail();
721
722	test_kstrtou32_ok();
723	test_kstrtou32_fail();
724	test_kstrtos32_ok();
725	test_kstrtos32_fail();
726
727	test_kstrtou16_ok();
728	test_kstrtou16_fail();
729	test_kstrtos16_ok();
730	test_kstrtos16_fail();
731
732	test_kstrtou8_ok();
733	test_kstrtou8_fail();
734	test_kstrtos8_ok();
735	test_kstrtos8_fail();
736	return -EINVAL;
737	}
738	module_init(test_kstrtox_init);
739	MODULE_LICENSE("Dual BSD/GPL");