1 #pragma prototyped noticed 2 3 /* 4 * regex(3) test harness 5 * 6 * build: cc -o testregex testregex.c 7 * help: testregex --man 8 * note: REG_* features are detected by #ifdef; if REG_* are enums 9 * then supply #define REG_foo REG_foo for each enum REG_foo 10 * 11 * Glenn Fowler <glenn.s.fowler@gmail.com> 12 * AT&T Research 13 * 14 * PLEASE: publish your tests so everyone can benefit 15 * 16 * The following license covers testregex.c and all associated test data. 17 * 18 * Permission is hereby granted, free of charge, to any person obtaining a 19 * copy of THIS SOFTWARE FILE (the "Software"), to deal in the Software 20 * without restriction, including without limitation the rights to use, 21 * copy, modify, merge, publish, distribute, and/or sell copies of the 22 * Software, and to permit persons to whom the Software is furnished to do 23 * so, subject to the following disclaimer: 24 * 25 * THIS SOFTWARE IS PROVIDED BY AT&T ``AS IS'' AND ANY EXPRESS OR IMPLIED 26 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 27 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 28 * IN NO EVENT SHALL AT&T BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 35 */ 36 37 static const char id[] = "\n@(#)$Id: testregex (AT&T Research) 2010-06-10 $\0\n"; 38 39 #if _PACKAGE_ast 40 #include <ast.h> 41 #else 42 #include <sys/types.h> 43 #endif 44 45 #include <stdio.h> 46 #include <regex.h> 47 #include <ctype.h> 48 #include <setjmp.h> 49 #include <signal.h> 50 #include <string.h> 51 #include <unistd.h> 52 53 #ifdef __STDC__ 54 #include <stdlib.h> 55 #include <locale.h> 56 #endif 57 58 #ifndef RE_DUP_MAX 59 #define RE_DUP_MAX 32767 60 #endif 61 62 #if !_PACKAGE_ast 63 #undef REG_DISCIPLINE 64 #endif 65 66 #ifndef REG_DELIMITED 67 #undef _REG_subcomp 68 #endif 69 70 #define TEST_ARE 0x00000001 71 #define TEST_BRE 0x00000002 72 #define TEST_ERE 0x00000004 73 #define TEST_KRE 0x00000008 74 #define TEST_LRE 0x00000010 75 #define TEST_SRE 0x00000020 76 77 #define TEST_EXPAND 0x00000100 78 #define TEST_LENIENT 0x00000200 79 80 #define TEST_QUERY 0x00000400 81 #define TEST_SUB 0x00000800 82 #define TEST_UNSPECIFIED 0x00001000 83 #define TEST_VERIFY 0x00002000 84 #define TEST_AND 0x00004000 85 #define TEST_OR 0x00008000 86 87 #define TEST_DELIMIT 0x00010000 88 #define TEST_OK 0x00020000 89 #define TEST_SAME 0x00040000 90 91 #define TEST_ACTUAL 0x00100000 92 #define TEST_BASELINE 0x00200000 93 #define TEST_FAIL 0x00400000 94 #define TEST_PASS 0x00800000 95 #define TEST_SUMMARY 0x01000000 96 97 #define TEST_IGNORE_ERROR 0x02000000 98 #define TEST_IGNORE_OVER 0x04000000 99 #define TEST_IGNORE_POSITION 0x08000000 100 101 #define TEST_CATCH 0x10000000 102 #define TEST_VERBOSE 0x20000000 103 104 #define TEST_DECOMP 0x40000000 105 106 #define TEST_GLOBAL (TEST_ACTUAL|TEST_AND|TEST_BASELINE|TEST_CATCH|TEST_FAIL|TEST_IGNORE_ERROR|TEST_IGNORE_OVER|TEST_IGNORE_POSITION|TEST_OR|TEST_PASS|TEST_SUMMARY|TEST_VERBOSE) 107 108 #ifdef REG_DISCIPLINE 109 110 111 #include <stk.h> 112 113 typedef struct Disc_s 114 { 115 regdisc_t disc; 116 int ordinal; 117 Sfio_t* sp; 118 } Disc_t; 119 120 static void* 121 compf(const regex_t* re, const char* xstr, size_t xlen, regdisc_t* disc) 122 { 123 Disc_t* dp = (Disc_t*)disc; 124 125 return (void*)((char*)0 + ++dp->ordinal); 126 } 127 128 static int 129 execf(const regex_t* re, void* data, const char* xstr, size_t xlen, const char* sstr, size_t slen, char** snxt, regdisc_t* disc) 130 { 131 Disc_t* dp = (Disc_t*)disc; 132 133 sfprintf(dp->sp, "{%-.*s}(%lu:%d)", xlen, xstr, (char*)data - (char*)0, slen); 134 return atoi(xstr); 135 } 136 137 static void* 138 resizef(void* handle, void* data, size_t size) 139 { 140 if (!size) 141 return 0; 142 return stkalloc((Sfio_t*)handle, size); 143 } 144 145 #endif 146 147 #ifndef NiL 148 #ifdef __STDC__ 149 #define NiL 0 150 #else 151 #define NiL (char*)0 152 #endif 153 #endif 154 155 #define H(x) do{if(html)fprintf(stderr,x);}while(0) 156 #define T(x) fprintf(stderr,x) 157 158 static void 159 help(int html) 160 { 161 H("<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML//EN\">\n"); 162 H("<HTML>\n"); 163 H("<HEAD>\n"); 164 H("<TITLE>testregex man document</TITLE>\n"); 165 H("</HEAD>\n"); 166 H("<BODY bgcolor=white>\n"); 167 H("<PRE>\n"); 168 T("NAME\n"); 169 T(" testregex - regex(3) test harness\n"); 170 T("\n"); 171 T("SYNOPSIS\n"); 172 T(" testregex [ options ]\n"); 173 T("\n"); 174 T("DESCRIPTION\n"); 175 T(" testregex reads regex(3) test specifications, one per line, from the\n"); 176 T(" standard input and writes one output line for each failed test. A\n"); 177 T(" summary line is written after all tests are done. Each successful\n"); 178 T(" test is run again with REG_NOSUB. Unsupported features are noted\n"); 179 T(" before the first test, and tests requiring these features are\n"); 180 T(" silently ignored.\n"); 181 T("\n"); 182 T("OPTIONS\n"); 183 T(" -c catch signals and non-terminating calls\n"); 184 T(" -e ignore error return mismatches\n"); 185 T(" -h list help on standard error\n"); 186 T(" -n do not repeat successful tests with regnexec()\n"); 187 T(" -o ignore match[] overrun errors\n"); 188 T(" -p ignore negative position mismatches\n"); 189 T(" -s use stack instead of malloc\n"); 190 T(" -x do not repeat successful tests with REG_NOSUB\n"); 191 T(" -v list each test line\n"); 192 T(" -A list failed test lines with actual answers\n"); 193 T(" -B list all test lines with actual answers\n"); 194 T(" -F list failed test lines\n"); 195 T(" -P list passed test lines\n"); 196 T(" -S output one summary line\n"); 197 T("\n"); 198 T("INPUT FORMAT\n"); 199 T(" Input lines may be blank, a comment beginning with #, or a test\n"); 200 T(" specification. A specification is five fields separated by one\n"); 201 T(" or more tabs. NULL denotes the empty string and NIL denotes the\n"); 202 T(" 0 pointer.\n"); 203 T("\n"); 204 T(" Field 1: the regex(3) flags to apply, one character per REG_feature\n"); 205 T(" flag. The test is skipped if REG_feature is not supported by the\n"); 206 T(" implementation. If the first character is not [BEASKLP] then the\n"); 207 T(" specification is a global control line. One or more of [BEASKLP] may be\n"); 208 T(" specified; the test will be repeated for each mode.\n"); 209 T("\n"); 210 T(" B basic BRE (grep, ed, sed)\n"); 211 T(" E REG_EXTENDED ERE (egrep)\n"); 212 T(" A REG_AUGMENTED ARE (egrep with negation)\n"); 213 T(" S REG_SHELL SRE (sh glob)\n"); 214 T(" K REG_SHELL|REG_AUGMENTED KRE (ksh glob)\n"); 215 T(" L REG_LITERAL LRE (fgrep)\n"); 216 T("\n"); 217 T(" a REG_LEFT|REG_RIGHT implicit ^...$\n"); 218 T(" b REG_NOTBOL lhs does not match ^\n"); 219 T(" c REG_COMMENT ignore space and #...\\n\n"); 220 T(" d REG_SHELL_DOT explicit leading . match\n"); 221 T(" e REG_NOTEOL rhs does not match $\n"); 222 T(" f REG_MULTIPLE multiple \\n separated patterns\n"); 223 T(" g FNM_LEADING_DIR testfnmatch only -- match until /\n"); 224 T(" h REG_MULTIREF multiple digit backref\n"); 225 T(" i REG_ICASE ignore case\n"); 226 T(" j REG_SPAN . matches \\n\n"); 227 T(" k REG_ESCAPE \\ to ecape [...] delimiter\n"); 228 T(" l REG_LEFT implicit ^...\n"); 229 T(" m REG_MINIMAL minimal match\n"); 230 T(" n REG_NEWLINE explicit \\n match\n"); 231 T(" o REG_ENCLOSED (|&) magic inside [@|&](...)\n"); 232 T(" p REG_SHELL_PATH explicit / match\n"); 233 T(" q REG_DELIMITED delimited pattern\n"); 234 T(" r REG_RIGHT implicit ...$\n"); 235 T(" s REG_SHELL_ESCAPED \\ not special\n"); 236 T(" t REG_MUSTDELIM all delimiters must be specified\n"); 237 T(" u standard unspecified behavior -- errors not counted\n"); 238 T(" v REG_CLASS_ESCAPE \\ special inside [...]\n"); 239 T(" w REG_NOSUB no subexpression match array\n"); 240 T(" x REG_LENIENT let some errors slide\n"); 241 T(" y REG_LEFT regexec() implicit ^...\n"); 242 T(" z REG_NULL NULL subexpressions ok\n"); 243 T(" $ expand C \\c escapes in fields 2 and 3\n"); 244 T(" / field 2 is a regsubcomp() expression\n"); 245 T(" = field 3 is a regdecomp() expression\n"); 246 T("\n"); 247 T(" Field 1 control lines:\n"); 248 T("\n"); 249 T(" C set LC_COLLATE and LC_CTYPE to locale in field 2\n"); 250 T("\n"); 251 T(" ?test ... output field 5 if passed and != EXPECTED, silent otherwise\n"); 252 T(" &test ... output field 5 if current and previous passed\n"); 253 T(" |test ... output field 5 if current passed and previous failed\n"); 254 T(" ; ... output field 2 if previous failed\n"); 255 T(" {test ... skip if failed until }\n"); 256 T(" } end of skip\n"); 257 T("\n"); 258 T(" : comment comment copied as output NOTE\n"); 259 T(" :comment:test :comment: ignored\n"); 260 T(" N[OTE] comment comment copied as output NOTE\n"); 261 T(" T[EST] comment comment\n"); 262 T("\n"); 263 T(" number use number for nmatch (20 by default)\n"); 264 T("\n"); 265 T(" Field 2: the regular expression pattern; SAME uses the pattern from\n"); 266 T(" the previous specification. RE_DUP_MAX inside {...} expands to the\n"); 267 T(" value from <limits.h>.\n"); 268 T("\n"); 269 T(" Field 3: the string to match. X...{RE_DUP_MAX} expands to RE_DUP_MAX\n"); 270 T(" copies of X.\n"); 271 T("\n"); 272 T(" Field 4: the test outcome. This is either one of the posix error\n"); 273 T(" codes (with REG_ omitted) or the match array, a list of (m,n)\n"); 274 T(" entries with m and n being first and last+1 positions in the\n"); 275 T(" field 3 string, or NULL if REG_NOSUB is in effect and success\n"); 276 T(" is expected. BADPAT is acceptable in place of any regcomp(3)\n"); 277 T(" error code. The match[] array is initialized to (-2,-2) before\n"); 278 T(" each test. All array elements from 0 to nmatch-1 must be specified\n"); 279 T(" in the outcome. Unspecified endpoints (offset -1) are denoted by ?.\n"); 280 T(" Unset endpoints (offset -2) are denoted by X. {x}(o:n) denotes a\n"); 281 T(" matched (?{...}) expression, where x is the text enclosed by {...},\n"); 282 T(" o is the expression ordinal counting from 1, and n is the length of\n"); 283 T(" the unmatched portion of the subject string. If x starts with a\n"); 284 T(" number then that is the return value of re_execf(), otherwise 0 is\n"); 285 T(" returned. RE_DUP_MAX[-+]N expands to the <limits.h> value -+N.\n"); 286 T("\n"); 287 T(" Field 5: optional comment appended to the report.\n"); 288 T("\n"); 289 T("CAVEAT\n"); 290 T(" If a regex implementation misbehaves with memory then all bets are off.\n"); 291 T("\n"); 292 T("CONTRIBUTORS\n"); 293 T(" Glenn Fowler glenn.s.fowler@gmail.com (ksh strmatch, regex extensions)\n"); 294 T(" David Korn dgkorn@gmail.com (ksh glob matcher)\n"); 295 T(" Doug McIlroy mcilroy@dartmouth.edu (ast regex/testre in C++)\n"); 296 T(" Tom Lord lord@regexps.com (rx tests)\n"); 297 T(" Henry Spencer henry@zoo.toronto.edu (original public regex)\n"); 298 T(" Andrew Hume andrew@research.att.com (gre tests)\n"); 299 T(" John Maddock John_Maddock@compuserve.com (regex++ tests)\n"); 300 T(" Philip Hazel ph10@cam.ac.uk (pcre tests)\n"); 301 T(" Ville Laurikari vl@iki.fi (libtre tests)\n"); 302 H("</PRE>\n"); 303 H("</BODY>\n"); 304 H("</HTML>\n"); 305 } 306 307 #ifndef elementsof 308 #define elementsof(x) (sizeof(x)/sizeof(x[0])) 309 #endif 310 311 #ifndef streq 312 #define streq(a,b) (*(a)==*(b)&&!strcmp(a,b)) 313 #endif 314 315 #define HUNG 2 316 #define NOTEST (~0) 317 318 #ifndef REG_TEST_DEFAULT 319 #define REG_TEST_DEFAULT 0 320 #endif 321 322 #ifndef REG_EXEC_DEFAULT 323 #define REG_EXEC_DEFAULT 0 324 #endif 325 326 static const char* unsupported[] = 327 { 328 "BASIC", 329 #ifndef REG_EXTENDED 330 "EXTENDED", 331 #endif 332 #ifndef REG_AUGMENTED 333 "AUGMENTED", 334 #endif 335 #ifndef REG_SHELL 336 "SHELL", 337 #endif 338 339 #ifndef REG_CLASS_ESCAPE 340 "CLASS_ESCAPE", 341 #endif 342 #ifndef REG_COMMENT 343 "COMMENT", 344 #endif 345 #ifndef REG_DELIMITED 346 "DELIMITED", 347 #endif 348 #ifndef REG_DISCIPLINE 349 "DISCIPLINE", 350 #endif 351 #ifndef REG_ESCAPE 352 "ESCAPE", 353 #endif 354 #ifndef REG_ICASE 355 "ICASE", 356 #endif 357 #ifndef REG_LEFT 358 "LEFT", 359 #endif 360 #ifndef REG_LENIENT 361 "LENIENT", 362 #endif 363 #ifndef REG_LITERAL 364 "LITERAL", 365 #endif 366 #ifndef REG_MINIMAL 367 "MINIMAL", 368 #endif 369 #ifndef REG_MULTIPLE 370 "MULTIPLE", 371 #endif 372 #ifndef REG_MULTIREF 373 "MULTIREF", 374 #endif 375 #ifndef REG_MUSTDELIM 376 "MUSTDELIM", 377 #endif 378 #ifndef REG_NEWLINE 379 "NEWLINE", 380 #endif 381 #ifndef REG_NOTBOL 382 "NOTBOL", 383 #endif 384 #ifndef REG_NOTEOL 385 "NOTEOL", 386 #endif 387 #ifndef REG_NULL 388 "NULL", 389 #endif 390 #ifndef REG_RIGHT 391 "RIGHT", 392 #endif 393 #ifndef REG_SHELL_DOT 394 "SHELL_DOT", 395 #endif 396 #ifndef REG_SHELL_ESCAPED 397 "SHELL_ESCAPED", 398 #endif 399 #ifndef REG_SHELL_GROUP 400 "SHELL_GROUP", 401 #endif 402 #ifndef REG_SHELL_PATH 403 "SHELL_PATH", 404 #endif 405 #ifndef REG_SPAN 406 "SPAN", 407 #endif 408 #if REG_NOSUB & REG_TEST_DEFAULT 409 "SUBMATCH", 410 #endif 411 #if !_REG_nexec 412 "regnexec", 413 #endif 414 #if !_REG_subcomp 415 "regsubcomp", 416 #endif 417 #if !_REG_decomp 418 "redecomp", 419 #endif 420 0 421 }; 422 423 #ifndef REG_CLASS_ESCAPE 424 #define REG_CLASS_ESCAPE NOTEST 425 #endif 426 #ifndef REG_COMMENT 427 #define REG_COMMENT NOTEST 428 #endif 429 #ifndef REG_DELIMITED 430 #define REG_DELIMITED NOTEST 431 #endif 432 #ifndef REG_ESCAPE 433 #define REG_ESCAPE NOTEST 434 #endif 435 #ifndef REG_ICASE 436 #define REG_ICASE NOTEST 437 #endif 438 #ifndef REG_LEFT 439 #define REG_LEFT NOTEST 440 #endif 441 #ifndef REG_LENIENT 442 #define REG_LENIENT 0 443 #endif 444 #ifndef REG_MINIMAL 445 #define REG_MINIMAL NOTEST 446 #endif 447 #ifndef REG_MULTIPLE 448 #define REG_MULTIPLE NOTEST 449 #endif 450 #ifndef REG_MULTIREF 451 #define REG_MULTIREF NOTEST 452 #endif 453 #ifndef REG_MUSTDELIM 454 #define REG_MUSTDELIM NOTEST 455 #endif 456 #ifndef REG_NEWLINE 457 #define REG_NEWLINE NOTEST 458 #endif 459 #ifndef REG_NOTBOL 460 #define REG_NOTBOL NOTEST 461 #endif 462 #ifndef REG_NOTEOL 463 #define REG_NOTEOL NOTEST 464 #endif 465 #ifndef REG_NULL 466 #define REG_NULL NOTEST 467 #endif 468 #ifndef REG_RIGHT 469 #define REG_RIGHT NOTEST 470 #endif 471 #ifndef REG_SHELL_DOT 472 #define REG_SHELL_DOT NOTEST 473 #endif 474 #ifndef REG_SHELL_ESCAPED 475 #define REG_SHELL_ESCAPED NOTEST 476 #endif 477 #ifndef REG_SHELL_GROUP 478 #define REG_SHELL_GROUP NOTEST 479 #endif 480 #ifndef REG_SHELL_PATH 481 #define REG_SHELL_PATH NOTEST 482 #endif 483 #ifndef REG_SPAN 484 #define REG_SPAN NOTEST 485 #endif 486 487 #define REG_UNKNOWN (-1) 488 489 #ifndef REG_ENEWLINE 490 #define REG_ENEWLINE (REG_UNKNOWN-1) 491 #endif 492 #ifndef REG_ENULL 493 #ifndef REG_EMPTY 494 #define REG_ENULL (REG_UNKNOWN-2) 495 #else 496 #define REG_ENULL REG_EMPTY 497 #endif 498 #endif 499 #ifndef REG_ECOUNT 500 #define REG_ECOUNT (REG_UNKNOWN-3) 501 #endif 502 #ifndef REG_BADESC 503 #define REG_BADESC (REG_UNKNOWN-4) 504 #endif 505 #ifndef REG_EMEM 506 #define REG_EMEM (REG_UNKNOWN-5) 507 #endif 508 #ifndef REG_EHUNG 509 #define REG_EHUNG (REG_UNKNOWN-6) 510 #endif 511 #ifndef REG_EBUS 512 #define REG_EBUS (REG_UNKNOWN-7) 513 #endif 514 #ifndef REG_EFAULT 515 #define REG_EFAULT (REG_UNKNOWN-8) 516 #endif 517 #ifndef REG_EFLAGS 518 #define REG_EFLAGS (REG_UNKNOWN-9) 519 #endif 520 #ifndef REG_EDELIM 521 #define REG_EDELIM (REG_UNKNOWN-9) 522 #endif 523 524 static const struct { int code; char* name; } codes[] = 525 { 526 REG_UNKNOWN, "UNKNOWN", 527 REG_NOMATCH, "NOMATCH", 528 REG_BADPAT, "BADPAT", 529 REG_ECOLLATE, "ECOLLATE", 530 REG_ECTYPE, "ECTYPE", 531 REG_EESCAPE, "EESCAPE", 532 REG_ESUBREG, "ESUBREG", 533 REG_EBRACK, "EBRACK", 534 REG_EPAREN, "EPAREN", 535 REG_EBRACE, "EBRACE", 536 REG_BADBR, "BADBR", 537 REG_ERANGE, "ERANGE", 538 REG_ESPACE, "ESPACE", 539 REG_BADRPT, "BADRPT", 540 REG_ENEWLINE, "ENEWLINE", 541 REG_ENULL, "ENULL", 542 REG_ECOUNT, "ECOUNT", 543 REG_BADESC, "BADESC", 544 REG_EMEM, "EMEM", 545 REG_EHUNG, "EHUNG", 546 REG_EBUS, "EBUS", 547 REG_EFAULT, "EFAULT", 548 REG_EFLAGS, "EFLAGS", 549 REG_EDELIM, "EDELIM", 550 }; 551 552 static struct 553 { 554 regmatch_t NOMATCH; 555 int errors; 556 int extracted; 557 int ignored; 558 int lineno; 559 int passed; 560 int signals; 561 int unspecified; 562 int verify; 563 int warnings; 564 char* file; 565 char* stack; 566 char* which; 567 jmp_buf gotcha; 568 #ifdef REG_DISCIPLINE 569 Disc_t disc; 570 #endif 571 } state; 572 573 static void 574 quote(char* s, int len, unsigned long test) 575 { 576 unsigned char* u = (unsigned char*)s; 577 unsigned char* e; 578 int c; 579 #ifdef MB_CUR_MAX 580 int w; 581 #endif 582 583 if (!u) 584 printf("NIL"); 585 else if (!*u && len <= 1) 586 printf("NULL"); 587 else if (test & TEST_EXPAND) 588 { 589 if (len < 0) 590 len = strlen((char*)u); 591 e = u + len; 592 if (test & TEST_DELIMIT) 593 printf("\""); 594 while (u < e) 595 switch (c = *u++) 596 { 597 case '\\': 598 printf("\\\\"); 599 break; 600 case '"': 601 if (test & TEST_DELIMIT) 602 printf("\\\""); 603 else 604 printf("\""); 605 break; 606 case '\a': 607 printf("\\a"); 608 break; 609 case '\b': 610 printf("\\b"); 611 break; 612 case 033: 613 printf("\\e"); 614 break; 615 case '\f': 616 printf("\\f"); 617 break; 618 case '\n': 619 printf("\\n"); 620 break; 621 case '\r': 622 printf("\\r"); 623 break; 624 case '\t': 625 printf("\\t"); 626 break; 627 case '\v': 628 printf("\\v"); 629 break; 630 default: 631 #ifdef MB_CUR_MAX 632 s = (char*)u - 1; 633 if ((w = mblen(s, (char*)e - s)) > 1) 634 { 635 u += w - 1; 636 fwrite(s, 1, w, stdout); 637 } 638 else 639 #endif 640 if (!iscntrl(c) && isprint(c)) 641 putchar(c); 642 else 643 printf("\\x%02x", c); 644 break; 645 } 646 if (test & TEST_DELIMIT) 647 printf("\""); 648 } 649 else 650 printf("%s", s); 651 } 652 653 static void 654 report(char* comment, char* fun, char* re, char* s, int len, char* msg, int flags, unsigned long test) 655 { 656 if (state.file) 657 printf("%s:", state.file); 658 printf("%d:", state.lineno); 659 if (re) 660 { 661 printf(" "); 662 quote(re, -1, test|TEST_DELIMIT); 663 if (s) 664 { 665 printf(" versus "); 666 quote(s, len, test|TEST_DELIMIT); 667 } 668 } 669 if (test & TEST_UNSPECIFIED) 670 { 671 state.unspecified++; 672 printf(" unspecified behavior"); 673 } 674 else 675 state.errors++; 676 if (state.which) 677 printf(" %s", state.which); 678 if (flags & REG_NOSUB) 679 printf(" NOSUB"); 680 if (fun) 681 printf(" %s", fun); 682 if (comment[strlen(comment)-1] == '\n') 683 printf(" %s", comment); 684 else 685 { 686 printf(" %s: ", comment); 687 if (msg) 688 printf("%s: ", msg); 689 } 690 } 691 692 static void 693 error(regex_t* preg, int code) 694 { 695 char* msg; 696 char buf[256]; 697 698 switch (code) 699 { 700 case REG_EBUS: 701 msg = "bus error"; 702 break; 703 case REG_EFAULT: 704 msg = "memory fault"; 705 break; 706 case REG_EHUNG: 707 msg = "did not terminate"; 708 break; 709 default: 710 regerror(code, preg, msg = buf, sizeof buf); 711 break; 712 } 713 printf("%s\n", msg); 714 } 715 716 static void 717 bad(char* comment, char* re, char* s, int len, unsigned long test) 718 { 719 printf("bad test case "); 720 report(comment, NiL, re, s, len, NiL, 0, test); 721 exit(1); 722 } 723 724 static int 725 escape(char* s) 726 { 727 char* b; 728 char* t; 729 char* q; 730 char* e; 731 int c; 732 733 for (b = t = s; *t = *s; s++, t++) 734 if (*s == '\\') 735 switch (*++s) 736 { 737 case '\\': 738 break; 739 case 'a': 740 *t = '\a'; 741 break; 742 case 'b': 743 *t = '\b'; 744 break; 745 case 'c': 746 if (*t = *++s) 747 *t &= 037; 748 else 749 s--; 750 break; 751 case 'e': 752 case 'E': 753 *t = 033; 754 break; 755 case 'f': 756 *t = '\f'; 757 break; 758 case 'n': 759 *t = '\n'; 760 break; 761 case 'r': 762 *t = '\r'; 763 break; 764 case 's': 765 *t = ' '; 766 break; 767 case 't': 768 *t = '\t'; 769 break; 770 case 'v': 771 *t = '\v'; 772 break; 773 case 'u': 774 case 'x': 775 c = 0; 776 q = c == 'u' ? (s + 5) : (char*)0; 777 e = s + 1; 778 while (!e || !q || s < q) 779 { 780 switch (*++s) 781 { 782 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': 783 c = (c << 4) + *s - 'a' + 10; 784 continue; 785 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': 786 c = (c << 4) + *s - 'A' + 10; 787 continue; 788 case '0': case '1': case '2': case '3': case '4': 789 case '5': case '6': case '7': case '8': case '9': 790 c = (c << 4) + *s - '0'; 791 continue; 792 case '{': 793 case '[': 794 if (s != e) 795 { 796 s--; 797 break; 798 } 799 e = 0; 800 continue; 801 case '}': 802 case ']': 803 if (e) 804 s--; 805 break; 806 default: 807 s--; 808 break; 809 } 810 break; 811 } 812 *t = c; 813 break; 814 case '0': case '1': case '2': case '3': 815 case '4': case '5': case '6': case '7': 816 c = *s - '0'; 817 q = s + 2; 818 while (s < q) 819 { 820 switch (*++s) 821 { 822 case '0': case '1': case '2': case '3': 823 case '4': case '5': case '6': case '7': 824 c = (c << 3) + *s - '0'; 825 break; 826 default: 827 q = --s; 828 break; 829 } 830 } 831 *t = c; 832 break; 833 default: 834 *(s + 1) = 0; 835 bad("invalid C \\ escape\n", s - 1, NiL, 0, 0); 836 } 837 return t - b; 838 } 839 840 static void 841 matchoffprint(int off) 842 { 843 switch (off) 844 { 845 case -2: 846 printf("X"); 847 break; 848 case -1: 849 printf("?"); 850 break; 851 default: 852 printf("%d", off); 853 break; 854 } 855 } 856 857 static void 858 matchprint(regmatch_t* match, int nmatch, int nsub, char* ans, unsigned long test) 859 { 860 int i; 861 862 for (; nmatch > nsub + 1; nmatch--) 863 if ((match[nmatch-1].rm_so != -1 || match[nmatch-1].rm_eo != -1) && (!(test & TEST_IGNORE_POSITION) || match[nmatch-1].rm_so >= 0 && match[nmatch-1].rm_eo >= 0)) 864 break; 865 for (i = 0; i < nmatch; i++) 866 { 867 printf("("); 868 matchoffprint(match[i].rm_so); 869 printf(","); 870 matchoffprint(match[i].rm_eo); 871 printf(")"); 872 } 873 if (!(test & (TEST_ACTUAL|TEST_BASELINE))) 874 { 875 if (ans) 876 printf(" expected: %s", ans); 877 printf("\n"); 878 } 879 } 880 881 static int 882 matchcheck(regmatch_t* match, int nmatch, int nsub, char* ans, char* re, char* s, int len, int flags, unsigned long test) 883 { 884 char* p; 885 int i; 886 int m; 887 int n; 888 889 if (streq(ans, "OK")) 890 return test & (TEST_BASELINE|TEST_PASS|TEST_VERIFY); 891 for (i = 0, p = ans; i < nmatch && *p; i++) 892 { 893 if (*p == '{') 894 { 895 #ifdef REG_DISCIPLINE 896 char* x; 897 898 if (!(x = sfstruse(state.disc.sp))) 899 bad("out of space [discipline string]\n", NiL, NiL, 0, 0); 900 if (strcmp(p, x)) 901 { 902 if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY)) 903 return 0; 904 report("callout failed", NiL, re, s, len, NiL, flags, test); 905 quote(p, -1, test); 906 printf(" expected, "); 907 quote(x, -1, test); 908 printf(" returned\n"); 909 } 910 #endif 911 break; 912 } 913 if (*p++ != '(') 914 bad("improper answer\n", re, s, -1, test); 915 if (*p == '?') 916 { 917 m = -1; 918 p++; 919 } 920 else if (*p == 'R' && !memcmp(p, "RE_DUP_MAX", 10)) 921 { 922 m = RE_DUP_MAX; 923 p += 10; 924 if (*p == '+' || *p == '-') 925 m += strtol(p, &p, 10); 926 } 927 else 928 m = strtol(p, &p, 10); 929 if (*p++ != ',') 930 bad("improper answer\n", re, s, -1, test); 931 if (*p == '?') 932 { 933 n = -1; 934 p++; 935 } 936 else if (*p == 'R' && !memcmp(p, "RE_DUP_MAX", 10)) 937 { 938 n = RE_DUP_MAX; 939 p += 10; 940 if (*p == '+' || *p == '-') 941 n += strtol(p, &p, 10); 942 } 943 else 944 n = strtol(p, &p, 10); 945 if (*p++ != ')') 946 bad("improper answer\n", re, s, -1, test); 947 if (m!=match[i].rm_so || n!=match[i].rm_eo) 948 { 949 if (!(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY))) 950 { 951 report("failed: match was", NiL, re, s, len, NiL, flags, test); 952 matchprint(match, nmatch, nsub, ans, test); 953 } 954 return 0; 955 } 956 } 957 for (; i < nmatch; i++) 958 { 959 if (match[i].rm_so!=-1 || match[i].rm_eo!=-1) 960 { 961 if (!(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_VERIFY))) 962 { 963 if ((test & TEST_IGNORE_POSITION) && (match[i].rm_so<0 || match[i].rm_eo<0)) 964 { 965 state.ignored++; 966 return 0; 967 } 968 if (!(test & TEST_SUMMARY)) 969 { 970 report("failed: match was", NiL, re, s, len, NiL, flags, test); 971 matchprint(match, nmatch, nsub, ans, test); 972 } 973 } 974 return 0; 975 } 976 } 977 if (!(test & TEST_IGNORE_OVER) && match[nmatch].rm_so != state.NOMATCH.rm_so) 978 { 979 if (!(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY))) 980 { 981 report("failed: overran match array", NiL, re, s, len, NiL, flags, test); 982 matchprint(match, nmatch + 1, nsub, NiL, test); 983 } 984 return 0; 985 } 986 return 1; 987 } 988 989 static void 990 sigunblock(int s) 991 { 992 #ifdef SIG_SETMASK 993 int op; 994 sigset_t mask; 995 996 sigemptyset(&mask); 997 if (s) 998 { 999 sigaddset(&mask, s); 1000 op = SIG_UNBLOCK; 1001 } 1002 else op = SIG_SETMASK; 1003 sigprocmask(op, &mask, NiL); 1004 #else 1005 #ifdef sigmask 1006 sigsetmask(s ? (sigsetmask(0L) & ~sigmask(s)) : 0L); 1007 #endif 1008 #endif 1009 } 1010 1011 static void 1012 gotcha(int sig) 1013 { 1014 int ret; 1015 1016 signal(sig, gotcha); 1017 alarm(0); 1018 state.signals++; 1019 switch (sig) 1020 { 1021 case SIGALRM: 1022 ret = REG_EHUNG; 1023 break; 1024 case SIGBUS: 1025 ret = REG_EBUS; 1026 break; 1027 default: 1028 ret = REG_EFAULT; 1029 break; 1030 } 1031 sigunblock(sig); 1032 longjmp(state.gotcha, ret); 1033 } 1034 1035 static char* 1036 get_line(FILE* fp) 1037 { 1038 static char buf[32 * 1024]; 1039 1040 register char* s = buf; 1041 register char* e = &buf[sizeof(buf)]; 1042 register char* b; 1043 1044 for (;;) 1045 { 1046 if (!(b = fgets(s, e - s, fp))) 1047 return 0; 1048 state.lineno++; 1049 s += strlen(s); 1050 if (s == b || *--s != '\n' || s == b || *(s - 1) != '\\') 1051 { 1052 *s = 0; 1053 break; 1054 } 1055 s--; 1056 } 1057 return buf; 1058 } 1059 1060 static unsigned long 1061 note(unsigned long level, char* msg, unsigned long skip, unsigned long test) 1062 { 1063 if (!(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_SUMMARY)) && !skip) 1064 { 1065 printf("NOTE\t"); 1066 if (msg) 1067 printf("%s: ", msg); 1068 printf("skipping lines %d", state.lineno); 1069 } 1070 return skip | level; 1071 } 1072 1073 #define TABS(n) &ts[7-((n)&7)] 1074 1075 static char ts[] = "\t\t\t\t\t\t\t"; 1076 1077 static unsigned long 1078 extract(int* tabs, char* spec, char* re, char* s, char* ans, char* msg, char* accept, regmatch_t* match, int nmatch, int nsub, unsigned long skip, unsigned long level, unsigned long test) 1079 { 1080 if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_OK|TEST_PASS|TEST_SUMMARY)) 1081 { 1082 state.extracted = 1; 1083 if (test & TEST_OK) 1084 { 1085 state.passed++; 1086 if ((test & TEST_VERIFY) && !(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_SUMMARY))) 1087 { 1088 if (msg && strcmp(msg, "EXPECTED")) 1089 printf("NOTE\t%s\n", msg); 1090 return skip; 1091 } 1092 test &= ~(TEST_PASS|TEST_QUERY); 1093 } 1094 if (test & (TEST_QUERY|TEST_VERIFY)) 1095 { 1096 if (test & TEST_BASELINE) 1097 test &= ~(TEST_BASELINE|TEST_PASS); 1098 else 1099 test |= TEST_PASS; 1100 skip |= level; 1101 } 1102 if (!(test & TEST_OK)) 1103 { 1104 if (test & TEST_UNSPECIFIED) 1105 state.unspecified++; 1106 else 1107 state.errors++; 1108 } 1109 if (test & (TEST_PASS|TEST_SUMMARY)) 1110 return skip; 1111 test &= ~TEST_DELIMIT; 1112 printf("%s%s", spec, TABS(*tabs++)); 1113 if ((test & (TEST_BASELINE|TEST_SAME)) == (TEST_BASELINE|TEST_SAME)) 1114 printf("SAME"); 1115 else 1116 quote(re, -1, test); 1117 printf("%s", TABS(*tabs++)); 1118 quote(s, -1, test); 1119 printf("%s", TABS(*tabs++)); 1120 if (!(test & (TEST_ACTUAL|TEST_BASELINE)) || !accept && !match) 1121 printf("%s", ans); 1122 else if (accept) 1123 printf("%s", accept); 1124 else 1125 matchprint(match, nmatch, nsub, NiL, test); 1126 if (msg) 1127 printf("%s%s", TABS(*tabs++), msg); 1128 putchar('\n'); 1129 } 1130 else if (test & TEST_QUERY) 1131 skip = note(level, msg, skip, test); 1132 else if (test & TEST_VERIFY) 1133 state.extracted = 1; 1134 return skip; 1135 } 1136 1137 static int 1138 catchfree(regex_t* preg, int flags, int* tabs, char* spec, char* re, char* s, char* ans, char* msg, char* accept, regmatch_t* match, int nmatch, int nsub, unsigned long skip, unsigned long level, unsigned long test) 1139 { 1140 int eret; 1141 1142 if (!(test & TEST_CATCH)) 1143 { 1144 regfree(preg); 1145 eret = 0; 1146 } 1147 else if (!(eret = setjmp(state.gotcha))) 1148 { 1149 alarm(HUNG); 1150 regfree(preg); 1151 alarm(0); 1152 } 1153 else if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY)) 1154 extract(tabs, spec, re, s, ans, msg, NiL, NiL, 0, 0, skip, level, test); 1155 else 1156 { 1157 report("failed", "regfree", re, NiL, -1, msg, flags, test); 1158 error(preg, eret); 1159 } 1160 return eret; 1161 } 1162 1163 static char* 1164 expand(char* os, char* ot) 1165 { 1166 char* s = os; 1167 char* t; 1168 int n = 0; 1169 int r; 1170 long m; 1171 1172 for (;;) 1173 { 1174 switch (*s++) 1175 { 1176 case 0: 1177 break; 1178 case '{': 1179 n++; 1180 continue; 1181 case '}': 1182 n--; 1183 continue; 1184 case 'R': 1185 if (n == 1 && !memcmp(s, "E_DUP_MAX", 9)) 1186 { 1187 s--; 1188 for (t = ot; os < s; *t++ = *os++); 1189 r = ((t - ot) >= 5 && t[-1] == '{' && t[-2] == '.' && t[-3] == '.' && t[-4] == '.') ? t[-5] : 0; 1190 os = ot; 1191 m = RE_DUP_MAX; 1192 if (*(s += 10) == '+' || *s == '-') 1193 m += strtol(s, &s, 10); 1194 if (r) 1195 { 1196 t -= 5; 1197 while (m-- > 0) 1198 *t++ = r; 1199 while (*s && *s++ != '}'); 1200 } 1201 else 1202 t += snprintf(t, 32, "%ld", m); 1203 while (*t = *s++) 1204 t++; 1205 break; 1206 } 1207 continue; 1208 default: 1209 continue; 1210 } 1211 break; 1212 } 1213 return os; 1214 } 1215 1216 int 1217 main(int argc, char** argv) 1218 { 1219 int flags; 1220 int cflags; 1221 int eflags; 1222 int nmatch; 1223 int nexec; 1224 int nstr; 1225 int cret; 1226 int eret; 1227 int nsub; 1228 int i; 1229 int j; 1230 int expected; 1231 int got; 1232 int locale; 1233 int subunitlen; 1234 int testno; 1235 unsigned long level; 1236 unsigned long skip; 1237 char* p; 1238 char* line; 1239 char* spec; 1240 char* re; 1241 char* s; 1242 char* ans; 1243 char* msg; 1244 char* fun; 1245 char* ppat; 1246 char* subunit; 1247 char* version; 1248 char* field[6]; 1249 char* delim[6]; 1250 FILE* fp; 1251 int tabs[6]; 1252 char unit[64]; 1253 regmatch_t match[100]; 1254 regex_t preg; 1255 1256 static char pat[32 * 1024]; 1257 static char patbuf[32 * 1024]; 1258 static char strbuf[32 * 1024]; 1259 1260 int nonosub = REG_NOSUB == 0; 1261 int nonexec = 0; 1262 1263 unsigned long test = 0; 1264 1265 static char* filter[] = { "-", 0 }; 1266 1267 state.NOMATCH.rm_so = state.NOMATCH.rm_eo = -2; 1268 p = unit; 1269 version = (char*)id + 10; 1270 while (p < &unit[sizeof(unit)-1] && (*p = *version++) && !isspace(*p)) 1271 p++; 1272 *p = 0; 1273 while ((p = *++argv) && *p == '-') 1274 for (;;) 1275 { 1276 switch (*++p) 1277 { 1278 case 0: 1279 break; 1280 case 'c': 1281 test |= TEST_CATCH; 1282 continue; 1283 case 'e': 1284 test |= TEST_IGNORE_ERROR; 1285 continue; 1286 case 'h': 1287 case '?': 1288 help(0); 1289 return 2; 1290 case '-': 1291 help(p[1] == 'h'); 1292 return 2; 1293 case 'n': 1294 nonexec = 1; 1295 continue; 1296 case 'o': 1297 test |= TEST_IGNORE_OVER; 1298 continue; 1299 case 'p': 1300 test |= TEST_IGNORE_POSITION; 1301 continue; 1302 case 's': 1303 #ifdef REG_DISCIPLINE 1304 if (!(state.stack = stkalloc(stkstd, 0))) 1305 fprintf(stderr, "%s: out of space [stack]", unit); 1306 state.disc.disc.re_resizef = resizef; 1307 state.disc.disc.re_resizehandle = (void*)stkstd; 1308 #endif 1309 continue; 1310 case 'x': 1311 nonosub = 1; 1312 continue; 1313 case 'v': 1314 test |= TEST_VERBOSE; 1315 continue; 1316 case 'A': 1317 test |= TEST_ACTUAL; 1318 continue; 1319 case 'B': 1320 test |= TEST_BASELINE; 1321 continue; 1322 case 'F': 1323 test |= TEST_FAIL; 1324 continue; 1325 case 'P': 1326 test |= TEST_PASS; 1327 continue; 1328 case 'S': 1329 test |= TEST_SUMMARY; 1330 continue; 1331 default: 1332 fprintf(stderr, "%s: %c: invalid option\n", unit, *p); 1333 return 2; 1334 } 1335 break; 1336 } 1337 if (!*argv) 1338 argv = filter; 1339 locale = 0; 1340 while (state.file = *argv++) 1341 { 1342 if (streq(state.file, "-") || streq(state.file, "/dev/stdin") || streq(state.file, "/dev/fd/0")) 1343 { 1344 state.file = 0; 1345 fp = stdin; 1346 } 1347 else if (!(fp = fopen(state.file, "r"))) 1348 { 1349 fprintf(stderr, "%s: %s: cannot read\n", unit, state.file); 1350 return 2; 1351 } 1352 testno = state.errors = state.ignored = state.lineno = state.passed = 1353 state.signals = state.unspecified = state.warnings = 0; 1354 skip = 0; 1355 level = 1; 1356 if (!(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_SUMMARY))) 1357 { 1358 printf("TEST\t%s ", unit); 1359 if (s = state.file) 1360 { 1361 subunit = p = 0; 1362 for (;;) 1363 { 1364 switch (*s++) 1365 { 1366 case 0: 1367 break; 1368 case '/': 1369 subunit = s; 1370 continue; 1371 case '.': 1372 p = s - 1; 1373 continue; 1374 default: 1375 continue; 1376 } 1377 break; 1378 } 1379 if (!subunit) 1380 subunit = state.file; 1381 if (p < subunit) 1382 p = s - 1; 1383 subunitlen = p - subunit; 1384 printf("%-.*s ", subunitlen, subunit); 1385 } 1386 else 1387 subunit = 0; 1388 for (s = version; *s && (*s != ' ' || *(s + 1) != '$'); s++) 1389 putchar(*s); 1390 if (test & TEST_CATCH) 1391 printf(", catch"); 1392 if (test & TEST_IGNORE_ERROR) 1393 printf(", ignore error code mismatches"); 1394 if (test & TEST_IGNORE_POSITION) 1395 printf(", ignore negative position mismatches"); 1396 #ifdef REG_DISCIPLINE 1397 if (state.stack) 1398 printf(", stack"); 1399 #endif 1400 if (test & TEST_VERBOSE) 1401 printf(", verbose"); 1402 printf("\n"); 1403 #ifdef REG_VERSIONID 1404 if (regerror(REG_VERSIONID, NiL, pat, sizeof(pat)) > 0) 1405 s = pat; 1406 else 1407 #endif 1408 #ifdef REG_TEST_VERSION 1409 s = REG_TEST_VERSION; 1410 #else 1411 s = "regex"; 1412 #endif 1413 printf("NOTE\t%s\n", s); 1414 if (elementsof(unsupported) > 1) 1415 { 1416 #if (REG_TEST_DEFAULT & (REG_AUGMENTED|REG_EXTENDED|REG_SHELL)) || !defined(REG_EXTENDED) 1417 i = 0; 1418 #else 1419 i = REG_EXTENDED != 0; 1420 #endif 1421 for (got = 0; i < elementsof(unsupported) - 1; i++) 1422 { 1423 if (!got) 1424 { 1425 got = 1; 1426 printf("NOTE\tunsupported: %s", unsupported[i]); 1427 } 1428 else 1429 printf(",%s", unsupported[i]); 1430 } 1431 if (got) 1432 printf("\n"); 1433 } 1434 } 1435 #ifdef REG_DISCIPLINE 1436 state.disc.disc.re_version = REG_VERSION; 1437 state.disc.disc.re_compf = compf; 1438 state.disc.disc.re_execf = execf; 1439 if (!(state.disc.sp = sfstropen())) 1440 bad("out of space [discipline string stream]\n", NiL, NiL, 0, 0); 1441 preg.re_disc = &state.disc.disc; 1442 #endif 1443 if (test & TEST_CATCH) 1444 { 1445 signal(SIGALRM, gotcha); 1446 signal(SIGBUS, gotcha); 1447 signal(SIGSEGV, gotcha); 1448 } 1449 while (p = get_line(fp)) 1450 { 1451 1452 /* parse: */ 1453 1454 line = p; 1455 if (*p == ':' && !isspace(*(p + 1))) 1456 { 1457 while (*++p && *p != ':'); 1458 if (!*p++) 1459 { 1460 if (test & TEST_BASELINE) 1461 printf("%s\n", line); 1462 continue; 1463 } 1464 } 1465 while (isspace(*p)) 1466 p++; 1467 if (*p == 0 || *p == '#' || *p == 'T') 1468 { 1469 if (test & TEST_BASELINE) 1470 printf("%s\n", line); 1471 continue; 1472 } 1473 if (*p == ':' || *p == 'N') 1474 { 1475 if (test & TEST_BASELINE) 1476 printf("%s\n", line); 1477 else if (!(test & (TEST_ACTUAL|TEST_FAIL|TEST_PASS|TEST_SUMMARY))) 1478 { 1479 while (*++p && !isspace(*p)); 1480 while (isspace(*p)) 1481 p++; 1482 printf("NOTE %s\n", p); 1483 } 1484 continue; 1485 } 1486 j = 0; 1487 i = 0; 1488 field[i++] = p; 1489 for (;;) 1490 { 1491 switch (*p++) 1492 { 1493 case 0: 1494 p--; 1495 j = 0; 1496 goto checkfield; 1497 case '\t': 1498 *(delim[i] = p - 1) = 0; 1499 j = 1; 1500 checkfield: 1501 s = field[i - 1]; 1502 if (streq(s, "NIL")) 1503 field[i - 1] = 0; 1504 else if (streq(s, "NULL")) 1505 *s = 0; 1506 while (*p == '\t') 1507 { 1508 p++; 1509 j++; 1510 } 1511 tabs[i - 1] = j; 1512 if (!*p) 1513 break; 1514 if (i >= elementsof(field)) 1515 bad("too many fields\n", NiL, NiL, 0, 0); 1516 field[i++] = p; 1517 /*FALLTHROUGH*/ 1518 default: 1519 continue; 1520 } 1521 break; 1522 } 1523 if (!(spec = field[0])) 1524 bad("NIL spec\n", NiL, NiL, 0, 0); 1525 1526 /* interpret: */ 1527 1528 cflags = REG_TEST_DEFAULT; 1529 eflags = REG_EXEC_DEFAULT; 1530 test &= TEST_GLOBAL; 1531 state.extracted = 0; 1532 nmatch = 20; 1533 nsub = -1; 1534 for (p = spec; *p; p++) 1535 { 1536 if (isdigit(*p)) 1537 { 1538 nmatch = strtol(p, &p, 10); 1539 if (nmatch >= elementsof(match)) 1540 bad("nmatch must be < 100\n", NiL, NiL, 0, 0); 1541 p--; 1542 continue; 1543 } 1544 switch (*p) 1545 { 1546 case 'A': 1547 test |= TEST_ARE; 1548 continue; 1549 case 'B': 1550 test |= TEST_BRE; 1551 continue; 1552 case 'C': 1553 if (!(test & TEST_QUERY) && !(skip & level)) 1554 bad("locale must be nested\n", NiL, NiL, 0, 0); 1555 test &= ~TEST_QUERY; 1556 if (locale) 1557 bad("locale nesting not supported\n", NiL, NiL, 0, 0); 1558 if (i != 2) 1559 bad("locale field expected\n", NiL, NiL, 0, 0); 1560 if (!(skip & level)) 1561 { 1562 #if defined(LC_COLLATE) && defined(LC_CTYPE) 1563 s = field[1]; 1564 if (!s || streq(s, "POSIX")) 1565 s = "C"; 1566 if ((ans = setlocale(LC_COLLATE, s)) && streq(ans, "POSIX")) 1567 ans = "C"; 1568 if (!ans || !streq(ans, s) && streq(s, "C")) 1569 ans = 0; 1570 else if ((ans = setlocale(LC_CTYPE, s)) && streq(ans, "POSIX")) 1571 ans = "C"; 1572 if (!ans || !streq(ans, s) && streq(s, "C")) 1573 skip = note(level, s, skip, test); 1574 else 1575 { 1576 if (!(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_SUMMARY))) 1577 printf("NOTE \"%s\" locale\n", s); 1578 locale = level; 1579 } 1580 #else 1581 skip = note(level, skip, test, "locales not supported"); 1582 #endif 1583 } 1584 cflags = NOTEST; 1585 continue; 1586 case 'E': 1587 test |= TEST_ERE; 1588 continue; 1589 case 'K': 1590 test |= TEST_KRE; 1591 continue; 1592 case 'L': 1593 test |= TEST_LRE; 1594 continue; 1595 case 'S': 1596 test |= TEST_SRE; 1597 continue; 1598 1599 case 'a': 1600 cflags |= REG_LEFT|REG_RIGHT; 1601 continue; 1602 case 'b': 1603 eflags |= REG_NOTBOL; 1604 continue; 1605 case 'c': 1606 cflags |= REG_COMMENT; 1607 continue; 1608 case 'd': 1609 cflags |= REG_SHELL_DOT; 1610 continue; 1611 case 'e': 1612 eflags |= REG_NOTEOL; 1613 continue; 1614 case 'f': 1615 cflags |= REG_MULTIPLE; 1616 continue; 1617 case 'g': 1618 cflags |= NOTEST; 1619 continue; 1620 case 'h': 1621 cflags |= REG_MULTIREF; 1622 continue; 1623 case 'i': 1624 cflags |= REG_ICASE; 1625 continue; 1626 case 'j': 1627 cflags |= REG_SPAN; 1628 continue; 1629 case 'k': 1630 cflags |= REG_ESCAPE; 1631 continue; 1632 case 'l': 1633 cflags |= REG_LEFT; 1634 continue; 1635 case 'm': 1636 cflags |= REG_MINIMAL; 1637 continue; 1638 case 'n': 1639 cflags |= REG_NEWLINE; 1640 continue; 1641 case 'o': 1642 cflags |= REG_SHELL_GROUP; 1643 continue; 1644 case 'p': 1645 cflags |= REG_SHELL_PATH; 1646 continue; 1647 case 'q': 1648 cflags |= REG_DELIMITED; 1649 continue; 1650 case 'r': 1651 cflags |= REG_RIGHT; 1652 continue; 1653 case 's': 1654 cflags |= REG_SHELL_ESCAPED; 1655 continue; 1656 case 't': 1657 cflags |= REG_MUSTDELIM; 1658 continue; 1659 case 'u': 1660 test |= TEST_UNSPECIFIED; 1661 continue; 1662 case 'v': 1663 cflags |= REG_CLASS_ESCAPE; 1664 continue; 1665 case 'w': 1666 cflags |= REG_NOSUB; 1667 continue; 1668 case 'x': 1669 if (REG_LENIENT) 1670 cflags |= REG_LENIENT; 1671 else 1672 test |= TEST_LENIENT; 1673 continue; 1674 case 'y': 1675 eflags |= REG_LEFT; 1676 continue; 1677 case 'z': 1678 cflags |= REG_NULL; 1679 continue; 1680 1681 case '$': 1682 test |= TEST_EXPAND; 1683 continue; 1684 1685 case '/': 1686 test |= TEST_SUB; 1687 continue; 1688 1689 case '=': 1690 test |= TEST_DECOMP; 1691 continue; 1692 1693 case '?': 1694 test |= TEST_VERIFY; 1695 test &= ~(TEST_AND|TEST_OR); 1696 state.verify = state.passed; 1697 continue; 1698 case '&': 1699 test |= TEST_VERIFY|TEST_AND; 1700 test &= ~TEST_OR; 1701 continue; 1702 case '|': 1703 test |= TEST_VERIFY|TEST_OR; 1704 test &= ~TEST_AND; 1705 continue; 1706 case ';': 1707 test |= TEST_OR; 1708 test &= ~TEST_AND; 1709 continue; 1710 1711 case '{': 1712 level <<= 1; 1713 if (skip & (level >> 1)) 1714 { 1715 skip |= level; 1716 cflags = NOTEST; 1717 } 1718 else 1719 { 1720 skip &= ~level; 1721 test |= TEST_QUERY; 1722 } 1723 continue; 1724 case '}': 1725 if (level == 1) 1726 bad("invalid {...} nesting\n", NiL, NiL, 0, 0); 1727 if ((skip & level) && !(skip & (level>>1))) 1728 { 1729 if (!(test & (TEST_BASELINE|TEST_SUMMARY))) 1730 { 1731 if (test & (TEST_ACTUAL|TEST_FAIL)) 1732 printf("}\n"); 1733 else if (!(test & TEST_PASS)) 1734 printf("-%d\n", state.lineno); 1735 } 1736 } 1737 #if defined(LC_COLLATE) && defined(LC_CTYPE) 1738 else if (locale & level) 1739 { 1740 locale = 0; 1741 if (!(skip & level)) 1742 { 1743 s = "C"; 1744 setlocale(LC_COLLATE, s); 1745 setlocale(LC_CTYPE, s); 1746 if (!(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_SUMMARY))) 1747 printf("NOTE \"%s\" locale\n", s); 1748 else if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_PASS)) 1749 printf("}\n"); 1750 } 1751 else if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL)) 1752 printf("}\n"); 1753 } 1754 #endif 1755 level >>= 1; 1756 cflags = NOTEST; 1757 continue; 1758 1759 default: 1760 bad("bad spec\n", spec, NiL, 0, test); 1761 break; 1762 1763 } 1764 break; 1765 } 1766 if ((cflags|eflags) == NOTEST || (skip & level) && (test & TEST_BASELINE)) 1767 { 1768 if (test & TEST_BASELINE) 1769 { 1770 while (i > 1) 1771 *delim[--i] = '\t'; 1772 printf("%s\n", line); 1773 } 1774 continue; 1775 } 1776 if (test & TEST_OR) 1777 { 1778 if (!(test & TEST_VERIFY)) 1779 { 1780 test &= ~TEST_OR; 1781 if (state.passed == state.verify && i > 1) 1782 printf("NOTE\t%s\n", field[1]); 1783 continue; 1784 } 1785 else if (state.passed > state.verify) 1786 continue; 1787 } 1788 else if (test & TEST_AND) 1789 { 1790 if (state.passed == state.verify) 1791 continue; 1792 state.passed = state.verify; 1793 } 1794 if (i < ((test & TEST_DECOMP) ? 3 : 4)) 1795 bad("too few fields\n", NiL, NiL, 0, test); 1796 while (i < elementsof(field)) 1797 field[i++] = 0; 1798 if (re = field[1]) 1799 { 1800 if (streq(re, "SAME")) 1801 { 1802 re = ppat; 1803 test |= TEST_SAME; 1804 } 1805 else 1806 { 1807 if (test & TEST_EXPAND) 1808 escape(re); 1809 re = expand(re, patbuf); 1810 strcpy(ppat = pat, re); 1811 } 1812 } 1813 else 1814 ppat = 0; 1815 nstr = -1; 1816 if (s = field[2]) 1817 { 1818 s = expand(s, strbuf); 1819 if (test & TEST_EXPAND) 1820 { 1821 nstr = escape(s); 1822 #if _REG_nexec 1823 if (nstr != strlen(s)) 1824 nexec = nstr; 1825 #endif 1826 } 1827 } 1828 if (!(ans = field[(test & TEST_DECOMP) ? 2 : 3])) 1829 bad("NIL answer\n", NiL, NiL, 0, test); 1830 msg = field[4]; 1831 fflush(stdout); 1832 if (test & TEST_SUB) 1833 #if _REG_subcomp 1834 cflags |= REG_DELIMITED; 1835 #else 1836 continue; 1837 #endif 1838 #if !_REG_decomp 1839 if (test & TEST_DECOMP) 1840 continue; 1841 #endif 1842 1843 compile: 1844 1845 if (state.extracted || (skip & level)) 1846 continue; 1847 #if !(REG_TEST_DEFAULT & (REG_AUGMENTED|REG_EXTENDED|REG_SHELL)) 1848 #ifdef REG_EXTENDED 1849 if (REG_EXTENDED != 0 && (test & TEST_BRE)) 1850 #else 1851 if (test & TEST_BRE) 1852 #endif 1853 { 1854 test &= ~TEST_BRE; 1855 flags = cflags; 1856 state.which = "BRE"; 1857 } 1858 else 1859 #endif 1860 #ifdef REG_EXTENDED 1861 if (test & TEST_ERE) 1862 { 1863 test &= ~TEST_ERE; 1864 flags = cflags | REG_EXTENDED; 1865 state.which = "ERE"; 1866 } 1867 else 1868 #endif 1869 #ifdef REG_AUGMENTED 1870 if (test & TEST_ARE) 1871 { 1872 test &= ~TEST_ARE; 1873 flags = cflags | REG_AUGMENTED; 1874 state.which = "ARE"; 1875 } 1876 else 1877 #endif 1878 #ifdef REG_LITERAL 1879 if (test & TEST_LRE) 1880 { 1881 test &= ~TEST_LRE; 1882 flags = cflags | REG_LITERAL; 1883 state.which = "LRE"; 1884 } 1885 else 1886 #endif 1887 #ifdef REG_SHELL 1888 if (test & TEST_SRE) 1889 { 1890 test &= ~TEST_SRE; 1891 flags = cflags | REG_SHELL; 1892 state.which = "SRE"; 1893 } 1894 else 1895 #ifdef REG_AUGMENTED 1896 if (test & TEST_KRE) 1897 { 1898 test &= ~TEST_KRE; 1899 flags = cflags | REG_SHELL | REG_AUGMENTED; 1900 state.which = "KRE"; 1901 } 1902 else 1903 #endif 1904 #endif 1905 { 1906 if (test & (TEST_BASELINE|TEST_PASS|TEST_VERIFY)) 1907 extract(tabs, line, re, s, ans, msg, NiL, NiL, 0, 0, skip, level, test|TEST_OK); 1908 continue; 1909 } 1910 if ((test & (TEST_QUERY|TEST_VERBOSE|TEST_VERIFY)) == TEST_VERBOSE) 1911 { 1912 printf("test %-3d %s ", state.lineno, state.which); 1913 quote(re, -1, test|TEST_DELIMIT); 1914 printf(" "); 1915 quote(s, nstr, test|TEST_DELIMIT); 1916 printf("\n"); 1917 } 1918 1919 nosub: 1920 fun = "regcomp"; 1921 #if _REG_nexec 1922 if (nstr >= 0 && nstr != strlen(s)) 1923 nexec = nstr; 1924 1925 else 1926 #endif 1927 nexec = -1; 1928 if (state.extracted || (skip & level)) 1929 continue; 1930 if (!(test & TEST_QUERY)) 1931 testno++; 1932 #ifdef REG_DISCIPLINE 1933 if (state.stack) 1934 stkset(stkstd, state.stack, 0); 1935 flags |= REG_DISCIPLINE; 1936 state.disc.ordinal = 0; 1937 sfstrseek(state.disc.sp, 0, SEEK_SET); 1938 #endif 1939 if (!(test & TEST_CATCH)) 1940 cret = regcomp(&preg, re, flags); 1941 else if (!(cret = setjmp(state.gotcha))) 1942 { 1943 alarm(HUNG); 1944 cret = regcomp(&preg, re, flags); 1945 alarm(0); 1946 } 1947 #if _REG_subcomp 1948 if (!cret && (test & TEST_SUB)) 1949 { 1950 fun = "regsubcomp"; 1951 p = re + preg.re_npat; 1952 if (!(test & TEST_CATCH)) 1953 cret = regsubcomp(&preg, p, NiL, 0, 0); 1954 else if (!(cret = setjmp(state.gotcha))) 1955 { 1956 alarm(HUNG); 1957 cret = regsubcomp(&preg, p, NiL, 0, 0); 1958 alarm(0); 1959 } 1960 if (!cret && *(p += preg.re_npat) && !(preg.re_sub->re_flags & REG_SUB_LAST)) 1961 { 1962 if (catchfree(&preg, flags, tabs, line, re, s, ans, msg, NiL, NiL, 0, 0, skip, level, test)) 1963 continue; 1964 cret = REG_EFLAGS; 1965 } 1966 } 1967 #endif 1968 #if _REG_decomp 1969 if (!cret && (test & TEST_DECOMP)) 1970 { 1971 char buf[128]; 1972 1973 if ((j = nmatch) > sizeof(buf)) 1974 j = sizeof(buf); 1975 fun = "regdecomp"; 1976 p = re + preg.re_npat; 1977 if (!(test & TEST_CATCH)) 1978 i = regdecomp(&preg, -1, buf, j); 1979 else if (!(cret = setjmp(state.gotcha))) 1980 { 1981 alarm(HUNG); 1982 i = regdecomp(&preg, -1, buf, j); 1983 alarm(0); 1984 } 1985 if (!cret) 1986 { 1987 catchfree(&preg, flags, tabs, line, re, s, ans, msg, NiL, NiL, 0, 0, skip, level, test); 1988 if (i > j) 1989 { 1990 if (i != (strlen(ans) + 1)) 1991 { 1992 report("failed", fun, re, s, nstr, msg, flags, test); 1993 printf(" %d byte buffer supplied, %d byte buffer required\n", j, i); 1994 } 1995 } 1996 else if (strcmp(buf, ans)) 1997 { 1998 report("failed", fun, re, s, nstr, msg, flags, test); 1999 quote(ans, -1, test|TEST_DELIMIT); 2000 printf(" expected, "); 2001 quote(buf, -1, test|TEST_DELIMIT); 2002 printf(" returned\n"); 2003 } 2004 continue; 2005 } 2006 } 2007 #endif 2008 if (!cret) 2009 { 2010 if (!(flags & REG_NOSUB) && nsub < 0 && *ans == '(') 2011 { 2012 for (p = ans; *p; p++) 2013 if (*p == '(') 2014 nsub++; 2015 else if (*p == '{') 2016 nsub--; 2017 if (nsub >= 0) 2018 { 2019 if (test & TEST_IGNORE_OVER) 2020 { 2021 if (nmatch > nsub) 2022 nmatch = nsub + 1; 2023 } 2024 else if (nsub != preg.re_nsub) 2025 { 2026 if (nsub > preg.re_nsub) 2027 { 2028 if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY)) 2029 skip = extract(tabs, line, re, s, ans, msg, "OK", NiL, 0, 0, skip, level, test|TEST_DELIMIT); 2030 else 2031 { 2032 report("re_nsub incorrect", fun, re, NiL, -1, msg, flags, test); 2033 printf("at least %d expected, %d returned\n", nsub, preg.re_nsub); 2034 state.errors++; 2035 } 2036 } 2037 else 2038 nsub = preg.re_nsub; 2039 } 2040 } 2041 } 2042 if (!(test & (TEST_DECOMP|TEST_SUB)) && *ans && *ans != '(' && !streq(ans, "OK") && !streq(ans, "NOMATCH")) 2043 { 2044 if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY)) 2045 skip = extract(tabs, line, re, s, ans, msg, "OK", NiL, 0, 0, skip, level, test|TEST_DELIMIT); 2046 else if (!(test & TEST_LENIENT)) 2047 { 2048 report("failed", fun, re, NiL, -1, msg, flags, test); 2049 printf("%s expected, OK returned\n", ans); 2050 } 2051 catchfree(&preg, flags, tabs, line, re, s, ans, msg, NiL, NiL, 0, 0, skip, level, test); 2052 continue; 2053 } 2054 } 2055 else 2056 { 2057 if (test & TEST_LENIENT) 2058 /* we'll let it go this time */; 2059 else if (!*ans || ans[0]=='(' || cret == REG_BADPAT && streq(ans, "NOMATCH")) 2060 { 2061 got = 0; 2062 for (i = 1; i < elementsof(codes); i++) 2063 if (cret==codes[i].code) 2064 got = i; 2065 if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY)) 2066 skip = extract(tabs, line, re, s, ans, msg, codes[got].name, NiL, 0, 0, skip, level, test|TEST_DELIMIT); 2067 else 2068 { 2069 report("failed", fun, re, NiL, -1, msg, flags, test); 2070 printf("%s returned: ", codes[got].name); 2071 error(&preg, cret); 2072 } 2073 } 2074 else 2075 { 2076 expected = got = 0; 2077 for (i = 1; i < elementsof(codes); i++) 2078 { 2079 if (streq(ans, codes[i].name)) 2080 expected = i; 2081 if (cret==codes[i].code) 2082 got = i; 2083 } 2084 if (!expected) 2085 { 2086 if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY)) 2087 skip = extract(tabs, line, re, s, ans, msg, codes[got].name, NiL, 0, 0, skip, level, test|TEST_DELIMIT); 2088 else 2089 { 2090 report("failed: invalid error code", NiL, re, NiL, -1, msg, flags, test); 2091 printf("%s expected, %s returned\n", ans, codes[got].name); 2092 } 2093 } 2094 else if (cret != codes[expected].code && cret != REG_BADPAT) 2095 { 2096 if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY)) 2097 skip = extract(tabs, line, re, s, ans, msg, codes[got].name, NiL, 0, 0, skip, level, test|TEST_DELIMIT); 2098 else if (test & TEST_IGNORE_ERROR) 2099 state.ignored++; 2100 else 2101 { 2102 report("should fail and did", fun, re, NiL, -1, msg, flags, test); 2103 printf("%s expected, %s returned: ", ans, codes[got].name); 2104 state.errors--; 2105 state.warnings++; 2106 error(&preg, cret); 2107 } 2108 } 2109 } 2110 goto compile; 2111 } 2112 2113 #if _REG_nexec 2114 execute: 2115 if (nexec >= 0) 2116 fun = "regnexec"; 2117 else 2118 #endif 2119 fun = "regexec"; 2120 2121 for (i = 0; i < elementsof(match); i++) 2122 match[i] = state.NOMATCH; 2123 2124 #if _REG_nexec 2125 if (nexec >= 0) 2126 { 2127 eret = regnexec(&preg, s, nexec, nmatch, match, eflags); 2128 s[nexec] = 0; 2129 } 2130 else 2131 #endif 2132 { 2133 if (!(test & TEST_CATCH)) 2134 eret = regexec(&preg, s, nmatch, match, eflags); 2135 else if (!(eret = setjmp(state.gotcha))) 2136 { 2137 alarm(HUNG); 2138 eret = regexec(&preg, s, nmatch, match, eflags); 2139 alarm(0); 2140 } 2141 } 2142 #if _REG_subcomp 2143 if ((test & TEST_SUB) && !eret) 2144 { 2145 fun = "regsubexec"; 2146 if (!(test & TEST_CATCH)) 2147 eret = regsubexec(&preg, s, nmatch, match); 2148 else if (!(eret = setjmp(state.gotcha))) 2149 { 2150 alarm(HUNG); 2151 eret = regsubexec(&preg, s, nmatch, match); 2152 alarm(0); 2153 } 2154 } 2155 #endif 2156 if (flags & REG_NOSUB) 2157 { 2158 if (eret) 2159 { 2160 if (eret != REG_NOMATCH || !streq(ans, "NOMATCH")) 2161 { 2162 if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY)) 2163 skip = extract(tabs, line, re, s, ans, msg, "NOMATCH", NiL, 0, 0, skip, level, test|TEST_DELIMIT); 2164 else 2165 { 2166 report("REG_NOSUB failed", fun, re, s, nstr, msg, flags, test); 2167 error(&preg, eret); 2168 } 2169 } 2170 } 2171 else if (streq(ans, "NOMATCH")) 2172 { 2173 if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY)) 2174 skip = extract(tabs, line, re, s, ans, msg, NiL, match, nmatch, nsub, skip, level, test|TEST_DELIMIT); 2175 else 2176 { 2177 report("should fail and didn't", fun, re, s, nstr, msg, flags, test); 2178 error(&preg, eret); 2179 } 2180 } 2181 } 2182 else if (eret) 2183 { 2184 if (eret != REG_NOMATCH || !streq(ans, "NOMATCH")) 2185 { 2186 if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY)) 2187 skip = extract(tabs, line, re, s, ans, msg, "NOMATCH", NiL, 0, nsub, skip, level, test|TEST_DELIMIT); 2188 else 2189 { 2190 report("failed", fun, re, s, nstr, msg, flags, test); 2191 if (eret != REG_NOMATCH) 2192 error(&preg, eret); 2193 else if (*ans) 2194 printf("expected: %s\n", ans); 2195 else 2196 printf("\n"); 2197 } 2198 } 2199 } 2200 else if (streq(ans, "NOMATCH")) 2201 { 2202 if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY)) 2203 skip = extract(tabs, line, re, s, ans, msg, NiL, match, nmatch, nsub, skip, level, test|TEST_DELIMIT); 2204 else 2205 { 2206 report("should fail and didn't", fun, re, s, nstr, msg, flags, test); 2207 matchprint(match, nmatch, nsub, NiL, test); 2208 } 2209 } 2210 #if _REG_subcomp 2211 else if (test & TEST_SUB) 2212 { 2213 p = preg.re_sub->re_buf; 2214 if (strcmp(p, ans)) 2215 { 2216 report("failed", fun, re, s, nstr, msg, flags, test); 2217 quote(ans, -1, test|TEST_DELIMIT); 2218 printf(" expected, "); 2219 quote(p, -1, test|TEST_DELIMIT); 2220 printf(" returned\n"); 2221 } 2222 } 2223 #endif 2224 else if (!*ans) 2225 { 2226 if (match[0].rm_so != state.NOMATCH.rm_so) 2227 { 2228 if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY)) 2229 skip = extract(tabs, line, re, s, ans, msg, NiL, NiL, 0, 0, skip, level, test); 2230 else 2231 { 2232 report("failed: no match but match array assigned", NiL, re, s, nstr, msg, flags, test); 2233 matchprint(match, nmatch, nsub, NiL, test); 2234 } 2235 } 2236 } 2237 else if (matchcheck(match, nmatch, nsub, ans, re, s, nstr, flags, test)) 2238 { 2239 #if _REG_nexec 2240 if (nexec < 0 && !nonexec) 2241 { 2242 nexec = nstr >= 0 ? nstr : strlen(s); 2243 s[nexec] = '\n'; 2244 testno++; 2245 goto execute; 2246 } 2247 #endif 2248 if (!(test & (TEST_DECOMP|TEST_SUB|TEST_VERIFY)) && !nonosub) 2249 { 2250 if (catchfree(&preg, flags, tabs, line, re, s, ans, msg, NiL, NiL, 0, 0, skip, level, test)) 2251 continue; 2252 flags |= REG_NOSUB; 2253 goto nosub; 2254 } 2255 if (test & (TEST_BASELINE|TEST_PASS|TEST_VERIFY)) 2256 skip = extract(tabs, line, re, s, ans, msg, NiL, match, nmatch, nsub, skip, level, test|TEST_OK); 2257 } 2258 else if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY)) 2259 skip = extract(tabs, line, re, s, ans, msg, NiL, match, nmatch, nsub, skip, level, test|TEST_DELIMIT); 2260 if (catchfree(&preg, flags, tabs, line, re, s, ans, msg, NiL, NiL, 0, 0, skip, level, test)) 2261 continue; 2262 goto compile; 2263 } 2264 if (test & TEST_SUMMARY) 2265 printf("tests=%-4d errors=%-4d warnings=%-2d ignored=%-2d unspecified=%-2d signals=%d\n", testno, state.errors, state.warnings, state.ignored, state.unspecified, state.signals); 2266 else if (!(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS))) 2267 { 2268 printf("TEST\t%s", unit); 2269 if (subunit) 2270 printf(" %-.*s", subunitlen, subunit); 2271 printf(", %d test%s", testno, testno == 1 ? "" : "s"); 2272 if (state.ignored) 2273 printf(", %d ignored mismatche%s", state.ignored, state.ignored == 1 ? "" : "s"); 2274 if (state.warnings) 2275 printf(", %d warning%s", state.warnings, state.warnings == 1 ? "" : "s"); 2276 if (state.unspecified) 2277 printf(", %d unspecified difference%s", state.unspecified, state.unspecified == 1 ? "" : "s"); 2278 if (state.signals) 2279 printf(", %d signal%s", state.signals, state.signals == 1 ? "" : "s"); 2280 printf(", %d error%s\n", state.errors, state.errors == 1 ? "" : "s"); 2281 } 2282 if (fp != stdin) 2283 fclose(fp); 2284 } 2285 return 0; 2286 } 2287