Test 1: main functionality.

/the quick brown fox/
    the quick brown fox: PASS
    The quick brown FOX: PASS
    What do you know about the quick brown fox?: PASS
    What do you know about THE QUICK BROWN FOX?: PASS

/The quick brown fox/i
    the quick brown fox: PASS
    The quick brown FOX: PASS
    What do you know about the quick brown fox?: PASS
    What do you know about THE QUICK BROWN FOX?: PASS

/abcd\t\n\r\f\a\e\071\x3b\$\\\?caxyz/
    abcd\t\n\r\f\a\e9;\$\\?caxyz: FAIL. Actual results: "null"

/a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/
    abxyzpqrrrabbxyyyypqAzz: PASS
    abxyzpqrrrabbxyyyypqAzz: PASS
    aabxyzpqrrrabbxyyyypqAzz: PASS
    aaabxyzpqrrrabbxyyyypqAzz: PASS
    aaaabxyzpqrrrabbxyyyypqAzz: PASS
    abcxyzpqrrrabbxyyyypqAzz: PASS
    aabcxyzpqrrrabbxyyyypqAzz: PASS
    aaabcxyzpqrrrabbxyyyypAzz: PASS
    aaabcxyzpqrrrabbxyyyypqAzz: PASS
    aaabcxyzpqrrrabbxyyyypqqAzz: PASS
    aaabcxyzpqrrrabbxyyyypqqqAzz: PASS
    aaabcxyzpqrrrabbxyyyypqqqqAzz: PASS
    aaabcxyzpqrrrabbxyyyypqqqqqAzz: PASS
    aaabcxyzpqrrrabbxyyyypqqqqqqAzz: PASS
    aaaabcxyzpqrrrabbxyyyypqAzz: PASS
    abxyzzpqrrrabbxyyyypqAzz: PASS
    aabxyzzzpqrrrabbxyyyypqAzz: PASS
    aaabxyzzzzpqrrrabbxyyyypqAzz: PASS
    aaaabxyzzzzpqrrrabbxyyyypqAzz: PASS
    abcxyzzpqrrrabbxyyyypqAzz: PASS
    aabcxyzzzpqrrrabbxyyyypqAzz: PASS
    aaabcxyzzzzpqrrrabbxyyyypqAzz: PASS
    aaaabcxyzzzzpqrrrabbxyyyypqAzz: PASS
    aaaabcxyzzzzpqrrrabbbxyyyypqAzz: PASS
    aaaabcxyzzzzpqrrrabbbxyyyyypqAzz: PASS
    aaabcxyzpqrrrabbxyyyypABzz: PASS
    aaabcxyzpqrrrabbxyyyypABBzz: PASS
    >>>aaabxyzpqrrrabbxyyyypqAzz: PASS
    >aaaabxyzpqrrrabbxyyyypqAzz: PASS
    >>>>abcxyzpqrrrabbxyyyypqAzz: PASS
    *** Failers
    abxyzpqrrabbxyyyypqAzz: PASS
    abxyzpqrrrrabbxyyyypqAzz: PASS
    abxyzpqrrrabxyyyypqAzz: PASS
    aaaabcxyzzzzpqrrrabbbxyyyyyypqAzz: PASS
    aaaabcxyzzzzpqrrrabbbxyyypqAzz: PASS
    aaabcxyzpqrrrabbxyyyypqqqqqqqAzz: PASS

/^(abc){1,2}zz/
    abczz: PASS
    abcabczz: PASS
    *** Failers
    zz: PASS
    abcabcabczz: PASS
    >>abczz: PASS

/^(b+?|a){1,2}?c/
    bc: PASS
    bbc: PASS
    bbbc: PASS
    bac: PASS
    bbac: PASS
    aac: PASS
    abbbbbbbbbbbc: PASS
    bbbbbbbbbbbac: PASS
    *** Failers
    aaac: PASS
    abbbbbbbbbbbac: PASS

/^(b+|a){1,2}c/
    bc: PASS
    bbc: PASS
    bbbc: PASS
    bac: PASS
    bbac: PASS
    aac: PASS
    abbbbbbbbbbbc: PASS
    bbbbbbbbbbbac: PASS
    *** Failers
    aaac: PASS
    abbbbbbbbbbbac: PASS

/^(b+|a){1,2}?bc/
    bbc: PASS

/^(b*|ba){1,2}?bc/
    babc: PASS
    bbabc: PASS
    bababc: PASS
    *** Failers
    bababbc: PASS
    babababc: PASS

/^(ba|b*){1,2}?bc/
    babc: PASS
    bbabc: PASS
    bababc: PASS
    *** Failers
    bababbc: PASS
    babababc: PASS

/^\ca\cA\c[\c{\c:/
FAILED TO COMPILE

/^[ab\]cde]/
    athing: PASS
    bthing: PASS
    ]thing: PASS
    cthing: PASS
    dthing: PASS
    ething: PASS
    *** Failers
    fthing: PASS
    [thing: PASS
    \\thing: PASS

/^[]cde]/
    ]thing: FAIL. Actual results: "null"
    cthing: FAIL. Actual results: "null"
    dthing: FAIL. Actual results: "null"
    ething: FAIL. Actual results: "null"
    *** Failers
    athing: PASS
    fthing: PASS

/^[^ab\]cde]/
    fthing: PASS
    [thing: PASS
    \\thing: PASS
    *** Failers
    athing: PASS
    bthing: PASS
    ]thing: PASS
    cthing: PASS
    dthing: PASS
    ething: PASS

/^[^]cde]/
    athing: FAIL. Actual results: "null"
    fthing: FAIL. Actual results: "null"
    *** Failers: FAIL. Actual results: "null"
    ]thing: PASS
    cthing: PASS
    dthing: PASS
    ething: PASS

/^\/
    : PASS

/^ÿ/
    ÿ: PASS

/^[0-9]+$/
    0: PASS
    1: PASS
    2: PASS
    3: PASS
    4: PASS
    5: PASS
    6: PASS
    7: PASS
    8: PASS
    9: PASS
    10: PASS
    100: PASS
    *** Failers
    abc: PASS

/^.*nter/
    enter: PASS
    inter: PASS
    uponter: PASS

/^xxx[0-9]+$/
    xxx0: PASS
    xxx1234: PASS
    *** Failers
    xxx: PASS

/^.+[0-9][0-9][0-9]$/
    x123: PASS
    xx123: PASS
    123456: PASS
    *** Failers
    123: PASS
    x1234: PASS

/^.+?[0-9][0-9][0-9]$/
    x123: PASS
    xx123: PASS
    123456: PASS
    *** Failers
    123: PASS
    x1234: PASS

/^([^!]+)!(.+)=apquxz\.ixr\.zzz\.ac\.uk$/
    abc!pqr=apquxz.ixr.zzz.ac.uk: PASS
    *** Failers
    !pqr=apquxz.ixr.zzz.ac.uk: PASS
    abc!=apquxz.ixr.zzz.ac.uk: PASS
    abc!pqr=apquxz:ixr.zzz.ac.uk: PASS
    abc!pqr=apquxz.ixr.zzz.ac.ukk: PASS

/:/
    Well, we need a colon: somewhere: PASS
    *** Fail if we don't: PASS

/([\da-f:]+)$/i
    0abc: PASS
    abc: PASS
    fed: PASS
    E: PASS
    ::: PASS
    5f03:12C0::932e: PASS
    fed def: PASS
    Any old stuff: PASS
    *** Failers
    0zzz: PASS
    gzzz: PASS
    fed : PASS
    Any old rubbish: PASS

/^.*\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/
    .1.2.3: PASS
    A.12.123.0: PASS
    *** Failers
    .1.2.3333: PASS
    1.2.3: PASS
    1234.2.3: PASS

