[ceph.git] / ceph / src / dpdk / app / test / test_kvargs.c

/*
 * Copyright 2014 6WIND S.A.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in
 *   the documentation and/or other materials provided with the
 *   distribution.
 *
 * - Neither the name of 6WIND S.A. nor the names of its
 *   contributors may be used to endorse or promote products derived
 *   from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <rte_common.h>
#include <rte_kvargs.h>

#include "test.h"

/* incrementd in handler, to check it is properly called once per
 * key/value association */
static unsigned count;

/* this handler increment the "count" variable at each call and check
 * that the key is "check" and the value is "value%d" */
static int check_handler(const char *key, const char *value,
	__rte_unused void *opaque)
{
	char buf[16];

	/* we check that the value is "check" */
	if (strcmp(key, "check"))
		return -1;

	/* we check that the value is "value$(count)" */
	snprintf(buf, sizeof(buf), "value%d", count);
	if (strncmp(buf, value, sizeof(buf)))
		return -1;

	count ++;
	return 0;
}

/* test a valid case */
static int test_valid_kvargs(void)
{
	struct rte_kvargs *kvlist;
	const char *args;
	const char *valid_keys_list[] = { "foo", "check", NULL };
	const char **valid_keys;

	/* empty args is valid */
	args = "";
	valid_keys = NULL;
	kvlist = rte_kvargs_parse(args, valid_keys);
	if (kvlist == NULL) {
		printf("rte_kvargs_parse() error");
		goto fail;
	}
	rte_kvargs_free(kvlist);

	/* first test without valid_keys */
	args = "foo=1234,check=value0,check=value1";
	valid_keys = NULL;
	kvlist = rte_kvargs_parse(args, valid_keys);
	if (kvlist == NULL) {
		printf("rte_kvargs_parse() error");
		goto fail;
	}
	/* call check_handler() for all entries with key="check" */
	count = 0;
	if (rte_kvargs_process(kvlist, "check", check_handler, NULL) < 0) {
		printf("rte_kvargs_process() error\n");
		rte_kvargs_free(kvlist);
		goto fail;
	}
	if (count != 2) {
		printf("invalid count value %d after rte_kvargs_process(check)\n",
			count);
		rte_kvargs_free(kvlist);
		goto fail;
	}
	count = 0;
	/* call check_handler() for all entries with key="unexistant_key" */
	if (rte_kvargs_process(kvlist, "unexistant_key", check_handler, NULL) < 0) {
		printf("rte_kvargs_process() error\n");
		rte_kvargs_free(kvlist);
		goto fail;
	}
	if (count != 0) {
		printf("invalid count value %d after rte_kvargs_process(unexistant_key)\n",
			count);
		rte_kvargs_free(kvlist);
		goto fail;
	}
	/* count all entries with key="foo" */
	count = rte_kvargs_count(kvlist, "foo");
	if (count != 1) {
		printf("invalid count value %d after rte_kvargs_count(foo)\n",
			count);
		rte_kvargs_free(kvlist);
		goto fail;
	}
	/* count all entries */
	count = rte_kvargs_count(kvlist, NULL);
	if (count != 3) {
		printf("invalid count value %d after rte_kvargs_count(NULL)\n",
			count);
		rte_kvargs_free(kvlist);
		goto fail;
	}
	/* count all entries with key="unexistant_key" */
	count = rte_kvargs_count(kvlist, "unexistant_key");
	if (count != 0) {
		printf("invalid count value %d after rte_kvargs_count(unexistant_key)\n",
			count);
		rte_kvargs_free(kvlist);
		goto fail;
	}
	rte_kvargs_free(kvlist);

	/* second test using valid_keys */
	args = "foo=droids,check=value0,check=value1,check=wrong_value";
	valid_keys = valid_keys_list;
	kvlist = rte_kvargs_parse(args, valid_keys);
	if (kvlist == NULL) {
		printf("rte_kvargs_parse() error");
		goto fail;
	}
	/* call check_handler() on all entries with key="check", it
	 * should fail as the value is not recognized by the handler */
	if (rte_kvargs_process(kvlist, "check", check_handler, NULL) == 0) {
		printf("rte_kvargs_process() is success bu should not\n");
		rte_kvargs_free(kvlist);
		goto fail;
	}
	count = rte_kvargs_count(kvlist, "check");
	if (count != 3) {
		printf("invalid count value %d after rte_kvargs_count(check)\n",
			count);
		rte_kvargs_free(kvlist);
		goto fail;
	}
	rte_kvargs_free(kvlist);

	return 0;

 fail:
	printf("while processing <%s>", args);
	if (valid_keys != NULL && *valid_keys != NULL) {
		printf(" using valid_keys=<%s", *valid_keys);
		while (*(++valid_keys) != NULL)
			printf(",%s", *valid_keys);
		printf(">");
	}
	printf("\n");
	return -1;
}

