[qemu.git] / tests / test-cutils.c

/*
 * cutils.c unit-tests
 *
 * Copyright (C) 2013 Red Hat Inc.
 *
 * Authors:
 *  Eduardo Habkost <ehabkost@redhat.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include <glib.h>
#include <errno.h>
#include <string.h>

#include "qemu-common.h"


static void test_parse_uint_null(void)
{
    unsigned long long i = 999;
    char f = 'X';
    char *endptr = &f;
    int r;

    r = parse_uint(NULL, &i, &endptr, 0);

    g_assert_cmpint(r, ==, -EINVAL);
    g_assert_cmpint(i, ==, 0);
    g_assert(endptr == NULL);
}

static void test_parse_uint_empty(void)
{
    unsigned long long i = 999;
    char f = 'X';
    char *endptr = &f;
    const char *str = "";
    int r;

    r = parse_uint(str, &i, &endptr, 0);

    g_assert_cmpint(r, ==, -EINVAL);
    g_assert_cmpint(i, ==, 0);
    g_assert(endptr == str);
}

static void test_parse_uint_whitespace(void)
{
    unsigned long long i = 999;
    char f = 'X';
    char *endptr = &f;
    const char *str = "   \t   ";
    int r;

    r = parse_uint(str, &i, &endptr, 0);

    g_assert_cmpint(r, ==, -EINVAL);
    g_assert_cmpint(i, ==, 0);
    g_assert(endptr == str);
}


static void test_parse_uint_invalid(void)
{
    unsigned long long i = 999;
    char f = 'X';
    char *endptr = &f;
    const char *str = " \t xxx";
    int r;

    r = parse_uint(str, &i, &endptr, 0);

    g_assert_cmpint(r, ==, -EINVAL);
    g_assert_cmpint(i, ==, 0);
    g_assert(endptr == str);
}


static void test_parse_uint_trailing(void)
{
    unsigned long long i = 999;
    char f = 'X';
    char *endptr = &f;
    const char *str = "123xxx";
    int r;

    r = parse_uint(str, &i, &endptr, 0);

    g_assert_cmpint(r, ==, 0);
    g_assert_cmpint(i, ==, 123);
    g_assert(endptr == str + 3);
}

static void test_parse_uint_correct(void)
{
    unsigned long long i = 999;
    char f = 'X';
    char *endptr = &f;
    const char *str = "123";
    int r;

    r = parse_uint(str, &i, &endptr, 0);

    g_assert_cmpint(r, ==, 0);
    g_assert_cmpint(i, ==, 123);
    g_assert(endptr == str + strlen(str));
}

static void test_parse_uint_octal(void)
{
    unsigned long long i = 999;
    char f = 'X';
    char *endptr = &f;
    const char *str = "0123";
    int r;

    r = parse_uint(str, &i, &endptr, 0);

    g_assert_cmpint(r, ==, 0);
    g_assert_cmpint(i, ==, 0123);
    g_assert(endptr == str + strlen(str));
}

static void test_parse_uint_decimal(void)
{
    unsigned long long i = 999;
    char f = 'X';
    char *endptr = &f;
    const char *str = "0123";
    int r;

    r = parse_uint(str, &i, &endptr, 10);

    g_assert_cmpint(r, ==, 0);
    g_assert_cmpint(i, ==, 123);
    g_assert(endptr == str + strlen(str));
}


static void test_parse_uint_llong_max(void)
{
    unsigned long long i = 999;
    char f = 'X';
    char *endptr = &f;
    char *str = g_strdup_printf("%llu", (unsigned long long)LLONG_MAX + 1);
    int r;

    r = parse_uint(str, &i, &endptr, 0);

    g_assert_cmpint(r, ==, 0);
    g_assert_cmpint(i, ==, (unsigned long long)LLONG_MAX + 1);
    g_assert(endptr == str + strlen(str));

    g_free(str);
}

static void test_parse_uint_overflow(void)
{
    unsigned long long i = 999;
    char f = 'X';
    char *endptr = &f;
    const char *str = "99999999999999999999999999999999999999";
    int r;

    r = parse_uint(str, &i, &endptr, 0);

    g_assert_cmpint(r, ==, -ERANGE);
    g_assert_cmpint(i, ==, ULLONG_MAX);
    g_assert(endptr == str + strlen(str));
}

static void test_parse_uint_negative(void)
{
    unsigned long long i = 999;
    char f = 'X';
    char *endptr = &f;
    const char *str = " \t -321";
    int r;

    r = parse_uint(str, &i, &endptr, 0);

    g_assert_cmpint(r, ==, -ERANGE);
    g_assert_cmpint(i, ==, 0);
    g_assert(endptr == str + strlen(str));
}


static void test_parse_uint_full_trailing(void)
{
    unsigned long long i = 999;
    const char *str = "123xxx";
    int r;

    r = parse_uint_full(str, &i, 0);

    g_assert_cmpint(r, ==, -EINVAL);
    g_assert_cmpint(i, ==, 0);
}

static void test_parse_uint_full_correct(void)
{
    unsigned long long i = 999;
    const char *str = "123";
    int r;

    r = parse_uint_full(str, &i, 0);

    g_assert_cmpint(r, ==, 0);
    g_assert_cmpint(i, ==, 123);
}

int main(int argc, char **argv)
{
    g_test_init(&argc, &argv, NULL);

    g_test_add_func("/cutils/parse_uint/null", test_parse_uint_null);
    g_test_add_func("/cutils/parse_uint/empty", test_parse_uint_empty);
    g_test_add_func("/cutils/parse_uint/whitespace",
                    test_parse_uint_whitespace);
    g_test_add_func("/cutils/parse_uint/invalid", test_parse_uint_invalid);
    g_test_add_func("/cutils/parse_uint/trailing", test_parse_uint_trailing);
    g_test_add_func("/cutils/parse_uint/correct", test_parse_uint_correct);
    g_test_add_func("/cutils/parse_uint/octal", test_parse_uint_octal);
    g_test_add_func("/cutils/parse_uint/decimal", test_parse_uint_decimal);
    g_test_add_func("/cutils/parse_uint/llong_max", test_parse_uint_llong_max);
    g_test_add_func("/cutils/parse_uint/overflow", test_parse_uint_overflow);
    g_test_add_func("/cutils/parse_uint/negative", test_parse_uint_negative);
    g_test_add_func("/cutils/parse_uint_full/trailing",
                    test_parse_uint_full_trailing);
    g_test_add_func("/cutils/parse_uint_full/correct",
                    test_parse_uint_full_correct);

    return g_test_run();
}
Commit	Line	Data
e3f9fe2d EH	1	/*
	2	* cutils.c unit-tests
	3	*
	4	* Copyright (C) 2013 Red Hat Inc.
	5	*
	6	* Authors:
	7	* Eduardo Habkost <ehabkost@redhat.com>
	8	*
	9	* Permission is hereby granted, free of charge, to any person obtaining a copy
	10	* of this software and associated documentation files (the "Software"), to deal
	11	* in the Software without restriction, including without limitation the rights
	12	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	13	* copies of the Software, and to permit persons to whom the Software is
	14	* furnished to do so, subject to the following conditions:
	15	*
	16	* The above copyright notice and this permission notice shall be included in
	17	* all copies or substantial portions of the Software.
	18	*
	19	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	20	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	21	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	22	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	23	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	24	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	25	* THE SOFTWARE.
	26	*/
	27
	28	#include <glib.h>
	29	#include <errno.h>
	30	#include <string.h>
	31
	32	#include "qemu-common.h"
	33
	34
	35	static void test_parse_uint_null(void)
	36	{
	37	unsigned long long i = 999;
	38	char f = 'X';
	39	char *endptr = &f;
	40	int r;
	41
	42	r = parse_uint(NULL, &i, &endptr, 0);
	43
	44	g_assert_cmpint(r, ==, -EINVAL);
	45	g_assert_cmpint(i, ==, 0);
	46	g_assert(endptr == NULL);
	47	}
	48
	49	static void test_parse_uint_empty(void)
	50	{
	51	unsigned long long i = 999;
	52	char f = 'X';
	53	char *endptr = &f;
	54	const char *str = "";
	55	int r;
	56
	57	r = parse_uint(str, &i, &endptr, 0);
	58
	59	g_assert_cmpint(r, ==, -EINVAL);
	60	g_assert_cmpint(i, ==, 0);
	61	g_assert(endptr == str);
	62	}
	63
	64	static void test_parse_uint_whitespace(void)