/^(\d+)\s+IN\s+SOA\s+(\S+)\s+(\S+)\s*\(\s*$/
    1 IN SOA non-sp1 non-sp2(: PASS
    1    IN    SOA    non-sp1    non-sp2   (: PASS
    *** Failers
    1IN SOA non-sp1 non-sp2(: PASS

/^[a-zA-Z\d][a-zA-Z\d\-]*(\.[a-zA-Z\d][a-zA-z\d\-]*)*\.$/
    a.: FAIL. Actual results: "a.,"
    Z.: FAIL. Actual results: "Z.,"
    2.: FAIL. Actual results: "2.,"
    ab-c.pq-r.: PASS
    sxk.zzz.ac.uk.: PASS
    x-.y-.: PASS
    *** Failers
    -abc.peq.: PASS

/^\*\.[a-z]([a-z\-\d]*[a-z\d]+)?(\.[a-z]([a-z\-\d]*[a-z\d]+)?)*$/
    *.a: FAIL. Actual results: "*.a,,,"
    *.b0-a: FAIL. Actual results: "*.b0-a,0-a,,"
    *.c3-b.c: FAIL. Actual results: "*.c3-b.c,3-b,.c,"
    *.c-a.b-c: PASS
    *** Failers
    *.0: PASS
    *.a-: PASS
    *.a-b.c-: PASS
    *.c-a.0-c: PASS

/^(?=ab(de))(abd)(e)/
    abde: PASS

/^(?!(ab)de|x)(abd)(f)/
    abdf: PASS

/^(?=(ab(cd)))(ab)/
    abcd: PASS

/^[\da-f](\.[\da-f])*$/i
    a.b.c.d: PASS
    A.B.C.D: PASS
    a.b.c.1.2.3.C: PASS

/^\".*\"\s*(;.*)?$/
    \"1234\": FAIL. Actual results: "null"
    \"abcd\" ;: FAIL. Actual results: "null"
    \"\" ; rhubarb: FAIL. Actual results: "null"
    *** Failers
    \"1234\" : things: PASS

/^$/
    \: FAIL. Actual results: "null"
    *** Failers

/   ^    a   (?# begins with a)  b\sc (?# then b c) $ (?# then end)/x
Unsupported modifiers: x

/(?x)   ^    a   (?# begins with a)  b\sc (?# then b c) $ (?# then end)/
FAILED TO COMPILE

/^   a\ b[c ]d       $/x
Unsupported modifiers: x

/^(a(b(c)))(d(e(f)))(h(i(j)))(k(l(m)))$/
    abcdefhijklm: PASS

/^(?:a(b(c)))(?:d(e(f)))(?:h(i(j)))(?:k(l(m)))$/
    abcdefhijklm: PASS

/^[\w][\W][\s][\S][\d][\D][\b][\n][\c]][\022]/
    a+ Z0+\n: FAIL. Actual results: "null"

/^[.^$|()*+?{,}]+/
    .^\$(*+)|{?,?}: FAIL. Actual results: ".^"

/^a*\w/
    z: PASS
    az: PASS
    aaaz: PASS
    a: PASS
    aa: PASS
    aaaa: PASS
    a+: PASS
    aa+: PASS

/^a*?\w/
    z: PASS
    az: PASS
    aaaz: PASS
    a: PASS
    aa: PASS
    aaaa: PASS
    a+: PASS
    aa+: PASS

/^a+\w/
    az: PASS
    aaaz: PASS
    aa: PASS
    aaaa: PASS
    aa+: PASS

/^a+?\w/
    az: PASS
    aaaz: PASS
    aa: PASS
    aaaa: PASS
    aa+: PASS

/^\d{8}\w{2,}/
    1234567890: PASS
    12345678ab: PASS
    12345678__: PASS
    *** Failers
    1234567: PASS

/^[aeiou\d]{4,5}$/
    uoie: PASS
    1234: PASS
    12345: PASS
    aaaaa: PASS
    *** Failers
    123456: PASS

/^[aeiou\d]{4,5}?/
    uoie: PASS
    1234: PASS
    12345: PASS
    aaaaa: PASS
    123456: PASS

/\A(abc|def)=(\1){2,3}\Z/
    abc=abcabc: FAIL. Actual results: "null"
    def=defdefdef: FAIL. Actual results: "null"
    *** Failers
    abc=defdef: PASS

/^(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\11*(\3\4)\1(?#)2$/
FAILED TO COMPILE

/(cat(a(ract|tonic)|erpillar)) \1()2(3)/
    cataract cataract23: PASS
    catatonic catatonic23: PASS
    caterpillar caterpillar23: PASS


FAILED TO COMPILE

/^From\s+\S+\s+([a-zA-Z]{3}\s+){2}\d{1,2}\s+\d\d:\d\d/
    From abcd  Mon Sep 01 12:33:02 1997: PASS
    From abcd  Mon Sep  1 12:33:02 1997: PASS
    *** Failers
    From abcd  Sep 01 12:33:02 1997: PASS

/^12.34/s
    12\n34: FAIL. Actual results: "null"
    12\r34: FAIL. Actual results: "null"

/\w+(?=\t)/
    the quick brown\t fox: FAIL. Actual results: "null"

/foo(?!bar)(.*)/
    foobar is foolish see?: PASS

/(?:(?!foo)...|^.{0,2})bar(.*)/
    foobar crowbar etc: PASS
    barrel: PASS
    2barrel: PASS
    A barrel: PASS

/^(\D*)(?=\d)(?!123)/
    abc456: PASS
    *** Failers
    abc123: PASS

/^1234(?# test newlines
  inside)/
FAILED TO COMPILE

/^1234 #comment in extended re
  /x
FAILED TO COMPILE

/#rhubarb
  abcd/x
FAILED TO COMPILE

/^abcd#rhubarb/x
Unsupported modifiers: x

/^(a)\1{2,3}(.)/
    aaab: PASS
    aaaab: PASS
    aaaaab: PASS
    aaaaaab: PASS

/(?!^)abc/
    the abc: PASS
    *** Failers
    abc: PASS

/(?=^)abc/
    abc: PASS
    *** Failers
    the abc: PASS

/^[ab]{1,3}(ab*|b)/
    aabbbbb: PASS

/^[ab]{1,3}?(ab*|b)/
    aabbbbb: PASS

/^[ab]{1,3}?(ab*?|b)/
    aabbbbb: PASS

/^[ab]{1,3}(ab*?|b)/
    aabbbbb: PASS

/abc\0def\00pqr\000xyz\0000AB/
    abc f qr xyz 0AB: FAIL. Actual results: "abc f qr xyz 0AB"
    abc456 abc f qr xyz 0ABCDE: FAIL. Actual results: "abc f qr xyz 0AB"

/abc\x0def\x00pqr\x000xyz\x0000AB/
FAILED TO COMPILE

/^[\000-\037]/
     : PASS
    : PASS
    C: PASS

/\0*/
FAILED TO COMPILE

/A\x0{2,3}Z/
    The A x0Z: FAIL. Actual results: "null"
    An A 0 : FAIL. Actual results: "null"
    *** Failers
    A : PASS
    A 0 0Z: PASS

/^(cow|)\1(bell)/
    cowcowbell: PASS
    bell: PASS
    *** Failers
    cowbell: PASS

/^\s/
     abc: PASS
    abc: PASS
    \nabc: FAIL. Actual results: "null"
    \rabc: FAIL. Actual results: "null"
    \tabc: FAIL. Actual results: "null"
    *** Failers
    abc: PASS

/^a	b
      c/x
FAILED TO COMPILE

/^(a|)\1*b/
    ab: PASS
    aaaab: PASS
    b: PASS
    *** Failers
    acb: PASS

/^(a|)\1+b/
    aab: PASS
    aaaab: PASS
    b: PASS
    *** Failers
    ab: PASS

/^(a|)\1?b/
    ab: PASS
    aab: PASS
    b: PASS
    *** Failers
    acb: PASS

/^(a|)\1{2}b/
    aaab: PASS
    b: PASS
    *** Failers
    ab: PASS
    aab: PASS
    aaaab: PASS

/^(a|)\1{2,3}b/
    aaab: PASS
    aaaab: PASS
    b: PASS
    *** Failers
    ab: PASS
    aab: PASS
    aaaaab: PASS

/ab{1,3}bc/
    abbbbc: PASS
    abbbc: PASS
    abbc: PASS
    *** Failers
    abc: PASS
    abbbbbc: PASS

/([^.]*)\.([^:]*):[T ]+(.*)/
    track1.title:TBlah blah blah: PASS

/([^.]*)\.([^:]*):[T ]+(.*)/i
    track1.title:TBlah blah blah: PASS

/([^.]*)\.([^:]*):[t ]+(.*)/i
    track1.title:TBlah blah blah: PASS

/^[W-c]+$/
    WXY_^abc: PASS
    *** Failers
    wxy: PASS

/^[W-c]+$/i
    WXY_^abc: PASS
    wxy_^ABC: PASS

/^[\x3f-\x5F]+$/i
    WXY_^abc: PASS
    wxy_^ABC: PASS

/^abc$/m
    abc: PASS
    qqq\nabc: FAIL. Actual results: "null"
    abc\nzzz: FAIL. Actual results: "null"
    qqq\nabc\nzzz: FAIL. Actual results: "null"

/^abc$/
    abc: PASS
    *** Failers
    qqq\nabc: PASS
    abc\nzzz: PASS
    qqq\nabc\nzzz: PASS

/\Aabc\Z/m
    abc: FAIL. Actual results: "null"
    abc\n: FAIL. Actual results: "null"
    *** Failers
    qqq\nabc: PASS
    abc\nzzz: PASS
    qqq\nabc\nzzz: PASS

/\A(.)*\Z/s
    abc\ndef: FAIL. Actual results: "null"

/\A(.)*\Z/m
    *** Failers: FAIL. Actual results: "null"
    abc\ndef: PASS

/(?:b)|(?::+)/
    b::c: PASS
    c::b: PASS

/[-az]+/
    az-: PASS
    *** Failers
    b: PASS

/[az-]+/
    za-: PASS
    *** Failers
    b: PASS

/[a\-z]+/
    a-z: PASS
    *** Failers
    b: PASS

/[a-z]+/
    abcdxyz: PASS

/[\d-]+/
    12-34: PASS
    *** Failers
    aaa: PASS

/[\d-z]+/
    12-34z: PASS
    *** Failers
    aaa: PASS

/\x5c/
FAILED TO COMPILE

/\x20Z/
    the Zoo: PASS
    *** Failers
    Zulu: PASS

/(abc)\1/i
    abcabc: PASS
    ABCabc: PASS
    abcABC: PASS

/ab{3cd/
    ab{3cd: PASS

/ab{3,cd/
    ab{3,cd: PASS

/ab{3,4a}cd/
    ab{3,4a}cd: PASS

/{4,5a}bc/
    {4,5a}bc: PASS

/abc$/
    abc: PASS
    abc\n: FAIL. Actual results: "null"
    *** Failers
    abc\ndef: PASS

/(abc)\123/
    abcS: PASS

/(abc)\223/
    abc: PASS

/(abc)\323/
    abcÓ: PASS

/(abc)\100/
    abc@: PASS
    abc\100: FAIL. Actual results: "null"

/(abc)\1000/
    abc@0: PASS
    abc@0: PASS
    abc\1000: FAIL. Actual results: "null"
    abc\1000: FAIL. Actual results: "null"
    abc\1000: FAIL. Actual results: "null"
    abc\100\60: FAIL. Actual results: "null"

/abc\81/
    abc : FAIL. Actual results: "null"
    abc 381: FAIL. Actual results: "null"

/abc\91/
    abc : FAIL. Actual results: "null"
    abc 391: FAIL. Actual results: "null"

/(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)\12\123/
    abcdefghijkllS: PASS

/(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\12\123/
    abcdefghijk\12S: FAIL. Actual results: "null"

/ab\idef/
    abidef: PASS

/a{0}bc/
    bc: PASS

/(a|(bc)){0,0}?xyz/
    xyz: FAIL. Actual results: "xyz,,"

/abc[\10]de/
    abcde: PASS

/abc[\1]de/
    abc\1de: FAIL. Actual results: "null"

/(abc)[\1]de/
    abc\1de: FAIL. Actual results: "null"

/(?s)a.b/
FAILED TO COMPILE

/^([^a])([^\b])([^c]*)([^d]{3,4})/
    baNOTccccd: PASS
    baNOTcccd: PASS
    baNOTccd: PASS
    bacccd: PASS
    *** Failers
    anything: PASS
    b\bc: PASS
    baccd: PASS

/[^a]/
    Abc: PASS

/[^a]/i
    Abc: PASS

/[^a]+/
    AAAaAbc: PASS

/[^a]+/i
    AAAaAbc: PASS

/[^a]+/
    bbb\nccc: FAIL. Actual results: "bbb\nccc"

/[^k]$/
    abc: PASS
    *** Failers
    abk: PASS

/[^k]{2,3}$/
    abc: PASS
    kbc: PASS
    kabc: PASS
    *** Failers
    abk: PASS
    akb: PASS
    akk: PASS

/^\d{8,}\@.+[^k]$/
    12345678\@a.b.c.d: FAIL. Actual results: "null"
    123456789\@x.y.z: FAIL. Actual results: "null"
    *** Failers
    12345678\@x.y.uk: PASS
    1234567\@a.b.c.d: PASS

/(a)\1{8,}/
    aaaaaaaaa: PASS
    aaaaaaaaaa: PASS
    *** Failers
    aaaaaaa: PASS

/[^a]/
    aaaabcd: PASS
    aaAabcd: PASS

/[^a]/i
    aaaabcd: PASS
    aaAabcd: PASS

/[^az]/
    aaaabcd: PASS
    aaAabcd: PASS

/[^az]/i
    aaaabcd: PASS
    aaAabcd: PASS

/\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\042\043\044\045\046\047\050\051\052\053\054\055\056\057\060\061\062\063\064\065\066\067\070\071\072\073\074\075\076\077\100\101\102\103\104\105\106\107\110\111\112\113\114\115\116\117\120\121\122\123\124\125\126\127\130\131\132\133\134\135\136\137\140\141\142\143\144\145\146\147\150\151\152\153\154\155\156\157\160\161\162\163\164\165\166\167\170\171\172\173\174\175\176\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377/
FAILED TO COMPILE

/P[^*]TAIRE[^*]{1,6}?LL/
    xxxxxxxxxxxPSTAIREISLLxxxxxxxxx: PASS

/P[^*]TAIRE[^*]{1,}?LL/
    xxxxxxxxxxxPSTAIREISLLxxxxxxxxx: PASS

/(\.\d\d[1-9]?)\d+/
    1.230003938: PASS
    1.875000282: PASS
    1.235: PASS

/(\.\d\d((?=0)|\d(?=\d)))/
    1.230003938: PASS
    1.875000282: PASS
    *** Failers
    1.235: PASS

/a(?)b/
FAILED TO COMPILE

/\b(foo)\s+(\w+)/i
    Food is on the foo table: PASS

/foo(.*)bar/
    The food is under the bar in the barn.: PASS

/foo(.*?)bar/  
    The food is under the bar in the barn.: PASS

/(.*)(\d*)/
    I have 2 numbers: 53147: PASS

/(.*)(\d+)/
    I have 2 numbers: 53147: PASS

/(.*?)(\d*)/
    I have 2 numbers: 53147: PASS

/(.*?)(\d+)/
    I have 2 numbers: 53147: PASS

/(.*)(\d+)$/
    I have 2 numbers: 53147: PASS

/(.*?)(\d+)$/
    I have 2 numbers: 53147: PASS

/(.*)\b(\d+)$/
    I have 2 numbers: 53147: PASS

/(.*\D)(\d+)$/
    I have 2 numbers: 53147: PASS

/^\D*(?!123)/
    ABC123: PASS

/^(\D*)(?=\d)(?!123)/
    ABC445: PASS
    *** Failers
    ABC123: PASS

/^[W-]46]/
    W46]789: PASS
    -46]789: PASS
    *** Failers
    Wall: PASS
    Zebra: PASS
    42: PASS
    [abcd]: PASS
    ]abcd[: PASS

/^[W-\]46]/
    W46]789: PASS
    Wall: PASS
    Zebra: PASS
    Xylophone: PASS
    42: PASS
    [abcd]: PASS
    ]abcd[: PASS
    \\backslash: PASS
    *** Failers
    -46]789: PASS
    well: PASS

/\d\d\/\d\d\/\d\d\d\d/
    01/01/2000: PASS

/word (?:[a-zA-Z0-9]+ ){0,10}otherword/
  word cat dog elephant mussel cow horse canary baboon snake shark otherword: PASS
  word cat dog elephant mussel cow horse canary baboon snake shark: PASS

/word (?:[a-zA-Z0-9]+ ){0,300}otherword/
  word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope: PASS

/^(a){0,0}/
    bcd: FAIL. Actual results: ","
    abc: FAIL. Actual results: ","
    aab: FAIL. Actual results: ","

/^(a){0,1}/
    bcd: FAIL. Actual results: ","
    abc: PASS
    aab: PASS

/^(a){0,2}/
    bcd: FAIL. Actual results: ","
    abc: PASS
    aab: PASS

/^(a){0,3}/
    bcd: FAIL. Actual results: ","
    abc: PASS
    aab: PASS
    aaa: PASS

/^(a){0,}/
    bcd: FAIL. Actual results: ","
    abc: PASS
    aab: PASS
    aaa: PASS
    aaaaaaaa: PASS

/^(a){1,1}/
    bcd: PASS
    abc: PASS
    aab: PASS

/^(a){1,2}/
    bcd: PASS
    abc: PASS
    aab: PASS

/^(a){1,3}/
    bcd: PASS
    abc: PASS
    aab: PASS
    aaa: PASS

/^(a){1,}/
    bcd: PASS
    abc: PASS
    aab: PASS
    aaa: PASS
    aaaaaaaa: PASS

/.*\.gif/
    borfle\nbib.gif\nno: FAIL. Actual results: "borfle\nbib.gif"

/.{0,}\.gif/
    borfle\nbib.gif\nno: FAIL. Actual results: "borfle\nbib.gif"

/.*\.gif/m
    borfle\nbib.gif\nno: FAIL. Actual results: "borfle\nbib.gif"

/.*\.gif/s
    borfle\nbib.gif\nno: FAIL. Actual results: "borfle\nbib.gif"

/.*\.gif/ms
    borfle\nbib.gif\nno: FAIL. Actual results: "borfle\nbib.gif"

/.*$/
    borfle\nbib.gif\nno: FAIL. Actual results: "borfle\nbib.gif\nno"

/.*$/m
    borfle\nbib.gif\nno: FAIL. Actual results: "borfle\nbib.gif\nno"

/.*$/s
    borfle\nbib.gif\nno: FAIL. Actual results: "borfle\nbib.gif\nno"

/.*$/ms
    borfle\nbib.gif\nno: FAIL. Actual results: "borfle\nbib.gif\nno"

/.*$/
    borfle\nbib.gif\nno\n: FAIL. Actual results: "borfle\nbib.gif\nno\n"

/.*$/m
    borfle\nbib.gif\nno\n: FAIL. Actual results: "borfle\nbib.gif\nno\n"

/.*$/s
    borfle\nbib.gif\nno\n: FAIL. Actual results: "borfle\nbib.gif\nno\n"

/.*$/ms
    borfle\nbib.gif\nno\n: FAIL. Actual results: "borfle\nbib.gif\nno\n"

/(.*X|^B)/
    abcde\n1234Xyz: FAIL. Actual results: "abcde\n1234X,abcde\n1234X"
    BarFoo: PASS
    *** Failers
    abcde\nBar: PASS

/(.*X|^B)/m
    abcde\n1234Xyz: FAIL. Actual results: "abcde\n1234X,abcde\n1234X"
    BarFoo: PASS
    abcde\nBar: FAIL. Actual results: "null"

/(.*X|^B)/s
    abcde\n1234Xyz: FAIL. Actual results: "abcde\n1234X,abcde\n1234X"
    BarFoo: PASS
    *** Failers
    abcde\nBar: PASS

/(.*X|^B)/ms
    abcde\n1234Xyz: FAIL. Actual results: "abcde\n1234X,abcde\n1234X"
    BarFoo: PASS
    abcde\nBar: FAIL. Actual results: "null"

/(?s)(.*X|^B)/
FAILED TO COMPILE

/(?s:.*X|^B)/
FAILED TO COMPILE

/^.*B/
    **** Failers
    abc\nB: FAIL. Actual results: "abc\nB"

/(?s)^.*B/
FAILED TO COMPILE

/(?m)^.*B/
FAILED TO COMPILE

/(?ms)^.*B/
FAILED TO COMPILE

/(?ms)^B/
FAILED TO COMPILE

/(?s)B$/
FAILED TO COMPILE

/^[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]/
    123456654321: PASS

/^\d\d\d\d\d\d\d\d\d\d\d\d/
    123456654321: PASS

/^[\d][\d][\d][\d][\d][\d][\d][\d][\d][\d][\d][\d]/
    123456654321: PASS

/^[abc]{12}/
    abcabcabcabc: PASS

/^[a-c]{12}/
    abcabcabcabc: PASS

/^(a|b|c){12}/
    abcabcabcabc: PASS

/^[abcdefghijklmnopqrstuvwxy0123456789]/
    n: PASS
    *** Failers
    z: PASS

/abcde{0,0}/
    abcd: PASS
    *** Failers
    abce: PASS

/ab[cd]{0,0}e/
    abe: PASS
    *** Failers
    abcde: PASS

/ab(c){0,0}d/
    abd: FAIL. Actual results: "abd,"
    *** Failers
    abcd: PASS

/a(b*)/
    a: PASS
    ab: PASS
    abbbb: PASS
    *** Failers
    bbbbb: PASS

/ab\d{0}e/
    abe: PASS
    *** Failers
    ab1e: PASS

/"([^\\"]+|\\.)*"/
    the \"quick\" brown fox: FAIL. Actual results: "null"
    \"the \\\"quick\\\" brown fox\": FAIL. Actual results: "null"

/.*?/g+
Unsupported modifiers: g+

/\b/g+
Unsupported modifiers: g+

/\b/+g
Unsupported modifiers: +g

//g
    abc: PASS
    abc: PASS
    abc: PASS
    abc: PASS

/<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>/is
  <TR BGCOLOR='#DBE9E9'><TD align=left valign=top>43.<a href='joblist.cfm?JobID=94 6735&Keyword='>Word Processor<BR>(N-1286)</a></TD><TD align=left valign=top>Lega lstaff.com</TD><TD align=left valign=top>CA - Statewide</TD></TR>: PASS

/a[^a]b/
    acb: PASS
    a\nb: FAIL. Actual results: "null"

/a.b/
    acb: PASS
    *** Failers
    a\nb: PASS

/a[^a]b/s
    acb: PASS
    a\nb: FAIL. Actual results: "null"

/a.b/s
    acb: PASS
    a\nb: FAIL. Actual results: "null"

/^(b+?|a){1,2}?c/
    bac: PASS
    bbac: PASS
    bbbac: PASS
    bbbbac: PASS
    bbbbbac: PASS

/^(b+|a){1,2}?c/
    bac: PASS
    bbac: PASS
    bbbac: PASS
    bbbbac: PASS
    bbbbbac: PASS

/(?!\A)x/m
    x\nb\n: FAIL. Actual results: "x"
    a\bx\n: PASS

/\x0{ab}/
     b}: FAIL. Actual results: "null"

/(A|B)*?CD/
    CD: FAIL. Actual results: "CD,"

/(A|B)*CD/
    CD: FAIL. Actual results: "CD,"

/(AB)*?\1/
    ABABAB: FAIL. Actual results: ","

/(AB)*\1/
    ABABAB: PASS

/(?<!bar)foo/
FAILED TO COMPILE

/\w{3}(?<!bar)foo/
FAILED TO COMPILE

/(?<=(foo)a)bar/
FAILED TO COMPILE

/\Aabc\z/m
    abc: FAIL. Actual results: "null"
    *** Failers
    abc\n: PASS
    qqq\nabc: PASS
    abc\nzzz: PASS
    qqq\nabc\nzzz: PASS

"(?>.*/)foo"
FAILED TO COMPILE

"(?>.*/)foo"
FAILED TO COMPILE

/(?>(\.\d\d[1-9]?))\d+/
FAILED TO COMPILE

/^((?>\w+)|(?>\s+))*$/
FAILED TO COMPILE

/(\d+)(\w)/
    12345a: PASS
    12345+: PASS

/((?>\d+))(\w)/
FAILED TO COMPILE

/(?>a+)b/
FAILED TO COMPILE

/((?>a+)b)/
FAILED TO COMPILE

/(?>(a+))b/
FAILED TO COMPILE

/(?>b)+/
FAILED TO COMPILE

/(?>a+|b+|c+)*c/
FAILED TO COMPILE

/((?>[^()]+)|\([^()]*\))+/
FAILED TO COMPILE

/\(((?>[^()]+)|\([^()]+\))+\)/ 
FAILED TO COMPILE

/a(?-i)b/i
FAILED TO COMPILE

/(a (?x)b c)d e/
FAILED TO COMPILE

/(a b(?x)c d (?-x)e f)/
FAILED TO COMPILE

/(a(?i)b)c/
FAILED TO COMPILE

/a(?i:b)c/
FAILED TO COMPILE

/a(?i:b)*c/
FAILED TO COMPILE

/a(?=b(?i)c)\w\wd/
FAILED TO COMPILE

/(?s-i:more.*than).*million/i
FAILED TO COMPILE

/(?:(?s-i)more.*than).*million/i
FAILED TO COMPILE

/(?>a(?i)b+)+c/ 
FAILED TO COMPILE

/(?=a(?i)b)\w\wc/
FAILED TO COMPILE

/(?<=a(?i)b)(\w\w)c/
FAILED TO COMPILE

/(?:(a)|b)(?(1)A|B)/
FAILED TO COMPILE

/^(a)?(?(1)a|b)+$/
FAILED TO COMPILE

/^(?(?=abc)\w{3}:|\d\d)$/
FAILED TO COMPILE

/^(?(?!abc)\d\d|\w{3}:)$/
FAILED TO COMPILE

/(?(?<=foo)bar|cat)/
FAILED TO COMPILE

/(?(?<!foo)cat|bar)/
FAILED TO COMPILE

/( \( )? [^()]+ (?(1) \) |) /x
Unsupported modifiers: x

/( \( )? [^()]+ (?(1) \) ) /x
Unsupported modifiers: x

/^(?(2)a|(1)(2))+$/
FAILED TO COMPILE

/((?i)blah)\s+\1/
FAILED TO COMPILE

/((?i)blah)\s+(?i:\1)/
FAILED TO COMPILE

/(?>a*)*/
FAILED TO COMPILE

/(abc|)+/
    abc: PASS
    abcabc: PASS
    abcabcabc: PASS
    xyz: PASS

/([a]*)*/
    a: PASS
    aaaaa: PASS

/([ab]*)*/
    a: PASS
    b: PASS
    ababab: PASS
    aaaabcde: PASS
    bbbb: PASS

/([^a]*)*/
    b: PASS
    bbbb: PASS
    aaa: PASS

/([^ab]*)*/
    cccc: PASS
    abab: PASS

/([a]*?)*/
    a: PASS
    aaaa: PASS

/([ab]*?)*/
    a: PASS
    b: PASS
    abab: PASS
    baba: PASS

/([^a]*?)*/
    b: PASS
    bbbb: PASS
    aaa: PASS

/([^ab]*?)*/
    c: PASS
    cccc: PASS
    baba: PASS

/(?>a*)*/
FAILED TO COMPILE

/((?>a*))*/
FAILED TO COMPILE

/((?>a*?))*/
FAILED TO COMPILE

/(?(?=[^a-z]+[a-z])  \d{2}-[a-z]{3}-\d{2}  |  \d{2}-\d{2}-\d{2} ) /x
Unsupported modifiers: x

/(?<=(foo))bar\1/
FAILED TO COMPILE

/(?i:saturday|sunday)/
FAILED TO COMPILE

/(a(?i)bc|BB)x/
FAILED TO COMPILE

/^([ab](?i)[cd]|[ef])/
FAILED TO COMPILE

/^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)/
FAILED TO COMPILE

/(?<=foo\n)^bar/m
FAILED TO COMPILE

/(?<=(?<!foo)bar)baz/
FAILED TO COMPILE

/The case of aaaaaa is missed out below because I think Perl 5.005_02 gets/
/it wrong; it sets $1 to aaa rather than aa. Compare the following test,/: PASS
/where it does set $1 to aa when matching aaaaaa./: PASS

/^(a\1?){4}$/
    a: PASS
    aa: PASS
    aaa: PASS
    aaaa: PASS
    aaaaa: PASS
    aaaaaaa: PASS
    aaaaaaaa: PASS
    aaaaaaaaa: PASS
    aaaaaaaaaa: PASS
    aaaaaaaaaaa: PASS
    aaaaaaaaaaaa: PASS
    aaaaaaaaaaaaa: PASS
    aaaaaaaaaaaaaa: PASS
    aaaaaaaaaaaaaaa: PASS
    aaaaaaaaaaaaaaaa: PASS

/^(a\1?)(a\1?)(a\2?)(a\3?)$/
    a: PASS
    aa: PASS
    aaa: PASS
    aaaa: PASS
    aaaaa: PASS
    aaaaaa: PASS
    aaaaaaa: PASS
    aaaaaaaa: PASS
    aaaaaaaaa: PASS
    aaaaaaaaaa: PASS
    aaaaaaaaaaa: PASS
    aaaaaaaaaaaa: PASS
    aaaaaaaaaaaaa: PASS
    aaaaaaaaaaaaaa: PASS
    aaaaaaaaaaaaaaa: PASS
    aaaaaaaaaaaaaaaa: PASS

/The following tests are taken from the Perl 5.005 test suite; some of them/
/are compatible with 5.004, but I'd rather not have to sort them out./: PASS

/abc/
    abc: PASS
    xabcy: PASS
    ababc: PASS
    *** Failers
    xbc: PASS
    axc: PASS
    abx: PASS

/ab*c/
    abc: PASS

/ab*bc/
    abc: PASS
    abbc: PASS
    abbbbc: PASS

/.{1}/
    abbbbc: PASS

/.{3,4}/
    abbbbc: PASS

/ab{0,}bc/
    abbbbc: PASS

/ab+bc/
    abbc: PASS
    *** Failers
    abc: PASS
    abq: PASS

/ab{1,}bc/

/ab+bc/
    abbbbc: PASS

/ab{1,}bc/
    abbbbc: PASS

/ab{1,3}bc/
    abbbbc: PASS

/ab{3,4}bc/
    abbbbc: PASS

/ab{4,5}bc/
    *** Failers
    abq: PASS
    abbbbc: PASS

/ab?bc/
    abbc: PASS
    abc: PASS

/ab{0,1}bc/
    abc: PASS

/ab?bc/

/ab?c/
    abc: PASS

/ab{0,1}c/
    abc: PASS

/^abc$/
    abc: PASS
    *** Failers
    abbbbc: PASS
    abcc: PASS

/^abc/
    abcc: PASS

/^abc$/

/abc$/
    aabc: PASS
    *** Failers
    aabc: PASS
    aabcd: PASS

/^/
    abc: PASS

/$/
    abc: PASS

/a.c/
    abc: PASS
    axc: PASS

/a.*c/
    axyzc: PASS

/a[bc]d/
    abd: PASS
    *** Failers
    axyzd: PASS
    abc: PASS

/a[b-d]e/
    ace: PASS

/a[b-d]/
    aac: PASS

/a[-b]/
    a-: PASS

/a[b-]/
    a-: PASS

/a]/
    a]: PASS

