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