[ceph.git] / ceph / src / spdk / dpdk / app / test / test_cmdline_string.c

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2010-2014 Intel Corporation
 */

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

#include <rte_common.h>
#include <rte_string_fns.h>

#include <cmdline_parse.h>
#include <cmdline_parse_string.h>

#include "test_cmdline.h"

/* structures needed to run tests */

struct string_elt_str {
	const char * str;	/* parsed string */
	const char * result;	/* expected string */
	int idx;	/* position at which result is expected to be */
};

struct string_elt_str string_elt_strs[] = {
		{"one#two#three", "three", 2},
		{"one#two with spaces#three", "three", 2},
		{"one#two\twith\ttabs#three", "three", 2},
		{"one#two\rwith\rreturns#three", "three", 2},
		{"one#two\nwith\nnewlines#three", "three", 2},
		{"one#two#three", "one", 0},
		{"one#two#three", "two", 1},
		{"one#two\0three", "two", 1},
		{"one#two with spaces#three", "two with spaces", 1},
		{"one#two\twith\ttabs#three", "two\twith\ttabs", 1},
		{"one#two\rwith\rreturns#three", "two\rwith\rreturns", 1},
		{"one#two\nwith\nnewlines#three", "two\nwith\nnewlines", 1},
};

#if (CMDLINE_TEST_BUFSIZE < STR_TOKEN_SIZE) \
|| (CMDLINE_TEST_BUFSIZE < STR_MULTI_TOKEN_SIZE)
#undef CMDLINE_TEST_BUFSIZE
#define CMDLINE_TEST_BUFSIZE RTE_MAX(STR_TOKEN_SIZE, STR_MULTI_TOKEN_SIZE)
#endif

struct string_nb_str {
	const char * str;	/* parsed string */
	int nb_strs;	/* expected number of strings in str */
};

struct string_nb_str string_nb_strs[] = {
		{"one#two#three", 3},
		{"one", 1},
		{"one# \t two \r # three \n #four", 4},
};


struct string_parse_str {
	const char * str;	/* parsed string */
	const char * fixed_str;	/* parsing mode (any, fixed or multi) */
	const char * result;	/* expected result */
};

struct string_parse_str string_parse_strs[] = {
		{"one", NULL, "one"},	/* any string */
		{"two", "one#two#three", "two"},	/* multiple choice string */
		{"three", "three", "three"},	/* fixed string */
		{"three", "one#two with\rgarbage\tcharacters\n#three", "three"},
		{"two with\rgarbage\tcharacters\n",
				"one#two with\rgarbage\tcharacters\n#three",
				"two with\rgarbage\tcharacters\n"},
		{"one two", "one", "one"}, /* fixed string */
		{"one two", TOKEN_STRING_MULTI, "one two"}, /* multi string */
		{"one two", NULL, "one"}, /* any string */
		{"one two #three", TOKEN_STRING_MULTI, "one two "},
		/* multi string with comment */
};


struct string_invalid_str {
	const char * str;	/* parsed string */
	const char * fixed_str;	/* parsing mode (any, fixed or multi) */
};

struct string_invalid_str string_invalid_strs[] = {
		{"invalid", "one"},	/* fixed string */
		{"invalid", "one#two#three"},	/* multiple choice string */
		{"invalid", "invalidone"},	/* string that starts the same */
		{"invalidone", "invalid"},	/* string that starts the same */
		{"toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!"
		 "toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!"
		 "toolong!!!", NULL },
		{"toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!"
		 "toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!"
		 "toolong!!!", "fixed" },
		{"toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!"
		 "toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!"
		 "toolong!!!", "multi#choice#string" },
		{"invalid",
		 "toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!"
		 "toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!"
		 "toolong!!!" },
		 {"", "invalid"}
};


const char * string_help_strs[] = {
		NULL,
		"fixed_str",
		"multi#str",
};

#define SMALL_BUF 8

/* test invalid parameters */
int
test_parse_string_invalid_param(void)
{
	cmdline_parse_token_string_t token;
	int result;
	char buf[CMDLINE_TEST_BUFSIZE];

	memset(&token, 0, sizeof(token));

	snprintf(buf, sizeof(buf), "buffer");

	/* test null token */
	if (cmdline_get_help_string(
		NULL, buf, 0) != -1) {
		printf("Error: function accepted null token!\n");
		return -1;
	}
	if (cmdline_complete_get_elt_string(
			NULL, 0, buf, 0) != -1) {
		printf("Error: function accepted null token!\n");
		return -1;
	}
	if (cmdline_complete_get_nb_string(NULL) != -1) {
		printf("Error: function accepted null token!\n");
		return -1;
	}
	if (cmdline_parse_string(NULL, buf, NULL, 0) != -1) {
		printf("Error: function accepted null token!\n");
		return -1;
	}
	/* test null buffer */
	if (cmdline_complete_get_elt_string(
			(cmdline_parse_token_hdr_t*)&token, 0, NULL, 0) != -1) {
		printf("Error: function accepted null buffer!\n");
		return -1;
	}
	if (cmdline_parse_string(
			(cmdline_parse_token_hdr_t*)&token, NULL,
			(void*)&result, sizeof(result)) != -1) {
		printf("Error: function accepted null buffer!\n");
		return -1;
	}
	if (cmdline_get_help_string(
			(cmdline_parse_token_hdr_t*)&token, NULL, 0) != -1) {
		printf("Error: function accepted null buffer!\n");
		return -1;
	}
	/* test null result */
	if (cmdline_parse_string(
			(cmdline_parse_token_hdr_t*)&token, buf, NULL, 0) == -1) {
		printf("Error: function rejected null result!\n");
		return -1;
	}
	/* test negative index */
	if (cmdline_complete_get_elt_string(
			(cmdline_parse_token_hdr_t*)&token, -1, buf, 0) != -1) {
		printf("Error: function accepted negative index!\n");
		return -1;
	}
	return 0;
}

/* test valid parameters but invalid data */
int
test_parse_string_invalid_data(void)
{
	cmdline_parse_token_string_t token;
	cmdline_parse_token_string_t help_token;
	char buf[CMDLINE_TEST_BUFSIZE];
	char help_str[CMDLINE_TEST_BUFSIZE];
	char small_buf[SMALL_BUF];
	unsigned i;

	/* test parsing invalid strings */
	for (i = 0; i < RTE_DIM(string_invalid_strs); i++) {
		memset(&token, 0, sizeof(token));
		memset(buf, 0, sizeof(buf));

		/* prepare test token data */
		token.string_data.str = string_invalid_strs[i].fixed_str;

		if (cmdline_parse_string((cmdline_parse_token_hdr_t*)&token,
				string_invalid_strs[i].str, (void*)buf,
				sizeof(buf)) != -1) {
			memset(help_str, 0, sizeof(help_str));
			memset(&help_token, 0, sizeof(help_token));

			help_token.string_data.str = string_invalid_strs[i].fixed_str;

			/* get parse type so we can give a good error message */
			cmdline_get_help_string((cmdline_parse_token_hdr_t*)&token, help_str,
					sizeof(help_str));

			printf("Error: parsing %s as %s succeeded!\n",
					string_invalid_strs[i].str, help_str);
			return -1;
		}
	}

	/* misc tests (big comments signify test cases) */
	memset(&token, 0, sizeof(token));
	memset(small_buf, 0, sizeof(small_buf));

	/*
	 * try to get element from a null token
	 */
	token.string_data.str = NULL;
	if (cmdline_complete_get_elt_string(
			(cmdline_parse_token_hdr_t*)&token, 1,
			buf, sizeof(buf)) != -1) {
		printf("Error: getting token from null token string!\n");
		return -1;
	}

	/*
	 * try to get element into a buffer that is too small
	 */
	token.string_data.str = "too_small_buffer";
	if (cmdline_complete_get_elt_string(
			(cmdline_parse_token_hdr_t*)&token, 0,
			small_buf, sizeof(small_buf)) != -1) {
		printf("Error: writing token into too small a buffer succeeded!\n");
		return -1;
	}

	/*
	 * get help string written into a buffer smaller than help string
	 * truncation should occur
	 */
	token.string_data.str = NULL;
	if (cmdline_get_help_string(
			(cmdline_parse_token_hdr_t*)&token,
			small_buf, sizeof(small_buf)) == -1) {
		printf("Error: writing help string into too small a buffer failed!\n");
		return -1;
	}
	/* get help string for "any string" so we can compare it with small_buf */
	cmdline_get_help_string((cmdline_parse_token_hdr_t*)&token, help_str,
			sizeof(help_str));
	if (strncmp(small_buf, help_str, sizeof(small_buf) - 1)) {
		printf("Error: help string mismatch!\n");
		return -1;
	}
	/* check null terminator */
	if (small_buf[sizeof(small_buf) - 1] != '\0') {
		printf("Error: small buffer doesn't have a null terminator!\n");
		return -1;
	}

	/*
	 * try to count tokens in a null token
	 */
	token.string_data.str = NULL;
	if (cmdline_complete_get_nb_string(
			(cmdline_parse_token_hdr_t*)&token) != 0) {
		printf("Error: getting token count from null token succeeded!\n");
		return -1;
	}

	return 0;
}

