posix/tst-rxspencer.c

   1 /* Regular expression tests.
   2    Copyright (C) 2003, 2005 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Jakub Jelinek <jakub@redhat.com>, 2003.
   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., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 #include <sys/types.h>
  22 #include <mcheck.h>
  23 #include <regex.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <locale.h>
  28 #include <getopt.h>
  29
  30 static void
  31 replace_special_chars (char *str)
  32 {
  33   for (; (str = strpbrk (str, "NTSZ")) != NULL; ++str)
  34     switch (*str)
  35       {
  36       case 'N': *str = '\n'; break;
  37       case 'T': *str = '\t'; break;
  38       case 'S': *str = ' '; break;
  39       case 'Z': *str = '\0'; break;
  40       }
  41 }
  42
  43 static void
  44 glibc_re_syntax (char *str)
  45 {
  46   char *p, *end = strchr (str, '\0') + 1;
  47
  48   /* Replace [[:<:]] with \< and [[:>:]] with \>.  */
  49   for (p = str; (p = strstr (p, "[[:")) != NULL; )
  50     if ((p[3] == '<' || p[3] == '>') && strncmp (p + 4, ":]]", 3) == 0)
  51       {
  52         p[0] = '\\';
  53         p[1] = p[3];
  54         memmove (p + 2, p + 7, end - p - 7);
  55         end -= 5;
  56         p += 2;
  57       }
  58     else
  59       p += 3;
  60 }
  61
  62 static char *
  63 mb_replace (char *dst, const char c)
  64 {
  65   switch (c)
  66     {
  67     /* Replace a with \'a and A with \'A.  */
  68     case 'a':
  69       *dst++ = '\xc3';
  70       *dst++ = '\xa1';
  71       break;
  72     case 'A':
  73       *dst++ = '\xc3';
  74       *dst++ = '\x81';
  75       break;
  76     /* Replace b with \v{c} and B with \v{C}.  */
  77     case 'b':
  78       *dst++ = '\xc4';
  79       *dst++ = '\x8d';
  80       break;
  81     case 'B':
  82       *dst++ = '\xc4';
  83       *dst++ = '\x8c';
  84       break;
  85     /* Replace c with \v{d} and C with \v{D}.  */
  86     case 'c':
  87       *dst++ = '\xc4';
  88       *dst++ = '\x8f';
  89       break;
  90     case 'C':
  91       *dst++ = '\xc4';
  92       *dst++ = '\x8e';
  93       break;
  94     /* Replace d with \'e and D with \'E.  */
  95     case 'd':
  96       *dst++ = '\xc3';
  97       *dst++ = '\xa9';
  98       break;
  99     case 'D':
 100       *dst++ = '\xc3';
 101       *dst++ = '\x89';
 102       break;
 103     }
 104   return dst;
 105 }
 106
 107 static char *
 108 mb_frob_string (const char *str, const char *letters)
 109 {
 110   char *ret, *dst;
 111   const char *src;
 112
 113   if (str == NULL)
 114     return NULL;
 115
 116   ret = malloc (2 * strlen (str) + 1);
 117   if (ret == NULL)
 118     return NULL;
 119
 120   for (src = str, dst = ret; *src; ++src)
 121     if (strchr (letters, *src))
 122       dst = mb_replace (dst, *src);
 123     else
 124       *dst++ = *src;
 125   *dst = '\0';
 126   return ret;
 127 }
 128
 129 /* Like mb_frob_string, but don't replace anything between
 130    [: and :], [. and .] or [= and =] or characters escaped
 131    with a backslash.  */
 132
 133 static char *
 134 mb_frob_pattern (const char *str, const char *letters)
 135 {
 136   char *ret, *dst;
 137   const char *src;
 138   int in_class = 0, escaped = 0;
 139
 140   if (str == NULL)
 141     return NULL;
 142
 143   ret = malloc (2 * strlen (str) + 1);
 144   if (ret == NULL)
 145     return NULL;
 146
 147   for (src = str, dst = ret; *src; ++src)
 148     if (*src == '\\')
 149       {
 150         escaped ^= 1;
 151         *dst++ = *src;
 152       }
 153     else if (escaped)
 154       {
 155         escaped = 0;
 156         *dst++ = *src;
 157         continue;
 158       }
 159     else if (!in_class && strchr (letters, *src))
 160       dst = mb_replace (dst, *src);
 161     else
 162       {
 163         if (!in_class && *src == '[' && strchr (":.=", src[1]))
 164           in_class = 1;
 165         else if (in_class && *src == ']' && strchr (":.=", src[-1]))
 166           in_class = 0;
 167         *dst++ = *src;
 168       }
 169   *dst = '\0';
 170   return ret;
 171 }
 172
 173 static int
 174 check_match (regmatch_t *rm, int idx, const char *string,
 175              const char *match, const char *fail)
 176 {
 177   if (match[0] == '-' && match[1] == '\0')
 178     {
 179       if (rm[idx].rm_so == -1 && rm[idx].rm_eo == -1)
 180         return 0;
 181       printf ("%s rm[%d] unexpectedly matched\n", fail, idx);
 182       return 1;
 183     }
 184
 185   if (rm[idx].rm_so == -1 || rm[idx].rm_eo == -1)
 186     {
 187       printf ("%s rm[%d] unexpectedly did not match\n", fail, idx);
 188       return 1;
 189     }
 190
 191   if (match[0] == '@')
 192     {
 193       if (rm[idx].rm_so != rm[idx].rm_eo)
 194         {
 195           printf ("%s rm[%d] not empty\n", fail, idx);
 196           return 1;
 197         }
 198
 199       if (strncmp (string + rm[idx].rm_so, match + 1, strlen (match + 1) ?: 1))
 200         {
 201           printf ("%s rm[%d] not matching %s\n", fail, idx, match);
 202           return 1;
 203         }
 204       return 0;
 205     }
 206
 207   if (rm[idx].rm_eo - rm[idx].rm_so != strlen (match)
 208       || strncmp (string + rm[idx].rm_so, match,
 209                   rm[idx].rm_eo - rm[idx].rm_so))
 210     {
 211       printf ("%s rm[%d] not matching %s\n", fail, idx, match);
 212       return 1;
 213     }
 214
 215   return 0;
 216 }
 217
 218 static int
 219 test (const char *pattern, int cflags, const char *string, int eflags,
 220       char *expect, char *matches, const char *fail)
 221 {
 222   regex_t re;
 223   regmatch_t rm[10];
 224   int n, ret = 0;
 225
 226   n = regcomp (&re, pattern, cflags);
 227   if (n != 0)
 228     {
 229       char buf[500];
 230       if (eflags == -1)
 231         {
 232           static struct { reg_errcode_t code; const char *name; } codes []
 233 #define C(x) { REG_##x, #x }
 234             = { C(NOERROR), C(NOMATCH), C(BADPAT), C(ECOLLATE),
 235                 C(ECTYPE), C(EESCAPE), C(ESUBREG), C(EBRACK),
 236                 C(EPAREN), C(EBRACE), C(BADBR), C(ERANGE),
 237                 C(ESPACE), C(BADRPT) };
 238
 239           for (int i = 0; i < sizeof (codes) / sizeof (codes[0]); ++i)
 240             if (n == codes[i].code)
 241               {
 242                 if (strcmp (string, codes[i].name))
 243                   {
 244                     printf ("%s regcomp returned REG_%s (expected REG_%s)\n",
 245                             fail, codes[i].name, string);
 246                     return 1;
 247                   }
 248                 return 0;
 249               }
 250
 251           printf ("%s regcomp return value REG_%d\n", fail, n);
 252           return 1;
 253         }
 254
 255       regerror (n, &re, buf, sizeof (buf));
 256       printf ("%s regcomp failed: %s\n", fail, buf);
 257       return 1;
 258     }
 259
 260   if (eflags == -1)
 261     {
 262       regfree (&re);
 263
 264       /* The test case file assumes something only guaranteed by the
 265          rxspencer regex implementation.  Namely that for empty
 266          expressions regcomp() return REG_EMPTY.  This is not the case
 267          for us and so we ignore this error.  */
 268       if (strcmp (string, "EMPTY") == 0)
 269         return 0;
 270
 271       printf ("%s regcomp unexpectedly succeeded\n", fail);
 272       return 1;
 273     }
 274
 275   if (regexec (&re, string, 10, rm, eflags))
 276     {
 277       regfree (&re);
 278       if (expect == NULL)
 279         return 0;
 280       printf ("%s regexec failed\n", fail);
 281       return 1;
 282     }
 283
 284   regfree (&re);
 285
 286   if (expect == NULL)
 287     {
 288       printf ("%s regexec unexpectedly succeeded\n", fail);
 289       return 1;
 290     }
 291
 292   if (cflags & REG_NOSUB)
 293     return 0;
 294
 295   ret = check_match (rm, 0, string, expect, fail);
 296   if (matches == NULL)
 297     return ret;
 298
 299   for (n = 1; ret == 0 && n < 10; ++n)
 300     {
 301       char *p = NULL;
 302
 303       if (matches)
 304         {
 305           p = strchr (matches, ',');
 306           if (p != NULL)
 307             *p = '\0';
 308         }
 309       ret = check_match (rm, n, string, matches ?: "-", fail);
 310       if (p)
 311         {
 312           *p = ',';
 313           matches = p + 1;
 314         }
 315       else
 316         matches = NULL;
 317     }
 318
 319   return ret;
 320 }
 321
 322 static int
 323 mb_test (const char *pattern, int cflags, const char *string, int eflags,
 324          char *expect, const char *matches, const char *letters,
 325          const char *fail)
 326 {
 327   char *pattern_mb = mb_frob_pattern (pattern, letters);
 328   const char *string_mb
 329     = eflags == -1 ? string : mb_frob_string (string, letters);
 330   char *expect_mb = mb_frob_string (expect, letters);
 331   char *matches_mb = mb_frob_string (matches, letters);
 332   int ret = 0;
 333
 334   if (!pattern_mb || !string_mb
 335       || (expect && !expect_mb) || (matches && !matches_mb))
 336     {
 337       printf ("%s %m", fail);
 338       ret = 1;
 339     }
 340   else
 341     ret = test (pattern_mb, cflags, string_mb, eflags, expect_mb,
 342                 matches_mb, fail);
 343
 344   free (matches_mb);
 345   free (expect_mb);
 346   if (string_mb != string)
 347     free ((char *) string_mb);
 348   free (pattern_mb);
 349   return ret;
 350 }
 351
 352 static int
 353 mb_tests (const char *pattern, int cflags, const char *string, int eflags,
 354           char *expect, const char *matches)
 355 {
 356   int ret = 0;
 357   int i;
 358   char letters[9], fail[20];
 359
 360   /* The tests aren't supposed to work with xdigit, since a-dA-D are
 361      hex digits while \'a \'A \v{c}\v{C}\v{d}\v{D}\'e \'E are not.  */
 362   if (strstr (pattern, "[:xdigit:]"))
 363     return 0;
 364
 365   /* XXX: regex ATM handles only single byte equivalence classes.  */
 366   if (strstr (pattern, "[[=b=]]"))
 367     return 0;
 368
 369   for (i = 1; i < 16; ++i)
 370     {
 371       char *p = letters;
 372       if (i & 1)
 373         {
 374           if (!strchr (pattern, 'a') && !strchr (string, 'a')
 375               && !strchr (pattern, 'A') && !strchr (string, 'A'))
 376             continue;
 377           *p++ = 'a', *p++ = 'A';
 378         }
 379       if (i & 2)
 380         {
 381           if (!strchr (pattern, 'b') && !strchr (string, 'b')
 382               && !strchr (pattern, 'B') && !strchr (string, 'B'))
 383             continue;
 384           *p++ = 'b', *p++ = 'B';
 385         }
 386       if (i & 4)
 387         {
 388           if (!strchr (pattern, 'c') && !strchr (string, 'c')
 389               && !strchr (pattern, 'C') && !strchr (string, 'C'))
 390             continue;
 391           *p++ = 'c', *p++ = 'C';
 392         }
 393       if (i & 8)
 394         {
 395           if (!strchr (pattern, 'd') && !strchr (string, 'd')
 396               && !strchr (pattern, 'D') && !strchr (string, 'D'))
 397             continue;
 398           *p++ = 'd', *p++ = 'D';
 399         }
 400       *p++ = '\0';
 401       sprintf (fail, "UTF-8 %s FAIL", letters);
 402       ret |= mb_test (pattern, cflags, string, eflags, expect, matches,
 403                       letters, fail);
 404     }
 405   return ret;
 406 }
 407
 408 int
 409 main (int argc, char **argv)
 410 {
 411   int ret = 0;
 412   char *line = NULL;
 413   size_t line_len = 0;
 414   ssize_t len;
 415   FILE *f;
 416   static int test_utf8 = 0;
 417   static const struct option options[] =
 418     {
 419       {"utf8",  no_argument,    &test_utf8,     1},
 420       {NULL,    0,              NULL,           0 }
 421     };
 422
 423   mtrace ();
 424
 425   while (getopt_long (argc, argv, "", options, NULL) >= 0);
 426
 427   if (optind + 1 != argc)
 428     {
 429       fprintf (stderr, "Missing test filename\n");
 430       return 1;
 431     }
 432
 433   f = fopen (argv[optind], "r");
 434   if (f == NULL)
 435     {
 436       fprintf (stderr, "Couldn't open %s\n", argv[optind]);
 437       return 1;
 438     }
 439
 440   while ((len = getline (&line, &line_len, f)) > 0)
 441     {
 442       char *pattern, *flagstr, *string, *expect, *matches, *p;
 443       int cflags = REG_EXTENDED, eflags = 0, try_bre_ere = 0;
 444
 445       if (line[len - 1] == '\n')
 446         line[len - 1] = '\0';
 447
 448       /* Skip comments and empty lines.  */
 449       if (*line == '#' || *line == '\0')
 450         continue;
 451
 452       puts (line);
 453       fflush (stdout);
 454
 455       pattern = strtok (line, "\t");
 456       if (pattern == NULL)
 457         continue;
 458
 459       if (strcmp (pattern, "\"\"") == 0)
 460         pattern += 2;
 461
 462       flagstr = strtok (NULL, "\t");
 463       if (flagstr == NULL)
 464         continue;
 465
 466       string = strtok (NULL, "\t");
 467       if (string == NULL)
 468         continue;
 469
 470       if (strcmp (string, "\"\"") == 0)
 471         string += 2;
 472
 473       for (p = flagstr; *p; ++p)
 474         switch (*p)
 475           {
 476           case '-':
 477             break;
 478           case 'b':
 479             cflags &= ~REG_EXTENDED;
 480             break;
 481           case '&':
 482             try_bre_ere = 1;
 483             break;
 484           case 'C':
 485             eflags = -1;
 486             break;
 487           case 'i':
 488             cflags |= REG_ICASE;
 489             break;
 490           case 's':
 491             cflags |= REG_NOSUB;
 492             break;
 493           case 'n':
 494             cflags |= REG_NEWLINE;
 495             break;
 496           case '^':
 497             eflags |= REG_NOTBOL;
 498             break;
 499           case '$':
 500             eflags |= REG_NOTEOL;
 501             break;
 502           case 'm':
 503           case 'p':
 504           case '#':
 505             /* Not supported.  */
 506             flagstr = NULL;
 507             break;
 508           }
 509
 510       if (flagstr == NULL)
 511         continue;
 512
 513       replace_special_chars (pattern);
 514       glibc_re_syntax (pattern);
 515       if (eflags != -1)
 516         replace_special_chars (string);
 517
 518       expect = strtok (NULL, "\t");
 519       matches = NULL;
 520       if (expect != NULL)
 521         {
 522           replace_special_chars (expect);
 523           matches = strtok (NULL, "\t");
 524           if (matches != NULL)
 525             replace_special_chars (matches);
 526         }
 527
 528       if (setlocale (LC_ALL, "C") == NULL)
 529         {
 530           puts ("setlocale C failed");
 531           ret = 1;
 532         }
 533       if (test (pattern, cflags, string, eflags, expect, matches, "FAIL")
 534           || (try_bre_ere
 535               && test (pattern, cflags & ~REG_EXTENDED, string, eflags,
 536                        expect, matches, "FAIL")))
 537         ret = 1;
 538       else if (test_utf8)
 539         {
 540           if (setlocale (LC_ALL, "cs_CZ.UTF-8") == NULL)
 541             {
 542               puts ("setlocale cs_CZ.UTF-8 failed");
 543               ret = 1;
 544             }
 545           else if (test (pattern, cflags, string, eflags, expect, matches,
 546                          "UTF-8 FAIL")
 547                    || (try_bre_ere
 548                        && test (pattern, cflags & ~REG_EXTENDED, string,
 549                                 eflags, expect, matches, "UTF-8 FAIL")))
 550             ret = 1;
 551           else if (mb_tests (pattern, cflags, string, eflags, expect, matches)
 552                    || (try_bre_ere
 553                        && mb_tests (pattern, cflags & ~REG_EXTENDED, string,
 554                                     eflags, expect, matches)))
 555             ret = 1;
 556         }
 557     }
 558
 559   free (line);
 560   fclose (f);
 561   return ret;
 562 }