/a[]]b/
    a]b: FAIL. Actual results: "null"

/a[^bc]d/
    aed: PASS
    *** Failers
    abd: PASS
    abd: PASS

/a[^-b]c/
    adc: PASS

/a[^]b]c/
    adc: FAIL. Actual results: "null"
    *** Failers
    a-c: FAIL. Actual results: "null"
    a]c: PASS

/\ba\b/
    a-: PASS
    -a: PASS
    -a-: PASS

/\by\b/
    *** Failers
    xy: PASS
    yz: PASS
    xyz: PASS

/\Ba\B/
    *** Failers
    a-: PASS
    -a: PASS
    -a-: PASS

/\By\b/
    xy: PASS

/\by\B/
    yz: PASS

/\By\B/
    xyz: PASS

/\w/
    a: PASS

/\W/
    -: PASS
    *** Failers
    -: PASS
    a: PASS

/a\sb/
    a b: PASS

/a\Sb/
    a-b: PASS
    *** Failers
    a-b: PASS
    a b: PASS

/\d/
    1: PASS

/\D/
    -: PASS
    *** Failers
    -: PASS
    1: PASS

/[\w]/
    a: PASS

/[\W]/
    -: PASS
    *** Failers
    -: PASS
    a: PASS

/a[\s]b/
    a b: PASS

