# Large number of macros in one regexp (Enhanced mode off)
E$ [A-Z]\\d\\s?\\d[A-Z]{2}|[A-Z]\\d{2}\\s?\\d[A-Z]{2}|[A-Z]{2}\\d\\s?\\d[A-Z]{2}|[A-Z]{2}\\d{2}\\s?\\d[A-Z]{2}|[A-Z]\\d[A-Z]\\s?\\d[A-Z]{2}|[A-Z]{2}\\d[A-Z]\\s?\\d[A-Z]{2}|[A-Z]{3}\\s?\\d[A-Z]{2} AdsdBC (0,6)
E a{11}(b{2}c){2} aaaaaaaaaaabbcbbc (0,17)(14,17)
E$ ^!packet [0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3} [0-9]+ !packet 127.0.0.1 999 (0,21)
E$ ^!pfast [0-9]{1,15} ([0-9]{1,3}\\.){3}[0-9]{1,3}\\.[0-9]{1,5}$ !pfast 1234567890 127.0.0.1.1234 (0,32)(24,26)
# Should these match or not?
B \(a\)*-\1b aaa-b NOMATCH
B \(\(.*\)\1\)\{1,\} xxxxxx ESUBREG
# Basic string matching
E foobar foobar (0,6)
E SAME xxxfoobarzapzot (3,9)
E aaaa xxaaaaaaaaaaaaaaaaa (2,6)
# Test zero length matches
E (a*) NULL (0,0)(0,0)
E (a*)* NULL (0,0)(0,0)
E ((a*)*)* NULL (0,0)(0,0)(0,0)
E (a*bcd)* aaaaaaaaaaaabcxbcxbcxaabcxaabcx (0,0)(?,?)
E SAME aaaaaaaaaaaabcxbcxbcxaabcxaabc (0,0)(?,?)
E SAME aaaaaaaaaaaabcxbcdbcxaabcxaabc (0,0)(?,?)
E SAME aaaaaaaaaaaabcdbcdbcxaabcxaabc (0,18)(15,18)
E (a*)+ - (0,0)(0,0)
#E NULL NULL (0,0)
#E SAME foo (0,0)
# Test for submatch addressing which requires arbitrary lookahead
E (a*)aaaaaa aaaaaaaaaaaaaaax (0,15)(0,9)
# Test leftmost and longest matching and some tricky submatches
E (a*)(a*) aaaa (0,4)(0,4)(4,4)
E (abcd|abc)(d?) abcd (0,4)(0,4)(4,4)
E (abc|abcd)(d?) abcd (0,4)(0,4)(4,4)
E (abc|abcd)(d?)e abcde (0,5)(0,4)(4,4)
E (abcd|abc)(d?)e abcde (0,5)(0,4)(4,4)
E a(bc|bcd)(d?) abcd (0,4)(1,4)(4,4)
E a(bcd|bc)(d?) abcd (0,4)(1,4)(4,4)
E a*(a?bc|bcd)(d?) aaabcd (0,6)(3,6)(6,6)
E a*(bcd|a?bc)(d?) aaabcd (0,6)(3,6)(6,6)
E (a|(a*b*))* NULL (0,0)(0,0)(0,0)
E SAME a (0,1)(0,1)(?,?)
E SAME aa (0,2)(0,2)(0,2)
E SAME aaa (0,3)(0,3)(0,3)
E SAME bbb (0,3)(0,3)(0,3)
E SAME aaabbb (0,6)(0,6)(0,6)
E SAME bbbaaa (0,6)(3,6)(3,6)
E ((a*b*)|a)* NULL (0,0)(0,0)(0,0)
E SAME a (0,1)(0,1)(0,1)
E SAME aa (0,2)(0,2)(0,2)
E SAME aaa (0,3)(0,3)(0,3)
E SAME bbb (0,3)(0,3)(0,3)
E SAME aaabbb (0,6)(0,6)(0,6)
E SAME bbbaaa (0,6)(3,6)(3,6)
E a.*(.*b.*(.*c.*).*d.*).*e.*(.*f.*).*g aabbccddeeffgg (0,14)(3,9)(5,7)(11,13)
E (wee|week)(night|knights)s* weeknights (0,10)(0,4)(4,9)
E SAME weeknightss (0,11)(0,4)(4,9)
E a* aaaaaaaaaa (0,10)
E aa* aaaaaaaaaa (0,10)
E aaa* aaaaaaaaaa (0,10)
E aaaa* aaaaaaaaaa (0,10)
# Test clearing old submatch data with nesting parentheses and iteration
E ((a)|(b))*c aaabc (0,5)(3,4)(?,?)(3,4)
E SAME aaaac (0,5)(3,4)(3,4)(?,?)
E foo((bar)*)*zot foozot (0,6)(3,3)(?,?)
E SAME foobarzot (0,9)(3,6)(3,6)
E SAME foobarbarzot (0,12)(3,9)(6,9)
E foo((zup)*|(bar)*|(zap)*)*zot foobarzapzot (0,12)(6,9)(?,?)(?,?)(6,9)
E SAME foobarbarzapzot (0,15)(9,12)(?,?)(?,?)(9,12)
E SAME foozupzot (0,9)(3,6)(3,6)(?,?)(?,?)
E SAME foobarzot (0,9)(3,6)(?,?)(3,6)(?,?)
E SAME foozapzot (0,9)(3,6)(?,?)(?,?)(3,6)
E SAME foozot (0,6)(3,3)(?,?)(?,?)(?,?)
# Test case where, e.g., Perl and Python regexp functions, and many
# other backtracking matchers, fail to produce the longest match.
# It is not exactly a bug since Perl does not claim to find the
# longest match, but a confusing feature and, in my opinion, a bad
# design choice because the union operator is traditionally defined
# to be commutative (with respect to the language denoted by the RE). */
E (a|ab)(blip)? ablip (0,5)(0,1)(1,5)
E SAME ab (0,2)(0,2)(?,?)
E (ab|a)(blip)? ablip (0,5)(0,1)(1,5)
E SAME ab (0,2)(0,2)(?,?)
E ((a|b)*)a(a|b)* aaaaabaaaba (0,11)(0,10)(9,10)(?,?)
E SAME aaaaabaaab (0,10)(0,8)(7,8)(9,10)
E SAME caa (1,3)(1,2)(1,2)(?,?)
E ((a|aba)*)(ababbaba)((a|b)*) aabaababbabaaababbab (0,20)(0,4)(1,4)(4,12)(12,20)(19,20)
E SAME aaaaababbaba (0,12)(0,4)(3,4)(4,12)(12,12)(?,?)
E ((a|aba|abb|bba|bab)*)(ababbababbabbbabbbbbbabbaba)((a|b)*) aabaabbbbabababaababbababbabbbabbbbbbabbabababbababababbabababa (0,63)(0,16)(13,16)(16,43)(43,63)(62,63)
# Test for empty subexpressions
#E (a|) a (0,1)(0,1)
#E SAME b (0,0)(0,0)
#E SAME NULL (0,0)(0,0)
#E (|a) a (0,1)(0,1)
#E SAME b (0,0)(0,0)
#E SAME NULL (0,0)(0,0)
#E a| a (0,1)
#E SAME b (0,0)
#E SAME NULL (0,0)
#E |a a (0,1)
#E SAME b (0,0)
#E SAME NULL (0,0)
# Miscellaneous tests
E (a*)b(c*) abc (0,3)(0,1)(2,3)
E SAME ***abc*** (3,6)(3,4)(5,6)
E (a) a (0,1)(0,1)
E ((a)) a (0,1)(0,1)(0,1)
E ((((((((((((((((((((a)))))))))))))))))))) a (0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)(0,1)
E ksntoeaiksntoeaikstneoaiksnteoaiksntoeaiskntoeaiskntoekainstoeiaskntoeakisntoeksaitnokesantiksoentaikosentaiksoentaiksnoeaisknteoaksintoekasitnoeksaitkosetniaksoetnaisknoetakistoeksintokesanitksoentaisknoetaisknoetiaksotneaikstoekasitoeskatioksentaiksoenatiksoetnaiksonateiksoteaeskanotisknetaiskntoeasknitoskenatiskonetaisknoteai x NOMATCH
E ((aab)|(aac)|(aa*))c aabc (0,4)(0,3)(0,3)(?,?)(?,?)
E SAME aacc (0,4)(0,3)(?,?)(0,3)(?,?)
E SAME aaac (0,4)(0,3)(?,?)(?,?)(0,3)
E ^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$ foo!bar!bas (0,11)(0,11)(?,?)(?,?)(4,8)(8,11)
E ^([^!]+!)?([^!]+)$|^.+!([^!]+!)([^!]+)$ foo!bar!bas (0,11)(?,?)(?,?)(4,8)(8,11)
E ^(([^!]+!)?([^!]+)|.+!([^!]+!)([^!]+))$ foo!bar!bas (0,11)(0,11)(?,?)(?,?)(4,8)(8,11)
E M[ou]'?am+[ae]r .*([AEae]l[- ])?[GKQ]h?[aeu]+([dtz][dhz]?)+af[iy] Muammar Quathafi (0,16)(?,?)(11,13)
Ei (Ab|cD)* aBcD (0,4)(2,4)
E a** NULL BADRPT
E a*+ NULL BADRPT
E a+* NULL BADRPT
E a++ NULL BADRPT
E a?+ NULL BADRPT
E a?* NULL BADRPT
E a{1,2}* NULL BADRPT
E a{1,2}+ NULL BADRPT
# Many of the following tests were mostly inspired by (or copied from) the
# libhackerlab posix test suite by Tom Lord
B a a (0,1)
B \. . (0,1)
B \[ [ (0,1)
B \\ \ (0,1)
B \* * (0,1)
B \^ ^ (0,1)
B \$ $ (0,1)
B \ NULL EESCAPE
B x\. x. (0,2)
B x\[ x[ (0,2)
B x\\ x\ (0,2)
B x\* x* (0,2)
B x\^ x^ (0,2)
B x\$ x$ (0,2)
B x\ NULL EESCAPE
B . a (0,1)
B$ SAME \n (0,1)
B (+|?) (+|?) (0,5)
B SAME +|? NOMATCH
B SAME (+) NOMATCH
B SAME + NOMATCH
# Test bracket expressions
B [ NULL EBRACK
B [] NULL EBRACK
B [^] NULL EBRACK
B []x] ] (0,1)
B []x] x (0,1)
B [.] . (0,1)
B SAME a NOMATCH
B [*] * (0,1)
B [[] [ (0,1)
B [\] \ (0,1)
B [-x] - (0,1)
B SAME x (0,1)
B [x-] - (0,1)
B SAME x (0,1)
B [-] - (0,1)
B [abc] a (0,1)
B SAME b (0,1)
B SAME c (0,1)
B SAME d NOMATCH
B SAME xa (1,2)
B SAME xb (1,2)
B SAME xc (1,2)
B SAME xd NOMATCH
B x[abc] xa (0,2)
B SAME xb (0,2)
B SAME xc (0,2)
B SAME xd NOMATCH
B [^abc] a NOMATCH
B SAME b NOMATCH
B SAME c NOMATCH
B SAME d (0,1)
B SAME xa (0,1)
B SAME xb (0,1)
B SAME xc (0,1)
B SAME xd (0,1)
B x[^abc] xa NOMATCH
B x[^abc] xb NOMATCH
B x[^abc] xc NOMATCH
B x[^abc] xd (0,2)
E [()+?*\]+ x\*?+()x (1,7)
# Standard character classes
E [[:alnum:]]+ %abc123890XYZ= (1,13)
E$ [[:cntrl:]]+ %\n\t\015\f (1,5)
E [[:lower:]]+ AbcdE (1,4)
Ei [[:lower:]]+ AbcdE (0,5)
E$ [[:space:]]+ x \t\f\nx (1,5)
E [[:alpha:]]+ %abC123890xyz= (1,4)
E [[:digit:]]+ %abC123890xyz= (4,10)
E [^[:digit:]]+ %abC123890xyz= (0,4)
E$ [[:print:]]+ \n %abC12\f (1,8)
E$ [[:upper:]]+ \n aBCDEFGHIJKLMNOPQRSTUVWXYz (3,27)
Ei$ [[:upper:]]+ \n aBCDEFGHIJKLMNOPQRSTUVWXYz (2,28)
E$ [[:blank:]]+ \na \t b (2,5)
E$ [[:graph:]]+ \n %abC12\f (2,8)
E [[:punct:]]+ a~!@#$%^&*()_+=-`[]{};':"|\,./?>< (1,33)
E [[:xdigit:]]+ -0123456789ABCDEFabcdef (1,23)
E [[:bogus-character-class-name:] NULL ECTYPE
# Range expressions (assuming that the C locale is being used)
E [a-z]+ ABCabcxyzABC (3,9)
E [z-a]+ NULL ERANGE
B [a-b-c] NULL ERANGE
E [a-a]+ zaaaaab (1,6)
E [--Z]+ !ABC-./XYZ~ (1,10)
B [*--] - (0,1)
B SAME * (0,1)
E [*--Z]+ !+*,---ABC (1,7)
E [a-]+ xa-a--a-ay (1,9)
# REG_ICASE and character sets
Ei [a-c]* cABbage (0,5)
Ei [^a-c]* tObAcCo (0,2)
Ei [A-C]* cABbage (0,5)
Ei [^A-C]* tObAcCo (0,2)
# Complex character sets
E [[:digit:]a-z#$%]+ __abc#lmn012$x%yz789* (2,20)
Ei [[:digit:]a-z#$%]+ __abcLMN012x%#$yz789* (2,20)
E [^[:digit:]a-z#$%]+ abc#lmn012$x%yz789--@*,abc (18,23)
Ei [^[:digit:]a-z#$%]+ abc#lmn012$x%yz789--@*,abc (18,23)
Ei [^[:digit:]#$%[:xdigit:]]+ abc#lmn012$x%yz789--@*,abc (4,7)
E [^-]+ ---afd*(&,ml--- (3,12)
E [^--Z]+ ---AFD*(&,ml--- (6,12)
Ei [^--Z]+ ---AFD*(&,ml--- (6,10)
# Miscellaneous tests
B abc\(\(de\)\(fg\)\)hi xabcdefghiy (1,10)(4,8)(4,6)(6,8)
B abc*def xabdefy (1,6)
B SAME xabcdefy (1,7)
B SAME xabcccccccdefy (1,13)
B abc\(def\)*ghi xabcghiy (1,7)(?,?)
B SAME xabcdefghi (1,10)(4,7)
B SAME xabcdefdefdefghi (1,16)(10,13)
E a? aaaaa (0,1)
E SAME xaaaaa (0,0)
E a+ aaaaa (0,5)
E SAME xaaaaa (1,6)
# Test anchors and their behaviour with the REG_NEWLINE compilation
# flag and the REG_NOTBOL, REG_NOTEOL execution flags.
#
# Normally, `^' matches the empty string at beginning of input.
# If REG_NOTBOL is used, `^' won't match the zero length string.
B ^abc abcdef (0,3)
Bb SAME abcdef NOMATCH
B SAME xyzabcdef NOMATCH
Bb SAME xyzabcdef NOMATCH
B$ SAME \nabcdef NOMATCH
Bb$ SAME \nabcdef NOMATCH
# Normally, `$' matches the empty string at end of input.
# If REG_NOTEOL is used, `$' won't match the zero length string.
B abc$ defabc (3,6)
Be SAME defabc NOMATCH
B SAME defabcxyz NOMATCH
Be SAME defabcxyz NOMATCH
B$ SAME defabc\n NOMATCH
Be$ SAME defabc\n NOMATCH
B ^abc$ abc (0,3)
Bb SAME abc NOMATCH
Be SAME abc NOMATCH
Bbe SAME abc NOMATCH
B$ SAME \nabc\n NOMATCH
B$ SAME defabc\n NOMATCH
B$ SAME \nabcdef NOMATCH
B SAME abcdef NOMATCH
B SAME defabc NOMATCH
B$ SAME abc\ndef NOMATCH
B$ SAME def\nabc NOMATCH
# If REG_NEWLINE is used, `^' matches the empty string immediately after
# a newline, regardless of whether execution flags contain REG_NOTBOL.
# Similarly, if REG_NEWLINE is used, `$' matches the empty string
# immediately before a newline, regardless of execution flags.
Bn ^abc abcdef (0,3)
Bbn SAME abcdef NOMATCH
Bn SAME xyzabcdef NOMATCH
Bbn SAME xyzabcdef NOMATCH
Bn$ SAME \nabcdef (1,4)
Bbn$ SAME \nabcdef (1,4)
Bn abc$ defabc (3,6)
Ben SAME defabc NOMATCH
Bn SAME defabcxyz NOMATCH
Ben SAME defabcxyz NOMATCH
Bn$ SAME defabc\n (3,6)
Ben$ SAME defabc\n (3,6)
Bn ^abc$ abc (0,3)
Bbn SAME abc NOMATCH
Ben SAME abc NOMATCH
Bben SAME abc NOMATCH
Bn$ SAME \nabc\n (1,4)
Bn$ SAME defabc\n NOMATCH
Bn$ SAME \nabcdef NOMATCH
Bn SAME abcdef NOMATCH
Bbn SAME abcdef NOMATCH
Bn SAME defabc NOMATCH
Ben SAME defabc NOMATCH
Bn$ SAME abc\ndef (0,3)
Bbn$ SAME abc\ndef NOMATCH
Ben$ SAME abc\ndef (0,3)
Bbn$ SAME abc\ndef NOMATCH
Bn$ SAME def\nabc (4,7)
Bbn$ SAME def\nabc (4,7)
Ben$ SAME def\nabc NOMATCH
Bben$ SAME def\nabc NOMATCH
# With BRE syntax, `^' has a special meaning only at the beginning of the
# RE or the beginning of a parenthesized subexpression.
B a\{0,1\}^bc bc NOMATCH
B SAME ^bc (0,3)
B SAME abc NOMATCH
B SAME a^bc (0,4)
B a\{0,1\}\(^bc\) bc (0,2)(0,2)
B SAME ^bc NOMATCH
B SAME abc NOMATCH
B SAME a^bc NOMATCH
B (^a (^a (0,3)
# With BRE syntax, `$' has a special meaning only at the end of the
# RE or the end of a parenthesized subexpression.
B ab$c\{0,1\} ab NOMATCH
B SAME ab$ (0,3)
B SAME abc NOMATCH
B SAME ab$c (0,4)
B \(ab$\)c\{0,1\} ab (0,2)(0,2)
B SAME ab$ NOMATCH
B SAME abc NOMATCH
B SAME ab$c NOMATCH
B a$) a$) (0,3)
# Miscellaneous tests for `^' and `$'
E foo^$ foo NOMATCH
En$ x$\n^y foo\nybarx\nyes\n (8,11)
B ^$ x NOMATCH
B SAME NULL (0,0)
B$ SAME \n NOMATCH
Bn ^$ x NOMATCH
Bn SAME NULL (0,0)
Bn$ SAME \n (0,0)
# REG_NEWLINE causes `.' not to match newlines
B$ .* ab\ncd (0,5)
Bn$ .* ab\ncd (0,2)
# Tests for nonstandard syntax extensions (Enhanced mode off)
#
# Zero width assertions (Enhanced mode off)
BE \<x aax xaa NOMATCH
BE SAME <x (0,2)
BE x\> axx xaa NOMATCH
BE SAME x> (0,2)
BE \bx axx xaa NOMATCH
BE SAME bx (0,2)
BE x\b axx xaa NOMATCH
BE SAME xb (0,2)
BE \Bx aax xxa NOMATCH
BE SAME Bx (0,2)
BE \Bx\b aax xxx NOMATCH
BE \Bx\b Bxb (0,3)
BE \<. ;xaa NOMATCH
BE SAME <a (0,2)
# Shorthands for character classes (Enhanced mode off)
B \w\{1,\} ,.(a23_Nt-öo) NOMATCH
B SAME vwx (1,2)
E \w{1,} ,.(a23_Nt-öo) NOMATCH
E SAME vwx (1,2)
B \d\{1,\} uR120_4=v4 NOMATCH
B SAME cdef (1,2)
E \d{1,} uR120_4=v4 NOMATCH
E SAME cdef (1,2)
B \D\{1,\} 120d_=vA4s NOMATCH
B SAME CDEF (1,2)
E \D{1,} 120d_=vA4s NOMATCH
E SAME CDEF (1,2)
E \w+ ,.(a23_Nt-öo) NOMATCH
E SAME vwx (1,2)
E \d+ uR120_4=v4 NOMATCH
E SAME cdef (1,2)
E \D+ 120d_=vA4s NOMATCH
E SAME CDEF (1,2)
# Quoted special characters (Enhanced mode off)
BE$ \\t \t NOMATCH
BE$ SAME t (0,1)
BE$ \\e \033 NOMATCH
BE$ \\e e (0,1)
# Test the \x1B and \x{263a} extensions for specifying 8 bit and wide
# characters in hexadecimal. (Enhanced mode off)
BE \x41 ABC NOMATCH
BE SAME x41 (0,3)
BE$ \\x5 \005 NOMATCH
BE$ SAME x5 (0,2)
BE$ \\x5r \005r NOMATCH
BE$ SAME x5r (0,3)
# test_comp("\\x",REG_EXTENDED,0)
# test_nexec("\000",1,0,REG_OK,0,1)
# test_comp("\\xr",REG_EXTENDED,0)
# test_nexec("\000r",2,0,REG_OK,0,2)
BE \x{41} ABC NOMATCH
B SAME x{41} (0,5)
E SAME xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx (0,41)
BE$ \\x{5} \005 NOMATCH
B$ SAME x{5} (0,4)
E$ SAME xxxxx (0,5)
BE$ \\x{5}r \005r NOMATCH
B$ SAME x{5}r (0,5)
E$ SAME xxxxxr (0,6)
# test_comp("\\x{}",REG_EXTENDED,0)
# test_nexec("\000",1,0,REG_OK,0,1)
# test_comp("\\x{}r",REG_EXTENDED,0)
# test_nexec("\000r",2,0,REG_OK,0,2)
# Tests for (?inrU-inrU) and (?inrU-inrU:) (Enhanced mode off)
E foo(?i)bar fooBaR BADRPT
E foo(?i)bar|zap fooBaR BADRPT
E SAME foozap BADRPT
E SAME foozAp BADRPT
E SAME bar BADRPT
E SAME zap BADRPT
Ei foo(?-i:zap)zot FoOzapZOt BADRPT
Ei SAME FoOzApZOt BADRPT
E foo(?i:bar|zap) foozap BADRPT
E SAME foobar BADRPT
E SAME foobAr BADRPT
E SAME fooZaP BADRPT
E foo(?U:o*)(o*) foooo BADRPT
# Test comment syntax (Enhanced mode off)
E foo(?# This here is a comment. )bar foobar BADRPT
# Tests for \Q and \E (Enhanced mode off)
E \((\Q)?:\<[^$\E) ()?:\<[^$ EBRACK
E \Qabc\E.* abcdef NOMATCH
E SAME QabcEdef (0,8)
E \Qabc\E.*|foo parabc123wxyz NOMATCH
E SAME fooabc123wxyz (0,3)
E SAME QabcEdef (0,8)
# Test bounded repetitions
E a{0,0} aaa (0,0)
E a{0,1} aaa (0,1)
E a{1,1} aaa (0,1)
E a{1,3} xaaaaa (1,4)
E a{0,3} aaaaa (0,3)
E a{0,} NULL (0,0)
E SAME a (0,1)
E SAME aa (0,2)
E SAME aaa (0,3)
E a{1,} NULL NOMATCH
E SAME a (0,1)
E SAME aa (0,2)
E SAME aaa (0,3)
E a{2,} NULL NOMATCH
E SAME a NOMATCH
E SAME aa (0,2)
E SAME aaa (0,3)
E a{3,} NULL NOMATCH
E SAME a NOMATCH
E SAME aa NOMATCH
E SAME aaa (0,3)
E SAME aaaa (0,4)
E SAME aaaaa (0,5)
E SAME aaaaaa (0,6)
E SAME aaaaaaa (0,7)
E a{5,10} aaaaaaa (0,7)
E a{6,6} aaaaaaaaaaaa (0,6)
E SAME xxaaaaaaaaaaaa (2,8)
E SAME xxaaaaa NOMATCH
E a{5,6} aaaaaaaaaaaa (0,6)
E SAME xxaaaaaaaaaaaa (2,8)
E SAME xxaaaaa (2,7)
E SAME xxaaaa NOMATCH
# Trickier ones...
E ([ab]{5,10})*b bbbbbabaaaaab (0,13)(7,12)
E SAME bbbbbbaaaaab (0,12)(6,11)
E SAME bbbbbbaaaab (0,11)(0,10)
E SAME bbbbbbaaab (0,10)(0,9)
E SAME bbbbbbaab (0,9)(0,8)
E SAME bbbbbbab (0,8)(0,7)
E ([ab]*)(ab[ab]{5,10})ba abbabbbabaabbbbbbbbbbbbbabaaaabab (0,10)(0,0)(0,8)
E SAME abbabbbabaabbbbbbbbbbbbabaaaaabab (0,32)(0,23)(23,30)
E SAME abbabbbabaabbbbbbbbbbbbabaaaabab (0,24)(0,10)(10,22)
E SAME abbabbbabaabbbbbbbbbbbba (0,24)(0,10)(10,22)
# Test repeating something that has submatches inside
E (a){0,5} NULL (0,0)(?,?)
E SAME a (0,1)(0,1)
E SAME aa (0,2)(1,2)
E SAME aaa (0,3)(2,3)
E SAME aaaa (0,4)(3,4)
E SAME aaaaa (0,5)(4,5)
E SAME aaaaaa (0,5)(4,5)
E (a){2,3} NULL NOMATCH
E SAME a NOMATCH
E SAME aa (0,2)(1,2)
E SAME aaa (0,3)(2,3)
E SAME aaaa (0,3)(2,3)
B \(a\)\{4\} aaaa (0,4)(3,4)
B \(a*\)\{2\} a (0,1)(1,1)
E ((..)|(.)){2} aa (0,2)(1,2)(?,?)(1,2)
# Nested repeats
#E (.){2}{3} xxxxx NOMATCH
#E SAME xxxxxx (0,6)(5,6)
#E (..){2}{3} xxxxxxxxxxx NOMATCH
#E SAME xxxxxxxxxxxx (0,12)(10,12)
E ((..){2}.){3} xxxxxxxxxxxxxx NOMATCH
E SAME xxxxxxxxxxxxxxx (0,15)(10,15)(12,14)
E ((..){1,2}.){3} xxxxxxxx NOMATCH
E SAME xxxxxxxxx (0,9)(6,9)(6,8)
E SAME xxxxxxxxxx (0,9)(6,9)(6,8)
E SAME xxxxxxxxxxx (0,11)(8,11)(8,10)
#E a{2}{2}x NULL NOMATCH
#E SAME x NOMATCH
#E SAME ax NOMATCH
#E SAME aax NOMATCH
#E SAME aaax NOMATCH
#E SAME aaaax (0,5)
#E SAME aaaaax (1,6)
#E SAME aaaaaax (2,7)
#E SAME aaaaaaax (3,8)
#E SAME aaaaaaaax (4,9)
# Repeats with iterations inside
E$ ([a-z]+){2,5} a\n NOMATCH
E$ SAME aa\n (0,2)(1,2)
# Multiple repeats in one regexp
E a{3}b{3} aaabbb (0,6)
E SAME aaabbbb (0,6)
E SAME aaaabbb (1,7)
E SAME aabbb NOMATCH
E SAME aaabb NOMATCH
# Test that different types of repetitions work correctly when used
# in the same regexp.
#E a{2}{2}xb+xc*xd?x aaaaxbxcxdx (0,11)
#E SAME aaaxbxcxdx NOMATCH
#E SAME aabxcxdx NOMATCH
#E SAME aaaacxdx NOMATCH
#E SAME aaaaxbdx NOMATCH
E ^!packet [0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3} [0-9]+ !packet 10.0.2.4 12765 ei voittoa (0,22)
# Back referencing tests
B \([a-z]*\) \1 foobar foobar (0,13)(0,6)
# Searching for a leftmost longest square (repeated string)
B \(.*\)\1 foobarfoobar (0,12)(0,6)
B a\(b\)*c\1 acb NOMATCH
B SAME abbcbbb (0,5)(2,3)
B SAME abbdbd NOMATCH
B \([a-c]*\)\1 abcacdef (0,0)(0,0)
B SAME abcabcabcd (0,6)(0,3)
B \(a*\)*\(x\)\(\1\) x (0,1)(0,0)(0,1)(1,1)
B SAME ax (0,2)(1,1)(1,2)(2,2)
B \(a\)\1\{1,2\} aabc (0,2)(0,1)
B \(\)\(\1\1\)* NULL (0,0)(0,0)(0,0)
# Check that back references work with REG_NOSUB
Bw \(o\)\1 foobar NULL
B \(o\)\1 foobar (1,3)(1,2)
B SAME fobar NOMATCH
B \1foo NULL ESUBREG
B \1foo\(bar\) x ESUBREG
# Back reference with zero-width assertion
B \(.\)\1$ foox NOMATCH
B SAME foo (1,3)(1,2)
# Back references together with {}
B \([0-9]\{5\}\)\1 12345 NOMATCH
B SAME 1234512345 (0,10)(0,5)
B \([0-9]\{4\}\)\1 1234 NOMATCH
B SAME 12341234 (0,8)(0,4)
# Test minimal repetitions (non-greedy repetitions)
#
# Basic
E .*? abcd BADRPT
E .+? abcd BADRPT
E .?? abcd BADRPT
E .{2,5}? abcd BADRPT
# More complicated
E <b>(.*?)</b> <b>text1</b><b>text2</b> BADRPT
E a(.*?)(foo|bar|zap) hubba wooga-booga zabar gafoo wazap BADRPT
##### Extras
# ^ magic after |
E (a|^b) bas (0,1)(0,1)
# Lack of +, ? and |
B a+ a+ (0,2)
B a\+ a+ (0,2)
B a? a? (0,2)
B a\? a? (0,2)
B a|b a|b (0,3)
B a\|b a|b (0,3)
# Lack of backref
E (a)\1 a1 (0,2)(0,1)
# Lack of minimal repetition
B a*? a? (0,2)
E a*? a? BADRPT
BE a*\? a? (0,2)