/* test valid parameters and data */
int
test_parse_string_valid(void)
{
	cmdline_parse_token_string_t token;
	cmdline_parse_token_string_t help_token;
	char buf[CMDLINE_TEST_BUFSIZE];
	char help_str[CMDLINE_TEST_BUFSIZE];
	unsigned i;

	/* test parsing strings */
	for (i = 0; i < RTE_DIM(string_parse_strs); i++) {
		memset(&token, 0, sizeof(token));
		memset(buf, 0, sizeof(buf));

		token.string_data.str = string_parse_strs[i].fixed_str;

		if (cmdline_parse_string((cmdline_parse_token_hdr_t*)&token,
				string_parse_strs[i].str, (void*)buf,
				sizeof(buf)) < 0) {

			/* clean help data */
			memset(&help_token, 0, sizeof(help_token));
			memset(help_str, 0, sizeof(help_str));

			/* prepare help token */
			help_token.string_data.str = string_parse_strs[i].fixed_str;

			/* get help string so that we get an informative error message */
			cmdline_get_help_string((cmdline_parse_token_hdr_t*)&token, help_str,
					sizeof(help_str));

			printf("Error: parsing %s as %s failed!\n",
					string_parse_strs[i].str, help_str);
			return -1;
		}
		if (strcmp(buf, string_parse_strs[i].result) != 0) {
			printf("Error: result mismatch!\n");
			return -1;
		}
	}

	/* get number of string tokens and verify it's correct */
	for (i = 0; i < RTE_DIM(string_nb_strs); i++) {
		memset(&token, 0, sizeof(token));

		token.string_data.str = string_nb_strs[i].str;

		if (cmdline_complete_get_nb_string(
				(cmdline_parse_token_hdr_t*)&token) <
				string_nb_strs[i].nb_strs) {
			printf("Error: strings count mismatch!\n");
			return -1;
		}
	}

	/* get token at specified position and verify it's correct */
	for (i = 0; i < RTE_DIM(string_elt_strs); i++) {
		memset(&token, 0, sizeof(token));
		memset(buf, 0, sizeof(buf));

		token.string_data.str = string_elt_strs[i].str;

		if (cmdline_complete_get_elt_string(
				(cmdline_parse_token_hdr_t*)&token, string_elt_strs[i].idx,
				buf, sizeof(buf)) < 0) {
			printf("Error: getting string element failed!\n");
			return -1;
		}
		if (strncmp(buf, string_elt_strs[i].result,
				sizeof(buf)) != 0) {
			printf("Error: result mismatch!\n");
			return -1;
		}
	}

	/* cover all cases with help strings */
	for (i = 0; i < RTE_DIM(string_help_strs); i++) {
		memset(&help_token, 0, sizeof(help_token));
		memset(help_str, 0, sizeof(help_str));
		help_token.string_data.str = string_help_strs[i];
		if (cmdline_get_help_string((cmdline_parse_token_hdr_t*)&help_token,
				help_str, sizeof(help_str)) < 0) {
			printf("Error: help operation failed!\n");
			return -1;
		}
	}

	return 0;
}
Commit	Line	Data
11fdf7f2 TL	1	/* SPDX-License-Identifier: BSD-3-Clause
11fdf7f2 TL	2	* Copyright(c) 2010-2014 Intel Corporation
7c673cae FG	3	*/
	4
	5	#include <stdio.h>
	6	#include <string.h>
	7	#include <inttypes.h>
	8
	9	#include <rte_common.h>
	10	#include <rte_string_fns.h>
	11
	12	#include <cmdline_parse.h>
	13	#include <cmdline_parse_string.h>
	14
	15	#include "test_cmdline.h"
	16
	17	/* structures needed to run tests */
	18
	19	struct string_elt_str {
	20	const char * str; /* parsed string */
	21	const char * result; /* expected string */
	22	int idx; /* position at which result is expected to be */
	23	};
	24
	25	struct string_elt_str string_elt_strs[] = {
	26	{"one#two#three", "three", 2},
	27	{"one#two with spaces#three", "three", 2},
	28	{"one#two\twith\ttabs#three", "three", 2},
	29	{"one#two\rwith\rreturns#three", "three", 2},
	30	{"one#two\nwith\nnewlines#three", "three", 2},
	31	{"one#two#three", "one", 0},
	32	{"one#two#three", "two", 1},
	33	{"one#two\0three", "two", 1},
	34	{"one#two with spaces#three", "two with spaces", 1},
	35	{"one#two\twith\ttabs#three", "two\twith\ttabs", 1},
	36	{"one#two\rwith\rreturns#three", "two\rwith\rreturns", 1},
	37	{"one#two\nwith\nnewlines#three", "two\nwith\nnewlines", 1},
	38	};
	39
	40	#if (CMDLINE_TEST_BUFSIZE < STR_TOKEN_SIZE) \
	41	\|\| (CMDLINE_TEST_BUFSIZE < STR_MULTI_TOKEN_SIZE)
	42	#undef CMDLINE_TEST_BUFSIZE
	43	#define CMDLINE_TEST_BUFSIZE RTE_MAX(STR_TOKEN_SIZE, STR_MULTI_TOKEN_SIZE)
	44	#endif
	45
	46	struct string_nb_str {
	47	const char * str; /* parsed string */
	48	int nb_strs; /* expected number of strings in str */
	49	};
	50
	51	struct string_nb_str string_nb_strs[] = {
	52	{"one#two#three", 3},
	53	{"one", 1},
	54	{"one# \t two \r # three \n #four", 4},
	55	};
	56
	57
	58
	59	struct string_parse_str {
	60	const char * str; /* parsed string */
	61	const char * fixed_str; /* parsing mode (any, fixed or multi) */
	62	const char * result; /* expected result */
	63	};
	64
	65	struct string_parse_str string_parse_strs[] = {
	66	{"one", NULL, "one"}, /* any string */
67	{"two", "one#two#three", "two"}, /* multiple choice string */
68	{"three", "three", "three"}, /* fixed string */
69	{"three", "one#two with\rgarbage\tcharacters\n#three", "three"},
70	{"two with\rgarbage\tcharacters\n",
71	"one#two with\rgarbage\tcharacters\n#three",
72	"two with\rgarbage\tcharacters\n"},
73	{"one two", "one", "one"}, /* fixed string */
74	{"one two", TOKEN_STRING_MULTI, "one two"}, /* multi string */
75	{"one two", NULL, "one"}, /* any string */
76	{"one two #three", TOKEN_STRING_MULTI, "one two "},
77	/* multi string with comment */
78	};
79
80
81
82	struct string_invalid_str {
83	const char * str; /* parsed string */
84	const char * fixed_str; /* parsing mode (any, fixed or multi) */
85	};
86
87	struct string_invalid_str string_invalid_strs[] = {
88	{"invalid", "one"}, /* fixed string */
89	{"invalid", "one#two#three"}, /* multiple choice string */
90	{"invalid", "invalidone"}, /* string that starts the same */
91	{"invalidone", "invalid"}, /* string that starts the same */
92	{"toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!"
93	"toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!"
94	"toolong!!!", NULL },
95	{"toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!"
96	"toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!"
97	"toolong!!!", "fixed" },
98	{"toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!"
99	"toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!"
100	"toolong!!!", "multi#choice#string" },
101	{"invalid",
102	"toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!"
103	"toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!toolong!!!"
104	"toolong!!!" },
105	{"", "invalid"}
106	};
107
108
109
110	const char * string_help_strs[] = {
111	NULL,
112	"fixed_str",
113	"multi#str",
114	};
115
7c673cae FG	116	#define SMALL_BUF 8
	117
	118	/* test invalid parameters */
	119	int
	120	test_parse_string_invalid_param(void)
	121	{
	122	cmdline_parse_token_string_t token;
	123	int result;
	124	char buf[CMDLINE_TEST_BUFSIZE];
	125
	126	memset(&token, 0, sizeof(token));
	127
	128	snprintf(buf, sizeof(buf), "buffer");
	129
	130	/* test null token */
	131	if (cmdline_get_help_string(
	132	NULL, buf, 0) != -1) {
	133	printf("Error: function accepted null token!\n");
	134	return -1;
	135	}
	136	if (cmdline_complete_get_elt_string(
	137	NULL, 0, buf, 0) != -1) {
	138	printf("Error: function accepted null token!\n");
	139	return -1;
	140	}
	141	if (cmdline_complete_get_nb_string(NULL) != -1) {
	142	printf("Error: function accepted null token!\n");
	143	return -1;
	144	}
	145	if (cmdline_parse_string(NULL, buf, NULL, 0) != -1) {
	146	printf("Error: function accepted null token!\n");
	147	return -1;
	148	}
	149	/* test null buffer */
	150	if (cmdline_complete_get_elt_string(
	151	(cmdline_parse_token_hdr_t*)&token, 0, NULL, 0) != -1) {
	152	printf("Error: function accepted null buffer!\n");
	153	return -1;
	154	}
	155	if (cmdline_parse_string(
	156	(cmdline_parse_token_hdr_t*)&token, NULL,
	157	(void*)&result, sizeof(result)) != -1) {
	158	printf("Error: function accepted null buffer!\n");
	159	return -1;
	160	}
	161	if (cmdline_get_help_string(
	162	(cmdline_parse_token_hdr_t*)&token, NULL, 0) != -1) {
	163	printf("Error: function accepted null buffer!\n");
	164	return -1;
	165	}
	166	/* test null result */
	167	if (cmdline_parse_string(
	168	(cmdline_parse_token_hdr_t*)&token, buf, NULL, 0) == -1) {
	169	printf("Error: function rejected null result!\n");
	170	return -1;
	171	}
	172	/* test negative index */
	173	if (cmdline_complete_get_elt_string(
	174	(cmdline_parse_token_hdr_t*)&token, -1, buf, 0) != -1) {
	175	printf("Error: function accepted negative index!\n");
	176	return -1;
	177	}
	178	return 0;
	179	}
