libraries/spcre/libpcre/pcre/RunGrepTest
changeset 0 7f656887cf89
equal deleted inserted replaced
-1:000000000000 0:7f656887cf89
       
     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.
       
     6 
       
     7 # Set the C locale, so that sort(1) behaves predictably.
       
     8 LC_ALL=C
       
     9 export LC_ALL
       
    10 
       
    11 pcregrep=`pwd`/pcregrep
       
    12 
       
    13 echo " "
       
    14 echo "Testing pcregrep"
       
    15 $pcregrep -V
       
    16 
       
    17 cf="diff -ub"
       
    18 valgrind=
       
    19 
       
    20 while [ $# -gt 0 ] ; do
       
    21   case $1 in
       
    22     valgrind) valgrind="valgrind -q --leak-check=no";;
       
    23     *) echo "Unknown argument $1"; exit 1;;
       
    24   esac
       
    25   shift
       
    26 done
       
    27 
       
    28 # If PCRE has been built in a directory other than the source directory, and
       
    29 # this test is being run from "make check" as usual, then $(srcdir) will be
       
    30 # set. If not, set it to the current directory. We then arrange to run the
       
    31 # pcregrep command in the source directory so that the file names that appear
       
    32 # in the output are always the same.
       
    33 
       
    34 if [ -z "$srcdir" -o ! -d "$srcdir/testdata" ] ; then
       
    35   srcdir=.
       
    36 fi
       
    37 
       
    38 # Check for the availability of UTF-8 support
       
    39 
       
    40 ./pcretest -C | ./pcregrep "No UTF-8 support" >/dev/null
       
    41 utf8=$?
       
    42 
       
    43 echo "---------------------------- Test 1 ------------------------------" >testtry
       
    44 (cd $srcdir; $valgrind $pcregrep PATTERN ./testdata/grepinput) >>testtry
       
    45 
       
    46 echo "---------------------------- Test 2 ------------------------------" >>testtry
       
    47 (cd $srcdir; $valgrind $pcregrep '^PATTERN' ./testdata/grepinput) >>testtry
       
    48 
       
    49 echo "---------------------------- Test 3 ------------------------------" >>testtry
       
    50 (cd $srcdir; $valgrind $pcregrep -in PATTERN ./testdata/grepinput) >>testtry
       
    51 
       
    52 echo "---------------------------- Test 4 ------------------------------" >>testtry
       
    53 (cd $srcdir; $valgrind $pcregrep -ic PATTERN ./testdata/grepinput) >>testtry
       
    54 
       
    55 echo "---------------------------- Test 5 ------------------------------" >>testtry
       
    56 (cd $srcdir; $valgrind $pcregrep -in PATTERN ./testdata/grepinput ./testdata/grepinputx) >>testtry
       
    57 
       
    58 echo "---------------------------- Test 6 ------------------------------" >>testtry
       
    59 (cd $srcdir; $valgrind $pcregrep -inh PATTERN ./testdata/grepinput ./testdata/grepinputx) >>testtry
       
    60 
       
    61 echo "---------------------------- Test 7 ------------------------------" >>testtry
       
    62 (cd $srcdir; $valgrind $pcregrep -il PATTERN ./testdata/grepinput ./testdata/grepinputx) >>testtry
       
    63 
       
    64 echo "---------------------------- Test 8 ------------------------------" >>testtry
       
    65 (cd $srcdir; $valgrind $pcregrep -l PATTERN ./testdata/grepinput ./testdata/grepinputx) >>testtry
       
    66 
       
    67 echo "---------------------------- Test 9 ------------------------------" >>testtry
       
    68 (cd $srcdir; $valgrind $pcregrep -q PATTERN ./testdata/grepinput ./testdata/grepinputx) >>testtry
       
    69 echo "RC=$?" >>testtry
       
    70 
       
    71 echo "---------------------------- Test 10 -----------------------------" >>testtry
       
    72 (cd $srcdir; $valgrind $pcregrep -q NEVER-PATTERN ./testdata/grepinput ./testdata/grepinputx) >>testtry
       
    73 echo "RC=$?" >>testtry
       
    74 
       
    75 echo "---------------------------- Test 11 -----------------------------" >>testtry
       
    76 (cd $srcdir; $valgrind $pcregrep -vn pattern ./testdata/grepinputx) >>testtry
       
    77 
       
    78 echo "---------------------------- Test 12 -----------------------------" >>testtry
       
    79 (cd $srcdir; $valgrind $pcregrep -ix pattern ./testdata/grepinputx) >>testtry
       
    80 
       
    81 echo "---------------------------- Test 13 -----------------------------" >>testtry
       
    82 (cd $srcdir; $valgrind $pcregrep -f./testdata/greplist ./testdata/grepinputx) >>testtry
       
    83 
       
    84 echo "---------------------------- Test 14 -----------------------------" >>testtry
       
    85 (cd $srcdir; $valgrind $pcregrep -w pat ./testdata/grepinput ./testdata/grepinputx) >>testtry
       
    86 
       
    87 echo "---------------------------- Test 15 -----------------------------" >>testtry
       
    88 (cd $srcdir; $valgrind $pcregrep 'abc^*' ./testdata/grepinput) 2>>testtry >>testtry
       
    89 
       
    90 echo "---------------------------- Test 16 -----------------------------" >>testtry
       
    91 (cd $srcdir; $valgrind $pcregrep abc ./testdata/grepinput ./testdata/nonexistfile) 2>>testtry >>testtry
       
    92 
       
    93 echo "---------------------------- Test 17 -----------------------------" >>testtry
       
    94 (cd $srcdir; $valgrind $pcregrep -M 'the\noutput' ./testdata/grepinput) >>testtry
       
    95 
       
    96 echo "---------------------------- Test 18 -----------------------------" >>testtry
       
    97 (cd $srcdir; $valgrind $pcregrep -Mn '(the\noutput|dog\.\n--)' ./testdata/grepinput) >>testtry
       
    98 
       
    99 echo "---------------------------- Test 19 -----------------------------" >>testtry
       
   100 (cd $srcdir; $valgrind $pcregrep -Mix 'Pattern' ./testdata/grepinputx) >>testtry
       
   101 
       
   102 echo "---------------------------- Test 20 -----------------------------" >>testtry
       
   103 (cd $srcdir; $valgrind $pcregrep -Mixn 'complete pair\nof lines' ./testdata/grepinputx) >>testtry
       
   104 
       
   105 echo "---------------------------- Test 21 -----------------------------" >>testtry
       
   106 (cd $srcdir; $valgrind $pcregrep -nA3 'four' ./testdata/grepinputx) >>testtry
       
   107 
       
   108 echo "---------------------------- Test 22 -----------------------------" >>testtry
       
   109 (cd $srcdir; $valgrind $pcregrep -nB3 'four' ./testdata/grepinputx) >>testtry
       
   110 
       
   111 echo "---------------------------- Test 23 -----------------------------" >>testtry
       
   112 (cd $srcdir; $valgrind $pcregrep -C3 'four' ./testdata/grepinputx) >>testtry
       
   113 
       
   114 echo "---------------------------- Test 24 -----------------------------" >>testtry
       
   115 (cd $srcdir; $valgrind $pcregrep -A9 'four' ./testdata/grepinputx) >>testtry
       
   116 
       
   117 echo "---------------------------- Test 25 -----------------------------" >>testtry
       
   118 (cd $srcdir; $valgrind $pcregrep -nB9 'four' ./testdata/grepinputx) >>testtry
       
   119 
       
   120 echo "---------------------------- Test 26 -----------------------------" >>testtry
       
   121 (cd $srcdir; $valgrind $pcregrep -A9 -B9 'four' ./testdata/grepinputx) >>testtry
       
   122 
       
   123 echo "---------------------------- Test 27 -----------------------------" >>testtry
       
   124 (cd $srcdir; $valgrind $pcregrep -A10 'four' ./testdata/grepinputx) >>testtry
       
   125 
       
   126 echo "---------------------------- Test 28 -----------------------------" >>testtry
       
   127 (cd $srcdir; $valgrind $pcregrep -nB10 'four' ./testdata/grepinputx) >>testtry
       
   128 
       
   129 echo "---------------------------- Test 29 -----------------------------" >>testtry
       
   130 (cd $srcdir; $valgrind $pcregrep -C12 -B10 'four' ./testdata/grepinputx) >>testtry
       
   131 
       
   132 echo "---------------------------- Test 30 -----------------------------" >>testtry
       
   133 (cd $srcdir; $valgrind $pcregrep -inB3 'pattern' ./testdata/grepinput ./testdata/grepinputx) >>testtry
       
   134 
       
   135 echo "---------------------------- Test 31 -----------------------------" >>testtry
       
   136 (cd $srcdir; $valgrind $pcregrep -inA3 'pattern' ./testdata/grepinput ./testdata/grepinputx) >>testtry
       
   137 
       
   138 echo "---------------------------- Test 32 -----------------------------" >>testtry
       
   139 (cd $srcdir; $valgrind $pcregrep -L 'fox' ./testdata/grepinput ./testdata/grepinputx) >>testtry
       
   140 
       
   141 echo "---------------------------- Test 33 -----------------------------" >>testtry
       
   142 (cd $srcdir; $valgrind $pcregrep 'fox' ./testdata/grepnonexist) >>testtry 2>&1
       
   143 echo "RC=$?" >>testtry
       
   144 
       
   145 echo "---------------------------- Test 34 -----------------------------" >>testtry
       
   146 (cd $srcdir; $valgrind $pcregrep -s 'fox' ./testdata/grepnonexist) >>testtry 2>&1
       
   147 echo "RC=$?" >>testtry
       
   148 
       
   149 echo "---------------------------- Test 35 -----------------------------" >>testtry
       
   150 (cd $srcdir; $valgrind $pcregrep -L -r --include=grepinputx --exclude_dir='^\.' 'fox' ./testdata) >>testtry
       
   151 echo "RC=$?" >>testtry
       
   152 
       
   153 echo "---------------------------- Test 36 -----------------------------" >>testtry
       
   154 (cd $srcdir; $valgrind $pcregrep -L -r --include=grepinput --exclude 'grepinput$' --exclude_dir='^\.' 'fox' ./testdata | sort) >>testtry
       
   155 echo "RC=$?" >>testtry
       
   156 
       
   157 echo "---------------------------- Test 37 -----------------------------" >>testtry
       
   158 (cd $srcdir; $valgrind $pcregrep  '^(a+)*\d' ./testdata/grepinput) >>testtry 2>teststderr
       
   159 echo "RC=$?" >>testtry
       
   160 echo "======== STDERR ========" >>testtry
       
   161 cat teststderr >>testtry
       
   162 
       
   163 echo "---------------------------- Test 38 ------------------------------" >>testtry
       
   164 (cd $srcdir; $valgrind $pcregrep '>\x00<' ./testdata/grepinput) >>testtry
       
   165 
       
   166 echo "---------------------------- Test 39 ------------------------------" >>testtry
       
   167 (cd $srcdir; $valgrind $pcregrep -A1 'before the binary zero' ./testdata/grepinput) >>testtry
       
   168 
       
   169 echo "---------------------------- Test 40 ------------------------------" >>testtry
       
   170 (cd $srcdir; $valgrind $pcregrep -B1 'after the binary zero' ./testdata/grepinput) >>testtry
       
   171 
       
   172 echo "---------------------------- Test 41 ------------------------------" >>testtry
       
   173 (cd $srcdir; $valgrind $pcregrep -B1 -o '\w+ the binary zero' ./testdata/grepinput) >>testtry
       
   174 
       
   175 echo "---------------------------- Test 41 ------------------------------" >>testtry
       
   176 (cd $srcdir; $valgrind $pcregrep -B1 -onH '\w+ the binary zero' ./testdata/grepinput) >>testtry
       
   177 
       
   178 echo "---------------------------- Test 42 ------------------------------" >>testtry
       
   179 (cd $srcdir; $valgrind $pcregrep -on 'before|zero|after' ./testdata/grepinput) >>testtry
       
   180 
       
   181 echo "---------------------------- Test 43 ------------------------------" >>testtry
       
   182 (cd $srcdir; $valgrind $pcregrep -on -e before -e zero -e after ./testdata/grepinput) >>testtry
       
   183 
       
   184 echo "---------------------------- Test 44 ------------------------------" >>testtry
       
   185 (cd $srcdir; $valgrind $pcregrep -on -f ./testdata/greplist -e binary ./testdata/grepinput) >>testtry
       
   186 
       
   187 echo "---------------------------- Test 45 ------------------------------" >>testtry
       
   188 (cd $srcdir; $valgrind $pcregrep -e abc -e '(unclosed' ./testdata/grepinput) 2>>testtry >>testtry
       
   189 
       
   190 echo "---------------------------- Test 46 ------------------------------" >>testtry
       
   191 (cd $srcdir; $valgrind $pcregrep -Fx "AB.VE
       
   192 elephant" ./testdata/grepinput) >>testtry
       
   193 
       
   194 echo "---------------------------- Test 47 ------------------------------" >>testtry
       
   195 (cd $srcdir; $valgrind $pcregrep -F "AB.VE
       
   196 elephant" ./testdata/grepinput) >>testtry
       
   197 
       
   198 echo "---------------------------- Test 48 ------------------------------" >>testtry
       
   199 (cd $srcdir; $valgrind $pcregrep -F -e DATA -e "AB.VE
       
   200 elephant" ./testdata/grepinput) >>testtry
       
   201 
       
   202 echo "---------------------------- Test 49 ------------------------------" >>testtry
       
   203 (cd $srcdir; $valgrind $pcregrep "^(abc|def|ghi|jkl)" ./testdata/grepinputx) >>testtry
       
   204 
       
   205 echo "---------------------------- Test 50 ------------------------------" >>testtry
       
   206 (cd $srcdir; $valgrind $pcregrep -Mv "brown\sfox" ./testdata/grepinputv) >>testtry
       
   207 
       
   208 echo "---------------------------- Test 51 ------------------------------" >>testtry
       
   209 (cd $srcdir; $valgrind $pcregrep --colour=always jumps ./testdata/grepinputv) >>testtry
       
   210 
       
   211 echo "---------------------------- Test 52 ------------------------------" >>testtry
       
   212 (cd $srcdir; $valgrind $pcregrep --file-offsets 'before|zero|after' ./testdata/grepinput) >>testtry
       
   213 
       
   214 echo "---------------------------- Test 53 ------------------------------" >>testtry
       
   215 (cd $srcdir; $valgrind $pcregrep --line-offsets 'before|zero|after' ./testdata/grepinput) >>testtry
       
   216 
       
   217 # Now compare the results.
       
   218 
       
   219 $cf $srcdir/testdata/grepoutput testtry
       
   220 if [ $? != 0 ] ; then exit 1; fi
       
   221 
       
   222 
       
   223 # These tests require UTF-8 support
       
   224 
       
   225 if [ $utf8 -ne 0 ] ; then
       
   226   echo "Testing pcregrep UTF-8 features"
       
   227 
       
   228   echo "---------------------------- Test U1 ------------------------------" >testtry
       
   229   (cd $srcdir; $valgrind $pcregrep -n -u --newline=any "^X" ./testdata/grepinput8) >>testtry
       
   230 
       
   231   echo "---------------------------- Test U2 ------------------------------" >>testtry
       
   232   (cd $srcdir; $valgrind $pcregrep -n -u -C 3 --newline=any "Match" ./testdata/grepinput8) >>testtry
       
   233 
       
   234   $cf $srcdir/testdata/grepoutput8 testtry
       
   235   if [ $? != 0 ] ; then exit 1; fi
       
   236 
       
   237 else
       
   238   echo "Skipping pcregrep UTF-8 tests: no UTF-8 support in PCRE library"
       
   239 fi
       
   240 
       
   241 
       
   242 # We go to some contortions to try to ensure that the tests for the various
       
   243 # newline settings will work in environments where the normal newline sequence
       
   244 # is not \n. Do not use exported files, whose line endings might be changed.
       
   245 # Instead, create an input file using printf so that its contents are exactly
       
   246 # what we want. Note the messy fudge to get printf to write a string that
       
   247 # starts with a hyphen.
       
   248 
       
   249 echo "Testing pcregrep newline settings"
       
   250 printf "abc\rdef\r\nghi\njkl" >testNinput
       
   251 
       
   252 printf "%c--------------------------- Test N1 ------------------------------\r\n" - >testtry
       
   253 $valgrind $pcregrep -n -N CR "^(abc|def|ghi|jkl)" testNinput >>testtry
       
   254 
       
   255 printf "%c--------------------------- Test N2 ------------------------------\r\n" - >>testtry
       
   256 $valgrind $pcregrep -n --newline=crlf "^(abc|def|ghi|jkl)" testNinput >>testtry
       
   257 
       
   258 printf "%c--------------------------- Test N3 ------------------------------\r\n" - >>testtry
       
   259 pattern=`printf 'def\rjkl'`
       
   260 $valgrind $pcregrep -n --newline=cr -F "$pattern" testNinput >>testtry
       
   261 
       
   262 printf "%c--------------------------- Test N4 ------------------------------\r\n" - >>testtry
       
   263 pattern=`printf 'xxx\r\njkl'`
       
   264 $valgrind $pcregrep -n --newline=crlf -F "$pattern" testNinput >>testtry
       
   265 
       
   266 printf "%c--------------------------- Test N5 ------------------------------\r\n" - >>testtry
       
   267 $valgrind $pcregrep -n --newline=any "^(abc|def|ghi|jkl)" testNinput >>testtry
       
   268 
       
   269 printf "%c--------------------------- Test N6 ------------------------------\r\n" - >>testtry
       
   270 $valgrind $pcregrep -n --newline=anycrlf "^(abc|def|ghi|jkl)" testNinput >>testtry
       
   271 
       
   272 $cf $srcdir/testdata/grepoutputN testtry
       
   273 if [ $? != 0 ] ; then exit 1; fi
       
   274 
       
   275 exit 0
       
   276 
       
   277 # End