string/tester.c

   1 /* Tester for string functions.
   2    Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 #ifndef _GNU_SOURCE
  21 #define _GNU_SOURCE
  22 #endif
  23
  24 /* Make sure we don't test the optimized inline functions if we want to
  25    test the real implementation.  */
  26 #if !defined DO_STRING_INLINES
  27 #undef __USE_STRING_INLINES
  28 #endif
  29
  30 #include <errno.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <strings.h>
  35 #include <fcntl.h>
  36
  37 #ifndef HAVE_GNU_LD
  38 #define _sys_nerr       sys_nerr
  39 #define _sys_errlist    sys_errlist
  40 #endif
  41
  42 #define STREQ(a, b)     (strcmp((a), (b)) == 0)
  43
  44 const char *it = "<UNSET>";     /* Routine name for message routines. */
  45 size_t errors = 0;
  46
  47 /* Complain if condition is not true.  */
  48 void
  49 check (int thing, int number)
  50 {
  51   if (!thing)
  52     {
  53       printf("%s flunked test %d\n", it, number);
  54       ++errors;
  55     }
  56 }
  57
  58 /* Complain if first two args don't strcmp as equal.  */
  59 void
  60 equal (const char *a, const char *b, int number)
  61 {
  62   check(a != NULL && b != NULL && STREQ (a, b), number);
  63 }
  64
  65 char one[50];
  66 char two[50];
  67 char *cp;
  68
  69 void
  70 test_strcmp (void)
  71 {
  72   it = "strcmp";
  73   check (strcmp ("", "") == 0, 1);              /* Trivial case. */
  74   check (strcmp ("a", "a") == 0, 2);            /* Identity. */
  75   check (strcmp ("abc", "abc") == 0, 3);        /* Multicharacter. */
  76   check (strcmp ("abc", "abcd") < 0, 4);        /* Length mismatches. */
  77   check (strcmp ("abcd", "abc") > 0, 5);
  78   check (strcmp ("abcd", "abce") < 0, 6);       /* Honest miscompares. */
  79   check (strcmp ("abce", "abcd") > 0, 7);
  80   check (strcmp ("a\203", "a") > 0, 8);         /* Tricky if char signed. */
  81   check (strcmp ("a\203", "a\003") > 0, 9);
  82
  83   {
  84     char buf1[0x40], buf2[0x40];
  85     int i, j;
  86     for (i=0; i < 0x10; i++)
  87       for (j = 0; j < 0x10; j++)
  88         {
  89           int k;
  90           for (k = 0; k < 0x3f; k++)
  91             {
  92               buf1[j] = '0' ^ (k & 4);
  93               buf2[j] = '4' ^ (k & 4);
  94             }
  95           buf1[i] = buf1[0x3f] = 0;
  96           buf2[j] = buf2[0x3f] = 0;
  97           for (k = 0; k < 0xf; k++)
  98             {
  99               int cnum = 0x10+0x10*k+0x100*j+0x1000*i;
 100               check (strcmp (buf1+i,buf2+j) == 0, cnum);
 101               buf1[i+k] = 'A' + i + k;
 102               buf1[i+k+1] = 0;
 103               check (strcmp (buf1+i,buf2+j) > 0, cnum+1);
 104               check (strcmp (buf2+j,buf1+i) < 0, cnum+2);
 105               buf2[j+k] = 'B' + i + k;
 106               buf2[j+k+1] = 0;
 107               check (strcmp (buf1+i,buf2+j) < 0, cnum+3);
 108               check (strcmp (buf2+j,buf1+i) > 0, cnum+4);
 109               buf2[j+k] = 'A' + i + k;
 110               buf1[i] = 'A' + i + 0x80;
 111               check (strcmp (buf1+i,buf2+j) > 0, cnum+5);
 112               check (strcmp (buf2+j,buf1+i) < 0, cnum+6);
 113               buf1[i] = 'A' + i;
 114             }
 115         }
 116   }
 117 }
 118
 119 void
 120 test_strcpy (void)
 121 {
 122   it = "strcpy";
 123   check (strcpy (one, "abcd") == one, 1); /* Returned value. */
 124   equal (one, "abcd", 2);               /* Basic test. */
 125
 126   (void) strcpy (one, "x");
 127   equal (one, "x", 3);                  /* Writeover. */
 128   equal (one+2, "cd", 4);               /* Wrote too much? */
 129
 130   (void) strcpy (two, "hi there");
 131   (void) strcpy (one, two);
 132   equal (one, "hi there", 5);           /* Basic test encore. */
 133   equal (two, "hi there", 6);           /* Stomped on source? */
 134
 135   (void) strcpy (one, "");
 136   equal (one, "", 7);                   /* Boundary condition. */
 137 }
 138
 139 void
 140 test_stpcpy (void)
 141 {
 142   it = "stpcpy";
 143   check ((stpcpy (one, "a") - one) == 1, 1);
 144   equal (one, "a", 2);
 145
 146   check ((stpcpy (one, "ab") - one) == 2, 3);
 147   equal (one, "ab", 4);
 148
 149   check ((stpcpy (one, "abc") - one) == 3, 5);
 150   equal (one, "abc", 6);
 151
 152   check ((stpcpy (one, "abcd") - one) == 4, 7);
 153   equal (one, "abcd", 8);
 154
 155   check ((stpcpy (one, "abcde") - one) == 5, 9);
 156   equal (one, "abcde", 10);
 157
 158   check ((stpcpy (one, "abcdef") - one) == 6, 11);
 159   equal (one, "abcdef", 12);
 160
 161   check ((stpcpy (one, "abcdefg") - one) == 7, 13);
 162   equal (one, "abcdefg", 14);
 163
 164   check ((stpcpy (one, "abcdefgh") - one) == 8, 15);
 165   equal (one, "abcdefgh", 16);
 166
 167   check ((stpcpy (one, "abcdefghi") - one) == 9, 17);
 168   equal (one, "abcdefghi", 18);
 169
 170   check ((stpcpy (one, "x") - one) == 1, 19);
 171   equal (one, "x", 20);                 /* Writeover. */
 172   equal (one+2, "cdefghi", 21);         /* Wrote too much? */
 173
 174   check ((stpcpy (one, "xx") - one) == 2, 22);
 175   equal (one, "xx", 23);                /* Writeover. */
 176   equal (one+3, "defghi", 24);          /* Wrote too much? */
 177
 178   check ((stpcpy (one, "xxx") - one) == 3, 25);
 179   equal (one, "xxx", 26);               /* Writeover. */
 180   equal (one+4, "efghi", 27);           /* Wrote too much? */
 181
 182   check ((stpcpy (one, "xxxx") - one) == 4, 28);
 183   equal (one, "xxxx", 29);              /* Writeover. */
 184   equal (one+5, "fghi", 30);            /* Wrote too much? */
 185
 186   check ((stpcpy (one, "xxxxx") - one) == 5, 31);
 187   equal (one, "xxxxx", 32);             /* Writeover. */
 188   equal (one+6, "ghi", 33);             /* Wrote too much? */
 189
 190   check ((stpcpy (one, "xxxxxx") - one) == 6, 34);
 191   equal (one, "xxxxxx", 35);            /* Writeover. */
 192   equal (one+7, "hi", 36);              /* Wrote too much? */
 193
 194   check ((stpcpy (one, "xxxxxxx") - one) == 7, 37);
 195   equal (one, "xxxxxxx", 38);           /* Writeover. */
 196   equal (one+8, "i", 39);               /* Wrote too much? */
 197
 198   check ((stpcpy (stpcpy (stpcpy (one, "a"), "b"), "c") - one) == 3, 40);
 199   equal (one, "abc", 41);
 200   equal (one + 4, "xxx", 42);
 201 }
 202
 203 void
 204 test_stpncpy (void)
 205 {
 206   it = "stpncpy";
 207   memset (one, 'x', sizeof (one));
 208   check (stpncpy (one, "abc", 2) == one + 2, 1);
 209   check (stpncpy (one, "abc", 3) == one + 3, 2);
 210   check (stpncpy (one, "abc", 4) == one + 3, 3);
 211   check (one[3] == '\0' && one[4] == 'x', 4);
 212   check (stpncpy (one, "abcd", 5) == one + 4, 5);
 213   check (one[4] == '\0' && one[5] == 'x', 6);
 214   check (stpncpy (one, "abcd", 6) == one + 4, 7);
 215   check (one[4] == '\0' && one[5] == '\0' && one[6] == 'x', 8);
 216 }
 217
 218 void
 219 test_strcat (void)
 220 {
 221   it = "strcat";
 222   (void) strcpy (one, "ijk");
 223   check (strcat (one, "lmn") == one, 1); /* Returned value. */
 224   equal (one, "ijklmn", 2);             /* Basic test. */
 225
 226   (void) strcpy (one, "x");
 227   (void) strcat (one, "yz");
 228   equal (one, "xyz", 3);                        /* Writeover. */
 229   equal (one+4, "mn", 4);                       /* Wrote too much? */
 230
 231   (void) strcpy (one, "gh");
 232   (void) strcpy (two, "ef");
 233   (void) strcat (one, two);
 234   equal (one, "ghef", 5);                       /* Basic test encore. */
 235   equal (two, "ef", 6);                 /* Stomped on source? */
 236
 237   (void) strcpy (one, "");
 238   (void) strcat (one, "");
 239   equal (one, "", 7);                   /* Boundary conditions. */
 240   (void) strcpy (one, "ab");
 241   (void) strcat (one, "");
 242   equal (one, "ab", 8);
 243   (void) strcpy (one, "");
 244   (void) strcat (one, "cd");
 245   equal (one, "cd", 9);
 246 }
 247
 248 void
 249 test_strncat (void)
 250 {
 251   /* First test it as strcat, with big counts, then test the count
 252      mechanism.  */
 253   it = "strncat";
 254   (void) strcpy (one, "ijk");
 255   check (strncat (one, "lmn", 99) == one, 1);   /* Returned value. */
 256   equal (one, "ijklmn", 2);             /* Basic test. */
 257
 258   (void) strcpy (one, "x");
 259   (void) strncat (one, "yz", 99);
 260   equal (one, "xyz", 3);                /* Writeover. */
 261   equal (one+4, "mn", 4);               /* Wrote too much? */
 262
 263   (void) strcpy (one, "gh");
 264   (void) strcpy (two, "ef");
 265   (void) strncat (one, two, 99);
 266   equal (one, "ghef", 5);                       /* Basic test encore. */
 267   equal (two, "ef", 6);                 /* Stomped on source? */
 268
 269   (void) strcpy (one, "");
 270   (void) strncat (one, "", 99);
 271   equal (one, "", 7);                   /* Boundary conditions. */
 272   (void) strcpy (one, "ab");
 273   (void) strncat (one, "", 99);
 274   equal (one, "ab", 8);
 275   (void) strcpy (one, "");
 276   (void) strncat (one, "cd", 99);
 277   equal (one, "cd", 9);
 278
 279   (void) strcpy (one, "ab");
 280   (void) strncat (one, "cdef", 2);
 281   equal (one, "abcd", 10);                      /* Count-limited. */
 282
 283   (void) strncat (one, "gh", 0);
 284   equal (one, "abcd", 11);                      /* Zero count. */
 285
 286   (void) strncat (one, "gh", 2);
 287   equal (one, "abcdgh", 12);            /* Count and length equal. */
 288 }
 289
 290 void
 291 test_strncmp (void)
 292 {
 293   /* First test as strcmp with big counts, then test count code.  */
 294   it = "strncmp";
 295   check (strncmp ("", "", 99) == 0, 1); /* Trivial case. */
 296   check (strncmp ("a", "a", 99) == 0, 2);       /* Identity. */
 297   check (strncmp ("abc", "abc", 99) == 0, 3);   /* Multicharacter. */
 298   check (strncmp ("abc", "abcd", 99) < 0, 4);   /* Length unequal. */
 299   check (strncmp ("abcd", "abc", 99) > 0, 5);
 300   check (strncmp ("abcd", "abce", 99) < 0, 6);  /* Honestly unequal. */
 301   check (strncmp ("abce", "abcd", 99) > 0, 7);
 302   check (strncmp ("a\203", "a", 2) > 0, 8);     /* Tricky if '\203' < 0 */
 303   check (strncmp ("a\203", "a\003", 2) > 0, 9);
 304   check (strncmp ("abce", "abcd", 3) == 0, 10); /* Count limited. */
 305   check (strncmp ("abce", "abc", 3) == 0, 11);  /* Count == length. */
 306   check (strncmp ("abcd", "abce", 4) < 0, 12);  /* Nudging limit. */
 307   check (strncmp ("abc", "def", 0) == 0, 13);   /* Zero count. */
 308 }
 309
 310 void
 311 test_strncpy (void)
 312 {
 313   /* Testing is a bit different because of odd semantics.  */
 314   it = "strncpy";
 315   check (strncpy (one, "abc", 4) == one, 1);    /* Returned value. */
 316   equal (one, "abc", 2);                        /* Did the copy go right? */
 317
 318   (void) strcpy (one, "abcdefgh");
 319   (void) strncpy (one, "xyz", 2);
 320   equal (one, "xycdefgh", 3);                   /* Copy cut by count. */
 321
 322   (void) strcpy (one, "abcdefgh");
 323   (void) strncpy (one, "xyz", 3);               /* Copy cut just before NUL. */
 324   equal (one, "xyzdefgh", 4);
 325
 326   (void) strcpy (one, "abcdefgh");
 327   (void) strncpy (one, "xyz", 4);               /* Copy just includes NUL. */
 328   equal (one, "xyz", 5);
 329   equal (one+4, "efgh", 6);                     /* Wrote too much? */
 330
 331   (void) strcpy (one, "abcdefgh");
 332   (void) strncpy (one, "xyz", 5);               /* Copy includes padding. */
 333   equal (one, "xyz", 7);
 334   equal (one+4, "", 8);
 335   equal (one+5, "fgh", 9);
 336
 337   (void) strcpy (one, "abc");
 338   (void) strncpy (one, "xyz", 0);               /* Zero-length copy. */
 339   equal (one, "abc", 10);
 340
 341   (void) strncpy (one, "", 2);          /* Zero-length source. */
 342   equal (one, "", 11);
 343   equal (one+1, "", 12);
 344   equal (one+2, "c", 13);
 345
 346   (void) strcpy (one, "hi there");
 347   (void) strncpy (two, one, 9);
 348   equal (two, "hi there", 14);          /* Just paranoia. */
 349   equal (one, "hi there", 15);          /* Stomped on source? */
 350 }
 351
 352 void
 353 test_strlen (void)
 354 {
 355   it = "strlen";
 356   check (strlen ("") == 0, 1);          /* Empty. */
 357   check (strlen ("a") == 1, 2);         /* Single char. */
 358   check (strlen ("abcd") == 4, 3);      /* Multiple chars. */
 359   {
 360     char buf[4096];
 361     int i;
 362     char *p;
 363     for (i=0; i < 0x100; i++)
 364       {
 365         p = (char *) ((unsigned long int)(buf + 0xff) & ~0xff) + i;
 366         strcpy (p, "OK");
 367         strcpy (p+3, "BAD/WRONG");
 368         check (strlen (p) == 2, 4+i);
 369       }
 370    }
 371 }
 372
 373 void
 374 test_strchr (void)
 375 {
 376   it = "strchr";
 377   check (strchr ("abcd", 'z') == NULL, 1);      /* Not found. */
 378   (void) strcpy (one, "abcd");
 379   check (strchr (one, 'c') == one+2, 2);        /* Basic test. */
 380   check (strchr (one, 'd') == one+3, 3);        /* End of string. */
 381   check (strchr (one, 'a') == one, 4);          /* Beginning. */
 382   check (strchr (one, '\0') == one+4, 5);       /* Finding NUL. */
 383   (void) strcpy (one, "ababa");
 384   check (strchr (one, 'b') == one+1, 6);        /* Finding first. */
 385   (void) strcpy (one, "");
 386   check (strchr (one, 'b') == NULL, 7);         /* Empty string. */
 387   check (strchr (one, '\0') == one, 8);         /* NUL in empty string. */
 388   {
 389     char buf[4096];
 390     int i;
 391     char *p;
 392     for (i=0; i < 0x100; i++)
 393       {
 394         p = (char *) ((unsigned long int) (buf + 0xff) & ~0xff) + i;
 395         strcpy (p, "OK");
 396         strcpy (p+3, "BAD/WRONG");
 397         check (strchr (p, '/') == NULL, 9+i);
 398       }
 399    }
 400 }
 401
 402 void
 403 test_index (void)
 404 {
 405   it = "index";
 406   check (index ("abcd", 'z') == NULL, 1);       /* Not found. */
 407   (void) strcpy (one, "abcd");
 408   check (index (one, 'c') == one+2, 2); /* Basic test. */
 409   check (index (one, 'd') == one+3, 3); /* End of string. */
 410   check (index (one, 'a') == one, 4);   /* Beginning. */
 411   check (index (one, '\0') == one+4, 5);        /* Finding NUL. */
 412   (void) strcpy (one, "ababa");
 413   check (index (one, 'b') == one+1, 6); /* Finding first. */
 414   (void) strcpy (one, "");
 415   check (index (one, 'b') == NULL, 7);  /* Empty string. */
 416   check (index (one, '\0') == one, 8);  /* NUL in empty string. */
 417 }
 418
 419 void
 420 test_strrchr (void)
 421 {
 422   it = "strrchr";
 423   check (strrchr ("abcd", 'z') == NULL, 1);     /* Not found. */
 424   (void) strcpy (one, "abcd");
 425   check (strrchr (one, 'c') == one+2, 2);       /* Basic test. */
 426   check (strrchr (one, 'd') == one+3, 3);       /* End of string. */
 427   check (strrchr (one, 'a') == one, 4);         /* Beginning. */
 428   check (strrchr (one, '\0') == one+4, 5);      /* Finding NUL. */
 429   (void) strcpy (one, "ababa");
 430   check (strrchr (one, 'b') == one+3, 6);       /* Finding last. */
 431   (void) strcpy (one, "");
 432   check (strrchr (one, 'b') == NULL, 7);        /* Empty string. */
 433   check (strrchr (one, '\0') == one, 8);        /* NUL in empty string. */
 434   {
 435     char buf[4096];
 436     int i;
 437     char *p;
 438     for (i=0; i < 0x100; i++)
 439       {
 440         p = (char *) ((unsigned long int) (buf + 0xff) & ~0xff) + i;
 441         strcpy (p, "OK");
 442         strcpy (p+3, "BAD/WRONG");
 443         check (strrchr (p, '/') == NULL, 9+i);
 444       }
 445    }
 446 }
 447
 448 void
 449 test_rindex (void)
 450 {
 451   it = "rindex";
 452   check (rindex ("abcd", 'z') == NULL, 1);      /* Not found. */
 453   (void) strcpy (one, "abcd");
 454   check (rindex (one, 'c') == one+2, 2);        /* Basic test. */
 455   check (rindex (one, 'd') == one+3, 3);        /* End of string. */
 456   check (rindex (one, 'a') == one, 4);  /* Beginning. */
 457   check (rindex (one, '\0') == one+4, 5);       /* Finding NUL. */
 458   (void) strcpy (one, "ababa");
 459   check (rindex (one, 'b') == one+3, 6);        /* Finding last. */
 460   (void) strcpy (one, "");
 461   check (rindex (one, 'b') == NULL, 7); /* Empty string. */
 462   check (rindex (one, '\0') == one, 8); /* NUL in empty string. */
 463 }
 464
 465 void
 466 test_strpbrk (void)
 467 {
 468   it = "strpbrk";
 469   check(strpbrk("abcd", "z") == NULL, 1);       /* Not found. */
 470   (void) strcpy(one, "abcd");
 471   check(strpbrk(one, "c") == one+2, 2); /* Basic test. */
 472   check(strpbrk(one, "d") == one+3, 3); /* End of string. */
 473   check(strpbrk(one, "a") == one, 4);   /* Beginning. */
 474   check(strpbrk(one, "") == NULL, 5);   /* Empty search list. */
 475   check(strpbrk(one, "cb") == one+1, 6);        /* Multiple search. */
 476   (void) strcpy(one, "abcabdea");
 477   check(strpbrk(one, "b") == one+1, 7); /* Finding first. */
 478   check(strpbrk(one, "cb") == one+1, 8);        /* With multiple search. */
 479   check(strpbrk(one, "db") == one+1, 9);        /* Another variant. */
 480   (void) strcpy(one, "");
 481   check(strpbrk(one, "bc") == NULL, 10);        /* Empty string. */
 482   (void) strcpy(one, "");
 483   check(strpbrk(one, "bcd") == NULL, 11);       /* Empty string. */
 484   (void) strcpy(one, "");
 485   check(strpbrk(one, "bcde") == NULL, 12);      /* Empty string. */
 486   check(strpbrk(one, "") == NULL, 13);  /* Both strings empty. */
 487   (void) strcpy(one, "abcabdea");
 488   check(strpbrk(one, "befg") == one+1, 14);     /* Finding first. */
 489   check(strpbrk(one, "cbr") == one+1, 15);      /* With multiple search. */
 490   check(strpbrk(one, "db") == one+1, 16);       /* Another variant. */
 491   check(strpbrk(one, "efgh") == one+6, 17);     /* And yet another. */
 492 }
 493
 494 void
 495 test_strstr (void)
 496 {
 497   it = "strstr";
 498   check(strstr("abcd", "z") == NULL, 1);        /* Not found. */
 499   check(strstr("abcd", "abx") == NULL, 2);      /* Dead end. */
 500   (void) strcpy(one, "abcd");
 501   check(strstr(one, "c") == one+2, 3);  /* Basic test. */
 502   check(strstr(one, "bc") == one+1, 4); /* Multichar. */
 503   check(strstr(one, "d") == one+3, 5);  /* End of string. */
 504   check(strstr(one, "cd") == one+2, 6); /* Tail of string. */
 505   check(strstr(one, "abc") == one, 7);  /* Beginning. */
 506   check(strstr(one, "abcd") == one, 8); /* Exact match. */
 507   check(strstr(one, "abcde") == NULL, 9);       /* Too long. */
 508   check(strstr(one, "de") == NULL, 10); /* Past end. */
 509   check(strstr(one, "") == one, 11);    /* Finding empty. */
 510   (void) strcpy(one, "ababa");
 511   check(strstr(one, "ba") == one+1, 12);        /* Finding first. */
 512   (void) strcpy(one, "");
 513   check(strstr(one, "b") == NULL, 13);  /* Empty string. */
 514   check(strstr(one, "") == one, 14);    /* Empty in empty string. */
 515   (void) strcpy(one, "bcbca");
 516   check(strstr(one, "bca") == one+2, 15);       /* False start. */
 517   (void) strcpy(one, "bbbcabbca");
 518   check(strstr(one, "bbca") == one+1, 16);      /* With overlap. */
 519 }
 520
 521 void
 522 test_strspn (void)
 523 {
 524   it = "strspn";
 525   check(strspn("abcba", "abc") == 5, 1);        /* Whole string. */
 526   check(strspn("abcba", "ab") == 2, 2); /* Partial. */
 527   check(strspn("abc", "qx") == 0, 3);   /* None. */
 528   check(strspn("", "ab") == 0, 4);      /* Null string. */
 529   check(strspn("abc", "") == 0, 5);     /* Null search list. */
 530 }
 531
 532 void
 533 test_strcspn (void)
 534 {
 535   it = "strcspn";
 536   check(strcspn("abcba", "qx") == 5, 1);        /* Whole string. */
 537   check(strcspn("abcba", "cx") == 2, 2);        /* Partial. */
 538   check(strcspn("abc", "abc") == 0, 3); /* None. */
 539   check(strcspn("", "ab") == 0, 4);     /* Null string. */
 540   check(strcspn("abc", "") == 3, 5);    /* Null search list. */
 541 }
 542
 543 void
 544 test_strtok (void)
 545 {
 546   it = "strtok";
 547   (void) strcpy(one, "first, second, third");
 548   equal(strtok(one, ", "), "first", 1); /* Basic test. */
 549   equal(one, "first", 2);
 550   equal(strtok((char *)NULL, ", "), "second", 3);
 551   equal(strtok((char *)NULL, ", "), "third", 4);
 552   check(strtok((char *)NULL, ", ") == NULL, 5);
 553   (void) strcpy(one, ", first, ");
 554   equal(strtok(one, ", "), "first", 6); /* Extra delims, 1 tok. */
 555   check(strtok((char *)NULL, ", ") == NULL, 7);
 556   (void) strcpy(one, "1a, 1b; 2a, 2b");
 557   equal(strtok(one, ", "), "1a", 8);    /* Changing delim lists. */
 558   equal(strtok((char *)NULL, "; "), "1b", 9);
 559   equal(strtok((char *)NULL, ", "), "2a", 10);
 560   (void) strcpy(two, "x-y");
 561   equal(strtok(two, "-"), "x", 11);     /* New string before done. */
 562   equal(strtok((char *)NULL, "-"), "y", 12);
 563   check(strtok((char *)NULL, "-") == NULL, 13);
 564   (void) strcpy(one, "a,b, c,, ,d");
 565   equal(strtok(one, ", "), "a", 14);    /* Different separators. */
 566   equal(strtok((char *)NULL, ", "), "b", 15);
 567   equal(strtok((char *)NULL, " ,"), "c", 16);   /* Permute list too. */
 568   equal(strtok((char *)NULL, " ,"), "d", 17);
 569   check(strtok((char *)NULL, ", ") == NULL, 18);
 570   check(strtok((char *)NULL, ", ") == NULL, 19);        /* Persistence. */
 571   (void) strcpy(one, ", ");
 572   check(strtok(one, ", ") == NULL, 20); /* No tokens. */
 573   (void) strcpy(one, "");
 574   check(strtok(one, ", ") == NULL, 21); /* Empty string. */
 575   (void) strcpy(one, "abc");
 576   equal(strtok(one, ", "), "abc", 22);  /* No delimiters. */
 577   check(strtok((char *)NULL, ", ") == NULL, 23);
 578   (void) strcpy(one, "abc");
 579   equal(strtok(one, ""), "abc", 24);    /* Empty delimiter list. */
 580   check(strtok((char *)NULL, "") == NULL, 25);
 581   (void) strcpy(one, "abcdefgh");
 582   (void) strcpy(one, "a,b,c");
 583   equal(strtok(one, ","), "a", 26);     /* Basics again... */
 584   equal(strtok((char *)NULL, ","), "b", 27);
 585   equal(strtok((char *)NULL, ","), "c", 28);
 586   check(strtok((char *)NULL, ",") == NULL, 29);
 587   equal(one+6, "gh", 30);                       /* Stomped past end? */
 588   equal(one, "a", 31);                  /* Stomped old tokens? */
 589   equal(one+2, "b", 32);
 590   equal(one+4, "c", 33);
 591 }
 592
 593 void
 594 test_strtok_r (void)
 595 {
 596   it = "strtok_r";
 597   (void) strcpy(one, "first, second, third");
 598   equal(strtok_r(one, ", ", &cp), "first", 1);  /* Basic test. */
 599   equal(one, "first", 2);
 600   equal(strtok_r((char *)NULL, ", ", &cp), "second", 3);
 601   equal(strtok_r((char *)NULL, ", ", &cp), "third", 4);
 602   check(strtok_r((char *)NULL, ", ", &cp) == NULL, 5);
 603   (void) strcpy(one, ", first, ");
 604   equal(strtok_r(one, ", ", &cp), "first", 6);  /* Extra delims, 1 tok. */
 605   check(strtok_r((char *)NULL, ", ", &cp) == NULL, 7);
 606   (void) strcpy(one, "1a, 1b; 2a, 2b");
 607   equal(strtok_r(one, ", ", &cp), "1a", 8);     /* Changing delim lists. */
 608   equal(strtok_r((char *)NULL, "; ", &cp), "1b", 9);
 609   equal(strtok_r((char *)NULL, ", ", &cp), "2a", 10);
 610   (void) strcpy(two, "x-y");
 611   equal(strtok_r(two, "-", &cp), "x", 11);      /* New string before done. */
 612   equal(strtok_r((char *)NULL, "-", &cp), "y", 12);
 613   check(strtok_r((char *)NULL, "-", &cp) == NULL, 13);
 614   (void) strcpy(one, "a,b, c,, ,d");
 615   equal(strtok_r(one, ", ", &cp), "a", 14);     /* Different separators. */
 616   equal(strtok_r((char *)NULL, ", ", &cp), "b", 15);
 617   equal(strtok_r((char *)NULL, " ,", &cp), "c", 16);    /* Permute list too. */
 618   equal(strtok_r((char *)NULL, " ,", &cp), "d", 17);
 619   check(strtok_r((char *)NULL, ", ", &cp) == NULL, 18);
 620   check(strtok_r((char *)NULL, ", ", &cp) == NULL, 19); /* Persistence. */
 621   (void) strcpy(one, ", ");
 622   check(strtok_r(one, ", ", &cp) == NULL, 20);  /* No tokens. */
 623   (void) strcpy(one, "");
 624   check(strtok_r(one, ", ", &cp) == NULL, 21);  /* Empty string. */
 625   (void) strcpy(one, "abc");
 626   equal(strtok_r(one, ", ", &cp), "abc", 22);   /* No delimiters. */
 627   check(strtok_r((char *)NULL, ", ", &cp) == NULL, 23);
 628   (void) strcpy(one, "abc");
 629   equal(strtok_r(one, "", &cp), "abc", 24);     /* Empty delimiter list. */
 630   check(strtok_r((char *)NULL, "", &cp) == NULL, 25);
 631   (void) strcpy(one, "abcdefgh");
 632   (void) strcpy(one, "a,b,c");
 633   equal(strtok_r(one, ",", &cp), "a", 26);      /* Basics again... */
 634   equal(strtok_r((char *)NULL, ",", &cp), "b", 27);
 635   equal(strtok_r((char *)NULL, ",", &cp), "c", 28);
 636   check(strtok_r((char *)NULL, ",", &cp) == NULL, 29);
 637   equal(one+6, "gh", 30);                       /* Stomped past end? */
 638   equal(one, "a", 31);                  /* Stomped old tokens? */
 639   equal(one+2, "b", 32);
 640   equal(one+4, "c", 33);
 641 }
 642
 643 void
 644 test_strsep (void)
 645 {
 646   it = "strsep";
 647   cp = strcpy(one, "first, second, third");
 648   equal(strsep(&cp, ", "), "first", 1); /* Basic test. */
 649   equal(one, "first", 2);
 650   equal(strsep(&cp, ", "), "", 3);
 651   equal(strsep(&cp, ", "), "second", 4);
 652   equal(strsep(&cp, ", "), "", 5);
 653   equal(strsep(&cp, ", "), "third", 6);
 654   check(strsep(&cp, ", ") == NULL, 7);
 655   cp = strcpy(one, ", first, ");
 656   equal(strsep(&cp, ", "), "", 8);
 657   equal(strsep(&cp, ", "), "", 9);
 658   equal(strsep(&cp, ", "), "first", 10);        /* Extra delims, 1 tok. */
 659   equal(strsep(&cp, ", "), "", 11);
 660   equal(strsep(&cp, ", "), "", 12);
 661   check(strsep(&cp, ", ") == NULL, 13);
 662   cp = strcpy(one, "1a, 1b; 2a, 2b");
 663   equal(strsep(&cp, ", "), "1a", 14);   /* Changing delim lists. */
 664   equal(strsep(&cp, ", "), "", 15);
 665   equal(strsep(&cp, "; "), "1b", 16);
 666   equal(strsep(&cp, ", "), "", 17);
 667   equal(strsep(&cp, ", "), "2a", 18);
 668   cp = strcpy(two, "x-y");
 669   equal(strsep(&cp, "-"), "x", 19);     /* New string before done. */
 670   equal(strsep(&cp, "-"), "y", 20);
 671   check(strsep(&cp, "-") == NULL, 21);
 672   cp = strcpy(one, "a,b, c,, ,d ");
 673   equal(strsep(&cp, ", "), "a", 22);    /* Different separators. */
 674   equal(strsep(&cp, ", "), "b", 23);
 675   equal(strsep(&cp, " ,"), "", 24);
 676   equal(strsep(&cp, " ,"), "c", 25);    /* Permute list too. */
 677   equal(strsep(&cp, " ,"), "", 26);
 678   equal(strsep(&cp, " ,"), "", 27);
 679   equal(strsep(&cp, " ,"), "", 28);
 680   equal(strsep(&cp, " ,"), "d", 29);
 681   equal(strsep(&cp, " ,"), "", 30);
 682   check(strsep(&cp, ", ") == NULL, 31);
 683   check(strsep(&cp, ", ") == NULL, 32); /* Persistence. */
 684   cp = strcpy(one, ", ");
 685   equal(strsep(&cp, ", "), "", 33);
 686   equal(strsep(&cp, ", "), "", 34);
 687   equal(strsep(&cp, ", "), "", 35);
 688   check(strsep(&cp, ", ") == NULL, 36); /* No tokens. */
 689   cp = strcpy(one, "");
 690   equal(strsep(&cp, ", "), "", 37);
 691   check(strsep(&cp, ", ") == NULL, 38); /* Empty string. */
 692   cp = strcpy(one, "abc");
 693   equal(strsep(&cp, ", "), "abc", 39);  /* No delimiters. */
 694   check(strsep(&cp, ", ") == NULL, 40);
 695   cp = strcpy(one, "abc");
 696   equal(strsep(&cp, ""), "abc", 41);    /* Empty delimiter list. */
 697   check(strsep(&cp, "") == NULL, 42);
 698   (void) strcpy(one, "abcdefgh");
 699   cp = strcpy(one, "a,b,c");
 700   equal(strsep(&cp, ","), "a", 43);     /* Basics again... */
 701   equal(strsep(&cp, ","), "b", 44);
 702   equal(strsep(&cp, ","), "c", 45);
 703   check(strsep(&cp, ",") == NULL, 46);
 704   equal(one+6, "gh", 47);               /* Stomped past end? */
 705   equal(one, "a", 48);                  /* Stomped old tokens? */
 706   equal(one+2, "b", 49);
 707   equal(one+4, "c", 50);
 708
 709   {
 710     char text[] = "This,is,a,test";
 711     char *list = strdupa (text);
 712     equal (strsep (&list, ","), "This", 51);
 713     equal (strsep (&list, ","), "is", 52);
 714     equal (strsep (&list, ","), "a", 53);
 715     equal (strsep (&list, ","), "test", 54);
 716     check (strsep (&list, ",") == NULL, 55);
 717   }
 718
 719   cp = strcpy(one, "a,b, c,, ,d,");
 720   equal(strsep(&cp, ","), "a", 56);     /* Different separators. */
 721   equal(strsep(&cp, ","), "b", 57);
 722   equal(strsep(&cp, ","), " c", 58);    /* Permute list too. */
 723   equal(strsep(&cp, ","), "", 59);
 724   equal(strsep(&cp, ","), " ", 60);
 725   equal(strsep(&cp, ","), "d", 61);
 726   equal(strsep(&cp, ","), "", 62);
 727   check(strsep(&cp, ",") == NULL, 63);
 728   check(strsep(&cp, ",") == NULL, 64);  /* Persistence. */
 729
 730   cp = strcpy(one, "a,b, c,, ,d,");
 731   equal(strsep(&cp, "xy,"), "a", 65);   /* Different separators. */
 732   equal(strsep(&cp, "x,y"), "b", 66);
 733   equal(strsep(&cp, ",xy"), " c", 67);  /* Permute list too. */
 734   equal(strsep(&cp, "xy,"), "", 68);
 735   equal(strsep(&cp, "x,y"), " ", 69);
 736   equal(strsep(&cp, ",xy"), "d", 70);
 737   equal(strsep(&cp, "xy,"), "", 71);
 738   check(strsep(&cp, "x,y") == NULL, 72);
 739   check(strsep(&cp, ",xy") == NULL, 73);        /* Persistence. */
 740 }
 741
 742 void
 743 test_memcmp (void)
 744 {
 745   it = "memcmp";
 746   check(memcmp("a", "a", 1) == 0, 1);           /* Identity. */
 747   check(memcmp("abc", "abc", 3) == 0, 2);       /* Multicharacter. */
 748   check(memcmp("abcd", "abce", 4) < 0, 3);      /* Honestly unequal. */
 749   check(memcmp("abce", "abcd", 4) > 0, 4);
 750   check(memcmp("alph", "beta", 4) < 0, 5);
 751   check(memcmp("a\203", "a\003", 2) > 0, 6);
 752   check(memcmp("abce", "abcd", 3) == 0, 7);     /* Count limited. */
 753   check(memcmp("abc", "def", 0) == 0, 8);       /* Zero count. */
 754 }
 755
 756 void
 757 test_memchr (void)
 758 {
 759   it = "memchr";
 760   check(memchr("abcd", 'z', 4) == NULL, 1);     /* Not found. */
 761   (void) strcpy(one, "abcd");
 762   check(memchr(one, 'c', 4) == one+2, 2);       /* Basic test. */
 763   check(memchr(one, ~0xff|'c', 4) == one+2, 2); /* ignore highorder bits. */
 764   check(memchr(one, 'd', 4) == one+3, 3);       /* End of string. */
 765   check(memchr(one, 'a', 4) == one, 4); /* Beginning. */
 766   check(memchr(one, '\0', 5) == one+4, 5);      /* Finding NUL. */
 767   (void) strcpy(one, "ababa");
 768   check(memchr(one, 'b', 5) == one+1, 6);       /* Finding first. */
 769   check(memchr(one, 'b', 0) == NULL, 7);        /* Zero count. */
 770   check(memchr(one, 'a', 1) == one, 8); /* Singleton case. */
 771   (void) strcpy(one, "a\203b");
 772   check(memchr(one, 0203, 3) == one+1, 9);      /* Unsignedness. */
 773
 774   /* now test all possible alignment and length combinations to catch
 775      bugs due to unrolled loops (assuming unrolling is limited to no
 776      more than 128 byte chunks: */
 777   {
 778     char buf[128 + sizeof(long)];
 779     long align, len, i, pos;
 780
 781     for (align = 0; align < (long) sizeof(long); ++align) {
 782       for (len = 0; len < (long) (sizeof(buf) - align); ++len) {
 783         for (i = 0; i < len; ++i) {
 784           buf[align + i] = 'x';         /* don't depend on memset... */
 785         }
 786         for (pos = 0; pos < len; ++pos) {
 787 #if 0
 788           printf("align %d, len %d, pos %d\n", align, len, pos);
 789 #endif
 790           check(memchr(buf + align, 'x', len) == buf + align + pos, 10);
 791           check(memchr(buf + align, 'x', pos) == NULL, 11);
 792           buf[align + pos] = '-';
 793         }
 794       }
 795     }
 796   }
 797 }
 798
 799 void
 800 test_memcpy (void)
 801 {
 802   it = "memcpy";
 803   check(memcpy(one, "abc", 4) == one, 1);       /* Returned value. */
 804   equal(one, "abc", 2);                 /* Did the copy go right? */
 805
 806   (void) strcpy(one, "abcdefgh");
 807   (void) memcpy(one+1, "xyz", 2);
 808   equal(one, "axydefgh", 3);            /* Basic test. */
 809
 810   (void) strcpy(one, "abc");
 811   (void) memcpy(one, "xyz", 0);
 812   equal(one, "abc", 4);                 /* Zero-length copy. */
 813
 814   (void) strcpy(one, "hi there");
 815   (void) strcpy(two, "foo");
 816   (void) memcpy(two, one, 9);
 817   equal(two, "hi there", 5);            /* Just paranoia. */
 818   equal(one, "hi there", 6);            /* Stomped on source? */
 819 }
 820
 821 void
 822 test_memmove (void)
 823 {
 824   it = "memmove";
 825   check(memmove(one, "abc", 4) == one, 1);      /* Returned value. */
 826   equal(one, "abc", 2);                 /* Did the copy go right? */
 827
 828   (void) strcpy(one, "abcdefgh");
 829   (void) memmove(one+1, "xyz", 2);
 830   equal(one, "axydefgh", 3);            /* Basic test. */
 831
 832   (void) strcpy(one, "abc");
 833   (void) memmove(one, "xyz", 0);
 834   equal(one, "abc", 4);                 /* Zero-length copy. */
 835
 836   (void) strcpy(one, "hi there");
 837   (void) strcpy(two, "foo");
 838   (void) memmove(two, one, 9);
 839   equal(two, "hi there", 5);            /* Just paranoia. */
 840   equal(one, "hi there", 6);            /* Stomped on source? */
 841
 842   (void) strcpy(one, "abcdefgh");
 843   (void) memmove(one+1, one, 9);
 844   equal(one, "aabcdefgh", 7);           /* Overlap, right-to-left. */
 845
 846   (void) strcpy(one, "abcdefgh");
 847   (void) memmove(one+1, one+2, 7);
 848   equal(one, "acdefgh", 8);             /* Overlap, left-to-right. */
 849
 850   (void) strcpy(one, "abcdefgh");
 851   (void) memmove(one, one, 9);
 852   equal(one, "abcdefgh", 9);            /* 100% overlap. */
 853 }
 854
 855 void
 856 test_memccpy (void)
 857 {
 858   /* First test like memcpy, then the search part The SVID, the only
 859      place where memccpy is mentioned, says overlap might fail, so we
 860      don't try it.  Besides, it's hard to see the rationale for a
 861      non-left-to-right memccpy.  */
 862   it = "memccpy";
 863   check(memccpy(one, "abc", 'q', 4) == NULL, 1);        /* Returned value. */
 864   equal(one, "abc", 2);                 /* Did the copy go right? */
 865
 866   (void) strcpy(one, "abcdefgh");
 867   (void) memccpy(one+1, "xyz", 'q', 2);
 868   equal(one, "axydefgh", 3);            /* Basic test. */
 869
 870   (void) strcpy(one, "abc");
 871   (void) memccpy(one, "xyz", 'q', 0);
 872   equal(one, "abc", 4);                 /* Zero-length copy. */
 873
 874   (void) strcpy(one, "hi there");
 875   (void) strcpy(two, "foo");
 876   (void) memccpy(two, one, 'q', 9);
 877   equal(two, "hi there", 5);            /* Just paranoia. */
 878   equal(one, "hi there", 6);            /* Stomped on source? */
 879
 880   (void) strcpy(one, "abcdefgh");
 881   (void) strcpy(two, "horsefeathers");
 882   check(memccpy(two, one, 'f', 9) == two+6, 7); /* Returned value. */
 883   equal(one, "abcdefgh", 8);            /* Source intact? */
 884   equal(two, "abcdefeathers", 9);               /* Copy correct? */
 885
 886   (void) strcpy(one, "abcd");
 887   (void) strcpy(two, "bumblebee");
 888   check(memccpy(two, one, 'a', 4) == two+1, 10);        /* First char. */
 889   equal(two, "aumblebee", 11);
 890   check(memccpy(two, one, 'd', 4) == two+4, 12);        /* Last char. */
 891   equal(two, "abcdlebee", 13);
 892   (void) strcpy(one, "xyz");
 893   check(memccpy(two, one, 'x', 1) == two+1, 14);        /* Singleton. */
 894   equal(two, "xbcdlebee", 15);
 895 }
 896
 897 void
 898 test_memset (void)
 899 {
 900   it = "memset";
 901   (void) strcpy(one, "abcdefgh");
 902   check(memset(one+1, 'x', 3) == one+1, 1);     /* Return value. */
 903   equal(one, "axxxefgh", 2);            /* Basic test. */
 904
 905   (void) memset(one+2, 'y', 0);
 906   equal(one, "axxxefgh", 3);            /* Zero-length set. */
 907
 908   (void) memset(one+5, 0, 1);
 909   equal(one, "axxxe", 4);                       /* Zero fill. */
 910   equal(one+6, "gh", 5);                        /* And the leftover. */
 911
 912   (void) memset(one+2, 010045, 1);
 913   equal(one, "ax\045xe", 6);            /* Unsigned char convert. */
 914
 915   /* Test for more complex versions of memset, for all alignments and
 916      lengths up to 256. This test takes a little while, perhaps it should
 917      be made weaker? */
 918   {
 919     char data[512];
 920     int i;
 921     int j;
 922     int k;
 923     int c;
 924
 925     for (i = 0; i < 512; i++)
 926       data[i] = 'x';
 927     for (c = 0; c <= 'y'; c += 'y')  /* check for memset(,0,) and
 928                                         memset(,'y',) */
 929       for (j = 0; j < 256; j++)
 930         for (i = 0; i < 256; i++)
 931           {
 932             memset(data+i,c,j);
 933             for (k = 0; k < i; k++)
 934               if (data[k] != 'x')
 935                 goto fail;
 936             for (k = i; k < i+j; k++)
 937               {
 938                 if (data[k] != c)
 939                   goto fail;
 940                 data[k] = 'x';
 941               }
 942             for (k = i+j; k < 512; k++)
 943               if (data[k] != 'x')
 944                 goto fail;
 945             continue;
 946
 947           fail:
 948             check(0,7+i+j*256+(c != 0)*256*256);
 949           }
 950   }
 951 }
 952
 953 void
 954 test_bcopy (void)
 955 {
 956   /* Much like memcpy.  Berklix manual is silent about overlap, so
 957      don't test it.  */
 958   it = "bcopy";
 959   (void) bcopy("abc", one, 4);
 960   equal(one, "abc", 1);                 /* Simple copy. */
 961
 962   (void) strcpy(one, "abcdefgh");
 963   (void) bcopy("xyz", one+1, 2);
 964   equal(one, "axydefgh", 2);            /* Basic test. */
 965
 966   (void) strcpy(one, "abc");
 967   (void) bcopy("xyz", one, 0);
 968   equal(one, "abc", 3);                 /* Zero-length copy. */
 969
 970   (void) strcpy(one, "hi there");
 971   (void) strcpy(two, "foo");
 972   (void) bcopy(one, two, 9);
 973   equal(two, "hi there", 4);            /* Just paranoia. */
 974   equal(one, "hi there", 5);            /* Stomped on source? */
 975 }
 976
 977 void
 978 test_bzero (void)
 979 {
 980   it = "bzero";
 981   (void) strcpy(one, "abcdef");
 982   bzero(one+2, 2);
 983   equal(one, "ab", 1);                  /* Basic test. */
 984   equal(one+3, "", 2);
 985   equal(one+4, "ef", 3);
 986
 987   (void) strcpy(one, "abcdef");
 988   bzero(one+2, 0);
 989   equal(one, "abcdef", 4);              /* Zero-length copy. */
 990 }
 991
 992 void
 993 test_bcmp (void)
 994 {
 995   it = "bcmp";
 996   check(bcmp("a", "a", 1) == 0, 1);     /* Identity. */
 997   check(bcmp("abc", "abc", 3) == 0, 2); /* Multicharacter. */
 998   check(bcmp("abcd", "abce", 4) != 0, 3);       /* Honestly unequal. */
 999   check(bcmp("abce", "abcd", 4) != 0, 4);
1000   check(bcmp("alph", "beta", 4) != 0, 5);
1001   check(bcmp("abce", "abcd", 3) == 0, 6);       /* Count limited. */
1002   check(bcmp("abc", "def", 0) == 0, 8); /* Zero count. */
1003 }
1004
1005 void
1006 test_strerror (void)
1007 {
1008   int f;
1009   it = "strerror";
1010   f = __open("/", O_WRONLY);    /* Should always fail. */
1011   check(f < 0 && errno > 0 && errno < _sys_nerr, 1);
1012   equal(strerror(errno), _sys_errlist[errno], 2);
1013 }
1014
1015 int
1016 main (void)
1017 {
1018   int status;
1019
1020   /* Test strcmp first because we use it to test other things.  */
1021   test_strcmp ();
1022
1023   /* Test strcpy next because we need it to set up other tests.  */
1024   test_strcpy ();
1025
1026   /* A closely related function is stpcpy.  */
1027   test_stpcpy ();
1028
1029   /* stpncpy.  */
1030   test_stpncpy ();
1031
1032   /* strcat.  */
1033   test_strcat ();
1034
1035   /* strncat.  */
1036   test_strncat ();
1037
1038   /* strncmp.  */
1039   test_strncmp ();
1040
1041   /* strncpy.  */
1042   test_strncpy ();
1043
1044   /* strlen.  */
1045   test_strlen ();
1046
1047   /* strchr.  */
1048   test_strchr ();
1049
1050   /* index - just like strchr.  */
1051   test_index ();
1052
1053   /* strrchr.  */
1054   test_strrchr ();
1055
1056   /* rindex - just like strrchr.  */
1057   test_rindex ();
1058
1059   /* strpbrk - somewhat like strchr.  */
1060   test_strpbrk ();
1061
1062   /* strstr - somewhat like strchr.  */
1063   test_strstr ();
1064
1065   /* strspn.  */
1066   test_strspn ();
1067
1068   /* strcspn.  */
1069   test_strcspn ();
1070
1071   /* strtok - the hard one.  */
1072   test_strtok ();
1073
1074   /* strtok_r.  */
1075   test_strtok_r ();
1076
1077   /* strsep.  */
1078   test_strsep ();
1079
1080   /* memcmp.  */
1081   test_memcmp ();
1082
1083   /* memchr.  */
1084   test_memchr ();
1085
1086   /* memcpy - need not work for overlap.  */
1087   test_memcpy ();
1088
1089   /* memmove - must work on overlap.  */
1090   test_memmove ();
1091
1092   /* memccpy.  */
1093   test_memccpy ();
1094
1095   /* memset.  */
1096   test_memset ();
1097
1098   /* bcopy.  */
1099   test_bcopy ();
1100
1101   /* bzero.  */
1102   test_bzero ();
1103
1104   /* bcmp - somewhat like memcmp.  */
1105   test_bcmp ();
1106
1107   /* strerror - VERY system-dependent.  */
1108   test_strerror ();
1109
1110
1111   if (errors == 0)
1112     {
1113       status = EXIT_SUCCESS;
1114       puts("No errors.");
1115     }
1116   else
1117     {
1118       status = EXIT_FAILURE;
1119       printf("%Zd errors.\n", errors);
1120     }
1121   exit(status);
1122 }