Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/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 < 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                 {"",   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                 {"\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                 {"\n", 0},
167                 {"\n", 8},
168                 {"\n", 10},
169                 {"\n", 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                 {"\n", 0},
218                 {"\n", 8},
219                 {"\n", 10},
220                 {"\n", 16},
221                 {"\n+", 0},
222                 {"\n+", 8},
223                 {"\n+", 10},
224                 {"\n+", 16},
225                 {"\n-", 0},
226                 {"\n-", 8},
227                 {"\n-", 10},
228                 {"\n-", 16},
229                 {"\n ", 0},
230                 {"\n ", 8},
231                 {"\n ", 10},
232                 {"\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                 {"",   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                 {"",   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                 {"",   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                 {"",   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                 {"",   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                 {"",   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                 {"",   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                 {"",   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                 {"",   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");
736 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us