180
181	/* test valid parameters but invalid data */
182	int
183	test_parse_string_invalid_data(void)
184	{
185	cmdline_parse_token_string_t token;
186	cmdline_parse_token_string_t help_token;
187	char buf[CMDLINE_TEST_BUFSIZE];
188	char help_str[CMDLINE_TEST_BUFSIZE];
189	char small_buf[SMALL_BUF];
190	unsigned i;
191
192	/* test parsing invalid strings */
f67539c2	193	for (i = 0; i < RTE_DIM(string_invalid_strs); i++) {
7c673cae FG	194	memset(&token, 0, sizeof(token));
	195	memset(buf, 0, sizeof(buf));
	196
	197	/* prepare test token data */
	198	token.string_data.str = string_invalid_strs[i].fixed_str;
	199
	200	if (cmdline_parse_string((cmdline_parse_token_hdr_t*)&token,
	201	string_invalid_strs[i].str, (void*)buf,
	202	sizeof(buf)) != -1) {
	203	memset(help_str, 0, sizeof(help_str));
	204	memset(&help_token, 0, sizeof(help_token));
	205
	206	help_token.string_data.str = string_invalid_strs[i].fixed_str;
	207
	208	/* get parse type so we can give a good error message */
	209	cmdline_get_help_string((cmdline_parse_token_hdr_t*)&token, help_str,
	210	sizeof(help_str));
	211
	212	printf("Error: parsing %s as %s succeeded!\n",
	213	string_invalid_strs[i].str, help_str);
	214	return -1;
	215	}
	216	}
	217
	218	/* misc tests (big comments signify test cases) */
	219	memset(&token, 0, sizeof(token));
	220	memset(small_buf, 0, sizeof(small_buf));
	221
	222	/*
	223	* try to get element from a null token
	224	*/
	225	token.string_data.str = NULL;
	226	if (cmdline_complete_get_elt_string(
	227	(cmdline_parse_token_hdr_t*)&token, 1,
	228	buf, sizeof(buf)) != -1) {
	229	printf("Error: getting token from null token string!\n");
	230	return -1;
	231	}
	232
	233	/*
	234	* try to get element into a buffer that is too small
	235	*/
	236	token.string_data.str = "too_small_buffer";
	237	if (cmdline_complete_get_elt_string(
	238	(cmdline_parse_token_hdr_t*)&token, 0,
	239	small_buf, sizeof(small_buf)) != -1) {
	240	printf("Error: writing token into too small a buffer succeeded!\n");
	241	return -1;
	242	}
	243
	244	/*
	245	* get help string written into a buffer smaller than help string
	246	* truncation should occur
	247	*/
	248	token.string_data.str = NULL;
	249	if (cmdline_get_help_string(
	250	(cmdline_parse_token_hdr_t*)&token,
	251	small_buf, sizeof(small_buf)) == -1) {
	252	printf("Error: writing help string into too small a buffer failed!\n");
	253	return -1;
	254	}
	255	/* get help string for "any string" so we can compare it with small_buf */
	256	cmdline_get_help_string((cmdline_parse_token_hdr_t*)&token, help_str,
	257	sizeof(help_str));
258	if (strncmp(small_buf, help_str, sizeof(small_buf) - 1)) {
259	printf("Error: help string mismatch!\n");
260	return -1;
261	}
262	/* check null terminator */
263	if (small_buf[sizeof(small_buf) - 1] != '\0') {
264	printf("Error: small buffer doesn't have a null terminator!\n");
265	return -1;
266	}
267
268	/*
269	* try to count tokens in a null token
270	*/
271	token.string_data.str = NULL;
272	if (cmdline_complete_get_nb_string(
273	(cmdline_parse_token_hdr_t*)&token) != 0) {
274	printf("Error: getting token count from null token succeeded!\n");
275	return -1;
276	}
277
278	return 0;
279	}
280
281	/* test valid parameters and data */
282	int
283	test_parse_string_valid(void)
284	{
285	cmdline_parse_token_string_t token;
286	cmdline_parse_token_string_t help_token;
287	char buf[CMDLINE_TEST_BUFSIZE];
288	char help_str[CMDLINE_TEST_BUFSIZE];
289	unsigned i;
290
291	/* test parsing strings */
f67539c2	292	for (i = 0; i < RTE_DIM(string_parse_strs); i++) {
7c673cae FG	293	memset(&token, 0, sizeof(token));
	294	memset(buf, 0, sizeof(buf));
	295
	296	token.string_data.str = string_parse_strs[i].fixed_str;
	297
	298	if (cmdline_parse_string((cmdline_parse_token_hdr_t*)&token,
	299	string_parse_strs[i].str, (void*)buf,
	300	sizeof(buf)) < 0) {
	301
	302	/* clean help data */
	303	memset(&help_token, 0, sizeof(help_token));
	304	memset(help_str, 0, sizeof(help_str));
	305
	306	/* prepare help token */
	307	help_token.string_data.str = string_parse_strs[i].fixed_str;
	308
	309	/* get help string so that we get an informative error message */
	310	cmdline_get_help_string((cmdline_parse_token_hdr_t*)&token, help_str,
	311	sizeof(help_str));
	312
	313	printf("Error: parsing %s as %s failed!\n",
	314	string_parse_strs[i].str, help_str);
	315	return -1;
	316	}
	317	if (strcmp(buf, string_parse_strs[i].result) != 0) {
	318	printf("Error: result mismatch!\n");
	319	return -1;
	320	}
	321	}
	322
	323	/* get number of string tokens and verify it's correct */
f67539c2	324	for (i = 0; i < RTE_DIM(string_nb_strs); i++) {
7c673cae FG	325	memset(&token, 0, sizeof(token));
	326
	327	token.string_data.str = string_nb_strs[i].str;
	328
	329	if (cmdline_complete_get_nb_string(
	330	(cmdline_parse_token_hdr_t*)&token) <
	331	string_nb_strs[i].nb_strs) {
	332	printf("Error: strings count mismatch!\n");
	333	return -1;
	334	}
	335	}
	336
	337	/* get token at specified position and verify it's correct */
f67539c2	338	for (i = 0; i < RTE_DIM(string_elt_strs); i++) {
7c673cae FG	339	memset(&token, 0, sizeof(token));
	340	memset(buf, 0, sizeof(buf));
	341
	342	token.string_data.str = string_elt_strs[i].str;
	343
	344	if (cmdline_complete_get_elt_string(
	345	(cmdline_parse_token_hdr_t*)&token, string_elt_strs[i].idx,
	346	buf, sizeof(buf)) < 0) {
	347	printf("Error: getting string element failed!\n");
	348	return -1;
	349	}
	350	if (strncmp(buf, string_elt_strs[i].result,
	351	sizeof(buf)) != 0) {
	352	printf("Error: result mismatch!\n");
	353	return -1;
	354	}
	355	}
	356
	357	/* cover all cases with help strings */
f67539c2	358	for (i = 0; i < RTE_DIM(string_help_strs); i++) {
7c673cae FG	359	memset(&help_token, 0, sizeof(help_token));
	360	memset(help_str, 0, sizeof(help_str));
	361	help_token.string_data.str = string_help_strs[i];
	362	if (cmdline_get_help_string((cmdline_parse_token_hdr_t*)&help_token,
	363	help_str, sizeof(help_str)) < 0) {
	364	printf("Error: help operation failed!\n");
	365	return -1;
	366	}
	367	}
	368
	369	return 0;
	370	}