/a[\S]b/
    a-b: PASS
    *** Failers
    a-b: PASS
    a b: PASS

/[\d]/
    1: PASS

/[\D]/
    -: PASS
    *** Failers
    -: PASS
    1: PASS

/ab|cd/
    abc: PASS
    abcd: PASS

/()ef/
    def: PASS

/$b/

/a\(b/
    a(b: PASS

/a\(*b/
    ab: PASS
    a((b: PASS

/a\\b/
    a\b: FAIL. Actual results: "a\b"

/((a))/
    abc: PASS

/(a)b(c)/
    abc: PASS

/a+b+c/
    aabbabc: PASS

/a{1,}b{1,}c/
    aabbabc: PASS

/a.+?c/
    abcabc: PASS

/(a+|b)*/
    ab: PASS

/(a+|b){0,}/
    ab: PASS

/(a+|b)+/
    ab: PASS

/(a+|b){1,}/
    ab: PASS

/(a+|b)?/
    ab: PASS

/(a+|b){0,1}/
    ab: PASS

/[^ab]*/
    cde: PASS

/abc/
    *** Failers
    b: PASS


FAILED TO COMPILE


FAILED TO COMPILE

/([abc])*bcd/
    abcd: PASS

/a|b|c|d|e/
    e: PASS

/(a|b|c|d|e)f/
    ef: PASS

/abcd*efg/
    abcdefg: PASS

/ab*/
    xabyabbbz: PASS
    xayabbbz: PASS

/(ab|cd)e/
    abcde: PASS

/[abhgefdc]ij/
    hij: PASS

/^(ab|cd)e/

/(abc|)ef/
    abcdef: PASS

/(a|b)c*d/
    abcd: PASS

/(ab|ab*)bc/
    abc: PASS

/a([bc]*)c*/
    abc: PASS

/a([bc]*)(c*d)/
    abcd: PASS

/a([bc]+)(c*d)/
    abcd: PASS

/a([bc]*)(c+d)/
    abcd: PASS

/a[bcd]*dcdcde/
    adcdcde: PASS

/a[bcd]+dcdcde/
    *** Failers
    abcde: PASS
    adcdcde: PASS

/(ab|a)b*c/
    abc: PASS

/((a)(b)c)(d)/
    abcd: PASS

/[a-zA-Z_][a-zA-Z0-9_]*/
    alpha: PASS

/^a(bc+|b[eh])g|.h$/
    abh: FAIL. Actual results: "bh,"

/(bc+d$|ef*g.|h?i(j|k))/
    effgz: FAIL. Actual results: "effgz,effgz,"
    ij: PASS
    reffgz: FAIL. Actual results: "effgz,effgz,"
    *** Failers
    effg: PASS
    bcdd: PASS

/((((((((((a))))))))))/
    a: PASS

/((((((((((a))))))))))\10/
    aa: PASS

/(((((((((a)))))))))/
    a: PASS

/multiple words of text/
    *** Failers
    aa: PASS
    uh-uh: PASS

/multiple words/
    multiple words, yeah: PASS

/(.*)c(.*)/
    abcde: PASS

/\((.*), (.*)\)/
    (a, b): PASS

/[k]/

/abcd/
    abcd: PASS

/a(bc)d/
    abcd: PASS

/a[-]?c/
    ac: PASS

/(abc)\1/
    abcabc: PASS

/([a-c]*)\1/
    abcabc: PASS

/(a)|\1/
    a: PASS
    *** Failers: FAIL. Actual results: ","
    ab: PASS
    x: FAIL. Actual results: ","

/(([a-c])b*?\2)*/
    ababbbcbc: PASS

/(([a-c])b*?\2){3}/
    ababbbcbc: PASS

/((\3|b)\2(a)x)+/
    aaaxabaxbaaxbbax: FAIL. Actual results: "ax,ax,,a"

/((\3|b)\2(a)){2,}/
    bbaababbabaaaaabbaaaabba: FAIL. Actual results: "abba,bba,b,a"

/abc/i
    ABC: PASS
    XABCY: PASS
    ABABC: PASS
    *** Failers
    aaxabxbaxbbx: PASS
    XBC: PASS
    AXC: PASS
    ABX: PASS

/ab*c/i
    ABC: PASS

/ab*bc/i
    ABC: PASS
    ABBC: PASS

/ab*?bc/i
    ABBBBC: PASS

/ab{0,}?bc/i
    ABBBBC: PASS

/ab+?bc/i
    ABBC: PASS

/ab+bc/i
    *** Failers
    ABC: PASS
    ABQ: PASS

/ab{1,}bc/i

/ab+bc/i
    ABBBBC: PASS

/ab{1,}?bc/i
    ABBBBC: PASS

/ab{1,3}?bc/i
    ABBBBC: PASS

/ab{3,4}?bc/i
    ABBBBC: PASS

/ab{4,5}?bc/i
    *** Failers
    ABQ: PASS
    ABBBBC: PASS

/ab??bc/i
    ABBC: PASS
    ABC: PASS

/ab{0,1}?bc/i
    ABC: PASS

/ab??bc/i

/ab??c/i
    ABC: PASS

/ab{0,1}?c/i
    ABC: PASS

/^abc$/i
    ABC: PASS
    *** Failers
    ABBBBC: PASS
    ABCC: PASS

/^abc/i
    ABCC: PASS

/^abc$/i

/abc$/i
    AABC: PASS

/^/i
    ABC: PASS

/$/i
    ABC: PASS

/a.c/i
    ABC: PASS
    AXC: PASS

/a.*?c/i
    AXYZC: PASS

/a.*c/i
    *** Failers
    AABC: PASS
    AXYZD: PASS

/a[bc]d/i
    ABD: PASS

/a[b-d]e/i
    ACE: PASS
    *** Failers
    ABC: PASS
    ABD: PASS

/a[b-d]/i
    AAC: PASS

/a[-b]/i
    A-: PASS

/a[b-]/i
    A-: PASS

/a]/i
    A]: PASS

/a[]]b/i
    A]B: FAIL. Actual results: "null"

/a[^bc]d/i
    AED: PASS

/a[^-b]c/i
    ADC: PASS
    *** Failers
    ABD: PASS
    A-C: PASS

/a[^]b]c/i
    ADC: FAIL. Actual results: "null"

