string/test-strncat.c

   1 /* Test strncat functions.
   2    Copyright (C) 2011-2023 Free Software Foundation, Inc.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <https://www.gnu.org/licenses/>.  */
  17
  18 #define TEST_MAIN
  19 #ifndef WIDE
  20 # define TEST_NAME "strncat"
  21 #else
  22 # define TEST_NAME "wcsncat"
  23 #endif /* WIDE */
  24 #include "test-string.h"
  25
  26 #ifndef WIDE
  27 # define STRNCAT strncat
  28 # define CHAR char
  29 # define UCHAR unsigned char
  30 # define SIMPLE_STRNCAT simple_strncat
  31 # define STRNLEN strnlen
  32 # define STRLEN strlen
  33 # define MEMSET memset
  34 # define MEMCPY memcpy
  35 # define MEMCMP memcmp
  36 # define BIG_CHAR CHAR_MAX
  37 # define SMALL_CHAR 127
  38 #else
  39 # include <wchar.h>
  40 # define STRNCAT wcsncat
  41 # define CHAR wchar_t
  42 # define UCHAR wchar_t
  43 # define SIMPLE_STRNCAT simple_wcsncat
  44 # define STRNLEN wcsnlen
  45 # define STRLEN wcslen
  46 # define MEMSET wmemset
  47 # define MEMCPY wmemcpy
  48 # define MEMCMP wmemcmp
  49 # define BIG_CHAR WCHAR_MAX
  50 # define SMALL_CHAR 1273
  51 #endif /* WIDE */
  52
  53 typedef CHAR *(*proto_t) (CHAR *, const CHAR *, size_t);
  54
  55 IMPL (STRNCAT, 2)
  56
  57 /* Naive implementation to verify results.  */
  58 CHAR *
  59 SIMPLE_STRNCAT (CHAR *dst, const CHAR *src, size_t n)
  60 {
  61   CHAR *ret = dst;
  62   while (*dst++ != '\0');
  63   --dst;
  64   while (n--)
  65     if ((*dst++ = *src++) == '\0')
  66       return ret;
  67   *dst = '\0';
  68   return ret;
  69 }
  70
  71 static void
  72 do_one_test (impl_t *impl, CHAR *dst, const CHAR *src, size_t n)
  73 {
  74   size_t k = STRLEN (dst);
  75   if (CALL (impl, dst, src, n) != dst)
  76     {
  77       error (0, 0, "Wrong result in function %s %p != %p", impl->name,
  78              CALL (impl, dst, src, n), dst);
  79       ret = 1;
  80       return;
  81     }
  82
  83   size_t len = STRNLEN (src, n);
  84   if (MEMCMP (dst + k, src, len + 1 > n ? n : len + 1) != 0)
  85     {
  86       error (0, 0, "Incorrect concatenation in function %s",
  87              impl->name);
  88       ret = 1;
  89       return;
  90     }
  91   if (n < len && dst[k + n] != '\0')
  92     {
  93       error (0, 0, "There is no zero in the end of output string in %s",
  94              impl->name);
  95       ret = 1;
  96       return;
  97     }
  98 }
  99
 100 static void
 101 do_test_src_no_nullterm_bz30065 (void)
 102 {
 103   /* NB: "src does not need to be null-terminated if it contains n or more
 104    * bytes." */
 105   CHAR *s1, *s2;
 106   size_t bound = page_size / sizeof (CHAR);
 107   s1 = (CHAR *) (buf1 + BUF1PAGES * page_size);
 108   s2 = (CHAR *) buf2;
 109   MEMSET (s1 - bound, -1, bound);
 110   for (size_t n = 0; n < bound; ++n)
 111     {
 112       FOR_EACH_IMPL (impl, 0)
 113         {
 114           s2[0] = '\0';
 115           do_one_test (impl, s2, s1 - n, n);
 116         }
 117     }
 118 }
 119
 120 static void
 121 do_test (size_t align1, size_t align2, size_t len1, size_t len2,
 122          size_t n, int max_char)
 123 {
 124   size_t i;
 125   CHAR *s1, *s2;
 126
 127   align1 &= 7;
 128   if ((align1 + len1) * sizeof (CHAR) >= page_size)
 129     return;
 130   if ((align1 + n) * sizeof (CHAR) > page_size)
 131     return;
 132   align2 &= 7;
 133   if ((align2 + len1 + len2) * sizeof (CHAR) >= page_size)
 134     return;
 135   if ((align2 + len1 + n) * sizeof (CHAR) > page_size)
 136     return;
 137   s1 = (CHAR *) (buf1) + align1;
 138   s2 = (CHAR *) (buf2) + align2;
 139
 140   for (i = 0; i < len1; ++i)
 141     s1[i] = 32 + 23 * i % (max_char - 32);
 142   s1[len1] = '\0';
 143
 144   for (i = 0; i < len2; i++)
 145     s2[i] = 32 + 23 * i % (max_char - 32);
 146
 147   FOR_EACH_IMPL (impl, 0)
 148     {
 149       s2[len2] = '\0';
 150       do_one_test (impl, s2, s1, n);
 151     }
 152 }
 153
 154 static void
 155 do_overflow_tests (void)
 156 {
 157   size_t i, j, len;
 158   const size_t one = 1;
 159   CHAR *s1, *s2;
 160   uintptr_t s1_addr;
 161   s1 = (CHAR *) buf1;
 162   s2 = (CHAR *) buf2;
 163   s1_addr = (uintptr_t)s1;
 164  for (j = 0; j < 200; ++j)
 165       s2[j] = 32 + 23 * j % (BIG_CHAR - 32);
 166  s2[200] = 0;
 167   for (i = 0; i < 750; ++i) {
 168     for (j = 0; j < i; ++j)
 169       s1[j] = 32 + 23 * j % (BIG_CHAR - 32);
 170     s1[i] = '\0';
 171
 172        FOR_EACH_IMPL (impl, 0)
 173     {
 174       s2[200] = '\0';
 175       do_one_test (impl, s2, s1, SIZE_MAX - i);
 176       s2[200] = '\0';
 177       do_one_test (impl, s2, s1, i - s1_addr);
 178       s2[200] = '\0';
 179       do_one_test (impl, s2, s1, -s1_addr - i);
 180       s2[200] = '\0';
 181       do_one_test (impl, s2, s1, SIZE_MAX - s1_addr - i);
 182       s2[200] = '\0';
 183       do_one_test (impl, s2, s1, SIZE_MAX - s1_addr + i);
 184     }
 185
 186     len = 0;
 187     for (j = 8 * sizeof(size_t) - 1; j ; --j)
 188       {
 189         len |= one << j;
 190         FOR_EACH_IMPL (impl, 0)
 191           {
 192             s2[200] = '\0';
 193             do_one_test (impl, s2, s1, len - i);
 194             s2[200] = '\0';
 195             do_one_test (impl, s2, s1, len + i);
 196             s2[200] = '\0';
 197             do_one_test (impl, s2, s1, len - s1_addr - i);
 198             s2[200] = '\0';
 199             do_one_test (impl, s2, s1, len - s1_addr + i);
 200
 201             s2[200] = '\0';
 202             do_one_test (impl, s2, s1, ~len - i);
 203             s2[200] = '\0';
 204             do_one_test (impl, s2, s1, ~len + i);
 205             s2[200] = '\0';
 206             do_one_test (impl, s2, s1, ~len - s1_addr - i);
 207             s2[200] = '\0';
 208             do_one_test (impl, s2, s1, ~len - s1_addr + i);
 209           }
 210       }
 211   }
 212 }
 213
 214 static void
 215 do_random_tests (void)
 216 {
 217   size_t i, j, n, align1, align2, len1, len2, N;
 218   UCHAR *p1 = (UCHAR *) (buf1 + page_size) - 512;
 219   UCHAR *p2 = (UCHAR *) (buf2 + page_size) - 512;
 220   UCHAR *p3 = (UCHAR *) buf1;
 221   UCHAR *res;
 222   fprintf (stdout, "Number of iterations in random test = %zd\n",
 223            ITERATIONS);
 224   for (n = 0; n < ITERATIONS; n++)
 225     {
 226       N = random () & 255;
 227       align1 = random () & 31;
 228       if (random () & 1)
 229         align2 = random () & 31;
 230       else
 231         align2 = align1 + (random () & 24);
 232       len1 = random () & 511;
 233       if (len1 + align2 > 512)
 234         len2 = random () & 7;
 235       else
 236         len2 = (512 - len1 - align2) * (random () & (1024 * 1024 - 1))
 237           / (1024 * 1024);
 238       j = align1;
 239       if (align2 + len2 > j)
 240         j = align2 + len2;
 241       if (len1 + j >= 511)
 242         len1 = 510 - j - (random () & 7);
 243       if (len1 >= 512)
 244         len1 = 0;
 245       if (align1 + len1 < 512 - 8)
 246         {
 247           j = 510 - align1 - len1 - (random () & 31);
 248           if (j > 0 && j < 512)
 249             align1 += j;
 250         }
 251       j = len1 + align1 + 64;
 252       if (j > 512)
 253         j = 512;
 254       for (i = 0; i < j; i++)
 255         {
 256           if (i == len1 + align1)
 257             p1[i] = 0;
 258           else
 259             {
 260               p1[i] = random () & BIG_CHAR;
 261               if (i >= align1 && i < len1 + align1 && !p1[i])
 262                 p1[i] = (random () & SMALL_CHAR) + 3;
 263             }
 264         }
 265       for (i = 0; i < len2; i++)
 266         {
 267           p3[i] = random () & BIG_CHAR;
 268           if (!p3[i])
 269             p3[i] = (random () & SMALL_CHAR) + 3;
 270         }
 271       p3[len2] = 0;
 272
 273       FOR_EACH_IMPL (impl, 1)
 274         {
 275           MEMSET (p2 - 64, '\1', align2 + 64);
 276           MEMSET (p2 + align2 + len2 + 1, '\1', 512 - align2 - len2 - 1);
 277           MEMCPY (p2 + align2, p3, len2 + 1);
 278           res = (UCHAR *) CALL (impl, (CHAR *) (p2 + align2),
 279                                 (CHAR *) (p1 + align1), N);
 280           if (res != p2 + align2)
 281             {
 282               error (0, 0, "Iteration %zd - wrong result in function %s "
 283                      "(%zd, %zd, %zd, %zd, %zd) %p != %p",
 284                      n, impl->name, align1, align2, len1, len2, N,
 285                      res, p2 + align2);
 286               ret = 1;
 287             }
 288           for (j = 0; j < align2 + 64; ++j)
 289             {
 290               if (p2[j - 64] != '\1')
 291                 {
 292                   error (0, 0, "Iteration %zd - garbage before dst, %s "
 293                          "%zd, %zd, %zd, %zd, %zd)",
 294                          n, impl->name, align1, align2, len1, len2, N);
 295                   ret = 1;
 296                   break;
 297                 }
 298             }
 299           if (MEMCMP (p2 + align2, p3, len2))
 300             {
 301               error (0, 0, "Iteration %zd - garbage in string before, %s "
 302                      "(%zd, %zd, %zd, %zd, %zd)",
 303                      n, impl->name, align1, align2, len1, len2, N);
 304               ret = 1;
 305             }
 306
 307           if ((len1 + 1) > N)
 308             j = align2 + N + 1 + len2;
 309           else
 310             j = align2 + len1 + 1 + len2;
 311           for (; j < 512; ++j)
 312             {
 313               if (p2[j] != '\1')
 314                 {
 315                   error (0, 0, "Iteration %zd - garbage after, %s "
 316                          "(%zd, %zd, %zd, %zd, %zd)",
 317                          n, impl->name, align1, align2, len1, len2, N);
 318                   ret = 1;
 319                   break;
 320                 }
 321             }
 322           if (len1 + 1 > N)
 323             {
 324               if (p2[align2 + N + len2] != '\0')
 325                 {
 326                   error (0, 0, "Iteration %zd - there is no zero at the "
 327                          "end of output string, %s (%zd, %zd, %zd, %zd, %zd)",
 328                          n, impl->name, align1, align2, len1, len2, N);
 329                   ret = 1;
 330                 }
 331             }
 332           if (MEMCMP (p1 + align1, p2 + align2 + len2,
 333                       (len1 + 1) > N ? N : len1 + 1))
 334             {
 335               error (0, 0, "Iteration %zd - different strings, %s "
 336                      "(%zd, %zd, %zd, %zd, %zd)",
 337                      n, impl->name, align1, align2, len1, len2, N);
 338               ret = 1;
 339             }
 340         }
 341     }
 342 }
 343
 344 int
 345 test_main (void)
 346 {
 347   size_t i, n;
 348
 349   test_init ();
 350
 351   printf ("%28s", "");
 352   FOR_EACH_IMPL (impl, 0)
 353     printf ("\t%s", impl->name);
 354   putchar ('\n');
 355
 356   for (n = 2; n <= 2048; n*=4)
 357     {
 358       do_test (0, 2, 2, 2, n, SMALL_CHAR);
 359       do_test (0, 0, 4, 4, n, SMALL_CHAR);
 360       do_test (4, 0, 4, 4, n, BIG_CHAR);
 361       do_test (0, 0, 8, 8, n, SMALL_CHAR);
 362       do_test (0, 8, 8, 8, n, SMALL_CHAR);
 363
 364       do_test (0, 2, 2, 2, SIZE_MAX, SMALL_CHAR);
 365       do_test (0, 0, 4, 4, SIZE_MAX, SMALL_CHAR);
 366       do_test (4, 0, 4, 4, SIZE_MAX, BIG_CHAR);
 367       do_test (0, 0, 8, 8, SIZE_MAX, SMALL_CHAR);
 368       do_test (0, 8, 8, 8, SIZE_MAX, SMALL_CHAR);
 369
 370       for (i = 1; i < 8; ++i)
 371         {
 372           do_test (0, 0, 8 << i, 8 << i, n, SMALL_CHAR);
 373           do_test (8 - i, 2 * i, 8 << i, 8 << i, n, SMALL_CHAR);
 374           do_test (0, 0, 8 << i, 2 << i, n, SMALL_CHAR);
 375           do_test (8 - i, 2 * i, 8 << i, 2 << i, n, SMALL_CHAR);
 376
 377           do_test (0, 0, 8 << i, 8 << i, SIZE_MAX, SMALL_CHAR);
 378           do_test (8 - i, 2 * i, 8 << i, 8 << i, SIZE_MAX, SMALL_CHAR);
 379           do_test (0, 0, 8 << i, 2 << i, SIZE_MAX, SMALL_CHAR);
 380           do_test (8 - i, 2 * i, 8 << i, 2 << i, SIZE_MAX, SMALL_CHAR);
 381         }
 382
 383       for (i = 1; i < 8; ++i)
 384         {
 385           do_test (i, 2 * i, 8 << i, 1, n, SMALL_CHAR);
 386           do_test (2 * i, i, 8 << i, 1, n, BIG_CHAR);
 387           do_test (i, i, 8 << i, 10, n, SMALL_CHAR);
 388
 389           do_test (i, 2 * i, 8 << i, 1, SIZE_MAX, SMALL_CHAR);
 390           do_test (2 * i, i, 8 << i, 1, SIZE_MAX, BIG_CHAR);
 391           do_test (i, i, 8 << i, 10, SIZE_MAX, SMALL_CHAR);
 392         }
 393     }
 394
 395   do_random_tests ();
 396   do_overflow_tests ();
 397   do_test_src_no_nullterm_bz30065 ();
 398   return ret;
 399 }
 400
 401 #include <support/test-driver.c>