]> git.proxmox.com Git - mirror_qemu.git/blame - tests/test-cutils.c
projects / mirror_qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
e1000: disable debug by default
[mirror_qemu.git] / tests / test-cutils.c
CommitLineData
e3f9fe2d
EH		 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
681c28a3 28#include "qemu/osdep.h"
e3f9fe2d 29
f348b6d1 30#include "qemu/cutils.h"
e3f9fe2d
EH		 31
32static void test_parse_uint_null(void)
33{
34 unsigned long long i = 999;
35 char f = 'X';
36 char *endptr = &f;
37 int r;
38
39 r = parse_uint(NULL, &i, &endptr, 0);
40
41 g_assert_cmpint(r, ==, -EINVAL);
42 g_assert_cmpint(i, ==, 0);
43 g_assert(endptr == NULL);
44}
45
46static void test_parse_uint_empty(void)
47{
48 unsigned long long i = 999;
49 char f = 'X';
50 char *endptr = &f;
51 const char *str = "";
52 int r;
53
54 r = parse_uint(str, &i, &endptr, 0);
55
56 g_assert_cmpint(r, ==, -EINVAL);
57 g_assert_cmpint(i, ==, 0);
58 g_assert(endptr == str);
59}
60
61static void test_parse_uint_whitespace(void)
62{
63 unsigned long long i = 999;
64 char f = 'X';
65 char *endptr = &f;
66 const char *str = " \t ";
67 int r;
68
69 r = parse_uint(str, &i, &endptr, 0);
70
71 g_assert_cmpint(r, ==, -EINVAL);
72 g_assert_cmpint(i, ==, 0);
73 g_assert(endptr == str);
74}
75
76
77static void test_parse_uint_invalid(void)
78{
79 unsigned long long i = 999;
80 char f = 'X';
81 char *endptr = &f;
82 const char *str = " \t xxx";
83 int r;
84
85 r = parse_uint(str, &i, &endptr, 0);
86
87 g_assert_cmpint(r, ==, -EINVAL);
88 g_assert_cmpint(i, ==, 0);
89 g_assert(endptr == str);
90}
91
92
93static void test_parse_uint_trailing(void)
94{
95 unsigned long long i = 999;
96 char f = 'X';
97 char *endptr = &f;
98 const char *str = "123xxx";
99 int r;
100
101 r = parse_uint(str, &i, &endptr, 0);
102
103 g_assert_cmpint(r, ==, 0);
104 g_assert_cmpint(i, ==, 123);
105 g_assert(endptr == str + 3);
106}
107
108static void test_parse_uint_correct(void)
109{
110 unsigned long long i = 999;
111 char f = 'X';
112 char *endptr = &f;
113 const char *str = "123";
114 int r;
115
116 r = parse_uint(str, &i, &endptr, 0);
117
118 g_assert_cmpint(r, ==, 0);
119 g_assert_cmpint(i, ==, 123);
120 g_assert(endptr == str + strlen(str));
121}
122
123static void test_parse_uint_octal(void)
124{
125 unsigned long long i = 999;
126 char f = 'X';
127 char *endptr = &f;
128 const char *str = "0123";
129 int r;
130
131 r = parse_uint(str, &i, &endptr, 0);
132
133 g_assert_cmpint(r, ==, 0);
134 g_assert_cmpint(i, ==, 0123);
135 g_assert(endptr == str + strlen(str));
136}
137
138static void test_parse_uint_decimal(void)
139{
140 unsigned long long i = 999;
141 char f = 'X';
142 char *endptr = &f;
143 const char *str = "0123";
144 int r;
145
146 r = parse_uint(str, &i, &endptr, 10);
147
148 g_assert_cmpint(r, ==, 0);
149 g_assert_cmpint(i, ==, 123);
150 g_assert(endptr == str + strlen(str));
151}
152
153
154static void test_parse_uint_llong_max(void)
155{
156 unsigned long long i = 999;
157 char f = 'X';
158 char *endptr = &f;
159 char *str = g_strdup_printf("%llu", (unsigned long long)LLONG_MAX + 1);
160 int r;
161
162 r = parse_uint(str, &i, &endptr, 0);
163
164 g_assert_cmpint(r, ==, 0);
165 g_assert_cmpint(i, ==, (unsigned long long)LLONG_MAX + 1);
166 g_assert(endptr == str + strlen(str));
167
168 g_free(str);
169}
170
171static void test_parse_uint_overflow(void)
172{
173 unsigned long long i = 999;
174 char f = 'X';
175 char *endptr = &f;
176 const char *str = "99999999999999999999999999999999999999";
177 int r;
178
179 r = parse_uint(str, &i, &endptr, 0);
180
181 g_assert_cmpint(r, ==, -ERANGE);
182 g_assert_cmpint(i, ==, ULLONG_MAX);
183 g_assert(endptr == str + strlen(str));
184}
185
186static void test_parse_uint_negative(void)
187{
188 unsigned long long i = 999;
189 char f = 'X';
190 char *endptr = &f;
191 const char *str = " \t -321";
192 int r;
193
194 r = parse_uint(str, &i, &endptr, 0);
195
196 g_assert_cmpint(r, ==, -ERANGE);
197 g_assert_cmpint(i, ==, 0);
198 g_assert(endptr == str + strlen(str));
199}
200
201
202static void test_parse_uint_full_trailing(void)
203{
204 unsigned long long i = 999;
205 const char *str = "123xxx";
206 int r;
207
208 r = parse_uint_full(str, &i, 0);
209
210 g_assert_cmpint(r, ==, -EINVAL);
211 g_assert_cmpint(i, ==, 0);
212}
213
214static void test_parse_uint_full_correct(void)
215{
216 unsigned long long i = 999;
217 const char *str = "123";
218 int r;
219
220 r = parse_uint_full(str, &i, 0);
221
222 g_assert_cmpint(r, ==, 0);
223 g_assert_cmpint(i, ==, 123);
224}
225
764e0fa4
CT		 226static void test_qemu_strtol_correct(void)
227{
228 const char *str = "12345 foo";
229 char f = 'X';
230 const char *endptr = &f;
231 long res = 999;
232 int err;
233
234 err = qemu_strtol(str, &endptr, 0, &res);
235
236 g_assert_cmpint(err, ==, 0);
237 g_assert_cmpint(res, ==, 12345);
238 g_assert(endptr == str + 5);
239}
240
241static void test_qemu_strtol_null(void)
242{
243 char f = 'X';
244 const char *endptr = &f;
245 long res = 999;
246 int err;
247
248 err = qemu_strtol(NULL, &endptr, 0, &res);
249
250 g_assert_cmpint(err, ==, -EINVAL);
251 g_assert(endptr == NULL);
252}
253
254static void test_qemu_strtol_empty(void)
255{
256 const char *str = "";
257 char f = 'X';
258 const char *endptr = &f;
259 long res = 999;
260 int err;
261
262 err = qemu_strtol(str, &endptr, 0, &res);
263
47d4be12 264 g_assert_cmpint(err, ==, -EINVAL);
73245450 265 g_assert(endptr == str);
764e0fa4
CT		 266}
267
268static void test_qemu_strtol_whitespace(void)
269{
270 const char *str = " \t ";
271 char f = 'X';
272 const char *endptr = &f;
273 long res = 999;
274 int err;
275
276 err = qemu_strtol(str, &endptr, 0, &res);
277
47d4be12 278 g_assert_cmpint(err, ==, -EINVAL);
73245450 279 g_assert(endptr == str);
764e0fa4
CT		 280}
281
282static void test_qemu_strtol_invalid(void)
283{
284 const char *str = " xxxx \t abc";
285 char f = 'X';
286 const char *endptr = &f;
287 long res = 999;
288 int err;
289
290 err = qemu_strtol(str, &endptr, 0, &res);
291
47d4be12 292 g_assert_cmpint(err, ==, -EINVAL);
73245450 293 g_assert(endptr == str);
764e0fa4
CT		 294}
295
296static void test_qemu_strtol_trailing(void)
297{
298 const char *str = "123xxx";
299 char f = 'X';
300 const char *endptr = &f;
301 long res = 999;
302 int err;
303
304 err = qemu_strtol(str, &endptr, 0, &res);
305
306 g_assert_cmpint(err, ==, 0);
307 g_assert_cmpint(res, ==, 123);
308 g_assert(endptr == str + 3);
309}
310
311static void test_qemu_strtol_octal(void)
312{
313 const char *str = "0123";
314 char f = 'X';
315 const char *endptr = &f;
316 long res = 999;
317 int err;
318
319 err = qemu_strtol(str, &endptr, 8, &res);
320
321 g_assert_cmpint(err, ==, 0);
322 g_assert_cmpint(res, ==, 0123);
323 g_assert(endptr == str + strlen(str));
324
325 res = 999;
326 endptr = &f;
327 err = qemu_strtol(str, &endptr, 0, &res);
328
329 g_assert_cmpint(err, ==, 0);
330 g_assert_cmpint(res, ==, 0123);
331 g_assert(endptr == str + strlen(str));
332}
333
334static void test_qemu_strtol_decimal(void)
335{
336 const char *str = "0123";
337 char f = 'X';
338 const char *endptr = &f;
339 long res = 999;
340 int err;
341
342 err = qemu_strtol(str, &endptr, 10, &res);
343
344 g_assert_cmpint(err, ==, 0);
345 g_assert_cmpint(res, ==, 123);
346 g_assert(endptr == str + strlen(str));
347
348 str = "123";
349 res = 999;
350 endptr = &f;
351 err = qemu_strtol(str, &endptr, 0, &res);
352
353 g_assert_cmpint(err, ==, 0);
354 g_assert_cmpint(res, ==, 123);
355 g_assert(endptr == str + strlen(str));
356}
357
358static void test_qemu_strtol_hex(void)
359{
360 const char *str = "0123";
361 char f = 'X';
362 const char *endptr = &f;
363 long res = 999;
364 int err;
365
366 err = qemu_strtol(str, &endptr, 16, &res);
367
368 g_assert_cmpint(err, ==, 0);
369 g_assert_cmpint(res, ==, 0x123);
370 g_assert(endptr == str + strlen(str));
371
372 str = "0x123";
373 res = 999;
374 endptr = &f;
375 err = qemu_strtol(str, &endptr, 0, &res);
376
377 g_assert_cmpint(err, ==, 0);
378 g_assert_cmpint(res, ==, 0x123);
379 g_assert(endptr == str + strlen(str));
380}
381
382static void test_qemu_strtol_max(void)
383{
d6f723b5 384 char *str = g_strdup_printf("%ld", LONG_MAX);
764e0fa4
CT		 385 char f = 'X';
386 const char *endptr = &f;
387 long res = 999;
388 int err;
389
390 err = qemu_strtol(str, &endptr, 0, &res);
391
392 g_assert_cmpint(err, ==, 0);
393 g_assert_cmpint(res, ==, LONG_MAX);
394 g_assert(endptr == str + strlen(str));
d6f723b5 395 g_free(str);
764e0fa4
CT		 396}
397
398static void test_qemu_strtol_overflow(void)
399{
400 const char *str = "99999999999999999999999999999999999999999999";
401 char f = 'X';
402 const char *endptr = &f;
403 long res = 999;
404 int err;
405
406 err = qemu_strtol(str, &endptr, 0, &res);
407
408 g_assert_cmpint(err, ==, -ERANGE);
409 g_assert_cmpint(res, ==, LONG_MAX);
410 g_assert(endptr == str + strlen(str));
411}
412
413static void test_qemu_strtol_underflow(void)
414{
415 const char *str = "-99999999999999999999999999999999999999999999";
416 char f = 'X';
417 const char *endptr = &f;
418 long res = 999;
419 int err;
420
421 err = qemu_strtol(str, &endptr, 0, &res);
422
423 g_assert_cmpint(err, ==, -ERANGE);
424 g_assert_cmpint(res, ==, LONG_MIN);
425 g_assert(endptr == str + strlen(str));
426}
427
428static void test_qemu_strtol_negative(void)
429{
430 const char *str = " \t -321";
431 char f = 'X';
432 const char *endptr = &f;
433 long res = 999;
434 int err;
435
436 err = qemu_strtol(str, &endptr, 0, &res);
437
438 g_assert_cmpint(err, ==, 0);
439 g_assert_cmpint(res, ==, -321);
440 g_assert(endptr == str + strlen(str));
441}
442
443static void test_qemu_strtol_full_correct(void)
444{
445 const char *str = "123";
446 long res = 999;
447 int err;
448
449 err = qemu_strtol(str, NULL, 0, &res);
450
451 g_assert_cmpint(err, ==, 0);
452 g_assert_cmpint(res, ==, 123);
453}
454
455static void test_qemu_strtol_full_null(void)
456{
457 char f = 'X';
458 const char *endptr = &f;
459 long res = 999;
460 int err;
461
462 err = qemu_strtol(NULL, &endptr, 0, &res);
463
464 g_assert_cmpint(err, ==, -EINVAL);
465 g_assert(endptr == NULL);
466}
467
468static void test_qemu_strtol_full_empty(void)
469{
470 const char *str = "";
471 long res = 999L;
472 int err;
473
474 err = qemu_strtol(str, NULL, 0, &res);
475
47d4be12 476 g_assert_cmpint(err, ==, -EINVAL);
764e0fa4
CT		 477}
478
479static void test_qemu_strtol_full_negative(void)
480{
481 const char *str = " \t -321";
482 long res = 999;
483 int err;
484
485 err = qemu_strtol(str, NULL, 0, &res);
486
487 g_assert_cmpint(err, ==, 0);
488 g_assert_cmpint(res, ==, -321);
489}
490
491static void test_qemu_strtol_full_trailing(void)
492{
493 const char *str = "123xxx";
494 long res;
495 int err;
496
497 err = qemu_strtol(str, NULL, 0, &res);
498
499 g_assert_cmpint(err, ==, -EINVAL);
500}
501
502static void test_qemu_strtol_full_max(void)
503{
d6f723b5 504 char *str = g_strdup_printf("%ld", LONG_MAX);
764e0fa4
CT		 505 long res;
506 int err;
507
508 err = qemu_strtol(str, NULL, 0, &res);
509
510 g_assert_cmpint(err, ==, 0);
511 g_assert_cmpint(res, ==, LONG_MAX);
d6f723b5 512 g_free(str);
764e0fa4 513}
c817c015
CT		 514
515static void test_qemu_strtoul_correct(void)
516{
517 const char *str = "12345 foo";
518 char f = 'X';
519 const char *endptr = &f;
520 unsigned long res = 999;
521 int err;
522
523 err = qemu_strtoul(str, &endptr, 0, &res);
524
525 g_assert_cmpint(err, ==, 0);
bc7c08a2 526 g_assert_cmpuint(res, ==, 12345);
c817c015
CT		 527 g_assert(endptr == str + 5);
528}
529
530static void test_qemu_strtoul_null(void)
531{
532 char f = 'X';
533 const char *endptr = &f;
534 unsigned long res = 999;
535 int err;
536
537 err = qemu_strtoul(NULL, &endptr, 0, &res);
538
539 g_assert_cmpint(err, ==, -EINVAL);
540 g_assert(endptr == NULL);
541}
542
543static void test_qemu_strtoul_empty(void)
544{
545 const char *str = "";
546 char f = 'X';
547 const char *endptr = &f;
548 unsigned long res = 999;
549 int err;
550
551 err = qemu_strtoul(str, &endptr, 0, &res);
552
47d4be12 553 g_assert_cmpint(err, ==, -EINVAL);
73245450 554 g_assert(endptr == str);
c817c015
CT		 555}
556
557static void test_qemu_strtoul_whitespace(void)
558{
559 const char *str = " \t ";
560 char f = 'X';
561 const char *endptr = &f;
562 unsigned long res = 999;
563 int err;
564
565 err = qemu_strtoul(str, &endptr, 0, &res);
566
47d4be12 567 g_assert_cmpint(err, ==, -EINVAL);
73245450 568 g_assert(endptr == str);
c817c015
CT		 569}
570
571static void test_qemu_strtoul_invalid(void)
572{
573 const char *str = " xxxx \t abc";
574 char f = 'X';
575 const char *endptr = &f;
576 unsigned long res = 999;
577 int err;
578
579 err = qemu_strtoul(str, &endptr, 0, &res);
580
47d4be12 581 g_assert_cmpint(err, ==, -EINVAL);
73245450 582 g_assert(endptr == str);
c817c015
CT		 583}
584
585static void test_qemu_strtoul_trailing(void)
586{
587 const char *str = "123xxx";
588 char f = 'X';
589 const char *endptr = &f;
590 unsigned long res = 999;
591 int err;
592
593 err = qemu_strtoul(str, &endptr, 0, &res);
594
595 g_assert_cmpint(err, ==, 0);
bc7c08a2 596 g_assert_cmpuint(res, ==, 123);
c817c015
CT		 597 g_assert(endptr == str + 3);
598}
599
600static void test_qemu_strtoul_octal(void)
601{
602 const char *str = "0123";
603 char f = 'X';
604 const char *endptr = &f;
605 unsigned long res = 999;
606 int err;
607
608 err = qemu_strtoul(str, &endptr, 8, &res);
609
610 g_assert_cmpint(err, ==, 0);
bc7c08a2 611 g_assert_cmpuint(res, ==, 0123);
c817c015
CT		 612 g_assert(endptr == str + strlen(str));
613
614 res = 999;
615 endptr = &f;
616 err = qemu_strtoul(str, &endptr, 0, &res);
617
618 g_assert_cmpint(err, ==, 0);
bc7c08a2 619 g_assert_cmpuint(res, ==, 0123);
c817c015
CT		 620 g_assert(endptr == str + strlen(str));
621}
622
623static void test_qemu_strtoul_decimal(void)
624{
625 const char *str = "0123";
626 char f = 'X';
627 const char *endptr = &f;
628 unsigned long res = 999;
629 int err;
630
631 err = qemu_strtoul(str, &endptr, 10, &res);
632
633 g_assert_cmpint(err, ==, 0);
bc7c08a2 634 g_assert_cmpuint(res, ==, 123);
c817c015
CT		 635 g_assert(endptr == str + strlen(str));
636
637 str = "123";
638 res = 999;
639 endptr = &f;
640 err = qemu_strtoul(str, &endptr, 0, &res);
641
642 g_assert_cmpint(err, ==, 0);
bc7c08a2 643 g_assert_cmpuint(res, ==, 123);
c817c015
CT		 644 g_assert(endptr == str + strlen(str));
645}
646
647static void test_qemu_strtoul_hex(void)
648{
649 const char *str = "0123";
650 char f = 'X';
651 const char *endptr = &f;
652 unsigned long res = 999;
653 int err;
654
655 err = qemu_strtoul(str, &endptr, 16, &res);
656
657 g_assert_cmpint(err, ==, 0);
bc7c08a2 658 g_assert_cmphex(res, ==, 0x123);
c817c015
CT		 659 g_assert(endptr == str + strlen(str));
660
661 str = "0x123";
662 res = 999;
663 endptr = &f;
664 err = qemu_strtoul(str, &endptr, 0, &res);
665
666 g_assert_cmpint(err, ==, 0);
bc7c08a2 667 g_assert_cmphex(res, ==, 0x123);
c817c015
CT		 668 g_assert(endptr == str + strlen(str));
669}
670
671static void test_qemu_strtoul_max(void)
672{
d6f723b5 673 char *str = g_strdup_printf("%lu", ULONG_MAX);
c817c015
CT		 674 char f = 'X';
675 const char *endptr = &f;
676 unsigned long res = 999;
677 int err;
678
679 err = qemu_strtoul(str, &endptr, 0, &res);
680
681 g_assert_cmpint(err, ==, 0);
bc7c08a2 682 g_assert_cmphex(res, ==, ULONG_MAX);
c817c015 683 g_assert(endptr == str + strlen(str));
d6f723b5 684 g_free(str);
c817c015
CT		 685}
686
687static void test_qemu_strtoul_overflow(void)
688{
689 const char *str = "99999999999999999999999999999999999999999999";
690 char f = 'X';
691 const char *endptr = &f;
692 unsigned long res = 999;
693 int err;
694
695 err = qemu_strtoul(str, &endptr, 0, &res);
696
697 g_assert_cmpint(err, ==, -ERANGE);
bc7c08a2 698 g_assert_cmphex(res, ==, ULONG_MAX);
c817c015
CT		 699 g_assert(endptr == str + strlen(str));
700}
701
702static void test_qemu_strtoul_underflow(void)
703{
704 const char *str = "-99999999999999999999999999999999999999999999";
705 char f = 'X';
706 const char *endptr = &f;
707 unsigned long res = 999;
708 int err;
709
710 err = qemu_strtoul(str, &endptr, 0, &res);
711
712 g_assert_cmpint(err, ==, -ERANGE);
bc7c08a2 713 g_assert_cmpuint(res, ==, -1ul);
c817c015
CT		 714 g_assert(endptr == str + strlen(str));
715}
716
717static void test_qemu_strtoul_negative(void)
718{
719 const char *str = " \t -321";
720 char f = 'X';
721 const char *endptr = &f;
722 unsigned long res = 999;
723 int err;
724
725 err = qemu_strtoul(str, &endptr, 0, &res);
726
727 g_assert_cmpint(err, ==, 0);
bc7c08a2 728 g_assert_cmpuint(res, ==, -321ul);
c817c015
CT		 729 g_assert(endptr == str + strlen(str));
730}
731
732static void test_qemu_strtoul_full_correct(void)
733{
734 const char *str = "123";
735 unsigned long res = 999;
736 int err;
737
738 err = qemu_strtoul(str, NULL, 0, &res);
739
740 g_assert_cmpint(err, ==, 0);
bc7c08a2 741 g_assert_cmpuint(res, ==, 123);
c817c015
CT		 742}
743
744static void test_qemu_strtoul_full_null(void)
745{
746 unsigned long res = 999;
747 int err;
748
749 err = qemu_strtoul(NULL, NULL, 0, &res);
750
751 g_assert_cmpint(err, ==, -EINVAL);
752}
753
754static void test_qemu_strtoul_full_empty(void)
755{
756 const char *str = "";
757 unsigned long res = 999;
758 int err;
759
760 err = qemu_strtoul(str, NULL, 0, &res);
761
47d4be12 762 g_assert_cmpint(err, ==, -EINVAL);
c817c015
CT		 763}
764static void test_qemu_strtoul_full_negative(void)
765{
766 const char *str = " \t -321";
767 unsigned long res = 999;
768 int err;
769
770 err = qemu_strtoul(str, NULL, 0, &res);
771 g_assert_cmpint(err, ==, 0);
bc7c08a2 772 g_assert_cmpuint(res, ==, -321ul);
c817c015
CT		 773}
774
775static void test_qemu_strtoul_full_trailing(void)
776{
777 const char *str = "123xxx";
778 unsigned long res;
779 int err;
780
781 err = qemu_strtoul(str, NULL, 0, &res);
782
783 g_assert_cmpint(err, ==, -EINVAL);
784}
785
786static void test_qemu_strtoul_full_max(void)
787{
d6f723b5 788 char *str = g_strdup_printf("%lu", ULONG_MAX);
c817c015
CT		 789 unsigned long res = 999;
790 int err;
791
792 err = qemu_strtoul(str, NULL, 0, &res);
793
794 g_assert_cmpint(err, ==, 0);
bc7c08a2 795 g_assert_cmphex(res, ==, ULONG_MAX);
d6f723b5 796 g_free(str);
c817c015
CT		 797}
798
b30d1886 799static void test_qemu_strtoi64_correct(void)
8ac4df40
CT		 800{
801 const char *str = "12345 foo";
802 char f = 'X';
803 const char *endptr = &f;
804 int64_t res = 999;
805 int err;
806
b30d1886 807 err = qemu_strtoi64(str, &endptr, 0, &res);
8ac4df40
CT		 808
809 g_assert_cmpint(err, ==, 0);
810 g_assert_cmpint(res, ==, 12345);
811 g_assert(endptr == str + 5);
812}
813
b30d1886 814static void test_qemu_strtoi64_null(void)
8ac4df40
CT		 815{
816 char f = 'X';
817 const char *endptr = &f;
818 int64_t res = 999;
819 int err;
820
b30d1886 821 err = qemu_strtoi64(NULL, &endptr, 0, &res);
8ac4df40
CT		 822
823 g_assert_cmpint(err, ==, -EINVAL);
824 g_assert(endptr == NULL);
825}
826
b30d1886 827static void test_qemu_strtoi64_empty(void)
8ac4df40
CT		 828{
829 const char *str = "";
830 char f = 'X';
831 const char *endptr = &f;
832 int64_t res = 999;
833 int err;
834
b30d1886 835 err = qemu_strtoi64(str, &endptr, 0, &res);
8ac4df40 836
47d4be12 837 g_assert_cmpint(err, ==, -EINVAL);
73245450 838 g_assert(endptr == str);
8ac4df40
CT		 839}
840
b30d1886 841static void test_qemu_strtoi64_whitespace(void)
8ac4df40
CT		 842{
843 const char *str = " \t ";
844 char f = 'X';
845 const char *endptr = &f;
846 int64_t res = 999;
847 int err;
848
b30d1886 849 err = qemu_strtoi64(str, &endptr, 0, &res);
8ac4df40 850
47d4be12 851 g_assert_cmpint(err, ==, -EINVAL);
73245450 852 g_assert(endptr == str);
8ac4df40
CT		 853}
854
b30d1886 855static void test_qemu_strtoi64_invalid(void)
8ac4df40
CT		 856{
857 const char *str = " xxxx \t abc";
858 char f = 'X';
859 const char *endptr = &f;
860 int64_t res = 999;
861 int err;
862
b30d1886 863 err = qemu_strtoi64(str, &endptr, 0, &res);
8ac4df40 864
47d4be12 865 g_assert_cmpint(err, ==, -EINVAL);
73245450 866 g_assert(endptr == str);
8ac4df40
CT		 867}
868
b30d1886 869static void test_qemu_strtoi64_trailing(void)
8ac4df40
CT		 870{
871 const char *str = "123xxx";
872 char f = 'X';
873 const char *endptr = &f;
874 int64_t res = 999;
875 int err;
876
b30d1886 877 err = qemu_strtoi64(str, &endptr, 0, &res);
8ac4df40
CT		 878
879 g_assert_cmpint(err, ==, 0);
880 g_assert_cmpint(res, ==, 123);
881 g_assert(endptr == str + 3);
882}
883
b30d1886 884static void test_qemu_strtoi64_octal(void)
8ac4df40
CT		 885{
886 const char *str = "0123";
887 char f = 'X';
888 const char *endptr = &f;
889 int64_t res = 999;
890 int err;
891
b30d1886 892 err = qemu_strtoi64(str, &endptr, 8, &res);
8ac4df40
CT		 893
894 g_assert_cmpint(err, ==, 0);
895 g_assert_cmpint(res, ==, 0123);
896 g_assert(endptr == str + strlen(str));
897
898 endptr = &f;
899 res = 999;
b30d1886 900 err = qemu_strtoi64(str, &endptr, 0, &res);
8ac4df40
CT		 901
902 g_assert_cmpint(err, ==, 0);
903 g_assert_cmpint(res, ==, 0123);
904 g_assert(endptr == str + strlen(str));
905}
906
b30d1886 907static void test_qemu_strtoi64_decimal(void)
8ac4df40
CT		 908{
909 const char *str = "0123";
910 char f = 'X';
911 const char *endptr = &f;
912 int64_t res = 999;
913 int err;
914
b30d1886 915 err = qemu_strtoi64(str, &endptr, 10, &res);
8ac4df40
CT		 916
917 g_assert_cmpint(err, ==, 0);
918 g_assert_cmpint(res, ==, 123);
919 g_assert(endptr == str + strlen(str));
920
921 str = "123";
922 endptr = &f;
923 res = 999;
b30d1886 924 err = qemu_strtoi64(str, &endptr, 0, &res);
8ac4df40
CT		 925
926 g_assert_cmpint(err, ==, 0);
927 g_assert_cmpint(res, ==, 123);
928 g_assert(endptr == str + strlen(str));
929}
930
b30d1886 931static void test_qemu_strtoi64_hex(void)
8ac4df40
CT		 932{
933 const char *str = "0123";
934 char f = 'X';
935 const char *endptr = &f;
936 int64_t res = 999;
937 int err;
938
b30d1886 939 err = qemu_strtoi64(str, &endptr, 16, &res);
8ac4df40
CT		 940
941 g_assert_cmpint(err, ==, 0);
942 g_assert_cmpint(res, ==, 0x123);
943 g_assert(endptr == str + strlen(str));
944
945 str = "0x123";
946 endptr = &f;
947 res = 999;
b30d1886 948 err = qemu_strtoi64(str, &endptr, 0, &res);
8ac4df40
CT		 949
950 g_assert_cmpint(err, ==, 0);
951 g_assert_cmpint(res, ==, 0x123);
952 g_assert(endptr == str + strlen(str));
953}
954
b30d1886 955static void test_qemu_strtoi64_max(void)
8ac4df40 956{
d6f723b5 957 char *str = g_strdup_printf("%lld", LLONG_MAX);
8ac4df40
CT		 958 char f = 'X';
959 const char *endptr = &f;
960 int64_t res = 999;
961 int err;
962
b30d1886 963 err = qemu_strtoi64(str, &endptr, 0, &res);
8ac4df40
CT		 964
965 g_assert_cmpint(err, ==, 0);
966 g_assert_cmpint(res, ==, LLONG_MAX);
967 g_assert(endptr == str + strlen(str));
d6f723b5 968 g_free(str);
8ac4df40
CT		 969}
970
b30d1886 971static void test_qemu_strtoi64_overflow(void)
8ac4df40
CT		 972{
973 const char *str = "99999999999999999999999999999999999999999999";
974 char f = 'X';
975 const char *endptr = &f;
976 int64_t res = 999;
977 int err;
978
b30d1886 979 err = qemu_strtoi64(str, &endptr, 0, &res);
8ac4df40
CT		 980
981 g_assert_cmpint(err, ==, -ERANGE);
982 g_assert_cmpint(res, ==, LLONG_MAX);
983 g_assert(endptr == str + strlen(str));
984}
985
b30d1886 986static void test_qemu_strtoi64_underflow(void)
8ac4df40
CT		 987{
988 const char *str = "-99999999999999999999999999999999999999999999";
989 char f = 'X';
990 const char *endptr = &f;
991 int64_t res = 999;
992 int err;
993
b30d1886 994 err = qemu_strtoi64(str, &endptr, 0, &res);
8ac4df40
CT		 995
996 g_assert_cmpint(err, ==, -ERANGE);
997 g_assert_cmpint(res, ==, LLONG_MIN);
998 g_assert(endptr == str + strlen(str));
999}
1000
b30d1886 1001static void test_qemu_strtoi64_negative(void)
8ac4df40
CT		 1002{
1003 const char *str = " \t -321";
1004 char f = 'X';
1005 const char *endptr = &f;
1006 int64_t res = 999;
1007 int err;
1008
b30d1886 1009 err = qemu_strtoi64(str, &endptr, 0, &res);
8ac4df40
CT		 1010
1011 g_assert_cmpint(err, ==, 0);
1012 g_assert_cmpint(res, ==, -321);
1013 g_assert(endptr == str + strlen(str));
1014}
1015
b30d1886 1016static void test_qemu_strtoi64_full_correct(void)
8ac4df40
CT		 1017{
1018 const char *str = "123";
1019 int64_t res = 999;
1020 int err;
1021
b30d1886 1022 err = qemu_strtoi64(str, NULL, 0, &res);
8ac4df40
CT		 1023
1024 g_assert_cmpint(err, ==, 0);
1025 g_assert_cmpint(res, ==, 123);
1026}
1027
b30d1886 1028static void test_qemu_strtoi64_full_null(void)
8ac4df40
CT		 1029{
1030 int64_t res = 999;
1031 int err;
1032
b30d1886 1033 err = qemu_strtoi64(NULL, NULL, 0, &res);
8ac4df40
CT		 1034
1035 g_assert_cmpint(err, ==, -EINVAL);
1036}
1037
b30d1886 1038static void test_qemu_strtoi64_full_empty(void)
8ac4df40
CT		 1039{
1040 const char *str = "";
1041 int64_t res = 999;
1042 int err;
1043
b30d1886 1044 err = qemu_strtoi64(str, NULL, 0, &res);
8ac4df40 1045
47d4be12 1046 g_assert_cmpint(err, ==, -EINVAL);
8ac4df40
CT		 1047}
1048
b30d1886 1049static void test_qemu_strtoi64_full_negative(void)
8ac4df40
CT		 1050{
1051 const char *str = " \t -321";
1052 int64_t res = 999;
1053 int err;
1054
b30d1886 1055 err = qemu_strtoi64(str, NULL, 0, &res);
8ac4df40
CT		 1056
1057 g_assert_cmpint(err, ==, 0);
1058 g_assert_cmpint(res, ==, -321);
1059}
1060
b30d1886 1061static void test_qemu_strtoi64_full_trailing(void)
8ac4df40
CT		 1062{
1063 const char *str = "123xxx";
1064 int64_t res = 999;
1065 int err;
1066
b30d1886 1067 err = qemu_strtoi64(str, NULL, 0, &res);
8ac4df40
CT		 1068
1069 g_assert_cmpint(err, ==, -EINVAL);
1070}
1071
b30d1886 1072static void test_qemu_strtoi64_full_max(void)
8ac4df40
CT		 1073{
1074
d6f723b5 1075 char *str = g_strdup_printf("%lld", LLONG_MAX);
8ac4df40
CT		 1076 int64_t res;
1077 int err;
1078
b30d1886 1079 err = qemu_strtoi64(str, NULL, 0, &res);
8ac4df40
CT		 1080
1081 g_assert_cmpint(err, ==, 0);
1082 g_assert_cmpint(res, ==, LLONG_MAX);
d6f723b5 1083 g_free(str);
8ac4df40
CT		 1084}
1085
b30d1886 1086static void test_qemu_strtou64_correct(void)
3904e6bf
CT		 1087{
1088 const char *str = "12345 foo";
1089 char f = 'X';
1090 const char *endptr = &f;
1091 uint64_t res = 999;
1092 int err;
1093
b30d1886 1094 err = qemu_strtou64(str, &endptr, 0, &res);
3904e6bf
CT		 1095
1096 g_assert_cmpint(err, ==, 0);
bc7c08a2 1097 g_assert_cmpuint(res, ==, 12345);
3904e6bf
CT		 1098 g_assert(endptr == str + 5);
1099}
1100
b30d1886 1101static void test_qemu_strtou64_null(void)
3904e6bf
CT		 1102{
1103 char f = 'X';
1104 const char *endptr = &f;
1105 uint64_t res = 999;
1106 int err;
1107
b30d1886 1108 err = qemu_strtou64(NULL, &endptr, 0, &res);
3904e6bf
CT		 1109
1110 g_assert_cmpint(err, ==, -EINVAL);
1111 g_assert(endptr == NULL);
1112}
1113
b30d1886 1114static void test_qemu_strtou64_empty(void)
3904e6bf
CT		 1115{
1116 const char *str = "";
1117 char f = 'X';
1118 const char *endptr = &f;
1119 uint64_t res = 999;
1120 int err;
1121
b30d1886 1122 err = qemu_strtou64(str, &endptr, 0, &res);
3904e6bf 1123
47d4be12 1124 g_assert_cmpint(err, ==, -EINVAL);
73245450 1125 g_assert(endptr == str);
3904e6bf
CT		 1126}
1127
b30d1886 1128static void test_qemu_strtou64_whitespace(void)
3904e6bf
CT		 1129{
1130 const char *str = " \t ";
1131 char f = 'X';
1132 const char *endptr = &f;
1133 uint64_t res = 999;
1134 int err;
1135
b30d1886 1136 err = qemu_strtou64(str, &endptr, 0, &res);
3904e6bf 1137
47d4be12 1138 g_assert_cmpint(err, ==, -EINVAL);
73245450 1139 g_assert(endptr == str);
3904e6bf
CT		 1140}
1141
b30d1886 1142static void test_qemu_strtou64_invalid(void)
3904e6bf
CT		 1143{
1144 const char *str = " xxxx \t abc";
1145 char f = 'X';
1146 const char *endptr = &f;
1147 uint64_t res = 999;
1148 int err;
1149
b30d1886 1150 err = qemu_strtou64(str, &endptr, 0, &res);
3904e6bf 1151
47d4be12 1152 g_assert_cmpint(err, ==, -EINVAL);
73245450 1153 g_assert(endptr == str);
3904e6bf
CT		 1154}
1155
b30d1886 1156static void test_qemu_strtou64_trailing(void)
3904e6bf
CT		 1157{
1158 const char *str = "123xxx";
1159 char f = 'X';
1160 const char *endptr = &f;
1161 uint64_t res = 999;
1162 int err;
1163
b30d1886 1164 err = qemu_strtou64(str, &endptr, 0, &res);
3904e6bf
CT		 1165
1166 g_assert_cmpint(err, ==, 0);
bc7c08a2 1167 g_assert_cmpuint(res, ==, 123);
3904e6bf
CT		 1168 g_assert(endptr == str + 3);
1169}
1170
b30d1886 1171static void test_qemu_strtou64_octal(void)
3904e6bf
CT		 1172{
1173 const char *str = "0123";
1174 char f = 'X';
1175 const char *endptr = &f;
1176 uint64_t res = 999;
1177 int err;
1178
b30d1886 1179 err = qemu_strtou64(str, &endptr, 8, &res);
3904e6bf
CT		 1180
1181 g_assert_cmpint(err, ==, 0);
bc7c08a2 1182 g_assert_cmpuint(res, ==, 0123);
3904e6bf
CT		 1183 g_assert(endptr == str + strlen(str));
1184
1185 endptr = &f;
1186 res = 999;
b30d1886 1187 err = qemu_strtou64(str, &endptr, 0, &res);
3904e6bf
CT		 1188
1189 g_assert_cmpint(err, ==, 0);
bc7c08a2 1190 g_assert_cmpuint(res, ==, 0123);
3904e6bf
CT		 1191 g_assert(endptr == str + strlen(str));
1192}
1193
b30d1886 1194static void test_qemu_strtou64_decimal(void)
3904e6bf
CT		 1195{
1196 const char *str = "0123";
1197 char f = 'X';
1198 const char *endptr = &f;
1199 uint64_t res = 999;
1200 int err;
1201
b30d1886 1202 err = qemu_strtou64(str, &endptr, 10, &res);
3904e6bf
CT		 1203
1204 g_assert_cmpint(err, ==, 0);
bc7c08a2 1205 g_assert_cmpuint(res, ==, 123);
3904e6bf
CT		 1206 g_assert(endptr == str + strlen(str));
1207
1208 str = "123";
1209 endptr = &f;
1210 res = 999;
b30d1886 1211 err = qemu_strtou64(str, &endptr, 0, &res);
3904e6bf
CT		 1212
1213 g_assert_cmpint(err, ==, 0);
bc7c08a2 1214 g_assert_cmpuint(res, ==, 123);
3904e6bf
CT		 1215 g_assert(endptr == str + strlen(str));
1216}
1217
b30d1886 1218static void test_qemu_strtou64_hex(void)
3904e6bf
CT		 1219{
1220 const char *str = "0123";
1221 char f = 'X';
1222 const char *endptr = &f;
1223 uint64_t res = 999;
1224 int err;
1225
b30d1886 1226 err = qemu_strtou64(str, &endptr, 16, &res);
3904e6bf
CT		 1227
1228 g_assert_cmpint(err, ==, 0);
bc7c08a2 1229 g_assert_cmphex(res, ==, 0x123);
3904e6bf
CT		 1230 g_assert(endptr == str + strlen(str));
1231
1232 str = "0x123";
1233 endptr = &f;
1234 res = 999;
b30d1886 1235 err = qemu_strtou64(str, &endptr, 0, &res);
3904e6bf
CT		 1236
1237 g_assert_cmpint(err, ==, 0);
bc7c08a2 1238 g_assert_cmphex(res, ==, 0x123);
3904e6bf
CT		 1239 g_assert(endptr == str + strlen(str));
1240}
1241
b30d1886 1242static void test_qemu_strtou64_max(void)
3904e6bf 1243{
d6f723b5 1244 char *str = g_strdup_printf("%llu", ULLONG_MAX);
3904e6bf
CT		 1245 char f = 'X';
1246 const char *endptr = &f;
1247 uint64_t res = 999;
1248 int err;
1249
b30d1886 1250 err = qemu_strtou64(str, &endptr, 0, &res);
3904e6bf
CT		 1251
1252 g_assert_cmpint(err, ==, 0);
bc7c08a2 1253 g_assert_cmphex(res, ==, ULLONG_MAX);
3904e6bf 1254 g_assert(endptr == str + strlen(str));
d6f723b5 1255 g_free(str);
3904e6bf
CT		 1256}
1257
b30d1886 1258static void test_qemu_strtou64_overflow(void)
3904e6bf
CT		 1259{
1260 const char *str = "99999999999999999999999999999999999999999999";
1261 char f = 'X';
1262 const char *endptr = &f;
1263 uint64_t res = 999;
1264 int err;
1265
b30d1886 1266 err = qemu_strtou64(str, &endptr, 0, &res);
3904e6bf
CT		 1267
1268 g_assert_cmpint(err, ==, -ERANGE);
bc7c08a2 1269 g_assert_cmphex(res, ==, ULLONG_MAX);
3904e6bf
CT		 1270 g_assert(endptr == str + strlen(str));
1271}
1272
b30d1886 1273static void test_qemu_strtou64_underflow(void)
3904e6bf
CT		 1274{
1275 const char *str = "-99999999999999999999999999999999999999999999";
1276 char f = 'X';
1277 const char *endptr = &f;
1278 uint64_t res = 999;
1279 int err;
1280
b30d1886 1281 err = qemu_strtou64(str, &endptr, 0, &res);
3904e6bf
CT		 1282
1283 g_assert_cmpint(err, ==, -ERANGE);
bc7c08a2 1284 g_assert_cmphex(res, ==, -1ull);
3904e6bf
CT		 1285 g_assert(endptr == str + strlen(str));
1286}
1287
b30d1886 1288static void test_qemu_strtou64_negative(void)
3904e6bf
CT		 1289{
1290 const char *str = " \t -321";
1291 char f = 'X';
1292 const char *endptr = &f;
1293 uint64_t res = 999;
1294 int err;
1295
b30d1886 1296 err = qemu_strtou64(str, &endptr, 0, &res);
3904e6bf
CT		 1297
1298 g_assert_cmpint(err, ==, 0);
bc7c08a2 1299 g_assert_cmpuint(res, ==, -321ull);
3904e6bf
CT		 1300 g_assert(endptr == str + strlen(str));
1301}
1302
b30d1886 1303static void test_qemu_strtou64_full_correct(void)
3904e6bf
CT		 1304{
1305 const char *str = "18446744073709551614";
1306 uint64_t res = 999;
1307 int err;
1308
b30d1886 1309 err = qemu_strtou64(str, NULL, 0, &res);
3904e6bf
CT		 1310
1311 g_assert_cmpint(err, ==, 0);
bc7c08a2 1312 g_assert_cmpuint(res, ==, 18446744073709551614ull);
3904e6bf
CT		 1313}
1314
b30d1886 1315static void test_qemu_strtou64_full_null(void)
3904e6bf
CT		 1316{
1317 uint64_t res = 999;
1318 int err;
1319
b30d1886 1320 err = qemu_strtou64(NULL, NULL, 0, &res);
3904e6bf
CT		 1321
1322 g_assert_cmpint(err, ==, -EINVAL);
1323}
1324
b30d1886 1325static void test_qemu_strtou64_full_empty(void)
3904e6bf
CT		 1326{
1327 const char *str = "";
1328 uint64_t res = 999;
1329 int err;
1330
b30d1886 1331 err = qemu_strtou64(str, NULL, 0, &res);
3904e6bf 1332
47d4be12 1333 g_assert_cmpint(err, ==, -EINVAL);
3904e6bf
CT		 1334}
1335
b30d1886 1336static void test_qemu_strtou64_full_negative(void)
3904e6bf
CT		 1337{
1338 const char *str = " \t -321";
1339 uint64_t res = 999;
1340 int err;
1341
b30d1886 1342 err = qemu_strtou64(str, NULL, 0, &res);
3904e6bf
CT		 1343
1344 g_assert_cmpint(err, ==, 0);
bc7c08a2 1345 g_assert_cmpuint(res, ==, -321ull);
3904e6bf
CT		 1346}
1347
b30d1886 1348static void test_qemu_strtou64_full_trailing(void)
3904e6bf
CT		 1349{
1350 const char *str = "18446744073709551614xxxxxx";
1351 uint64_t res = 999;
1352 int err;
1353
b30d1886 1354 err = qemu_strtou64(str, NULL, 0, &res);
3904e6bf
CT		 1355
1356 g_assert_cmpint(err, ==, -EINVAL);
1357}
1358
b30d1886 1359static void test_qemu_strtou64_full_max(void)
3904e6bf 1360{
d6f723b5 1361 char *str = g_strdup_printf("%lld", ULLONG_MAX);
3904e6bf
CT		 1362 uint64_t res = 999;
1363 int err;
1364
b30d1886 1365 err = qemu_strtou64(str, NULL, 0, &res);
3904e6bf
CT		 1366
1367 g_assert_cmpint(err, ==, 0);
bc7c08a2 1368 g_assert_cmphex(res, ==, ULLONG_MAX);
d6f723b5 1369 g_free(str);
3904e6bf
CT		 1370}
1371
fe854538
MAL		 1372static void test_qemu_strtosz_simple(void)
1373{
0b742797 1374 const char *str;
fe854538 1375 char *endptr = NULL;
f17fd4fd 1376 int err;
f46bfdbf 1377 uint64_t res = 0xbaadf00d;
fe854538 1378
0b742797 1379 str = "0";
f17fd4fd
MA		 1380 err = qemu_strtosz(str, &endptr, &res);
1381 g_assert_cmpint(err, ==, 0);
0b742797
MA		 1382 g_assert_cmpint(res, ==, 0);
1383 g_assert(endptr == str + 1);
1384
dab9cc92 1385 str = "12345";
f17fd4fd
MA		 1386 err = qemu_strtosz(str, &endptr, &res);
1387 g_assert_cmpint(err, ==, 0);
dab9cc92
MA		 1388 g_assert_cmpint(res, ==, 12345);
1389 g_assert(endptr == str + 5);
fe854538 1390
f17fd4fd
MA		 1391 err = qemu_strtosz(str, NULL, &res);
1392 g_assert_cmpint(err, ==, 0);
dab9cc92 1393 g_assert_cmpint(res, ==, 12345);
0b742797
MA		 1394
1395 /* Note: precision is 53 bits since we're parsing with strtod() */
1396
1397 str = "9007199254740991"; /* 2^53-1 */
f17fd4fd
MA		 1398 err = qemu_strtosz(str, &endptr, &res);
1399 g_assert_cmpint(err, ==, 0);
0b742797
MA		 1400 g_assert_cmpint(res, ==, 0x1fffffffffffff);
1401 g_assert(endptr == str + 16);
1402
1403 str = "9007199254740992"; /* 2^53 */
f17fd4fd
MA		 1404 err = qemu_strtosz(str, &endptr, &res);
1405 g_assert_cmpint(err, ==, 0);
0b742797
MA		 1406 g_assert_cmpint(res, ==, 0x20000000000000);
1407 g_assert(endptr == str + 16);
1408
1409 str = "9007199254740993"; /* 2^53+1 */
f17fd4fd
MA		 1410 err = qemu_strtosz(str, &endptr, &res);
1411 g_assert_cmpint(err, ==, 0);
0b742797
MA		 1412 g_assert_cmpint(res, ==, 0x20000000000000); /* rounded to 53 bits */
1413 g_assert(endptr == str + 16);
1414
f46bfdbf 1415 str = "18446744073709549568"; /* 0xfffffffffffff800 (53 msbs set) */
f17fd4fd
MA		 1416 err = qemu_strtosz(str, &endptr, &res);
1417 g_assert_cmpint(err, ==, 0);
f46bfdbf
MA		 1418 g_assert_cmpint(res, ==, 0xfffffffffffff800);
1419 g_assert(endptr == str + 20);
0b742797 1420
f46bfdbf 1421 str = "18446744073709550591"; /* 0xfffffffffffffbff */
f17fd4fd
MA		 1422 err = qemu_strtosz(str, &endptr, &res);
1423 g_assert_cmpint(err, ==, 0);
f46bfdbf
MA		 1424 g_assert_cmpint(res, ==, 0xfffffffffffff800); /* rounded to 53 bits */
1425 g_assert(endptr == str + 20);
0b742797
MA		 1426
1427 /* 0x7ffffffffffffe00..0x7fffffffffffffff get rounded to
1428 * 0x8000000000000000, thus -ERANGE; see test_qemu_strtosz_erange() */
fe854538
MAL		 1429}
1430
1431static void test_qemu_strtosz_units(void)
1432{
1433 const char *none = "1";
1434 const char *b = "1B";
1435 const char *k = "1K";
1436 const char *m = "1M";
1437 const char *g = "1G";
1438 const char *t = "1T";
1439 const char *p = "1P";
1440 const char *e = "1E";
f17fd4fd 1441 int err;
019144b2 1442 char *endptr = NULL;
f46bfdbf 1443 uint64_t res = 0xbaadf00d;
fe854538
MAL		 1444
1445 /* default is M */
f17fd4fd
MA		 1446 err = qemu_strtosz_MiB(none, &endptr, &res);
1447 g_assert_cmpint(err, ==, 0);
fe854538 1448 g_assert_cmpint(res, ==, M_BYTE);
019144b2 1449 g_assert(endptr == none + 1);
fe854538 1450
f17fd4fd
MA		 1451 err = qemu_strtosz(b, &endptr, &res);
1452 g_assert_cmpint(err, ==, 0);
fe854538 1453 g_assert_cmpint(res, ==, 1);
019144b2 1454 g_assert(endptr == b + 2);
fe854538 1455
f17fd4fd
MA		 1456 err = qemu_strtosz(k, &endptr, &res);
1457 g_assert_cmpint(err, ==, 0);
fe854538 1458 g_assert_cmpint(res, ==, K_BYTE);
019144b2 1459 g_assert(endptr == k + 2);
fe854538 1460
f17fd4fd
MA		 1461 err = qemu_strtosz(m, &endptr, &res);
1462 g_assert_cmpint(err, ==, 0);
fe854538 1463 g_assert_cmpint(res, ==, M_BYTE);
019144b2 1464 g_assert(endptr == m + 2);
fe854538 1465
f17fd4fd
MA		 1466 err = qemu_strtosz(g, &endptr, &res);
1467 g_assert_cmpint(err, ==, 0);
fe854538 1468 g_assert_cmpint(res, ==, G_BYTE);
019144b2 1469 g_assert(endptr == g + 2);
fe854538 1470
f17fd4fd
MA		 1471 err = qemu_strtosz(t, &endptr, &res);
1472 g_assert_cmpint(err, ==, 0);
fe854538 1473 g_assert_cmpint(res, ==, T_BYTE);
019144b2 1474 g_assert(endptr == t + 2);
fe854538 1475
f17fd4fd
MA		 1476 err = qemu_strtosz(p, &endptr, &res);
1477 g_assert_cmpint(err, ==, 0);
fe854538 1478 g_assert_cmpint(res, ==, P_BYTE);
019144b2 1479 g_assert(endptr == p + 2);
fe854538 1480
f17fd4fd
MA		 1481 err = qemu_strtosz(e, &endptr, &res);
1482 g_assert_cmpint(err, ==, 0);
fe854538 1483 g_assert_cmpint(res, ==, E_BYTE);
019144b2 1484 g_assert(endptr == e + 2);
fe854538
MAL		 1485}
1486
1487static void test_qemu_strtosz_float(void)
1488{
1489 const char *str = "12.345M";
f17fd4fd 1490 int err;
019144b2 1491 char *endptr = NULL;
f46bfdbf 1492 uint64_t res = 0xbaadf00d;
fe854538 1493
f17fd4fd
MA		 1494 err = qemu_strtosz(str, &endptr, &res);
1495 g_assert_cmpint(err, ==, 0);
fe854538 1496 g_assert_cmpint(res, ==, 12.345 * M_BYTE);
019144b2 1497 g_assert(endptr == str + 7);
fe854538
MAL		 1498}
1499
18aec479
MA		 1500static void test_qemu_strtosz_invalid(void)
1501{
1502 const char *str;
1503 char *endptr = NULL;
f17fd4fd 1504 int err;
f46bfdbf 1505 uint64_t res = 0xbaadf00d;
18aec479
MA		 1506
1507 str = "";
f17fd4fd
MA		 1508 err = qemu_strtosz(str, &endptr, &res);
1509 g_assert_cmpint(err, ==, -EINVAL);
18aec479
MA		 1510 g_assert(endptr == str);
1511
1512 str = " \t ";
f17fd4fd
MA		 1513 err = qemu_strtosz(str, &endptr, &res);
1514 g_assert_cmpint(err, ==, -EINVAL);
18aec479
MA		 1515 g_assert(endptr == str);
1516
1517 str = "crap";
f17fd4fd
MA		 1518 err = qemu_strtosz(str, &endptr, &res);
1519 g_assert_cmpint(err, ==, -EINVAL);
18aec479
MA		 1520 g_assert(endptr == str);
1521}
1522
a6b4373f
MA		 1523static void test_qemu_strtosz_trailing(void)
1524{
1525 const char *str;
1526 char *endptr = NULL;
f17fd4fd 1527 int err;
f46bfdbf 1528 uint64_t res = 0xbaadf00d;
a6b4373f
MA		 1529
1530 str = "123xxx";
f17fd4fd 1531 err = qemu_strtosz_MiB(str, &endptr, &res);
a6b4373f
MA		 1532 g_assert_cmpint(res, ==, 123 * M_BYTE);
1533 g_assert(endptr == str + 3);
1534
f17fd4fd
MA		 1535 err = qemu_strtosz(str, NULL, &res);
1536 g_assert_cmpint(err, ==, -EINVAL);
4fcdf65a 1537
a6b4373f 1538 str = "1kiB";
f17fd4fd
MA		 1539 err = qemu_strtosz(str, &endptr, &res);
1540 g_assert_cmpint(err, ==, 0);
a6b4373f
MA		 1541 g_assert_cmpint(res, ==, 1024);
1542 g_assert(endptr == str + 2);
4fcdf65a 1543
f17fd4fd
MA		 1544 err = qemu_strtosz(str, NULL, &res);
1545 g_assert_cmpint(err, ==, -EINVAL);
a6b4373f
MA		 1546}
1547
fe854538
MAL		 1548static void test_qemu_strtosz_erange(void)
1549{
0b742797 1550 const char *str;
019144b2 1551 char *endptr = NULL;
f17fd4fd 1552 int err;
f46bfdbf 1553 uint64_t res = 0xbaadf00d;
fe854538 1554
0b742797 1555 str = "-1";
f17fd4fd
MA		 1556 err = qemu_strtosz(str, &endptr, &res);
1557 g_assert_cmpint(err, ==, -ERANGE);
0b742797
MA		 1558 g_assert(endptr == str + 2);
1559
f46bfdbf 1560 str = "18446744073709550592"; /* 0xfffffffffffffc00 */
f17fd4fd
MA		 1561 err = qemu_strtosz(str, &endptr, &res);
1562 g_assert_cmpint(err, ==, -ERANGE);
f46bfdbf 1563 g_assert(endptr == str + 20);
0b742797 1564
f46bfdbf 1565 str = "18446744073709551615"; /* 2^64-1 */
f17fd4fd
MA		 1566 err = qemu_strtosz(str, &endptr, &res);
1567 g_assert_cmpint(err, ==, -ERANGE);
f46bfdbf 1568 g_assert(endptr == str + 20);
0b742797 1569
f46bfdbf 1570 str = "18446744073709551616"; /* 2^64 */
f17fd4fd
MA		 1571 err = qemu_strtosz(str, &endptr, &res);
1572 g_assert_cmpint(err, ==, -ERANGE);
f46bfdbf 1573 g_assert(endptr == str + 20);
0b742797 1574
f46bfdbf 1575 str = "20E";
f17fd4fd
MA		 1576 err = qemu_strtosz(str, &endptr, &res);
1577 g_assert_cmpint(err, ==, -ERANGE);
019144b2 1578 g_assert(endptr == str + 3);
fe854538
MAL		 1579}
1580
d2734d26 1581static void test_qemu_strtosz_metric(void)
fe854538 1582{
d2734d26 1583 const char *str = "12345k";
f17fd4fd 1584 int err;
019144b2 1585 char *endptr = NULL;
f46bfdbf 1586 uint64_t res = 0xbaadf00d;
fe854538 1587
f17fd4fd
MA		 1588 err = qemu_strtosz_metric(str, &endptr, &res);
1589 g_assert_cmpint(err, ==, 0);
fe854538 1590 g_assert_cmpint(res, ==, 12345000);
d2734d26 1591 g_assert(endptr == str + 6);
fe854538
MAL		 1592}
1593
e3f9fe2d
EH		 1594int main(int argc, char **argv)
1595{
1596 g_test_init(&argc, &argv, NULL);
1597
1598 g_test_add_func("/cutils/parse_uint/null", test_parse_uint_null);
1599 g_test_add_func("/cutils/parse_uint/empty", test_parse_uint_empty);
1600 g_test_add_func("/cutils/parse_uint/whitespace",
1601 test_parse_uint_whitespace);
1602 g_test_add_func("/cutils/parse_uint/invalid", test_parse_uint_invalid);
1603 g_test_add_func("/cutils/parse_uint/trailing", test_parse_uint_trailing);
1604 g_test_add_func("/cutils/parse_uint/correct", test_parse_uint_correct);
1605 g_test_add_func("/cutils/parse_uint/octal", test_parse_uint_octal);
1606 g_test_add_func("/cutils/parse_uint/decimal", test_parse_uint_decimal);
1607 g_test_add_func("/cutils/parse_uint/llong_max", test_parse_uint_llong_max);
1608 g_test_add_func("/cutils/parse_uint/overflow", test_parse_uint_overflow);
1609 g_test_add_func("/cutils/parse_uint/negative", test_parse_uint_negative);
1610 g_test_add_func("/cutils/parse_uint_full/trailing",
1611 test_parse_uint_full_trailing);
1612 g_test_add_func("/cutils/parse_uint_full/correct",
1613 test_parse_uint_full_correct);
1614
764e0fa4 1615 /* qemu_strtol() tests */
b30d1886
MA		 1616 g_test_add_func("/cutils/qemu_strtol/correct",
1617 test_qemu_strtol_correct);
1618 g_test_add_func("/cutils/qemu_strtol/null",
1619 test_qemu_strtol_null);
1620 g_test_add_func("/cutils/qemu_strtol/empty",
1621 test_qemu_strtol_empty);
764e0fa4
CT		 1622 g_test_add_func("/cutils/qemu_strtol/whitespace",
1623 test_qemu_strtol_whitespace);
b30d1886
MA		 1624 g_test_add_func("/cutils/qemu_strtol/invalid",
1625 test_qemu_strtol_invalid);
1626 g_test_add_func("/cutils/qemu_strtol/trailing",
1627 test_qemu_strtol_trailing);
1628 g_test_add_func("/cutils/qemu_strtol/octal",
1629 test_qemu_strtol_octal);
1630 g_test_add_func("/cutils/qemu_strtol/decimal",
1631 test_qemu_strtol_decimal);
1632 g_test_add_func("/cutils/qemu_strtol/hex",
1633 test_qemu_strtol_hex);
1634 g_test_add_func("/cutils/qemu_strtol/max",
1635 test_qemu_strtol_max);
1636 g_test_add_func("/cutils/qemu_strtol/overflow",
1637 test_qemu_strtol_overflow);
764e0fa4
CT		 1638 g_test_add_func("/cutils/qemu_strtol/underflow",
1639 test_qemu_strtol_underflow);
b30d1886
MA		 1640 g_test_add_func("/cutils/qemu_strtol/negative",
1641 test_qemu_strtol_negative);
764e0fa4
CT		 1642 g_test_add_func("/cutils/qemu_strtol_full/correct",
1643 test_qemu_strtol_full_correct);
1644 g_test_add_func("/cutils/qemu_strtol_full/null",
1645 test_qemu_strtol_full_null);
1646 g_test_add_func("/cutils/qemu_strtol_full/empty",
1647 test_qemu_strtol_full_empty);
1648 g_test_add_func("/cutils/qemu_strtol_full/negative",
1649 test_qemu_strtol_full_negative);
1650 g_test_add_func("/cutils/qemu_strtol_full/trailing",
1651 test_qemu_strtol_full_trailing);
1652 g_test_add_func("/cutils/qemu_strtol_full/max",
1653 test_qemu_strtol_full_max);
1654
c817c015 1655 /* qemu_strtoul() tests */
b30d1886
MA		 1656 g_test_add_func("/cutils/qemu_strtoul/correct",
1657 test_qemu_strtoul_correct);
1658 g_test_add_func("/cutils/qemu_strtoul/null",
1659 test_qemu_strtoul_null);
1660 g_test_add_func("/cutils/qemu_strtoul/empty",
1661 test_qemu_strtoul_empty);
c817c015
CT		 1662 g_test_add_func("/cutils/qemu_strtoul/whitespace",
1663 test_qemu_strtoul_whitespace);
b30d1886
MA		 1664 g_test_add_func("/cutils/qemu_strtoul/invalid",
1665 test_qemu_strtoul_invalid);
c817c015
CT		 1666 g_test_add_func("/cutils/qemu_strtoul/trailing",
1667 test_qemu_strtoul_trailing);
b30d1886
MA		 1668 g_test_add_func("/cutils/qemu_strtoul/octal",
1669 test_qemu_strtoul_octal);
1670 g_test_add_func("/cutils/qemu_strtoul/decimal",
1671 test_qemu_strtoul_decimal);
1672 g_test_add_func("/cutils/qemu_strtoul/hex",
1673 test_qemu_strtoul_hex);
1674 g_test_add_func("/cutils/qemu_strtoul/max",
1675 test_qemu_strtoul_max);
c817c015
CT		 1676 g_test_add_func("/cutils/qemu_strtoul/overflow",
1677 test_qemu_strtoul_overflow);
1678 g_test_add_func("/cutils/qemu_strtoul/underflow",
1679 test_qemu_strtoul_underflow);
1680 g_test_add_func("/cutils/qemu_strtoul/negative",
1681 test_qemu_strtoul_negative);
1682 g_test_add_func("/cutils/qemu_strtoul_full/correct",
1683 test_qemu_strtoul_full_correct);
1684 g_test_add_func("/cutils/qemu_strtoul_full/null",
1685 test_qemu_strtoul_full_null);
1686 g_test_add_func("/cutils/qemu_strtoul_full/empty",
1687 test_qemu_strtoul_full_empty);
1688 g_test_add_func("/cutils/qemu_strtoul_full/negative",
1689 test_qemu_strtoul_full_negative);
1690 g_test_add_func("/cutils/qemu_strtoul_full/trailing",
1691 test_qemu_strtoul_full_trailing);
1692 g_test_add_func("/cutils/qemu_strtoul_full/max",
1693 test_qemu_strtoul_full_max);
1694
b30d1886
MA		 1695 /* qemu_strtoi64() tests */
1696 g_test_add_func("/cutils/qemu_strtoi64/correct",
1697 test_qemu_strtoi64_correct);
1698 g_test_add_func("/cutils/qemu_strtoi64/null",
1699 test_qemu_strtoi64_null);
1700 g_test_add_func("/cutils/qemu_strtoi64/empty",
1701 test_qemu_strtoi64_empty);
1702 g_test_add_func("/cutils/qemu_strtoi64/whitespace",
1703 test_qemu_strtoi64_whitespace);
1704 g_test_add_func("/cutils/qemu_strtoi64/invalid"
1705 ,
1706 test_qemu_strtoi64_invalid);
1707 g_test_add_func("/cutils/qemu_strtoi64/trailing",
1708 test_qemu_strtoi64_trailing);
1709 g_test_add_func("/cutils/qemu_strtoi64/octal",
1710 test_qemu_strtoi64_octal);
1711 g_test_add_func("/cutils/qemu_strtoi64/decimal",
1712 test_qemu_strtoi64_decimal);
1713 g_test_add_func("/cutils/qemu_strtoi64/hex",
1714 test_qemu_strtoi64_hex);
1715 g_test_add_func("/cutils/qemu_strtoi64/max",
1716 test_qemu_strtoi64_max);
1717 g_test_add_func("/cutils/qemu_strtoi64/overflow",
1718 test_qemu_strtoi64_overflow);
1719 g_test_add_func("/cutils/qemu_strtoi64/underflow",
1720 test_qemu_strtoi64_underflow);
1721 g_test_add_func("/cutils/qemu_strtoi64/negative",
1722 test_qemu_strtoi64_negative);
1723 g_test_add_func("/cutils/qemu_strtoi64_full/correct",
1724 test_qemu_strtoi64_full_correct);
1725 g_test_add_func("/cutils/qemu_strtoi64_full/null",
1726 test_qemu_strtoi64_full_null);
1727 g_test_add_func("/cutils/qemu_strtoi64_full/empty",
1728 test_qemu_strtoi64_full_empty);
1729 g_test_add_func("/cutils/qemu_strtoi64_full/negative",
1730 test_qemu_strtoi64_full_negative);
1731 g_test_add_func("/cutils/qemu_strtoi64_full/trailing",
1732 test_qemu_strtoi64_full_trailing);
1733 g_test_add_func("/cutils/qemu_strtoi64_full/max",
1734 test_qemu_strtoi64_full_max);
1735
1736 /* qemu_strtou64() tests */
1737 g_test_add_func("/cutils/qemu_strtou64/correct",
1738 test_qemu_strtou64_correct);
1739 g_test_add_func("/cutils/qemu_strtou64/null",
1740 test_qemu_strtou64_null);
1741 g_test_add_func("/cutils/qemu_strtou64/empty",
1742 test_qemu_strtou64_empty);
1743 g_test_add_func("/cutils/qemu_strtou64/whitespace",
1744 test_qemu_strtou64_whitespace);
1745 g_test_add_func("/cutils/qemu_strtou64/invalid",
1746 test_qemu_strtou64_invalid);
1747 g_test_add_func("/cutils/qemu_strtou64/trailing",
1748 test_qemu_strtou64_trailing);
1749 g_test_add_func("/cutils/qemu_strtou64/octal",
1750 test_qemu_strtou64_octal);
1751 g_test_add_func("/cutils/qemu_strtou64/decimal",
1752 test_qemu_strtou64_decimal);
1753 g_test_add_func("/cutils/qemu_strtou64/hex",
1754 test_qemu_strtou64_hex);
1755 g_test_add_func("/cutils/qemu_strtou64/max",
1756 test_qemu_strtou64_max);
1757 g_test_add_func("/cutils/qemu_strtou64/overflow",
1758 test_qemu_strtou64_overflow);
1759 g_test_add_func("/cutils/qemu_strtou64/underflow",
1760 test_qemu_strtou64_underflow);
1761 g_test_add_func("/cutils/qemu_strtou64/negative",
1762 test_qemu_strtou64_negative);
1763 g_test_add_func("/cutils/qemu_strtou64_full/correct",
1764 test_qemu_strtou64_full_correct);
1765 g_test_add_func("/cutils/qemu_strtou64_full/null",
1766 test_qemu_strtou64_full_null);
1767 g_test_add_func("/cutils/qemu_strtou64_full/empty",
1768 test_qemu_strtou64_full_empty);
1769 g_test_add_func("/cutils/qemu_strtou64_full/negative",
1770 test_qemu_strtou64_full_negative);
1771 g_test_add_func("/cutils/qemu_strtou64_full/trailing",
1772 test_qemu_strtou64_full_trailing);
1773 g_test_add_func("/cutils/qemu_strtou64_full/max",
1774 test_qemu_strtou64_full_max);
3904e6bf 1775
fe854538
MAL		 1776 g_test_add_func("/cutils/strtosz/simple",
1777 test_qemu_strtosz_simple);
1778 g_test_add_func("/cutils/strtosz/units",
1779 test_qemu_strtosz_units);
1780 g_test_add_func("/cutils/strtosz/float",
1781 test_qemu_strtosz_float);
18aec479
MA		 1782 g_test_add_func("/cutils/strtosz/invalid",
1783 test_qemu_strtosz_invalid);
a6b4373f
MA		 1784 g_test_add_func("/cutils/strtosz/trailing",
1785 test_qemu_strtosz_trailing);
fe854538
MAL		 1786 g_test_add_func("/cutils/strtosz/erange",
1787 test_qemu_strtosz_erange);
d2734d26
MA		 1788 g_test_add_func("/cutils/strtosz/metric",
1789 test_qemu_strtosz_metric);
fe854538 1790
e3f9fe2d
EH		 1791 return g_test_run();
1792}
QEMU mirror