src/plugins/unittest/string_test.c

   1 /*
   2  * Copyright (c) 2018 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15 #include <vlib/vlib.h>
  16 #include <vppinfra/string.h>
  17
  18 static int
  19 test_memset_s (vlib_main_t * vm, unformat_input_t * input)
  20 {
  21   u8 dst[64];
  22   int i;
  23   errno_t err;
  24
  25   vlib_cli_output (vm, "Test memset_s...");
  26
  27   err = memset_s (dst, ARRAY_LEN (dst), 0xfe, ARRAY_LEN (dst));
  28
  29   if (err != EOK)
  30     return -1;
  31
  32   for (i = 0; i < ARRAY_LEN (dst); i++)
  33     if (dst[i] != 0xFE)
  34       return -1;
  35
  36   err = memset_s (dst, ARRAY_LEN (dst), 0xfa, ARRAY_LEN (dst) + 1);
  37
  38   if (err == EOK)
  39     return -1;
  40
  41   return 0;
  42 }
  43
  44 static int
  45 test_clib_memset (vlib_main_t * vm, unformat_input_t * input)
  46 {
  47   u8 dst[64];
  48   int i;
  49   errno_t err;
  50
  51   vlib_cli_output (vm, "Test clib_memset...");
  52
  53   err = clib_memset (dst, 0xfe, ARRAY_LEN (dst));
  54
  55   if (err != EOK)
  56     return -1;
  57
  58   for (i = 0; i < ARRAY_LEN (dst); i++)
  59     if (dst[i] != 0xFE)
  60       return -1;
  61
  62   return 0;
  63 }
  64
  65 static int
  66 test_memcpy_s (vlib_main_t * vm, unformat_input_t * input)
  67 {
  68   char src[64], dst[64];
  69   int i;
  70   errno_t err;
  71
  72   vlib_cli_output (vm, "Test memcpy_s...");
  73
  74   for (i = 0; i < ARRAY_LEN (src); i++)
  75     src[i] = i + 1;
  76
  77   /* Typical case */
  78   err = memcpy_s (dst, sizeof (dst), src, sizeof (src));
  79
  80   if (err != EOK)
  81     return -1;
  82
  83   /* This better not fail but check anyhow */
  84   for (i = 0; i < ARRAY_LEN (dst); i++)
  85     if (src[i] != dst[i])
  86       return -1;
  87
  88   /*
  89    * Size test: sizeof (src) > sizeof (dst)
  90    * Skip this test when __builtin_constant_p (sizeof (src)) is true.
  91    * This is because memcpy_s_inline skips all the errors checking when the
  92    * the above buildin function returns true which may cause overrun problem
  93    * for dst buffer if this test is executed.
  94    */
  95   if (__builtin_constant_p (sizeof (src)) == 0)
  96     {
  97       err = memcpy_s (dst + 1, sizeof (dst) - 1, src, sizeof (src));
  98
  99       if (err == EOK)
 100         return -1;
 101     }
 102
 103   /* overlap fail */
 104   err = memcpy_s (dst, sizeof (dst), dst + 1, sizeof (dst) - 1);
 105
 106   if (err == EOK)
 107     return -1;
 108
 109   /* Zero length copy */
 110   err = memcpy_s (0, sizeof (dst), src, 0);
 111
 112   if (err != EOK)
 113     return -1;
 114
 115   /* OK, seems to work */
 116   return 0;
 117 }
 118
 119 static int
 120 test_clib_memcpy (vlib_main_t * vm, unformat_input_t * input)
 121 {
 122   char src[64], dst[64];
 123   int i;
 124   errno_t err;
 125
 126   vlib_cli_output (vm, "Test clib_memcpy...");
 127
 128   for (i = 0; i < ARRAY_LEN (src); i++)
 129     src[i] = i + 1;
 130
 131   /* Typical case */
 132   err = clib_memcpy (dst, src, sizeof (src));
 133
 134   if (err != EOK)
 135     return -1;
 136
 137   /* This better not fail but check anyhow */
 138   for (i = 0; i < ARRAY_LEN (dst); i++)
 139     if (src[i] != dst[i])
 140       return -1;
 141   /* verify it against memcpy */
 142   memcpy (dst, src, sizeof (src));
 143
 144   /* This better not fail but check anyhow */
 145   for (i = 0; i < ARRAY_LEN (dst); i++)
 146     if (src[i] != dst[i])
 147       return -1;
 148
 149   /* Zero length copy */
 150   err = clib_memcpy (0, src, 0);
 151
 152   if (err != EOK)
 153     return -1;
 154
 155   /* OK, seems to work */
 156   return 0;
 157 }
 158
 159 static int
 160 test_memcmp_s (vlib_main_t * vm, unformat_input_t * input)
 161 {
 162   char src[64], dst[64];
 163   errno_t err;
 164   int diff = 0;
 165
 166   vlib_cli_output (vm, "Test memcmp_s...");
 167
 168   /* Fill array with different values */
 169   err = clib_memset (src, 0x1, ARRAY_LEN (src));
 170   if (err != EOK)
 171     return -1;
 172   err = clib_memset (dst, 0x3, ARRAY_LEN (dst));
 173   if (err != EOK)
 174     return -1;
 175
 176   /* s1 > s2, > 0 is expected in diff */
 177   err = memcmp_s (dst, ARRAY_LEN (dst), src, ARRAY_LEN (src), &diff);
 178   if (err != EOK)
 179     return -1;
 180   if (!(diff > 0))
 181     return -1;
 182
 183   /* s1 < s2, < 0 is expected in diff */
 184   err = memcmp_s (src, ARRAY_LEN (src), dst, ARRAY_LEN (dst), &diff);
 185   if (err != EOK)
 186     return -1;
 187   if (!(diff < 0))
 188     return -1;
 189
 190   err = clib_memset (dst, 0x1, ARRAY_LEN (dst));
 191   if (err != EOK)
 192     return -1;
 193
 194   /* s1 == s2, 0 is expected in diff */
 195   err = memcmp_s (src, ARRAY_LEN (src), dst, ARRAY_LEN (dst), &diff);
 196   if (err != EOK)
 197     return -1;
 198   if (diff != 0)
 199     return -1;
 200
 201   /* Try negative tests */
 202   err = memcmp_s (0, 0, 0, 0, 0);
 203   if (err != EINVAL)
 204     return -1;
 205
 206   /* Try s2max > s1max */
 207   err = memcmp_s (src, ARRAY_LEN (src) - 1, dst, ARRAY_LEN (dst), &diff);
 208   if (err != EINVAL)
 209     return -1;
 210
 211   /* OK, seems to work */
 212   return 0;
 213 }
 214
 215 static int
 216 test_clib_memcmp (vlib_main_t * vm, unformat_input_t * input)
 217 {
 218   char src[64], dst[64];
 219   errno_t err;
 220   char *s;
 221
 222   vlib_cli_output (vm, "Test clib_memcmp...");
 223
 224   /* Fill array with different values */
 225   err = clib_memset (src, 0x1, ARRAY_LEN (src));
 226   if (err != EOK)
 227     return -1;
 228   err = clib_memset (dst, 0x3, ARRAY_LEN (dst));
 229   if (err != EOK)
 230     return -1;
 231
 232   /* s1 > s2, > 0 is expected in diff */
 233   if (!(clib_memcmp (dst, src, ARRAY_LEN (src)) > 0))
 234     return -1;
 235   /* verify it against memcmp */
 236   if (!(memcmp (dst, src, ARRAY_LEN (src)) > 0))
 237     return -1;
 238
 239   /* s1 < s2, < 0 is expected in diff */
 240   if (!(clib_memcmp (src, dst, ARRAY_LEN (dst)) < 0))
 241     return -1;
 242   /* verify it against memcmp */
 243   if (!(memcmp (src, dst, ARRAY_LEN (dst)) < 0))
 244     return -1;
 245
 246   err = clib_memset (dst, 0x1, ARRAY_LEN (dst));
 247   if (err != EOK)
 248     return -1;
 249
 250   /* s1 == s2, 0 is expected in diff */
 251   if (clib_memcmp (src, dst, ARRAY_LEN (dst)) != 0)
 252     return -1;
 253   /* verify it against memcmp */
 254   if (memcmp (src, dst, ARRAY_LEN (dst)) != 0)
 255     return -1;
 256
 257   /* Try negative tests */
 258   s = 0;
 259   if (clib_memcmp (s, s, 0) != 0)
 260     return -1;
 261   /* verify it against memcmp */
 262   if (memcmp (s, s, 0) != 0)
 263     return -1;
 264
 265   /* OK, seems to work */
 266   return 0;
 267 }
 268
 269 static int
 270 test_strcmp_s (vlib_main_t * vm, unformat_input_t * input)
 271 {
 272   char s1[] = "Simplicity is the ultimate sophistication";
 273   uword s1len = sizeof (s1) - 1;        // excluding null
 274   errno_t err;
 275   int indicator = 0;
 276
 277   vlib_cli_output (vm, "Test strcmp_s...");
 278
 279   /* s1 == s2, 0 is expected */
 280   err = strcmp_s (s1, s1len, "Simplicity is the ultimate sophistication",
 281                   &indicator);
 282   if (err != EOK)
 283     return -1;
 284   if (indicator != 0)
 285     return -1;
 286
 287   /* s1 > s2, > 0 is expected */
 288   err = strcmp_s (s1, s1len, "Simplicity is the ultimate", &indicator);
 289   if (err != EOK)
 290     return -1;
 291   if (!(indicator > 0))
 292     return -1;
 293
 294   /* s1 < s2, < 0 is expected */
 295   err = strcmp_s (s1, s1len, "Simplicity is the ultimate sophistication!",
 296                   &indicator);
 297   if (err != EOK)
 298     return -1;
 299   if (!(indicator < 0))
 300     return -1;
 301
 302   /* Try some negative tests */
 303
 304   /* Null pointers test */
 305   err = strcmp_s (0, 0, 0, 0);
 306   if (err != EINVAL)
 307     return -1;
 308
 309   /* non-null terminated s1 */
 310   s1[s1len] = 0x1;
 311   err = strcmp_s (s1, s1len, "Simplicity is the ultimate sophistication",
 312                   &indicator);
 313   if (err != EINVAL)
 314     return -1;
 315
 316   /* OK, seems to work */
 317   return 0;
 318 }
 319
 320 static int
 321 test_clib_strcmp (vlib_main_t * vm, unformat_input_t * input)
 322 {
 323   char s1[] = "Simplicity is the ultimate sophistication";
 324   int indicator;
 325   char *s;
 326
 327   vlib_cli_output (vm, "Test clib_strcmp...");
 328
 329   /* s1 == s2, 0 is expected */
 330   indicator = clib_strcmp (s1, "Simplicity is the ultimate sophistication");
 331   if (indicator != 0)
 332     return -1;
 333   /* verify it against strcmp */
 334   indicator = strcmp (s1, "Simplicity is the ultimate sophistication");
 335   if (indicator != 0)
 336     return -1;
 337
 338   /* s1 > s2, > 0 is expected */
 339   indicator = clib_strcmp (s1, "Simplicity is the ultimate");
 340   if (!(indicator > 0))
 341     return -1;
 342   /* verify it against strcmp */
 343   indicator = strcmp (s1, "Simplicity is the ultimate");
 344   if (!(indicator > 0))
 345     return -1;
 346
 347   /* s1 < s2, < 0 is expected */
 348   indicator = clib_strcmp (s1, "Simplicity is the ultimate sophistication!");
 349   if (!(indicator < 0))
 350     return -1;
 351   /* verify it against strcmp */
 352   indicator = strcmp (s1, "Simplicity is the ultimate sophistication!");
 353   if (!(indicator < 0))
 354     return -1;
 355
 356   /* Try some negative tests */
 357
 358   /* Null pointers comparison */
 359   s = 0;
 360   indicator = clib_strcmp (s, s);
 361   if (indicator != 0)
 362     return -1;
 363
 364   /* OK, seems to work */
 365   return 0;
 366 }
 367
 368 static int
 369 test_strncmp_s (vlib_main_t * vm, unformat_input_t * input)
 370 {
 371   char s1[] = "Every moment is a fresh beginning";
 372   uword s1len = sizeof (s1) - 1;        // excluding null
 373   errno_t err;
 374   int indicator = 0;
 375
 376   vlib_cli_output (vm, "Test strncmp_s...");
 377
 378   /* s1 == s2, 0 is expected */
 379   err = strncmp_s (s1, s1len, "Every moment is a fresh beginning", s1len,
 380                    &indicator);
 381   if (err != EOK)
 382     return -1;
 383   if (indicator != 0)
 384     return -1;
 385
 386   /* s1 > s2, 0 is expected since comparison is no more than n character */
 387   err = strncmp_s (s1, s1len, "Every moment is a fresh begin",
 388                    sizeof ("Every moment is a fresh begin") - 1, &indicator);
 389   if (err != EOK)
 390     return -1;
 391   if (indicator != 0)
 392     return -1;
 393
 394   /* s1 < s2, < 0 is expected */
 395   err = strncmp_s (s1, s1len, "Every moment is fresh beginning",
 396                    sizeof ("Every moment is fresh beginning") - 1,
 397                    &indicator);
 398   if (err != EOK)
 399     return -1;
 400   if (!(indicator < 0))
 401     return -1;
 402
 403   /* s1 > s2, > 0 is expected */
 404   err = strncmp_s ("Every moment is fresh beginning. ",
 405                    sizeof ("Every moment is fresh beginning. ") - 1, s1,
 406                    s1len, &indicator);
 407   if (err != EOK)
 408     return -1;
 409   if (!(indicator > 0))
 410     return -1;
 411
 412   /* Try some negative tests */
 413
 414   /* Null pointers */
 415   err = strncmp_s (0, 0, 0, 0, 0);
 416   if (err != EINVAL)
 417     return -1;
 418
 419   /* n > s1max */
 420   err = strncmp_s (s1, s1len, "Every moment is a fresh beginning", s1len + 1,
 421                    &indicator);
 422   if (err != EINVAL)
 423     return -1;
 424
 425   /* unterminated s1 */
 426   s1[s1len] = 0x1;
 427   err = strncmp_s (s1, s1len, "Every moment is a fresh beginning",
 428                    sizeof ("Every moment is a fresh beginning") - 1,
 429                    &indicator);
 430   if (err != EINVAL)
 431     return -1;
 432
 433   /* OK, seems to work */
 434   return 0;
 435 }
 436
 437 static int
 438 test_clib_strncmp (vlib_main_t * vm, unformat_input_t * input)
 439 {
 440   char s1[] = "Every moment is a fresh beginning";
 441   uword s1len = sizeof (s1) - 1;        // excluding null
 442   int indicator, v_indicator;
 443
 444   vlib_cli_output (vm, "Test clib_strncmp...");
 445
 446   /* s1 == s2, 0 is expected */
 447   indicator = clib_strncmp (s1, "Every moment is a fresh beginning", s1len);
 448   if (indicator != 0)
 449     return -1;
 450   /* verify it against strncmp */
 451   v_indicator = strncmp (s1, "Every moment is a fresh beginning", s1len);
 452   if (v_indicator != 0)
 453     return -1;
 454
 455   /* s1 > s2, 0 is expected since comparison is no more than n character */
 456   indicator = clib_strncmp (s1, "Every moment is a fresh begin",
 457                             sizeof ("Every moment is a fresh begin") - 1);
 458   if (indicator != 0)
 459     return -1;
 460   /* verify it against strncmp */
 461   v_indicator = strncmp (s1, "Every moment is a fresh begin",
 462                          sizeof ("Every moment is a fresh begin") - 1);
 463   if (v_indicator != 0)
 464     return -1;
 465
 466   /* s1 < s2, < 0 is expected */
 467   indicator = clib_strncmp (s1, "Every moment is fresh beginning",
 468                             sizeof ("Every moment is fresh beginning") - 1);
 469   if (!(indicator < 0))
 470     return -1;
 471   /* verify it against strncmp */
 472   v_indicator = strncmp (s1, "Every moment is fresh beginning",
 473                          sizeof ("Every moment is fresh beginning") - 1);
 474   if (!(v_indicator < 0))
 475     return -1;
 476   if (v_indicator != indicator)
 477     return -1;
 478
 479   /* s1 > s2, > 0 is expected */
 480   indicator = clib_strncmp ("Every moment is fresh beginning. ", s1, s1len);
 481   if (!(indicator > 0))
 482     return -1;
 483   /* verify it against strncmp */
 484   v_indicator = strncmp ("Every moment is fresh beginning. ", s1, s1len);
 485   if (!(v_indicator > 0))
 486     return -1;
 487   if (v_indicator != indicator)
 488     return -1;
 489
 490   /* Try some negative tests */
 491
 492   /* Null pointers */
 493
 494   /* make sure we don't crash */
 495   indicator = clib_strncmp (0, 0, 0);
 496   if (indicator != EOK)
 497     return -1;
 498
 499   /* n > s1 len */
 500   indicator =
 501     clib_strncmp (s1, "Every moment is a fresh beginning", s1len + 1);
 502   if (indicator != 0)
 503     return -1;
 504   /* verify it against strncmp */
 505   v_indicator = strncmp (s1, "Every moment is a fresh beginning", s1len + 1);
 506   if (v_indicator != 0)
 507     return -1;
 508
 509   /* unterminated s1 */
 510   s1[s1len] = 0x1;
 511   clib_mem_unpoison (s1, CLIB_STRING_MACRO_MAX);
 512   indicator = clib_strncmp (s1, "Every moment is a fresh beginning",
 513                             sizeof ("every moment is a fresh beginning") - 1);
 514   if (indicator != 0)
 515     return -1;
 516   /* verify it against strncmp */
 517   v_indicator = strncmp (s1, "Every moment is a fresh beginning",
 518                          sizeof ("Every moment is a fresh beginning") - 1);
 519   if (v_indicator != 0)
 520     return -1;
 521
 522   /* OK, seems to work */
 523   return 0;
 524 }
 525
 526 static int
 527 test_strcpy_s (vlib_main_t * vm, unformat_input_t * input)
 528 {
 529   char src[] = "To err is human.";
 530   char dst[64];
 531   int indicator;
 532   size_t s1size = sizeof (dst); // including null
 533   errno_t err;
 534
 535   vlib_cli_output (vm, "Test strcpy_s...");
 536
 537   err = strcpy_s (dst, s1size, src);
 538   if (err != EOK)
 539     return -1;
 540
 541   /* This better not fail but check anyhow */
 542   if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), src, &indicator) !=
 543       EOK)
 544     return -1;
 545   if (indicator != 0)
 546     return -1;
 547
 548   /* Negative tests */
 549
 550   err = strcpy_s (0, 0, 0);
 551   if (err == EOK)
 552     return -1;
 553
 554   /* Size fail */
 555   err = strcpy_s (dst, 10, src);
 556   if (err == EOK)
 557     return -1;
 558
 559   /* overlap fail */
 560 #if __GNUC__ < 8
 561   /* GCC 8 flunks this one at compile time... */
 562   err = strcpy_s (dst, s1size, dst);
 563   if (err == EOK)
 564     return -1;
 565 #endif
 566
 567   /* overlap fail */
 568   err = strcpy_s (dst, s1size, dst + 1);
 569   if (err == EOK)
 570     return -1;
 571
 572   /* OK, seems to work */
 573   return 0;
 574 }
 575
 576 static int
 577 test_strncpy_s (vlib_main_t * vm, unformat_input_t * input)
 578 {
 579   char src[] = "Those who dare to fail miserably can achieve greatly.";
 580   char dst[100], old_dst[100];
 581   int indicator, i;
 582   size_t s1size = sizeof (dst); // including null
 583   errno_t err;
 584
 585   vlib_cli_output (vm, "Test strncpy_s...");
 586
 587   /* dmax includes null, n excludes null */
 588
 589   /* n == string len of src */
 590   err = strncpy_s (dst, s1size, src, clib_strnlen (src, sizeof (src)));
 591   if (err != EOK)
 592     return -1;
 593   if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), src, &indicator) !=
 594       EOK)
 595     return -1;
 596   if (indicator != 0)
 597     return -1;
 598
 599   /* limited copy -- strlen src > n, copy up to n */
 600   err = strncpy_s (dst, s1size, "The price of greatness is responsibility.",
 601                    10);
 602   if (err != EOK)
 603     return -1;
 604   if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), "The price ",
 605                 &indicator) != EOK)
 606     return -1;
 607   if (indicator != 0)
 608     return -1;
 609
 610   /* n > string len of src */
 611   err = clib_memset (dst, 1, sizeof (dst));
 612   if (err != EOK)
 613     return -1;
 614
 615   err = strncpy_s (dst, s1size, src, clib_strnlen (src, sizeof (src)) + 10);
 616   if (err != EOK)
 617     return -1;
 618   if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), src, &indicator) !=
 619       EOK)
 620     return -1;
 621   if (indicator != 0)
 622     return -1;
 623
 624   /* Make sure bytes after strlen(dst) is untouched */
 625   for (i = 1 + clib_strnlen (dst, sizeof (dst)); i < sizeof (dst); i++)
 626     if (dst[i] != 1)
 627       return -1;
 628
 629   /* truncation, n >= dmax */
 630   err = strncpy_s (dst, clib_strnlen (src, sizeof (src)), src,
 631                    clib_strnlen (src, sizeof (src)));
 632   if (err != EOVERFLOW)
 633     return -1;
 634
 635   /* Check dst content */
 636   if (dst[strlen (dst)] != '\0')
 637     return -1;
 638   if (strncmp_s (dst, clib_strnlen (dst, sizeof (dst)), src,
 639                  clib_strnlen (dst, sizeof (dst)), &indicator) != EOK)
 640     return -1;
 641   if (indicator != 0)
 642     return -1;
 643
 644   /* zero length copy */
 645   clib_strncpy (old_dst, dst, clib_strnlen (dst, sizeof (dst)));
 646   err = strncpy_s (dst, sizeof (dst), src, 0);
 647   if (err != EOK)
 648     return -1;
 649   /* verify dst is untouched */
 650   if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), old_dst, &indicator) !=
 651       EOK)
 652     return -1;
 653   if (indicator != 0)
 654     return -1;
 655
 656   /* Negative tests */
 657
 658   err = strncpy_s (0, 0, 0, 1);
 659   if (err == EOK)
 660     return -1;
 661
 662   /* overlap fail */
 663   err = strncpy_s (dst, s1size, dst + 1, s1size - 1);
 664   if (err == EOK)
 665     return -1;
 666
 667   /* overlap fail */
 668 #if __GNUC__ < 8
 669   /* GCC 8 flunks this one at compile time... */
 670   err = strncpy_s (dst, s1size, dst, s1size);
 671   if (err == EOK)
 672     return -1;
 673 #endif
 674
 675   /* OK, seems to work */
 676   return 0;
 677 }
 678
 679 static int
 680 test_clib_strncpy (vlib_main_t * vm, unformat_input_t * input)
 681 {
 682   char src[] = "Those who dare to fail miserably can achieve greatly.";
 683   char dst[100], old_dst[100];
 684   int indicator;
 685   size_t s1size = sizeof (dst); // including null
 686   errno_t err;
 687
 688   vlib_cli_output (vm, "Test clib_strncpy...");
 689
 690   /* n == string len of src */
 691   err = clib_strncpy (dst, src, clib_strnlen (src, sizeof (src)));
 692   if (err != EOK)
 693     return -1;
 694
 695   /* This better not fail but check anyhow */
 696   if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), src, &indicator) !=
 697       EOK)
 698     return -1;
 699   if (indicator != 0)
 700     return -1;
 701
 702   /* Verify it against strncpy */
 703 #if __GNUC__ < 8
 704   /* GCC 8 debian flunks this one at compile time */
 705   strncpy (dst, src, strlen (src));
 706
 707   /* This better not fail but check anyhow */
 708   if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), src, &indicator) !=
 709       EOK)
 710     return -1;
 711   if (indicator != 0)
 712     return -1;
 713 #endif
 714
 715   /* limited copy -- strlen src > n, copy up to n */
 716   err = clib_strncpy (dst, "The price of greatness is responsibility.", 10);
 717   if (err != EOK)
 718     return -1;
 719   if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), "The price ",
 720                 &indicator) != EOK)
 721     return -1;
 722   if (indicator != 0)
 723     return -1;
 724   /* verify it against strncpy */
 725   memset_s (dst, sizeof (dst), 0, sizeof (dst));
 726
 727 #if __GNUC__ < 8
 728   /* GCC 8 flunks this one at compile time... */
 729   strncpy (dst, "The price of greatness is responsibility.", 10);
 730   if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), "The price ",
 731                 &indicator) != EOK)
 732     return -1;
 733   if (indicator != 0)
 734     return -1;
 735 #endif
 736
 737   /* n > string len of src */
 738   err = clib_strncpy (dst, src, clib_strnlen (src, sizeof (src)) + 10);
 739   if (err != EOK)
 740     return -1;
 741   if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), src, &indicator) !=
 742       EOK)
 743     return -1;
 744   if (indicator != 0)
 745     return -1;
 746   /* Verify it against strncpy */
 747 #if __GNUC__ < 8
 748   /* GCC 8 debian flunks this one at compile time */
 749   strncpy (dst, src, strlen (src));
 750   if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), src, &indicator) !=
 751       EOK)
 752     return -1;
 753   if (indicator != 0)
 754     return -1;
 755 #endif
 756
 757   /* zero length copy */
 758   clib_strncpy (old_dst, dst, clib_strnlen (dst, sizeof (dst)));
 759   err = clib_strncpy (dst, src, 0);
 760   if (err != EOK)
 761     return -1;
 762   /* verify dst is untouched */
 763   if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), old_dst, &indicator) !=
 764       EOK)
 765     return -1;
 766   if (indicator != 0)
 767     return -1;
 768
 769   /* Negative tests */
 770
 771   err = clib_strncpy (0, 0, 1);
 772   if (err == EOK)
 773     return -1;
 774
 775   /* overlap fail */
 776   err = clib_strncpy (dst, dst + 1, s1size);
 777   if (err == EOK)
 778     return -1;
 779
 780   /* overlap fail */
 781 #if __GNUC__ < 8
 782   /* GCC 8 flunks this one at compile time... */
 783   err = clib_strncpy (dst, dst, s1size);
 784   if (err == EOK)
 785     return -1;
 786 #endif
 787
 788   /* OK, seems to work */
 789   return 0;
 790 }
 791
 792 static int
 793 test_strcat_s (vlib_main_t * vm, unformat_input_t * input)
 794 {
 795   char src[100], dst[100], old_dst[100];
 796   size_t s1size = sizeof (dst); // including null
 797   errno_t err;
 798   int indicator;
 799
 800   vlib_cli_output (vm, "Test strcat_s...");
 801
 802   strcpy_s (dst, sizeof (dst), "Tough time never last ");
 803   strcpy_s (src, sizeof (src), "but tough people do");
 804   err = strcat_s (dst, s1size, src);
 805   if (err != EOK)
 806     return -1;
 807   if (strcmp_s (dst, s1size - 1,
 808                 "Tough time never last but tough people do",
 809                 &indicator) != EOK)
 810     return -1;
 811   if (indicator != 0)
 812     return -1;
 813
 814   /* empty string concatenation */
 815   clib_strncpy (old_dst, dst, clib_strnlen (dst, sizeof (dst)));
 816   err = strcat_s (dst, s1size, "");
 817   if (err != EOK)
 818     return -1;
 819   /* verify dst is untouched */
 820   if (strcmp_s (dst, s1size - 1, old_dst, &indicator) != EOK)
 821     return -1;
 822   if (indicator != 0)
 823     return -1;
 824
 825   /* negative stuff */
 826   err = strcat_s (0, 0, 0);
 827   if (err != EINVAL)
 828     return -1;
 829
 830   /* overlap fail */
 831   err = strcat_s (dst, s1size, dst + 1);
 832   if (err != EINVAL)
 833     return -1;
 834
 835   /* overlap fail */
 836 #if __GNUC__ < 8
 837   /* GCC 8 flunks this one at compile time... */
 838   err = strcat_s (dst, s1size, dst);
 839   if (err != EINVAL)
 840     return -1;
 841 #endif
 842
 843   /* not enough space for dst */
 844   err = strcat_s (dst, 10, src);
 845   if (err != EINVAL)
 846     return -1;
 847
 848   /* OK, seems to work */
 849   return 0;
 850 }
 851
 852 static int
 853 test_strncat_s (vlib_main_t * vm, unformat_input_t * input)
 854 {
 855   char src[100], dst[100], old_dst[100];
 856   size_t s1size = sizeof (dst); // including null
 857   errno_t err;
 858   char s1[] = "Two things are infinite: ";
 859   char s2[] = "the universe and human stupidity; ";
 860   char s3[] = "I am not sure about the universe.";
 861   int indicator;
 862
 863   vlib_cli_output (vm, "Test strncat_s...");
 864
 865   strcpy_s (dst, sizeof (dst), s1);
 866   strcpy_s (src, sizeof (src), s2);
 867   err = strncat_s (dst, s1size, src, clib_strnlen (src, sizeof (src)));
 868   if (err != EOK)
 869     return -1;
 870   if (strcmp_s (dst, s1size - 1,
 871                 "Two things are infinite: the universe and human stupidity; ",
 872                 &indicator) != EOK)
 873     return -1;
 874   if (indicator != 0)
 875     return -1;
 876
 877   /* truncation, n >= dmax - strnlen_s (dst, dmax) */
 878   err = strncat_s (dst, clib_strnlen (dst, sizeof (dst)) +
 879                    clib_strnlen (s3, sizeof (s3)), s3,
 880                    clib_strnlen (s3, sizeof (s3)));
 881   if (err != EOVERFLOW)
 882     return -1;
 883   /*
 884    * resulting string is dst + strlen (s3) - 1 characters + null.
 885    * notice the "." is missing at the end of the resulting string because
 886    * the space is needed to accommodate the null
 887    * Notice strcmp_s will check s1 or dst to make sure it is null terminated
 888    */
 889   if (strcmp_s (dst, s1size - 1,
 890                 "Two things are infinite: the universe and human stupidity; "
 891                 "I am not sure about the universe", &indicator) != EOK)
 892     return -1;
 893   if (indicator != 0)
 894     return -1;
 895
 896   /* n > strlen src */
 897   strcpy_s (dst, sizeof (dst), s1);
 898   err = strncat_s (dst, s1size, src, clib_strnlen (src, sizeof (src)) + 10);
 899   if (err != EOK)
 900     return -1;
 901   if (strcmp_s (dst, s1size - 1,
 902                 "Two things are infinite: the universe and human stupidity; ",
 903                 &indicator) != EOK)
 904     return -1;
 905   if (indicator != 0)
 906     return -1;
 907
 908   /* zero length strncat */
 909   clib_strncpy (old_dst, dst, clib_strnlen (dst, sizeof (dst)));
 910   err = strncat_s (dst, sizeof (dst), src, 0);
 911   if (err != EOK)
 912     return -1;
 913   /* verify dst is untouched */
 914   if (strcmp_s (dst, s1size - 1, old_dst, &indicator) != EOK)
 915     return -1;
 916   if (indicator != 0)
 917     return -1;
 918
 919   /* empty string, wrong n concatenation */
 920   err = strncat_s (dst, sizeof (dst), "", 10);
 921   if (err != EOK)
 922     return -1;
 923   /* verify dst is untouched */
 924   if (strcmp_s (dst, s1size - 1, old_dst, &indicator) != EOK)
 925     return -1;
 926   if (indicator != 0)
 927     return -1;
 928
 929   /* limited concatenation, string > n, copy up to n */
 930   strcpy_s (dst, sizeof (dst), s1);
 931   err = strncat_s (dst, s1size, s2, 13);
 932   if (err != EOK)
 933     return -1;
 934   if (strcmp_s (dst, s1size - 1, "Two things are infinite: the universe ",
 935                 &indicator) != EOK)
 936     return -1;
 937   if (indicator != 0)
 938     return -1;
 939   /* verify it against strncat */
 940 #if __GNUC__ < 8
 941   /* GCC 8 debian flunks this one at compile time */
 942   strcpy_s (dst, sizeof (dst), s1);
 943   strncat (dst, s2, 13);
 944   if (strcmp_s (dst, s1size - 1, "Two things are infinite: the universe ",
 945                 &indicator) != EOK)
 946     return -1;
 947   if (indicator != 0)
 948     return -1;
 949 #endif
 950
 951   /* negative stuff */
 952   err = strncat_s (0, 0, 0, 1);
 953   if (err != EINVAL)
 954     return -1;
 955
 956   /* no room for dst -- dmax - strnlen_s (dst, dmax) == 0 */
 957   err = strncat_s (dst, clib_strnlen (dst, sizeof (dst)), s2,
 958                    clib_strnlen (s2, sizeof (s2)));
 959   if (err != EINVAL)
 960     return -1;
 961
 962   /* overlap fail */
 963   err = strncat_s (dst, s1size, dst + 1, clib_strnlen (dst + 1, s1size - 1));
 964   if (err != EINVAL)
 965     return -1;
 966
 967   /* overlap fail */
 968 #if __GNUC__ < 8
 969   /* GCC 8 flunks this one at compile time... */
 970   err = strncat_s (dst, s1size, dst, clib_strnlen (dst, sizeof (dst)));
 971   if (err != EINVAL)
 972     return -1;
 973 #endif
 974
 975   /* OK, seems to work */
 976   return 0;
 977 }
 978
 979 static int
 980 test_strtok_s (vlib_main_t * vm, unformat_input_t * input)
 981 {
 982   int indicator;
 983   char *tok, *ptr;
 984   char str2[20];
 985   char str1[40];
 986   uword len;
 987   char *p2str = 0;
 988   char *tok1, *tok2, *tok3, *tok4, *tok5, *tok6, *tok7;
 989
 990   vlib_cli_output (vm, "Test strtok_s...");
 991   strcpy_s (str1, sizeof (str1), "brevity is the soul of wit");
 992   len = strnlen_s (str1, sizeof (str1));
 993   tok1 = strtok_s (str1, &len, " ", &p2str);
 994   tok2 = strtok_s (0, &len, " ", &p2str);
 995   tok3 = strtok_s (0, &len, " ", &p2str);
 996   tok4 = strtok_s (0, &len, " ", &p2str);
 997   tok5 = strtok_s (0, &len, " ", &p2str);
 998   tok6 = strtok_s (0, &len, " ", &p2str);
 999   tok7 = strtok_s (0, &len, " ", &p2str);
1000   if ((tok1 == 0) ||
1001       strcmp_s (tok1, strlen (tok1), "brevity", &indicator) != EOK)
1002     return -1;
1003   if (indicator != 0)
1004     return -1;
1005   if ((tok2 == 0) || strcmp_s (tok2, strlen (tok2), "is", &indicator) != EOK)
1006     return -1;
1007   if (indicator != 0)
1008     return -1;
1009   if ((tok3 == 0) || strcmp_s (tok3, strlen (tok3), "the", &indicator) != EOK)
1010     return -1;
1011   if (indicator != 0)
1012     return -1;
1013   if ((tok4 == 0)
1014       || strcmp_s (tok4, strlen (tok4), "soul", &indicator) != EOK)
1015     return -1;
1016   if (indicator != 0)
1017     return -1;
1018   if ((tok5 == 0) || strcmp_s (tok5, strlen (tok5), "of", &indicator) != EOK)
1019     return -1;
1020   if (indicator != 0)
1021     return -1;
1022   if ((tok6 == 0) || strcmp_s (tok6, strlen (tok6), "wit", &indicator) != EOK)
1023     return -1;
1024   if (indicator != 0)
1025     return -1;
1026   if (tok7 != 0)
1027     return -1;
1028
1029   /* delimiter not present in the string -- the whole string is returned */
1030   strcpy_s (str1, sizeof (str1), "brevity is the soul of wit");
1031   len = strnlen_s (str1, sizeof (str1) - 1);
1032   p2str = 0;
1033   tok1 = strtok_s (str1, &len, ",", &p2str);
1034   if ((tok1 == 0) || strcmp_s (tok1, strlen (tok1), str1, &indicator) != EOK)
1035     return -1;
1036   if (indicator != 0)
1037     return -1;
1038
1039   /* negative stuff */
1040   tok = strtok_s (0, 0, 0, 0);
1041   if (tok != 0)
1042     return -1;
1043
1044   /* s1 and ptr contents are null */
1045   ptr = 0;
1046   tok = strtok_s (0, 0, 0, &ptr);
1047   if (tok != 0)
1048     return -1;
1049
1050   /* unterminate s1 */
1051   p2str = 0;
1052   len = strnlen_s (str1, sizeof (str1) - 1);
1053   str1[strlen (str1)] = 0x2;
1054   tok = strtok_s (str1, &len, ",", &p2str);
1055   if (tok != 0)
1056     return -1;
1057
1058   /*
1059    * unterminated s2. This test case in not perfect because there is no
1060    * argument for s2max. But s2 len is limited to 16 characters. If the API
1061    * does not find the null character at s2[15], it declares the string s2
1062    * as unterminated.
1063    */
1064   memset_s (str2, sizeof (str2), 0xfa, sizeof (str2));
1065   tok = strtok_s (str1, &len, str2, &p2str);
1066   if (tok != 0)
1067     return -1;
1068
1069   /* OK, seems to work */
1070   return 0;
1071 }
1072
1073 static int
1074 test_clib_strtok (vlib_main_t * vm, unformat_input_t * input)
1075 {
1076   int indicator;
1077   char *s1 __attribute__ ((unused));
1078   char *tok __attribute__ ((unused));
1079   char *ptr __attribute__ ((unused));
1080   char str1[40];
1081   char *p2str;
1082   char *tok1, *tok2, *tok3, *tok4, *tok5, *tok6, *tok7;
1083
1084   vlib_cli_output (vm, "Test clib_strtok...");
1085   strcpy_s (str1, sizeof (str1), "brevity is the soul of wit");
1086   p2str = 0;
1087   tok1 = clib_strtok (str1, " ", &p2str);
1088   tok2 = clib_strtok (0, " ", &p2str);
1089   tok3 = clib_strtok (0, " ", &p2str);
1090   tok4 = clib_strtok (0, " ", &p2str);
1091   tok5 = clib_strtok (0, " ", &p2str);
1092   tok6 = clib_strtok (0, " ", &p2str);
1093   tok7 = clib_strtok (0, " ", &p2str);
1094   if ((tok1 == 0) ||
1095       strcmp_s (tok1, strlen (tok1), "brevity", &indicator) != EOK)
1096     return -1;
1097   if (indicator != 0)
1098     return -1;
1099   if ((tok2 == 0) || strcmp_s (tok2, strlen (tok2), "is", &indicator) != EOK)
1100     return -1;
1101   if (indicator != 0)
1102     return -1;
1103   if ((tok3 == 0) || strcmp_s (tok3, strlen (tok3), "the", &indicator) != EOK)
1104     return -1;
1105   if (indicator != 0)
1106     return -1;
1107   if ((tok4 == 0)
1108       || strcmp_s (tok4, strlen (tok4), "soul", &indicator) != EOK)
1109     return -1;
1110   if (indicator != 0)
1111     return -1;
1112   if ((tok5 == 0) || strcmp_s (tok5, strlen (tok5), "of", &indicator) != EOK)
1113     return -1;
1114   if (indicator != 0)
1115     return -1;
1116   if ((tok6 == 0) || strcmp_s (tok6, strlen (tok6), "wit", &indicator) != EOK)
1117     return -1;
1118   if (indicator != 0)
1119     return -1;
1120   if (tok7 != 0)
1121     return -1;
1122   /* verify it againest strtok_r */
1123   strcpy_s (str1, sizeof (str1), "brevity is the soul of wit");
1124   p2str = 0;
1125   tok1 = strtok_r (str1, " ", &p2str);
1126   tok2 = strtok_r (0, " ", &p2str);
1127   tok3 = strtok_r (0, " ", &p2str);
1128   tok4 = strtok_r (0, " ", &p2str);
1129   tok5 = strtok_r (0, " ", &p2str);
1130   tok6 = strtok_r (0, " ", &p2str);
1131   tok7 = strtok_r (0, " ", &p2str);
1132   if ((tok1 == 0) ||
1133       strcmp_s (tok1, strlen (tok1), "brevity", &indicator) != EOK)
1134     return -1;
1135   if (indicator != 0)
1136     return -1;
1137   if ((tok2 == 0) || strcmp_s (tok2, strlen (tok2), "is", &indicator) != EOK)
1138     return -1;
1139   if (indicator != 0)
1140     return -1;
1141   if ((tok3 == 0) || strcmp_s (tok3, strlen (tok3), "the", &indicator) != EOK)
1142     return -1;
1143   if (indicator != 0)
1144     return -1;
1145   if ((tok4 == 0)
1146       || strcmp_s (tok4, strlen (tok4), "soul", &indicator) != EOK)
1147     return -1;
1148   if (indicator != 0)
1149     return -1;
1150   if ((tok5 == 0) || strcmp_s (tok5, strlen (tok5), "of", &indicator) != EOK)
1151     return -1;
1152   if (indicator != 0)
1153     return -1;
1154   if ((tok6 == 0) || strcmp_s (tok6, strlen (tok6), "wit", &indicator) != EOK)
1155     return -1;
1156   if (indicator != 0)
1157     return -1;
1158   if (tok7 != 0)
1159     return -1;
1160
1161   /* delimiter not present in the string -- the whole string is returned */
1162   strcpy_s (str1, sizeof (str1), "brevity is the soul of wit");
1163   p2str = 0;
1164   tok1 = clib_strtok (str1, ",", &p2str);
1165   if ((tok1 == 0) || strcmp_s (tok1, strlen (tok1), str1, &indicator) != EOK)
1166     return -1;
1167   if (indicator != 0)
1168     return -1;
1169   /* verify it against strtok_r */
1170   strcpy_s (str1, sizeof (str1), "brevity is the soul of wit");
1171   p2str = 0;
1172   tok1 = strtok_r (str1, ",", &p2str);
1173   if ((tok1 == 0) || strcmp_s (tok1, strlen (tok1), str1, &indicator) != EOK)
1174     return -1;
1175   if (indicator != 0)
1176     return -1;
1177
1178   /* negative stuff */
1179   s1 = 0;
1180   ptr = 0;
1181 #if __GNUC__ < 8
1182   /* GCC 8 flunks this one at compile time... */
1183   tok = clib_strtok (s1, s1, (char **) 0);
1184   if (tok != 0)
1185     return -1;
1186
1187   /* s1 and ptr contents are null */
1188   tok = clib_strtok (s1, s1, &ptr);
1189   if (tok != 0)
1190     return -1;
1191 #endif
1192
1193   /* verify it against strtok_r */
1194   /* No can do. This causes a crash in strtok_r */
1195   // tok = strtok_r (s1, " ", &ptr);
1196   // if (tok != 0)
1197   //  return -1;
1198
1199   /*
1200    * Can't test unterminated string s1 and s2 becuase clib_strtok does not
1201    * supply s1 and s2 max
1202    */
1203
1204   /* OK, seems to work */
1205   return 0;
1206 }
1207
1208 static int
1209 test_strnlen_s (vlib_main_t * vm, unformat_input_t * input)
1210 {
1211   const char s1[] = "Truth is incontrovertible";
1212   size_t len;
1213
1214   vlib_cli_output (vm, "Test strnlen_s...");
1215
1216   len = strnlen_s (s1, sizeof (s1));
1217   if (len != sizeof (s1) - 1)
1218     return -1;
1219
1220   len = strnlen_s (s1, 5);
1221   if (len != 5)
1222     return -1;
1223
1224   /* negative stuff */
1225   len = strnlen_s (0, 0);
1226   if (len != 0)
1227     return -1;
1228
1229   /* OK, seems to work */
1230   return 0;
1231 }
1232
1233 static int
1234 test_clib_strnlen (vlib_main_t * vm, unformat_input_t * input)
1235 {
1236   const char s1[] = "Truth is incontrovertible";
1237   size_t len;
1238
1239   vlib_cli_output (vm, "Test clib_strnlen...");
1240
1241   len = clib_strnlen (s1, sizeof (s1));
1242   if (len != sizeof (s1) - 1)
1243     return -1;
1244
1245   len = clib_strnlen (s1, 5);
1246   if (len != 5)
1247     return -1;
1248
1249   /* negative stuff */
1250   len = clib_strnlen (0, 0);
1251   if (len != 0)
1252     return -1;
1253
1254   /* OK, seems to work */
1255   return 0;
1256 }
1257
1258 static int
1259 test_strstr_s (vlib_main_t * vm, unformat_input_t * input)
1260 {
1261   errno_t err;
1262   char *sub = 0;
1263   char s1[64];
1264   size_t s1len = sizeof (s1) - 1;       // excluding null
1265   int indicator;
1266
1267   vlib_cli_output (vm, "Test strstr_s...");
1268
1269   /* substring not present */
1270   strcpy_s (s1, s1len, "success is not final, failure is not fatal.");
1271   err = strstr_s (s1, s1len, "failures", sizeof ("failures"), &sub);;
1272   if (err != ESRCH)
1273     return -1;
1274
1275   /* substring present */
1276   err = strstr_s (s1, s1len, "failure", sizeof ("failure"), &sub);
1277   if (err != EOK)
1278     return -1;
1279
1280   if ((sub == 0) ||
1281       strcmp_s (sub, strlen (sub), "failure is not fatal.", &indicator)
1282       != EOK)
1283     return -1;
1284   if (indicator != 0)
1285     return -1;
1286
1287   /* negative stuff */
1288
1289   /* Null pointers test */
1290   err = strstr_s (0, 0, 0, 0, 0);
1291   if (err != EINVAL)
1292     return -1;
1293
1294   /* unterminated s1 and s2 */
1295   memset_s (s1, ARRAY_LEN (s1), 0xfe, ARRAY_LEN (s1));
1296   err = strstr_s (s1, s1len, s1, s1len, &sub);
1297   if (err != EINVAL)
1298     return -1;
1299
1300   /* OK, seems to work */
1301   return 0;
1302 }
1303
1304 #define foreach_string_test                                                   \
1305   _ (0, MEMCPY_S, "memcpy_s", memcpy_s)                                       \
1306   _ (1, CLIB_MEMCPY, "clib_memcpy", clib_memcpy)                              \
1307   _ (2, MEMSET_S, "memset_s", memset_s)                                       \
1308   _ (3, CLIB_MEMSET, "clib_memset", clib_memset)                              \
1309   _ (4, MEMCMP_S, "memcmp_s", memcmp_s)                                       \
1310   _ (5, CLIB_MEMCMP, "clib_memcmp", clib_memcmp)                              \
1311   _ (6, STRCMP_S, "strcmp_s", strcmp_s)                                       \
1312   _ (7, CLIB_STRCMP, "clib_strcmp", clib_strcmp)                              \
1313   _ (8, STRNCMP_S, "strncmp_s", strncmp_s)                                    \
1314   _ (9, CLIB_STRNCMP, "clib_strncmp", clib_strncmp)                           \
1315   _ (10, STRCPY_S, "strcpy_s", strcpy_s)                                      \
1316   _ (11, STRNCPY_S, "strncpy_s", strncpy_s)                                   \
1317   _ (12, CLIB_STRNCPY, "clib_strncpy", clib_strncpy)                          \
1318   _ (13, STRCAT_S, "strcat_s", strcat_s)                                      \
1319   _ (14, STRNCAT_S, "strncat_s", strncat_s)                                   \
1320   _ (15, STRTOK_S, "strtok_s", strtok_s)                                      \
1321   _ (16, CLIB_STRTOK, "clib_strtok", clib_strtok)                             \
1322   _ (17, STRNLEN_S, "strnlen_s", strnlen_s)                                   \
1323   _ (18, CLIB_STRNLEN, "clib_strnlen", clib_strnlen)                          \
1324   _ (19, STRSTR_S, "strstr_s", strstr_s)
1325
1326 typedef enum
1327 {
1328 #define _(v,f,s,p) STRING_TEST_##f = v,
1329   foreach_string_test
1330 #undef _
1331 #define STRING_TEST_FIRST       STRING_TEST_MEMCPY_S
1332 #define STRING_TEST_LAST        STRING_TEST_STRSTR_S
1333 } string_test_t;
1334
1335 static uword
1336 unformat_string_test (unformat_input_t * input, va_list * args)
1337 {
1338   u8 *r = va_arg (*args, u8 *);
1339
1340   if (0)
1341     ;
1342 #define _(v,f,s,p) else if (unformat (input, s)) *r = STRING_TEST_##f;
1343   foreach_string_test
1344 #undef _
1345     else
1346     return 0;
1347
1348   return 1;
1349 }
1350
1351 typedef int (*string_test_func) (vlib_main_t * vm, unformat_input_t * input);
1352
1353 typedef struct
1354 {
1355   string_test_func test;
1356 } string_test_func_t;
1357
1358 static clib_error_t *
1359 string_test_command_fn (vlib_main_t * vm,
1360                         unformat_input_t * input,
1361                         vlib_cli_command_t * cmd_arg)
1362 {
1363   string_test_func_t string_func[] = {
1364 #define _(v,f,s,p) { test_##p },
1365     foreach_string_test
1366 #undef _
1367   };
1368   const char *string_table[] = {
1369 #define _(v,f,s,p) s,
1370     foreach_string_test
1371 #undef _
1372   };
1373   int res = 0, ok;
1374   i8 specific_test = ~0;
1375
1376   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1377     {
1378       if (unformat (input, "%U", unformat_string_test, &specific_test))
1379         break;
1380       else
1381         return clib_error_return (0, "unknown input `%U'",
1382                                   format_unformat_error, input);
1383     }
1384
1385   if (specific_test == ~0)
1386     {
1387       for (specific_test = STRING_TEST_FIRST;
1388            specific_test <= STRING_TEST_LAST; specific_test++)
1389         {
1390           ok = (string_func[specific_test]).test (vm, input);
1391           res += ok;
1392           if (ok != 0)
1393             vlib_cli_output (vm, "test_%s failed",
1394                              string_table[specific_test]);
1395         }
1396     }
1397   else
1398     res = (string_func[specific_test]).test (vm, input);
1399   if (res)
1400     vlib_cli_output (vm, "String unit test(s) failed...");
1401   else
1402     vlib_cli_output (vm, "String unit test(s) OK...");
1403   return 0;
1404 }
1405
1406 VLIB_CLI_COMMAND (string_test_command, static) = {
1407   .path = "test string",
1408   .short_help =
1409     "test string [memcpy_s | clib_memcpy | memset_s | "
1410     "clib_memset | memcmp_s | clib_memcmp | strcmp_s | clib_strcmp | "
1411     "strncmp_s | clib_strncmp | strcpy_s | strncpy_s | "
1412     "clib_strncpy | strcat_s | strncat_s | "
1413     "strtok_s |  clib_strtok | strnlen_s | clib_strnlen | strstr_s ]",
1414   .function = string_test_command_fn,
1415 };
1416
1417 /*
1418  * fd.io coding-style-patch-verification: ON
1419  *
1420  * Local Variables:
1421  * eval: (c-set-style "gnu")
1422  * End:
1423  */