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