lib/test-kstrtox.c

   1 #include <linux/init.h>
   2 #include <linux/kernel.h>
   3 #include <linux/module.h>
   4
   5 #define for_each_test(i, test)  \
   6         for (i = 0; i < sizeof(test) / sizeof(test[0]); i++)
   7
   8 struct test_fail {
   9         const char *str;
  10         unsigned int base;
  11 };
  12
  13 #define DEFINE_TEST_FAIL(test)  \
  14         const struct test_fail test[] __initdata
  15
  16 #define DECLARE_TEST_OK(type, test_type)        \
  17         test_type {                             \
  18                 const char *str;                \
  19                 unsigned int base;              \
  20                 type expected_res;              \
  21         }
  22
  23 #define DEFINE_TEST_OK(type, test)      \
  24         const type test[] __initdata
  25
  26 #define TEST_FAIL(fn, type, fmt, test)                                  \
  27 {                                                                       \
  28         unsigned int i;                                                 \
  29                                                                         \
  30         for_each_test(i, test) {                                        \
  31                 const struct test_fail *t = &test[i];                   \
  32                 type tmp;                                               \
  33                 int rv;                                                 \
  34                                                                         \
  35                 tmp = 0;                                                \
  36                 rv = fn(t->str, t->base, &tmp);                         \
  37                 if (rv >= 0) {                                          \
  38                         WARN(1, "str '%s', base %u, expected -E, got %d/" fmt "\n",     \
  39                                 t->str, t->base, rv, tmp);              \
  40                         continue;                                       \
  41                 }                                                       \
  42         }                                                               \
  43 }
  44
  45 #define TEST_OK(fn, type, fmt, test)                                    \
  46 {                                                                       \
  47         unsigned int i;                                                 \
  48                                                                         \
  49         for_each_test(i, test) {                                        \
  50                 const typeof(test[0]) *t = &test[i];                    \
  51                 type res;                                               \
  52                 int rv;                                                 \
  53                                                                         \
  54                 rv = fn(t->str, t->base, &res);                         \
  55                 if (rv != 0) {                                          \
  56                         WARN(1, "str '%s', base %u, expected 0/" fmt ", got %d\n",      \
  57                                 t->str, t->base, t->expected_res, rv);  \
  58                         continue;                                       \
  59                 }                                                       \
  60                 if (res != t->expected_res) {                           \
  61                         WARN(1, "str '%s', base %u, expected " fmt ", got " fmt "\n",   \
  62                                 t->str, t->base, t->expected_res, res); \
  63                         continue;                                       \
  64                 }                                                       \
  65         }                                                               \
  66 }
  67
  68 static void __init test_kstrtoull_ok(void)
  69 {
  70         DECLARE_TEST_OK(unsigned long long, struct test_ull);
  71         static DEFINE_TEST_OK(struct test_ull, test_ull_ok) = {
  72                 {"0",   10,     0ULL},
  73                 {"1",   10,     1ULL},
  74                 {"127", 10,     127ULL},
  75                 {"128", 10,     128ULL},
  76                 {"129", 10,     129ULL},
  77                 {"255", 10,     255ULL},
  78                 {"256", 10,     256ULL},
  79                 {"257", 10,     257ULL},
  80                 {"32767",       10,     32767ULL},
  81                 {"32768",       10,     32768ULL},
  82                 {"32769",       10,     32769ULL},
  83                 {"65535",       10,     65535ULL},
  84                 {"65536",       10,     65536ULL},
  85                 {"65537",       10,     65537ULL},
  86                 {"2147483647",  10,     2147483647ULL},
  87                 {"2147483648",  10,     2147483648ULL},
  88                 {"2147483649",  10,     2147483649ULL},
  89                 {"4294967295",  10,     4294967295ULL},
  90                 {"4294967296",  10,     4294967296ULL},
  91                 {"4294967297",  10,     4294967297ULL},
  92                 {"9223372036854775807", 10,     9223372036854775807ULL},
  93                 {"9223372036854775808", 10,     9223372036854775808ULL},
  94                 {"9223372036854775809", 10,     9223372036854775809ULL},
  95                 {"18446744073709551614",        10,     18446744073709551614ULL},
  96                 {"18446744073709551615",        10,     18446744073709551615ULL},
  97
  98                 {"00",          8,      00ULL},
  99                 {"01",          8,      01ULL},
 100                 {"0177",        8,      0177ULL},
 101                 {"0200",        8,      0200ULL},
 102                 {"0201",        8,      0201ULL},
 103                 {"0377",        8,      0377ULL},
 104                 {"0400",        8,      0400ULL},
 105                 {"0401",        8,      0401ULL},
 106                 {"077777",      8,      077777ULL},
 107                 {"0100000",     8,      0100000ULL},
 108                 {"0100001",     8,      0100001ULL},
 109                 {"0177777",     8,      0177777ULL},
 110                 {"0200000",     8,      0200000ULL},
 111                 {"0200001",     8,      0200001ULL},
 112                 {"017777777777",        8,      017777777777ULL},
 113                 {"020000000000",        8,      020000000000ULL},
 114                 {"020000000001",        8,      020000000001ULL},
 115                 {"037777777777",        8,      037777777777ULL},
 116                 {"040000000000",        8,      040000000000ULL},
 117                 {"040000000001",        8,      040000000001ULL},
 118                 {"0777777777777777777777",      8,      0777777777777777777777ULL},
 119                 {"01000000000000000000000",     8,      01000000000000000000000ULL},
 120                 {"01000000000000000000001",     8,      01000000000000000000001ULL},
 121                 {"01777777777777777777776",     8,      01777777777777777777776ULL},
 122                 {"01777777777777777777777",     8,      01777777777777777777777ULL},
 123
 124                 {"0x0",         16,     0x0ULL},
 125                 {"0x1",         16,     0x1ULL},
 126                 {"0x7f",        16,     0x7fULL},
 127                 {"0x80",        16,     0x80ULL},
 128                 {"0x81",        16,     0x81ULL},
 129                 {"0xff",        16,     0xffULL},
 130                 {"0x100",       16,     0x100ULL},
 131                 {"0x101",       16,     0x101ULL},
 132                 {"0x7fff",      16,     0x7fffULL},
 133                 {"0x8000",      16,     0x8000ULL},
 134                 {"0x8001",      16,     0x8001ULL},
 135                 {"0xffff",      16,     0xffffULL},
 136                 {"0x10000",     16,     0x10000ULL},
 137                 {"0x10001",     16,     0x10001ULL},
 138                 {"0x7fffffff",  16,     0x7fffffffULL},
 139                 {"0x80000000",  16,     0x80000000ULL},
 140                 {"0x80000001",  16,     0x80000001ULL},
 141                 {"0xffffffff",  16,     0xffffffffULL},
 142                 {"0x100000000", 16,     0x100000000ULL},
 143                 {"0x100000001", 16,     0x100000001ULL},
 144                 {"0x7fffffffffffffff",  16,     0x7fffffffffffffffULL},
 145                 {"0x8000000000000000",  16,     0x8000000000000000ULL},
 146                 {"0x8000000000000001",  16,     0x8000000000000001ULL},
 147                 {"0xfffffffffffffffe",  16,     0xfffffffffffffffeULL},
 148                 {"0xffffffffffffffff",  16,     0xffffffffffffffffULL},
 149
 150                 {"0\n", 0,      0ULL},
 151         };
 152         TEST_OK(kstrtoull, unsigned long long, "%llu", test_ull_ok);
 153 }
 154
 155 static void __init test_kstrtoull_fail(void)
 156 {
 157         static DEFINE_TEST_FAIL(test_ull_fail) = {
 158                 {"",    0},
 159                 {"",    8},
 160                 {"",    10},
 161                 {"",    16},
 162                 {"\n",  0},
 163                 {"\n",  8},
 164                 {"\n",  10},
 165                 {"\n",  16},
 166                 {"\n0", 0},
 167                 {"\n0", 8},
 168                 {"\n0", 10},
 169                 {"\n0", 16},
 170                 {"+",   0},
 171                 {"+",   8},
 172                 {"+",   10},
 173                 {"+",   16},
 174                 {"-",   0},
 175                 {"-",   8},
 176                 {"-",   10},
 177                 {"-",   16},
 178                 {"0x",  0},
 179                 {"0x",  16},
 180                 {"0X",  0},
 181                 {"0X",  16},
 182                 {"0 ",  0},
 183                 {"1+",  0},
 184                 {"1-",  0},
 185                 {" 2",  0},
 186                 /* base autodetection */
 187                 {"0x0z",        0},
 188                 {"0z",          0},
 189                 {"a",           0},
 190                 /* digit >= base */
 191                 {"2",   2},
 192                 {"8",   8},
 193                 {"a",   10},
 194                 {"A",   10},
 195                 {"g",   16},
 196                 {"G",   16},
 197                 /* overflow */
 198                 {"10000000000000000000000000000000000000000000000000000000000000000",   2},
 199                 {"2000000000000000000000",      8},
 200                 {"18446744073709551616",        10},
 201                 {"10000000000000000",   16},
 202                 /* negative */
 203                 {"-0", 0},
 204                 {"-0", 8},
 205                 {"-0", 10},
 206                 {"-0", 16},
 207                 {"-1", 0},
 208                 {"-1", 8},
 209                 {"-1", 10},
 210                 {"-1", 16},
 211                 /* sign is first character if any */
 212                 {"-+1", 0},
 213                 {"-+1", 8},
 214                 {"-+1", 10},
 215                 {"-+1", 16},
 216                 /* nothing after \n */
 217                 {"0\n0", 0},
 218                 {"0\n0", 8},
 219                 {"0\n0", 10},
 220                 {"0\n0", 16},
 221                 {"0\n+", 0},
 222                 {"0\n+", 8},
 223                 {"0\n+", 10},
 224                 {"0\n+", 16},
 225                 {"0\n-", 0},
 226                 {"0\n-", 8},
 227                 {"0\n-", 10},
 228                 {"0\n-", 16},
 229                 {"0\n ", 0},
 230                 {"0\n ", 8},
 231                 {"0\n ", 10},
 232                 {"0\n ", 16},
 233         };
 234         TEST_FAIL(kstrtoull, unsigned long long, "%llu", test_ull_fail);
 235 }
 236
 237 static void __init test_kstrtoll_ok(void)
 238 {
 239         DECLARE_TEST_OK(long long, struct test_ll);
 240         static DEFINE_TEST_OK(struct test_ll, test_ll_ok) = {
 241                 {"0",   10,     0LL},
 242                 {"1",   10,     1LL},
 243                 {"127", 10,     127LL},
 244                 {"128", 10,     128LL},
 245                 {"129", 10,     129LL},
 246                 {"255", 10,     255LL},
 247                 {"256", 10,     256LL},
 248                 {"257", 10,     257LL},
 249                 {"32767",       10,     32767LL},
 250                 {"32768",       10,     32768LL},
 251                 {"32769",       10,     32769LL},
 252                 {"65535",       10,     65535LL},
 253                 {"65536",       10,     65536LL},
 254                 {"65537",       10,     65537LL},
 255                 {"2147483647",  10,     2147483647LL},
 256                 {"2147483648",  10,     2147483648LL},
 257                 {"2147483649",  10,     2147483649LL},
 258                 {"4294967295",  10,     4294967295LL},
 259                 {"4294967296",  10,     4294967296LL},
 260                 {"4294967297",  10,     4294967297LL},
 261                 {"9223372036854775807", 10,     9223372036854775807LL},
 262
 263                 {"-1",  10,     -1LL},
 264                 {"-2",  10,     -2LL},
 265                 {"-9223372036854775808",        10,     LLONG_MIN},
 266         };
 267         TEST_OK(kstrtoll, long long, "%lld", test_ll_ok);
 268 }
 269
 270 static void __init test_kstrtoll_fail(void)
 271 {
 272         static DEFINE_TEST_FAIL(test_ll_fail) = {
 273                 {"9223372036854775808", 10},
 274                 {"9223372036854775809", 10},
 275                 {"18446744073709551614",        10},
 276                 {"18446744073709551615",        10},
 277                 {"-9223372036854775809",        10},
 278                 {"-18446744073709551614",       10},
 279                 {"-18446744073709551615",       10},
 280                 /* negative zero isn't an integer in Linux */
 281                 {"-0",  0},
 282                 {"-0",  8},
 283                 {"-0",  10},
 284                 {"-0",  16},
 285                 /* sign is first character if any */
 286                 {"-+1", 0},
 287                 {"-+1", 8},
 288                 {"-+1", 10},
 289                 {"-+1", 16},
 290         };
 291         TEST_FAIL(kstrtoll, long long, "%lld", test_ll_fail);
 292 }
 293
 294 static void __init test_kstrtou64_ok(void)
 295 {
 296         DECLARE_TEST_OK(u64, struct test_u64);
 297         static DEFINE_TEST_OK(struct test_u64, test_u64_ok) = {
 298                 {"0",   10,     0},
 299                 {"1",   10,     1},
 300                 {"126", 10,     126},
 301                 {"127", 10,     127},
 302                 {"128", 10,     128},
 303                 {"129", 10,     129},
 304                 {"254", 10,     254},
 305                 {"255", 10,     255},
 306                 {"256", 10,     256},
 307                 {"257", 10,     257},
 308                 {"32766",       10,     32766},
 309                 {"32767",       10,     32767},
 310                 {"32768",       10,     32768},
 311                 {"32769",       10,     32769},
 312                 {"65534",       10,     65534},
 313                 {"65535",       10,     65535},
 314                 {"65536",       10,     65536},
 315                 {"65537",       10,     65537},
 316                 {"2147483646",  10,     2147483646},
 317                 {"2147483647",  10,     2147483647},
 318                 {"2147483648",  10,     2147483648},
 319                 {"2147483649",  10,     2147483649},
 320                 {"4294967294",  10,     4294967294},
 321                 {"4294967295",  10,     4294967295},
 322                 {"4294967296",  10,     4294967296},
 323                 {"4294967297",  10,     4294967297},
 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,     2147483648},
 373                 {"2147483649",  10,     2147483649},
 374                 {"4294967294",  10,     4294967294},
 375                 {"4294967295",  10,     4294967295},
 376                 {"4294967296",  10,     4294967296},
 377                 {"4294967297",  10,     4294967297},
 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,     2147483648},
 422                 {"2147483649",  10,     2147483649},
 423                 {"4294967294",  10,     4294967294},
 424                 {"4294967295",  10,     4294967295},
 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");