Root/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
8struct 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
68static 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
155static 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
237static 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
270static 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
294static 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
334static 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
345static 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
384static 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
397static 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
429static 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
448static 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
479static 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
500static 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
524static 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
551static 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
576static 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
605static 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
621static 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
656static 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
671static 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
710static 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}
738module_init(test_kstrtox_init);
739MODULE_LICENSE("Dual BSD/GPL");
740

Archive Download this file



interactive