test-cutils.c - qemu - FORK: QEMU emulator

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