tests/unit/test-cutils.c

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