?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[cris-mirror.git] / lib / test-kstrtox.c
blobf355f67169b6a32fbb7162b46691a45de4291cd2
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
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 {"-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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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");
CRIS linux kernel tree