/* 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));
rte_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) != -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) != -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) == -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;
}
void cmdline_init(int argc, char *argv[])
{
char **defv = NULL;
int defc = 0;
struct param *p;
char *s;
int i;
/* Build default command line as separate tokens */
s = strtok(def_cmdline, OPTION_DELIM);
while (s) {
defv = realloc(defv, ++defc * sizeof(char *));
defv[defc - 1] = s;
s = strtok(NULL, OPTION_DELIM);
}
/* Build final command line based on project configuration */
cmdline_build(argc, argv, defc, defv);
/* Print version and command line first */
fprintf(stdout, "Emux version %s\n", PACKAGE_VERSION);
fprintf(stdout, "Command line:");
for (i = 0; i < cmdline.argc; i++)
fprintf(stdout, " %s", cmdline.argv[i]);
fprintf(stdout, "\n");
/* Parse and fill parameters */
for (i = 0; i < num_params; i++) {
p = params[i];
if (!strcmp(p->type, "bool"))
cmdline_parse_bool(p->name, p->address);
else if (!strcmp(p->type, "int"))
cmdline_parse_int(p->name, p->address);
else if (!strcmp(p->type, "string"))
cmdline_parse_string(p->name, p->address);
}
/* Free command lines */
free(cmdline.argv);
free(defv);
}
/* 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 < STRING_PARSE_STRS_SIZE; 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) < 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 (strncmp(buf, string_parse_strs[i].result,
sizeof(string_parse_strs[i].result) - 1) != 0) {
printf("Error: result mismatch!\n");
return -1;
}
}
/* get number of string tokens and verify it's correct */
for (i = 0; i < STRING_NB_STRS_SIZE; 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 < STRING_ELT_STRS_SIZE; 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 < STRING_HELP_STRS_SIZE; 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;
}
/* 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 < STRING_INVALID_STRS_SIZE; 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) != -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;
}