app/test/test_kvargs.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2014 6WIND S.A.
   3  */
   4
   5 #include <stdlib.h>
   6 #include <stdio.h>
   7 #include <string.h>
   8
   9 #include <rte_common.h>
  10 #include <rte_kvargs.h>
  11
  12 #include "test.h"
  13
  14 /* incrementd in handler, to check it is properly called once per
  15  * key/value association */
  16 static unsigned count;
  17
  18 /* this handler increment the "count" variable at each call and check
  19  * that the key is "check" and the value is "value%d" */
  20 static int check_handler(const char *key, const char *value,
  21         __rte_unused void *opaque)
  22 {
  23         char buf[16];
  24
  25         /* we check that the value is "check" */
  26         if (strcmp(key, "check"))
  27                 return -1;
  28
  29         /* we check that the value is "value$(count)" */
  30         snprintf(buf, sizeof(buf), "value%d", count);
  31         if (strncmp(buf, value, sizeof(buf)))
  32                 return -1;
  33
  34         count ++;
  35         return 0;
  36 }
  37
  38 /* test a valid case */
  39 static int test_valid_kvargs(void)
  40 {
  41         struct rte_kvargs *kvlist;
  42         const char *args;
  43         const char *valid_keys_list[] = { "foo", "check", NULL };
  44         const char **valid_keys;
  45
  46         /* empty args is valid */
  47         args = "";
  48         valid_keys = NULL;
  49         kvlist = rte_kvargs_parse(args, valid_keys);
  50         if (kvlist == NULL) {
  51                 printf("rte_kvargs_parse() error");
  52                 goto fail;
  53         }
  54         rte_kvargs_free(kvlist);
  55
  56         /* first test without valid_keys */
  57         args = "foo=1234,check=value0,check=value1";
  58         valid_keys = NULL;
  59         kvlist = rte_kvargs_parse(args, valid_keys);
  60         if (kvlist == NULL) {
  61                 printf("rte_kvargs_parse() error");
  62                 goto fail;
  63         }
  64         /* call check_handler() for all entries with key="check" */
  65         count = 0;
  66         if (rte_kvargs_process(kvlist, "check", check_handler, NULL) < 0) {
  67                 printf("rte_kvargs_process() error\n");
  68                 rte_kvargs_free(kvlist);
  69                 goto fail;
  70         }
  71         if (count != 2) {
  72                 printf("invalid count value %d after rte_kvargs_process(check)\n",
  73                         count);
  74                 rte_kvargs_free(kvlist);
  75                 goto fail;
  76         }
  77         count = 0;
  78         /* call check_handler() for all entries with key="unexistant_key" */
  79         if (rte_kvargs_process(kvlist, "unexistant_key", check_handler, NULL) < 0) {
  80                 printf("rte_kvargs_process() error\n");
  81                 rte_kvargs_free(kvlist);
  82                 goto fail;
  83         }
  84         if (count != 0) {
  85                 printf("invalid count value %d after rte_kvargs_process(unexistant_key)\n",
  86                         count);
  87                 rte_kvargs_free(kvlist);
  88                 goto fail;
  89         }
  90         /* count all entries with key="foo" */
  91         count = rte_kvargs_count(kvlist, "foo");
  92         if (count != 1) {
  93                 printf("invalid count value %d after rte_kvargs_count(foo)\n",
  94                         count);
  95                 rte_kvargs_free(kvlist);
  96                 goto fail;
  97         }
  98         /* count all entries */
  99         count = rte_kvargs_count(kvlist, NULL);
 100         if (count != 3) {
 101                 printf("invalid count value %d after rte_kvargs_count(NULL)\n",
 102                         count);
 103                 rte_kvargs_free(kvlist);
 104                 goto fail;
 105         }
 106         /* count all entries with key="unexistant_key" */
 107         count = rte_kvargs_count(kvlist, "unexistant_key");
 108         if (count != 0) {
 109                 printf("invalid count value %d after rte_kvargs_count(unexistant_key)\n",
 110                         count);
 111                 rte_kvargs_free(kvlist);
 112                 goto fail;
 113         }
 114         rte_kvargs_free(kvlist);
 115
 116         /* second test using valid_keys */
 117         args = "foo=droids,check=value0,check=value1,check=wrong_value";
 118         valid_keys = valid_keys_list;
 119         kvlist = rte_kvargs_parse(args, valid_keys);
 120         if (kvlist == NULL) {
 121                 printf("rte_kvargs_parse() error");
 122                 goto fail;
 123         }
 124         /* call check_handler() on all entries with key="check", it
 125          * should fail as the value is not recognized by the handler */
 126         if (rte_kvargs_process(kvlist, "check", check_handler, NULL) == 0) {
 127                 printf("rte_kvargs_process() is success bu should not\n");
 128                 rte_kvargs_free(kvlist);
 129                 goto fail;
 130         }
 131         count = rte_kvargs_count(kvlist, "check");
 132         if (count != 3) {
 133                 printf("invalid count value %d after rte_kvargs_count(check)\n",
 134                         count);
 135                 rte_kvargs_free(kvlist);
 136                 goto fail;
 137         }
 138         rte_kvargs_free(kvlist);
 139
 140         /* third test using list as value */
 141         args = "foo=[0,1],check=value2";
 142         valid_keys = valid_keys_list;
 143         kvlist = rte_kvargs_parse(args, valid_keys);
 144         if (kvlist == NULL) {
 145                 printf("rte_kvargs_parse() error\n");
 146                 goto fail;
 147         }
 148         if (strcmp(kvlist->pairs[0].value, "[0,1]") != 0) {
 149                 printf("wrong value %s", kvlist->pairs[0].value);
 150                 goto fail;
 151         }
 152         count = kvlist->count;
 153         if (count != 2) {
 154                 printf("invalid count value %d\n", count);
 155                 rte_kvargs_free(kvlist);
 156                 goto fail;
 157         }
 158         rte_kvargs_free(kvlist);
 159
 160         /* test using empty string (it is valid) */
 161         args = "";
 162         kvlist = rte_kvargs_parse(args, NULL);
 163         if (kvlist == NULL) {
 164                 printf("rte_kvargs_parse() error\n");
 165                 goto fail;
 166         }
 167         if (rte_kvargs_count(kvlist, NULL) != 0) {
 168                 printf("invalid count value\n");
 169                 goto fail;
 170         }
 171         rte_kvargs_free(kvlist);
 172
 173         /* test using empty elements (it is valid) */
 174         args = "foo=1,,check=value2,,";
 175         kvlist = rte_kvargs_parse(args, NULL);
 176         if (kvlist == NULL) {
 177                 printf("rte_kvargs_parse() error\n");
 178                 goto fail;
 179         }
 180         if (rte_kvargs_count(kvlist, NULL) != 2) {
 181                 printf("invalid count value\n");
 182                 goto fail;
 183         }
 184         if (rte_kvargs_count(kvlist, "foo") != 1) {
 185                 printf("invalid count value for 'foo'\n");
 186                 goto fail;
 187         }
 188         if (rte_kvargs_count(kvlist, "check") != 1) {
 189                 printf("invalid count value for 'check'\n");
 190                 goto fail;
 191         }
 192         rte_kvargs_free(kvlist);
 193
 194         return 0;
 195
 196  fail:
 197         printf("while processing <%s>", args);
 198         if (valid_keys != NULL && *valid_keys != NULL) {
 199                 printf(" using valid_keys=<%s", *valid_keys);
 200                 while (*(++valid_keys) != NULL)
 201                         printf(",%s", *valid_keys);
 202                 printf(">");
 203         }
 204         printf("\n");
 205         return -1;
 206 }
 207
 208 /* test several error cases */
 209 static int test_invalid_kvargs(void)
 210 {
 211         struct rte_kvargs *kvlist;
 212         /* list of argument that should fail */
 213         const char *args_list[] = {
 214                 "wrong-key=x",     /* key not in valid_keys_list */
 215                 "foo=1,foo=",      /* empty value */
 216                 "foo=1,foo",       /* no value */
 217                 "foo=1,=2",        /* no key */
 218                 "foo=[1,2",        /* no closing bracket in value */
 219                 ",=",              /* also test with a smiley */
 220                 "foo=[",           /* no value in list and no closing bracket */
 221                 NULL };
 222         const char **args;
 223         const char *valid_keys_list[] = { "foo", "check", NULL };
 224         const char **valid_keys = valid_keys_list;
 225
 226         for (args = args_list; *args != NULL; args++) {
 227
 228                 kvlist = rte_kvargs_parse(*args, valid_keys);
 229                 if (kvlist != NULL) {
 230                         printf("rte_kvargs_parse() returned 0 (but should not)\n");
 231                         rte_kvargs_free(kvlist);
 232                         goto fail;
 233                 }
 234         }
 235         return 0;
 236
 237  fail:
 238         printf("while processing <%s>", *args);
 239         if (valid_keys != NULL && *valid_keys != NULL) {
 240                 printf(" using valid_keys=<%s", *valid_keys);
 241                 while (*(++valid_keys) != NULL)
 242                         printf(",%s", *valid_keys);
 243                 printf(">");
 244         }
 245         printf("\n");
 246         return -1;
 247 }
 248
 249 static int
 250 test_kvargs(void)
 251 {
 252         printf("== test valid case ==\n");
 253         if (test_valid_kvargs() < 0)
 254                 return -1;
 255         printf("== test invalid case ==\n");
 256         if (test_invalid_kvargs() < 0)
 257                 return -1;
 258         return 0;
 259 }
 260
 261 REGISTER_TEST_COMMAND(kvargs_autotest, test_kvargs);