Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net
[linux-2.6.git] / lib / test-kstrtox.c
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)  \
14         const struct test_fail test[] __initdata
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[] __initdata
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},
318                 {"2147483648",  10,     2147483648ULL},
319                 {"2147483649",  10,     2147483649ULL},
320                 {"4294967294",  10,     4294967294ULL},
321                 {"4294967295",  10,     4294967295ULL},
322                 {"4294967296",  10,     4294967296ULL},
323                 {"4294967297",  10,     4294967297ULL},
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},
372                 {"2147483648",  10,     2147483648LL},
373                 {"2147483649",  10,     2147483649LL},
374                 {"4294967294",  10,     4294967294LL},
375                 {"4294967295",  10,     4294967295LL},
376                 {"4294967296",  10,     4294967296LL},
377                 {"4294967297",  10,     4294967297LL},
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},
421                 {"2147483648",  10,     2147483648U},
422                 {"2147483649",  10,     2147483649U},
423                 {"4294967294",  10,     4294967294U},
424                 {"4294967295",  10,     4294967295U},
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");