]> git.proxmox.com Git - mirror_qemu.git/blame - tests/test-cutils.c
projects / mirror_qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
cutils: Add qemu_strtoll() wrapper
[mirror_qemu.git] / tests / test-cutils.c
CommitLineData
e3f9fe2d
EH		 1/*
2 * cutils.c unit-tests
3 *
4 * Copyright (C) 2013 Red Hat Inc.
5 *
6 * Authors:
7 * Eduardo Habkost <ehabkost@redhat.com>
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a copy
10 * of this software and associated documentation files (the "Software"), to deal
11 * in the Software without restriction, including without limitation the rights
12 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 * copies of the Software, and to permit persons to whom the Software is
14 * furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included in
17 * all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 * THE SOFTWARE.
26 */
27
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
267 g_assert_cmpint(err, ==, 0);
268 g_assert_cmpint(res, ==, 0);
269 g_assert(endptr == str);
270}
271
272static void test_qemu_strtol_whitespace(void)
273{
274 const char *str = " \t ";
275 char f = 'X';
276 const char *endptr = &f;
277 long res = 999;
278 int err;
279
280 err = qemu_strtol(str, &endptr, 0, &res);
281
282 g_assert_cmpint(err, ==, 0);
283 g_assert_cmpint(res, ==, 0);
284 g_assert(endptr == str);
285}
286
287static void test_qemu_strtol_invalid(void)
288{
289 const char *str = " xxxx \t abc";
290 char f = 'X';
291 const char *endptr = &f;
292 long res = 999;
293 int err;
294
295 err = qemu_strtol(str, &endptr, 0, &res);
296
297 g_assert_cmpint(err, ==, 0);
298 g_assert_cmpint(res, ==, 0);
299 g_assert(endptr == str);
300}
301
302static void test_qemu_strtol_trailing(void)
303{
304 const char *str = "123xxx";
305 char f = 'X';
306 const char *endptr = &f;
307 long res = 999;
308 int err;
309
310 err = qemu_strtol(str, &endptr, 0, &res);
311
312 g_assert_cmpint(err, ==, 0);
313 g_assert_cmpint(res, ==, 123);
314 g_assert(endptr == str + 3);
315}
316
317static void test_qemu_strtol_octal(void)
318{
319 const char *str = "0123";
320 char f = 'X';
321 const char *endptr = &f;
322 long res = 999;
323 int err;
324
325 err = qemu_strtol(str, &endptr, 8, &res);
326
327 g_assert_cmpint(err, ==, 0);
328 g_assert_cmpint(res, ==, 0123);
329 g_assert(endptr == str + strlen(str));
330
331 res = 999;
332 endptr = &f;
333 err = qemu_strtol(str, &endptr, 0, &res);
334
335 g_assert_cmpint(err, ==, 0);
336 g_assert_cmpint(res, ==, 0123);
337 g_assert(endptr == str + strlen(str));
338}
339
340static void test_qemu_strtol_decimal(void)
341{
342 const char *str = "0123";
343 char f = 'X';
344 const char *endptr = &f;
345 long res = 999;
346 int err;
347
348 err = qemu_strtol(str, &endptr, 10, &res);
349
350 g_assert_cmpint(err, ==, 0);
351 g_assert_cmpint(res, ==, 123);
352 g_assert(endptr == str + strlen(str));
353
354 str = "123";
355 res = 999;
356 endptr = &f;
357 err = qemu_strtol(str, &endptr, 0, &res);
358
359 g_assert_cmpint(err, ==, 0);
360 g_assert_cmpint(res, ==, 123);
361 g_assert(endptr == str + strlen(str));
362}
363
364static void test_qemu_strtol_hex(void)
365{
366 const char *str = "0123";
367 char f = 'X';
368 const char *endptr = &f;
369 long res = 999;
370 int err;
371
372 err = qemu_strtol(str, &endptr, 16, &res);
373
374 g_assert_cmpint(err, ==, 0);
375 g_assert_cmpint(res, ==, 0x123);
376 g_assert(endptr == str + strlen(str));
377
378 str = "0x123";
379 res = 999;
380 endptr = &f;
381 err = qemu_strtol(str, &endptr, 0, &res);
382
383 g_assert_cmpint(err, ==, 0);
384 g_assert_cmpint(res, ==, 0x123);
385 g_assert(endptr == str + strlen(str));
386}
387
388static void test_qemu_strtol_max(void)
389{
390 const char *str = g_strdup_printf("%ld", LONG_MAX);
391 char f = 'X';
392 const char *endptr = &f;
393 long res = 999;
394 int err;
395
396 err = qemu_strtol(str, &endptr, 0, &res);
397
398 g_assert_cmpint(err, ==, 0);
399 g_assert_cmpint(res, ==, LONG_MAX);
400 g_assert(endptr == str + strlen(str));
401}
402
403static void test_qemu_strtol_overflow(void)
404{
405 const char *str = "99999999999999999999999999999999999999999999";
406 char f = 'X';
407 const char *endptr = &f;
408 long res = 999;
409 int err;
410
411 err = qemu_strtol(str, &endptr, 0, &res);
412
413 g_assert_cmpint(err, ==, -ERANGE);
414 g_assert_cmpint(res, ==, LONG_MAX);
415 g_assert(endptr == str + strlen(str));
416}
417
418static void test_qemu_strtol_underflow(void)
419{
420 const char *str = "-99999999999999999999999999999999999999999999";
421 char f = 'X';
422 const char *endptr = &f;
423 long res = 999;
424 int err;
425
426 err = qemu_strtol(str, &endptr, 0, &res);
427
428 g_assert_cmpint(err, ==, -ERANGE);
429 g_assert_cmpint(res, ==, LONG_MIN);
430 g_assert(endptr == str + strlen(str));
431}
432
433static void test_qemu_strtol_negative(void)
434{
435 const char *str = " \t -321";
436 char f = 'X';
437 const char *endptr = &f;
438 long res = 999;
439 int err;
440
441 err = qemu_strtol(str, &endptr, 0, &res);
442
443 g_assert_cmpint(err, ==, 0);
444 g_assert_cmpint(res, ==, -321);
445 g_assert(endptr == str + strlen(str));
446}
447
448static void test_qemu_strtol_full_correct(void)
449{
450 const char *str = "123";
451 long res = 999;
452 int err;
453
454 err = qemu_strtol(str, NULL, 0, &res);
455
456 g_assert_cmpint(err, ==, 0);
457 g_assert_cmpint(res, ==, 123);
458}
459
460static void test_qemu_strtol_full_null(void)
461{
462 char f = 'X';
463 const char *endptr = &f;
464 long res = 999;
465 int err;
466
467 err = qemu_strtol(NULL, &endptr, 0, &res);
468
469 g_assert_cmpint(err, ==, -EINVAL);
470 g_assert(endptr == NULL);
471}
472
473static void test_qemu_strtol_full_empty(void)
474{
475 const char *str = "";
476 long res = 999L;
477 int err;
478
479 err = qemu_strtol(str, NULL, 0, &res);
480
481 g_assert_cmpint(err, ==, 0);
482 g_assert_cmpint(res, ==, 0);
483}
484
485static void test_qemu_strtol_full_negative(void)
486{
487 const char *str = " \t -321";
488 long res = 999;
489 int err;
490
491 err = qemu_strtol(str, NULL, 0, &res);
492
493 g_assert_cmpint(err, ==, 0);
494 g_assert_cmpint(res, ==, -321);
495}
496
497static void test_qemu_strtol_full_trailing(void)
498{
499 const char *str = "123xxx";
500 long res;
501 int err;
502
503 err = qemu_strtol(str, NULL, 0, &res);
504
505 g_assert_cmpint(err, ==, -EINVAL);
506}
507
508static void test_qemu_strtol_full_max(void)
509{
510 const char *str = g_strdup_printf("%ld", LONG_MAX);
511 long res;
512 int err;
513
514 err = qemu_strtol(str, NULL, 0, &res);
515
516 g_assert_cmpint(err, ==, 0);
517 g_assert_cmpint(res, ==, LONG_MAX);
518}
c817c015
CT		 519
520static void test_qemu_strtoul_correct(void)
521{
522 const char *str = "12345 foo";
523 char f = 'X';
524 const char *endptr = &f;
525 unsigned long res = 999;
526 int err;
527
528 err = qemu_strtoul(str, &endptr, 0, &res);
529
530 g_assert_cmpint(err, ==, 0);
531 g_assert_cmpint(res, ==, 12345);
532 g_assert(endptr == str + 5);
533}
534
535static void test_qemu_strtoul_null(void)
536{
537 char f = 'X';
538 const char *endptr = &f;
539 unsigned long res = 999;
540 int err;
541
542 err = qemu_strtoul(NULL, &endptr, 0, &res);
543
544 g_assert_cmpint(err, ==, -EINVAL);
545 g_assert(endptr == NULL);
546}
547
548static void test_qemu_strtoul_empty(void)
549{
550 const char *str = "";
551 char f = 'X';
552 const char *endptr = &f;
553 unsigned long res = 999;
554 int err;
555
556 err = qemu_strtoul(str, &endptr, 0, &res);
557
558 g_assert_cmpint(err, ==, 0);
559 g_assert_cmpint(res, ==, 0);
560 g_assert(endptr == str);
561}
562
563static void test_qemu_strtoul_whitespace(void)
564{
565 const char *str = " \t ";
566 char f = 'X';
567 const char *endptr = &f;
568 unsigned long res = 999;
569 int err;
570
571 err = qemu_strtoul(str, &endptr, 0, &res);
572
573 g_assert_cmpint(err, ==, 0);
574 g_assert_cmpint(res, ==, 0);
575 g_assert(endptr == str);
576}
577
578static void test_qemu_strtoul_invalid(void)
579{
580 const char *str = " xxxx \t abc";
581 char f = 'X';
582 const char *endptr = &f;
583 unsigned long res = 999;
584 int err;
585
586 err = qemu_strtoul(str, &endptr, 0, &res);
587
588 g_assert_cmpint(err, ==, 0);
589 g_assert(endptr == str);
590}
591
592static void test_qemu_strtoul_trailing(void)
593{
594 const char *str = "123xxx";
595 char f = 'X';
596 const char *endptr = &f;
597 unsigned long res = 999;
598 int err;
599
600 err = qemu_strtoul(str, &endptr, 0, &res);
601
602 g_assert_cmpint(err, ==, 0);
603 g_assert_cmpint(res, ==, 123);
604 g_assert(endptr == str + 3);
605}
606
607static void test_qemu_strtoul_octal(void)
608{
609 const char *str = "0123";
610 char f = 'X';
611 const char *endptr = &f;
612 unsigned long res = 999;
613 int err;
614
615 err = qemu_strtoul(str, &endptr, 8, &res);
616
617 g_assert_cmpint(err, ==, 0);
618 g_assert_cmpint(res, ==, 0123);
619 g_assert(endptr == str + strlen(str));
620
621 res = 999;
622 endptr = &f;
623 err = qemu_strtoul(str, &endptr, 0, &res);
624
625 g_assert_cmpint(err, ==, 0);
626 g_assert_cmpint(res, ==, 0123);
627 g_assert(endptr == str + strlen(str));
628}
629
630static void test_qemu_strtoul_decimal(void)
631{
632 const char *str = "0123";
633 char f = 'X';
634 const char *endptr = &f;
635 unsigned long res = 999;
636 int err;
637
638 err = qemu_strtoul(str, &endptr, 10, &res);
639
640 g_assert_cmpint(err, ==, 0);
641 g_assert_cmpint(res, ==, 123);
642 g_assert(endptr == str + strlen(str));
643
644 str = "123";
645 res = 999;
646 endptr = &f;
647 err = qemu_strtoul(str, &endptr, 0, &res);
648
649 g_assert_cmpint(err, ==, 0);
650 g_assert_cmpint(res, ==, 123);
651 g_assert(endptr == str + strlen(str));
652}
653
654static void test_qemu_strtoul_hex(void)
655{
656 const char *str = "0123";
657 char f = 'X';
658 const char *endptr = &f;
659 unsigned long res = 999;
660 int err;
661
662 err = qemu_strtoul(str, &endptr, 16, &res);
663
664 g_assert_cmpint(err, ==, 0);
665 g_assert_cmpint(res, ==, 0x123);
666 g_assert(endptr == str + strlen(str));
667
668 str = "0x123";
669 res = 999;
670 endptr = &f;
671 err = qemu_strtoul(str, &endptr, 0, &res);
672
673 g_assert_cmpint(err, ==, 0);
674 g_assert_cmpint(res, ==, 0x123);
675 g_assert(endptr == str + strlen(str));
676}
677
678static void test_qemu_strtoul_max(void)
679{
680 const char *str = g_strdup_printf("%lu", ULONG_MAX);
681 char f = 'X';
682 const char *endptr = &f;
683 unsigned long res = 999;
684 int err;
685
686 err = qemu_strtoul(str, &endptr, 0, &res);
687
688 g_assert_cmpint(err, ==, 0);
689 g_assert_cmpint(res, ==, ULONG_MAX);
690 g_assert(endptr == str + strlen(str));
691}
692
693static void test_qemu_strtoul_overflow(void)
694{
695 const char *str = "99999999999999999999999999999999999999999999";
696 char f = 'X';
697 const char *endptr = &f;
698 unsigned long res = 999;
699 int err;
700
701 err = qemu_strtoul(str, &endptr, 0, &res);
702
703 g_assert_cmpint(err, ==, -ERANGE);
704 g_assert_cmpint(res, ==, ULONG_MAX);
705 g_assert(endptr == str + strlen(str));
706}
707
708static void test_qemu_strtoul_underflow(void)
709{
710 const char *str = "-99999999999999999999999999999999999999999999";
711 char f = 'X';
712 const char *endptr = &f;
713 unsigned long res = 999;
714 int err;
715
716 err = qemu_strtoul(str, &endptr, 0, &res);
717
718 g_assert_cmpint(err, ==, -ERANGE);
719 g_assert_cmpint(res, ==, -1ul);
720 g_assert(endptr == str + strlen(str));
721}
722
723static void test_qemu_strtoul_negative(void)
724{
725 const char *str = " \t -321";
726 char f = 'X';
727 const char *endptr = &f;
728 unsigned long res = 999;
729 int err;
730
731 err = qemu_strtoul(str, &endptr, 0, &res);
732
733 g_assert_cmpint(err, ==, 0);
734 g_assert_cmpint(res, ==, -321ul);
735 g_assert(endptr == str + strlen(str));
736}
737
738static void test_qemu_strtoul_full_correct(void)
739{
740 const char *str = "123";
741 unsigned long res = 999;
742 int err;
743
744 err = qemu_strtoul(str, NULL, 0, &res);
745
746 g_assert_cmpint(err, ==, 0);
747 g_assert_cmpint(res, ==, 123);
748}
749
750static void test_qemu_strtoul_full_null(void)
751{
752 unsigned long res = 999;
753 int err;
754
755 err = qemu_strtoul(NULL, NULL, 0, &res);
756
757 g_assert_cmpint(err, ==, -EINVAL);
758}
759
760static void test_qemu_strtoul_full_empty(void)
761{
762 const char *str = "";
763 unsigned long res = 999;
764 int err;
765
766 err = qemu_strtoul(str, NULL, 0, &res);
767
768 g_assert_cmpint(err, ==, 0);
769 g_assert_cmpint(res, ==, 0);
770}
771static void test_qemu_strtoul_full_negative(void)
772{
773 const char *str = " \t -321";
774 unsigned long res = 999;
775 int err;
776
777 err = qemu_strtoul(str, NULL, 0, &res);
778 g_assert_cmpint(err, ==, 0);
779 g_assert_cmpint(res, ==, -321ul);
780}
781
782static void test_qemu_strtoul_full_trailing(void)
783{
784 const char *str = "123xxx";
785 unsigned long res;
786 int err;
787
788 err = qemu_strtoul(str, NULL, 0, &res);
789
790 g_assert_cmpint(err, ==, -EINVAL);
791}
792
793static void test_qemu_strtoul_full_max(void)
794{
795 const char *str = g_strdup_printf("%lu", ULONG_MAX);
796 unsigned long res = 999;
797 int err;
798
799 err = qemu_strtoul(str, NULL, 0, &res);
800
801 g_assert_cmpint(err, ==, 0);
802 g_assert_cmpint(res, ==, ULONG_MAX);
803}
804
8ac4df40
CT		 805static void test_qemu_strtoll_correct(void)
806{
807 const char *str = "12345 foo";
808 char f = 'X';
809 const char *endptr = &f;
810 int64_t res = 999;
811 int err;
812
813 err = qemu_strtoll(str, &endptr, 0, &res);
814
815 g_assert_cmpint(err, ==, 0);
816 g_assert_cmpint(res, ==, 12345);
817 g_assert(endptr == str + 5);
818}
819
820static void test_qemu_strtoll_null(void)
821{
822 char f = 'X';
823 const char *endptr = &f;
824 int64_t res = 999;
825 int err;
826
827 err = qemu_strtoll(NULL, &endptr, 0, &res);
828
829 g_assert_cmpint(err, ==, -EINVAL);
830 g_assert(endptr == NULL);
831}
832
833static void test_qemu_strtoll_empty(void)
834{
835 const char *str = "";
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
843 g_assert_cmpint(err, ==, 0);
844 g_assert_cmpint(res, ==, 0);
845 g_assert(endptr == str);
846}
847
848static void test_qemu_strtoll_whitespace(void)
849{
850 const char *str = " \t ";
851 char f = 'X';
852 const char *endptr = &f;
853 int64_t res = 999;
854 int err;
855
856 err = qemu_strtoll(str, &endptr, 0, &res);
857
858 g_assert_cmpint(err, ==, 0);
859 g_assert_cmpint(res, ==, 0);
860 g_assert(endptr == str);
861}
862
863static void test_qemu_strtoll_invalid(void)
864{
865 const char *str = " xxxx \t abc";
866 char f = 'X';
867 const char *endptr = &f;
868 int64_t res = 999;
869 int err;
870
871 err = qemu_strtoll(str, &endptr, 0, &res);
872
873 g_assert_cmpint(err, ==, 0);
874 g_assert(endptr == str);
875}
876
877static void test_qemu_strtoll_trailing(void)
878{
879 const char *str = "123xxx";
880 char f = 'X';
881 const char *endptr = &f;
882 int64_t res = 999;
883 int err;
884
885 err = qemu_strtoll(str, &endptr, 0, &res);
886
887 g_assert_cmpint(err, ==, 0);
888 g_assert_cmpint(res, ==, 123);
889 g_assert(endptr == str + 3);
890}
891
892static void test_qemu_strtoll_octal(void)
893{
894 const char *str = "0123";
895 char f = 'X';
896 const char *endptr = &f;
897 int64_t res = 999;
898 int err;
899
900 err = qemu_strtoll(str, &endptr, 8, &res);
901
902 g_assert_cmpint(err, ==, 0);
903 g_assert_cmpint(res, ==, 0123);
904 g_assert(endptr == str + strlen(str));
905
906 endptr = &f;
907 res = 999;
908 err = qemu_strtoll(str, &endptr, 0, &res);
909
910 g_assert_cmpint(err, ==, 0);
911 g_assert_cmpint(res, ==, 0123);
912 g_assert(endptr == str + strlen(str));
913}
914
915static void test_qemu_strtoll_decimal(void)
916{
917 const char *str = "0123";
918 char f = 'X';
919 const char *endptr = &f;
920 int64_t res = 999;
921 int err;
922
923 err = qemu_strtoll(str, &endptr, 10, &res);
924
925 g_assert_cmpint(err, ==, 0);
926 g_assert_cmpint(res, ==, 123);
927 g_assert(endptr == str + strlen(str));
928
929 str = "123";
930 endptr = &f;
931 res = 999;
932 err = qemu_strtoll(str, &endptr, 0, &res);
933
934 g_assert_cmpint(err, ==, 0);
935 g_assert_cmpint(res, ==, 123);
936 g_assert(endptr == str + strlen(str));
937}
938
939static void test_qemu_strtoll_hex(void)
940{
941 const char *str = "0123";
942 char f = 'X';
943 const char *endptr = &f;
944 int64_t res = 999;
945 int err;
946
947 err = qemu_strtoll(str, &endptr, 16, &res);
948
949 g_assert_cmpint(err, ==, 0);
950 g_assert_cmpint(res, ==, 0x123);
951 g_assert(endptr == str + strlen(str));
952
953 str = "0x123";
954 endptr = &f;
955 res = 999;
956 err = qemu_strtoll(str, &endptr, 0, &res);
957
958 g_assert_cmpint(err, ==, 0);
959 g_assert_cmpint(res, ==, 0x123);
960 g_assert(endptr == str + strlen(str));
961}
962
963static void test_qemu_strtoll_max(void)
964{
965 const char *str = g_strdup_printf("%lld", LLONG_MAX);
966 char f = 'X';
967 const char *endptr = &f;
968 int64_t res = 999;
969 int err;
970
971 err = qemu_strtoll(str, &endptr, 0, &res);
972
973 g_assert_cmpint(err, ==, 0);
974 g_assert_cmpint(res, ==, LLONG_MAX);
975 g_assert(endptr == str + strlen(str));
976}
977
978static void test_qemu_strtoll_overflow(void)
979{
980 const char *str = "99999999999999999999999999999999999999999999";
981 char f = 'X';
982 const char *endptr = &f;
983 int64_t res = 999;
984 int err;
985
986 err = qemu_strtoll(str, &endptr, 0, &res);
987
988 g_assert_cmpint(err, ==, -ERANGE);
989 g_assert_cmpint(res, ==, LLONG_MAX);
990 g_assert(endptr == str + strlen(str));
991}
992
993static void test_qemu_strtoll_underflow(void)
994{
995 const char *str = "-99999999999999999999999999999999999999999999";
996 char f = 'X';
997 const char *endptr = &f;
998 int64_t res = 999;
999 int err;
1000
1001 err = qemu_strtoll(str, &endptr, 0, &res);
1002
1003 g_assert_cmpint(err, ==, -ERANGE);
1004 g_assert_cmpint(res, ==, LLONG_MIN);
1005 g_assert(endptr == str + strlen(str));
1006}
1007
1008static void test_qemu_strtoll_negative(void)
1009{
1010 const char *str = " \t -321";
1011 char f = 'X';
1012 const char *endptr = &f;
1013 int64_t res = 999;
1014 int err;
1015
1016 err = qemu_strtoll(str, &endptr, 0, &res);
1017
1018 g_assert_cmpint(err, ==, 0);
1019 g_assert_cmpint(res, ==, -321);
1020 g_assert(endptr == str + strlen(str));
1021}
1022
1023static void test_qemu_strtoll_full_correct(void)
1024{
1025 const char *str = "123";
1026 int64_t res = 999;
1027 int err;
1028
1029 err = qemu_strtoll(str, NULL, 0, &res);
1030
1031 g_assert_cmpint(err, ==, 0);
1032 g_assert_cmpint(res, ==, 123);
1033}
1034
1035static void test_qemu_strtoll_full_null(void)
1036{
1037 int64_t res = 999;
1038 int err;
1039
1040 err = qemu_strtoll(NULL, NULL, 0, &res);
1041
1042 g_assert_cmpint(err, ==, -EINVAL);
1043}
1044
1045static void test_qemu_strtoll_full_empty(void)
1046{
1047 const char *str = "";
1048 int64_t res = 999;
1049 int err;
1050
1051 err = qemu_strtoll(str, NULL, 0, &res);
1052
1053 g_assert_cmpint(err, ==, 0);
1054 g_assert_cmpint(res, ==, 0);
1055}
1056
1057static void test_qemu_strtoll_full_negative(void)
1058{
1059 const char *str = " \t -321";
1060 int64_t res = 999;
1061 int err;
1062
1063 err = qemu_strtoll(str, NULL, 0, &res);
1064
1065 g_assert_cmpint(err, ==, 0);
1066 g_assert_cmpint(res, ==, -321);
1067}
1068
1069static void test_qemu_strtoll_full_trailing(void)
1070{
1071 const char *str = "123xxx";
1072 int64_t res = 999;
1073 int err;
1074
1075 err = qemu_strtoll(str, NULL, 0, &res);
1076
1077 g_assert_cmpint(err, ==, -EINVAL);
1078}
1079
1080static void test_qemu_strtoll_full_max(void)
1081{
1082
1083 const char *str = g_strdup_printf("%lld", LLONG_MAX);
1084 int64_t res;
1085 int err;
1086
1087 err = qemu_strtoll(str, NULL, 0, &res);
1088
1089 g_assert_cmpint(err, ==, 0);
1090 g_assert_cmpint(res, ==, LLONG_MAX);
1091}
1092
e3f9fe2d
EH		 1093int main(int argc, char **argv)
1094{
1095 g_test_init(&argc, &argv, NULL);
1096
1097 g_test_add_func("/cutils/parse_uint/null", test_parse_uint_null);
1098 g_test_add_func("/cutils/parse_uint/empty", test_parse_uint_empty);
1099 g_test_add_func("/cutils/parse_uint/whitespace",
1100 test_parse_uint_whitespace);
1101 g_test_add_func("/cutils/parse_uint/invalid", test_parse_uint_invalid);
1102 g_test_add_func("/cutils/parse_uint/trailing", test_parse_uint_trailing);
1103 g_test_add_func("/cutils/parse_uint/correct", test_parse_uint_correct);
1104 g_test_add_func("/cutils/parse_uint/octal", test_parse_uint_octal);
1105 g_test_add_func("/cutils/parse_uint/decimal", test_parse_uint_decimal);
1106 g_test_add_func("/cutils/parse_uint/llong_max", test_parse_uint_llong_max);
1107 g_test_add_func("/cutils/parse_uint/overflow", test_parse_uint_overflow);
1108 g_test_add_func("/cutils/parse_uint/negative", test_parse_uint_negative);
1109 g_test_add_func("/cutils/parse_uint_full/trailing",
1110 test_parse_uint_full_trailing);
1111 g_test_add_func("/cutils/parse_uint_full/correct",
1112 test_parse_uint_full_correct);
1113
764e0fa4
CT		 1114 /* qemu_strtol() tests */
1115 g_test_add_func("/cutils/qemu_strtol/correct", test_qemu_strtol_correct);
1116 g_test_add_func("/cutils/qemu_strtol/null", test_qemu_strtol_null);
1117 g_test_add_func("/cutils/qemu_strtol/empty", test_qemu_strtol_empty);
1118 g_test_add_func("/cutils/qemu_strtol/whitespace",
1119 test_qemu_strtol_whitespace);
1120 g_test_add_func("/cutils/qemu_strtol/invalid", test_qemu_strtol_invalid);
1121 g_test_add_func("/cutils/qemu_strtol/trailing", test_qemu_strtol_trailing);
1122 g_test_add_func("/cutils/qemu_strtol/octal", test_qemu_strtol_octal);
1123 g_test_add_func("/cutils/qemu_strtol/decimal", test_qemu_strtol_decimal);
1124 g_test_add_func("/cutils/qemu_strtol/hex", test_qemu_strtol_hex);
1125 g_test_add_func("/cutils/qemu_strtol/max", test_qemu_strtol_max);
1126 g_test_add_func("/cutils/qemu_strtol/overflow", test_qemu_strtol_overflow);
1127 g_test_add_func("/cutils/qemu_strtol/underflow",
1128 test_qemu_strtol_underflow);
1129 g_test_add_func("/cutils/qemu_strtol/negative", test_qemu_strtol_negative);
1130 g_test_add_func("/cutils/qemu_strtol_full/correct",
1131 test_qemu_strtol_full_correct);
1132 g_test_add_func("/cutils/qemu_strtol_full/null",
1133 test_qemu_strtol_full_null);
1134 g_test_add_func("/cutils/qemu_strtol_full/empty",
1135 test_qemu_strtol_full_empty);
1136 g_test_add_func("/cutils/qemu_strtol_full/negative",
1137 test_qemu_strtol_full_negative);
1138 g_test_add_func("/cutils/qemu_strtol_full/trailing",
1139 test_qemu_strtol_full_trailing);
1140 g_test_add_func("/cutils/qemu_strtol_full/max",
1141 test_qemu_strtol_full_max);
1142
c817c015
CT		 1143 /* qemu_strtoul() tests */
1144 g_test_add_func("/cutils/qemu_strtoul/correct", test_qemu_strtoul_correct);
1145 g_test_add_func("/cutils/qemu_strtoul/null", test_qemu_strtoul_null);
1146 g_test_add_func("/cutils/qemu_strtoul/empty", test_qemu_strtoul_empty);
1147 g_test_add_func("/cutils/qemu_strtoul/whitespace",
1148 test_qemu_strtoul_whitespace);
1149 g_test_add_func("/cutils/qemu_strtoul/invalid", test_qemu_strtoul_invalid);
1150 g_test_add_func("/cutils/qemu_strtoul/trailing",
1151 test_qemu_strtoul_trailing);
1152 g_test_add_func("/cutils/qemu_strtoul/octal", test_qemu_strtoul_octal);
1153 g_test_add_func("/cutils/qemu_strtoul/decimal", test_qemu_strtoul_decimal);
1154 g_test_add_func("/cutils/qemu_strtoul/hex", test_qemu_strtoul_hex);
1155 g_test_add_func("/cutils/qemu_strtoul/max", test_qemu_strtoul_max);
1156 g_test_add_func("/cutils/qemu_strtoul/overflow",
1157 test_qemu_strtoul_overflow);
1158 g_test_add_func("/cutils/qemu_strtoul/underflow",
1159 test_qemu_strtoul_underflow);
1160 g_test_add_func("/cutils/qemu_strtoul/negative",
1161 test_qemu_strtoul_negative);
1162 g_test_add_func("/cutils/qemu_strtoul_full/correct",
1163 test_qemu_strtoul_full_correct);
1164 g_test_add_func("/cutils/qemu_strtoul_full/null",
1165 test_qemu_strtoul_full_null);
1166 g_test_add_func("/cutils/qemu_strtoul_full/empty",
1167 test_qemu_strtoul_full_empty);
1168 g_test_add_func("/cutils/qemu_strtoul_full/negative",
1169 test_qemu_strtoul_full_negative);
1170 g_test_add_func("/cutils/qemu_strtoul_full/trailing",
1171 test_qemu_strtoul_full_trailing);
1172 g_test_add_func("/cutils/qemu_strtoul_full/max",
1173 test_qemu_strtoul_full_max);
1174
8ac4df40
CT		 1175 /* qemu_strtoll() tests */
1176 g_test_add_func("/cutils/qemu_strtoll/correct", test_qemu_strtoll_correct);
1177 g_test_add_func("/cutils/qemu_strtoll/null", test_qemu_strtoll_null);
1178 g_test_add_func("/cutils/qemu_strtoll/empty", test_qemu_strtoll_empty);
1179 g_test_add_func("/cutils/qemu_strtoll/whitespace",
1180 test_qemu_strtoll_whitespace);
1181 g_test_add_func("/cutils/qemu_strtoll/invalid", test_qemu_strtoll_invalid);
1182 g_test_add_func("/cutils/qemu_strtoll/trailing",
1183 test_qemu_strtoll_trailing);
1184 g_test_add_func("/cutils/qemu_strtoll/octal", test_qemu_strtoll_octal);
1185 g_test_add_func("/cutils/qemu_strtoll/decimal", test_qemu_strtoll_decimal);
1186 g_test_add_func("/cutils/qemu_strtoll/hex", test_qemu_strtoll_hex);
1187 g_test_add_func("/cutils/qemu_strtoll/max", test_qemu_strtoll_max);
1188 g_test_add_func("/cutils/qemu_strtoll/overflow",
1189 test_qemu_strtoll_overflow);
1190 g_test_add_func("/cutils/qemu_strtoll/underflow",
1191 test_qemu_strtoll_underflow);
1192 g_test_add_func("/cutils/qemu_strtoll/negative",
1193 test_qemu_strtoll_negative);
1194 g_test_add_func("/cutils/qemu_strtoll_full/correct",
1195 test_qemu_strtoll_full_correct);
1196 g_test_add_func("/cutils/qemu_strtoll_full/null",
1197 test_qemu_strtoll_full_null);
1198 g_test_add_func("/cutils/qemu_strtoll_full/empty",
1199 test_qemu_strtoll_full_empty);
1200 g_test_add_func("/cutils/qemu_strtoll_full/negative",
1201 test_qemu_strtoll_full_negative);
1202 g_test_add_func("/cutils/qemu_strtoll_full/trailing",
1203 test_qemu_strtoll_full_trailing);
1204 g_test_add_func("/cutils/qemu_strtoll_full/max",
1205 test_qemu_strtoll_full_max);
1206
e3f9fe2d
EH		 1207 return g_test_run();
1208}
QEMU mirror