test-cutils.c · samitouri/QOSamiQemu

Code Commits Issues Pulls Sessions CI/CD

master

c 4,065 lines 108 KB

Raw

1	/*
2	* cutils.c unit-tests
3	*
4	* Copyright Red Hat
5	*
6	* Authors:
7	* Eduardo Habkost <ehabkost@redhat.com>
8	*
9	* Permission is hereby granted, free of charge, to any person obtaining a copy
10	* of this software and associated documentation files (the "Software"), to deal
11	* in the Software without restriction, including without limitation the rights
12	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13	* copies of the Software, and to permit persons to whom the Software is
14	* furnished to do so, subject to the following conditions:
15	*
16	* The above copyright notice and this permission notice shall be included in
17	* all copies or substantial portions of the Software.
18	*
19	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25	* THE SOFTWARE.
26	*/
27
28	#include "qemu/osdep.h"
29	#include <math.h>
30
31	#include "qemu/cutils.h"
32	#include "qemu/units.h"
33
34	static void test_parse_uint_null(void)
35	{
36	uint64_t i = 999;
37	const char *endptr = "somewhere";
38	int r;
39
40	r = parse_uint(NULL, &endptr, 0, &i);
41
42	g_assert_cmpint(r, ==, -EINVAL);
43	g_assert_cmpuint(i, ==, 0);
44	g_assert_null(endptr);
45	}
46
47	static void test_parse_uint_empty(void)
48	{
49	uint64_t i = 999;
50	const char *endptr = "somewhere";
51	const char *str = "";
52	int r;
53
54	r = parse_uint(str, &endptr, 0, &i);
55
56	g_assert_cmpint(r, ==, -EINVAL);
57	g_assert_cmpuint(i, ==, 0);
58	g_assert_true(endptr == str);
59	}
60
61	static void test_parse_uint_whitespace(void)
62	{
63	uint64_t i = 999;
64	const char *endptr = "somewhere";
65	const char *str = " \t ";
66	int r;
67
68	r = parse_uint(str, &endptr, 0, &i);
69
70	g_assert_cmpint(r, ==, -EINVAL);
71	g_assert_cmpuint(i, ==, 0);
72	g_assert_true(endptr == str);
73	}
74
75
76	static void test_parse_uint_invalid(void)
77	{
78	uint64_t i = 999;
79	const char *endptr = "somewhere";
80	const char *str = " \t xxx";
81	int r;
82
83	r = parse_uint(str, &endptr, 0, &i);
84
85	g_assert_cmpint(r, ==, -EINVAL);
86	g_assert_cmpuint(i, ==, 0);
87	g_assert_true(endptr == str);
88	}
89
90
91	static void test_parse_uint_trailing(void)
92	{
93	uint64_t i = 999;
94	const char *endptr = "somewhere";
95	const char *str = "123xxx";
96	int r;
97
98	r = parse_uint(str, &endptr, 0, &i);
99
100	g_assert_cmpint(r, ==, 0);
101	g_assert_cmpuint(i, ==, 123);
102	g_assert_true(endptr == str + 3);
103	}
104
105	static void test_parse_uint_correct(void)
106	{
107	uint64_t i = 999;
108	const char *endptr = "somewhere";
109	const char *str = "123";
110	int r;
111
112	r = parse_uint(str, &endptr, 0, &i);
113
114	g_assert_cmpint(r, ==, 0);
115	g_assert_cmpuint(i, ==, 123);
116	g_assert_true(endptr == str + strlen(str));
117	}
118
119	static void test_parse_uint_octal(void)
120	{
121	uint64_t i = 999;
122	const char *endptr = "somewhere";
123	const char *str = "0123";
124	int r;
125
126	r = parse_uint(str, &endptr, 0, &i);
127
128	g_assert_cmpint(r, ==, 0);
129	g_assert_cmpuint(i, ==, 0123);
130	g_assert_true(endptr == str + strlen(str));
131	}
132
133	static void test_parse_uint_decimal(void)
134	{
135	uint64_t i = 999;
136	const char *endptr = "somewhere";
137	const char *str = "0123";
138	int r;
139
140	r = parse_uint(str, &endptr, 10, &i);
141
142	g_assert_cmpint(r, ==, 0);
143	g_assert_cmpuint(i, ==, 123);
144	g_assert_true(endptr == str + strlen(str));
145	}
146
147	static void test_parse_uint_llong_max(void)
148	{
149	uint64_t i = 999;
150	const char *endptr = "somewhere";
151	char *str = g_strdup_printf("%llu", (unsigned long long)LLONG_MAX + 1);
152	int r;
153
154	r = parse_uint(str, &endptr, 0, &i);
155
156	g_assert_cmpint(r, ==, 0);
157	g_assert_cmpuint(i, ==, (unsigned long long)LLONG_MAX + 1);
158	g_assert_true(endptr == str + strlen(str));
159
160	g_free(str);
161	}
162
163	static void test_parse_uint_max(void)
164	{
165	uint64_t i = 999;
166	const char *endptr = "somewhere";
167	char *str = g_strdup_printf("%llu", ULLONG_MAX);
168	int r;
169
170	r = parse_uint(str, &endptr, 0, &i);
171
172	g_assert_cmpint(r, ==, 0);
173	g_assert_cmpuint(i, ==, ULLONG_MAX);
174	g_assert_true(endptr == str + strlen(str));
175
176	g_free(str);
177	}
178
179	static void test_parse_uint_overflow(void)
180	{
181	uint64_t i;
182	const char *endptr;
183	const char *str;
184	int r;
185
186	i = 999;
187	endptr = "somewhere";
188	str = "99999999999999999999999999999999999999";
189	r = parse_uint(str, &endptr, 0, &i);
190	g_assert_cmpint(r, ==, -ERANGE);
191	g_assert_cmpuint(i, ==, ULLONG_MAX);
192	g_assert_true(endptr == str + strlen(str));
193
194	i = 999;
195	endptr = "somewhere";
196	str = "0x10000000000000000"; /* 65 bits, 64-bit sign bit clear */
197	r = parse_uint(str, &endptr, 0, &i);
198	g_assert_cmpint(r, ==, -ERANGE);
199	g_assert_cmpuint(i, ==, ULLONG_MAX);
200	g_assert_true(endptr == str + strlen(str));
201
202	i = 999;
203	endptr = "somewhere";
204	str = "0x18000000080000000"; /* 65 bits, 64-bit sign bit set */
205	r = parse_uint(str, &endptr, 0, &i);
206	g_assert_cmpint(r, ==, -ERANGE);
207	g_assert_cmpuint(i, ==, ULLONG_MAX);
208	g_assert_true(endptr == str + strlen(str));
209	}
210
211	static void test_parse_uint_negative(void)
212	{
213	uint64_t i;
214	const char *endptr;
215	const char *str;
216	int r;
217
218	i = 999;
219	endptr = "somewhere";
220	str = " \t -321";
221	r = parse_uint(str, &endptr, 0, &i);
222	g_assert_cmpint(r, ==, -ERANGE);
223	g_assert_cmpuint(i, ==, 0);
224	g_assert_true(endptr == str + strlen(str));
225
226	i = 999;
227	endptr = "somewhere";
228	str = "-0xffffffff00000001";
229	r = parse_uint(str, &endptr, 0, &i);
230	g_assert_cmpint(r, ==, -ERANGE);
231	g_assert_cmpuint(i, ==, 0);
232	g_assert_true(endptr == str + strlen(str));
233	}
234
235	static void test_parse_uint_negzero(void)
236	{
237	uint64_t i = 999;
238	const char *endptr = "somewhere";
239	const char *str = " -0";
240	int r;
241
242	r = parse_uint(str, &endptr, 0, &i);
243
244	g_assert_cmpint(r, ==, -ERANGE);
245	g_assert_cmpuint(i, ==, 0);
246	g_assert_true(endptr == str + strlen(str));
247	}
248
249	static void test_parse_uint_full_trailing(void)
250	{
251	uint64_t i = 999;
252	const char *str = "123xxx";
253	int r;
254
255	r = parse_uint_full(str, 0, &i);
256
257	g_assert_cmpint(r, ==, -EINVAL);
258	g_assert_cmpuint(i, ==, 0);
259	}
260
261	static void test_parse_uint_full_correct(void)
262	{
263	uint64_t i = 999;
264	const char *str = "123";
265	int r;
266
267	r = parse_uint_full(str, 0, &i);
268
269	g_assert_cmpint(r, ==, 0);
270	g_assert_cmpuint(i, ==, 123);
271	}
272
273	static void test_parse_uint_full_erange_junk(void)
274	{
275	/* EINVAL has priority over ERANGE */
276	uint64_t i = 999;
277	const char *str = "-2junk";
278	int r;
279
280	r = parse_uint_full(str, 0, &i);
281
282	g_assert_cmpint(r, ==, -EINVAL);
283	g_assert_cmpuint(i, ==, 0);
284	}
285
286	static void test_parse_uint_full_null(void)
287	{
288	uint64_t i = 999;
289	const char *str = NULL;
290	int r;
291
292	r = parse_uint_full(str, 0, &i);
293
294	g_assert_cmpint(r, ==, -EINVAL);
295	g_assert_cmpuint(i, ==, 0);
296	}
297
298	static void test_qemu_strtoi_correct(void)
299	{
300	const char *str = "12345 foo";
301	char f = 'X';
302	const char *endptr = &f;
303	int res = 999;
304	int err;
305
306	err = qemu_strtoi(str, &endptr, 0, &res);
307
308	g_assert_cmpint(err, ==, 0);
309	g_assert_cmpint(res, ==, 12345);
310	g_assert_true(endptr == str + 5);
311	}
312
313	static void test_qemu_strtoi_null(void)
314	{
315	char f = 'X';
316	const char *endptr = &f;
317	int res = 999;
318	int err;
319
320	err = qemu_strtoi(NULL, &endptr, 0, &res);
321
322	g_assert_cmpint(err, ==, -EINVAL);
323	g_assert_cmpint(res, ==, 0);
324	g_assert_null(endptr);
325	}
326
327	static void test_qemu_strtoi_empty(void)
328	{
329	const char *str = "";
330	char f = 'X';
331	const char *endptr = &f;
332	int res = 999;
333	int err;
334
335	err = qemu_strtoi(str, &endptr, 0, &res);
336
337	g_assert_cmpint(err, ==, -EINVAL);
338	g_assert_cmpint(res, ==, 0);
339	g_assert_true(endptr == str);
340	}
341
342	static void test_qemu_strtoi_whitespace(void)
343	{
344	const char *str = " \t ";
345	char f = 'X';
346	const char *endptr = &f;
347	int res = 999;
348	int err;
349
350	err = qemu_strtoi(str, &endptr, 0, &res);
351
352	g_assert_cmpint(err, ==, -EINVAL);
353	g_assert_cmpint(res, ==, 0);
354	g_assert_true(endptr == str);
355	}
356
357	static void test_qemu_strtoi_invalid(void)
358	{
359	const char *str = " xxxx \t abc";
360	char f = 'X';
361	const char *endptr = &f;
362	int res = 999;
363	int err;
364
365	err = qemu_strtoi(str, &endptr, 0, &res);
366
367	g_assert_cmpint(err, ==, -EINVAL);
368	g_assert_cmpint(res, ==, 0);
369	g_assert_true(endptr == str);
370	}
371
372	static void test_qemu_strtoi_trailing(void)
373	{
374	const char *str = "123xxx";
375	char f = 'X';
376	const char *endptr = &f;
377	int res = 999;
378	int err;
379
380	err = qemu_strtoi(str, &endptr, 0, &res);
381
382	g_assert_cmpint(err, ==, 0);
383	g_assert_cmpint(res, ==, 123);
384	g_assert_true(endptr == str + 3);
385	}
386
387	static void test_qemu_strtoi_octal(void)
388	{
389	const char *str = "0123";
390	char f = 'X';
391	const char *endptr = &f;
392	int res = 999;
393	int err;
394
395	err = qemu_strtoi(str, &endptr, 8, &res);
396
397	g_assert_cmpint(err, ==, 0);
398	g_assert_cmpint(res, ==, 0123);
399	g_assert_true(endptr == str + strlen(str));
400
401	res = 999;
402	endptr = &f;
403	err = qemu_strtoi(str, &endptr, 0, &res);
404
405	g_assert_cmpint(err, ==, 0);
406	g_assert_cmpint(res, ==, 0123);
407	g_assert_true(endptr == str + strlen(str));
408	}
409
410	static void test_qemu_strtoi_decimal(void)
411	{
412	const char *str = "0123";
413	char f = 'X';
414	const char *endptr = &f;
415	int res = 999;
416	int err;
417
418	err = qemu_strtoi(str, &endptr, 10, &res);
419
420	g_assert_cmpint(err, ==, 0);
421	g_assert_cmpint(res, ==, 123);
422	g_assert_true(endptr == str + strlen(str));
423
424	str = "123";
425	res = 999;
426	endptr = &f;
427	err = qemu_strtoi(str, &endptr, 0, &res);
428
429	g_assert_cmpint(err, ==, 0);
430	g_assert_cmpint(res, ==, 123);
431	g_assert_true(endptr == str + strlen(str));
432	}
433
434	static void test_qemu_strtoi_hex(void)
435	{
436	const char *str = "0123";
437	char f = 'X';
438	const char *endptr = &f;
439	int res = 999;
440	int err;
441
442	err = qemu_strtoi(str, &endptr, 16, &res);
443
444	g_assert_cmpint(err, ==, 0);
445	g_assert_cmpint(res, ==, 0x123);
446	g_assert_true(endptr == str + strlen(str));
447
448	str = "0x123";
449	res = 999;
450	endptr = &f;
451	err = qemu_strtoi(str, &endptr, 0, &res);
452
453	g_assert_cmpint(err, ==, 0);
454	g_assert_cmpint(res, ==, 0x123);
455	g_assert_true(endptr == str + strlen(str));
456
457	str = "0x";
458	res = 999;
459	endptr = &f;
460	err = qemu_strtoi(str, &endptr, 16, &res);
461
462	g_assert_cmpint(err, ==, 0);
463	g_assert_cmpint(res, ==, 0);
464	g_assert_true(endptr == str + 1);
465	}
466
467	static void test_qemu_strtoi_max(void)
468	{
469	char *str = g_strdup_printf("%d", INT_MAX);
470	char f = 'X';
471	const char *endptr = &f;
472	int res = 999;
473	int err;
474
475	err = qemu_strtoi(str, &endptr, 0, &res);
476
477	g_assert_cmpint(err, ==, 0);
478	g_assert_cmpint(res, ==, INT_MAX);
479	g_assert_true(endptr == str + strlen(str));
480	g_free(str);
481	}
482
483	static void test_qemu_strtoi_overflow(void)
484	{
485	const char *str;
486	const char *endptr;
487	int res;
488	int err;
489
490	str = "2147483648"; /* INT_MAX + 1ll */
491	endptr = "somewhere";
492	res = 999;
493	err = qemu_strtoi(str, &endptr, 0, &res);
494	g_assert_cmpint(err, ==, -ERANGE);
495	g_assert_cmpint(res, ==, INT_MAX);
496	g_assert_true(endptr == str + strlen(str));
497
498	str = "0x7fffffffffffffff"; /* LLONG_MAX */
499	endptr = "somewhere";
500	res = 999;
501	err = qemu_strtoi(str, &endptr, 0, &res);
502	g_assert_cmpint(err, ==, -ERANGE);
503	g_assert_cmpint(res, ==, INT_MAX);
504	g_assert_true(endptr == str + strlen(str));
505
506	str = "0x8000000000000000"; /* (uint64_t)LLONG_MIN */
507	endptr = "somewhere";
508	res = 999;
509	err = qemu_strtoi(str, &endptr, 0, &res);
510	g_assert_cmpint(err, ==, -ERANGE);
511	g_assert_cmpint(res, ==, INT_MAX);
512	g_assert_true(endptr == str + strlen(str));
513
514	str = "0x10000000000000000"; /* 65 bits, 32-bit sign bit clear */
515	endptr = "somewhere";
516	res = 999;
517	err = qemu_strtoi(str, &endptr, 0, &res);
518	g_assert_cmpint(err, ==, -ERANGE);
519	g_assert_cmpint(res, ==, INT_MAX);
520	g_assert_true(endptr == str + strlen(str));
521
522	str = "0x18000000080000000"; /* 65 bits, 32-bit sign bit set */
523	endptr = "somewhere";
524	res = 999;
525	err = qemu_strtoi(str, &endptr, 0, &res);
526	g_assert_cmpint(err, ==, -ERANGE);
527	g_assert_cmpint(res, ==, INT_MAX);
528	g_assert_true(endptr == str + strlen(str));
529	}
530
531	static void test_qemu_strtoi_min(void)
532	{
533	char *str = g_strdup_printf("%d", INT_MIN);
534	char f = 'X';
535	const char *endptr = &f;
536	int res = 999;
537	int err;
538
539	err = qemu_strtoi(str, &endptr, 0, &res);
540
541	g_assert_cmpint(err, ==, 0);
542	g_assert_cmpint(res, ==, INT_MIN);
543	g_assert_true(endptr == str + strlen(str));
544	g_free(str);
545	}
546
547	static void test_qemu_strtoi_underflow(void)
548	{
549	const char *str;
550	const char *endptr;
551	int res;
552	int err;
553
554	str = "-2147483649"; /* INT_MIN - 1ll */
555	endptr = "somewhere";
556	res = 999;
557	err = qemu_strtoi(str, &endptr, 0, &res);
558	g_assert_cmpint(err, ==, -ERANGE);
559	g_assert_cmpint(res, ==, INT_MIN);
560	g_assert_true(endptr == str + strlen(str));
561
562	str = "-0x7fffffffffffffff"; /* -LLONG_MAX */
563	endptr = "somewhere";
564	res = 999;
565	err = qemu_strtoi(str, &endptr, 0, &res);
566	g_assert_cmpint(err, ==, -ERANGE);
567	g_assert_cmpint(res, ==, INT_MIN);
568	g_assert_true(endptr == str + strlen(str));
569
570	str = "-0x8000000000000000"; /* (uint64_t)LLONG_MIN */
571	endptr = "somewhere";
572	res = 999;
573	err = qemu_strtoi(str, &endptr, 0, &res);
574	g_assert_cmpint(err, ==, -ERANGE);
575	g_assert_cmpint(res, ==, INT_MIN);
576	g_assert_true(endptr == str + strlen(str));
577
578	str = "-18446744073709551615"; /* -UINT64_MAX (not 1) */
579	endptr = "somewhere";
580	res = 999;
581	err = qemu_strtoi(str, &endptr, 0, &res);
582	g_assert_cmpint(err, ==, -ERANGE);
583	g_assert_cmpint(res, ==, INT_MIN);
584	g_assert_true(endptr == str + strlen(str));
585
586	str = "-0x10000000000000000"; /* 65 bits, 32-bit sign bit clear */
587	endptr = "somewhere";
588	res = 999;
589	err = qemu_strtoi(str, &endptr, 0, &res);
590	g_assert_cmpint(err, ==, -ERANGE);
591	g_assert_cmpint(res, ==, INT_MIN);
592	g_assert_true(endptr == str + strlen(str));
593
594	str = "-0x18000000080000000"; /* 65 bits, 32-bit sign bit set */
595	endptr = "somewhere";
596	res = 999;
597	err = qemu_strtoi(str, &endptr, 0, &res);
598	g_assert_cmpint(err, ==, -ERANGE);
599	g_assert_cmpint(res, ==, INT_MIN);
600	g_assert_true(endptr == str + strlen(str));
601	}
602
603	static void test_qemu_strtoi_negative(void)
604	{
605	const char *str;
606	const char *endptr;
607	int res;
608	int err;
609
610	str = " \t -321";
611	endptr = "somewhere";
612	res = 999;
613	err = qemu_strtoi(str, &endptr, 0, &res);
614	g_assert_cmpint(err, ==, 0);
615	g_assert_cmpint(res, ==, -321);
616	g_assert_true(endptr == str + strlen(str));
617
618	str = "-2147483648"; /* INT_MIN */
619	endptr = "somewhere";
620	res = 999;
621	err = qemu_strtoi(str, &endptr, 0, &res);
622	g_assert_cmpint(err, ==, 0);
623	g_assert_cmpint(res, ==, INT_MIN);
624	g_assert_true(endptr == str + strlen(str));
625	}
626
627	static void test_qemu_strtoi_negzero(void)
628	{
629	const char *str = " -0";
630	char f = 'X';
631	const char *endptr = &f;
632	int res = 999;
633	int err;
634
635	err = qemu_strtoi(str, &endptr, 0, &res);
636
637	g_assert_cmpint(err, ==, 0);
638	g_assert_cmpint(res, ==, 0);
639	g_assert_true(endptr == str + strlen(str));
640	}
641
642	static void test_qemu_strtoi_full_correct(void)
643	{
644	const char *str = "123";
645	int res = 999;
646	int err;
647
648	err = qemu_strtoi(str, NULL, 0, &res);
649
650	g_assert_cmpint(err, ==, 0);
651	g_assert_cmpint(res, ==, 123);
652	}
653
654	static void test_qemu_strtoi_full_null(void)
655	{
656	char f = 'X';
657	const char *endptr = &f;
658	int res = 999;
659	int err;
660
661	err = qemu_strtoi(NULL, &endptr, 0, &res);
662
663	g_assert_cmpint(err, ==, -EINVAL);
664	g_assert_cmpint(res, ==, 0);
665	g_assert_null(endptr);
666	}
667
668	static void test_qemu_strtoi_full_empty(void)
669	{
670	const char *str = "";
671	int res = 999;
672	int err;
673
674	err = qemu_strtoi(str, NULL, 0, &res);
675
676	g_assert_cmpint(err, ==, -EINVAL);
677	g_assert_cmpint(res, ==, 0);
678	}
679
680	static void test_qemu_strtoi_full_negative(void)
681	{
682	const char *str = " \t -321";
683	int res = 999;
684	int err;
685
686	err = qemu_strtoi(str, NULL, 0, &res);
687
688	g_assert_cmpint(err, ==, 0);
689	g_assert_cmpint(res, ==, -321);
690	}
691
692	static void test_qemu_strtoi_full_negzero(void)
693	{
694	const char *str = " -0";
695	int res = 999;
696	int err;
697
698	err = qemu_strtoi(str, NULL, 0, &res);
699
700	g_assert_cmpint(err, ==, 0);
701	g_assert_cmpint(res, ==, 0);
702	}
703
704	static void test_qemu_strtoi_full_trailing(void)
705	{
706	const char *str = "123xxx";
707	int res = 999;
708	int err;
709
710	err = qemu_strtoi(str, NULL, 0, &res);
711
712	g_assert_cmpint(err, ==, -EINVAL);
713	g_assert_cmpint(res, ==, 123);
714	}
715
716	static void test_qemu_strtoi_full_max(void)
717	{
718	char *str = g_strdup_printf("%d", INT_MAX);
719	int res = 999;
720	int err;
721
722	err = qemu_strtoi(str, NULL, 0, &res);
723
724	g_assert_cmpint(err, ==, 0);
725	g_assert_cmpint(res, ==, INT_MAX);
726	g_free(str);
727	}
728
729	static void test_qemu_strtoi_full_erange_junk(void)
730	{
731	/* EINVAL has priority over ERANGE */
732	const char *str = "-9999999999junk";
733	int res = 999;
734	int err;
735
736	err = qemu_strtoi(str, NULL, 0, &res);
737
738	g_assert_cmpint(err, ==, -EINVAL);
739	g_assert_cmpint(res, ==, INT_MIN);
740	}
741
742	static void test_qemu_strtoui_correct(void)
743	{
744	const char *str = "12345 foo";
745	char f = 'X';
746	const char *endptr = &f;
747	unsigned int res = 999;
748	int err;
749
750	err = qemu_strtoui(str, &endptr, 0, &res);
751
752	g_assert_cmpint(err, ==, 0);
753	g_assert_cmpuint(res, ==, 12345);
754	g_assert_true(endptr == str + 5);
755	}
756
757	static void test_qemu_strtoui_null(void)
758	{
759	char f = 'X';
760	const char *endptr = &f;
761	unsigned int res = 999;
762	int err;
763
764	err = qemu_strtoui(NULL, &endptr, 0, &res);
765
766	g_assert_cmpint(err, ==, -EINVAL);
767	g_assert_cmpuint(res, ==, 0);
768	g_assert_null(endptr);
769	}
770
771	static void test_qemu_strtoui_empty(void)
772	{
773	const char *str = "";
774	char f = 'X';
775	const char *endptr = &f;
776	unsigned int res = 999;
777	int err;
778
779	err = qemu_strtoui(str, &endptr, 0, &res);
780
781	g_assert_cmpint(err, ==, -EINVAL);
782	g_assert_cmpuint(res, ==, 0);
783	g_assert_true(endptr == str);
784	}
785
786	static void test_qemu_strtoui_whitespace(void)
787	{
788	const char *str = " \t ";
789	char f = 'X';
790	const char *endptr = &f;
791	unsigned int res = 999;
792	int err;
793
794	err = qemu_strtoui(str, &endptr, 0, &res);
795
796	g_assert_cmpint(err, ==, -EINVAL);
797	g_assert_cmpuint(res, ==, 0);
798	g_assert_true(endptr == str);
799	}
800
801	static void test_qemu_strtoui_invalid(void)
802	{
803	const char *str = " xxxx \t abc";
804	char f = 'X';
805	const char *endptr = &f;
806	unsigned int res = 999;
807	int err;
808
809	err = qemu_strtoui(str, &endptr, 0, &res);
810
811	g_assert_cmpint(err, ==, -EINVAL);
812	g_assert_cmpuint(res, ==, 0);
813	g_assert_true(endptr == str);
814	}
815
816	static void test_qemu_strtoui_trailing(void)
817	{
818	const char *str = "123xxx";
819	char f = 'X';
820	const char *endptr = &f;
821	unsigned int res = 999;
822	int err;
823
824	err = qemu_strtoui(str, &endptr, 0, &res);
825
826	g_assert_cmpint(err, ==, 0);
827	g_assert_cmpuint(res, ==, 123);
828	g_assert_true(endptr == str + 3);
829	}
830
831	static void test_qemu_strtoui_octal(void)
832	{
833	const char *str = "0123";
834	char f = 'X';
835	const char *endptr = &f;
836	unsigned int res = 999;
837	int err;
838
839	err = qemu_strtoui(str, &endptr, 8, &res);
840
841	g_assert_cmpint(err, ==, 0);
842	g_assert_cmpuint(res, ==, 0123);
843	g_assert_true(endptr == str + strlen(str));
844
845	res = 999;
846	endptr = &f;
847	err = qemu_strtoui(str, &endptr, 0, &res);
848
849	g_assert_cmpint(err, ==, 0);
850	g_assert_cmpuint(res, ==, 0123);
851	g_assert_true(endptr == str + strlen(str));
852	}
853
854	static void test_qemu_strtoui_decimal(void)
855	{
856	const char *str = "0123";
857	char f = 'X';
858	const char *endptr = &f;
859	unsigned int res = 999;
860	int err;
861
862	err = qemu_strtoui(str, &endptr, 10, &res);
863
864	g_assert_cmpint(err, ==, 0);
865	g_assert_cmpuint(res, ==, 123);
866	g_assert_true(endptr == str + strlen(str));
867
868	str = "123";
869	res = 999;
870	endptr = &f;
871	err = qemu_strtoui(str, &endptr, 0, &res);
872
873	g_assert_cmpint(err, ==, 0);
874	g_assert_cmpuint(res, ==, 123);
875	g_assert_true(endptr == str + strlen(str));
876	}
877
878	static void test_qemu_strtoui_hex(void)
879	{
880	const char *str = "0123";
881	char f = 'X';
882	const char *endptr = &f;
883	unsigned int res = 999;
884	int err;
885
886	err = qemu_strtoui(str, &endptr, 16, &res);
887
888	g_assert_cmpint(err, ==, 0);
889	g_assert_cmphex(res, ==, 0x123);
890	g_assert_true(endptr == str + strlen(str));
891
892	str = "0x123";
893	res = 999;
894	endptr = &f;
895	err = qemu_strtoui(str, &endptr, 0, &res);
896
897	g_assert_cmpint(err, ==, 0);
898	g_assert_cmphex(res, ==, 0x123);
899	g_assert_true(endptr == str + strlen(str));
900
901	str = "0x";
902	res = 999;
903	endptr = &f;
904	err = qemu_strtoui(str, &endptr, 16, &res);
905
906	g_assert_cmpint(err, ==, 0);
907	g_assert_cmphex(res, ==, 0);
908	g_assert_true(endptr == str + 1);
909	}
910
911	static void test_qemu_strtoui_wrap(void)
912	{
913	/* wraparound is consistent with 32-bit strtoul */
914	const char str = "-4294967295"; / 1 mod 2^32 */
915	char f = 'X';
916	const char *endptr = &f;
917	unsigned int res = 999;
918	int err;
919
920	err = qemu_strtoui(str, &endptr, 0, &res);
921
922	g_assert_cmpint(err, ==, 0);
923	g_assert_cmphex(res, ==, 1);
924	g_assert_true(endptr == str + strlen(str));
925	}
926
927	static void test_qemu_strtoui_max(void)
928	{
929	char *str = g_strdup_printf("%u", UINT_MAX);
930	char f = 'X';
931	const char *endptr = &f;
932	unsigned int res = 999;
933	int err;
934
935	err = qemu_strtoui(str, &endptr, 0, &res);
936
937	g_assert_cmpint(err, ==, 0);
938	g_assert_cmphex(res, ==, UINT_MAX);
939	g_assert_true(endptr == str + strlen(str));
940	g_free(str);
941	}
942
943	static void test_qemu_strtoui_overflow(void)
944	{
945	const char *str;
946	const char *endptr;
947	unsigned int res;
948	int err;
949
950	str = "4294967296"; /* UINT_MAX + 1ll */
951	endptr = "somewhere";
952	res = 999;
953	err = qemu_strtoui(str, &endptr, 0, &res);
954	g_assert_cmpint(err, ==, -ERANGE);
955	g_assert_cmpuint(res, ==, UINT_MAX);
956	g_assert_true(endptr == str + strlen(str));
957
958	str = "0x7fffffffffffffff"; /* LLONG_MAX */
959	endptr = "somewhere";
960	res = 999;
961	err = qemu_strtoui(str, &endptr, 0, &res);
962	g_assert_cmpint(err, ==, -ERANGE);
963	g_assert_cmpuint(res, ==, UINT_MAX);
964	g_assert_true(endptr == str + strlen(str));
965
966	str = "0x8000000000000000"; /* (uint64_t)LLONG_MIN */
967	endptr = "somewhere";
968	res = 999;
969	err = qemu_strtoui(str, &endptr, 0, &res);
970	g_assert_cmpint(err, ==, -ERANGE);
971	g_assert_cmpuint(res, ==, UINT_MAX);
972	g_assert_true(endptr == str + strlen(str));
973
974	str = "0xffffffff00000001"; /* ULLONG_MAX - UINT_MAX + 1 (not 1) */
975	endptr = "somewhere";
976	res = 999;
977	err = qemu_strtoui(str, &endptr, 0, &res);
978	g_assert_cmpint(err, ==, -ERANGE);
979	g_assert_cmpuint(res, ==, UINT_MAX);
980	g_assert_true(endptr == str + strlen(str));
981
982	str = "0xfffffffffffffffe"; /* ULLONG_MAX - 1 (not UINT_MAX - 1) */
983	endptr = "somewhere";
984	res = 999;
985	err = qemu_strtoui(str, &endptr, 0, &res);
986	g_assert_cmpint(err, ==, -ERANGE);
987	g_assert_cmpuint(res, ==, UINT_MAX);
988	g_assert_true(endptr == str + strlen(str));
989
990	str = "0x10000000000000000"; /* 65 bits, 32-bit sign bit clear */
991	endptr = "somewhere";
992	res = 999;
993	err = qemu_strtoui(str, &endptr, 0, &res);
994	g_assert_cmpint(err, ==, -ERANGE);
995	g_assert_cmpuint(res, ==, UINT_MAX);
996	g_assert_true(endptr == str + strlen(str));
997
998	str = "0x18000000080000000"; /* 65 bits, 32-bit sign bit set */
999	endptr = "somewhere";
1000	res = 999;
1001	err = qemu_strtoui(str, &endptr, 0, &res);
1002	g_assert_cmpint(err, ==, -ERANGE);
1003	g_assert_cmpuint(res, ==, UINT_MAX);
1004	g_assert_true(endptr == str + strlen(str));
1005	}
1006
1007	static void test_qemu_strtoui_underflow(void)
1008	{
1009	const char *str;
1010	const char *endptr;
1011	unsigned int res;
1012	int err;
1013
1014	str = "-4294967296"; /* -(long long)UINT_MAX - 1ll */
1015	endptr = "somewhere";
1016	res = 999;
1017	err = qemu_strtoui(str, &endptr, 0, &res);
1018	g_assert_cmpint(err, ==, -ERANGE);
1019	g_assert_cmpuint(res, ==, UINT_MAX);
1020	g_assert_true(endptr == str + strlen(str));
1021
1022	str = "-18446744073709551615"; /* -UINT64_MAX (not -(-1)) */
1023	endptr = "somewhere";
1024	res = 999;
1025	err = qemu_strtoui(str, &endptr, 0, &res);
1026	g_assert_cmpint(err, ==, -ERANGE);
1027	g_assert_cmpuint(res, ==, UINT_MAX);
1028	g_assert_true(endptr == str + strlen(str));
1029
1030	str = "-0xffffffff00000002";
1031	endptr = "somewhere";
1032	res = 999;
1033	err = qemu_strtoui(str, &endptr, 0, &res);
1034	g_assert_cmpint(err, ==, -ERANGE);
1035	g_assert_cmpuint(res, ==, UINT_MAX);
1036	g_assert_true(endptr == str + strlen(str));
1037
1038	str = "-0x10000000000000000"; /* 65 bits, 32-bit sign bit clear */
1039	endptr = "somewhere";
1040	res = 999;
1041	err = qemu_strtoui(str, &endptr, 0, &res);
1042	g_assert_cmpint(err, ==, -ERANGE);
1043	g_assert_cmpuint(res, ==, UINT_MAX);
1044	g_assert_true(endptr == str + strlen(str));
1045
1046	str = "-0x18000000080000000"; /* 65 bits, 32-bit sign bit set */
1047	endptr = "somewhere";
1048	res = 999;
1049	err = qemu_strtoui(str, &endptr, 0, &res);
1050	g_assert_cmpint(err, ==, -ERANGE);
1051	g_assert_cmpuint(res, ==, UINT_MAX);
1052	g_assert_true(endptr == str + strlen(str));
1053	}
1054
1055	static void test_qemu_strtoui_negative(void)
1056	{
1057	const char *str = " \t -321";
1058	char f = 'X';
1059	const char *endptr = &f;
1060	unsigned int res = 999;
1061	int err;
1062
1063	err = qemu_strtoui(str, &endptr, 0, &res);
1064
1065	g_assert_cmpint(err, ==, 0);
1066	g_assert_cmpuint(res, ==, (unsigned int)-321);
1067	g_assert_true(endptr == str + strlen(str));
1068	}
1069
1070	static void test_qemu_strtoui_negzero(void)
1071	{
1072	const char *str = " -0";
1073	char f = 'X';
1074	const char *endptr = &f;
1075	unsigned int res = 999;
1076	int err;
1077
1078	err = qemu_strtoui(str, &endptr, 0, &res);
1079
1080	g_assert_cmpint(err, ==, 0);
1081	g_assert_cmpuint(res, ==, 0);
1082	g_assert_true(endptr == str + strlen(str));
1083	}
1084
1085	static void test_qemu_strtoui_full_correct(void)
1086	{
1087	const char *str = "123";
1088	unsigned int res = 999;
1089	int err;
1090
1091	err = qemu_strtoui(str, NULL, 0, &res);
1092
1093	g_assert_cmpint(err, ==, 0);
1094	g_assert_cmpuint(res, ==, 123);
1095	}
1096
1097	static void test_qemu_strtoui_full_null(void)
1098	{
1099	unsigned int res = 999;
1100	int err;
1101
1102	err = qemu_strtoui(NULL, NULL, 0, &res);
1103
1104	g_assert_cmpint(err, ==, -EINVAL);
1105	g_assert_cmpuint(res, ==, 0);
1106	}
1107
1108	static void test_qemu_strtoui_full_empty(void)
1109	{
1110	const char *str = "";
1111	unsigned int res = 999;
1112	int err;
1113
1114	err = qemu_strtoui(str, NULL, 0, &res);
1115
1116	g_assert_cmpint(err, ==, -EINVAL);
1117	g_assert_cmpuint(res, ==, 0);
1118	}
1119
1120	static void test_qemu_strtoui_full_negative(void)
1121	{
1122	const char *str = " \t -321";
1123	unsigned int res = 999;
1124	int err;
1125
1126	err = qemu_strtoui(str, NULL, 0, &res);
1127	g_assert_cmpint(err, ==, 0);
1128	g_assert_cmpuint(res, ==, (unsigned int)-321);
1129	}
1130
1131	static void test_qemu_strtoui_full_negzero(void)
1132	{
1133	const char *str = " -0";
1134	unsigned int res = 999;
1135	int err;
1136
1137	err = qemu_strtoui(str, NULL, 0, &res);
1138	g_assert_cmpint(err, ==, 0);
1139	g_assert_cmpuint(res, ==, 0);
1140	}
1141
1142	static void test_qemu_strtoui_full_trailing(void)
1143	{
1144	const char *str = "123xxx";
1145	unsigned int res = 999;
1146	int err;
1147
1148	err = qemu_strtoui(str, NULL, 0, &res);
1149
1150	g_assert_cmpint(err, ==, -EINVAL);
1151	g_assert_cmpuint(res, ==, 123);
1152	}
1153
1154	static void test_qemu_strtoui_full_max(void)
1155	{
1156	char *str = g_strdup_printf("%u", UINT_MAX);
1157	unsigned int res = 999;
1158	int err;
1159
1160	err = qemu_strtoui(str, NULL, 0, &res);
1161
1162	g_assert_cmpint(err, ==, 0);
1163	g_assert_cmphex(res, ==, UINT_MAX);
1164	g_free(str);
1165	}
1166
1167	static void test_qemu_strtoui_full_erange_junk(void)
1168	{
1169	/* EINVAL has priority over ERANGE */
1170	const char *str = "-9999999999junk";
1171	unsigned int res = 999;
1172	int err;
1173
1174	err = qemu_strtoui(str, NULL, 0, &res);
1175
1176	g_assert_cmpint(err, ==, -EINVAL);
1177	g_assert_cmpuint(res, ==, UINT_MAX);
1178	}
1179
1180	static void test_qemu_strtol_correct(void)
1181	{
1182	const char *str = "12345 foo";
1183	char f = 'X';
1184	const char *endptr = &f;
1185	long res = 999;
1186	int err;
1187
1188	err = qemu_strtol(str, &endptr, 0, &res);
1189
1190	g_assert_cmpint(err, ==, 0);
1191	g_assert_cmpint(res, ==, 12345);
1192	g_assert_true(endptr == str + 5);
1193	}
1194
1195	static void test_qemu_strtol_null(void)
1196	{
1197	char f = 'X';
1198	const char *endptr = &f;
1199	long res = 999;
1200	int err;
1201
1202	err = qemu_strtol(NULL, &endptr, 0, &res);
1203
1204	g_assert_cmpint(err, ==, -EINVAL);
1205	g_assert_cmpint(res, ==, 0);
1206	g_assert_null(endptr);
1207	}
1208
1209	static void test_qemu_strtol_empty(void)
1210	{
1211	const char *str = "";
1212	char f = 'X';
1213	const char *endptr = &f;
1214	long res = 999;
1215	int err;
1216
1217	err = qemu_strtol(str, &endptr, 0, &res);
1218
1219	g_assert_cmpint(err, ==, -EINVAL);
1220	g_assert_cmpint(res, ==, 0);
1221	g_assert_true(endptr == str);
1222	}
1223
1224	static void test_qemu_strtol_whitespace(void)
1225	{
1226	const char *str = " \t ";
1227	char f = 'X';
1228	const char *endptr = &f;
1229	long res = 999;
1230	int err;
1231
1232	err = qemu_strtol(str, &endptr, 0, &res);
1233
1234	g_assert_cmpint(err, ==, -EINVAL);
1235	g_assert_cmpint(res, ==, 0);
1236	g_assert_true(endptr == str);
1237	}
1238
1239	static void test_qemu_strtol_invalid(void)
1240	{
1241	const char *str = " xxxx \t abc";
1242	char f = 'X';
1243	const char *endptr = &f;
1244	long res = 999;
1245	int err;
1246
1247	err = qemu_strtol(str, &endptr, 0, &res);
1248
1249	g_assert_cmpint(err, ==, -EINVAL);
1250	g_assert_cmpint(res, ==, 0);
1251	g_assert_true(endptr == str);
1252	}
1253
1254	static void test_qemu_strtol_trailing(void)
1255	{
1256	const char *str = "123xxx";
1257	char f = 'X';
1258	const char *endptr = &f;
1259	long res = 999;
1260	int err;
1261
1262	err = qemu_strtol(str, &endptr, 0, &res);
1263
1264	g_assert_cmpint(err, ==, 0);
1265	g_assert_cmpint(res, ==, 123);
1266	g_assert_true(endptr == str + 3);
1267	}
1268
1269	static void test_qemu_strtol_octal(void)
1270	{
1271	const char *str = "0123";
1272	char f = 'X';
1273	const char *endptr = &f;
1274	long res = 999;
1275	int err;
1276
1277	err = qemu_strtol(str, &endptr, 8, &res);
1278
1279	g_assert_cmpint(err, ==, 0);
1280	g_assert_cmpint(res, ==, 0123);
1281	g_assert_true(endptr == str + strlen(str));
1282
1283	res = 999;
1284	endptr = &f;
1285	err = qemu_strtol(str, &endptr, 0, &res);
1286
1287	g_assert_cmpint(err, ==, 0);
1288	g_assert_cmpint(res, ==, 0123);
1289	g_assert_true(endptr == str + strlen(str));
1290	}
1291
1292	static void test_qemu_strtol_decimal(void)
1293	{
1294	const char *str = "0123";
1295	char f = 'X';
1296	const char *endptr = &f;
1297	long res = 999;
1298	int err;
1299
1300	err = qemu_strtol(str, &endptr, 10, &res);
1301
1302	g_assert_cmpint(err, ==, 0);
1303	g_assert_cmpint(res, ==, 123);
1304	g_assert_true(endptr == str + strlen(str));
1305
1306	str = "123";
1307	res = 999;
1308	endptr = &f;
1309	err = qemu_strtol(str, &endptr, 0, &res);
1310
1311	g_assert_cmpint(err, ==, 0);
1312	g_assert_cmpint(res, ==, 123);
1313	g_assert_true(endptr == str + strlen(str));
1314	}
1315
1316	static void test_qemu_strtol_hex(void)
1317	{
1318	const char *str = "0123";
1319	char f = 'X';
1320	const char *endptr = &f;
1321	long res = 999;
1322	int err;
1323
1324	err = qemu_strtol(str, &endptr, 16, &res);
1325
1326	g_assert_cmpint(err, ==, 0);
1327	g_assert_cmpint(res, ==, 0x123);
1328	g_assert_true(endptr == str + strlen(str));
1329
1330	str = "0x123";
1331	res = 999;
1332	endptr = &f;
1333	err = qemu_strtol(str, &endptr, 0, &res);
1334
1335	g_assert_cmpint(err, ==, 0);
1336	g_assert_cmpint(res, ==, 0x123);
1337	g_assert_true(endptr == str + strlen(str));
1338
1339	str = "0x";
1340	res = 999;
1341	endptr = &f;
1342	err = qemu_strtol(str, &endptr, 16, &res);
1343
1344	g_assert_cmpint(err, ==, 0);
1345	g_assert_cmpint(res, ==, 0);
1346	g_assert_true(endptr == str + 1);
1347	}
1348
1349	static void test_qemu_strtol_max(void)
1350	{
1351	char *str = g_strdup_printf("%ld", LONG_MAX);
1352	char f = 'X';
1353	const char *endptr = &f;
1354	long res = 999;
1355	int err;
1356
1357	err = qemu_strtol(str, &endptr, 0, &res);
1358
1359	g_assert_cmpint(err, ==, 0);
1360	g_assert_cmpint(res, ==, LONG_MAX);
1361	g_assert_true(endptr == str + strlen(str));
1362	g_free(str);
1363	}
1364
1365	static void test_qemu_strtol_overflow(void)
1366	{
1367	const char *str;
1368	const char *endptr;
1369	long res;
1370	int err;
1371
1372	/* 1 more than LONG_MAX */
1373	str = LONG_MAX == INT_MAX ? "2147483648" : "9223372036854775808";
1374	endptr = "somewhere";
1375	res = 999;
1376	err = qemu_strtol(str, &endptr, 0, &res);
1377	g_assert_cmpint(err, ==, -ERANGE);
1378	g_assert_cmpint(res, ==, LONG_MAX);
1379	g_assert_true(endptr == str + strlen(str));
1380
1381	if (LONG_MAX == INT_MAX) {
1382	str = "0xffffffff00000001"; /* ULLONG_MAX - UINT_MAX + 1 (not 1) */
1383	endptr = "somewhere";
1384	res = 999;
1385	err = qemu_strtol(str, &endptr, 0, &res);
1386	g_assert_cmpint(err, ==, -ERANGE);
1387	g_assert_cmpint(res, ==, LONG_MAX);
1388	g_assert_true(endptr == str + strlen(str));
1389	}
1390
1391	str = "0x10000000000000000"; /* 65 bits, either sign bit position clear */
1392	endptr = "somewhere";
1393	res = 999;
1394	err = qemu_strtol(str, &endptr, 0, &res);
1395	g_assert_cmpint(err, ==, -ERANGE);
1396	g_assert_cmpint(res, ==, LONG_MAX);
1397	g_assert_true(endptr == str + strlen(str));
1398
1399	str = "0x18000000080000000"; /* 65 bits, either sign bit position set */
1400	endptr = "somewhere";
1401	res = 999;
1402	err = qemu_strtol(str, &endptr, 0, &res);
1403	g_assert_cmpint(err, ==, -ERANGE);
1404	g_assert_cmpint(res, ==, LONG_MAX);
1405	g_assert_true(endptr == str + strlen(str));
1406	}
1407
1408	static void test_qemu_strtol_min(void)
1409	{
1410	char *str = g_strdup_printf("%ld", LONG_MIN);
1411	char f = 'X';
1412	const char *endptr = &f;
1413	long res = 999;
1414	int err;
1415
1416	err = qemu_strtol(str, &endptr, 0, &res);
1417
1418	g_assert_cmpint(err, ==, 0);
1419	g_assert_cmpint(res, ==, LONG_MIN);
1420	g_assert_true(endptr == str + strlen(str));
1421	g_free(str);
1422	}
1423
1424	static void test_qemu_strtol_underflow(void)
1425	{
1426	const char *str;
1427	const char *endptr;
1428	long res;
1429	int err;
1430
1431	/* 1 less than LONG_MIN */
1432	str = LONG_MIN == INT_MIN ? "-2147483649" : "-9223372036854775809";
1433	endptr = "somewhere";
1434	res = 999;
1435	err = qemu_strtol(str, &endptr, 0, &res);
1436	g_assert_cmpint(err, ==, -ERANGE);
1437	g_assert_cmpint(res, ==, LONG_MIN);
1438	g_assert_true(endptr == str + strlen(str));
1439
1440	if (LONG_MAX == INT_MAX) {
1441	str = "-18446744073709551615"; /* -UINT64_MAX (not 1) */
1442	endptr = "somewhere";
1443	res = 999;
1444	err = qemu_strtol(str, &endptr, 0, &res);
1445	g_assert_cmpint(err, ==, -ERANGE);
1446	g_assert_cmpint(res, ==, LONG_MIN);
1447	g_assert_true(endptr == str + strlen(str));
1448	}
1449
1450	str = "-0x10000000000000000"; /* 65 bits, either sign bit position clear */
1451	endptr = "somewhere";
1452	res = 999;
1453	err = qemu_strtol(str, &endptr, 0, &res);
1454	g_assert_cmpint(err, ==, -ERANGE);
1455	g_assert_cmpint(res, ==, LONG_MIN);
1456	g_assert_true(endptr == str + strlen(str));
1457
1458	str = "-0x18000000080000000"; /* 65 bits, either sign bit position set */
1459	endptr = "somewhere";
1460	res = 999;
1461	err = qemu_strtol(str, &endptr, 0, &res);
1462	g_assert_cmpint(err, ==, -ERANGE);
1463	g_assert_cmpint(res, ==, LONG_MIN);
1464	g_assert_true(endptr == str + strlen(str));
1465	}
1466
1467	static void test_qemu_strtol_negative(void)
1468	{
1469	const char *str = " \t -321";
1470	char f = 'X';
1471	const char *endptr = &f;
1472	long res = 999;
1473	int err;
1474
1475	err = qemu_strtol(str, &endptr, 0, &res);
1476
1477	g_assert_cmpint(err, ==, 0);
1478	g_assert_cmpint(res, ==, -321);
1479	g_assert_true(endptr == str + strlen(str));
1480	}
1481
1482	static void test_qemu_strtol_negzero(void)
1483	{
1484	const char *str = " -0";
1485	char f = 'X';
1486	const char *endptr = &f;
1487	long res = 999;
1488	int err;
1489
1490	err = qemu_strtol(str, &endptr, 0, &res);
1491
1492	g_assert_cmpint(err, ==, 0);
1493	g_assert_cmpint(res, ==, 0);
1494	g_assert_true(endptr == str + strlen(str));
1495	}
1496
1497	static void test_qemu_strtol_full_correct(void)
1498	{
1499	const char *str = "123";
1500	long res = 999;
1501	int err;
1502
1503	err = qemu_strtol(str, NULL, 0, &res);
1504
1505	g_assert_cmpint(err, ==, 0);
1506	g_assert_cmpint(res, ==, 123);
1507	}
1508
1509	static void test_qemu_strtol_full_null(void)
1510	{
1511	char f = 'X';
1512	const char *endptr = &f;
1513	long res = 999;
1514	int err;
1515
1516	err = qemu_strtol(NULL, &endptr, 0, &res);
1517
1518	g_assert_cmpint(err, ==, -EINVAL);
1519	g_assert_cmpint(res, ==, 0);
1520	g_assert_null(endptr);
1521	}
1522
1523	static void test_qemu_strtol_full_empty(void)
1524	{
1525	const char *str = "";
1526	long res = 999L;
1527	int err;
1528
1529	err = qemu_strtol(str, NULL, 0, &res);
1530
1531	g_assert_cmpint(err, ==, -EINVAL);
1532	g_assert_cmpint(res, ==, 0);
1533	}
1534
1535	static void test_qemu_strtol_full_negative(void)
1536	{
1537	const char *str = " \t -321";
1538	long res = 999;
1539	int err;
1540
1541	err = qemu_strtol(str, NULL, 0, &res);
1542
1543	g_assert_cmpint(err, ==, 0);
1544	g_assert_cmpint(res, ==, -321);
1545	}
1546
1547	static void test_qemu_strtol_full_negzero(void)
1548	{
1549	const char *str = " -0";
1550	long res = 999;
1551	int err;
1552
1553	err = qemu_strtol(str, NULL, 0, &res);
1554
1555	g_assert_cmpint(err, ==, 0);
1556	g_assert_cmpint(res, ==, 0);
1557	}
1558
1559	static void test_qemu_strtol_full_trailing(void)
1560	{
1561	const char *str = "123xxx";
1562	long res = 999;
1563	int err;
1564
1565	err = qemu_strtol(str, NULL, 0, &res);
1566
1567	g_assert_cmpint(err, ==, -EINVAL);
1568	g_assert_cmpint(res, ==, 123);
1569	}
1570
1571	static void test_qemu_strtol_full_max(void)
1572	{
1573	char *str = g_strdup_printf("%ld", LONG_MAX);
1574	long res = 999;
1575	int err;
1576
1577	err = qemu_strtol(str, NULL, 0, &res);
1578
1579	g_assert_cmpint(err, ==, 0);
1580	g_assert_cmpint(res, ==, LONG_MAX);
1581	g_free(str);
1582	}
1583
1584	static void test_qemu_strtol_full_erange_junk(void)
1585	{
1586	/* EINVAL has priority over ERANGE */
1587	const char *str = "-99999999999999999999junk";
1588	long res = 999;
1589	int err;
1590
1591	err = qemu_strtol(str, NULL, 0, &res);
1592
1593	g_assert_cmpint(err, ==, -EINVAL);
1594	g_assert_cmpint(res, ==, LONG_MIN);
1595	}
1596
1597	static void test_qemu_strtoul_correct(void)
1598	{
1599	const char *str = "12345 foo";
1600	char f = 'X';
1601	const char *endptr = &f;
1602	unsigned long res = 999;
1603	int err;
1604
1605	err = qemu_strtoul(str, &endptr, 0, &res);
1606
1607	g_assert_cmpint(err, ==, 0);
1608	g_assert_cmpuint(res, ==, 12345);
1609	g_assert_true(endptr == str + 5);
1610	}
1611
1612	static void test_qemu_strtoul_null(void)
1613	{
1614	char f = 'X';
1615	const char *endptr = &f;
1616	unsigned long res = 999;
1617	int err;
1618
1619	err = qemu_strtoul(NULL, &endptr, 0, &res);
1620
1621	g_assert_cmpint(err, ==, -EINVAL);
1622	g_assert_cmpuint(res, ==, 0);
1623	g_assert_null(endptr);
1624	}
1625
1626	static void test_qemu_strtoul_empty(void)
1627	{
1628	const char *str = "";
1629	char f = 'X';
1630	const char *endptr = &f;
1631	unsigned long res = 999;
1632	int err;
1633
1634	err = qemu_strtoul(str, &endptr, 0, &res);
1635
1636	g_assert_cmpint(err, ==, -EINVAL);
1637	g_assert_cmpuint(res, ==, 0);
1638	g_assert_true(endptr == str);
1639	}
1640
1641	static void test_qemu_strtoul_whitespace(void)
1642	{
1643	const char *str = " \t ";
1644	char f = 'X';
1645	const char *endptr = &f;
1646	unsigned long res = 999;
1647	int err;
1648
1649	err = qemu_strtoul(str, &endptr, 0, &res);
1650
1651	g_assert_cmpint(err, ==, -EINVAL);
1652	g_assert_cmpuint(res, ==, 0);
1653	g_assert_true(endptr == str);
1654	}
1655
1656	static void test_qemu_strtoul_invalid(void)
1657	{
1658	const char *str = " xxxx \t abc";
1659	char f = 'X';
1660	const char *endptr = &f;
1661	unsigned long res = 999;
1662	int err;
1663
1664	err = qemu_strtoul(str, &endptr, 0, &res);
1665
1666	g_assert_cmpint(err, ==, -EINVAL);
1667	g_assert_cmpuint(res, ==, 0);
1668	g_assert_true(endptr == str);
1669	}
1670
1671	static void test_qemu_strtoul_trailing(void)
1672	{
1673	const char *str = "123xxx";
1674	char f = 'X';
1675	const char *endptr = &f;
1676	unsigned long res = 999;
1677	int err;
1678
1679	err = qemu_strtoul(str, &endptr, 0, &res);
1680
1681	g_assert_cmpint(err, ==, 0);
1682	g_assert_cmpuint(res, ==, 123);
1683	g_assert_true(endptr == str + 3);
1684	}
1685
1686	static void test_qemu_strtoul_octal(void)
1687	{
1688	const char *str = "0123";
1689	char f = 'X';
1690	const char *endptr = &f;
1691	unsigned long res = 999;
1692	int err;
1693
1694	err = qemu_strtoul(str, &endptr, 8, &res);
1695
1696	g_assert_cmpint(err, ==, 0);
1697	g_assert_cmpuint(res, ==, 0123);
1698	g_assert_true(endptr == str + strlen(str));
1699
1700	res = 999;
1701	endptr = &f;
1702	err = qemu_strtoul(str, &endptr, 0, &res);
1703
1704	g_assert_cmpint(err, ==, 0);
1705	g_assert_cmpuint(res, ==, 0123);
1706	g_assert_true(endptr == str + strlen(str));
1707	}
1708
1709	static void test_qemu_strtoul_decimal(void)
1710	{
1711	const char *str = "0123";
1712	char f = 'X';
1713	const char *endptr = &f;
1714	unsigned long res = 999;
1715	int err;
1716
1717	err = qemu_strtoul(str, &endptr, 10, &res);
1718
1719	g_assert_cmpint(err, ==, 0);
1720	g_assert_cmpuint(res, ==, 123);
1721	g_assert_true(endptr == str + strlen(str));
1722
1723	str = "123";
1724	res = 999;
1725	endptr = &f;
1726	err = qemu_strtoul(str, &endptr, 0, &res);
1727
1728	g_assert_cmpint(err, ==, 0);
1729	g_assert_cmpuint(res, ==, 123);
1730	g_assert_true(endptr == str + strlen(str));
1731	}
1732
1733	static void test_qemu_strtoul_hex(void)
1734	{
1735	const char *str = "0123";
1736	char f = 'X';
1737	const char *endptr = &f;
1738	unsigned long res = 999;
1739	int err;
1740
1741	err = qemu_strtoul(str, &endptr, 16, &res);
1742
1743	g_assert_cmpint(err, ==, 0);
1744	g_assert_cmphex(res, ==, 0x123);
1745	g_assert_true(endptr == str + strlen(str));
1746
1747	str = "0x123";
1748	res = 999;
1749	endptr = &f;
1750	err = qemu_strtoul(str, &endptr, 0, &res);
1751
1752	g_assert_cmpint(err, ==, 0);
1753	g_assert_cmphex(res, ==, 0x123);
1754	g_assert_true(endptr == str + strlen(str));
1755
1756	str = "0x";
1757	res = 999;
1758	endptr = &f;
1759	err = qemu_strtoul(str, &endptr, 16, &res);
1760
1761	g_assert_cmpint(err, ==, 0);
1762	g_assert_cmphex(res, ==, 0);
1763	g_assert_true(endptr == str + 1);
1764	}
1765
1766	static void test_qemu_strtoul_wrap(void)
1767	{
1768	const char *str;
1769	char f = 'X';
1770	const char *endptr = &f;
1771	unsigned long res = 999;
1772	int err;
1773
1774	/* 1 mod 2^(sizeof(long)8) /
1775	str = LONG_MAX == INT_MAX ? "-4294967295" : "-18446744073709551615";
1776	err = qemu_strtoul(str, &endptr, 0, &res);
1777
1778	g_assert_cmpint(err, ==, 0);
1779	g_assert_cmphex(res, ==, 1);
1780	g_assert_true(endptr == str + strlen(str));
1781	}
1782
1783	static void test_qemu_strtoul_max(void)
1784	{
1785	char *str = g_strdup_printf("%lu", ULONG_MAX);
1786	char f = 'X';
1787	const char *endptr = &f;
1788	unsigned long res = 999;
1789	int err;
1790
1791	err = qemu_strtoul(str, &endptr, 0, &res);
1792
1793	g_assert_cmpint(err, ==, 0);
1794	g_assert_cmphex(res, ==, ULONG_MAX);
1795	g_assert_true(endptr == str + strlen(str));
1796	g_free(str);
1797	}
1798
1799	static void test_qemu_strtoul_overflow(void)
1800	{
1801	const char *str;
1802	const char *endptr;
1803	unsigned long res;
1804	int err;
1805
1806	/* 1 more than ULONG_MAX */
1807	str = ULONG_MAX == UINT_MAX ? "4294967296" : "18446744073709551616";
1808	endptr = "somewhere";
1809	res = 999;
1810	err = qemu_strtoul(str, &endptr, 0, &res);
1811	g_assert_cmpint(err, ==, -ERANGE);
1812	g_assert_cmpuint(res, ==, ULONG_MAX);
1813	g_assert_true(endptr == str + strlen(str));
1814
1815	if (LONG_MAX == INT_MAX) {
1816	str = "0xffffffff00000001"; /* UINT64_MAX - UINT_MAX + 1 (not 1) */
1817	endptr = "somewhere";
1818	res = 999;
1819	err = qemu_strtoul(str, &endptr, 0, &res);
1820	g_assert_cmpint(err, ==, -ERANGE);
1821	g_assert_cmpuint(res, ==, ULONG_MAX);
1822	g_assert_true(endptr == str + strlen(str));
1823	}
1824
1825	str = "0x10000000000000000"; /* 65 bits, either sign bit position clear */
1826	endptr = "somewhere";
1827	res = 999;
1828	err = qemu_strtoul(str, &endptr, 0, &res);
1829	g_assert_cmpint(err, ==, -ERANGE);
1830	g_assert_cmpuint(res, ==, ULONG_MAX);
1831	g_assert_true(endptr == str + strlen(str));
1832
1833	str = "0x18000000080000000"; /* 65 bits, either sign bit position set */
1834	endptr = "somewhere";
1835	res = 999;
1836	err = qemu_strtoul(str, &endptr, 0, &res);
1837	g_assert_cmpint(err, ==, -ERANGE);
1838	g_assert_cmpuint(res, ==, ULONG_MAX);
1839	g_assert_true(endptr == str + strlen(str));
1840	}
1841
1842	static void test_qemu_strtoul_underflow(void)
1843	{
1844	const char *str;
1845	const char *endptr;
1846	unsigned long res;
1847	int err;
1848
1849	/* 1 less than -ULONG_MAX */
1850	str = ULONG_MAX == UINT_MAX ? "-4294967296" : "-18446744073709551616";
1851	endptr = "somewhere";
1852	res = 999;
1853	err = qemu_strtoul(str, &endptr, 0, &res);
1854	g_assert_cmpint(err, ==, -ERANGE);
1855	g_assert_cmpuint(res, ==, ULONG_MAX);
1856	g_assert_true(endptr == str + strlen(str));
1857
1858	if (LONG_MAX == INT_MAX) {
1859	str = "-0xffffffff00000002";
1860	endptr = "somewhere";
1861	res = 999;
1862	err = qemu_strtoul(str, &endptr, 0, &res);
1863	g_assert_cmpint(err, ==, -ERANGE);
1864	g_assert_cmpuint(res, ==, ULONG_MAX);
1865	g_assert_true(endptr == str + strlen(str));
1866	}
1867
1868	str = "-0x10000000000000000"; /* 65 bits, either sign bit position clear */
1869	endptr = "somewhere";
1870	res = 999;
1871	err = qemu_strtoul(str, &endptr, 0, &res);
1872	g_assert_cmpint(err, ==, -ERANGE);
1873	g_assert_cmpuint(res, ==, ULONG_MAX);
1874	g_assert_true(endptr == str + strlen(str));
1875
1876	str = "-0x18000000080000000"; /* 65 bits, either sign bit position set */
1877	endptr = "somewhere";
1878	res = 999;
1879	err = qemu_strtoul(str, &endptr, 0, &res);
1880	g_assert_cmpint(err, ==, -ERANGE);
1881	g_assert_cmpuint(res, ==, ULONG_MAX);
1882	g_assert_true(endptr == str + strlen(str));
1883	}
1884
1885	static void test_qemu_strtoul_negative(void)
1886	{
1887	const char *str = " \t -321";
1888	char f = 'X';
1889	const char *endptr = &f;
1890	unsigned long res = 999;
1891	int err;
1892
1893	err = qemu_strtoul(str, &endptr, 0, &res);
1894
1895	g_assert_cmpint(err, ==, 0);
1896	g_assert_cmpuint(res, ==, -321ul);
1897	g_assert_true(endptr == str + strlen(str));
1898	}
1899
1900	static void test_qemu_strtoul_negzero(void)
1901	{
1902	const char *str = " -0";
1903	char f = 'X';
1904	const char *endptr = &f;
1905	unsigned long res = 999;
1906	int err;
1907
1908	err = qemu_strtoul(str, &endptr, 0, &res);
1909
1910	g_assert_cmpint(err, ==, 0);
1911	g_assert_cmpuint(res, ==, 0);
1912	g_assert_true(endptr == str + strlen(str));
1913	}
1914
1915	static void test_qemu_strtoul_full_correct(void)
1916	{
1917	const char *str = "123";
1918	unsigned long res = 999;
1919	int err;
1920
1921	err = qemu_strtoul(str, NULL, 0, &res);
1922
1923	g_assert_cmpint(err, ==, 0);
1924	g_assert_cmpuint(res, ==, 123);
1925	}
1926
1927	static void test_qemu_strtoul_full_null(void)
1928	{
1929	unsigned long res = 999;
1930	int err;
1931
1932	err = qemu_strtoul(NULL, NULL, 0, &res);
1933
1934	g_assert_cmpint(err, ==, -EINVAL);
1935	g_assert_cmpuint(res, ==, 0);
1936	}
1937
1938	static void test_qemu_strtoul_full_empty(void)
1939	{
1940	const char *str = "";
1941	unsigned long res = 999;
1942	int err;
1943
1944	err = qemu_strtoul(str, NULL, 0, &res);
1945
1946	g_assert_cmpint(err, ==, -EINVAL);
1947	g_assert_cmpuint(res, ==, 0);
1948	}
1949
1950	static void test_qemu_strtoul_full_negative(void)
1951	{
1952	const char *str = " \t -321";
1953	unsigned long res = 999;
1954	int err;
1955
1956	err = qemu_strtoul(str, NULL, 0, &res);
1957	g_assert_cmpint(err, ==, 0);
1958	g_assert_cmpuint(res, ==, -321ul);
1959	}
1960
1961	static void test_qemu_strtoul_full_negzero(void)
1962	{
1963	const char *str = " -0";
1964	unsigned long res = 999;
1965	int err;
1966
1967	err = qemu_strtoul(str, NULL, 0, &res);
1968	g_assert_cmpint(err, ==, 0);
1969	g_assert_cmpuint(res, ==, 0);
1970	}
1971
1972	static void test_qemu_strtoul_full_trailing(void)
1973	{
1974	const char *str = "123xxx";
1975	unsigned long res = 999;
1976	int err;
1977
1978	err = qemu_strtoul(str, NULL, 0, &res);
1979
1980	g_assert_cmpint(err, ==, -EINVAL);
1981	g_assert_cmpuint(res, ==, 123);
1982	}
1983
1984	static void test_qemu_strtoul_full_max(void)
1985	{
1986	char *str = g_strdup_printf("%lu", ULONG_MAX);
1987	unsigned long res = 999;
1988	int err;
1989
1990	err = qemu_strtoul(str, NULL, 0, &res);
1991
1992	g_assert_cmpint(err, ==, 0);
1993	g_assert_cmphex(res, ==, ULONG_MAX);
1994	g_free(str);
1995	}
1996
1997	static void test_qemu_strtoul_full_erange_junk(void)
1998	{
1999	/* EINVAL has priority over ERANGE */
2000	const char *str = "-99999999999999999999junk";
2001	unsigned long res = 999;
2002	int err;
2003
2004	err = qemu_strtoul(str, NULL, 0, &res);
2005
2006	g_assert_cmpint(err, ==, -EINVAL);
2007	g_assert_cmpuint(res, ==, ULONG_MAX);
2008	}
2009
2010	static void test_qemu_strtoi64_correct(void)
2011	{
2012	const char *str = "12345 foo";
2013	char f = 'X';
2014	const char *endptr = &f;
2015	int64_t res = 999;
2016	int err;
2017
2018	err = qemu_strtoi64(str, &endptr, 0, &res);
2019
2020	g_assert_cmpint(err, ==, 0);
2021	g_assert_cmpint(res, ==, 12345);
2022	g_assert_true(endptr == str + 5);
2023	}
2024
2025	static void test_qemu_strtoi64_null(void)
2026	{
2027	char f = 'X';
2028	const char *endptr = &f;
2029	int64_t res = 999;
2030	int err;
2031
2032	err = qemu_strtoi64(NULL, &endptr, 0, &res);
2033
2034	g_assert_cmpint(err, ==, -EINVAL);
2035	g_assert_cmpint(res, ==, 0);
2036	g_assert_null(endptr);
2037	}
2038
2039	static void test_qemu_strtoi64_empty(void)
2040	{
2041	const char *str = "";
2042	char f = 'X';
2043	const char *endptr = &f;
2044	int64_t res = 999;
2045	int err;
2046
2047	err = qemu_strtoi64(str, &endptr, 0, &res);
2048
2049	g_assert_cmpint(err, ==, -EINVAL);
2050	g_assert_cmpint(res, ==, 0);
2051	g_assert_true(endptr == str);
2052	}
2053
2054	static void test_qemu_strtoi64_whitespace(void)
2055	{
2056	const char *str = " \t ";
2057	char f = 'X';
2058	const char *endptr = &f;
2059	int64_t res = 999;
2060	int err;
2061
2062	err = qemu_strtoi64(str, &endptr, 0, &res);
2063
2064	g_assert_cmpint(err, ==, -EINVAL);
2065	g_assert_cmpint(res, ==, 0);
2066	g_assert_true(endptr == str);
2067	}
2068
2069	static void test_qemu_strtoi64_invalid(void)
2070	{
2071	const char *str = " xxxx \t abc";
2072	char f = 'X';
2073	const char *endptr = &f;
2074	int64_t res = 999;
2075	int err;
2076
2077	err = qemu_strtoi64(str, &endptr, 0, &res);
2078
2079	g_assert_cmpint(err, ==, -EINVAL);
2080	g_assert_cmpint(res, ==, 0);
2081	g_assert_true(endptr == str);
2082	}
2083
2084	static void test_qemu_strtoi64_trailing(void)
2085	{
2086	const char *str = "123xxx";
2087	char f = 'X';
2088	const char *endptr = &f;
2089	int64_t res = 999;
2090	int err;
2091
2092	err = qemu_strtoi64(str, &endptr, 0, &res);
2093
2094	g_assert_cmpint(err, ==, 0);
2095	g_assert_cmpint(res, ==, 123);
2096	g_assert_true(endptr == str + 3);
2097	}
2098
2099	static void test_qemu_strtoi64_octal(void)
2100	{
2101	const char *str = "0123";
2102	char f = 'X';
2103	const char *endptr = &f;
2104	int64_t res = 999;
2105	int err;
2106
2107	err = qemu_strtoi64(str, &endptr, 8, &res);
2108
2109	g_assert_cmpint(err, ==, 0);
2110	g_assert_cmpint(res, ==, 0123);
2111	g_assert_true(endptr == str + strlen(str));
2112
2113	endptr = &f;
2114	res = 999;
2115	err = qemu_strtoi64(str, &endptr, 0, &res);
2116
2117	g_assert_cmpint(err, ==, 0);
2118	g_assert_cmpint(res, ==, 0123);
2119	g_assert_true(endptr == str + strlen(str));
2120	}
2121
2122	static void test_qemu_strtoi64_decimal(void)
2123	{
2124	const char *str = "0123";
2125	char f = 'X';
2126	const char *endptr = &f;
2127	int64_t res = 999;
2128	int err;
2129
2130	err = qemu_strtoi64(str, &endptr, 10, &res);
2131
2132	g_assert_cmpint(err, ==, 0);
2133	g_assert_cmpint(res, ==, 123);
2134	g_assert_true(endptr == str + strlen(str));
2135
2136	str = "123";
2137	endptr = &f;
2138	res = 999;
2139	err = qemu_strtoi64(str, &endptr, 0, &res);
2140
2141	g_assert_cmpint(err, ==, 0);
2142	g_assert_cmpint(res, ==, 123);
2143	g_assert_true(endptr == str + strlen(str));
2144	}
2145
2146	static void test_qemu_strtoi64_hex(void)
2147	{
2148	const char *str = "0123";
2149	char f = 'X';
2150	const char *endptr = &f;
2151	int64_t res = 999;
2152	int err;
2153
2154	err = qemu_strtoi64(str, &endptr, 16, &res);
2155
2156	g_assert_cmpint(err, ==, 0);
2157	g_assert_cmpint(res, ==, 0x123);
2158	g_assert_true(endptr == str + strlen(str));
2159
2160	str = "0x123";
2161	endptr = &f;
2162	res = 999;
2163	err = qemu_strtoi64(str, &endptr, 0, &res);
2164
2165	g_assert_cmpint(err, ==, 0);
2166	g_assert_cmpint(res, ==, 0x123);
2167	g_assert_true(endptr == str + strlen(str));
2168
2169	str = "0x";
2170	endptr = &f;
2171	res = 999;
2172	err = qemu_strtoi64(str, &endptr, 16, &res);
2173
2174	g_assert_cmpint(err, ==, 0);
2175	g_assert_cmpint(res, ==, 0);
2176	g_assert_true(endptr == str + 1);
2177	}
2178
2179	static void test_qemu_strtoi64_max(void)
2180	{
2181	char *str = g_strdup_printf("%lld", LLONG_MAX);
2182	char f = 'X';
2183	const char *endptr = &f;
2184	int64_t res = 999;
2185	int err;
2186
2187	err = qemu_strtoi64(str, &endptr, 0, &res);
2188
2189	g_assert_cmpint(err, ==, 0);
2190	g_assert_cmpint(res, ==, LLONG_MAX);
2191	g_assert_true(endptr == str + strlen(str));
2192	g_free(str);
2193	}
2194
2195	static void test_qemu_strtoi64_overflow(void)
2196	{
2197	const char *str;
2198	const char *endptr;
2199	int64_t res;
2200	int err;
2201
2202	str = "9223372036854775808"; /* 1 more than INT64_MAX */
2203	endptr = "somewhere";
2204	res = 999;
2205	err = qemu_strtoi64(str, &endptr, 0, &res);
2206	g_assert_cmpint(err, ==, -ERANGE);
2207	g_assert_cmpint(res, ==, INT64_MAX);
2208	g_assert_true(endptr == str + strlen(str));
2209
2210	str = "0x10000000000000000"; /* 65 bits, 64-bit sign bit clear */
2211	endptr = "somewhere";
2212	res = 999;
2213	err = qemu_strtoi64(str, &endptr, 0, &res);
2214	g_assert_cmpint(err, ==, -ERANGE);
2215	g_assert_cmpint(res, ==, INT64_MAX);
2216	g_assert_true(endptr == str + strlen(str));
2217
2218	str = "0x18000000080000000"; /* 65 bits, 64-bit sign bit set */
2219	endptr = "somewhere";
2220	res = 999;
2221	err = qemu_strtoi64(str, &endptr, 0, &res);
2222	g_assert_cmpint(err, ==, -ERANGE);
2223	g_assert_cmpint(res, ==, INT64_MAX);
2224	g_assert_true(endptr == str + strlen(str));
2225	}
2226
2227	static void test_qemu_strtoi64_min(void)
2228	{
2229	char *str = g_strdup_printf("%lld", LLONG_MIN);
2230	char f = 'X';
2231	const char *endptr = &f;
2232	int64_t res = 999;
2233	int err;
2234
2235	err = qemu_strtoi64(str, &endptr, 0, &res);
2236
2237	g_assert_cmpint(err, ==, 0);
2238	g_assert_cmpint(res, ==, LLONG_MIN);
2239	g_assert_true(endptr == str + strlen(str));
2240	g_free(str);
2241	}
2242
2243	static void test_qemu_strtoi64_underflow(void)
2244	{
2245	const char *str;
2246	const char *endptr;
2247	int64_t res;
2248	int err;
2249
2250	str = "-9223372036854775809"; /* 1 less than INT64_MIN */
2251	endptr = "somewhere";
2252	res = 999;
2253	err = qemu_strtoi64(str, &endptr, 0, &res);
2254	g_assert_cmpint(err, ==, -ERANGE);
2255	g_assert_cmpint(res, ==, INT64_MIN);
2256	g_assert_true(endptr == str + strlen(str));
2257
2258	str = "-0x10000000000000000"; /* 65 bits, 64-bit sign bit clear */
2259	endptr = "somewhere";
2260	res = 999;
2261	err = qemu_strtoi64(str, &endptr, 0, &res);
2262	g_assert_cmpint(err, ==, -ERANGE);
2263	g_assert_cmpint(res, ==, INT64_MIN);
2264	g_assert_true(endptr == str + strlen(str));
2265
2266	str = "-0x18000000080000000"; /* 65 bits, 64-bit sign bit set */
2267	endptr = "somewhere";
2268	res = 999;
2269	err = qemu_strtoi64(str, &endptr, 0, &res);
2270	g_assert_cmpint(err, ==, -ERANGE);
2271	g_assert_cmpint(res, ==, INT64_MIN);
2272	g_assert_true(endptr == str + strlen(str));
2273	}
2274
2275	static void test_qemu_strtoi64_negative(void)
2276	{
2277	const char *str = " \t -321";
2278	char f = 'X';
2279	const char *endptr = &f;
2280	int64_t res = 999;
2281	int err;
2282
2283	err = qemu_strtoi64(str, &endptr, 0, &res);
2284
2285	g_assert_cmpint(err, ==, 0);
2286	g_assert_cmpint(res, ==, -321);
2287	g_assert_true(endptr == str + strlen(str));
2288	}
2289
2290	static void test_qemu_strtoi64_negzero(void)
2291	{
2292	const char *str = " -0";
2293	char f = 'X';
2294	const char *endptr = &f;
2295	int64_t res = 999;
2296	int err;
2297
2298	err = qemu_strtoi64(str, &endptr, 0, &res);
2299
2300	g_assert_cmpint(err, ==, 0);
2301	g_assert_cmpint(res, ==, 0);
2302	g_assert_true(endptr == str + strlen(str));
2303	}
2304
2305	static void test_qemu_strtoi64_full_correct(void)
2306	{
2307	const char *str = "123";
2308	int64_t res = 999;
2309	int err;
2310
2311	err = qemu_strtoi64(str, NULL, 0, &res);
2312
2313	g_assert_cmpint(err, ==, 0);
2314	g_assert_cmpint(res, ==, 123);
2315	}
2316
2317	static void test_qemu_strtoi64_full_null(void)
2318	{
2319	int64_t res = 999;
2320	int err;
2321
2322	err = qemu_strtoi64(NULL, NULL, 0, &res);
2323
2324	g_assert_cmpint(err, ==, -EINVAL);
2325	g_assert_cmpint(res, ==, 0);
2326	}
2327
2328	static void test_qemu_strtoi64_full_empty(void)
2329	{
2330	const char *str = "";
2331	int64_t res = 999;
2332	int err;
2333
2334	err = qemu_strtoi64(str, NULL, 0, &res);
2335
2336	g_assert_cmpint(err, ==, -EINVAL);
2337	g_assert_cmpint(res, ==, 0);
2338	}
2339
2340	static void test_qemu_strtoi64_full_negative(void)
2341	{
2342	const char *str = " \t -321";
2343	int64_t res = 999;
2344	int err;
2345
2346	err = qemu_strtoi64(str, NULL, 0, &res);
2347
2348	g_assert_cmpint(err, ==, 0);
2349	g_assert_cmpint(res, ==, -321);
2350	}
2351
2352	static void test_qemu_strtoi64_full_negzero(void)
2353	{
2354	const char *str = " -0";
2355	int64_t res = 999;
2356	int err;
2357
2358	err = qemu_strtoi64(str, NULL, 0, &res);
2359
2360	g_assert_cmpint(err, ==, 0);
2361	g_assert_cmpint(res, ==, 0);
2362	}
2363
2364	static void test_qemu_strtoi64_full_trailing(void)
2365	{
2366	const char *str = "123xxx";
2367	int64_t res = 999;
2368	int err;
2369
2370	err = qemu_strtoi64(str, NULL, 0, &res);
2371
2372	g_assert_cmpint(err, ==, -EINVAL);
2373	g_assert_cmpint(res, ==, 123);
2374	}
2375
2376	static void test_qemu_strtoi64_full_max(void)
2377	{
2378
2379	char *str = g_strdup_printf("%lld", LLONG_MAX);
2380	int64_t res = 999;
2381	int err;
2382
2383	err = qemu_strtoi64(str, NULL, 0, &res);
2384
2385	g_assert_cmpint(err, ==, 0);
2386	g_assert_cmpint(res, ==, LLONG_MAX);
2387	g_free(str);
2388	}
2389
2390	static void test_qemu_strtoi64_full_erange_junk(void)
2391	{
2392	/* EINVAL has priority over ERANGE */
2393	const char *str = "-99999999999999999999junk";
2394	int64_t res = 999;
2395	int err;
2396
2397	err = qemu_strtoi64(str, NULL, 0, &res);
2398
2399	g_assert_cmpint(err, ==, -EINVAL);
2400	g_assert_cmpint(res, ==, INT64_MIN);
2401	}
2402
2403	static void test_qemu_strtou64_correct(void)
2404	{
2405	const char *str = "12345 foo";
2406	char f = 'X';
2407	const char *endptr = &f;
2408	uint64_t res = 999;
2409	int err;
2410
2411	err = qemu_strtou64(str, &endptr, 0, &res);
2412
2413	g_assert_cmpint(err, ==, 0);
2414	g_assert_cmpuint(res, ==, 12345);
2415	g_assert_true(endptr == str + 5);
2416	}
2417
2418	static void test_qemu_strtou64_null(void)
2419	{
2420	char f = 'X';
2421	const char *endptr = &f;
2422	uint64_t res = 999;
2423	int err;
2424
2425	err = qemu_strtou64(NULL, &endptr, 0, &res);
2426
2427	g_assert_cmpint(err, ==, -EINVAL);
2428	g_assert_cmpuint(res, ==, 0);
2429	g_assert_null(endptr);
2430	}
2431
2432	static void test_qemu_strtou64_empty(void)
2433	{
2434	const char *str = "";
2435	char f = 'X';
2436	const char *endptr = &f;
2437	uint64_t res = 999;
2438	int err;
2439
2440	err = qemu_strtou64(str, &endptr, 0, &res);
2441
2442	g_assert_cmpint(err, ==, -EINVAL);
2443	g_assert_cmpuint(res, ==, 0);
2444	g_assert_true(endptr == str);
2445	}
2446
2447	static void test_qemu_strtou64_whitespace(void)
2448	{
2449	const char *str = " \t ";
2450	char f = 'X';
2451	const char *endptr = &f;
2452	uint64_t res = 999;
2453	int err;
2454
2455	err = qemu_strtou64(str, &endptr, 0, &res);
2456
2457	g_assert_cmpint(err, ==, -EINVAL);
2458	g_assert_cmpuint(res, ==, 0);
2459	g_assert_true(endptr == str);
2460	}
2461
2462	static void test_qemu_strtou64_invalid(void)
2463	{
2464	const char *str = " xxxx \t abc";
2465	char f = 'X';
2466	const char *endptr = &f;
2467	uint64_t res = 999;
2468	int err;
2469
2470	err = qemu_strtou64(str, &endptr, 0, &res);
2471
2472	g_assert_cmpint(err, ==, -EINVAL);
2473	g_assert_cmpuint(res, ==, 0);
2474	g_assert_true(endptr == str);
2475	}
2476
2477	static void test_qemu_strtou64_trailing(void)
2478	{
2479	const char *str = "123xxx";
2480	char f = 'X';
2481	const char *endptr = &f;
2482	uint64_t res = 999;
2483	int err;
2484
2485	err = qemu_strtou64(str, &endptr, 0, &res);
2486
2487	g_assert_cmpint(err, ==, 0);
2488	g_assert_cmpuint(res, ==, 123);
2489	g_assert_true(endptr == str + 3);
2490	}
2491
2492	static void test_qemu_strtou64_octal(void)
2493	{
2494	const char *str = "0123";
2495	char f = 'X';
2496	const char *endptr = &f;
2497	uint64_t res = 999;
2498	int err;
2499
2500	err = qemu_strtou64(str, &endptr, 8, &res);
2501
2502	g_assert_cmpint(err, ==, 0);
2503	g_assert_cmpuint(res, ==, 0123);
2504	g_assert_true(endptr == str + strlen(str));
2505
2506	endptr = &f;
2507	res = 999;
2508	err = qemu_strtou64(str, &endptr, 0, &res);
2509
2510	g_assert_cmpint(err, ==, 0);
2511	g_assert_cmpuint(res, ==, 0123);
2512	g_assert_true(endptr == str + strlen(str));
2513	}
2514
2515	static void test_qemu_strtou64_decimal(void)
2516	{
2517	const char *str = "0123";
2518	char f = 'X';
2519	const char *endptr = &f;
2520	uint64_t res = 999;
2521	int err;
2522
2523	err = qemu_strtou64(str, &endptr, 10, &res);
2524
2525	g_assert_cmpint(err, ==, 0);
2526	g_assert_cmpuint(res, ==, 123);
2527	g_assert_true(endptr == str + strlen(str));
2528
2529	str = "123";
2530	endptr = &f;
2531	res = 999;
2532	err = qemu_strtou64(str, &endptr, 0, &res);
2533
2534	g_assert_cmpint(err, ==, 0);
2535	g_assert_cmpuint(res, ==, 123);
2536	g_assert_true(endptr == str + strlen(str));
2537	}
2538
2539	static void test_qemu_strtou64_hex(void)
2540	{
2541	const char *str = "0123";
2542	char f = 'X';
2543	const char *endptr = &f;
2544	uint64_t res = 999;
2545	int err;
2546
2547	err = qemu_strtou64(str, &endptr, 16, &res);
2548
2549	g_assert_cmpint(err, ==, 0);
2550	g_assert_cmphex(res, ==, 0x123);
2551	g_assert_true(endptr == str + strlen(str));
2552
2553	str = "0x123";
2554	endptr = &f;
2555	res = 999;
2556	err = qemu_strtou64(str, &endptr, 0, &res);
2557
2558	g_assert_cmpint(err, ==, 0);
2559	g_assert_cmphex(res, ==, 0x123);
2560	g_assert_true(endptr == str + strlen(str));
2561
2562	str = "0x";
2563	endptr = &f;
2564	res = 999;
2565	err = qemu_strtou64(str, &endptr, 16, &res);
2566
2567	g_assert_cmpint(err, ==, 0);
2568	g_assert_cmphex(res, ==, 0);
2569	g_assert_true(endptr == str + 1);
2570	}
2571
2572	static void test_qemu_strtou64_wrap(void)
2573	{
2574	const char str = "-18446744073709551615"; / 1 mod 2^64 */
2575	char f = 'X';
2576	const char *endptr = &f;
2577	uint64_t res = 999;
2578	int err;
2579
2580	err = qemu_strtou64(str, &endptr, 0, &res);
2581
2582	g_assert_cmpint(err, ==, 0);
2583	g_assert_cmpuint(res, ==, 1);
2584	g_assert_true(endptr == str + strlen(str));
2585	}
2586
2587	static void test_qemu_strtou64_max(void)
2588	{
2589	char *str = g_strdup_printf("%llu", ULLONG_MAX);
2590	char f = 'X';
2591	const char *endptr = &f;
2592	uint64_t res = 999;
2593	int err;
2594
2595	err = qemu_strtou64(str, &endptr, 0, &res);
2596
2597	g_assert_cmpint(err, ==, 0);
2598	g_assert_cmphex(res, ==, ULLONG_MAX);
2599	g_assert_true(endptr == str + strlen(str));
2600	g_free(str);
2601	}
2602
2603	static void test_qemu_strtou64_overflow(void)
2604	{
2605	const char *str;
2606	const char *endptr;
2607	uint64_t res;
2608	int err;
2609
2610	str = "18446744073709551616"; /* 1 more than UINT64_MAX */
2611	endptr = "somewhere";
2612	res = 999;
2613	err = qemu_strtou64(str, &endptr, 0, &res);
2614	g_assert_cmpint(err, ==, -ERANGE);
2615	g_assert_cmpuint(res, ==, UINT64_MAX);
2616	g_assert_true(endptr == str + strlen(str));
2617
2618	str = "0x10000000000000000"; /* 65 bits, 64-bit sign bit clear */
2619	endptr = "somewhere";
2620	res = 999;
2621	err = qemu_strtou64(str, &endptr, 0, &res);
2622	g_assert_cmpint(err, ==, -ERANGE);
2623	g_assert_cmpuint(res, ==, UINT64_MAX);
2624	g_assert_true(endptr == str + strlen(str));
2625
2626	str = "0x18000000080000000"; /* 65 bits, 64-bit sign bit set */
2627	endptr = "somewhere";
2628	res = 999;
2629	err = qemu_strtou64(str, &endptr, 0, &res);
2630	g_assert_cmpint(err, ==, -ERANGE);
2631	g_assert_cmpuint(res, ==, UINT64_MAX);
2632	g_assert_true(endptr == str + strlen(str));
2633	}
2634
2635	static void test_qemu_strtou64_underflow(void)
2636	{
2637	const char *str;
2638	const char *endptr;
2639	uint64_t res;
2640	int err;
2641
2642	str = "-99999999999999999999999999999999999999999999";
2643	endptr = "somewhere";
2644	res = 999;
2645	err = qemu_strtou64(str, &endptr, 0, &res);
2646	g_assert_cmpint(err, ==, -ERANGE);
2647	g_assert_cmpuint(res, ==, UINT64_MAX);
2648	g_assert_true(endptr == str + strlen(str));
2649
2650	str = "-0x10000000000000000"; /* 65 bits, 64-bit sign bit clear */
2651	endptr = "somewhere";
2652	res = 999;
2653	err = qemu_strtou64(str, &endptr, 0, &res);
2654	g_assert_cmpint(err, ==, -ERANGE);
2655	g_assert_cmpuint(res, ==, UINT64_MAX);
2656	g_assert_true(endptr == str + strlen(str));
2657
2658	str = "-0x18000000080000000"; /* 65 bits, 64-bit sign bit set */
2659	endptr = "somewhere";
2660	res = 999;
2661	err = qemu_strtou64(str, &endptr, 0, &res);
2662	g_assert_cmpint(err, ==, -ERANGE);
2663	g_assert_cmpuint(res, ==, UINT64_MAX);
2664	g_assert_true(endptr == str + strlen(str));
2665	}
2666
2667	static void test_qemu_strtou64_negative(void)
2668	{
2669	const char *str = " \t -321";
2670	char f = 'X';
2671	const char *endptr = &f;
2672	uint64_t res = 999;
2673	int err;
2674
2675	err = qemu_strtou64(str, &endptr, 0, &res);
2676
2677	g_assert_cmpint(err, ==, 0);
2678	g_assert_cmpuint(res, ==, -321ull);
2679	g_assert_true(endptr == str + strlen(str));
2680	}
2681
2682	static void test_qemu_strtou64_negzero(void)
2683	{
2684	const char *str = " -0";
2685	char f = 'X';
2686	const char *endptr = &f;
2687	uint64_t res = 999;
2688	int err;
2689
2690	err = qemu_strtou64(str, &endptr, 0, &res);
2691
2692	g_assert_cmpint(err, ==, 0);
2693	g_assert_cmpuint(res, ==, 0);
2694	g_assert_true(endptr == str + strlen(str));
2695	}
2696
2697	static void test_qemu_strtou64_full_correct(void)
2698	{
2699	const char *str = "18446744073709551614";
2700	uint64_t res = 999;
2701	int err;
2702
2703	err = qemu_strtou64(str, NULL, 0, &res);
2704
2705	g_assert_cmpint(err, ==, 0);
2706	g_assert_cmpuint(res, ==, 18446744073709551614ull);
2707	}
2708
2709	static void test_qemu_strtou64_full_null(void)
2710	{
2711	uint64_t res = 999;
2712	int err;
2713
2714	err = qemu_strtou64(NULL, NULL, 0, &res);
2715
2716	g_assert_cmpint(err, ==, -EINVAL);
2717	g_assert_cmpuint(res, ==, 0);
2718	}
2719
2720	static void test_qemu_strtou64_full_empty(void)
2721	{
2722	const char *str = "";
2723	uint64_t res = 999;
2724	int err;
2725
2726	err = qemu_strtou64(str, NULL, 0, &res);
2727
2728	g_assert_cmpint(err, ==, -EINVAL);
2729	g_assert_cmpuint(res, ==, 0);
2730	}
2731
2732	static void test_qemu_strtou64_full_negative(void)
2733	{
2734	const char *str = " \t -321";
2735	uint64_t res = 999;
2736	int err;
2737
2738	err = qemu_strtou64(str, NULL, 0, &res);
2739
2740	g_assert_cmpint(err, ==, 0);
2741	g_assert_cmpuint(res, ==, -321ull);
2742	}
2743
2744	static void test_qemu_strtou64_full_negzero(void)
2745	{
2746	const char *str = " -0";
2747	uint64_t res = 999;
2748	int err;
2749
2750	err = qemu_strtou64(str, NULL, 0, &res);
2751
2752	g_assert_cmpint(err, ==, 0);
2753	g_assert_cmpuint(res, ==, 0);
2754	}
2755
2756	static void test_qemu_strtou64_full_trailing(void)
2757	{
2758	const char *str = "18446744073709551614xxxxxx";
2759	uint64_t res = 999;
2760	int err;
2761
2762	err = qemu_strtou64(str, NULL, 0, &res);
2763
2764	g_assert_cmpint(err, ==, -EINVAL);
2765	g_assert_cmpuint(res, ==, 18446744073709551614ULL);
2766	}
2767
2768	static void test_qemu_strtou64_full_max(void)
2769	{
2770	char *str = g_strdup_printf("%lld", ULLONG_MAX);
2771	uint64_t res = 999;
2772	int err;
2773
2774	err = qemu_strtou64(str, NULL, 0, &res);
2775
2776	g_assert_cmpint(err, ==, 0);
2777	g_assert_cmphex(res, ==, ULLONG_MAX);
2778	g_free(str);
2779	}
2780
2781	static void test_qemu_strtou64_full_erange_junk(void)
2782	{
2783	/* EINVAL has priority over ERANGE */
2784	const char *str = "-99999999999999999999junk";
2785	uint64_t res = 999;
2786	int err;
2787
2788	err = qemu_strtou64(str, NULL, 0, &res);
2789
2790	g_assert_cmpint(err, ==, -EINVAL);
2791	g_assert_cmpuint(res, ==, UINT64_MAX);
2792	}
2793
2794	static void test_qemu_strtod_simple(void)
2795	{
2796	const char *str;
2797	const char *endptr;
2798	int err;
2799	double res;
2800
2801	/* no radix or exponent */
2802	str = "1";
2803	endptr = "somewhere";
2804	res = 999;
2805	err = qemu_strtod(str, &endptr, &res);
2806	g_assert_cmpint(err, ==, 0);
2807	g_assert_cmpfloat(res, ==, 1.0);
2808	g_assert_true(endptr == str + 1);
2809
2810	/* leading space and sign */
2811	str = " -0.0";
2812	endptr = "somewhere";
2813	res = 999;
2814	err = qemu_strtod(str, &endptr, &res);
2815	g_assert_cmpint(err, ==, 0);
2816	g_assert_cmpfloat(res, ==, -0.0);
2817	g_assert_true(signbit(res));
2818	g_assert_true(endptr == str + 5);
2819
2820	/* fraction only */
2821	str = "+.5";
2822	endptr = "somewhere";
2823	res = 999;
2824	err = qemu_strtod(str, &endptr, &res);
2825	g_assert_cmpint(err, ==, 0);
2826	g_assert_cmpfloat(res, ==, 0.5);
2827	g_assert_true(endptr == str + 3);
2828
2829	/* exponent */
2830	str = "1.e+1";
2831	endptr = "somewhere";
2832	res = 999;
2833	err = qemu_strtod(str, &endptr, &res);
2834	g_assert_cmpint(err, ==, 0);
2835	g_assert_cmpfloat(res, ==, 10.0);
2836	g_assert_true(endptr == str + 5);
2837
2838	/* hex without radix */
2839	str = "0x10";
2840	endptr = "somewhere";
2841	res = 999;
2842	err = qemu_strtod(str, &endptr, &res);
2843	g_assert_cmpint(err, ==, 0);
2844	g_assert_cmpfloat(res, ==, 16.0);
2845	g_assert_true(endptr == str + 4);
2846	}
2847
2848	static void test_qemu_strtod_einval(void)
2849	{
2850	const char *str;
2851	const char *endptr;
2852	int err;
2853	double res;
2854
2855	/* empty */
2856	str = "";
2857	endptr = "somewhere";
2858	res = 999;
2859	err = qemu_strtod(str, &endptr, &res);
2860	g_assert_cmpint(err, ==, -EINVAL);
2861	g_assert_cmpfloat(res, ==, 0.0);
2862	g_assert_false(signbit(res));
2863	g_assert_true(endptr == str);
2864
2865	/* NULL */
2866	str = NULL;
2867	endptr = "random";
2868	res = 999;
2869	err = qemu_strtod(str, &endptr, &res);
2870	g_assert_cmpint(err, ==, -EINVAL);
2871	g_assert_cmpfloat(res, ==, 0.0);
2872	g_assert_false(signbit(res));
2873	g_assert_null(endptr);
2874
2875	/* not recognizable */
2876	str = " junk";
2877	endptr = "somewhere";
2878	res = 999;
2879	err = qemu_strtod(str, &endptr, &res);
2880	g_assert_cmpint(err, ==, -EINVAL);
2881	g_assert_cmpfloat(res, ==, 0.0);
2882	g_assert_false(signbit(res));
2883	g_assert_true(endptr == str);
2884	}
2885
2886	static void test_qemu_strtod_erange(void)
2887	{
2888	const char *str;
2889	const char *endptr;
2890	int err;
2891	double res;
2892
2893	/* overflow */
2894	str = "9e999";
2895	endptr = "somewhere";
2896	res = 999;
2897	err = qemu_strtod(str, &endptr, &res);
2898	g_assert_cmpint(err, ==, -ERANGE);
2899	g_assert_cmpfloat(res, ==, HUGE_VAL);
2900	g_assert_true(endptr == str + 5);
2901
2902	str = "-9e+999";
2903	endptr = "somewhere";
2904	res = 999;
2905	err = qemu_strtod(str, &endptr, &res);
2906	g_assert_cmpint(err, ==, -ERANGE);
2907	g_assert_cmpfloat(res, ==, -HUGE_VAL);
2908	g_assert_true(endptr == str + 7);
2909
2910	/* underflow */
2911	str = "-9e-999";
2912	endptr = "somewhere";
2913	res = 999;
2914	err = qemu_strtod(str, &endptr, &res);
2915	g_assert_cmpint(err, ==, -ERANGE);
2916	g_assert_cmpfloat(res, >=, -DBL_MIN);
2917	g_assert_cmpfloat(res, <=, -0.0);
2918	g_assert_true(signbit(res));
2919	g_assert_true(endptr == str + 7);
2920	}
2921
2922	static void test_qemu_strtod_nonfinite(void)
2923	{
2924	const char *str;
2925	const char *endptr;
2926	int err;
2927	double res;
2928
2929	/* infinity */
2930	str = "inf";
2931	endptr = "somewhere";
2932	res = 999;
2933	err = qemu_strtod(str, &endptr, &res);
2934	g_assert_cmpint(err, ==, 0);
2935	g_assert_true(isinf(res));
2936	g_assert_false(signbit(res));
2937	g_assert_true(endptr == str + 3);
2938
2939	str = "-infinity";
2940	endptr = "somewhere";
2941	res = 999;
2942	err = qemu_strtod(str, &endptr, &res);
2943	g_assert_cmpint(err, ==, 0);
2944	g_assert_true(isinf(res));
2945	g_assert_true(signbit(res));
2946	g_assert_true(endptr == str + 9);
2947
2948	/* not a number */
2949	str = " NaN";
2950	endptr = "somewhere";
2951	res = 999;
2952	err = qemu_strtod(str, &endptr, &res);
2953	g_assert_cmpint(err, ==, 0);
2954	g_assert_true(isnan(res));
2955	g_assert_true(endptr == str + 4);
2956	}
2957
2958	static void test_qemu_strtod_trailing(void)
2959	{
2960	const char *str;
2961	const char *endptr;
2962	int err;
2963	double res;
2964
2965	/* trailing whitespace */
2966	str = "1. ";
2967	endptr = "somewhere";
2968	res = 999;
2969	err = qemu_strtod(str, &endptr, &res);
2970	g_assert_cmpint(err, ==, 0);
2971	g_assert_cmpfloat(res, ==, 1.0);
2972	g_assert_true(endptr == str + 2);
2973
2974	endptr = "somewhere";
2975	res = 999;
2976	err = qemu_strtod(str, NULL, &res);
2977	g_assert_cmpint(err, ==, -EINVAL);
2978	g_assert_cmpfloat(res, ==, 1.0);
2979
2980	/* trailing e is not an exponent */
2981	str = ".5e";
2982	endptr = "somewhere";
2983	res = 999;
2984	err = qemu_strtod(str, &endptr, &res);
2985	g_assert_cmpint(err, ==, 0);
2986	g_assert_cmpfloat(res, ==, 0.5);
2987	g_assert_true(endptr == str + 2);
2988
2989	endptr = "somewhere";
2990	res = 999;
2991	err = qemu_strtod(str, NULL, &res);
2992	g_assert_cmpint(err, ==, -EINVAL);
2993	g_assert_cmpfloat(res, ==, 0.5);
2994
2995	/* trailing ( not part of long NaN */
2996	str = "nan(";
2997	endptr = "somewhere";
2998	res = 999;
2999	err = qemu_strtod(str, &endptr, &res);
3000	g_assert_cmpint(err, ==, 0);
3001	g_assert_true(isnan(res));
3002	g_assert_true(endptr == str + 3);
3003
3004	endptr = "somewhere";
3005	res = 999;
3006	err = qemu_strtod(str, NULL, &res);
3007	g_assert_cmpint(err, ==, -EINVAL);
3008	g_assert_true(isnan(res));
3009	}
3010
3011	static void test_qemu_strtod_erange_junk(void)
3012	{
3013	const char *str;
3014	const char *endptr;
3015	int err;
3016	double res;
3017
3018	/* ERANGE with trailing junk... */
3019	str = "1e-999junk";
3020	endptr = "somewhere";
3021	res = 999;
3022	err = qemu_strtod(str, &endptr, &res);
3023	g_assert_cmpint(err, ==, -ERANGE);
3024	g_assert_cmpfloat(res, <=, DBL_MIN);
3025	g_assert_cmpfloat(res, >=, 0.0);
3026	g_assert_false(signbit(res));
3027	g_assert_true(endptr == str + 6);
3028
3029	/* ...has less priority than EINVAL when full parse not possible */
3030	endptr = "somewhere";
3031	res = 999;
3032	err = qemu_strtod(str, NULL, &res);
3033	g_assert_cmpint(err, ==, -EINVAL);
3034	g_assert_cmpfloat(res, ==, 0.0);
3035	g_assert_false(signbit(res));
3036	}
3037
3038	static void test_qemu_strtod_finite_simple(void)
3039	{
3040	const char *str;
3041	const char *endptr;
3042	int err;
3043	double res;
3044
3045	/* no radix or exponent */
3046	str = "1";
3047	endptr = "somewhere";
3048	res = 999;
3049	err = qemu_strtod_finite(str, &endptr, &res);
3050	g_assert_cmpint(err, ==, 0);
3051	g_assert_cmpfloat(res, ==, 1.0);
3052	g_assert_true(endptr == str + 1);
3053
3054	/* leading space and sign */
3055	str = " -0.0";
3056	endptr = "somewhere";
3057	res = 999;
3058	err = qemu_strtod_finite(str, &endptr, &res);
3059	g_assert_cmpint(err, ==, 0);
3060	g_assert_cmpfloat(res, ==, -0.0);
3061	g_assert_true(signbit(res));
3062	g_assert_true(endptr == str + 5);
3063
3064	/* fraction only */
3065	str = "+.5";
3066	endptr = "somewhere";
3067	res = 999;
3068	err = qemu_strtod_finite(str, &endptr, &res);
3069	g_assert_cmpint(err, ==, 0);
3070	g_assert_cmpfloat(res, ==, 0.5);
3071	g_assert_true(endptr == str + 3);
3072
3073	/* exponent */
3074	str = "1.e+1";
3075	endptr = "somewhere";
3076	res = 999;
3077	err = qemu_strtod_finite(str, &endptr, &res);
3078	g_assert_cmpint(err, ==, 0);
3079	g_assert_cmpfloat(res, ==, 10.0);
3080	g_assert_true(endptr == str + 5);
3081
3082	/* hex without radix */
3083	str = "0x10";
3084	endptr = "somewhere";
3085	res = 999;
3086	err = qemu_strtod(str, &endptr, &res);
3087	g_assert_cmpint(err, ==, 0);
3088	g_assert_cmpfloat(res, ==, 16.0);
3089	g_assert_true(endptr == str + 4);
3090	}
3091
3092	static void test_qemu_strtod_finite_einval(void)
3093	{
3094	const char *str;
3095	const char *endptr;
3096	int err;
3097	double res;
3098
3099	/* empty */
3100	str = "";
3101	endptr = "somewhere";
3102	res = 999;
3103	err = qemu_strtod_finite(str, &endptr, &res);
3104	g_assert_cmpint(err, ==, -EINVAL);
3105	g_assert_cmpfloat(res, ==, 0.0);
3106	g_assert_false(signbit(res));
3107	g_assert_true(endptr == str);
3108
3109	/* NULL */
3110	str = NULL;
3111	endptr = "random";
3112	res = 999;
3113	err = qemu_strtod_finite(str, &endptr, &res);
3114	g_assert_cmpint(err, ==, -EINVAL);
3115	g_assert_cmpfloat(res, ==, 0.0);
3116	g_assert_false(signbit(res));
3117	g_assert_null(endptr);
3118
3119	/* not recognizable */
3120	str = " junk";
3121	endptr = "somewhere";
3122	res = 999;
3123	err = qemu_strtod_finite(str, &endptr, &res);
3124	g_assert_cmpint(err, ==, -EINVAL);
3125	g_assert_cmpfloat(res, ==, 0.0);
3126	g_assert_false(signbit(res));
3127	g_assert_true(endptr == str);
3128	}
3129
3130	static void test_qemu_strtod_finite_erange(void)
3131	{
3132	const char *str;
3133	const char *endptr;
3134	int err;
3135	double res;
3136
3137	/* overflow turns into EINVAL */
3138	str = "9e999";
3139	endptr = "somewhere";
3140	res = 999;
3141	err = qemu_strtod_finite(str, &endptr, &res);
3142	g_assert_cmpint(err, ==, -EINVAL);
3143	g_assert_cmpfloat(res, ==, 0.0);
3144	g_assert_false(signbit(res));
3145	g_assert_true(endptr == str);
3146
3147	str = "-9e+999";
3148	endptr = "somewhere";
3149	res = 999;
3150	err = qemu_strtod_finite(str, &endptr, &res);
3151	g_assert_cmpint(err, ==, -EINVAL);
3152	g_assert_cmpfloat(res, ==, 0.0);
3153	g_assert_false(signbit(res));
3154	g_assert_true(endptr == str);
3155
3156	/* underflow is still possible */
3157	str = "-9e-999";
3158	endptr = "somewhere";
3159	res = 999;
3160	err = qemu_strtod_finite(str, &endptr, &res);
3161	g_assert_cmpint(err, ==, -ERANGE);
3162	g_assert_cmpfloat(res, >=, -DBL_MIN);
3163	g_assert_cmpfloat(res, <=, -0.0);
3164	g_assert_true(signbit(res));
3165	g_assert_true(endptr == str + 7);
3166	}
3167
3168	static void test_qemu_strtod_finite_nonfinite(void)
3169	{
3170	const char *str;
3171	const char *endptr;
3172	int err;
3173	double res;
3174
3175	/* infinity */
3176	str = "inf";
3177	endptr = "somewhere";
3178	res = 999;
3179	err = qemu_strtod_finite(str, &endptr, &res);
3180	g_assert_cmpint(err, ==, -EINVAL);
3181	g_assert_cmpfloat(res, ==, 0.0);
3182	g_assert_false(signbit(res));
3183	g_assert_true(endptr == str);
3184
3185	str = "-infinity";
3186	endptr = "somewhere";
3187	res = 999;
3188	err = qemu_strtod_finite(str, &endptr, &res);
3189	g_assert_cmpint(err, ==, -EINVAL);
3190	g_assert_cmpfloat(res, ==, 0.0);
3191	g_assert_false(signbit(res));
3192	g_assert_true(endptr == str);
3193
3194	/* not a number */
3195	str = " NaN";
3196	endptr = "somewhere";
3197	res = 999;
3198	err = qemu_strtod_finite(str, &endptr, &res);
3199	g_assert_cmpint(err, ==, -EINVAL);
3200	g_assert_cmpfloat(res, ==, 0.0);
3201	g_assert_false(signbit(res));
3202	g_assert_true(endptr == str);
3203	}
3204
3205	static void test_qemu_strtod_finite_trailing(void)
3206	{
3207	const char *str;
3208	const char *endptr;
3209	int err;
3210	double res;
3211
3212	/* trailing whitespace */
3213	str = "1. ";
3214	endptr = "somewhere";
3215	res = 999;
3216	err = qemu_strtod_finite(str, &endptr, &res);
3217	g_assert_cmpint(err, ==, 0);
3218	g_assert_cmpfloat(res, ==, 1.0);
3219	g_assert_true(endptr == str + 2);
3220
3221	endptr = "somewhere";
3222	res = 999;
3223	err = qemu_strtod_finite(str, NULL, &res);
3224	g_assert_cmpint(err, ==, -EINVAL);
3225	g_assert_cmpfloat(res, ==, 1.0);
3226	g_assert_false(signbit(res));
3227
3228	/* trailing e is not an exponent */
3229	str = ".5e";
3230	endptr = "somewhere";
3231	res = 999;
3232	err = qemu_strtod_finite(str, &endptr, &res);
3233	g_assert_cmpint(err, ==, 0);
3234	g_assert_cmpfloat(res, ==, 0.5);
3235	g_assert_true(endptr == str + 2);
3236
3237	endptr = "somewhere";
3238	res = 999;
3239	err = qemu_strtod_finite(str, NULL, &res);
3240	g_assert_cmpint(err, ==, -EINVAL);
3241	g_assert_cmpfloat(res, ==, 0.5);
3242
3243	/* trailing ( not part of long NaN */
3244	str = "nan(";
3245	endptr = "somewhere";
3246	res = 999;
3247	err = qemu_strtod_finite(str, &endptr, &res);
3248	g_assert_cmpint(err, ==, -EINVAL);
3249	g_assert_cmpfloat(res, ==, 0.0);
3250	g_assert_false(signbit(res));
3251	g_assert_true(endptr == str);
3252
3253	endptr = "somewhere";
3254	res = 999;
3255	err = qemu_strtod_finite(str, NULL, &res);
3256	g_assert_cmpint(err, ==, -EINVAL);
3257	g_assert_cmpfloat(res, ==, 0.0);
3258	g_assert_false(signbit(res));
3259	}
3260
3261	static void test_qemu_strtod_finite_erange_junk(void)
3262	{
3263	const char *str;
3264	const char *endptr;
3265	int err;
3266	double res;
3267
3268	/* ERANGE with trailing junk... */
3269	str = "1e-999junk";
3270	endptr = "somewhere";
3271	res = 999;
3272	err = qemu_strtod_finite(str, &endptr, &res);
3273	g_assert_cmpint(err, ==, -ERANGE);
3274	g_assert_cmpfloat(res, <=, DBL_MIN);
3275	g_assert_cmpfloat(res, >=, 0.0);
3276	g_assert_false(signbit(res));
3277	g_assert_true(endptr == str + 6);
3278
3279	/* ...has less priority than EINVAL when full parse not possible */
3280	endptr = "somewhere";
3281	res = 999;
3282	err = qemu_strtod_finite(str, NULL, &res);
3283	g_assert_cmpint(err, ==, -EINVAL);
3284	g_assert_cmpfloat(res, ==, 0.0);
3285	g_assert_false(signbit(res));
3286	}
3287
3288	typedef int (qemu_strtosz_fn)(const char , const char *, uint64_t );
3289	static void do_strtosz_full(const char *str, qemu_strtosz_fn fn,
3290	int exp_ptr_ret, uint64_t exp_ptr_val,
3291	size_t exp_ptr_offset, int exp_null_ret,
3292	uint64_t exp_null_val)
3293	{
3294	const char *endptr = "somewhere";
3295	uint64_t val = 0xbaadf00d;
3296	int ret;
3297
3298	ret = fn(str, &endptr, &val);
3299	g_assert_cmpint(ret, ==, exp_ptr_ret);
3300	g_assert_cmpuint(val, ==, exp_ptr_val);
3301	if (str) {
3302	g_assert_true(endptr == str + exp_ptr_offset);
3303	} else {
3304	g_assert_cmpint(exp_ptr_offset, ==, 0);
3305	g_assert_null(endptr);
3306	}
3307
3308	val = 0xbaadf00d;
3309	ret = fn(str, NULL, &val);
3310	g_assert_cmpint(ret, ==, exp_null_ret);
3311	g_assert_cmpuint(val, ==, exp_null_val);
3312	}
3313
3314	static void do_strtosz(const char *str, int exp_ret, uint64_t exp_val,
3315	size_t exp_offset)
3316	{
3317	do_strtosz_full(str, qemu_strtosz, exp_ret, exp_val, exp_offset,
3318	exp_ret, exp_val);
3319	}
3320
3321	static void do_strtosz_MiB(const char *str, int exp_ret, uint64_t exp_val,
3322	size_t exp_offset)
3323	{
3324	do_strtosz_full(str, qemu_strtosz_MiB, exp_ret, exp_val, exp_offset,
3325	exp_ret, exp_val);
3326	}
3327
3328	static void do_strtosz_metric(const char *str, int exp_ret, uint64_t exp_val,
3329	size_t exp_offset)
3330	{
3331	do_strtosz_full(str, qemu_strtosz_metric, exp_ret, exp_val, exp_offset,
3332	exp_ret, exp_val);
3333	}
3334
3335	static void test_qemu_strtosz_simple(void)
3336	{
3337	do_strtosz("0", 0, 0, 1);
3338
3339	/* Leading 0 gives decimal results, not octal */
3340	do_strtosz("08", 0, 8, 2);
3341
3342	/* Leading space and + are ignored */
3343	do_strtosz(" +12345", 0, 12345, 7);
3344
3345	/* 2^53-1 */
3346	do_strtosz("9007199254740991", 0, 0x1fffffffffffffULL, 16);
3347
3348	/* 2^53 */
3349	do_strtosz("9007199254740992", 0, 0x20000000000000ULL, 16);
3350
3351	/* 2^53+1 */
3352	do_strtosz("9007199254740993", 0, 0x20000000000001ULL, 16);
3353
3354	/* 0xfffffffffffff800 (53 msbs set) */
3355	do_strtosz("18446744073709549568", 0, 0xfffffffffffff800ULL, 20);
3356
3357	/* 0xfffffffffffffbff */
3358	do_strtosz("18446744073709550591", 0, 0xfffffffffffffbffULL, 20);
3359
3360	/* 0xffffffffffffffff */
3361	do_strtosz("18446744073709551615", 0, 0xffffffffffffffffULL, 20);
3362	}
3363
3364	static void test_qemu_strtosz_hex(void)
3365	{
3366	do_strtosz("0x0", 0, 0, 3);
3367
3368	do_strtosz("0xab", 0, 171, 4);
3369
3370	do_strtosz(" +0xae", 0, 174, 6);
3371	}
3372
3373	static void test_qemu_strtosz_units(void)
3374	{
3375	/* default scale depends on function */
3376	do_strtosz("1", 0, 1, 1);
3377	do_strtosz_MiB("1", 0, MiB, 1);
3378	do_strtosz_metric("1", 0, 1, 1);
3379
3380	/* Explicit byte suffix works for all functions */
3381	do_strtosz("1B", 0, 1, 2);
3382	do_strtosz_MiB("1B", 0, 1, 2);
3383	do_strtosz_metric("1B", 0, 1, 2);
3384
3385	/* Expose the scale */
3386	do_strtosz("1K", 0, KiB, 2);
3387	do_strtosz_MiB("1K", 0, KiB, 2);
3388	do_strtosz_metric("1K", 0, 1000, 2);
3389
3390	/* Other suffixes, see also test_qemu_strtosz_metric */
3391	do_strtosz("1M", 0, MiB, 2);
3392	do_strtosz("1G", 0, GiB, 2);
3393	do_strtosz("1T", 0, TiB, 2);
3394	do_strtosz("1P", 0, PiB, 2);
3395	do_strtosz("1E", 0, EiB, 2);
3396	}
3397
3398	static void test_qemu_strtosz_float(void)
3399	{
3400	do_strtosz("0.5E", 0, EiB / 2, 4);
3401
3402	/* Implied M suffix okay */
3403	do_strtosz_MiB("0.5", 0, MiB / 2, 3);
3404
3405	/* For convenience, a fraction of 0 is tolerated even on bytes */
3406	do_strtosz("1.0B", 0, 1, 4);
3407
3408	/* An empty fraction tail is tolerated */
3409	do_strtosz("1.k", 0, 1024, 3);
3410
3411	/* An empty fraction head is tolerated */
3412	do_strtosz(" .5k", 0, 512, 4);
3413
3414	/* For convenience, we permit values that are not byte-exact */
3415	do_strtosz("12.345M", 0, (uint64_t) (12.345 * MiB + 0.5), 7);
3416
3417	/* Fraction tail can round up */
3418	do_strtosz("1.9999k", 0, 2048, 7);
3419	do_strtosz("1.9999999999999999999999999999999999999999999999999999k", 0,
3420	2048, 55);
3421
3422	/* ERANGE underflow in the fraction tail does not matter for 'k' */
3423	do_strtosz("1."
3424	"00000000000000000000000000000000000000000000000000"
3425	"00000000000000000000000000000000000000000000000000"
3426	"00000000000000000000000000000000000000000000000000"
3427	"00000000000000000000000000000000000000000000000000"
3428	"00000000000000000000000000000000000000000000000000"
3429	"00000000000000000000000000000000000000000000000000"
3430	"00000000000000000000000000000000000000000000000000"
3431	"1k", 0, 1024, 354);
3432	}
3433
3434	static void test_qemu_strtosz_invalid(void)
3435	{
3436	do_strtosz(NULL, -EINVAL, 0, 0);
3437
3438	/* Must parse at least one digit */
3439	do_strtosz("", -EINVAL, 0, 0);
3440	do_strtosz(" \t ", -EINVAL, 0, 0);
3441	do_strtosz(".", -EINVAL, 0, 0);
3442	do_strtosz(" .", -EINVAL, 0, 0);
3443	do_strtosz(" .k", -EINVAL, 0, 0);
3444	do_strtosz("inf", -EINVAL, 0, 0);
3445	do_strtosz("NaN", -EINVAL, 0, 0);
3446
3447	/* Lone suffix is not okay */
3448	do_strtosz("k", -EINVAL, 0, 0);
3449	do_strtosz(" M", -EINVAL, 0, 0);
3450
3451	/* Fractional values require scale larger than bytes */
3452	do_strtosz("1.1B", -EINVAL, 0, 0);
3453	do_strtosz("1.1", -EINVAL, 0, 0);
3454
3455	/* 'B' cannot have any nonzero fraction, even with rounding or underflow */
3456	do_strtosz("1.00001B", -EINVAL, 0, 0);
3457	do_strtosz("1.00000000000000000001B", -EINVAL, 0, 0);
3458	do_strtosz("1."
3459	"00000000000000000000000000000000000000000000000000"
3460	"00000000000000000000000000000000000000000000000000"
3461	"00000000000000000000000000000000000000000000000000"
3462	"00000000000000000000000000000000000000000000000000"
3463	"00000000000000000000000000000000000000000000000000"
3464	"00000000000000000000000000000000000000000000000000"
3465	"00000000000000000000000000000000000000000000000000"
3466	"1B", -EINVAL, 0, 0);
3467
3468	/* No hex fractions */
3469	do_strtosz("0x1.8k", -EINVAL, 0, 0);
3470	do_strtosz("0x1.k", -EINVAL, 0, 0);
3471
3472	/* No hex suffixes */
3473	do_strtosz("0x18M", -EINVAL, 0, 0);
3474	do_strtosz("0x1p1", -EINVAL, 0, 0);
3475
3476	/* decimal in place of scaling suffix */
3477	do_strtosz("1.1.k", -EINVAL, 0, 0);
3478	do_strtosz("1.1.", -EINVAL, 0, 0);
3479	}
3480
3481	static void test_qemu_strtosz_trailing(void)
3482	{
3483	/* Trailing whitespace */
3484	do_strtosz_full("1k ", qemu_strtosz, 0, 1024, 2, -EINVAL, 0);
3485
3486	/* Unknown suffix overrides even implied scale*/
3487	do_strtosz_full("123xxx", qemu_strtosz, 0, 123, 3, -EINVAL, 0);
3488
3489	/* Implied scale allows partial parse */
3490	do_strtosz_full("123xxx", qemu_strtosz_MiB, 0, 123 * MiB, 3, -EINVAL, 0);
3491	do_strtosz_full("1.5.k", qemu_strtosz_MiB, 0, 1.5 * MiB, 3, -EINVAL, 0);
3492
3493	/* Junk after one-byte suffix */
3494	do_strtosz_full("1kiB", qemu_strtosz, 0, 1024, 2, -EINVAL, 0);
3495
3496	/* Incomplete hex is an unknown suffix */
3497	do_strtosz_full("0x", qemu_strtosz, 0, 0, 1, -EINVAL, 0);
3498
3499	/* Hex literals use only one leading zero */
3500	do_strtosz_full("00x1", qemu_strtosz, 0, 0, 2, -EINVAL, 0);
3501
3502	/* No support for binary literals; 'b' is valid suffix */
3503	do_strtosz_full("0b1000", qemu_strtosz, 0, 0, 2, -EINVAL, 0);
3504
3505	/* Junk after decimal */
3506	do_strtosz_full("0.NaN", qemu_strtosz, 0, 0, 2, -EINVAL, 0);
3507
3508	/* Although negatives are invalid, '-' may be in trailing junk */
3509	do_strtosz_full("123-45", qemu_strtosz, 0, 123, 3, -EINVAL, 0);
3510	do_strtosz_full(" 123 - 45", qemu_strtosz, 0, 123, 4, -EINVAL, 0);
3511
3512	/* Parse stops at 'e', which is not a floating point exponent */
3513	do_strtosz_full("1.5e1k", qemu_strtosz, 0, EiB * 1.5, 4, -EINVAL, 0);
3514	do_strtosz_full("1.5E+0k", qemu_strtosz, 0, EiB * 1.5, 4, -EINVAL, 0);
3515	do_strtosz_full("1.5E999", qemu_strtosz, 0, EiB * 1.5, 4, -EINVAL, 0);
3516	}
3517
3518	static void test_qemu_strtosz_erange(void)
3519	{
3520	/* no negative values */
3521	do_strtosz(" -0", -ERANGE, 0, 3);
3522	do_strtosz("-1", -ERANGE, 0, 2);
3523	do_strtosz_full("-2M", qemu_strtosz, -ERANGE, 0, 2, -EINVAL, 0);
3524	do_strtosz(" -.0", -ERANGE, 0, 4);
3525	do_strtosz_full("-.1k", qemu_strtosz, -ERANGE, 0, 3, -EINVAL, 0);
3526	do_strtosz_full(" -."
3527	"00000000000000000000000000000000000000000000000000"
3528	"00000000000000000000000000000000000000000000000000"
3529	"00000000000000000000000000000000000000000000000000"
3530	"00000000000000000000000000000000000000000000000000"
3531	"00000000000000000000000000000000000000000000000000"
3532	"00000000000000000000000000000000000000000000000000"
3533	"00000000000000000000000000000000000000000000000000"
3534	"1M", qemu_strtosz, -ERANGE, 0, 354, -EINVAL, 0);
3535
3536	/* 2^64; see strtosz_simple for 2^64-1 */
3537	do_strtosz("18446744073709551616", -ERANGE, 0, 20);
3538
3539	do_strtosz("20E", -ERANGE, 0, 3);
3540
3541	/* Fraction tail can cause ERANGE overflow */
3542	do_strtosz("15.9999999999999999999999999999999999999999999999999999E",
3543	-ERANGE, 0, 56);
3544
3545	/* EINVAL has priority over ERANGE */
3546	do_strtosz_full("100000Pjunk", qemu_strtosz, -ERANGE, 0, 7, -EINVAL, 0);
3547	}
3548
3549	static void test_qemu_strtosz_metric(void)
3550	{
3551	do_strtosz_metric("12345k", 0, 12345000, 6);
3552	do_strtosz_metric("12.345M", 0, 12345000, 7);
3553
3554	/* Fraction is affected by floating-point rounding */
3555	/* This would be 0xfffffffffffffbff with infinite precision */
3556	do_strtosz_metric("18.446744073709550591E", 0, 0xfffffffffffffc0cULL, 22);
3557	}
3558
3559	static void test_freq_to_str(void)
3560	{
3561	char *str;
3562
3563	str = freq_to_str(999);
3564	g_assert_cmpstr(str, ==, "999 Hz");
3565	g_free(str);
3566
3567	str = freq_to_str(1000);
3568	g_assert_cmpstr(str, ==, "1 KHz");
3569	g_free(str);
3570
3571	str = freq_to_str(1010);
3572	g_assert_cmpstr(str, ==, "1.01 KHz");
3573	g_free(str);
3574	}
3575
3576	static void test_size_to_str(void)
3577	{
3578	char *str;
3579
3580	str = size_to_str(0);
3581	g_assert_cmpstr(str, ==, "0 B");
3582	g_free(str);
3583
3584	str = size_to_str(1);
3585	g_assert_cmpstr(str, ==, "1 B");
3586	g_free(str);
3587
3588	str = size_to_str(1016);
3589	g_assert_cmpstr(str, ==, "0.992 KiB");
3590	g_free(str);
3591
3592	str = size_to_str(1024);
3593	g_assert_cmpstr(str, ==, "1 KiB");
3594	g_free(str);
3595
3596	str = size_to_str(512ull << 20);
3597	g_assert_cmpstr(str, ==, "512 MiB");
3598	g_free(str);
3599	}
3600
3601	static void test_iec_binary_prefix(void)
3602	{
3603	g_assert_cmpstr(iec_binary_prefix(0), ==, "");
3604	g_assert_cmpstr(iec_binary_prefix(10), ==, "Ki");
3605	g_assert_cmpstr(iec_binary_prefix(20), ==, "Mi");
3606	g_assert_cmpstr(iec_binary_prefix(30), ==, "Gi");
3607	g_assert_cmpstr(iec_binary_prefix(40), ==, "Ti");
3608	g_assert_cmpstr(iec_binary_prefix(50), ==, "Pi");
3609	g_assert_cmpstr(iec_binary_prefix(60), ==, "Ei");
3610	}
3611
3612	static void test_si_prefix(void)
3613	{
3614	g_assert_cmpstr(si_prefix(-18), ==, "a");
3615	g_assert_cmpstr(si_prefix(-15), ==, "f");
3616	g_assert_cmpstr(si_prefix(-12), ==, "p");
3617	g_assert_cmpstr(si_prefix(-9), ==, "n");
3618	g_assert_cmpstr(si_prefix(-6), ==, "u");
3619	g_assert_cmpstr(si_prefix(-3), ==, "m");
3620	g_assert_cmpstr(si_prefix(0), ==, "");
3621	g_assert_cmpstr(si_prefix(3), ==, "K");
3622	g_assert_cmpstr(si_prefix(6), ==, "M");
3623	g_assert_cmpstr(si_prefix(9), ==, "G");
3624	g_assert_cmpstr(si_prefix(12), ==, "T");
3625	g_assert_cmpstr(si_prefix(15), ==, "P");
3626	g_assert_cmpstr(si_prefix(18), ==, "E");
3627	}
3628
3629	static void test_qemu_hexdump_alignment(void)
3630	{
3631	/*
3632	* Test that ASCII part is properly aligned for incomplete lines.
3633	* This test catches the bug that was fixed in previous commit
3634	* "util/hexdump: fix QEMU_HEXDUMP_LINE_WIDTH logic".
3635	*
3636	* We use data that is not aligned to 16 bytes, so last line
3637	* is incomplete.
3638	*/
3639	static const uint8_t data[] = {
3640	/* First line: 16 bytes */
3641	0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, /* "Hello Wo" */
3642	0x72, 0x6c, 0x64, 0x21, 0x20, 0x54, 0x68, 0x69, /* "rld! Thi" */
3643	/* Second line: 5 bytes (incomplete) */
3644	0x73, 0x20, 0x69, 0x73, 0x20 /* "s is " */
3645	};
3646	char *fname = NULL;
3647	int fd;
3648	g_autofree char *output = NULL;
3649	size_t size, bytes_read;
3650	FILE *f;
3651
3652	fd = g_file_open_tmp("test-qemu-hexdump-alignment-XXXXXX", &fname, NULL);
3653	g_assert(fd >= 0);
3654	g_assert_nonnull(fname);
3655	f = fdopen(fd, "w+");
3656
3657	g_assert_nonnull(f);
3658
3659	qemu_hexdump(f, "test", data, sizeof(data));
3660
3661	size = ftell(f);
3662	fseek(f, 0, SEEK_SET);
3663
3664	output = g_malloc(size + 1);
3665	bytes_read = 0;
3666	while (bytes_read < size) {
3667	size_t chunk = fread(output + bytes_read, 1, size - bytes_read, f);
3668	if (chunk == 0) {
3669	break;
3670	}
3671	bytes_read += chunk;
3672	}
3673	g_assert_cmpuint(bytes_read, ==, size);
3674	output[size] = '\0';
3675
3676	fclose(f);
3677	unlink(fname);
3678	g_free(fname);
3679
3680	/* We expect proper alignment of "s is" part on the second line */
3681	static const char *expected =
3682	"test: 0000: 48 65 6c 6c 6f 20 57 6f 72 6c 64 21 20 54 68 69 "
3683	"Hello World! Thi\n"
3684	"test: 0010: 73 20 69 73 20 "
3685	"s is \n";
3686
3687	g_assert_cmpstr(output, ==, expected);
3688	}
3689
3690	int main(int argc, char **argv)
3691	{
3692	g_test_init(&argc, &argv, NULL);
3693
3694	g_test_add_func("/cutils/parse_uint/null", test_parse_uint_null);
3695	g_test_add_func("/cutils/parse_uint/empty", test_parse_uint_empty);
3696	g_test_add_func("/cutils/parse_uint/whitespace",
3697	test_parse_uint_whitespace);
3698	g_test_add_func("/cutils/parse_uint/invalid", test_parse_uint_invalid);
3699	g_test_add_func("/cutils/parse_uint/trailing", test_parse_uint_trailing);
3700	g_test_add_func("/cutils/parse_uint/correct", test_parse_uint_correct);
3701	g_test_add_func("/cutils/parse_uint/octal", test_parse_uint_octal);
3702	g_test_add_func("/cutils/parse_uint/decimal", test_parse_uint_decimal);
3703	g_test_add_func("/cutils/parse_uint/llong_max", test_parse_uint_llong_max);
3704	g_test_add_func("/cutils/parse_uint/max", test_parse_uint_max);
3705	g_test_add_func("/cutils/parse_uint/overflow", test_parse_uint_overflow);
3706	g_test_add_func("/cutils/parse_uint/negative", test_parse_uint_negative);
3707	g_test_add_func("/cutils/parse_uint/negzero", test_parse_uint_negzero);
3708	g_test_add_func("/cutils/parse_uint_full/trailing",
3709	test_parse_uint_full_trailing);
3710	g_test_add_func("/cutils/parse_uint_full/correct",
3711	test_parse_uint_full_correct);
3712	g_test_add_func("/cutils/parse_uint_full/erange_junk",
3713	test_parse_uint_full_erange_junk);
3714	g_test_add_func("/cutils/parse_uint_full/null",
3715	test_parse_uint_full_null);
3716
3717	/* qemu_strtoi() tests */
3718	g_test_add_func("/cutils/qemu_strtoi/correct",
3719	test_qemu_strtoi_correct);
3720	g_test_add_func("/cutils/qemu_strtoi/null",
3721	test_qemu_strtoi_null);
3722	g_test_add_func("/cutils/qemu_strtoi/empty",
3723	test_qemu_strtoi_empty);
3724	g_test_add_func("/cutils/qemu_strtoi/whitespace",
3725	test_qemu_strtoi_whitespace);
3726	g_test_add_func("/cutils/qemu_strtoi/invalid",
3727	test_qemu_strtoi_invalid);
3728	g_test_add_func("/cutils/qemu_strtoi/trailing",
3729	test_qemu_strtoi_trailing);
3730	g_test_add_func("/cutils/qemu_strtoi/octal",
3731	test_qemu_strtoi_octal);
3732	g_test_add_func("/cutils/qemu_strtoi/decimal",
3733	test_qemu_strtoi_decimal);
3734	g_test_add_func("/cutils/qemu_strtoi/hex",
3735	test_qemu_strtoi_hex);
3736	g_test_add_func("/cutils/qemu_strtoi/max",
3737	test_qemu_strtoi_max);
3738	g_test_add_func("/cutils/qemu_strtoi/overflow",
3739	test_qemu_strtoi_overflow);
3740	g_test_add_func("/cutils/qemu_strtoi/min",
3741	test_qemu_strtoi_min);
3742	g_test_add_func("/cutils/qemu_strtoi/underflow",
3743	test_qemu_strtoi_underflow);
3744	g_test_add_func("/cutils/qemu_strtoi/negative",
3745	test_qemu_strtoi_negative);
3746	g_test_add_func("/cutils/qemu_strtoi/negzero",
3747	test_qemu_strtoi_negzero);
3748	g_test_add_func("/cutils/qemu_strtoi_full/correct",
3749	test_qemu_strtoi_full_correct);
3750	g_test_add_func("/cutils/qemu_strtoi_full/null",
3751	test_qemu_strtoi_full_null);
3752	g_test_add_func("/cutils/qemu_strtoi_full/empty",
3753	test_qemu_strtoi_full_empty);
3754	g_test_add_func("/cutils/qemu_strtoi_full/negative",
3755	test_qemu_strtoi_full_negative);
3756	g_test_add_func("/cutils/qemu_strtoi_full/negzero",
3757	test_qemu_strtoi_full_negzero);
3758	g_test_add_func("/cutils/qemu_strtoi_full/trailing",
3759	test_qemu_strtoi_full_trailing);
3760	g_test_add_func("/cutils/qemu_strtoi_full/max",
3761	test_qemu_strtoi_full_max);
3762	g_test_add_func("/cutils/qemu_strtoi_full/erange_junk",
3763	test_qemu_strtoi_full_erange_junk);
3764
3765	/* qemu_strtoui() tests */
3766	g_test_add_func("/cutils/qemu_strtoui/correct",
3767	test_qemu_strtoui_correct);
3768	g_test_add_func("/cutils/qemu_strtoui/null",
3769	test_qemu_strtoui_null);
3770	g_test_add_func("/cutils/qemu_strtoui/empty",
3771	test_qemu_strtoui_empty);
3772	g_test_add_func("/cutils/qemu_strtoui/whitespace",
3773	test_qemu_strtoui_whitespace);
3774	g_test_add_func("/cutils/qemu_strtoui/invalid",
3775	test_qemu_strtoui_invalid);
3776	g_test_add_func("/cutils/qemu_strtoui/trailing",
3777	test_qemu_strtoui_trailing);
3778	g_test_add_func("/cutils/qemu_strtoui/octal",
3779	test_qemu_strtoui_octal);
3780	g_test_add_func("/cutils/qemu_strtoui/decimal",
3781	test_qemu_strtoui_decimal);
3782	g_test_add_func("/cutils/qemu_strtoui/hex",
3783	test_qemu_strtoui_hex);
3784	g_test_add_func("/cutils/qemu_strtoui/wrap",
3785	test_qemu_strtoui_wrap);
3786	g_test_add_func("/cutils/qemu_strtoui/max",
3787	test_qemu_strtoui_max);
3788	g_test_add_func("/cutils/qemu_strtoui/overflow",
3789	test_qemu_strtoui_overflow);
3790	g_test_add_func("/cutils/qemu_strtoui/underflow",
3791	test_qemu_strtoui_underflow);
3792	g_test_add_func("/cutils/qemu_strtoui/negative",
3793	test_qemu_strtoui_negative);
3794	g_test_add_func("/cutils/qemu_strtoui/negzero",
3795	test_qemu_strtoui_negzero);
3796	g_test_add_func("/cutils/qemu_strtoui_full/correct",
3797	test_qemu_strtoui_full_correct);
3798	g_test_add_func("/cutils/qemu_strtoui_full/null",
3799	test_qemu_strtoui_full_null);
3800	g_test_add_func("/cutils/qemu_strtoui_full/empty",
3801	test_qemu_strtoui_full_empty);
3802	g_test_add_func("/cutils/qemu_strtoui_full/negative",
3803	test_qemu_strtoui_full_negative);
3804	g_test_add_func("/cutils/qemu_strtoui_full/negzero",
3805	test_qemu_strtoui_full_negzero);
3806	g_test_add_func("/cutils/qemu_strtoui_full/trailing",
3807	test_qemu_strtoui_full_trailing);
3808	g_test_add_func("/cutils/qemu_strtoui_full/max",
3809	test_qemu_strtoui_full_max);
3810	g_test_add_func("/cutils/qemu_strtoui_full/erange_junk",
3811	test_qemu_strtoui_full_erange_junk);
3812
3813	/* qemu_strtol() tests */
3814	g_test_add_func("/cutils/qemu_strtol/correct",
3815	test_qemu_strtol_correct);
3816	g_test_add_func("/cutils/qemu_strtol/null",
3817	test_qemu_strtol_null);
3818	g_test_add_func("/cutils/qemu_strtol/empty",
3819	test_qemu_strtol_empty);
3820	g_test_add_func("/cutils/qemu_strtol/whitespace",
3821	test_qemu_strtol_whitespace);
3822	g_test_add_func("/cutils/qemu_strtol/invalid",
3823	test_qemu_strtol_invalid);
3824	g_test_add_func("/cutils/qemu_strtol/trailing",
3825	test_qemu_strtol_trailing);
3826	g_test_add_func("/cutils/qemu_strtol/octal",
3827	test_qemu_strtol_octal);
3828	g_test_add_func("/cutils/qemu_strtol/decimal",
3829	test_qemu_strtol_decimal);
3830	g_test_add_func("/cutils/qemu_strtol/hex",
3831	test_qemu_strtol_hex);
3832	g_test_add_func("/cutils/qemu_strtol/max",
3833	test_qemu_strtol_max);
3834	g_test_add_func("/cutils/qemu_strtol/overflow",
3835	test_qemu_strtol_overflow);
3836	g_test_add_func("/cutils/qemu_strtol/min",
3837	test_qemu_strtol_min);
3838	g_test_add_func("/cutils/qemu_strtol/underflow",
3839	test_qemu_strtol_underflow);
3840	g_test_add_func("/cutils/qemu_strtol/negative",
3841	test_qemu_strtol_negative);
3842	g_test_add_func("/cutils/qemu_strtol/negzero",
3843	test_qemu_strtol_negzero);
3844	g_test_add_func("/cutils/qemu_strtol_full/correct",
3845	test_qemu_strtol_full_correct);
3846	g_test_add_func("/cutils/qemu_strtol_full/null",
3847	test_qemu_strtol_full_null);
3848	g_test_add_func("/cutils/qemu_strtol_full/empty",
3849	test_qemu_strtol_full_empty);
3850	g_test_add_func("/cutils/qemu_strtol_full/negative",
3851	test_qemu_strtol_full_negative);
3852	g_test_add_func("/cutils/qemu_strtol_full/negzero",
3853	test_qemu_strtol_full_negzero);
3854	g_test_add_func("/cutils/qemu_strtol_full/trailing",
3855	test_qemu_strtol_full_trailing);
3856	g_test_add_func("/cutils/qemu_strtol_full/max",
3857	test_qemu_strtol_full_max);
3858	g_test_add_func("/cutils/qemu_strtol_full/erange_junk",
3859	test_qemu_strtol_full_erange_junk);
3860
3861	/* qemu_strtoul() tests */
3862	g_test_add_func("/cutils/qemu_strtoul/correct",
3863	test_qemu_strtoul_correct);
3864	g_test_add_func("/cutils/qemu_strtoul/null",
3865	test_qemu_strtoul_null);
3866	g_test_add_func("/cutils/qemu_strtoul/empty",
3867	test_qemu_strtoul_empty);
3868	g_test_add_func("/cutils/qemu_strtoul/whitespace",
3869	test_qemu_strtoul_whitespace);
3870	g_test_add_func("/cutils/qemu_strtoul/invalid",
3871	test_qemu_strtoul_invalid);
3872	g_test_add_func("/cutils/qemu_strtoul/trailing",
3873	test_qemu_strtoul_trailing);
3874	g_test_add_func("/cutils/qemu_strtoul/octal",
3875	test_qemu_strtoul_octal);
3876	g_test_add_func("/cutils/qemu_strtoul/decimal",
3877	test_qemu_strtoul_decimal);
3878	g_test_add_func("/cutils/qemu_strtoul/hex",
3879	test_qemu_strtoul_hex);
3880	g_test_add_func("/cutils/qemu_strtoul/wrap",
3881	test_qemu_strtoul_wrap);
3882	g_test_add_func("/cutils/qemu_strtoul/max",
3883	test_qemu_strtoul_max);
3884	g_test_add_func("/cutils/qemu_strtoul/overflow",
3885	test_qemu_strtoul_overflow);
3886	g_test_add_func("/cutils/qemu_strtoul/underflow",
3887	test_qemu_strtoul_underflow);
3888	g_test_add_func("/cutils/qemu_strtoul/negative",
3889	test_qemu_strtoul_negative);
3890	g_test_add_func("/cutils/qemu_strtoul/negzero",
3891	test_qemu_strtoul_negzero);
3892	g_test_add_func("/cutils/qemu_strtoul_full/correct",
3893	test_qemu_strtoul_full_correct);
3894	g_test_add_func("/cutils/qemu_strtoul_full/null",
3895	test_qemu_strtoul_full_null);
3896	g_test_add_func("/cutils/qemu_strtoul_full/empty",
3897	test_qemu_strtoul_full_empty);
3898	g_test_add_func("/cutils/qemu_strtoul_full/negative",
3899	test_qemu_strtoul_full_negative);
3900	g_test_add_func("/cutils/qemu_strtoul_full/negzero",
3901	test_qemu_strtoul_full_negzero);
3902	g_test_add_func("/cutils/qemu_strtoul_full/trailing",
3903	test_qemu_strtoul_full_trailing);
3904	g_test_add_func("/cutils/qemu_strtoul_full/max",
3905	test_qemu_strtoul_full_max);
3906	g_test_add_func("/cutils/qemu_strtoul_full/erange_junk",
3907	test_qemu_strtoul_full_erange_junk);
3908
3909	/* qemu_strtoi64() tests */
3910	g_test_add_func("/cutils/qemu_strtoi64/correct",
3911	test_qemu_strtoi64_correct);
3912	g_test_add_func("/cutils/qemu_strtoi64/null",
3913	test_qemu_strtoi64_null);
3914	g_test_add_func("/cutils/qemu_strtoi64/empty",
3915	test_qemu_strtoi64_empty);
3916	g_test_add_func("/cutils/qemu_strtoi64/whitespace",
3917	test_qemu_strtoi64_whitespace);
3918	g_test_add_func("/cutils/qemu_strtoi64/invalid",
3919	test_qemu_strtoi64_invalid);
3920	g_test_add_func("/cutils/qemu_strtoi64/trailing",
3921	test_qemu_strtoi64_trailing);
3922	g_test_add_func("/cutils/qemu_strtoi64/octal",
3923	test_qemu_strtoi64_octal);
3924	g_test_add_func("/cutils/qemu_strtoi64/decimal",
3925	test_qemu_strtoi64_decimal);
3926	g_test_add_func("/cutils/qemu_strtoi64/hex",
3927	test_qemu_strtoi64_hex);
3928	g_test_add_func("/cutils/qemu_strtoi64/max",
3929	test_qemu_strtoi64_max);
3930	g_test_add_func("/cutils/qemu_strtoi64/overflow",
3931	test_qemu_strtoi64_overflow);
3932	g_test_add_func("/cutils/qemu_strtoi64/min",
3933	test_qemu_strtoi64_min);
3934	g_test_add_func("/cutils/qemu_strtoi64/underflow",
3935	test_qemu_strtoi64_underflow);
3936	g_test_add_func("/cutils/qemu_strtoi64/negative",
3937	test_qemu_strtoi64_negative);
3938	g_test_add_func("/cutils/qemu_strtoi64/negzero",
3939	test_qemu_strtoi64_negzero);
3940	g_test_add_func("/cutils/qemu_strtoi64_full/correct",
3941	test_qemu_strtoi64_full_correct);
3942	g_test_add_func("/cutils/qemu_strtoi64_full/null",
3943	test_qemu_strtoi64_full_null);
3944	g_test_add_func("/cutils/qemu_strtoi64_full/empty",
3945	test_qemu_strtoi64_full_empty);
3946	g_test_add_func("/cutils/qemu_strtoi64_full/negative",
3947	test_qemu_strtoi64_full_negative);
3948	g_test_add_func("/cutils/qemu_strtoi64_full/negzero",
3949	test_qemu_strtoi64_full_negzero);
3950	g_test_add_func("/cutils/qemu_strtoi64_full/trailing",
3951	test_qemu_strtoi64_full_trailing);
3952	g_test_add_func("/cutils/qemu_strtoi64_full/max",
3953	test_qemu_strtoi64_full_max);
3954	g_test_add_func("/cutils/qemu_strtoi64_full/erange_junk",
3955	test_qemu_strtoi64_full_erange_junk);
3956
3957	/* qemu_strtou64() tests */
3958	g_test_add_func("/cutils/qemu_strtou64/correct",
3959	test_qemu_strtou64_correct);
3960	g_test_add_func("/cutils/qemu_strtou64/null",
3961	test_qemu_strtou64_null);
3962	g_test_add_func("/cutils/qemu_strtou64/empty",
3963	test_qemu_strtou64_empty);
3964	g_test_add_func("/cutils/qemu_strtou64/whitespace",
3965	test_qemu_strtou64_whitespace);
3966	g_test_add_func("/cutils/qemu_strtou64/invalid",
3967	test_qemu_strtou64_invalid);
3968	g_test_add_func("/cutils/qemu_strtou64/trailing",
3969	test_qemu_strtou64_trailing);
3970	g_test_add_func("/cutils/qemu_strtou64/octal",
3971	test_qemu_strtou64_octal);
3972	g_test_add_func("/cutils/qemu_strtou64/decimal",
3973	test_qemu_strtou64_decimal);
3974	g_test_add_func("/cutils/qemu_strtou64/hex",
3975	test_qemu_strtou64_hex);
3976	g_test_add_func("/cutils/qemu_strtou64/wrap",
3977	test_qemu_strtou64_wrap);
3978	g_test_add_func("/cutils/qemu_strtou64/max",
3979	test_qemu_strtou64_max);
3980	g_test_add_func("/cutils/qemu_strtou64/overflow",
3981	test_qemu_strtou64_overflow);
3982	g_test_add_func("/cutils/qemu_strtou64/underflow",
3983	test_qemu_strtou64_underflow);
3984	g_test_add_func("/cutils/qemu_strtou64/negative",
3985	test_qemu_strtou64_negative);
3986	g_test_add_func("/cutils/qemu_strtou64/negzero",
3987	test_qemu_strtou64_negzero);
3988	g_test_add_func("/cutils/qemu_strtou64_full/correct",
3989	test_qemu_strtou64_full_correct);
3990	g_test_add_func("/cutils/qemu_strtou64_full/null",
3991	test_qemu_strtou64_full_null);
3992	g_test_add_func("/cutils/qemu_strtou64_full/empty",
3993	test_qemu_strtou64_full_empty);
3994	g_test_add_func("/cutils/qemu_strtou64_full/negative",
3995	test_qemu_strtou64_full_negative);
3996	g_test_add_func("/cutils/qemu_strtou64_full/negzero",
3997	test_qemu_strtou64_full_negzero);
3998	g_test_add_func("/cutils/qemu_strtou64_full/trailing",
3999	test_qemu_strtou64_full_trailing);
4000	g_test_add_func("/cutils/qemu_strtou64_full/max",
4001	test_qemu_strtou64_full_max);
4002	g_test_add_func("/cutils/qemu_strtou64_full/erange_junk",
4003	test_qemu_strtou64_full_erange_junk);
4004
4005	/* qemu_strtod() tests */
4006	g_test_add_func("/cutils/qemu_strtod/simple",
4007	test_qemu_strtod_simple);
4008	g_test_add_func("/cutils/qemu_strtod/einval",
4009	test_qemu_strtod_einval);
4010	g_test_add_func("/cutils/qemu_strtod/erange",
4011	test_qemu_strtod_erange);
4012	g_test_add_func("/cutils/qemu_strtod/nonfinite",
4013	test_qemu_strtod_nonfinite);
4014	g_test_add_func("/cutils/qemu_strtod/trailing",
4015	test_qemu_strtod_trailing);
4016	g_test_add_func("/cutils/qemu_strtod/erange_junk",
4017	test_qemu_strtod_erange_junk);
4018
4019	/* qemu_strtod_finite() tests */
4020	g_test_add_func("/cutils/qemu_strtod_finite/simple",
4021	test_qemu_strtod_finite_simple);
4022	g_test_add_func("/cutils/qemu_strtod_finite/einval",
4023	test_qemu_strtod_finite_einval);
4024	g_test_add_func("/cutils/qemu_strtod_finite/erange",
4025	test_qemu_strtod_finite_erange);
4026	g_test_add_func("/cutils/qemu_strtod_finite/nonfinite",
4027	test_qemu_strtod_finite_nonfinite);
4028	g_test_add_func("/cutils/qemu_strtod_finite/trailing",
4029	test_qemu_strtod_finite_trailing);
4030	g_test_add_func("/cutils/qemu_strtod_finite/erange_junk",
4031	test_qemu_strtod_finite_erange_junk);
4032
4033	/* qemu_strtosz() tests */
4034	g_test_add_func("/cutils/strtosz/simple",
4035	test_qemu_strtosz_simple);
4036	g_test_add_func("/cutils/strtosz/hex",
4037	test_qemu_strtosz_hex);
4038	g_test_add_func("/cutils/strtosz/units",
4039	test_qemu_strtosz_units);
4040	g_test_add_func("/cutils/strtosz/float",
4041	test_qemu_strtosz_float);
4042	g_test_add_func("/cutils/strtosz/invalid",
4043	test_qemu_strtosz_invalid);
4044	g_test_add_func("/cutils/strtosz/trailing",
4045	test_qemu_strtosz_trailing);
4046	g_test_add_func("/cutils/strtosz/erange",
4047	test_qemu_strtosz_erange);
4048	g_test_add_func("/cutils/strtosz/metric",
4049	test_qemu_strtosz_metric);
4050
4051	g_test_add_func("/cutils/size_to_str",
4052	test_size_to_str);
4053	g_test_add_func("/cutils/freq_to_str",
4054	test_freq_to_str);
4055	g_test_add_func("/cutils/iec_binary_prefix",
4056	test_iec_binary_prefix);
4057	g_test_add_func("/cutils/si_prefix",
4058	test_si_prefix);
4059
4060	/* qemu_hexdump() test */
4061	g_test_add_func("/cutils/qemu_hexdump/alignment",
4062	test_qemu_hexdump_alignment);
4063
4064	return g_test_run();
4065	}