/* test several error cases */
static int test_invalid_kvargs(void)
{
	struct rte_kvargs *kvlist;
	/* list of argument that should fail */
	const char *args_list[] = {
		"wrong-key=x",     /* key not in valid_keys_list */
		"foo=1,foo=",      /* empty value */
		"foo=1,,foo=2",    /* empty key/value */
		"foo=1,foo",       /* no value */
		"foo=1,=2",        /* no key */
		",=",              /* also test with a smiley */
		NULL };
	const char **args;
	const char *valid_keys_list[] = { "foo", "check", NULL };
	const char **valid_keys = valid_keys_list;

	for (args = args_list; *args != NULL; args++) {

		kvlist = rte_kvargs_parse(*args, valid_keys);
		if (kvlist != NULL) {
			printf("rte_kvargs_parse() returned 0 (but should not)\n");
			rte_kvargs_free(kvlist);
			goto fail;
		}
		return 0;
	}

 fail:
	printf("while processing <%s>", *args);
	if (valid_keys != NULL && *valid_keys != NULL) {
		printf(" using valid_keys=<%s", *valid_keys);
		while (*(++valid_keys) != NULL)
			printf(",%s", *valid_keys);
		printf(">");
	}
	printf("\n");
	return -1;
}

static int
test_kvargs(void)
{
	printf("== test valid case ==\n");
	if (test_valid_kvargs() < 0)
		return -1;
	printf("== test invalid case ==\n");
	if (test_invalid_kvargs() < 0)
		return -1;
	return 0;
}

