Annotation of embedaddon/pcre/RunGrepTest, revision 1.1.1.5
1.1 misho 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
1.1.1.4 misho 5: # supported by pcregrep. This script must be run in the build directory.
1.1 misho 6:
7: # Set the C locale, so that sort(1) behaves predictably.
8:
9: LC_ALL=C
10: export LC_ALL
11:
1.1.1.2 misho 12: # Remove any non-default colouring and aliases that the caller may have set.
1.1 misho 13:
14: unset PCREGREP_COLOUR PCREGREP_COLOR
1.1.1.2 misho 15: unset cp ls mv rm
1.1 misho 16:
1.1.1.4 misho 17: # Remember the current (build) directory, set the program to be tested, and
18: # valgrind settings when requested.
1.1 misho 19:
1.1.1.4 misho 20: builddir=`pwd`
21: pcregrep=$builddir/pcregrep
1.1 misho 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 " "
1.1.1.4 misho 33: pcregrep_version=`$pcregrep -V`
1.1 misho 34: if [ "$valgrind" = "" ] ; then
1.1.1.4 misho 35: echo "Testing $pcregrep_version"
1.1 misho 36: else
1.1.1.4 misho 37: echo "Testing $pcregrep_version using valgrind"
1.1 misho 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:
1.1.1.4 misho 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.
1.1 misho 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:
1.1.1.2 misho 67: ./pcretest -C utf >/dev/null
1.1 misho 68: utf8=$?
69:
1.1.1.4 misho 70: echo "Testing pcregrep main features"
71:
1.1 misho 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
1.1.1.4 misho 121: echo seventeen >testtemp1
122: (cd $srcdir; $valgrind $pcregrep -f./testdata/greplist -f $builddir/testtemp1 ./testdata/grepinputx) >>testtry
1.1 misho 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
1.1.1.4 misho 210: (cd $srcdir; $valgrind $pcregrep -L -r --include=grepinputx --include grepinput8 --exclude-dir='^\.' 'fox' ./testdata | sort) >>testtry
1.1 misho 211: echo "RC=$?" >>testtry
212:
213: echo "---------------------------- Test 36 -----------------------------" >>testtry
1.1.1.4 misho 214: (cd $srcdir; $valgrind $pcregrep -L -r --include=grepinput --exclude 'grepinput$' --exclude=grepinput8 --exclude-dir='^\.' 'fox' ./testdata | sort) >>testtry
1.1 misho 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:
1.1.1.3 misho 410: echo "---------------------------- Test 84 -----------------------------" >>testtry
1.1.1.4 misho 411: echo testdata/grepinput3 >testtemp1
412: (cd $srcdir; $valgrind $pcregrep --file-list ./testdata/grepfilelist --file-list $builddir/testtemp1 "fox|complete|t7") >>testtry 2>&1
1.1.1.3 misho 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:
1.1.1.4 misho 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:
1.1.1.5 ! misho 505: echo "---------------------------- Test 106 -----------------------------" >>testtry
! 506: (cd $srcdir; echo "a" | $valgrind $pcregrep -M "|a" ) >>testtry 2>&1
! 507: echo "RC=$?" >>testtry
! 508:
1.1.1.4 misho 509:
1.1 misho 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
1.1.1.4 misho 542: # starts with a hyphen. These tests are run in the build directory.
1.1 misho 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
1.1.1.2 misho 558: $valgrind $pcregrep -n --newline=crlf -F -f $srcdir/testdata/greppatN4 testNinput >>testtry
1.1 misho 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
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to RunGrepTest CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre