5936 lines
		
	
	
		
			100 KiB
		
	
	
	
		
			Plaintext
		
	
	
	
			
		
		
	
	
			5936 lines
		
	
	
		
			100 KiB
		
	
	
	
		
			Plaintext
		
	
	
	
# This set of tests is not Perl-compatible. It checks on special features
 | 
						||
# of PCRE2's API, error diagnostics, and the compiled code of some patterns.
 | 
						||
# It also checks the non-Perl syntax that PCRE2 supports (Python, .NET,
 | 
						||
# Oniguruma). There are also some tests where PCRE2 and Perl differ,
 | 
						||
# either because PCRE2 can't be compatible, or there is a possible Perl
 | 
						||
# bug.
 | 
						||
 | 
						||
# NOTE: This is a non-UTF set of tests. When UTF support is needed, use
 | 
						||
# test 5.
 | 
						||
 | 
						||
#forbid_utf
 | 
						||
#newline_default lf any anycrlf
 | 
						||
 | 
						||
# Test binary zeroes in the pattern
 | 
						||
 | 
						||
# /a\0B/ where 0 is a binary zero
 | 
						||
/61 5c 00 62/B,hex
 | 
						||
    a\x{0}b
 | 
						||
 | 
						||
# /a0b/ where 0 is a binary zero
 | 
						||
/61 00 62/B,hex
 | 
						||
    a\x{0}b
 | 
						||
 | 
						||
# /(?#B0C)DE/ where 0 is a binary zero
 | 
						||
/28 3f 23 42 00 43 29 44 45/B,hex
 | 
						||
    DE
 | 
						||
 | 
						||
/(a)b|/I
 | 
						||
 | 
						||
/abc/I
 | 
						||
    abc
 | 
						||
    defabc
 | 
						||
    abc\=anchored
 | 
						||
\= Expect no match
 | 
						||
    defabc\=anchored
 | 
						||
    ABC
 | 
						||
 | 
						||
/^abc/I
 | 
						||
    abc
 | 
						||
    abc\=anchored
 | 
						||
\= Expect no match
 | 
						||
    defabc
 | 
						||
    defabc\=anchored
 | 
						||
 | 
						||
/a+bc/I
 | 
						||
 | 
						||
/a*bc/I
 | 
						||
 | 
						||
/a{3}bc/I
 | 
						||
 | 
						||
/(abc|a+z)/I
 | 
						||
 | 
						||
/^abc$/I
 | 
						||
    abc
 | 
						||
\= Expect no match
 | 
						||
    def\nabc
 | 
						||
 | 
						||
/ab\idef/
 | 
						||
 | 
						||
/(?X)ab\idef/
 | 
						||
 | 
						||
/x{5,4}/
 | 
						||
 | 
						||
/z{65536}/
 | 
						||
 | 
						||
/[abcd/
 | 
						||
 | 
						||
/[\B]/B
 | 
						||
 | 
						||
/[\R]/B
 | 
						||
 | 
						||
/[\X]/B
 | 
						||
 | 
						||
/[z-a]/
 | 
						||
 | 
						||
/^*/
 | 
						||
 | 
						||
/(abc/
 | 
						||
 | 
						||
/(?# abc/
 | 
						||
 | 
						||
/(?z)abc/
 | 
						||
 | 
						||
/.*b/I
 | 
						||
 | 
						||
/.*?b/I
 | 
						||
 | 
						||
/cat|dog|elephant/I
 | 
						||
    this sentence eventually mentions a cat
 | 
						||
    this sentences rambles on and on for a while and then reaches elephant
 | 
						||
 | 
						||
/cat|dog|elephant/I
 | 
						||
    this sentence eventually mentions a cat
 | 
						||
    this sentences rambles on and on for a while and then reaches elephant
 | 
						||
 | 
						||
/cat|dog|elephant/Ii
 | 
						||
    this sentence eventually mentions a CAT cat
 | 
						||
    this sentences rambles on and on for a while to elephant ElePhant
 | 
						||
 | 
						||
/a|[bcd]/I
 | 
						||
 | 
						||
/(a|[^\dZ])/I
 | 
						||
 | 
						||
/(a|b)*[\s]/I
 | 
						||
 | 
						||
/(ab\2)/
 | 
						||
 | 
						||
/{4,5}abc/
 | 
						||
 | 
						||
/(a)(b)(c)\2/I
 | 
						||
    abcb
 | 
						||
    abcb\=ovector=0
 | 
						||
    abcb\=ovector=1
 | 
						||
    abcb\=ovector=2
 | 
						||
    abcb\=ovector=3
 | 
						||
    abcb\=ovector=4
 | 
						||
 | 
						||
/(a)bc|(a)(b)\2/I
 | 
						||
    abc
 | 
						||
    abc\=ovector=0
 | 
						||
    abc\=ovector=1
 | 
						||
    abc\=ovector=2
 | 
						||
    aba
 | 
						||
    aba\=ovector=0
 | 
						||
    aba\=ovector=1
 | 
						||
    aba\=ovector=2
 | 
						||
    aba\=ovector=3
 | 
						||
    aba\=ovector=4
 | 
						||
 | 
						||
/abc$/I,dollar_endonly
 | 
						||
    abc
 | 
						||
\= Expect no match
 | 
						||
    abc\n
 | 
						||
    abc\ndef
 | 
						||
 | 
						||
/(a)(b)(c)(d)(e)\6/
 | 
						||
 | 
						||
/the quick brown fox/I
 | 
						||
    the quick brown fox
 | 
						||
    this is a line with the quick brown fox
 | 
						||
 | 
						||
/the quick brown fox/I,anchored
 | 
						||
    the quick brown fox
 | 
						||
\= Expect no match
 | 
						||
    this is a line with the quick brown fox
 | 
						||
 | 
						||
/ab(?z)cd/
 | 
						||
 | 
						||
/^abc|def/I
 | 
						||
    abcdef
 | 
						||
    abcdef\=notbol
 | 
						||
 | 
						||
/.*((abc)$|(def))/I
 | 
						||
    defabc
 | 
						||
    defabc\=noteol
 | 
						||
 | 
						||
/)/
 | 
						||
 | 
						||
/a[]b/
 | 
						||
 | 
						||
/[^aeiou ]{3,}/I
 | 
						||
    co-processors, and for
 | 
						||
 | 
						||
/<.*>/I
 | 
						||
    abc<def>ghi<klm>nop
 | 
						||
 | 
						||
/<.*?>/I
 | 
						||
    abc<def>ghi<klm>nop
 | 
						||
 | 
						||
/<.*>/I,ungreedy
 | 
						||
    abc<def>ghi<klm>nop
 | 
						||
 | 
						||
/(?U)<.*>/I
 | 
						||
    abc<def>ghi<klm>nop
 | 
						||
 | 
						||
/<.*?>/I,ungreedy
 | 
						||
    abc<def>ghi<klm>nop
 | 
						||
 | 
						||
/={3,}/I,ungreedy
 | 
						||
    abc========def
 | 
						||
 | 
						||
/(?U)={3,}?/I
 | 
						||
    abc========def
 | 
						||
 | 
						||
/(?<!bar|cattle)foo/I
 | 
						||
    foo
 | 
						||
    catfoo
 | 
						||
\= Expect no match
 | 
						||
    the barfoo
 | 
						||
    and cattlefoo
 | 
						||
 | 
						||
/abc(?<=a+)b/
 | 
						||
 | 
						||
/12345(?<=aaa|b{0,3})b/
 | 
						||
 | 
						||
/(?<!(foo)a\1)bar/
 | 
						||
 | 
						||
/(?i)abc/I
 | 
						||
 | 
						||
/(a|(?m)a)/I
 | 
						||
 | 
						||
/(?i)^1234/I
 | 
						||
 | 
						||
/(^b|(?i)^d)/I
 | 
						||
 | 
						||
/(?s).*/I
 | 
						||
 | 
						||
/[abcd]/I
 | 
						||
 | 
						||
/(?i)[abcd]/I
 | 
						||
 | 
						||
/(?m)[xy]|(b|c)/I
 | 
						||
 | 
						||
/(^a|^b)/Im
 | 
						||
 | 
						||
/(?i)(^a|^b)/Im
 | 
						||
 | 
						||
/(a)(?(1)a|b|c)/
 | 
						||
 | 
						||
/(?(?=a)a|b|c)/
 | 
						||
 | 
						||
/(?(1a)/
 | 
						||
 | 
						||
/(?(1a))/
 | 
						||
 | 
						||
/(?(?i))/
 | 
						||
 | 
						||
/(?(abc))/
 | 
						||
 | 
						||
/(?(?<ab))/
 | 
						||
 | 
						||
/((?s)blah)\s+\1/I
 | 
						||
 | 
						||
/((?i)blah)\s+\1/I
 | 
						||
 | 
						||
/((?i)b)/IB
 | 
						||
 | 
						||
/(a*b|(?i:c*(?-i)d))/I
 | 
						||
 | 
						||
/a$/I
 | 
						||
    a
 | 
						||
    a\n
 | 
						||
\= Expect no match
 | 
						||
    a\=noteol
 | 
						||
    a\n\=noteol
 | 
						||
 | 
						||
/a$/Im
 | 
						||
    a
 | 
						||
    a\n
 | 
						||
    a\n\=noteol
 | 
						||
\= Expect no match
 | 
						||
    a\=noteol
 | 
						||
 | 
						||
/\Aabc/Im
 | 
						||
 | 
						||
/^abc/Im
 | 
						||
 | 
						||
/^((a+)(?U)([ab]+)(?-U)([bc]+)(\w*))/I
 | 
						||
  aaaaabbbbbcccccdef
 | 
						||
 | 
						||
/(?<=foo)[ab]/I
 | 
						||
 | 
						||
/(?<!foo)(alpha|omega)/I
 | 
						||
 | 
						||
/(?!alphabet)[ab]/I
 | 
						||
 | 
						||
/(?<=foo\n)^bar/Im
 | 
						||
    foo\nbarbar
 | 
						||
\= Expect no match
 | 
						||
    rhubarb
 | 
						||
    barbell
 | 
						||
    abc\nbarton
 | 
						||
 | 
						||
/^(?<=foo\n)bar/Im
 | 
						||
    foo\nbarbar
 | 
						||
\= Expect no match
 | 
						||
    rhubarb
 | 
						||
    barbell
 | 
						||
    abc\nbarton
 | 
						||
 | 
						||
/(?>^abc)/Im
 | 
						||
    abc
 | 
						||
    def\nabc
 | 
						||
\= Expect no match
 | 
						||
    defabc
 | 
						||
 | 
						||
/(?<=ab(c+)d)ef/
 | 
						||
 | 
						||
/(?<=ab(?<=c+)d)ef/
 | 
						||
 | 
						||
/(?<=ab(c|de)f)g/
 | 
						||
 | 
						||
/The next three are in testinput2 because they have variable length branches/
 | 
						||
 | 
						||
/(?<=bullock|donkey)-cart/I
 | 
						||
    the bullock-cart
 | 
						||
    a donkey-cart race
 | 
						||
\= Expect no match
 | 
						||
    cart
 | 
						||
    horse-and-cart
 | 
						||
 | 
						||
/(?<=ab(?i)x|y|z)/I
 | 
						||
 | 
						||
/(?>.*)(?<=(abcd)|(xyz))/I
 | 
						||
    alphabetabcd
 | 
						||
    endingxyz
 | 
						||
 | 
						||
/(?<=ab(?i)x(?-i)y|(?i)z|b)ZZ/I
 | 
						||
    abxyZZ
 | 
						||
    abXyZZ
 | 
						||
    ZZZ
 | 
						||
    zZZ
 | 
						||
    bZZ
 | 
						||
    BZZ
 | 
						||
\= Expect no match
 | 
						||
    ZZ
 | 
						||
    abXYZZ
 | 
						||
    zzz
 | 
						||
    bzz
 | 
						||
 | 
						||
/(?<!(foo)a)bar/I
 | 
						||
    bar
 | 
						||
    foobbar
 | 
						||
\= Expect no match
 | 
						||
    fooabar
 | 
						||
 | 
						||
# Perl does not fail these two for the final subjects.
 | 
						||
 | 
						||
/^(xa|=?\1a){2}$/
 | 
						||
    xa=xaa
 | 
						||
\= Expect no match
 | 
						||
    xa=xaaa
 | 
						||
 | 
						||
/^(xa|=?\1a)+$/
 | 
						||
    xa=xaa
 | 
						||
\= Expect no match
 | 
						||
    xa=xaaa
 | 
						||
 | 
						||
# These are syntax tests from Perl 5.005
 | 
						||
 | 
						||
/a[b-a]/
 | 
						||
 | 
						||
/a[]b/
 | 
						||
 | 
						||
/a[/
 | 
						||
 | 
						||
/*a/
 | 
						||
 | 
						||
/(*)b/
 | 
						||
 | 
						||
/abc)/
 | 
						||
 | 
						||
/(abc/
 | 
						||
 | 
						||
/a**/
 | 
						||
 | 
						||
/)(/
 | 
						||
 | 
						||
/\1/
 | 
						||
 | 
						||
/\2/
 | 
						||
 | 
						||
/(a)|\2/
 | 
						||
 | 
						||
/a[b-a]/Ii
 | 
						||
 | 
						||
/a[]b/Ii
 | 
						||
 | 
						||
/a[/Ii
 | 
						||
 | 
						||
/*a/Ii
 | 
						||
 | 
						||
/(*)b/Ii
 | 
						||
 | 
						||
/abc)/Ii
 | 
						||
 | 
						||
/(abc/Ii
 | 
						||
 | 
						||
/a**/Ii
 | 
						||
 | 
						||
/)(/Ii
 | 
						||
 | 
						||
/:(?:/
 | 
						||
 | 
						||
/(?<%)b/
 | 
						||
 | 
						||
/a(?{)b/
 | 
						||
 | 
						||
/a(?{{})b/
 | 
						||
 | 
						||
/a(?{}})b/
 | 
						||
 | 
						||
/a(?{"{"})b/
 | 
						||
 | 
						||
/a(?{"{"}})b/
 | 
						||
 | 
						||
/(?(1?)a|b)/
 | 
						||
 | 
						||
/[a[:xyz:/
 | 
						||
 | 
						||
/(?<=x+)y/
 | 
						||
 | 
						||
/a{37,17}/
 | 
						||
 | 
						||
/abc/\
 | 
						||
 | 
						||
/abc/\i
 | 
						||
 | 
						||
/(a)bc(d)/I
 | 
						||
    abcd
 | 
						||
    abcd\=copy=2
 | 
						||
    abcd\=copy=5
 | 
						||
 | 
						||
/(.{20})/I
 | 
						||
    abcdefghijklmnopqrstuvwxyz
 | 
						||
    abcdefghijklmnopqrstuvwxyz\=copy=1
 | 
						||
    abcdefghijklmnopqrstuvwxyz\=get=1
 | 
						||
 | 
						||
/(.{15})/I
 | 
						||
    abcdefghijklmnopqrstuvwxyz
 | 
						||
    abcdefghijklmnopqrstuvwxyz\=copy=1,get=1
 | 
						||
 | 
						||
/(.{16})/I
 | 
						||
    abcdefghijklmnopqrstuvwxyz
 | 
						||
    abcdefghijklmnopqrstuvwxyz\=copy=1,get=1,getall
 | 
						||
 | 
						||
/^(a|(bc))de(f)/I
 | 
						||
    adef\=get=1,get=2,get=3,get=4,getall
 | 
						||
    bcdef\=get=1,get=2,get=3,get=4,getall
 | 
						||
    adefghijk\=copy=0
 | 
						||
 | 
						||
/^abc\00def/I
 | 
						||
    abc\00def\=copy=0,getall
 | 
						||
 | 
						||
/word ((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+
 | 
						||
)((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+ )((?:[a-zA-Z0-9]+
 | 
						||
)?)?)?)?)?)?)?)?)?otherword/I
 | 
						||
 | 
						||
/.*X/IB
 | 
						||
 | 
						||
/.*X/IBs
 | 
						||
 | 
						||
/(.*X|^B)/IB
 | 
						||
 | 
						||
/(.*X|^B)/IBs
 | 
						||
 | 
						||
/(?s)(.*X|^B)/IB
 | 
						||
 | 
						||
/(?s:.*X|^B)/IB
 | 
						||
 | 
						||
/\Biss\B/I,aftertext
 | 
						||
    Mississippi
 | 
						||
 | 
						||
/iss/I,aftertext,altglobal
 | 
						||
    Mississippi
 | 
						||
 | 
						||
/\Biss\B/I,aftertext,altglobal
 | 
						||
    Mississippi
 | 
						||
 | 
						||
/\Biss\B/Ig,aftertext
 | 
						||
    Mississippi
 | 
						||
\= Expect no match
 | 
						||
    Mississippi\=anchored
 | 
						||
 | 
						||
/(?<=[Ms])iss/Ig,aftertext
 | 
						||
    Mississippi
 | 
						||
 | 
						||
/(?<=[Ms])iss/I,aftertext,altglobal
 | 
						||
    Mississippi
 | 
						||
 | 
						||
/^iss/Ig,aftertext
 | 
						||
    ississippi
 | 
						||
 | 
						||
/.*iss/Ig,aftertext
 | 
						||
    abciss\nxyzisspqr
 | 
						||
 | 
						||
/.i./Ig,aftertext
 | 
						||
    Mississippi
 | 
						||
    Mississippi\=anchored
 | 
						||
    Missouri river
 | 
						||
    Missouri river\=anchored
 | 
						||
 | 
						||
/^.is/Ig,aftertext
 | 
						||
    Mississippi
 | 
						||
 | 
						||
/^ab\n/Ig,aftertext
 | 
						||
    ab\nab\ncd
 | 
						||
 | 
						||
/^ab\n/Igm,aftertext
 | 
						||
    ab\nab\ncd
 | 
						||
 | 
						||
/^/gm,newline=any
 | 
						||
    a\rb\nc\r\nxyz\=aftertext
 | 
						||
 | 
						||
/abc/I
 | 
						||
 | 
						||
/abc|bac/I
 | 
						||
 | 
						||
/(abc|bac)/I
 | 
						||
 | 
						||
/(abc|(c|dc))/I
 | 
						||
 | 
						||
/(abc|(d|de)c)/I
 | 
						||
 | 
						||
/a*/I
 | 
						||
 | 
						||
/a+/I
 | 
						||
 | 
						||
/(baa|a+)/I
 | 
						||
 | 
						||
/a{0,3}/I
 | 
						||
 | 
						||
/baa{3,}/I
 | 
						||
 | 
						||
/"([^\\"]+|\\.)*"/I
 | 
						||
 | 
						||
/(abc|ab[cd])/I
 | 
						||
 | 
						||
/(a|.)/I
 | 
						||
 | 
						||
/a|ba|\w/I
 | 
						||
 | 
						||
/abc(?=pqr)/I
 | 
						||
 | 
						||
/...(?<=abc)/I
 | 
						||
 | 
						||
/abc(?!pqr)/I
 | 
						||
 | 
						||
/ab./I
 | 
						||
 | 
						||
/ab[xyz]/I
 | 
						||
 | 
						||
/abc*/I
 | 
						||
 | 
						||
/ab.c*/I
 | 
						||
 | 
						||
/a.c*/I
 | 
						||
 | 
						||
/.c*/I
 | 
						||
 | 
						||
/ac*/I
 | 
						||
 | 
						||
/(a.c*|b.c*)/I
 | 
						||
 | 
						||
/a.c*|aba/I
 | 
						||
 | 
						||
/.+a/I
 | 
						||
 | 
						||
/(?=abcda)a.*/I
 | 
						||
 | 
						||
/(?=a)a.*/I
 | 
						||
 | 
						||
/a(b)*/I
 | 
						||
 | 
						||
/a\d*/I
 | 
						||
 | 
						||
/ab\d*/I
 | 
						||
 | 
						||
/a(\d)*/I
 | 
						||
 | 
						||
/abcde{0,0}/I
 | 
						||
 | 
						||
/ab\d+/I
 | 
						||
 | 
						||
/a(?(1)b)(.)/I
 | 
						||
 | 
						||
/a(?(1)bag|big)(.)/I
 | 
						||
 | 
						||
/a(?(1)bag|big)*(.)/I
 | 
						||
 | 
						||
/a(?(1)bag|big)+(.)/I
 | 
						||
 | 
						||
/a(?(1)b..|b..)(.)/I
 | 
						||
 | 
						||
/ab\d{0}e/I
 | 
						||
 | 
						||
/a?b?/I
 | 
						||
    a
 | 
						||
    b
 | 
						||
    ab
 | 
						||
    \
 | 
						||
\= Expect no match
 | 
						||
    \=notempty
 | 
						||
 | 
						||
/|-/I
 | 
						||
    abcd
 | 
						||
    -abc
 | 
						||
    ab-c\=notempty
 | 
						||
\= Expect no match
 | 
						||
    abc\=notempty
 | 
						||
 | 
						||
/^.?abcd/I
 | 
						||
 | 
						||
/\(             # ( at start
 | 
						||
  (?:           # Non-capturing bracket
 | 
						||
  (?>[^()]+)    # Either a sequence of non-brackets (no backtracking)
 | 
						||
  |             # Or
 | 
						||
  (?R)          # Recurse - i.e. nested bracketed string
 | 
						||
  )*            # Zero or more contents
 | 
						||
  \)            # Closing )
 | 
						||
  /Ix
 | 
						||
    (abcd)
 | 
						||
    (abcd)xyz
 | 
						||
    xyz(abcd)
 | 
						||
    (ab(xy)cd)pqr
 | 
						||
    (ab(xycd)pqr
 | 
						||
    () abc ()
 | 
						||
    12(abcde(fsh)xyz(foo(bar))lmno)89
 | 
						||
\= Expect no match
 | 
						||
    abcd
 | 
						||
    abcd)
 | 
						||
    (abcd
 | 
						||
 | 
						||
/\(  ( (?>[^()]+) | (?R) )* \) /Igx
 | 
						||
    (ab(xy)cd)pqr
 | 
						||
    1(abcd)(x(y)z)pqr
 | 
						||
 | 
						||
/\(  (?: (?>[^()]+) | (?R) ) \) /Ix
 | 
						||
    (abcd)
 | 
						||
    (ab(xy)cd)
 | 
						||
    (a(b(c)d)e)
 | 
						||
    ((ab))
 | 
						||
\= Expect no match
 | 
						||
    ()
 | 
						||
 | 
						||
/\(  (?: (?>[^()]+) | (?R) )? \) /Ix
 | 
						||
    ()
 | 
						||
    12(abcde(fsh)xyz(foo(bar))lmno)89
 | 
						||
 | 
						||
/\(  ( (?>[^()]+) | (?R) )* \) /Ix
 | 
						||
    (ab(xy)cd)
 | 
						||
 | 
						||
/\( ( ( (?>[^()]+) | (?R) )* ) \) /Ix
 | 
						||
    (ab(xy)cd)
 | 
						||
 | 
						||
/\( (123)? ( ( (?>[^()]+) | (?R) )* ) \) /Ix
 | 
						||
    (ab(xy)cd)
 | 
						||
    (123ab(xy)cd)
 | 
						||
 | 
						||
/\( ( (123)? ( (?>[^()]+) | (?R) )* ) \) /Ix
 | 
						||
    (ab(xy)cd)
 | 
						||
    (123ab(xy)cd)
 | 
						||
 | 
						||
/\( (((((((((( ( (?>[^()]+) | (?R) )* )))))))))) \) /Ix
 | 
						||
    (ab(xy)cd)
 | 
						||
 | 
						||
/\( ( ( (?>[^()<>]+) | ((?>[^()]+)) | (?R) )* ) \) /Ix
 | 
						||
    (abcd(xyz<p>qrs)123)
 | 
						||
 | 
						||
/\( ( ( (?>[^()]+) | ((?R)) )* ) \) /Ix
 | 
						||
    (ab(cd)ef)
 | 
						||
    (ab(cd(ef)gh)ij)
 | 
						||
 | 
						||
/^[[:alnum:]]/IB
 | 
						||
 | 
						||
/^[[:^alnum:]]/IB
 | 
						||
 | 
						||
/^[[:alpha:]]/IB
 | 
						||
 | 
						||
/^[[:^alpha:]]/IB
 | 
						||
 | 
						||
/[_[:alpha:]]/I
 | 
						||
 | 
						||
/^[[:ascii:]]/IB
 | 
						||
 | 
						||
/^[[:^ascii:]]/IB
 | 
						||
 | 
						||
/^[[:blank:]]/IB
 | 
						||
 | 
						||
/^[[:^blank:]]/IB
 | 
						||
 | 
						||
/[\n\x0b\x0c\x0d[:blank:]]/I
 | 
						||
 | 
						||
/^[[:cntrl:]]/IB
 | 
						||
 | 
						||
/^[[:digit:]]/IB
 | 
						||
 | 
						||
/^[[:graph:]]/IB
 | 
						||
 | 
						||
/^[[:lower:]]/IB
 | 
						||
 | 
						||
/^[[:print:]]/IB
 | 
						||
 | 
						||
/^[[:punct:]]/IB
 | 
						||
 | 
						||
/^[[:space:]]/IB
 | 
						||
 | 
						||
/^[[:upper:]]/IB
 | 
						||
 | 
						||
/^[[:xdigit:]]/IB
 | 
						||
 | 
						||
/^[[:word:]]/IB
 | 
						||
 | 
						||
/^[[:^cntrl:]]/IB
 | 
						||
 | 
						||
/^[12[:^digit:]]/IB
 | 
						||
 | 
						||
/^[[:^blank:]]/IB
 | 
						||
 | 
						||
/[01[:alpha:]%]/IB
 | 
						||
 | 
						||
/[[.ch.]]/I
 | 
						||
 | 
						||
/[[=ch=]]/I
 | 
						||
 | 
						||
/[[:rhubarb:]]/I
 | 
						||
 | 
						||
/[[:upper:]]/Ii
 | 
						||
    A
 | 
						||
    a
 | 
						||
 | 
						||
/[[:lower:]]/Ii
 | 
						||
    A
 | 
						||
    a
 | 
						||
 | 
						||
/((?-i)[[:lower:]])[[:lower:]]/Ii
 | 
						||
    ab
 | 
						||
    aB
 | 
						||
\= Expect no match
 | 
						||
    Ab
 | 
						||
    AB
 | 
						||
 | 
						||
/[\200-\110]/I
 | 
						||
 | 
						||
/^(?(0)f|b)oo/I
 | 
						||
 | 
						||
# This one's here because of the large output vector needed
 | 
						||
 | 
						||
/(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\d+(?:\s|$))(\w+)\s+(\270)/I
 | 
						||
     1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 ABC ABC\=ovector=300
 | 
						||
 | 
						||
# This one's here because Perl does this differently and PCRE2 can't at present
 | 
						||
 | 
						||
/(main(O)?)+/I
 | 
						||
    mainmain
 | 
						||
    mainOmain
 | 
						||
 | 
						||
# These are all cases where Perl does it differently (nested captures)
 | 
						||
 | 
						||
/^(a(b)?)+$/I
 | 
						||
    aba
 | 
						||
 | 
						||
/^(aa(bb)?)+$/I
 | 
						||
    aabbaa
 | 
						||
 | 
						||
/^(aa|aa(bb))+$/I
 | 
						||
    aabbaa
 | 
						||
 | 
						||
/^(aa(bb)??)+$/I
 | 
						||
    aabbaa
 | 
						||
 | 
						||
/^(?:aa(bb)?)+$/I
 | 
						||
    aabbaa
 | 
						||
 | 
						||
/^(aa(b(b))?)+$/I
 | 
						||
    aabbaa
 | 
						||
 | 
						||
/^(?:aa(b(b))?)+$/I
 | 
						||
    aabbaa
 | 
						||
 | 
						||
/^(?:aa(b(?:b))?)+$/I
 | 
						||
    aabbaa
 | 
						||
 | 
						||
/^(?:aa(bb(?:b))?)+$/I
 | 
						||
    aabbbaa
 | 
						||
 | 
						||
/^(?:aa(b(?:bb))?)+$/I
 | 
						||
    aabbbaa
 | 
						||
 | 
						||
/^(?:aa(?:b(b))?)+$/I
 | 
						||
    aabbaa
 | 
						||
 | 
						||
/^(?:aa(?:b(bb))?)+$/I
 | 
						||
    aabbbaa
 | 
						||
 | 
						||
/^(aa(b(bb))?)+$/I
 | 
						||
    aabbbaa
 | 
						||
 | 
						||
/^(aa(bb(bb))?)+$/I
 | 
						||
    aabbbbaa
 | 
						||
 | 
						||
# ----------------
 | 
						||
 | 
						||
/#/IBx
 | 
						||
 | 
						||
/a#/IBx
 | 
						||
 | 
						||
/[\s]/IB
 | 
						||
 | 
						||
/[\S]/IB
 | 
						||
 | 
						||
/a(?i)b/IB
 | 
						||
    ab
 | 
						||
    aB
 | 
						||
\= Expect no match
 | 
						||
    AB
 | 
						||
 | 
						||
/(a(?i)b)/IB
 | 
						||
    ab
 | 
						||
    aB
 | 
						||
\= Expect no match
 | 
						||
    AB
 | 
						||
 | 
						||
/   (?i)abc/IBx
 | 
						||
 | 
						||
/#this is a comment
 | 
						||
  (?i)abc/IBx
 | 
						||
 | 
						||
/123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890/IB
 | 
						||
 | 
						||
/\Q123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890/IB
 | 
						||
 | 
						||
/\Q\E/IB
 | 
						||
    \
 | 
						||
 | 
						||
/\Q\Ex/IB
 | 
						||
 | 
						||
/ \Q\E/IB
 | 
						||
 | 
						||
/a\Q\E/IB
 | 
						||
  abc
 | 
						||
  bca
 | 
						||
  bac
 | 
						||
 | 
						||
/a\Q\Eb/IB
 | 
						||
  abc
 | 
						||
 | 
						||
/\Q\Eabc/IB
 | 
						||
 | 
						||
/x*+\w/IB
 | 
						||
\= Expect no match
 | 
						||
    xxxxx
 | 
						||
 | 
						||
/x?+/IB
 | 
						||
 | 
						||
/x++/IB
 | 
						||
 | 
						||
/x{1,3}+/B,no_auto_possess
 | 
						||
 | 
						||
/x{1,3}+/Bi,no_auto_possess
 | 
						||
 | 
						||
/[^x]{1,3}+/B,no_auto_possess
 | 
						||
 | 
						||
/[^x]{1,3}+/Bi,no_auto_possess
 | 
						||
 | 
						||
/(x)*+/IB
 | 
						||
 | 
						||
/^(\w++|\s++)*$/I
 | 
						||
    now is the time for all good men to come to the aid of the party
 | 
						||
\= Expect no match
 | 
						||
    this is not a line with only words and spaces!
 | 
						||
 | 
						||
/(\d++)(\w)/I
 | 
						||
    12345a
 | 
						||
\= Expect no match
 | 
						||
    12345+
 | 
						||
 | 
						||
/a++b/I
 | 
						||
    aaab
 | 
						||
 | 
						||
/(a++b)/I
 | 
						||
    aaab
 | 
						||
 | 
						||
/(a++)b/I
 | 
						||
    aaab
 | 
						||
 | 
						||
/([^()]++|\([^()]*\))+/I
 | 
						||
    ((abc(ade)ufh()()x
 | 
						||
 | 
						||
/\(([^()]++|\([^()]+\))+\)/I
 | 
						||
    (abc)
 | 
						||
    (abc(def)xyz)
 | 
						||
\= Expect no match
 | 
						||
    ((()aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 | 
						||
 | 
						||
/(abc){1,3}+/IB
 | 
						||
 | 
						||
/a+?+/I
 | 
						||
 | 
						||
/a{2,3}?+b/I
 | 
						||
 | 
						||
/(?U)a+?+/I
 | 
						||
 | 
						||
/a{2,3}?+b/I,ungreedy
 | 
						||
 | 
						||
/x(?U)a++b/IB
 | 
						||
    xaaaab
 | 
						||
 | 
						||
/(?U)xa++b/IB
 | 
						||
    xaaaab
 | 
						||
 | 
						||
/^((a+)(?U)([ab]+)(?-U)([bc]+)(\w*))/IB
 | 
						||
 | 
						||
/^x(?U)a+b/IB
 | 
						||
 | 
						||
/^x(?U)(a+)b/IB
 | 
						||
 | 
						||
/[.x.]/I
 | 
						||
 | 
						||
/[=x=]/I
 | 
						||
 | 
						||
/[:x:]/I
 | 
						||
 | 
						||
/\F/I
 | 
						||
 | 
						||
/\l/I
 | 
						||
 | 
						||
/\L/I
 | 
						||
 | 
						||
/\N{name}/I
 | 
						||
 | 
						||
/\u/I
 | 
						||
 | 
						||
/\U/I
 | 
						||
 | 
						||
/a{1,3}b/ungreedy
 | 
						||
    ab
 | 
						||
 | 
						||
/[/I
 | 
						||
 | 
						||
/[a-/I
 | 
						||
 | 
						||
/[[:space:]/I
 | 
						||
 | 
						||
/[\s]/IB
 | 
						||
 | 
						||
/[[:space:]]/IB
 | 
						||
 | 
						||
/[[:space:]abcde]/IB
 | 
						||
 | 
						||
/< (?: (?(R) \d++  | [^<>]*+) | (?R)) * >/Ix
 | 
						||
    <>
 | 
						||
    <abcd>
 | 
						||
    <abc <123> hij>
 | 
						||
    <abc <def> hij>
 | 
						||
    <abc<>def>
 | 
						||
    <abc<>
 | 
						||
\= Expect no match
 | 
						||
    <abc
 | 
						||
 | 
						||
/8J\$WE\<\.rX\+ix\[d1b\!H\#\?vV0vrK\:ZH1\=2M\>iV\;\?aPhFB\<\*vW\@QW\@sO9\}cfZA\-i\'w\%hKd6gt1UJP\,15_\#QY\$M\^Mss_U\/\]\&LK9\[5vQub\^w\[KDD\<EjmhUZ\?\.akp2dF\>qmj\;2\}YWFdYx\.Ap\]hjCPTP\(n28k\+3\;o\&WXqs\/gOXdr\$\:r\'do0\;b4c\(f_Gr\=\"\\4\)\[01T7ajQJvL\$W\~mL_sS\/4h\:x\*\[ZN\=KLs\&L5zX\/\/\>it\,o\:aU\(\;Z\>pW\&T7oP\'2K\^E\:x9\'c\[\%z\-\,64JQ5AeH_G\#KijUKghQw\^\\vea3a\?kka_G\$8\#\`\*kynsxzBLru\'\]k_\[7FrVx\}\^\=\$blx\>s\-N\%j\;D\*aZDnsw\:YKZ\%Q\.Kne9\#hP\?\+b3\(SOvL\,\^\;\&u5\@\?5C5Bhb\=m\-vEh_L15Jl\]U\)0RP6\{q\%L\^_z5E\'Dw6X\b/IB
 | 
						||
 | 
						||
/\$\<\.X\+ix\[d1b\!H\#\?vV0vrK\:ZH1\=2M\>iV\;\?aPhFB\<\*vW\@QW\@sO9\}cfZA\-i\'w\%hKd6gt1UJP\,15_\#QY\$M\^Mss_U\/\]\&LK9\[5vQub\^w\[KDD\<EjmhUZ\?\.akp2dF\>qmj\;2\}YWFdYx\.Ap\]hjCPTP\(n28k\+3\;o\&WXqs\/gOXdr\$\:r\'do0\;b4c\(f_Gr\=\"\\4\)\[01T7ajQJvL\$W\~mL_sS\/4h\:x\*\[ZN\=KLs\&L5zX\/\/\>it\,o\:aU\(\;Z\>pW\&T7oP\'2K\^E\:x9\'c\[\%z\-\,64JQ5AeH_G\#KijUKghQw\^\\vea3a\?kka_G\$8\#\`\*kynsxzBLru\'\]k_\[7FrVx\}\^\=\$blx\>s\-N\%j\;D\*aZDnsw\:YKZ\%Q\.Kne9\#hP\?\+b3\(SOvL\,\^\;\&u5\@\?5C5Bhb\=m\-vEh_L15Jl\]U\)0RP6\{q\%L\^_z5E\'Dw6X\b/IB
 | 
						||
 | 
						||
/(.*)\d+\1/I
 | 
						||
 | 
						||
/(.*)\d+/I
 | 
						||
 | 
						||
/(.*)\d+\1/Is
 | 
						||
 | 
						||
/(.*)\d+/Is
 | 
						||
 | 
						||
/(.*(xyz))\d+\2/I
 | 
						||
 | 
						||
/((.*))\d+\1/I
 | 
						||
    abc123bc
 | 
						||
 | 
						||
/a[b]/I
 | 
						||
 | 
						||
/(?=a).*/I
 | 
						||
 | 
						||
/(?=abc).xyz/Ii
 | 
						||
 | 
						||
/(?=abc)(?i).xyz/I
 | 
						||
 | 
						||
/(?=a)(?=b)/I
 | 
						||
 | 
						||
/(?=.)a/I
 | 
						||
 | 
						||
/((?=abcda)a)/I
 | 
						||
 | 
						||
/((?=abcda)ab)/I
 | 
						||
 | 
						||
/()a/I
 | 
						||
 | 
						||
/(?:(?=.)|(?<!x))a/I
 | 
						||
 | 
						||
/(?(1)ab|ac)(.)/I
 | 
						||
 | 
						||
/(?(1)abz|acz)(.)/I
 | 
						||
 | 
						||
/(?(1)abz)(.)/I
 | 
						||
 | 
						||
/(?(1)abz)(1)23/I
 | 
						||
 | 
						||
/(a)+/I
 | 
						||
 | 
						||
/(a){2,3}/I
 | 
						||
 | 
						||
/(a)*/I
 | 
						||
 | 
						||
/[a]/I
 | 
						||
 | 
						||
/[ab]/I
 | 
						||
 | 
						||
/[ab]/I
 | 
						||
 | 
						||
/[^a]/I
 | 
						||
 | 
						||
/\d456/I
 | 
						||
 | 
						||
/\d456/I
 | 
						||
 | 
						||
/a^b/I
 | 
						||
 | 
						||
/^a/Im
 | 
						||
  abcde
 | 
						||
  xy\nabc
 | 
						||
\= Expect no match
 | 
						||
  xyabc
 | 
						||
 | 
						||
/c|abc/I
 | 
						||
 | 
						||
/(?i)[ab]/I
 | 
						||
 | 
						||
/[ab](?i)cd/I
 | 
						||
 | 
						||
/abc(?C)def/I
 | 
						||
    abcdef
 | 
						||
    1234abcdef
 | 
						||
\= Expect no match
 | 
						||
    abcxyz
 | 
						||
    abcxyzf
 | 
						||
 | 
						||
/abc(?C)de(?C1)f/I
 | 
						||
    123abcdef
 | 
						||
 | 
						||
/(?C1)\dabc(?C2)def/I
 | 
						||
    1234abcdef
 | 
						||
\= Expect no match
 | 
						||
    abcdef
 | 
						||
 | 
						||
/(?C1)\dabc(?C2)def/I
 | 
						||
    1234abcdef
 | 
						||
\= Expect no match
 | 
						||
    abcdef
 | 
						||
 | 
						||
/(?C255)ab/I
 | 
						||
 | 
						||
/(?C256)ab/I
 | 
						||
 | 
						||
/(?Cab)xx/I
 | 
						||
 | 
						||
/(?C12vr)x/I
 | 
						||
 | 
						||
/abc(?C)def/I
 | 
						||
    \x83\x0\x61bcdef
 | 
						||
 | 
						||
/(abc)(?C)de(?C1)f/I
 | 
						||
    123abcdef
 | 
						||
    123abcdef\=callout_capture
 | 
						||
    123abcdefC-\=callout_none
 | 
						||
\= Expect no match
 | 
						||
    123abcdef\=callout_fail=1
 | 
						||
 | 
						||
/(?C0)(abc(?C1))*/I
 | 
						||
    abcabcabc
 | 
						||
    abcabc\=callout_fail=1:4
 | 
						||
    abcabcabc\=callout_fail=1:4
 | 
						||
 | 
						||
/(\d{3}(?C))*/I
 | 
						||
    123\=callout_capture
 | 
						||
    123456\=callout_capture
 | 
						||
    123456789\=callout_capture
 | 
						||
 | 
						||
/((xyz)(?C)p|(?C1)xyzabc)/I
 | 
						||
    xyzabc\=callout_capture
 | 
						||
 | 
						||
/(X)((xyz)(?C)p|(?C1)xyzabc)/I
 | 
						||
    Xxyzabc\=callout_capture
 | 
						||
 | 
						||
/(?=(abc))(?C)abcdef/I
 | 
						||
    abcdef\=callout_capture
 | 
						||
 | 
						||
/(?!(abc)(?C1)d)(?C2)abcxyz/I
 | 
						||
    abcxyz\=callout_capture
 | 
						||
 | 
						||
/(?<=(abc)(?C))xyz/I
 | 
						||
   abcxyz\=callout_capture
 | 
						||
 | 
						||
/a(b+)(c*)(?C1)/I
 | 
						||
\= Expect no match
 | 
						||
    abbbbbccc\=callout_data=1
 | 
						||
 | 
						||
/a(b+?)(c*?)(?C1)/I
 | 
						||
\= Expect no match
 | 
						||
    abbbbbccc\=callout_data=1
 | 
						||
 | 
						||
/(?C)abc/I
 | 
						||
 | 
						||
/(?C)^abc/I
 | 
						||
 | 
						||
/(?C)a|b/I
 | 
						||
 | 
						||
/a|(b)(?C)/I
 | 
						||
    b
 | 
						||
 | 
						||
/x(ab|(bc|(de|(?R))))/I
 | 
						||
    xab
 | 
						||
    xbc
 | 
						||
    xde
 | 
						||
    xxab
 | 
						||
    xxxab
 | 
						||
\= Expect no match
 | 
						||
    xyab
 | 
						||
 | 
						||
/^([^()]|\((?1)*\))*$/I
 | 
						||
    abc
 | 
						||
    a(b)c
 | 
						||
    a(b(c))d
 | 
						||
\= Expect no match)
 | 
						||
    a(b(c)d
 | 
						||
 | 
						||
/^>abc>([^()]|\((?1)*\))*<xyz<$/I
 | 
						||
   >abc>123<xyz<
 | 
						||
   >abc>1(2)3<xyz<
 | 
						||
   >abc>(1(2)3)<xyz<
 | 
						||
 | 
						||
/(a(?1)b)/IB
 | 
						||
 | 
						||
/(a(?1)+b)/IB
 | 
						||
 | 
						||
/^(\d+|\((?1)([+*-])(?1)\)|-(?1))$/I
 | 
						||
    12
 | 
						||
    (((2+2)*-3)-7)
 | 
						||
    -12
 | 
						||
\= Expect no match
 | 
						||
    ((2+2)*-3)-7)
 | 
						||
 | 
						||
/^(x(y|(?1){2})z)/I
 | 
						||
    xyz
 | 
						||
    xxyzxyzz
 | 
						||
\= Expect no match
 | 
						||
    xxyzz
 | 
						||
    xxyzxyzxyzz
 | 
						||
 | 
						||
/((< (?: (?(R) \d++  | [^<>]*+) | (?2)) * >))/Ix
 | 
						||
    <>
 | 
						||
    <abcd>
 | 
						||
    <abc <123> hij>
 | 
						||
    <abc <def> hij>
 | 
						||
    <abc<>def>
 | 
						||
    <abc<>
 | 
						||
\= Expect no match
 | 
						||
    <abc
 | 
						||
 | 
						||
/(?1)/I
 | 
						||
 | 
						||
/((?2)(abc)/I
 | 
						||
 | 
						||
/^(abc)def(?1)/I
 | 
						||
    abcdefabc
 | 
						||
 | 
						||
/^(a|b|c)=(?1)+/I
 | 
						||
    a=a
 | 
						||
    a=b
 | 
						||
    a=bc
 | 
						||
 | 
						||
/^(a|b|c)=((?1))+/I
 | 
						||
    a=a
 | 
						||
    a=b
 | 
						||
    a=bc
 | 
						||
 | 
						||
/a(?P<name1>b|c)d(?P<longername2>e)/IB
 | 
						||
    abde
 | 
						||
    acde
 | 
						||
 | 
						||
/(?:a(?P<c>c(?P<d>d)))(?P<a>a)/IB
 | 
						||
 | 
						||
/(?P<a>a)...(?P=a)bbb(?P>a)d/IB
 | 
						||
 | 
						||
/^\W*(?:(?P<one>(?P<two>.)\W*(?P>one)\W*(?P=two)|)|(?P<three>(?P<four>.)\W*(?P>three)\W*(?P=four)|\W*.\W*))\W*$/Ii
 | 
						||
    1221
 | 
						||
    Satan, oscillate my metallic sonatas!
 | 
						||
    A man, a plan, a canal: Panama!
 | 
						||
    Able was I ere I saw Elba.
 | 
						||
\= Expect no match
 | 
						||
    The quick brown fox
 | 
						||
 | 
						||
/((?(R)a|b))\1(?1)?/I
 | 
						||
  bb
 | 
						||
  bbaa
 | 
						||
 | 
						||
/(.*)a/Is
 | 
						||
 | 
						||
/(.*)a\1/Is
 | 
						||
 | 
						||
/(.*)a(b)\2/Is
 | 
						||
 | 
						||
/((.*)a|(.*)b)z/Is
 | 
						||
 | 
						||
/((.*)a|(.*)b)z\1/Is
 | 
						||
 | 
						||
/((.*)a|(.*)b)z\2/Is
 | 
						||
 | 
						||
/((.*)a|(.*)b)z\3/Is
 | 
						||
 | 
						||
/((.*)a|^(.*)b)z\3/Is
 | 
						||
 | 
						||
/(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)a/Is
 | 
						||
 | 
						||
/(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)a\31/Is
 | 
						||
 | 
						||
/(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)|(.*)a\32/Is
 | 
						||
 | 
						||
/(a)(bc)/IB,no_auto_capture
 | 
						||
  abc
 | 
						||
 | 
						||
/(?P<one>a)(bc)/IB,no_auto_capture
 | 
						||
  abc
 | 
						||
 | 
						||
/(a)(?P<named>bc)/IB,no_auto_capture
 | 
						||
 | 
						||
/(aaa(?C1)bbb|ab)/I
 | 
						||
   aaabbb
 | 
						||
   aaabbb\=callout_data=0
 | 
						||
   aaabbb\=callout_data=1
 | 
						||
\= Expect no match
 | 
						||
   aaabbb\=callout_data=-1
 | 
						||
 | 
						||
/ab(?P<one>cd)ef(?P<two>gh)/I
 | 
						||
    abcdefgh
 | 
						||
    abcdefgh\=copy=1,get=two
 | 
						||
    abcdefgh\=copy=one,copy=two
 | 
						||
    abcdefgh\=copy=three
 | 
						||
 | 
						||
/(?P<Tes>)(?P<Test>)/IB
 | 
						||
 | 
						||
/(?P<Test>)(?P<Tes>)/IB
 | 
						||
 | 
						||
/(?P<Z>zz)(?P<A>aa)/I
 | 
						||
    zzaa\=copy=Z
 | 
						||
    zzaa\=copy=A
 | 
						||
 | 
						||
/(?P<x>eks)(?P<x>eccs)/I
 | 
						||
 | 
						||
/(?P<abc>abc(?P<def>def)(?P<abc>xyz))/I
 | 
						||
 | 
						||
"\[((?P<elem>\d+)(,(?P>elem))*)\]"I
 | 
						||
    [10,20,30,5,5,4,4,2,43,23,4234]
 | 
						||
\= Expect no match
 | 
						||
    []
 | 
						||
 | 
						||
"\[((?P<elem>\d+)(,(?P>elem))*)?\]"I
 | 
						||
    [10,20,30,5,5,4,4,2,43,23,4234]
 | 
						||
    []
 | 
						||
 | 
						||
/(a(b(?2)c))?/IB
 | 
						||
 | 
						||
/(a(b(?2)c))*/IB
 | 
						||
 | 
						||
/(a(b(?2)c)){0,2}/IB
 | 
						||
 | 
						||
/[ab]{1}+/B
 | 
						||
 | 
						||
/()(?1){1}/B
 | 
						||
 | 
						||
/()(?1)/B
 | 
						||
 | 
						||
/((w\/|-|with)*(free|immediate)*.*?shipping\s*[!.-]*)/Ii
 | 
						||
     Baby Bjorn Active Carrier - With free SHIPPING!!
 | 
						||
 | 
						||
/((w\/|-|with)*(free|immediate)*.*?shipping\s*[!.-]*)/Ii
 | 
						||
     Baby Bjorn Active Carrier - With free SHIPPING!!
 | 
						||
 | 
						||
/a*.*b/IB
 | 
						||
 | 
						||
/(a|b)*.?c/IB
 | 
						||
 | 
						||
/abc(?C255)de(?C)f/IB
 | 
						||
 | 
						||
/abcde/IB,auto_callout
 | 
						||
  abcde
 | 
						||
\= Expect no match
 | 
						||
  abcdfe
 | 
						||
 | 
						||
/a*b/IB,auto_callout
 | 
						||
  ab
 | 
						||
  aaaab
 | 
						||
  aaaacb
 | 
						||
 | 
						||
/a*b/IB,auto_callout
 | 
						||
  ab
 | 
						||
  aaaab
 | 
						||
  aaaacb
 | 
						||
 | 
						||
/a+b/IB,auto_callout
 | 
						||
  ab
 | 
						||
  aaaab
 | 
						||
\= Expect no match
 | 
						||
  aaaacb
 | 
						||
 | 
						||
/(abc|def)x/IB,auto_callout
 | 
						||
  abcx
 | 
						||
  defx
 | 
						||
\= Expect no match
 | 
						||
  abcdefzx
 | 
						||
 | 
						||
/(abc|def)x/IB,auto_callout
 | 
						||
  abcx
 | 
						||
  defx
 | 
						||
\= Expect no match
 | 
						||
  abcdefzx
 | 
						||
 | 
						||
/(ab|cd){3,4}/I,auto_callout
 | 
						||
  ababab
 | 
						||
  abcdabcd
 | 
						||
  abcdcdcdcdcd
 | 
						||
 | 
						||
/([ab]{,4}c|xy)/IB,auto_callout
 | 
						||
\= Expect no match
 | 
						||
    Note: that { does NOT introduce a quantifier
 | 
						||
 | 
						||
/([ab]{,4}c|xy)/IB,auto_callout
 | 
						||
\= Expect no match
 | 
						||
    Note: that { does NOT introduce a quantifier
 | 
						||
 | 
						||
/([ab]{1,4}c|xy){4,5}?123/IB,auto_callout
 | 
						||
    aacaacaacaacaac123
 | 
						||
 | 
						||
/\b.*/I
 | 
						||
  ab cd\=offset=1
 | 
						||
 | 
						||
/\b.*/Is
 | 
						||
  ab cd\=startoffset=1
 | 
						||
 | 
						||
/(?!.bcd).*/I
 | 
						||
  Xbcd12345
 | 
						||
 | 
						||
/abcde/I
 | 
						||
    ab\=ps
 | 
						||
    abc\=ps
 | 
						||
    abcd\=ps
 | 
						||
    abcde\=ps
 | 
						||
    the quick brown abc\=ps
 | 
						||
\= Expect no match\=ps
 | 
						||
    the quick brown abxyz fox\=ps
 | 
						||
 | 
						||
"^(0?[1-9]|[12][0-9]|3[01])/(0?[1-9]|1[012])/(20)?\d\d$"I
 | 
						||
    13/05/04\=ps
 | 
						||
    13/5/2004\=ps
 | 
						||
    02/05/09\=ps
 | 
						||
    1\=ps
 | 
						||
    1/2\=ps
 | 
						||
    1/2/0\=ps
 | 
						||
    1/2/04\=ps
 | 
						||
    0\=ps
 | 
						||
    02/\=ps
 | 
						||
    02/0\=ps
 | 
						||
    02/1\=ps
 | 
						||
\= Expect no match\=ps
 | 
						||
    \=ps
 | 
						||
    123\=ps
 | 
						||
    33/4/04\=ps
 | 
						||
    3/13/04\=ps
 | 
						||
    0/1/2003\=ps
 | 
						||
    0/\=ps
 | 
						||
    02/0/\=ps
 | 
						||
    02/13\=ps
 | 
						||
 | 
						||
/0{0,2}ABC/I
 | 
						||
 | 
						||
/\d{3,}ABC/I
 | 
						||
 | 
						||
/\d*ABC/I
 | 
						||
 | 
						||
/[abc]+DE/I
 | 
						||
 | 
						||
/[abc]?123/I
 | 
						||
    123\=ps
 | 
						||
    a\=ps
 | 
						||
    b\=ps
 | 
						||
    c\=ps
 | 
						||
    c12\=ps
 | 
						||
    c123\=ps
 | 
						||
 | 
						||
/^(?:\d){3,5}X/I
 | 
						||
    1\=ps
 | 
						||
    123\=ps
 | 
						||
    123X
 | 
						||
    1234\=ps
 | 
						||
    1234X
 | 
						||
    12345\=ps
 | 
						||
    12345X
 | 
						||
\= Expect no match
 | 
						||
    1X
 | 
						||
    123456\=ps
 | 
						||
 | 
						||
"<(\w+)/?>(.)*</(\1)>"Igms
 | 
						||
    <!DOCTYPE seite SYSTEM "http://www.lco.lineas.de/xmlCms.dtd">\n<seite>\n<dokumenteninformation>\n<seitentitel>Partner der LCO</seitentitel>\n<sprache>de</sprache>\n<seitenbeschreibung>Partner der LINEAS Consulting\nGmbH</seitenbeschreibung>\n<schluesselworte>LINEAS Consulting GmbH Hamburg\nPartnerfirmen</schluesselworte>\n<revisit>30 days</revisit>\n<robots>index,follow</robots>\n<menueinformation>\n<aktiv>ja</aktiv>\n<menueposition>3</menueposition>\n<menuetext>Partner</menuetext>\n</menueinformation>\n<lastedited>\n<autor>LCO</autor>\n<firma>LINEAS Consulting</firma>\n<datum>15.10.2003</datum>\n</lastedited>\n</dokumenteninformation>\n<inhalt>\n\n<absatzueberschrift>Die Partnerfirmen der LINEAS Consulting\nGmbH</absatzueberschrift>\n\n<absatz><link ziel="http://www.ca.com/" zielfenster="_blank">\n<bild name="logo_ca.gif" rahmen="no"/></link> <link\nziel="http://www.ey.com/" zielfenster="_blank"><bild\nname="logo_euy.gif" rahmen="no"/></link>\n</absatz>\n\n<absatz><link ziel="http://www.cisco.de/" zielfenster="_blank">\n<bild name="logo_cisco.gif" rahmen="ja"/></link></absatz>\n\n<absatz><link ziel="http://www.atelion.de/"\nzielfenster="_blank"><bild\nname="logo_atelion.gif" rahmen="no"/></link>\n</absatz>\n\n<absatz><link ziel="http://www.line-information.de/"\nzielfenster="_blank">\n<bild name="logo_line_information.gif" rahmen="no"/></link>\n</absatz>\n\n<absatz><bild name="logo_aw.gif" rahmen="no"/></absatz>\n\n<absatz><link ziel="http://www.incognis.de/"\nzielfenster="_blank"><bild\nname="logo_incognis.gif" rahmen="no"/></link></absatz>\n\n<absatz><link ziel="http://www.addcraft.com/"\nzielfenster="_blank"><bild\nname="logo_addcraft.gif" rahmen="no"/></link></absatz>\n\n<absatz><link ziel="http://www.comendo.com/"\nzielfenster="_blank"><bild\nname="logo_comendo.gif" rahmen="no"/></link></absatz>\n\n</inhalt>\n</seite>\=jitstack=1024
 | 
						||
 | 
						||
/line\nbreak/I
 | 
						||
    this is a line\nbreak
 | 
						||
    line one\nthis is a line\nbreak in the second line
 | 
						||
 | 
						||
/line\nbreak/I,firstline
 | 
						||
    this is a line\nbreak
 | 
						||
\= Expect no match
 | 
						||
    line one\nthis is a line\nbreak in the second line
 | 
						||
 | 
						||
/line\nbreak/Im,firstline
 | 
						||
    this is a line\nbreak
 | 
						||
\= Expect no match
 | 
						||
    line one\nthis is a line\nbreak in the second line
 | 
						||
 | 
						||
/(?i)(?-i)AbCd/I
 | 
						||
    AbCd
 | 
						||
\= Expect no match
 | 
						||
    abcd
 | 
						||
 | 
						||
/a{11111111111111111111}/I
 | 
						||
 | 
						||
/(){64294967295}/I
 | 
						||
 | 
						||
/(){2,4294967295}/I
 | 
						||
 | 
						||
"(?i:a)(?i:b)(?i:c)(?i:d)(?i:e)(?i:f)(?i:g)(?i:h)(?i:i)(?i:j)(k)(?i:l)A\1B"I
 | 
						||
    abcdefghijklAkB
 | 
						||
 | 
						||
"(?P<n0>a)(?P<n1>b)(?P<n2>c)(?P<n3>d)(?P<n4>e)(?P<n5>f)(?P<n6>g)(?P<n7>h)(?P<n8>i)(?P<n9>j)(?P<n10>k)(?P<n11>l)A\11B"I
 | 
						||
    abcdefghijklAkB
 | 
						||
 | 
						||
"(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)A\11B"I
 | 
						||
    abcdefghijklAkB
 | 
						||
 | 
						||
"(?P<name0>a)(?P<name1>a)(?P<name2>a)(?P<name3>a)(?P<name4>a)(?P<name5>a)(?P<name6>a)(?P<name7>a)(?P<name8>a)(?P<name9>a)(?P<name10>a)(?P<name11>a)(?P<name12>a)(?P<name13>a)(?P<name14>a)(?P<name15>a)(?P<name16>a)(?P<name17>a)(?P<name18>a)(?P<name19>a)(?P<name20>a)(?P<name21>a)(?P<name22>a)(?P<name23>a)(?P<name24>a)(?P<name25>a)(?P<name26>a)(?P<name27>a)(?P<name28>a)(?P<name29>a)(?P<name30>a)(?P<name31>a)(?P<name32>a)(?P<name33>a)(?P<name34>a)(?P<name35>a)(?P<name36>a)(?P<name37>a)(?P<name38>a)(?P<name39>a)(?P<name40>a)(?P<name41>a)(?P<name42>a)(?P<name43>a)(?P<name44>a)(?P<name45>a)(?P<name46>a)(?P<name47>a)(?P<name48>a)(?P<name49>a)(?P<name50>a)(?P<name51>a)(?P<name52>a)(?P<name53>a)(?P<name54>a)(?P<name55>a)(?P<name56>a)(?P<name57>a)(?P<name58>a)(?P<name59>a)(?P<name60>a)(?P<name61>a)(?P<name62>a)(?P<name63>a)(?P<name64>a)(?P<name65>a)(?P<name66>a)(?P<name67>a)(?P<name68>a)(?P<name69>a)(?P<name70>a)(?P<name71>a)(?P<name72>a)(?P<name73>a)(?P<name74>a)(?P<name75>a)(?P<name76>a)(?P<name77>a)(?P<name78>a)(?P<name79>a)(?P<name80>a)(?P<name81>a)(?P<name82>a)(?P<name83>a)(?P<name84>a)(?P<name85>a)(?P<name86>a)(?P<name87>a)(?P<name88>a)(?P<name89>a)(?P<name90>a)(?P<name91>a)(?P<name92>a)(?P<name93>a)(?P<name94>a)(?P<name95>a)(?P<name96>a)(?P<name97>a)(?P<name98>a)(?P<name99>a)(?P<name100>a)"I
 | 
						||
    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 | 
						||
 | 
						||
"(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)(a)"I
 | 
						||
    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 | 
						||
 | 
						||
/[^()]*(?:\((?R)\)[^()]*)*/I
 | 
						||
    (this(and)that
 | 
						||
    (this(and)that)
 | 
						||
    (this(and)that)stuff
 | 
						||
 | 
						||
/[^()]*(?:\((?>(?R))\)[^()]*)*/I
 | 
						||
    (this(and)that
 | 
						||
    (this(and)that)
 | 
						||
 | 
						||
/[^()]*(?:\((?R)\))*[^()]*/I
 | 
						||
    (this(and)that
 | 
						||
    (this(and)that)
 | 
						||
 | 
						||
/(?:\((?R)\))*[^()]*/I
 | 
						||
    (this(and)that
 | 
						||
    (this(and)that)
 | 
						||
    ((this))
 | 
						||
 | 
						||
/(?:\((?R)\))|[^()]*/I
 | 
						||
    (this(and)that
 | 
						||
    (this(and)that)
 | 
						||
    (this)
 | 
						||
    ((this))
 | 
						||
 | 
						||
/\x{0000ff}/I
 | 
						||
 | 
						||
/^((?P<A>a1)|(?P<A>a2)b)/I
 | 
						||
 | 
						||
/^((?P<A>a1)|(?P<A>a2)b)/I,dupnames
 | 
						||
    a1b\=copy=A
 | 
						||
    a2b\=copy=A
 | 
						||
    a1b\=copy=Z,copy=A
 | 
						||
 | 
						||
/(?|(?<a>)(?<b>)(?<a>)|(?<a>)(?<b>)(?<a>))/I,dupnames
 | 
						||
 | 
						||
/^(?P<A>a)(?P<A>b)/I,dupnames
 | 
						||
    ab\=copy=A
 | 
						||
 | 
						||
/^(?P<A>a)(?P<A>b)|cd/I,dupnames
 | 
						||
    ab\=copy=A
 | 
						||
    cd\=copy=A
 | 
						||
 | 
						||
/^(?P<A>a)(?P<A>b)|cd(?P<A>ef)(?P<A>gh)/I,dupnames
 | 
						||
    cdefgh\=copy=A
 | 
						||
 | 
						||
/^((?P<A>a1)|(?P<A>a2)b)/I,dupnames
 | 
						||
    a1b\=get=A
 | 
						||
    a2b\=get=A
 | 
						||
    a1b\=get=Z,get=A
 | 
						||
 | 
						||
/^(?P<A>a)(?P<A>b)/I,dupnames
 | 
						||
    ab\=get=A
 | 
						||
 | 
						||
/^(?P<A>a)(?P<A>b)|cd/I,dupnames
 | 
						||
    ab\=get=A
 | 
						||
    cd\=get=A
 | 
						||
 | 
						||
/^(?P<A>a)(?P<A>b)|cd(?P<A>ef)(?P<A>gh)/I,dupnames
 | 
						||
    cdefgh\=get=A
 | 
						||
 | 
						||
/(?J)^((?P<A>a1)|(?P<A>a2)b)/I
 | 
						||
    a1b\=copy=A
 | 
						||
    a2b\=copy=A
 | 
						||
 | 
						||
/^(?P<A>a) (?J:(?P<B>b)(?P<B>c)) (?P<A>d)/I
 | 
						||
 | 
						||
# In this next test, J is not set at the outer level; consequently it isn't set
 | 
						||
# in the pattern's options; consequently pcre2_substring_get_byname() produces
 | 
						||
# a random value.
 | 
						||
 | 
						||
/^(?P<A>a) (?J:(?P<B>b)(?P<B>c)) (?P<C>d)/I
 | 
						||
    a bc d\=copy=A,copy=B,copy=C
 | 
						||
 | 
						||
/^(?P<A>a)?(?(A)a|b)/I
 | 
						||
    aabc
 | 
						||
    bc
 | 
						||
\= Expect no match
 | 
						||
    abc
 | 
						||
 | 
						||
/(?:(?(ZZ)a|b)(?P<ZZ>X))+/I
 | 
						||
    bXaX
 | 
						||
 | 
						||
/(?:(?(2y)a|b)(X))+/I
 | 
						||
 | 
						||
/(?:(?(ZA)a|b)(?P<ZZ>X))+/I
 | 
						||
 | 
						||
/(?:(?(ZZ)a|b)(?(ZZ)a|b)(?P<ZZ>X))+/I
 | 
						||
    bbXaaX
 | 
						||
 | 
						||
/(?:(?(ZZ)a|\(b\))\\(?P<ZZ>X))+/I
 | 
						||
    (b)\\Xa\\X
 | 
						||
 | 
						||
/(?P<ABC/I
 | 
						||
 | 
						||
/(?:(?(A)(?P=A)a|b)(?P<A>X|Y))+/I
 | 
						||
    bXXaYYaY
 | 
						||
    bXYaXXaX
 | 
						||
 | 
						||
/()()()()()()()()()(?:(?(A)(?P=A)a|b)(?P<A>X|Y))+/I
 | 
						||
    bXXaYYaY
 | 
						||
 | 
						||
/\s*,\s*/I
 | 
						||
    \x0b,\x0b
 | 
						||
    \x0c,\x0d
 | 
						||
 | 
						||
/^abc/Im,newline=lf
 | 
						||
    xyz\nabc
 | 
						||
    xyz\r\nabc
 | 
						||
\= Expect no match
 | 
						||
    xyz\rabc
 | 
						||
    xyzabc\r
 | 
						||
    xyzabc\rpqr
 | 
						||
    xyzabc\r\n
 | 
						||
    xyzabc\r\npqr
 | 
						||
 | 
						||
/^abc/Im,newline=crlf
 | 
						||
    xyz\r\nabclf>
 | 
						||
\= Expect no match
 | 
						||
    xyz\nabclf
 | 
						||
    xyz\rabclf
 | 
						||
 | 
						||
/^abc/Im,newline=cr
 | 
						||
    xyz\rabc
 | 
						||
\= Expect no match
 | 
						||
    xyz\nabc
 | 
						||
    xyz\r\nabc
 | 
						||
 | 
						||
/^abc/Im,newline=bad
 | 
						||
 | 
						||
/.*/I,newline=lf
 | 
						||
    abc\ndef
 | 
						||
    abc\rdef
 | 
						||
    abc\r\ndef
 | 
						||
 | 
						||
/.*/I,newline=cr
 | 
						||
    abc\ndef
 | 
						||
    abc\rdef
 | 
						||
    abc\r\ndef
 | 
						||
 | 
						||
/.*/I,newline=crlf
 | 
						||
    abc\ndef
 | 
						||
    abc\rdef
 | 
						||
    abc\r\ndef
 | 
						||
 | 
						||
/\w+(.)(.)?def/Is
 | 
						||
    abc\ndef
 | 
						||
    abc\rdef
 | 
						||
    abc\r\ndef
 | 
						||
 | 
						||
/(?P<B>25[0-5]|2[0-4]\d|[01]?\d?\d)(?:\.(?P>B)){3}/I
 | 
						||
 | 
						||
/()()()()()()()()()()()()()()()()()()()()
 | 
						||
 ()()()()()()()()()()()()()()()()()()()()
 | 
						||
 ()()()()()()()()()()()()()()()()()()()()
 | 
						||
 ()()()()()()()()()()()()()()()()()()()()
 | 
						||
 ()()()()()()()()()()()()()()()()()()()()
 | 
						||
 (.(.))/Ix
 | 
						||
    XY\=ovector=133
 | 
						||
 | 
						||
/(a*b|(?i:c*(?-i)d))/I
 | 
						||
 | 
						||
/()[ab]xyz/I
 | 
						||
 | 
						||
/(|)[ab]xyz/I
 | 
						||
 | 
						||
/(|c)[ab]xyz/I
 | 
						||
 | 
						||
/(|c?)[ab]xyz/I
 | 
						||
 | 
						||
/(d?|c?)[ab]xyz/I
 | 
						||
 | 
						||
/(d?|c)[ab]xyz/I
 | 
						||
 | 
						||
/^a*b\d/IB
 | 
						||
 | 
						||
/^a*+b\d/IB
 | 
						||
 | 
						||
/^a*?b\d/IB
 | 
						||
 | 
						||
/^a+A\d/IB
 | 
						||
    aaaA5
 | 
						||
\= Expect no match
 | 
						||
    aaaa5
 | 
						||
 | 
						||
/^a*A\d/IBi
 | 
						||
    aaaA5
 | 
						||
    aaaa5
 | 
						||
    a5 
 | 
						||
 | 
						||
/(a*|b*)[cd]/I
 | 
						||
 | 
						||
/(a+|b*)[cd]/I
 | 
						||
 | 
						||
/(a*|b+)[cd]/I
 | 
						||
 | 
						||
/(a+|b+)[cd]/I
 | 
						||
 | 
						||
/((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
 | 
						||
 ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
 | 
						||
 (((
 | 
						||
 a
 | 
						||
 ))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
 | 
						||
 ))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
 | 
						||
 )))
 | 
						||
/Ix
 | 
						||
  large nest
 | 
						||
 | 
						||
/a*\d/B
 | 
						||
 | 
						||
/a*\D/B
 | 
						||
 | 
						||
/0*\d/B
 | 
						||
 | 
						||
/0*\D/B
 | 
						||
 | 
						||
/a*\s/B
 | 
						||
 | 
						||
/a*\S/B
 | 
						||
 | 
						||
/ *\s/B
 | 
						||
 | 
						||
/ *\S/B
 | 
						||
 | 
						||
/a*\w/B
 | 
						||
 | 
						||
/a*\W/B
 | 
						||
 | 
						||
/=*\w/B
 | 
						||
 | 
						||
/=*\W/B
 | 
						||
 | 
						||
/\d*a/B
 | 
						||
 | 
						||
/\d*2/B
 | 
						||
 | 
						||
/\d*\d/B
 | 
						||
 | 
						||
/\d*\D/B
 | 
						||
 | 
						||
/\d*\s/B
 | 
						||
 | 
						||
/\d*\S/B
 | 
						||
 | 
						||
/\d*\w/B
 | 
						||
 | 
						||
/\d*\W/B
 | 
						||
 | 
						||
/\D*a/B
 | 
						||
 | 
						||
/\D*2/B
 | 
						||
 | 
						||
/\D*\d/B
 | 
						||
 | 
						||
/\D*\D/B
 | 
						||
 | 
						||
/\D*\s/B
 | 
						||
 | 
						||
/\D*\S/B
 | 
						||
 | 
						||
/\D*\w/B
 | 
						||
 | 
						||
/\D*\W/B
 | 
						||
 | 
						||
/\s*a/B
 | 
						||
 | 
						||
/\s*2/B
 | 
						||
 | 
						||
/\s*\d/B
 | 
						||
 | 
						||
/\s*\D/B
 | 
						||
 | 
						||
/\s*\s/B
 | 
						||
 | 
						||
/\s*\S/B
 | 
						||
 | 
						||
/\s*\w/B
 | 
						||
 | 
						||
/\s*\W/B
 | 
						||
 | 
						||
/\S*a/B
 | 
						||
 | 
						||
/\S*2/B
 | 
						||
 | 
						||
/\S*\d/B
 | 
						||
 | 
						||
/\S*\D/B
 | 
						||
 | 
						||
/\S*\s/B
 | 
						||
 | 
						||
/\S*\S/B
 | 
						||
 | 
						||
/\S*\w/B
 | 
						||
 | 
						||
/\S*\W/B
 | 
						||
 | 
						||
/\w*a/B
 | 
						||
 | 
						||
/\w*2/B
 | 
						||
 | 
						||
/\w*\d/B
 | 
						||
 | 
						||
/\w*\D/B
 | 
						||
 | 
						||
/\w*\s/B
 | 
						||
 | 
						||
/\w*\S/B
 | 
						||
 | 
						||
/\w*\w/B
 | 
						||
 | 
						||
/\w*\W/B
 | 
						||
 | 
						||
/\W*a/B
 | 
						||
 | 
						||
/\W*2/B
 | 
						||
 | 
						||
/\W*\d/B
 | 
						||
 | 
						||
/\W*\D/B
 | 
						||
 | 
						||
/\W*\s/B
 | 
						||
 | 
						||
/\W*\S/B
 | 
						||
 | 
						||
/\W*\w/B
 | 
						||
 | 
						||
/\W*\W/B
 | 
						||
 | 
						||
/[^a]+a/B
 | 
						||
 | 
						||
/[^a]+a/Bi
 | 
						||
 | 
						||
/[^a]+A/Bi
 | 
						||
 | 
						||
/[^a]+b/B
 | 
						||
 | 
						||
/[^a]+\d/B
 | 
						||
 | 
						||
/a*[^a]/B
 | 
						||
 | 
						||
/(?P<abc>x)(?P<xyz>y)/I
 | 
						||
    xy\=copy=abc,copy=xyz
 | 
						||
 | 
						||
/(?<abc>x)(?'xyz'y)/I
 | 
						||
    xy\=copy=abc,copy=xyz
 | 
						||
 | 
						||
/(?<abc'x)(?'xyz'y)/I
 | 
						||
 | 
						||
/(?<abc>x)(?'xyz>y)/I
 | 
						||
 | 
						||
/(?P'abc'x)(?P<xyz>y)/I
 | 
						||
 | 
						||
/^(?:(?(ZZ)a|b)(?<ZZ>X))+/
 | 
						||
    bXaX
 | 
						||
    bXbX
 | 
						||
\= Expect no match
 | 
						||
    aXaX
 | 
						||
    aXbX
 | 
						||
 | 
						||
/^(?P>abc)(?<abcd>xxx)/
 | 
						||
 | 
						||
/^(?P>abc)(?<abc>x|y)/
 | 
						||
    xx
 | 
						||
    xy
 | 
						||
    yy
 | 
						||
    yx
 | 
						||
 | 
						||
/^(?P>abc)(?P<abc>x|y)/
 | 
						||
    xx
 | 
						||
    xy
 | 
						||
    yy
 | 
						||
    yx
 | 
						||
 | 
						||
/^((?(abc)a|b)(?<abc>x|y))+/
 | 
						||
    bxay
 | 
						||
    bxby
 | 
						||
\= Expect no match
 | 
						||
    axby
 | 
						||
 | 
						||
/^(((?P=abc)|X)(?<abc>x|y))+/
 | 
						||
    XxXxxx
 | 
						||
    XxXyyx
 | 
						||
    XxXyxx
 | 
						||
\= Expect no match
 | 
						||
    x
 | 
						||
 | 
						||
/^(?1)(abc)/
 | 
						||
    abcabc
 | 
						||
 | 
						||
/^(?:(?:\1|X)(a|b))+/
 | 
						||
    Xaaa
 | 
						||
    Xaba
 | 
						||
 | 
						||
/^[\E\Qa\E-\Qz\E]+/B
 | 
						||
 | 
						||
/^[a\Q]bc\E]/B
 | 
						||
 | 
						||
/^[a-\Q\E]/B
 | 
						||
 | 
						||
/^(?P>abc)[()](?<abc>)/B
 | 
						||
 | 
						||
/^((?(abc)y)[()](?P<abc>x))+/B
 | 
						||
    (xy)x
 | 
						||
 | 
						||
/^(?P>abc)\Q()\E(?<abc>)/B
 | 
						||
 | 
						||
/^(?P>abc)[a\Q(]\E(](?<abc>)/B
 | 
						||
 | 
						||
/^(?P>abc) # this is (a comment)
 | 
						||
  (?<abc>)/Bx
 | 
						||
 | 
						||
/^\W*(?:(?<one>(?<two>.)\W*(?&one)\W*\k<two>|)|(?<three>(?<four>.)\W*(?&three)\W*\k'four'|\W*.\W*))\W*$/Ii
 | 
						||
    1221
 | 
						||
    Satan, oscillate my metallic sonatas!
 | 
						||
    A man, a plan, a canal: Panama!
 | 
						||
    Able was I ere I saw Elba.
 | 
						||
\= Expect no match
 | 
						||
    The quick brown fox
 | 
						||
 | 
						||
/(?=(\w+))\1:/I
 | 
						||
    abcd:
 | 
						||
 | 
						||
/(?=(?'abc'\w+))\k<abc>:/I
 | 
						||
    abcd:
 | 
						||
 | 
						||
/(?'abc'a|b)(?<abc>d|e)\k<abc>{2}/dupnames
 | 
						||
    adaa
 | 
						||
\= Expect no match
 | 
						||
    addd
 | 
						||
    adbb
 | 
						||
 | 
						||
/(?'abc'a|b)(?<abc>d|e)(?&abc){2}/dupnames
 | 
						||
    bdaa
 | 
						||
    bdab
 | 
						||
\= Expect no match
 | 
						||
    bddd
 | 
						||
 | 
						||
/(?(<bc))/
 | 
						||
 | 
						||
/(?(''))/
 | 
						||
 | 
						||
/(?('R')stuff)/
 | 
						||
 | 
						||
/((abc (?(R) (?(R1)1) (?(R2)2) X  |  (?1)  (?2)   (?R) ))) /x
 | 
						||
    abcabc1Xabc2XabcXabcabc
 | 
						||
 | 
						||
/(?<A> (?'B' abc (?(R) (?(R&A)1) (?(R&B)2) X  |  (?1)  (?2)   (?R) ))) /x
 | 
						||
    abcabc1Xabc2XabcXabcabc
 | 
						||
 | 
						||
/(?<A> (?'B' abc (?(R) (?(R&C)1) (?(R&B)2) X  |  (?1)  (?2)   (?R) ))) /x
 | 
						||
 | 
						||
/^(?(DEFINE) abc | xyz ) /x
 | 
						||
 | 
						||
/(?(DEFINE) abc) xyz/Ix
 | 
						||
 | 
						||
/(a|)*\d/
 | 
						||
  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa4\=ovector=0
 | 
						||
\= Expect no match
 | 
						||
  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\=ovector=0
 | 
						||
 | 
						||
/^a.b/newline=lf
 | 
						||
    a\rb
 | 
						||
\= Expect no match
 | 
						||
    a\nb
 | 
						||
 | 
						||
/^a.b/newline=cr
 | 
						||
    a\nb
 | 
						||
\= Expect no match
 | 
						||
    a\rb
 | 
						||
 | 
						||
/^a.b/newline=anycrlf
 | 
						||
    a\x85b
 | 
						||
\= Expect no match
 | 
						||
    a\rb
 | 
						||
 | 
						||
/^a.b/newline=any
 | 
						||
\= Expect no match
 | 
						||
    a\nb
 | 
						||
    a\rb
 | 
						||
    a\x85b
 | 
						||
 | 
						||
/^abc./gmx,newline=any
 | 
						||
    abc1 \x0aabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\x0aabc6 \x85abc7 JUNK
 | 
						||
 | 
						||
/abc.$/gmx,newline=any
 | 
						||
    abc1\x0a abc2\x0b abc3\x0c abc4\x0d abc5\x0d\x0a abc6\x85 abc7 abc9
 | 
						||
 | 
						||
/^a\Rb/bsr=unicode
 | 
						||
    a\nb
 | 
						||
    a\rb
 | 
						||
    a\r\nb
 | 
						||
    a\x0bb
 | 
						||
    a\x0cb
 | 
						||
    a\x85b
 | 
						||
\= Expect no match
 | 
						||
    a\n\rb
 | 
						||
 | 
						||
/^a\R*b/bsr=unicode
 | 
						||
    ab
 | 
						||
    a\nb
 | 
						||
    a\rb
 | 
						||
    a\r\nb
 | 
						||
    a\x0bb
 | 
						||
    a\x0cb
 | 
						||
    a\x85b
 | 
						||
    a\n\rb
 | 
						||
    a\n\r\x85\x0cb
 | 
						||
 | 
						||
/^a\R+b/bsr=unicode
 | 
						||
    a\nb
 | 
						||
    a\rb
 | 
						||
    a\r\nb
 | 
						||
    a\x0bb
 | 
						||
    a\x0cb
 | 
						||
    a\x85b
 | 
						||
    a\n\rb
 | 
						||
    a\n\r\x85\x0cb
 | 
						||
\= Expect no match
 | 
						||
    ab
 | 
						||
 | 
						||
/^a\R{1,3}b/bsr=unicode
 | 
						||
    a\nb
 | 
						||
    a\n\rb
 | 
						||
    a\n\r\x85b
 | 
						||
    a\r\n\r\nb
 | 
						||
    a\r\n\r\n\r\nb
 | 
						||
    a\n\r\n\rb
 | 
						||
    a\n\n\r\nb
 | 
						||
\= Expect no match
 | 
						||
    a\n\n\n\rb
 | 
						||
    a\r
 | 
						||
 | 
						||
/(?&abc)X(?<abc>P)/I
 | 
						||
    abcPXP123
 | 
						||
 | 
						||
/(?1)X(?<abc>P)/I
 | 
						||
    abcPXP123
 | 
						||
 | 
						||
/(?:a(?&abc)b)*(?<abc>x)/
 | 
						||
    123axbaxbaxbx456
 | 
						||
    123axbaxbaxb456
 | 
						||
 | 
						||
/(?:a(?&abc)b){1,5}(?<abc>x)/
 | 
						||
    123axbaxbaxbx456
 | 
						||
 | 
						||
/(?:a(?&abc)b){2,5}(?<abc>x)/
 | 
						||
    123axbaxbaxbx456
 | 
						||
 | 
						||
/(?:a(?&abc)b){2,}(?<abc>x)/
 | 
						||
    123axbaxbaxbx456
 | 
						||
 | 
						||
/(abc)(?i:(?1))/
 | 
						||
    defabcabcxyz
 | 
						||
\= Expect no match
 | 
						||
    DEFabcABCXYZ
 | 
						||
 | 
						||
/(abc)(?:(?i)(?1))/
 | 
						||
    defabcabcxyz
 | 
						||
\= Expect no match
 | 
						||
    DEFabcABCXYZ
 | 
						||
 | 
						||
/^(a)\g-2/
 | 
						||
 | 
						||
/^(a)\g/
 | 
						||
 | 
						||
/^(a)\g{0}/
 | 
						||
 | 
						||
/^(a)\g{3/
 | 
						||
 | 
						||
/^(a)\g{aa}/
 | 
						||
 | 
						||
/^a.b/newline=lf
 | 
						||
    a\rb
 | 
						||
\= Expect no match
 | 
						||
    a\nb
 | 
						||
 | 
						||
/.+foo/
 | 
						||
    afoo
 | 
						||
\= Expect no match
 | 
						||
    \r\nfoo
 | 
						||
    \nfoo
 | 
						||
 | 
						||
/.+foo/newline=crlf
 | 
						||
    afoo
 | 
						||
    \nfoo
 | 
						||
\= Expect no match
 | 
						||
    \r\nfoo
 | 
						||
 | 
						||
/.+foo/newline=any
 | 
						||
    afoo
 | 
						||
\= Expect no match
 | 
						||
    \nfoo
 | 
						||
    \r\nfoo
 | 
						||
 | 
						||
/.+foo/s
 | 
						||
    afoo
 | 
						||
    \r\nfoo
 | 
						||
    \nfoo
 | 
						||
 | 
						||
/^$/gm,newline=any
 | 
						||
    abc\r\rxyz
 | 
						||
    abc\n\rxyz
 | 
						||
\= Expect no match
 | 
						||
    abc\r\nxyz
 | 
						||
 | 
						||
/(?m)^$/g,newline=any,aftertext
 | 
						||
    abc\r\n\r\n
 | 
						||
 | 
						||
/(?m)^$|^\r\n/g,newline=any,aftertext
 | 
						||
    abc\r\n\r\n
 | 
						||
 | 
						||
/(?m)$/g,newline=any,aftertext
 | 
						||
    abc\r\n\r\n
 | 
						||
 | 
						||
/abc.$/gmx,newline=anycrlf
 | 
						||
    abc1\x0a abc2\x0b abc3\x0c abc4\x0d abc5\x0d\x0a abc6\x85 abc9
 | 
						||
 | 
						||
/^X/m
 | 
						||
    XABC
 | 
						||
\= Expect no match
 | 
						||
    XABC\=notbol
 | 
						||
 | 
						||
/(ab|c)(?-1)/B
 | 
						||
    abc
 | 
						||
 | 
						||
/xy(?+1)(abc)/B
 | 
						||
    xyabcabc
 | 
						||
\= Expect no match
 | 
						||
    xyabc
 | 
						||
 | 
						||
/x(?-0)y/
 | 
						||
 | 
						||
/x(?-1)y/
 | 
						||
 | 
						||
/x(?+0)y/
 | 
						||
 | 
						||
/x(?+1)y/
 | 
						||
 | 
						||
/^(abc)?(?(-1)X|Y)/B
 | 
						||
    abcX
 | 
						||
    Y
 | 
						||
\= Expect no match
 | 
						||
    abcY
 | 
						||
 | 
						||
/^((?(+1)X|Y)(abc))+/B
 | 
						||
    YabcXabc
 | 
						||
    YabcXabcXabc
 | 
						||
\= Expect no match
 | 
						||
    XabcXabc
 | 
						||
 | 
						||
/(?(-1)a)/B
 | 
						||
 | 
						||
/((?(-1)a))/B
 | 
						||
 | 
						||
/((?(-2)a))/B
 | 
						||
 | 
						||
/^(?(+1)X|Y)(.)/B
 | 
						||
    Y!
 | 
						||
 | 
						||
/(?<A>tom|bon)-\k{A}/
 | 
						||
    tom-tom
 | 
						||
    bon-bon
 | 
						||
\= Expect no match
 | 
						||
    tom-bon
 | 
						||
 | 
						||
/\g{A/
 | 
						||
 | 
						||
/(?|(abc)|(xyz))/B
 | 
						||
   >abc<
 | 
						||
   >xyz<
 | 
						||
 | 
						||
/(x)(?|(abc)|(xyz))(x)/B
 | 
						||
    xabcx
 | 
						||
    xxyzx
 | 
						||
 | 
						||
/(x)(?|(abc)(pqr)|(xyz))(x)/B
 | 
						||
    xabcpqrx
 | 
						||
    xxyzx
 | 
						||
 | 
						||
/\H++X/B
 | 
						||
\= Expect no match
 | 
						||
    XXXX
 | 
						||
 | 
						||
/\H+\hY/B
 | 
						||
    XXXX Y
 | 
						||
 | 
						||
/\H+ Y/B
 | 
						||
 | 
						||
/\h+A/B
 | 
						||
 | 
						||
/\v*B/B
 | 
						||
 | 
						||
/\V+\x0a/B
 | 
						||
 | 
						||
/A+\h/B
 | 
						||
 | 
						||
/ *\H/B
 | 
						||
 | 
						||
/A*\v/B
 | 
						||
 | 
						||
/\x0b*\V/B
 | 
						||
 | 
						||
/\d+\h/B
 | 
						||
 | 
						||
/\d*\v/B
 | 
						||
 | 
						||
/S+\h\S+\v/B
 | 
						||
 | 
						||
/\w{3,}\h\w+\v/B
 | 
						||
 | 
						||
/\h+\d\h+\w\h+\S\h+\H/B
 | 
						||
 | 
						||
/\v+\d\v+\w\v+\S\v+\V/B
 | 
						||
 | 
						||
/\H+\h\H+\d/B
 | 
						||
 | 
						||
/\V+\v\V+\w/B
 | 
						||
 | 
						||
/\( (?: [^()]* | (?R) )* \)/x
 | 
						||
(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(0(00)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)0)\=jitstack=1024
 | 
						||
 | 
						||
/[\E]AAA/
 | 
						||
 | 
						||
/[\Q\E]AAA/
 | 
						||
 | 
						||
/[^\E]AAA/
 | 
						||
 | 
						||
/[^\Q\E]AAA/
 | 
						||
 | 
						||
/[\E^]AAA/
 | 
						||
 | 
						||
/[\Q\E^]AAA/
 | 
						||
 | 
						||
/A(*PRUNE)B(*SKIP)C(*THEN)D(*COMMIT)E(*F)F(*FAIL)G(?!)H(*ACCEPT)I/B
 | 
						||
 | 
						||
/^a+(*FAIL)/auto_callout
 | 
						||
\= Expect no match
 | 
						||
    aaaaaa
 | 
						||
 | 
						||
/a+b?c+(*FAIL)/auto_callout
 | 
						||
\= Expect no match
 | 
						||
    aaabccc
 | 
						||
 | 
						||
/a+b?(*PRUNE)c+(*FAIL)/auto_callout
 | 
						||
\= Expect no match
 | 
						||
    aaabccc
 | 
						||
 | 
						||
/a+b?(*COMMIT)c+(*FAIL)/auto_callout
 | 
						||
\= Expect no match
 | 
						||
    aaabccc
 | 
						||
 | 
						||
/a+b?(*SKIP)c+(*FAIL)/auto_callout
 | 
						||
\= Expect no match
 | 
						||
    aaabcccaaabccc
 | 
						||
 | 
						||
/a+b?(*THEN)c+(*FAIL)/auto_callout
 | 
						||
\= Expect no match
 | 
						||
    aaabccc
 | 
						||
 | 
						||
/a(*MARK)b/
 | 
						||
 | 
						||
/\g6666666666/
 | 
						||
 | 
						||
/[\g6666666666]/B
 | 
						||
 | 
						||
/(?1)\c[/
 | 
						||
 | 
						||
/.+A/newline=crlf
 | 
						||
\= Expect no match
 | 
						||
    \r\nA
 | 
						||
 | 
						||
/\nA/newline=crlf
 | 
						||
    \r\nA
 | 
						||
 | 
						||
/[\r\n]A/newline=crlf
 | 
						||
    \r\nA
 | 
						||
 | 
						||
/(\r|\n)A/newline=crlf
 | 
						||
    \r\nA
 | 
						||
 | 
						||
/a(*CR)b/
 | 
						||
 | 
						||
/(*CR)a.b/
 | 
						||
    a\nb
 | 
						||
\= Expect no match
 | 
						||
    a\rb
 | 
						||
 | 
						||
/(*CR)a.b/newline=lf
 | 
						||
    a\nb
 | 
						||
\= Expect no match
 | 
						||
    a\rb
 | 
						||
 | 
						||
/(*LF)a.b/newline=CRLF
 | 
						||
    a\rb
 | 
						||
\= Expect no match
 | 
						||
    a\nb
 | 
						||
 | 
						||
/(*CRLF)a.b/
 | 
						||
    a\rb
 | 
						||
    a\nb
 | 
						||
\= Expect no match
 | 
						||
    a\r\nb
 | 
						||
 | 
						||
/(*ANYCRLF)a.b/newline=CR
 | 
						||
\= Expect no match
 | 
						||
    a\rb
 | 
						||
    a\nb
 | 
						||
    a\r\nb
 | 
						||
 | 
						||
/(*ANY)a.b/newline=cr
 | 
						||
\= Expect no match
 | 
						||
    a\rb
 | 
						||
    a\nb
 | 
						||
    a\r\nb
 | 
						||
    a\x85b
 | 
						||
 | 
						||
/(*ANY).*/g
 | 
						||
    abc\r\ndef
 | 
						||
 | 
						||
/(*ANYCRLF).*/g
 | 
						||
    abc\r\ndef
 | 
						||
 | 
						||
/(*CRLF).*/g
 | 
						||
    abc\r\ndef
 | 
						||
 | 
						||
/(*NUL)^.*/
 | 
						||
    a\nb\x00ccc
 | 
						||
 | 
						||
/(*NUL)^.*/s
 | 
						||
    a\nb\x00ccc
 | 
						||
 | 
						||
/^x/m,newline=NUL
 | 
						||
    ab\x00xy
 | 
						||
 | 
						||
/'#comment' 0d 0a 00 '^x\' 0a 'y'/x,newline=nul,hex
 | 
						||
    x\nyz
 | 
						||
 | 
						||
/(*NUL)^X\NY/
 | 
						||
    X\nY
 | 
						||
    X\rY
 | 
						||
\= Expect no match
 | 
						||
    X\x00Y
 | 
						||
 | 
						||
/a\Rb/I,bsr=anycrlf
 | 
						||
    a\rb
 | 
						||
    a\nb
 | 
						||
    a\r\nb
 | 
						||
\= Expect no match
 | 
						||
    a\x85b
 | 
						||
    a\x0bb
 | 
						||
 | 
						||
/a\Rb/I,bsr=unicode
 | 
						||
    a\rb
 | 
						||
    a\nb
 | 
						||
    a\r\nb
 | 
						||
    a\x85b
 | 
						||
    a\x0bb
 | 
						||
 | 
						||
/a\R?b/I,bsr=anycrlf
 | 
						||
    a\rb
 | 
						||
    a\nb
 | 
						||
    a\r\nb
 | 
						||
\= Expect no match
 | 
						||
    a\x85b
 | 
						||
    a\x0bb
 | 
						||
 | 
						||
/a\R?b/I,bsr=unicode
 | 
						||
    a\rb
 | 
						||
    a\nb
 | 
						||
    a\r\nb
 | 
						||
    a\x85b
 | 
						||
    a\x0bb
 | 
						||
 | 
						||
/a\R{2,4}b/I,bsr=anycrlf
 | 
						||
    a\r\n\nb
 | 
						||
    a\n\r\rb
 | 
						||
    a\r\n\r\n\r\n\r\nb
 | 
						||
\= Expect no match
 | 
						||
    a\x85\x85b
 | 
						||
    a\x0b\x0bb
 | 
						||
 | 
						||
/a\R{2,4}b/I,bsr=unicode
 | 
						||
    a\r\rb
 | 
						||
    a\n\n\nb
 | 
						||
    a\r\n\n\r\rb
 | 
						||
    a\x85\x85b
 | 
						||
    a\x0b\x0bb
 | 
						||
\= Expect no match
 | 
						||
    a\r\r\r\r\rb
 | 
						||
 | 
						||
/(*BSR_ANYCRLF)a\Rb/I
 | 
						||
    a\nb
 | 
						||
    a\rb
 | 
						||
 | 
						||
/(*BSR_UNICODE)a\Rb/I
 | 
						||
    a\x85b
 | 
						||
 | 
						||
/(*BSR_ANYCRLF)(*CRLF)a\Rb/I
 | 
						||
    a\nb
 | 
						||
    a\rb
 | 
						||
 | 
						||
/(*CRLF)(*BSR_UNICODE)a\Rb/I
 | 
						||
    a\x85b
 | 
						||
 | 
						||
/(*CRLF)(*BSR_ANYCRLF)(*CR)ab/I
 | 
						||
 | 
						||
/(?<a>)(?&)/
 | 
						||
 | 
						||
/(?<abc>)(?&a)/
 | 
						||
 | 
						||
/(?<a>)(?&aaaaaaaaaaaaaaaaaaaaaaa)/
 | 
						||
 | 
						||
/(?+-a)/
 | 
						||
 | 
						||
/(?-+a)/
 | 
						||
 | 
						||
/(?(-1))/
 | 
						||
 | 
						||
/(?(+10))/
 | 
						||
 | 
						||
/(?(10))/
 | 
						||
 | 
						||
/(?(+2))()()/
 | 
						||
 | 
						||
/(?(2))()()/
 | 
						||
 | 
						||
/\k''/
 | 
						||
 | 
						||
/\k<>/
 | 
						||
 | 
						||
/\k{}/
 | 
						||
 | 
						||
/\k/
 | 
						||
 | 
						||
/\kabc/
 | 
						||
 | 
						||
/(?P=)/
 | 
						||
 | 
						||
/(?P>)/
 | 
						||
 | 
						||
/[[:foo:]]/
 | 
						||
 | 
						||
/[[:1234:]]/
 | 
						||
 | 
						||
/[[:f\oo:]]/
 | 
						||
 | 
						||
/[[: :]]/
 | 
						||
 | 
						||
/[[:...:]]/
 | 
						||
 | 
						||
/[[:l\ower:]]/
 | 
						||
 | 
						||
/[[:abc\:]]/
 | 
						||
 | 
						||
/[abc[:x\]pqr:]]/
 | 
						||
 | 
						||
/[[:a\dz:]]/
 | 
						||
 | 
						||
/(^(a|b\g<-1'c))/
 | 
						||
 | 
						||
/^(?+1)(?<a>x|y){0}z/
 | 
						||
    xzxx
 | 
						||
    yzyy
 | 
						||
\= Expect no match
 | 
						||
    xxz
 | 
						||
 | 
						||
/(\3)(\1)(a)/
 | 
						||
\= Expect no match
 | 
						||
    cat
 | 
						||
 | 
						||
/(\3)(\1)(a)/allow_empty_class,match_unset_backref,dupnames
 | 
						||
    cat
 | 
						||
 | 
						||
/TA]/
 | 
						||
    The ACTA] comes
 | 
						||
 | 
						||
/TA]/allow_empty_class,match_unset_backref,dupnames
 | 
						||
    The ACTA] comes
 | 
						||
 | 
						||
/(?2)[]a()b](abc)/
 | 
						||
    abcbabc
 | 
						||
 | 
						||
/(?2)[^]a()b](abc)/
 | 
						||
    abcbabc
 | 
						||
 | 
						||
/(?1)[]a()b](abc)/
 | 
						||
    abcbabc
 | 
						||
\= Expect no match
 | 
						||
    abcXabc
 | 
						||
 | 
						||
/(?1)[^]a()b](abc)/
 | 
						||
    abcXabc
 | 
						||
\= Expect no match
 | 
						||
    abcbabc
 | 
						||
 | 
						||
/(?2)[]a()b](abc)(xyz)/
 | 
						||
    xyzbabcxyz
 | 
						||
 | 
						||
/(?&N)[]a(?<N>)](?<M>abc)/
 | 
						||
   abc<abc
 | 
						||
 | 
						||
/(?&N)[]a(?<N>)](abc)/
 | 
						||
   abc<abc
 | 
						||
 | 
						||
/a[]b/
 | 
						||
 | 
						||
/a[^]b/
 | 
						||
 | 
						||
/a[]b/allow_empty_class,match_unset_backref,dupnames
 | 
						||
\= Expect no match
 | 
						||
    ab
 | 
						||
 | 
						||
/a[]+b/allow_empty_class,match_unset_backref,dupnames
 | 
						||
\= Expect no match
 | 
						||
    ab
 | 
						||
 | 
						||
/a[]*+b/allow_empty_class,match_unset_backref,dupnames
 | 
						||
\= Expect no match
 | 
						||
    ab
 | 
						||
 | 
						||
/a[^]b/allow_empty_class,match_unset_backref,dupnames
 | 
						||
    aXb
 | 
						||
    a\nb
 | 
						||
\= Expect no match
 | 
						||
    ab
 | 
						||
 | 
						||
/a[^]+b/allow_empty_class,match_unset_backref,dupnames
 | 
						||
    aXb
 | 
						||
    a\nX\nXb
 | 
						||
\= Expect no match
 | 
						||
    ab
 | 
						||
 | 
						||
/a(?!)b/B
 | 
						||
 | 
						||
/(?!)?a/B
 | 
						||
    ab
 | 
						||
 | 
						||
/a(*FAIL)+b/
 | 
						||
 | 
						||
/(abc|pqr|123){0}[xyz]/I
 | 
						||
 | 
						||
/(?(?=.*b)b|^)/I,auto_callout
 | 
						||
   adc
 | 
						||
   abc
 | 
						||
 | 
						||
/(?(?=b).*b|^d)/I
 | 
						||
 | 
						||
/(?(?=.*b).*b|^d)/I
 | 
						||
 | 
						||
/xyz/auto_callout
 | 
						||
  xyz
 | 
						||
  abcxyz
 | 
						||
\= Expect no match
 | 
						||
  abc
 | 
						||
  abcxypqr
 | 
						||
 | 
						||
/xyz/auto_callout,no_start_optimize
 | 
						||
  abcxyz
 | 
						||
\= Expect no match
 | 
						||
  abc
 | 
						||
  abcxypqr
 | 
						||
 | 
						||
/(*NO_START_OPT)xyz/auto_callout
 | 
						||
  abcxyz
 | 
						||
 | 
						||
/(*NO_AUTO_POSSESS)a+b/B
 | 
						||
 | 
						||
/xyz/auto_callout,no_start_optimize
 | 
						||
  abcxyz
 | 
						||
 | 
						||
/^"((?(?=[a])[^"])|b)*"$/auto_callout
 | 
						||
    "ab"
 | 
						||
 | 
						||
/^"((?(?=[a])[^"])|b)*"$/
 | 
						||
    "ab"
 | 
						||
 | 
						||
/^X(?5)(a)(?|(b)|(q))(c)(d)Y/
 | 
						||
    XYabcdY
 | 
						||
 | 
						||
/^X(?&N)(a)(?|(b)|(q))(c)(d)(?<N>Y)/
 | 
						||
    XYabcdY
 | 
						||
 | 
						||
/Xa{2,4}b/
 | 
						||
    X\=ps
 | 
						||
    Xa\=ps
 | 
						||
    Xaa\=ps
 | 
						||
    Xaaa\=ps
 | 
						||
    Xaaaa\=ps
 | 
						||
 | 
						||
/Xa{2,4}?b/
 | 
						||
    X\=ps
 | 
						||
    Xa\=ps
 | 
						||
    Xaa\=ps
 | 
						||
    Xaaa\=ps
 | 
						||
    Xaaaa\=ps
 | 
						||
 | 
						||
/Xa{2,4}+b/
 | 
						||
    X\=ps
 | 
						||
    Xa\=ps
 | 
						||
    Xaa\=ps
 | 
						||
    Xaaa\=ps
 | 
						||
    Xaaaa\=ps
 | 
						||
 | 
						||
/X\d{2,4}b/
 | 
						||
    X\=ps
 | 
						||
    X3\=ps
 | 
						||
    X33\=ps
 | 
						||
    X333\=ps
 | 
						||
    X3333\=ps
 | 
						||
 | 
						||
/X\d{2,4}?b/
 | 
						||
    X\=ps
 | 
						||
    X3\=ps
 | 
						||
    X33\=ps
 | 
						||
    X333\=ps
 | 
						||
    X3333\=ps
 | 
						||
 | 
						||
/X\d{2,4}+b/
 | 
						||
    X\=ps
 | 
						||
    X3\=ps
 | 
						||
    X33\=ps
 | 
						||
    X333\=ps
 | 
						||
    X3333\=ps
 | 
						||
 | 
						||
/X\D{2,4}b/
 | 
						||
    X\=ps
 | 
						||
    Xa\=ps
 | 
						||
    Xaa\=ps
 | 
						||
    Xaaa\=ps
 | 
						||
    Xaaaa\=ps
 | 
						||
 | 
						||
/X\D{2,4}?b/
 | 
						||
    X\=ps
 | 
						||
    Xa\=ps
 | 
						||
    Xaa\=ps
 | 
						||
    Xaaa\=ps
 | 
						||
    Xaaaa\=ps
 | 
						||
 | 
						||
/X\D{2,4}+b/
 | 
						||
    X\=ps
 | 
						||
    Xa\=ps
 | 
						||
    Xaa\=ps
 | 
						||
    Xaaa\=ps
 | 
						||
    Xaaaa\=ps
 | 
						||
 | 
						||
/X[abc]{2,4}b/
 | 
						||
    X\=ps
 | 
						||
    Xa\=ps
 | 
						||
    Xaa\=ps
 | 
						||
    Xaaa\=ps
 | 
						||
    Xaaaa\=ps
 | 
						||
 | 
						||
/X[abc]{2,4}?b/
 | 
						||
    X\=ps
 | 
						||
    Xa\=ps
 | 
						||
    Xaa\=ps
 | 
						||
    Xaaa\=ps
 | 
						||
    Xaaaa\=ps
 | 
						||
 | 
						||
/X[abc]{2,4}+b/
 | 
						||
    X\=ps
 | 
						||
    Xa\=ps
 | 
						||
    Xaa\=ps
 | 
						||
    Xaaa\=ps
 | 
						||
    Xaaaa\=ps
 | 
						||
 | 
						||
/X[^a]{2,4}b/
 | 
						||
    X\=ps
 | 
						||
    Xz\=ps
 | 
						||
    Xzz\=ps
 | 
						||
    Xzzz\=ps
 | 
						||
    Xzzzz\=ps
 | 
						||
 | 
						||
/X[^a]{2,4}?b/
 | 
						||
    X\=ps
 | 
						||
    Xz\=ps
 | 
						||
    Xzz\=ps
 | 
						||
    Xzzz\=ps
 | 
						||
    Xzzzz\=ps
 | 
						||
 | 
						||
/X[^a]{2,4}+b/
 | 
						||
    X\=ps
 | 
						||
    Xz\=ps
 | 
						||
    Xzz\=ps
 | 
						||
    Xzzz\=ps
 | 
						||
    Xzzzz\=ps
 | 
						||
 | 
						||
/(Y)X\1{2,4}b/
 | 
						||
    YX\=ps
 | 
						||
    YXY\=ps
 | 
						||
    YXYY\=ps
 | 
						||
    YXYYY\=ps
 | 
						||
    YXYYYY\=ps
 | 
						||
 | 
						||
/(Y)X\1{2,4}?b/
 | 
						||
    YX\=ps
 | 
						||
    YXY\=ps
 | 
						||
    YXYY\=ps
 | 
						||
    YXYYY\=ps
 | 
						||
    YXYYYY\=ps
 | 
						||
 | 
						||
/(Y)X\1{2,4}+b/
 | 
						||
    YX\=ps
 | 
						||
    YXY\=ps
 | 
						||
    YXYY\=ps
 | 
						||
    YXYYY\=ps
 | 
						||
    YXYYYY\=ps
 | 
						||
 | 
						||
/\++\KZ|\d+X|9+Y/startchar
 | 
						||
    ++++123999\=ps
 | 
						||
    ++++123999Y\=ps
 | 
						||
    ++++Z1234\=ps
 | 
						||
 | 
						||
/Z(*F)/
 | 
						||
\= Expect no match
 | 
						||
    Z\=ps
 | 
						||
    ZA\=ps
 | 
						||
 | 
						||
/Z(?!)/
 | 
						||
\= Expect no match
 | 
						||
    Z\=ps
 | 
						||
    ZA\=ps
 | 
						||
 | 
						||
/dog(sbody)?/
 | 
						||
    dogs\=ps
 | 
						||
    dogs\=ph
 | 
						||
 | 
						||
/dog(sbody)??/
 | 
						||
    dogs\=ps
 | 
						||
    dogs\=ph
 | 
						||
 | 
						||
/dog|dogsbody/
 | 
						||
    dogs\=ps
 | 
						||
    dogs\=ph
 | 
						||
 | 
						||
/dogsbody|dog/
 | 
						||
    dogs\=ps
 | 
						||
    dogs\=ph
 | 
						||
 | 
						||
/\bthe cat\b/
 | 
						||
    the cat\=ps
 | 
						||
    the cat\=ph
 | 
						||
 | 
						||
/abc/
 | 
						||
   abc\=ps
 | 
						||
   abc\=ph
 | 
						||
 | 
						||
/abc\K123/startchar
 | 
						||
    xyzabc123pqr
 | 
						||
    xyzabc12\=ps
 | 
						||
    xyzabc12\=ph
 | 
						||
 | 
						||
/(?<=abc)123/
 | 
						||
    xyzabc123pqr
 | 
						||
    xyzabc12\=ps
 | 
						||
    xyzabc12\=ph
 | 
						||
 | 
						||
/\babc\b/
 | 
						||
    +++abc+++
 | 
						||
    +++ab\=ps
 | 
						||
    +++ab\=ph
 | 
						||
 | 
						||
/(?&word)(?&element)(?(DEFINE)(?<element><[^m][^>]>[^<])(?<word>\w*+))/B
 | 
						||
 | 
						||
/(?&word)(?&element)(?(DEFINE)(?<element><[^\d][^>]>[^<])(?<word>\w*+))/B
 | 
						||
 | 
						||
/(ab)(x(y)z(cd(*ACCEPT)))pq/B
 | 
						||
 | 
						||
/abc\K/aftertext,startchar
 | 
						||
    abcdef
 | 
						||
    abcdef\=notempty_atstart
 | 
						||
    xyzabcdef\=notempty_atstart
 | 
						||
\= Expect no match
 | 
						||
    abcdef\=notempty
 | 
						||
    xyzabcdef\=notempty
 | 
						||
 | 
						||
/^(?:(?=abc)|abc\K)/aftertext,startchar
 | 
						||
    abcdef
 | 
						||
    abcdef\=notempty_atstart
 | 
						||
\= Expect no match
 | 
						||
    abcdef\=notempty
 | 
						||
 | 
						||
/a?b?/aftertext
 | 
						||
    xyz
 | 
						||
    xyzabc
 | 
						||
    xyzabc\=notempty
 | 
						||
    xyzabc\=notempty_atstart
 | 
						||
    xyz\=notempty_atstart
 | 
						||
\= Expect no match
 | 
						||
    xyz\=notempty
 | 
						||
 | 
						||
/^a?b?/aftertext
 | 
						||
    xyz
 | 
						||
    xyzabc
 | 
						||
\= Expect no match
 | 
						||
    xyzabc\=notempty
 | 
						||
    xyzabc\=notempty_atstart
 | 
						||
    xyz\=notempty_atstart
 | 
						||
    xyz\=notempty
 | 
						||
 | 
						||
/^(?<name>a|b\g<name>c)/
 | 
						||
    aaaa
 | 
						||
    bacxxx
 | 
						||
    bbaccxxx
 | 
						||
    bbbacccxx
 | 
						||
 | 
						||
/^(?<name>a|b\g'name'c)/
 | 
						||
    aaaa
 | 
						||
    bacxxx
 | 
						||
    bbaccxxx
 | 
						||
    bbbacccxx
 | 
						||
 | 
						||
/^(a|b\g<1>c)/
 | 
						||
    aaaa
 | 
						||
    bacxxx
 | 
						||
    bbaccxxx
 | 
						||
    bbbacccxx
 | 
						||
 | 
						||
/^(a|b\g'1'c)/
 | 
						||
    aaaa
 | 
						||
    bacxxx
 | 
						||
    bbaccxxx
 | 
						||
    bbbacccxx
 | 
						||
 | 
						||
/^(a|b\g'-1'c)/
 | 
						||
    aaaa
 | 
						||
    bacxxx
 | 
						||
    bbaccxxx
 | 
						||
    bbbacccxx
 | 
						||
 | 
						||
/(^(a|b\g<-1>c))/
 | 
						||
    aaaa
 | 
						||
    bacxxx
 | 
						||
    bbaccxxx
 | 
						||
    bbbacccxx
 | 
						||
 | 
						||
/(?-i:\g<name>)(?i:(?<name>a))/
 | 
						||
    XaaX
 | 
						||
    XAAX
 | 
						||
 | 
						||
/(?i:\g<name>)(?-i:(?<name>a))/
 | 
						||
    XaaX
 | 
						||
\= Expect no match
 | 
						||
    XAAX
 | 
						||
 | 
						||
/(?-i:\g<+1>)(?i:(a))/
 | 
						||
    XaaX
 | 
						||
    XAAX
 | 
						||
 | 
						||
/(?=(?<regex>(?#simplesyntax)\$(?<name>[a-zA-Z_\x{7f}-\x{ff}][a-zA-Z0-9_\x{7f}-\x{ff}]*)(?:\[(?<index>[a-zA-Z0-9_\x{7f}-\x{ff}]+|\$\g<name>)\]|->\g<name>(\(.*?\))?)?|(?#simple syntax withbraces)\$\{(?:\g<name>(?<indices>\[(?:\g<index>|'(?:\\.|[^'\\])*'|"(?:\g<regex>|\\.|[^"\\])*")\])?|\g<complex>|\$\{\g<complex>\})\}|(?#complexsyntax)\{(?<complex>\$(?<segment>\g<name>(\g<indices>*|\(.*?\))?)(?:->\g<segment>)*|\$\g<complex>|\$\{\g<complex>\})\}))\{/
 | 
						||
 | 
						||
/(?<n>a|b|c)\g<n>*/
 | 
						||
   abc
 | 
						||
   accccbbb
 | 
						||
 | 
						||
/^X(?7)(a)(?|(b)|(q)(r)(s))(c)(d)(Y)/
 | 
						||
    XYabcdY
 | 
						||
 | 
						||
/(?<=b(?1)|zzz)(a)/
 | 
						||
    xbaax
 | 
						||
    xzzzax
 | 
						||
 | 
						||
/(a)(?<=b\1)/
 | 
						||
 | 
						||
/(a)(?<=b+(?1))/
 | 
						||
 | 
						||
/(a+)(?<=b(?1))/
 | 
						||
 | 
						||
/(a(?<=b(?1)))/
 | 
						||
 | 
						||
/(?<=b(?1))xyz/
 | 
						||
 | 
						||
/(?<=b(?1))xyz(b+)pqrstuvew/
 | 
						||
 | 
						||
/(a|bc)\1/I
 | 
						||
 | 
						||
/(a|bc)\1{2,3}/I
 | 
						||
 | 
						||
/(a|bc)(?1)/I
 | 
						||
 | 
						||
/(a|b\1)(a|b\1)/I
 | 
						||
 | 
						||
/(a|b\1){2}/I
 | 
						||
 | 
						||
/(a|bbbb\1)(a|bbbb\1)/I
 | 
						||
 | 
						||
/(a|bbbb\1){2}/I
 | 
						||
 | 
						||
/^From +([^ ]+) +[a-zA-Z][a-zA-Z][a-zA-Z] +[a-zA-Z][a-zA-Z][a-zA-Z] +[0-9]?[0-9] +[0-9][0-9]:[0-9][0-9]/I
 | 
						||
 | 
						||
/<tr([\w\W\s\d][^<>]{0,})><TD([\w\W\s\d][^<>]{0,})>([\d]{0,}\.)(.*)((<BR>([\w\W\s\d][^<>]{0,})|[\s]{0,}))<\/a><\/TD><TD([\w\W\s\d][^<>]{0,})>([\w\W\s\d][^<>]{0,})<\/TD><TD([\w\W\s\d][^<>]{0,})>([\w\W\s\d][^<>]{0,})<\/TD><\/TR>/Iis
 | 
						||
 | 
						||
"(?>.*/)foo"I
 | 
						||
 | 
						||
/(?(?=[^a-z]+[a-z])  \d{2}-[a-z]{3}-\d{2}  |  \d{2}-\d{2}-\d{2} ) /Ix
 | 
						||
 | 
						||
/(?:(?:(?:(?:(?:(?:(?:(?:(?:(a|b|c))))))))))/Ii
 | 
						||
 | 
						||
/(?:c|d)(?:)(?:aaaaaaaa(?:)(?:bbbbbbbb)(?:bbbbbbbb(?:))(?:bbbbbbbb(?:)(?:bbbbbbbb)))/I
 | 
						||
 | 
						||
/<a[\s]+href[\s]*=[\s]*          # find <a href=
 | 
						||
 ([\"\'])?                       # find single or double quote
 | 
						||
 (?(1) (.*?)\1 | ([^\s]+))       # if quote found, match up to next matching
 | 
						||
                                 # quote, otherwise match up to next space
 | 
						||
/Iisx
 | 
						||
 | 
						||
/^(?!:)                       # colon disallowed at start
 | 
						||
  (?:                         # start of item
 | 
						||
    (?: [0-9a-f]{1,4} |       # 1-4 hex digits or
 | 
						||
    (?(1)0 | () ) )           # if null previously matched, fail; else null
 | 
						||
    :                         # followed by colon
 | 
						||
  ){1,7}                      # end item; 1-7 of them required
 | 
						||
  [0-9a-f]{1,4} $             # final hex number at end of string
 | 
						||
  (?(1)|.)                    # check that there was an empty component
 | 
						||
  /Iix
 | 
						||
 | 
						||
/(?|(?<a>A)|(?<a>B))/I
 | 
						||
    AB\=copy=a
 | 
						||
    BA\=copy=a
 | 
						||
 | 
						||
/(?|(?<a>A)|(?<b>B))/
 | 
						||
 | 
						||
/(?:a(?<quote> (?<apostrophe>')|(?<realquote>")) |
 | 
						||
    b(?<quote> (?<apostrophe>')|(?<realquote>")) )
 | 
						||
    (?('quote')[a-z]+|[0-9]+)/Ix,dupnames
 | 
						||
    a"aaaaa
 | 
						||
    b"aaaaa
 | 
						||
\= Expect no match
 | 
						||
    b"11111
 | 
						||
    a"11111
 | 
						||
 | 
						||
/^(?|(a)(b)(c)(?<D>d)|(?<D>e)) (?('D')X|Y)/IBx,dupnames
 | 
						||
    abcdX
 | 
						||
    eX
 | 
						||
\= Expect no match
 | 
						||
    abcdY
 | 
						||
    ey
 | 
						||
 | 
						||
/(?<A>a) (b)(c)  (?<A>d  (?(R&A)$ | (?4)) )/IBx,dupnames
 | 
						||
    abcdd
 | 
						||
\= Expect no match
 | 
						||
    abcdde
 | 
						||
 | 
						||
/abcd*/
 | 
						||
    xxxxabcd\=ps
 | 
						||
    xxxxabcd\=ph
 | 
						||
 | 
						||
/abcd*/i
 | 
						||
    xxxxabcd\=ps
 | 
						||
    xxxxabcd\=ph
 | 
						||
    XXXXABCD\=ps
 | 
						||
    XXXXABCD\=ph
 | 
						||
 | 
						||
/abc\d*/
 | 
						||
    xxxxabc1\=ps
 | 
						||
    xxxxabc1\=ph
 | 
						||
 | 
						||
/(a)bc\1*/
 | 
						||
    xxxxabca\=ps
 | 
						||
    xxxxabca\=ph
 | 
						||
 | 
						||
/abc[de]*/
 | 
						||
    xxxxabcde\=ps
 | 
						||
    xxxxabcde\=ph
 | 
						||
 | 
						||
/(\3)(\1)(a)/allow_empty_class,match_unset_backref,dupnames
 | 
						||
    cat
 | 
						||
 | 
						||
/(\3)(\1)(a)/I,allow_empty_class,match_unset_backref,dupnames
 | 
						||
    cat
 | 
						||
 | 
						||
/(\3)(\1)(a)/I
 | 
						||
\= Expect no match
 | 
						||
    cat
 | 
						||
 | 
						||
/i(?(DEFINE)(?<s>a))/I
 | 
						||
    i
 | 
						||
 | 
						||
/()i(?(1)a)/I
 | 
						||
    ia
 | 
						||
 | 
						||
/(?i)a(?-i)b|c/B
 | 
						||
    XabX
 | 
						||
    XAbX
 | 
						||
    CcC
 | 
						||
\= Expect no match
 | 
						||
    XABX
 | 
						||
 | 
						||
/(?i)a(?s)b|c/B
 | 
						||
 | 
						||
/(?i)a(?s-i)b|c/B
 | 
						||
 | 
						||
/^(ab(c\1)d|x){2}$/B
 | 
						||
    xabcxd
 | 
						||
 | 
						||
/^(?&t)*+(?(DEFINE)(?<t>.))$/B
 | 
						||
 | 
						||
/^(?&t)*(?(DEFINE)(?<t>.))$/B
 | 
						||
 | 
						||
# This one is here because Perl gives the match as "b" rather than "ab". I
 | 
						||
# believe this to be a Perl bug.
 | 
						||
 | 
						||
/(?>a\Kb)z|(ab)/
 | 
						||
    ab\=startchar
 | 
						||
 | 
						||
/(?P<L1>(?P<L2>0|)|(?P>L2)(?P>L1))/
 | 
						||
    abcd
 | 
						||
    0abc
 | 
						||
 | 
						||
/abc(*MARK:)pqr/
 | 
						||
 | 
						||
/abc(*:)pqr/
 | 
						||
 | 
						||
/(*COMMIT:X)/B
 | 
						||
 | 
						||
# This should, and does, fail. In Perl, it does not, which I think is a
 | 
						||
# bug because replacing the B in the pattern by (B|D) does make it fail.
 | 
						||
# Turning off Perl's optimization by inserting (??{""}) also makes it fail.
 | 
						||
 | 
						||
/A(*COMMIT)B/aftertext,mark
 | 
						||
\= Expect no match
 | 
						||
    ACABX
 | 
						||
 | 
						||
# These should be different, but in Perl they are not, which I think
 | 
						||
# is a bug in Perl.
 | 
						||
 | 
						||
/A(*THEN)B|A(*THEN)C/mark
 | 
						||
    AC
 | 
						||
 | 
						||
/A(*PRUNE)B|A(*PRUNE)C/mark
 | 
						||
\= Expect no match
 | 
						||
    AC
 | 
						||
 | 
						||
# Mark names can be duplicated. Perl doesn't give a mark for this one,
 | 
						||
# though PCRE2 does.
 | 
						||
 | 
						||
/^A(*:A)B|^X(*:A)Y/mark
 | 
						||
\= Expect no match
 | 
						||
    XAQQ
 | 
						||
 | 
						||
# COMMIT at the start of a pattern should be the same as an anchor. Perl
 | 
						||
# optimizations defeat this. So does the PCRE2 optimization unless we disable
 | 
						||
# it.
 | 
						||
 | 
						||
/(*COMMIT)ABC/
 | 
						||
    ABCDEFG
 | 
						||
 | 
						||
/(*COMMIT)ABC/no_start_optimize
 | 
						||
\= Expect no match
 | 
						||
    DEFGABC
 | 
						||
 | 
						||
/^(ab (c+(*THEN)cd) | xyz)/x
 | 
						||
\= Expect no match
 | 
						||
    abcccd
 | 
						||
 | 
						||
/^(ab (c+(*PRUNE)cd) | xyz)/x
 | 
						||
\= Expect no match
 | 
						||
    abcccd
 | 
						||
 | 
						||
/^(ab (c+(*FAIL)cd) | xyz)/x
 | 
						||
\= Expect no match
 | 
						||
    abcccd
 | 
						||
 | 
						||
# Perl gets some of these wrong
 | 
						||
 | 
						||
/(?>.(*ACCEPT))*?5/
 | 
						||
    abcde
 | 
						||
 | 
						||
/(.(*ACCEPT))*?5/
 | 
						||
    abcde
 | 
						||
 | 
						||
/(.(*ACCEPT))5/
 | 
						||
    abcde
 | 
						||
 | 
						||
/(.(*ACCEPT))*5/
 | 
						||
    abcde
 | 
						||
 | 
						||
/A\NB./B
 | 
						||
    ACBD
 | 
						||
\= Expect no match
 | 
						||
    A\nB
 | 
						||
    ACB\n
 | 
						||
 | 
						||
/A\NB./Bs
 | 
						||
    ACBD
 | 
						||
    ACB\n
 | 
						||
\= Expect no match
 | 
						||
    A\nB
 | 
						||
 | 
						||
/A\NB/newline=crlf
 | 
						||
    A\nB
 | 
						||
    A\rB
 | 
						||
\= Expect no match
 | 
						||
    A\r\nB
 | 
						||
 | 
						||
/\R+b/B
 | 
						||
 | 
						||
/\R+\n/B
 | 
						||
 | 
						||
/\R+\d/B
 | 
						||
 | 
						||
/\d*\R/B
 | 
						||
 | 
						||
/\s*\R/B
 | 
						||
    \x20\x0a
 | 
						||
    \x20\x0d
 | 
						||
    \x20\x0d\x0a
 | 
						||
 | 
						||
/\S*\R/B
 | 
						||
    a\x0a
 | 
						||
 | 
						||
/X\h*\R/B
 | 
						||
    X\x20\x0a
 | 
						||
 | 
						||
/X\H*\R/B
 | 
						||
    X\x0d\x0a
 | 
						||
 | 
						||
/X\H+\R/B
 | 
						||
    X\x0d\x0a
 | 
						||
 | 
						||
/X\H++\R/B
 | 
						||
\= Expect no match
 | 
						||
    X\x0d\x0a
 | 
						||
 | 
						||
/(?<=abc)def/
 | 
						||
    abc\=ph
 | 
						||
 | 
						||
/abc$/
 | 
						||
    abc
 | 
						||
    abc\=ps
 | 
						||
    abc\=ph
 | 
						||
 | 
						||
/abc$/m
 | 
						||
    abc
 | 
						||
    abc\n
 | 
						||
    abc\=ph
 | 
						||
    abc\n\=ph
 | 
						||
    abc\=ps
 | 
						||
    abc\n\=ps
 | 
						||
 | 
						||
/abc\z/
 | 
						||
    abc
 | 
						||
    abc\=ps
 | 
						||
    abc\=ph
 | 
						||
 | 
						||
/abc\Z/
 | 
						||
    abc
 | 
						||
    abc\=ps
 | 
						||
    abc\=ph
 | 
						||
 | 
						||
/abc\b/
 | 
						||
    abc
 | 
						||
    abc\=ps
 | 
						||
    abc\=ph
 | 
						||
 | 
						||
/abc\B/
 | 
						||
    abc\=ps
 | 
						||
    abc\=ph
 | 
						||
\= Expect no match
 | 
						||
    abc
 | 
						||
 | 
						||
/.+/
 | 
						||
\= Bad offsets
 | 
						||
    abc\=offset=4
 | 
						||
    abc\=offset=-4
 | 
						||
\= Valid data
 | 
						||
    abc\=offset=0
 | 
						||
    abc\=offset=1
 | 
						||
    abc\=offset=2
 | 
						||
\= Expect no match
 | 
						||
    abc\=offset=3
 | 
						||
 | 
						||
/^\cģ/
 | 
						||
 | 
						||
/(?P<abn>(?P=abn)xxx)/B
 | 
						||
 | 
						||
/(a\1z)/B
 | 
						||
 | 
						||
/(?P<abn>(?P=abn)(?<badstufxxx)/B
 | 
						||
 | 
						||
/(?P<abn>(?P=axn)xxx)/B
 | 
						||
 | 
						||
/(?P<abn>(?P=axn)xxx)(?<axn>yy)/B
 | 
						||
 | 
						||
# These tests are here because Perl gets the first one wrong.
 | 
						||
 | 
						||
/(\R*)(.)/s
 | 
						||
    \r\n
 | 
						||
    \r\r\n\n\r
 | 
						||
    \r\r\n\n\r\n
 | 
						||
 | 
						||
/(\R)*(.)/s
 | 
						||
    \r\n
 | 
						||
    \r\r\n\n\r
 | 
						||
    \r\r\n\n\r\n
 | 
						||
 | 
						||
/((?>\r\n|\n|\x0b|\f|\r|\x85)*)(.)/s
 | 
						||
    \r\n
 | 
						||
    \r\r\n\n\r
 | 
						||
    \r\r\n\n\r\n
 | 
						||
 | 
						||
# -------------
 | 
						||
 | 
						||
/^abc$/B
 | 
						||
 | 
						||
/^abc$/Bm
 | 
						||
 | 
						||
/^(a)*+(\w)/
 | 
						||
    aaaaX
 | 
						||
\= Expect no match
 | 
						||
    aaaa
 | 
						||
 | 
						||
/^(?:a)*+(\w)/
 | 
						||
    aaaaX
 | 
						||
\= Expect no match
 | 
						||
    aaaa
 | 
						||
 | 
						||
/(a)++1234/IB
 | 
						||
 | 
						||
/([abc])++1234/I
 | 
						||
 | 
						||
/(?<=(abc)+)X/
 | 
						||
 | 
						||
/(^ab)/I
 | 
						||
 | 
						||
/(^ab)++/I
 | 
						||
 | 
						||
/(^ab|^)+/I
 | 
						||
 | 
						||
/(^ab|^)++/I
 | 
						||
 | 
						||
/(?:^ab)/I
 | 
						||
 | 
						||
/(?:^ab)++/I
 | 
						||
 | 
						||
/(?:^ab|^)+/I
 | 
						||
 | 
						||
/(?:^ab|^)++/I
 | 
						||
 | 
						||
/(.*ab)/I
 | 
						||
 | 
						||
/(.*ab)++/I
 | 
						||
 | 
						||
/(.*ab|.*)+/I
 | 
						||
 | 
						||
/(.*ab|.*)++/I
 | 
						||
 | 
						||
/(?:.*ab)/I
 | 
						||
 | 
						||
/(?:.*ab)++/I
 | 
						||
 | 
						||
/(?:.*ab|.*)+/I
 | 
						||
 | 
						||
/(?:.*ab|.*)++/I
 | 
						||
 | 
						||
/(?=a)[bcd]/I
 | 
						||
 | 
						||
/((?=a))[bcd]/I
 | 
						||
 | 
						||
/((?=a))+[bcd]/I
 | 
						||
 | 
						||
/((?=a))++[bcd]/I
 | 
						||
 | 
						||
/(?=a+)[bcd]/Ii
 | 
						||
 | 
						||
/(?=a+?)[bcd]/Ii
 | 
						||
 | 
						||
/(?=a++)[bcd]/Ii
 | 
						||
 | 
						||
/(?=a{3})[bcd]/Ii
 | 
						||
 | 
						||
/(abc)\1+/
 | 
						||
 | 
						||
# Perl doesn't get these right IMO (the 3rd is PCRE2-specific)
 | 
						||
 | 
						||
/(?1)(?:(b(*ACCEPT))){0}/
 | 
						||
    b
 | 
						||
 | 
						||
/(?1)(?:(b(*ACCEPT))){0}c/
 | 
						||
    bc
 | 
						||
\= Expect no match
 | 
						||
    b
 | 
						||
 | 
						||
/(?1)(?:((*ACCEPT))){0}c/
 | 
						||
    c
 | 
						||
    c\=notempty
 | 
						||
 | 
						||
/^.*?(?(?=a)a|b(*THEN)c)/
 | 
						||
\= Expect no match
 | 
						||
    ba
 | 
						||
 | 
						||
/^.*?(?(?=a)a|bc)/
 | 
						||
    ba
 | 
						||
 | 
						||
/^.*?(?(?=a)a(*THEN)b|c)/
 | 
						||
\= Expect no match
 | 
						||
    ac
 | 
						||
 | 
						||
/^.*?(?(?=a)a(*THEN)b)c/
 | 
						||
\= Expect no match
 | 
						||
    ac
 | 
						||
 | 
						||
/^.*?(a(*THEN)b)c/
 | 
						||
\= Expect no match
 | 
						||
    aabc
 | 
						||
 | 
						||
/^.*? (?1) c (?(DEFINE)(a(*THEN)b))/x
 | 
						||
    aabc
 | 
						||
 | 
						||
/^.*?(a(*THEN)b|z)c/
 | 
						||
    aabc
 | 
						||
 | 
						||
/^.*?(z|a(*THEN)b)c/
 | 
						||
    aabc
 | 
						||
 | 
						||
# These are here because they are not Perl-compatible; the studying means the
 | 
						||
# mark is not seen.
 | 
						||
 | 
						||
/(*MARK:A)(*SKIP:B)(C|X)/mark
 | 
						||
    C
 | 
						||
\= Expect no match
 | 
						||
    D
 | 
						||
 | 
						||
/(*:A)A+(*SKIP:A)(B|Z)/mark
 | 
						||
\= Expect no match
 | 
						||
    AAAC
 | 
						||
 | 
						||
# ----------------------------
 | 
						||
 | 
						||
"(?=a*(*ACCEPT)b)c"
 | 
						||
    c
 | 
						||
    c\=notempty
 | 
						||
 | 
						||
/(?1)c(?(DEFINE)((*ACCEPT)b))/
 | 
						||
    c
 | 
						||
    c\=notempty
 | 
						||
 | 
						||
/(?>(*ACCEPT)b)c/
 | 
						||
    c
 | 
						||
\= Expect no match
 | 
						||
    c\=notempty
 | 
						||
 | 
						||
/(?:(?>(a)))+a%/allaftertext
 | 
						||
    %aa%
 | 
						||
 | 
						||
/(a)b|ac/allaftertext
 | 
						||
    ac\=ovector=1
 | 
						||
 | 
						||
/(a)(b)x|abc/allaftertext
 | 
						||
     abc\=ovector=2
 | 
						||
 | 
						||
/(a)bc|(a)(b)\2/
 | 
						||
    abc\=ovector=1
 | 
						||
    abc\=ovector=2
 | 
						||
    aba\=ovector=1
 | 
						||
    aba\=ovector=2
 | 
						||
    aba\=ovector=3
 | 
						||
    aba\=ovector=4
 | 
						||
 | 
						||
/(?(DEFINE)(a(?2)|b)(b(?1)|a))(?:(?1)|(?2))/I
 | 
						||
 | 
						||
/(a(?2)|b)(b(?1)|a)(?:(?1)|(?2))/I
 | 
						||
 | 
						||
/(a(?2)|b)(b(?1)|a)(?1)(?2)/I
 | 
						||
 | 
						||
/(abc)(?1)/I
 | 
						||
 | 
						||
/(?:(foo)|(bar)|(baz))X/allcaptures
 | 
						||
    bazfooX
 | 
						||
    foobazbarX
 | 
						||
    barfooX
 | 
						||
    bazX
 | 
						||
    foobarbazX
 | 
						||
    bazfooX\=ovector=0
 | 
						||
    bazfooX\=ovector=1
 | 
						||
    bazfooX\=ovector=2
 | 
						||
    bazfooX\=ovector=3
 | 
						||
 | 
						||
/(?=abc){3}abc/B
 | 
						||
 | 
						||
/(?=abc)+abc/B
 | 
						||
 | 
						||
/(?=abc)++abc/B
 | 
						||
 | 
						||
/(?=abc){0}xyz/B
 | 
						||
 | 
						||
/(?=(a))?./B
 | 
						||
 | 
						||
/(?=(a))??./B
 | 
						||
 | 
						||
/^(?=(a)){0}b(?1)/B
 | 
						||
 | 
						||
/(?(DEFINE)(a))?b(?1)/B
 | 
						||
 | 
						||
/^(?=(?1))?[az]([abc])d/B
 | 
						||
 | 
						||
/^(?!a){0}\w+/B
 | 
						||
 | 
						||
/(?<=(abc))?xyz/B
 | 
						||
 | 
						||
/[:a[:abc]b:]/B
 | 
						||
 | 
						||
/^(a(*:A)(d|e(*:B))z|aeq)/auto_callout
 | 
						||
    adz
 | 
						||
    aez
 | 
						||
    aeqwerty
 | 
						||
 | 
						||
/.(*F)/
 | 
						||
\= Expect no match
 | 
						||
    abc\=ph
 | 
						||
 | 
						||
/\btype\b\W*?\btext\b\W*?\bjavascript\b/I
 | 
						||
 | 
						||
/\btype\b\W*?\btext\b\W*?\bjavascript\b|\burl\b\W*?\bshell:|<input\b.*?\btype\b\W*?\bimage\b|\bonkeyup\b\W*?\=/I
 | 
						||
 | 
						||
/a(*SKIP)c|b(*ACCEPT)|/I,aftertext
 | 
						||
    a
 | 
						||
 | 
						||
/a(*SKIP)c|b(*ACCEPT)cd(*ACCEPT)|x/I
 | 
						||
    ax
 | 
						||
 | 
						||
'a*(*ACCEPT)b'aftertext
 | 
						||
    abc\=notempty_atstart
 | 
						||
    bbb\=notempty_atstart
 | 
						||
\= Expect no match
 | 
						||
    \=notempty_atstart
 | 
						||
 | 
						||
/(*ACCEPT)a/I,aftertext
 | 
						||
    bax
 | 
						||
 | 
						||
/z(*ACCEPT)a/I,aftertext
 | 
						||
    baxzbx
 | 
						||
 | 
						||
/^(?>a+)(?>(z+))\w/B
 | 
						||
    aaaazzzzb
 | 
						||
\= Expect no match
 | 
						||
    aazz
 | 
						||
 | 
						||
/(.)(\1|a(?2))/
 | 
						||
    bab
 | 
						||
 | 
						||
/\1|(.)(?R)\1/
 | 
						||
    cbbbc
 | 
						||
 | 
						||
/(.)((?(1)c|a)|a(?2))/
 | 
						||
\= Expect no match
 | 
						||
    baa
 | 
						||
 | 
						||
/(?P<abn>(?P=abn)xxx)/B
 | 
						||
 | 
						||
/(a\1z)/B
 | 
						||
 | 
						||
/^a\x41z/alt_bsux,allow_empty_class,match_unset_backref,dupnames
 | 
						||
    aAz
 | 
						||
\= Expect no match
 | 
						||
    ax41z
 | 
						||
 | 
						||
/^a[m\x41]z/alt_bsux,allow_empty_class,match_unset_backref,dupnames
 | 
						||
    aAz
 | 
						||
 | 
						||
/^a\x1z/alt_bsux,allow_empty_class,match_unset_backref,dupnames
 | 
						||
    ax1z
 | 
						||
 | 
						||
/^a\u0041z/alt_bsux,allow_empty_class,match_unset_backref,dupnames
 | 
						||
    aAz
 | 
						||
\= Expect no match
 | 
						||
    au0041z
 | 
						||
 | 
						||
/^a[m\u0041]z/alt_bsux,allow_empty_class,match_unset_backref,dupnames
 | 
						||
    aAz
 | 
						||
 | 
						||
/^a\u041z/alt_bsux,allow_empty_class,match_unset_backref,dupnames
 | 
						||
    au041z
 | 
						||
\= Expect no match
 | 
						||
    aAz
 | 
						||
 | 
						||
/^a\U0041z/alt_bsux,allow_empty_class,match_unset_backref,dupnames
 | 
						||
    aU0041z
 | 
						||
\= Expect no match
 | 
						||
    aAz
 | 
						||
    
 | 
						||
/^\u{7a}/alt_bsux
 | 
						||
    u{7a}
 | 
						||
\= Expect no match
 | 
						||
    zoo 
 | 
						||
 | 
						||
/^\u{7a}/extra_alt_bsux
 | 
						||
    zoo 
 | 
						||
 | 
						||
/(?(?=c)c|d)++Y/B
 | 
						||
 | 
						||
/(?(?=c)c|d)*+Y/B
 | 
						||
 | 
						||
/a[\NB]c/
 | 
						||
    aNc
 | 
						||
 | 
						||
/a[B-\Nc]/
 | 
						||
 | 
						||
/a[B\Nc]/
 | 
						||
 | 
						||
/(a)(?2){0,1999}?(b)/
 | 
						||
 | 
						||
/(a)(?(DEFINE)(b))(?2){0,1999}?(?2)/
 | 
						||
 | 
						||
# This test, with something more complicated than individual letters, causes
 | 
						||
# different behaviour in Perl. Perhaps it disables some optimization; no tag is
 | 
						||
# passed back for the failures, whereas in PCRE2 there is a tag.
 | 
						||
 | 
						||
/(A|P)(*:A)(B|P) | (X|P)(X|P)(*:B)(Y|P)/x,mark
 | 
						||
    AABC
 | 
						||
    XXYZ
 | 
						||
\= Expect no match
 | 
						||
    XAQQ
 | 
						||
    XAQQXZZ
 | 
						||
    AXQQQ
 | 
						||
    AXXQQQ
 | 
						||
 | 
						||
# Perl doesn't give marks for these, though it does if the alternatives are
 | 
						||
# replaced by single letters.
 | 
						||
 | 
						||
/(b|q)(*:m)f|a(*:n)w/mark
 | 
						||
    aw
 | 
						||
\= Expect no match
 | 
						||
    abc
 | 
						||
 | 
						||
/(q|b)(*:m)f|a(*:n)w/mark
 | 
						||
    aw
 | 
						||
\= Expect no match
 | 
						||
    abc
 | 
						||
 | 
						||
# After a partial match, the behaviour is as for a failure.
 | 
						||
 | 
						||
/^a(*:X)bcde/mark
 | 
						||
   abc\=ps
 | 
						||
 | 
						||
# These are here because Perl doesn't return a mark, except for the first.
 | 
						||
 | 
						||
/(?=(*:x))(q|)/aftertext,mark
 | 
						||
    abc
 | 
						||
 | 
						||
/(?=(*:x))((*:y)q|)/aftertext,mark
 | 
						||
    abc
 | 
						||
 | 
						||
/(?=(*:x))(?:(*:y)q|)/aftertext,mark
 | 
						||
    abc
 | 
						||
 | 
						||
/(?=(*:x))(?>(*:y)q|)/aftertext,mark
 | 
						||
    abc
 | 
						||
 | 
						||
/(?=a(*:x))(?!a(*:y)c)/aftertext,mark
 | 
						||
    ab
 | 
						||
 | 
						||
/(?=a(*:x))(?=a(*:y)c|)/aftertext,mark
 | 
						||
    ab
 | 
						||
 | 
						||
/(..)\1/
 | 
						||
    ab\=ps
 | 
						||
    aba\=ps
 | 
						||
    abab\=ps
 | 
						||
 | 
						||
/(..)\1/i
 | 
						||
    ab\=ps
 | 
						||
    abA\=ps
 | 
						||
    aBAb\=ps
 | 
						||
 | 
						||
/(..)\1{2,}/
 | 
						||
    ab\=ps
 | 
						||
    aba\=ps
 | 
						||
    abab\=ps
 | 
						||
    ababa\=ps
 | 
						||
    ababab\=ps
 | 
						||
    ababab\=ph
 | 
						||
    abababa\=ps
 | 
						||
    abababa\=ph
 | 
						||
 | 
						||
/(..)\1{2,}/i
 | 
						||
    ab\=ps
 | 
						||
    aBa\=ps
 | 
						||
    aBAb\=ps
 | 
						||
    AbaBA\=ps
 | 
						||
    abABAb\=ps
 | 
						||
    aBAbaB\=ph
 | 
						||
    abABabA\=ps
 | 
						||
    abaBABa\=ph
 | 
						||
 | 
						||
/(..)\1{2,}?x/i
 | 
						||
    ab\=ps
 | 
						||
    abA\=ps
 | 
						||
    aBAb\=ps
 | 
						||
    abaBA\=ps
 | 
						||
    abAbaB\=ps
 | 
						||
    abaBabA\=ps
 | 
						||
    abAbABaBx\=ps
 | 
						||
 | 
						||
/^(..)\1/
 | 
						||
    aba\=ps
 | 
						||
 | 
						||
/^(..)\1{2,3}x/
 | 
						||
    aba\=ps
 | 
						||
    ababa\=ps
 | 
						||
    ababa\=ph
 | 
						||
    abababx
 | 
						||
    ababababx
 | 
						||
 | 
						||
/^(..)\1{2,3}?x/
 | 
						||
    aba\=ps
 | 
						||
    ababa\=ps
 | 
						||
    ababa\=ph
 | 
						||
    abababx
 | 
						||
    ababababx
 | 
						||
 | 
						||
/^(..)(\1{2,3})ab/
 | 
						||
    abababab
 | 
						||
 | 
						||
/^\R/
 | 
						||
    \r\=ps
 | 
						||
    \r\=ph
 | 
						||
 | 
						||
/^\R{2,3}x/
 | 
						||
    \r\=ps
 | 
						||
    \r\=ph
 | 
						||
    \r\r\=ps
 | 
						||
    \r\r\=ph
 | 
						||
    \r\r\r\=ps
 | 
						||
    \r\r\r\=ph
 | 
						||
    \r\rx
 | 
						||
    \r\r\rx
 | 
						||
 | 
						||
/^\R{2,3}?x/
 | 
						||
    \r\=ps
 | 
						||
    \r\=ph
 | 
						||
    \r\r\=ps
 | 
						||
    \r\r\=ph
 | 
						||
    \r\r\r\=ps
 | 
						||
    \r\r\r\=ph
 | 
						||
    \r\rx
 | 
						||
    \r\r\rx
 | 
						||
 | 
						||
/^\R?x/
 | 
						||
    \r\=ps
 | 
						||
    \r\=ph
 | 
						||
    x
 | 
						||
    \rx
 | 
						||
 | 
						||
/^\R+x/
 | 
						||
    \r\=ps
 | 
						||
    \r\=ph
 | 
						||
    \r\n\=ps
 | 
						||
    \r\n\=ph
 | 
						||
    \rx
 | 
						||
 | 
						||
/^a$/newline=crlf
 | 
						||
    a\r\=ps
 | 
						||
    a\r\=ph
 | 
						||
 | 
						||
/^a$/m,newline=crlf
 | 
						||
    a\r\=ps
 | 
						||
    a\r\=ph
 | 
						||
 | 
						||
/^(a$|a\r)/newline=crlf
 | 
						||
    a\r\=ps
 | 
						||
    a\r\=ph
 | 
						||
 | 
						||
/^(a$|a\r)/m,newline=crlf
 | 
						||
    a\r\=ps
 | 
						||
    a\r\=ph
 | 
						||
 | 
						||
/./newline=crlf
 | 
						||
    \r\=ps
 | 
						||
    \r\=ph
 | 
						||
 | 
						||
/.{2,3}/newline=crlf
 | 
						||
    \r\=ps
 | 
						||
    \r\=ph
 | 
						||
    \r\r\=ps
 | 
						||
    \r\r\=ph
 | 
						||
    \r\r\r\=ps
 | 
						||
    \r\r\r\=ph
 | 
						||
 | 
						||
/.{2,3}?/newline=crlf
 | 
						||
    \r\=ps
 | 
						||
    \r\=ph
 | 
						||
    \r\r\=ps
 | 
						||
    \r\r\=ph
 | 
						||
    \r\r\r\=ps
 | 
						||
    \r\r\r\=ph
 | 
						||
 | 
						||
"AB(C(D))(E(F))?(?(?=\2)(?=\4))"
 | 
						||
    ABCDGHI\=ovector=01
 | 
						||
 | 
						||
# These are all run as real matches in test 1; here we are just checking the
 | 
						||
# settings of the anchored and startline bits.
 | 
						||
 | 
						||
/(?>.*?a)(?<=ba)/I
 | 
						||
 | 
						||
/(?:.*?a)(?<=ba)/I
 | 
						||
 | 
						||
/.*?a(*PRUNE)b/I
 | 
						||
 | 
						||
/.*?a(*PRUNE)b/Is
 | 
						||
 | 
						||
/^a(*PRUNE)b/Is
 | 
						||
 | 
						||
/.*?a(*SKIP)b/I
 | 
						||
 | 
						||
/(?>.*?a)b/Is
 | 
						||
 | 
						||
/(?>.*?a)b/I
 | 
						||
 | 
						||
/(?>^a)b/Is
 | 
						||
 | 
						||
/(?>.*?)(?<=(abcd)|(wxyz))/I
 | 
						||
 | 
						||
/(?>.*)(?<=(abcd)|(wxyz))/I
 | 
						||
 | 
						||
"(?>.*)foo"I
 | 
						||
 | 
						||
"(?>.*?)foo"I
 | 
						||
 | 
						||
/(?>^abc)/Im
 | 
						||
 | 
						||
/(?>.*abc)/Im
 | 
						||
 | 
						||
/(?:.*abc)/Im
 | 
						||
 | 
						||
/(?:(a)+(?C1)bb|aa(?C2)b)/
 | 
						||
    aab\=callout_capture
 | 
						||
 | 
						||
/(?:(a)++(?C1)bb|aa(?C2)b)/
 | 
						||
    aab\=callout_capture
 | 
						||
 | 
						||
/(?:(?>(a))(?C1)bb|aa(?C2)b)/
 | 
						||
    aab\=callout_capture
 | 
						||
 | 
						||
/(?:(?1)(?C1)x|ab(?C2))((a)){0}/
 | 
						||
    aab\=callout_capture
 | 
						||
 | 
						||
/(?1)(?C1)((a)(?C2)){0}/
 | 
						||
    aab\=callout_capture
 | 
						||
 | 
						||
/(?:(a)+(?C1)bb|aa(?C2)b)++/
 | 
						||
    aab\=callout_capture
 | 
						||
    aab\=callout_capture,ovector=1
 | 
						||
 | 
						||
/(ab)x|ab/
 | 
						||
    ab\=ovector=0
 | 
						||
    ab\=ovector=1
 | 
						||
 | 
						||
/(?<=123)(*MARK:xx)abc/mark
 | 
						||
    xxxx123a\=ph
 | 
						||
    xxxx123a\=ps
 | 
						||
 | 
						||
/123\Kabc/startchar
 | 
						||
    xxxx123a\=ph
 | 
						||
    xxxx123a\=ps
 | 
						||
 | 
						||
/^(?(?=a)aa|bb)/auto_callout
 | 
						||
    bb
 | 
						||
 | 
						||
/(?C1)^(?C2)(?(?C99)(?=(?C3)a(?C4))(?C5)a(?C6)a(?C7)|(?C8)b(?C9)b(?C10))(?C11)/
 | 
						||
    bb
 | 
						||
 | 
						||
# Perl seems to have a bug with this one.
 | 
						||
 | 
						||
/aaaaa(*COMMIT)(*PRUNE)b|a+c/
 | 
						||
    aaaaaac
 | 
						||
 | 
						||
# Here are some that Perl treats differently because of the way it handles
 | 
						||
# backtracking verbs.
 | 
						||
 | 
						||
/(?!a(*COMMIT)b)ac|ad/
 | 
						||
     ac
 | 
						||
     ad
 | 
						||
 | 
						||
/^(?!a(*THEN)b|ac)../
 | 
						||
     ad
 | 
						||
\= Expect no match
 | 
						||
     ac
 | 
						||
 | 
						||
/^(?=a(*THEN)b|ac)/
 | 
						||
    ac
 | 
						||
 | 
						||
/\A.*?(?:a|b(*THEN)c)/
 | 
						||
    ba
 | 
						||
 | 
						||
/\A.*?(?:a|b(*THEN)c)++/
 | 
						||
    ba
 | 
						||
 | 
						||
/\A.*?(?:a|b(*THEN)c|d)/
 | 
						||
    ba
 | 
						||
 | 
						||
/(?:(a(*MARK:X)a+(*SKIP:X)b)){0}(?:(?1)|aac)/
 | 
						||
    aac
 | 
						||
 | 
						||
/\A.*?(a|b(*THEN)c)/
 | 
						||
    ba
 | 
						||
 | 
						||
/^(A(*THEN)B|A(*THEN)D)/
 | 
						||
    AD
 | 
						||
 | 
						||
/(?!b(*THEN)a)bn|bnn/
 | 
						||
    bnn
 | 
						||
 | 
						||
/(?(?=b(*SKIP)a)bn|bnn)/
 | 
						||
    bnn
 | 
						||
 | 
						||
/(?=b(*THEN)a|)bn|bnn/
 | 
						||
    bnn
 | 
						||
 | 
						||
# This test causes a segfault with Perl 5.18.0
 | 
						||
 | 
						||
/^(?=(a)){0}b(?1)/
 | 
						||
    backgammon
 | 
						||
 | 
						||
/(?|(?<n>f)|(?<n>b))/I,dupnames
 | 
						||
 | 
						||
/(?<a>abc)(?<a>z)\k<a>()/IB,dupnames
 | 
						||
 | 
						||
/a*[bcd]/B
 | 
						||
 | 
						||
/[bcd]*a/B
 | 
						||
 | 
						||
# A complete set of tests for auto-possessification of character types, but
 | 
						||
# omitting \C because it might be disabled (it has its own tests).
 | 
						||
 | 
						||
/\D+\D \D+\d \D+\S \D+\s \D+\W \D+\w \D+. \D+\R \D+\H \D+\h \D+\V \D+\v \D+\Z \D+\z \D+$/Bx
 | 
						||
 | 
						||
/\d+\D \d+\d \d+\S \d+\s \d+\W \d+\w \d+. \d+\R \d+\H \d+\h \d+\V \d+\v \d+\Z \d+\z \d+$/Bx
 | 
						||
 | 
						||
/\S+\D \S+\d \S+\S \S+\s \S+\W \S+\w \S+. \S+\R \S+\H \S+\h \S+\V \S+\v \S+\Z \S+\z \S+$/Bx
 | 
						||
 | 
						||
/\s+\D \s+\d \s+\S \s+\s \s+\W \s+\w \s+. \s+\R \s+\H \s+\h \s+\V \s+\v \s+\Z \s+\z \s+$/Bx
 | 
						||
 | 
						||
/\W+\D \W+\d \W+\S \W+\s \W+\W \W+\w \W+. \W+\R \W+\H \W+\h \W+\V \W+\v \W+\Z \W+\z \W+$/Bx
 | 
						||
 | 
						||
/\w+\D \w+\d \w+\S \w+\s \w+\W \w+\w \w+. \w+\R \w+\H \w+\h \w+\V \w+\v \w+\Z \w+\z \w+$/Bx
 | 
						||
 | 
						||
/\R+\D \R+\d \R+\S \R+\s \R+\W \R+\w \R+. \R+\R \R+\H \R+\h \R+\V \R+\v \R+\Z \R+\z \R+$/Bx
 | 
						||
 | 
						||
/\H+\D \H+\d \H+\S \H+\s \H+\W \H+\w \H+. \H+\R \H+\H \H+\h \H+\V \H+\v \H+\Z \H+\z \H+$/Bx
 | 
						||
 | 
						||
/\h+\D \h+\d \h+\S \h+\s \h+\W \h+\w \h+. \h+\R \h+\H \h+\h \h+\V \h+\v \h+\Z \h+\z \h+$/Bx
 | 
						||
 | 
						||
/\V+\D \V+\d \V+\S \V+\s \V+\W \V+\w \V+. \V+\R \V+\H \V+\h \V+\V \V+\v \V+\Z \V+\z \V+$/Bx
 | 
						||
 | 
						||
/\v+\D \v+\d \v+\S \v+\s \v+\W \v+\w \v+. \v+\R \v+\H \v+\h \v+\V \v+\v \v+\Z \v+\z \v+$/Bx
 | 
						||
 | 
						||
/ a+\D  a+\d  a+\S  a+\s  a+\W  a+\w  a+.  a+\R  a+\H  a+\h  a+\V  a+\v  a+\Z  a+\z  a+$/Bx
 | 
						||
 | 
						||
/\n+\D \n+\d \n+\S \n+\s \n+\W \n+\w \n+. \n+\R \n+\H \n+\h \n+\V \n+\v \n+\Z \n+\z \n+$/Bx
 | 
						||
 | 
						||
/ .+\D  .+\d  .+\S  .+\s  .+\W  .+\w  .+.  .+\R  .+\H  .+\h  .+\V  .+\v  .+\Z  .+\z  .+$/Bx
 | 
						||
 | 
						||
/ .+\D  .+\d  .+\S  .+\s  .+\W  .+\w  .+.  .+\R  .+\H  .+\h  .+\V  .+\v  .+\Z  .+\z  .+$/Bsx
 | 
						||
 | 
						||
/ \D+$  \d+$  \S+$  \s+$  \W+$  \w+$  \R+$  \H+$  \h+$  \V+$ \v+$  a+$   \n+$  .+$  .+$/Bmx
 | 
						||
 | 
						||
/(?=a+)a(a+)++a/B
 | 
						||
 | 
						||
/a+(bb|cc)a+(?:bb|cc)a+(?>bb|cc)a+(?:bb|cc)+a+(aa)a+(?:bb|aa)/B
 | 
						||
 | 
						||
/a+(bb|cc)?#a+(?:bb|cc)??#a+(?:bb|cc)?+#a+(?:bb|cc)*#a+(bb|cc)?a#a+(?:aa)?/B
 | 
						||
 | 
						||
/a+(?:bb)?a#a+(?:|||)#a+(?:|b)a#a+(?:|||)?a/B
 | 
						||
 | 
						||
/[ab]*/B
 | 
						||
    aaaa
 | 
						||
 | 
						||
/[ab]*?/B
 | 
						||
    aaaa
 | 
						||
 | 
						||
/[ab]?/B
 | 
						||
    aaaa
 | 
						||
 | 
						||
/[ab]??/B
 | 
						||
    aaaa
 | 
						||
 | 
						||
/[ab]+/B
 | 
						||
    aaaa
 | 
						||
 | 
						||
/[ab]+?/B
 | 
						||
    aaaa
 | 
						||
 | 
						||
/[ab]{2,3}/B
 | 
						||
    aaaa
 | 
						||
 | 
						||
/[ab]{2,3}?/B
 | 
						||
    aaaa
 | 
						||
 | 
						||
/[ab]{2,}/B
 | 
						||
    aaaa
 | 
						||
 | 
						||
/[ab]{2,}?/B
 | 
						||
    aaaa
 | 
						||
 | 
						||
/\d+\s{0,5}=\s*\S?=\w{0,4}\W*/B
 | 
						||
 | 
						||
/[a-d]{5,12}[e-z0-9]*#[^a-z]+[b-y]*a[2-7]?[^0-9a-z]+/B
 | 
						||
 | 
						||
/[a-z]*\s#[ \t]?\S#[a-c]*\S#[C-G]+?\d#[4-8]*\D#[4-9,]*\D#[!$]{0,5}\w#[M-Xf-l]+\W#[a-c,]?\W/B
 | 
						||
 | 
						||
/a+(aa|bb)*c#a*(bb|cc)*a#a?(bb|cc)*d#[a-f]*(g|hh)*f/B
 | 
						||
 | 
						||
/[a-f]*(g|hh|i)*i#[a-x]{4,}(y{0,6})*y#[a-k]+(ll|mm)+n/B
 | 
						||
 | 
						||
/[a-f]*(?>gg|hh)+#[a-f]*(?>gg|hh)?#[a-f]*(?>gg|hh)*a#[a-f]*(?>gg|hh)*h/B
 | 
						||
 | 
						||
/[a-c]*d/IB
 | 
						||
 | 
						||
/[a-c]+d/IB
 | 
						||
 | 
						||
/[a-c]?d/IB
 | 
						||
 | 
						||
/[a-c]{4,6}d/IB
 | 
						||
 | 
						||
/[a-c]{0,6}d/IB
 | 
						||
 | 
						||
# End of special auto-possessive tests
 | 
						||
 | 
						||
/^A\o{1239}B/
 | 
						||
    A\123B
 | 
						||
 | 
						||
/^A\oB/
 | 
						||
 | 
						||
/^A\x{zz}B/
 | 
						||
 | 
						||
/^A\x{12Z/
 | 
						||
 | 
						||
/^A\x{/
 | 
						||
 | 
						||
/[ab]++/B,no_auto_possess
 | 
						||
 | 
						||
/[^ab]*+/B,no_auto_possess
 | 
						||
 | 
						||
/a{4}+/B,no_auto_possess
 | 
						||
 | 
						||
/a{4}+/Bi,no_auto_possess
 | 
						||
 | 
						||
/[a-[:digit:]]+/
 | 
						||
 | 
						||
/[A-[:digit:]]+/
 | 
						||
 | 
						||
/[a-[.xxx.]]+/
 | 
						||
 | 
						||
/[a-[=xxx=]]+/
 | 
						||
 | 
						||
/[a-[!xxx!]]+/
 | 
						||
 | 
						||
/[A-[!xxx!]]+/
 | 
						||
    A]]]
 | 
						||
 | 
						||
/[a-\d]+/
 | 
						||
 | 
						||
/(?<0abc>xx)/
 | 
						||
 | 
						||
/(?&1abc)xx(?<1abc>y)/
 | 
						||
 | 
						||
/(?<ab-cd>xx)/
 | 
						||
 | 
						||
/(?'0abc'xx)/
 | 
						||
 | 
						||
/(?P<0abc>xx)/
 | 
						||
 | 
						||
/\k<5ghj>/
 | 
						||
 | 
						||
/\k'5ghj'/
 | 
						||
 | 
						||
/\k{2fgh}/
 | 
						||
 | 
						||
/(?P=8yuki)/
 | 
						||
 | 
						||
/\g{4df}/
 | 
						||
 | 
						||
/(?&1abc)xx(?<1abc>y)/
 | 
						||
 | 
						||
/(?P>1abc)xx(?<1abc>y)/
 | 
						||
 | 
						||
/\g'3gh'/
 | 
						||
 | 
						||
/\g<5fg>/
 | 
						||
 | 
						||
/(?(<4gh>)abc)/
 | 
						||
 | 
						||
/(?('4gh')abc)/
 | 
						||
 | 
						||
/(?(4gh)abc)/
 | 
						||
 | 
						||
/(?(R&6yh)abc)/
 | 
						||
 | 
						||
/(((a\2)|(a*)\g<-1>))*a?/B
 | 
						||
 | 
						||
# Test the ugly "start or end of word" compatibility syntax.
 | 
						||
 | 
						||
/[[:<:]]red[[:>:]]/B
 | 
						||
    little red riding hood
 | 
						||
    a /red/ thing
 | 
						||
    red is a colour
 | 
						||
    put it all on red
 | 
						||
\= Expect no match
 | 
						||
    no reduction
 | 
						||
    Alfred Winifred
 | 
						||
 | 
						||
/[a[:<:]] should give error/
 | 
						||
 | 
						||
/(?=ab\K)/aftertext,allow_lookaround_bsk
 | 
						||
    abcd\=startchar
 | 
						||
 | 
						||
/abcd/newline=lf,firstline
 | 
						||
\= Expect no match
 | 
						||
    xx\nxabcd
 | 
						||
 | 
						||
# Test stack guard external calls.
 | 
						||
 | 
						||
/(((a)))/stackguard=1
 | 
						||
 | 
						||
/(((a)))/stackguard=2
 | 
						||
 | 
						||
/(((a)))/stackguard=3
 | 
						||
 | 
						||
/(((((a)))))/
 | 
						||
 | 
						||
# End stack guard tests
 | 
						||
 | 
						||
/^\w+(?>\s*)(?<=\w)/B
 | 
						||
 | 
						||
/\othing/
 | 
						||
 | 
						||
/\o{}/
 | 
						||
 | 
						||
/\o{whatever}/
 | 
						||
 | 
						||
/\xthing/
 | 
						||
 | 
						||
/\x{}/
 | 
						||
 | 
						||
/\x{whatever}/
 | 
						||
 | 
						||
/A\8B/
 | 
						||
 | 
						||
/A\9B/
 | 
						||
 | 
						||
# This one is here because Perl fails to match "12" for this pattern when the $
 | 
						||
# is present.
 | 
						||
 | 
						||
/^(?(?=abc)\w{3}:|\d\d)$/
 | 
						||
    abc:
 | 
						||
    12
 | 
						||
\= Expect no match
 | 
						||
    123
 | 
						||
    xyz
 | 
						||
 | 
						||
# Perl gets this one wrong, giving "a" as the after text for ca and failing to
 | 
						||
# match for cd.
 | 
						||
 | 
						||
/(?(?=ab)ab)/aftertext
 | 
						||
    abxxx
 | 
						||
    ca
 | 
						||
    cd
 | 
						||
 | 
						||
# This should test both paths for processing OP_RECURSE.
 | 
						||
 | 
						||
/(?(R)a+|(?R)b)/
 | 
						||
    aaaabcde
 | 
						||
    aaaabcde\=ovector=100
 | 
						||
 | 
						||
/a*?b*?/
 | 
						||
    ab
 | 
						||
 | 
						||
/(*NOTEMPTY)a*?b*?/
 | 
						||
    ab
 | 
						||
    ba
 | 
						||
    cb
 | 
						||
 | 
						||
/(*NOTEMPTY_ATSTART)a*?b*?/aftertext
 | 
						||
    ab
 | 
						||
    cdab
 | 
						||
 | 
						||
/(?(VERSION>=10.0)yes|no)/I
 | 
						||
    yesno
 | 
						||
 | 
						||
/(?(VERSION>=10.04)yes|no)/
 | 
						||
    yesno
 | 
						||
 | 
						||
/(?(VERSION=8)yes){3}/BI,aftertext
 | 
						||
    yesno
 | 
						||
 | 
						||
/(?(VERSION=8)yes|no){3}/I
 | 
						||
    yesnononoyes
 | 
						||
\= Expect no match
 | 
						||
    yesno
 | 
						||
 | 
						||
/(?:(?<VERSION>abc)|xyz)(?(VERSION)yes|no)/I
 | 
						||
    abcyes
 | 
						||
    xyzno
 | 
						||
\= Expect no match
 | 
						||
    abcno
 | 
						||
    xyzyes
 | 
						||
 | 
						||
/(?(VERSION<10)yes|no)/
 | 
						||
 | 
						||
/(?(VERSION>10)yes|no)/
 | 
						||
 | 
						||
/(?(VERSION>=10.0.0)yes|no)/
 | 
						||
 | 
						||
/(?(VERSION=10.101)yes|no)/
 | 
						||
 | 
						||
/abcd/I
 | 
						||
 | 
						||
/abcd/I,no_start_optimize
 | 
						||
 | 
						||
/(|ab)*?d/I
 | 
						||
   abd
 | 
						||
   xyd
 | 
						||
 | 
						||
/(|ab)*?d/I,no_start_optimize
 | 
						||
   abd
 | 
						||
   xyd
 | 
						||
 | 
						||
/\k<A>*(?<A>aa)(?<A>bb)/match_unset_backref,dupnames
 | 
						||
    aabb
 | 
						||
 | 
						||
/(((((a)))))/parens_nest_limit=2
 | 
						||
 | 
						||
/abc/replace=XYZ
 | 
						||
    123123
 | 
						||
    123abc123
 | 
						||
    123abc123abc123
 | 
						||
    123123\=zero_terminate
 | 
						||
    123abc123\=zero_terminate
 | 
						||
    123abc123abc123\=zero_terminate
 | 
						||
 | 
						||
/abc/g,replace=XYZ
 | 
						||
    123abc123
 | 
						||
    123abc123abc123
 | 
						||
 | 
						||
/abc/replace=X$$Z
 | 
						||
    123abc123
 | 
						||
 | 
						||
/abc/g,replace=X$$Z
 | 
						||
    123abc123abc123
 | 
						||
 | 
						||
/a(b)c(d)e/replace=X$1Y${2}Z
 | 
						||
    "abcde"
 | 
						||
 | 
						||
/a(b)c(d)e/replace=X$1Y${2}Z,global
 | 
						||
    "abcde-abcde"
 | 
						||
 | 
						||
/a(?<ONE>b)c(?<TWO>d)e/replace=X$ONE+${TWO}Z
 | 
						||
    "abcde"
 | 
						||
 | 
						||
/a(?<ONE>b)c(?<TWO>d)e/g,replace=X$ONE+${TWO}Z
 | 
						||
    "abcde-abcde-"
 | 
						||
 | 
						||
/abc/replace=a$++
 | 
						||
    123abc
 | 
						||
 | 
						||
/abc/replace=a$bad
 | 
						||
    123abc
 | 
						||
 | 
						||
/abc/replace=a${A234567890123456789_123456789012}z
 | 
						||
    123abc
 | 
						||
 | 
						||
/abc/replace=a${A23456789012345678901234567890123}z
 | 
						||
    123abc
 | 
						||
 | 
						||
/abc/replace=a${bcd
 | 
						||
    123abc
 | 
						||
 | 
						||
/abc/replace=a${b+d}z
 | 
						||
    123abc
 | 
						||
 | 
						||
/abc/replace=[10]XYZ
 | 
						||
    123abc123
 | 
						||
 | 
						||
/abc/replace=[9]XYZ
 | 
						||
    123abc123
 | 
						||
 | 
						||
/abc/replace=xyz
 | 
						||
    1abc2\=partial_hard
 | 
						||
 | 
						||
/abc/replace=xyz
 | 
						||
    123abc456
 | 
						||
    123abc456\=replace=pqr
 | 
						||
    123abc456abc789
 | 
						||
    123abc456abc789\=g
 | 
						||
 | 
						||
/(?<=abc)(|def)/g,replace=<$0>
 | 
						||
    123abcxyzabcdef789abcpqr
 | 
						||
 | 
						||
/./replace=$0
 | 
						||
    a
 | 
						||
 | 
						||
/(.)(.)/replace=$2+$1
 | 
						||
    abc
 | 
						||
 | 
						||
/(?<A>.)(?<B>.)/replace=$B+$A
 | 
						||
    abc
 | 
						||
 | 
						||
/(.)(.)/g,replace=$2$1
 | 
						||
    abcdefgh
 | 
						||
 | 
						||
/(*:pear)apple|(*:orange)lemon|(*:strawberry)blackberry/g,replace=${*MARK}
 | 
						||
    apple lemon blackberry
 | 
						||
    apple strudel
 | 
						||
    fruitless
 | 
						||
 | 
						||
/(*:pear)apple|(*:orange)lemon|(*:strawberry)blackberry/replace=${*MARK} sauce,
 | 
						||
    apple lemon blackberry
 | 
						||
 | 
						||
/(*:pear)apple|(*:orange)lemon|(*:strawberry)blackberry/g,replace=<$*MARK>
 | 
						||
    apple lemon blackberry
 | 
						||
    apple strudel
 | 
						||
    fruitless
 | 
						||
 | 
						||
/(*:pear)apple/g,replace=${*MARKING}
 | 
						||
    apple lemon blackberry
 | 
						||
 | 
						||
/(*:pear)apple/g,replace=${*MARK-time
 | 
						||
    apple lemon blackberry
 | 
						||
 | 
						||
/(*:pear)apple/g,replace=${*mark}
 | 
						||
    apple lemon blackberry
 | 
						||
 | 
						||
/(*:pear)apple|(*:orange)lemon|(*:strawberry)blackberry/g,replace=<$*MARKET>
 | 
						||
    apple lemon blackberry
 | 
						||
 | 
						||
/(*:pear)apple|(*:orange)lemon|(*:strawberry)blackberry/g,replace=[22]${*MARK}
 | 
						||
    apple lemon blackberry
 | 
						||
    apple lemon blackberry\=substitute_overflow_length
 | 
						||
 | 
						||
/(*:pear)apple|(*:orange)lemon|(*:strawberry)blackberry/g,replace=[23]${*MARK}
 | 
						||
    apple lemon blackberry
 | 
						||
 | 
						||
/abc/
 | 
						||
    123abc123\=replace=[9]XYZ
 | 
						||
    123abc123\=substitute_overflow_length,replace=[9]XYZ
 | 
						||
    123abc123\=substitute_overflow_length,replace=[6]XYZ
 | 
						||
    123abc123\=substitute_overflow_length,replace=[1]XYZ
 | 
						||
    123abc123\=substitute_overflow_length,replace=[0]XYZ
 | 
						||
 | 
						||
/a(b)c/
 | 
						||
    123abc123\=replace=[9]x$1z
 | 
						||
    123abc123\=substitute_overflow_length,replace=[9]x$1z
 | 
						||
    123abc123\=substitute_overflow_length,replace=[6]x$1z
 | 
						||
    123abc123\=substitute_overflow_length,replace=[1]x$1z
 | 
						||
    123abc123\=substitute_overflow_length,replace=[0]x$1z
 | 
						||
 | 
						||
"((?=(?(?=(?(?=(?(?=()))))))))"
 | 
						||
    a
 | 
						||
 | 
						||
"(?(?=)==)(((((((((?=)))))))))"
 | 
						||
\= Expect no match
 | 
						||
    a
 | 
						||
 | 
						||
/(a)(b)|(c)/
 | 
						||
    XcX\=ovector=2,get=1,get=2,get=3,get=4,getall
 | 
						||
 | 
						||
/x(?=ab\K)/allow_lookaround_bsk
 | 
						||
    xab\=get=0
 | 
						||
    xab\=copy=0
 | 
						||
    xab\=getall
 | 
						||
 | 
						||
/(?<A>a)|(?<A>b)/dupnames
 | 
						||
    a\=ovector=1,copy=A,get=A,get=2
 | 
						||
    a\=ovector=2,copy=A,get=A,get=2
 | 
						||
    b\=ovector=2,copy=A,get=A,get=2
 | 
						||
 | 
						||
/a(b)c(d)/
 | 
						||
    abc\=ph,copy=0,copy=1,getall
 | 
						||
 | 
						||
/^abc/info
 | 
						||
 | 
						||
/^abc/info,no_dotstar_anchor
 | 
						||
 | 
						||
/.*\d/info,auto_callout
 | 
						||
\= Expect no match
 | 
						||
    aaa
 | 
						||
 | 
						||
/.*\d/info,no_dotstar_anchor,auto_callout
 | 
						||
\= Expect no match
 | 
						||
    aaa
 | 
						||
 | 
						||
/.*\d/dotall,info
 | 
						||
 | 
						||
/.*\d/dotall,no_dotstar_anchor,info
 | 
						||
 | 
						||
/(*NO_DOTSTAR_ANCHOR)(?s).*\d/info
 | 
						||
 | 
						||
'^(?:(a)|b)(?(1)A|B)'
 | 
						||
    aA123\=ovector=1
 | 
						||
    aA123\=ovector=2
 | 
						||
 | 
						||
'^(?:(?<AA>a)|b)(?(<AA>)A|B)'
 | 
						||
    aA123\=ovector=1
 | 
						||
    aA123\=ovector=2
 | 
						||
 | 
						||
'^(?<AA>)(?:(?<AA>a)|b)(?(<AA>)A|B)'dupnames
 | 
						||
    aA123\=ovector=1
 | 
						||
    aA123\=ovector=2
 | 
						||
    aA123\=ovector=3
 | 
						||
 | 
						||
'^(?:(?<AA>X)|)(?:(?<AA>a)|b)\k{AA}'dupnames
 | 
						||
    aa123\=ovector=1
 | 
						||
    aa123\=ovector=2
 | 
						||
    aa123\=ovector=3
 | 
						||
 | 
						||
/(?<N111>(?J)(?<N111>1(111111)11|)1|1|)(?(<N111>)1)/
 | 
						||
 | 
						||
/(?<N>(?J)(?<N>))(?-J)\k<N>/
 | 
						||
 | 
						||
# Quantifiers are not allowed on condition assertions, but are otherwise
 | 
						||
# OK in conditions.
 | 
						||
 | 
						||
/(?(?=0)?)+/
 | 
						||
 | 
						||
/(?(?=0)(?=00)?00765)/
 | 
						||
     00765
 | 
						||
 | 
						||
/(?(?=0)(?=00)?00765|(?!3).56)/
 | 
						||
     00765
 | 
						||
     456
 | 
						||
\= Expect no match
 | 
						||
     356
 | 
						||
 | 
						||
'^(a)*+(\w)'
 | 
						||
    g
 | 
						||
    g\=ovector=1
 | 
						||
 | 
						||
'^(?:a)*+(\w)'
 | 
						||
    g
 | 
						||
    g\=ovector=1
 | 
						||
 | 
						||
# These two pattern showeds up compile-time bugs
 | 
						||
 | 
						||
"((?2){0,1999}())?"
 | 
						||
 | 
						||
/((?+1)(\1))/B
 | 
						||
 | 
						||
# Callouts with string arguments
 | 
						||
 | 
						||
/a(?C"/
 | 
						||
 | 
						||
/a(?C"a/
 | 
						||
 | 
						||
/a(?C"a"/
 | 
						||
 | 
						||
/a(?C"a"bcde(?C"b")xyz/
 | 
						||
 | 
						||
/a(?C"a)b""c")/B
 | 
						||
 | 
						||
/ab(?C" any text with spaces ")cde/B
 | 
						||
    abcde
 | 
						||
    12abcde
 | 
						||
 | 
						||
/^a(b)c(?C1)def/
 | 
						||
      abcdef
 | 
						||
 | 
						||
/^a(b)c(?C"AB")def/
 | 
						||
      abcdef
 | 
						||
 | 
						||
/^a(b)c(?C1)def/
 | 
						||
      abcdef\=callout_capture
 | 
						||
 | 
						||
/^a(b)c(?C{AB})def/B
 | 
						||
      abcdef\=callout_capture
 | 
						||
 | 
						||
/(?C`a``b`)(?C'a''b')(?C"a""b")(?C^a^^b^)(?C%a%%b%)(?C#a##b#)(?C$a$$b$)(?C{a}}b})/B,callout_info
 | 
						||
 | 
						||
/(?:a(?C`code`)){3}/B
 | 
						||
 | 
						||
/^(?(?C25)(?=abc)abcd|xyz)/B,callout_info
 | 
						||
    abcdefg
 | 
						||
    xyz123
 | 
						||
 | 
						||
/^(?(?C$abc$)(?=abc)abcd|xyz)/B
 | 
						||
    abcdefg
 | 
						||
    xyz123
 | 
						||
 | 
						||
/^ab(?C'first')cd(?C"second")ef/
 | 
						||
    abcdefg
 | 
						||
 | 
						||
/(?:a(?C`code`)){3}X/
 | 
						||
    aaaXY
 | 
						||
 | 
						||
# Binary zero in callout string
 | 
						||
#  a  (  ?  C  '  x     z  '  )  b
 | 
						||
/ 61 28 3f 43 27 78 00 7a 27 29 62/hex,callout_info
 | 
						||
    abcdefgh
 | 
						||
 | 
						||
/(?(?!)^)/
 | 
						||
 | 
						||
/(?(?!)a|b)/
 | 
						||
    bbb
 | 
						||
\= Expect no match
 | 
						||
    aaa
 | 
						||
 | 
						||
# JIT gives a different error message for the infinite recursion
 | 
						||
 | 
						||
"(*NO_JIT)((?2)+)((?1)){"
 | 
						||
    abcd{
 | 
						||
 | 
						||
# Perl fails to diagnose the absence of an assertion
 | 
						||
 | 
						||
"(?(?<E>.*!.*)?)"
 | 
						||
 | 
						||
"X((?2)()*+){2}+"B
 | 
						||
 | 
						||
"X((?2)()*+){2}"B
 | 
						||
 | 
						||
/(?<=\bABQ(3(?-7)))/
 | 
						||
 | 
						||
/(?<=\bABQ(3(?+7)))/
 | 
						||
 | 
						||
";(?<=()((?3))((?2)))"
 | 
						||
 | 
						||
# Perl loops on this (PCRE2 used to!)
 | 
						||
 | 
						||
/(?<=\Ka)/g,aftertext,allow_lookaround_bsk
 | 
						||
    aaaaa
 | 
						||
 | 
						||
/(?<=\Ka)/altglobal,aftertext,allow_lookaround_bsk
 | 
						||
    aaaaa
 | 
						||
 | 
						||
/((?2){73}(?2))((?1))/info
 | 
						||
 | 
						||
/abc/
 | 
						||
\= Expect no match
 | 
						||
    \[9x!xxx(]{9999}
 | 
						||
 | 
						||
/(abc)*/
 | 
						||
    \[abc]{5}
 | 
						||
 | 
						||
/^/gm
 | 
						||
    \n\n\n
 | 
						||
 | 
						||
/^/gm,alt_circumflex
 | 
						||
    \n\n\n
 | 
						||
 | 
						||
/((((((((x))))))))\81/
 | 
						||
    xx1
 | 
						||
 | 
						||
/((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((x))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))\80/
 | 
						||
    xx
 | 
						||
 | 
						||
/\80/
 | 
						||
 | 
						||
/A\8B\9C/
 | 
						||
    A8B9C
 | 
						||
 | 
						||
/(?x:((?'a')) # comment (with parentheses) and | vertical
 | 
						||
(?-x:#not a comment (?'b')) # this is a comment ()
 | 
						||
(?'c')) # not a comment (?'d')/info
 | 
						||
 | 
						||
/(?|(?'a')(2)(?'b')|(?'a')(?'a')(3))/I,dupnames
 | 
						||
    A23B
 | 
						||
    B32A
 | 
						||
 | 
						||
# These are some patterns that used to cause buffer overflows or other errors
 | 
						||
# while compiling.
 | 
						||
 | 
						||
/.((?2)(?R)|\1|$)()/B
 | 
						||
 | 
						||
/.((?3)(?R)()(?2)|\1|$)()/B
 | 
						||
 | 
						||
/(\9*+(?2);\3++()2|)++{/
 | 
						||
 | 
						||
/\V\x85\9*+((?2)\3++()2)*:2/
 | 
						||
 | 
						||
/(((?(R)){0,2}) (?'x'((?'R')((?'R')))))/dupnames
 | 
						||
 | 
						||
/(((?(X)){0,2}) (?'x'((?'X')((?'X')))))/dupnames
 | 
						||
 | 
						||
/(((?(R)){0,2}) (?'x'((?'X')((?'R')))))/
 | 
						||
 | 
						||
"(?J)(?'d'(?'d'\g{d}))"
 | 
						||
 | 
						||
"(?=!((?2)(?))({8(?<=(?1){29}8bbbb\x16\xd\xc6^($(\xa9H4){4}h}?1)B))\x15')"
 | 
						||
 | 
						||
/A(?'')Z/
 | 
						||
 | 
						||
"(?J:(?|(?'R')(\k'R')|((?'R'))))"
 | 
						||
 | 
						||
/(?<=|(\,\$(?73591620449005828816)\xa8.{7}){6}\x09)/
 | 
						||
 | 
						||
/^(?:(?(1)x|)+)+$()/B
 | 
						||
 | 
						||
/[[:>:]](?<)/
 | 
						||
 | 
						||
/((?x)(*:0))#(?'/
 | 
						||
 | 
						||
/(?C$[$)(?<]/
 | 
						||
 | 
						||
/(?C$)$)(?<]/
 | 
						||
 | 
						||
/(?(R))*+/B
 | 
						||
    abcd
 | 
						||
 | 
						||
/((?x)(?#))#(?'/
 | 
						||
 | 
						||
/((?x)(?#))#(?'abc')/I
 | 
						||
 | 
						||
/[[:\\](?<[::]/
 | 
						||
 | 
						||
/[[:\\](?'abc')[a:]/I
 | 
						||
 | 
						||
"[[[.\xe8Nq\xffq\xff\xe0\x2|||::Nq\xffq\xff\xe0\x6\x2|||::[[[:[::::::[[[[[::::::::[:[[[:[:::[[[[[[[[[[[[:::::::::::::::::[[.\xe8Nq\xffq\xff\xe0\x2|||::Nq\xffq\xff\xe0\x6\x2|||::[[[:[::::::[[[[[::::::::[:[[[:[:::[[[[[[[[[[[[[[:::E[[[:[:[[:[:::[[:::E[[[:[:[[:'[:::::E[[[:[::::::[[[:[[[[[[[::E[[[:[::::::[[[:[[[[[[[[:[[::[::::[[:::::::[[:[[[[[[[:[[::[:[[:[~"
 | 
						||
 | 
						||
/()(?(R)0)*+/B
 | 
						||
 | 
						||
/(?R-:(?</
 | 
						||
 | 
						||
/(?R-:(?<)/
 | 
						||
 | 
						||
/(?(?C{\Q})(?!(?'/
 | 
						||
 | 
						||
/(?(?C{\Q})(?!(?'abc')))/I
 | 
						||
 | 
						||
/(?1){3918}(((((0(\k'R'))))(?J)(?'R'(?'R'\3){99})))/I
 | 
						||
 | 
						||
/(?|(aaa)|(b))\g{1}/I
 | 
						||
 | 
						||
/(?|(aaa)|(b))(?1)/I
 | 
						||
 | 
						||
/(?|(aaa)|(b))/I
 | 
						||
 | 
						||
/(?|(?'a'aaa)|(?'a'b))\k'a'/I
 | 
						||
 | 
						||
/(?|(?'a'aaa)|(?'a'b))(?'a'cccc)\k'a'/I,dupnames
 | 
						||
 | 
						||
/ab{3cd/
 | 
						||
    ab{3cd
 | 
						||
 | 
						||
/ab{3,cd/
 | 
						||
    ab{3,cd
 | 
						||
 | 
						||
/ab{3,4a}cd/
 | 
						||
    ab{3,4a}cd
 | 
						||
 | 
						||
/{4,5a}bc/
 | 
						||
    {4,5a}bc
 | 
						||
 | 
						||
/\x0{ab}/
 | 
						||
    \0{ab}
 | 
						||
 | 
						||
/^(a(b))\1\g1\g{1}\g-1\g{-1}\g{-02}Z/
 | 
						||
    ababababbbabZXXXX
 | 
						||
 | 
						||
/.*?a(*PRUNE)b/
 | 
						||
    aab
 | 
						||
 | 
						||
/.*?a(*PRUNE)b/s
 | 
						||
    aab
 | 
						||
 | 
						||
/^a(*PRUNE)b/s
 | 
						||
\= Expect no match
 | 
						||
    aab
 | 
						||
 | 
						||
/.*?a(*SKIP)b/
 | 
						||
    aab
 | 
						||
 | 
						||
/(?(8000000000/
 | 
						||
 | 
						||
/((?(R8000000000)))/
 | 
						||
 | 
						||
/0(?0)|(1)(*THEN)(*SKIP:0)(*FAIL)/
 | 
						||
\= Expect no match
 | 
						||
    01
 | 
						||
 | 
						||
/(?(1)()\983040\2)/
 | 
						||
 | 
						||
/(*LIMIT_MATCH=)abc/
 | 
						||
 | 
						||
/(*CRLF)(*LIMIT_MATCH=)abc/
 | 
						||
 | 
						||
/(?:ab)?(?:ab)(?:ab)/
 | 
						||
    abab
 | 
						||
    ababab
 | 
						||
\= Expect no match
 | 
						||
    aba
 | 
						||
 | 
						||
/((*MARK:A))++a(*SKIP:B)b/
 | 
						||
\= Expect no match
 | 
						||
    aacb
 | 
						||
 | 
						||
/(*MARK:a\zb)z/alt_verbnames
 | 
						||
 | 
						||
/(*:ab\t(d\)c)xxx/
 | 
						||
 | 
						||
/(*:ab\t(d\)c)xxx/alt_verbnames,mark
 | 
						||
    cxxxz
 | 
						||
 | 
						||
/(*:A\Qxx)x\EB)x/alt_verbnames,mark
 | 
						||
    x
 | 
						||
 | 
						||
/(*:A\ExxxB)x/alt_verbnames,mark
 | 
						||
    x
 | 
						||
 | 
						||
/(*: A \ and #comment
 | 
						||
     \ B)x/x,alt_verbnames,mark
 | 
						||
    x
 | 
						||
 | 
						||
/(*: A \ and #comment
 | 
						||
     \ B)x/alt_verbnames,mark
 | 
						||
    x
 | 
						||
 | 
						||
/(*: A \ and #comment
 | 
						||
     \ B)x/x,mark
 | 
						||
    x
 | 
						||
 | 
						||
/(*: A \ and #comment
 | 
						||
     \ B)x/mark
 | 
						||
    x
 | 
						||
 | 
						||
/(*:A
 | 
						||
B)x/alt_verbnames,mark
 | 
						||
    x
 | 
						||
 | 
						||
/(*:abc\Qpqr)/alt_verbnames
 | 
						||
 | 
						||
/abc/use_offset_limit
 | 
						||
    1234abcde\=offset_limit=100
 | 
						||
    1234abcde\=offset_limit=9
 | 
						||
    1234abcde\=offset_limit=4
 | 
						||
    1234abcde\=offset_limit=4,offset=4
 | 
						||
\= Expect no match
 | 
						||
    1234abcde\=offset_limit=4,offset=5
 | 
						||
    1234abcde\=offset_limit=3
 | 
						||
 | 
						||
/(?<=abc)/use_offset_limit
 | 
						||
    1234abc\=offset_limit=7
 | 
						||
\= Expect no match
 | 
						||
    1234abc\=offset_limit=6
 | 
						||
 | 
						||
/A/g,replace=-,use_offset_limit
 | 
						||
    XAXAXAXAXA\=offset_limit=4
 | 
						||
 | 
						||
/abc/
 | 
						||
\= Expect error
 | 
						||
    1234abcde\=offset_limit=4
 | 
						||
 | 
						||
/^\w/m,use_offset_limit
 | 
						||
    \n..\naa\=offset_limit=3
 | 
						||
    \n..\naa\=offset_limit=4
 | 
						||
 | 
						||
/abcd/null_context
 | 
						||
    abcd\=null_context
 | 
						||
\= Expect error - not allowed together
 | 
						||
    abcd\=null_context,find_limits
 | 
						||
    abcd\=allusedtext,startchar
 | 
						||
 | 
						||
/abcd/replace=w\rx\x82y\o{333}z(\Q12\$34$$\x34\E5$$),substitute_extended
 | 
						||
    abcd
 | 
						||
 | 
						||
/abcd/replace=w\rx\x82y\o{333}z(\Q12\$34$$\x34\E5$$),substitute_extended,substitute_literal
 | 
						||
    >>abcd<<
 | 
						||
    
 | 
						||
/abcd/g,replace=\$1$2\,substitute_literal
 | 
						||
    XabcdYabcdZ
 | 
						||
 | 
						||
/a(bc)(DE)/replace=a\u$1\U$1\E$1\l$2\L$2\Eab\Uab\LYZ\EDone,substitute_extended
 | 
						||
    abcDE
 | 
						||
 | 
						||
/abcd/replace=xy\kz,substitute_extended
 | 
						||
    abcd
 | 
						||
 | 
						||
/a(?:(b)|(c))/substitute_extended,replace=X${1:+1:-1}X${2:+2:-2}
 | 
						||
    ab
 | 
						||
    ac
 | 
						||
    ab\=replace=${1:+$1\:$1:$2}
 | 
						||
    ac\=replace=${1:+$1\:$1:$2}
 | 
						||
    >>ac<<\=replace=${1:+$1\:$1:$2},substitute_literal
 | 
						||
 | 
						||
/a(?:(b)|(c))/substitute_extended,replace=X${1:-1:-1}X${2:-2:-2}
 | 
						||
    ab
 | 
						||
    ac
 | 
						||
 | 
						||
/(a)/substitute_extended,replace=>${1:+\Q$1:{}$$\E+\U$1}<
 | 
						||
    a
 | 
						||
 | 
						||
/X(b)Y/substitute_extended
 | 
						||
    XbY\=replace=x${1:+$1\U$1}y
 | 
						||
    XbY\=replace=\Ux${1:+$1$1}y
 | 
						||
 | 
						||
/a/substitute_extended,replace=${*MARK:+a:b}
 | 
						||
    a
 | 
						||
 | 
						||
/(abcd)/replace=${1:+xy\kz},substitute_extended
 | 
						||
    abcd
 | 
						||
 | 
						||
/(abcd)/
 | 
						||
    abcd\=replace=${1:+xy\kz},substitute_extended
 | 
						||
 | 
						||
/abcd/substitute_extended,replace=>$1<
 | 
						||
    abcd
 | 
						||
 | 
						||
/abcd/substitute_extended,replace=>xxx${xyz}<<<
 | 
						||
    abcd
 | 
						||
 | 
						||
/(?J)(?:(?<A>a)|(?<A>b))/replace=<$A>
 | 
						||
    [a]
 | 
						||
    [b]
 | 
						||
\= Expect error
 | 
						||
    (a)\=ovector=1
 | 
						||
 | 
						||
/(a)|(b)/replace=<$1>
 | 
						||
\= Expect error
 | 
						||
    b
 | 
						||
 | 
						||
/(aa)(BB)/substitute_extended,replace=\U$1\L$2\E$1..\U$1\l$2$1
 | 
						||
    aaBB
 | 
						||
    
 | 
						||
/abcd/replace=wxyz,substitute_matched
 | 
						||
    abcd
 | 
						||
    pqrs 
 | 
						||
 | 
						||
/abcd/g
 | 
						||
    >abcd1234abcd5678<\=replace=wxyz,substitute_matched
 | 
						||
 | 
						||
/^(o(\1{72}{\"{\\{00000059079}\d*){74}}){19}/I
 | 
						||
 | 
						||
/((p(?'K/
 | 
						||
 | 
						||
/((p(?'K/no_auto_capture
 | 
						||
 | 
						||
/abc/replace=A$3123456789Z
 | 
						||
    abc
 | 
						||
 | 
						||
/(?<!a{65535}a{5})x/I
 | 
						||
 | 
						||
/(?<!a{65535})x/I
 | 
						||
 | 
						||
/(?=a\K)/replace=z,allow_lookaround_bsk
 | 
						||
    BaCaD
 | 
						||
    
 | 
						||
/(?<=\K.)/g,replace=-,allow_lookaround_bsk
 | 
						||
    ab
 | 
						||
 | 
						||
/(?'abcdefghijklmnopqrstuvwxyzABCDEFG'toolong)/
 | 
						||
 | 
						||
/(?'abcdefghijklmnopqrstuvwxyzABCDEF'justright)/
 | 
						||
 | 
						||
# These two use zero-termination
 | 
						||
/abcd/max_pattern_length=3
 | 
						||
 | 
						||
/abc/max_pattern_length=3
 | 
						||
 | 
						||
# These two, being hex, pass the length
 | 
						||
/abcdefab/hex,max_pattern_length=3
 | 
						||
 | 
						||
/abcdef/hex,max_pattern_length=3
 | 
						||
 | 
						||
# These patterns used to take a long time to compile
 | 
						||
 | 
						||
"(.*)
 | 
						||
((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))
 | 
						||
((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))
 | 
						||
((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))"xI
 | 
						||
 | 
						||
"(?<=a()
 | 
						||
((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))
 | 
						||
((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))
 | 
						||
((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))
 | 
						||
a)"xI
 | 
						||
 | 
						||
"(?|()|())(.*)
 | 
						||
((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))
 | 
						||
((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))
 | 
						||
((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))"xI
 | 
						||
 | 
						||
"(?|()|())(?<=a()
 | 
						||
((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))
 | 
						||
((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))
 | 
						||
((?-2)(?-2))((?-2)(?-2))((?-2)(?-2))
 | 
						||
a)"xI
 | 
						||
 | 
						||
# Test the use of malloc for caching group information when there are more
 | 
						||
# groups than fit into the on-stack workspace.
 | 
						||
 | 
						||
/\[()]{1024}/I,expand
 | 
						||
 | 
						||
# Test minlength capped at 65535
 | 
						||
 | 
						||
/(A{65000})\1{65000}/I
 | 
						||
 | 
						||
# Test group scans when numbers are not unique
 | 
						||
 | 
						||
/(?|()+|(a)+)/BI
 | 
						||
 | 
						||
/(?|(a)+|()+)/BI
 | 
						||
 | 
						||
/(?|()|(a))/BI
 | 
						||
 | 
						||
/(?|(a)|())/BI
 | 
						||
 | 
						||
# Test CRLF handling in empty string substitutions
 | 
						||
 | 
						||
/^$/gm,newline=anycrlf,replace=-
 | 
						||
    X\r\n\r\nY
 | 
						||
 | 
						||
/^$/gm,newline=crlf,replace=-
 | 
						||
    X\r\n\r\nY
 | 
						||
 | 
						||
/^$/gm,newline=any,replace=-
 | 
						||
    X\r\n\r\nY
 | 
						||
 | 
						||
"(*ANYCRLF)(?m)^(.*[^0-9\r\n].*|)$"g,replace=NaN
 | 
						||
    15\r\nfoo\r\n20\r\nbar\r\nbaz\r\n\r\n20
 | 
						||
 | 
						||
/a[[:punct:]b]/bincode
 | 
						||
 | 
						||
/a[b[:punct:]]/bincode
 | 
						||
 | 
						||
/L(?#(|++<!(2)?/B
 | 
						||
 | 
						||
/L(?#(|++<!(2)?/B,no_auto_possess
 | 
						||
 | 
						||
/L(?#(|++<!(2)?/B,auto_callout
 | 
						||
 | 
						||
/L(?#(|++<!(2)?/B,no_auto_possess,auto_callout
 | 
						||
 | 
						||
/(A*)\E+/B,auto_callout
 | 
						||
 | 
						||
/()\Q\E*]/B,auto_callout
 | 
						||
    a[bc]d
 | 
						||
 | 
						||
/\x8a+f|;T?(*:;.'?`(\xeap ){![^()!y*''C*(?';]{1;(\x08)/B,alt_verbnames,dupnames,extended
 | 
						||
 | 
						||
# Tests for NULL characters in comments and verb "names" and callouts
 | 
						||
 | 
						||
# /A#B\x00C\x0aZ/
 | 
						||
/41 23 42 00 43 0a 5a/Bx,hex
 | 
						||
 | 
						||
# /A+#B\x00C\x0a+/
 | 
						||
/41 2b 23 42 00 43 0a 2b/Bx,hex
 | 
						||
 | 
						||
# /A(*:B\x00W#X\00Y\x0aC)Z/
 | 
						||
/41 28 2a 3a 42 00 57 23 58 00 59 0a 43 29 5a/Bx,hex,alt_verbnames
 | 
						||
 | 
						||
# /A(*:B\x00W#X\00Y\x0aC)Z/
 | 
						||
/41 28 2a 3a 42 00 57 23 58 00 59 0a 43 29 5a/Bx,hex
 | 
						||
 | 
						||
# /A(?C{X\x00Y})B/
 | 
						||
/41 28 3f 43 7b 58 00 59 7d 29 42/B,hex
 | 
						||
 | 
						||
# /A(?#X\x00Y)B/
 | 
						||
/41 28 3f 23 7b 00 7d 29 42/B,hex
 | 
						||
 | 
						||
# Tests for leading comment in extended patterns
 | 
						||
 | 
						||
/ (?-x):?/extended
 | 
						||
 | 
						||
/(?-x):?/extended
 | 
						||
 | 
						||
/0b 28 3f 2d 78 29 3a/hex,extended
 | 
						||
 | 
						||
/#comment
 | 
						||
(?-x):?/extended
 | 
						||
 | 
						||
/(8(*:6^\x09x\xa6l\)6!|\xd0:[^:|)\x09d\Z\d{85*m(?'(?<1!)*\W[*\xff]!!h\w]*\xbe;/alt_bsux,alt_verbnames,allow_empty_class,dollar_endonly,extended,multiline,never_utf,no_dotstar_anchor,no_start_optimize
 | 
						||
 | 
						||
/a|(b)c/replace=>$1<,substitute_unset_empty
 | 
						||
    cat
 | 
						||
    xbcom
 | 
						||
 | 
						||
/a|(b)c/
 | 
						||
    cat\=replace=>$1<
 | 
						||
    cat\=replace=>$1<,substitute_unset_empty
 | 
						||
    xbcom\=replace=>$1<,substitute_unset_empty
 | 
						||
 | 
						||
/a|(b)c/substitute_extended
 | 
						||
    cat\=replace=>${2:-xx}<
 | 
						||
    cat\=replace=>${2:-xx}<,substitute_unknown_unset
 | 
						||
    cat\=replace=>${X:-xx}<,substitute_unknown_unset
 | 
						||
 | 
						||
/a|(?'X'b)c/replace=>$X<,substitute_unset_empty
 | 
						||
    cat
 | 
						||
    xbcom
 | 
						||
 | 
						||
/a|(?'X'b)c/replace=>$Y<,substitute_unset_empty
 | 
						||
    cat
 | 
						||
    cat\=substitute_unknown_unset
 | 
						||
    cat\=substitute_unknown_unset,-substitute_unset_empty
 | 
						||
 | 
						||
/a|(b)c/replace=>$2<,substitute_unset_empty
 | 
						||
    cat
 | 
						||
    cat\=substitute_unknown_unset
 | 
						||
    cat\=substitute_unknown_unset,-substitute_unset_empty
 | 
						||
 | 
						||
/()()()/use_offset_limit
 | 
						||
    \=ovector=11000000000
 | 
						||
    \=callout_fail=11000000000
 | 
						||
    \=callout_fail=1:11000000000
 | 
						||
    \=callout_data=11000000000
 | 
						||
    \=callout_data=-11000000000
 | 
						||
    \=offset_limit=1100000000000000000000
 | 
						||
    \=copy=11000000000
 | 
						||
 | 
						||
/(*MARK:A\x00b)/mark
 | 
						||
    abc
 | 
						||
 | 
						||
/(*MARK:A\x00b)/mark,alt_verbnames
 | 
						||
    abc
 | 
						||
 | 
						||
/"(*MARK:A" 00 "b)"/mark,hex
 | 
						||
    abc
 | 
						||
 | 
						||
/"(*MARK:A" 00 "b)"/mark,hex,alt_verbnames
 | 
						||
    abc
 | 
						||
 | 
						||
/efg/hex
 | 
						||
 | 
						||
/eff/hex
 | 
						||
 | 
						||
/effg/hex
 | 
						||
 | 
						||
/(?J)(?'a'))(?'a')/
 | 
						||
 | 
						||
/(?<=((?C)0))/
 | 
						||
    9010
 | 
						||
\= Expect no match
 | 
						||
    abc
 | 
						||
 | 
						||
/aaa/
 | 
						||
\[abc]{10000000000000000000000000000}
 | 
						||
\[a]{3}
 | 
						||
 | 
						||
/\[AB]{6000000000000000000000}/expand
 | 
						||
 | 
						||
# Hex uses pattern length, not zero-terminated. This tests for overrunning
 | 
						||
# the given length of a pattern.
 | 
						||
 | 
						||
/'(*U'/hex
 | 
						||
 | 
						||
/'(*'/hex
 | 
						||
 | 
						||
/'('/hex
 | 
						||
 | 
						||
//hex
 | 
						||
 | 
						||
# These tests are here because Perl never allows a back reference in a
 | 
						||
# lookbehind. PCRE2 supports some limited cases.
 | 
						||
 | 
						||
/([ab])...(?<=\1)z/
 | 
						||
    a11az
 | 
						||
    b11bz
 | 
						||
\= Expect no match
 | 
						||
    b11az
 | 
						||
 | 
						||
/(?|([ab]))...(?<=\1)z/
 | 
						||
 | 
						||
/([ab])(\1)...(?<=\2)z/
 | 
						||
    aa11az
 | 
						||
 | 
						||
/(a\2)(b\1)(?<=\2)/
 | 
						||
 | 
						||
/(?<A>[ab])...(?<=\k'A')z/
 | 
						||
    a11az
 | 
						||
    b11bz
 | 
						||
\= Expect no match
 | 
						||
    b11az
 | 
						||
 | 
						||
/(?<A>[ab])...(?<=\k'A')(?<A>)z/dupnames
 | 
						||
 | 
						||
# Perl does not support \g+n
 | 
						||
 | 
						||
/((\g+1X)?([ab]))+/
 | 
						||
    aaXbbXa
 | 
						||
 | 
						||
/ab(?C1)c/auto_callout
 | 
						||
    abc
 | 
						||
 | 
						||
/'ab(?C1)c'/hex,auto_callout
 | 
						||
    abc
 | 
						||
 | 
						||
# Perl accepts these, but gives a warning. We can't warn, so give an error.
 | 
						||
 | 
						||
/[a-[:digit:]]+/
 | 
						||
    a-a9-a
 | 
						||
 | 
						||
/[A-[:digit:]]+/
 | 
						||
    A-A9-A
 | 
						||
 | 
						||
/[a-\d]+/
 | 
						||
    a-a9-a
 | 
						||
 | 
						||
/(?<RA>abc)(?(R)xyz)/B
 | 
						||
 | 
						||
/(?<R>abc)(?(R)xyz)/B
 | 
						||
 | 
						||
/(?=.*[A-Z])/I
 | 
						||
 | 
						||
/()(?<=(?0))/
 | 
						||
 | 
						||
/(?<!|!(?<!))/
 | 
						||
 | 
						||
/(?<!|!|!||||||(?<!)||(?<!)!|!||(?<!)!|!(?<!)!|!|!|!||||!!|<!)!|!||||!|/
 | 
						||
 | 
						||
/{2,2{2,2/use_length
 | 
						||
 | 
						||
/.>*?\g'0/use_length
 | 
						||
 | 
						||
/.>*?\g'0/
 | 
						||
 | 
						||
/{<7B>̈́<EFBFBD>̈́<EFBFBD>{'{22{2{{2{'{22{{22{2{'{22{2{{2{{222{{2{'{22{2{22{2{'{22{2{{2{'{22{2{22{2{'{'{22{2{22{2{'{22{2{{2{'{22{2{22{2{'{222{2Ą̈́<C484>̈́<EFBFBD>{'{22{2{{2{'{22{{11{2{'{22{2{{2{{'{22{2{{2{'{22{{22{1{'{22{2{{2{{222{{2{'{22{2{22{2{'{/auto_callout
 | 
						||
 | 
						||
//
 | 
						||
\=get=i00000000000000000000000000000000
 | 
						||
\=get=i2345678901234567890123456789012,get=i1245678901234567890123456789012
 | 
						||
 | 
						||
"(?(?C))"
 | 
						||
 | 
						||
/(?(?(?(?(?(?))))))/
 | 
						||
 | 
						||
/(?<=(?1))((?s))/anchored
 | 
						||
 | 
						||
/(*:ab)*/
 | 
						||
 | 
						||
%(*:(:(svvvvvvvvvv:]*[   Z!*;[]*[^[]*!^[+.+{{2,7}'      _\\\\\\\\\\\\\)?.:..    *w////\\\Q\\\\\\\\\\\\\\\T\\\\\+/?/////'+\\\EEE?/////'+/*+/[^K]?]//(w)%never_backslash_c,alt_verbnames,auto_callout
 | 
						||
 | 
						||
/./newline=crlf
 | 
						||
    \=ph
 | 
						||
 | 
						||
/(\x0e00\000000\xc)/replace=\P,substitute_extended
 | 
						||
    \x0e00\000000\xc
 | 
						||
 | 
						||
//replace=0
 | 
						||
    \=offset=7
 | 
						||
 | 
						||
/(?<=\G.)/g,replace=+
 | 
						||
    abc
 | 
						||
 | 
						||
".+\QX\E+"B,no_auto_possess
 | 
						||
 | 
						||
".+\QX\E+"B,auto_callout,no_auto_possess
 | 
						||
 | 
						||
# This one is here because Perl gives an 'unmatched )' error which goes away
 | 
						||
# if one of the \) sequences is removed - which is weird. PCRE finds it too
 | 
						||
# complicated to find a minimum matching length.
 | 
						||
 | 
						||
"()X|((((((((()))))))((((())))))\2())((((((\2\2)))\2)(\22((((\2\2)2))\2)))(2\ZZZ)+:)Z^|91ZiZZnter(ZZ |91Z(ZZ ZZ(\r2Z( or#(\Z2(Z\Z(\2\2)2))\2Z)Z(\22Z((\Z2(Z\Z(\2\2)2))\2Z+:)Z|91Z(ZZ ZZ(\r2Z( or#(\Z2(Z\Z((Z*(\2(Z\':))\0)i|||||||||||||||loZ\2\2)2))\2Z)Z(\22Z((\Z2(Z\Z(\2\2)2))\2Z)))int \)\0nte!rnal errpr\2\\21r(2\ZZZ)+:)Z!|91Z(ZZ ZZ(\r2Z( or#(\Z2(Z\Z(\2\2)2))\2Z)Z(\22Z((\Z2(Z\Z(\2\2)2))\2Z)))int \)\0(2\ZZZ)+:)Z^|91ZiZZnter(ZZ |91Z(ZZ ZZ(\r2Z( or#(\Z2(Z\Z(\2\2)2))\2Z)Z(\22Z((\Z2(Z\Z(\2\2)2))\2Z)))int \)\0(2\ZZZ)+:)Z^)))int \)\0(2\ZZZ)+:)Z^|91ZiZZnter(ZZernZal ZZ(\r2Z( or#(\Z2(Z\Z(\2\2)2))\2Z)Z(\22Z((\Z2(Z\Z(\2\2)2))\2Z)))int \))\ZZ(\r2Z( or#(\Z2(Z\Z(\2\2)2))\2Z)Z(\22Z((\Z2(Z\Z(\2\2)))\2))))((((((\2\2))))))"I
 | 
						||
 | 
						||
# This checks that new code for handling groups that may match an empty string
 | 
						||
# works on a very large number of alternatives. This pattern used to provoke a
 | 
						||
# complaint that it was too complicated.
 | 
						||
 | 
						||
/(?:\[A|B|C|D|E|F|G|H|I|J|]{200}Z)/expand
 | 
						||
 | 
						||
# This one used to compile rubbish instead of a compile error, and then
 | 
						||
# behave unpredictably at match time.
 | 
						||
 | 
						||
/.+(?(?C'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'))?!XXXX.=X/
 | 
						||
    .+(?(?C'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'))?!XXXX.=X
 | 
						||
 | 
						||
/[:[:alnum:]-[[a:lnum:]+/
 | 
						||
 | 
						||
/((?(?C'')\QX\E(?!((?(?C'')(?!X=X));=)r*X=X));=)/
 | 
						||
 | 
						||
/((?(?C'')\Q\E(?!((?(?C'')(?!X=X));=)r*X=X));=)/
 | 
						||
 | 
						||
/abcd/auto_callout
 | 
						||
    abcd\=callout_error=255:2
 | 
						||
 | 
						||
/()(\g+65534)/
 | 
						||
 | 
						||
/()(\g+65533)/
 | 
						||
 | 
						||
/<2F>\x00\x00\x00<17>(\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\2*\x00k\d+\x00\x00\x00\x00\x00\x00\2*\x00\x00\1*.){36}int^\x00\x00<08><>\x00<30>(\1{50779}?)J\w2/I
 | 
						||
 | 
						||
/(a)(b)\2\1\1\1\1/I
 | 
						||
 | 
						||
/(?<a>a)(?<b>b)\g{b}\g{a}\g{a}\g{a}\g{a}(?<a>xx)(?<b>zz)/I,dupnames
 | 
						||
 | 
						||
//
 | 
						||
    \=ovector=7777777777
 | 
						||
 | 
						||
# This is here because Perl matches, even though a COMMIT is encountered
 | 
						||
# outside of the recursion.
 | 
						||
 | 
						||
/(?1)(A(*COMMIT)|B)D/
 | 
						||
    BAXBAD
 | 
						||
 | 
						||
"(?1){2}(a)"B
 | 
						||
 | 
						||
"(?1){2,4}(a)"B
 | 
						||
 | 
						||
# This test differs from Perl for the first subject. Perl ends up with
 | 
						||
# $1 set to 'B'; PCRE2 has it unset (which I think is right).
 | 
						||
 | 
						||
/^(?:
 | 
						||
(?:A| (?:B|B(*ACCEPT)) (?<=(.)) D)
 | 
						||
(Z)
 | 
						||
)+$/x
 | 
						||
    AZB
 | 
						||
    AZBDZ
 | 
						||
 | 
						||
# The first of these, when run by Perl, gives the mark 'aa', which is wrong.
 | 
						||
 | 
						||
'(?>a(*:aa))b|ac' mark
 | 
						||
    ac
 | 
						||
 | 
						||
'(?:a(*:aa))b|ac' mark
 | 
						||
    ac
 | 
						||
 | 
						||
/(R?){65}/
 | 
						||
    (R?){65}
 | 
						||
 | 
						||
/\[(a)]{60}/expand
 | 
						||
    aaaa
 | 
						||
 | 
						||
/(?<!\1((?U)1((?U))))(*F)/never_backslash_c,alt_bsux,anchored,extended
 | 
						||
 | 
						||
/\g{3/
 | 
						||
 | 
						||
/(a(?C1)(b)(c)d)+/
 | 
						||
  abcdabcd\=callout_capture
 | 
						||
 | 
						||
# Perl matches this one, but PCRE does not because (*ACCEPT) clears out any
 | 
						||
# pending backtracks in the recursion.
 | 
						||
 | 
						||
/^ (?(DEFINE) (..(*ACCEPT)|...) ) (?1)$/x
 | 
						||
\= Expect no match
 | 
						||
    abc
 | 
						||
 | 
						||
# Perl gives no match for this one
 | 
						||
 | 
						||
/(a(*MARK:m)(*ACCEPT)){0}(?1)/mark
 | 
						||
    abc
 | 
						||
 | 
						||
/abc/endanchored
 | 
						||
    xyzabc
 | 
						||
\= Expect no match
 | 
						||
    xyzabcdef
 | 
						||
\= Expect error
 | 
						||
    xyzabc\=ph
 | 
						||
 | 
						||
/abc/
 | 
						||
    xyzabc\=endanchored
 | 
						||
\= Expect no match
 | 
						||
    xyzabcdef\=endanchored
 | 
						||
\= Expect error
 | 
						||
    xyzabc\=ps,endanchored
 | 
						||
 | 
						||
/abc(*ACCEPT)d/endanchored
 | 
						||
    xyzabc
 | 
						||
\= Expect no match
 | 
						||
    xyzabcdef
 | 
						||
 | 
						||
/abc|bcd/endanchored
 | 
						||
    xyzabcd
 | 
						||
\= Expect no match
 | 
						||
    xyzabcdef
 | 
						||
 | 
						||
/a(*ACCEPT)x|aa/endanchored
 | 
						||
    aaa
 | 
						||
 | 
						||
# Check auto-anchoring when there is a group that is never obeyed at
 | 
						||
# the start of a branch.
 | 
						||
 | 
						||
/(?(DEFINE)(a))^bc/I
 | 
						||
 | 
						||
/(a){0}.*bc/sI
 | 
						||
 | 
						||
# This should be anchored, as the condition is always false and there is
 | 
						||
# no alternative branch.
 | 
						||
 | 
						||
/(?(VERSION>=999)yes)^bc/I
 | 
						||
 | 
						||
# This should not be anchored.
 | 
						||
 | 
						||
/(?(VERSION>=999)yes|no)^bc/I
 | 
						||
 | 
						||
/(*LIMIT_HEAP=0)xxx/I
 | 
						||
 | 
						||
/\d{0,3}(*:abc)(?C1)xxx/callout_info
 | 
						||
 | 
						||
# ----------------------------------------------------------------------
 | 
						||
 | 
						||
# These are a whole pile of tests that touch lines of code that are not
 | 
						||
# used by any other tests (at least when these were created).
 | 
						||
 | 
						||
/^a+?x/i,no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    aaa
 | 
						||
 | 
						||
/^[^a]{3,}?x/i,no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    bbb
 | 
						||
    cc
 | 
						||
 | 
						||
/^X\S/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X
 | 
						||
 | 
						||
/^X\W/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X
 | 
						||
 | 
						||
/^X\H/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X
 | 
						||
 | 
						||
/^X\h/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X
 | 
						||
 | 
						||
/^X\V/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X
 | 
						||
 | 
						||
/^X\v/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X
 | 
						||
 | 
						||
/^X\h/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    XY
 | 
						||
 | 
						||
/^X\V/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X\n
 | 
						||
 | 
						||
/^X\v/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    XX
 | 
						||
 | 
						||
/^X.+?/s,no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X
 | 
						||
 | 
						||
/^X\R+?/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    XX
 | 
						||
 | 
						||
/^X\H+?/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X
 | 
						||
 | 
						||
/^X\h+?/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X
 | 
						||
 | 
						||
/^X\V+?/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X
 | 
						||
    X\n
 | 
						||
 | 
						||
/^X\D+?/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X
 | 
						||
    X9
 | 
						||
 | 
						||
/^X\S+?/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X
 | 
						||
    X\n
 | 
						||
 | 
						||
/^X\W+?/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X
 | 
						||
    XX
 | 
						||
 | 
						||
/^X.+?Z/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    XY\n
 | 
						||
 | 
						||
/(*CRLF)^X.+?Z/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    XY\r\=ps
 | 
						||
 | 
						||
/^X\R+?Z/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X\nX
 | 
						||
    X\n\r\n
 | 
						||
    X\n\rY
 | 
						||
    X\n\nY
 | 
						||
    X\n\x{0c}Y
 | 
						||
 | 
						||
/(*BSR_ANYCRLF)^X\R+?Z/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X\nX
 | 
						||
    X\n\r\n
 | 
						||
    X\n\rY
 | 
						||
    X\n\nY
 | 
						||
    X\n\x{0c}Y
 | 
						||
 | 
						||
/^X\H+?Z/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    XY\t
 | 
						||
    XYY
 | 
						||
 | 
						||
/^X\h+?Z/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X\t\t
 | 
						||
    X\tY
 | 
						||
 | 
						||
/^X\V+?Z/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    XY\n
 | 
						||
    XYY
 | 
						||
 | 
						||
/^X\v+?Z/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X\n\n
 | 
						||
    X\nY
 | 
						||
 | 
						||
/^X\D+?Z/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    XY9
 | 
						||
    XYY
 | 
						||
 | 
						||
/^X\d+?Z/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X99
 | 
						||
    X9Y
 | 
						||
 | 
						||
/^X\S+?Z/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    XY\n
 | 
						||
    XYY
 | 
						||
 | 
						||
/^X\s+?Z/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X\n\n
 | 
						||
    X\nY
 | 
						||
 | 
						||
/^X\W+?Z/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X.A
 | 
						||
    X++
 | 
						||
 | 
						||
/^X\w+?Z/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    Xa.
 | 
						||
    Xaa
 | 
						||
 | 
						||
/^X.{1,3}Z/s,no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    Xa.bd
 | 
						||
 | 
						||
/^X\h+Z/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    X\t\t
 | 
						||
    X\tY
 | 
						||
 | 
						||
/^X\V+Z/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    XY\n
 | 
						||
    XYY
 | 
						||
 | 
						||
/^(X(*THEN)Y|AB){0}(?1)/
 | 
						||
    ABX
 | 
						||
\= Expect no match
 | 
						||
    XAB
 | 
						||
 | 
						||
/^(?!A(?C1)B)C/
 | 
						||
    ABC\=callout_error=1,no_jit
 | 
						||
 | 
						||
/^(?!A(?C1)B)C/no_start_optimize
 | 
						||
    ABC\=callout_error=1
 | 
						||
 | 
						||
/^(?(?!A(?C1)B)C)/
 | 
						||
    ABC\=callout_error=1
 | 
						||
 | 
						||
# ----------------------------------------------------------------------
 | 
						||
 | 
						||
/[a b c]/BxxI
 | 
						||
 | 
						||
/[a b c]/BxxxI
 | 
						||
 | 
						||
/[a b c]/B,extended_more
 | 
						||
 | 
						||
/[ a b c ]/B,extended_more
 | 
						||
 | 
						||
/[a b](?xx: [ 12 ] (?-xx:[ 34 ]) )y z/B
 | 
						||
 | 
						||
# Unsetting /x also unsets /xx
 | 
						||
 | 
						||
/[a b](?xx: [ 12 ] (?-x:[ 34 ]) )y z/B
 | 
						||
 | 
						||
/(a)(?-n:(b))(c)/nB
 | 
						||
 | 
						||
# ----------------------------------------------------------------------
 | 
						||
# These test the dangerous PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL option.
 | 
						||
 | 
						||
/\j\x{z}\o{82}\L\uabcd\u\U\g{\g/B,\bad_escape_is_literal
 | 
						||
 | 
						||
/\N{\c/IB,bad_escape_is_literal
 | 
						||
 | 
						||
/[\j\x{z}\o\gAb\g]/B,bad_escape_is_literal
 | 
						||
 | 
						||
/[Q-\N]/B,bad_escape_is_literal
 | 
						||
 | 
						||
/[\s-_]/bad_escape_is_literal
 | 
						||
 | 
						||
/[_-\s]/bad_escape_is_literal
 | 
						||
 | 
						||
/[\B\R\X]/B
 | 
						||
 | 
						||
/[\B\R\X]/B,bad_escape_is_literal
 | 
						||
 | 
						||
/[A-\BP-\RV-\X]/B
 | 
						||
 | 
						||
/[A-\BP-\RV-\X]/B,bad_escape_is_literal
 | 
						||
 | 
						||
# ----------------------------------------------------------------------
 | 
						||
 | 
						||
/a\b(c/literal
 | 
						||
    a\\b(c
 | 
						||
 | 
						||
/a\b(c/literal,caseless
 | 
						||
    a\\b(c
 | 
						||
    a\\B(c
 | 
						||
 | 
						||
/a\b(c/literal,firstline
 | 
						||
    XYYa\\b(c
 | 
						||
\= Expect no match
 | 
						||
    X\na\\b(c
 | 
						||
 | 
						||
/a\b?c/literal,use_offset_limit
 | 
						||
    XXXXa\\b?c\=offset_limit=4
 | 
						||
\= Expect no match
 | 
						||
    XXXXa\\b?c\=offset_limit=3
 | 
						||
 | 
						||
/a\b(c/literal,anchored,endanchored
 | 
						||
    a\\b(c
 | 
						||
\= Expect no match
 | 
						||
    Xa\\b(c
 | 
						||
    a\\b(cX
 | 
						||
    Xa\\b(cX
 | 
						||
 | 
						||
//literal,extended
 | 
						||
 | 
						||
/a\b(c/literal,auto_callout,no_start_optimize
 | 
						||
    XXXXa\\b(c
 | 
						||
 | 
						||
/a\b(c/literal,auto_callout
 | 
						||
    XXXXa\\b(c
 | 
						||
 | 
						||
/(*CR)abc/literal
 | 
						||
    (*CR)abc
 | 
						||
 | 
						||
/cat|dog/I,match_word
 | 
						||
    the cat sat
 | 
						||
\= Expect no match
 | 
						||
    caterpillar
 | 
						||
    snowcat
 | 
						||
    syndicate
 | 
						||
 | 
						||
/(cat)|dog/I,match_line,literal
 | 
						||
    (cat)|dog
 | 
						||
\= Expect no match
 | 
						||
    the cat sat
 | 
						||
    caterpillar
 | 
						||
    snowcat
 | 
						||
    syndicate
 | 
						||
 | 
						||
/a whole line/match_line,multiline
 | 
						||
    Rhubarb \na whole line\n custard
 | 
						||
\= Expect no match
 | 
						||
    Not a whole line
 | 
						||
 | 
						||
# Perl gets this wrong, failing to capture 'b' in group 1.
 | 
						||
 | 
						||
/^(b+|a){1,2}?bc/
 | 
						||
    bbc
 | 
						||
    
 | 
						||
# And again here, for the "babc" subject string. 
 | 
						||
 | 
						||
/^(b*|ba){1,2}?bc/
 | 
						||
    babc
 | 
						||
    bbabc
 | 
						||
    bababc
 | 
						||
\= Expect no match
 | 
						||
    bababbc
 | 
						||
    babababc
 | 
						||
 | 
						||
/[[:digit:]-a]/
 | 
						||
 | 
						||
/[[:digit:]-[:print:]]/
 | 
						||
 | 
						||
/[\d-a]/
 | 
						||
 | 
						||
/[\H-z]/
 | 
						||
 | 
						||
/[\d-[:print:]]/
 | 
						||
 | 
						||
# Perl gets the second of these wrong, giving no match.
 | 
						||
 | 
						||
"(?<=(a))\1?b"I
 | 
						||
    ab
 | 
						||
    aaab 
 | 
						||
 | 
						||
"(?=(a))\1?b"I
 | 
						||
    ab
 | 
						||
    aaab
 | 
						||
    
 | 
						||
# JIT does not support callout_extra  
 | 
						||
    
 | 
						||
/(*NO_JIT)(a+)b/auto_callout,no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    aac\=callout_extra 
 | 
						||
    
 | 
						||
/(*NO_JIT)a+(?C'XXX')b/no_start_optimize,no_auto_possess
 | 
						||
\= Expect no match
 | 
						||
    aac\=callout_extra 
 | 
						||
 | 
						||
/\n/firstline
 | 
						||
    xyz\nabc
 | 
						||
 | 
						||
/\nabc/firstline
 | 
						||
    xyz\nabc
 | 
						||
 | 
						||
/\x{0a}abc/firstline,newline=crlf
 | 
						||
\= Expect no match
 | 
						||
    xyz\r\nabc
 | 
						||
 | 
						||
/[abc]/firstline
 | 
						||
\= Expect no match
 | 
						||
    \na
 | 
						||
    
 | 
						||
# These tests are matched in test 1 as they are Perl compatible. Here we are
 | 
						||
# looking at what does and does not get auto-possessified. 
 | 
						||
 | 
						||
/(?(DEFINE)(?<optional_a>a?))^(?&optional_a)a$/B
 | 
						||
 | 
						||
/(?(DEFINE)(?<optional_a>a?)X)^(?&optional_a)a$/B
 | 
						||
    
 | 
						||
/^(a?)b(?1)a/B
 | 
						||
 | 
						||
/^(a?)+b(?1)a/B
 | 
						||
 | 
						||
/^(a?)++b(?1)a/B
 | 
						||
 | 
						||
/^(a?)+b/B
 | 
						||
 | 
						||
/(?=a+)a(a+)++b/B
 | 
						||
 | 
						||
/(?<=(?=.){4,5}x)/B
 | 
						||
 | 
						||
# Perl behaves differently with these when optimization is turned off
 | 
						||
 | 
						||
/a(*PRUNE:X)bc|qq/mark,no_start_optimize
 | 
						||
\= Expect no match
 | 
						||
    axy
 | 
						||
 | 
						||
/a(*THEN:X)bc|qq/mark,no_start_optimize
 | 
						||
\= Expect no match
 | 
						||
    axy
 | 
						||
 | 
						||
/(?^x-i)AB/ 
 | 
						||
 | 
						||
/(?^-i)AB/ 
 | 
						||
 | 
						||
/(?x-i-i)/
 | 
						||
 | 
						||
/(?(?=^))b/I
 | 
						||
    abc
 | 
						||
 | 
						||
/(?(?=^)|)b/I
 | 
						||
    abc
 | 
						||
 | 
						||
/(?(?=^)|^)b/I
 | 
						||
    bbc
 | 
						||
\= Expect no match
 | 
						||
    abc     
 | 
						||
 | 
						||
/(?(1)^|^())/I
 | 
						||
 | 
						||
/(?(1)^())b/I
 | 
						||
 | 
						||
/(?(1)^())+b/I,aftertext
 | 
						||
    abc
 | 
						||
 | 
						||
/(?(1)^()|^)+b/I,aftertext
 | 
						||
    bbc 
 | 
						||
\= Expect no match     
 | 
						||
    abc
 | 
						||
 | 
						||
/(?(1)^()|^)*b/I,aftertext
 | 
						||
    bbc 
 | 
						||
    abc
 | 
						||
    xbc 
 | 
						||
 | 
						||
/(?(1)^())+b/I,aftertext
 | 
						||
    abc
 | 
						||
 | 
						||
/(?(1)^a()|^a)+b/I,aftertext
 | 
						||
    abc 
 | 
						||
\= Expect no match     
 | 
						||
    bbc
 | 
						||
 | 
						||
/(?(1)^|^(a))+b/I,aftertext
 | 
						||
    abc 
 | 
						||
\= Expect no match     
 | 
						||
    bbc
 | 
						||
 | 
						||
/(?(1)^a()|^a)*b/I,aftertext
 | 
						||
    abc 
 | 
						||
    bbc
 | 
						||
    xbc 
 | 
						||
 | 
						||
/a(b)c|xyz/g,allvector,replace=<$0>
 | 
						||
    abcdefabcpqr\=ovector=4
 | 
						||
    abxyz\=ovector=4
 | 
						||
    abcdefxyz\=ovector=4
 | 
						||
    
 | 
						||
/a(b)c|xyz/allvector
 | 
						||
    abcdef\=ovector=4
 | 
						||
    abxyz\=ovector=4
 | 
						||
 | 
						||
/a(b)c|xyz/g,replace=<$0>,substitute_callout
 | 
						||
    abcdefabcpqr
 | 
						||
    abxyzpqrabcxyz
 | 
						||
    12abc34xyz99abc55\=substitute_stop=2
 | 
						||
    12abc34xyz99abc55\=substitute_skip=1
 | 
						||
    12abc34xyz99abc55\=substitute_skip=2
 | 
						||
 | 
						||
/a(b)c|xyz/g,replace=<$0>
 | 
						||
    abcdefabcpqr
 | 
						||
    abxyzpqrabcxyz
 | 
						||
    12abc34xyz\=substitute_stop=2
 | 
						||
    12abc34xyz\=substitute_skip=1
 | 
						||
 | 
						||
/a(b)c|xyz/replace=<$0>
 | 
						||
    abcdefabcpqr
 | 
						||
    12abc34xyz\=substitute_skip=1
 | 
						||
    12abc34xyz\=substitute_stop=1
 | 
						||
 | 
						||
/abc\rdef/
 | 
						||
    abc\ndef
 | 
						||
 | 
						||
/abc\rdef\x{0d}xyz/escaped_cr_is_lf
 | 
						||
    abc\ndef\rxyz
 | 
						||
\= Expect no match     
 | 
						||
    abc\ndef\nxyz
 | 
						||
 | 
						||
/(?(*ACCEPT)xxx)/
 | 
						||
 | 
						||
/(?(*atomic:xx)xxx)/
 | 
						||
 | 
						||
/(?(*script_run:xxx)zzz)/
 | 
						||
 | 
						||
/foobar/
 | 
						||
    the foobar thing\=copy_matched_subject
 | 
						||
    the foobar thing\=copy_matched_subject,zero_terminate
 | 
						||
 | 
						||
/foobar/g
 | 
						||
    the foobar thing foobar again\=copy_matched_subject
 | 
						||
 | 
						||
/(*:XX)^abc/I
 | 
						||
 | 
						||
/(*COMMIT:XX)^abc/I
 | 
						||
 | 
						||
/(*ACCEPT:XX)^abc/I
 | 
						||
 | 
						||
/abc/replace=xyz
 | 
						||
    abc\=null_context
 | 
						||
 | 
						||
/abc/replace=xyz,substitute_callout
 | 
						||
    abc 
 | 
						||
\= Expect error message
 | 
						||
    abc\=null_context
 | 
						||
 | 
						||
/\[()]{65535}()/expand
 | 
						||
 | 
						||
/\[()]{65535}(?<A>)/expand
 | 
						||
 | 
						||
/a(?:(*ACCEPT))??bc/
 | 
						||
    abc
 | 
						||
    axy
 | 
						||
 | 
						||
/a(*ACCEPT)??bc/
 | 
						||
    abc
 | 
						||
    axy
 | 
						||
 | 
						||
/a(*ACCEPT:XX)??bc/mark
 | 
						||
    abc
 | 
						||
    axy
 | 
						||
 | 
						||
/(*:\)?/
 | 
						||
 | 
						||
/(*:\Q \E){5}/alt_verbnames
 | 
						||
 | 
						||
/(?=abc)/I
 | 
						||
 | 
						||
/(?|(X)|(XY))\1abc/I
 | 
						||
 | 
						||
/(?|(a)|(bcde))(c)\2/I
 | 
						||
 | 
						||
/(?|(a)|(bcde))(c)\1/I
 | 
						||
 | 
						||
/(?|(?'A'a)|(?'A'bcde))(?'B'c)\k'B'(?'A')/I,dupnames
 | 
						||
 | 
						||
/(?|(?'A'a)|(?'A'bcde))(?'B'c)\k'A'(?'A')/I,dupnames
 | 
						||
 | 
						||
/((a|)+)+Z/I
 | 
						||
 | 
						||
/((?=a))[abcd]/I
 | 
						||
 | 
						||
/A(?:(*ACCEPT))?B/info
 | 
						||
 | 
						||
/(A(*ACCEPT)??B)C/
 | 
						||
    ABC
 | 
						||
    AXY 
 | 
						||
 | 
						||
/(?<=(?<=a)b)c.*/I
 | 
						||
    abc\=ph
 | 
						||
\= Expect no match
 | 
						||
    xbc\=ph
 | 
						||
 | 
						||
/(?<=ab)c.*/I
 | 
						||
    abc\=ph
 | 
						||
\= Expect no match
 | 
						||
    xbc\=ph
 | 
						||
 | 
						||
/(?<=a(?<=a|a)c)/I
 | 
						||
 | 
						||
/(?<=a(?<=a|ba)c)/I
 | 
						||
 | 
						||
/(?<=(?<=a)b)(?<!abcd)/I
 | 
						||
 | 
						||
/(?<=(?<=a)b)(?<!abcd)(?<=(?<=a)bcde)/I
 | 
						||
 | 
						||
# Addition overflow
 | 
						||
/( {32742} {42})(?<!\1{65481})/
 | 
						||
 | 
						||
# Multiplication overflow
 | 
						||
/(X{65535})(?<=\1{32770})/
 | 
						||
 | 
						||
# ---- Non-atomic assertion tests ----
 | 
						||
 | 
						||
# Expect error: not allowed as a condition
 | 
						||
/(?(*napla:xx)bc)/
 | 
						||
 | 
						||
/\A(*pla:.*\b(\w++))(?>.*?\b\1\b){3}/
 | 
						||
    word1 word3 word1 word2 word3 word2 word2 word1 word3 word4
 | 
						||
 | 
						||
/\A(*napla:.*\b(\w++))(?>.*?\b\1\b){3}/
 | 
						||
    word1 word3 word1 word2 word3 word2 word2 word1 word3 word4
 | 
						||
 | 
						||
/\A(?*.*\b(\w++))(?>.*?\b\1\b){3}/
 | 
						||
    word1 word3 word1 word2 word3 word2 word2 word1 word3 word4
 | 
						||
 | 
						||
/(*plb:(.)..|(.)...)(\1|\2)/
 | 
						||
    abcdb\=offset=4 
 | 
						||
    abcda\=offset=4 
 | 
						||
 | 
						||
/(*naplb:(.)..|(.)...)(\1|\2)/
 | 
						||
    abcdb\=offset=4 
 | 
						||
    abcda\=offset=4 
 | 
						||
    
 | 
						||
/(?<*(.)..|(.)...)(\1|\2)/
 | 
						||
    abcdb\=offset=4 
 | 
						||
    abcda\=offset=4 
 | 
						||
    
 | 
						||
/(*non_atomic_positive_lookahead:ab)/B
 | 
						||
 
 | 
						||
/(*non_atomic_positive_lookbehind:ab)/B 
 | 
						||
 | 
						||
/(*pla:ab+)/B
 | 
						||
 | 
						||
/(*napla:ab+)/B
 | 
						||
 | 
						||
/(*napla:)+/
 | 
						||
 | 
						||
/(*naplb:)+/
 | 
						||
 | 
						||
/(*napla:^x|^y)/I
 | 
						||
 | 
						||
/(*napla:abc|abd)/I
 | 
						||
 | 
						||
/(*napla:a|(.)(*ACCEPT)zz)\1../
 | 
						||
    abcd
 | 
						||
    
 | 
						||
/(*napla:a(*ACCEPT)zz|(.))\1../
 | 
						||
    abcd
 | 
						||
    
 | 
						||
/(*napla:a|(*COMMIT)(.))\1\1/
 | 
						||
    aabc
 | 
						||
\= Expect no match     
 | 
						||
    abbc   
 | 
						||
 | 
						||
/(*napla:a|(.))\1\1/
 | 
						||
    aabc
 | 
						||
    abbc   
 | 
						||
 | 
						||
# ----
 | 
						||
 | 
						||
# Expect error (recursion => not fixed length)
 | 
						||
/(\2)((?=(?<=\1)))/
 | 
						||
 | 
						||
/c*+(?<=[bc])/
 | 
						||
    abc\=ph
 | 
						||
    ab\=ph
 | 
						||
    abc\=ps
 | 
						||
    ab\=ps
 | 
						||
 | 
						||
/c++(?<=[bc])/
 | 
						||
    abc\=ph
 | 
						||
    ab\=ph
 | 
						||
 | 
						||
/(?<=(?=.(?<=x)))/
 | 
						||
    abx
 | 
						||
    ab\=ph
 | 
						||
    bxyz 
 | 
						||
    xyz
 | 
						||
    
 | 
						||
/\z/
 | 
						||
   abc\=ph
 | 
						||
   abc\=ps 
 | 
						||
   
 | 
						||
/\Z/
 | 
						||
   abc\=ph
 | 
						||
   abc\=ps 
 | 
						||
   abc\n\=ph
 | 
						||
   abc\n\=ps
 | 
						||
 | 
						||
/(?![ab]).*/
 | 
						||
    ab\=ph
 | 
						||
 | 
						||
/c*+/
 | 
						||
    ab\=ph,offset=2
 | 
						||
 | 
						||
/\A\s*(a|(?:[^`]{28500}){4})/I
 | 
						||
    a
 | 
						||
 | 
						||
/\A\s*((?:[^`]{28500}){4})/I
 | 
						||
 | 
						||
/\A\s*((?:[^`]{28500}){4}|a)/I
 | 
						||
    a
 | 
						||
 | 
						||
/(?<A>a)(?(<A>)b)((?<=b).*)/B
 | 
						||
 | 
						||
/(?(1)b)((?<=b).*)/B
 | 
						||
 | 
						||
/(?(R1)b)((?<=b).*)/B
 | 
						||
 | 
						||
/(?(DEFINE)b)((?<=b).*)/B
 | 
						||
 | 
						||
/(?(VERSION=10.3)b)((?<=b).*)/B
 | 
						||
 | 
						||
/[aA]b[cC]/IB
 | 
						||
 | 
						||
/[cc]abcd/I
 | 
						||
 | 
						||
/[Cc]abcd/I
 | 
						||
 | 
						||
/[c]abcd/I
 | 
						||
 | 
						||
/(?:c|C)abcd/I
 | 
						||
 | 
						||
/(a)?a/I
 | 
						||
    manm
 | 
						||
 | 
						||
/^(?|(\*)(*napla:\S*_(\2?+.+))|(\w)(?=\S*_(\2?+\1)))+_\2$/
 | 
						||
    *abc_12345abc
 | 
						||
 | 
						||
/^(?|(\*)(*napla:\S*_(\3?+.+))|(\w)(?=\S*_((\2?+\1))))+_\2$/
 | 
						||
    *abc_12345abc
 | 
						||
 | 
						||
/^((\1+)(?C)|\d)+133X$/
 | 
						||
    111133X\=callout_capture
 | 
						||
 | 
						||
/abc/replace=xyz,substitute_replacement_only
 | 
						||
    123abc456
 | 
						||
 | 
						||
/a(?<ONE>b)c(?<TWO>d)e/g,replace=X$ONE+${TWO}Z,substitute_replacement_only
 | 
						||
    "abcde-abcde-"
 | 
						||
     
 | 
						||
/a(b)c|xyz/g,replace=<$0>,substitute_callout,substitute_replacement_only
 | 
						||
    abcdefabcpqr                
 | 
						||
    abxyzpqrabcxyz              
 | 
						||
    12abc34xyz99abc55\=substitute_stop=2                          
 | 
						||
    12abc34xyz99abc55\=substitute_skip=1
 | 
						||
    12abc34xyz99abc55\=substitute_skip=2
 | 
						||
 | 
						||
/a(..)d/replace=>$1<,substitute_matched
 | 
						||
    xyzabcdxyzabcdxyz
 | 
						||
    xyzabcdxyzabcdxyz\=ovector=2
 | 
						||
\= Expect error     
 | 
						||
    xyzabcdxyzabcdxyz\=ovector=1
 | 
						||
 | 
						||
/a(..)d/g,replace=>$1<,substitute_matched
 | 
						||
    xyzabcdxyzabcdxyz
 | 
						||
    xyzabcdxyzabcdxyz\=ovector=2
 | 
						||
\= Expect error     
 | 
						||
    xyzabcdxyzabcdxyz\=ovector=1
 | 
						||
    xyzabcdxyzabcdxyz\=ovector=1,substitute_unset_empty
 | 
						||
 | 
						||
/55|a(..)d/g,replace=>$1<,substitute_matched
 | 
						||
    xyz55abcdxyzabcdxyz\=ovector=2,substitute_unset_empty
 | 
						||
\= Expect error     
 | 
						||
    xyz55abcdxyzabcdxyz\=ovector=2
 | 
						||
 | 
						||
/55|a(..)d/replace=>$1<,substitute_matched
 | 
						||
    xyz55abcdxyzabcdxyz\=ovector=2,substitute_unset_empty
 | 
						||
 | 
						||
/55|a(..)d/replace=>$1<
 | 
						||
    xyz55abcdxyzabcdxyz\=ovector=2,substitute_unset_empty
 | 
						||
 | 
						||
/55|a(..)d/g,replace=>$1<
 | 
						||
    xyz55abcdxyzabcdxyz\=ovector=2,substitute_unset_empty
 | 
						||
    
 | 
						||
/abc/replace=,caseless
 | 
						||
    XabcY
 | 
						||
    XABCY 
 | 
						||
 | 
						||
/abc/replace=[4],caseless
 | 
						||
    XabcY
 | 
						||
    XABCY 
 | 
						||
 | 
						||
/abc/replace=*,caseless
 | 
						||
    XabcY
 | 
						||
    XABCY
 | 
						||
    XabcY\=replace=  
 | 
						||
 | 
						||
# Expect non-fixed-length error
 | 
						||
 | 
						||
"(?<=X(?(DEFINE)(.*))(?1))."
 | 
						||
 | 
						||
/\sxxx\s/tables=1
 | 
						||
\= Expect no match
 | 
						||
    AB\x{85}xxx\x{a0}XYZ
 | 
						||
 | 
						||
/\sxxx\s/tables=2
 | 
						||
    AB\x{85}xxx\x{a0}XYZ
 | 
						||
 | 
						||
/^\w+/tables=2
 | 
						||
    École
 | 
						||
 | 
						||
/^\w+/tables=3
 | 
						||
    École
 | 
						||
 | 
						||
#loadtables ./testbtables
 | 
						||
 | 
						||
/^\w+/tables=3
 | 
						||
    École
 | 
						||
 | 
						||
/"(*MARK:>" 00 "<).."/hex,mark,no_start_optimize
 | 
						||
    AB
 | 
						||
    A\=ph 
 | 
						||
\= Expect no match
 | 
						||
    A
 | 
						||
 | 
						||
/"(*MARK:>" 00 "<).(?C1)."/hex,mark,no_start_optimize
 | 
						||
    AB
 | 
						||
 | 
						||
/(?(VERSION=0.0/
 | 
						||
 | 
						||
# Perl has made \K in lookarounds an error. PCRE2 now rejects as well, unless
 | 
						||
# explicitly authorized.
 | 
						||
 | 
						||
/(?=a\Kb)ab/
 | 
						||
 | 
						||
/(?=a\Kb)ab/allow_lookaround_bsk
 | 
						||
    ab 
 | 
						||
 | 
						||
/(?!a\Kb)ac/
 | 
						||
 | 
						||
/(?!a\Kb)ac/allow_lookaround_bsk
 | 
						||
    ac 
 | 
						||
    
 | 
						||
/^abc(?<=b\Kc)d/
 | 
						||
 | 
						||
/^abc(?<=b\Kc)d/allow_lookaround_bsk
 | 
						||
    abcd
 | 
						||
 | 
						||
/^abc(?<!b\Kq)d/
 | 
						||
 | 
						||
/^abc(?<!b\Kq)d/,allow_lookaround_bsk
 | 
						||
    abcd
 | 
						||
    
 | 
						||
# --------- 
 | 
						||
 | 
						||
# Tests for zero-length NULL to be treated as an empty string.
 | 
						||
 | 
						||
//
 | 
						||
    \=null_subject
 | 
						||
\= Expect error     
 | 
						||
    abc\=null_subject
 | 
						||
 | 
						||
//replace=[20]
 | 
						||
    abc\=null_replacement
 | 
						||
    \=null_subject
 | 
						||
    \=null_replacement
 | 
						||
 | 
						||
/X*/g,replace=xy
 | 
						||
\= Expect error
 | 
						||
    >X<\=null_replacement
 | 
						||
 | 
						||
/X+/replace=[20]
 | 
						||
    >XX<\=null_replacement
 | 
						||
 | 
						||
# --------- 
 | 
						||
 | 
						||
/[Aa]{2}/BI
 | 
						||
    aabcd
 | 
						||
 | 
						||
/A{2}/iBI
 | 
						||
    aabcd
 | 
						||
 | 
						||
/[Aa]{2,3}/BI
 | 
						||
    aabcd
 | 
						||
 | 
						||
# End of testinput2
 |