l4/pkg/uclibc/lib/contrib/uclibc/test/string/stratcliff.c

   1 /* Test for string function add boundaries of usable memory.
   2    Copyright (C) 1996,1997,1999-2002,2003 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #define _GNU_SOURCE 1
  21
  22 /* Make sure we don't test the optimized inline functions if we want to
  23    test the real implementation.  */
  24 #undef __USE_STRING_INLINES
  25
  26 #include <errno.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30 #include <sys/mman.h>
  31 #include <sys/param.h>
  32
  33 #ifndef MAX
  34 #define MAX(a, b) ((a) > (b) ? (a) : (b))
  35 #endif
  36
  37 int
  38 main (int argc, char *argv[])
  39 {
  40   int size = sysconf (_SC_PAGESIZE);
  41   char *adr, *dest;
  42   int result = 0;
  43
  44   adr = (char *) mmap (NULL, 3 * size, PROT_READ | PROT_WRITE,
  45                        MAP_PRIVATE | MAP_ANON, -1, 0);
  46   dest = (char *) mmap (NULL, 3 * size, PROT_READ | PROT_WRITE,
  47                         MAP_PRIVATE | MAP_ANON, -1, 0);
  48   if (adr == MAP_FAILED || dest == MAP_FAILED)
  49     {
  50       if (errno == ENOSYS)
  51         puts ("No test, mmap not available.");
  52       else
  53         {
  54           printf ("mmap failed: %s", strerror(errno));
  55           result = 1;
  56         }
  57     }
  58   else
  59     {
  60       int inner, middle, outer;
  61
  62       mprotect(adr, size, PROT_NONE);
  63       mprotect(adr + 2 * size, size, PROT_NONE);
  64       adr += size;
  65
  66       mprotect(dest, size, PROT_NONE);
  67       mprotect(dest + 2 * size, size, PROT_NONE);
  68       dest += size;
  69
  70       memset (adr, 'T', size);
  71
  72       /* strlen test */
  73       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
  74         {
  75           for (inner = MAX (outer, size - 64); inner < size; ++inner)
  76             {
  77               adr[inner] = '\0';
  78
  79               if (strlen (&adr[outer]) != (size_t) (inner - outer))
  80                 {
  81                   printf ("strlen flunked for outer = %d, inner = %d\n",
  82                           outer, inner);
  83                   result = 1;
  84                 }
  85
  86               adr[inner] = 'T';
  87             }
  88         }
  89
  90       /* strchr test */
  91       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
  92         {
  93           for (middle = MAX (outer, size - 64); middle < size; ++middle)
  94             {
  95               for (inner = middle; inner < size; ++inner)
  96                 {
  97                   char *cp;
  98                   adr[middle] = 'V';
  99                   adr[inner] = '\0';
 100
 101                   cp = strchr (&adr[outer], 'V');
 102
 103                   if ((inner == middle && cp != NULL)
 104                       || (inner != middle
 105                           && (cp - &adr[outer]) != middle - outer))
 106                     {
 107                       printf ("strchr flunked for outer = %d, middle = %d, "
 108                               "inner = %d\n", outer, middle, inner);
 109                       result = 1;
 110                     }
 111
 112                   adr[inner] = 'T';
 113                   adr[middle] = 'T';
 114                 }
 115             }
 116         }
 117
 118       /* Special test.  */
 119       adr[size - 1] = '\0';
 120       if (strchr (&adr[size - 1], '\n') != NULL)
 121         {
 122           puts ("strchr flunked for test of empty string at end of page");
 123           result = 1;
 124         }
 125
 126       /* strrchr test */
 127       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 128         {
 129           for (middle = MAX (outer, size - 64); middle < size; ++middle)
 130             {
 131               for (inner = middle; inner < size; ++inner)
 132                 {
 133                   char *cp;
 134                   adr[middle] = 'V';
 135                   adr[inner] = '\0';
 136
 137                   cp = strrchr (&adr[outer], 'V');
 138
 139                   if ((inner == middle && cp != NULL)
 140                       || (inner != middle
 141                           && (cp - &adr[outer]) != middle - outer))
 142                     {
 143                       printf ("strrchr flunked for outer = %d, middle = %d, "
 144                               "inner = %d\n", outer, middle, inner);
 145                       result = 1;
 146                     }
 147
 148                   adr[inner] = 'T';
 149                   adr[middle] = 'T';
 150                 }
 151             }
 152         }
 153
 154       /* rawmemchr test */
 155       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 156         {
 157           for (middle = MAX (outer, size - 64); middle < size; ++middle)
 158             {
 159               char *cp;
 160               adr[middle] = 'V';
 161
 162               cp = rawmemchr (&adr[outer], 'V');
 163
 164               if (cp - &adr[outer] != middle - outer)
 165                 {
 166                   printf ("rawmemchr flunked for outer = %d, middle = %d\n",
 167                           outer, middle);
 168                   result = 1;
 169                 }
 170
 171               adr[middle] = 'T';
 172             }
 173         }
 174
 175       /* strcpy test */
 176       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 177         {
 178           for (inner = MAX (outer, size - 64); inner < size; ++inner)
 179             {
 180               adr[inner] = '\0';
 181
 182               if (strcpy (dest, &adr[outer]) != dest
 183                   || strlen (dest) != (size_t) (inner - outer))
 184                 {
 185                   printf ("strcpy flunked for outer = %d, inner = %d\n",
 186                           outer, inner);
 187                   result = 1;
 188                 }
 189
 190               adr[inner] = 'T';
 191             }
 192         }
 193
 194       /* strncpy tests */
 195       adr[size-1] = 'T';
 196       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 197         {
 198           size_t len;
 199
 200           for (len = 0; len < size - outer; ++len)
 201             {
 202               if (strncpy (dest, &adr[outer], len) != dest
 203                   || memcmp (dest, &adr[outer], len) != 0)
 204                 {
 205                   printf ("outer strncpy flunked for outer = %d, len = %Zd\n",
 206                           outer, len);
 207                   result = 1;
 208                 }
 209             }
 210         }
 211       adr[size-1] = '\0';
 212
 213       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 214         {
 215           for (inner = MAX (outer, size - 64); inner < size; ++inner)
 216             {
 217               size_t len;
 218
 219               adr[inner] = '\0';
 220
 221               for (len = 0; len < size - outer + 64; ++len)
 222                 {
 223                   if (strncpy (dest, &adr[outer], len) != dest
 224                       || memcmp (dest, &adr[outer],
 225                                  MIN (inner - outer, len)) != 0
 226                       || (inner - outer < len
 227                           && strlen (dest) != (inner - outer)))
 228                     {
 229                       printf ("strncpy flunked for outer = %d, inner = %d, len = %Zd\n",
 230                               outer, inner, len);
 231                       result = 1;
 232                     }
 233                   if (strncpy (dest + 1, &adr[outer], len) != dest + 1
 234                       || memcmp (dest + 1, &adr[outer],
 235                                  MIN (inner - outer, len)) != 0
 236                       || (inner - outer < len
 237                           && strlen (dest + 1) != (inner - outer)))
 238                     {
 239                       printf ("strncpy+1 flunked for outer = %d, inner = %d, len = %Zd\n",
 240                               outer, inner, len);
 241                       result = 1;
 242                     }
 243                 }
 244
 245               adr[inner] = 'T';
 246             }
 247         }
 248
 249       /* stpcpy test */
 250       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 251         {
 252           for (inner = MAX (outer, size - 64); inner < size; ++inner)
 253             {
 254               adr[inner] = '\0';
 255
 256               if ((stpcpy (dest, &adr[outer]) - dest) != inner - outer)
 257                 {
 258                   printf ("stpcpy flunked for outer = %d, inner = %d\n",
 259                           outer, inner);
 260                   result = 1;
 261                 }
 262
 263               adr[inner] = 'T';
 264             }
 265         }
 266
 267       /* stpncpy test */
 268       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 269         {
 270           for (middle = MAX (outer, size - 64); middle < size; ++middle)
 271             {
 272               adr[middle] = '\0';
 273
 274               for (inner = 0; inner < size - outer; ++ inner)
 275                 {
 276                   if ((stpncpy (dest, &adr[outer], inner) - dest)
 277                       != MIN (inner, middle - outer))
 278                     {
 279                       printf ("stpncpy flunked for outer = %d, middle = %d, "
 280                               "inner = %d\n", outer, middle, inner);
 281                       result = 1;
 282                     }
 283                 }
 284
 285               adr[middle] = 'T';
 286             }
 287         }
 288
 289       /* memcpy test */
 290       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 291         for (inner = 0; inner < size - outer; ++inner)
 292           if (memcpy (dest, &adr[outer], inner) !=  dest)
 293             {
 294               printf ("memcpy flunked for outer = %d, inner = %d\n",
 295                       outer, inner);
 296               result = 1;
 297             }
 298
 299       /* mempcpy test */
 300       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 301         for (inner = 0; inner < size - outer; ++inner)
 302           if (mempcpy (dest, &adr[outer], inner) !=  dest + inner)
 303             {
 304               printf ("mempcpy flunked for outer = %d, inner = %d\n",
 305                       outer, inner);
 306               result = 1;
 307             }
 308
 309       /* memccpy test */
 310       memset (adr, '\0', size);
 311       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 312         for (inner = 0; inner < size - outer; ++inner)
 313           if (memccpy (dest, &adr[outer], '\1', inner) != NULL)
 314             {
 315               printf ("memccpy flunked full copy for outer = %d, inner = %d\n",
 316                       outer, inner);
 317               result = 1;
 318             }
 319       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 320         for (middle = 0; middle < size - outer; ++middle)
 321           {
 322             memset (dest, '\2', middle + 1);
 323             for (inner = 0; inner < middle; ++inner)
 324               {
 325                 adr[outer + inner] = '\1';
 326
 327                 if (memccpy (dest, &adr[outer], '\1', middle + 128)
 328                     !=  dest + inner + 1)
 329                   {
 330                     printf ("\
 331 memccpy flunked partial copy for outer = %d, middle = %d, inner = %d\n",
 332                             outer, middle, inner);
 333                     result = 1;
 334                   }
 335                 else if (dest[inner + 1] != '\2')
 336                   {
 337                     printf ("\
 338 memccpy copied too much for outer = %d, middle = %d, inner = %d\n",
 339                             outer, middle, inner);
 340                     result = 1;
 341                   }
 342                 adr[outer + inner] = '\0';
 343               }
 344           }
 345     }
 346
 347   return result;
 348 }