Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
test-kstrtox.c
Go to the documentation of this file.
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[] __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  {"-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");
Generated on Thu Jan 10 2013 14:55:56 for Linux Kernel by   doxygen 1.8.2