contrib/netbsd-tests/lib/libc/regex/t_regex_att.c

   1 /*      $NetBSD: t_regex_att.c,v 1.1 2012/08/24 20:24:40 jmmv Exp $     */
   2
   3 /*-
   4  * Copyright (c) 2011 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Christos Zoulas.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. All advertising materials mentioning features or use of this software
  19  *    must display the following acknowledgement:
  20  *        This product includes software developed by the NetBSD
  21  *        Foundation, Inc. and its contributors.
  22  * 4. Neither the name of The NetBSD Foundation nor the names of its
  23  *    contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  36  * POSSIBILITY OF SUCH DAMAGE.
  37  */
  38
  39 #include <sys/cdefs.h>
  40 __RCSID("$NetBSD: t_regex_att.c,v 1.1 2012/08/24 20:24:40 jmmv Exp $");
  41
  42 #include <sys/param.h>
  43
  44 #include <stdio.h>
  45 #include <regex.h>
  46 #include <string.h>
  47 #include <stdlib.h>
  48 #include <vis.h>
  49 #include <ctype.h>
  50 #include <atf-c.h>
  51 #ifdef __FreeBSD__
  52 #include <libutil.h>
  53 #endif
  54
  55 static const char sep[] = "\r\n\t";
  56 static const char delim[3] = "\\\\\0";
  57
  58
  59 static void
  60 fail(const char *pattern, const char *input, size_t lineno) {
  61         fprintf(stderr,
  62             "skipping failed test at line %zu (pattern=%s, input=%s)\n",
  63             lineno, pattern, input);
  64 }
  65
  66 static int
  67 bug(const char *pattern, const char *input, size_t lineno) {
  68         static const struct {
  69                 const char *p;
  70                 const char *i;
  71         } b[] = {
  72 #if defined(REGEX_SPENCER)
  73                 /*
  74                  * The default libc implementation by Henry Spencer
  75                  */
  76                 { "a[-]?c", "ac" },                     // basic.dat
  77                 { "(a*)*", "a" },                       // categorization.dat
  78                 { "(aba|a*b)*", "ababa" },              // categorization.dat
  79                 { "\\(a\\(b\\)*\\)*\\2", "abab" },      // categorization.dat
  80                 { "(a*)*", "aaaaaa" },                  // nullsubexpression.dat
  81                 { "(a*)*", "aaaaaax" },                 // nullsubexpression.dat
  82                 { "(a*)+", "a" },                       // nullsubexpression.dat
  83                 { "(a*)+", "aaaaaa" },                  // nullsubexpression.dat
  84                 { "(a*)+", "aaaaaax" },                 // nullsubexpression.dat
  85                 { "([a]*)*", "a" },                     // nullsubexpression.dat
  86                 { "([a]*)*", "aaaaaa" },                // nullsubexpression.dat
  87                 { "([a]*)*", "aaaaaax" },               // nullsubexpression.dat
  88                 { "([a]*)+", "a" },                     // nullsubexpression.dat
  89                 { "([a]*)+", "aaaaaa" },                // nullsubexpression.dat
  90                 { "([a]*)+", "aaaaaax" },               // nullsubexpression.dat
  91                 { "([^b]*)*", "a" },                    // nullsubexpression.dat
  92                 { "([^b]*)*", "aaaaaa" },               // nullsubexpression.dat
  93                 { "([^b]*)*", "aaaaaab" },              // nullsubexpression.dat
  94                 { "([ab]*)*", "a" },                    // nullsubexpression.dat
  95                 { "([ab]*)*", "aaaaaa" },               // nullsubexpression.dat
  96                 { "([ab]*)*", "ababab" },               // nullsubexpression.dat
  97                 { "([ab]*)*", "bababa" },               // nullsubexpression.dat
  98                 { "([ab]*)*", "b" },                    // nullsubexpression.dat
  99                 { "([ab]*)*", "bbbbbb" },               // nullsubexpression.dat
 100                 { "([ab]*)*", "aaaabcde" },             // nullsubexpression.dat
 101                 { "([^a]*)*", "b" },                    // nullsubexpression.dat
 102                 { "([^a]*)*", "bbbbbb" },               // nullsubexpression.dat
 103                 { "([^ab]*)*", "ccccxx" },              // nullsubexpression.dat
 104                 { "\\(a*\\)*\\(x\\)", "ax" },           // nullsubexpression.dat
 105                 { "\\(a*\\)*\\(x\\)", "axa" },          // nullsubexpression.dat
 106                 { "\\(a*\\)*\\(x\\)\\(\\1\\)", "x" },   // nullsubexpression.dat
 107 /* crash! */    { "\\(a*\\)*\\(x\\)\\(\\1\\)", "ax" },  // nullsubexpression.dat
 108 /* crash! */    { "\\(a*\\)*\\(x\\)\\(\\1\\)\\(x\\)", "axxa" }, // ""
 109                 { "(a*)*(x)",  "ax" },                  // nullsubexpression.dat
 110                 { "(a*)*(x)",  "axa" },                 // nullsubexpression.dat
 111                 { "(a*)+(x)",  "ax" },                  // nullsubexpression.dat
 112                 { "(a*)+(x)",  "axa" },                 // nullsubexpression.dat
 113                 { "((a|ab)(c|bcd))(d*)", "abcd" },      // forcedassoc.dat
 114                 { "((a|ab)(bcd|c))(d*)", "abcd" },      // forcedassoc.dat
 115                 { "((ab|a)(c|bcd))(d*)", "abcd" },      // forcedassoc.dat
 116                 { "((ab|a)(bcd|c))(d*)", "abcd" },      // forcedassoc.dat
 117                 { "((a*)(b|abc))(c*)", "abc" },         // forcedassoc.dat
 118                 { "((a*)(abc|b))(c*)", "abc" },         // forcedassoc.dat
 119                 { "((..)|(.)){2}", "aaa" },             // repetition.dat
 120                 { "((..)|(.)){3}", "aaa" },             // repetition.dat
 121                 { "((..)|(.)){3}", "aaaa" },            // repetition.dat
 122                 { "((..)|(.)){3}", "aaaaa" },           // repetition.dat
 123                 { "X(.?){0,}Y", "X1234567Y" },          // repetition.dat
 124                 { "X(.?){1,}Y", "X1234567Y" },          // repetition.dat
 125                 { "X(.?){2,}Y", "X1234567Y" },          // repetition.dat
 126                 { "X(.?){3,}Y", "X1234567Y" },          // repetition.dat
 127                 { "X(.?){4,}Y", "X1234567Y" },          // repetition.dat
 128                 { "X(.?){5,}Y", "X1234567Y" },          // repetition.dat
 129                 { "X(.?){6,}Y", "X1234567Y" },          // repetition.dat
 130                 { "X(.?){7,}Y", "X1234567Y" },          // repetition.dat
 131                 { "X(.?){0,8}Y", "X1234567Y" },         // repetition.dat
 132                 { "X(.?){1,8}Y", "X1234567Y" },         // repetition.dat
 133                 { "X(.?){2,8}Y", "X1234567Y" },         // repetition.dat
 134                 { "X(.?){3,8}Y", "X1234567Y" },         // repetition.dat
 135                 { "X(.?){4,8}Y", "X1234567Y" },         // repetition.dat
 136                 { "X(.?){5,8}Y", "X1234567Y" },         // repetition.dat
 137                 { "X(.?){6,8}Y", "X1234567Y" },         // repetition.dat
 138                 { "X(.?){7,8}Y", "X1234567Y" },         // repetition.dat
 139                 { "(a|ab|c|bcd){0,}(d*)", "ababcd" },   // repetition.dat
 140                 { "(a|ab|c|bcd){1,}(d*)", "ababcd" },   // repetition.dat
 141                 { "(a|ab|c|bcd){2,}(d*)", "ababcd" },   // repetition.dat
 142                 { "(a|ab|c|bcd){3,}(d*)", "ababcd" },   // repetition.dat
 143                 { "(a|ab|c|bcd){1,10}(d*)", "ababcd" }, // repetition.dat
 144                 { "(a|ab|c|bcd){2,10}(d*)", "ababcd" }, // repetition.dat
 145                 { "(a|ab|c|bcd){3,10}(d*)", "ababcd" }, // repetition.dat
 146                 { "(a|ab|c|bcd)*(d*)", "ababcd" },      // repetition.dat
 147                 { "(a|ab|c|bcd)+(d*)", "ababcd" },      // repetition.dat
 148                 { "(ab|a|c|bcd){0,}(d*)", "ababcd" },   // repetition.dat
 149                 { "(ab|a|c|bcd){1,}(d*)", "ababcd" },   // repetition.dat
 150                 { "(ab|a|c|bcd){2,}(d*)", "ababcd" },   // repetition.dat
 151                 { "(ab|a|c|bcd){3,}(d*)", "ababcd" },   // repetition.dat
 152                 { "(ab|a|c|bcd){1,10}(d*)", "ababcd" }, // repetition.dat
 153                 { "(ab|a|c|bcd){2,10}(d*)", "ababcd" }, // repetition.dat
 154                 { "(ab|a|c|bcd){3,10}(d*)", "ababcd" }, // repetition.dat
 155                 { "(ab|a|c|bcd)*(d*)", "ababcd" },      // repetition.dat
 156                 { "(ab|a|c|bcd)+(d*)", "ababcd" },      // repetition.dat
 157 #elif defined(REGEX_TRE)
 158                 { "a[-]?c", "ac" },                     // basic.dat
 159                 { "a\\(b\\)*\\1", "a" },                // categorization.dat
 160                 { "a\\(b\\)*\\1", "abab" },             // categorization.dat
 161                 { "\\(a\\(b\\)*\\)*\\2", "abab" },      // categorization.dat
 162                 { "\\(a*\\)*\\(x\\)\\(\\1\\)", "ax" },  // categorization.dat
 163                 { "\\(a*\\)*\\(x\\)\\(\\1\\)\\(x\\)", "axxa" }, // ""
 164                 { "((..)|(.))*", "aa" },                // repetition.dat
 165                 { "((..)|(.))*", "aaa" },               // repetition.dat
 166                 { "((..)|(.))*", "aaaaa" },             // repetition.dat
 167                 { "X(.?){7,}Y", "X1234567Y" },          // repetition.dat
 168 #else
 169                 { "", "" }
 170 #endif
 171         };
 172
 173         for (size_t i = 0; i < __arraycount(b); i++) {
 174                 if (strcmp(pattern, b[i].p) == 0 &&
 175                     strcmp(input, b[i].i) == 0) {
 176                         fail(pattern, input, lineno);
 177                         return 1;
 178                 }
 179         }
 180         return 0;
 181 }
 182
 183 #ifdef REGEX_SPENCER
 184 #define HAVE_BRACES     1
 185 #define HAVE_MINIMAL    0
 186 #endif
 187 #ifndef HAVE_BRACES
 188 #define HAVE_BRACES     1
 189 #endif
 190 #ifndef HAVE_MINIMAL
 191 #define HAVE_MINIMAL    1
 192 #endif
 193
 194 static int
 195 optional(const char *s)
 196 {
 197         static const struct{
 198                 const char *n;
 199                 int v;
 200         } nv[]= {
 201                 { "[[<element>]] not supported", HAVE_BRACES },
 202                 { "no *? +? mimimal match ops", HAVE_MINIMAL },
 203         };
 204
 205         for (size_t i = 0; i < __arraycount(nv); i++)
 206                 if (strcmp(nv[i].n, s) == 0) {
 207                         if (nv[i].v)
 208                                 return 0;
 209                         fprintf(stderr, "skipping unsupported [%s] tests\n", s);
 210                         return 1;
 211                 }
 212
 213         ATF_REQUIRE_MSG(0, "Unknown feature: %s", s);
 214         return 0;
 215 }
 216
 217 static int
 218 unsupported(const char *s)
 219 {
 220         static const char *we[] = {
 221 #if defined(REGEX_SPENCER)
 222                 "ASSOCIATIVITY=left",           // have right associativity
 223                 "SUBEXPRESSION=precedence",     // have grouping subexpression
 224                 "REPEAT_LONGEST=last",          // have first repeat longest
 225                 "BUG=alternation-order",        // don't have it
 226                 "BUG=first-match",              // don't have it
 227                 "BUG=nomatch-match",            // don't have it
 228                 "BUG=repeat-any",               // don't have it
 229                 "BUG=range-null",               // don't have it
 230                 "BUG=repeat-null-unknown",      // don't have it
 231                 "BUG=repeat-null",              // don't have it
 232                 "BUG=repeat-artifact",          // don't have it
 233                 "BUG=subexpression-first",      // don't have it
 234 #elif defined(REGEX_TRE)
 235                 "ASSOCIATIVITY=right",          // have left associativity
 236                 "SUBEXPRESSION=grouping",       // have precedence subexpression
 237                 "REPEAT_LONGEST=first",         // have last repeat longest
 238                 "LENGTH=first",                 // have last length
 239                 "BUG=alternation-order",        // don't have it
 240                 "BUG=first-match",              // don't have it
 241                 "BUG=range-null",               // don't have it
 242                 "BUG=repeat-null",              // don't have it
 243                 "BUG=repeat-artifact",          // don't have it
 244                 "BUG=subexpression-first",      // don't have it
 245                 "BUG=repeat-short",             // don't have it
 246 #endif
 247         };
 248
 249         if (s == NULL)
 250                 return 0;
 251
 252         while (*s == '#' || isspace((unsigned char)*s))
 253                 s++;
 254
 255         for (size_t i = 0; i < __arraycount(we); i++)
 256                 if (strcmp(we[i], s) == 0)
 257                         return 1;
 258         return 0;
 259 }
 260
 261 static void
 262 geterror(const char *s, int *comp, int *exec)
 263 {
 264         static const struct {
 265                 const char *n;
 266                 int v;
 267                 int ce;
 268         } nv[] = {
 269 #define COMP 1
 270 #define EXEC 2
 271                 { "OK", 0, COMP|EXEC },
 272 #define _DO(a, b)       { # a, REG_ ## a, b },
 273                 _DO(NOMATCH, EXEC)
 274                 _DO(BADPAT, COMP)
 275                 _DO(ECOLLATE, COMP)
 276                 _DO(ECTYPE, COMP)
 277                 _DO(EESCAPE, COMP)
 278                 _DO(ESUBREG, COMP)
 279                 _DO(EBRACK, COMP)
 280                 _DO(EPAREN, COMP)
 281                 _DO(EBRACE, COMP)
 282                 _DO(BADBR, COMP)
 283                 _DO(ERANGE, COMP)
 284                 _DO(ESPACE, EXEC)
 285                 _DO(BADRPT, COMP)
 286                 _DO(EMPTY, COMP)
 287                 _DO(ASSERT, COMP)
 288                 _DO(INVARG, COMP)
 289                 _DO(ENOSYS, COMP)
 290 #undef _DO
 291         };
 292         *comp = 0;
 293         *exec = 0;
 294         for (size_t i = 0; i < __arraycount(nv); i++)
 295                 if (strcmp(s, nv[i].n) == 0) {
 296                         if (nv[i].ce & COMP)
 297                                 *comp = nv[i].v;
 298                         if (nv[i].ce & EXEC)
 299                                 *exec = nv[i].v;
 300                         return;
 301                 }
 302         ATF_REQUIRE_MSG(0, "Unknown error %s", s);
 303         return;
 304 }
 305
 306 static int
 307 getflags(char *s)
 308 {
 309         int flags = 0;
 310
 311         for (;; s++)
 312                 switch (*s) {
 313                 case '0': case '1': case '2': case '3': case '4':
 314                 case '5': case '6': case '7': case '8': case '9':
 315                         *s = '\0';
 316                         break;
 317                 case '\0':
 318                         return flags;
 319                 case 'B':
 320                 case 'E':
 321                 case 'F':
 322                 case 'L':
 323                         break;
 324                 case 'i':
 325                         flags |= REG_ICASE;
 326                         *s = '\0';
 327                         break;
 328                 case '$':
 329                         *s = '\0';
 330                         break;
 331                 case 'n':
 332                         *s = '\0';
 333                         break;
 334                 default:
 335                         ATF_REQUIRE_MSG(0, "Unknown char %c", *s);
 336                         break;
 337                 }
 338 }
 339
 340 static size_t
 341 getmatches(const char *s)
 342 {
 343         size_t i;
 344         char *q;
 345         for (i = 0; (q = strchr(s, '(')) != NULL; i++, s = q + 1)
 346                 continue;
 347         ATF_REQUIRE_MSG(i != 0, "No parentheses found");
 348         return i;
 349 }
 350
 351 static void
 352 checkcomment(const char *s, size_t lineno)
 353 {
 354         if (s && strstr(s, "BUG") != NULL)
 355                 fprintf(stderr, "Expected %s at line %zu\n", s, lineno);
 356 }
 357
 358 static void
 359 checkmatches(const char *matches, size_t nm, const regmatch_t *pm,
 360     size_t lineno)
 361 {
 362         if (nm == 0)
 363                 return;
 364
 365         char *res;
 366         size_t len = strlen(matches) + 1, off = 0;
 367
 368         ATF_REQUIRE((res = strdup(matches)) != NULL);
 369         for (size_t i = 0; i < nm; i++) {
 370                 int l;
 371                 if (pm[i].rm_so == -1 && pm[i].rm_eo == -1)
 372                         l = snprintf(res + off, len - off, "(?,?)");
 373                 else
 374                         l = snprintf(res + off, len - off, "(%lld,%lld)",
 375                             (long long)pm[i].rm_so, (long long)pm[i].rm_eo);
 376                 ATF_REQUIRE_MSG((size_t) l < len - off, "String too long %s"
 377                     " cur=%d, max=%zu", res, l, len - off);
 378                 off += l;
 379         }
 380 #ifdef __FreeBSD__
 381         ATF_CHECK_STREQ_MSG(res, matches, " at line %zu", lineno);
 382 #else
 383         ATF_REQUIRE_STREQ_MSG(res, matches, " at line %zu", lineno);
 384 #endif
 385         free(res);
 386 }
 387
 388 static void
 389 att_test(const struct atf_tc *tc, const char *data_name)
 390 {
 391         regex_t re;
 392         char *line, *lastpattern = NULL, data_path[MAXPATHLEN];
 393         size_t len, lineno = 0;
 394         int skipping = 0;
 395         FILE *input_file;
 396
 397         snprintf(data_path, sizeof(data_path), "%s/data/%s.dat",
 398             atf_tc_get_config_var(tc, "srcdir"), data_name);
 399
 400         input_file = fopen(data_path, "r");
 401         if (input_file == NULL)
 402                 atf_tc_fail("Failed to open input file %s", data_path);
 403
 404         for (; (line = fparseln(input_file, &len, &lineno, delim, 0))
 405             != NULL; free(line)) {
 406                 char *name, *pattern, *input, *matches, *comment;
 407                 regmatch_t *pm;
 408                 size_t nm;
 409 #ifdef DEBUG
 410                 fprintf(stderr, "[%s]\n", line);
 411 #endif
 412                 if ((name = strtok(line, sep)) == NULL)
 413                         continue;
 414
 415                 /*
 416                  * We check these early so that we skip the lines quickly
 417                  * in order to do more strict testing on the other arguments
 418                  * The same characters are also tested in the switch below
 419                  */
 420                 if (*name == '}') {
 421                         skipping = 0;
 422                         continue;
 423                 }
 424                 if (skipping)
 425                         continue;
 426                 if (*name == ';' || *name == '#' || strcmp(name, "NOTE") == 0)
 427                         continue;
 428                 if (*name == ':') {
 429                         /* Skip ":HA#???:" prefix */
 430                         while (*++name && *name != ':')
 431                                 continue;
 432                         if (*name)
 433                                 name++;
 434                 }
 435
 436                 ATF_REQUIRE_MSG((pattern = strtok(NULL, sep)) != NULL,
 437                         "Missing pattern at line %zu", lineno);
 438                 ATF_REQUIRE_MSG((input = strtok(NULL, sep)) != NULL,
 439                         "Missing input at line %zu", lineno);
 440
 441                 if (strchr(name, '$')) {
 442                         ATF_REQUIRE(strunvis(pattern, pattern) != -1);
 443                         ATF_REQUIRE(strunvis(input, input) != -1);
 444                 }
 445
 446
 447                 if (strcmp(input, "NULL") == 0)
 448                         *input = '\0';
 449
 450                 if (strcmp(pattern, "SAME") == 0) {
 451                         ATF_REQUIRE(lastpattern != NULL);
 452                         pattern = lastpattern;
 453                 } else {
 454                         free(lastpattern);
 455                         ATF_REQUIRE((lastpattern = strdup(pattern)) != NULL);
 456                 }
 457
 458                 ATF_REQUIRE_MSG((matches = strtok(NULL, sep)) != NULL,
 459                     "Missing matches at line %zu", lineno);
 460
 461                 comment = strtok(NULL, sep);
 462                 switch (*name) {
 463                 case '{':       /* Begin optional implementation */
 464                         if (optional(comment)) {
 465                                 skipping++;
 466                                 continue;
 467                         }
 468                         name++; /* We have it, so ignore */
 469                         break;
 470                 case '}':       /* End optional implementation */
 471                         skipping = 0;
 472                         continue;
 473                 case '?':       /* Optional */
 474                 case '|':       /* Alternative */
 475                         if (unsupported(comment))
 476                                 continue;
 477                         name++; /* We have it, so ignore */
 478                         break;
 479                 case '#':       /* Comment */
 480                 case ';':       /* Skip */
 481                         continue;
 482                 default:
 483                         break;
 484                 }
 485
 486                 /* XXX: Our bug */
 487                 if (bug(pattern, input, lineno))
 488                         continue;
 489
 490                 int comp, exec;
 491                 if (*matches != '(') {
 492                         geterror(matches, &comp, &exec);
 493                         pm = NULL;
 494                         nm = 0;
 495                 } else {
 496                         comp = exec = 0;
 497                         nm = getmatches(matches);
 498                         ATF_REQUIRE((pm = calloc(nm, sizeof(*pm))) != NULL);
 499                 }
 500
 501
 502
 503                 int iflags = getflags(name);
 504                 for (; *name; name++) {
 505                         int flags;
 506                         switch (*name) {
 507                         case 'B':
 508                                 flags = REG_BASIC;
 509                                 break;
 510                         case 'E':
 511                                 flags = REG_EXTENDED;
 512                                 break;
 513                         case 'L':
 514                                 flags = REG_NOSPEC;
 515                                 break;
 516                         default:
 517                                 ATF_REQUIRE_MSG(0, "Bad name %c", *name);
 518                                 continue;
 519                         }
 520                         int c = regcomp(&re, pattern, flags | iflags);
 521                         ATF_REQUIRE_MSG(c == comp,
 522                             "regcomp returned %d for pattern %s at line %zu",
 523                             c, pattern, lineno);
 524                         if (c)
 525                                 continue;
 526                         int e = regexec(&re, input, nm, pm, 0);
 527                         ATF_REQUIRE_MSG(e == exec, "Expected error %d,"
 528                             " got %d at line %zu", exec, e, lineno);
 529                         checkmatches(matches, nm, pm, lineno);
 530                         checkcomment(comment, lineno);
 531                         regfree(&re);
 532                 }
 533                 free(pm);
 534         }
 535
 536         fclose(input_file);
 537 }
 538
 539 ATF_TC(basic);
 540 ATF_TC_HEAD(basic, tc)
 541 {
 542         atf_tc_set_md_var(tc, "descr", "Tests basic functionality");
 543 }
 544 ATF_TC_BODY(basic, tc)
 545 {
 546         att_test(tc, "basic");
 547 }
 548
 549 ATF_TC(categorization);
 550 ATF_TC_HEAD(categorization, tc)
 551 {
 552         atf_tc_set_md_var(tc, "descr", "Tests implementation categorization");
 553 }
 554 ATF_TC_BODY(categorization, tc)
 555 {
 556         att_test(tc, "categorization");
 557 }
 558
 559 ATF_TC(nullsubexpr);
 560 ATF_TC_HEAD(nullsubexpr, tc)
 561 {
 562         atf_tc_set_md_var(tc, "descr", "Tests (...)*");
 563 }
 564 ATF_TC_BODY(nullsubexpr, tc)
 565 {
 566         att_test(tc, "nullsubexpr");
 567 }
 568
 569 ATF_TC(leftassoc);
 570 ATF_TC_HEAD(leftassoc, tc)
 571 {
 572         atf_tc_set_md_var(tc, "descr", "Tests left-associative "
 573             "implementations");
 574 }
 575 ATF_TC_BODY(leftassoc, tc)
 576 {
 577 #if SKIP_LEFTASSOC
 578         /* jmmv: I converted the original shell-based tests to C and they
 579          * disabled this test in a very unconventional way without giving
 580          * any explation.  Mark as broken here, but I don't know why. */
 581         atf_tc_expect_fail("Reason for breakage unknown");
 582 #endif
 583 #ifdef __FreeBSD__
 584         atf_tc_expect_fail("The expected and matched groups are mismatched on FreeBSD");
 585 #endif
 586         att_test(tc, "leftassoc");
 587 }
 588
 589 ATF_TC(rightassoc);
 590 ATF_TC_HEAD(rightassoc, tc)
 591 {
 592         atf_tc_set_md_var(tc, "descr", "Tests right-associative "
 593             "implementations");
 594 }
 595 ATF_TC_BODY(rightassoc, tc)
 596 {
 597 #if SKIP_RIGHTASSOC
 598         /* jmmv: I converted the original shell-based tests to C and they
 599          * disabled this test in a very unconventional way without giving
 600          * any explation.  Mark as broken here, but I don't know why. */
 601         atf_tc_expect_fail("Reason for breakage unknown");
 602 #endif
 603         att_test(tc, "rightassoc");
 604 }
 605
 606 ATF_TC(forcedassoc);
 607 ATF_TC_HEAD(forcedassoc, tc)
 608 {
 609         atf_tc_set_md_var(tc, "descr", "Tests subexpression grouping to "
 610             "force association");
 611 }
 612 ATF_TC_BODY(forcedassoc, tc)
 613 {
 614         att_test(tc, "forcedassoc");
 615 }
 616
 617 ATF_TC(repetition);
 618 ATF_TC_HEAD(repetition, tc)
 619 {
 620         atf_tc_set_md_var(tc, "descr", "Tests implicit vs. explicit "
 621             "repetition");
 622 }
 623 ATF_TC_BODY(repetition, tc)
 624 {
 625         att_test(tc, "repetition");
 626 }
 627
 628 ATF_TP_ADD_TCS(tp)
 629 {
 630
 631         ATF_TP_ADD_TC(tp, basic);
 632         ATF_TP_ADD_TC(tp, categorization);
 633         ATF_TP_ADD_TC(tp, nullsubexpr);
 634         ATF_TP_ADD_TC(tp, leftassoc);
 635         ATF_TP_ADD_TC(tp, rightassoc);
 636         ATF_TP_ADD_TC(tp, forcedassoc);
 637         ATF_TP_ADD_TC(tp, repetition);
 638         return atf_no_error();
 639 }