libmudflap/testsuite/libmudflap.c/pass-stratcliff.c

   1 /* Test for string function add boundaries of usable memory.
   2    Copyright (C) 1996,1997,1999,2000,2001,2002 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, write to the Free
  18    Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19    02110-1301 USA.  */
  20
  21 #define _GNU_SOURCE 1
  22 #define __USE_GNU
  23
  24 /* Make sure we don't test the optimized inline functions if we want to
  25    test the real implementation.  */
  26 #undef __USE_STRING_INLINES
  27
  28 #include <errno.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <unistd.h>
  32 #include <sys/mman.h>
  33 #include <sys/param.h>
  34
  35 #ifndef MAX
  36 #define MAX(a, b) ((a) > (b) ? (a) : (b))
  37 #endif
  38
  39 int
  40 main (int argc, char *argv[])
  41 {
  42   int size = sysconf (_SC_PAGESIZE);
  43   char *adr, *dest;
  44   int result = 0;
  45
  46   adr = (char *) mmap (NULL, 3 * size, PROT_READ | PROT_WRITE,
  47                        MAP_PRIVATE | MAP_ANON, -1, 0);
  48   dest = (char *) mmap (NULL, 3 * size, PROT_READ | PROT_WRITE,
  49                         MAP_PRIVATE | MAP_ANON, -1, 0);
  50   if (adr == MAP_FAILED || dest == MAP_FAILED)
  51     {
  52       if (errno == ENOSYS)
  53         puts ("No test, mmap not available.");
  54       else
  55         {
  56           printf ("mmap failed: %m");
  57           result = 1;
  58         }
  59     }
  60   else
  61     {
  62       int inner, middle, outer;
  63
  64       mprotect(adr, size, PROT_NONE);
  65       mprotect(adr + 2 * size, size, PROT_NONE);
  66       adr += size;
  67
  68       mprotect(dest, size, PROT_NONE);
  69       mprotect(dest + 2 * size, size, PROT_NONE);
  70       dest += size;
  71
  72       memset (adr, 'T', size);
  73
  74       /* strlen test */
  75       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
  76         {
  77           for (inner = MAX (outer, size - 64); inner < size; ++inner)
  78             {
  79               adr[inner] = '\0';
  80
  81               if (strlen (&adr[outer]) != (size_t) (inner - outer))
  82                 {
  83                   printf ("strlen flunked for outer = %d, inner = %d\n",
  84                           outer, inner);
  85                   result = 1;
  86                 }
  87
  88               adr[inner] = 'T';
  89             }
  90         }
  91
  92       /* strchr test */
  93       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
  94         {
  95           for (middle = MAX (outer, size - 64); middle < size; ++middle)
  96             {
  97               for (inner = middle; inner < size; ++inner)
  98                 {
  99                   char *cp;
 100                   adr[middle] = 'V';
 101                   adr[inner] = '\0';
 102
 103                   cp = strchr (&adr[outer], 'V');
 104
 105                   if ((inner == middle && cp != NULL)
 106                       || (inner != middle
 107                           && (cp - &adr[outer]) != middle - outer))
 108                     {
 109                       printf ("strchr flunked for outer = %d, middle = %d, "
 110                               "inner = %d\n", outer, middle, inner);
 111                       result = 1;
 112                     }
 113
 114                   adr[inner] = 'T';
 115                   adr[middle] = 'T';
 116                 }
 117             }
 118         }
 119
 120       /* Special test.  */
 121       adr[size - 1] = '\0';
 122       if (strchr (&adr[size - 1], '\n') != NULL)
 123         {
 124           puts ("strchr flunked for test of empty string at end of page");
 125           result = 1;
 126         }
 127
 128       /* strrchr test */
 129       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 130         {
 131           for (middle = MAX (outer, size - 64); middle < size; ++middle)
 132             {
 133               for (inner = middle; inner < size; ++inner)
 134                 {
 135                   char *cp;
 136                   adr[middle] = 'V';
 137                   adr[inner] = '\0';
 138
 139                   cp = strrchr (&adr[outer], 'V');
 140
 141                   if ((inner == middle && cp != NULL)
 142                       || (inner != middle
 143                           && (cp - &adr[outer]) != middle - outer))
 144                     {
 145                       printf ("strrchr flunked for outer = %d, middle = %d, "
 146                               "inner = %d\n", outer, middle, inner);
 147                       result = 1;
 148                     }
 149
 150                   adr[inner] = 'T';
 151                   adr[middle] = 'T';
 152                 }
 153             }
 154         }
 155
 156 #if !defined  __FreeBSD__ && !(defined __sun__ && defined __svr4__)
 157       /* rawmemchr test */
 158       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 159         {
 160           for (middle = MAX (outer, size - 64); middle < size; ++middle)
 161             {
 162               char *cp;
 163               adr[middle] = 'V';
 164
 165               cp = (char *) rawmemchr (&adr[outer], 'V');
 166
 167               if (cp - &adr[outer] != middle - outer)
 168                 {
 169                   printf ("rawmemchr flunked for outer = %d, middle = %d\n",
 170                           outer, middle);
 171                   result = 1;
 172                 }
 173
 174               adr[middle] = 'T';
 175             }
 176         }
 177 #endif
 178
 179       /* strcpy test */
 180       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 181         {
 182           for (inner = MAX (outer, size - 64); inner < size; ++inner)
 183             {
 184               adr[inner] = '\0';
 185
 186               if (strcpy (dest, &adr[outer]) != dest
 187                   || strlen (dest) != (size_t) (inner - outer))
 188                 {
 189                   printf ("strcpy flunked for outer = %d, inner = %d\n",
 190                           outer, inner);
 191                   result = 1;
 192                 }
 193
 194               adr[inner] = 'T';
 195             }
 196         }
 197
 198       /* strncpy tests */
 199       adr[size-1] = 'T';
 200       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 201         {
 202           size_t len;
 203
 204           for (len = 0; len < size - outer; ++len)
 205             {
 206               if (strncpy (dest, &adr[outer], len) != dest
 207                   || memcmp (dest, &adr[outer], len) != 0)
 208                 {
 209                   printf ("outer strncpy flunked for outer = %d, len = %Zd\n",
 210                           outer, len);
 211                   result = 1;
 212                 }
 213             }
 214         }
 215       adr[size-1] = '\0';
 216
 217       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 218         {
 219           for (inner = MAX (outer, size - 64); inner < size; ++inner)
 220             {
 221               size_t len;
 222
 223               adr[inner] = '\0';
 224
 225               for (len = 0; len < size - outer + 64; ++len)
 226                 {
 227                   if (strncpy (dest, &adr[outer], len) != dest
 228                       || memcmp (dest, &adr[outer],
 229                                  MIN (inner - outer, len)) != 0
 230                       || (inner - outer < len
 231                           && strlen (dest) != (inner - outer)))
 232                     {
 233                       printf ("strncpy flunked for outer = %d, inner = %d, len = %Zd\n",
 234                               outer, inner, len);
 235                       result = 1;
 236                     }
 237                   if (strncpy (dest + 1, &adr[outer], len) != dest + 1
 238                       || memcmp (dest + 1, &adr[outer],
 239                                  MIN (inner - outer, len)) != 0
 240                       || (inner - outer < len
 241                           && strlen (dest + 1) != (inner - outer)))
 242                     {
 243                       printf ("strncpy+1 flunked for outer = %d, inner = %d, len = %Zd\n",
 244                               outer, inner, len);
 245                       result = 1;
 246                     }
 247                 }
 248
 249               adr[inner] = 'T';
 250             }
 251         }
 252
 253 #ifndef __FreeBSD__ && !(defined __sun__ && defined __svr4__)
 254       /* stpcpy test */
 255       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 256         {
 257           for (inner = MAX (outer, size - 64); inner < size; ++inner)
 258             {
 259               adr[inner] = '\0';
 260
 261               if ((stpcpy (dest, &adr[outer]) - dest) != inner - outer)
 262                 {
 263                   printf ("stpcpy flunked for outer = %d, inner = %d\n",
 264                           outer, inner);
 265                   result = 1;
 266                 }
 267
 268               adr[inner] = 'T';
 269             }
 270         }
 271
 272       /* stpncpy test */
 273       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 274         {
 275           for (middle = MAX (outer, size - 64); middle < size; ++middle)
 276             {
 277               adr[middle] = '\0';
 278
 279               for (inner = 0; inner < size - outer; ++ inner)
 280                 {
 281                   if ((stpncpy (dest, &adr[outer], inner) - dest)
 282                       != MIN (inner, middle - outer))
 283                     {
 284                       printf ("stpncpy flunked for outer = %d, middle = %d, "
 285                               "inner = %d\n", outer, middle, inner);
 286                       result = 1;
 287                     }
 288                 }
 289
 290               adr[middle] = 'T';
 291             }
 292         }
 293 #endif
 294
 295       /* memcpy test */
 296       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 297         for (inner = 0; inner < size - outer; ++inner)
 298           if (memcpy (dest, &adr[outer], inner) !=  dest)
 299             {
 300               printf ("memcpy flunked for outer = %d, inner = %d\n",
 301                       outer, inner);
 302               result = 1;
 303             }
 304
 305 #if !defined __FreeBSD__ && !(defined __sun__ && defined __svr4__)
 306       /* mempcpy test */
 307       for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
 308         for (inner = 0; inner < size - outer; ++inner)
 309           if (mempcpy (dest, &adr[outer], inner) !=  dest + inner)
 310             {
 311               printf ("mempcpy flunked for outer = %d, inner = %d\n",
 312                       outer, inner);
 313               result = 1;
 314             }
 315 #endif
 316     }
 317
 318   return result;
 319 }