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