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 8struct 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 68static 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 155static 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 237static void __init test_kstrtoll_ok(void) 238{ 239 DECLARE_TEST_OK(long long, struct test_ll); 240 static DEFINE_TEST_OK(struct test_ll, test_ll_ok) = { 241 {"0", 10, 0LL}, 242 {"1", 10, 1LL}, 243 {"127", 10, 127LL}, 244 {"128", 10, 128LL}, 245 {"129", 10, 129LL}, 246 {"255", 10, 255LL}, 247 {"256", 10, 256LL}, 248 {"257", 10, 257LL}, 249 {"32767", 10, 32767LL}, 250 {"32768", 10, 32768LL}, 251 {"32769", 10, 32769LL}, 252 {"65535", 10, 65535LL}, 253 {"65536", 10, 65536LL}, 254 {"65537", 10, 65537LL}, 255 {"2147483647", 10, 2147483647LL}, 256 {"2147483648", 10, 2147483648LL}, 257 {"2147483649", 10, 2147483649LL}, 258 {"4294967295", 10, 4294967295LL}, 259 {"4294967296", 10, 4294967296LL}, 260 {"4294967297", 10, 4294967297LL}, 261 {"9223372036854775807", 10, 9223372036854775807LL}, 262 263 {"-0", 10, 0LL}, 264 {"-1", 10, -1LL}, 265 {"-2", 10, -2LL}, 266 {"-9223372036854775808", 10, LLONG_MIN}, 267 }; 268 TEST_OK(kstrtoll, long long, "%lld", test_ll_ok); 269} 270 271static 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 290static void __init test_kstrtou64_ok(void) 291{ 292 DECLARE_TEST_OK(u64, struct test_u64); 293 static DEFINE_TEST_OK(struct test_u64, test_u64_ok) = { 294 {"0", 10, 0}, 295 {"1", 10, 1}, 296 {"126", 10, 126}, 297 {"127", 10, 127}, 298 {"128", 10, 128}, 299 {"129", 10, 129}, 300 {"254", 10, 254}, 301 {"255", 10, 255}, 302 {"256", 10, 256}, 303 {"257", 10, 257}, 304 {"32766", 10, 32766}, 305 {"32767", 10, 32767}, 306 {"32768", 10, 32768}, 307 {"32769", 10, 32769}, 308 {"65534", 10, 65534}, 309 {"65535", 10, 65535}, 310 {"65536", 10, 65536}, 311 {"65537", 10, 65537}, 312 {"2147483646", 10, 2147483646}, 313 {"2147483647", 10, 2147483647}, 314 {"2147483648", 10, 2147483648ULL}, 315 {"2147483649", 10, 2147483649ULL}, 316 {"4294967294", 10, 4294967294ULL}, 317 {"4294967295", 10, 4294967295ULL}, 318 {"4294967296", 10, 4294967296ULL}, 319 {"4294967297", 10, 4294967297ULL}, 320 {"9223372036854775806", 10, 9223372036854775806ULL}, 321 {"9223372036854775807", 10, 9223372036854775807ULL}, 322 {"9223372036854775808", 10, 9223372036854775808ULL}, 323 {"9223372036854775809", 10, 9223372036854775809ULL}, 324 {"18446744073709551614", 10, 18446744073709551614ULL}, 325 {"18446744073709551615", 10, 18446744073709551615ULL}, 326 }; 327 TEST_OK(kstrtou64, u64, "%llu", test_u64_ok); 328} 329 330static 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 341static void __init test_kstrtos64_ok(void) 342{ 343 DECLARE_TEST_OK(s64, struct test_s64); 344 static DEFINE_TEST_OK(struct test_s64, test_s64_ok) = { 345 {"-128", 10, -128}, 346 {"-127", 10, -127}, 347 {"-1", 10, -1}, 348 {"0", 10, 0}, 349 {"1", 10, 1}, 350 {"126", 10, 126}, 351 {"127", 10, 127}, 352 {"128", 10, 128}, 353 {"129", 10, 129}, 354 {"254", 10, 254}, 355 {"255", 10, 255}, 356 {"256", 10, 256}, 357 {"257", 10, 257}, 358 {"32766", 10, 32766}, 359 {"32767", 10, 32767}, 360 {"32768", 10, 32768}, 361 {"32769", 10, 32769}, 362 {"65534", 10, 65534}, 363 {"65535", 10, 65535}, 364 {"65536", 10, 65536}, 365 {"65537", 10, 65537}, 366 {"2147483646", 10, 2147483646}, 367 {"2147483647", 10, 2147483647}, 368 {"2147483648", 10, 2147483648LL}, 369 {"2147483649", 10, 2147483649LL}, 370 {"4294967294", 10, 4294967294LL}, 371 {"4294967295", 10, 4294967295LL}, 372 {"4294967296", 10, 4294967296LL}, 373 {"4294967297", 10, 4294967297LL}, 374 {"9223372036854775806", 10, 9223372036854775806LL}, 375 {"9223372036854775807", 10, 9223372036854775807LL}, 376 }; 377 TEST_OK(kstrtos64, s64, "%lld", test_s64_ok); 378} 379 380static 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 393static void __init test_kstrtou32_ok(void) 394{ 395 DECLARE_TEST_OK(u32, struct test_u32); 396 static DEFINE_TEST_OK(struct test_u32, test_u32_ok) = { 397 {"0", 10, 0}, 398 {"1", 10, 1}, 399 {"126", 10, 126}, 400 {"127", 10, 127}, 401 {"128", 10, 128}, 402 {"129", 10, 129}, 403 {"254", 10, 254}, 404 {"255", 10, 255}, 405 {"256", 10, 256}, 406 {"257", 10, 257}, 407 {"32766", 10, 32766}, 408 {"32767", 10, 32767}, 409 {"32768", 10, 32768}, 410 {"32769", 10, 32769}, 411 {"65534", 10, 65534}, 412 {"65535", 10, 65535}, 413 {"65536", 10, 65536}, 414 {"65537", 10, 65537}, 415 {"2147483646", 10, 2147483646}, 416 {"2147483647", 10, 2147483647}, 417 {"2147483648", 10, 2147483648U}, 418 {"2147483649", 10, 2147483649U}, 419 {"4294967294", 10, 4294967294U}, 420 {"4294967295", 10, 4294967295U}, 421 }; 422 TEST_OK(kstrtou32, u32, "%u", test_u32_ok); 423} 424 425static 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 444static void __init test_kstrtos32_ok(void) 445{ 446 DECLARE_TEST_OK(s32, struct test_s32); 447 static DEFINE_TEST_OK(struct test_s32, test_s32_ok) = { 448 {"-128", 10, -128}, 449 {"-127", 10, -127}, 450 {"-1", 10, -1}, 451 {"0", 10, 0}, 452 {"1", 10, 1}, 453 {"126", 10, 126}, 454 {"127", 10, 127}, 455 {"128", 10, 128}, 456 {"129", 10, 129}, 457 {"254", 10, 254}, 458 {"255", 10, 255}, 459 {"256", 10, 256}, 460 {"257", 10, 257}, 461 {"32766", 10, 32766}, 462 {"32767", 10, 32767}, 463 {"32768", 10, 32768}, 464 {"32769", 10, 32769}, 465 {"65534", 10, 65534}, 466 {"65535", 10, 65535}, 467 {"65536", 10, 65536}, 468 {"65537", 10, 65537}, 469 {"2147483646", 10, 2147483646}, 470 {"2147483647", 10, 2147483647}, 471 }; 472 TEST_OK(kstrtos32, s32, "%d", test_s32_ok); 473} 474 475static 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 496static void __init test_kstrtou16_ok(void) 497{ 498 DECLARE_TEST_OK(u16, struct test_u16); 499 static DEFINE_TEST_OK(struct test_u16, test_u16_ok) = { 500 {"0", 10, 0}, 501 {"1", 10, 1}, 502 {"126", 10, 126}, 503 {"127", 10, 127}, 504 {"128", 10, 128}, 505 {"129", 10, 129}, 506 {"254", 10, 254}, 507 {"255", 10, 255}, 508 {"256", 10, 256}, 509 {"257", 10, 257}, 510 {"32766", 10, 32766}, 511 {"32767", 10, 32767}, 512 {"32768", 10, 32768}, 513 {"32769", 10, 32769}, 514 {"65534", 10, 65534}, 515 {"65535", 10, 65535}, 516 }; 517 TEST_OK(kstrtou16, u16, "%hu", test_u16_ok); 518} 519 520static 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 547static void __init test_kstrtos16_ok(void) 548{ 549 DECLARE_TEST_OK(s16, struct test_s16); 550 static DEFINE_TEST_OK(struct test_s16, test_s16_ok) = { 551 {"-130", 10, -130}, 552 {"-129", 10, -129}, 553 {"-128", 10, -128}, 554 {"-127", 10, -127}, 555 {"-1", 10, -1}, 556 {"0", 10, 0}, 557 {"1", 10, 1}, 558 {"126", 10, 126}, 559 {"127", 10, 127}, 560 {"128", 10, 128}, 561 {"129", 10, 129}, 562 {"254", 10, 254}, 563 {"255", 10, 255}, 564 {"256", 10, 256}, 565 {"257", 10, 257}, 566 {"32766", 10, 32766}, 567 {"32767", 10, 32767}, 568 }; 569 TEST_OK(kstrtos16, s16, "%hd", test_s16_ok); 570} 571 572static 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 601static void __init test_kstrtou8_ok(void) 602{ 603 DECLARE_TEST_OK(u8, struct test_u8); 604 static DEFINE_TEST_OK(struct test_u8, test_u8_ok) = { 605 {"0", 10, 0}, 606 {"1", 10, 1}, 607 {"126", 10, 126}, 608 {"127", 10, 127}, 609 {"128", 10, 128}, 610 {"129", 10, 129}, 611 {"254", 10, 254}, 612 {"255", 10, 255}, 613 }; 614 TEST_OK(kstrtou8, u8, "%hhu", test_u8_ok); 615} 616 617static 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 652static void __init test_kstrtos8_ok(void) 653{ 654 DECLARE_TEST_OK(s8, struct test_s8); 655 static DEFINE_TEST_OK(struct test_s8, test_s8_ok) = { 656 {"-128", 10, -128}, 657 {"-127", 10, -127}, 658 {"-1", 10, -1}, 659 {"0", 10, 0}, 660 {"1", 10, 1}, 661 {"126", 10, 126}, 662 {"127", 10, 127}, 663 }; 664 TEST_OK(kstrtos8, s8, "%hhd", test_s8_ok); 665} 666 667static 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 706static 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} 734module_init(test_kstrtox_init); 735MODULE_LICENSE("Dual BSD/GPL"); 736