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