tests/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
  30 #include "qemu/cutils.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_cmpint(i, ==, 0);
  43     g_assert(endptr == NULL);
  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_cmpint(i, ==, 0);
  58     g_assert(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_cmpint(i, ==, 0);
  73     g_assert(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_cmpint(i, ==, 0);
  89     g_assert(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_cmpint(i, ==, 123);
 105     g_assert(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_cmpint(i, ==, 123);
 120     g_assert(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_cmpint(i, ==, 0123);
 135     g_assert(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_cmpint(i, ==, 123);
 150     g_assert(endptr == str + strlen(str));
 151 }
 152
 153
 154 static void test_parse_uint_llong_max(void)
 155 {
 156     unsigned long long i = 999;
 157     char f = 'X';
 158     char *endptr = &f;
 159     char *str = g_strdup_printf("%llu", (unsigned long long)LLONG_MAX + 1);
 160     int r;
 161
 162     r = parse_uint(str, &i, &endptr, 0);
 163
 164     g_assert_cmpint(r, ==, 0);
 165     g_assert_cmpint(i, ==, (unsigned long long)LLONG_MAX + 1);
 166     g_assert(endptr == str + strlen(str));
 167
 168     g_free(str);
 169 }
 170
 171 static void test_parse_uint_overflow(void)
 172 {
 173     unsigned long long i = 999;
 174     char f = 'X';
 175     char *endptr = &f;
 176     const char *str = "99999999999999999999999999999999999999";
 177     int r;
 178
 179     r = parse_uint(str, &i, &endptr, 0);
 180
 181     g_assert_cmpint(r, ==, -ERANGE);
 182     g_assert_cmpint(i, ==, ULLONG_MAX);
 183     g_assert(endptr == str + strlen(str));
 184 }
 185
 186 static void test_parse_uint_negative(void)
 187 {
 188     unsigned long long i = 999;
 189     char f = 'X';
 190     char *endptr = &f;
 191     const char *str = " \t -321";
 192     int r;
 193
 194     r = parse_uint(str, &i, &endptr, 0);
 195
 196     g_assert_cmpint(r, ==, -ERANGE);
 197     g_assert_cmpint(i, ==, 0);
 198     g_assert(endptr == str + strlen(str));
 199 }
 200
 201
 202 static void test_parse_uint_full_trailing(void)
 203 {
 204     unsigned long long i = 999;
 205     const char *str = "123xxx";
 206     int r;
 207
 208     r = parse_uint_full(str, &i, 0);
 209
 210     g_assert_cmpint(r, ==, -EINVAL);
 211     g_assert_cmpint(i, ==, 0);
 212 }
 213
 214 static void test_parse_uint_full_correct(void)
 215 {
 216     unsigned long long i = 999;
 217     const char *str = "123";
 218     int r;
 219
 220     r = parse_uint_full(str, &i, 0);
 221
 222     g_assert_cmpint(r, ==, 0);
 223     g_assert_cmpint(i, ==, 123);
 224 }
 225
 226 static void test_qemu_strtol_correct(void)
 227 {
 228     const char *str = "12345 foo";
 229     char f = 'X';
 230     const char *endptr = &f;
 231     long res = 999;
 232     int err;
 233
 234     err = qemu_strtol(str, &endptr, 0, &res);
 235
 236     g_assert_cmpint(err, ==, 0);
 237     g_assert_cmpint(res, ==, 12345);
 238     g_assert(endptr == str + 5);
 239 }
 240
 241 static void test_qemu_strtol_null(void)
 242 {
 243     char f = 'X';
 244     const char *endptr = &f;
 245     long res = 999;
 246     int err;
 247
 248     err = qemu_strtol(NULL, &endptr, 0, &res);
 249
 250     g_assert_cmpint(err, ==, -EINVAL);
 251     g_assert(endptr == NULL);
 252 }
 253
 254 static void test_qemu_strtol_empty(void)
 255 {
 256     const char *str = "";
 257     char f = 'X';
 258     const char *endptr = &f;
 259     long res = 999;
 260     int err;
 261
 262     err = qemu_strtol(str, &endptr, 0, &res);
 263
 264     g_assert_cmpint(err, ==, -EINVAL);
 265     g_assert(endptr == str);
 266 }
 267
 268 static void test_qemu_strtol_whitespace(void)
 269 {
 270     const char *str = "  \t  ";
 271     char f = 'X';
 272     const char *endptr = &f;
 273     long res = 999;
 274     int err;
 275
 276     err = qemu_strtol(str, &endptr, 0, &res);
 277
 278     g_assert_cmpint(err, ==, -EINVAL);
 279     g_assert(endptr == str);
 280 }
 281
 282 static void test_qemu_strtol_invalid(void)
 283 {
 284     const char *str = "   xxxx  \t abc";
 285     char f = 'X';
 286     const char *endptr = &f;
 287     long res = 999;
 288     int err;
 289
 290     err = qemu_strtol(str, &endptr, 0, &res);
 291
 292     g_assert_cmpint(err, ==, -EINVAL);
 293     g_assert(endptr == str);
 294 }
 295
 296 static void test_qemu_strtol_trailing(void)
 297 {
 298     const char *str = "123xxx";
 299     char f = 'X';
 300     const char *endptr = &f;
 301     long res = 999;
 302     int err;
 303
 304     err = qemu_strtol(str, &endptr, 0, &res);
 305
 306     g_assert_cmpint(err, ==, 0);
 307     g_assert_cmpint(res, ==, 123);
 308     g_assert(endptr == str + 3);
 309 }
 310
 311 static void test_qemu_strtol_octal(void)
 312 {
 313     const char *str = "0123";
 314     char f = 'X';
 315     const char *endptr = &f;
 316     long res = 999;
 317     int err;
 318
 319     err = qemu_strtol(str, &endptr, 8, &res);
 320
 321     g_assert_cmpint(err, ==, 0);
 322     g_assert_cmpint(res, ==, 0123);
 323     g_assert(endptr == str + strlen(str));
 324
 325     res = 999;
 326     endptr = &f;
 327     err = qemu_strtol(str, &endptr, 0, &res);
 328
 329     g_assert_cmpint(err, ==, 0);
 330     g_assert_cmpint(res, ==, 0123);
 331     g_assert(endptr == str + strlen(str));
 332 }
 333
 334 static void test_qemu_strtol_decimal(void)
 335 {
 336     const char *str = "0123";
 337     char f = 'X';
 338     const char *endptr = &f;
 339     long res = 999;
 340     int err;
 341
 342     err = qemu_strtol(str, &endptr, 10, &res);
 343
 344     g_assert_cmpint(err, ==, 0);
 345     g_assert_cmpint(res, ==, 123);
 346     g_assert(endptr == str + strlen(str));
 347
 348     str = "123";
 349     res = 999;
 350     endptr = &f;
 351     err = qemu_strtol(str, &endptr, 0, &res);
 352
 353     g_assert_cmpint(err, ==, 0);
 354     g_assert_cmpint(res, ==, 123);
 355     g_assert(endptr == str + strlen(str));
 356 }
 357
 358 static void test_qemu_strtol_hex(void)
 359 {
 360     const char *str = "0123";
 361     char f = 'X';
 362     const char *endptr = &f;
 363     long res = 999;
 364     int err;
 365
 366     err = qemu_strtol(str, &endptr, 16, &res);
 367
 368     g_assert_cmpint(err, ==, 0);
 369     g_assert_cmpint(res, ==, 0x123);
 370     g_assert(endptr == str + strlen(str));
 371
 372     str = "0x123";
 373     res = 999;
 374     endptr = &f;
 375     err = qemu_strtol(str, &endptr, 0, &res);
 376
 377     g_assert_cmpint(err, ==, 0);
 378     g_assert_cmpint(res, ==, 0x123);
 379     g_assert(endptr == str + strlen(str));
 380 }
 381
 382 static void test_qemu_strtol_max(void)
 383 {
 384     char *str = g_strdup_printf("%ld", LONG_MAX);
 385     char f = 'X';
 386     const char *endptr = &f;
 387     long res = 999;
 388     int err;
 389
 390     err = qemu_strtol(str, &endptr, 0, &res);
 391
 392     g_assert_cmpint(err, ==, 0);
 393     g_assert_cmpint(res, ==, LONG_MAX);
 394     g_assert(endptr == str + strlen(str));
 395     g_free(str);
 396 }
 397
 398 static void test_qemu_strtol_overflow(void)
 399 {
 400     const char *str = "99999999999999999999999999999999999999999999";
 401     char f = 'X';
 402     const char *endptr = &f;
 403     long res = 999;
 404     int err;
 405
 406     err = qemu_strtol(str, &endptr, 0, &res);
 407
 408     g_assert_cmpint(err, ==, -ERANGE);
 409     g_assert_cmpint(res, ==, LONG_MAX);
 410     g_assert(endptr == str + strlen(str));
 411 }
 412
 413 static void test_qemu_strtol_underflow(void)
 414 {
 415     const char *str = "-99999999999999999999999999999999999999999999";
 416     char f = 'X';
 417     const char *endptr = &f;
 418     long res = 999;
 419     int err;
 420
 421     err  = qemu_strtol(str, &endptr, 0, &res);
 422
 423     g_assert_cmpint(err, ==, -ERANGE);
 424     g_assert_cmpint(res, ==, LONG_MIN);
 425     g_assert(endptr == str + strlen(str));
 426 }
 427
 428 static void test_qemu_strtol_negative(void)
 429 {
 430     const char *str = "  \t -321";
 431     char f = 'X';
 432     const char *endptr = &f;
 433     long res = 999;
 434     int err;
 435
 436     err = qemu_strtol(str, &endptr, 0, &res);
 437
 438     g_assert_cmpint(err, ==, 0);
 439     g_assert_cmpint(res, ==, -321);
 440     g_assert(endptr == str + strlen(str));
 441 }
 442
 443 static void test_qemu_strtol_full_correct(void)
 444 {
 445     const char *str = "123";
 446     long res = 999;
 447     int err;
 448
 449     err = qemu_strtol(str, NULL, 0, &res);
 450
 451     g_assert_cmpint(err, ==, 0);
 452     g_assert_cmpint(res, ==, 123);
 453 }
 454
 455 static void test_qemu_strtol_full_null(void)
 456 {
 457     char f = 'X';
 458     const char *endptr = &f;
 459     long res = 999;
 460     int err;
 461
 462     err = qemu_strtol(NULL, &endptr, 0, &res);
 463
 464     g_assert_cmpint(err, ==, -EINVAL);
 465     g_assert(endptr == NULL);
 466 }
 467
 468 static void test_qemu_strtol_full_empty(void)
 469 {
 470     const char *str = "";
 471     long res = 999L;
 472     int err;
 473
 474     err =  qemu_strtol(str, NULL, 0, &res);
 475
 476     g_assert_cmpint(err, ==, -EINVAL);
 477 }
 478
 479 static void test_qemu_strtol_full_negative(void)
 480 {
 481     const char *str = " \t -321";
 482     long res = 999;
 483     int err;
 484
 485     err = qemu_strtol(str, NULL, 0, &res);
 486
 487     g_assert_cmpint(err, ==, 0);
 488     g_assert_cmpint(res, ==, -321);
 489 }
 490
 491 static void test_qemu_strtol_full_trailing(void)
 492 {
 493     const char *str = "123xxx";
 494     long res;
 495     int err;
 496
 497     err = qemu_strtol(str, NULL, 0, &res);
 498
 499     g_assert_cmpint(err, ==, -EINVAL);
 500 }
 501
 502 static void test_qemu_strtol_full_max(void)
 503 {
 504     char *str = g_strdup_printf("%ld", LONG_MAX);
 505     long res;
 506     int err;
 507
 508     err = qemu_strtol(str, NULL, 0, &res);
 509
 510     g_assert_cmpint(err, ==, 0);
 511     g_assert_cmpint(res, ==, LONG_MAX);
 512     g_free(str);
 513 }
 514
 515 static void test_qemu_strtoul_correct(void)
 516 {
 517     const char *str = "12345 foo";
 518     char f = 'X';
 519     const char *endptr = &f;
 520     unsigned long res = 999;
 521     int err;
 522
 523     err = qemu_strtoul(str, &endptr, 0, &res);
 524
 525     g_assert_cmpint(err, ==, 0);
 526     g_assert_cmpint(res, ==, 12345);
 527     g_assert(endptr == str + 5);
 528 }
 529
 530 static void test_qemu_strtoul_null(void)
 531 {
 532     char f = 'X';
 533     const char *endptr = &f;
 534     unsigned long res = 999;
 535     int err;
 536
 537     err = qemu_strtoul(NULL, &endptr, 0, &res);
 538
 539     g_assert_cmpint(err, ==, -EINVAL);
 540     g_assert(endptr == NULL);
 541 }
 542
 543 static void test_qemu_strtoul_empty(void)
 544 {
 545     const char *str = "";
 546     char f = 'X';
 547     const char *endptr = &f;
 548     unsigned long res = 999;
 549     int err;
 550
 551     err = qemu_strtoul(str, &endptr, 0, &res);
 552
 553     g_assert_cmpint(err, ==, -EINVAL);
 554     g_assert(endptr == str);
 555 }
 556
 557 static void test_qemu_strtoul_whitespace(void)
 558 {
 559     const char *str = "  \t  ";
 560     char f = 'X';
 561     const char *endptr = &f;
 562     unsigned long res = 999;
 563     int err;
 564
 565     err = qemu_strtoul(str, &endptr, 0, &res);
 566
 567     g_assert_cmpint(err, ==, -EINVAL);
 568     g_assert(endptr == str);
 569 }
 570
 571 static void test_qemu_strtoul_invalid(void)
 572 {
 573     const char *str = "   xxxx  \t abc";
 574     char f = 'X';
 575     const char *endptr = &f;
 576     unsigned long res = 999;
 577     int err;
 578
 579     err = qemu_strtoul(str, &endptr, 0, &res);
 580
 581     g_assert_cmpint(err, ==, -EINVAL);
 582     g_assert(endptr == str);
 583 }
 584
 585 static void test_qemu_strtoul_trailing(void)
 586 {
 587     const char *str = "123xxx";
 588     char f = 'X';
 589     const char *endptr = &f;
 590     unsigned long res = 999;
 591     int err;
 592
 593     err = qemu_strtoul(str, &endptr, 0, &res);
 594
 595     g_assert_cmpint(err, ==, 0);
 596     g_assert_cmpint(res, ==, 123);
 597     g_assert(endptr == str + 3);
 598 }
 599
 600 static void test_qemu_strtoul_octal(void)
 601 {
 602     const char *str = "0123";
 603     char f = 'X';
 604     const char *endptr = &f;
 605     unsigned long res = 999;
 606     int err;
 607
 608     err = qemu_strtoul(str, &endptr, 8, &res);
 609
 610     g_assert_cmpint(err, ==, 0);
 611     g_assert_cmpint(res, ==, 0123);
 612     g_assert(endptr == str + strlen(str));
 613
 614     res = 999;
 615     endptr = &f;
 616     err = qemu_strtoul(str, &endptr, 0, &res);
 617
 618     g_assert_cmpint(err, ==, 0);
 619     g_assert_cmpint(res, ==, 0123);
 620     g_assert(endptr == str + strlen(str));
 621 }
 622
 623 static void test_qemu_strtoul_decimal(void)
 624 {
 625     const char *str = "0123";
 626     char f = 'X';
 627     const char *endptr = &f;
 628     unsigned long res = 999;
 629     int err;
 630
 631     err = qemu_strtoul(str, &endptr, 10, &res);
 632
 633     g_assert_cmpint(err, ==, 0);
 634     g_assert_cmpint(res, ==, 123);
 635     g_assert(endptr == str + strlen(str));
 636
 637     str = "123";
 638     res = 999;
 639     endptr = &f;
 640     err = qemu_strtoul(str, &endptr, 0, &res);
 641
 642     g_assert_cmpint(err, ==, 0);
 643     g_assert_cmpint(res, ==, 123);
 644     g_assert(endptr == str + strlen(str));
 645 }
 646
 647 static void test_qemu_strtoul_hex(void)
 648 {
 649     const char *str = "0123";
 650     char f = 'X';
 651     const char *endptr = &f;
 652     unsigned long res = 999;
 653     int err;
 654
 655     err = qemu_strtoul(str, &endptr, 16, &res);
 656
 657     g_assert_cmpint(err, ==, 0);
 658     g_assert_cmpint(res, ==, 0x123);
 659     g_assert(endptr == str + strlen(str));
 660
 661     str = "0x123";
 662     res = 999;
 663     endptr = &f;
 664     err = qemu_strtoul(str, &endptr, 0, &res);
 665
 666     g_assert_cmpint(err, ==, 0);
 667     g_assert_cmpint(res, ==, 0x123);
 668     g_assert(endptr == str + strlen(str));
 669 }
 670
 671 static void test_qemu_strtoul_max(void)
 672 {
 673     char *str = g_strdup_printf("%lu", ULONG_MAX);
 674     char f = 'X';
 675     const char *endptr = &f;
 676     unsigned long res = 999;
 677     int err;
 678
 679     err = qemu_strtoul(str, &endptr, 0, &res);
 680
 681     g_assert_cmpint(err, ==, 0);
 682     g_assert_cmpint(res, ==, ULONG_MAX);
 683     g_assert(endptr == str + strlen(str));
 684     g_free(str);
 685 }
 686
 687 static void test_qemu_strtoul_overflow(void)
 688 {
 689     const char *str = "99999999999999999999999999999999999999999999";
 690     char f = 'X';
 691     const char *endptr = &f;
 692     unsigned long res = 999;
 693     int err;
 694
 695     err = qemu_strtoul(str, &endptr, 0, &res);
 696
 697     g_assert_cmpint(err, ==, -ERANGE);
 698     g_assert_cmpint(res, ==, ULONG_MAX);
 699     g_assert(endptr == str + strlen(str));
 700 }
 701
 702 static void test_qemu_strtoul_underflow(void)
 703 {
 704     const char *str = "-99999999999999999999999999999999999999999999";
 705     char f = 'X';
 706     const char *endptr = &f;
 707     unsigned long res = 999;
 708     int err;
 709
 710     err  = qemu_strtoul(str, &endptr, 0, &res);
 711
 712     g_assert_cmpint(err, ==, -ERANGE);
 713     g_assert_cmpint(res, ==, -1ul);
 714     g_assert(endptr == str + strlen(str));
 715 }
 716
 717 static void test_qemu_strtoul_negative(void)
 718 {
 719     const char *str = "  \t -321";
 720     char f = 'X';
 721     const char *endptr = &f;
 722     unsigned long res = 999;
 723     int err;
 724
 725     err = qemu_strtoul(str, &endptr, 0, &res);
 726
 727     g_assert_cmpint(err, ==, 0);
 728     g_assert_cmpint(res, ==, -321ul);
 729     g_assert(endptr == str + strlen(str));
 730 }
 731
 732 static void test_qemu_strtoul_full_correct(void)
 733 {
 734     const char *str = "123";
 735     unsigned long res = 999;
 736     int err;
 737
 738     err = qemu_strtoul(str, NULL, 0, &res);
 739
 740     g_assert_cmpint(err, ==, 0);
 741     g_assert_cmpint(res, ==, 123);
 742 }
 743
 744 static void test_qemu_strtoul_full_null(void)
 745 {
 746     unsigned long res = 999;
 747     int err;
 748
 749     err = qemu_strtoul(NULL, NULL, 0, &res);
 750
 751     g_assert_cmpint(err, ==, -EINVAL);
 752 }
 753
 754 static void test_qemu_strtoul_full_empty(void)
 755 {
 756     const char *str = "";
 757     unsigned long res = 999;
 758     int err;
 759
 760     err = qemu_strtoul(str, NULL, 0, &res);
 761
 762     g_assert_cmpint(err, ==, -EINVAL);
 763 }
 764 static void test_qemu_strtoul_full_negative(void)
 765 {
 766     const char *str = " \t -321";
 767     unsigned long res = 999;
 768     int err;
 769
 770     err = qemu_strtoul(str, NULL, 0, &res);
 771     g_assert_cmpint(err, ==, 0);
 772     g_assert_cmpint(res, ==, -321ul);
 773 }
 774
 775 static void test_qemu_strtoul_full_trailing(void)
 776 {
 777     const char *str = "123xxx";
 778     unsigned long res;
 779     int err;
 780
 781     err = qemu_strtoul(str, NULL, 0, &res);
 782
 783     g_assert_cmpint(err, ==, -EINVAL);
 784 }
 785
 786 static void test_qemu_strtoul_full_max(void)
 787 {
 788     char *str = g_strdup_printf("%lu", ULONG_MAX);
 789     unsigned long res = 999;
 790     int err;
 791
 792     err = qemu_strtoul(str, NULL, 0, &res);
 793
 794     g_assert_cmpint(err, ==, 0);
 795     g_assert_cmpint(res, ==, ULONG_MAX);
 796     g_free(str);
 797 }
 798
 799 static void test_qemu_strtoll_correct(void)
 800 {
 801     const char *str = "12345 foo";
 802     char f = 'X';
 803     const char *endptr = &f;
 804     int64_t res = 999;
 805     int err;
 806
 807     err = qemu_strtoll(str, &endptr, 0, &res);
 808
 809     g_assert_cmpint(err, ==, 0);
 810     g_assert_cmpint(res, ==, 12345);
 811     g_assert(endptr == str + 5);
 812 }
 813
 814 static void test_qemu_strtoll_null(void)
 815 {
 816     char f = 'X';
 817     const char *endptr = &f;
 818     int64_t res = 999;
 819     int err;
 820
 821     err = qemu_strtoll(NULL, &endptr, 0, &res);
 822
 823     g_assert_cmpint(err, ==, -EINVAL);
 824     g_assert(endptr == NULL);
 825 }
 826
 827 static void test_qemu_strtoll_empty(void)
 828 {
 829     const char *str = "";
 830     char f = 'X';
 831     const char *endptr = &f;
 832     int64_t res = 999;
 833     int err;
 834
 835     err = qemu_strtoll(str, &endptr, 0, &res);
 836
 837     g_assert_cmpint(err, ==, -EINVAL);
 838     g_assert(endptr == str);
 839 }
 840
 841 static void test_qemu_strtoll_whitespace(void)
 842 {
 843     const char *str = "  \t  ";
 844     char f = 'X';
 845     const char *endptr = &f;
 846     int64_t res = 999;
 847     int err;
 848
 849     err = qemu_strtoll(str, &endptr, 0, &res);
 850
 851     g_assert_cmpint(err, ==, -EINVAL);
 852     g_assert(endptr == str);
 853 }
 854
 855 static void test_qemu_strtoll_invalid(void)
 856 {
 857     const char *str = "   xxxx  \t abc";
 858     char f = 'X';
 859     const char *endptr = &f;
 860     int64_t res = 999;
 861     int err;
 862
 863     err = qemu_strtoll(str, &endptr, 0, &res);
 864
 865     g_assert_cmpint(err, ==, -EINVAL);
 866     g_assert(endptr == str);
 867 }
 868
 869 static void test_qemu_strtoll_trailing(void)
 870 {
 871     const char *str = "123xxx";
 872     char f = 'X';
 873     const char *endptr = &f;
 874     int64_t res = 999;
 875     int err;
 876
 877     err = qemu_strtoll(str, &endptr, 0, &res);
 878
 879     g_assert_cmpint(err, ==, 0);
 880     g_assert_cmpint(res, ==, 123);
 881     g_assert(endptr == str + 3);
 882 }
 883
 884 static void test_qemu_strtoll_octal(void)
 885 {
 886     const char *str = "0123";
 887     char f = 'X';
 888     const char *endptr = &f;
 889     int64_t res = 999;
 890     int err;
 891
 892     err = qemu_strtoll(str, &endptr, 8, &res);
 893
 894     g_assert_cmpint(err, ==, 0);
 895     g_assert_cmpint(res, ==, 0123);
 896     g_assert(endptr == str + strlen(str));
 897
 898     endptr = &f;
 899     res = 999;
 900     err = qemu_strtoll(str, &endptr, 0, &res);
 901
 902     g_assert_cmpint(err, ==, 0);
 903     g_assert_cmpint(res, ==, 0123);
 904     g_assert(endptr == str + strlen(str));
 905 }
 906
 907 static void test_qemu_strtoll_decimal(void)
 908 {
 909     const char *str = "0123";
 910     char f = 'X';
 911     const char *endptr = &f;
 912     int64_t res = 999;
 913     int err;
 914
 915     err = qemu_strtoll(str, &endptr, 10, &res);
 916
 917     g_assert_cmpint(err, ==, 0);
 918     g_assert_cmpint(res, ==, 123);
 919     g_assert(endptr == str + strlen(str));
 920
 921     str = "123";
 922     endptr = &f;
 923     res = 999;
 924     err = qemu_strtoll(str, &endptr, 0, &res);
 925
 926     g_assert_cmpint(err, ==, 0);
 927     g_assert_cmpint(res, ==, 123);
 928     g_assert(endptr == str + strlen(str));
 929 }
 930
 931 static void test_qemu_strtoll_hex(void)
 932 {
 933     const char *str = "0123";
 934     char f = 'X';
 935     const char *endptr = &f;
 936     int64_t res = 999;
 937     int err;
 938
 939     err = qemu_strtoll(str, &endptr, 16, &res);
 940
 941     g_assert_cmpint(err, ==, 0);
 942     g_assert_cmpint(res, ==, 0x123);
 943     g_assert(endptr == str + strlen(str));
 944
 945     str = "0x123";
 946     endptr = &f;
 947     res = 999;
 948     err = qemu_strtoll(str, &endptr, 0, &res);
 949
 950     g_assert_cmpint(err, ==, 0);
 951     g_assert_cmpint(res, ==, 0x123);
 952     g_assert(endptr == str + strlen(str));
 953 }
 954
 955 static void test_qemu_strtoll_max(void)
 956 {
 957     char *str = g_strdup_printf("%lld", LLONG_MAX);
 958     char f = 'X';
 959     const char *endptr = &f;
 960     int64_t res = 999;
 961     int err;
 962
 963     err = qemu_strtoll(str, &endptr, 0, &res);
 964
 965     g_assert_cmpint(err, ==, 0);
 966     g_assert_cmpint(res, ==, LLONG_MAX);
 967     g_assert(endptr == str + strlen(str));
 968     g_free(str);
 969 }
 970
 971 static void test_qemu_strtoll_overflow(void)
 972 {
 973     const char *str = "99999999999999999999999999999999999999999999";
 974     char f = 'X';
 975     const char *endptr = &f;
 976     int64_t res = 999;
 977     int err;
 978
 979     err = qemu_strtoll(str, &endptr, 0, &res);
 980
 981     g_assert_cmpint(err, ==, -ERANGE);
 982     g_assert_cmpint(res, ==, LLONG_MAX);
 983     g_assert(endptr == str + strlen(str));
 984 }
 985
 986 static void test_qemu_strtoll_underflow(void)
 987 {
 988     const char *str = "-99999999999999999999999999999999999999999999";
 989     char f = 'X';
 990     const char *endptr = &f;
 991     int64_t res = 999;
 992     int err;
 993
 994     err  = qemu_strtoll(str, &endptr, 0, &res);
 995
 996     g_assert_cmpint(err, ==, -ERANGE);
 997     g_assert_cmpint(res, ==, LLONG_MIN);
 998     g_assert(endptr == str + strlen(str));
 999 }
1000
1001 static void test_qemu_strtoll_negative(void)
1002 {
1003     const char *str = "  \t -321";
1004     char f = 'X';
1005     const char *endptr = &f;
1006     int64_t res = 999;
1007     int err;
1008
1009     err = qemu_strtoll(str, &endptr, 0, &res);
1010
1011     g_assert_cmpint(err, ==, 0);
1012     g_assert_cmpint(res, ==, -321);
1013     g_assert(endptr == str + strlen(str));
1014 }
1015
1016 static void test_qemu_strtoll_full_correct(void)
1017 {
1018     const char *str = "123";
1019     int64_t res = 999;
1020     int err;
1021
1022     err = qemu_strtoll(str, NULL, 0, &res);
1023
1024     g_assert_cmpint(err, ==, 0);
1025     g_assert_cmpint(res, ==, 123);
1026 }
1027
1028 static void test_qemu_strtoll_full_null(void)
1029 {
1030     int64_t res = 999;
1031     int err;
1032
1033     err = qemu_strtoll(NULL, NULL, 0, &res);
1034
1035     g_assert_cmpint(err, ==, -EINVAL);
1036 }
1037
1038 static void test_qemu_strtoll_full_empty(void)
1039 {
1040     const char *str = "";
1041     int64_t res = 999;
1042     int err;
1043
1044     err = qemu_strtoll(str, NULL, 0, &res);
1045
1046     g_assert_cmpint(err, ==, -EINVAL);
1047 }
1048
1049 static void test_qemu_strtoll_full_negative(void)
1050 {
1051     const char *str = " \t -321";
1052     int64_t res = 999;
1053     int err;
1054
1055     err = qemu_strtoll(str, NULL, 0, &res);
1056
1057     g_assert_cmpint(err, ==, 0);
1058     g_assert_cmpint(res, ==, -321);
1059 }
1060
1061 static void test_qemu_strtoll_full_trailing(void)
1062 {
1063     const char *str = "123xxx";
1064     int64_t res = 999;
1065     int err;
1066
1067     err = qemu_strtoll(str, NULL, 0, &res);
1068
1069     g_assert_cmpint(err, ==, -EINVAL);
1070 }
1071
1072 static void test_qemu_strtoll_full_max(void)
1073 {
1074
1075     char *str = g_strdup_printf("%lld", LLONG_MAX);
1076     int64_t res;
1077     int err;
1078
1079     err = qemu_strtoll(str, NULL, 0, &res);
1080
1081     g_assert_cmpint(err, ==, 0);
1082     g_assert_cmpint(res, ==, LLONG_MAX);
1083     g_free(str);
1084 }
1085
1086 static void test_qemu_strtoull_correct(void)
1087 {
1088     const char *str = "12345 foo";
1089     char f = 'X';
1090     const char *endptr = &f;
1091     uint64_t res = 999;
1092     int err;
1093
1094     err = qemu_strtoull(str, &endptr, 0, &res);
1095
1096     g_assert_cmpint(err, ==, 0);
1097     g_assert_cmpint(res, ==, 12345);
1098     g_assert(endptr == str + 5);
1099 }
1100
1101 static void test_qemu_strtoull_null(void)
1102 {
1103     char f = 'X';
1104     const char *endptr = &f;
1105     uint64_t res = 999;
1106     int err;
1107
1108     err = qemu_strtoull(NULL, &endptr, 0, &res);
1109
1110     g_assert_cmpint(err, ==, -EINVAL);
1111     g_assert(endptr == NULL);
1112 }
1113
1114 static void test_qemu_strtoull_empty(void)
1115 {
1116     const char *str = "";
1117     char f = 'X';
1118     const char *endptr = &f;
1119     uint64_t res = 999;
1120     int err;
1121
1122     err = qemu_strtoull(str, &endptr, 0, &res);
1123
1124     g_assert_cmpint(err, ==, -EINVAL);
1125     g_assert(endptr == str);
1126 }
1127
1128 static void test_qemu_strtoull_whitespace(void)
1129 {
1130     const char *str = "  \t  ";
1131     char f = 'X';
1132     const char *endptr = &f;
1133     uint64_t res = 999;
1134     int err;
1135
1136     err = qemu_strtoull(str, &endptr, 0, &res);
1137
1138     g_assert_cmpint(err, ==, -EINVAL);
1139     g_assert(endptr == str);
1140 }
1141
1142 static void test_qemu_strtoull_invalid(void)
1143 {
1144     const char *str = "   xxxx  \t abc";
1145     char f = 'X';
1146     const char *endptr = &f;
1147     uint64_t res = 999;
1148     int err;
1149
1150     err = qemu_strtoull(str, &endptr, 0, &res);
1151
1152     g_assert_cmpint(err, ==, -EINVAL);
1153     g_assert(endptr == str);
1154 }
1155
1156 static void test_qemu_strtoull_trailing(void)
1157 {
1158     const char *str = "123xxx";
1159     char f = 'X';
1160     const char *endptr = &f;
1161     uint64_t res = 999;
1162     int err;
1163
1164     err = qemu_strtoull(str, &endptr, 0, &res);
1165
1166     g_assert_cmpint(err, ==, 0);
1167     g_assert_cmpint(res, ==, 123);
1168     g_assert(endptr == str + 3);
1169 }
1170
1171 static void test_qemu_strtoull_octal(void)
1172 {
1173     const char *str = "0123";
1174     char f = 'X';
1175     const char *endptr = &f;
1176     uint64_t res = 999;
1177     int err;
1178
1179     err = qemu_strtoull(str, &endptr, 8, &res);
1180
1181     g_assert_cmpint(err, ==, 0);
1182     g_assert_cmpint(res, ==, 0123);
1183     g_assert(endptr == str + strlen(str));
1184
1185     endptr = &f;
1186     res = 999;
1187     err = qemu_strtoull(str, &endptr, 0, &res);
1188
1189     g_assert_cmpint(err, ==, 0);
1190     g_assert_cmpint(res, ==, 0123);
1191     g_assert(endptr == str + strlen(str));
1192 }
1193
1194 static void test_qemu_strtoull_decimal(void)
1195 {
1196     const char *str = "0123";
1197     char f = 'X';
1198     const char *endptr = &f;
1199     uint64_t res = 999;
1200     int err;
1201
1202     err = qemu_strtoull(str, &endptr, 10, &res);
1203
1204     g_assert_cmpint(err, ==, 0);
1205     g_assert_cmpint(res, ==, 123);
1206     g_assert(endptr == str + strlen(str));
1207
1208     str = "123";
1209     endptr = &f;
1210     res = 999;
1211     err = qemu_strtoull(str, &endptr, 0, &res);
1212
1213     g_assert_cmpint(err, ==, 0);
1214     g_assert_cmpint(res, ==, 123);
1215     g_assert(endptr == str + strlen(str));
1216 }
1217
1218 static void test_qemu_strtoull_hex(void)
1219 {
1220     const char *str = "0123";
1221     char f = 'X';
1222     const char *endptr = &f;
1223     uint64_t res = 999;
1224     int err;
1225
1226     err = qemu_strtoull(str, &endptr, 16, &res);
1227
1228     g_assert_cmpint(err, ==, 0);
1229     g_assert_cmpint(res, ==, 0x123);
1230     g_assert(endptr == str + strlen(str));
1231
1232     str = "0x123";
1233     endptr = &f;
1234     res = 999;
1235     err = qemu_strtoull(str, &endptr, 0, &res);
1236
1237     g_assert_cmpint(err, ==, 0);
1238     g_assert_cmpint(res, ==, 0x123);
1239     g_assert(endptr == str + strlen(str));
1240 }
1241
1242 static void test_qemu_strtoull_max(void)
1243 {
1244     char *str = g_strdup_printf("%llu", ULLONG_MAX);
1245     char f = 'X';
1246     const char *endptr = &f;
1247     uint64_t res = 999;
1248     int err;
1249
1250     err = qemu_strtoull(str, &endptr, 0, &res);
1251
1252     g_assert_cmpint(err, ==, 0);
1253     g_assert_cmpint(res, ==, ULLONG_MAX);
1254     g_assert(endptr == str + strlen(str));
1255     g_free(str);
1256 }
1257
1258 static void test_qemu_strtoull_overflow(void)
1259 {
1260     const char *str = "99999999999999999999999999999999999999999999";
1261     char f = 'X';
1262     const char *endptr = &f;
1263     uint64_t res = 999;
1264     int err;
1265
1266     err = qemu_strtoull(str, &endptr, 0, &res);
1267
1268     g_assert_cmpint(err, ==, -ERANGE);
1269     g_assert_cmpint(res, ==, ULLONG_MAX);
1270     g_assert(endptr == str + strlen(str));
1271 }
1272
1273 static void test_qemu_strtoull_underflow(void)
1274 {
1275     const char *str = "-99999999999999999999999999999999999999999999";
1276     char f = 'X';
1277     const char *endptr = &f;
1278     uint64_t res = 999;
1279     int err;
1280
1281     err  = qemu_strtoull(str, &endptr, 0, &res);
1282
1283     g_assert_cmpint(err, ==, -ERANGE);
1284     g_assert_cmpint(res, ==, -1);
1285     g_assert(endptr == str + strlen(str));
1286 }
1287
1288 static void test_qemu_strtoull_negative(void)
1289 {
1290     const char *str = "  \t -321";
1291     char f = 'X';
1292     const char *endptr = &f;
1293     uint64_t res = 999;
1294     int err;
1295
1296     err = qemu_strtoull(str, &endptr, 0, &res);
1297
1298     g_assert_cmpint(err, ==, 0);
1299     g_assert_cmpint(res, ==, -321);
1300     g_assert(endptr == str + strlen(str));
1301 }
1302
1303 static void test_qemu_strtoull_full_correct(void)
1304 {
1305     const char *str = "18446744073709551614";
1306     uint64_t res = 999;
1307     int err;
1308
1309     err = qemu_strtoull(str, NULL, 0, &res);
1310
1311     g_assert_cmpint(err, ==, 0);
1312     g_assert_cmpint(res, ==, 18446744073709551614LLU);
1313 }
1314
1315 static void test_qemu_strtoull_full_null(void)
1316 {
1317     uint64_t res = 999;
1318     int err;
1319
1320     err = qemu_strtoull(NULL, NULL, 0, &res);
1321
1322     g_assert_cmpint(err, ==, -EINVAL);
1323 }
1324
1325 static void test_qemu_strtoull_full_empty(void)
1326 {
1327     const char *str = "";
1328     uint64_t res = 999;
1329     int err;
1330
1331     err = qemu_strtoull(str, NULL, 0, &res);
1332
1333     g_assert_cmpint(err, ==, -EINVAL);
1334 }
1335
1336 static void test_qemu_strtoull_full_negative(void)
1337 {
1338     const char *str = " \t -321";
1339     uint64_t res = 999;
1340     int err;
1341
1342     err = qemu_strtoull(str, NULL, 0, &res);
1343
1344     g_assert_cmpint(err, ==, 0);
1345     g_assert_cmpint(res, ==, 18446744073709551295LLU);
1346 }
1347
1348 static void test_qemu_strtoull_full_trailing(void)
1349 {
1350     const char *str = "18446744073709551614xxxxxx";
1351     uint64_t res = 999;
1352     int err;
1353
1354     err = qemu_strtoull(str, NULL, 0, &res);
1355
1356     g_assert_cmpint(err, ==, -EINVAL);
1357 }
1358
1359 static void test_qemu_strtoull_full_max(void)
1360 {
1361     char *str = g_strdup_printf("%lld", ULLONG_MAX);
1362     uint64_t res = 999;
1363     int err;
1364
1365     err = qemu_strtoull(str, NULL, 0, &res);
1366
1367     g_assert_cmpint(err, ==, 0);
1368     g_assert_cmpint(res, ==, ULLONG_MAX);
1369     g_free(str);
1370 }
1371
1372 static void test_qemu_strtosz_simple(void)
1373 {
1374     const char *str = "12345M";
1375     char *endptr = NULL;
1376     int64_t res;
1377
1378     res = qemu_strtosz(str, &endptr);
1379     g_assert_cmpint(res, ==, 12345 * M_BYTE);
1380     g_assert(endptr == str + 6);
1381
1382     res = qemu_strtosz(str, NULL);
1383     g_assert_cmpint(res, ==, 12345 * M_BYTE);
1384 }
1385
1386 static void test_qemu_strtosz_units(void)
1387 {
1388     const char *none = "1";
1389     const char *b = "1B";
1390     const char *k = "1K";
1391     const char *m = "1M";
1392     const char *g = "1G";
1393     const char *t = "1T";
1394     const char *p = "1P";
1395     const char *e = "1E";
1396     int64_t res;
1397
1398     /* default is M */
1399     res = qemu_strtosz(none, NULL);
1400     g_assert_cmpint(res, ==, M_BYTE);
1401
1402     res = qemu_strtosz(b, NULL);
1403     g_assert_cmpint(res, ==, 1);
1404
1405     res = qemu_strtosz(k, NULL);
1406     g_assert_cmpint(res, ==, K_BYTE);
1407
1408     res = qemu_strtosz(m, NULL);
1409     g_assert_cmpint(res, ==, M_BYTE);
1410
1411     res = qemu_strtosz(g, NULL);
1412     g_assert_cmpint(res, ==, G_BYTE);
1413
1414     res = qemu_strtosz(t, NULL);
1415     g_assert_cmpint(res, ==, T_BYTE);
1416
1417     res = qemu_strtosz(p, NULL);
1418     g_assert_cmpint(res, ==, P_BYTE);
1419
1420     res = qemu_strtosz(e, NULL);
1421     g_assert_cmpint(res, ==, E_BYTE);
1422 }
1423
1424 static void test_qemu_strtosz_float(void)
1425 {
1426     const char *str = "12.345M";
1427     int64_t res;
1428
1429     res = qemu_strtosz(str, NULL);
1430     g_assert_cmpint(res, ==, 12.345 * M_BYTE);
1431 }
1432
1433 static void test_qemu_strtosz_erange(void)
1434 {
1435     const char *str = "10E";
1436     int64_t res;
1437
1438     res = qemu_strtosz(str, NULL);
1439     g_assert_cmpint(res, ==, -ERANGE);
1440 }
1441
1442 static void test_qemu_strtosz_suffix_unit(void)
1443 {
1444     const char *str = "12345";
1445     int64_t res;
1446
1447     res = qemu_strtosz_suffix_unit(str, NULL,
1448                                    QEMU_STRTOSZ_DEFSUFFIX_KB, 1000);
1449     g_assert_cmpint(res, ==, 12345000);
1450 }
1451
1452 int main(int argc, char **argv)
1453 {
1454     g_test_init(&argc, &argv, NULL);
1455
1456     g_test_add_func("/cutils/parse_uint/null", test_parse_uint_null);
1457     g_test_add_func("/cutils/parse_uint/empty", test_parse_uint_empty);
1458     g_test_add_func("/cutils/parse_uint/whitespace",
1459                     test_parse_uint_whitespace);
1460     g_test_add_func("/cutils/parse_uint/invalid", test_parse_uint_invalid);
1461     g_test_add_func("/cutils/parse_uint/trailing", test_parse_uint_trailing);
1462     g_test_add_func("/cutils/parse_uint/correct", test_parse_uint_correct);
1463     g_test_add_func("/cutils/parse_uint/octal", test_parse_uint_octal);
1464     g_test_add_func("/cutils/parse_uint/decimal", test_parse_uint_decimal);
1465     g_test_add_func("/cutils/parse_uint/llong_max", test_parse_uint_llong_max);
1466     g_test_add_func("/cutils/parse_uint/overflow", test_parse_uint_overflow);
1467     g_test_add_func("/cutils/parse_uint/negative", test_parse_uint_negative);
1468     g_test_add_func("/cutils/parse_uint_full/trailing",
1469                     test_parse_uint_full_trailing);
1470     g_test_add_func("/cutils/parse_uint_full/correct",
1471                     test_parse_uint_full_correct);
1472
1473     /* qemu_strtol() tests */
1474     g_test_add_func("/cutils/qemu_strtol/correct", test_qemu_strtol_correct);
1475     g_test_add_func("/cutils/qemu_strtol/null", test_qemu_strtol_null);
1476     g_test_add_func("/cutils/qemu_strtol/empty", test_qemu_strtol_empty);
1477     g_test_add_func("/cutils/qemu_strtol/whitespace",
1478                     test_qemu_strtol_whitespace);
1479     g_test_add_func("/cutils/qemu_strtol/invalid", test_qemu_strtol_invalid);
1480     g_test_add_func("/cutils/qemu_strtol/trailing", test_qemu_strtol_trailing);
1481     g_test_add_func("/cutils/qemu_strtol/octal", test_qemu_strtol_octal);
1482     g_test_add_func("/cutils/qemu_strtol/decimal", test_qemu_strtol_decimal);
1483     g_test_add_func("/cutils/qemu_strtol/hex", test_qemu_strtol_hex);
1484     g_test_add_func("/cutils/qemu_strtol/max", test_qemu_strtol_max);
1485     g_test_add_func("/cutils/qemu_strtol/overflow", test_qemu_strtol_overflow);
1486     g_test_add_func("/cutils/qemu_strtol/underflow",
1487                     test_qemu_strtol_underflow);
1488     g_test_add_func("/cutils/qemu_strtol/negative", test_qemu_strtol_negative);
1489     g_test_add_func("/cutils/qemu_strtol_full/correct",
1490                     test_qemu_strtol_full_correct);
1491     g_test_add_func("/cutils/qemu_strtol_full/null",
1492                     test_qemu_strtol_full_null);
1493     g_test_add_func("/cutils/qemu_strtol_full/empty",
1494                     test_qemu_strtol_full_empty);
1495     g_test_add_func("/cutils/qemu_strtol_full/negative",
1496                     test_qemu_strtol_full_negative);
1497     g_test_add_func("/cutils/qemu_strtol_full/trailing",
1498                     test_qemu_strtol_full_trailing);
1499     g_test_add_func("/cutils/qemu_strtol_full/max",
1500                     test_qemu_strtol_full_max);
1501
1502     /* qemu_strtoul() tests */
1503     g_test_add_func("/cutils/qemu_strtoul/correct", test_qemu_strtoul_correct);
1504     g_test_add_func("/cutils/qemu_strtoul/null", test_qemu_strtoul_null);
1505     g_test_add_func("/cutils/qemu_strtoul/empty", test_qemu_strtoul_empty);
1506     g_test_add_func("/cutils/qemu_strtoul/whitespace",
1507                     test_qemu_strtoul_whitespace);
1508     g_test_add_func("/cutils/qemu_strtoul/invalid", test_qemu_strtoul_invalid);
1509     g_test_add_func("/cutils/qemu_strtoul/trailing",
1510                     test_qemu_strtoul_trailing);
1511     g_test_add_func("/cutils/qemu_strtoul/octal", test_qemu_strtoul_octal);
1512     g_test_add_func("/cutils/qemu_strtoul/decimal", test_qemu_strtoul_decimal);
1513     g_test_add_func("/cutils/qemu_strtoul/hex", test_qemu_strtoul_hex);
1514     g_test_add_func("/cutils/qemu_strtoul/max", test_qemu_strtoul_max);
1515     g_test_add_func("/cutils/qemu_strtoul/overflow",
1516                     test_qemu_strtoul_overflow);
1517     g_test_add_func("/cutils/qemu_strtoul/underflow",
1518                     test_qemu_strtoul_underflow);
1519     g_test_add_func("/cutils/qemu_strtoul/negative",
1520                     test_qemu_strtoul_negative);
1521     g_test_add_func("/cutils/qemu_strtoul_full/correct",
1522                     test_qemu_strtoul_full_correct);
1523     g_test_add_func("/cutils/qemu_strtoul_full/null",
1524                     test_qemu_strtoul_full_null);
1525     g_test_add_func("/cutils/qemu_strtoul_full/empty",
1526                     test_qemu_strtoul_full_empty);
1527     g_test_add_func("/cutils/qemu_strtoul_full/negative",
1528                     test_qemu_strtoul_full_negative);
1529     g_test_add_func("/cutils/qemu_strtoul_full/trailing",
1530                     test_qemu_strtoul_full_trailing);
1531     g_test_add_func("/cutils/qemu_strtoul_full/max",
1532                     test_qemu_strtoul_full_max);
1533
1534     /* qemu_strtoll() tests */
1535     g_test_add_func("/cutils/qemu_strtoll/correct", test_qemu_strtoll_correct);
1536     g_test_add_func("/cutils/qemu_strtoll/null", test_qemu_strtoll_null);
1537     g_test_add_func("/cutils/qemu_strtoll/empty", test_qemu_strtoll_empty);
1538     g_test_add_func("/cutils/qemu_strtoll/whitespace",
1539                     test_qemu_strtoll_whitespace);
1540     g_test_add_func("/cutils/qemu_strtoll/invalid", test_qemu_strtoll_invalid);
1541     g_test_add_func("/cutils/qemu_strtoll/trailing",
1542                     test_qemu_strtoll_trailing);
1543     g_test_add_func("/cutils/qemu_strtoll/octal", test_qemu_strtoll_octal);
1544     g_test_add_func("/cutils/qemu_strtoll/decimal", test_qemu_strtoll_decimal);
1545     g_test_add_func("/cutils/qemu_strtoll/hex", test_qemu_strtoll_hex);
1546     g_test_add_func("/cutils/qemu_strtoll/max", test_qemu_strtoll_max);
1547     g_test_add_func("/cutils/qemu_strtoll/overflow",
1548                     test_qemu_strtoll_overflow);
1549     g_test_add_func("/cutils/qemu_strtoll/underflow",
1550                     test_qemu_strtoll_underflow);
1551     g_test_add_func("/cutils/qemu_strtoll/negative",
1552                     test_qemu_strtoll_negative);
1553     g_test_add_func("/cutils/qemu_strtoll_full/correct",
1554                     test_qemu_strtoll_full_correct);
1555     g_test_add_func("/cutils/qemu_strtoll_full/null",
1556                     test_qemu_strtoll_full_null);
1557     g_test_add_func("/cutils/qemu_strtoll_full/empty",
1558                     test_qemu_strtoll_full_empty);
1559     g_test_add_func("/cutils/qemu_strtoll_full/negative",
1560                     test_qemu_strtoll_full_negative);
1561     g_test_add_func("/cutils/qemu_strtoll_full/trailing",
1562                     test_qemu_strtoll_full_trailing);
1563     g_test_add_func("/cutils/qemu_strtoll_full/max",
1564                     test_qemu_strtoll_full_max);
1565
1566     /* qemu_strtoull() tests */
1567     g_test_add_func("/cutils/qemu_strtoull/correct",
1568                     test_qemu_strtoull_correct);
1569     g_test_add_func("/cutils/qemu_strtoull/null",
1570                     test_qemu_strtoull_null);
1571     g_test_add_func("/cutils/qemu_strtoull/empty", test_qemu_strtoull_empty);
1572     g_test_add_func("/cutils/qemu_strtoull/whitespace",
1573                     test_qemu_strtoull_whitespace);
1574     g_test_add_func("/cutils/qemu_strtoull/invalid",
1575                     test_qemu_strtoull_invalid);
1576     g_test_add_func("/cutils/qemu_strtoull/trailing",
1577                     test_qemu_strtoull_trailing);
1578     g_test_add_func("/cutils/qemu_strtoull/octal", test_qemu_strtoull_octal);
1579     g_test_add_func("/cutils/qemu_strtoull/decimal",
1580                     test_qemu_strtoull_decimal);
1581     g_test_add_func("/cutils/qemu_strtoull/hex", test_qemu_strtoull_hex);
1582     g_test_add_func("/cutils/qemu_strtoull/max", test_qemu_strtoull_max);
1583     g_test_add_func("/cutils/qemu_strtoull/overflow",
1584                     test_qemu_strtoull_overflow);
1585     g_test_add_func("/cutils/qemu_strtoull/underflow",
1586                     test_qemu_strtoull_underflow);
1587     g_test_add_func("/cutils/qemu_strtoull/negative",
1588                     test_qemu_strtoull_negative);
1589     g_test_add_func("/cutils/qemu_strtoull_full/correct",
1590                     test_qemu_strtoull_full_correct);
1591     g_test_add_func("/cutils/qemu_strtoull_full/null",
1592                     test_qemu_strtoull_full_null);
1593     g_test_add_func("/cutils/qemu_strtoull_full/empty",
1594                     test_qemu_strtoull_full_empty);
1595     g_test_add_func("/cutils/qemu_strtoull_full/negative",
1596                     test_qemu_strtoull_full_negative);
1597     g_test_add_func("/cutils/qemu_strtoull_full/trailing",
1598                     test_qemu_strtoull_full_trailing);
1599     g_test_add_func("/cutils/qemu_strtoull_full/max",
1600                     test_qemu_strtoull_full_max);
1601
1602     g_test_add_func("/cutils/strtosz/simple",
1603                     test_qemu_strtosz_simple);
1604     g_test_add_func("/cutils/strtosz/units",
1605                     test_qemu_strtosz_units);
1606     g_test_add_func("/cutils/strtosz/float",
1607                     test_qemu_strtosz_float);
1608     g_test_add_func("/cutils/strtosz/erange",
1609                     test_qemu_strtosz_erange);
1610     g_test_add_func("/cutils/strtosz/suffix-unit",
1611                     test_qemu_strtosz_suffix_unit);
1612
1613     return g_test_run();
1614 }