Loading...
--- Libc/Libc-1725.40.4/tests/regex/datafiles/tre-tests.dat
+++ /dev/null
@@ -1,577 +0,0 @@
-# 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)