1 /* 2 * cutils.c unit-tests 3 * 4 * Copyright Red Hat 5 * 6 * Authors: 7 * Eduardo Habkost <ehabkost@redhat.com> 8 * 9 * Permission is hereby granted, free of charge, to any person obtaining a copy 10 * of this software and associated documentation files (the "Software"), to deal 11 * in the Software without restriction, including without limitation the rights 12 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 13 * copies of the Software, and to permit persons to whom the Software is 14 * furnished to do so, subject to the following conditions: 15 * 16 * The above copyright notice and this permission notice shall be included in 17 * all copies or substantial portions of the Software. 18 * 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 22 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 23 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 24 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 25 * THE SOFTWARE. 26 */ 27 28 #include "qemu/osdep.h" 29 #include "qemu/cutils.h" 30 #include "qemu/units.h" 31 32 static void test_parse_uint_null(void) 33 { 34 unsigned long long i = 999; 35 char f = 'X'; 36 char *endptr = &f; 37 int r; 38 39 r = parse_uint(NULL, &i, &endptr, 0); 40 41 g_assert_cmpint(r, ==, -EINVAL); 42 g_assert_cmpuint(i, ==, 0); 43 g_assert_null(endptr); 44 } 45 46 static void test_parse_uint_empty(void) 47 { 48 unsigned long long i = 999; 49 char f = 'X'; 50 char *endptr = &f; 51 const char *str = ""; 52 int r; 53 54 r = parse_uint(str, &i, &endptr, 0); 55 56 g_assert_cmpint(r, ==, -EINVAL); 57 g_assert_cmpuint(i, ==, 0); 58 g_assert_true(endptr == str); 59 } 60 61 static void test_parse_uint_whitespace(void) 62 { 63 unsigned long long i = 999; 64 char f = 'X'; 65 char *endptr = &f; 66 const char *str = " \t "; 67 int r; 68 69 r = parse_uint(str, &i, &endptr, 0); 70 71 g_assert_cmpint(r, ==, -EINVAL); 72 g_assert_cmpuint(i, ==, 0); 73 g_assert_true(endptr == str); 74 } 75 76 77 static void test_parse_uint_invalid(void) 78 { 79 unsigned long long i = 999; 80 char f = 'X'; 81 char *endptr = &f; 82 const char *str = " \t xxx"; 83 int r; 84 85 r = parse_uint(str, &i, &endptr, 0); 86 87 g_assert_cmpint(r, ==, -EINVAL); 88 g_assert_cmpuint(i, ==, 0); 89 g_assert_true(endptr == str); 90 } 91 92 93 static void test_parse_uint_trailing(void) 94 { 95 unsigned long long i = 999; 96 char f = 'X'; 97 char *endptr = &f; 98 const char *str = "123xxx"; 99 int r; 100 101 r = parse_uint(str, &i, &endptr, 0); 102 103 g_assert_cmpint(r, ==, 0); 104 g_assert_cmpuint(i, ==, 123); 105 g_assert_true(endptr == str + 3); 106 } 107 108 static void test_parse_uint_correct(void) 109 { 110 unsigned long long i = 999; 111 char f = 'X'; 112 char *endptr = &f; 113 const char *str = "123"; 114 int r; 115 116 r = parse_uint(str, &i, &endptr, 0); 117 118 g_assert_cmpint(r, ==, 0); 119 g_assert_cmpuint(i, ==, 123); 120 g_assert_true(endptr == str + strlen(str)); 121 } 122 123 static void test_parse_uint_octal(void) 124 { 125 unsigned long long i = 999; 126 char f = 'X'; 127 char *endptr = &f; 128 const char *str = "0123"; 129 int r; 130 131 r = parse_uint(str, &i, &endptr, 0); 132 133 g_assert_cmpint(r, ==, 0); 134 g_assert_cmpuint(i, ==, 0123); 135 g_assert_true(endptr == str + strlen(str)); 136 } 137 138 static void test_parse_uint_decimal(void) 139 { 140 unsigned long long i = 999; 141 char f = 'X'; 142 char *endptr = &f; 143 const char *str = "0123"; 144 int r; 145 146 r = parse_uint(str, &i, &endptr, 10); 147 148 g_assert_cmpint(r, ==, 0); 149 g_assert_cmpuint(i, ==, 123); 150 g_assert_true(endptr == str + strlen(str)); 151 } 152 153 static void test_parse_uint_llong_max(void) 154 { 155 unsigned long long i = 999; 156 char f = 'X'; 157 char *endptr = &f; 158 char *str = g_strdup_printf("%llu", (unsigned long long)LLONG_MAX + 1); 159 int r; 160 161 r = parse_uint(str, &i, &endptr, 0); 162 163 g_assert_cmpint(r, ==, 0); 164 g_assert_cmpuint(i, ==, (unsigned long long)LLONG_MAX + 1); 165 g_assert_true(endptr == str + strlen(str)); 166 167 g_free(str); 168 } 169 170 static void test_parse_uint_max(void) 171 { 172 unsigned long long i = 999; 173 char f = 'X'; 174 char *endptr = &f; 175 char *str = g_strdup_printf("%llu", ULLONG_MAX); 176 int r; 177 178 r = parse_uint(str, &i, &endptr, 0); 179 180 g_assert_cmpint(r, ==, 0); 181 g_assert_cmpuint(i, ==, ULLONG_MAX); 182 g_assert_true(endptr == str + strlen(str)); 183 184 g_free(str); 185 } 186 187 static void test_parse_uint_overflow(void) 188 { 189 unsigned long long i; 190 char f = 'X'; 191 char *endptr; 192 const char *str; 193 int r; 194 195 i = 999; 196 endptr = &f; 197 str = "99999999999999999999999999999999999999"; 198 r = parse_uint(str, &i, &endptr, 0); 199 g_assert_cmpint(r, ==, -ERANGE); 200 g_assert_cmpuint(i, ==, ULLONG_MAX); 201 g_assert_true(endptr == str + strlen(str)); 202 203 i = 999; 204 endptr = &f; 205 str = "0x10000000000000000"; /* 65 bits, 64-bit sign bit clear */ 206 r = parse_uint(str, &i, &endptr, 0); 207 g_assert_cmpint(r, ==, -ERANGE); 208 g_assert_cmpuint(i, ==, ULLONG_MAX); 209 g_assert_true(endptr == str + strlen(str)); 210 211 i = 999; 212 endptr = &f; 213 str = "0x18000000080000000"; /* 65 bits, 64-bit sign bit set */ 214 r = parse_uint(str, &i, &endptr, 0); 215 g_assert_cmpint(r, ==, -ERANGE); 216 g_assert_cmpuint(i, ==, ULLONG_MAX); 217 g_assert_true(endptr == str + strlen(str)); 218 } 219 220 static void test_parse_uint_negative(void) 221 { 222 unsigned long long i; 223 char f = 'X'; 224 char *endptr; 225 const char *str; 226 int r; 227 228 i = 999; 229 endptr = &f; 230 str = " \t -321"; 231 r = parse_uint(str, &i, &endptr, 0); 232 g_assert_cmpint(r, ==, -ERANGE); 233 g_assert_cmpuint(i, ==, 0); 234 g_assert_true(endptr == str + strlen(str)); 235 236 i = 999; 237 endptr = &f; 238 str = "-0xffffffff00000001"; 239 r = parse_uint(str, &i, &endptr, 0); 240 g_assert_cmpint(r, ==, -ERANGE); 241 g_assert_cmpuint(i, ==, 0); 242 g_assert_true(endptr == str + strlen(str)); 243 } 244 245 static void test_parse_uint_negzero(void) 246 { 247 unsigned long long i = 999; 248 char f = 'X'; 249 char *endptr = &f; 250 const char *str = " -0"; 251 int r; 252 253 r = parse_uint(str, &i, &endptr, 0); 254 255 g_assert_cmpint(r, ==, -ERANGE); 256 g_assert_cmpuint(i, ==, 0); 257 g_assert_true(endptr == str + strlen(str)); 258 } 259 260 static void test_parse_uint_full_trailing(void) 261 { 262 unsigned long long i = 999; 263 const char *str = "123xxx"; 264 int r; 265 266 r = parse_uint_full(str, &i, 0); 267 268 g_assert_cmpint(r, ==, -EINVAL); 269 g_assert_cmpuint(i, ==, 0); 270 } 271 272 static void test_parse_uint_full_correct(void) 273 { 274 unsigned long long i = 999; 275 const char *str = "123"; 276 int r; 277 278 r = parse_uint_full(str, &i, 0); 279 280 g_assert_cmpint(r, ==, 0); 281 g_assert_cmpuint(i, ==, 123); 282 } 283 284 static void test_parse_uint_full_erange_junk(void) 285 { 286 /* FIXME - inconsistent with qemu_strto* which favors EINVAL */ 287 unsigned long long i = 999; 288 const char *str = "-2junk"; 289 int r; 290 291 r = parse_uint_full(str, &i, 0); 292 293 g_assert_cmpint(r, ==, -ERANGE /* FIXME -EINVAL */); 294 g_assert_cmpuint(i, ==, 0); 295 } 296 297 static void test_qemu_strtoi_correct(void) 298 { 299 const char *str = "12345 foo"; 300 char f = 'X'; 301 const char *endptr = &f; 302 int res = 999; 303 int err; 304 305 err = qemu_strtoi(str, &endptr, 0, &res); 306 307 g_assert_cmpint(err, ==, 0); 308 g_assert_cmpint(res, ==, 12345); 309 g_assert_true(endptr == str + 5); 310 } 311 312 static void test_qemu_strtoi_null(void) 313 { 314 char f = 'X'; 315 const char *endptr = &f; 316 int res = 999; 317 int err; 318 319 err = qemu_strtoi(NULL, &endptr, 0, &res); 320 321 g_assert_cmpint(err, ==, -EINVAL); 322 g_assert_cmpint(res, ==, 999); 323 g_assert_null(endptr); 324 } 325 326 static void test_qemu_strtoi_empty(void) 327 { 328 const char *str = ""; 329 char f = 'X'; 330 const char *endptr = &f; 331 int res = 999; 332 int err; 333 334 err = qemu_strtoi(str, &endptr, 0, &res); 335 336 g_assert_cmpint(err, ==, -EINVAL); 337 g_assert_cmpint(res, ==, 0); 338 g_assert_true(endptr == str); 339 } 340 341 static void test_qemu_strtoi_whitespace(void) 342 { 343 const char *str = " \t "; 344 char f = 'X'; 345 const char *endptr = &f; 346 int res = 999; 347 int err; 348 349 err = qemu_strtoi(str, &endptr, 0, &res); 350 351 g_assert_cmpint(err, ==, -EINVAL); 352 g_assert_cmpint(res, ==, 0); 353 g_assert_true(endptr == str); 354 } 355 356 static void test_qemu_strtoi_invalid(void) 357 { 358 const char *str = " xxxx \t abc"; 359 char f = 'X'; 360 const char *endptr = &f; 361 int res = 999; 362 int err; 363 364 err = qemu_strtoi(str, &endptr, 0, &res); 365 366 g_assert_cmpint(err, ==, -EINVAL); 367 g_assert_cmpint(res, ==, 0); 368 g_assert_true(endptr == str); 369 } 370 371 static void test_qemu_strtoi_trailing(void) 372 { 373 const char *str = "123xxx"; 374 char f = 'X'; 375 const char *endptr = &f; 376 int res = 999; 377 int err; 378 379 err = qemu_strtoi(str, &endptr, 0, &res); 380 381 g_assert_cmpint(err, ==, 0); 382 g_assert_cmpint(res, ==, 123); 383 g_assert_true(endptr == str + 3); 384 } 385 386 static void test_qemu_strtoi_octal(void) 387 { 388 const char *str = "0123"; 389 char f = 'X'; 390 const char *endptr = &f; 391 int res = 999; 392 int err; 393 394 err = qemu_strtoi(str, &endptr, 8, &res); 395 396 g_assert_cmpint(err, ==, 0); 397 g_assert_cmpint(res, ==, 0123); 398 g_assert_true(endptr == str + strlen(str)); 399 400 res = 999; 401 endptr = &f; 402 err = qemu_strtoi(str, &endptr, 0, &res); 403 404 g_assert_cmpint(err, ==, 0); 405 g_assert_cmpint(res, ==, 0123); 406 g_assert_true(endptr == str + strlen(str)); 407 } 408 409 static void test_qemu_strtoi_decimal(void) 410 { 411 const char *str = "0123"; 412 char f = 'X'; 413 const char *endptr = &f; 414 int res = 999; 415 int err; 416 417 err = qemu_strtoi(str, &endptr, 10, &res); 418 419 g_assert_cmpint(err, ==, 0); 420 g_assert_cmpint(res, ==, 123); 421 g_assert_true(endptr == str + strlen(str)); 422 423 str = "123"; 424 res = 999; 425 endptr = &f; 426 err = qemu_strtoi(str, &endptr, 0, &res); 427 428 g_assert_cmpint(err, ==, 0); 429 g_assert_cmpint(res, ==, 123); 430 g_assert_true(endptr == str + strlen(str)); 431 } 432 433 static void test_qemu_strtoi_hex(void) 434 { 435 const char *str = "0123"; 436 char f = 'X'; 437 const char *endptr = &f; 438 int res = 999; 439 int err; 440 441 err = qemu_strtoi(str, &endptr, 16, &res); 442 443 g_assert_cmpint(err, ==, 0); 444 g_assert_cmpint(res, ==, 0x123); 445 g_assert_true(endptr == str + strlen(str)); 446 447 str = "0x123"; 448 res = 999; 449 endptr = &f; 450 err = qemu_strtoi(str, &endptr, 0, &res); 451 452 g_assert_cmpint(err, ==, 0); 453 g_assert_cmpint(res, ==, 0x123); 454 g_assert_true(endptr == str + strlen(str)); 455 456 str = "0x"; 457 res = 999; 458 endptr = &f; 459 err = qemu_strtoi(str, &endptr, 16, &res); 460 461 g_assert_cmpint(err, ==, 0); 462 g_assert_cmpint(res, ==, 0); 463 g_assert_true(endptr == str + 1); 464 } 465 466 static void test_qemu_strtoi_max(void) 467 { 468 char *str = g_strdup_printf("%d", INT_MAX); 469 char f = 'X'; 470 const char *endptr = &f; 471 int res = 999; 472 int err; 473 474 err = qemu_strtoi(str, &endptr, 0, &res); 475 476 g_assert_cmpint(err, ==, 0); 477 g_assert_cmpint(res, ==, INT_MAX); 478 g_assert_true(endptr == str + strlen(str)); 479 g_free(str); 480 } 481 482 static void test_qemu_strtoi_overflow(void) 483 { 484 const char *str; 485 const char *endptr; 486 int res; 487 int err; 488 489 str = "2147483648"; /* INT_MAX + 1ll */ 490 endptr = "somewhere"; 491 res = 999; 492 err = qemu_strtoi(str, &endptr, 0, &res); 493 g_assert_cmpint(err, ==, -ERANGE); 494 g_assert_cmpint(res, ==, INT_MAX); 495 g_assert_true(endptr == str + strlen(str)); 496 497 str = "0x7fffffffffffffff"; /* LLONG_MAX */ 498 endptr = "somewhere"; 499 res = 999; 500 err = qemu_strtoi(str, &endptr, 0, &res); 501 g_assert_cmpint(err, ==, -ERANGE); 502 g_assert_cmpint(res, ==, INT_MAX); 503 g_assert_true(endptr == str + strlen(str)); 504 505 str = "0x8000000000000000"; /* (uint64_t)LLONG_MIN */ 506 endptr = "somewhere"; 507 res = 999; 508 err = qemu_strtoi(str, &endptr, 0, &res); 509 g_assert_cmpint(err, ==, -ERANGE); 510 g_assert_cmpint(res, ==, INT_MAX); 511 g_assert_true(endptr == str + strlen(str)); 512 513 str = "0x10000000000000000"; /* 65 bits, 32-bit sign bit clear */ 514 endptr = "somewhere"; 515 res = 999; 516 err = qemu_strtoi(str, &endptr, 0, &res); 517 g_assert_cmpint(err, ==, -ERANGE); 518 g_assert_cmpint(res, ==, INT_MAX); 519 g_assert_true(endptr == str + strlen(str)); 520 521 str = "0x18000000080000000"; /* 65 bits, 32-bit sign bit set */ 522 endptr = "somewhere"; 523 res = 999; 524 err = qemu_strtoi(str, &endptr, 0, &res); 525 g_assert_cmpint(err, ==, -ERANGE); 526 g_assert_cmpint(res, ==, INT_MAX); 527 g_assert_true(endptr == str + strlen(str)); 528 } 529 530 static void test_qemu_strtoi_min(void) 531 { 532 char *str = g_strdup_printf("%d", INT_MIN); 533 char f = 'X'; 534 const char *endptr = &f; 535 int res = 999; 536 int err; 537 538 err = qemu_strtoi(str, &endptr, 0, &res); 539 540 g_assert_cmpint(err, ==, 0); 541 g_assert_cmpint(res, ==, INT_MIN); 542 g_assert_true(endptr == str + strlen(str)); 543 g_free(str); 544 } 545 546 static void test_qemu_strtoi_underflow(void) 547 { 548 const char *str; 549 const char *endptr; 550 int res; 551 int err; 552 553 str = "-2147483649"; /* INT_MIN - 1ll */ 554 endptr = "somewhere"; 555 res = 999; 556 err = qemu_strtoi(str, &endptr, 0, &res); 557 g_assert_cmpint(err, ==, -ERANGE); 558 g_assert_cmpint(res, ==, INT_MIN); 559 g_assert_true(endptr == str + strlen(str)); 560 561 str = "-0x7fffffffffffffff"; /* -LLONG_MAX */ 562 endptr = "somewhere"; 563 res = 999; 564 err = qemu_strtoi(str, &endptr, 0, &res); 565 g_assert_cmpint(err, ==, -ERANGE); 566 g_assert_cmpint(res, ==, INT_MIN); 567 g_assert_true(endptr == str + strlen(str)); 568 569 str = "-0x8000000000000000"; /* (uint64_t)LLONG_MIN */ 570 endptr = "somewhere"; 571 res = 999; 572 err = qemu_strtoi(str, &endptr, 0, &res); 573 g_assert_cmpint(err, ==, -ERANGE); 574 g_assert_cmpint(res, ==, INT_MIN); 575 g_assert_true(endptr == str + strlen(str)); 576 577 str = "-18446744073709551615"; /* -UINT64_MAX (not 1) */ 578 endptr = "somewhere"; 579 res = 999; 580 err = qemu_strtoi(str, &endptr, 0, &res); 581 g_assert_cmpint(err, ==, -ERANGE); 582 g_assert_cmpint(res, ==, INT_MIN); 583 g_assert_true(endptr == str + strlen(str)); 584 585 str = "-0x10000000000000000"; /* 65 bits, 32-bit sign bit clear */ 586 endptr = "somewhere"; 587 res = 999; 588 err = qemu_strtoi(str, &endptr, 0, &res); 589 g_assert_cmpint(err, ==, -ERANGE); 590 g_assert_cmpint(res, ==, INT_MIN); 591 g_assert_true(endptr == str + strlen(str)); 592 593 str = "-0x18000000080000000"; /* 65 bits, 32-bit sign bit set */ 594 endptr = "somewhere"; 595 res = 999; 596 err = qemu_strtoi(str, &endptr, 0, &res); 597 g_assert_cmpint(err, ==, -ERANGE); 598 g_assert_cmpint(res, ==, INT_MIN); 599 g_assert_true(endptr == str + strlen(str)); 600 } 601 602 static void test_qemu_strtoi_negative(void) 603 { 604 const char *str; 605 const char *endptr; 606 int res; 607 int err; 608 609 str = " \t -321"; 610 endptr = "somewhere"; 611 res = 999; 612 err = qemu_strtoi(str, &endptr, 0, &res); 613 g_assert_cmpint(err, ==, 0); 614 g_assert_cmpint(res, ==, -321); 615 g_assert_true(endptr == str + strlen(str)); 616 617 str = "-2147483648"; /* INT_MIN */ 618 endptr = "somewhere"; 619 res = 999; 620 err = qemu_strtoi(str, &endptr, 0, &res); 621 g_assert_cmpint(err, ==, 0); 622 g_assert_cmpint(res, ==, INT_MIN); 623 g_assert_true(endptr == str + strlen(str)); 624 } 625 626 static void test_qemu_strtoi_negzero(void) 627 { 628 const char *str = " -0"; 629 char f = 'X'; 630 const char *endptr = &f; 631 int res = 999; 632 int err; 633 634 err = qemu_strtoi(str, &endptr, 0, &res); 635 636 g_assert_cmpint(err, ==, 0); 637 g_assert_cmpint(res, ==, 0); 638 g_assert_true(endptr == str + strlen(str)); 639 } 640 641 static void test_qemu_strtoi_full_correct(void) 642 { 643 const char *str = "123"; 644 int res = 999; 645 int err; 646 647 err = qemu_strtoi(str, NULL, 0, &res); 648 649 g_assert_cmpint(err, ==, 0); 650 g_assert_cmpint(res, ==, 123); 651 } 652 653 static void test_qemu_strtoi_full_null(void) 654 { 655 char f = 'X'; 656 const char *endptr = &f; 657 int res = 999; 658 int err; 659 660 err = qemu_strtoi(NULL, &endptr, 0, &res); 661 662 g_assert_cmpint(err, ==, -EINVAL); 663 g_assert_cmpint(res, ==, 999); 664 g_assert_null(endptr); 665 } 666 667 static void test_qemu_strtoi_full_empty(void) 668 { 669 const char *str = ""; 670 int res = 999; 671 int err; 672 673 err = qemu_strtoi(str, NULL, 0, &res); 674 675 g_assert_cmpint(err, ==, -EINVAL); 676 g_assert_cmpint(res, ==, 0); 677 } 678 679 static void test_qemu_strtoi_full_negative(void) 680 { 681 const char *str = " \t -321"; 682 int res = 999; 683 int err; 684 685 err = qemu_strtoi(str, NULL, 0, &res); 686 687 g_assert_cmpint(err, ==, 0); 688 g_assert_cmpint(res, ==, -321); 689 } 690 691 static void test_qemu_strtoi_full_negzero(void) 692 { 693 const char *str = " -0"; 694 int res = 999; 695 int err; 696 697 err = qemu_strtoi(str, NULL, 0, &res); 698 699 g_assert_cmpint(err, ==, 0); 700 g_assert_cmpint(res, ==, 0); 701 } 702 703 static void test_qemu_strtoi_full_trailing(void) 704 { 705 const char *str = "123xxx"; 706 int res = 999; 707 int err; 708 709 err = qemu_strtoi(str, NULL, 0, &res); 710 711 g_assert_cmpint(err, ==, -EINVAL); 712 g_assert_cmpint(res, ==, 123); 713 } 714 715 static void test_qemu_strtoi_full_max(void) 716 { 717 char *str = g_strdup_printf("%d", INT_MAX); 718 int res = 999; 719 int err; 720 721 err = qemu_strtoi(str, NULL, 0, &res); 722 723 g_assert_cmpint(err, ==, 0); 724 g_assert_cmpint(res, ==, INT_MAX); 725 g_free(str); 726 } 727 728 static void test_qemu_strtoi_full_erange_junk(void) 729 { 730 /* EINVAL has priority over ERANGE */ 731 const char *str = "-9999999999junk"; 732 int res = 999; 733 int err; 734 735 err = qemu_strtoi(str, NULL, 0, &res); 736 737 g_assert_cmpint(err, ==, -EINVAL); 738 g_assert_cmpint(res, ==, INT_MIN); 739 } 740 741 static void test_qemu_strtoui_correct(void) 742 { 743 const char *str = "12345 foo"; 744 char f = 'X'; 745 const char *endptr = &f; 746 unsigned int res = 999; 747 int err; 748 749 err = qemu_strtoui(str, &endptr, 0, &res); 750 751 g_assert_cmpint(err, ==, 0); 752 g_assert_cmpuint(res, ==, 12345); 753 g_assert_true(endptr == str + 5); 754 } 755 756 static void test_qemu_strtoui_null(void) 757 { 758 char f = 'X'; 759 const char *endptr = &f; 760 unsigned int res = 999; 761 int err; 762 763 err = qemu_strtoui(NULL, &endptr, 0, &res); 764 765 g_assert_cmpint(err, ==, -EINVAL); 766 g_assert_cmpuint(res, ==, 999); 767 g_assert_null(endptr); 768 } 769 770 static void test_qemu_strtoui_empty(void) 771 { 772 const char *str = ""; 773 char f = 'X'; 774 const char *endptr = &f; 775 unsigned int res = 999; 776 int err; 777 778 err = qemu_strtoui(str, &endptr, 0, &res); 779 780 g_assert_cmpint(err, ==, -EINVAL); 781 g_assert_cmpuint(res, ==, 0); 782 g_assert_true(endptr == str); 783 } 784 785 static void test_qemu_strtoui_whitespace(void) 786 { 787 const char *str = " \t "; 788 char f = 'X'; 789 const char *endptr = &f; 790 unsigned int res = 999; 791 int err; 792 793 err = qemu_strtoui(str, &endptr, 0, &res); 794 795 g_assert_cmpint(err, ==, -EINVAL); 796 g_assert_cmpuint(res, ==, 0); 797 g_assert_true(endptr == str); 798 } 799 800 static void test_qemu_strtoui_invalid(void) 801 { 802 const char *str = " xxxx \t abc"; 803 char f = 'X'; 804 const char *endptr = &f; 805 unsigned int res = 999; 806 int err; 807 808 err = qemu_strtoui(str, &endptr, 0, &res); 809 810 g_assert_cmpint(err, ==, -EINVAL); 811 g_assert_cmpuint(res, ==, 0); 812 g_assert_true(endptr == str); 813 } 814 815 static void test_qemu_strtoui_trailing(void) 816 { 817 const char *str = "123xxx"; 818 char f = 'X'; 819 const char *endptr = &f; 820 unsigned int res = 999; 821 int err; 822 823 err = qemu_strtoui(str, &endptr, 0, &res); 824 825 g_assert_cmpint(err, ==, 0); 826 g_assert_cmpuint(res, ==, 123); 827 g_assert_true(endptr == str + 3); 828 } 829 830 static void test_qemu_strtoui_octal(void) 831 { 832 const char *str = "0123"; 833 char f = 'X'; 834 const char *endptr = &f; 835 unsigned int res = 999; 836 int err; 837 838 err = qemu_strtoui(str, &endptr, 8, &res); 839 840 g_assert_cmpint(err, ==, 0); 841 g_assert_cmpuint(res, ==, 0123); 842 g_assert_true(endptr == str + strlen(str)); 843 844 res = 999; 845 endptr = &f; 846 err = qemu_strtoui(str, &endptr, 0, &res); 847 848 g_assert_cmpint(err, ==, 0); 849 g_assert_cmpuint(res, ==, 0123); 850 g_assert_true(endptr == str + strlen(str)); 851 } 852 853 static void test_qemu_strtoui_decimal(void) 854 { 855 const char *str = "0123"; 856 char f = 'X'; 857 const char *endptr = &f; 858 unsigned int res = 999; 859 int err; 860 861 err = qemu_strtoui(str, &endptr, 10, &res); 862 863 g_assert_cmpint(err, ==, 0); 864 g_assert_cmpuint(res, ==, 123); 865 g_assert_true(endptr == str + strlen(str)); 866 867 str = "123"; 868 res = 999; 869 endptr = &f; 870 err = qemu_strtoui(str, &endptr, 0, &res); 871 872 g_assert_cmpint(err, ==, 0); 873 g_assert_cmpuint(res, ==, 123); 874 g_assert_true(endptr == str + strlen(str)); 875 } 876 877 static void test_qemu_strtoui_hex(void) 878 { 879 const char *str = "0123"; 880 char f = 'X'; 881 const char *endptr = &f; 882 unsigned int res = 999; 883 int err; 884 885 err = qemu_strtoui(str, &endptr, 16, &res); 886 887 g_assert_cmpint(err, ==, 0); 888 g_assert_cmphex(res, ==, 0x123); 889 g_assert_true(endptr == str + strlen(str)); 890 891 str = "0x123"; 892 res = 999; 893 endptr = &f; 894 err = qemu_strtoui(str, &endptr, 0, &res); 895 896 g_assert_cmpint(err, ==, 0); 897 g_assert_cmphex(res, ==, 0x123); 898 g_assert_true(endptr == str + strlen(str)); 899 900 str = "0x"; 901 res = 999; 902 endptr = &f; 903 err = qemu_strtoui(str, &endptr, 16, &res); 904 905 g_assert_cmpint(err, ==, 0); 906 g_assert_cmphex(res, ==, 0); 907 g_assert_true(endptr == str + 1); 908 } 909 910 static void test_qemu_strtoui_wrap(void) 911 { 912 /* wraparound is consistent with 32-bit strtoul */ 913 const char *str = "-4294967295"; /* 1 mod 2^32 */ 914 char f = 'X'; 915 const char *endptr = &f; 916 unsigned int res = 999; 917 int err; 918 919 err = qemu_strtoui(str, &endptr, 0, &res); 920 921 g_assert_cmpint(err, ==, 0); 922 g_assert_cmphex(res, ==, 1); 923 g_assert_true(endptr == str + strlen(str)); 924 } 925 926 static void test_qemu_strtoui_max(void) 927 { 928 char *str = g_strdup_printf("%u", UINT_MAX); 929 char f = 'X'; 930 const char *endptr = &f; 931 unsigned int res = 999; 932 int err; 933 934 err = qemu_strtoui(str, &endptr, 0, &res); 935 936 g_assert_cmpint(err, ==, 0); 937 g_assert_cmphex(res, ==, UINT_MAX); 938 g_assert_true(endptr == str + strlen(str)); 939 g_free(str); 940 } 941 942 static void test_qemu_strtoui_overflow(void) 943 { 944 const char *str; 945 const char *endptr; 946 unsigned int res; 947 int err; 948 949 str = "4294967296"; /* UINT_MAX + 1ll */ 950 endptr = "somewhere"; 951 res = 999; 952 err = qemu_strtoui(str, &endptr, 0, &res); 953 g_assert_cmpint(err, ==, -ERANGE); 954 g_assert_cmpuint(res, ==, UINT_MAX); 955 g_assert_true(endptr == str + strlen(str)); 956 957 str = "0x7fffffffffffffff"; /* LLONG_MAX */ 958 endptr = "somewhere"; 959 res = 999; 960 err = qemu_strtoui(str, &endptr, 0, &res); 961 g_assert_cmpint(err, ==, -ERANGE); 962 g_assert_cmpuint(res, ==, UINT_MAX); 963 g_assert_true(endptr == str + strlen(str)); 964 965 str = "0x8000000000000000"; /* (uint64_t)LLONG_MIN */ 966 endptr = "somewhere"; 967 res = 999; 968 err = qemu_strtoui(str, &endptr, 0, &res); 969 g_assert_cmpint(err, ==, -ERANGE); 970 g_assert_cmpuint(res, ==, UINT_MAX); 971 g_assert_true(endptr == str + strlen(str)); 972 973 str = "0xffffffff00000001"; /* ULLONG_MAX - UINT_MAX + 1 (not 1) */ 974 endptr = "somewhere"; 975 res = 999; 976 err = qemu_strtoui(str, &endptr, 0, &res); 977 g_assert_cmpint(err, ==, -ERANGE); 978 g_assert_cmpuint(res, ==, UINT_MAX); 979 g_assert_true(endptr == str + strlen(str)); 980 981 str = "0xfffffffffffffffe"; /* ULLONG_MAX - 1 (not UINT_MAX - 1) */ 982 endptr = "somewhere"; 983 res = 999; 984 err = qemu_strtoui(str, &endptr, 0, &res); 985 g_assert_cmpint(err, ==, -ERANGE); 986 g_assert_cmpuint(res, ==, UINT_MAX); 987 g_assert_true(endptr == str + strlen(str)); 988 989 str = "0x10000000000000000"; /* 65 bits, 32-bit sign bit clear */ 990 endptr = "somewhere"; 991 res = 999; 992 err = qemu_strtoui(str, &endptr, 0, &res); 993 g_assert_cmpint(err, ==, -ERANGE); 994 g_assert_cmpuint(res, ==, UINT_MAX); 995 g_assert_true(endptr == str + strlen(str)); 996 997 str = "0x18000000080000000"; /* 65 bits, 32-bit sign bit set */ 998 endptr = "somewhere"; 999 res = 999; 1000 err = qemu_strtoui(str, &endptr, 0, &res); 1001 g_assert_cmpint(err, ==, -ERANGE); 1002 g_assert_cmpuint(res, ==, UINT_MAX); 1003 g_assert_true(endptr == str + strlen(str)); 1004 } 1005 1006 static void test_qemu_strtoui_underflow(void) 1007 { 1008 const char *str; 1009 const char *endptr; 1010 unsigned int res; 1011 int err; 1012 1013 str = "-4294967296"; /* -(long long)UINT_MAX - 1ll */ 1014 endptr = "somewhere"; 1015 res = 999; 1016 err = qemu_strtoui(str, &endptr, 0, &res); 1017 g_assert_cmpint(err, ==, -ERANGE); 1018 g_assert_cmpuint(res, ==, UINT_MAX); 1019 g_assert_true(endptr == str + strlen(str)); 1020 1021 str = "-18446744073709551615"; /* -UINT64_MAX (not -(-1)) */ 1022 endptr = "somewhere"; 1023 res = 999; 1024 err = qemu_strtoui(str, &endptr, 0, &res); 1025 g_assert_cmpint(err, ==, -ERANGE); 1026 g_assert_cmpuint(res, ==, UINT_MAX); 1027 g_assert_true(endptr == str + strlen(str)); 1028 1029 str = "-0xffffffff00000002"; 1030 endptr = "somewhere"; 1031 res = 999; 1032 err = qemu_strtoui(str, &endptr, 0, &res); 1033 g_assert_cmpint(err, ==, -ERANGE); 1034 g_assert_cmpuint(res, ==, UINT_MAX); 1035 g_assert_true(endptr == str + strlen(str)); 1036 1037 str = "-0x10000000000000000"; /* 65 bits, 32-bit sign bit clear */ 1038 endptr = "somewhere"; 1039 res = 999; 1040 err = qemu_strtoui(str, &endptr, 0, &res); 1041 g_assert_cmpint(err, ==, -ERANGE); 1042 g_assert_cmpuint(res, ==, UINT_MAX); 1043 g_assert_true(endptr == str + strlen(str)); 1044 1045 str = "-0x18000000080000000"; /* 65 bits, 32-bit sign bit set */ 1046 endptr = "somewhere"; 1047 res = 999; 1048 err = qemu_strtoui(str, &endptr, 0, &res); 1049 g_assert_cmpint(err, ==, -ERANGE); 1050 g_assert_cmpuint(res, ==, UINT_MAX); 1051 g_assert_true(endptr == str + strlen(str)); 1052 } 1053 1054 static void test_qemu_strtoui_negative(void) 1055 { 1056 const char *str = " \t -321"; 1057 char f = 'X'; 1058 const char *endptr = &f; 1059 unsigned int res = 999; 1060 int err; 1061 1062 err = qemu_strtoui(str, &endptr, 0, &res); 1063 1064 g_assert_cmpint(err, ==, 0); 1065 g_assert_cmpuint(res, ==, (unsigned int)-321); 1066 g_assert_true(endptr == str + strlen(str)); 1067 } 1068 1069 static void test_qemu_strtoui_negzero(void) 1070 { 1071 const char *str = " -0"; 1072 char f = 'X'; 1073 const char *endptr = &f; 1074 unsigned int res = 999; 1075 int err; 1076 1077 err = qemu_strtoui(str, &endptr, 0, &res); 1078 1079 g_assert_cmpint(err, ==, 0); 1080 g_assert_cmpuint(res, ==, 0); 1081 g_assert_true(endptr == str + strlen(str)); 1082 } 1083 1084 static void test_qemu_strtoui_full_correct(void) 1085 { 1086 const char *str = "123"; 1087 unsigned int res = 999; 1088 int err; 1089 1090 err = qemu_strtoui(str, NULL, 0, &res); 1091 1092 g_assert_cmpint(err, ==, 0); 1093 g_assert_cmpuint(res, ==, 123); 1094 } 1095 1096 static void test_qemu_strtoui_full_null(void) 1097 { 1098 unsigned int res = 999; 1099 int err; 1100 1101 err = qemu_strtoui(NULL, NULL, 0, &res); 1102 1103 g_assert_cmpint(err, ==, -EINVAL); 1104 g_assert_cmpuint(res, ==, 999); 1105 } 1106 1107 static void test_qemu_strtoui_full_empty(void) 1108 { 1109 const char *str = ""; 1110 unsigned int res = 999; 1111 int err; 1112 1113 err = qemu_strtoui(str, NULL, 0, &res); 1114 1115 g_assert_cmpint(err, ==, -EINVAL); 1116 g_assert_cmpuint(res, ==, 0); 1117 } 1118 1119 static void test_qemu_strtoui_full_negative(void) 1120 { 1121 const char *str = " \t -321"; 1122 unsigned int res = 999; 1123 int err; 1124 1125 err = qemu_strtoui(str, NULL, 0, &res); 1126 g_assert_cmpint(err, ==, 0); 1127 g_assert_cmpuint(res, ==, (unsigned int)-321); 1128 } 1129 1130 static void test_qemu_strtoui_full_negzero(void) 1131 { 1132 const char *str = " -0"; 1133 unsigned int res = 999; 1134 int err; 1135 1136 err = qemu_strtoui(str, NULL, 0, &res); 1137 g_assert_cmpint(err, ==, 0); 1138 g_assert_cmpuint(res, ==, 0); 1139 } 1140 1141 static void test_qemu_strtoui_full_trailing(void) 1142 { 1143 const char *str = "123xxx"; 1144 unsigned int res = 999; 1145 int err; 1146 1147 err = qemu_strtoui(str, NULL, 0, &res); 1148 1149 g_assert_cmpint(err, ==, -EINVAL); 1150 g_assert_cmpuint(res, ==, 123); 1151 } 1152 1153 static void test_qemu_strtoui_full_max(void) 1154 { 1155 char *str = g_strdup_printf("%u", UINT_MAX); 1156 unsigned int res = 999; 1157 int err; 1158 1159 err = qemu_strtoui(str, NULL, 0, &res); 1160 1161 g_assert_cmpint(err, ==, 0); 1162 g_assert_cmphex(res, ==, UINT_MAX); 1163 g_free(str); 1164 } 1165 1166 static void test_qemu_strtoui_full_erange_junk(void) 1167 { 1168 /* EINVAL has priority over ERANGE */ 1169 const char *str = "-9999999999junk"; 1170 unsigned int res = 999; 1171 int err; 1172 1173 err = qemu_strtoui(str, NULL, 0, &res); 1174 1175 g_assert_cmpint(err, ==, -EINVAL); 1176 g_assert_cmpuint(res, ==, UINT_MAX); 1177 } 1178 1179 static void test_qemu_strtol_correct(void) 1180 { 1181 const char *str = "12345 foo"; 1182 char f = 'X'; 1183 const char *endptr = &f; 1184 long res = 999; 1185 int err; 1186 1187 err = qemu_strtol(str, &endptr, 0, &res); 1188 1189 g_assert_cmpint(err, ==, 0); 1190 g_assert_cmpint(res, ==, 12345); 1191 g_assert_true(endptr == str + 5); 1192 } 1193 1194 static void test_qemu_strtol_null(void) 1195 { 1196 char f = 'X'; 1197 const char *endptr = &f; 1198 long res = 999; 1199 int err; 1200 1201 err = qemu_strtol(NULL, &endptr, 0, &res); 1202 1203 g_assert_cmpint(err, ==, -EINVAL); 1204 g_assert_cmpint(res, ==, 999); 1205 g_assert_null(endptr); 1206 } 1207 1208 static void test_qemu_strtol_empty(void) 1209 { 1210 const char *str = ""; 1211 char f = 'X'; 1212 const char *endptr = &f; 1213 long res = 999; 1214 int err; 1215 1216 err = qemu_strtol(str, &endptr, 0, &res); 1217 1218 g_assert_cmpint(err, ==, -EINVAL); 1219 g_assert_cmpint(res, ==, 0); 1220 g_assert_true(endptr == str); 1221 } 1222 1223 static void test_qemu_strtol_whitespace(void) 1224 { 1225 const char *str = " \t "; 1226 char f = 'X'; 1227 const char *endptr = &f; 1228 long res = 999; 1229 int err; 1230 1231 err = qemu_strtol(str, &endptr, 0, &res); 1232 1233 g_assert_cmpint(err, ==, -EINVAL); 1234 g_assert_cmpint(res, ==, 0); 1235 g_assert_true(endptr == str); 1236 } 1237 1238 static void test_qemu_strtol_invalid(void) 1239 { 1240 const char *str = " xxxx \t abc"; 1241 char f = 'X'; 1242 const char *endptr = &f; 1243 long res = 999; 1244 int err; 1245 1246 err = qemu_strtol(str, &endptr, 0, &res); 1247 1248 g_assert_cmpint(err, ==, -EINVAL); 1249 g_assert_cmpint(res, ==, 0); 1250 g_assert_true(endptr == str); 1251 } 1252 1253 static void test_qemu_strtol_trailing(void) 1254 { 1255 const char *str = "123xxx"; 1256 char f = 'X'; 1257 const char *endptr = &f; 1258 long res = 999; 1259 int err; 1260 1261 err = qemu_strtol(str, &endptr, 0, &res); 1262 1263 g_assert_cmpint(err, ==, 0); 1264 g_assert_cmpint(res, ==, 123); 1265 g_assert_true(endptr == str + 3); 1266 } 1267 1268 static void test_qemu_strtol_octal(void) 1269 { 1270 const char *str = "0123"; 1271 char f = 'X'; 1272 const char *endptr = &f; 1273 long res = 999; 1274 int err; 1275 1276 err = qemu_strtol(str, &endptr, 8, &res); 1277 1278 g_assert_cmpint(err, ==, 0); 1279 g_assert_cmpint(res, ==, 0123); 1280 g_assert_true(endptr == str + strlen(str)); 1281 1282 res = 999; 1283 endptr = &f; 1284 err = qemu_strtol(str, &endptr, 0, &res); 1285 1286 g_assert_cmpint(err, ==, 0); 1287 g_assert_cmpint(res, ==, 0123); 1288 g_assert_true(endptr == str + strlen(str)); 1289 } 1290 1291 static void test_qemu_strtol_decimal(void) 1292 { 1293 const char *str = "0123"; 1294 char f = 'X'; 1295 const char *endptr = &f; 1296 long res = 999; 1297 int err; 1298 1299 err = qemu_strtol(str, &endptr, 10, &res); 1300 1301 g_assert_cmpint(err, ==, 0); 1302 g_assert_cmpint(res, ==, 123); 1303 g_assert_true(endptr == str + strlen(str)); 1304 1305 str = "123"; 1306 res = 999; 1307 endptr = &f; 1308 err = qemu_strtol(str, &endptr, 0, &res); 1309 1310 g_assert_cmpint(err, ==, 0); 1311 g_assert_cmpint(res, ==, 123); 1312 g_assert_true(endptr == str + strlen(str)); 1313 } 1314 1315 static void test_qemu_strtol_hex(void) 1316 { 1317 const char *str = "0123"; 1318 char f = 'X'; 1319 const char *endptr = &f; 1320 long res = 999; 1321 int err; 1322 1323 err = qemu_strtol(str, &endptr, 16, &res); 1324 1325 g_assert_cmpint(err, ==, 0); 1326 g_assert_cmpint(res, ==, 0x123); 1327 g_assert_true(endptr == str + strlen(str)); 1328 1329 str = "0x123"; 1330 res = 999; 1331 endptr = &f; 1332 err = qemu_strtol(str, &endptr, 0, &res); 1333 1334 g_assert_cmpint(err, ==, 0); 1335 g_assert_cmpint(res, ==, 0x123); 1336 g_assert_true(endptr == str + strlen(str)); 1337 1338 str = "0x"; 1339 res = 999; 1340 endptr = &f; 1341 err = qemu_strtol(str, &endptr, 16, &res); 1342 1343 g_assert_cmpint(err, ==, 0); 1344 g_assert_cmpint(res, ==, 0); 1345 g_assert_true(endptr == str + 1); 1346 } 1347 1348 static void test_qemu_strtol_max(void) 1349 { 1350 char *str = g_strdup_printf("%ld", LONG_MAX); 1351 char f = 'X'; 1352 const char *endptr = &f; 1353 long res = 999; 1354 int err; 1355 1356 err = qemu_strtol(str, &endptr, 0, &res); 1357 1358 g_assert_cmpint(err, ==, 0); 1359 g_assert_cmpint(res, ==, LONG_MAX); 1360 g_assert_true(endptr == str + strlen(str)); 1361 g_free(str); 1362 } 1363 1364 static void test_qemu_strtol_overflow(void) 1365 { 1366 const char *str; 1367 const char *endptr; 1368 long res; 1369 int err; 1370 1371 /* 1 more than LONG_MAX */ 1372 str = LONG_MAX == INT_MAX ? "2147483648" : "9223372036854775808"; 1373 endptr = "somewhere"; 1374 res = 999; 1375 err = qemu_strtol(str, &endptr, 0, &res); 1376 g_assert_cmpint(err, ==, -ERANGE); 1377 g_assert_cmpint(res, ==, LONG_MAX); 1378 g_assert_true(endptr == str + strlen(str)); 1379 1380 if (LONG_MAX == INT_MAX) { 1381 str = "0xffffffff00000001"; /* ULLONG_MAX - UINT_MAX + 1 (not 1) */ 1382 endptr = "somewhere"; 1383 res = 999; 1384 err = qemu_strtol(str, &endptr, 0, &res); 1385 g_assert_cmpint(err, ==, -ERANGE); 1386 g_assert_cmpint(res, ==, LONG_MAX); 1387 g_assert_true(endptr == str + strlen(str)); 1388 } 1389 1390 str = "0x10000000000000000"; /* 65 bits, either sign bit position clear */ 1391 endptr = "somewhere"; 1392 res = 999; 1393 err = qemu_strtol(str, &endptr, 0, &res); 1394 g_assert_cmpint(err, ==, -ERANGE); 1395 g_assert_cmpint(res, ==, LONG_MAX); 1396 g_assert_true(endptr == str + strlen(str)); 1397 1398 str = "0x18000000080000000"; /* 65 bits, either sign bit position set */ 1399 endptr = "somewhere"; 1400 res = 999; 1401 err = qemu_strtol(str, &endptr, 0, &res); 1402 g_assert_cmpint(err, ==, -ERANGE); 1403 g_assert_cmpint(res, ==, LONG_MAX); 1404 g_assert_true(endptr == str + strlen(str)); 1405 } 1406 1407 static void test_qemu_strtol_min(void) 1408 { 1409 char *str = g_strdup_printf("%ld", LONG_MIN); 1410 char f = 'X'; 1411 const char *endptr = &f; 1412 long res = 999; 1413 int err; 1414 1415 err = qemu_strtol(str, &endptr, 0, &res); 1416 1417 g_assert_cmpint(err, ==, 0); 1418 g_assert_cmpint(res, ==, LONG_MIN); 1419 g_assert_true(endptr == str + strlen(str)); 1420 g_free(str); 1421 } 1422 1423 static void test_qemu_strtol_underflow(void) 1424 { 1425 const char *str; 1426 const char *endptr; 1427 long res; 1428 int err; 1429 1430 /* 1 less than LONG_MIN */ 1431 str = LONG_MIN == INT_MIN ? "-2147483649" : "-9223372036854775809"; 1432 endptr = "somewhere"; 1433 res = 999; 1434 err = qemu_strtol(str, &endptr, 0, &res); 1435 g_assert_cmpint(err, ==, -ERANGE); 1436 g_assert_cmpint(res, ==, LONG_MIN); 1437 g_assert_true(endptr == str + strlen(str)); 1438 1439 if (LONG_MAX == INT_MAX) { 1440 str = "-18446744073709551615"; /* -UINT64_MAX (not 1) */ 1441 endptr = "somewhere"; 1442 res = 999; 1443 err = qemu_strtol(str, &endptr, 0, &res); 1444 g_assert_cmpint(err, ==, -ERANGE); 1445 g_assert_cmpint(res, ==, LONG_MIN); 1446 g_assert_true(endptr == str + strlen(str)); 1447 } 1448 1449 str = "-0x10000000000000000"; /* 65 bits, either sign bit position clear */ 1450 endptr = "somewhere"; 1451 res = 999; 1452 err = qemu_strtol(str, &endptr, 0, &res); 1453 g_assert_cmpint(err, ==, -ERANGE); 1454 g_assert_cmpint(res, ==, LONG_MIN); 1455 g_assert_true(endptr == str + strlen(str)); 1456 1457 str = "-0x18000000080000000"; /* 65 bits, either sign bit position set */ 1458 endptr = "somewhere"; 1459 res = 999; 1460 err = qemu_strtol(str, &endptr, 0, &res); 1461 g_assert_cmpint(err, ==, -ERANGE); 1462 g_assert_cmpint(res, ==, LONG_MIN); 1463 g_assert_true(endptr == str + strlen(str)); 1464 } 1465 1466 static void test_qemu_strtol_negative(void) 1467 { 1468 const char *str = " \t -321"; 1469 char f = 'X'; 1470 const char *endptr = &f; 1471 long res = 999; 1472 int err; 1473 1474 err = qemu_strtol(str, &endptr, 0, &res); 1475 1476 g_assert_cmpint(err, ==, 0); 1477 g_assert_cmpint(res, ==, -321); 1478 g_assert_true(endptr == str + strlen(str)); 1479 } 1480 1481 static void test_qemu_strtol_negzero(void) 1482 { 1483 const char *str = " -0"; 1484 char f = 'X'; 1485 const char *endptr = &f; 1486 long res = 999; 1487 int err; 1488 1489 err = qemu_strtol(str, &endptr, 0, &res); 1490 1491 g_assert_cmpint(err, ==, 0); 1492 g_assert_cmpint(res, ==, 0); 1493 g_assert_true(endptr == str + strlen(str)); 1494 } 1495 1496 static void test_qemu_strtol_full_correct(void) 1497 { 1498 const char *str = "123"; 1499 long res = 999; 1500 int err; 1501 1502 err = qemu_strtol(str, NULL, 0, &res); 1503 1504 g_assert_cmpint(err, ==, 0); 1505 g_assert_cmpint(res, ==, 123); 1506 } 1507 1508 static void test_qemu_strtol_full_null(void) 1509 { 1510 char f = 'X'; 1511 const char *endptr = &f; 1512 long res = 999; 1513 int err; 1514 1515 err = qemu_strtol(NULL, &endptr, 0, &res); 1516 1517 g_assert_cmpint(err, ==, -EINVAL); 1518 g_assert_cmpint(res, ==, 999); 1519 g_assert_null(endptr); 1520 } 1521 1522 static void test_qemu_strtol_full_empty(void) 1523 { 1524 const char *str = ""; 1525 long res = 999L; 1526 int err; 1527 1528 err = qemu_strtol(str, NULL, 0, &res); 1529 1530 g_assert_cmpint(err, ==, -EINVAL); 1531 g_assert_cmpint(res, ==, 0); 1532 } 1533 1534 static void test_qemu_strtol_full_negative(void) 1535 { 1536 const char *str = " \t -321"; 1537 long res = 999; 1538 int err; 1539 1540 err = qemu_strtol(str, NULL, 0, &res); 1541 1542 g_assert_cmpint(err, ==, 0); 1543 g_assert_cmpint(res, ==, -321); 1544 } 1545 1546 static void test_qemu_strtol_full_negzero(void) 1547 { 1548 const char *str = " -0"; 1549 long res = 999; 1550 int err; 1551 1552 err = qemu_strtol(str, NULL, 0, &res); 1553 1554 g_assert_cmpint(err, ==, 0); 1555 g_assert_cmpint(res, ==, 0); 1556 } 1557 1558 static void test_qemu_strtol_full_trailing(void) 1559 { 1560 const char *str = "123xxx"; 1561 long res = 999; 1562 int err; 1563 1564 err = qemu_strtol(str, NULL, 0, &res); 1565 1566 g_assert_cmpint(err, ==, -EINVAL); 1567 g_assert_cmpint(res, ==, 123); 1568 } 1569 1570 static void test_qemu_strtol_full_max(void) 1571 { 1572 char *str = g_strdup_printf("%ld", LONG_MAX); 1573 long res = 999; 1574 int err; 1575 1576 err = qemu_strtol(str, NULL, 0, &res); 1577 1578 g_assert_cmpint(err, ==, 0); 1579 g_assert_cmpint(res, ==, LONG_MAX); 1580 g_free(str); 1581 } 1582 1583 static void test_qemu_strtol_full_erange_junk(void) 1584 { 1585 /* EINVAL has priority over ERANGE */ 1586 const char *str = "-99999999999999999999junk"; 1587 long res = 999; 1588 int err; 1589 1590 err = qemu_strtol(str, NULL, 0, &res); 1591 1592 g_assert_cmpint(err, ==, -EINVAL); 1593 g_assert_cmpint(res, ==, LONG_MIN); 1594 } 1595 1596 static void test_qemu_strtoul_correct(void) 1597 { 1598 const char *str = "12345 foo"; 1599 char f = 'X'; 1600 const char *endptr = &f; 1601 unsigned long res = 999; 1602 int err; 1603 1604 err = qemu_strtoul(str, &endptr, 0, &res); 1605 1606 g_assert_cmpint(err, ==, 0); 1607 g_assert_cmpuint(res, ==, 12345); 1608 g_assert_true(endptr == str + 5); 1609 } 1610 1611 static void test_qemu_strtoul_null(void) 1612 { 1613 char f = 'X'; 1614 const char *endptr = &f; 1615 unsigned long res = 999; 1616 int err; 1617 1618 err = qemu_strtoul(NULL, &endptr, 0, &res); 1619 1620 g_assert_cmpint(err, ==, -EINVAL); 1621 g_assert_cmpuint(res, ==, 999); 1622 g_assert_null(endptr); 1623 } 1624 1625 static void test_qemu_strtoul_empty(void) 1626 { 1627 const char *str = ""; 1628 char f = 'X'; 1629 const char *endptr = &f; 1630 unsigned long res = 999; 1631 int err; 1632 1633 err = qemu_strtoul(str, &endptr, 0, &res); 1634 1635 g_assert_cmpint(err, ==, -EINVAL); 1636 g_assert_cmpuint(res, ==, 0); 1637 g_assert_true(endptr == str); 1638 } 1639 1640 static void test_qemu_strtoul_whitespace(void) 1641 { 1642 const char *str = " \t "; 1643 char f = 'X'; 1644 const char *endptr = &f; 1645 unsigned long res = 999; 1646 int err; 1647 1648 err = qemu_strtoul(str, &endptr, 0, &res); 1649 1650 g_assert_cmpint(err, ==, -EINVAL); 1651 g_assert_cmpuint(res, ==, 0); 1652 g_assert_true(endptr == str); 1653 } 1654 1655 static void test_qemu_strtoul_invalid(void) 1656 { 1657 const char *str = " xxxx \t abc"; 1658 char f = 'X'; 1659 const char *endptr = &f; 1660 unsigned long res = 999; 1661 int err; 1662 1663 err = qemu_strtoul(str, &endptr, 0, &res); 1664 1665 g_assert_cmpint(err, ==, -EINVAL); 1666 g_assert_cmpuint(res, ==, 0); 1667 g_assert_true(endptr == str); 1668 } 1669 1670 static void test_qemu_strtoul_trailing(void) 1671 { 1672 const char *str = "123xxx"; 1673 char f = 'X'; 1674 const char *endptr = &f; 1675 unsigned long res = 999; 1676 int err; 1677 1678 err = qemu_strtoul(str, &endptr, 0, &res); 1679 1680 g_assert_cmpint(err, ==, 0); 1681 g_assert_cmpuint(res, ==, 123); 1682 g_assert_true(endptr == str + 3); 1683 } 1684 1685 static void test_qemu_strtoul_octal(void) 1686 { 1687 const char *str = "0123"; 1688 char f = 'X'; 1689 const char *endptr = &f; 1690 unsigned long res = 999; 1691 int err; 1692 1693 err = qemu_strtoul(str, &endptr, 8, &res); 1694 1695 g_assert_cmpint(err, ==, 0); 1696 g_assert_cmpuint(res, ==, 0123); 1697 g_assert_true(endptr == str + strlen(str)); 1698 1699 res = 999; 1700 endptr = &f; 1701 err = qemu_strtoul(str, &endptr, 0, &res); 1702 1703 g_assert_cmpint(err, ==, 0); 1704 g_assert_cmpuint(res, ==, 0123); 1705 g_assert_true(endptr == str + strlen(str)); 1706 } 1707 1708 static void test_qemu_strtoul_decimal(void) 1709 { 1710 const char *str = "0123"; 1711 char f = 'X'; 1712 const char *endptr = &f; 1713 unsigned long res = 999; 1714 int err; 1715 1716 err = qemu_strtoul(str, &endptr, 10, &res); 1717 1718 g_assert_cmpint(err, ==, 0); 1719 g_assert_cmpuint(res, ==, 123); 1720 g_assert_true(endptr == str + strlen(str)); 1721 1722 str = "123"; 1723 res = 999; 1724 endptr = &f; 1725 err = qemu_strtoul(str, &endptr, 0, &res); 1726 1727 g_assert_cmpint(err, ==, 0); 1728 g_assert_cmpuint(res, ==, 123); 1729 g_assert_true(endptr == str + strlen(str)); 1730 } 1731 1732 static void test_qemu_strtoul_hex(void) 1733 { 1734 const char *str = "0123"; 1735 char f = 'X'; 1736 const char *endptr = &f; 1737 unsigned long res = 999; 1738 int err; 1739 1740 err = qemu_strtoul(str, &endptr, 16, &res); 1741 1742 g_assert_cmpint(err, ==, 0); 1743 g_assert_cmphex(res, ==, 0x123); 1744 g_assert_true(endptr == str + strlen(str)); 1745 1746 str = "0x123"; 1747 res = 999; 1748 endptr = &f; 1749 err = qemu_strtoul(str, &endptr, 0, &res); 1750 1751 g_assert_cmpint(err, ==, 0); 1752 g_assert_cmphex(res, ==, 0x123); 1753 g_assert_true(endptr == str + strlen(str)); 1754 1755 str = "0x"; 1756 res = 999; 1757 endptr = &f; 1758 err = qemu_strtoul(str, &endptr, 16, &res); 1759 1760 g_assert_cmpint(err, ==, 0); 1761 g_assert_cmphex(res, ==, 0); 1762 g_assert_true(endptr == str + 1); 1763 } 1764 1765 static void test_qemu_strtoul_wrap(void) 1766 { 1767 const char *str; 1768 char f = 'X'; 1769 const char *endptr = &f; 1770 unsigned long res = 999; 1771 int err; 1772 1773 /* 1 mod 2^(sizeof(long)*8) */ 1774 str = LONG_MAX == INT_MAX ? "-4294967295" : "-18446744073709551615"; 1775 err = qemu_strtoul(str, &endptr, 0, &res); 1776 1777 g_assert_cmpint(err, ==, 0); 1778 g_assert_cmphex(res, ==, 1); 1779 g_assert_true(endptr == str + strlen(str)); 1780 } 1781 1782 static void test_qemu_strtoul_max(void) 1783 { 1784 char *str = g_strdup_printf("%lu", ULONG_MAX); 1785 char f = 'X'; 1786 const char *endptr = &f; 1787 unsigned long res = 999; 1788 int err; 1789 1790 err = qemu_strtoul(str, &endptr, 0, &res); 1791 1792 g_assert_cmpint(err, ==, 0); 1793 g_assert_cmphex(res, ==, ULONG_MAX); 1794 g_assert_true(endptr == str + strlen(str)); 1795 g_free(str); 1796 } 1797 1798 static void test_qemu_strtoul_overflow(void) 1799 { 1800 const char *str; 1801 const char *endptr; 1802 unsigned long res; 1803 int err; 1804 1805 /* 1 more than ULONG_MAX */ 1806 str = ULONG_MAX == UINT_MAX ? "4294967296" : "18446744073709551616"; 1807 endptr = "somewhere"; 1808 res = 999; 1809 err = qemu_strtoul(str, &endptr, 0, &res); 1810 g_assert_cmpint(err, ==, -ERANGE); 1811 g_assert_cmpuint(res, ==, ULONG_MAX); 1812 g_assert_true(endptr == str + strlen(str)); 1813 1814 if (LONG_MAX == INT_MAX) { 1815 str = "0xffffffff00000001"; /* UINT64_MAX - UINT_MAX + 1 (not 1) */ 1816 endptr = "somewhere"; 1817 res = 999; 1818 err = qemu_strtoul(str, &endptr, 0, &res); 1819 g_assert_cmpint(err, ==, -ERANGE); 1820 g_assert_cmpuint(res, ==, ULONG_MAX); 1821 g_assert_true(endptr == str + strlen(str)); 1822 } 1823 1824 str = "0x10000000000000000"; /* 65 bits, either sign bit position clear */ 1825 endptr = "somewhere"; 1826 res = 999; 1827 err = qemu_strtoul(str, &endptr, 0, &res); 1828 g_assert_cmpint(err, ==, -ERANGE); 1829 g_assert_cmpuint(res, ==, ULONG_MAX); 1830 g_assert_true(endptr == str + strlen(str)); 1831 1832 str = "0x18000000080000000"; /* 65 bits, either sign bit position set */ 1833 endptr = "somewhere"; 1834 res = 999; 1835 err = qemu_strtoul(str, &endptr, 0, &res); 1836 g_assert_cmpint(err, ==, -ERANGE); 1837 g_assert_cmpuint(res, ==, ULONG_MAX); 1838 g_assert_true(endptr == str + strlen(str)); 1839 } 1840 1841 static void test_qemu_strtoul_underflow(void) 1842 { 1843 const char *str; 1844 const char *endptr; 1845 unsigned long res; 1846 int err; 1847 1848 /* 1 less than -ULONG_MAX */ 1849 str = ULONG_MAX == UINT_MAX ? "-4294967296" : "-18446744073709551616"; 1850 endptr = "somewhere"; 1851 res = 999; 1852 err = qemu_strtoul(str, &endptr, 0, &res); 1853 g_assert_cmpint(err, ==, -ERANGE); 1854 g_assert_cmpuint(res, ==, ULONG_MAX); 1855 g_assert_true(endptr == str + strlen(str)); 1856 1857 if (LONG_MAX == INT_MAX) { 1858 str = "-0xffffffff00000002"; 1859 endptr = "somewhere"; 1860 res = 999; 1861 err = qemu_strtoul(str, &endptr, 0, &res); 1862 g_assert_cmpint(err, ==, -ERANGE); 1863 g_assert_cmpuint(res, ==, ULONG_MAX); 1864 g_assert_true(endptr == str + strlen(str)); 1865 } 1866 1867 str = "-0x10000000000000000"; /* 65 bits, either sign bit position clear */ 1868 endptr = "somewhere"; 1869 res = 999; 1870 err = qemu_strtoul(str, &endptr, 0, &res); 1871 g_assert_cmpint(err, ==, -ERANGE); 1872 g_assert_cmpuint(res, ==, ULONG_MAX); 1873 g_assert_true(endptr == str + strlen(str)); 1874 1875 str = "-0x18000000080000000"; /* 65 bits, either sign bit position set */ 1876 endptr = "somewhere"; 1877 res = 999; 1878 err = qemu_strtoul(str, &endptr, 0, &res); 1879 g_assert_cmpint(err, ==, -ERANGE); 1880 g_assert_cmpuint(res, ==, ULONG_MAX); 1881 g_assert_true(endptr == str + strlen(str)); 1882 } 1883 1884 static void test_qemu_strtoul_negative(void) 1885 { 1886 const char *str = " \t -321"; 1887 char f = 'X'; 1888 const char *endptr = &f; 1889 unsigned long res = 999; 1890 int err; 1891 1892 err = qemu_strtoul(str, &endptr, 0, &res); 1893 1894 g_assert_cmpint(err, ==, 0); 1895 g_assert_cmpuint(res, ==, -321ul); 1896 g_assert_true(endptr == str + strlen(str)); 1897 } 1898 1899 static void test_qemu_strtoul_negzero(void) 1900 { 1901 const char *str = " -0"; 1902 char f = 'X'; 1903 const char *endptr = &f; 1904 unsigned long res = 999; 1905 int err; 1906 1907 err = qemu_strtoul(str, &endptr, 0, &res); 1908 1909 g_assert_cmpint(err, ==, 0); 1910 g_assert_cmpuint(res, ==, 0); 1911 g_assert_true(endptr == str + strlen(str)); 1912 } 1913 1914 static void test_qemu_strtoul_full_correct(void) 1915 { 1916 const char *str = "123"; 1917 unsigned long res = 999; 1918 int err; 1919 1920 err = qemu_strtoul(str, NULL, 0, &res); 1921 1922 g_assert_cmpint(err, ==, 0); 1923 g_assert_cmpuint(res, ==, 123); 1924 } 1925 1926 static void test_qemu_strtoul_full_null(void) 1927 { 1928 unsigned long res = 999; 1929 int err; 1930 1931 err = qemu_strtoul(NULL, NULL, 0, &res); 1932 1933 g_assert_cmpint(err, ==, -EINVAL); 1934 g_assert_cmpuint(res, ==, 999); 1935 } 1936 1937 static void test_qemu_strtoul_full_empty(void) 1938 { 1939 const char *str = ""; 1940 unsigned long res = 999; 1941 int err; 1942 1943 err = qemu_strtoul(str, NULL, 0, &res); 1944 1945 g_assert_cmpint(err, ==, -EINVAL); 1946 g_assert_cmpuint(res, ==, 0); 1947 } 1948 1949 static void test_qemu_strtoul_full_negative(void) 1950 { 1951 const char *str = " \t -321"; 1952 unsigned long res = 999; 1953 int err; 1954 1955 err = qemu_strtoul(str, NULL, 0, &res); 1956 g_assert_cmpint(err, ==, 0); 1957 g_assert_cmpuint(res, ==, -321ul); 1958 } 1959 1960 static void test_qemu_strtoul_full_negzero(void) 1961 { 1962 const char *str = " -0"; 1963 unsigned long res = 999; 1964 int err; 1965 1966 err = qemu_strtoul(str, NULL, 0, &res); 1967 g_assert_cmpint(err, ==, 0); 1968 g_assert_cmpuint(res, ==, 0); 1969 } 1970 1971 static void test_qemu_strtoul_full_trailing(void) 1972 { 1973 const char *str = "123xxx"; 1974 unsigned long res = 999; 1975 int err; 1976 1977 err = qemu_strtoul(str, NULL, 0, &res); 1978 1979 g_assert_cmpint(err, ==, -EINVAL); 1980 g_assert_cmpuint(res, ==, 123); 1981 } 1982 1983 static void test_qemu_strtoul_full_max(void) 1984 { 1985 char *str = g_strdup_printf("%lu", ULONG_MAX); 1986 unsigned long res = 999; 1987 int err; 1988 1989 err = qemu_strtoul(str, NULL, 0, &res); 1990 1991 g_assert_cmpint(err, ==, 0); 1992 g_assert_cmphex(res, ==, ULONG_MAX); 1993 g_free(str); 1994 } 1995 1996 static void test_qemu_strtoul_full_erange_junk(void) 1997 { 1998 /* EINVAL has priority over ERANGE */ 1999 const char *str = "-99999999999999999999junk"; 2000 unsigned long res = 999; 2001 int err; 2002 2003 err = qemu_strtoul(str, NULL, 0, &res); 2004 2005 g_assert_cmpint(err, ==, -EINVAL); 2006 g_assert_cmpuint(res, ==, ULONG_MAX); 2007 } 2008 2009 static void test_qemu_strtoi64_correct(void) 2010 { 2011 const char *str = "12345 foo"; 2012 char f = 'X'; 2013 const char *endptr = &f; 2014 int64_t res = 999; 2015 int err; 2016 2017 err = qemu_strtoi64(str, &endptr, 0, &res); 2018 2019 g_assert_cmpint(err, ==, 0); 2020 g_assert_cmpint(res, ==, 12345); 2021 g_assert_true(endptr == str + 5); 2022 } 2023 2024 static void test_qemu_strtoi64_null(void) 2025 { 2026 char f = 'X'; 2027 const char *endptr = &f; 2028 int64_t res = 999; 2029 int err; 2030 2031 err = qemu_strtoi64(NULL, &endptr, 0, &res); 2032 2033 g_assert_cmpint(err, ==, -EINVAL); 2034 g_assert_cmpint(res, ==, 999); 2035 g_assert_null(endptr); 2036 } 2037 2038 static void test_qemu_strtoi64_empty(void) 2039 { 2040 const char *str = ""; 2041 char f = 'X'; 2042 const char *endptr = &f; 2043 int64_t res = 999; 2044 int err; 2045 2046 err = qemu_strtoi64(str, &endptr, 0, &res); 2047 2048 g_assert_cmpint(err, ==, -EINVAL); 2049 g_assert_cmpint(res, ==, 0); 2050 g_assert_true(endptr == str); 2051 } 2052 2053 static void test_qemu_strtoi64_whitespace(void) 2054 { 2055 const char *str = " \t "; 2056 char f = 'X'; 2057 const char *endptr = &f; 2058 int64_t res = 999; 2059 int err; 2060 2061 err = qemu_strtoi64(str, &endptr, 0, &res); 2062 2063 g_assert_cmpint(err, ==, -EINVAL); 2064 g_assert_cmpint(res, ==, 0); 2065 g_assert_true(endptr == str); 2066 } 2067 2068 static void test_qemu_strtoi64_invalid(void) 2069 { 2070 const char *str = " xxxx \t abc"; 2071 char f = 'X'; 2072 const char *endptr = &f; 2073 int64_t res = 999; 2074 int err; 2075 2076 err = qemu_strtoi64(str, &endptr, 0, &res); 2077 2078 g_assert_cmpint(err, ==, -EINVAL); 2079 g_assert_cmpint(res, ==, 0); 2080 g_assert_true(endptr == str); 2081 } 2082 2083 static void test_qemu_strtoi64_trailing(void) 2084 { 2085 const char *str = "123xxx"; 2086 char f = 'X'; 2087 const char *endptr = &f; 2088 int64_t res = 999; 2089 int err; 2090 2091 err = qemu_strtoi64(str, &endptr, 0, &res); 2092 2093 g_assert_cmpint(err, ==, 0); 2094 g_assert_cmpint(res, ==, 123); 2095 g_assert_true(endptr == str + 3); 2096 } 2097 2098 static void test_qemu_strtoi64_octal(void) 2099 { 2100 const char *str = "0123"; 2101 char f = 'X'; 2102 const char *endptr = &f; 2103 int64_t res = 999; 2104 int err; 2105 2106 err = qemu_strtoi64(str, &endptr, 8, &res); 2107 2108 g_assert_cmpint(err, ==, 0); 2109 g_assert_cmpint(res, ==, 0123); 2110 g_assert_true(endptr == str + strlen(str)); 2111 2112 endptr = &f; 2113 res = 999; 2114 err = qemu_strtoi64(str, &endptr, 0, &res); 2115 2116 g_assert_cmpint(err, ==, 0); 2117 g_assert_cmpint(res, ==, 0123); 2118 g_assert_true(endptr == str + strlen(str)); 2119 } 2120 2121 static void test_qemu_strtoi64_decimal(void) 2122 { 2123 const char *str = "0123"; 2124 char f = 'X'; 2125 const char *endptr = &f; 2126 int64_t res = 999; 2127 int err; 2128 2129 err = qemu_strtoi64(str, &endptr, 10, &res); 2130 2131 g_assert_cmpint(err, ==, 0); 2132 g_assert_cmpint(res, ==, 123); 2133 g_assert_true(endptr == str + strlen(str)); 2134 2135 str = "123"; 2136 endptr = &f; 2137 res = 999; 2138 err = qemu_strtoi64(str, &endptr, 0, &res); 2139 2140 g_assert_cmpint(err, ==, 0); 2141 g_assert_cmpint(res, ==, 123); 2142 g_assert_true(endptr == str + strlen(str)); 2143 } 2144 2145 static void test_qemu_strtoi64_hex(void) 2146 { 2147 const char *str = "0123"; 2148 char f = 'X'; 2149 const char *endptr = &f; 2150 int64_t res = 999; 2151 int err; 2152 2153 err = qemu_strtoi64(str, &endptr, 16, &res); 2154 2155 g_assert_cmpint(err, ==, 0); 2156 g_assert_cmpint(res, ==, 0x123); 2157 g_assert_true(endptr == str + strlen(str)); 2158 2159 str = "0x123"; 2160 endptr = &f; 2161 res = 999; 2162 err = qemu_strtoi64(str, &endptr, 0, &res); 2163 2164 g_assert_cmpint(err, ==, 0); 2165 g_assert_cmpint(res, ==, 0x123); 2166 g_assert_true(endptr == str + strlen(str)); 2167 2168 str = "0x"; 2169 endptr = &f; 2170 res = 999; 2171 err = qemu_strtoi64(str, &endptr, 16, &res); 2172 2173 g_assert_cmpint(err, ==, 0); 2174 g_assert_cmpint(res, ==, 0); 2175 g_assert_true(endptr == str + 1); 2176 } 2177 2178 static void test_qemu_strtoi64_max(void) 2179 { 2180 char *str = g_strdup_printf("%lld", LLONG_MAX); 2181 char f = 'X'; 2182 const char *endptr = &f; 2183 int64_t res = 999; 2184 int err; 2185 2186 err = qemu_strtoi64(str, &endptr, 0, &res); 2187 2188 g_assert_cmpint(err, ==, 0); 2189 g_assert_cmpint(res, ==, LLONG_MAX); 2190 g_assert_true(endptr == str + strlen(str)); 2191 g_free(str); 2192 } 2193 2194 static void test_qemu_strtoi64_overflow(void) 2195 { 2196 const char *str; 2197 const char *endptr; 2198 int64_t res; 2199 int err; 2200 2201 str = "9223372036854775808"; /* 1 more than INT64_MAX */ 2202 endptr = "somewhere"; 2203 res = 999; 2204 err = qemu_strtoi64(str, &endptr, 0, &res); 2205 g_assert_cmpint(err, ==, -ERANGE); 2206 g_assert_cmpint(res, ==, INT64_MAX); 2207 g_assert_true(endptr == str + strlen(str)); 2208 2209 str = "0x10000000000000000"; /* 65 bits, 64-bit sign bit clear */ 2210 endptr = "somewhere"; 2211 res = 999; 2212 err = qemu_strtoi64(str, &endptr, 0, &res); 2213 g_assert_cmpint(err, ==, -ERANGE); 2214 g_assert_cmpint(res, ==, INT64_MAX); 2215 g_assert_true(endptr == str + strlen(str)); 2216 2217 str = "0x18000000080000000"; /* 65 bits, 64-bit sign bit set */ 2218 endptr = "somewhere"; 2219 res = 999; 2220 err = qemu_strtoi64(str, &endptr, 0, &res); 2221 g_assert_cmpint(err, ==, -ERANGE); 2222 g_assert_cmpint(res, ==, INT64_MAX); 2223 g_assert_true(endptr == str + strlen(str)); 2224 } 2225 2226 static void test_qemu_strtoi64_min(void) 2227 { 2228 char *str = g_strdup_printf("%lld", LLONG_MIN); 2229 char f = 'X'; 2230 const char *endptr = &f; 2231 int64_t res = 999; 2232 int err; 2233 2234 err = qemu_strtoi64(str, &endptr, 0, &res); 2235 2236 g_assert_cmpint(err, ==, 0); 2237 g_assert_cmpint(res, ==, LLONG_MIN); 2238 g_assert_true(endptr == str + strlen(str)); 2239 g_free(str); 2240 } 2241 2242 static void test_qemu_strtoi64_underflow(void) 2243 { 2244 const char *str; 2245 const char *endptr; 2246 int64_t res; 2247 int err; 2248 2249 str = "-9223372036854775809"; /* 1 less than INT64_MIN */ 2250 endptr = "somewhere"; 2251 res = 999; 2252 err = qemu_strtoi64(str, &endptr, 0, &res); 2253 g_assert_cmpint(err, ==, -ERANGE); 2254 g_assert_cmpint(res, ==, INT64_MIN); 2255 g_assert_true(endptr == str + strlen(str)); 2256 2257 str = "-0x10000000000000000"; /* 65 bits, 64-bit sign bit clear */ 2258 endptr = "somewhere"; 2259 res = 999; 2260 err = qemu_strtoi64(str, &endptr, 0, &res); 2261 g_assert_cmpint(err, ==, -ERANGE); 2262 g_assert_cmpint(res, ==, INT64_MIN); 2263 g_assert_true(endptr == str + strlen(str)); 2264 2265 str = "-0x18000000080000000"; /* 65 bits, 64-bit sign bit set */ 2266 endptr = "somewhere"; 2267 res = 999; 2268 err = qemu_strtoi64(str, &endptr, 0, &res); 2269 g_assert_cmpint(err, ==, -ERANGE); 2270 g_assert_cmpint(res, ==, INT64_MIN); 2271 g_assert_true(endptr == str + strlen(str)); 2272 } 2273 2274 static void test_qemu_strtoi64_negative(void) 2275 { 2276 const char *str = " \t -321"; 2277 char f = 'X'; 2278 const char *endptr = &f; 2279 int64_t res = 999; 2280 int err; 2281 2282 err = qemu_strtoi64(str, &endptr, 0, &res); 2283 2284 g_assert_cmpint(err, ==, 0); 2285 g_assert_cmpint(res, ==, -321); 2286 g_assert_true(endptr == str + strlen(str)); 2287 } 2288 2289 static void test_qemu_strtoi64_negzero(void) 2290 { 2291 const char *str = " -0"; 2292 char f = 'X'; 2293 const char *endptr = &f; 2294 int64_t res = 999; 2295 int err; 2296 2297 err = qemu_strtoi64(str, &endptr, 0, &res); 2298 2299 g_assert_cmpint(err, ==, 0); 2300 g_assert_cmpint(res, ==, 0); 2301 g_assert_true(endptr == str + strlen(str)); 2302 } 2303 2304 static void test_qemu_strtoi64_full_correct(void) 2305 { 2306 const char *str = "123"; 2307 int64_t res = 999; 2308 int err; 2309 2310 err = qemu_strtoi64(str, NULL, 0, &res); 2311 2312 g_assert_cmpint(err, ==, 0); 2313 g_assert_cmpint(res, ==, 123); 2314 } 2315 2316 static void test_qemu_strtoi64_full_null(void) 2317 { 2318 int64_t res = 999; 2319 int err; 2320 2321 err = qemu_strtoi64(NULL, NULL, 0, &res); 2322 2323 g_assert_cmpint(err, ==, -EINVAL); 2324 g_assert_cmpint(res, ==, 999); 2325 } 2326 2327 static void test_qemu_strtoi64_full_empty(void) 2328 { 2329 const char *str = ""; 2330 int64_t res = 999; 2331 int err; 2332 2333 err = qemu_strtoi64(str, NULL, 0, &res); 2334 2335 g_assert_cmpint(err, ==, -EINVAL); 2336 g_assert_cmpint(res, ==, 0); 2337 } 2338 2339 static void test_qemu_strtoi64_full_negative(void) 2340 { 2341 const char *str = " \t -321"; 2342 int64_t res = 999; 2343 int err; 2344 2345 err = qemu_strtoi64(str, NULL, 0, &res); 2346 2347 g_assert_cmpint(err, ==, 0); 2348 g_assert_cmpint(res, ==, -321); 2349 } 2350 2351 static void test_qemu_strtoi64_full_negzero(void) 2352 { 2353 const char *str = " -0"; 2354 int64_t res = 999; 2355 int err; 2356 2357 err = qemu_strtoi64(str, NULL, 0, &res); 2358 2359 g_assert_cmpint(err, ==, 0); 2360 g_assert_cmpint(res, ==, 0); 2361 } 2362 2363 static void test_qemu_strtoi64_full_trailing(void) 2364 { 2365 const char *str = "123xxx"; 2366 int64_t res = 999; 2367 int err; 2368 2369 err = qemu_strtoi64(str, NULL, 0, &res); 2370 2371 g_assert_cmpint(err, ==, -EINVAL); 2372 g_assert_cmpint(res, ==, 123); 2373 } 2374 2375 static void test_qemu_strtoi64_full_max(void) 2376 { 2377 2378 char *str = g_strdup_printf("%lld", LLONG_MAX); 2379 int64_t res = 999; 2380 int err; 2381 2382 err = qemu_strtoi64(str, NULL, 0, &res); 2383 2384 g_assert_cmpint(err, ==, 0); 2385 g_assert_cmpint(res, ==, LLONG_MAX); 2386 g_free(str); 2387 } 2388 2389 static void test_qemu_strtoi64_full_erange_junk(void) 2390 { 2391 /* EINVAL has priority over ERANGE */ 2392 const char *str = "-99999999999999999999junk"; 2393 int64_t res = 999; 2394 int err; 2395 2396 err = qemu_strtoi64(str, NULL, 0, &res); 2397 2398 g_assert_cmpint(err, ==, -EINVAL); 2399 g_assert_cmpint(res, ==, INT64_MIN); 2400 } 2401 2402 static void test_qemu_strtou64_correct(void) 2403 { 2404 const char *str = "12345 foo"; 2405 char f = 'X'; 2406 const char *endptr = &f; 2407 uint64_t res = 999; 2408 int err; 2409 2410 err = qemu_strtou64(str, &endptr, 0, &res); 2411 2412 g_assert_cmpint(err, ==, 0); 2413 g_assert_cmpuint(res, ==, 12345); 2414 g_assert_true(endptr == str + 5); 2415 } 2416 2417 static void test_qemu_strtou64_null(void) 2418 { 2419 char f = 'X'; 2420 const char *endptr = &f; 2421 uint64_t res = 999; 2422 int err; 2423 2424 err = qemu_strtou64(NULL, &endptr, 0, &res); 2425 2426 g_assert_cmpint(err, ==, -EINVAL); 2427 g_assert_cmpuint(res, ==, 999); 2428 g_assert_null(endptr); 2429 } 2430 2431 static void test_qemu_strtou64_empty(void) 2432 { 2433 const char *str = ""; 2434 char f = 'X'; 2435 const char *endptr = &f; 2436 uint64_t res = 999; 2437 int err; 2438 2439 err = qemu_strtou64(str, &endptr, 0, &res); 2440 2441 g_assert_cmpint(err, ==, -EINVAL); 2442 g_assert_cmpuint(res, ==, 0); 2443 g_assert_true(endptr == str); 2444 } 2445 2446 static void test_qemu_strtou64_whitespace(void) 2447 { 2448 const char *str = " \t "; 2449 char f = 'X'; 2450 const char *endptr = &f; 2451 uint64_t res = 999; 2452 int err; 2453 2454 err = qemu_strtou64(str, &endptr, 0, &res); 2455 2456 g_assert_cmpint(err, ==, -EINVAL); 2457 g_assert_cmpuint(res, ==, 0); 2458 g_assert_true(endptr == str); 2459 } 2460 2461 static void test_qemu_strtou64_invalid(void) 2462 { 2463 const char *str = " xxxx \t abc"; 2464 char f = 'X'; 2465 const char *endptr = &f; 2466 uint64_t res = 999; 2467 int err; 2468 2469 err = qemu_strtou64(str, &endptr, 0, &res); 2470 2471 g_assert_cmpint(err, ==, -EINVAL); 2472 g_assert_cmpuint(res, ==, 0); 2473 g_assert_true(endptr == str); 2474 } 2475 2476 static void test_qemu_strtou64_trailing(void) 2477 { 2478 const char *str = "123xxx"; 2479 char f = 'X'; 2480 const char *endptr = &f; 2481 uint64_t res = 999; 2482 int err; 2483 2484 err = qemu_strtou64(str, &endptr, 0, &res); 2485 2486 g_assert_cmpint(err, ==, 0); 2487 g_assert_cmpuint(res, ==, 123); 2488 g_assert_true(endptr == str + 3); 2489 } 2490 2491 static void test_qemu_strtou64_octal(void) 2492 { 2493 const char *str = "0123"; 2494 char f = 'X'; 2495 const char *endptr = &f; 2496 uint64_t res = 999; 2497 int err; 2498 2499 err = qemu_strtou64(str, &endptr, 8, &res); 2500 2501 g_assert_cmpint(err, ==, 0); 2502 g_assert_cmpuint(res, ==, 0123); 2503 g_assert_true(endptr == str + strlen(str)); 2504 2505 endptr = &f; 2506 res = 999; 2507 err = qemu_strtou64(str, &endptr, 0, &res); 2508 2509 g_assert_cmpint(err, ==, 0); 2510 g_assert_cmpuint(res, ==, 0123); 2511 g_assert_true(endptr == str + strlen(str)); 2512 } 2513 2514 static void test_qemu_strtou64_decimal(void) 2515 { 2516 const char *str = "0123"; 2517 char f = 'X'; 2518 const char *endptr = &f; 2519 uint64_t res = 999; 2520 int err; 2521 2522 err = qemu_strtou64(str, &endptr, 10, &res); 2523 2524 g_assert_cmpint(err, ==, 0); 2525 g_assert_cmpuint(res, ==, 123); 2526 g_assert_true(endptr == str + strlen(str)); 2527 2528 str = "123"; 2529 endptr = &f; 2530 res = 999; 2531 err = qemu_strtou64(str, &endptr, 0, &res); 2532 2533 g_assert_cmpint(err, ==, 0); 2534 g_assert_cmpuint(res, ==, 123); 2535 g_assert_true(endptr == str + strlen(str)); 2536 } 2537 2538 static void test_qemu_strtou64_hex(void) 2539 { 2540 const char *str = "0123"; 2541 char f = 'X'; 2542 const char *endptr = &f; 2543 uint64_t res = 999; 2544 int err; 2545 2546 err = qemu_strtou64(str, &endptr, 16, &res); 2547 2548 g_assert_cmpint(err, ==, 0); 2549 g_assert_cmphex(res, ==, 0x123); 2550 g_assert_true(endptr == str + strlen(str)); 2551 2552 str = "0x123"; 2553 endptr = &f; 2554 res = 999; 2555 err = qemu_strtou64(str, &endptr, 0, &res); 2556 2557 g_assert_cmpint(err, ==, 0); 2558 g_assert_cmphex(res, ==, 0x123); 2559 g_assert_true(endptr == str + strlen(str)); 2560 2561 str = "0x"; 2562 endptr = &f; 2563 res = 999; 2564 err = qemu_strtou64(str, &endptr, 16, &res); 2565 2566 g_assert_cmpint(err, ==, 0); 2567 g_assert_cmphex(res, ==, 0); 2568 g_assert_true(endptr == str + 1); 2569 } 2570 2571 static void test_qemu_strtou64_wrap(void) 2572 { 2573 const char *str = "-18446744073709551615"; /* 1 mod 2^64 */ 2574 char f = 'X'; 2575 const char *endptr = &f; 2576 uint64_t res = 999; 2577 int err; 2578 2579 err = qemu_strtou64(str, &endptr, 0, &res); 2580 2581 g_assert_cmpint(err, ==, 0); 2582 g_assert_cmpuint(res, ==, 1); 2583 g_assert_true(endptr == str + strlen(str)); 2584 } 2585 2586 static void test_qemu_strtou64_max(void) 2587 { 2588 char *str = g_strdup_printf("%llu", ULLONG_MAX); 2589 char f = 'X'; 2590 const char *endptr = &f; 2591 uint64_t res = 999; 2592 int err; 2593 2594 err = qemu_strtou64(str, &endptr, 0, &res); 2595 2596 g_assert_cmpint(err, ==, 0); 2597 g_assert_cmphex(res, ==, ULLONG_MAX); 2598 g_assert_true(endptr == str + strlen(str)); 2599 g_free(str); 2600 } 2601 2602 static void test_qemu_strtou64_overflow(void) 2603 { 2604 const char *str; 2605 const char *endptr; 2606 uint64_t res; 2607 int err; 2608 2609 str = "18446744073709551616"; /* 1 more than UINT64_MAX */ 2610 endptr = "somewhere"; 2611 res = 999; 2612 err = qemu_strtou64(str, &endptr, 0, &res); 2613 g_assert_cmpint(err, ==, -ERANGE); 2614 g_assert_cmpuint(res, ==, UINT64_MAX); 2615 g_assert_true(endptr == str + strlen(str)); 2616 2617 str = "0x10000000000000000"; /* 65 bits, 64-bit sign bit clear */ 2618 endptr = "somewhere"; 2619 res = 999; 2620 err = qemu_strtou64(str, &endptr, 0, &res); 2621 g_assert_cmpint(err, ==, -ERANGE); 2622 g_assert_cmpuint(res, ==, UINT64_MAX); 2623 g_assert_true(endptr == str + strlen(str)); 2624 2625 str = "0x18000000080000000"; /* 65 bits, 64-bit sign bit set */ 2626 endptr = "somewhere"; 2627 res = 999; 2628 err = qemu_strtou64(str, &endptr, 0, &res); 2629 g_assert_cmpint(err, ==, -ERANGE); 2630 g_assert_cmpuint(res, ==, UINT64_MAX); 2631 g_assert_true(endptr == str + strlen(str)); 2632 } 2633 2634 static void test_qemu_strtou64_underflow(void) 2635 { 2636 const char *str; 2637 const char *endptr; 2638 uint64_t res; 2639 int err; 2640 2641 str = "-99999999999999999999999999999999999999999999"; 2642 endptr = "somewhere"; 2643 res = 999; 2644 err = qemu_strtou64(str, &endptr, 0, &res); 2645 g_assert_cmpint(err, ==, -ERANGE); 2646 g_assert_cmpuint(res, ==, UINT64_MAX); 2647 g_assert_true(endptr == str + strlen(str)); 2648 2649 str = "-0x10000000000000000"; /* 65 bits, 64-bit sign bit clear */ 2650 endptr = "somewhere"; 2651 res = 999; 2652 err = qemu_strtou64(str, &endptr, 0, &res); 2653 g_assert_cmpint(err, ==, -ERANGE); 2654 g_assert_cmpuint(res, ==, UINT64_MAX); 2655 g_assert_true(endptr == str + strlen(str)); 2656 2657 str = "-0x18000000080000000"; /* 65 bits, 64-bit sign bit set */ 2658 endptr = "somewhere"; 2659 res = 999; 2660 err = qemu_strtou64(str, &endptr, 0, &res); 2661 g_assert_cmpint(err, ==, -ERANGE); 2662 g_assert_cmpuint(res, ==, UINT64_MAX); 2663 g_assert_true(endptr == str + strlen(str)); 2664 } 2665 2666 static void test_qemu_strtou64_negative(void) 2667 { 2668 const char *str = " \t -321"; 2669 char f = 'X'; 2670 const char *endptr = &f; 2671 uint64_t res = 999; 2672 int err; 2673 2674 err = qemu_strtou64(str, &endptr, 0, &res); 2675 2676 g_assert_cmpint(err, ==, 0); 2677 g_assert_cmpuint(res, ==, -321ull); 2678 g_assert_true(endptr == str + strlen(str)); 2679 } 2680 2681 static void test_qemu_strtou64_negzero(void) 2682 { 2683 const char *str = " -0"; 2684 char f = 'X'; 2685 const char *endptr = &f; 2686 uint64_t res = 999; 2687 int err; 2688 2689 err = qemu_strtou64(str, &endptr, 0, &res); 2690 2691 g_assert_cmpint(err, ==, 0); 2692 g_assert_cmpuint(res, ==, 0); 2693 g_assert_true(endptr == str + strlen(str)); 2694 } 2695 2696 static void test_qemu_strtou64_full_correct(void) 2697 { 2698 const char *str = "18446744073709551614"; 2699 uint64_t res = 999; 2700 int err; 2701 2702 err = qemu_strtou64(str, NULL, 0, &res); 2703 2704 g_assert_cmpint(err, ==, 0); 2705 g_assert_cmpuint(res, ==, 18446744073709551614ull); 2706 } 2707 2708 static void test_qemu_strtou64_full_null(void) 2709 { 2710 uint64_t res = 999; 2711 int err; 2712 2713 err = qemu_strtou64(NULL, NULL, 0, &res); 2714 2715 g_assert_cmpint(err, ==, -EINVAL); 2716 g_assert_cmpuint(res, ==, 999); 2717 } 2718 2719 static void test_qemu_strtou64_full_empty(void) 2720 { 2721 const char *str = ""; 2722 uint64_t res = 999; 2723 int err; 2724 2725 err = qemu_strtou64(str, NULL, 0, &res); 2726 2727 g_assert_cmpint(err, ==, -EINVAL); 2728 g_assert_cmpuint(res, ==, 0); 2729 } 2730 2731 static void test_qemu_strtou64_full_negative(void) 2732 { 2733 const char *str = " \t -321"; 2734 uint64_t res = 999; 2735 int err; 2736 2737 err = qemu_strtou64(str, NULL, 0, &res); 2738 2739 g_assert_cmpint(err, ==, 0); 2740 g_assert_cmpuint(res, ==, -321ull); 2741 } 2742 2743 static void test_qemu_strtou64_full_negzero(void) 2744 { 2745 const char *str = " -0"; 2746 uint64_t res = 999; 2747 int err; 2748 2749 err = qemu_strtou64(str, NULL, 0, &res); 2750 2751 g_assert_cmpint(err, ==, 0); 2752 g_assert_cmpuint(res, ==, 0); 2753 } 2754 2755 static void test_qemu_strtou64_full_trailing(void) 2756 { 2757 const char *str = "18446744073709551614xxxxxx"; 2758 uint64_t res = 999; 2759 int err; 2760 2761 err = qemu_strtou64(str, NULL, 0, &res); 2762 2763 g_assert_cmpint(err, ==, -EINVAL); 2764 g_assert_cmpuint(res, ==, 18446744073709551614ULL); 2765 } 2766 2767 static void test_qemu_strtou64_full_max(void) 2768 { 2769 char *str = g_strdup_printf("%lld", ULLONG_MAX); 2770 uint64_t res = 999; 2771 int err; 2772 2773 err = qemu_strtou64(str, NULL, 0, &res); 2774 2775 g_assert_cmpint(err, ==, 0); 2776 g_assert_cmphex(res, ==, ULLONG_MAX); 2777 g_free(str); 2778 } 2779 2780 static void test_qemu_strtou64_full_erange_junk(void) 2781 { 2782 /* EINVAL has priority over ERANGE */ 2783 const char *str = "-99999999999999999999junk"; 2784 uint64_t res = 999; 2785 int err; 2786 2787 err = qemu_strtou64(str, NULL, 0, &res); 2788 2789 g_assert_cmpint(err, ==, -EINVAL); 2790 g_assert_cmpuint(res, ==, UINT64_MAX); 2791 } 2792 2793 static void test_qemu_strtosz_simple(void) 2794 { 2795 const char *str; 2796 const char *endptr; 2797 int err; 2798 uint64_t res; 2799 2800 str = "0"; 2801 endptr = str; 2802 res = 0xbaadf00d; 2803 err = qemu_strtosz(str, &endptr, &res); 2804 g_assert_cmpint(err, ==, 0); 2805 g_assert_cmpuint(res, ==, 0); 2806 g_assert_true(endptr == str + 1); 2807 2808 /* Leading 0 gives decimal results, not octal */ 2809 str = "08"; 2810 endptr = str; 2811 res = 0xbaadf00d; 2812 err = qemu_strtosz(str, &endptr, &res); 2813 g_assert_cmpint(err, ==, 0); 2814 g_assert_cmpuint(res, ==, 8); 2815 g_assert_true(endptr == str + 2); 2816 2817 /* Leading space is ignored */ 2818 str = " 12345"; 2819 endptr = str; 2820 res = 0xbaadf00d; 2821 err = qemu_strtosz(str, &endptr, &res); 2822 g_assert_cmpint(err, ==, 0); 2823 g_assert_cmpuint(res, ==, 12345); 2824 g_assert_true(endptr == str + 6); 2825 2826 res = 0xbaadf00d; 2827 err = qemu_strtosz(str, NULL, &res); 2828 g_assert_cmpint(err, ==, 0); 2829 g_assert_cmpuint(res, ==, 12345); 2830 2831 str = "9007199254740991"; /* 2^53-1 */ 2832 endptr = str; 2833 res = 0xbaadf00d; 2834 err = qemu_strtosz(str, &endptr, &res); 2835 g_assert_cmpint(err, ==, 0); 2836 g_assert_cmphex(res, ==, 0x1fffffffffffffULL); 2837 g_assert_true(endptr == str + 16); 2838 2839 str = "9007199254740992"; /* 2^53 */ 2840 endptr = str; 2841 res = 0xbaadf00d; 2842 err = qemu_strtosz(str, &endptr, &res); 2843 g_assert_cmpint(err, ==, 0); 2844 g_assert_cmphex(res, ==, 0x20000000000000ULL); 2845 g_assert_true(endptr == str + 16); 2846 2847 str = "9007199254740993"; /* 2^53+1 */ 2848 endptr = str; 2849 res = 0xbaadf00d; 2850 err = qemu_strtosz(str, &endptr, &res); 2851 g_assert_cmpint(err, ==, 0); 2852 g_assert_cmphex(res, ==, 0x20000000000001ULL); 2853 g_assert_true(endptr == str + 16); 2854 2855 str = "18446744073709549568"; /* 0xfffffffffffff800 (53 msbs set) */ 2856 endptr = str; 2857 res = 0xbaadf00d; 2858 err = qemu_strtosz(str, &endptr, &res); 2859 g_assert_cmpint(err, ==, 0); 2860 g_assert_cmphex(res, ==, 0xfffffffffffff800ULL); 2861 g_assert_true(endptr == str + 20); 2862 2863 str = "18446744073709550591"; /* 0xfffffffffffffbff */ 2864 endptr = str; 2865 res = 0xbaadf00d; 2866 err = qemu_strtosz(str, &endptr, &res); 2867 g_assert_cmpint(err, ==, 0); 2868 g_assert_cmphex(res, ==, 0xfffffffffffffbffULL); 2869 g_assert_true(endptr == str + 20); 2870 2871 str = "18446744073709551615"; /* 0xffffffffffffffff */ 2872 endptr = str; 2873 res = 0xbaadf00d; 2874 err = qemu_strtosz(str, &endptr, &res); 2875 g_assert_cmpint(err, ==, 0); 2876 g_assert_cmphex(res, ==, 0xffffffffffffffffULL); 2877 g_assert_true(endptr == str + 20); 2878 } 2879 2880 static void test_qemu_strtosz_hex(void) 2881 { 2882 const char *str; 2883 const char *endptr; 2884 int err; 2885 uint64_t res; 2886 2887 str = "0x0"; 2888 endptr = str; 2889 res = 0xbaadf00d; 2890 err = qemu_strtosz(str, &endptr, &res); 2891 g_assert_cmpint(err, ==, 0); 2892 g_assert_cmpuint(res, ==, 0); 2893 g_assert_true(endptr == str + 3); 2894 2895 str = "0xab"; 2896 endptr = str; 2897 res = 0xbaadf00d; 2898 err = qemu_strtosz(str, &endptr, &res); 2899 g_assert_cmpint(err, ==, 0); 2900 g_assert_cmpuint(res, ==, 171); 2901 g_assert_true(endptr == str + 4); 2902 2903 str = "0xae"; 2904 endptr = str; 2905 res = 0xbaadf00d; 2906 err = qemu_strtosz(str, &endptr, &res); 2907 g_assert_cmpint(err, ==, 0); 2908 g_assert_cmpuint(res, ==, 174); 2909 g_assert_true(endptr == str + 4); 2910 } 2911 2912 static void test_qemu_strtosz_units(void) 2913 { 2914 const char *none = "1"; 2915 const char *b = "1B"; 2916 const char *k = "1K"; 2917 const char *m = "1M"; 2918 const char *g = "1G"; 2919 const char *t = "1T"; 2920 const char *p = "1P"; 2921 const char *e = "1E"; 2922 int err; 2923 const char *endptr; 2924 uint64_t res; 2925 2926 /* default is M */ 2927 endptr = NULL; 2928 res = 0xbaadf00d; 2929 err = qemu_strtosz_MiB(none, &endptr, &res); 2930 g_assert_cmpint(err, ==, 0); 2931 g_assert_cmpuint(res, ==, MiB); 2932 g_assert_true(endptr == none + 1); 2933 2934 endptr = NULL; 2935 res = 0xbaadf00d; 2936 err = qemu_strtosz(b, &endptr, &res); 2937 g_assert_cmpint(err, ==, 0); 2938 g_assert_cmpuint(res, ==, 1); 2939 g_assert_true(endptr == b + 2); 2940 2941 endptr = NULL; 2942 res = 0xbaadf00d; 2943 err = qemu_strtosz(k, &endptr, &res); 2944 g_assert_cmpint(err, ==, 0); 2945 g_assert_cmpuint(res, ==, KiB); 2946 g_assert_true(endptr == k + 2); 2947 2948 endptr = NULL; 2949 res = 0xbaadf00d; 2950 err = qemu_strtosz(m, &endptr, &res); 2951 g_assert_cmpint(err, ==, 0); 2952 g_assert_cmpuint(res, ==, MiB); 2953 g_assert_true(endptr == m + 2); 2954 2955 endptr = NULL; 2956 res = 0xbaadf00d; 2957 err = qemu_strtosz(g, &endptr, &res); 2958 g_assert_cmpint(err, ==, 0); 2959 g_assert_cmpuint(res, ==, GiB); 2960 g_assert_true(endptr == g + 2); 2961 2962 endptr = NULL; 2963 res = 0xbaadf00d; 2964 err = qemu_strtosz(t, &endptr, &res); 2965 g_assert_cmpint(err, ==, 0); 2966 g_assert_cmpuint(res, ==, TiB); 2967 g_assert_true(endptr == t + 2); 2968 2969 endptr = NULL; 2970 res = 0xbaadf00d; 2971 err = qemu_strtosz(p, &endptr, &res); 2972 g_assert_cmpint(err, ==, 0); 2973 g_assert_cmpuint(res, ==, PiB); 2974 g_assert_true(endptr == p + 2); 2975 2976 endptr = NULL; 2977 res = 0xbaadf00d; 2978 err = qemu_strtosz(e, &endptr, &res); 2979 g_assert_cmpint(err, ==, 0); 2980 g_assert_cmpuint(res, ==, EiB); 2981 g_assert_true(endptr == e + 2); 2982 } 2983 2984 static void test_qemu_strtosz_float(void) 2985 { 2986 const char *str; 2987 int err; 2988 const char *endptr; 2989 uint64_t res; 2990 2991 str = "0.5E"; 2992 endptr = str; 2993 res = 0xbaadf00d; 2994 err = qemu_strtosz(str, &endptr, &res); 2995 g_assert_cmpint(err, ==, 0); 2996 g_assert_cmpuint(res, ==, EiB / 2); 2997 g_assert_true(endptr == str + 4); 2998 2999 /* For convenience, a fraction of 0 is tolerated even on bytes */ 3000 str = "1.0B"; 3001 endptr = str; 3002 res = 0xbaadf00d; 3003 err = qemu_strtosz(str, &endptr, &res); 3004 g_assert_cmpint(err, ==, 0); 3005 g_assert_cmpuint(res, ==, 1); 3006 g_assert_true(endptr == str + 4); 3007 3008 /* An empty fraction is tolerated */ 3009 str = "1.k"; 3010 endptr = str; 3011 res = 0xbaadf00d; 3012 err = qemu_strtosz(str, &endptr, &res); 3013 g_assert_cmpint(err, ==, 0); 3014 g_assert_cmpuint(res, ==, 1024); 3015 g_assert_true(endptr == str + 3); 3016 3017 /* For convenience, we permit values that are not byte-exact */ 3018 str = "12.345M"; 3019 endptr = str; 3020 res = 0xbaadf00d; 3021 err = qemu_strtosz(str, &endptr, &res); 3022 g_assert_cmpint(err, ==, 0); 3023 g_assert_cmpuint(res, ==, (uint64_t) (12.345 * MiB + 0.5)); 3024 g_assert_true(endptr == str + 7); 3025 } 3026 3027 static void test_qemu_strtosz_invalid(void) 3028 { 3029 const char *str; 3030 const char *endptr; 3031 int err; 3032 uint64_t res = 0xbaadf00d; 3033 3034 str = ""; 3035 endptr = NULL; 3036 err = qemu_strtosz(str, &endptr, &res); 3037 g_assert_cmpint(err, ==, -EINVAL); 3038 g_assert_cmphex(res, ==, 0xbaadf00d); 3039 g_assert_true(endptr == str); 3040 3041 str = " \t "; 3042 endptr = NULL; 3043 err = qemu_strtosz(str, &endptr, &res); 3044 g_assert_cmpint(err, ==, -EINVAL); 3045 g_assert_cmphex(res, ==, 0xbaadf00d); 3046 g_assert_true(endptr == str); 3047 3048 str = "crap"; 3049 endptr = NULL; 3050 err = qemu_strtosz(str, &endptr, &res); 3051 g_assert_cmpint(err, ==, -EINVAL); 3052 g_assert_cmphex(res, ==, 0xbaadf00d); 3053 g_assert_true(endptr == str); 3054 3055 str = "inf"; 3056 endptr = NULL; 3057 err = qemu_strtosz(str, &endptr, &res); 3058 g_assert_cmpint(err, ==, -EINVAL); 3059 g_assert_cmphex(res, ==, 0xbaadf00d); 3060 g_assert_true(endptr == str); 3061 3062 str = "NaN"; 3063 endptr = NULL; 3064 err = qemu_strtosz(str, &endptr, &res); 3065 g_assert_cmpint(err, ==, -EINVAL); 3066 g_assert_cmphex(res, ==, 0xbaadf00d); 3067 g_assert_true(endptr == str); 3068 3069 /* Fractional values require scale larger than bytes */ 3070 str = "1.1B"; 3071 endptr = NULL; 3072 err = qemu_strtosz(str, &endptr, &res); 3073 g_assert_cmpint(err, ==, -EINVAL); 3074 g_assert_cmphex(res, ==, 0xbaadf00d); 3075 g_assert_true(endptr == str); 3076 3077 str = "1.1"; 3078 endptr = NULL; 3079 err = qemu_strtosz(str, &endptr, &res); 3080 g_assert_cmpint(err, ==, -EINVAL); 3081 g_assert_cmphex(res, ==, 0xbaadf00d); 3082 g_assert_true(endptr == str); 3083 3084 /* No floating point exponents */ 3085 str = "1.5e1k"; 3086 endptr = NULL; 3087 err = qemu_strtosz(str, &endptr, &res); 3088 g_assert_cmpint(err, ==, -EINVAL); 3089 g_assert_cmphex(res, ==, 0xbaadf00d); 3090 g_assert_true(endptr == str); 3091 3092 str = "1.5E+0k"; 3093 endptr = NULL; 3094 err = qemu_strtosz(str, &endptr, &res); 3095 g_assert_cmpint(err, ==, -EINVAL); 3096 g_assert_cmphex(res, ==, 0xbaadf00d); 3097 g_assert_true(endptr == str); 3098 3099 /* No hex fractions */ 3100 str = "0x1.8k"; 3101 endptr = NULL; 3102 err = qemu_strtosz(str, &endptr, &res); 3103 g_assert_cmpint(err, ==, -EINVAL); 3104 g_assert_cmphex(res, ==, 0xbaadf00d); 3105 g_assert_true(endptr == str); 3106 3107 /* No suffixes */ 3108 str = "0x18M"; 3109 endptr = NULL; 3110 err = qemu_strtosz(str, &endptr, &res); 3111 g_assert_cmpint(err, ==, -EINVAL); 3112 g_assert_cmphex(res, ==, 0xbaadf00d); 3113 g_assert_true(endptr == str); 3114 3115 /* No negative values */ 3116 str = "-0"; 3117 endptr = NULL; 3118 err = qemu_strtosz(str, &endptr, &res); 3119 g_assert_cmpint(err, ==, -EINVAL); 3120 g_assert_cmphex(res, ==, 0xbaadf00d); 3121 g_assert_true(endptr == str); 3122 3123 str = "-1"; 3124 endptr = NULL; 3125 err = qemu_strtosz(str, &endptr, &res); 3126 g_assert_cmpint(err, ==, -EINVAL); 3127 g_assert_cmphex(res, ==, 0xbaadf00d); 3128 g_assert_true(endptr == str); 3129 } 3130 3131 static void test_qemu_strtosz_trailing(void) 3132 { 3133 const char *str; 3134 const char *endptr; 3135 int err; 3136 uint64_t res; 3137 3138 str = "123xxx"; 3139 endptr = NULL; 3140 res = 0xbaadf00d; 3141 err = qemu_strtosz_MiB(str, &endptr, &res); 3142 g_assert_cmpint(err, ==, 0); 3143 g_assert_cmpuint(res, ==, 123 * MiB); 3144 g_assert_true(endptr == str + 3); 3145 3146 res = 0xbaadf00d; 3147 err = qemu_strtosz(str, NULL, &res); 3148 g_assert_cmpint(err, ==, -EINVAL); 3149 g_assert_cmphex(res, ==, 0xbaadf00d); 3150 3151 str = "1kiB"; 3152 endptr = NULL; 3153 res = 0xbaadf00d; 3154 err = qemu_strtosz(str, &endptr, &res); 3155 g_assert_cmpint(err, ==, 0); 3156 g_assert_cmpuint(res, ==, 1024); 3157 g_assert_true(endptr == str + 2); 3158 3159 res = 0xbaadf00d; 3160 err = qemu_strtosz(str, NULL, &res); 3161 g_assert_cmpint(err, ==, -EINVAL); 3162 g_assert_cmphex(res, ==, 0xbaadf00d); 3163 3164 str = "0x"; 3165 endptr = NULL; 3166 res = 0xbaadf00d; 3167 err = qemu_strtosz(str, &endptr, &res); 3168 g_assert_cmpint(err, ==, 0); 3169 g_assert_cmpuint(res, ==, 0); 3170 g_assert_true(endptr == str + 1); 3171 3172 res = 0xbaadf00d; 3173 err = qemu_strtosz(str, NULL, &res); 3174 g_assert_cmpint(err, ==, -EINVAL); 3175 g_assert_cmphex(res, ==, 0xbaadf00d); 3176 3177 str = "0.NaN"; 3178 endptr = NULL; 3179 res = 0xbaadf00d; 3180 err = qemu_strtosz(str, &endptr, &res); 3181 g_assert_cmpint(err, ==, 0); 3182 g_assert_cmpuint(res, ==, 0); 3183 g_assert_true(endptr == str + 2); 3184 3185 res = 0xbaadf00d; 3186 err = qemu_strtosz(str, NULL, &res); 3187 g_assert_cmpint(err, ==, -EINVAL); 3188 g_assert_cmphex(res, ==, 0xbaadf00d); 3189 3190 str = "123-45"; 3191 endptr = NULL; 3192 res = 0xbaadf00d; 3193 err = qemu_strtosz(str, &endptr, &res); 3194 g_assert_cmpint(err, ==, 0); 3195 g_assert_cmpuint(res, ==, 123); 3196 g_assert_true(endptr == str + 3); 3197 3198 res = 0xbaadf00d; 3199 err = qemu_strtosz(str, NULL, &res); 3200 g_assert_cmpint(err, ==, -EINVAL); 3201 g_assert_cmphex(res, ==, 0xbaadf00d); 3202 } 3203 3204 static void test_qemu_strtosz_erange(void) 3205 { 3206 const char *str; 3207 const char *endptr; 3208 int err; 3209 uint64_t res = 0xbaadf00d; 3210 3211 str = "18446744073709551616"; /* 2^64; see strtosz_simple for 2^64-1 */ 3212 endptr = NULL; 3213 err = qemu_strtosz(str, &endptr, &res); 3214 g_assert_cmpint(err, ==, -ERANGE); 3215 g_assert_cmphex(res, ==, 0xbaadf00d); 3216 g_assert_true(endptr == str + 20); 3217 3218 str = "20E"; 3219 endptr = NULL; 3220 err = qemu_strtosz(str, &endptr, &res); 3221 g_assert_cmpint(err, ==, -ERANGE); 3222 g_assert_cmphex(res, ==, 0xbaadf00d); 3223 g_assert_true(endptr == str + 3); 3224 } 3225 3226 static void test_qemu_strtosz_metric(void) 3227 { 3228 const char *str; 3229 int err; 3230 const char *endptr; 3231 uint64_t res; 3232 3233 str = "12345k"; 3234 endptr = str; 3235 res = 0xbaadf00d; 3236 err = qemu_strtosz_metric(str, &endptr, &res); 3237 g_assert_cmpint(err, ==, 0); 3238 g_assert_cmpuint(res, ==, 12345000); 3239 g_assert_true(endptr == str + 6); 3240 3241 str = "12.345M"; 3242 endptr = str; 3243 res = 0xbaadf00d; 3244 err = qemu_strtosz_metric(str, &endptr, &res); 3245 g_assert_cmpint(err, ==, 0); 3246 g_assert_cmpuint(res, ==, 12345000); 3247 g_assert_true(endptr == str + 7); 3248 } 3249 3250 static void test_freq_to_str(void) 3251 { 3252 char *str; 3253 3254 str = freq_to_str(999); 3255 g_assert_cmpstr(str, ==, "999 Hz"); 3256 g_free(str); 3257 3258 str = freq_to_str(1000); 3259 g_assert_cmpstr(str, ==, "1 KHz"); 3260 g_free(str); 3261 3262 str = freq_to_str(1010); 3263 g_assert_cmpstr(str, ==, "1.01 KHz"); 3264 g_free(str); 3265 } 3266 3267 static void test_size_to_str(void) 3268 { 3269 char *str; 3270 3271 str = size_to_str(0); 3272 g_assert_cmpstr(str, ==, "0 B"); 3273 g_free(str); 3274 3275 str = size_to_str(1); 3276 g_assert_cmpstr(str, ==, "1 B"); 3277 g_free(str); 3278 3279 str = size_to_str(1016); 3280 g_assert_cmpstr(str, ==, "0.992 KiB"); 3281 g_free(str); 3282 3283 str = size_to_str(1024); 3284 g_assert_cmpstr(str, ==, "1 KiB"); 3285 g_free(str); 3286 3287 str = size_to_str(512ull << 20); 3288 g_assert_cmpstr(str, ==, "512 MiB"); 3289 g_free(str); 3290 } 3291 3292 static void test_iec_binary_prefix(void) 3293 { 3294 g_assert_cmpstr(iec_binary_prefix(0), ==, ""); 3295 g_assert_cmpstr(iec_binary_prefix(10), ==, "Ki"); 3296 g_assert_cmpstr(iec_binary_prefix(20), ==, "Mi"); 3297 g_assert_cmpstr(iec_binary_prefix(30), ==, "Gi"); 3298 g_assert_cmpstr(iec_binary_prefix(40), ==, "Ti"); 3299 g_assert_cmpstr(iec_binary_prefix(50), ==, "Pi"); 3300 g_assert_cmpstr(iec_binary_prefix(60), ==, "Ei"); 3301 } 3302 3303 static void test_si_prefix(void) 3304 { 3305 g_assert_cmpstr(si_prefix(-18), ==, "a"); 3306 g_assert_cmpstr(si_prefix(-15), ==, "f"); 3307 g_assert_cmpstr(si_prefix(-12), ==, "p"); 3308 g_assert_cmpstr(si_prefix(-9), ==, "n"); 3309 g_assert_cmpstr(si_prefix(-6), ==, "u"); 3310 g_assert_cmpstr(si_prefix(-3), ==, "m"); 3311 g_assert_cmpstr(si_prefix(0), ==, ""); 3312 g_assert_cmpstr(si_prefix(3), ==, "K"); 3313 g_assert_cmpstr(si_prefix(6), ==, "M"); 3314 g_assert_cmpstr(si_prefix(9), ==, "G"); 3315 g_assert_cmpstr(si_prefix(12), ==, "T"); 3316 g_assert_cmpstr(si_prefix(15), ==, "P"); 3317 g_assert_cmpstr(si_prefix(18), ==, "E"); 3318 } 3319 3320 int main(int argc, char **argv) 3321 { 3322 g_test_init(&argc, &argv, NULL); 3323 3324 g_test_add_func("/cutils/parse_uint/null", test_parse_uint_null); 3325 g_test_add_func("/cutils/parse_uint/empty", test_parse_uint_empty); 3326 g_test_add_func("/cutils/parse_uint/whitespace", 3327 test_parse_uint_whitespace); 3328 g_test_add_func("/cutils/parse_uint/invalid", test_parse_uint_invalid); 3329 g_test_add_func("/cutils/parse_uint/trailing", test_parse_uint_trailing); 3330 g_test_add_func("/cutils/parse_uint/correct", test_parse_uint_correct); 3331 g_test_add_func("/cutils/parse_uint/octal", test_parse_uint_octal); 3332 g_test_add_func("/cutils/parse_uint/decimal", test_parse_uint_decimal); 3333 g_test_add_func("/cutils/parse_uint/llong_max", test_parse_uint_llong_max); 3334 g_test_add_func("/cutils/parse_uint/max", test_parse_uint_max); 3335 g_test_add_func("/cutils/parse_uint/overflow", test_parse_uint_overflow); 3336 g_test_add_func("/cutils/parse_uint/negative", test_parse_uint_negative); 3337 g_test_add_func("/cutils/parse_uint/negzero", test_parse_uint_negzero); 3338 g_test_add_func("/cutils/parse_uint_full/trailing", 3339 test_parse_uint_full_trailing); 3340 g_test_add_func("/cutils/parse_uint_full/correct", 3341 test_parse_uint_full_correct); 3342 g_test_add_func("/cutils/parse_uint_full/erange_junk", 3343 test_parse_uint_full_erange_junk); 3344 3345 /* qemu_strtoi() tests */ 3346 g_test_add_func("/cutils/qemu_strtoi/correct", 3347 test_qemu_strtoi_correct); 3348 g_test_add_func("/cutils/qemu_strtoi/null", 3349 test_qemu_strtoi_null); 3350 g_test_add_func("/cutils/qemu_strtoi/empty", 3351 test_qemu_strtoi_empty); 3352 g_test_add_func("/cutils/qemu_strtoi/whitespace", 3353 test_qemu_strtoi_whitespace); 3354 g_test_add_func("/cutils/qemu_strtoi/invalid", 3355 test_qemu_strtoi_invalid); 3356 g_test_add_func("/cutils/qemu_strtoi/trailing", 3357 test_qemu_strtoi_trailing); 3358 g_test_add_func("/cutils/qemu_strtoi/octal", 3359 test_qemu_strtoi_octal); 3360 g_test_add_func("/cutils/qemu_strtoi/decimal", 3361 test_qemu_strtoi_decimal); 3362 g_test_add_func("/cutils/qemu_strtoi/hex", 3363 test_qemu_strtoi_hex); 3364 g_test_add_func("/cutils/qemu_strtoi/max", 3365 test_qemu_strtoi_max); 3366 g_test_add_func("/cutils/qemu_strtoi/overflow", 3367 test_qemu_strtoi_overflow); 3368 g_test_add_func("/cutils/qemu_strtoi/min", 3369 test_qemu_strtoi_min); 3370 g_test_add_func("/cutils/qemu_strtoi/underflow", 3371 test_qemu_strtoi_underflow); 3372 g_test_add_func("/cutils/qemu_strtoi/negative", 3373 test_qemu_strtoi_negative); 3374 g_test_add_func("/cutils/qemu_strtoi/negzero", 3375 test_qemu_strtoi_negzero); 3376 g_test_add_func("/cutils/qemu_strtoi_full/correct", 3377 test_qemu_strtoi_full_correct); 3378 g_test_add_func("/cutils/qemu_strtoi_full/null", 3379 test_qemu_strtoi_full_null); 3380 g_test_add_func("/cutils/qemu_strtoi_full/empty", 3381 test_qemu_strtoi_full_empty); 3382 g_test_add_func("/cutils/qemu_strtoi_full/negative", 3383 test_qemu_strtoi_full_negative); 3384 g_test_add_func("/cutils/qemu_strtoi_full/negzero", 3385 test_qemu_strtoi_full_negzero); 3386 g_test_add_func("/cutils/qemu_strtoi_full/trailing", 3387 test_qemu_strtoi_full_trailing); 3388 g_test_add_func("/cutils/qemu_strtoi_full/max", 3389 test_qemu_strtoi_full_max); 3390 g_test_add_func("/cutils/qemu_strtoi_full/erange_junk", 3391 test_qemu_strtoi_full_erange_junk); 3392 3393 /* qemu_strtoui() tests */ 3394 g_test_add_func("/cutils/qemu_strtoui/correct", 3395 test_qemu_strtoui_correct); 3396 g_test_add_func("/cutils/qemu_strtoui/null", 3397 test_qemu_strtoui_null); 3398 g_test_add_func("/cutils/qemu_strtoui/empty", 3399 test_qemu_strtoui_empty); 3400 g_test_add_func("/cutils/qemu_strtoui/whitespace", 3401 test_qemu_strtoui_whitespace); 3402 g_test_add_func("/cutils/qemu_strtoui/invalid", 3403 test_qemu_strtoui_invalid); 3404 g_test_add_func("/cutils/qemu_strtoui/trailing", 3405 test_qemu_strtoui_trailing); 3406 g_test_add_func("/cutils/qemu_strtoui/octal", 3407 test_qemu_strtoui_octal); 3408 g_test_add_func("/cutils/qemu_strtoui/decimal", 3409 test_qemu_strtoui_decimal); 3410 g_test_add_func("/cutils/qemu_strtoui/hex", 3411 test_qemu_strtoui_hex); 3412 g_test_add_func("/cutils/qemu_strtoui/wrap", 3413 test_qemu_strtoui_wrap); 3414 g_test_add_func("/cutils/qemu_strtoui/max", 3415 test_qemu_strtoui_max); 3416 g_test_add_func("/cutils/qemu_strtoui/overflow", 3417 test_qemu_strtoui_overflow); 3418 g_test_add_func("/cutils/qemu_strtoui/underflow", 3419 test_qemu_strtoui_underflow); 3420 g_test_add_func("/cutils/qemu_strtoui/negative", 3421 test_qemu_strtoui_negative); 3422 g_test_add_func("/cutils/qemu_strtoui/negzero", 3423 test_qemu_strtoui_negzero); 3424 g_test_add_func("/cutils/qemu_strtoui_full/correct", 3425 test_qemu_strtoui_full_correct); 3426 g_test_add_func("/cutils/qemu_strtoui_full/null", 3427 test_qemu_strtoui_full_null); 3428 g_test_add_func("/cutils/qemu_strtoui_full/empty", 3429 test_qemu_strtoui_full_empty); 3430 g_test_add_func("/cutils/qemu_strtoui_full/negative", 3431 test_qemu_strtoui_full_negative); 3432 g_test_add_func("/cutils/qemu_strtoui_full/negzero", 3433 test_qemu_strtoui_full_negzero); 3434 g_test_add_func("/cutils/qemu_strtoui_full/trailing", 3435 test_qemu_strtoui_full_trailing); 3436 g_test_add_func("/cutils/qemu_strtoui_full/max", 3437 test_qemu_strtoui_full_max); 3438 g_test_add_func("/cutils/qemu_strtoui_full/erange_junk", 3439 test_qemu_strtoui_full_erange_junk); 3440 3441 /* qemu_strtol() tests */ 3442 g_test_add_func("/cutils/qemu_strtol/correct", 3443 test_qemu_strtol_correct); 3444 g_test_add_func("/cutils/qemu_strtol/null", 3445 test_qemu_strtol_null); 3446 g_test_add_func("/cutils/qemu_strtol/empty", 3447 test_qemu_strtol_empty); 3448 g_test_add_func("/cutils/qemu_strtol/whitespace", 3449 test_qemu_strtol_whitespace); 3450 g_test_add_func("/cutils/qemu_strtol/invalid", 3451 test_qemu_strtol_invalid); 3452 g_test_add_func("/cutils/qemu_strtol/trailing", 3453 test_qemu_strtol_trailing); 3454 g_test_add_func("/cutils/qemu_strtol/octal", 3455 test_qemu_strtol_octal); 3456 g_test_add_func("/cutils/qemu_strtol/decimal", 3457 test_qemu_strtol_decimal); 3458 g_test_add_func("/cutils/qemu_strtol/hex", 3459 test_qemu_strtol_hex); 3460 g_test_add_func("/cutils/qemu_strtol/max", 3461 test_qemu_strtol_max); 3462 g_test_add_func("/cutils/qemu_strtol/overflow", 3463 test_qemu_strtol_overflow); 3464 g_test_add_func("/cutils/qemu_strtol/min", 3465 test_qemu_strtol_min); 3466 g_test_add_func("/cutils/qemu_strtol/underflow", 3467 test_qemu_strtol_underflow); 3468 g_test_add_func("/cutils/qemu_strtol/negative", 3469 test_qemu_strtol_negative); 3470 g_test_add_func("/cutils/qemu_strtol/negzero", 3471 test_qemu_strtol_negzero); 3472 g_test_add_func("/cutils/qemu_strtol_full/correct", 3473 test_qemu_strtol_full_correct); 3474 g_test_add_func("/cutils/qemu_strtol_full/null", 3475 test_qemu_strtol_full_null); 3476 g_test_add_func("/cutils/qemu_strtol_full/empty", 3477 test_qemu_strtol_full_empty); 3478 g_test_add_func("/cutils/qemu_strtol_full/negative", 3479 test_qemu_strtol_full_negative); 3480 g_test_add_func("/cutils/qemu_strtol_full/negzero", 3481 test_qemu_strtol_full_negzero); 3482 g_test_add_func("/cutils/qemu_strtol_full/trailing", 3483 test_qemu_strtol_full_trailing); 3484 g_test_add_func("/cutils/qemu_strtol_full/max", 3485 test_qemu_strtol_full_max); 3486 g_test_add_func("/cutils/qemu_strtol_full/erange_junk", 3487 test_qemu_strtol_full_erange_junk); 3488 3489 /* qemu_strtoul() tests */ 3490 g_test_add_func("/cutils/qemu_strtoul/correct", 3491 test_qemu_strtoul_correct); 3492 g_test_add_func("/cutils/qemu_strtoul/null", 3493 test_qemu_strtoul_null); 3494 g_test_add_func("/cutils/qemu_strtoul/empty", 3495 test_qemu_strtoul_empty); 3496 g_test_add_func("/cutils/qemu_strtoul/whitespace", 3497 test_qemu_strtoul_whitespace); 3498 g_test_add_func("/cutils/qemu_strtoul/invalid", 3499 test_qemu_strtoul_invalid); 3500 g_test_add_func("/cutils/qemu_strtoul/trailing", 3501 test_qemu_strtoul_trailing); 3502 g_test_add_func("/cutils/qemu_strtoul/octal", 3503 test_qemu_strtoul_octal); 3504 g_test_add_func("/cutils/qemu_strtoul/decimal", 3505 test_qemu_strtoul_decimal); 3506 g_test_add_func("/cutils/qemu_strtoul/hex", 3507 test_qemu_strtoul_hex); 3508 g_test_add_func("/cutils/qemu_strtoul/wrap", 3509 test_qemu_strtoul_wrap); 3510 g_test_add_func("/cutils/qemu_strtoul/max", 3511 test_qemu_strtoul_max); 3512 g_test_add_func("/cutils/qemu_strtoul/overflow", 3513 test_qemu_strtoul_overflow); 3514 g_test_add_func("/cutils/qemu_strtoul/underflow", 3515 test_qemu_strtoul_underflow); 3516 g_test_add_func("/cutils/qemu_strtoul/negative", 3517 test_qemu_strtoul_negative); 3518 g_test_add_func("/cutils/qemu_strtoul/negzero", 3519 test_qemu_strtoul_negzero); 3520 g_test_add_func("/cutils/qemu_strtoul_full/correct", 3521 test_qemu_strtoul_full_correct); 3522 g_test_add_func("/cutils/qemu_strtoul_full/null", 3523 test_qemu_strtoul_full_null); 3524 g_test_add_func("/cutils/qemu_strtoul_full/empty", 3525 test_qemu_strtoul_full_empty); 3526 g_test_add_func("/cutils/qemu_strtoul_full/negative", 3527 test_qemu_strtoul_full_negative); 3528 g_test_add_func("/cutils/qemu_strtoul_full/negzero", 3529 test_qemu_strtoul_full_negzero); 3530 g_test_add_func("/cutils/qemu_strtoul_full/trailing", 3531 test_qemu_strtoul_full_trailing); 3532 g_test_add_func("/cutils/qemu_strtoul_full/max", 3533 test_qemu_strtoul_full_max); 3534 g_test_add_func("/cutils/qemu_strtoul_full/erange_junk", 3535 test_qemu_strtoul_full_erange_junk); 3536 3537 /* qemu_strtoi64() tests */ 3538 g_test_add_func("/cutils/qemu_strtoi64/correct", 3539 test_qemu_strtoi64_correct); 3540 g_test_add_func("/cutils/qemu_strtoi64/null", 3541 test_qemu_strtoi64_null); 3542 g_test_add_func("/cutils/qemu_strtoi64/empty", 3543 test_qemu_strtoi64_empty); 3544 g_test_add_func("/cutils/qemu_strtoi64/whitespace", 3545 test_qemu_strtoi64_whitespace); 3546 g_test_add_func("/cutils/qemu_strtoi64/invalid", 3547 test_qemu_strtoi64_invalid); 3548 g_test_add_func("/cutils/qemu_strtoi64/trailing", 3549 test_qemu_strtoi64_trailing); 3550 g_test_add_func("/cutils/qemu_strtoi64/octal", 3551 test_qemu_strtoi64_octal); 3552 g_test_add_func("/cutils/qemu_strtoi64/decimal", 3553 test_qemu_strtoi64_decimal); 3554 g_test_add_func("/cutils/qemu_strtoi64/hex", 3555 test_qemu_strtoi64_hex); 3556 g_test_add_func("/cutils/qemu_strtoi64/max", 3557 test_qemu_strtoi64_max); 3558 g_test_add_func("/cutils/qemu_strtoi64/overflow", 3559 test_qemu_strtoi64_overflow); 3560 g_test_add_func("/cutils/qemu_strtoi64/min", 3561 test_qemu_strtoi64_min); 3562 g_test_add_func("/cutils/qemu_strtoi64/underflow", 3563 test_qemu_strtoi64_underflow); 3564 g_test_add_func("/cutils/qemu_strtoi64/negative", 3565 test_qemu_strtoi64_negative); 3566 g_test_add_func("/cutils/qemu_strtoi64/negzero", 3567 test_qemu_strtoi64_negzero); 3568 g_test_add_func("/cutils/qemu_strtoi64_full/correct", 3569 test_qemu_strtoi64_full_correct); 3570 g_test_add_func("/cutils/qemu_strtoi64_full/null", 3571 test_qemu_strtoi64_full_null); 3572 g_test_add_func("/cutils/qemu_strtoi64_full/empty", 3573 test_qemu_strtoi64_full_empty); 3574 g_test_add_func("/cutils/qemu_strtoi64_full/negative", 3575 test_qemu_strtoi64_full_negative); 3576 g_test_add_func("/cutils/qemu_strtoi64_full/negzero", 3577 test_qemu_strtoi64_full_negzero); 3578 g_test_add_func("/cutils/qemu_strtoi64_full/trailing", 3579 test_qemu_strtoi64_full_trailing); 3580 g_test_add_func("/cutils/qemu_strtoi64_full/max", 3581 test_qemu_strtoi64_full_max); 3582 g_test_add_func("/cutils/qemu_strtoi64_full/erange_junk", 3583 test_qemu_strtoi64_full_erange_junk); 3584 3585 /* qemu_strtou64() tests */ 3586 g_test_add_func("/cutils/qemu_strtou64/correct", 3587 test_qemu_strtou64_correct); 3588 g_test_add_func("/cutils/qemu_strtou64/null", 3589 test_qemu_strtou64_null); 3590 g_test_add_func("/cutils/qemu_strtou64/empty", 3591 test_qemu_strtou64_empty); 3592 g_test_add_func("/cutils/qemu_strtou64/whitespace", 3593 test_qemu_strtou64_whitespace); 3594 g_test_add_func("/cutils/qemu_strtou64/invalid", 3595 test_qemu_strtou64_invalid); 3596 g_test_add_func("/cutils/qemu_strtou64/trailing", 3597 test_qemu_strtou64_trailing); 3598 g_test_add_func("/cutils/qemu_strtou64/octal", 3599 test_qemu_strtou64_octal); 3600 g_test_add_func("/cutils/qemu_strtou64/decimal", 3601 test_qemu_strtou64_decimal); 3602 g_test_add_func("/cutils/qemu_strtou64/hex", 3603 test_qemu_strtou64_hex); 3604 g_test_add_func("/cutils/qemu_strtou64/wrap", 3605 test_qemu_strtou64_wrap); 3606 g_test_add_func("/cutils/qemu_strtou64/max", 3607 test_qemu_strtou64_max); 3608 g_test_add_func("/cutils/qemu_strtou64/overflow", 3609 test_qemu_strtou64_overflow); 3610 g_test_add_func("/cutils/qemu_strtou64/underflow", 3611 test_qemu_strtou64_underflow); 3612 g_test_add_func("/cutils/qemu_strtou64/negative", 3613 test_qemu_strtou64_negative); 3614 g_test_add_func("/cutils/qemu_strtou64/negzero", 3615 test_qemu_strtou64_negzero); 3616 g_test_add_func("/cutils/qemu_strtou64_full/correct", 3617 test_qemu_strtou64_full_correct); 3618 g_test_add_func("/cutils/qemu_strtou64_full/null", 3619 test_qemu_strtou64_full_null); 3620 g_test_add_func("/cutils/qemu_strtou64_full/empty", 3621 test_qemu_strtou64_full_empty); 3622 g_test_add_func("/cutils/qemu_strtou64_full/negative", 3623 test_qemu_strtou64_full_negative); 3624 g_test_add_func("/cutils/qemu_strtou64_full/negzero", 3625 test_qemu_strtou64_full_negzero); 3626 g_test_add_func("/cutils/qemu_strtou64_full/trailing", 3627 test_qemu_strtou64_full_trailing); 3628 g_test_add_func("/cutils/qemu_strtou64_full/max", 3629 test_qemu_strtou64_full_max); 3630 g_test_add_func("/cutils/qemu_strtou64_full/erange_junk", 3631 test_qemu_strtou64_full_erange_junk); 3632 3633 g_test_add_func("/cutils/strtosz/simple", 3634 test_qemu_strtosz_simple); 3635 g_test_add_func("/cutils/strtosz/hex", 3636 test_qemu_strtosz_hex); 3637 g_test_add_func("/cutils/strtosz/units", 3638 test_qemu_strtosz_units); 3639 g_test_add_func("/cutils/strtosz/float", 3640 test_qemu_strtosz_float); 3641 g_test_add_func("/cutils/strtosz/invalid", 3642 test_qemu_strtosz_invalid); 3643 g_test_add_func("/cutils/strtosz/trailing", 3644 test_qemu_strtosz_trailing); 3645 g_test_add_func("/cutils/strtosz/erange", 3646 test_qemu_strtosz_erange); 3647 g_test_add_func("/cutils/strtosz/metric", 3648 test_qemu_strtosz_metric); 3649 3650 g_test_add_func("/cutils/size_to_str", 3651 test_size_to_str); 3652 g_test_add_func("/cutils/freq_to_str", 3653 test_freq_to_str); 3654 g_test_add_func("/cutils/iec_binary_prefix", 3655 test_iec_binary_prefix); 3656 g_test_add_func("/cutils/si_prefix", 3657 test_si_prefix); 3658 return g_test_run(); 3659 } 3660