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