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 154 static void test_parse_uint_llong_max(void) 155 { 156 unsigned long long i = 999; 157 char f = 'X'; 158 char *endptr = &f; 159 char *str = g_strdup_printf("%llu", (unsigned long long)LLONG_MAX + 1); 160 int r; 161 162 r = parse_uint(str, &i, &endptr, 0); 163 164 g_assert_cmpint(r, ==, 0); 165 g_assert_cmpuint(i, ==, (unsigned long long)LLONG_MAX + 1); 166 g_assert_true(endptr == str + strlen(str)); 167 168 g_free(str); 169 } 170 171 static void test_parse_uint_overflow(void) 172 { 173 unsigned long long i = 999; 174 char f = 'X'; 175 char *endptr = &f; 176 const char *str = "99999999999999999999999999999999999999"; 177 int r; 178 179 r = parse_uint(str, &i, &endptr, 0); 180 181 g_assert_cmpint(r, ==, -ERANGE); 182 g_assert_cmpuint(i, ==, ULLONG_MAX); 183 g_assert_true(endptr == str + strlen(str)); 184 } 185 186 static void test_parse_uint_negative(void) 187 { 188 unsigned long long i = 999; 189 char f = 'X'; 190 char *endptr = &f; 191 const char *str = " \t -321"; 192 int r; 193 194 r = parse_uint(str, &i, &endptr, 0); 195 196 g_assert_cmpint(r, ==, -ERANGE); 197 g_assert_cmpuint(i, ==, 0); 198 g_assert_true(endptr == str + strlen(str)); 199 } 200 201 202 static void test_parse_uint_full_trailing(void) 203 { 204 unsigned long long i = 999; 205 const char *str = "123xxx"; 206 int r; 207 208 r = parse_uint_full(str, &i, 0); 209 210 g_assert_cmpint(r, ==, -EINVAL); 211 g_assert_cmpuint(i, ==, 0); 212 } 213 214 static void test_parse_uint_full_correct(void) 215 { 216 unsigned long long i = 999; 217 const char *str = "123"; 218 int r; 219 220 r = parse_uint_full(str, &i, 0); 221 222 g_assert_cmpint(r, ==, 0); 223 g_assert_cmpuint(i, ==, 123); 224 } 225 226 static void test_qemu_strtoi_correct(void) 227 { 228 const char *str = "12345 foo"; 229 char f = 'X'; 230 const char *endptr = &f; 231 int res = 999; 232 int err; 233 234 err = qemu_strtoi(str, &endptr, 0, &res); 235 236 g_assert_cmpint(err, ==, 0); 237 g_assert_cmpint(res, ==, 12345); 238 g_assert_true(endptr == str + 5); 239 } 240 241 static void test_qemu_strtoi_null(void) 242 { 243 char f = 'X'; 244 const char *endptr = &f; 245 int res = 999; 246 int err; 247 248 err = qemu_strtoi(NULL, &endptr, 0, &res); 249 250 g_assert_cmpint(err, ==, -EINVAL); 251 g_assert_cmpint(res, ==, 999); 252 g_assert_null(endptr); 253 } 254 255 static void test_qemu_strtoi_empty(void) 256 { 257 const char *str = ""; 258 char f = 'X'; 259 const char *endptr = &f; 260 int res = 999; 261 int err; 262 263 err = qemu_strtoi(str, &endptr, 0, &res); 264 265 g_assert_cmpint(err, ==, -EINVAL); 266 g_assert_cmpint(res, ==, 0); 267 g_assert_true(endptr == str); 268 } 269 270 static void test_qemu_strtoi_whitespace(void) 271 { 272 const char *str = " \t "; 273 char f = 'X'; 274 const char *endptr = &f; 275 int res = 999; 276 int err; 277 278 err = qemu_strtoi(str, &endptr, 0, &res); 279 280 g_assert_cmpint(err, ==, -EINVAL); 281 g_assert_cmpint(res, ==, 0); 282 g_assert_true(endptr == str); 283 } 284 285 static void test_qemu_strtoi_invalid(void) 286 { 287 const char *str = " xxxx \t abc"; 288 char f = 'X'; 289 const char *endptr = &f; 290 int res = 999; 291 int err; 292 293 err = qemu_strtoi(str, &endptr, 0, &res); 294 295 g_assert_cmpint(err, ==, -EINVAL); 296 g_assert_cmpint(res, ==, 0); 297 g_assert_true(endptr == str); 298 } 299 300 static void test_qemu_strtoi_trailing(void) 301 { 302 const char *str = "123xxx"; 303 char f = 'X'; 304 const char *endptr = &f; 305 int res = 999; 306 int err; 307 308 err = qemu_strtoi(str, &endptr, 0, &res); 309 310 g_assert_cmpint(err, ==, 0); 311 g_assert_cmpint(res, ==, 123); 312 g_assert_true(endptr == str + 3); 313 } 314 315 static void test_qemu_strtoi_octal(void) 316 { 317 const char *str = "0123"; 318 char f = 'X'; 319 const char *endptr = &f; 320 int res = 999; 321 int err; 322 323 err = qemu_strtoi(str, &endptr, 8, &res); 324 325 g_assert_cmpint(err, ==, 0); 326 g_assert_cmpint(res, ==, 0123); 327 g_assert_true(endptr == str + strlen(str)); 328 329 res = 999; 330 endptr = &f; 331 err = qemu_strtoi(str, &endptr, 0, &res); 332 333 g_assert_cmpint(err, ==, 0); 334 g_assert_cmpint(res, ==, 0123); 335 g_assert_true(endptr == str + strlen(str)); 336 } 337 338 static void test_qemu_strtoi_decimal(void) 339 { 340 const char *str = "0123"; 341 char f = 'X'; 342 const char *endptr = &f; 343 int res = 999; 344 int err; 345 346 err = qemu_strtoi(str, &endptr, 10, &res); 347 348 g_assert_cmpint(err, ==, 0); 349 g_assert_cmpint(res, ==, 123); 350 g_assert_true(endptr == str + strlen(str)); 351 352 str = "123"; 353 res = 999; 354 endptr = &f; 355 err = qemu_strtoi(str, &endptr, 0, &res); 356 357 g_assert_cmpint(err, ==, 0); 358 g_assert_cmpint(res, ==, 123); 359 g_assert_true(endptr == str + strlen(str)); 360 } 361 362 static void test_qemu_strtoi_hex(void) 363 { 364 const char *str = "0123"; 365 char f = 'X'; 366 const char *endptr = &f; 367 int res = 999; 368 int err; 369 370 err = qemu_strtoi(str, &endptr, 16, &res); 371 372 g_assert_cmpint(err, ==, 0); 373 g_assert_cmpint(res, ==, 0x123); 374 g_assert_true(endptr == str + strlen(str)); 375 376 str = "0x123"; 377 res = 999; 378 endptr = &f; 379 err = qemu_strtoi(str, &endptr, 0, &res); 380 381 g_assert_cmpint(err, ==, 0); 382 g_assert_cmpint(res, ==, 0x123); 383 g_assert_true(endptr == str + strlen(str)); 384 385 str = "0x"; 386 res = 999; 387 endptr = &f; 388 err = qemu_strtoi(str, &endptr, 16, &res); 389 390 g_assert_cmpint(err, ==, 0); 391 g_assert_cmpint(res, ==, 0); 392 g_assert_true(endptr == str + 1); 393 } 394 395 static void test_qemu_strtoi_max(void) 396 { 397 char *str = g_strdup_printf("%d", INT_MAX); 398 char f = 'X'; 399 const char *endptr = &f; 400 int res = 999; 401 int err; 402 403 err = qemu_strtoi(str, &endptr, 0, &res); 404 405 g_assert_cmpint(err, ==, 0); 406 g_assert_cmpint(res, ==, INT_MAX); 407 g_assert_true(endptr == str + strlen(str)); 408 g_free(str); 409 } 410 411 static void test_qemu_strtoi_overflow(void) 412 { 413 char *str = g_strdup_printf("%lld", (long long)INT_MAX + 1ll); 414 char f = 'X'; 415 const char *endptr = &f; 416 int res = 999; 417 int err; 418 419 err = qemu_strtoi(str, &endptr, 0, &res); 420 421 g_assert_cmpint(err, ==, -ERANGE); 422 g_assert_cmpint(res, ==, INT_MAX); 423 g_assert_true(endptr == str + strlen(str)); 424 g_free(str); 425 } 426 427 static void test_qemu_strtoi_underflow(void) 428 { 429 char *str = g_strdup_printf("%lld", (long long)INT_MIN - 1ll); 430 char f = 'X'; 431 const char *endptr = &f; 432 int res = 999; 433 int err; 434 435 err = qemu_strtoi(str, &endptr, 0, &res); 436 437 g_assert_cmpint(err, ==, -ERANGE); 438 g_assert_cmpint(res, ==, INT_MIN); 439 g_assert_true(endptr == str + strlen(str)); 440 g_free(str); 441 } 442 443 static void test_qemu_strtoi_negative(void) 444 { 445 const char *str = " \t -321"; 446 char f = 'X'; 447 const char *endptr = &f; 448 int res = 999; 449 int err; 450 451 err = qemu_strtoi(str, &endptr, 0, &res); 452 453 g_assert_cmpint(err, ==, 0); 454 g_assert_cmpint(res, ==, -321); 455 g_assert_true(endptr == str + strlen(str)); 456 } 457 458 static void test_qemu_strtoi_full_correct(void) 459 { 460 const char *str = "123"; 461 int res = 999; 462 int err; 463 464 err = qemu_strtoi(str, NULL, 0, &res); 465 466 g_assert_cmpint(err, ==, 0); 467 g_assert_cmpint(res, ==, 123); 468 } 469 470 static void test_qemu_strtoi_full_null(void) 471 { 472 char f = 'X'; 473 const char *endptr = &f; 474 int res = 999; 475 int err; 476 477 err = qemu_strtoi(NULL, &endptr, 0, &res); 478 479 g_assert_cmpint(err, ==, -EINVAL); 480 g_assert_cmpint(res, ==, 999); 481 g_assert_null(endptr); 482 } 483 484 static void test_qemu_strtoi_full_empty(void) 485 { 486 const char *str = ""; 487 int res = 999; 488 int err; 489 490 err = qemu_strtoi(str, NULL, 0, &res); 491 492 g_assert_cmpint(err, ==, -EINVAL); 493 g_assert_cmpint(res, ==, 0); 494 } 495 496 static void test_qemu_strtoi_full_negative(void) 497 { 498 const char *str = " \t -321"; 499 int res = 999; 500 int err; 501 502 err = qemu_strtoi(str, NULL, 0, &res); 503 504 g_assert_cmpint(err, ==, 0); 505 g_assert_cmpint(res, ==, -321); 506 } 507 508 static void test_qemu_strtoi_full_trailing(void) 509 { 510 const char *str = "123xxx"; 511 int res = 999; 512 int err; 513 514 err = qemu_strtoi(str, NULL, 0, &res); 515 516 g_assert_cmpint(err, ==, -EINVAL); 517 g_assert_cmpint(res, ==, 123); 518 } 519 520 static void test_qemu_strtoi_full_max(void) 521 { 522 char *str = g_strdup_printf("%d", INT_MAX); 523 int res = 999; 524 int err; 525 526 err = qemu_strtoi(str, NULL, 0, &res); 527 528 g_assert_cmpint(err, ==, 0); 529 g_assert_cmpint(res, ==, INT_MAX); 530 g_free(str); 531 } 532 533 static void test_qemu_strtoui_correct(void) 534 { 535 const char *str = "12345 foo"; 536 char f = 'X'; 537 const char *endptr = &f; 538 unsigned int res = 999; 539 int err; 540 541 err = qemu_strtoui(str, &endptr, 0, &res); 542 543 g_assert_cmpint(err, ==, 0); 544 g_assert_cmpuint(res, ==, 12345); 545 g_assert_true(endptr == str + 5); 546 } 547 548 static void test_qemu_strtoui_null(void) 549 { 550 char f = 'X'; 551 const char *endptr = &f; 552 unsigned int res = 999; 553 int err; 554 555 err = qemu_strtoui(NULL, &endptr, 0, &res); 556 557 g_assert_cmpint(err, ==, -EINVAL); 558 g_assert_cmpuint(res, ==, 999); 559 g_assert_null(endptr); 560 } 561 562 static void test_qemu_strtoui_empty(void) 563 { 564 const char *str = ""; 565 char f = 'X'; 566 const char *endptr = &f; 567 unsigned int res = 999; 568 int err; 569 570 err = qemu_strtoui(str, &endptr, 0, &res); 571 572 g_assert_cmpint(err, ==, -EINVAL); 573 g_assert_cmpuint(res, ==, 0); 574 g_assert_true(endptr == str); 575 } 576 577 static void test_qemu_strtoui_whitespace(void) 578 { 579 const char *str = " \t "; 580 char f = 'X'; 581 const char *endptr = &f; 582 unsigned int res = 999; 583 int err; 584 585 err = qemu_strtoui(str, &endptr, 0, &res); 586 587 g_assert_cmpint(err, ==, -EINVAL); 588 g_assert_cmpuint(res, ==, 0); 589 g_assert_true(endptr == str); 590 } 591 592 static void test_qemu_strtoui_invalid(void) 593 { 594 const char *str = " xxxx \t abc"; 595 char f = 'X'; 596 const char *endptr = &f; 597 unsigned int res = 999; 598 int err; 599 600 err = qemu_strtoui(str, &endptr, 0, &res); 601 602 g_assert_cmpint(err, ==, -EINVAL); 603 g_assert_cmpuint(res, ==, 0); 604 g_assert_true(endptr == str); 605 } 606 607 static void test_qemu_strtoui_trailing(void) 608 { 609 const char *str = "123xxx"; 610 char f = 'X'; 611 const char *endptr = &f; 612 unsigned int res = 999; 613 int err; 614 615 err = qemu_strtoui(str, &endptr, 0, &res); 616 617 g_assert_cmpint(err, ==, 0); 618 g_assert_cmpuint(res, ==, 123); 619 g_assert_true(endptr == str + 3); 620 } 621 622 static void test_qemu_strtoui_octal(void) 623 { 624 const char *str = "0123"; 625 char f = 'X'; 626 const char *endptr = &f; 627 unsigned int res = 999; 628 int err; 629 630 err = qemu_strtoui(str, &endptr, 8, &res); 631 632 g_assert_cmpint(err, ==, 0); 633 g_assert_cmpuint(res, ==, 0123); 634 g_assert_true(endptr == str + strlen(str)); 635 636 res = 999; 637 endptr = &f; 638 err = qemu_strtoui(str, &endptr, 0, &res); 639 640 g_assert_cmpint(err, ==, 0); 641 g_assert_cmpuint(res, ==, 0123); 642 g_assert_true(endptr == str + strlen(str)); 643 } 644 645 static void test_qemu_strtoui_decimal(void) 646 { 647 const char *str = "0123"; 648 char f = 'X'; 649 const char *endptr = &f; 650 unsigned int res = 999; 651 int err; 652 653 err = qemu_strtoui(str, &endptr, 10, &res); 654 655 g_assert_cmpint(err, ==, 0); 656 g_assert_cmpuint(res, ==, 123); 657 g_assert_true(endptr == str + strlen(str)); 658 659 str = "123"; 660 res = 999; 661 endptr = &f; 662 err = qemu_strtoui(str, &endptr, 0, &res); 663 664 g_assert_cmpint(err, ==, 0); 665 g_assert_cmpuint(res, ==, 123); 666 g_assert_true(endptr == str + strlen(str)); 667 } 668 669 static void test_qemu_strtoui_hex(void) 670 { 671 const char *str = "0123"; 672 char f = 'X'; 673 const char *endptr = &f; 674 unsigned int res = 999; 675 int err; 676 677 err = qemu_strtoui(str, &endptr, 16, &res); 678 679 g_assert_cmpint(err, ==, 0); 680 g_assert_cmphex(res, ==, 0x123); 681 g_assert_true(endptr == str + strlen(str)); 682 683 str = "0x123"; 684 res = 999; 685 endptr = &f; 686 err = qemu_strtoui(str, &endptr, 0, &res); 687 688 g_assert_cmpint(err, ==, 0); 689 g_assert_cmphex(res, ==, 0x123); 690 g_assert_true(endptr == str + strlen(str)); 691 692 str = "0x"; 693 res = 999; 694 endptr = &f; 695 err = qemu_strtoui(str, &endptr, 16, &res); 696 697 g_assert_cmpint(err, ==, 0); 698 g_assert_cmphex(res, ==, 0); 699 g_assert_true(endptr == str + 1); 700 } 701 702 static void test_qemu_strtoui_max(void) 703 { 704 char *str = g_strdup_printf("%u", UINT_MAX); 705 char f = 'X'; 706 const char *endptr = &f; 707 unsigned int res = 999; 708 int err; 709 710 err = qemu_strtoui(str, &endptr, 0, &res); 711 712 g_assert_cmpint(err, ==, 0); 713 g_assert_cmphex(res, ==, UINT_MAX); 714 g_assert_true(endptr == str + strlen(str)); 715 g_free(str); 716 } 717 718 static void test_qemu_strtoui_overflow(void) 719 { 720 char *str = g_strdup_printf("%lld", (long long)UINT_MAX + 1ll); 721 char f = 'X'; 722 const char *endptr = &f; 723 unsigned int res = 999; 724 int err; 725 726 err = qemu_strtoui(str, &endptr, 0, &res); 727 728 g_assert_cmpint(err, ==, -ERANGE); 729 g_assert_cmphex(res, ==, UINT_MAX); 730 g_assert_true(endptr == str + strlen(str)); 731 g_free(str); 732 } 733 734 static void test_qemu_strtoui_underflow(void) 735 { 736 char *str = g_strdup_printf("%lld", (long long)INT_MIN - 1ll); 737 char f = 'X'; 738 const char *endptr = &f; 739 unsigned int res = 999; 740 int err; 741 742 err = qemu_strtoui(str, &endptr, 0, &res); 743 744 g_assert_cmpint(err, ==, -ERANGE); 745 g_assert_cmpuint(res, ==, (unsigned int)-1); 746 g_assert_true(endptr == str + strlen(str)); 747 g_free(str); 748 } 749 750 static void test_qemu_strtoui_negative(void) 751 { 752 const char *str = " \t -321"; 753 char f = 'X'; 754 const char *endptr = &f; 755 unsigned int res = 999; 756 int err; 757 758 err = qemu_strtoui(str, &endptr, 0, &res); 759 760 g_assert_cmpint(err, ==, 0); 761 g_assert_cmpuint(res, ==, (unsigned int)-321); 762 g_assert_true(endptr == str + strlen(str)); 763 } 764 765 static void test_qemu_strtoui_full_correct(void) 766 { 767 const char *str = "123"; 768 unsigned int res = 999; 769 int err; 770 771 err = qemu_strtoui(str, NULL, 0, &res); 772 773 g_assert_cmpint(err, ==, 0); 774 g_assert_cmpuint(res, ==, 123); 775 } 776 777 static void test_qemu_strtoui_full_null(void) 778 { 779 unsigned int res = 999; 780 int err; 781 782 err = qemu_strtoui(NULL, NULL, 0, &res); 783 784 g_assert_cmpint(err, ==, -EINVAL); 785 g_assert_cmpuint(res, ==, 999); 786 } 787 788 static void test_qemu_strtoui_full_empty(void) 789 { 790 const char *str = ""; 791 unsigned int res = 999; 792 int err; 793 794 err = qemu_strtoui(str, NULL, 0, &res); 795 796 g_assert_cmpint(err, ==, -EINVAL); 797 g_assert_cmpuint(res, ==, 0); 798 } 799 800 static void test_qemu_strtoui_full_negative(void) 801 { 802 const char *str = " \t -321"; 803 unsigned int res = 999; 804 int err; 805 806 err = qemu_strtoui(str, NULL, 0, &res); 807 g_assert_cmpint(err, ==, 0); 808 g_assert_cmpuint(res, ==, (unsigned int)-321); 809 } 810 811 static void test_qemu_strtoui_full_trailing(void) 812 { 813 const char *str = "123xxx"; 814 unsigned int res = 999; 815 int err; 816 817 err = qemu_strtoui(str, NULL, 0, &res); 818 819 g_assert_cmpint(err, ==, -EINVAL); 820 g_assert_cmpuint(res, ==, 123); 821 } 822 823 static void test_qemu_strtoui_full_max(void) 824 { 825 char *str = g_strdup_printf("%u", UINT_MAX); 826 unsigned int res = 999; 827 int err; 828 829 err = qemu_strtoui(str, NULL, 0, &res); 830 831 g_assert_cmpint(err, ==, 0); 832 g_assert_cmphex(res, ==, UINT_MAX); 833 g_free(str); 834 } 835 836 static void test_qemu_strtol_correct(void) 837 { 838 const char *str = "12345 foo"; 839 char f = 'X'; 840 const char *endptr = &f; 841 long res = 999; 842 int err; 843 844 err = qemu_strtol(str, &endptr, 0, &res); 845 846 g_assert_cmpint(err, ==, 0); 847 g_assert_cmpint(res, ==, 12345); 848 g_assert_true(endptr == str + 5); 849 } 850 851 static void test_qemu_strtol_null(void) 852 { 853 char f = 'X'; 854 const char *endptr = &f; 855 long res = 999; 856 int err; 857 858 err = qemu_strtol(NULL, &endptr, 0, &res); 859 860 g_assert_cmpint(err, ==, -EINVAL); 861 g_assert_cmpint(res, ==, 999); 862 g_assert_null(endptr); 863 } 864 865 static void test_qemu_strtol_empty(void) 866 { 867 const char *str = ""; 868 char f = 'X'; 869 const char *endptr = &f; 870 long res = 999; 871 int err; 872 873 err = qemu_strtol(str, &endptr, 0, &res); 874 875 g_assert_cmpint(err, ==, -EINVAL); 876 g_assert_cmpint(res, ==, 0); 877 g_assert_true(endptr == str); 878 } 879 880 static void test_qemu_strtol_whitespace(void) 881 { 882 const char *str = " \t "; 883 char f = 'X'; 884 const char *endptr = &f; 885 long res = 999; 886 int err; 887 888 err = qemu_strtol(str, &endptr, 0, &res); 889 890 g_assert_cmpint(err, ==, -EINVAL); 891 g_assert_cmpint(res, ==, 0); 892 g_assert_true(endptr == str); 893 } 894 895 static void test_qemu_strtol_invalid(void) 896 { 897 const char *str = " xxxx \t abc"; 898 char f = 'X'; 899 const char *endptr = &f; 900 long res = 999; 901 int err; 902 903 err = qemu_strtol(str, &endptr, 0, &res); 904 905 g_assert_cmpint(err, ==, -EINVAL); 906 g_assert_cmpint(res, ==, 0); 907 g_assert_true(endptr == str); 908 } 909 910 static void test_qemu_strtol_trailing(void) 911 { 912 const char *str = "123xxx"; 913 char f = 'X'; 914 const char *endptr = &f; 915 long res = 999; 916 int err; 917 918 err = qemu_strtol(str, &endptr, 0, &res); 919 920 g_assert_cmpint(err, ==, 0); 921 g_assert_cmpint(res, ==, 123); 922 g_assert_true(endptr == str + 3); 923 } 924 925 static void test_qemu_strtol_octal(void) 926 { 927 const char *str = "0123"; 928 char f = 'X'; 929 const char *endptr = &f; 930 long res = 999; 931 int err; 932 933 err = qemu_strtol(str, &endptr, 8, &res); 934 935 g_assert_cmpint(err, ==, 0); 936 g_assert_cmpint(res, ==, 0123); 937 g_assert_true(endptr == str + strlen(str)); 938 939 res = 999; 940 endptr = &f; 941 err = qemu_strtol(str, &endptr, 0, &res); 942 943 g_assert_cmpint(err, ==, 0); 944 g_assert_cmpint(res, ==, 0123); 945 g_assert_true(endptr == str + strlen(str)); 946 } 947 948 static void test_qemu_strtol_decimal(void) 949 { 950 const char *str = "0123"; 951 char f = 'X'; 952 const char *endptr = &f; 953 long res = 999; 954 int err; 955 956 err = qemu_strtol(str, &endptr, 10, &res); 957 958 g_assert_cmpint(err, ==, 0); 959 g_assert_cmpint(res, ==, 123); 960 g_assert_true(endptr == str + strlen(str)); 961 962 str = "123"; 963 res = 999; 964 endptr = &f; 965 err = qemu_strtol(str, &endptr, 0, &res); 966 967 g_assert_cmpint(err, ==, 0); 968 g_assert_cmpint(res, ==, 123); 969 g_assert_true(endptr == str + strlen(str)); 970 } 971 972 static void test_qemu_strtol_hex(void) 973 { 974 const char *str = "0123"; 975 char f = 'X'; 976 const char *endptr = &f; 977 long res = 999; 978 int err; 979 980 err = qemu_strtol(str, &endptr, 16, &res); 981 982 g_assert_cmpint(err, ==, 0); 983 g_assert_cmpint(res, ==, 0x123); 984 g_assert_true(endptr == str + strlen(str)); 985 986 str = "0x123"; 987 res = 999; 988 endptr = &f; 989 err = qemu_strtol(str, &endptr, 0, &res); 990 991 g_assert_cmpint(err, ==, 0); 992 g_assert_cmpint(res, ==, 0x123); 993 g_assert_true(endptr == str + strlen(str)); 994 995 str = "0x"; 996 res = 999; 997 endptr = &f; 998 err = qemu_strtol(str, &endptr, 16, &res); 999 1000 g_assert_cmpint(err, ==, 0); 1001 g_assert_cmpint(res, ==, 0); 1002 g_assert_true(endptr == str + 1); 1003 } 1004 1005 static void test_qemu_strtol_max(void) 1006 { 1007 char *str = g_strdup_printf("%ld", LONG_MAX); 1008 char f = 'X'; 1009 const char *endptr = &f; 1010 long res = 999; 1011 int err; 1012 1013 err = qemu_strtol(str, &endptr, 0, &res); 1014 1015 g_assert_cmpint(err, ==, 0); 1016 g_assert_cmpint(res, ==, LONG_MAX); 1017 g_assert_true(endptr == str + strlen(str)); 1018 g_free(str); 1019 } 1020 1021 static void test_qemu_strtol_overflow(void) 1022 { 1023 const char *str = "99999999999999999999999999999999999999999999"; 1024 char f = 'X'; 1025 const char *endptr = &f; 1026 long res = 999; 1027 int err; 1028 1029 err = qemu_strtol(str, &endptr, 0, &res); 1030 1031 g_assert_cmpint(err, ==, -ERANGE); 1032 g_assert_cmpint(res, ==, LONG_MAX); 1033 g_assert_true(endptr == str + strlen(str)); 1034 } 1035 1036 static void test_qemu_strtol_underflow(void) 1037 { 1038 const char *str = "-99999999999999999999999999999999999999999999"; 1039 char f = 'X'; 1040 const char *endptr = &f; 1041 long res = 999; 1042 int err; 1043 1044 err = qemu_strtol(str, &endptr, 0, &res); 1045 1046 g_assert_cmpint(err, ==, -ERANGE); 1047 g_assert_cmpint(res, ==, LONG_MIN); 1048 g_assert_true(endptr == str + strlen(str)); 1049 } 1050 1051 static void test_qemu_strtol_negative(void) 1052 { 1053 const char *str = " \t -321"; 1054 char f = 'X'; 1055 const char *endptr = &f; 1056 long res = 999; 1057 int err; 1058 1059 err = qemu_strtol(str, &endptr, 0, &res); 1060 1061 g_assert_cmpint(err, ==, 0); 1062 g_assert_cmpint(res, ==, -321); 1063 g_assert_true(endptr == str + strlen(str)); 1064 } 1065 1066 static void test_qemu_strtol_full_correct(void) 1067 { 1068 const char *str = "123"; 1069 long res = 999; 1070 int err; 1071 1072 err = qemu_strtol(str, NULL, 0, &res); 1073 1074 g_assert_cmpint(err, ==, 0); 1075 g_assert_cmpint(res, ==, 123); 1076 } 1077 1078 static void test_qemu_strtol_full_null(void) 1079 { 1080 char f = 'X'; 1081 const char *endptr = &f; 1082 long res = 999; 1083 int err; 1084 1085 err = qemu_strtol(NULL, &endptr, 0, &res); 1086 1087 g_assert_cmpint(err, ==, -EINVAL); 1088 g_assert_cmpint(res, ==, 999); 1089 g_assert_null(endptr); 1090 } 1091 1092 static void test_qemu_strtol_full_empty(void) 1093 { 1094 const char *str = ""; 1095 long res = 999L; 1096 int err; 1097 1098 err = qemu_strtol(str, NULL, 0, &res); 1099 1100 g_assert_cmpint(err, ==, -EINVAL); 1101 g_assert_cmpint(res, ==, 0); 1102 } 1103 1104 static void test_qemu_strtol_full_negative(void) 1105 { 1106 const char *str = " \t -321"; 1107 long res = 999; 1108 int err; 1109 1110 err = qemu_strtol(str, NULL, 0, &res); 1111 1112 g_assert_cmpint(err, ==, 0); 1113 g_assert_cmpint(res, ==, -321); 1114 } 1115 1116 static void test_qemu_strtol_full_trailing(void) 1117 { 1118 const char *str = "123xxx"; 1119 long res = 999; 1120 int err; 1121 1122 err = qemu_strtol(str, NULL, 0, &res); 1123 1124 g_assert_cmpint(err, ==, -EINVAL); 1125 g_assert_cmpint(res, ==, 123); 1126 } 1127 1128 static void test_qemu_strtol_full_max(void) 1129 { 1130 char *str = g_strdup_printf("%ld", LONG_MAX); 1131 long res = 999; 1132 int err; 1133 1134 err = qemu_strtol(str, NULL, 0, &res); 1135 1136 g_assert_cmpint(err, ==, 0); 1137 g_assert_cmpint(res, ==, LONG_MAX); 1138 g_free(str); 1139 } 1140 1141 static void test_qemu_strtoul_correct(void) 1142 { 1143 const char *str = "12345 foo"; 1144 char f = 'X'; 1145 const char *endptr = &f; 1146 unsigned long res = 999; 1147 int err; 1148 1149 err = qemu_strtoul(str, &endptr, 0, &res); 1150 1151 g_assert_cmpint(err, ==, 0); 1152 g_assert_cmpuint(res, ==, 12345); 1153 g_assert_true(endptr == str + 5); 1154 } 1155 1156 static void test_qemu_strtoul_null(void) 1157 { 1158 char f = 'X'; 1159 const char *endptr = &f; 1160 unsigned long res = 999; 1161 int err; 1162 1163 err = qemu_strtoul(NULL, &endptr, 0, &res); 1164 1165 g_assert_cmpint(err, ==, -EINVAL); 1166 g_assert_cmpuint(res, ==, 999); 1167 g_assert_null(endptr); 1168 } 1169 1170 static void test_qemu_strtoul_empty(void) 1171 { 1172 const char *str = ""; 1173 char f = 'X'; 1174 const char *endptr = &f; 1175 unsigned long res = 999; 1176 int err; 1177 1178 err = qemu_strtoul(str, &endptr, 0, &res); 1179 1180 g_assert_cmpint(err, ==, -EINVAL); 1181 g_assert_cmpuint(res, ==, 0); 1182 g_assert_true(endptr == str); 1183 } 1184 1185 static void test_qemu_strtoul_whitespace(void) 1186 { 1187 const char *str = " \t "; 1188 char f = 'X'; 1189 const char *endptr = &f; 1190 unsigned long res = 999; 1191 int err; 1192 1193 err = qemu_strtoul(str, &endptr, 0, &res); 1194 1195 g_assert_cmpint(err, ==, -EINVAL); 1196 g_assert_cmpuint(res, ==, 0); 1197 g_assert_true(endptr == str); 1198 } 1199 1200 static void test_qemu_strtoul_invalid(void) 1201 { 1202 const char *str = " xxxx \t abc"; 1203 char f = 'X'; 1204 const char *endptr = &f; 1205 unsigned long res = 999; 1206 int err; 1207 1208 err = qemu_strtoul(str, &endptr, 0, &res); 1209 1210 g_assert_cmpint(err, ==, -EINVAL); 1211 g_assert_cmpuint(res, ==, 0); 1212 g_assert_true(endptr == str); 1213 } 1214 1215 static void test_qemu_strtoul_trailing(void) 1216 { 1217 const char *str = "123xxx"; 1218 char f = 'X'; 1219 const char *endptr = &f; 1220 unsigned long res = 999; 1221 int err; 1222 1223 err = qemu_strtoul(str, &endptr, 0, &res); 1224 1225 g_assert_cmpint(err, ==, 0); 1226 g_assert_cmpuint(res, ==, 123); 1227 g_assert_true(endptr == str + 3); 1228 } 1229 1230 static void test_qemu_strtoul_octal(void) 1231 { 1232 const char *str = "0123"; 1233 char f = 'X'; 1234 const char *endptr = &f; 1235 unsigned long res = 999; 1236 int err; 1237 1238 err = qemu_strtoul(str, &endptr, 8, &res); 1239 1240 g_assert_cmpint(err, ==, 0); 1241 g_assert_cmpuint(res, ==, 0123); 1242 g_assert_true(endptr == str + strlen(str)); 1243 1244 res = 999; 1245 endptr = &f; 1246 err = qemu_strtoul(str, &endptr, 0, &res); 1247 1248 g_assert_cmpint(err, ==, 0); 1249 g_assert_cmpuint(res, ==, 0123); 1250 g_assert_true(endptr == str + strlen(str)); 1251 } 1252 1253 static void test_qemu_strtoul_decimal(void) 1254 { 1255 const char *str = "0123"; 1256 char f = 'X'; 1257 const char *endptr = &f; 1258 unsigned long res = 999; 1259 int err; 1260 1261 err = qemu_strtoul(str, &endptr, 10, &res); 1262 1263 g_assert_cmpint(err, ==, 0); 1264 g_assert_cmpuint(res, ==, 123); 1265 g_assert_true(endptr == str + strlen(str)); 1266 1267 str = "123"; 1268 res = 999; 1269 endptr = &f; 1270 err = qemu_strtoul(str, &endptr, 0, &res); 1271 1272 g_assert_cmpint(err, ==, 0); 1273 g_assert_cmpuint(res, ==, 123); 1274 g_assert_true(endptr == str + strlen(str)); 1275 } 1276 1277 static void test_qemu_strtoul_hex(void) 1278 { 1279 const char *str = "0123"; 1280 char f = 'X'; 1281 const char *endptr = &f; 1282 unsigned long res = 999; 1283 int err; 1284 1285 err = qemu_strtoul(str, &endptr, 16, &res); 1286 1287 g_assert_cmpint(err, ==, 0); 1288 g_assert_cmphex(res, ==, 0x123); 1289 g_assert_true(endptr == str + strlen(str)); 1290 1291 str = "0x123"; 1292 res = 999; 1293 endptr = &f; 1294 err = qemu_strtoul(str, &endptr, 0, &res); 1295 1296 g_assert_cmpint(err, ==, 0); 1297 g_assert_cmphex(res, ==, 0x123); 1298 g_assert_true(endptr == str + strlen(str)); 1299 1300 str = "0x"; 1301 res = 999; 1302 endptr = &f; 1303 err = qemu_strtoul(str, &endptr, 16, &res); 1304 1305 g_assert_cmpint(err, ==, 0); 1306 g_assert_cmphex(res, ==, 0); 1307 g_assert_true(endptr == str + 1); 1308 } 1309 1310 static void test_qemu_strtoul_max(void) 1311 { 1312 char *str = g_strdup_printf("%lu", ULONG_MAX); 1313 char f = 'X'; 1314 const char *endptr = &f; 1315 unsigned long res = 999; 1316 int err; 1317 1318 err = qemu_strtoul(str, &endptr, 0, &res); 1319 1320 g_assert_cmpint(err, ==, 0); 1321 g_assert_cmphex(res, ==, ULONG_MAX); 1322 g_assert_true(endptr == str + strlen(str)); 1323 g_free(str); 1324 } 1325 1326 static void test_qemu_strtoul_overflow(void) 1327 { 1328 const char *str = "99999999999999999999999999999999999999999999"; 1329 char f = 'X'; 1330 const char *endptr = &f; 1331 unsigned long res = 999; 1332 int err; 1333 1334 err = qemu_strtoul(str, &endptr, 0, &res); 1335 1336 g_assert_cmpint(err, ==, -ERANGE); 1337 g_assert_cmphex(res, ==, ULONG_MAX); 1338 g_assert_true(endptr == str + strlen(str)); 1339 } 1340 1341 static void test_qemu_strtoul_underflow(void) 1342 { 1343 const char *str = "-99999999999999999999999999999999999999999999"; 1344 char f = 'X'; 1345 const char *endptr = &f; 1346 unsigned long res = 999; 1347 int err; 1348 1349 err = qemu_strtoul(str, &endptr, 0, &res); 1350 1351 g_assert_cmpint(err, ==, -ERANGE); 1352 g_assert_cmpuint(res, ==, -1ul); 1353 g_assert_true(endptr == str + strlen(str)); 1354 } 1355 1356 static void test_qemu_strtoul_negative(void) 1357 { 1358 const char *str = " \t -321"; 1359 char f = 'X'; 1360 const char *endptr = &f; 1361 unsigned long res = 999; 1362 int err; 1363 1364 err = qemu_strtoul(str, &endptr, 0, &res); 1365 1366 g_assert_cmpint(err, ==, 0); 1367 g_assert_cmpuint(res, ==, -321ul); 1368 g_assert_true(endptr == str + strlen(str)); 1369 } 1370 1371 static void test_qemu_strtoul_full_correct(void) 1372 { 1373 const char *str = "123"; 1374 unsigned long res = 999; 1375 int err; 1376 1377 err = qemu_strtoul(str, NULL, 0, &res); 1378 1379 g_assert_cmpint(err, ==, 0); 1380 g_assert_cmpuint(res, ==, 123); 1381 } 1382 1383 static void test_qemu_strtoul_full_null(void) 1384 { 1385 unsigned long res = 999; 1386 int err; 1387 1388 err = qemu_strtoul(NULL, NULL, 0, &res); 1389 1390 g_assert_cmpint(err, ==, -EINVAL); 1391 g_assert_cmpuint(res, ==, 999); 1392 } 1393 1394 static void test_qemu_strtoul_full_empty(void) 1395 { 1396 const char *str = ""; 1397 unsigned long res = 999; 1398 int err; 1399 1400 err = qemu_strtoul(str, NULL, 0, &res); 1401 1402 g_assert_cmpint(err, ==, -EINVAL); 1403 g_assert_cmpuint(res, ==, 0); 1404 } 1405 1406 static void test_qemu_strtoul_full_negative(void) 1407 { 1408 const char *str = " \t -321"; 1409 unsigned long res = 999; 1410 int err; 1411 1412 err = qemu_strtoul(str, NULL, 0, &res); 1413 g_assert_cmpint(err, ==, 0); 1414 g_assert_cmpuint(res, ==, -321ul); 1415 } 1416 1417 static void test_qemu_strtoul_full_trailing(void) 1418 { 1419 const char *str = "123xxx"; 1420 unsigned long res = 999; 1421 int err; 1422 1423 err = qemu_strtoul(str, NULL, 0, &res); 1424 1425 g_assert_cmpint(err, ==, -EINVAL); 1426 g_assert_cmpuint(res, ==, 123); 1427 } 1428 1429 static void test_qemu_strtoul_full_max(void) 1430 { 1431 char *str = g_strdup_printf("%lu", ULONG_MAX); 1432 unsigned long res = 999; 1433 int err; 1434 1435 err = qemu_strtoul(str, NULL, 0, &res); 1436 1437 g_assert_cmpint(err, ==, 0); 1438 g_assert_cmphex(res, ==, ULONG_MAX); 1439 g_free(str); 1440 } 1441 1442 static void test_qemu_strtoi64_correct(void) 1443 { 1444 const char *str = "12345 foo"; 1445 char f = 'X'; 1446 const char *endptr = &f; 1447 int64_t res = 999; 1448 int err; 1449 1450 err = qemu_strtoi64(str, &endptr, 0, &res); 1451 1452 g_assert_cmpint(err, ==, 0); 1453 g_assert_cmpint(res, ==, 12345); 1454 g_assert_true(endptr == str + 5); 1455 } 1456 1457 static void test_qemu_strtoi64_null(void) 1458 { 1459 char f = 'X'; 1460 const char *endptr = &f; 1461 int64_t res = 999; 1462 int err; 1463 1464 err = qemu_strtoi64(NULL, &endptr, 0, &res); 1465 1466 g_assert_cmpint(err, ==, -EINVAL); 1467 g_assert_cmpint(res, ==, 999); 1468 g_assert_null(endptr); 1469 } 1470 1471 static void test_qemu_strtoi64_empty(void) 1472 { 1473 const char *str = ""; 1474 char f = 'X'; 1475 const char *endptr = &f; 1476 int64_t res = 999; 1477 int err; 1478 1479 err = qemu_strtoi64(str, &endptr, 0, &res); 1480 1481 g_assert_cmpint(err, ==, -EINVAL); 1482 g_assert_cmpint(res, ==, 0); 1483 g_assert_true(endptr == str); 1484 } 1485 1486 static void test_qemu_strtoi64_whitespace(void) 1487 { 1488 const char *str = " \t "; 1489 char f = 'X'; 1490 const char *endptr = &f; 1491 int64_t res = 999; 1492 int err; 1493 1494 err = qemu_strtoi64(str, &endptr, 0, &res); 1495 1496 g_assert_cmpint(err, ==, -EINVAL); 1497 g_assert_cmpint(res, ==, 0); 1498 g_assert_true(endptr == str); 1499 } 1500 1501 static void test_qemu_strtoi64_invalid(void) 1502 { 1503 const char *str = " xxxx \t abc"; 1504 char f = 'X'; 1505 const char *endptr = &f; 1506 int64_t res = 999; 1507 int err; 1508 1509 err = qemu_strtoi64(str, &endptr, 0, &res); 1510 1511 g_assert_cmpint(err, ==, -EINVAL); 1512 g_assert_cmpint(res, ==, 0); 1513 g_assert_true(endptr == str); 1514 } 1515 1516 static void test_qemu_strtoi64_trailing(void) 1517 { 1518 const char *str = "123xxx"; 1519 char f = 'X'; 1520 const char *endptr = &f; 1521 int64_t res = 999; 1522 int err; 1523 1524 err = qemu_strtoi64(str, &endptr, 0, &res); 1525 1526 g_assert_cmpint(err, ==, 0); 1527 g_assert_cmpint(res, ==, 123); 1528 g_assert_true(endptr == str + 3); 1529 } 1530 1531 static void test_qemu_strtoi64_octal(void) 1532 { 1533 const char *str = "0123"; 1534 char f = 'X'; 1535 const char *endptr = &f; 1536 int64_t res = 999; 1537 int err; 1538 1539 err = qemu_strtoi64(str, &endptr, 8, &res); 1540 1541 g_assert_cmpint(err, ==, 0); 1542 g_assert_cmpint(res, ==, 0123); 1543 g_assert_true(endptr == str + strlen(str)); 1544 1545 endptr = &f; 1546 res = 999; 1547 err = qemu_strtoi64(str, &endptr, 0, &res); 1548 1549 g_assert_cmpint(err, ==, 0); 1550 g_assert_cmpint(res, ==, 0123); 1551 g_assert_true(endptr == str + strlen(str)); 1552 } 1553 1554 static void test_qemu_strtoi64_decimal(void) 1555 { 1556 const char *str = "0123"; 1557 char f = 'X'; 1558 const char *endptr = &f; 1559 int64_t res = 999; 1560 int err; 1561 1562 err = qemu_strtoi64(str, &endptr, 10, &res); 1563 1564 g_assert_cmpint(err, ==, 0); 1565 g_assert_cmpint(res, ==, 123); 1566 g_assert_true(endptr == str + strlen(str)); 1567 1568 str = "123"; 1569 endptr = &f; 1570 res = 999; 1571 err = qemu_strtoi64(str, &endptr, 0, &res); 1572 1573 g_assert_cmpint(err, ==, 0); 1574 g_assert_cmpint(res, ==, 123); 1575 g_assert_true(endptr == str + strlen(str)); 1576 } 1577 1578 static void test_qemu_strtoi64_hex(void) 1579 { 1580 const char *str = "0123"; 1581 char f = 'X'; 1582 const char *endptr = &f; 1583 int64_t res = 999; 1584 int err; 1585 1586 err = qemu_strtoi64(str, &endptr, 16, &res); 1587 1588 g_assert_cmpint(err, ==, 0); 1589 g_assert_cmpint(res, ==, 0x123); 1590 g_assert_true(endptr == str + strlen(str)); 1591 1592 str = "0x123"; 1593 endptr = &f; 1594 res = 999; 1595 err = qemu_strtoi64(str, &endptr, 0, &res); 1596 1597 g_assert_cmpint(err, ==, 0); 1598 g_assert_cmpint(res, ==, 0x123); 1599 g_assert_true(endptr == str + strlen(str)); 1600 1601 str = "0x"; 1602 endptr = &f; 1603 res = 999; 1604 err = qemu_strtoi64(str, &endptr, 16, &res); 1605 1606 g_assert_cmpint(err, ==, 0); 1607 g_assert_cmpint(res, ==, 0); 1608 g_assert_true(endptr == str + 1); 1609 } 1610 1611 static void test_qemu_strtoi64_max(void) 1612 { 1613 char *str = g_strdup_printf("%lld", LLONG_MAX); 1614 char f = 'X'; 1615 const char *endptr = &f; 1616 int64_t res = 999; 1617 int err; 1618 1619 err = qemu_strtoi64(str, &endptr, 0, &res); 1620 1621 g_assert_cmpint(err, ==, 0); 1622 g_assert_cmpint(res, ==, LLONG_MAX); 1623 g_assert_true(endptr == str + strlen(str)); 1624 g_free(str); 1625 } 1626 1627 static void test_qemu_strtoi64_overflow(void) 1628 { 1629 const char *str = "99999999999999999999999999999999999999999999"; 1630 char f = 'X'; 1631 const char *endptr = &f; 1632 int64_t res = 999; 1633 int err; 1634 1635 err = qemu_strtoi64(str, &endptr, 0, &res); 1636 1637 g_assert_cmpint(err, ==, -ERANGE); 1638 g_assert_cmpint(res, ==, LLONG_MAX); 1639 g_assert_true(endptr == str + strlen(str)); 1640 } 1641 1642 static void test_qemu_strtoi64_underflow(void) 1643 { 1644 const char *str = "-99999999999999999999999999999999999999999999"; 1645 char f = 'X'; 1646 const char *endptr = &f; 1647 int64_t res = 999; 1648 int err; 1649 1650 err = qemu_strtoi64(str, &endptr, 0, &res); 1651 1652 g_assert_cmpint(err, ==, -ERANGE); 1653 g_assert_cmpint(res, ==, LLONG_MIN); 1654 g_assert_true(endptr == str + strlen(str)); 1655 } 1656 1657 static void test_qemu_strtoi64_negative(void) 1658 { 1659 const char *str = " \t -321"; 1660 char f = 'X'; 1661 const char *endptr = &f; 1662 int64_t res = 999; 1663 int err; 1664 1665 err = qemu_strtoi64(str, &endptr, 0, &res); 1666 1667 g_assert_cmpint(err, ==, 0); 1668 g_assert_cmpint(res, ==, -321); 1669 g_assert_true(endptr == str + strlen(str)); 1670 } 1671 1672 static void test_qemu_strtoi64_full_correct(void) 1673 { 1674 const char *str = "123"; 1675 int64_t res = 999; 1676 int err; 1677 1678 err = qemu_strtoi64(str, NULL, 0, &res); 1679 1680 g_assert_cmpint(err, ==, 0); 1681 g_assert_cmpint(res, ==, 123); 1682 } 1683 1684 static void test_qemu_strtoi64_full_null(void) 1685 { 1686 int64_t res = 999; 1687 int err; 1688 1689 err = qemu_strtoi64(NULL, NULL, 0, &res); 1690 1691 g_assert_cmpint(err, ==, -EINVAL); 1692 g_assert_cmpint(res, ==, 999); 1693 } 1694 1695 static void test_qemu_strtoi64_full_empty(void) 1696 { 1697 const char *str = ""; 1698 int64_t res = 999; 1699 int err; 1700 1701 err = qemu_strtoi64(str, NULL, 0, &res); 1702 1703 g_assert_cmpint(err, ==, -EINVAL); 1704 g_assert_cmpint(res, ==, 0); 1705 } 1706 1707 static void test_qemu_strtoi64_full_negative(void) 1708 { 1709 const char *str = " \t -321"; 1710 int64_t res = 999; 1711 int err; 1712 1713 err = qemu_strtoi64(str, NULL, 0, &res); 1714 1715 g_assert_cmpint(err, ==, 0); 1716 g_assert_cmpint(res, ==, -321); 1717 } 1718 1719 static void test_qemu_strtoi64_full_trailing(void) 1720 { 1721 const char *str = "123xxx"; 1722 int64_t res = 999; 1723 int err; 1724 1725 err = qemu_strtoi64(str, NULL, 0, &res); 1726 1727 g_assert_cmpint(err, ==, -EINVAL); 1728 g_assert_cmpint(res, ==, 123); 1729 } 1730 1731 static void test_qemu_strtoi64_full_max(void) 1732 { 1733 1734 char *str = g_strdup_printf("%lld", LLONG_MAX); 1735 int64_t res = 999; 1736 int err; 1737 1738 err = qemu_strtoi64(str, NULL, 0, &res); 1739 1740 g_assert_cmpint(err, ==, 0); 1741 g_assert_cmpint(res, ==, LLONG_MAX); 1742 g_free(str); 1743 } 1744 1745 static void test_qemu_strtou64_correct(void) 1746 { 1747 const char *str = "12345 foo"; 1748 char f = 'X'; 1749 const char *endptr = &f; 1750 uint64_t res = 999; 1751 int err; 1752 1753 err = qemu_strtou64(str, &endptr, 0, &res); 1754 1755 g_assert_cmpint(err, ==, 0); 1756 g_assert_cmpuint(res, ==, 12345); 1757 g_assert_true(endptr == str + 5); 1758 } 1759 1760 static void test_qemu_strtou64_null(void) 1761 { 1762 char f = 'X'; 1763 const char *endptr = &f; 1764 uint64_t res = 999; 1765 int err; 1766 1767 err = qemu_strtou64(NULL, &endptr, 0, &res); 1768 1769 g_assert_cmpint(err, ==, -EINVAL); 1770 g_assert_cmpuint(res, ==, 999); 1771 g_assert_null(endptr); 1772 } 1773 1774 static void test_qemu_strtou64_empty(void) 1775 { 1776 const char *str = ""; 1777 char f = 'X'; 1778 const char *endptr = &f; 1779 uint64_t res = 999; 1780 int err; 1781 1782 err = qemu_strtou64(str, &endptr, 0, &res); 1783 1784 g_assert_cmpint(err, ==, -EINVAL); 1785 g_assert_cmpuint(res, ==, 0); 1786 g_assert_true(endptr == str); 1787 } 1788 1789 static void test_qemu_strtou64_whitespace(void) 1790 { 1791 const char *str = " \t "; 1792 char f = 'X'; 1793 const char *endptr = &f; 1794 uint64_t res = 999; 1795 int err; 1796 1797 err = qemu_strtou64(str, &endptr, 0, &res); 1798 1799 g_assert_cmpint(err, ==, -EINVAL); 1800 g_assert_cmpuint(res, ==, 0); 1801 g_assert_true(endptr == str); 1802 } 1803 1804 static void test_qemu_strtou64_invalid(void) 1805 { 1806 const char *str = " xxxx \t abc"; 1807 char f = 'X'; 1808 const char *endptr = &f; 1809 uint64_t res = 999; 1810 int err; 1811 1812 err = qemu_strtou64(str, &endptr, 0, &res); 1813 1814 g_assert_cmpint(err, ==, -EINVAL); 1815 g_assert_cmpuint(res, ==, 0); 1816 g_assert_true(endptr == str); 1817 } 1818 1819 static void test_qemu_strtou64_trailing(void) 1820 { 1821 const char *str = "123xxx"; 1822 char f = 'X'; 1823 const char *endptr = &f; 1824 uint64_t res = 999; 1825 int err; 1826 1827 err = qemu_strtou64(str, &endptr, 0, &res); 1828 1829 g_assert_cmpint(err, ==, 0); 1830 g_assert_cmpuint(res, ==, 123); 1831 g_assert_true(endptr == str + 3); 1832 } 1833 1834 static void test_qemu_strtou64_octal(void) 1835 { 1836 const char *str = "0123"; 1837 char f = 'X'; 1838 const char *endptr = &f; 1839 uint64_t res = 999; 1840 int err; 1841 1842 err = qemu_strtou64(str, &endptr, 8, &res); 1843 1844 g_assert_cmpint(err, ==, 0); 1845 g_assert_cmpuint(res, ==, 0123); 1846 g_assert_true(endptr == str + strlen(str)); 1847 1848 endptr = &f; 1849 res = 999; 1850 err = qemu_strtou64(str, &endptr, 0, &res); 1851 1852 g_assert_cmpint(err, ==, 0); 1853 g_assert_cmpuint(res, ==, 0123); 1854 g_assert_true(endptr == str + strlen(str)); 1855 } 1856 1857 static void test_qemu_strtou64_decimal(void) 1858 { 1859 const char *str = "0123"; 1860 char f = 'X'; 1861 const char *endptr = &f; 1862 uint64_t res = 999; 1863 int err; 1864 1865 err = qemu_strtou64(str, &endptr, 10, &res); 1866 1867 g_assert_cmpint(err, ==, 0); 1868 g_assert_cmpuint(res, ==, 123); 1869 g_assert_true(endptr == str + strlen(str)); 1870 1871 str = "123"; 1872 endptr = &f; 1873 res = 999; 1874 err = qemu_strtou64(str, &endptr, 0, &res); 1875 1876 g_assert_cmpint(err, ==, 0); 1877 g_assert_cmpuint(res, ==, 123); 1878 g_assert_true(endptr == str + strlen(str)); 1879 } 1880 1881 static void test_qemu_strtou64_hex(void) 1882 { 1883 const char *str = "0123"; 1884 char f = 'X'; 1885 const char *endptr = &f; 1886 uint64_t res = 999; 1887 int err; 1888 1889 err = qemu_strtou64(str, &endptr, 16, &res); 1890 1891 g_assert_cmpint(err, ==, 0); 1892 g_assert_cmphex(res, ==, 0x123); 1893 g_assert_true(endptr == str + strlen(str)); 1894 1895 str = "0x123"; 1896 endptr = &f; 1897 res = 999; 1898 err = qemu_strtou64(str, &endptr, 0, &res); 1899 1900 g_assert_cmpint(err, ==, 0); 1901 g_assert_cmphex(res, ==, 0x123); 1902 g_assert_true(endptr == str + strlen(str)); 1903 1904 str = "0x"; 1905 endptr = &f; 1906 res = 999; 1907 err = qemu_strtou64(str, &endptr, 16, &res); 1908 1909 g_assert_cmpint(err, ==, 0); 1910 g_assert_cmphex(res, ==, 0); 1911 g_assert_true(endptr == str + 1); 1912 } 1913 1914 static void test_qemu_strtou64_max(void) 1915 { 1916 char *str = g_strdup_printf("%llu", ULLONG_MAX); 1917 char f = 'X'; 1918 const char *endptr = &f; 1919 uint64_t res = 999; 1920 int err; 1921 1922 err = qemu_strtou64(str, &endptr, 0, &res); 1923 1924 g_assert_cmpint(err, ==, 0); 1925 g_assert_cmphex(res, ==, ULLONG_MAX); 1926 g_assert_true(endptr == str + strlen(str)); 1927 g_free(str); 1928 } 1929 1930 static void test_qemu_strtou64_overflow(void) 1931 { 1932 const char *str = "99999999999999999999999999999999999999999999"; 1933 char f = 'X'; 1934 const char *endptr = &f; 1935 uint64_t res = 999; 1936 int err; 1937 1938 err = qemu_strtou64(str, &endptr, 0, &res); 1939 1940 g_assert_cmpint(err, ==, -ERANGE); 1941 g_assert_cmphex(res, ==, ULLONG_MAX); 1942 g_assert_true(endptr == str + strlen(str)); 1943 } 1944 1945 static void test_qemu_strtou64_underflow(void) 1946 { 1947 const char *str = "-99999999999999999999999999999999999999999999"; 1948 char f = 'X'; 1949 const char *endptr = &f; 1950 uint64_t res = 999; 1951 int err; 1952 1953 err = qemu_strtou64(str, &endptr, 0, &res); 1954 1955 g_assert_cmpint(err, ==, -ERANGE); 1956 g_assert_cmphex(res, ==, -1ull); 1957 g_assert_true(endptr == str + strlen(str)); 1958 } 1959 1960 static void test_qemu_strtou64_negative(void) 1961 { 1962 const char *str = " \t -321"; 1963 char f = 'X'; 1964 const char *endptr = &f; 1965 uint64_t res = 999; 1966 int err; 1967 1968 err = qemu_strtou64(str, &endptr, 0, &res); 1969 1970 g_assert_cmpint(err, ==, 0); 1971 g_assert_cmpuint(res, ==, -321ull); 1972 g_assert_true(endptr == str + strlen(str)); 1973 } 1974 1975 static void test_qemu_strtou64_full_correct(void) 1976 { 1977 const char *str = "18446744073709551614"; 1978 uint64_t res = 999; 1979 int err; 1980 1981 err = qemu_strtou64(str, NULL, 0, &res); 1982 1983 g_assert_cmpint(err, ==, 0); 1984 g_assert_cmpuint(res, ==, 18446744073709551614ull); 1985 } 1986 1987 static void test_qemu_strtou64_full_null(void) 1988 { 1989 uint64_t res = 999; 1990 int err; 1991 1992 err = qemu_strtou64(NULL, NULL, 0, &res); 1993 1994 g_assert_cmpint(err, ==, -EINVAL); 1995 g_assert_cmpuint(res, ==, 999); 1996 } 1997 1998 static void test_qemu_strtou64_full_empty(void) 1999 { 2000 const char *str = ""; 2001 uint64_t res = 999; 2002 int err; 2003 2004 err = qemu_strtou64(str, NULL, 0, &res); 2005 2006 g_assert_cmpint(err, ==, -EINVAL); 2007 g_assert_cmpuint(res, ==, 0); 2008 } 2009 2010 static void test_qemu_strtou64_full_negative(void) 2011 { 2012 const char *str = " \t -321"; 2013 uint64_t res = 999; 2014 int err; 2015 2016 err = qemu_strtou64(str, NULL, 0, &res); 2017 2018 g_assert_cmpint(err, ==, 0); 2019 g_assert_cmpuint(res, ==, -321ull); 2020 } 2021 2022 static void test_qemu_strtou64_full_trailing(void) 2023 { 2024 const char *str = "18446744073709551614xxxxxx"; 2025 uint64_t res = 999; 2026 int err; 2027 2028 err = qemu_strtou64(str, NULL, 0, &res); 2029 2030 g_assert_cmpint(err, ==, -EINVAL); 2031 g_assert_cmpuint(res, ==, 18446744073709551614ULL); 2032 } 2033 2034 static void test_qemu_strtou64_full_max(void) 2035 { 2036 char *str = g_strdup_printf("%lld", ULLONG_MAX); 2037 uint64_t res = 999; 2038 int err; 2039 2040 err = qemu_strtou64(str, NULL, 0, &res); 2041 2042 g_assert_cmpint(err, ==, 0); 2043 g_assert_cmphex(res, ==, ULLONG_MAX); 2044 g_free(str); 2045 } 2046 2047 static void test_qemu_strtosz_simple(void) 2048 { 2049 const char *str; 2050 const char *endptr; 2051 int err; 2052 uint64_t res; 2053 2054 str = "0"; 2055 endptr = str; 2056 res = 0xbaadf00d; 2057 err = qemu_strtosz(str, &endptr, &res); 2058 g_assert_cmpint(err, ==, 0); 2059 g_assert_cmpuint(res, ==, 0); 2060 g_assert_true(endptr == str + 1); 2061 2062 /* Leading 0 gives decimal results, not octal */ 2063 str = "08"; 2064 endptr = str; 2065 res = 0xbaadf00d; 2066 err = qemu_strtosz(str, &endptr, &res); 2067 g_assert_cmpint(err, ==, 0); 2068 g_assert_cmpuint(res, ==, 8); 2069 g_assert_true(endptr == str + 2); 2070 2071 /* Leading space is ignored */ 2072 str = " 12345"; 2073 endptr = str; 2074 res = 0xbaadf00d; 2075 err = qemu_strtosz(str, &endptr, &res); 2076 g_assert_cmpint(err, ==, 0); 2077 g_assert_cmpuint(res, ==, 12345); 2078 g_assert_true(endptr == str + 6); 2079 2080 res = 0xbaadf00d; 2081 err = qemu_strtosz(str, NULL, &res); 2082 g_assert_cmpint(err, ==, 0); 2083 g_assert_cmpuint(res, ==, 12345); 2084 2085 str = "9007199254740991"; /* 2^53-1 */ 2086 endptr = str; 2087 res = 0xbaadf00d; 2088 err = qemu_strtosz(str, &endptr, &res); 2089 g_assert_cmpint(err, ==, 0); 2090 g_assert_cmphex(res, ==, 0x1fffffffffffffULL); 2091 g_assert_true(endptr == str + 16); 2092 2093 str = "9007199254740992"; /* 2^53 */ 2094 endptr = str; 2095 res = 0xbaadf00d; 2096 err = qemu_strtosz(str, &endptr, &res); 2097 g_assert_cmpint(err, ==, 0); 2098 g_assert_cmphex(res, ==, 0x20000000000000ULL); 2099 g_assert_true(endptr == str + 16); 2100 2101 str = "9007199254740993"; /* 2^53+1 */ 2102 endptr = str; 2103 res = 0xbaadf00d; 2104 err = qemu_strtosz(str, &endptr, &res); 2105 g_assert_cmpint(err, ==, 0); 2106 g_assert_cmphex(res, ==, 0x20000000000001ULL); 2107 g_assert_true(endptr == str + 16); 2108 2109 str = "18446744073709549568"; /* 0xfffffffffffff800 (53 msbs set) */ 2110 endptr = str; 2111 res = 0xbaadf00d; 2112 err = qemu_strtosz(str, &endptr, &res); 2113 g_assert_cmpint(err, ==, 0); 2114 g_assert_cmphex(res, ==, 0xfffffffffffff800ULL); 2115 g_assert_true(endptr == str + 20); 2116 2117 str = "18446744073709550591"; /* 0xfffffffffffffbff */ 2118 endptr = str; 2119 res = 0xbaadf00d; 2120 err = qemu_strtosz(str, &endptr, &res); 2121 g_assert_cmpint(err, ==, 0); 2122 g_assert_cmphex(res, ==, 0xfffffffffffffbffULL); 2123 g_assert_true(endptr == str + 20); 2124 2125 str = "18446744073709551615"; /* 0xffffffffffffffff */ 2126 endptr = str; 2127 res = 0xbaadf00d; 2128 err = qemu_strtosz(str, &endptr, &res); 2129 g_assert_cmpint(err, ==, 0); 2130 g_assert_cmphex(res, ==, 0xffffffffffffffffULL); 2131 g_assert_true(endptr == str + 20); 2132 } 2133 2134 static void test_qemu_strtosz_hex(void) 2135 { 2136 const char *str; 2137 const char *endptr; 2138 int err; 2139 uint64_t res; 2140 2141 str = "0x0"; 2142 endptr = str; 2143 res = 0xbaadf00d; 2144 err = qemu_strtosz(str, &endptr, &res); 2145 g_assert_cmpint(err, ==, 0); 2146 g_assert_cmpuint(res, ==, 0); 2147 g_assert_true(endptr == str + 3); 2148 2149 str = "0xab"; 2150 endptr = str; 2151 res = 0xbaadf00d; 2152 err = qemu_strtosz(str, &endptr, &res); 2153 g_assert_cmpint(err, ==, 0); 2154 g_assert_cmpuint(res, ==, 171); 2155 g_assert_true(endptr == str + 4); 2156 2157 str = "0xae"; 2158 endptr = str; 2159 res = 0xbaadf00d; 2160 err = qemu_strtosz(str, &endptr, &res); 2161 g_assert_cmpint(err, ==, 0); 2162 g_assert_cmpuint(res, ==, 174); 2163 g_assert_true(endptr == str + 4); 2164 } 2165 2166 static void test_qemu_strtosz_units(void) 2167 { 2168 const char *none = "1"; 2169 const char *b = "1B"; 2170 const char *k = "1K"; 2171 const char *m = "1M"; 2172 const char *g = "1G"; 2173 const char *t = "1T"; 2174 const char *p = "1P"; 2175 const char *e = "1E"; 2176 int err; 2177 const char *endptr; 2178 uint64_t res; 2179 2180 /* default is M */ 2181 endptr = NULL; 2182 res = 0xbaadf00d; 2183 err = qemu_strtosz_MiB(none, &endptr, &res); 2184 g_assert_cmpint(err, ==, 0); 2185 g_assert_cmpuint(res, ==, MiB); 2186 g_assert_true(endptr == none + 1); 2187 2188 endptr = NULL; 2189 res = 0xbaadf00d; 2190 err = qemu_strtosz(b, &endptr, &res); 2191 g_assert_cmpint(err, ==, 0); 2192 g_assert_cmpuint(res, ==, 1); 2193 g_assert_true(endptr == b + 2); 2194 2195 endptr = NULL; 2196 res = 0xbaadf00d; 2197 err = qemu_strtosz(k, &endptr, &res); 2198 g_assert_cmpint(err, ==, 0); 2199 g_assert_cmpuint(res, ==, KiB); 2200 g_assert_true(endptr == k + 2); 2201 2202 endptr = NULL; 2203 res = 0xbaadf00d; 2204 err = qemu_strtosz(m, &endptr, &res); 2205 g_assert_cmpint(err, ==, 0); 2206 g_assert_cmpuint(res, ==, MiB); 2207 g_assert_true(endptr == m + 2); 2208 2209 endptr = NULL; 2210 res = 0xbaadf00d; 2211 err = qemu_strtosz(g, &endptr, &res); 2212 g_assert_cmpint(err, ==, 0); 2213 g_assert_cmpuint(res, ==, GiB); 2214 g_assert_true(endptr == g + 2); 2215 2216 endptr = NULL; 2217 res = 0xbaadf00d; 2218 err = qemu_strtosz(t, &endptr, &res); 2219 g_assert_cmpint(err, ==, 0); 2220 g_assert_cmpuint(res, ==, TiB); 2221 g_assert_true(endptr == t + 2); 2222 2223 endptr = NULL; 2224 res = 0xbaadf00d; 2225 err = qemu_strtosz(p, &endptr, &res); 2226 g_assert_cmpint(err, ==, 0); 2227 g_assert_cmpuint(res, ==, PiB); 2228 g_assert_true(endptr == p + 2); 2229 2230 endptr = NULL; 2231 res = 0xbaadf00d; 2232 err = qemu_strtosz(e, &endptr, &res); 2233 g_assert_cmpint(err, ==, 0); 2234 g_assert_cmpuint(res, ==, EiB); 2235 g_assert_true(endptr == e + 2); 2236 } 2237 2238 static void test_qemu_strtosz_float(void) 2239 { 2240 const char *str; 2241 int err; 2242 const char *endptr; 2243 uint64_t res; 2244 2245 str = "0.5E"; 2246 endptr = str; 2247 res = 0xbaadf00d; 2248 err = qemu_strtosz(str, &endptr, &res); 2249 g_assert_cmpint(err, ==, 0); 2250 g_assert_cmpuint(res, ==, EiB / 2); 2251 g_assert_true(endptr == str + 4); 2252 2253 /* For convenience, a fraction of 0 is tolerated even on bytes */ 2254 str = "1.0B"; 2255 endptr = str; 2256 res = 0xbaadf00d; 2257 err = qemu_strtosz(str, &endptr, &res); 2258 g_assert_cmpint(err, ==, 0); 2259 g_assert_cmpuint(res, ==, 1); 2260 g_assert_true(endptr == str + 4); 2261 2262 /* An empty fraction is tolerated */ 2263 str = "1.k"; 2264 endptr = str; 2265 res = 0xbaadf00d; 2266 err = qemu_strtosz(str, &endptr, &res); 2267 g_assert_cmpint(err, ==, 0); 2268 g_assert_cmpuint(res, ==, 1024); 2269 g_assert_true(endptr == str + 3); 2270 2271 /* For convenience, we permit values that are not byte-exact */ 2272 str = "12.345M"; 2273 endptr = str; 2274 res = 0xbaadf00d; 2275 err = qemu_strtosz(str, &endptr, &res); 2276 g_assert_cmpint(err, ==, 0); 2277 g_assert_cmpuint(res, ==, (uint64_t) (12.345 * MiB + 0.5)); 2278 g_assert_true(endptr == str + 7); 2279 } 2280 2281 static void test_qemu_strtosz_invalid(void) 2282 { 2283 const char *str; 2284 const char *endptr; 2285 int err; 2286 uint64_t res = 0xbaadf00d; 2287 2288 str = ""; 2289 endptr = NULL; 2290 err = qemu_strtosz(str, &endptr, &res); 2291 g_assert_cmpint(err, ==, -EINVAL); 2292 g_assert_cmphex(res, ==, 0xbaadf00d); 2293 g_assert_true(endptr == str); 2294 2295 str = " \t "; 2296 endptr = NULL; 2297 err = qemu_strtosz(str, &endptr, &res); 2298 g_assert_cmpint(err, ==, -EINVAL); 2299 g_assert_cmphex(res, ==, 0xbaadf00d); 2300 g_assert_true(endptr == str); 2301 2302 str = "crap"; 2303 endptr = NULL; 2304 err = qemu_strtosz(str, &endptr, &res); 2305 g_assert_cmpint(err, ==, -EINVAL); 2306 g_assert_cmphex(res, ==, 0xbaadf00d); 2307 g_assert_true(endptr == str); 2308 2309 str = "inf"; 2310 endptr = NULL; 2311 err = qemu_strtosz(str, &endptr, &res); 2312 g_assert_cmpint(err, ==, -EINVAL); 2313 g_assert_cmphex(res, ==, 0xbaadf00d); 2314 g_assert_true(endptr == str); 2315 2316 str = "NaN"; 2317 endptr = NULL; 2318 err = qemu_strtosz(str, &endptr, &res); 2319 g_assert_cmpint(err, ==, -EINVAL); 2320 g_assert_cmphex(res, ==, 0xbaadf00d); 2321 g_assert_true(endptr == str); 2322 2323 /* Fractional values require scale larger than bytes */ 2324 str = "1.1B"; 2325 endptr = NULL; 2326 err = qemu_strtosz(str, &endptr, &res); 2327 g_assert_cmpint(err, ==, -EINVAL); 2328 g_assert_cmphex(res, ==, 0xbaadf00d); 2329 g_assert_true(endptr == str); 2330 2331 str = "1.1"; 2332 endptr = NULL; 2333 err = qemu_strtosz(str, &endptr, &res); 2334 g_assert_cmpint(err, ==, -EINVAL); 2335 g_assert_cmphex(res, ==, 0xbaadf00d); 2336 g_assert_true(endptr == str); 2337 2338 /* No floating point exponents */ 2339 str = "1.5e1k"; 2340 endptr = NULL; 2341 err = qemu_strtosz(str, &endptr, &res); 2342 g_assert_cmpint(err, ==, -EINVAL); 2343 g_assert_cmphex(res, ==, 0xbaadf00d); 2344 g_assert_true(endptr == str); 2345 2346 str = "1.5E+0k"; 2347 endptr = NULL; 2348 err = qemu_strtosz(str, &endptr, &res); 2349 g_assert_cmpint(err, ==, -EINVAL); 2350 g_assert_cmphex(res, ==, 0xbaadf00d); 2351 g_assert_true(endptr == str); 2352 2353 /* No hex fractions */ 2354 str = "0x1.8k"; 2355 endptr = NULL; 2356 err = qemu_strtosz(str, &endptr, &res); 2357 g_assert_cmpint(err, ==, -EINVAL); 2358 g_assert_cmphex(res, ==, 0xbaadf00d); 2359 g_assert_true(endptr == str); 2360 2361 /* No suffixes */ 2362 str = "0x18M"; 2363 endptr = NULL; 2364 err = qemu_strtosz(str, &endptr, &res); 2365 g_assert_cmpint(err, ==, -EINVAL); 2366 g_assert_cmphex(res, ==, 0xbaadf00d); 2367 g_assert_true(endptr == str); 2368 2369 /* No negative values */ 2370 str = "-0"; 2371 endptr = NULL; 2372 err = qemu_strtosz(str, &endptr, &res); 2373 g_assert_cmpint(err, ==, -EINVAL); 2374 g_assert_cmphex(res, ==, 0xbaadf00d); 2375 g_assert_true(endptr == str); 2376 2377 str = "-1"; 2378 endptr = NULL; 2379 err = qemu_strtosz(str, &endptr, &res); 2380 g_assert_cmpint(err, ==, -EINVAL); 2381 g_assert_cmphex(res, ==, 0xbaadf00d); 2382 g_assert_true(endptr == str); 2383 } 2384 2385 static void test_qemu_strtosz_trailing(void) 2386 { 2387 const char *str; 2388 const char *endptr; 2389 int err; 2390 uint64_t res; 2391 2392 str = "123xxx"; 2393 endptr = NULL; 2394 res = 0xbaadf00d; 2395 err = qemu_strtosz_MiB(str, &endptr, &res); 2396 g_assert_cmpint(err, ==, 0); 2397 g_assert_cmpuint(res, ==, 123 * MiB); 2398 g_assert_true(endptr == str + 3); 2399 2400 res = 0xbaadf00d; 2401 err = qemu_strtosz(str, NULL, &res); 2402 g_assert_cmpint(err, ==, -EINVAL); 2403 g_assert_cmphex(res, ==, 0xbaadf00d); 2404 2405 str = "1kiB"; 2406 endptr = NULL; 2407 res = 0xbaadf00d; 2408 err = qemu_strtosz(str, &endptr, &res); 2409 g_assert_cmpint(err, ==, 0); 2410 g_assert_cmpuint(res, ==, 1024); 2411 g_assert_true(endptr == str + 2); 2412 2413 res = 0xbaadf00d; 2414 err = qemu_strtosz(str, NULL, &res); 2415 g_assert_cmpint(err, ==, -EINVAL); 2416 g_assert_cmphex(res, ==, 0xbaadf00d); 2417 2418 str = "0x"; 2419 endptr = NULL; 2420 res = 0xbaadf00d; 2421 err = qemu_strtosz(str, &endptr, &res); 2422 g_assert_cmpint(err, ==, 0); 2423 g_assert_cmpuint(res, ==, 0); 2424 g_assert_true(endptr == str + 1); 2425 2426 res = 0xbaadf00d; 2427 err = qemu_strtosz(str, NULL, &res); 2428 g_assert_cmpint(err, ==, -EINVAL); 2429 g_assert_cmphex(res, ==, 0xbaadf00d); 2430 2431 str = "0.NaN"; 2432 endptr = NULL; 2433 res = 0xbaadf00d; 2434 err = qemu_strtosz(str, &endptr, &res); 2435 g_assert_cmpint(err, ==, 0); 2436 g_assert_cmpuint(res, ==, 0); 2437 g_assert_true(endptr == str + 2); 2438 2439 res = 0xbaadf00d; 2440 err = qemu_strtosz(str, NULL, &res); 2441 g_assert_cmpint(err, ==, -EINVAL); 2442 g_assert_cmphex(res, ==, 0xbaadf00d); 2443 2444 str = "123-45"; 2445 endptr = NULL; 2446 res = 0xbaadf00d; 2447 err = qemu_strtosz(str, &endptr, &res); 2448 g_assert_cmpint(err, ==, 0); 2449 g_assert_cmpuint(res, ==, 123); 2450 g_assert_true(endptr == str + 3); 2451 2452 res = 0xbaadf00d; 2453 err = qemu_strtosz(str, NULL, &res); 2454 g_assert_cmpint(err, ==, -EINVAL); 2455 g_assert_cmphex(res, ==, 0xbaadf00d); 2456 } 2457 2458 static void test_qemu_strtosz_erange(void) 2459 { 2460 const char *str; 2461 const char *endptr; 2462 int err; 2463 uint64_t res = 0xbaadf00d; 2464 2465 str = "18446744073709551616"; /* 2^64; see strtosz_simple for 2^64-1 */ 2466 endptr = NULL; 2467 err = qemu_strtosz(str, &endptr, &res); 2468 g_assert_cmpint(err, ==, -ERANGE); 2469 g_assert_cmphex(res, ==, 0xbaadf00d); 2470 g_assert_true(endptr == str + 20); 2471 2472 str = "20E"; 2473 endptr = NULL; 2474 err = qemu_strtosz(str, &endptr, &res); 2475 g_assert_cmpint(err, ==, -ERANGE); 2476 g_assert_cmphex(res, ==, 0xbaadf00d); 2477 g_assert_true(endptr == str + 3); 2478 } 2479 2480 static void test_qemu_strtosz_metric(void) 2481 { 2482 const char *str; 2483 int err; 2484 const char *endptr; 2485 uint64_t res; 2486 2487 str = "12345k"; 2488 endptr = str; 2489 res = 0xbaadf00d; 2490 err = qemu_strtosz_metric(str, &endptr, &res); 2491 g_assert_cmpint(err, ==, 0); 2492 g_assert_cmpuint(res, ==, 12345000); 2493 g_assert_true(endptr == str + 6); 2494 2495 str = "12.345M"; 2496 endptr = str; 2497 res = 0xbaadf00d; 2498 err = qemu_strtosz_metric(str, &endptr, &res); 2499 g_assert_cmpint(err, ==, 0); 2500 g_assert_cmpuint(res, ==, 12345000); 2501 g_assert_true(endptr == str + 7); 2502 } 2503 2504 static void test_freq_to_str(void) 2505 { 2506 char *str; 2507 2508 str = freq_to_str(999); 2509 g_assert_cmpstr(str, ==, "999 Hz"); 2510 g_free(str); 2511 2512 str = freq_to_str(1000); 2513 g_assert_cmpstr(str, ==, "1 KHz"); 2514 g_free(str); 2515 2516 str = freq_to_str(1010); 2517 g_assert_cmpstr(str, ==, "1.01 KHz"); 2518 g_free(str); 2519 } 2520 2521 static void test_size_to_str(void) 2522 { 2523 char *str; 2524 2525 str = size_to_str(0); 2526 g_assert_cmpstr(str, ==, "0 B"); 2527 g_free(str); 2528 2529 str = size_to_str(1); 2530 g_assert_cmpstr(str, ==, "1 B"); 2531 g_free(str); 2532 2533 str = size_to_str(1016); 2534 g_assert_cmpstr(str, ==, "0.992 KiB"); 2535 g_free(str); 2536 2537 str = size_to_str(1024); 2538 g_assert_cmpstr(str, ==, "1 KiB"); 2539 g_free(str); 2540 2541 str = size_to_str(512ull << 20); 2542 g_assert_cmpstr(str, ==, "512 MiB"); 2543 g_free(str); 2544 } 2545 2546 static void test_iec_binary_prefix(void) 2547 { 2548 g_assert_cmpstr(iec_binary_prefix(0), ==, ""); 2549 g_assert_cmpstr(iec_binary_prefix(10), ==, "Ki"); 2550 g_assert_cmpstr(iec_binary_prefix(20), ==, "Mi"); 2551 g_assert_cmpstr(iec_binary_prefix(30), ==, "Gi"); 2552 g_assert_cmpstr(iec_binary_prefix(40), ==, "Ti"); 2553 g_assert_cmpstr(iec_binary_prefix(50), ==, "Pi"); 2554 g_assert_cmpstr(iec_binary_prefix(60), ==, "Ei"); 2555 } 2556 2557 static void test_si_prefix(void) 2558 { 2559 g_assert_cmpstr(si_prefix(-18), ==, "a"); 2560 g_assert_cmpstr(si_prefix(-15), ==, "f"); 2561 g_assert_cmpstr(si_prefix(-12), ==, "p"); 2562 g_assert_cmpstr(si_prefix(-9), ==, "n"); 2563 g_assert_cmpstr(si_prefix(-6), ==, "u"); 2564 g_assert_cmpstr(si_prefix(-3), ==, "m"); 2565 g_assert_cmpstr(si_prefix(0), ==, ""); 2566 g_assert_cmpstr(si_prefix(3), ==, "K"); 2567 g_assert_cmpstr(si_prefix(6), ==, "M"); 2568 g_assert_cmpstr(si_prefix(9), ==, "G"); 2569 g_assert_cmpstr(si_prefix(12), ==, "T"); 2570 g_assert_cmpstr(si_prefix(15), ==, "P"); 2571 g_assert_cmpstr(si_prefix(18), ==, "E"); 2572 } 2573 2574 int main(int argc, char **argv) 2575 { 2576 g_test_init(&argc, &argv, NULL); 2577 2578 g_test_add_func("/cutils/parse_uint/null", test_parse_uint_null); 2579 g_test_add_func("/cutils/parse_uint/empty", test_parse_uint_empty); 2580 g_test_add_func("/cutils/parse_uint/whitespace", 2581 test_parse_uint_whitespace); 2582 g_test_add_func("/cutils/parse_uint/invalid", test_parse_uint_invalid); 2583 g_test_add_func("/cutils/parse_uint/trailing", test_parse_uint_trailing); 2584 g_test_add_func("/cutils/parse_uint/correct", test_parse_uint_correct); 2585 g_test_add_func("/cutils/parse_uint/octal", test_parse_uint_octal); 2586 g_test_add_func("/cutils/parse_uint/decimal", test_parse_uint_decimal); 2587 g_test_add_func("/cutils/parse_uint/llong_max", test_parse_uint_llong_max); 2588 g_test_add_func("/cutils/parse_uint/overflow", test_parse_uint_overflow); 2589 g_test_add_func("/cutils/parse_uint/negative", test_parse_uint_negative); 2590 g_test_add_func("/cutils/parse_uint_full/trailing", 2591 test_parse_uint_full_trailing); 2592 g_test_add_func("/cutils/parse_uint_full/correct", 2593 test_parse_uint_full_correct); 2594 2595 /* qemu_strtoi() tests */ 2596 g_test_add_func("/cutils/qemu_strtoi/correct", 2597 test_qemu_strtoi_correct); 2598 g_test_add_func("/cutils/qemu_strtoi/null", 2599 test_qemu_strtoi_null); 2600 g_test_add_func("/cutils/qemu_strtoi/empty", 2601 test_qemu_strtoi_empty); 2602 g_test_add_func("/cutils/qemu_strtoi/whitespace", 2603 test_qemu_strtoi_whitespace); 2604 g_test_add_func("/cutils/qemu_strtoi/invalid", 2605 test_qemu_strtoi_invalid); 2606 g_test_add_func("/cutils/qemu_strtoi/trailing", 2607 test_qemu_strtoi_trailing); 2608 g_test_add_func("/cutils/qemu_strtoi/octal", 2609 test_qemu_strtoi_octal); 2610 g_test_add_func("/cutils/qemu_strtoi/decimal", 2611 test_qemu_strtoi_decimal); 2612 g_test_add_func("/cutils/qemu_strtoi/hex", 2613 test_qemu_strtoi_hex); 2614 g_test_add_func("/cutils/qemu_strtoi/max", 2615 test_qemu_strtoi_max); 2616 g_test_add_func("/cutils/qemu_strtoi/overflow", 2617 test_qemu_strtoi_overflow); 2618 g_test_add_func("/cutils/qemu_strtoi/underflow", 2619 test_qemu_strtoi_underflow); 2620 g_test_add_func("/cutils/qemu_strtoi/negative", 2621 test_qemu_strtoi_negative); 2622 g_test_add_func("/cutils/qemu_strtoi_full/correct", 2623 test_qemu_strtoi_full_correct); 2624 g_test_add_func("/cutils/qemu_strtoi_full/null", 2625 test_qemu_strtoi_full_null); 2626 g_test_add_func("/cutils/qemu_strtoi_full/empty", 2627 test_qemu_strtoi_full_empty); 2628 g_test_add_func("/cutils/qemu_strtoi_full/negative", 2629 test_qemu_strtoi_full_negative); 2630 g_test_add_func("/cutils/qemu_strtoi_full/trailing", 2631 test_qemu_strtoi_full_trailing); 2632 g_test_add_func("/cutils/qemu_strtoi_full/max", 2633 test_qemu_strtoi_full_max); 2634 2635 /* qemu_strtoui() tests */ 2636 g_test_add_func("/cutils/qemu_strtoui/correct", 2637 test_qemu_strtoui_correct); 2638 g_test_add_func("/cutils/qemu_strtoui/null", 2639 test_qemu_strtoui_null); 2640 g_test_add_func("/cutils/qemu_strtoui/empty", 2641 test_qemu_strtoui_empty); 2642 g_test_add_func("/cutils/qemu_strtoui/whitespace", 2643 test_qemu_strtoui_whitespace); 2644 g_test_add_func("/cutils/qemu_strtoui/invalid", 2645 test_qemu_strtoui_invalid); 2646 g_test_add_func("/cutils/qemu_strtoui/trailing", 2647 test_qemu_strtoui_trailing); 2648 g_test_add_func("/cutils/qemu_strtoui/octal", 2649 test_qemu_strtoui_octal); 2650 g_test_add_func("/cutils/qemu_strtoui/decimal", 2651 test_qemu_strtoui_decimal); 2652 g_test_add_func("/cutils/qemu_strtoui/hex", 2653 test_qemu_strtoui_hex); 2654 g_test_add_func("/cutils/qemu_strtoui/max", 2655 test_qemu_strtoui_max); 2656 g_test_add_func("/cutils/qemu_strtoui/overflow", 2657 test_qemu_strtoui_overflow); 2658 g_test_add_func("/cutils/qemu_strtoui/underflow", 2659 test_qemu_strtoui_underflow); 2660 g_test_add_func("/cutils/qemu_strtoui/negative", 2661 test_qemu_strtoui_negative); 2662 g_test_add_func("/cutils/qemu_strtoui_full/correct", 2663 test_qemu_strtoui_full_correct); 2664 g_test_add_func("/cutils/qemu_strtoui_full/null", 2665 test_qemu_strtoui_full_null); 2666 g_test_add_func("/cutils/qemu_strtoui_full/empty", 2667 test_qemu_strtoui_full_empty); 2668 g_test_add_func("/cutils/qemu_strtoui_full/negative", 2669 test_qemu_strtoui_full_negative); 2670 g_test_add_func("/cutils/qemu_strtoui_full/trailing", 2671 test_qemu_strtoui_full_trailing); 2672 g_test_add_func("/cutils/qemu_strtoui_full/max", 2673 test_qemu_strtoui_full_max); 2674 2675 /* qemu_strtol() tests */ 2676 g_test_add_func("/cutils/qemu_strtol/correct", 2677 test_qemu_strtol_correct); 2678 g_test_add_func("/cutils/qemu_strtol/null", 2679 test_qemu_strtol_null); 2680 g_test_add_func("/cutils/qemu_strtol/empty", 2681 test_qemu_strtol_empty); 2682 g_test_add_func("/cutils/qemu_strtol/whitespace", 2683 test_qemu_strtol_whitespace); 2684 g_test_add_func("/cutils/qemu_strtol/invalid", 2685 test_qemu_strtol_invalid); 2686 g_test_add_func("/cutils/qemu_strtol/trailing", 2687 test_qemu_strtol_trailing); 2688 g_test_add_func("/cutils/qemu_strtol/octal", 2689 test_qemu_strtol_octal); 2690 g_test_add_func("/cutils/qemu_strtol/decimal", 2691 test_qemu_strtol_decimal); 2692 g_test_add_func("/cutils/qemu_strtol/hex", 2693 test_qemu_strtol_hex); 2694 g_test_add_func("/cutils/qemu_strtol/max", 2695 test_qemu_strtol_max); 2696 g_test_add_func("/cutils/qemu_strtol/overflow", 2697 test_qemu_strtol_overflow); 2698 g_test_add_func("/cutils/qemu_strtol/underflow", 2699 test_qemu_strtol_underflow); 2700 g_test_add_func("/cutils/qemu_strtol/negative", 2701 test_qemu_strtol_negative); 2702 g_test_add_func("/cutils/qemu_strtol_full/correct", 2703 test_qemu_strtol_full_correct); 2704 g_test_add_func("/cutils/qemu_strtol_full/null", 2705 test_qemu_strtol_full_null); 2706 g_test_add_func("/cutils/qemu_strtol_full/empty", 2707 test_qemu_strtol_full_empty); 2708 g_test_add_func("/cutils/qemu_strtol_full/negative", 2709 test_qemu_strtol_full_negative); 2710 g_test_add_func("/cutils/qemu_strtol_full/trailing", 2711 test_qemu_strtol_full_trailing); 2712 g_test_add_func("/cutils/qemu_strtol_full/max", 2713 test_qemu_strtol_full_max); 2714 2715 /* qemu_strtoul() tests */ 2716 g_test_add_func("/cutils/qemu_strtoul/correct", 2717 test_qemu_strtoul_correct); 2718 g_test_add_func("/cutils/qemu_strtoul/null", 2719 test_qemu_strtoul_null); 2720 g_test_add_func("/cutils/qemu_strtoul/empty", 2721 test_qemu_strtoul_empty); 2722 g_test_add_func("/cutils/qemu_strtoul/whitespace", 2723 test_qemu_strtoul_whitespace); 2724 g_test_add_func("/cutils/qemu_strtoul/invalid", 2725 test_qemu_strtoul_invalid); 2726 g_test_add_func("/cutils/qemu_strtoul/trailing", 2727 test_qemu_strtoul_trailing); 2728 g_test_add_func("/cutils/qemu_strtoul/octal", 2729 test_qemu_strtoul_octal); 2730 g_test_add_func("/cutils/qemu_strtoul/decimal", 2731 test_qemu_strtoul_decimal); 2732 g_test_add_func("/cutils/qemu_strtoul/hex", 2733 test_qemu_strtoul_hex); 2734 g_test_add_func("/cutils/qemu_strtoul/max", 2735 test_qemu_strtoul_max); 2736 g_test_add_func("/cutils/qemu_strtoul/overflow", 2737 test_qemu_strtoul_overflow); 2738 g_test_add_func("/cutils/qemu_strtoul/underflow", 2739 test_qemu_strtoul_underflow); 2740 g_test_add_func("/cutils/qemu_strtoul/negative", 2741 test_qemu_strtoul_negative); 2742 g_test_add_func("/cutils/qemu_strtoul_full/correct", 2743 test_qemu_strtoul_full_correct); 2744 g_test_add_func("/cutils/qemu_strtoul_full/null", 2745 test_qemu_strtoul_full_null); 2746 g_test_add_func("/cutils/qemu_strtoul_full/empty", 2747 test_qemu_strtoul_full_empty); 2748 g_test_add_func("/cutils/qemu_strtoul_full/negative", 2749 test_qemu_strtoul_full_negative); 2750 g_test_add_func("/cutils/qemu_strtoul_full/trailing", 2751 test_qemu_strtoul_full_trailing); 2752 g_test_add_func("/cutils/qemu_strtoul_full/max", 2753 test_qemu_strtoul_full_max); 2754 2755 /* qemu_strtoi64() tests */ 2756 g_test_add_func("/cutils/qemu_strtoi64/correct", 2757 test_qemu_strtoi64_correct); 2758 g_test_add_func("/cutils/qemu_strtoi64/null", 2759 test_qemu_strtoi64_null); 2760 g_test_add_func("/cutils/qemu_strtoi64/empty", 2761 test_qemu_strtoi64_empty); 2762 g_test_add_func("/cutils/qemu_strtoi64/whitespace", 2763 test_qemu_strtoi64_whitespace); 2764 g_test_add_func("/cutils/qemu_strtoi64/invalid" 2765 , 2766 test_qemu_strtoi64_invalid); 2767 g_test_add_func("/cutils/qemu_strtoi64/trailing", 2768 test_qemu_strtoi64_trailing); 2769 g_test_add_func("/cutils/qemu_strtoi64/octal", 2770 test_qemu_strtoi64_octal); 2771 g_test_add_func("/cutils/qemu_strtoi64/decimal", 2772 test_qemu_strtoi64_decimal); 2773 g_test_add_func("/cutils/qemu_strtoi64/hex", 2774 test_qemu_strtoi64_hex); 2775 g_test_add_func("/cutils/qemu_strtoi64/max", 2776 test_qemu_strtoi64_max); 2777 g_test_add_func("/cutils/qemu_strtoi64/overflow", 2778 test_qemu_strtoi64_overflow); 2779 g_test_add_func("/cutils/qemu_strtoi64/underflow", 2780 test_qemu_strtoi64_underflow); 2781 g_test_add_func("/cutils/qemu_strtoi64/negative", 2782 test_qemu_strtoi64_negative); 2783 g_test_add_func("/cutils/qemu_strtoi64_full/correct", 2784 test_qemu_strtoi64_full_correct); 2785 g_test_add_func("/cutils/qemu_strtoi64_full/null", 2786 test_qemu_strtoi64_full_null); 2787 g_test_add_func("/cutils/qemu_strtoi64_full/empty", 2788 test_qemu_strtoi64_full_empty); 2789 g_test_add_func("/cutils/qemu_strtoi64_full/negative", 2790 test_qemu_strtoi64_full_negative); 2791 g_test_add_func("/cutils/qemu_strtoi64_full/trailing", 2792 test_qemu_strtoi64_full_trailing); 2793 g_test_add_func("/cutils/qemu_strtoi64_full/max", 2794 test_qemu_strtoi64_full_max); 2795 2796 /* qemu_strtou64() tests */ 2797 g_test_add_func("/cutils/qemu_strtou64/correct", 2798 test_qemu_strtou64_correct); 2799 g_test_add_func("/cutils/qemu_strtou64/null", 2800 test_qemu_strtou64_null); 2801 g_test_add_func("/cutils/qemu_strtou64/empty", 2802 test_qemu_strtou64_empty); 2803 g_test_add_func("/cutils/qemu_strtou64/whitespace", 2804 test_qemu_strtou64_whitespace); 2805 g_test_add_func("/cutils/qemu_strtou64/invalid", 2806 test_qemu_strtou64_invalid); 2807 g_test_add_func("/cutils/qemu_strtou64/trailing", 2808 test_qemu_strtou64_trailing); 2809 g_test_add_func("/cutils/qemu_strtou64/octal", 2810 test_qemu_strtou64_octal); 2811 g_test_add_func("/cutils/qemu_strtou64/decimal", 2812 test_qemu_strtou64_decimal); 2813 g_test_add_func("/cutils/qemu_strtou64/hex", 2814 test_qemu_strtou64_hex); 2815 g_test_add_func("/cutils/qemu_strtou64/max", 2816 test_qemu_strtou64_max); 2817 g_test_add_func("/cutils/qemu_strtou64/overflow", 2818 test_qemu_strtou64_overflow); 2819 g_test_add_func("/cutils/qemu_strtou64/underflow", 2820 test_qemu_strtou64_underflow); 2821 g_test_add_func("/cutils/qemu_strtou64/negative", 2822 test_qemu_strtou64_negative); 2823 g_test_add_func("/cutils/qemu_strtou64_full/correct", 2824 test_qemu_strtou64_full_correct); 2825 g_test_add_func("/cutils/qemu_strtou64_full/null", 2826 test_qemu_strtou64_full_null); 2827 g_test_add_func("/cutils/qemu_strtou64_full/empty", 2828 test_qemu_strtou64_full_empty); 2829 g_test_add_func("/cutils/qemu_strtou64_full/negative", 2830 test_qemu_strtou64_full_negative); 2831 g_test_add_func("/cutils/qemu_strtou64_full/trailing", 2832 test_qemu_strtou64_full_trailing); 2833 g_test_add_func("/cutils/qemu_strtou64_full/max", 2834 test_qemu_strtou64_full_max); 2835 2836 g_test_add_func("/cutils/strtosz/simple", 2837 test_qemu_strtosz_simple); 2838 g_test_add_func("/cutils/strtosz/hex", 2839 test_qemu_strtosz_hex); 2840 g_test_add_func("/cutils/strtosz/units", 2841 test_qemu_strtosz_units); 2842 g_test_add_func("/cutils/strtosz/float", 2843 test_qemu_strtosz_float); 2844 g_test_add_func("/cutils/strtosz/invalid", 2845 test_qemu_strtosz_invalid); 2846 g_test_add_func("/cutils/strtosz/trailing", 2847 test_qemu_strtosz_trailing); 2848 g_test_add_func("/cutils/strtosz/erange", 2849 test_qemu_strtosz_erange); 2850 g_test_add_func("/cutils/strtosz/metric", 2851 test_qemu_strtosz_metric); 2852 2853 g_test_add_func("/cutils/size_to_str", 2854 test_size_to_str); 2855 g_test_add_func("/cutils/freq_to_str", 2856 test_freq_to_str); 2857 g_test_add_func("/cutils/iec_binary_prefix", 2858 test_iec_binary_prefix); 2859 g_test_add_func("/cutils/si_prefix", 2860 test_si_prefix); 2861 return g_test_run(); 2862 } 2863