Lib/test/re_tests.py

   1 #!/usr/bin/env python
   2 # -*- mode: python -*-
   3
   4 # Re test suite and benchmark suite v1.5
   5
   6 # The 3 possible outcomes for each pattern
   7 [SUCCEED, FAIL, SYNTAX_ERROR] = range(3)
   8
   9 # Benchmark suite (needs expansion)
  10 #
  11 # The benchmark suite does not test correctness, just speed.  The
  12 # first element of each tuple is the regex pattern; the second is a
  13 # string to match it against.  The benchmarking code will embed the
  14 # second string inside several sizes of padding, to test how regex
  15 # matching performs on large strings.
  16
  17 benchmarks = [
  18
  19     # test common prefix
  20     ('Python|Perl', 'Perl'),    # Alternation
  21     ('(Python|Perl)', 'Perl'),  # Grouped alternation
  22
  23     ('Python|Perl|Tcl', 'Perl'),        # Alternation
  24     ('(Python|Perl|Tcl)', 'Perl'),      # Grouped alternation
  25
  26     ('(Python)\\1', 'PythonPython'),    # Backreference
  27     ('([0a-z][a-z0-9]*,)+', 'a5,b7,c9,'), # Disable the fastmap optimization
  28     ('([a-z][a-z0-9]*,)+', 'a5,b7,c9,'), # A few sets
  29
  30     ('Python', 'Python'),               # Simple text literal
  31     ('.*Python', 'Python'),             # Bad text literal
  32     ('.*Python.*', 'Python'),           # Worse text literal
  33     ('.*(Python)', 'Python'),           # Bad text literal with grouping
  34
  35 ]
  36
  37 # Test suite (for verifying correctness)
  38 #
  39 # The test suite is a list of 5- or 3-tuples.  The 5 parts of a
  40 # complete tuple are:
  41 # element 0: a string containing the pattern
  42 #         1: the string to match against the pattern
  43 #         2: the expected result (SUCCEED, FAIL, SYNTAX_ERROR)
  44 #         3: a string that will be eval()'ed to produce a test string.
  45 #            This is an arbitrary Python expression; the available
  46 #            variables are "found" (the whole match), and "g1", "g2", ...
  47 #            up to "g99" contain the contents of each group, or the
  48 #            string 'None' if the group wasn't given a value, or the
  49 #            string 'Error' if the group index was out of range;
  50 #            also "groups", the return value of m.group() (a tuple).
  51 #         4: The expected result of evaluating the expression.
  52 #            If the two don't match, an error is reported.
  53 #
  54 # If the regex isn't expected to work, the latter two elements can be omitted.
  55
  56 tests = [
  57     # Test ?P< and ?P= extensions
  58     ('(?P<foo_123', '', SYNTAX_ERROR),      # Unterminated group identifier
  59     ('(?P<1>a)', '', SYNTAX_ERROR),         # Begins with a digit
  60     ('(?P<!>a)', '', SYNTAX_ERROR),         # Begins with an illegal char
  61     ('(?P<foo!>a)', '', SYNTAX_ERROR),      # Begins with an illegal char
  62
  63     # Same tests, for the ?P= form
  64     ('(?P<foo_123>a)(?P=foo_123', 'aa', SYNTAX_ERROR),
  65     ('(?P<foo_123>a)(?P=1)', 'aa', SYNTAX_ERROR),
  66     ('(?P<foo_123>a)(?P=!)', 'aa', SYNTAX_ERROR),
  67     ('(?P<foo_123>a)(?P=foo_124', 'aa', SYNTAX_ERROR),  # Backref to undefined group
  68
  69     ('(?P<foo_123>a)', 'a', SUCCEED, 'g1', 'a'),
  70     ('(?P<foo_123>a)(?P=foo_123)', 'aa', SUCCEED, 'g1', 'a'),
  71
  72     # Test octal escapes
  73     ('\\1', 'a', SYNTAX_ERROR),    # Backreference
  74     ('[\\1]', '\1', SUCCEED, 'found', '\1'),  # Character
  75     ('\\09', chr(0) + '9', SUCCEED, 'found', chr(0) + '9'),
  76     ('\\141', 'a', SUCCEED, 'found', 'a'),
  77     ('(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)\\119', 'abcdefghijklk9', SUCCEED, 'found+"-"+g11', 'abcdefghijklk9-k'),
  78
  79     # Test \0 is handled everywhere
  80     (r'\0', '\0', SUCCEED, 'found', '\0'),
  81     (r'[\0a]', '\0', SUCCEED, 'found', '\0'),
  82     (r'[a\0]', '\0', SUCCEED, 'found', '\0'),
  83     (r'[^a\0]', '\0', FAIL),
  84
  85     # Test various letter escapes
  86     (r'\a[\b]\f\n\r\t\v', '\a\b\f\n\r\t\v', SUCCEED, 'found', '\a\b\f\n\r\t\v'),
  87     (r'[\a][\b][\f][\n][\r][\t][\v]', '\a\b\f\n\r\t\v', SUCCEED, 'found', '\a\b\f\n\r\t\v'),
  88     # NOTE: not an error under PCRE/PRE:
  89     # (r'\u', '', SYNTAX_ERROR),    # A Perl escape
  90     (r'\c\e\g\h\i\j\k\m\o\p\q\y\z', 'ceghijkmopqyz', SUCCEED, 'found', 'ceghijkmopqyz'),
  91     (r'\xff', '\377', SUCCEED, 'found', chr(255)),
  92     # new \x semantics
  93     (r'\x00ffffffffffffff', '\377', FAIL, 'found', chr(255)),
  94     (r'\x00f', '\017', FAIL, 'found', chr(15)),
  95     (r'\x00fe', '\376', FAIL, 'found', chr(254)),
  96     # (r'\x00ffffffffffffff', '\377', SUCCEED, 'found', chr(255)),
  97     # (r'\x00f', '\017', SUCCEED, 'found', chr(15)),
  98     # (r'\x00fe', '\376', SUCCEED, 'found', chr(254)),
  99
 100     (r"^\w+=(\\[\000-\277]|[^\n\\])*", "SRC=eval.c g.c blah blah blah \\\\\n\tapes.c",
 101      SUCCEED, 'found', "SRC=eval.c g.c blah blah blah \\\\"),
 102
 103     # Test that . only matches \n in DOTALL mode
 104     ('a.b', 'acb', SUCCEED, 'found', 'acb'),
 105     ('a.b', 'a\nb', FAIL),
 106     ('a.*b', 'acc\nccb', FAIL),
 107     ('a.{4,5}b', 'acc\nccb', FAIL),
 108     ('a.b', 'a\rb', SUCCEED, 'found', 'a\rb'),
 109     ('a.b(?s)', 'a\nb', SUCCEED, 'found', 'a\nb'),
 110     ('a.*(?s)b', 'acc\nccb', SUCCEED, 'found', 'acc\nccb'),
 111     ('(?s)a.{4,5}b', 'acc\nccb', SUCCEED, 'found', 'acc\nccb'),
 112     ('(?s)a.b', 'a\nb', SUCCEED, 'found', 'a\nb'),
 113
 114     (')', '', SYNTAX_ERROR),           # Unmatched right bracket
 115     ('', '', SUCCEED, 'found', ''),    # Empty pattern
 116     ('abc', 'abc', SUCCEED, 'found', 'abc'),
 117     ('abc', 'xbc', FAIL),
 118     ('abc', 'axc', FAIL),
 119     ('abc', 'abx', FAIL),
 120     ('abc', 'xabcy', SUCCEED, 'found', 'abc'),
 121     ('abc', 'ababc', SUCCEED, 'found', 'abc'),
 122     ('ab*c', 'abc', SUCCEED, 'found', 'abc'),
 123     ('ab*bc', 'abc', SUCCEED, 'found', 'abc'),
 124     ('ab*bc', 'abbc', SUCCEED, 'found', 'abbc'),
 125     ('ab*bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
 126     ('ab+bc', 'abbc', SUCCEED, 'found', 'abbc'),
 127     ('ab+bc', 'abc', FAIL),
 128     ('ab+bc', 'abq', FAIL),
 129     ('ab+bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
 130     ('ab?bc', 'abbc', SUCCEED, 'found', 'abbc'),
 131     ('ab?bc', 'abc', SUCCEED, 'found', 'abc'),
 132     ('ab?bc', 'abbbbc', FAIL),
 133     ('ab?c', 'abc', SUCCEED, 'found', 'abc'),
 134     ('^abc$', 'abc', SUCCEED, 'found', 'abc'),
 135     ('^abc$', 'abcc', FAIL),
 136     ('^abc', 'abcc', SUCCEED, 'found', 'abc'),
 137     ('^abc$', 'aabc', FAIL),
 138     ('abc$', 'aabc', SUCCEED, 'found', 'abc'),
 139     ('^', 'abc', SUCCEED, 'found+"-"', '-'),
 140     ('$', 'abc', SUCCEED, 'found+"-"', '-'),
 141     ('a.c', 'abc', SUCCEED, 'found', 'abc'),
 142     ('a.c', 'axc', SUCCEED, 'found', 'axc'),
 143     ('a.*c', 'axyzc', SUCCEED, 'found', 'axyzc'),
 144     ('a.*c', 'axyzd', FAIL),
 145     ('a[bc]d', 'abc', FAIL),
 146     ('a[bc]d', 'abd', SUCCEED, 'found', 'abd'),
 147     ('a[b-d]e', 'abd', FAIL),
 148     ('a[b-d]e', 'ace', SUCCEED, 'found', 'ace'),
 149     ('a[b-d]', 'aac', SUCCEED, 'found', 'ac'),
 150     ('a[-b]', 'a-', SUCCEED, 'found', 'a-'),
 151     ('a[\\-b]', 'a-', SUCCEED, 'found', 'a-'),
 152     # NOTE: not an error under PCRE/PRE:
 153     # ('a[b-]', 'a-', SYNTAX_ERROR),
 154     ('a[]b', '-', SYNTAX_ERROR),
 155     ('a[', '-', SYNTAX_ERROR),
 156     ('a\\', '-', SYNTAX_ERROR),
 157     ('abc)', '-', SYNTAX_ERROR),
 158     ('(abc', '-', SYNTAX_ERROR),
 159     ('a]', 'a]', SUCCEED, 'found', 'a]'),
 160     ('a[]]b', 'a]b', SUCCEED, 'found', 'a]b'),
 161     ('a[\]]b', 'a]b', SUCCEED, 'found', 'a]b'),
 162     ('a[^bc]d', 'aed', SUCCEED, 'found', 'aed'),
 163     ('a[^bc]d', 'abd', FAIL),
 164     ('a[^-b]c', 'adc', SUCCEED, 'found', 'adc'),
 165     ('a[^-b]c', 'a-c', FAIL),
 166     ('a[^]b]c', 'a]c', FAIL),
 167     ('a[^]b]c', 'adc', SUCCEED, 'found', 'adc'),
 168     ('\\ba\\b', 'a-', SUCCEED, '"-"', '-'),
 169     ('\\ba\\b', '-a', SUCCEED, '"-"', '-'),
 170     ('\\ba\\b', '-a-', SUCCEED, '"-"', '-'),
 171     ('\\by\\b', 'xy', FAIL),
 172     ('\\by\\b', 'yz', FAIL),
 173     ('\\by\\b', 'xyz', FAIL),
 174     ('x\\b', 'xyz', FAIL),
 175     ('x\\B', 'xyz', SUCCEED, '"-"', '-'),
 176     ('\\Bz', 'xyz', SUCCEED, '"-"', '-'),
 177     ('z\\B', 'xyz', FAIL),
 178     ('\\Bx', 'xyz', FAIL),
 179     ('\\Ba\\B', 'a-', FAIL, '"-"', '-'),
 180     ('\\Ba\\B', '-a', FAIL, '"-"', '-'),
 181     ('\\Ba\\B', '-a-', FAIL, '"-"', '-'),
 182     ('\\By\\B', 'xy', FAIL),
 183     ('\\By\\B', 'yz', FAIL),
 184     ('\\By\\b', 'xy', SUCCEED, '"-"', '-'),
 185     ('\\by\\B', 'yz', SUCCEED, '"-"', '-'),
 186     ('\\By\\B', 'xyz', SUCCEED, '"-"', '-'),
 187     ('ab|cd', 'abc', SUCCEED, 'found', 'ab'),
 188     ('ab|cd', 'abcd', SUCCEED, 'found', 'ab'),
 189     ('()ef', 'def', SUCCEED, 'found+"-"+g1', 'ef-'),
 190     ('$b', 'b', FAIL),
 191     ('a\\(b', 'a(b', SUCCEED, 'found+"-"+g1', 'a(b-Error'),
 192     ('a\\(*b', 'ab', SUCCEED, 'found', 'ab'),
 193     ('a\\(*b', 'a((b', SUCCEED, 'found', 'a((b'),
 194     ('a\\\\b', 'a\\b', SUCCEED, 'found', 'a\\b'),
 195     ('((a))', 'abc', SUCCEED, 'found+"-"+g1+"-"+g2', 'a-a-a'),
 196     ('(a)b(c)', 'abc', SUCCEED, 'found+"-"+g1+"-"+g2', 'abc-a-c'),
 197     ('a+b+c', 'aabbabc', SUCCEED, 'found', 'abc'),
 198     ('(a+|b)*', 'ab', SUCCEED, 'found+"-"+g1', 'ab-b'),
 199     ('(a+|b)+', 'ab', SUCCEED, 'found+"-"+g1', 'ab-b'),
 200     ('(a+|b)?', 'ab', SUCCEED, 'found+"-"+g1', 'a-a'),
 201     (')(', '-', SYNTAX_ERROR),
 202     ('[^ab]*', 'cde', SUCCEED, 'found', 'cde'),
 203     ('abc', '', FAIL),
 204     ('a*', '', SUCCEED, 'found', ''),
 205     ('a|b|c|d|e', 'e', SUCCEED, 'found', 'e'),
 206     ('(a|b|c|d|e)f', 'ef', SUCCEED, 'found+"-"+g1', 'ef-e'),
 207     ('abcd*efg', 'abcdefg', SUCCEED, 'found', 'abcdefg'),
 208     ('ab*', 'xabyabbbz', SUCCEED, 'found', 'ab'),
 209     ('ab*', 'xayabbbz', SUCCEED, 'found', 'a'),
 210     ('(ab|cd)e', 'abcde', SUCCEED, 'found+"-"+g1', 'cde-cd'),
 211     ('[abhgefdc]ij', 'hij', SUCCEED, 'found', 'hij'),
 212     ('^(ab|cd)e', 'abcde', FAIL, 'xg1y', 'xy'),
 213     ('(abc|)ef', 'abcdef', SUCCEED, 'found+"-"+g1', 'ef-'),
 214     ('(a|b)c*d', 'abcd', SUCCEED, 'found+"-"+g1', 'bcd-b'),
 215     ('(ab|ab*)bc', 'abc', SUCCEED, 'found+"-"+g1', 'abc-a'),
 216     ('a([bc]*)c*', 'abc', SUCCEED, 'found+"-"+g1', 'abc-bc'),
 217     ('a([bc]*)(c*d)', 'abcd', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcd-bc-d'),
 218     ('a([bc]+)(c*d)', 'abcd', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcd-bc-d'),
 219     ('a([bc]*)(c+d)', 'abcd', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcd-b-cd'),
 220     ('a[bcd]*dcdcde', 'adcdcde', SUCCEED, 'found', 'adcdcde'),
 221     ('a[bcd]+dcdcde', 'adcdcde', FAIL),
 222     ('(ab|a)b*c', 'abc', SUCCEED, 'found+"-"+g1', 'abc-ab'),
 223     ('((a)(b)c)(d)', 'abcd', SUCCEED, 'g1+"-"+g2+"-"+g3+"-"+g4', 'abc-a-b-d'),
 224     ('[a-zA-Z_][a-zA-Z0-9_]*', 'alpha', SUCCEED, 'found', 'alpha'),
 225     ('^a(bc+|b[eh])g|.h$', 'abh', SUCCEED, 'found+"-"+g1', 'bh-None'),
 226     ('(bc+d$|ef*g.|h?i(j|k))', 'effgz', SUCCEED, 'found+"-"+g1+"-"+g2', 'effgz-effgz-None'),
 227     ('(bc+d$|ef*g.|h?i(j|k))', 'ij', SUCCEED, 'found+"-"+g1+"-"+g2', 'ij-ij-j'),
 228     ('(bc+d$|ef*g.|h?i(j|k))', 'effg', FAIL),
 229     ('(bc+d$|ef*g.|h?i(j|k))', 'bcdd', FAIL),
 230     ('(bc+d$|ef*g.|h?i(j|k))', 'reffgz', SUCCEED, 'found+"-"+g1+"-"+g2', 'effgz-effgz-None'),
 231     ('(((((((((a)))))))))', 'a', SUCCEED, 'found', 'a'),
 232     ('multiple words of text', 'uh-uh', FAIL),
 233     ('multiple words', 'multiple words, yeah', SUCCEED, 'found', 'multiple words'),
 234     ('(.*)c(.*)', 'abcde', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcde-ab-de'),
 235     ('\\((.*), (.*)\\)', '(a, b)', SUCCEED, 'g2+"-"+g1', 'b-a'),
 236     ('[k]', 'ab', FAIL),
 237     ('a[-]?c', 'ac', SUCCEED, 'found', 'ac'),
 238     ('(abc)\\1', 'abcabc', SUCCEED, 'g1', 'abc'),
 239     ('([a-c]*)\\1', 'abcabc', SUCCEED, 'g1', 'abc'),
 240     ('^(.+)?B', 'AB', SUCCEED, 'g1', 'A'),
 241     ('(a+).\\1$', 'aaaaa', SUCCEED, 'found+"-"+g1', 'aaaaa-aa'),
 242     ('^(a+).\\1$', 'aaaa', FAIL),
 243     ('(abc)\\1', 'abcabc', SUCCEED, 'found+"-"+g1', 'abcabc-abc'),
 244     ('([a-c]+)\\1', 'abcabc', SUCCEED, 'found+"-"+g1', 'abcabc-abc'),
 245     ('(a)\\1', 'aa', SUCCEED, 'found+"-"+g1', 'aa-a'),
 246     ('(a+)\\1', 'aa', SUCCEED, 'found+"-"+g1', 'aa-a'),
 247     ('(a+)+\\1', 'aa', SUCCEED, 'found+"-"+g1', 'aa-a'),
 248     ('(a).+\\1', 'aba', SUCCEED, 'found+"-"+g1', 'aba-a'),
 249     ('(a)ba*\\1', 'aba', SUCCEED, 'found+"-"+g1', 'aba-a'),
 250     ('(aa|a)a\\1$', 'aaa', SUCCEED, 'found+"-"+g1', 'aaa-a'),
 251     ('(a|aa)a\\1$', 'aaa', SUCCEED, 'found+"-"+g1', 'aaa-a'),
 252     ('(a+)a\\1$', 'aaa', SUCCEED, 'found+"-"+g1', 'aaa-a'),
 253     ('([abc]*)\\1', 'abcabc', SUCCEED, 'found+"-"+g1', 'abcabc-abc'),
 254     ('(a)(b)c|ab', 'ab', SUCCEED, 'found+"-"+g1+"-"+g2', 'ab-None-None'),
 255     ('(a)+x', 'aaax', SUCCEED, 'found+"-"+g1', 'aaax-a'),
 256     ('([ac])+x', 'aacx', SUCCEED, 'found+"-"+g1', 'aacx-c'),
 257     ('([^/]*/)*sub1/', 'd:msgs/tdir/sub1/trial/away.cpp', SUCCEED, 'found+"-"+g1', 'd:msgs/tdir/sub1/-tdir/'),
 258     ('([^.]*)\\.([^:]*):[T ]+(.*)', 'track1.title:TBlah blah blah', SUCCEED, 'found+"-"+g1+"-"+g2+"-"+g3', 'track1.title:TBlah blah blah-track1-title-Blah blah blah'),
 259     ('([^N]*N)+', 'abNNxyzN', SUCCEED, 'found+"-"+g1', 'abNNxyzN-xyzN'),
 260     ('([^N]*N)+', 'abNNxyz', SUCCEED, 'found+"-"+g1', 'abNN-N'),
 261     ('([abc]*)x', 'abcx', SUCCEED, 'found+"-"+g1', 'abcx-abc'),
 262     ('([abc]*)x', 'abc', FAIL),
 263     ('([xyz]*)x', 'abcx', SUCCEED, 'found+"-"+g1', 'x-'),
 264     ('(a)+b|aac', 'aac', SUCCEED, 'found+"-"+g1', 'aac-None'),
 265
 266     # Test symbolic groups
 267
 268     ('(?P<i d>aaa)a', 'aaaa', SYNTAX_ERROR),
 269     ('(?P<id>aaa)a', 'aaaa', SUCCEED, 'found+"-"+id', 'aaaa-aaa'),
 270     ('(?P<id>aa)(?P=id)', 'aaaa', SUCCEED, 'found+"-"+id', 'aaaa-aa'),
 271     ('(?P<id>aa)(?P=xd)', 'aaaa', SYNTAX_ERROR),
 272
 273     # Test octal escapes/memory references
 274
 275     ('\\1', 'a', SYNTAX_ERROR),
 276     ('\\09', chr(0) + '9', SUCCEED, 'found', chr(0) + '9'),
 277     ('\\141', 'a', SUCCEED, 'found', 'a'),
 278     ('(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)\\119', 'abcdefghijklk9', SUCCEED, 'found+"-"+g11', 'abcdefghijklk9-k'),
 279
 280     # All tests from Perl
 281
 282     ('abc', 'abc', SUCCEED, 'found', 'abc'),
 283     ('abc', 'xbc', FAIL),
 284     ('abc', 'axc', FAIL),
 285     ('abc', 'abx', FAIL),
 286     ('abc', 'xabcy', SUCCEED, 'found', 'abc'),
 287     ('abc', 'ababc', SUCCEED, 'found', 'abc'),
 288     ('ab*c', 'abc', SUCCEED, 'found', 'abc'),
 289     ('ab*bc', 'abc', SUCCEED, 'found', 'abc'),
 290     ('ab*bc', 'abbc', SUCCEED, 'found', 'abbc'),
 291     ('ab*bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
 292     ('ab{0,}bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
 293     ('ab+bc', 'abbc', SUCCEED, 'found', 'abbc'),
 294     ('ab+bc', 'abc', FAIL),
 295     ('ab+bc', 'abq', FAIL),
 296     ('ab{1,}bc', 'abq', FAIL),
 297     ('ab+bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
 298     ('ab{1,}bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
 299     ('ab{1,3}bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
 300     ('ab{3,4}bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
 301     ('ab{4,5}bc', 'abbbbc', FAIL),
 302     ('ab?bc', 'abbc', SUCCEED, 'found', 'abbc'),
 303     ('ab?bc', 'abc', SUCCEED, 'found', 'abc'),
 304     ('ab{0,1}bc', 'abc', SUCCEED, 'found', 'abc'),
 305     ('ab?bc', 'abbbbc', FAIL),
 306     ('ab?c', 'abc', SUCCEED, 'found', 'abc'),
 307     ('ab{0,1}c', 'abc', SUCCEED, 'found', 'abc'),
 308     ('^abc$', 'abc', SUCCEED, 'found', 'abc'),
 309     ('^abc$', 'abcc', FAIL),
 310     ('^abc', 'abcc', SUCCEED, 'found', 'abc'),
 311     ('^abc$', 'aabc', FAIL),
 312     ('abc$', 'aabc', SUCCEED, 'found', 'abc'),
 313     ('^', 'abc', SUCCEED, 'found', ''),
 314     ('$', 'abc', SUCCEED, 'found', ''),
 315     ('a.c', 'abc', SUCCEED, 'found', 'abc'),
 316     ('a.c', 'axc', SUCCEED, 'found', 'axc'),
 317     ('a.*c', 'axyzc', SUCCEED, 'found', 'axyzc'),
 318     ('a.*c', 'axyzd', FAIL),
 319     ('a[bc]d', 'abc', FAIL),
 320     ('a[bc]d', 'abd', SUCCEED, 'found', 'abd'),
 321     ('a[b-d]e', 'abd', FAIL),
 322     ('a[b-d]e', 'ace', SUCCEED, 'found', 'ace'),
 323     ('a[b-d]', 'aac', SUCCEED, 'found', 'ac'),
 324     ('a[-b]', 'a-', SUCCEED, 'found', 'a-'),
 325     ('a[b-]', 'a-', SUCCEED, 'found', 'a-'),
 326     ('a[b-a]', '-', SYNTAX_ERROR),
 327     ('a[]b', '-', SYNTAX_ERROR),
 328     ('a[', '-', SYNTAX_ERROR),
 329     ('a]', 'a]', SUCCEED, 'found', 'a]'),
 330     ('a[]]b', 'a]b', SUCCEED, 'found', 'a]b'),
 331     ('a[^bc]d', 'aed', SUCCEED, 'found', 'aed'),
 332     ('a[^bc]d', 'abd', FAIL),
 333     ('a[^-b]c', 'adc', SUCCEED, 'found', 'adc'),
 334     ('a[^-b]c', 'a-c', FAIL),
 335     ('a[^]b]c', 'a]c', FAIL),
 336     ('a[^]b]c', 'adc', SUCCEED, 'found', 'adc'),
 337     ('ab|cd', 'abc', SUCCEED, 'found', 'ab'),
 338     ('ab|cd', 'abcd', SUCCEED, 'found', 'ab'),
 339     ('()ef', 'def', SUCCEED, 'found+"-"+g1', 'ef-'),
 340     ('*a', '-', SYNTAX_ERROR),
 341     ('(*)b', '-', SYNTAX_ERROR),
 342     ('$b', 'b', FAIL),
 343     ('a\\', '-', SYNTAX_ERROR),
 344     ('a\\(b', 'a(b', SUCCEED, 'found+"-"+g1', 'a(b-Error'),
 345     ('a\\(*b', 'ab', SUCCEED, 'found', 'ab'),
 346     ('a\\(*b', 'a((b', SUCCEED, 'found', 'a((b'),
 347     ('a\\\\b', 'a\\b', SUCCEED, 'found', 'a\\b'),
 348     ('abc)', '-', SYNTAX_ERROR),
 349     ('(abc', '-', SYNTAX_ERROR),
 350     ('((a))', 'abc', SUCCEED, 'found+"-"+g1+"-"+g2', 'a-a-a'),
 351     ('(a)b(c)', 'abc', SUCCEED, 'found+"-"+g1+"-"+g2', 'abc-a-c'),
 352     ('a+b+c', 'aabbabc', SUCCEED, 'found', 'abc'),
 353     ('a{1,}b{1,}c', 'aabbabc', SUCCEED, 'found', 'abc'),
 354     ('a**', '-', SYNTAX_ERROR),
 355     ('a.+?c', 'abcabc', SUCCEED, 'found', 'abc'),
 356     ('(a+|b)*', 'ab', SUCCEED, 'found+"-"+g1', 'ab-b'),
 357     ('(a+|b){0,}', 'ab', SUCCEED, 'found+"-"+g1', 'ab-b'),
 358     ('(a+|b)+', 'ab', SUCCEED, 'found+"-"+g1', 'ab-b'),
 359     ('(a+|b){1,}', 'ab', SUCCEED, 'found+"-"+g1', 'ab-b'),
 360     ('(a+|b)?', 'ab', SUCCEED, 'found+"-"+g1', 'a-a'),
 361     ('(a+|b){0,1}', 'ab', SUCCEED, 'found+"-"+g1', 'a-a'),
 362     (')(', '-', SYNTAX_ERROR),
 363     ('[^ab]*', 'cde', SUCCEED, 'found', 'cde'),
 364     ('abc', '', FAIL),
 365     ('a*', '', SUCCEED, 'found', ''),
 366     ('([abc])*d', 'abbbcd', SUCCEED, 'found+"-"+g1', 'abbbcd-c'),
 367     ('([abc])*bcd', 'abcd', SUCCEED, 'found+"-"+g1', 'abcd-a'),
 368     ('a|b|c|d|e', 'e', SUCCEED, 'found', 'e'),
 369     ('(a|b|c|d|e)f', 'ef', SUCCEED, 'found+"-"+g1', 'ef-e'),
 370     ('abcd*efg', 'abcdefg', SUCCEED, 'found', 'abcdefg'),
 371     ('ab*', 'xabyabbbz', SUCCEED, 'found', 'ab'),
 372     ('ab*', 'xayabbbz', SUCCEED, 'found', 'a'),
 373     ('(ab|cd)e', 'abcde', SUCCEED, 'found+"-"+g1', 'cde-cd'),
 374     ('[abhgefdc]ij', 'hij', SUCCEED, 'found', 'hij'),
 375     ('^(ab|cd)e', 'abcde', FAIL),
 376     ('(abc|)ef', 'abcdef', SUCCEED, 'found+"-"+g1', 'ef-'),
 377     ('(a|b)c*d', 'abcd', SUCCEED, 'found+"-"+g1', 'bcd-b'),
 378     ('(ab|ab*)bc', 'abc', SUCCEED, 'found+"-"+g1', 'abc-a'),
 379     ('a([bc]*)c*', 'abc', SUCCEED, 'found+"-"+g1', 'abc-bc'),
 380     ('a([bc]*)(c*d)', 'abcd', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcd-bc-d'),
 381     ('a([bc]+)(c*d)', 'abcd', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcd-bc-d'),
 382     ('a([bc]*)(c+d)', 'abcd', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcd-b-cd'),
 383     ('a[bcd]*dcdcde', 'adcdcde', SUCCEED, 'found', 'adcdcde'),
 384     ('a[bcd]+dcdcde', 'adcdcde', FAIL),
 385     ('(ab|a)b*c', 'abc', SUCCEED, 'found+"-"+g1', 'abc-ab'),
 386     ('((a)(b)c)(d)', 'abcd', SUCCEED, 'g1+"-"+g2+"-"+g3+"-"+g4', 'abc-a-b-d'),
 387     ('[a-zA-Z_][a-zA-Z0-9_]*', 'alpha', SUCCEED, 'found', 'alpha'),
 388     ('^a(bc+|b[eh])g|.h$', 'abh', SUCCEED, 'found+"-"+g1', 'bh-None'),
 389     ('(bc+d$|ef*g.|h?i(j|k))', 'effgz', SUCCEED, 'found+"-"+g1+"-"+g2', 'effgz-effgz-None'),
 390     ('(bc+d$|ef*g.|h?i(j|k))', 'ij', SUCCEED, 'found+"-"+g1+"-"+g2', 'ij-ij-j'),
 391     ('(bc+d$|ef*g.|h?i(j|k))', 'effg', FAIL),
 392     ('(bc+d$|ef*g.|h?i(j|k))', 'bcdd', FAIL),
 393     ('(bc+d$|ef*g.|h?i(j|k))', 'reffgz', SUCCEED, 'found+"-"+g1+"-"+g2', 'effgz-effgz-None'),
 394     ('((((((((((a))))))))))', 'a', SUCCEED, 'g10', 'a'),
 395     ('((((((((((a))))))))))\\10', 'aa', SUCCEED, 'found', 'aa'),
 396 # Python does not have the same rules for \\41 so this is a syntax error
 397 #    ('((((((((((a))))))))))\\41', 'aa', FAIL),
 398 #    ('((((((((((a))))))))))\\41', 'a!', SUCCEED, 'found', 'a!'),
 399     ('((((((((((a))))))))))\\41', '', SYNTAX_ERROR),
 400     ('(?i)((((((((((a))))))))))\\41', '', SYNTAX_ERROR),
 401     ('(((((((((a)))))))))', 'a', SUCCEED, 'found', 'a'),
 402     ('multiple words of text', 'uh-uh', FAIL),
 403     ('multiple words', 'multiple words, yeah', SUCCEED, 'found', 'multiple words'),
 404     ('(.*)c(.*)', 'abcde', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcde-ab-de'),
 405     ('\\((.*), (.*)\\)', '(a, b)', SUCCEED, 'g2+"-"+g1', 'b-a'),
 406     ('[k]', 'ab', FAIL),
 407     ('a[-]?c', 'ac', SUCCEED, 'found', 'ac'),
 408     ('(abc)\\1', 'abcabc', SUCCEED, 'g1', 'abc'),
 409     ('([a-c]*)\\1', 'abcabc', SUCCEED, 'g1', 'abc'),
 410     ('(?i)abc', 'ABC', SUCCEED, 'found', 'ABC'),
 411     ('(?i)abc', 'XBC', FAIL),
 412     ('(?i)abc', 'AXC', FAIL),
 413     ('(?i)abc', 'ABX', FAIL),
 414     ('(?i)abc', 'XABCY', SUCCEED, 'found', 'ABC'),
 415     ('(?i)abc', 'ABABC', SUCCEED, 'found', 'ABC'),
 416     ('(?i)ab*c', 'ABC', SUCCEED, 'found', 'ABC'),
 417     ('(?i)ab*bc', 'ABC', SUCCEED, 'found', 'ABC'),
 418     ('(?i)ab*bc', 'ABBC', SUCCEED, 'found', 'ABBC'),
 419     ('(?i)ab*?bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
 420     ('(?i)ab{0,}?bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
 421     ('(?i)ab+?bc', 'ABBC', SUCCEED, 'found', 'ABBC'),
 422     ('(?i)ab+bc', 'ABC', FAIL),
 423     ('(?i)ab+bc', 'ABQ', FAIL),
 424     ('(?i)ab{1,}bc', 'ABQ', FAIL),
 425     ('(?i)ab+bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
 426     ('(?i)ab{1,}?bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
 427     ('(?i)ab{1,3}?bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
 428     ('(?i)ab{3,4}?bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
 429     ('(?i)ab{4,5}?bc', 'ABBBBC', FAIL),
 430     ('(?i)ab??bc', 'ABBC', SUCCEED, 'found', 'ABBC'),
 431     ('(?i)ab??bc', 'ABC', SUCCEED, 'found', 'ABC'),
 432     ('(?i)ab{0,1}?bc', 'ABC', SUCCEED, 'found', 'ABC'),
 433     ('(?i)ab??bc', 'ABBBBC', FAIL),
 434     ('(?i)ab??c', 'ABC', SUCCEED, 'found', 'ABC'),
 435     ('(?i)ab{0,1}?c', 'ABC', SUCCEED, 'found', 'ABC'),
 436     ('(?i)^abc$', 'ABC', SUCCEED, 'found', 'ABC'),
 437     ('(?i)^abc$', 'ABCC', FAIL),
 438     ('(?i)^abc', 'ABCC', SUCCEED, 'found', 'ABC'),
 439     ('(?i)^abc$', 'AABC', FAIL),
 440     ('(?i)abc$', 'AABC', SUCCEED, 'found', 'ABC'),
 441     ('(?i)^', 'ABC', SUCCEED, 'found', ''),
 442     ('(?i)$', 'ABC', SUCCEED, 'found', ''),
 443     ('(?i)a.c', 'ABC', SUCCEED, 'found', 'ABC'),
 444     ('(?i)a.c', 'AXC', SUCCEED, 'found', 'AXC'),
 445     ('(?i)a.*?c', 'AXYZC', SUCCEED, 'found', 'AXYZC'),
 446     ('(?i)a.*c', 'AXYZD', FAIL),
 447     ('(?i)a[bc]d', 'ABC', FAIL),
 448     ('(?i)a[bc]d', 'ABD', SUCCEED, 'found', 'ABD'),
 449     ('(?i)a[b-d]e', 'ABD', FAIL),
 450     ('(?i)a[b-d]e', 'ACE', SUCCEED, 'found', 'ACE'),
 451     ('(?i)a[b-d]', 'AAC', SUCCEED, 'found', 'AC'),
 452     ('(?i)a[-b]', 'A-', SUCCEED, 'found', 'A-'),
 453     ('(?i)a[b-]', 'A-', SUCCEED, 'found', 'A-'),
 454     ('(?i)a[b-a]', '-', SYNTAX_ERROR),
 455     ('(?i)a[]b', '-', SYNTAX_ERROR),
 456     ('(?i)a[', '-', SYNTAX_ERROR),
 457     ('(?i)a]', 'A]', SUCCEED, 'found', 'A]'),
 458     ('(?i)a[]]b', 'A]B', SUCCEED, 'found', 'A]B'),
 459     ('(?i)a[^bc]d', 'AED', SUCCEED, 'found', 'AED'),
 460     ('(?i)a[^bc]d', 'ABD', FAIL),
 461     ('(?i)a[^-b]c', 'ADC', SUCCEED, 'found', 'ADC'),
 462     ('(?i)a[^-b]c', 'A-C', FAIL),
 463     ('(?i)a[^]b]c', 'A]C', FAIL),
 464     ('(?i)a[^]b]c', 'ADC', SUCCEED, 'found', 'ADC'),
 465     ('(?i)ab|cd', 'ABC', SUCCEED, 'found', 'AB'),
 466     ('(?i)ab|cd', 'ABCD', SUCCEED, 'found', 'AB'),
 467     ('(?i)()ef', 'DEF', SUCCEED, 'found+"-"+g1', 'EF-'),
 468     ('(?i)*a', '-', SYNTAX_ERROR),
 469     ('(?i)(*)b', '-', SYNTAX_ERROR),
 470     ('(?i)$b', 'B', FAIL),
 471     ('(?i)a\\', '-', SYNTAX_ERROR),
 472     ('(?i)a\\(b', 'A(B', SUCCEED, 'found+"-"+g1', 'A(B-Error'),
 473     ('(?i)a\\(*b', 'AB', SUCCEED, 'found', 'AB'),
 474     ('(?i)a\\(*b', 'A((B', SUCCEED, 'found', 'A((B'),
 475     ('(?i)a\\\\b', 'A\\B', SUCCEED, 'found', 'A\\B'),
 476     ('(?i)abc)', '-', SYNTAX_ERROR),
 477     ('(?i)(abc', '-', SYNTAX_ERROR),
 478     ('(?i)((a))', 'ABC', SUCCEED, 'found+"-"+g1+"-"+g2', 'A-A-A'),
 479     ('(?i)(a)b(c)', 'ABC', SUCCEED, 'found+"-"+g1+"-"+g2', 'ABC-A-C'),
 480     ('(?i)a+b+c', 'AABBABC', SUCCEED, 'found', 'ABC'),
 481     ('(?i)a{1,}b{1,}c', 'AABBABC', SUCCEED, 'found', 'ABC'),
 482     ('(?i)a**', '-', SYNTAX_ERROR),
 483     ('(?i)a.+?c', 'ABCABC', SUCCEED, 'found', 'ABC'),
 484     ('(?i)a.*?c', 'ABCABC', SUCCEED, 'found', 'ABC'),
 485     ('(?i)a.{0,5}?c', 'ABCABC', SUCCEED, 'found', 'ABC'),
 486     ('(?i)(a+|b)*', 'AB', SUCCEED, 'found+"-"+g1', 'AB-B'),
 487     ('(?i)(a+|b){0,}', 'AB', SUCCEED, 'found+"-"+g1', 'AB-B'),
 488     ('(?i)(a+|b)+', 'AB', SUCCEED, 'found+"-"+g1', 'AB-B'),
 489     ('(?i)(a+|b){1,}', 'AB', SUCCEED, 'found+"-"+g1', 'AB-B'),
 490     ('(?i)(a+|b)?', 'AB', SUCCEED, 'found+"-"+g1', 'A-A'),
 491     ('(?i)(a+|b){0,1}', 'AB', SUCCEED, 'found+"-"+g1', 'A-A'),
 492     ('(?i)(a+|b){0,1}?', 'AB', SUCCEED, 'found+"-"+g1', '-None'),
 493     ('(?i))(', '-', SYNTAX_ERROR),
 494     ('(?i)[^ab]*', 'CDE', SUCCEED, 'found', 'CDE'),
 495     ('(?i)abc', '', FAIL),
 496     ('(?i)a*', '', SUCCEED, 'found', ''),
 497     ('(?i)([abc])*d', 'ABBBCD', SUCCEED, 'found+"-"+g1', 'ABBBCD-C'),
 498     ('(?i)([abc])*bcd', 'ABCD', SUCCEED, 'found+"-"+g1', 'ABCD-A'),
 499     ('(?i)a|b|c|d|e', 'E', SUCCEED, 'found', 'E'),
 500     ('(?i)(a|b|c|d|e)f', 'EF', SUCCEED, 'found+"-"+g1', 'EF-E'),
 501     ('(?i)abcd*efg', 'ABCDEFG', SUCCEED, 'found', 'ABCDEFG'),
 502     ('(?i)ab*', 'XABYABBBZ', SUCCEED, 'found', 'AB'),
 503     ('(?i)ab*', 'XAYABBBZ', SUCCEED, 'found', 'A'),
 504     ('(?i)(ab|cd)e', 'ABCDE', SUCCEED, 'found+"-"+g1', 'CDE-CD'),
 505     ('(?i)[abhgefdc]ij', 'HIJ', SUCCEED, 'found', 'HIJ'),
 506     ('(?i)^(ab|cd)e', 'ABCDE', FAIL),
 507     ('(?i)(abc|)ef', 'ABCDEF', SUCCEED, 'found+"-"+g1', 'EF-'),
 508     ('(?i)(a|b)c*d', 'ABCD', SUCCEED, 'found+"-"+g1', 'BCD-B'),
 509     ('(?i)(ab|ab*)bc', 'ABC', SUCCEED, 'found+"-"+g1', 'ABC-A'),
 510     ('(?i)a([bc]*)c*', 'ABC', SUCCEED, 'found+"-"+g1', 'ABC-BC'),
 511     ('(?i)a([bc]*)(c*d)', 'ABCD', SUCCEED, 'found+"-"+g1+"-"+g2', 'ABCD-BC-D'),
 512     ('(?i)a([bc]+)(c*d)', 'ABCD', SUCCEED, 'found+"-"+g1+"-"+g2', 'ABCD-BC-D'),
 513     ('(?i)a([bc]*)(c+d)', 'ABCD', SUCCEED, 'found+"-"+g1+"-"+g2', 'ABCD-B-CD'),
 514     ('(?i)a[bcd]*dcdcde', 'ADCDCDE', SUCCEED, 'found', 'ADCDCDE'),
 515     ('(?i)a[bcd]+dcdcde', 'ADCDCDE', FAIL),
 516     ('(?i)(ab|a)b*c', 'ABC', SUCCEED, 'found+"-"+g1', 'ABC-AB'),
 517     ('(?i)((a)(b)c)(d)', 'ABCD', SUCCEED, 'g1+"-"+g2+"-"+g3+"-"+g4', 'ABC-A-B-D'),
 518     ('(?i)[a-zA-Z_][a-zA-Z0-9_]*', 'ALPHA', SUCCEED, 'found', 'ALPHA'),
 519     ('(?i)^a(bc+|b[eh])g|.h$', 'ABH', SUCCEED, 'found+"-"+g1', 'BH-None'),
 520     ('(?i)(bc+d$|ef*g.|h?i(j|k))', 'EFFGZ', SUCCEED, 'found+"-"+g1+"-"+g2', 'EFFGZ-EFFGZ-None'),
 521     ('(?i)(bc+d$|ef*g.|h?i(j|k))', 'IJ', SUCCEED, 'found+"-"+g1+"-"+g2', 'IJ-IJ-J'),
 522     ('(?i)(bc+d$|ef*g.|h?i(j|k))', 'EFFG', FAIL),
 523     ('(?i)(bc+d$|ef*g.|h?i(j|k))', 'BCDD', FAIL),
 524     ('(?i)(bc+d$|ef*g.|h?i(j|k))', 'REFFGZ', SUCCEED, 'found+"-"+g1+"-"+g2', 'EFFGZ-EFFGZ-None'),
 525     ('(?i)((((((((((a))))))))))', 'A', SUCCEED, 'g10', 'A'),
 526     ('(?i)((((((((((a))))))))))\\10', 'AA', SUCCEED, 'found', 'AA'),
 527     #('(?i)((((((((((a))))))))))\\41', 'AA', FAIL),
 528     #('(?i)((((((((((a))))))))))\\41', 'A!', SUCCEED, 'found', 'A!'),
 529     ('(?i)(((((((((a)))))))))', 'A', SUCCEED, 'found', 'A'),
 530     ('(?i)(?:(?:(?:(?:(?:(?:(?:(?:(?:(a))))))))))', 'A', SUCCEED, 'g1', 'A'),
 531     ('(?i)(?:(?:(?:(?:(?:(?:(?:(?:(?:(a|b|c))))))))))', 'C', SUCCEED, 'g1', 'C'),
 532     ('(?i)multiple words of text', 'UH-UH', FAIL),
 533     ('(?i)multiple words', 'MULTIPLE WORDS, YEAH', SUCCEED, 'found', 'MULTIPLE WORDS'),
 534     ('(?i)(.*)c(.*)', 'ABCDE', SUCCEED, 'found+"-"+g1+"-"+g2', 'ABCDE-AB-DE'),
 535     ('(?i)\\((.*), (.*)\\)', '(A, B)', SUCCEED, 'g2+"-"+g1', 'B-A'),
 536     ('(?i)[k]', 'AB', FAIL),
 537 #    ('(?i)abcd', 'ABCD', SUCCEED, 'found+"-"+\\found+"-"+\\\\found', 'ABCD-$&-\\ABCD'),
 538 #    ('(?i)a(bc)d', 'ABCD', SUCCEED, 'g1+"-"+\\g1+"-"+\\\\g1', 'BC-$1-\\BC'),
 539     ('(?i)a[-]?c', 'AC', SUCCEED, 'found', 'AC'),
 540     ('(?i)(abc)\\1', 'ABCABC', SUCCEED, 'g1', 'ABC'),
 541     ('(?i)([a-c]*)\\1', 'ABCABC', SUCCEED, 'g1', 'ABC'),
 542     ('a(?!b).', 'abad', SUCCEED, 'found', 'ad'),
 543     ('a(?=d).', 'abad', SUCCEED, 'found', 'ad'),
 544     ('a(?=c|d).', 'abad', SUCCEED, 'found', 'ad'),
 545     ('a(?:b|c|d)(.)', 'ace', SUCCEED, 'g1', 'e'),
 546     ('a(?:b|c|d)*(.)', 'ace', SUCCEED, 'g1', 'e'),
 547     ('a(?:b|c|d)+?(.)', 'ace', SUCCEED, 'g1', 'e'),
 548     ('a(?:b|(c|e){1,2}?|d)+?(.)', 'ace', SUCCEED, 'g1 + g2', 'ce'),
 549     ('^(.+)?B', 'AB', SUCCEED, 'g1', 'A'),
 550
 551     # lookbehind: split by : but not if it is escaped by -.
 552     ('(?<!-):(.*?)(?<!-):', 'a:bc-:de:f', SUCCEED, 'g1', 'bc-:de' ),
 553     # escaping with \ as we know it
 554     ('(?<!\\\):(.*?)(?<!\\\):', 'a:bc\\:de:f', SUCCEED, 'g1', 'bc\\:de' ),
 555     # terminating with ' and escaping with ? as in edifact
 556     ("(?<!\\?)'(.*?)(?<!\\?)'", "a'bc?'de'f", SUCCEED, 'g1', "bc?'de" ),
 557
 558     # Comments using the (?#...) syntax
 559
 560     ('w(?# comment', 'w', SYNTAX_ERROR),
 561     ('w(?# comment 1)xy(?# comment 2)z', 'wxyz', SUCCEED, 'found', 'wxyz'),
 562
 563     # Check odd placement of embedded pattern modifiers
 564
 565     # not an error under PCRE/PRE:
 566     ('w(?i)', 'W', SUCCEED, 'found', 'W'),
 567     # ('w(?i)', 'W', SYNTAX_ERROR),
 568
 569     # Comments using the x embedded pattern modifier
 570
 571     ("""(?x)w# comment 1
 572         x y
 573         # comment 2
 574         z""", 'wxyz', SUCCEED, 'found', 'wxyz'),
 575
 576     # using the m embedded pattern modifier
 577
 578     ('^abc', """jkl
 579 abc
 580 xyz""", FAIL),
 581     ('(?m)^abc', """jkl
 582 abc
 583 xyz""", SUCCEED, 'found', 'abc'),
 584
 585     ('(?m)abc$', """jkl
 586 xyzabc
 587 123""", SUCCEED, 'found', 'abc'),
 588
 589     # using the s embedded pattern modifier
 590
 591     ('a.b', 'a\nb', FAIL),
 592     ('(?s)a.b', 'a\nb', SUCCEED, 'found', 'a\nb'),
 593
 594     # test \w, etc. both inside and outside character classes
 595
 596     ('\\w+', '--ab_cd0123--', SUCCEED, 'found', 'ab_cd0123'),
 597     ('[\\w]+', '--ab_cd0123--', SUCCEED, 'found', 'ab_cd0123'),
 598     ('\\D+', '1234abc5678', SUCCEED, 'found', 'abc'),
 599     ('[\\D]+', '1234abc5678', SUCCEED, 'found', 'abc'),
 600     ('[\\da-fA-F]+', '123abc', SUCCEED, 'found', '123abc'),
 601     # not an error under PCRE/PRE:
 602     # ('[\\d-x]', '-', SYNTAX_ERROR),
 603     (r'([\s]*)([\S]*)([\s]*)', ' testing!1972', SUCCEED, 'g3+g2+g1', 'testing!1972 '),
 604     (r'(\s*)(\S*)(\s*)', ' testing!1972', SUCCEED, 'g3+g2+g1', 'testing!1972 '),
 605
 606     (r'\xff', '\377', SUCCEED, 'found', chr(255)),
 607     # new \x semantics
 608     (r'\x00ff', '\377', FAIL),
 609     # (r'\x00ff', '\377', SUCCEED, 'found', chr(255)),
 610     (r'\t\n\v\r\f\a\g', '\t\n\v\r\f\ag', SUCCEED, 'found', '\t\n\v\r\f\ag'),
 611     ('\t\n\v\r\f\a\g', '\t\n\v\r\f\ag', SUCCEED, 'found', '\t\n\v\r\f\ag'),
 612     (r'\t\n\v\r\f\a', '\t\n\v\r\f\a', SUCCEED, 'found', chr(9)+chr(10)+chr(11)+chr(13)+chr(12)+chr(7)),
 613     (r'[\t][\n][\v][\r][\f][\b]', '\t\n\v\r\f\b', SUCCEED, 'found', '\t\n\v\r\f\b'),
 614
 615     #
 616     # post-1.5.2 additions
 617
 618     # xmllib problem
 619     (r'(([a-z]+):)?([a-z]+)$', 'smil', SUCCEED, 'g1+"-"+g2+"-"+g3', 'None-None-smil'),
 620     # bug 110866: reference to undefined group
 621     (r'((.)\1+)', '', SYNTAX_ERROR),
 622     # bug 111869: search (PRE/PCRE fails on this one, SRE doesn't)
 623     (r'.*d', 'abc\nabd', SUCCEED, 'found', 'abd'),
 624     # bug 112468: various expected syntax errors
 625     (r'(', '', SYNTAX_ERROR),
 626     (r'[\41]', '!', SUCCEED, 'found', '!'),
 627     # bug 114033: nothing to repeat
 628     (r'(x?)?', 'x', SUCCEED, 'found', 'x'),
 629     # bug 115040: rescan if flags are modified inside pattern
 630     (r' (?x)foo ', 'foo', SUCCEED, 'found', 'foo'),
 631     # bug 115618: negative lookahead
 632     (r'(?<!abc)(d.f)', 'abcdefdof', SUCCEED, 'found', 'dof'),
 633     # bug 116251: character class bug
 634     (r'[\w-]+', 'laser_beam', SUCCEED, 'found', 'laser_beam'),
 635     # bug 123769+127259: non-greedy backtracking bug
 636     (r'.*?\S *:', 'xx:', SUCCEED, 'found', 'xx:'),
 637     (r'a[ ]*?\ (\d+).*', 'a   10', SUCCEED, 'found', 'a   10'),
 638     (r'a[ ]*?\ (\d+).*', 'a    10', SUCCEED, 'found', 'a    10'),
 639     # bug 127259: \Z shouldn't depend on multiline mode
 640     (r'(?ms).*?x\s*\Z(.*)','xx\nx\n', SUCCEED, 'g1', ''),
 641     # bug 128899: uppercase literals under the ignorecase flag
 642     (r'(?i)M+', 'MMM', SUCCEED, 'found', 'MMM'),
 643     (r'(?i)m+', 'MMM', SUCCEED, 'found', 'MMM'),
 644     (r'(?i)[M]+', 'MMM', SUCCEED, 'found', 'MMM'),
 645     (r'(?i)[m]+', 'MMM', SUCCEED, 'found', 'MMM'),
 646     # bug 130748: ^* should be an error (nothing to repeat)
 647     (r'^*', '', SYNTAX_ERROR),
 648     # bug 133283: minimizing repeat problem
 649     (r'"(?:\\"|[^"])*?"', r'"\""', SUCCEED, 'found', r'"\""'),
 650     # bug 477728: minimizing repeat problem
 651     (r'^.*?$', 'one\ntwo\nthree\n', FAIL),
 652     # bug 483789: minimizing repeat problem
 653     (r'a[^>]*?b', 'a>b', FAIL),
 654     # bug 490573: minimizing repeat problem
 655     (r'^a*?$', 'foo', FAIL),
 656     # bug 470582: nested groups problem
 657     (r'^((a)c)?(ab)$', 'ab', SUCCEED, 'g1+"-"+g2+"-"+g3', 'None-None-ab'),
 658     # another minimizing repeat problem (capturing groups in assertions)
 659     ('^([ab]*?)(?=(b)?)c', 'abc', SUCCEED, 'g1+"-"+g2', 'ab-None'),
 660     ('^([ab]*?)(?!(b))c', 'abc', SUCCEED, 'g1+"-"+g2', 'ab-None'),
 661     ('^([ab]*?)(?<!(a))c', 'abc', SUCCEED, 'g1+"-"+g2', 'ab-None'),
 662 ]
 663
 664 try:
 665     u = eval("u'\N{LATIN CAPITAL LETTER A WITH DIAERESIS}'")
 666 except SyntaxError:
 667     pass
 668 else:
 669     tests.extend([
 670     # bug 410271: \b broken under locales
 671     (r'\b.\b', 'a', SUCCEED, 'found', 'a'),
 672     (r'(?u)\b.\b', u, SUCCEED, 'found', u),
 673     (r'(?u)\w', u, SUCCEED, 'found', u),
 674     ])