Return to RunGrepTest CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre

pcre 8.34

    1: #! /bin/sh
    2: 
    3: # Run pcregrep tests. The assumption is that the PCRE tests check the library
    4: # itself. What we are checking here is the file handling and options that are
    5: # supported by pcregrep. This script must be run in the build directory.
    6: 
    7: # Set the C locale, so that sort(1) behaves predictably.
    8: 
    9: LC_ALL=C
   10: export LC_ALL
   11: 
   12: # Remove any non-default colouring and aliases that the caller may have set.
   13: 
   14: unset PCREGREP_COLOUR PCREGREP_COLOR
   15: unset cp ls mv rm
   16: 
   17: # Remember the current (build) directory, set the program to be tested, and
   18: # valgrind settings when requested.
   19: 
   20: builddir=`pwd`
   21: pcregrep=$builddir/pcregrep
   22: 
   23: valgrind=
   24: while [ $# -gt 0 ] ; do
   25:   case $1 in
   26:     valgrind) valgrind="valgrind -q --leak-check=no --smc-check=all";;
   27:     *) echo "RunGrepTest: Unknown argument $1"; exit 1;;
   28:   esac
   29:   shift
   30: done
   31: 
   32: echo " "
   33: pcregrep_version=`$pcregrep -V`
   34: if [ "$valgrind" = "" ] ; then
   35:   echo "Testing $pcregrep_version"
   36: else
   37:   echo "Testing $pcregrep_version using valgrind"
   38: fi
   39: 
   40: # Set up a suitable "diff" command for comparison. Some systems have a diff
   41: # that lacks a -u option. Try to deal with this; better do the test for the -b
   42: # option as well.
   43: 
   44: cf="diff"
   45: diff -b  /dev/null /dev/null 2>/dev/null && cf="diff -b"
   46: diff -u  /dev/null /dev/null 2>/dev/null && cf="diff -u"
   47: diff -ub /dev/null /dev/null 2>/dev/null && cf="diff -ub"
   48: 
   49: # If this test is being run from "make check", $srcdir will be set. If not, set
   50: # it to the current or parent directory, whichever one contains the test data.
   51: # Subsequently, we run most of the pcregrep tests in the source directory so
   52: # that the file names in the output are always the same.
   53: 
   54: if [ -z "$srcdir" -o ! -d "$srcdir/testdata" ] ; then
   55:   if [ -d "./testdata" ] ; then
   56:     srcdir=.
   57:   elif [ -d "../testdata" ] ; then
   58:     srcdir=..
   59:   else
   60:     echo "Cannot find the testdata directory"
   61:     exit 1
   62:   fi
   63: fi
   64: 
   65: # Check for the availability of UTF-8 support
   66: 
   67: ./pcretest -C utf >/dev/null
   68: utf8=$?
   69: 
   70: echo "Testing pcregrep main features"
   71: 
   72: echo "---------------------------- Test 1 ------------------------------" >testtry
   73: (cd $srcdir; $valgrind $pcregrep PATTERN ./testdata/grepinput) >>testtry
   74: echo "RC=$?" >>testtry
   75: 
   76: echo "---------------------------- Test 2 ------------------------------" >>testtry
   77: (cd $srcdir; $valgrind $pcregrep '^PATTERN' ./testdata/grepinput) >>testtry
   78: echo "RC=$?" >>testtry
   79: 
   80: echo "---------------------------- Test 3 ------------------------------" >>testtry
   81: (cd $srcdir; $valgrind $pcregrep -in PATTERN ./testdata/grepinput) >>testtry
   82: echo "RC=$?" >>testtry
   83: 
   84: echo "---------------------------- Test 4 ------------------------------" >>testtry
   85: (cd $srcdir; $valgrind $pcregrep -ic PATTERN ./testdata/grepinput) >>testtry
   86: echo "RC=$?" >>testtry
   87: 
   88: echo "---------------------------- Test 5 ------------------------------" >>testtry
   89: (cd $srcdir; $valgrind $pcregrep -in PATTERN ./testdata/grepinput ./testdata/grepinputx) >>testtry
   90: echo "RC=$?" >>testtry
   91: 
   92: echo "---------------------------- Test 6 ------------------------------" >>testtry
   93: (cd $srcdir; $valgrind $pcregrep -inh PATTERN ./testdata/grepinput ./testdata/grepinputx) >>testtry
   94: echo "RC=$?" >>testtry
   95: 
   96: echo "---------------------------- Test 7 ------------------------------" >>testtry
   97: (cd $srcdir; $valgrind $pcregrep -il PATTERN ./testdata/grepinput ./testdata/grepinputx) >>testtry
   98: echo "RC=$?" >>testtry
   99: 
  100: echo "---------------------------- Test 8 ------------------------------" >>testtry
  101: (cd $srcdir; $valgrind $pcregrep -l PATTERN ./testdata/grepinput ./testdata/grepinputx) >>testtry
  102: echo "RC=$?" >>testtry
  103: 
  104: echo "---------------------------- Test 9 ------------------------------" >>testtry
  105: (cd $srcdir; $valgrind $pcregrep -q PATTERN ./testdata/grepinput ./testdata/grepinputx) >>testtry
  106: echo "RC=$?" >>testtry
  107: 
  108: echo "---------------------------- Test 10 -----------------------------" >>testtry
  109: (cd $srcdir; $valgrind $pcregrep -q NEVER-PATTERN ./testdata/grepinput ./testdata/grepinputx) >>testtry
  110: echo "RC=$?" >>testtry
  111: 
  112: echo "---------------------------- Test 11 -----------------------------" >>testtry
  113: (cd $srcdir; $valgrind $pcregrep -vn pattern ./testdata/grepinputx) >>testtry
  114: echo "RC=$?" >>testtry
  115: 
  116: echo "---------------------------- Test 12 -----------------------------" >>testtry
  117: (cd $srcdir; $valgrind $pcregrep -ix pattern ./testdata/grepinputx) >>testtry
  118: echo "RC=$?" >>testtry
  119: 
  120: echo "---------------------------- Test 13 -----------------------------" >>testtry
  121: echo seventeen >testtemp1
  122: (cd $srcdir; $valgrind $pcregrep -f./testdata/greplist -f $builddir/testtemp1 ./testdata/grepinputx) >>testtry
  123: echo "RC=$?" >>testtry
  124: 
  125: echo "---------------------------- Test 14 -----------------------------" >>testtry
  126: (cd $srcdir; $valgrind $pcregrep -w pat ./testdata/grepinput ./testdata/grepinputx) >>testtry
  127: echo "RC=$?" >>testtry
  128: 
  129: echo "---------------------------- Test 15 -----------------------------" >>testtry
  130: (cd $srcdir; $valgrind $pcregrep 'abc^*' ./testdata/grepinput) 2>>testtry >>testtry
  131: echo "RC=$?" >>testtry
  132: 
  133: echo "---------------------------- Test 16 -----------------------------" >>testtry
  134: (cd $srcdir; $valgrind $pcregrep abc ./testdata/grepinput ./testdata/nonexistfile) 2>>testtry >>testtry
  135: echo "RC=$?" >>testtry
  136: 
  137: echo "---------------------------- Test 17 -----------------------------" >>testtry
  138: (cd $srcdir; $valgrind $pcregrep -M 'the\noutput' ./testdata/grepinput) >>testtry
  139: echo "RC=$?" >>testtry
  140: 
  141: echo "---------------------------- Test 18 -----------------------------" >>testtry
  142: (cd $srcdir; $valgrind $pcregrep -Mn '(the\noutput|dog\.\n--)' ./testdata/grepinput) >>testtry
  143: echo "RC=$?" >>testtry
  144: 
  145: echo "---------------------------- Test 19 -----------------------------" >>testtry
  146: (cd $srcdir; $valgrind $pcregrep -Mix 'Pattern' ./testdata/grepinputx) >>testtry
  147: echo "RC=$?" >>testtry
  148: 
  149: echo "---------------------------- Test 20 -----------------------------" >>testtry
  150: (cd $srcdir; $valgrind $pcregrep -Mixn 'complete pair\nof lines' ./testdata/grepinputx) >>testtry
  151: echo "RC=$?" >>testtry
  152: 
  153: echo "---------------------------- Test 21 -----------------------------" >>testtry
  154: (cd $srcdir; $valgrind $pcregrep -nA3 'four' ./testdata/grepinputx) >>testtry
  155: echo "RC=$?" >>testtry
  156: 
  157: echo "---------------------------- Test 22 -----------------------------" >>testtry
  158: (cd $srcdir; $valgrind $pcregrep -nB3 'four' ./testdata/grepinputx) >>testtry
  159: echo "RC=$?" >>testtry
  160: 
  161: echo "---------------------------- Test 23 -----------------------------" >>testtry
  162: (cd $srcdir; $valgrind $pcregrep -C3 'four' ./testdata/grepinputx) >>testtry
  163: echo "RC=$?" >>testtry
  164: 
  165: echo "---------------------------- Test 24 -----------------------------" >>testtry
  166: (cd $srcdir; $valgrind $pcregrep -A9 'four' ./testdata/grepinputx) >>testtry
  167: echo "RC=$?" >>testtry
  168: 
  169: echo "---------------------------- Test 25 -----------------------------" >>testtry
  170: (cd $srcdir; $valgrind $pcregrep -nB9 'four' ./testdata/grepinputx) >>testtry
  171: echo "RC=$?" >>testtry
  172: 
  173: echo "---------------------------- Test 26 -----------------------------" >>testtry
  174: (cd $srcdir; $valgrind $pcregrep -A9 -B9 'four' ./testdata/grepinputx) >>testtry
  175: echo "RC=$?" >>testtry
  176: 
  177: echo "---------------------------- Test 27 -----------------------------" >>testtry
  178: (cd $srcdir; $valgrind $pcregrep -A10 'four' ./testdata/grepinputx) >>testtry
  179: echo "RC=$?" >>testtry
  180: 
  181: echo "---------------------------- Test 28 -----------------------------" >>testtry
  182: (cd $srcdir; $valgrind $pcregrep -nB10 'four' ./testdata/grepinputx) >>testtry
  183: echo "RC=$?" >>testtry
  184: 
  185: echo "---------------------------- Test 29 -----------------------------" >>testtry
  186: (cd $srcdir; $valgrind $pcregrep -C12 -B10 'four' ./testdata/grepinputx) >>testtry
  187: echo "RC=$?" >>testtry
  188: 
  189: echo "---------------------------- Test 30 -----------------------------" >>testtry
  190: (cd $srcdir; $valgrind $pcregrep -inB3 'pattern' ./testdata/grepinput ./testdata/grepinputx) >>testtry
  191: echo "RC=$?" >>testtry
  192: 
  193: echo "---------------------------- Test 31 -----------------------------" >>testtry
  194: (cd $srcdir; $valgrind $pcregrep -inA3 'pattern' ./testdata/grepinput ./testdata/grepinputx) >>testtry
  195: echo "RC=$?" >>testtry
  196: 
  197: echo "---------------------------- Test 32 -----------------------------" >>testtry
  198: (cd $srcdir; $valgrind $pcregrep -L 'fox' ./testdata/grepinput ./testdata/grepinputx) >>testtry
  199: echo "RC=$?" >>testtry
  200: 
  201: echo "---------------------------- Test 33 -----------------------------" >>testtry
  202: (cd $srcdir; $valgrind $pcregrep 'fox' ./testdata/grepnonexist) >>testtry 2>&1
  203: echo "RC=$?" >>testtry
  204: 
  205: echo "---------------------------- Test 34 -----------------------------" >>testtry
  206: (cd $srcdir; $valgrind $pcregrep -s 'fox' ./testdata/grepnonexist) >>testtry 2>&1
  207: echo "RC=$?" >>testtry
  208: 
  209: echo "---------------------------- Test 35 -----------------------------" >>testtry
  210: (cd $srcdir; $valgrind $pcregrep -L -r --include=grepinputx --include grepinput8 --exclude-dir='^\.' 'fox' ./testdata | sort) >>testtry
  211: echo "RC=$?" >>testtry
  212: 
  213: echo "---------------------------- Test 36 -----------------------------" >>testtry
  214: (cd $srcdir; $valgrind $pcregrep -L -r --include=grepinput --exclude 'grepinput$' --exclude=grepinput8 --exclude-dir='^\.' 'fox' ./testdata | sort) >>testtry
  215: echo "RC=$?" >>testtry
  216: 
  217: echo "---------------------------- Test 37 -----------------------------" >>testtry
  218: (cd $srcdir; $valgrind $pcregrep  '^(a+)*\d' ./testdata/grepinput) >>testtry 2>teststderr
  219: echo "RC=$?" >>testtry
  220: echo "======== STDERR ========" >>testtry
  221: cat teststderr >>testtry
  222: 
  223: echo "---------------------------- Test 38 ------------------------------" >>testtry
  224: (cd $srcdir; $valgrind $pcregrep '>\x00<' ./testdata/grepinput) >>testtry
  225: echo "RC=$?" >>testtry
  226: 
  227: echo "---------------------------- Test 39 ------------------------------" >>testtry
  228: (cd $srcdir; $valgrind $pcregrep -A1 'before the binary zero' ./testdata/grepinput) >>testtry
  229: echo "RC=$?" >>testtry
  230: 
  231: echo "---------------------------- Test 40 ------------------------------" >>testtry
  232: (cd $srcdir; $valgrind $pcregrep -B1 'after the binary zero' ./testdata/grepinput) >>testtry
  233: echo "RC=$?" >>testtry
  234: 
  235: echo "---------------------------- Test 41 ------------------------------" >>testtry
  236: (cd $srcdir; $valgrind $pcregrep -B1 -o '\w+ the binary zero' ./testdata/grepinput) >>testtry
  237: echo "RC=$?" >>testtry
  238: 
  239: echo "---------------------------- Test 42 ------------------------------" >>testtry
  240: (cd $srcdir; $valgrind $pcregrep -B1 -onH '\w+ the binary zero' ./testdata/grepinput) >>testtry
  241: echo "RC=$?" >>testtry
  242: 
  243: echo "---------------------------- Test 43 ------------------------------" >>testtry
  244: (cd $srcdir; $valgrind $pcregrep -on 'before|zero|after' ./testdata/grepinput) >>testtry
  245: echo "RC=$?" >>testtry
  246: 
  247: echo "---------------------------- Test 44 ------------------------------" >>testtry
  248: (cd $srcdir; $valgrind $pcregrep -on -e before -ezero -e after ./testdata/grepinput) >>testtry
  249: echo "RC=$?" >>testtry
  250: 
  251: echo "---------------------------- Test 45 ------------------------------" >>testtry
  252: (cd $srcdir; $valgrind $pcregrep -on -f ./testdata/greplist -e binary ./testdata/grepinput) >>testtry
  253: echo "RC=$?" >>testtry
  254: 
  255: echo "---------------------------- Test 46 ------------------------------" >>testtry
  256: (cd $srcdir; $valgrind $pcregrep -eabc -e '(unclosed' ./testdata/grepinput) 2>>testtry >>testtry
  257: echo "RC=$?" >>testtry
  258: 
  259: echo "---------------------------- Test 47 ------------------------------" >>testtry
  260: (cd $srcdir; $valgrind $pcregrep -Fx "AB.VE
  261: elephant" ./testdata/grepinput) >>testtry
  262: echo "RC=$?" >>testtry
  263: 
  264: echo "---------------------------- Test 48 ------------------------------" >>testtry
  265: (cd $srcdir; $valgrind $pcregrep -F "AB.VE
  266: elephant" ./testdata/grepinput) >>testtry
  267: echo "RC=$?" >>testtry
  268: 
  269: echo "---------------------------- Test 49 ------------------------------" >>testtry
  270: (cd $srcdir; $valgrind $pcregrep -F -e DATA -e "AB.VE
  271: elephant" ./testdata/grepinput) >>testtry
  272: echo "RC=$?" >>testtry
  273: 
  274: echo "---------------------------- Test 50 ------------------------------" >>testtry
  275: (cd $srcdir; $valgrind $pcregrep "^(abc|def|ghi|jkl)" ./testdata/grepinputx) >>testtry
  276: echo "RC=$?" >>testtry
  277: 
  278: echo "---------------------------- Test 51 ------------------------------" >>testtry
  279: (cd $srcdir; $valgrind $pcregrep -Mv "brown\sfox" ./testdata/grepinputv) >>testtry
  280: echo "RC=$?" >>testtry
  281: 
  282: echo "---------------------------- Test 52 ------------------------------" >>testtry
  283: (cd $srcdir; $valgrind $pcregrep --colour=always jumps ./testdata/grepinputv) >>testtry
  284: echo "RC=$?" >>testtry
  285: 
  286: echo "---------------------------- Test 53 ------------------------------" >>testtry
  287: (cd $srcdir; $valgrind $pcregrep --file-offsets 'before|zero|after' ./testdata/grepinput) >>testtry
  288: echo "RC=$?" >>testtry
  289: 
  290: echo "---------------------------- Test 54 ------------------------------" >>testtry
  291: (cd $srcdir; $valgrind $pcregrep --line-offsets 'before|zero|after' ./testdata/grepinput) >>testtry
  292: echo "RC=$?" >>testtry
  293: 
  294: echo "---------------------------- Test 55 -----------------------------" >>testtry
  295: (cd $srcdir; $valgrind $pcregrep -f./testdata/greplist --color=always ./testdata/grepinputx) >>testtry
  296: echo "RC=$?" >>testtry
  297: 
  298: echo "---------------------------- Test 56 -----------------------------" >>testtry
  299: (cd $srcdir; $valgrind $pcregrep -c lazy ./testdata/grepinput*) >>testtry
  300: echo "RC=$?" >>testtry
  301: 
  302: echo "---------------------------- Test 57 -----------------------------" >>testtry
  303: (cd $srcdir; $valgrind $pcregrep -c -l lazy ./testdata/grepinput*) >>testtry
  304: echo "RC=$?" >>testtry
  305: 
  306: echo "---------------------------- Test 58 -----------------------------" >>testtry
  307: (cd $srcdir; $valgrind $pcregrep --regex=PATTERN ./testdata/grepinput) >>testtry
  308: echo "RC=$?" >>testtry
  309: 
  310: echo "---------------------------- Test 59 -----------------------------" >>testtry
  311: (cd $srcdir; $valgrind $pcregrep --regexp=PATTERN ./testdata/grepinput) >>testtry
  312: echo "RC=$?" >>testtry
  313: 
  314: echo "---------------------------- Test 60 -----------------------------" >>testtry
  315: (cd $srcdir; $valgrind $pcregrep --regex PATTERN ./testdata/grepinput) >>testtry
  316: echo "RC=$?" >>testtry
  317: 
  318: echo "---------------------------- Test 61 -----------------------------" >>testtry
  319: (cd $srcdir; $valgrind $pcregrep --regexp PATTERN ./testdata/grepinput) >>testtry
  320: echo "RC=$?" >>testtry
  321: 
  322: echo "---------------------------- Test 62 -----------------------------" >>testtry
  323: (cd $srcdir; $valgrind $pcregrep --match-limit=1000 --no-jit -M 'This is a file(.|\R)*file.' ./testdata/grepinput) >>testtry 2>&1
  324: echo "RC=$?" >>testtry
  325: 
  326: echo "---------------------------- Test 63 -----------------------------" >>testtry
  327: (cd $srcdir; $valgrind $pcregrep --recursion-limit=1000 --no-jit -M 'This is a file(.|\R)*file.' ./testdata/grepinput) >>testtry 2>&1
  328: echo "RC=$?" >>testtry
  329: 
  330: echo "---------------------------- Test 64 ------------------------------" >>testtry
  331: (cd $srcdir; $valgrind $pcregrep -o1 '(?<=PAT)TERN (ap(pear)s)' ./testdata/grepinput) >>testtry
  332: echo "RC=$?" >>testtry
  333: 
  334: echo "---------------------------- Test 65 ------------------------------" >>testtry
  335: (cd $srcdir; $valgrind $pcregrep -o2 '(?<=PAT)TERN (ap(pear)s)' ./testdata/grepinput) >>testtry
  336: echo "RC=$?" >>testtry
  337: 
  338: echo "---------------------------- Test 66 ------------------------------" >>testtry
  339: (cd $srcdir; $valgrind $pcregrep -o3 '(?<=PAT)TERN (ap(pear)s)' ./testdata/grepinput) >>testtry
  340: echo "RC=$?" >>testtry
  341: 
  342: echo "---------------------------- Test 67 ------------------------------" >>testtry
  343: (cd $srcdir; $valgrind $pcregrep -o12 '(?<=PAT)TERN (ap(pear)s)' ./testdata/grepinput) >>testtry
  344: echo "RC=$?" >>testtry
  345: 
  346: echo "---------------------------- Test 68 ------------------------------" >>testtry
  347: (cd $srcdir; $valgrind $pcregrep --only-matching=2 '(?<=PAT)TERN (ap(pear)s)' ./testdata/grepinput) >>testtry
  348: echo "RC=$?" >>testtry
  349: 
  350: echo "---------------------------- Test 69 -----------------------------" >>testtry
  351: (cd $srcdir; $valgrind $pcregrep -vn --colour=always pattern ./testdata/grepinputx) >>testtry
  352: echo "RC=$?" >>testtry
  353: 
  354: echo "---------------------------- Test 70 -----------------------------" >>testtry
  355: (cd $srcdir; $valgrind $pcregrep --color=always -M "triple:\t.*\n\n" ./testdata/grepinput3) >>testtry
  356: echo "RC=$?" >>testtry
  357: 
  358: echo "---------------------------- Test 71 -----------------------------" >>testtry
  359: (cd $srcdir; $valgrind $pcregrep -o "^01|^02|^03" ./testdata/grepinput) >>testtry
  360: echo "RC=$?" >>testtry
  361: 
  362: echo "---------------------------- Test 72 -----------------------------" >>testtry
  363: (cd $srcdir; $valgrind $pcregrep --color=always "^01|^02|^03" ./testdata/grepinput) >>testtry
  364: echo "RC=$?" >>testtry
  365: 
  366: echo "---------------------------- Test 73 -----------------------------" >>testtry
  367: (cd $srcdir; $valgrind $pcregrep -o --colour=always "^01|^02|^03" ./testdata/grepinput) >>testtry
  368: echo "RC=$?" >>testtry
  369: 
  370: echo "---------------------------- Test 74 -----------------------------" >>testtry
  371: (cd $srcdir; $valgrind $pcregrep -o "^01|02|^03" ./testdata/grepinput) >>testtry
  372: echo "RC=$?" >>testtry
  373: 
  374: echo "---------------------------- Test 75 -----------------------------" >>testtry
  375: (cd $srcdir; $valgrind $pcregrep --color=always "^01|02|^03" ./testdata/grepinput) >>testtry
  376: echo "RC=$?" >>testtry
  377: 
  378: echo "---------------------------- Test 76 -----------------------------" >>testtry
  379: (cd $srcdir; $valgrind $pcregrep -o --colour=always "^01|02|^03" ./testdata/grepinput) >>testtry
  380: echo "RC=$?" >>testtry
  381: 
  382: echo "---------------------------- Test 77 -----------------------------" >>testtry
  383: (cd $srcdir; $valgrind $pcregrep -o "^01|^02|03" ./testdata/grepinput) >>testtry
  384: echo "RC=$?" >>testtry
  385: 
  386: echo "---------------------------- Test 78 -----------------------------" >>testtry
  387: (cd $srcdir; $valgrind $pcregrep --color=always "^01|^02|03" ./testdata/grepinput) >>testtry
  388: echo "RC=$?" >>testtry
  389: 
  390: echo "---------------------------- Test 79 -----------------------------" >>testtry
  391: (cd $srcdir; $valgrind $pcregrep -o --colour=always "^01|^02|03" ./testdata/grepinput) >>testtry
  392: echo "RC=$?" >>testtry
  393: 
  394: echo "---------------------------- Test 80 -----------------------------" >>testtry
  395: (cd $srcdir; $valgrind $pcregrep -o "\b01|\b02" ./testdata/grepinput) >>testtry
  396: echo "RC=$?" >>testtry
  397: 
  398: echo "---------------------------- Test 81 -----------------------------" >>testtry
  399: (cd $srcdir; $valgrind $pcregrep --color=always "\\b01|\\b02" ./testdata/grepinput) >>testtry
  400: echo "RC=$?" >>testtry
  401: 
  402: echo "---------------------------- Test 82 -----------------------------" >>testtry
  403: (cd $srcdir; $valgrind $pcregrep -o --colour=always "\\b01|\\b02" ./testdata/grepinput) >>testtry
  404: echo "RC=$?" >>testtry
  405: 
  406: echo "---------------------------- Test 83 -----------------------------" >>testtry
  407: (cd $srcdir; $valgrind $pcregrep --buffer-size=100 "^a" ./testdata/grepinput3) >>testtry 2>&1
  408: echo "RC=$?" >>testtry
  409: 
  410: echo "---------------------------- Test 84 -----------------------------" >>testtry
  411: echo testdata/grepinput3 >testtemp1
  412: (cd $srcdir; $valgrind $pcregrep --file-list ./testdata/grepfilelist --file-list $builddir/testtemp1 "fox|complete|t7") >>testtry 2>&1
  413: echo "RC=$?" >>testtry
  414: 
  415: echo "---------------------------- Test 85 -----------------------------" >>testtry
  416: (cd $srcdir; $valgrind $pcregrep --file-list=./testdata/grepfilelist "dolor" ./testdata/grepinput3) >>testtry 2>&1
  417: echo "RC=$?" >>testtry
  418: 
  419: echo "---------------------------- Test 86 -----------------------------" >>testtry
  420: (cd $srcdir; $valgrind $pcregrep "dog" ./testdata/grepbinary) >>testtry 2>&1
  421: echo "RC=$?" >>testtry
  422: 
  423: echo "---------------------------- Test 87 -----------------------------" >>testtry
  424: (cd $srcdir; $valgrind $pcregrep "cat" ./testdata/grepbinary) >>testtry 2>&1
  425: echo "RC=$?" >>testtry
  426: 
  427: echo "---------------------------- Test 88 -----------------------------" >>testtry
  428: (cd $srcdir; $valgrind $pcregrep -v "cat" ./testdata/grepbinary) >>testtry 2>&1
  429: echo "RC=$?" >>testtry
  430: 
  431: echo "---------------------------- Test 89 -----------------------------" >>testtry
  432: (cd $srcdir; $valgrind $pcregrep -I "dog" ./testdata/grepbinary) >>testtry 2>&1
  433: echo "RC=$?" >>testtry
  434: 
  435: echo "---------------------------- Test 90 -----------------------------" >>testtry
  436: (cd $srcdir; $valgrind $pcregrep --binary-files=without-match "dog" ./testdata/grepbinary) >>testtry 2>&1
  437: echo "RC=$?" >>testtry
  438: 
  439: echo "---------------------------- Test 91 -----------------------------" >>testtry
  440: (cd $srcdir; $valgrind $pcregrep -a "dog" ./testdata/grepbinary) >>testtry 2>&1
  441: echo "RC=$?" >>testtry
  442: 
  443: echo "---------------------------- Test 92 -----------------------------" >>testtry
  444: (cd $srcdir; $valgrind $pcregrep --binary-files=text "dog" ./testdata/grepbinary) >>testtry 2>&1
  445: echo "RC=$?" >>testtry
  446: 
  447: echo "---------------------------- Test 93 -----------------------------" >>testtry
  448: (cd $srcdir; $valgrind $pcregrep --text "dog" ./testdata/grepbinary) >>testtry 2>&1
  449: echo "RC=$?" >>testtry
  450: 
  451: echo "---------------------------- Test 94 -----------------------------" >>testtry
  452: (cd $srcdir; $valgrind $pcregrep -L -r --include=grepinputx --include grepinput8 'fox' ./testdata/grepinput* | sort) >>testtry
  453: echo "RC=$?" >>testtry
  454: 
  455: echo "---------------------------- Test 95 -----------------------------" >>testtry
  456: (cd $srcdir; $valgrind $pcregrep --file-list ./testdata/grepfilelist --exclude grepinputv "fox|complete") >>testtry 2>&1
  457: echo "RC=$?" >>testtry
  458: 
  459: echo "---------------------------- Test 96 -----------------------------" >>testtry
  460: (cd $srcdir; $valgrind $pcregrep -L -r --include-dir=testdata --exclude '^(?!grepinput)' 'fox' ./test* | sort) >>testtry
  461: echo "RC=$?" >>testtry
  462: 
  463: echo "---------------------------- Test 97 -----------------------------" >>testtry
  464: echo "grepinput$" >testtemp1
  465: echo "grepinput8" >>testtemp1
  466: (cd $srcdir; $valgrind $pcregrep -L -r --include=grepinput --exclude-from $builddir/testtemp1 --exclude-dir='^\.' 'fox' ./testdata | sort) >>testtry
  467: echo "RC=$?" >>testtry
  468: 
  469: echo "---------------------------- Test 98 -----------------------------" >>testtry
  470: echo "grepinput$" >testtemp1
  471: echo "grepinput8" >>testtemp1
  472: (cd $srcdir; $valgrind $pcregrep -L -r --exclude=grepinput3 --include=grepinput --exclude-from $builddir/testtemp1 --exclude-dir='^\.' 'fox' ./testdata | sort) >>testtry
  473: echo "RC=$?" >>testtry
  474: 
  475: echo "---------------------------- Test 99 -----------------------------" >>testtry
  476: echo "grepinput$" >testtemp1
  477: echo "grepinput8" >testtemp2
  478: (cd $srcdir; $valgrind $pcregrep -L -r --include grepinput --exclude-from $builddir/testtemp1 --exclude-from=$builddir/testtemp2 --exclude-dir='^\.' 'fox' ./testdata | sort) >>testtry
  479: echo "RC=$?" >>testtry
  480: 
  481: echo "---------------------------- Test 100 ------------------------------" >>testtry
  482: (cd $srcdir; $valgrind $pcregrep -Ho2 --only-matching=1 -o3 '(\w+) binary (\w+)(\.)?' ./testdata/grepinput) >>testtry
  483: echo "RC=$?" >>testtry
  484: 
  485: echo "---------------------------- Test 101 ------------------------------" >>testtry
  486: (cd $srcdir; $valgrind $pcregrep -o3 -Ho2 -o12 --only-matching=1 -o3 --colour=always --om-separator='|' '(\w+) binary (\w+)(\.)?' ./testdata/grepinput) >>testtry
  487: echo "RC=$?" >>testtry
  488: 
  489: echo "---------------------------- Test 102 -----------------------------" >>testtry
  490: (cd $srcdir; $valgrind $pcregrep -n "^$" ./testdata/grepinput3) >>testtry 2>&1
  491: echo "RC=$?" >>testtry
  492: 
  493: echo "---------------------------- Test 103 -----------------------------" >>testtry
  494: (cd $srcdir; $valgrind $pcregrep --only-matching "^$" ./testdata/grepinput3) >>testtry 2>&1
  495: echo "RC=$?" >>testtry
  496: 
  497: echo "---------------------------- Test 104 -----------------------------" >>testtry
  498: (cd $srcdir; $valgrind $pcregrep -n --only-matching "^$" ./testdata/grepinput3) >>testtry 2>&1
  499: echo "RC=$?" >>testtry
  500: 
  501: echo "---------------------------- Test 105 -----------------------------" >>testtry
  502: (cd $srcdir; $valgrind $pcregrep --colour=always "ipsum|" ./testdata/grepinput3) >>testtry 2>&1
  503: echo "RC=$?" >>testtry
  504: 
  505: echo "---------------------------- Test 106 -----------------------------" >>testtry
  506: (cd $srcdir; echo "a" | $valgrind $pcregrep -M "|a" ) >>testtry 2>&1
  507: echo "RC=$?" >>testtry
  508: 
  509: 
  510: # Now compare the results.
  511: 
  512: $cf $srcdir/testdata/grepoutput testtry
  513: if [ $? != 0 ] ; then exit 1; fi
  514: 
  515: 
  516: # These tests require UTF-8 support
  517: 
  518: if [ $utf8 -ne 0 ] ; then
  519:   echo "Testing pcregrep UTF-8 features"
  520: 
  521:   echo "---------------------------- Test U1 ------------------------------" >testtry
  522:   (cd $srcdir; $valgrind $pcregrep -n -u --newline=any "^X" ./testdata/grepinput8) >>testtry
  523:   echo "RC=$?" >>testtry
  524: 
  525:   echo "---------------------------- Test U2 ------------------------------" >>testtry
  526:   (cd $srcdir; $valgrind $pcregrep -n -u -C 3 --newline=any "Match" ./testdata/grepinput8) >>testtry
  527:   echo "RC=$?" >>testtry
  528: 
  529:   $cf $srcdir/testdata/grepoutput8 testtry
  530:   if [ $? != 0 ] ; then exit 1; fi
  531: 
  532: else
  533:   echo "Skipping pcregrep UTF-8 tests: no UTF-8 support in PCRE library"
  534: fi
  535: 
  536: 
  537: # We go to some contortions to try to ensure that the tests for the various
  538: # newline settings will work in environments where the normal newline sequence
  539: # is not \n. Do not use exported files, whose line endings might be changed.
  540: # Instead, create an input file using printf so that its contents are exactly
  541: # what we want. Note the messy fudge to get printf to write a string that
  542: # starts with a hyphen. These tests are run in the build directory.
  543: 
  544: echo "Testing pcregrep newline settings"
  545: printf "abc\rdef\r\nghi\njkl" >testNinput
  546: 
  547: printf "%c--------------------------- Test N1 ------------------------------\r\n" - >testtry
  548: $valgrind $pcregrep -n -N CR "^(abc|def|ghi|jkl)" testNinput >>testtry
  549: 
  550: printf "%c--------------------------- Test N2 ------------------------------\r\n" - >>testtry
  551: $valgrind $pcregrep -n --newline=crlf "^(abc|def|ghi|jkl)" testNinput >>testtry
  552: 
  553: printf "%c--------------------------- Test N3 ------------------------------\r\n" - >>testtry
  554: pattern=`printf 'def\rjkl'`
  555: $valgrind $pcregrep -n --newline=cr -F "$pattern" testNinput >>testtry
  556: 
  557: printf "%c--------------------------- Test N4 ------------------------------\r\n" - >>testtry
  558: $valgrind $pcregrep -n --newline=crlf -F -f $srcdir/testdata/greppatN4 testNinput >>testtry
  559: 
  560: printf "%c--------------------------- Test N5 ------------------------------\r\n" - >>testtry
  561: $valgrind $pcregrep -n --newline=any "^(abc|def|ghi|jkl)" testNinput >>testtry
  562: 
  563: printf "%c--------------------------- Test N6 ------------------------------\r\n" - >>testtry
  564: $valgrind $pcregrep -n --newline=anycrlf "^(abc|def|ghi|jkl)" testNinput >>testtry
  565: 
  566: $cf $srcdir/testdata/grepoutputN testtry
  567: if [ $? != 0 ] ; then exit 1; fi
  568: 
  569: exit 0
  570: 
  571: # End