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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
15 #include <vlib/vlib.h>
16 #include <vppinfra/string.h>
19 test_memset_s (vlib_main_t * vm, unformat_input_t * input)
25 vlib_cli_output (vm, "Test memset_s...");
27 err = memset_s (dst, ARRAY_LEN (dst), 0xfe, ARRAY_LEN (dst));
32 for (i = 0; i < ARRAY_LEN (dst); i++)
36 err = memset_s (dst, ARRAY_LEN (dst), 0xfa, ARRAY_LEN (dst) + 1);
45 test_clib_memset (vlib_main_t * vm, unformat_input_t * input)
51 vlib_cli_output (vm, "Test clib_memset...");
53 err = clib_memset (dst, 0xfe, ARRAY_LEN (dst));
58 for (i = 0; i < ARRAY_LEN (dst); i++)
66 test_memcpy_s (vlib_main_t * vm, unformat_input_t * input)
68 char src[64], dst[64];
72 vlib_cli_output (vm, "Test memcpy_s...");
74 for (i = 0; i < ARRAY_LEN (src); i++)
78 err = memcpy_s (dst, sizeof (dst), src, sizeof (src));
83 /* This better not fail but check anyhow */
84 for (i = 0; i < ARRAY_LEN (dst); i++)
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.
95 if (__builtin_constant_p (sizeof (src)) == 0)
97 err = memcpy_s (dst + 1, sizeof (dst) - 1, src, sizeof (src));
104 err = memcpy_s (dst, sizeof (dst), dst + 1, sizeof (dst) - 1);
109 /* Zero length copy */
110 err = memcpy_s (0, sizeof (dst), src, 0);
115 /* OK, seems to work */
120 test_clib_memcpy (vlib_main_t * vm, unformat_input_t * input)
122 char src[64], dst[64];
126 vlib_cli_output (vm, "Test clib_memcpy...");
128 for (i = 0; i < ARRAY_LEN (src); i++)
132 err = clib_memcpy (dst, src, sizeof (src));
137 /* This better not fail but check anyhow */
138 for (i = 0; i < ARRAY_LEN (dst); i++)
139 if (src[i] != dst[i])
141 /* verify it against memcpy */
142 memcpy (dst, src, sizeof (src));
144 /* This better not fail but check anyhow */
145 for (i = 0; i < ARRAY_LEN (dst); i++)
146 if (src[i] != dst[i])
149 /* Zero length copy */
150 err = clib_memcpy (0, src, 0);
155 /* OK, seems to work */
160 test_memcmp_s (vlib_main_t * vm, unformat_input_t * input)
162 char src[64], dst[64];
166 vlib_cli_output (vm, "Test memcmp_s...");
168 /* Fill array with different values */
169 err = clib_memset (src, 0x1, ARRAY_LEN (src));
172 err = clib_memset (dst, 0x3, ARRAY_LEN (dst));
176 /* s1 > s2, > 0 is expected in diff */
177 err = memcmp_s (dst, ARRAY_LEN (dst), src, ARRAY_LEN (src), &diff);
183 /* s1 < s2, < 0 is expected in diff */
184 err = memcmp_s (src, ARRAY_LEN (src), dst, ARRAY_LEN (dst), &diff);
190 err = clib_memset (dst, 0x1, ARRAY_LEN (dst));
194 /* s1 == s2, 0 is expected in diff */
195 err = memcmp_s (src, ARRAY_LEN (src), dst, ARRAY_LEN (dst), &diff);
201 /* Try negative tests */
202 err = memcmp_s (0, 0, 0, 0, 0);
206 /* Try s2max > s1max */
207 err = memcmp_s (src, ARRAY_LEN (src) - 1, dst, ARRAY_LEN (dst), &diff);
211 /* OK, seems to work */
216 test_clib_memcmp (vlib_main_t * vm, unformat_input_t * input)
218 char src[64], dst[64];
222 vlib_cli_output (vm, "Test clib_memcmp...");
224 /* Fill array with different values */
225 err = clib_memset (src, 0x1, ARRAY_LEN (src));
228 err = clib_memset (dst, 0x3, ARRAY_LEN (dst));
232 /* s1 > s2, > 0 is expected in diff */
233 if (!(clib_memcmp (dst, src, ARRAY_LEN (src)) > 0))
235 /* verify it against memcmp */
236 if (!(memcmp (dst, src, ARRAY_LEN (src)) > 0))
239 /* s1 < s2, < 0 is expected in diff */
240 if (!(clib_memcmp (src, dst, ARRAY_LEN (dst)) < 0))
242 /* verify it against memcmp */
243 if (!(memcmp (src, dst, ARRAY_LEN (dst)) < 0))
246 err = clib_memset (dst, 0x1, ARRAY_LEN (dst));
250 /* s1 == s2, 0 is expected in diff */
251 if (clib_memcmp (src, dst, ARRAY_LEN (dst)) != 0)
253 /* verify it against memcmp */
254 if (memcmp (src, dst, ARRAY_LEN (dst)) != 0)
257 /* Try negative tests */
259 if (clib_memcmp (s, s, 0) != 0)
261 /* verify it against memcmp */
262 if (memcmp (s, s, 0) != 0)
265 /* OK, seems to work */
270 test_strcmp_s (vlib_main_t * vm, unformat_input_t * input)
272 char s1[] = "Simplicity is the ultimate sophistication";
273 uword s1len = sizeof (s1) - 1; // excluding null
277 vlib_cli_output (vm, "Test strcmp_s...");
279 /* s1 == s2, 0 is expected */
280 err = strcmp_s (s1, s1len, "Simplicity is the ultimate sophistication",
287 /* s1 > s2, > 0 is expected */
288 err = strcmp_s (s1, s1len, "Simplicity is the ultimate", &indicator);
291 if (!(indicator > 0))
294 /* s1 < s2, < 0 is expected */
295 err = strcmp_s (s1, s1len, "Simplicity is the ultimate sophistication!",
299 if (!(indicator < 0))
302 /* Try some negative tests */
304 /* Null pointers test */
305 err = strcmp_s (0, 0, 0, 0);
309 /* non-null terminated s1 */
311 err = strcmp_s (s1, s1len, "Simplicity is the ultimate sophistication",
316 /* OK, seems to work */
321 test_clib_strcmp (vlib_main_t * vm, unformat_input_t * input)
323 char s1[] = "Simplicity is the ultimate sophistication";
327 vlib_cli_output (vm, "Test clib_strcmp...");
329 /* s1 == s2, 0 is expected */
330 indicator = clib_strcmp (s1, "Simplicity is the ultimate sophistication");
333 /* verify it against strcmp */
334 indicator = strcmp (s1, "Simplicity is the ultimate sophistication");
338 /* s1 > s2, > 0 is expected */
339 indicator = clib_strcmp (s1, "Simplicity is the ultimate");
340 if (!(indicator > 0))
342 /* verify it against strcmp */
343 indicator = strcmp (s1, "Simplicity is the ultimate");
344 if (!(indicator > 0))
347 /* s1 < s2, < 0 is expected */
348 indicator = clib_strcmp (s1, "Simplicity is the ultimate sophistication!");
349 if (!(indicator < 0))
351 /* verify it against strcmp */
352 indicator = strcmp (s1, "Simplicity is the ultimate sophistication!");
353 if (!(indicator < 0))
356 /* Try some negative tests */
358 /* Null pointers comparison */
360 indicator = clib_strcmp (s, s);
364 /* OK, seems to work */
369 test_strncmp_s (vlib_main_t * vm, unformat_input_t * input)
371 char s1[] = "Every moment is a fresh beginning";
372 uword s1len = sizeof (s1) - 1; // excluding null
376 vlib_cli_output (vm, "Test strncmp_s...");
378 /* s1 == s2, 0 is expected */
379 err = strncmp_s (s1, s1len, "Every moment is a fresh beginning", s1len,
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);
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,
400 if (!(indicator < 0))
403 /* s1 > s2, > 0 is expected */
404 err = strncmp_s ("Every moment is fresh beginning. ",
405 sizeof ("Every moment is fresh beginning. ") - 1, s1,
409 if (!(indicator > 0))
412 /* Try some negative tests */
415 err = strncmp_s (0, 0, 0, 0, 0);
420 err = strncmp_s (s1, s1len, "Every moment is a fresh beginning", s1len + 1,
425 /* unterminated s1 */
427 err = strncmp_s (s1, s1len, "Every moment is a fresh beginning",
428 sizeof ("Every moment is a fresh beginning") - 1,
433 /* OK, seems to work */
438 test_clib_strncmp (vlib_main_t * vm, unformat_input_t * input)
440 char s1[] = "Every moment is a fresh beginning";
441 uword s1len = sizeof (s1) - 1; // excluding null
442 int indicator, v_indicator;
444 vlib_cli_output (vm, "Test clib_strncmp...");
446 /* s1 == s2, 0 is expected */
447 indicator = clib_strncmp (s1, "Every moment is a fresh beginning", s1len);
450 /* verify it against strncmp */
451 v_indicator = strncmp (s1, "Every moment is a fresh beginning", s1len);
452 if (v_indicator != 0)
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);
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)
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))
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))
476 if (v_indicator != indicator)
479 /* s1 > s2, > 0 is expected */
480 indicator = clib_strncmp ("Every moment is fresh beginning. ", s1, s1len);
481 if (!(indicator > 0))
483 /* verify it against strncmp */
484 v_indicator = strncmp ("Every moment is fresh beginning. ", s1, s1len);
485 if (!(v_indicator > 0))
487 if (v_indicator != indicator)
490 /* Try some negative tests */
494 /* make sure we don't crash */
495 indicator = clib_strncmp (0, 0, 0);
496 if (indicator != EOK)
501 clib_strncmp (s1, "Every moment is a fresh beginning", s1len + 1);
504 /* verify it against strncmp */
505 v_indicator = strncmp (s1, "Every moment is a fresh beginning", s1len + 1);
506 if (v_indicator != 0)
509 /* unterminated s1 */
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);
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)
522 /* OK, seems to work */
527 test_strcpy_s (vlib_main_t * vm, unformat_input_t * input)
529 char src[] = "To err is human.";
532 size_t s1size = sizeof (dst); // including null
535 vlib_cli_output (vm, "Test strcpy_s...");
537 err = strcpy_s (dst, s1size, src);
541 /* This better not fail but check anyhow */
542 if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), src, &indicator) !=
550 err = strcpy_s (0, 0, 0);
555 err = strcpy_s (dst, 10, src);
561 /* GCC 8 flunks this one at compile time... */
562 err = strcpy_s (dst, s1size, dst);
568 err = strcpy_s (dst, s1size, dst + 1);
572 /* OK, seems to work */
577 test_clib_strcpy (vlib_main_t * vm, unformat_input_t * input)
579 char src[] = "The journey of a one thousand miles begins with one step.";
584 vlib_cli_output (vm, "Test clib_strcpy...");
586 err = clib_strcpy (dst, src);
590 /* This better not fail but check anyhow */
591 if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), src, &indicator) !=
597 /* verify it against strcpy */
598 strcpy (dst, src); //NOSONAR
600 /* This better not fail but check anyhow */
601 if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), src, &indicator) !=
609 err = clib_strcpy (0, 0);
615 /* GCC 8 flunks this one at compile time... */
616 err = clib_strcpy (dst, dst);
622 err = clib_strcpy (dst, dst + 1);
626 /* OK, seems to work */
631 test_strncpy_s (vlib_main_t * vm, unformat_input_t * input)
633 char src[] = "Those who dare to fail miserably can achieve greatly.";
634 char dst[100], old_dst[100];
636 size_t s1size = sizeof (dst); // including null
639 vlib_cli_output (vm, "Test strncpy_s...");
641 /* dmax includes null, n excludes null */
643 /* n == string len of src */
644 err = strncpy_s (dst, s1size, src, clib_strnlen (src, sizeof (src)));
647 if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), src, &indicator) !=
653 /* limited copy -- strlen src > n, copy up to n */
654 err = strncpy_s (dst, s1size, "The price of greatness is responsibility.",
658 if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), "The price ",
664 /* n > string len of src */
665 err = clib_memset (dst, 1, sizeof (dst));
669 err = strncpy_s (dst, s1size, src, clib_strnlen (src, sizeof (src)) + 10);
672 if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), src, &indicator) !=
678 /* Make sure bytes after strlen(dst) is untouched */
679 for (i = 1 + clib_strnlen (dst, sizeof (dst)); i < sizeof (dst); i++)
683 /* truncation, n >= dmax */
684 err = strncpy_s (dst, clib_strnlen (src, sizeof (src)), src,
685 clib_strnlen (src, sizeof (src)));
686 if (err != EOVERFLOW)
689 /* Check dst content */
690 if (dst[strlen (dst)] != '\0')
692 if (strncmp_s (dst, clib_strnlen (dst, sizeof (dst)), src,
693 clib_strnlen (dst, sizeof (dst)), &indicator) != EOK)
698 /* zero length copy */
699 clib_strncpy (old_dst, dst, clib_strnlen (dst, sizeof (dst)));
700 err = strncpy_s (dst, sizeof (dst), src, 0);
703 /* verify dst is untouched */
704 if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), old_dst, &indicator) !=
712 err = strncpy_s (0, 0, 0, 1);
717 err = strncpy_s (dst, s1size, dst + 1, s1size - 1);
723 /* GCC 8 flunks this one at compile time... */
724 err = strncpy_s (dst, s1size, dst, s1size);
729 /* OK, seems to work */
734 test_clib_strncpy (vlib_main_t * vm, unformat_input_t * input)
736 char src[] = "Those who dare to fail miserably can achieve greatly.";
737 char dst[100], old_dst[100];
739 size_t s1size = sizeof (dst); // including null
742 vlib_cli_output (vm, "Test clib_strncpy...");
744 /* n == string len of src */
745 err = clib_strncpy (dst, src, clib_strnlen (src, sizeof (src)));
749 /* This better not fail but check anyhow */
750 if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), src, &indicator) !=
756 /* Verify it against strncpy */
758 /* GCC 8 debian flunks this one at compile time */
759 strncpy (dst, src, strlen (src));
761 /* This better not fail but check anyhow */
762 if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), src, &indicator) !=
769 /* limited copy -- strlen src > n, copy up to n */
770 err = clib_strncpy (dst, "The price of greatness is responsibility.", 10);
773 if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), "The price ",
778 /* verify it against strncpy */
779 memset_s (dst, sizeof (dst), 0, sizeof (dst));
782 /* GCC 8 flunks this one at compile time... */
783 strncpy (dst, "The price of greatness is responsibility.", 10);
784 if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), "The price ",
791 /* n > string len of src */
792 err = clib_strncpy (dst, src, clib_strnlen (src, sizeof (src)) + 10);
795 if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), src, &indicator) !=
800 /* Verify it against strncpy */
802 /* GCC 8 debian flunks this one at compile time */
803 strncpy (dst, src, strlen (src));
804 if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), src, &indicator) !=
811 /* zero length copy */
812 clib_strncpy (old_dst, dst, clib_strnlen (dst, sizeof (dst)));
813 err = clib_strncpy (dst, src, 0);
816 /* verify dst is untouched */
817 if (strcmp_s (dst, clib_strnlen (dst, sizeof (dst)), old_dst, &indicator) !=
825 err = clib_strncpy (0, 0, 1);
830 err = clib_strncpy (dst, dst + 1, s1size);
836 /* GCC 8 flunks this one at compile time... */
837 err = clib_strncpy (dst, dst, s1size);
842 /* OK, seems to work */
847 test_strcat_s (vlib_main_t * vm, unformat_input_t * input)
849 char src[100], dst[100], old_dst[100];
850 size_t s1size = sizeof (dst); // including null
854 vlib_cli_output (vm, "Test strcat_s...");
856 strcpy_s (dst, sizeof (dst), "Tough time never last ");
857 strcpy_s (src, sizeof (src), "but tough people do");
858 err = strcat_s (dst, s1size, src);
861 if (strcmp_s (dst, s1size - 1,
862 "Tough time never last but tough people do",
868 /* empty string concatenation */
869 clib_strncpy (old_dst, dst, clib_strnlen (dst, sizeof (dst)));
870 err = strcat_s (dst, s1size, "");
873 /* verify dst is untouched */
874 if (strcmp_s (dst, s1size - 1, old_dst, &indicator) != EOK)
880 err = strcat_s (0, 0, 0);
885 err = strcat_s (dst, s1size, dst + 1);
891 /* GCC 8 flunks this one at compile time... */
892 err = strcat_s (dst, s1size, dst);
897 /* not enough space for dst */
898 err = strcat_s (dst, 10, src);
902 /* OK, seems to work */
907 test_clib_strcat (vlib_main_t * vm, unformat_input_t * input)
909 char src[100], dst[100], old_dst[100];
910 size_t s1size = sizeof (dst); // including null
914 vlib_cli_output (vm, "Test clib_strcat...");
916 strcpy_s (dst, sizeof (dst), "Tough time never last ");
917 strcpy_s (src, sizeof (src), "but tough people do");
918 err = clib_strcat (dst, src);
921 if (strcmp_s (dst, s1size - 1,
922 "Tough time never last but tough people do",
927 /* verify it against strcat */
928 strcpy_s (dst, sizeof (dst), "Tough time never last ");
929 strcpy_s (src, sizeof (src), "but tough people do");
931 if (strcmp_s (dst, s1size - 1,
932 "Tough time never last but tough people do",
938 /* empty string concatenation */
939 clib_strncpy (old_dst, dst, clib_strnlen (dst, sizeof (dst)));
940 err = clib_strcat (dst, "");
943 /* verify dst is untouched */
944 if (strcmp_s (dst, s1size - 1, old_dst, &indicator) != EOK)
950 err = clib_strcat (0, 0);
955 err = clib_strcat (dst, dst + 1);
961 /* GCC 8 flunks this one at compile time... */
962 err = clib_strcat (dst, dst);
967 /* OK, seems to work */
972 test_strncat_s (vlib_main_t * vm, unformat_input_t * input)
974 char src[100], dst[100], old_dst[100];
975 size_t s1size = sizeof (dst); // including null
977 char s1[] = "Two things are infinite: ";
978 char s2[] = "the universe and human stupidity; ";
979 char s3[] = "I am not sure about the universe.";
982 vlib_cli_output (vm, "Test strncat_s...");
984 strcpy_s (dst, sizeof (dst), s1);
985 strcpy_s (src, sizeof (src), s2);
986 err = strncat_s (dst, s1size, src, clib_strnlen (src, sizeof (src)));
989 if (strcmp_s (dst, s1size - 1,
990 "Two things are infinite: the universe and human stupidity; ",
996 /* truncation, n >= dmax - strnlen_s (dst, dmax) */
997 err = strncat_s (dst, clib_strnlen (dst, sizeof (dst)) +
998 clib_strnlen (s3, sizeof (s3)), s3,
999 clib_strnlen (s3, sizeof (s3)));
1000 if (err != EOVERFLOW)
1003 * resulting string is dst + strlen (s3) - 1 characters + null.
1004 * notice the "." is missing at the end of the resulting string because
1005 * the space is needed to accommodate the null
1006 * Notice strcmp_s will check s1 or dst to make sure it is null terminated
1008 if (strcmp_s (dst, s1size - 1,
1009 "Two things are infinite: the universe and human stupidity; "
1010 "I am not sure about the universe", &indicator) != EOK)
1015 /* n > strlen src */
1016 strcpy_s (dst, sizeof (dst), s1);
1017 err = strncat_s (dst, s1size, src, clib_strnlen (src, sizeof (src)) + 10);
1020 if (strcmp_s (dst, s1size - 1,
1021 "Two things are infinite: the universe and human stupidity; ",
1027 /* zero length strncat */
1028 clib_strncpy (old_dst, dst, clib_strnlen (dst, sizeof (dst)));
1029 err = strncat_s (dst, sizeof (dst), src, 0);
1032 /* verify dst is untouched */
1033 if (strcmp_s (dst, s1size - 1, old_dst, &indicator) != EOK)
1038 /* empty string, wrong n concatenation */
1039 err = strncat_s (dst, sizeof (dst), "", 10);
1042 /* verify dst is untouched */
1043 if (strcmp_s (dst, s1size - 1, old_dst, &indicator) != EOK)
1048 /* limited concatenation, string > n, copy up to n */
1049 strcpy_s (dst, sizeof (dst), s1);
1050 err = strncat_s (dst, s1size, s2, 13);
1053 if (strcmp_s (dst, s1size - 1, "Two things are infinite: the universe ",
1058 /* verify it against strncat */
1060 /* GCC 8 debian flunks this one at compile time */
1061 strcpy_s (dst, sizeof (dst), s1);
1062 strncat (dst, s2, 13);
1063 if (strcmp_s (dst, s1size - 1, "Two things are infinite: the universe ",
1070 /* negative stuff */
1071 err = strncat_s (0, 0, 0, 1);
1075 /* no room for dst -- dmax - strnlen_s (dst, dmax) == 0 */
1076 err = strncat_s (dst, clib_strnlen (dst, sizeof (dst)), s2,
1077 clib_strnlen (s2, sizeof (s2)));
1082 err = strncat_s (dst, s1size, dst + 1, clib_strnlen (dst + 1, s1size - 1));
1088 /* GCC 8 flunks this one at compile time... */
1089 err = strncat_s (dst, s1size, dst, clib_strnlen (dst, sizeof (dst)));
1094 /* OK, seems to work */
1099 test_clib_strncat (vlib_main_t * vm, unformat_input_t * input)
1101 char src[100], dst[100], old_dst[100];
1102 size_t s1size = sizeof (dst); // including null
1104 char s1[] = "Two things are infinite: ";
1105 char s2[] = "the universe and human stupidity; ";
1108 vlib_cli_output (vm, "Test clib_strncat...");
1110 /* n == strlen src */
1111 strcpy_s (dst, sizeof (dst), s1);
1112 strcpy_s (src, sizeof (src), s2);
1113 err = clib_strncat (dst, src, clib_strnlen (src, sizeof (src)));
1116 if (strcmp_s (dst, s1size - 1,
1117 "Two things are infinite: the universe and human stupidity; ",
1122 /* verify it against strncat */
1123 strcpy_s (dst, sizeof (dst), s1);
1124 strncat (dst, src, clib_strnlen (src, sizeof (src)));
1125 if (strcmp_s (dst, s1size - 1,
1126 "Two things are infinite: the universe and human stupidity; ",
1132 /* n > strlen src */
1133 strcpy_s (dst, sizeof (dst), s1);
1134 err = clib_strncat (dst, src, clib_strnlen (src, sizeof (src)) + 10);
1137 if (strcmp_s (dst, s1size - 1,
1138 "Two things are infinite: the universe and human stupidity; ",
1143 /* verify it against strncat */
1144 strcpy_s (dst, sizeof (dst), s1);
1145 strncat (dst, src, clib_strnlen (src, sizeof (src)));
1146 if (strcmp_s (dst, s1size - 1,
1147 "Two things are infinite: the universe and human stupidity; ",
1153 /* zero length strncat */
1154 clib_strncpy (old_dst, dst, clib_strnlen (dst, sizeof (dst)));
1155 err = clib_strncat (dst, src, 0);
1158 /* verify dst is untouched */
1159 if (strcmp_s (dst, s1size - 1, old_dst, &indicator) != EOK)
1164 /* empty string, wrong n concatenation */
1165 err = clib_strncat (dst, "", 10);
1168 /* verify dst is untouched */
1169 if (strcmp_s (dst, s1size - 1, old_dst, &indicator) != EOK)
1174 /* limited concatenation, string > n, copy up to n */
1175 strcpy_s (dst, sizeof (dst), s1);
1176 err = clib_strncat (dst, s2, 13);
1179 if (strcmp_s (dst, s1size - 1, "Two things are infinite: the universe ",
1184 /* verify it against strncat */
1186 /* GCC 8 debian flunks this one at compile time */
1187 strcpy_s (dst, sizeof (dst), s1);
1188 strncat (dst, s2, 13);
1189 if (strcmp_s (dst, s1size - 1, "Two things are infinite: the universe ",
1196 /* negative stuff */
1197 err = clib_strncat (0, 0, 1);
1202 err = clib_strncat (dst, dst + 1, s1size - 1);
1208 /* GCC 8 flunks this one at compile time... */
1209 err = clib_strncat (dst, dst, clib_strnlen (dst, sizeof (dst)));
1214 /* OK, seems to work */
1219 test_strtok_s (vlib_main_t * vm, unformat_input_t * input)
1227 char *tok1, *tok2, *tok3, *tok4, *tok5, *tok6, *tok7;
1229 vlib_cli_output (vm, "Test strtok_s...");
1230 strcpy_s (str1, sizeof (str1), "brevity is the soul of wit");
1231 len = strnlen_s (str1, sizeof (str1));
1232 tok1 = strtok_s (str1, &len, " ", &p2str);
1233 tok2 = strtok_s (0, &len, " ", &p2str);
1234 tok3 = strtok_s (0, &len, " ", &p2str);
1235 tok4 = strtok_s (0, &len, " ", &p2str);
1236 tok5 = strtok_s (0, &len, " ", &p2str);
1237 tok6 = strtok_s (0, &len, " ", &p2str);
1238 tok7 = strtok_s (0, &len, " ", &p2str);
1240 strcmp_s (tok1, strlen (tok1), "brevity", &indicator) != EOK)
1244 if ((tok2 == 0) || strcmp_s (tok2, strlen (tok2), "is", &indicator) != EOK)
1248 if ((tok3 == 0) || strcmp_s (tok3, strlen (tok3), "the", &indicator) != EOK)
1253 || strcmp_s (tok4, strlen (tok4), "soul", &indicator) != EOK)
1257 if ((tok5 == 0) || strcmp_s (tok5, strlen (tok5), "of", &indicator) != EOK)
1261 if ((tok6 == 0) || strcmp_s (tok6, strlen (tok6), "wit", &indicator) != EOK)
1268 /* delimiter not present in the string -- the whole string is returned */
1269 strcpy_s (str1, sizeof (str1), "brevity is the soul of wit");
1270 len = strnlen_s (str1, sizeof (str1) - 1);
1272 tok1 = strtok_s (str1, &len, ",", &p2str);
1273 if ((tok1 == 0) || strcmp_s (tok1, strlen (tok1), str1, &indicator) != EOK)
1278 /* negative stuff */
1279 tok = strtok_s (0, 0, 0, 0);
1283 /* s1 and ptr contents are null */
1285 tok = strtok_s (0, 0, 0, &ptr);
1289 /* unterminate s1 */
1291 len = strnlen_s (str1, sizeof (str1) - 1);
1292 str1[strlen (str1)] = 0x2;
1293 tok = strtok_s (str1, &len, ",", &p2str);
1298 * unterminated s2. This test case in not perfect because there is no
1299 * argument for s2max. But s2 len is limited to 16 characters. If the API
1300 * does not find the null character at s2[15], it declares the string s2
1303 memset_s (str2, sizeof (str2), 0xfa, sizeof (str2));
1304 tok = strtok_s (str1, &len, str2, &p2str);
1308 /* OK, seems to work */
1313 test_clib_strtok (vlib_main_t * vm, unformat_input_t * input)
1316 char *s1 __attribute__ ((unused));
1317 char *tok __attribute__ ((unused));
1318 char *ptr __attribute__ ((unused));
1321 char *tok1, *tok2, *tok3, *tok4, *tok5, *tok6, *tok7;
1323 vlib_cli_output (vm, "Test clib_strtok...");
1324 strcpy_s (str1, sizeof (str1), "brevity is the soul of wit");
1326 tok1 = clib_strtok (str1, " ", &p2str);
1327 tok2 = clib_strtok (0, " ", &p2str);
1328 tok3 = clib_strtok (0, " ", &p2str);
1329 tok4 = clib_strtok (0, " ", &p2str);
1330 tok5 = clib_strtok (0, " ", &p2str);
1331 tok6 = clib_strtok (0, " ", &p2str);
1332 tok7 = clib_strtok (0, " ", &p2str);
1334 strcmp_s (tok1, strlen (tok1), "brevity", &indicator) != EOK)
1338 if ((tok2 == 0) || strcmp_s (tok2, strlen (tok2), "is", &indicator) != EOK)
1342 if ((tok3 == 0) || strcmp_s (tok3, strlen (tok3), "the", &indicator) != EOK)
1347 || strcmp_s (tok4, strlen (tok4), "soul", &indicator) != EOK)
1351 if ((tok5 == 0) || strcmp_s (tok5, strlen (tok5), "of", &indicator) != EOK)
1355 if ((tok6 == 0) || strcmp_s (tok6, strlen (tok6), "wit", &indicator) != EOK)
1361 /* verify it againest strtok_r */
1362 strcpy_s (str1, sizeof (str1), "brevity is the soul of wit");
1364 tok1 = strtok_r (str1, " ", &p2str);
1365 tok2 = strtok_r (0, " ", &p2str);
1366 tok3 = strtok_r (0, " ", &p2str);
1367 tok4 = strtok_r (0, " ", &p2str);
1368 tok5 = strtok_r (0, " ", &p2str);
1369 tok6 = strtok_r (0, " ", &p2str);
1370 tok7 = strtok_r (0, " ", &p2str);
1372 strcmp_s (tok1, strlen (tok1), "brevity", &indicator) != EOK)
1376 if ((tok2 == 0) || strcmp_s (tok2, strlen (tok2), "is", &indicator) != EOK)
1380 if ((tok3 == 0) || strcmp_s (tok3, strlen (tok3), "the", &indicator) != EOK)
1385 || strcmp_s (tok4, strlen (tok4), "soul", &indicator) != EOK)
1389 if ((tok5 == 0) || strcmp_s (tok5, strlen (tok5), "of", &indicator) != EOK)
1393 if ((tok6 == 0) || strcmp_s (tok6, strlen (tok6), "wit", &indicator) != EOK)
1400 /* delimiter not present in the string -- the whole string is returned */
1401 strcpy_s (str1, sizeof (str1), "brevity is the soul of wit");
1403 tok1 = clib_strtok (str1, ",", &p2str);
1404 if ((tok1 == 0) || strcmp_s (tok1, strlen (tok1), str1, &indicator) != EOK)
1408 /* verify it against strtok_r */
1409 strcpy_s (str1, sizeof (str1), "brevity is the soul of wit");
1411 tok1 = strtok_r (str1, ",", &p2str);
1412 if ((tok1 == 0) || strcmp_s (tok1, strlen (tok1), str1, &indicator) != EOK)
1417 /* negative stuff */
1421 /* GCC 8 flunks this one at compile time... */
1422 tok = clib_strtok (s1, s1, (char **) 0);
1426 /* s1 and ptr contents are null */
1427 tok = clib_strtok (s1, s1, &ptr);
1432 /* verify it against strtok_r */
1433 /* No can do. This causes a crash in strtok_r */
1434 // tok = strtok_r (s1, " ", &ptr);
1439 * Can't test unterminated string s1 and s2 becuase clib_strtok does not
1440 * supply s1 and s2 max
1443 /* OK, seems to work */
1448 test_strnlen_s (vlib_main_t * vm, unformat_input_t * input)
1450 const char s1[] = "Truth is incontrovertible";
1453 vlib_cli_output (vm, "Test strnlen_s...");
1455 len = strnlen_s (s1, sizeof (s1));
1456 if (len != sizeof (s1) - 1)
1459 len = strnlen_s (s1, 5);
1463 /* negative stuff */
1464 len = strnlen_s (0, 0);
1468 /* OK, seems to work */
1473 test_clib_strnlen (vlib_main_t * vm, unformat_input_t * input)
1475 const char s1[] = "Truth is incontrovertible";
1478 vlib_cli_output (vm, "Test clib_strnlen...");
1480 len = clib_strnlen (s1, sizeof (s1));
1481 if (len != sizeof (s1) - 1)
1484 len = clib_strnlen (s1, 5);
1488 /* negative stuff */
1489 len = clib_strnlen (0, 0);
1493 /* OK, seems to work */
1498 test_strstr_s (vlib_main_t * vm, unformat_input_t * input)
1503 size_t s1len = sizeof (s1) - 1; // excluding null
1506 vlib_cli_output (vm, "Test strstr_s...");
1508 /* substring not present */
1509 strcpy_s (s1, s1len, "success is not final, failure is not fatal.");
1510 err = strstr_s (s1, s1len, "failures", sizeof ("failures"), &sub);;
1514 /* substring present */
1515 err = strstr_s (s1, s1len, "failure", sizeof ("failure"), &sub);
1520 strcmp_s (sub, strlen (sub), "failure is not fatal.", &indicator)
1526 /* negative stuff */
1528 /* Null pointers test */
1529 err = strstr_s (0, 0, 0, 0, 0);
1533 /* unterminated s1 and s2 */
1534 memset_s (s1, ARRAY_LEN (s1), 0xfe, ARRAY_LEN (s1));
1535 err = strstr_s (s1, s1len, s1, s1len, &sub);
1539 /* OK, seems to work */
1544 test_clib_strstr (vlib_main_t * vm, unformat_input_t * input)
1548 size_t s1len = sizeof (s1) - 1; // excluding null
1551 vlib_cli_output (vm, "Test clib_strstr...");
1553 /* substring not present */
1554 strcpy_s (s1, s1len, "success is not final, failure is not fatal.");
1555 sub = clib_strstr (s1, "failures");
1558 /* verify it against strstr */
1559 sub = strstr (s1, "failures");
1563 /* substring present */
1564 sub = clib_strstr (s1, "failure");
1567 if (strcmp_s (sub, strlen (sub), "failure is not fatal.", &indicator) !=
1572 /* verify it against strstr */
1573 sub = strstr (s1, "failure");
1576 if (strcmp_s (sub, strlen (sub), "failure is not fatal.", &indicator) !=
1582 /* negative stuff */
1584 /* Null pointers test */
1586 sub = clib_strstr (s, s);
1590 * Can't verify it against strstr for this test. Null pointers cause strstr
1591 * to crash. Go figure!
1594 /* unterminated s1 and s2 */
1595 memset_s (s1, ARRAY_LEN (s1), 0xfe, ARRAY_LEN (s1));
1596 CLIB_MEM_UNPOISON (s1, CLIB_STRING_MACRO_MAX);
1597 sub = clib_strstr (s1, s1);
1601 * Can't verify it against strstr for this test. Unterminated string causes
1602 * strstr to crash. Go figure!
1605 /* OK, seems to work */
1609 #define foreach_string_test \
1610 _ (0, MEMCPY_S, "memcpy_s", memcpy_s) \
1611 _ (1, CLIB_MEMCPY, "clib_memcpy", clib_memcpy) \
1612 _ (2, MEMSET_S , "memset_s", memset_s) \
1613 _ (3, CLIB_MEMSET , "clib_memset", clib_memset) \
1614 _ (4, MEMCMP_S, "memcmp_s", memcmp_s) \
1615 _ (5, CLIB_MEMCMP, "clib_memcmp", clib_memcmp) \
1616 _ (6, STRCMP_S, "strcmp_s", strcmp_s) \
1617 _ (7, CLIB_STRCMP, "clib_strcmp", clib_strcmp) \
1618 _ (8, STRNCMP_S, "strncmp_s", strncmp_s) \
1619 _ (9, CLIB_STRNCMP, "clib_strncmp", clib_strncmp) \
1620 _ (10, STRCPY_S, "strcpy_s", strcpy_s) \
1621 _ (11, CLIB_STRCPY, "clib_strcpy", clib_strcpy) \
1622 _ (12, STRNCPY_S, "strncpy_s", strncpy_s) \
1623 _ (13, CLIB_STRNCPY, "clib_strncpy", clib_strncpy) \
1624 _ (14, STRCAT_S, "strcat_s", strcat_s) \
1625 _ (15, CLIB_STRCAT, "clib_strcat", clib_strcat) \
1626 _ (16, STRNCAT_S, "strncat_s", strncat_s) \
1627 _ (17, CLIB_STRNCAT, "clib_strncat", clib_strncat) \
1628 _ (18, STRTOK_S, "strtok_s", strtok_s) \
1629 _ (19, CLIB_STRTOK, "clib_strtok", clib_strtok) \
1630 _ (20, STRNLEN_S, "strnlen_s", strnlen_s) \
1631 _ (21, CLIB_STRNLEN, "clib_strnlen", clib_strnlen) \
1632 _ (22, STRSTR_S, "strstr_s", strstr_s) \
1633 _ (23, CLIB_STRSTR, "clib_strstr", clib_strstr)
1637 #define _(v,f,s,p) STRING_TEST_##f = v,
1643 unformat_string_test (unformat_input_t * input, va_list * args)
1645 u8 *r = va_arg (*args, u8 *);
1649 #define _(v,f,s,p) else if (unformat (input, s)) *r = STRING_TEST_##f;
1658 typedef int (*string_test_func) (vlib_main_t * vm, unformat_input_t * input);
1662 string_test_func test;
1663 } string_test_func_t;
1665 static clib_error_t *
1666 string_test_command_fn (vlib_main_t * vm,
1667 unformat_input_t * input,
1668 vlib_cli_command_t * cmd_arg)
1670 string_test_func_t string_func[] = {
1671 #define _(v,f,s,p) { test_##p },
1675 const char *string_table[] = {
1676 #define _(v,f,s,p) s,
1681 i8 specific_test = ~0;
1683 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1685 if (unformat (input, "%U", unformat_string_test, &specific_test))
1688 return clib_error_return (0, "unknown input `%U'",
1689 format_unformat_error, input);
1692 if (specific_test == ~0)
1694 for (specific_test = STRING_TEST_MEMCPY_S;
1695 specific_test <= STRING_TEST_CLIB_STRSTR; specific_test++)
1697 ok = (string_func[specific_test]).test (vm, input);
1700 vlib_cli_output (vm, "test_%s failed",
1701 string_table[specific_test]);
1705 res = (string_func[specific_test]).test (vm, input);
1707 vlib_cli_output (vm, "String unit test(s) failed...");
1709 vlib_cli_output (vm, "String unit test(s) OK...");
1714 VLIB_CLI_COMMAND (string_test_command, static) =
1716 .path = "test string",
1717 .short_help = "test string [memcpy_s | clib_memcpy | memset_s | "
1718 "clib_memset | memcmp_s | clib_memcmp | strcmp_s | clib_strcmp | "
1719 "strncmp_s | clib_strncmp | strcpy_s | clib_strcpy | strncpy_s | "
1720 "clib_strncpy | strcat_s | clib_strcat | strncat_s | clib_strncat | "
1721 "strtok_s | clib_strtok | strnlen_s | clib_strnlen | strstr_s | "
1723 .function = string_test_command_fn,
1728 * fd.io coding-style-patch-verification: ON
1731 * eval: (c-set-style "gnu")