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 <glib.h>
  29 #include <errno.h>
  30 #include <string.h>
  31
  32 #include "qemu-common.h"
  33
  34
  35 static void test_parse_uint_null(void)
  36 {
  37     unsigned long long i = 999;
  38     char f = 'X';
  39     char *endptr = &f;
  40     int r;
  41
  42     r = parse_uint(NULL, &i, &endptr, 0);
  43
  44     g_assert_cmpint(r, ==, -EINVAL);
  45     g_assert_cmpint(i, ==, 0);
  46     g_assert(endptr == NULL);
  47 }
  48
  49 static void test_parse_uint_empty(void)
  50 {
  51     unsigned long long i = 999;
  52     char f = 'X';
  53     char *endptr = &f;
  54     const char *str = "";
  55     int r;
  56
  57     r = parse_uint(str, &i, &endptr, 0);
  58
  59     g_assert_cmpint(r, ==, -EINVAL);
  60     g_assert_cmpint(i, ==, 0);
  61     g_assert(endptr == str);
  62 }
  63
  64 static void test_parse_uint_whitespace(void)
  65 {
  66     unsigned long long i = 999;
  67     char f = 'X';
  68     char *endptr = &f;
  69     const char *str = "   \t   ";
  70     int r;
  71
  72     r = parse_uint(str, &i, &endptr, 0);
  73
  74     g_assert_cmpint(r, ==, -EINVAL);
  75     g_assert_cmpint(i, ==, 0);
  76     g_assert(endptr == str);
  77 }
  78
  79
  80 static void test_parse_uint_invalid(void)
  81 {
  82     unsigned long long i = 999;
  83     char f = 'X';
  84     char *endptr = &f;
  85     const char *str = " \t xxx";
  86     int r;
  87
  88     r = parse_uint(str, &i, &endptr, 0);
  89
  90     g_assert_cmpint(r, ==, -EINVAL);
  91     g_assert_cmpint(i, ==, 0);
  92     g_assert(endptr == str);
  93 }
  94
  95
  96 static void test_parse_uint_trailing(void)
  97 {
  98     unsigned long long i = 999;
  99     char f = 'X';
 100     char *endptr = &f;
 101     const char *str = "123xxx";
 102     int r;
 103
 104     r = parse_uint(str, &i, &endptr, 0);
 105
 106     g_assert_cmpint(r, ==, 0);
 107     g_assert_cmpint(i, ==, 123);
 108     g_assert(endptr == str + 3);
 109 }
 110
 111 static void test_parse_uint_correct(void)
 112 {
 113     unsigned long long i = 999;
 114     char f = 'X';
 115     char *endptr = &f;
 116     const char *str = "123";
 117     int r;
 118
 119     r = parse_uint(str, &i, &endptr, 0);
 120
 121     g_assert_cmpint(r, ==, 0);
 122     g_assert_cmpint(i, ==, 123);
 123     g_assert(endptr == str + strlen(str));
 124 }
 125
 126 static void test_parse_uint_octal(void)
 127 {
 128     unsigned long long i = 999;
 129     char f = 'X';
 130     char *endptr = &f;
 131     const char *str = "0123";
 132     int r;
 133
 134     r = parse_uint(str, &i, &endptr, 0);
 135
 136     g_assert_cmpint(r, ==, 0);
 137     g_assert_cmpint(i, ==, 0123);
 138     g_assert(endptr == str + strlen(str));
 139 }
 140
 141 static void test_parse_uint_decimal(void)
 142 {
 143     unsigned long long i = 999;
 144     char f = 'X';
 145     char *endptr = &f;
 146     const char *str = "0123";
 147     int r;
 148
 149     r = parse_uint(str, &i, &endptr, 10);
 150
 151     g_assert_cmpint(r, ==, 0);
 152     g_assert_cmpint(i, ==, 123);
 153     g_assert(endptr == str + strlen(str));
 154 }
 155
 156
 157 static void test_parse_uint_llong_max(void)
 158 {
 159     unsigned long long i = 999;
 160     char f = 'X';
 161     char *endptr = &f;
 162     char *str = g_strdup_printf("%llu", (unsigned long long)LLONG_MAX + 1);
 163     int r;
 164
 165     r = parse_uint(str, &i, &endptr, 0);
 166
 167     g_assert_cmpint(r, ==, 0);
 168     g_assert_cmpint(i, ==, (unsigned long long)LLONG_MAX + 1);
 169     g_assert(endptr == str + strlen(str));
 170
 171     g_free(str);
 172 }
 173
 174 static void test_parse_uint_overflow(void)
 175 {
 176     unsigned long long i = 999;
 177     char f = 'X';
 178     char *endptr = &f;
 179     const char *str = "99999999999999999999999999999999999999";
 180     int r;
 181
 182     r = parse_uint(str, &i, &endptr, 0);
 183
 184     g_assert_cmpint(r, ==, -ERANGE);
 185     g_assert_cmpint(i, ==, ULLONG_MAX);
 186     g_assert(endptr == str + strlen(str));
 187 }
 188
 189 static void test_parse_uint_negative(void)
 190 {
 191     unsigned long long i = 999;
 192     char f = 'X';
 193     char *endptr = &f;
 194     const char *str = " \t -321";
 195     int r;
 196
 197     r = parse_uint(str, &i, &endptr, 0);
 198
 199     g_assert_cmpint(r, ==, -ERANGE);
 200     g_assert_cmpint(i, ==, 0);
 201     g_assert(endptr == str + strlen(str));
 202 }
 203
 204
 205 static void test_parse_uint_full_trailing(void)
 206 {
 207     unsigned long long i = 999;
 208     const char *str = "123xxx";
 209     int r;
 210
 211     r = parse_uint_full(str, &i, 0);
 212
 213     g_assert_cmpint(r, ==, -EINVAL);
 214     g_assert_cmpint(i, ==, 0);
 215 }
 216
 217 static void test_parse_uint_full_correct(void)
 218 {
 219     unsigned long long i = 999;
 220     const char *str = "123";
 221     int r;
 222
 223     r = parse_uint_full(str, &i, 0);
 224
 225     g_assert_cmpint(r, ==, 0);
 226     g_assert_cmpint(i, ==, 123);
 227 }
 228
 229 static void test_qemu_strtol_correct(void)
 230 {
 231     const char *str = "12345 foo";
 232     char f = 'X';
 233     const char *endptr = &f;
 234     long res = 999;
 235     int err;
 236
 237     err = qemu_strtol(str, &endptr, 0, &res);
 238
 239     g_assert_cmpint(err, ==, 0);
 240     g_assert_cmpint(res, ==, 12345);
 241     g_assert(endptr == str + 5);
 242 }
 243
 244 static void test_qemu_strtol_null(void)
 245 {
 246     char f = 'X';
 247     const char *endptr = &f;
 248     long res = 999;
 249     int err;
 250
 251     err = qemu_strtol(NULL, &endptr, 0, &res);
 252
 253     g_assert_cmpint(err, ==, -EINVAL);
 254     g_assert(endptr == NULL);
 255 }
 256
 257 static void test_qemu_strtol_empty(void)
 258 {
 259     const char *str = "";
 260     char f = 'X';
 261     const char *endptr = &f;
 262     long res = 999;
 263     int err;
 264
 265     err = qemu_strtol(str, &endptr, 0, &res);
 266
 267     g_assert_cmpint(err, ==, 0);
 268     g_assert_cmpint(res, ==, 0);
 269     g_assert(endptr == str);
 270 }
 271
 272 static void test_qemu_strtol_whitespace(void)
 273 {
 274     const char *str = "  \t  ";
 275     char f = 'X';
 276     const char *endptr = &f;
 277     long res = 999;
 278     int err;
 279
 280     err = qemu_strtol(str, &endptr, 0, &res);
 281
 282     g_assert_cmpint(err, ==, 0);
 283     g_assert_cmpint(res, ==, 0);
 284     g_assert(endptr == str);
 285 }
 286
 287 static void test_qemu_strtol_invalid(void)
 288 {
 289     const char *str = "   xxxx  \t abc";
 290     char f = 'X';
 291     const char *endptr = &f;
 292     long res = 999;
 293     int err;
 294
 295     err = qemu_strtol(str, &endptr, 0, &res);
 296
 297     g_assert_cmpint(err, ==, 0);
 298     g_assert_cmpint(res, ==, 0);
 299     g_assert(endptr == str);
 300 }
 301
 302 static void test_qemu_strtol_trailing(void)
 303 {
 304     const char *str = "123xxx";
 305     char f = 'X';
 306     const char *endptr = &f;
 307     long res = 999;
 308     int err;
 309
 310     err = qemu_strtol(str, &endptr, 0, &res);
 311
 312     g_assert_cmpint(err, ==, 0);
 313     g_assert_cmpint(res, ==, 123);
 314     g_assert(endptr == str + 3);
 315 }
 316
 317 static void test_qemu_strtol_octal(void)
 318 {
 319     const char *str = "0123";
 320     char f = 'X';
 321     const char *endptr = &f;
 322     long res = 999;
 323     int err;
 324
 325     err = qemu_strtol(str, &endptr, 8, &res);
 326
 327     g_assert_cmpint(err, ==, 0);
 328     g_assert_cmpint(res, ==, 0123);
 329     g_assert(endptr == str + strlen(str));
 330
 331     res = 999;
 332     endptr = &f;
 333     err = qemu_strtol(str, &endptr, 0, &res);
 334
 335     g_assert_cmpint(err, ==, 0);
 336     g_assert_cmpint(res, ==, 0123);
 337     g_assert(endptr == str + strlen(str));
 338 }
 339
 340 static void test_qemu_strtol_decimal(void)
 341 {
 342     const char *str = "0123";
 343     char f = 'X';
 344     const char *endptr = &f;
 345     long res = 999;
 346     int err;
 347
 348     err = qemu_strtol(str, &endptr, 10, &res);
 349
 350     g_assert_cmpint(err, ==, 0);
 351     g_assert_cmpint(res, ==, 123);
 352     g_assert(endptr == str + strlen(str));
 353
 354     str = "123";
 355     res = 999;
 356     endptr = &f;
 357     err = qemu_strtol(str, &endptr, 0, &res);
 358
 359     g_assert_cmpint(err, ==, 0);
 360     g_assert_cmpint(res, ==, 123);
 361     g_assert(endptr == str + strlen(str));
 362 }
 363
 364 static void test_qemu_strtol_hex(void)
 365 {
 366     const char *str = "0123";
 367     char f = 'X';
 368     const char *endptr = &f;
 369     long res = 999;
 370     int err;
 371
 372     err = qemu_strtol(str, &endptr, 16, &res);
 373
 374     g_assert_cmpint(err, ==, 0);
 375     g_assert_cmpint(res, ==, 0x123);
 376     g_assert(endptr == str + strlen(str));
 377
 378     str = "0x123";
 379     res = 999;
 380     endptr = &f;
 381     err = qemu_strtol(str, &endptr, 0, &res);
 382
 383     g_assert_cmpint(err, ==, 0);
 384     g_assert_cmpint(res, ==, 0x123);
 385     g_assert(endptr == str + strlen(str));
 386 }
 387
 388 static void test_qemu_strtol_max(void)
 389 {
 390     const char *str = g_strdup_printf("%ld", LONG_MAX);
 391     char f = 'X';
 392     const char *endptr = &f;
 393     long res = 999;
 394     int err;
 395
 396     err = qemu_strtol(str, &endptr, 0, &res);
 397
 398     g_assert_cmpint(err, ==, 0);
 399     g_assert_cmpint(res, ==, LONG_MAX);
 400     g_assert(endptr == str + strlen(str));
 401 }
 402
 403 static void test_qemu_strtol_overflow(void)
 404 {
 405     const char *str = "99999999999999999999999999999999999999999999";
 406     char f = 'X';
 407     const char *endptr = &f;
 408     long res = 999;
 409     int err;
 410
 411     err = qemu_strtol(str, &endptr, 0, &res);
 412
 413     g_assert_cmpint(err, ==, -ERANGE);
 414     g_assert_cmpint(res, ==, LONG_MAX);
 415     g_assert(endptr == str + strlen(str));
 416 }
 417
 418 static void test_qemu_strtol_underflow(void)
 419 {
 420     const char *str = "-99999999999999999999999999999999999999999999";
 421     char f = 'X';
 422     const char *endptr = &f;
 423     long res = 999;
 424     int err;
 425
 426     err  = qemu_strtol(str, &endptr, 0, &res);
 427
 428     g_assert_cmpint(err, ==, -ERANGE);
 429     g_assert_cmpint(res, ==, LONG_MIN);
 430     g_assert(endptr == str + strlen(str));
 431 }
 432
 433 static void test_qemu_strtol_negative(void)
 434 {
 435     const char *str = "  \t -321";
 436     char f = 'X';
 437     const char *endptr = &f;
 438     long res = 999;
 439     int err;
 440
 441     err = qemu_strtol(str, &endptr, 0, &res);
 442
 443     g_assert_cmpint(err, ==, 0);
 444     g_assert_cmpint(res, ==, -321);
 445     g_assert(endptr == str + strlen(str));
 446 }
 447
 448 static void test_qemu_strtol_full_correct(void)
 449 {
 450     const char *str = "123";
 451     long res = 999;
 452     int err;
 453
 454     err = qemu_strtol(str, NULL, 0, &res);
 455
 456     g_assert_cmpint(err, ==, 0);
 457     g_assert_cmpint(res, ==, 123);
 458 }
 459
 460 static void test_qemu_strtol_full_null(void)
 461 {
 462     char f = 'X';
 463     const char *endptr = &f;
 464     long res = 999;
 465     int err;
 466
 467     err = qemu_strtol(NULL, &endptr, 0, &res);
 468
 469     g_assert_cmpint(err, ==, -EINVAL);
 470     g_assert(endptr == NULL);
 471 }
 472
 473 static void test_qemu_strtol_full_empty(void)
 474 {
 475     const char *str = "";
 476     long res = 999L;
 477     int err;
 478
 479     err =  qemu_strtol(str, NULL, 0, &res);
 480
 481     g_assert_cmpint(err, ==, 0);
 482     g_assert_cmpint(res, ==, 0);
 483 }
 484
 485 static void test_qemu_strtol_full_negative(void)
 486 {
 487     const char *str = " \t -321";
 488     long res = 999;
 489     int err;
 490
 491     err = qemu_strtol(str, NULL, 0, &res);
 492
 493     g_assert_cmpint(err, ==, 0);
 494     g_assert_cmpint(res, ==, -321);
 495 }
 496
 497 static void test_qemu_strtol_full_trailing(void)
 498 {
 499     const char *str = "123xxx";
 500     long res;
 501     int err;
 502
 503     err = qemu_strtol(str, NULL, 0, &res);
 504
 505     g_assert_cmpint(err, ==, -EINVAL);
 506 }
 507
 508 static void test_qemu_strtol_full_max(void)
 509 {
 510     const char *str = g_strdup_printf("%ld", LONG_MAX);
 511     long res;
 512     int err;
 513
 514     err = qemu_strtol(str, NULL, 0, &res);
 515
 516     g_assert_cmpint(err, ==, 0);
 517     g_assert_cmpint(res, ==, LONG_MAX);
 518 }
 519
 520 static void test_qemu_strtoul_correct(void)
 521 {
 522     const char *str = "12345 foo";
 523     char f = 'X';
 524     const char *endptr = &f;
 525     unsigned long res = 999;
 526     int err;
 527
 528     err = qemu_strtoul(str, &endptr, 0, &res);
 529
 530     g_assert_cmpint(err, ==, 0);
 531     g_assert_cmpint(res, ==, 12345);
 532     g_assert(endptr == str + 5);
 533 }
 534
 535 static void test_qemu_strtoul_null(void)
 536 {
 537     char f = 'X';
 538     const char *endptr = &f;
 539     unsigned long res = 999;
 540     int err;
 541
 542     err = qemu_strtoul(NULL, &endptr, 0, &res);
 543
 544     g_assert_cmpint(err, ==, -EINVAL);
 545     g_assert(endptr == NULL);
 546 }
 547
 548 static void test_qemu_strtoul_empty(void)
 549 {
 550     const char *str = "";
 551     char f = 'X';
 552     const char *endptr = &f;
 553     unsigned long res = 999;
 554     int err;
 555
 556     err = qemu_strtoul(str, &endptr, 0, &res);
 557
 558     g_assert_cmpint(err, ==, 0);
 559     g_assert_cmpint(res, ==, 0);
 560     g_assert(endptr == str);
 561 }
 562
 563 static void test_qemu_strtoul_whitespace(void)
 564 {
 565     const char *str = "  \t  ";
 566     char f = 'X';
 567     const char *endptr = &f;
 568     unsigned long res = 999;
 569     int err;
 570
 571     err = qemu_strtoul(str, &endptr, 0, &res);
 572
 573     g_assert_cmpint(err, ==, 0);
 574     g_assert_cmpint(res, ==, 0);
 575     g_assert(endptr == str);
 576 }
 577
 578 static void test_qemu_strtoul_invalid(void)
 579 {
 580     const char *str = "   xxxx  \t abc";
 581     char f = 'X';
 582     const char *endptr = &f;
 583     unsigned long res = 999;
 584     int err;
 585
 586     err = qemu_strtoul(str, &endptr, 0, &res);
 587
 588     g_assert_cmpint(err, ==, 0);
 589     g_assert(endptr == str);
 590 }
 591
 592 static void test_qemu_strtoul_trailing(void)
 593 {
 594     const char *str = "123xxx";
 595     char f = 'X';
 596     const char *endptr = &f;
 597     unsigned long res = 999;
 598     int err;
 599
 600     err = qemu_strtoul(str, &endptr, 0, &res);
 601
 602     g_assert_cmpint(err, ==, 0);
 603     g_assert_cmpint(res, ==, 123);
 604     g_assert(endptr == str + 3);
 605 }
 606
 607 static void test_qemu_strtoul_octal(void)
 608 {
 609     const char *str = "0123";
 610     char f = 'X';
 611     const char *endptr = &f;
 612     unsigned long res = 999;
 613     int err;
 614
 615     err = qemu_strtoul(str, &endptr, 8, &res);
 616
 617     g_assert_cmpint(err, ==, 0);
 618     g_assert_cmpint(res, ==, 0123);
 619     g_assert(endptr == str + strlen(str));
 620
 621     res = 999;
 622     endptr = &f;
 623     err = qemu_strtoul(str, &endptr, 0, &res);
 624
 625     g_assert_cmpint(err, ==, 0);
 626     g_assert_cmpint(res, ==, 0123);
 627     g_assert(endptr == str + strlen(str));
 628 }
 629
 630 static void test_qemu_strtoul_decimal(void)
 631 {
 632     const char *str = "0123";
 633     char f = 'X';
 634     const char *endptr = &f;
 635     unsigned long res = 999;
 636     int err;
 637
 638     err = qemu_strtoul(str, &endptr, 10, &res);
 639
 640     g_assert_cmpint(err, ==, 0);
 641     g_assert_cmpint(res, ==, 123);
 642     g_assert(endptr == str + strlen(str));
 643
 644     str = "123";
 645     res = 999;
 646     endptr = &f;
 647     err = qemu_strtoul(str, &endptr, 0, &res);
 648
 649     g_assert_cmpint(err, ==, 0);
 650     g_assert_cmpint(res, ==, 123);
 651     g_assert(endptr == str + strlen(str));
 652 }
 653
 654 static void test_qemu_strtoul_hex(void)
 655 {
 656     const char *str = "0123";
 657     char f = 'X';
 658     const char *endptr = &f;
 659     unsigned long res = 999;
 660     int err;
 661
 662     err = qemu_strtoul(str, &endptr, 16, &res);
 663
 664     g_assert_cmpint(err, ==, 0);
 665     g_assert_cmpint(res, ==, 0x123);
 666     g_assert(endptr == str + strlen(str));
 667
 668     str = "0x123";
 669     res = 999;
 670     endptr = &f;
 671     err = qemu_strtoul(str, &endptr, 0, &res);
 672
 673     g_assert_cmpint(err, ==, 0);
 674     g_assert_cmpint(res, ==, 0x123);
 675     g_assert(endptr == str + strlen(str));
 676 }
 677
 678 static void test_qemu_strtoul_max(void)
 679 {
 680     const char *str = g_strdup_printf("%lu", ULONG_MAX);
 681     char f = 'X';
 682     const char *endptr = &f;
 683     unsigned long res = 999;
 684     int err;
 685
 686     err = qemu_strtoul(str, &endptr, 0, &res);
 687
 688     g_assert_cmpint(err, ==, 0);
 689     g_assert_cmpint(res, ==, ULONG_MAX);
 690     g_assert(endptr == str + strlen(str));
 691 }
 692
 693 static void test_qemu_strtoul_overflow(void)
 694 {
 695     const char *str = "99999999999999999999999999999999999999999999";
 696     char f = 'X';
 697     const char *endptr = &f;
 698     unsigned long res = 999;
 699     int err;
 700
 701     err = qemu_strtoul(str, &endptr, 0, &res);
 702
 703     g_assert_cmpint(err, ==, -ERANGE);
 704     g_assert_cmpint(res, ==, ULONG_MAX);
 705     g_assert(endptr == str + strlen(str));
 706 }
 707
 708 static void test_qemu_strtoul_underflow(void)
 709 {
 710     const char *str = "-99999999999999999999999999999999999999999999";
 711     char f = 'X';
 712     const char *endptr = &f;
 713     unsigned long res = 999;
 714     int err;
 715
 716     err  = qemu_strtoul(str, &endptr, 0, &res);
 717
 718     g_assert_cmpint(err, ==, -ERANGE);
 719     g_assert_cmpint(res, ==, -1ul);
 720     g_assert(endptr == str + strlen(str));
 721 }
 722
 723 static void test_qemu_strtoul_negative(void)
 724 {
 725     const char *str = "  \t -321";
 726     char f = 'X';
 727     const char *endptr = &f;
 728     unsigned long res = 999;
 729     int err;
 730
 731     err = qemu_strtoul(str, &endptr, 0, &res);
 732
 733     g_assert_cmpint(err, ==, 0);
 734     g_assert_cmpint(res, ==, -321ul);
 735     g_assert(endptr == str + strlen(str));
 736 }
 737
 738 static void test_qemu_strtoul_full_correct(void)
 739 {
 740     const char *str = "123";
 741     unsigned long res = 999;
 742     int err;
 743
 744     err = qemu_strtoul(str, NULL, 0, &res);
 745
 746     g_assert_cmpint(err, ==, 0);
 747     g_assert_cmpint(res, ==, 123);
 748 }
 749
 750 static void test_qemu_strtoul_full_null(void)
 751 {
 752     unsigned long res = 999;
 753     int err;
 754
 755     err = qemu_strtoul(NULL, NULL, 0, &res);
 756
 757     g_assert_cmpint(err, ==, -EINVAL);
 758 }
 759
 760 static void test_qemu_strtoul_full_empty(void)
 761 {
 762     const char *str = "";
 763     unsigned long res = 999;
 764     int err;
 765
 766     err = qemu_strtoul(str, NULL, 0, &res);
 767
 768     g_assert_cmpint(err, ==, 0);
 769     g_assert_cmpint(res, ==, 0);
 770 }
 771 static void test_qemu_strtoul_full_negative(void)
 772 {
 773     const char *str = " \t -321";
 774     unsigned long res = 999;
 775     int err;
 776
 777     err = qemu_strtoul(str, NULL, 0, &res);
 778     g_assert_cmpint(err, ==, 0);
 779     g_assert_cmpint(res, ==, -321ul);
 780 }
 781
 782 static void test_qemu_strtoul_full_trailing(void)
 783 {
 784     const char *str = "123xxx";
 785     unsigned long res;
 786     int err;
 787
 788     err = qemu_strtoul(str, NULL, 0, &res);
 789
 790     g_assert_cmpint(err, ==, -EINVAL);
 791 }
 792
 793 static void test_qemu_strtoul_full_max(void)
 794 {
 795     const char *str = g_strdup_printf("%lu", ULONG_MAX);
 796     unsigned long res = 999;
 797     int err;
 798
 799     err = qemu_strtoul(str, NULL, 0, &res);
 800
 801     g_assert_cmpint(err, ==, 0);
 802     g_assert_cmpint(res, ==, ULONG_MAX);
 803 }
 804
 805 int main(int argc, char **argv)
 806 {
 807     g_test_init(&argc, &argv, NULL);
 808
 809     g_test_add_func("/cutils/parse_uint/null", test_parse_uint_null);
 810     g_test_add_func("/cutils/parse_uint/empty", test_parse_uint_empty);
 811     g_test_add_func("/cutils/parse_uint/whitespace",
 812                     test_parse_uint_whitespace);
 813     g_test_add_func("/cutils/parse_uint/invalid", test_parse_uint_invalid);
 814     g_test_add_func("/cutils/parse_uint/trailing", test_parse_uint_trailing);
 815     g_test_add_func("/cutils/parse_uint/correct", test_parse_uint_correct);
 816     g_test_add_func("/cutils/parse_uint/octal", test_parse_uint_octal);
 817     g_test_add_func("/cutils/parse_uint/decimal", test_parse_uint_decimal);
 818     g_test_add_func("/cutils/parse_uint/llong_max", test_parse_uint_llong_max);
 819     g_test_add_func("/cutils/parse_uint/overflow", test_parse_uint_overflow);
 820     g_test_add_func("/cutils/parse_uint/negative", test_parse_uint_negative);
 821     g_test_add_func("/cutils/parse_uint_full/trailing",
 822                     test_parse_uint_full_trailing);
 823     g_test_add_func("/cutils/parse_uint_full/correct",
 824                     test_parse_uint_full_correct);
 825
 826     /* qemu_strtol() tests */
 827     g_test_add_func("/cutils/qemu_strtol/correct", test_qemu_strtol_correct);
 828     g_test_add_func("/cutils/qemu_strtol/null", test_qemu_strtol_null);
 829     g_test_add_func("/cutils/qemu_strtol/empty", test_qemu_strtol_empty);
 830     g_test_add_func("/cutils/qemu_strtol/whitespace",
 831                     test_qemu_strtol_whitespace);
 832     g_test_add_func("/cutils/qemu_strtol/invalid", test_qemu_strtol_invalid);
 833     g_test_add_func("/cutils/qemu_strtol/trailing", test_qemu_strtol_trailing);
 834     g_test_add_func("/cutils/qemu_strtol/octal", test_qemu_strtol_octal);
 835     g_test_add_func("/cutils/qemu_strtol/decimal", test_qemu_strtol_decimal);
 836     g_test_add_func("/cutils/qemu_strtol/hex", test_qemu_strtol_hex);
 837     g_test_add_func("/cutils/qemu_strtol/max", test_qemu_strtol_max);
 838     g_test_add_func("/cutils/qemu_strtol/overflow", test_qemu_strtol_overflow);
 839     g_test_add_func("/cutils/qemu_strtol/underflow",
 840                     test_qemu_strtol_underflow);
 841     g_test_add_func("/cutils/qemu_strtol/negative", test_qemu_strtol_negative);
 842     g_test_add_func("/cutils/qemu_strtol_full/correct",
 843                     test_qemu_strtol_full_correct);
 844     g_test_add_func("/cutils/qemu_strtol_full/null",
 845                     test_qemu_strtol_full_null);
 846     g_test_add_func("/cutils/qemu_strtol_full/empty",
 847                     test_qemu_strtol_full_empty);
 848     g_test_add_func("/cutils/qemu_strtol_full/negative",
 849                     test_qemu_strtol_full_negative);
 850     g_test_add_func("/cutils/qemu_strtol_full/trailing",
 851                     test_qemu_strtol_full_trailing);
 852     g_test_add_func("/cutils/qemu_strtol_full/max",
 853                     test_qemu_strtol_full_max);
 854
 855     /* qemu_strtoul() tests */
 856     g_test_add_func("/cutils/qemu_strtoul/correct", test_qemu_strtoul_correct);
 857     g_test_add_func("/cutils/qemu_strtoul/null", test_qemu_strtoul_null);
 858     g_test_add_func("/cutils/qemu_strtoul/empty", test_qemu_strtoul_empty);
 859     g_test_add_func("/cutils/qemu_strtoul/whitespace",
 860                     test_qemu_strtoul_whitespace);
 861     g_test_add_func("/cutils/qemu_strtoul/invalid", test_qemu_strtoul_invalid);
 862     g_test_add_func("/cutils/qemu_strtoul/trailing",
 863                     test_qemu_strtoul_trailing);
 864     g_test_add_func("/cutils/qemu_strtoul/octal", test_qemu_strtoul_octal);
 865     g_test_add_func("/cutils/qemu_strtoul/decimal", test_qemu_strtoul_decimal);
 866     g_test_add_func("/cutils/qemu_strtoul/hex", test_qemu_strtoul_hex);
 867     g_test_add_func("/cutils/qemu_strtoul/max", test_qemu_strtoul_max);
 868     g_test_add_func("/cutils/qemu_strtoul/overflow",
 869                     test_qemu_strtoul_overflow);
 870     g_test_add_func("/cutils/qemu_strtoul/underflow",
 871                     test_qemu_strtoul_underflow);
 872     g_test_add_func("/cutils/qemu_strtoul/negative",
 873                     test_qemu_strtoul_negative);
 874     g_test_add_func("/cutils/qemu_strtoul_full/correct",
 875                     test_qemu_strtoul_full_correct);
 876     g_test_add_func("/cutils/qemu_strtoul_full/null",
 877                     test_qemu_strtoul_full_null);
 878     g_test_add_func("/cutils/qemu_strtoul_full/empty",
 879                     test_qemu_strtoul_full_empty);
 880     g_test_add_func("/cutils/qemu_strtoul_full/negative",
 881                     test_qemu_strtoul_full_negative);
 882     g_test_add_func("/cutils/qemu_strtoul_full/trailing",
 883                     test_qemu_strtoul_full_trailing);
 884     g_test_add_func("/cutils/qemu_strtoul_full/max",
 885                     test_qemu_strtoul_full_max);
 886
 887     return g_test_run();
 888 }