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 < ARRAY_SIZE(test); i++)
7 
8 struct test_fail {
9 	const char *str;
10 	unsigned int base;
11 };
12 
13 #define DEFINE_TEST_FAIL(test)	\
14 	const struct test_fail test[] __initconst
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)	\
24 	const type test[] __initconst
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 
test_kstrtoull_ok(void)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 
test_kstrtoull_fail(void)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 
test_kstrtoll_ok(void)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 		{"-0",	10,	0LL},
264 		{"-1",	10,	-1LL},
265 		{"-2",	10,	-2LL},
266 		{"-9223372036854775808",	10,	LLONG_MIN},
267 	};
268 	TEST_OK(kstrtoll, long long, "%lld", test_ll_ok);
269 }
270 
test_kstrtoll_fail(void)271 static void __init test_kstrtoll_fail(void)
272 {
273 	static DEFINE_TEST_FAIL(test_ll_fail) = {
274 		{"9223372036854775808",	10},
275 		{"9223372036854775809",	10},
276 		{"18446744073709551614",	10},
277 		{"18446744073709551615",	10},
278 		{"-9223372036854775809",	10},
279 		{"-18446744073709551614",	10},
280 		{"-18446744073709551615",	10},
281 		/* sign is first character if any */
282 		{"-+1", 0},
283 		{"-+1", 8},
284 		{"-+1", 10},
285 		{"-+1", 16},
286 	};
287 	TEST_FAIL(kstrtoll, long long, "%lld", test_ll_fail);
288 }
289 
test_kstrtou64_ok(void)290 static void __init test_kstrtou64_ok(void)
291 {
292 	DECLARE_TEST_OK(u64, struct test_u64);
293 	static DEFINE_TEST_OK(struct test_u64, test_u64_ok) = {
294 		{"0",	10,	0},
295 		{"1",	10,	1},
296 		{"126",	10,	126},
297 		{"127",	10,	127},
298 		{"128",	10,	128},
299 		{"129",	10,	129},
300 		{"254",	10,	254},
301 		{"255",	10,	255},
302 		{"256",	10,	256},
303 		{"257",	10,	257},
304 		{"32766",	10,	32766},
305 		{"32767",	10,	32767},
306 		{"32768",	10,	32768},
307 		{"32769",	10,	32769},
308 		{"65534",	10,	65534},
309 		{"65535",	10,	65535},
310 		{"65536",	10,	65536},
311 		{"65537",	10,	65537},
312 		{"2147483646",	10,	2147483646},
313 		{"2147483647",	10,	2147483647},
314 		{"2147483648",	10,	2147483648ULL},
315 		{"2147483649",	10,	2147483649ULL},
316 		{"4294967294",	10,	4294967294ULL},
317 		{"4294967295",	10,	4294967295ULL},
318 		{"4294967296",	10,	4294967296ULL},
319 		{"4294967297",	10,	4294967297ULL},
320 		{"9223372036854775806",	10,	9223372036854775806ULL},
321 		{"9223372036854775807",	10,	9223372036854775807ULL},
322 		{"9223372036854775808",	10,	9223372036854775808ULL},
323 		{"9223372036854775809",	10,	9223372036854775809ULL},
324 		{"18446744073709551614",	10,	18446744073709551614ULL},
325 		{"18446744073709551615",	10,	18446744073709551615ULL},
326 	};
327 	TEST_OK(kstrtou64, u64, "%llu", test_u64_ok);
328 }
329 
test_kstrtou64_fail(void)330 static void __init test_kstrtou64_fail(void)
331 {
332 	static DEFINE_TEST_FAIL(test_u64_fail) = {
333 		{"-2",	10},
334 		{"-1",	10},
335 		{"18446744073709551616",	10},
336 		{"18446744073709551617",	10},
337 	};
338 	TEST_FAIL(kstrtou64, u64, "%llu", test_u64_fail);
339 }
340 
test_kstrtos64_ok(void)341 static void __init test_kstrtos64_ok(void)
342 {
343 	DECLARE_TEST_OK(s64, struct test_s64);
344 	static DEFINE_TEST_OK(struct test_s64, test_s64_ok) = {
345 		{"-128",	10,	-128},
346 		{"-127",	10,	-127},
347 		{"-1",	10,	-1},
348 		{"0",	10,	0},
349 		{"1",	10,	1},
350 		{"126",	10,	126},
351 		{"127",	10,	127},
352 		{"128",	10,	128},
353 		{"129",	10,	129},
354 		{"254",	10,	254},
355 		{"255",	10,	255},
356 		{"256",	10,	256},
357 		{"257",	10,	257},
358 		{"32766",	10,	32766},
359 		{"32767",	10,	32767},
360 		{"32768",	10,	32768},
361 		{"32769",	10,	32769},
362 		{"65534",	10,	65534},
363 		{"65535",	10,	65535},
364 		{"65536",	10,	65536},
365 		{"65537",	10,	65537},
366 		{"2147483646",	10,	2147483646},
367 		{"2147483647",	10,	2147483647},
368 		{"2147483648",	10,	2147483648LL},
369 		{"2147483649",	10,	2147483649LL},
370 		{"4294967294",	10,	4294967294LL},
371 		{"4294967295",	10,	4294967295LL},
372 		{"4294967296",	10,	4294967296LL},
373 		{"4294967297",	10,	4294967297LL},
374 		{"9223372036854775806",	10,	9223372036854775806LL},
375 		{"9223372036854775807",	10,	9223372036854775807LL},
376 	};
377 	TEST_OK(kstrtos64, s64, "%lld", test_s64_ok);
378 }
379 
test_kstrtos64_fail(void)380 static void __init test_kstrtos64_fail(void)
381 {
382 	static DEFINE_TEST_FAIL(test_s64_fail) = {
383 		{"9223372036854775808",	10},
384 		{"9223372036854775809",	10},
385 		{"18446744073709551614",	10},
386 		{"18446744073709551615",	10},
387 		{"18446744073709551616",	10},
388 		{"18446744073709551617",	10},
389 	};
390 	TEST_FAIL(kstrtos64, s64, "%lld", test_s64_fail);
391 }
392 
test_kstrtou32_ok(void)393 static void __init test_kstrtou32_ok(void)
394 {
395 	DECLARE_TEST_OK(u32, struct test_u32);
396 	static DEFINE_TEST_OK(struct test_u32, test_u32_ok) = {
397 		{"0",	10,	0},
398 		{"1",	10,	1},
399 		{"126",	10,	126},
400 		{"127",	10,	127},
401 		{"128",	10,	128},
402 		{"129",	10,	129},
403 		{"254",	10,	254},
404 		{"255",	10,	255},
405 		{"256",	10,	256},
406 		{"257",	10,	257},
407 		{"32766",	10,	32766},
408 		{"32767",	10,	32767},
409 		{"32768",	10,	32768},
410 		{"32769",	10,	32769},
411 		{"65534",	10,	65534},
412 		{"65535",	10,	65535},
413 		{"65536",	10,	65536},
414 		{"65537",	10,	65537},
415 		{"2147483646",	10,	2147483646},
416 		{"2147483647",	10,	2147483647},
417 		{"2147483648",	10,	2147483648U},
418 		{"2147483649",	10,	2147483649U},
419 		{"4294967294",	10,	4294967294U},
420 		{"4294967295",	10,	4294967295U},
421 	};
422 	TEST_OK(kstrtou32, u32, "%u", test_u32_ok);
423 }
424 
test_kstrtou32_fail(void)425 static void __init test_kstrtou32_fail(void)
426 {
427 	static DEFINE_TEST_FAIL(test_u32_fail) = {
428 		{"-2",	10},
429 		{"-1",	10},
430 		{"4294967296",	10},
431 		{"4294967297",	10},
432 		{"9223372036854775806",	10},
433 		{"9223372036854775807",	10},
434 		{"9223372036854775808",	10},
435 		{"9223372036854775809",	10},
436 		{"18446744073709551614",	10},
437 		{"18446744073709551615",	10},
438 		{"18446744073709551616",	10},
439 		{"18446744073709551617",	10},
440 	};
441 	TEST_FAIL(kstrtou32, u32, "%u", test_u32_fail);
442 }
443 
test_kstrtos32_ok(void)444 static void __init test_kstrtos32_ok(void)
445 {
446 	DECLARE_TEST_OK(s32, struct test_s32);
447 	static DEFINE_TEST_OK(struct test_s32, test_s32_ok) = {
448 		{"-128",	10,	-128},
449 		{"-127",	10,	-127},
450 		{"-1",	10,	-1},
451 		{"0",	10,	0},
452 		{"1",	10,	1},
453 		{"126",	10,	126},
454 		{"127",	10,	127},
455 		{"128",	10,	128},
456 		{"129",	10,	129},
457 		{"254",	10,	254},
458 		{"255",	10,	255},
459 		{"256",	10,	256},
460 		{"257",	10,	257},
461 		{"32766",	10,	32766},
462 		{"32767",	10,	32767},
463 		{"32768",	10,	32768},
464 		{"32769",	10,	32769},
465 		{"65534",	10,	65534},
466 		{"65535",	10,	65535},
467 		{"65536",	10,	65536},
468 		{"65537",	10,	65537},
469 		{"2147483646",	10,	2147483646},
470 		{"2147483647",	10,	2147483647},
471 	};
472 	TEST_OK(kstrtos32, s32, "%d", test_s32_ok);
473 }
474 
test_kstrtos32_fail(void)475 static void __init test_kstrtos32_fail(void)
476 {
477 	static DEFINE_TEST_FAIL(test_s32_fail) = {
478 		{"2147483648",	10},
479 		{"2147483649",	10},
480 		{"4294967294",	10},
481 		{"4294967295",	10},
482 		{"4294967296",	10},
483 		{"4294967297",	10},
484 		{"9223372036854775806",	10},
485 		{"9223372036854775807",	10},
486 		{"9223372036854775808",	10},
487 		{"9223372036854775809",	10},
488 		{"18446744073709551614",	10},
489 		{"18446744073709551615",	10},
490 		{"18446744073709551616",	10},
491 		{"18446744073709551617",	10},
492 	};
493 	TEST_FAIL(kstrtos32, s32, "%d", test_s32_fail);
494 }
495 
test_kstrtou16_ok(void)496 static void __init test_kstrtou16_ok(void)
497 {
498 	DECLARE_TEST_OK(u16, struct test_u16);
499 	static DEFINE_TEST_OK(struct test_u16, test_u16_ok) = {
500 		{"0",	10,	0},
501 		{"1",	10,	1},
502 		{"126",	10,	126},
503 		{"127",	10,	127},
504 		{"128",	10,	128},
505 		{"129",	10,	129},
506 		{"254",	10,	254},
507 		{"255",	10,	255},
508 		{"256",	10,	256},
509 		{"257",	10,	257},
510 		{"32766",	10,	32766},
511 		{"32767",	10,	32767},
512 		{"32768",	10,	32768},
513 		{"32769",	10,	32769},
514 		{"65534",	10,	65534},
515 		{"65535",	10,	65535},
516 	};
517 	TEST_OK(kstrtou16, u16, "%hu", test_u16_ok);
518 }
519 
test_kstrtou16_fail(void)520 static void __init test_kstrtou16_fail(void)
521 {
522 	static DEFINE_TEST_FAIL(test_u16_fail) = {
523 		{"-2",	10},
524 		{"-1",	10},
525 		{"65536",	10},
526 		{"65537",	10},
527 		{"2147483646",	10},
528 		{"2147483647",	10},
529 		{"2147483648",	10},
530 		{"2147483649",	10},
531 		{"4294967294",	10},
532 		{"4294967295",	10},
533 		{"4294967296",	10},
534 		{"4294967297",	10},
535 		{"9223372036854775806",	10},
536 		{"9223372036854775807",	10},
537 		{"9223372036854775808",	10},
538 		{"9223372036854775809",	10},
539 		{"18446744073709551614",	10},
540 		{"18446744073709551615",	10},
541 		{"18446744073709551616",	10},
542 		{"18446744073709551617",	10},
543 	};
544 	TEST_FAIL(kstrtou16, u16, "%hu", test_u16_fail);
545 }
546 
test_kstrtos16_ok(void)547 static void __init test_kstrtos16_ok(void)
548 {
549 	DECLARE_TEST_OK(s16, struct test_s16);
550 	static DEFINE_TEST_OK(struct test_s16, test_s16_ok) = {
551 		{"-130",	10,	-130},
552 		{"-129",	10,	-129},
553 		{"-128",	10,	-128},
554 		{"-127",	10,	-127},
555 		{"-1",	10,	-1},
556 		{"0",	10,	0},
557 		{"1",	10,	1},
558 		{"126",	10,	126},
559 		{"127",	10,	127},
560 		{"128",	10,	128},
561 		{"129",	10,	129},
562 		{"254",	10,	254},
563 		{"255",	10,	255},
564 		{"256",	10,	256},
565 		{"257",	10,	257},
566 		{"32766",	10,	32766},
567 		{"32767",	10,	32767},
568 	};
569 	TEST_OK(kstrtos16, s16, "%hd", test_s16_ok);
570 }
571 
test_kstrtos16_fail(void)572 static void __init test_kstrtos16_fail(void)
573 {
574 	static DEFINE_TEST_FAIL(test_s16_fail) = {
575 		{"32768",	10},
576 		{"32769",	10},
577 		{"65534",	10},
578 		{"65535",	10},
579 		{"65536",	10},
580 		{"65537",	10},
581 		{"2147483646",	10},
582 		{"2147483647",	10},
583 		{"2147483648",	10},
584 		{"2147483649",	10},
585 		{"4294967294",	10},
586 		{"4294967295",	10},
587 		{"4294967296",	10},
588 		{"4294967297",	10},
589 		{"9223372036854775806",	10},
590 		{"9223372036854775807",	10},
591 		{"9223372036854775808",	10},
592 		{"9223372036854775809",	10},
593 		{"18446744073709551614",	10},
594 		{"18446744073709551615",	10},
595 		{"18446744073709551616",	10},
596 		{"18446744073709551617",	10},
597 	};
598 	TEST_FAIL(kstrtos16, s16, "%hd", test_s16_fail);
599 }
600 
test_kstrtou8_ok(void)601 static void __init test_kstrtou8_ok(void)
602 {
603 	DECLARE_TEST_OK(u8, struct test_u8);
604 	static DEFINE_TEST_OK(struct test_u8, test_u8_ok) = {
605 		{"0",	10,	0},
606 		{"1",	10,	1},
607 		{"126",	10,	126},
608 		{"127",	10,	127},
609 		{"128",	10,	128},
610 		{"129",	10,	129},
611 		{"254",	10,	254},
612 		{"255",	10,	255},
613 	};
614 	TEST_OK(kstrtou8, u8, "%hhu", test_u8_ok);
615 }
616 
test_kstrtou8_fail(void)617 static void __init test_kstrtou8_fail(void)
618 {
619 	static DEFINE_TEST_FAIL(test_u8_fail) = {
620 		{"-2",	10},
621 		{"-1",	10},
622 		{"256",	10},
623 		{"257",	10},
624 		{"32766",	10},
625 		{"32767",	10},
626 		{"32768",	10},
627 		{"32769",	10},
628 		{"65534",	10},
629 		{"65535",	10},
630 		{"65536",	10},
631 		{"65537",	10},
632 		{"2147483646",	10},
633 		{"2147483647",	10},
634 		{"2147483648",	10},
635 		{"2147483649",	10},
636 		{"4294967294",	10},
637 		{"4294967295",	10},
638 		{"4294967296",	10},
639 		{"4294967297",	10},
640 		{"9223372036854775806",	10},
641 		{"9223372036854775807",	10},
642 		{"9223372036854775808",	10},
643 		{"9223372036854775809",	10},
644 		{"18446744073709551614",	10},
645 		{"18446744073709551615",	10},
646 		{"18446744073709551616",	10},
647 		{"18446744073709551617",	10},
648 	};
649 	TEST_FAIL(kstrtou8, u8, "%hhu", test_u8_fail);
650 }
651 
test_kstrtos8_ok(void)652 static void __init test_kstrtos8_ok(void)
653 {
654 	DECLARE_TEST_OK(s8, struct test_s8);
655 	static DEFINE_TEST_OK(struct test_s8, test_s8_ok) = {
656 		{"-128",	10,	-128},
657 		{"-127",	10,	-127},
658 		{"-1",	10,	-1},
659 		{"0",	10,	0},
660 		{"1",	10,	1},
661 		{"126",	10,	126},
662 		{"127",	10,	127},
663 	};
664 	TEST_OK(kstrtos8, s8, "%hhd", test_s8_ok);
665 }
666 
test_kstrtos8_fail(void)667 static void __init test_kstrtos8_fail(void)
668 {
669 	static DEFINE_TEST_FAIL(test_s8_fail) = {
670 		{"-130",	10},
671 		{"-129",	10},
672 		{"128",	10},
673 		{"129",	10},
674 		{"254",	10},
675 		{"255",	10},
676 		{"256",	10},
677 		{"257",	10},
678 		{"32766",	10},
679 		{"32767",	10},
680 		{"32768",	10},
681 		{"32769",	10},
682 		{"65534",	10},
683 		{"65535",	10},
684 		{"65536",	10},
685 		{"65537",	10},
686 		{"2147483646",	10},
687 		{"2147483647",	10},
688 		{"2147483648",	10},
689 		{"2147483649",	10},
690 		{"4294967294",	10},
691 		{"4294967295",	10},
692 		{"4294967296",	10},
693 		{"4294967297",	10},
694 		{"9223372036854775806",	10},
695 		{"9223372036854775807",	10},
696 		{"9223372036854775808",	10},
697 		{"9223372036854775809",	10},
698 		{"18446744073709551614",	10},
699 		{"18446744073709551615",	10},
700 		{"18446744073709551616",	10},
701 		{"18446744073709551617",	10},
702 	};
703 	TEST_FAIL(kstrtos8, s8, "%hhd", test_s8_fail);
704 }
705 
test_kstrtox_init(void)706 static int __init test_kstrtox_init(void)
707 {
708 	test_kstrtoull_ok();
709 	test_kstrtoull_fail();
710 	test_kstrtoll_ok();
711 	test_kstrtoll_fail();
712 
713 	test_kstrtou64_ok();
714 	test_kstrtou64_fail();
715 	test_kstrtos64_ok();
716 	test_kstrtos64_fail();
717 
718 	test_kstrtou32_ok();
719 	test_kstrtou32_fail();
720 	test_kstrtos32_ok();
721 	test_kstrtos32_fail();
722 
723 	test_kstrtou16_ok();
724 	test_kstrtou16_fail();
725 	test_kstrtos16_ok();
726 	test_kstrtos16_fail();
727 
728 	test_kstrtou8_ok();
729 	test_kstrtou8_fail();
730 	test_kstrtos8_ok();
731 	test_kstrtos8_fail();
732 	return -EINVAL;
733 }
734 module_init(test_kstrtox_init);
735 MODULE_LICENSE("Dual BSD/GPL");
736