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 {"-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"); 740