REGISTER_TEST_COMMAND(kvargs_autotest, test_kvargs);
Commit	Line	Data
7c673cae FG	1	/*
	2	* Copyright 2014 6WIND S.A.
	3	*
	4	* Redistribution and use in source and binary forms, with or without
	5	* modification, are permitted provided that the following conditions
	6	* are met:
	7	*
	8	* - Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	*
	11	* - Redistributions in binary form must reproduce the above copyright
	12	* notice, this list of conditions and the following disclaimer in
	13	* the documentation and/or other materials provided with the
	14	* distribution.
	15	*
	16	* - Neither the name of 6WIND S.A. nor the names of its
	17	* contributors may be used to endorse or promote products derived
	18	* from this software without specific prior written permission.
	19	*
	20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	21	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	22	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	23	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	24	* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	25	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	26	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	27	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	28	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	29	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
	31	* OF THE POSSIBILITY OF SUCH DAMAGE.
	32	*/
	33
	34	#include <stdlib.h>
	35	#include <stdio.h>
	36	#include <string.h>
	37
	38	#include <rte_common.h>
	39	#include <rte_kvargs.h>
	40
	41	#include "test.h"
	42
	43	/* incrementd in handler, to check it is properly called once per
	44	* key/value association */
	45	static unsigned count;
	46
	47	/* this handler increment the "count" variable at each call and check
	48	* that the key is "check" and the value is "value%d" */
	49	static int check_handler(const char key, const char value,
	50	__rte_unused void *opaque)
	51	{
	52	char buf[16];
	53
	54	/* we check that the value is "check" */
	55	if (strcmp(key, "check"))
	56	return -1;
	57
	58	/* we check that the value is "value$(count)" */
	59	snprintf(buf, sizeof(buf), "value%d", count);
	60	if (strncmp(buf, value, sizeof(buf)))
	61	return -1;
	62
	63	count ++;
	64	return 0;
65	}
66
67	/* test a valid case */
68	static int test_valid_kvargs(void)
69	{
70	struct rte_kvargs *kvlist;
71	const char *args;
72	const char *valid_keys_list[] = { "foo", "check", NULL };
73	const char **valid_keys;
74
75	/* empty args is valid */
76	args = "";
77	valid_keys = NULL;
78	kvlist = rte_kvargs_parse(args, valid_keys);
79	if (kvlist == NULL) {
80	printf("rte_kvargs_parse() error");
81	goto fail;
82	}
83	rte_kvargs_free(kvlist);
84
85	/* first test without valid_keys */
86	args = "foo=1234,check=value0,check=value1";
87	valid_keys = NULL;
88	kvlist = rte_kvargs_parse(args, valid_keys);
89	if (kvlist == NULL) {
90	printf("rte_kvargs_parse() error");
91	goto fail;
92	}
93	/* call check_handler() for all entries with key="check" */
94	count = 0;
95	if (rte_kvargs_process(kvlist, "check", check_handler, NULL) < 0) {
96	printf("rte_kvargs_process() error\n");
97	rte_kvargs_free(kvlist);
98	goto fail;
99	}
100	if (count != 2) {
101	printf("invalid count value %d after rte_kvargs_process(check)\n",
102	count);
103	rte_kvargs_free(kvlist);
104	goto fail;
105	}
106	count = 0;
107	/* call check_handler() for all entries with key="unexistant_key" */
108	if (rte_kvargs_process(kvlist, "unexistant_key", check_handler, NULL) < 0) {
109	printf("rte_kvargs_process() error\n");
110	rte_kvargs_free(kvlist);
111	goto fail;
112	}
113	if (count != 0) {
114	printf("invalid count value %d after rte_kvargs_process(unexistant_key)\n",
115	count);
116	rte_kvargs_free(kvlist);
117	goto fail;
118	}
119	/* count all entries with key="foo" */
120	count = rte_kvargs_count(kvlist, "foo");
121	if (count != 1) {
122	printf("invalid count value %d after rte_kvargs_count(foo)\n",
123	count);
124	rte_kvargs_free(kvlist);
125	goto fail;
126	}
127	/* count all entries */
128	count = rte_kvargs_count(kvlist, NULL);
129	if (count != 3) {
130	printf("invalid count value %d after rte_kvargs_count(NULL)\n",
131	count);
132	rte_kvargs_free(kvlist);
133	goto fail;
134	}
135	/* count all entries with key="unexistant_key" */
136	count = rte_kvargs_count(kvlist, "unexistant_key");
137	if (count != 0) {
138	printf("invalid count value %d after rte_kvargs_count(unexistant_key)\n",
139	count);
140	rte_kvargs_free(kvlist);
141	goto fail;
142	}
143	rte_kvargs_free(kvlist);
144
145	/* second test using valid_keys */
146	args = "foo=droids,check=value0,check=value1,check=wrong_value";
147	valid_keys = valid_keys_list;
148	kvlist = rte_kvargs_parse(args, valid_keys);
149	if (kvlist == NULL) {
150	printf("rte_kvargs_parse() error");
151	goto fail;
152	}
153	/* call check_handler() on all entries with key="check", it
154	* should fail as the value is not recognized by the handler */
155	if (rte_kvargs_process(kvlist, "check", check_handler, NULL) == 0) {
156	printf("rte_kvargs_process() is success bu should not\n");
157	rte_kvargs_free(kvlist);
158	goto fail;
159	}
160	count = rte_kvargs_count(kvlist, "check");
161	if (count != 3) {
162	printf("invalid count value %d after rte_kvargs_count(check)\n",
163	count);
164	rte_kvargs_free(kvlist);
165	goto fail;
166	}
167	rte_kvargs_free(kvlist);
168
169	return 0;
170
171	fail:
172	printf("while processing <%s>", args);
173	if (valid_keys != NULL && *valid_keys != NULL) {
174	printf(" using valid_keys=<%s", *valid_keys);
175	while (*(++valid_keys) != NULL)
176	printf(",%s", *valid_keys);
177	printf(">");
178	}
179	printf("\n");
180	return -1;
181	}
182
183	/* test several error cases */
184	static int test_invalid_kvargs(void)
185	{
186	struct rte_kvargs *kvlist;
187	/* list of argument that should fail */
188	const char *args_list[] = {
189	"wrong-key=x", /* key not in valid_keys_list */
190	"foo=1,foo=", /* empty value */
191	"foo=1,,foo=2", /* empty key/value */
192	"foo=1,foo", /* no value */
193	"foo=1,=2", /* no key */
194	",=", /* also test with a smiley */
195	NULL };
196	const char **args;
197	const char *valid_keys_list[] = { "foo", "check", NULL };
198	const char **valid_keys = valid_keys_list;
199
200	for (args = args_list; *args != NULL; args++) {
201
202	kvlist = rte_kvargs_parse(*args, valid_keys);
203	if (kvlist != NULL) {
204	printf("rte_kvargs_parse() returned 0 (but should not)\n");
205	rte_kvargs_free(kvlist);
206	goto fail;
207	}
208	return 0;
209	}
210
211	fail:
212	printf("while processing <%s>", *args);
213	if (valid_keys != NULL && *valid_keys != NULL) {
214	printf(" using valid_keys=<%s", *valid_keys);
215	while (*(++valid_keys) != NULL)
216	printf(",%s", *valid_keys);
217	printf(">");
218	}
219	printf("\n");
220	return -1;
221	}
222
223	static int
224	test_kvargs(void)
225	{
226	printf("== test valid case ==\n");
227	if (test_valid_kvargs() < 0)
228	return -1;
229	printf("== test invalid case ==\n");
230	if (test_invalid_kvargs() < 0)
231	return -1;
232	return 0;
233	}
234
235	REGISTER_TEST_COMMAND(kvargs_autotest, test_kvargs);