tests/unit/test-cutils.c

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