tests/unit/test-cutils.c

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