65	{
66	unsigned long long i = 999;
67	char f = 'X';
68	char *endptr = &f;
69	const char *str = " \t ";
70	int r;
71
72	r = parse_uint(str, &i, &endptr, 0);
73
74	g_assert_cmpint(r, ==, -EINVAL);
75	g_assert_cmpint(i, ==, 0);
76	g_assert(endptr == str);
77	}
78
79
80	static void test_parse_uint_invalid(void)
81	{
82	unsigned long long i = 999;
83	char f = 'X';
84	char *endptr = &f;
85	const char *str = " \t xxx";
86	int r;
87
88	r = parse_uint(str, &i, &endptr, 0);
89
90	g_assert_cmpint(r, ==, -EINVAL);
91	g_assert_cmpint(i, ==, 0);
92	g_assert(endptr == str);
93	}
94
95
96	static void test_parse_uint_trailing(void)
97	{
98	unsigned long long i = 999;
99	char f = 'X';
100	char *endptr = &f;
101	const char *str = "123xxx";
102	int r;
103
104	r = parse_uint(str, &i, &endptr, 0);
105
106	g_assert_cmpint(r, ==, 0);
107	g_assert_cmpint(i, ==, 123);
108	g_assert(endptr == str + 3);
109	}
110
111	static void test_parse_uint_correct(void)
112	{
113	unsigned long long i = 999;
114	char f = 'X';
115	char *endptr = &f;
116	const char *str = "123";
117	int r;
118
119	r = parse_uint(str, &i, &endptr, 0);
120
121	g_assert_cmpint(r, ==, 0);
122	g_assert_cmpint(i, ==, 123);
123	g_assert(endptr == str + strlen(str));
124	}
125
126	static void test_parse_uint_octal(void)
127	{
128	unsigned long long i = 999;
129	char f = 'X';
130	char *endptr = &f;
131	const char *str = "0123";
132	int r;
133
134	r = parse_uint(str, &i, &endptr, 0);
135
136	g_assert_cmpint(r, ==, 0);
137	g_assert_cmpint(i, ==, 0123);
138	g_assert(endptr == str + strlen(str));
139	}
140
141	static void test_parse_uint_decimal(void)
142	{
143	unsigned long long i = 999;
144	char f = 'X';
145	char *endptr = &f;
146	const char *str = "0123";
147	int r;
148
149	r = parse_uint(str, &i, &endptr, 10);
150
151	g_assert_cmpint(r, ==, 0);
152	g_assert_cmpint(i, ==, 123);
153	g_assert(endptr == str + strlen(str));
154	}
155
156
157	static void test_parse_uint_llong_max(void)
158	{
159	unsigned long long i = 999;
160	char f = 'X';
161	char *endptr = &f;
162	char *str = g_strdup_printf("%llu", (unsigned long long)LLONG_MAX + 1);
163	int r;
164
165	r = parse_uint(str, &i, &endptr, 0);
166
167	g_assert_cmpint(r, ==, 0);
168	g_assert_cmpint(i, ==, (unsigned long long)LLONG_MAX + 1);
169	g_assert(endptr == str + strlen(str));
170
171	g_free(str);
172	}
173
174	static void test_parse_uint_overflow(void)
175	{
176	unsigned long long i = 999;
177	char f = 'X';
178	char *endptr = &f;
179	const char *str = "99999999999999999999999999999999999999";
180	int r;
181
182	r = parse_uint(str, &i, &endptr, 0);
183
184	g_assert_cmpint(r, ==, -ERANGE);
185	g_assert_cmpint(i, ==, ULLONG_MAX);
186	g_assert(endptr == str + strlen(str));
187	}
188
189	static void test_parse_uint_negative(void)
190	{
191	unsigned long long i = 999;
192	char f = 'X';
193	char *endptr = &f;
194	const char *str = " \t -321";
195	int r;
196
197	r = parse_uint(str, &i, &endptr, 0);
198
199	g_assert_cmpint(r, ==, -ERANGE);
200	g_assert_cmpint(i, ==, 0);
201	g_assert(endptr == str + strlen(str));
202	}
203
204
205	static void test_parse_uint_full_trailing(void)
206	{
207	unsigned long long i = 999;
208	const char *str = "123xxx";
209	int r;
210
211	r = parse_uint_full(str, &i, 0);
212
213	g_assert_cmpint(r, ==, -EINVAL);
214	g_assert_cmpint(i, ==, 0);
215	}
216
217	static void test_parse_uint_full_correct(void)
218	{
219	unsigned long long i = 999;
220	const char *str = "123";
221	int r;
222
223	r = parse_uint_full(str, &i, 0);
224
225	g_assert_cmpint(r, ==, 0);
226	g_assert_cmpint(i, ==, 123);
227	}
228
229	int main(int argc, char **argv)
230	{
231	g_test_init(&argc, &argv, NULL);
232
233	g_test_add_func("/cutils/parse_uint/null", test_parse_uint_null);
234	g_test_add_func("/cutils/parse_uint/empty", test_parse_uint_empty);
235	g_test_add_func("/cutils/parse_uint/whitespace",
236	test_parse_uint_whitespace);
237	g_test_add_func("/cutils/parse_uint/invalid", test_parse_uint_invalid);
238	g_test_add_func("/cutils/parse_uint/trailing", test_parse_uint_trailing);
239	g_test_add_func("/cutils/parse_uint/correct", test_parse_uint_correct);
240	g_test_add_func("/cutils/parse_uint/octal", test_parse_uint_octal);
241	g_test_add_func("/cutils/parse_uint/decimal", test_parse_uint_decimal);
242	g_test_add_func("/cutils/parse_uint/llong_max", test_parse_uint_llong_max);
243	g_test_add_func("/cutils/parse_uint/overflow", test_parse_uint_overflow);
244	g_test_add_func("/cutils/parse_uint/negative", test_parse_uint_negative);
245	g_test_add_func("/cutils/parse_uint_full/trailing",
246	test_parse_uint_full_trailing);
247	g_test_add_func("/cutils/parse_uint_full/correct",
248	test_parse_uint_full_correct);
249
250	return g_test_run();
251	}