/ab|cd/i
    ABC: PASS
    ABCD: PASS

/()ef/i
    DEF: PASS

/$b/i
    *** Failers
    A]C: PASS
    B: PASS

/a\(b/i
    A(B: PASS

/a\(*b/i
    AB: PASS
    A((B: PASS

/a\\b/i
    A\B: FAIL. Actual results: "A\B"

/((a))/i
    ABC: PASS

/(a)b(c)/i
    ABC: PASS

/a+b+c/i
    AABBABC: PASS

/a{1,}b{1,}c/i
    AABBABC: PASS

/a.+?c/i
    ABCABC: PASS

/a.*?c/i
    ABCABC: PASS

/a.{0,5}?c/i
    ABCABC: PASS

/(a+|b)*/i
    AB: PASS

/(a+|b){0,}/i
    AB: PASS

/(a+|b)+/i
    AB: PASS

/(a+|b){1,}/i
    AB: PASS

/(a+|b)?/i
    AB: PASS

/(a+|b){0,1}/i
    AB: PASS

/(a+|b){0,1}?/i
    AB: FAIL. Actual results: ","

/[^ab]*/i
    CDE: PASS

/abc/i

/a*/i


FAILED TO COMPILE

/([abc])*bcd/i
    ABCD: PASS

/a|b|c|d|e/i
    E: PASS

/(a|b|c|d|e)f/i
    EF: PASS

/abcd*efg/i
    ABCDEFG: PASS

/ab*/i
    XABYABBBZ: PASS
    XAYABBBZ: PASS

/(ab|cd)e/i
    ABCDE: PASS

/[abhgefdc]ij/i
    HIJ: PASS

/^(ab|cd)e/i
    ABCDE: PASS

/(abc|)ef/i
    ABCDEF: PASS

/(a|b)c*d/i
    ABCD: PASS

/(ab|ab*)bc/i
    ABC: PASS

/a([bc]*)c*/i
    ABC: PASS

/a([bc]*)(c*d)/i
    ABCD: PASS

/a([bc]+)(c*d)/i
    ABCD: PASS

/a([bc]*)(c+d)/i
    ABCD: PASS

/a[bcd]*dcdcde/i
    ADCDCDE: PASS

/a[bcd]+dcdcde/i

/(ab|a)b*c/i
    ABC: PASS

/((a)(b)c)(d)/i
    ABCD: PASS

/[a-zA-Z_][a-zA-Z0-9_]*/i
    ALPHA: PASS

/^a(bc+|b[eh])g|.h$/i
    ABH: FAIL. Actual results: "BH,"

/(bc+d$|ef*g.|h?i(j|k))/i
    EFFGZ: FAIL. Actual results: "EFFGZ,EFFGZ,"
    IJ: PASS
    REFFGZ: FAIL. Actual results: "EFFGZ,EFFGZ,"
    *** Failers
    ADCDCDE: PASS
    EFFG: PASS
    BCDD: PASS

/((((((((((a))))))))))/i
    A: PASS

/((((((((((a))))))))))\10/i
    AA: PASS

/(((((((((a)))))))))/i
    A: PASS

/(?:(?:(?:(?:(?:(?:(?:(?:(?:(a))))))))))/i
    A: PASS

/(?:(?:(?:(?:(?:(?:(?:(?:(?:(a|b|c))))))))))/i
    C: PASS

/multiple words of text/i
    *** Failers
    AA: PASS
    UH-UH: PASS

/multiple words/i
    MULTIPLE WORDS, YEAH: PASS

/(.*)c(.*)/i
    ABCDE: PASS

/\((.*), (.*)\)/i
    (A, B): PASS

/[k]/i

/abcd/i
    ABCD: PASS

/a(bc)d/i
    ABCD: PASS

/a[-]?c/i
    AC: PASS

/(abc)\1/i
    ABCABC: PASS

/([a-c]*)\1/i
    ABCABC: PASS

/a(?!b)./
    abad: PASS

/a(?=d)./
    abad: PASS

/a(?=c|d)./
    abad: PASS

/a(?:b|c|d)(.)/
    ace: PASS

/a(?:b|c|d)*(.)/
    ace: PASS

/a(?:b|c|d)+?(.)/
    ace: PASS
    acdbcdbe: PASS

/a(?:b|c|d)+(.)/
    acdbcdbe: PASS

/a(?:b|c|d){2}(.)/
    acdbcdbe: PASS

/a(?:b|c|d){4,5}(.)/
    acdbcdbe: PASS

/a(?:b|c|d){4,5}?(.)/
    acdbcdbe: PASS

/((foo)|(bar))*/
    foobar: PASS

/a(?:b|c|d){6,7}(.)/
    acdbcdbe: PASS

/a(?:b|c|d){6,7}?(.)/
    acdbcdbe: PASS

/a(?:b|c|d){5,6}(.)/
    acdbcdbe: PASS

/a(?:b|c|d){5,6}?(.)/
    acdbcdbe: PASS

/a(?:b|c|d){5,7}(.)/
    acdbcdbe: PASS

/a(?:b|c|d){5,7}?(.)/
    acdbcdbe: PASS

/a(?:b|(c|e){1,2}?|d)+?(.)/
    ace: PASS

/^(.+)?B/
    AB: PASS

/^([^a-z])|(\^)$/
    .: FAIL. Actual results: ".,.,"

/^[<>]&/
    <&OUT: PASS

/^(a\1?){4}$/
    aaaaaaaaaa: PASS
    *** Failers
    AB: PASS
    aaaaaaaaa: PASS
    aaaaaaaaaaa: PASS

/^(a(?(1)\1)){4}$/
FAILED TO COMPILE

/(?:(f)(o)(o)|(b)(a)(r))*/
    foobar: PASS

/(?<=a)b/
FAILED TO COMPILE

/(?<!c)b/
FAILED TO COMPILE

/(?:..)*a/
    aba: PASS

/(?:..)*?a/
    aba: PASS

/^(?:b|a(?=(.)))*\1/
    abc: PASS

/^(){3,5}/
    abc: PASS

/^(a+)*ax/
    aax: PASS

/^((a|b)+)*ax/
    aax: PASS

/^((a|bc)+)*ax/
    aax: PASS

/(a|x)*ab/
    cab: FAIL. Actual results: "ab,"

/(a)*ab/
    cab: FAIL. Actual results: "ab,"

/(?:(?i)a)b/
FAILED TO COMPILE

/((?i)a)b/
FAILED TO COMPILE

/(?:(?i)a)b/
FAILED TO COMPILE

/((?i)a)b/
FAILED TO COMPILE

/(?:(?i)a)b/
FAILED TO COMPILE

/((?i)a)b/
FAILED TO COMPILE

/(?i:a)b/
FAILED TO COMPILE

/((?i:a))b/
FAILED TO COMPILE

/(?i:a)b/
FAILED TO COMPILE

/((?i:a))b/
FAILED TO COMPILE

/(?i:a)b/
FAILED TO COMPILE

/((?i:a))b/
FAILED TO COMPILE

/(?:(?-i)a)b/i
FAILED TO COMPILE

/((?-i)a)b/i
FAILED TO COMPILE

/(?:(?-i)a)b/i
FAILED TO COMPILE

/((?-i)a)b/i
FAILED TO COMPILE

/(?:(?-i)a)b/i
FAILED TO COMPILE

/((?-i)a)b/i
FAILED TO COMPILE

/(?:(?-i)a)b/i
FAILED TO COMPILE

/((?-i)a)b/i
FAILED TO COMPILE

/(?:(?-i)a)b/i
FAILED TO COMPILE

/((?-i)a)b/i
FAILED TO COMPILE

/(?-i:a)b/i
FAILED TO COMPILE

/((?-i:a))b/i
FAILED TO COMPILE

/(?-i:a)b/i
FAILED TO COMPILE

/((?-i:a))b/i
FAILED TO COMPILE

/(?-i:a)b/i
FAILED TO COMPILE

/((?-i:a))b/i
FAILED TO COMPILE

/(?-i:a)b/i
FAILED TO COMPILE

/((?-i:a))b/i
FAILED TO COMPILE

/(?-i:a)b/i
FAILED TO COMPILE

/((?-i:a))b/i
FAILED TO COMPILE

/((?-i:a.))b/i
FAILED TO COMPILE

/((?s-i:a.))b/i
FAILED TO COMPILE

/(?:c|d)(?:)(?:a(?:)(?:b)(?:b(?:))(?:b(?:)(?:b)))/
    cabbbb: PASS

/(?:c|d)(?:)(?:aaaaaaaa(?:)(?:bbbbbbbb)(?:bbbbbbbb(?:))(?:bbbbbbbb(?:)(?:bbbbbbbb)))/
    caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb: PASS

/(ab)\d\1/i
    Ab4ab: PASS
    ab4Ab: PASS

/foo\w*\d{4}baz/
    foobar1234baz: PASS

/x(~~)*(?:(?:F)?)?/
    x~~: PASS

/^a(?#xxx){3}c/
FAILED TO COMPILE

/^a (?#xxx) (?#yyy) {3}c/x
Unsupported modifiers: x

/(?<![cd])b/
FAILED TO COMPILE

/(?<![cd])[ab]/
FAILED TO COMPILE

/(?<!(c|d))b/
FAILED TO COMPILE

/(?<!(c|d))[ab]/
FAILED TO COMPILE

/(?<!cd)[ab]/
FAILED TO COMPILE

/^(?:a?b?)*$/
    \: FAIL. Actual results: "null"
    a: PASS
    ab: PASS
    aaa: PASS
    *** Failers
    dbcb: PASS
    a--: PASS
    aa--: PASS

/((?s)^a(.))((?m)^b$)/
FAILED TO COMPILE

/((?m)^b$)/
FAILED TO COMPILE

/(?m)^b/
FAILED TO COMPILE

/(?m)^(b)/
FAILED TO COMPILE

/((?m)^b)/
FAILED TO COMPILE

/\n((?m)^b)/
FAILED TO COMPILE

/((?s).)c(?!.)/
FAILED TO COMPILE

/((?s)b.)c(?!.)/
FAILED TO COMPILE

/^b/

/()^b/
    *** Failers
    a\nb\nc\n: PASS
    a\nb\nc\n: PASS

/((?m)^b)/
FAILED TO COMPILE

/(?(1)a|b)/
FAILED TO COMPILE

/(?(1)b|a)/
FAILED TO COMPILE

/(x)?(?(1)a|b)/
FAILED TO COMPILE

/(x)?(?(1)b|a)/
FAILED TO COMPILE

/()?(?(1)b|a)/
FAILED TO COMPILE

/()(?(1)b|a)/
FAILED TO COMPILE

/()?(?(1)a|b)/
FAILED TO COMPILE

/^(\()?blah(?(1)(\)))$/
FAILED TO COMPILE

/^(\(+)?blah(?(1)(\)))$/
FAILED TO COMPILE

/(?(?!a)a|b)/
FAILED TO COMPILE

/(?(?!a)b|a)/
FAILED TO COMPILE

/(?(?=a)b|a)/
FAILED TO COMPILE

/(?(?=a)a|b)/
FAILED TO COMPILE

/(?=(a+?))(\1ab)/
    aaab: PASS

/^(?=(a+?))\1ab/

/(\w+:)+/
    one:: PASS

/$(?<=^(a))/
FAILED TO COMPILE

/(?=(a+?))(\1ab)/
    aaab: PASS

/^(?=(a+?))\1ab/
    *** Failers
    aaab: PASS
    aaab: PASS

/([\w:]+::)?(\w+)$/
    abcd: PASS
    xy:z:::abcd: PASS

/^[^bcd]*(c+)/
    aexycd: PASS

/(a*)b+/
    caab: PASS

/([\w:]+::)?(\w+)$/
    abcd: PASS
    xy:z:::abcd: PASS
    *** Failers
    abcd:: PASS
    abcd:: PASS

/^[^bcd]*(c+)/
    aexycd: PASS

/(>a+)ab/

/(?>a+)b/
FAILED TO COMPILE

/([[:]+)/
    a:[b]:: PASS

/([[=]+)/
    a=[b]=: PASS

/([[.]+)/
    a.[b].: PASS

/((?>a+)b)/
FAILED TO COMPILE

/(?>(a+))b/
FAILED TO COMPILE

/((?>[^()]+)|\([^()]*\))+/
FAILED TO COMPILE

/a\Z/
    *** Failers
    aaab: PASS
    a\nb\n: PASS

/b\Z/
    a\nb\n: FAIL. Actual results: "null"

/b\z/

/b\Z/
    a\nb: FAIL. Actual results: "null"

/b\z/
    a\nb: FAIL. Actual results: "null"
    *** Failers

/^(?>(?(1)\.|())[^\W_](?>[a-z0-9-]*[^\W_])?)+$/
FAILED TO COMPILE

/(?>.*)(?<=(abcd|wxyz))/
FAILED TO COMPILE

/word (?>(?:(?!otherword)[a-zA-Z0-9]+ ){0,30})otherword/
FAILED TO COMPILE

/word (?>[a-zA-Z0-9]+ ){0,30}otherword/
FAILED TO COMPILE

/(?<=\d{3}(?!999))foo/
FAILED TO COMPILE

/(?<=(?!...999)\d{3})foo/
FAILED TO COMPILE

/(?<=\d{3}(?!999)...)foo/
FAILED TO COMPILE

/(?<=\d{3}...)(?<!999)foo/
FAILED TO COMPILE

/<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
/isx
FAILED TO COMPILE

/<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
/isx
FAILED TO COMPILE

/<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
/isx
FAILED TO COMPILE

/((Z)+|A)*/
    ZABCDEFG: PASS

/(Z()|A)*/
    ZABCDEFG: PASS

/(Z(())|A)*/
    ZABCDEFG: PASS

/((?>Z)+|A)*/
FAILED TO COMPILE

/((?>)+|A)*/
FAILED TO COMPILE

/a*/g
    abbab: PASS
    abbab: PASS
    abbab: PASS
    abbab: FAIL. Actual results: ""
    abbab: PASS
    abbab: PASS

/^[a-\d]/
    abcde: PASS
    -things: PASS
    0digit: PASS
    *** Failers
    bcdef: PASS

/^[\d-a]/
    abcde: PASS
    -things: PASS
    0digit: PASS
    *** Failers
    bcdef: PASS

/[[:space:]]+/
    > 	
<: FAIL. Actual results: "null"

/[[:blank:]]+/
    > 	
<: FAIL. Actual results: "null"

/[\s]+/
    > 	
<: FAIL. Actual results: " 	
"

/\s+/
    > 	
<: FAIL. Actual results: " 	
"

/ab/x
Unsupported modifiers: x

/(?!\A)x/m
  a\nxb\n: PASS

/(?!^)x/m
  a\nxb\n: FAIL. Actual results: "x"

/abc\Qabc\Eabc/
    abcabcabc: FAIL. Actual results: "null"

/abc\Q(*+|\Eabc/
FAILED TO COMPILE

/   abc\Q abc\Eabc/x
Unsupported modifiers: x

/abc#comment
    \Q#not comment
    literal\E/x
FAILED TO COMPILE

/abc#comment
    \Q#not comment
    literal/x
FAILED TO COMPILE

/abc#comment
    \Q#not comment
    literal\E #more comment
    /x
FAILED TO COMPILE

/abc#comment
    \Q#not comment
    literal\E #more comment/x
FAILED TO COMPILE

/\Qabc\$xyz\E/
    abc\\\$xyz: FAIL. Actual results: "null"

/\Qabc\E\$\Qxyz\E/
    abc\$xyz: FAIL. Actual results: "null"

/\Gabc/
    abc: FAIL. Actual results: "null"
    *** Failers
    xyzabc: PASS

/\Gabc./g
    abc1abc2xyzabc3: FAIL. Actual results: "null"
    abc1abc2xyzabc3: FAIL. Actual results: "null"

/abc./g
    abc1abc2xyzabc3: PASS
    abc1abc2xyzabc3: PASS
    abc1abc2xyzabc3: PASS

/a(?x: b c )d/
FAILED TO COMPILE

/((?x)x y z | a b c)/
FAILED TO COMPILE

/(?i)AB(?-i)C/
FAILED TO COMPILE

/((?i)AB(?-i)C|D)E/
FAILED TO COMPILE

/(.*)\d+\1/
    abc123abc: PASS
    abc123bc: PASS

/(.*)\d+\1/s
    abc123abc: PASS
    abc123bc: PASS

/((.*))\d+\1/
    abc123abc: PASS
    abc123bc: PASS

/-- This tests for an IPv6 address in the form where it can have up to --/
/-- eight components, one and only one of which is empty. This must be --/: PASS
/-- an internal component. --/: PASS

/^(?!:)                       # 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
  /xi
FAILED TO COMPILE

/[z\Qa-d]\E]/
    z: FAIL. Actual results: "null"
    a: FAIL. Actual results: "null"
    -: FAIL. Actual results: "null"
    d: FAIL. Actual results: "null"
    ]: FAIL. Actual results: "null"
    *** Failers: FAIL. Actual results: "null"
    b: PASS

/[\z\C]/
    z: PASS
    C: PASS

/\M/
    M: PASS

/(a+)*b/
    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: PASS

/(?i)reg(?:ul(?:[aä]|ae)r|ex)/
FAILED TO COMPILE

/Åæåä[à-ÿÀ-ß]+/
    Åæåäà: PASS
    Åæåäÿ: PASS
    ÅæåäÀ: PASS
    Åæåäß: PASS

/(?<=Z)X./
FAILED TO COMPILE

/ab cd (?x) de fg/
FAILED TO COMPILE

/ab cd(?x) de fg/
FAILED TO COMPILE

/(?<![^f]oo)(bar)/
FAILED TO COMPILE

/(?<![^f])X/
FAILED TO COMPILE

/(?<=[^f])X/
FAILED TO COMPILE

/^/mg
    a\nb\nc\n: PASS
    a\nb\nc\n: PASS
    a\nb\nc\n: PASS
    \: PASS

/(?<=C\n)^/mg
FAILED TO COMPILE

/(?:(?(1)a|b)(X))+/
FAILED TO COMPILE

/(?:(?(1)\1a|b)(X|Y))+/
FAILED TO COMPILE

/()()()()()()()()()(?:(?(10)\10a|b)(X|Y))+/
FAILED TO COMPILE

/[[,abc,]+]/
    abc]: PASS
    a,b]: PASS
    [a,b,c]: PASS

/(?-x: )/x
Unsupported modifiers: x

"(?x)(?-x: \s*#\s*)"
FAILED TO COMPILE

"(?x-is)(?:(?-ixs) \s*#\s*) include"
FAILED TO COMPILE

/a*b*\w/
    aaabbbb: PASS
    aaaa: PASS
    a: PASS

/a*b?\w/
    aaabbbb: PASS
    aaaa: PASS
    a: PASS

/a*b{0,4}\w/
    aaabbbb: PASS
    aaaa: PASS
    a: PASS

/a*b{0,}\w/
    aaabbbb: PASS
    aaaa: PASS
    a: PASS

/a*\d*\w/
    0a: PASS
    a: PASS

/a*b *\w/x
Unsupported modifiers: x

/a*b#comment
  *\w/x
FAILED TO COMPILE

/a* b *\w/x
Unsupported modifiers: x

/^\w+=.*(\\\n.*)*/
    abc=xyz\\\npqr: FAIL. Actual results: "abc=xyz\\\npqr,"

/(?=(\w+))\1:/
    abcd:: FAIL. Actual results: "null"

/^(?=(\w+))\1:/
    abcd:: PASS

/^\Eabc/
    abc: FAIL. Actual results: "null"

/^[\Eabc]/
    a: PASS
    ** Failers: PASS
    E: FAIL. Actual results: "E"

/^[a-\Ec]/
FAILED TO COMPILE

/^[a\E\E-\Ec]/
    b: FAIL. Actual results: "null"
    ** Failers: PASS
    -: PASS
    E: FAIL. Actual results: "E"

/^[\E\Qa\E-\Qz\E]+/
    b: FAIL. Actual results: "null"
    ** Failers: PASS
    -: PASS

/^[a\Q]bc\E]/
    a: FAIL. Actual results: "null"
    ]: FAIL. Actual results: "null"
    c: FAIL. Actual results: "null"

/^[a-\Q\E]/
FAILED TO COMPILE

/^(a()*)*/
    aaaa: FAIL. Actual results: "a,a,"

/^(?:a(?:(?:))*)*/
    aaaa: FAIL. Actual results: "a"

/^(a()+)+/
    aaaa: PASS

/^(?:a(?:(?:))+)+/
    aaaa: PASS

/(a){0,3}(?(1)b|(c|))*D/
FAILED TO COMPILE

/(a|)*\d/
  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: PASS
  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa4: PASS

/(?>a|)*\d/
FAILED TO COMPILE

/(?:a|)*\d/
  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: PASS
  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa4: PASS

/\Z/g
  abc\n: FAIL. Actual results: "null"
  abc\n: FAIL. Actual results: "null"

/^(?s)(?>.*)(?<!\n)/
FAILED TO COMPILE

/^(?![^\n]*\n\z)/
  abc: PASS
  abc\n: FAIL. Actual results: ""

/\z(?<!\n)/
FAILED TO COMPILE

/(.*(.)?)*/
    abcd: FAIL. Actual results: "abcd,,"

/( (A | (?(1)0|) )*   )/x
Unsupported modifiers: x

/( ( (?(1)0|) )*   )/x
Unsupported modifiers: x

/(  (?(1)0|)*   )/x
Unsupported modifiers: x

/[[:abcd:xyz]]/
    a]: PASS
    :]: PASS

/[abc[:x\]pqr]/
    a: PASS
    [: PASS
    :: PASS
    ]: PASS
    p: PASS

DONE