import sys

sys.path = ['.'] + sys.path

from test.test_support import verbose, run_unittest

import re

from re import Scanner

import sys, os, traceback

from weakref import proxy

# Misc tests from Tim Peters' re.doc

# WARNING: Don't change details in these tests if you don't know

# what you're doing. Some of these tests were carefuly modeled to

# cover most of the code.

import unittest

class ReTests(unittest.TestCase):

    def test_weakref(self):

        s = 'QabbbcR'

        x = re.compile('ab+c')

        y = proxy(x)

        self.assertEqual(x.findall('QabbbcR'), y.findall('QabbbcR'))

    def test_search_star_plus(self):

        self.assertEqual(re.search('x*', 'axx').span(0), (0, 0))

        self.assertEqual(re.search('x*', 'axx').span(), (0, 0))

        self.assertEqual(re.search('x+', 'axx').span(0), (1, 3))

        self.assertEqual(re.search('x+', 'axx').span(), (1, 3))

        self.assertEqual(re.search('x', 'aaa'), None)

        self.assertEqual(re.match('a*', 'xxx').span(0), (0, 0))

        self.assertEqual(re.match('a*', 'xxx').span(), (0, 0))

        self.assertEqual(re.match('x*', 'xxxa').span(0), (0, 3))

        self.assertEqual(re.match('x*', 'xxxa').span(), (0, 3))

        self.assertEqual(re.match('a+', 'xxx'), None)

    def bump_num(self, matchobj):

        int_value = int(matchobj.group(0))

        return str(int_value + 1)

    def test_basic_re_sub(self):

        self.assertEqual(re.sub("(?i)b+", "x", "bbbb BBBB"), 'x x')

        self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y'),

                         '9.3 -3 24x100y')

        self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y', 3),

                         '9.3 -3 23x99y')

        self.assertEqual(re.sub('.', lambda m: r"\n", 'x'), '\\n')

        self.assertEqual(re.sub('.', r"\n", 'x'), '\n')

        s = r"\1\1"

        self.assertEqual(re.sub('(.)', s, 'x'), 'xx')

        self.assertEqual(re.sub('(.)', re.escape(s), 'x'), s)

        self.assertEqual(re.sub('(.)', lambda m: s, 'x'), s)

        self.assertEqual(re.sub('(?P<a>x)', '\g<a>\g<a>', 'xx'), 'xxxx')

        self.assertEqual(re.sub('(?P<a>x)', '\g<a>\g<1>', 'xx'), 'xxxx')

        self.assertEqual(re.sub('(?P<unk>x)', '\g<unk>\g<unk>', 'xx'), 'xxxx')

        self.assertEqual(re.sub('(?P<unk>x)', '\g<1>\g<1>', 'xx'), 'xxxx')

        self.assertEqual(re.sub('a',r'\t\n\v\r\f\a\b\B\Z\a\A\w\W\s\S\d\D','a'),

                         '\t\n\v\r\f\a\b\\B\\Z\a\\A\\w\\W\\s\\S\\d\\D')

        self.assertEqual(re.sub('a', '\t\n\v\r\f\a', 'a'), '\t\n\v\r\f\a')

        self.assertEqual(re.sub('a', '\t\n\v\r\f\a', 'a'),

                         (chr(9)+chr(10)+chr(11)+chr(13)+chr(12)+chr(7)))

        self.assertEqual(re.sub('^\s*', 'X', 'test'), 'Xtest')

    def test_bug_449964(self):

        # fails for group followed by other escape

        self.assertEqual(re.sub(r'(?P<unk>x)', '\g<1>\g<1>\\b', 'xx'),

                         'xx\bxx\b')

    def test_bug_449000(self):

        # Test for sub() on escaped characters

        self.assertEqual(re.sub(r'\r\n', r'\n', 'abc\r\ndef\r\n'),

                         'abc\ndef\n')

        self.assertEqual(re.sub('\r\n', r'\n', 'abc\r\ndef\r\n'),

                         'abc\ndef\n')

        self.assertEqual(re.sub(r'\r\n', '\n', 'abc\r\ndef\r\n'),

                         'abc\ndef\n')

        self.assertEqual(re.sub('\r\n', '\n', 'abc\r\ndef\r\n'),

                         'abc\ndef\n')

    def test_bug_1140(self):

        # re.sub(x, y, u'') should return u'', not '', and

        # re.sub(x, y, '') should return '', not u''.

        # Also:

        # re.sub(x, y, unicode(x)) should return unicode(y), and

        # re.sub(x, y, str(x)) should return

        #     str(y) if isinstance(y, str) else unicode(y).

        for x in 'x', u'x':

            for y in 'y', u'y':

                z = re.sub(x, y, u'')

                self.assertEqual(z, u'')

                self.assertEqual(type(z), unicode)

                #

                z = re.sub(x, y, '')

                self.assertEqual(z, '')

                self.assertEqual(type(z), str)

                #

                z = re.sub(x, y, unicode(x))

                self.assertEqual(z, y)

                self.assertEqual(type(z), unicode)

                #

                z = re.sub(x, y, str(x))

                self.assertEqual(z, y)

                self.assertEqual(type(z), type(y))

    def test_bug_1661(self):

        # Verify that flags do not get silently ignored with compiled patterns

        pattern = re.compile('.')

        self.assertRaises(ValueError, re.match, pattern, 'A', re.I)

        self.assertRaises(ValueError, re.search, pattern, 'A', re.I)

        self.assertRaises(ValueError, re.findall, pattern, 'A', re.I)

        self.assertRaises(ValueError, re.compile, pattern, re.I)

    def test_bug_3629(self):

        # A regex that triggered a bug in the sre-code validator

        re.compile("(?P<quote>)(?(quote))")

    def test_sub_template_numeric_escape(self):

        # bug 776311 and friends

        self.assertEqual(re.sub('x', r'\0', 'x'), '\0')

        self.assertEqual(re.sub('x', r'\000', 'x'), '\000')

        self.assertEqual(re.sub('x', r'\001', 'x'), '\001')

        self.assertEqual(re.sub('x', r'\008', 'x'), '\0' + '8')

        self.assertEqual(re.sub('x', r'\009', 'x'), '\0' + '9')

        self.assertEqual(re.sub('x', r'\111', 'x'), '\111')

        self.assertEqual(re.sub('x', r'\117', 'x'), '\117')

        self.assertEqual(re.sub('x', r'\1111', 'x'), '\1111')

        self.assertEqual(re.sub('x', r'\1111', 'x'), '\111' + '1')

        self.assertEqual(re.sub('x', r'\00', 'x'), '\x00')

        self.assertEqual(re.sub('x', r'\07', 'x'), '\x07')

        self.assertEqual(re.sub('x', r'\08', 'x'), '\0' + '8')

        self.assertEqual(re.sub('x', r'\09', 'x'), '\0' + '9')

        self.assertEqual(re.sub('x', r'\0a', 'x'), '\0' + 'a')

        self.assertEqual(re.sub('x', r'\400', 'x'), '\0')

        self.assertEqual(re.sub('x', r'\777', 'x'), '\377')

        self.assertRaises(re.error, re.sub, 'x', r'\1', 'x')

        self.assertRaises(re.error, re.sub, 'x', r'\8', 'x')

        self.assertRaises(re.error, re.sub, 'x', r'\9', 'x')

        self.assertRaises(re.error, re.sub, 'x', r'\11', 'x')

        self.assertRaises(re.error, re.sub, 'x', r'\18', 'x')

        self.assertRaises(re.error, re.sub, 'x', r'\1a', 'x')

        self.assertRaises(re.error, re.sub, 'x', r'\90', 'x')

        self.assertRaises(re.error, re.sub, 'x', r'\99', 'x')

        self.assertRaises(re.error, re.sub, 'x', r'\118', 'x') # r'\11' + '8'

        self.assertRaises(re.error, re.sub, 'x', r'\11a', 'x')

        self.assertRaises(re.error, re.sub, 'x', r'\181', 'x') # r'\18' + '1'

        self.assertRaises(re.error, re.sub, 'x', r'\800', 'x') # r'\80' + '0'

        # in python2.3 (etc), these loop endlessly in sre_parser.py

        self.assertEqual(re.sub('(((((((((((x)))))))))))', r'\11', 'x'), 'x')

        self.assertEqual(re.sub('((((((((((y))))))))))(.)', r'\118', 'xyz'),

                         'xz8')

        self.assertEqual(re.sub('((((((((((y))))))))))(.)', r'\11a', 'xyz'),

                         'xza')

    def test_qualified_re_sub(self):

        self.assertEqual(re.sub('a', 'b', 'aaaaa'), 'bbbbb')

        self.assertEqual(re.sub('a', 'b', 'aaaaa', 1), 'baaaa')

    def test_bug_114660(self):

        self.assertEqual(re.sub(r'(\S)\s+(\S)', r'\1 \2', 'hello  there'),

                         'hello there')

    def test_bug_462270(self):

        # Test for empty sub() behaviour, see SF bug #462270

        self.assertEqual(re.sub('x*', '-', 'abxd'), '-a-b-d-')

        self.assertEqual(re.sub('x+', '-', 'abxd'), 'ab-d')

    def test_symbolic_refs(self):

        self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<a', 'xx')

        self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<', 'xx')

        self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g', 'xx')

        self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<a a>', 'xx')

        self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<1a1>', 'xx')

        self.assertRaises(IndexError, re.sub, '(?P<a>x)', '\g<ab>', 'xx')

        self.assertRaises(re.error, re.sub, '(?P<a>x)|(?P<b>y)', '\g<b>', 'xx')

        self.assertRaises(re.error, re.sub, '(?P<a>x)|(?P<b>y)', '\\2', 'xx')

        self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<-1>', 'xx')

    def test_re_subn(self):

        self.assertEqual(re.subn("(?i)b+", "x", "bbbb BBBB"), ('x x', 2))

        self.assertEqual(re.subn("b+", "x", "bbbb BBBB"), ('x BBBB', 1))

        self.assertEqual(re.subn("b+", "x", "xyz"), ('xyz', 0))

        self.assertEqual(re.subn("b*", "x", "xyz"), ('xxxyxzx', 4))

        self.assertEqual(re.subn("b*", "x", "xyz", 2), ('xxxyz', 2))

    def test_re_split(self):

        self.assertEqual(re.split(":", ":a:b::c"), ['', 'a', 'b', '', 'c'])

        self.assertEqual(re.split(":*", ":a:b::c"), ['', 'a', 'b', 'c'])

        self.assertEqual(re.split("(:*)", ":a:b::c"),

                         ['', ':', 'a', ':', 'b', '::', 'c'])

        self.assertEqual(re.split("(?::*)", ":a:b::c"), ['', 'a', 'b', 'c'])

        self.assertEqual(re.split("(:)*", ":a:b::c"),

                         ['', ':', 'a', ':', 'b', ':', 'c'])

        self.assertEqual(re.split("([b:]+)", ":a:b::c"),

                         ['', ':', 'a', ':b::', 'c'])

        self.assertEqual(re.split("(b)|(:+)", ":a:b::c"),

                         ['', None, ':', 'a', None, ':', '', 'b', None, '',

                          None, '::', 'c'])

        self.assertEqual(re.split("(?:b)|(?::+)", ":a:b::c"),

                         ['', 'a', '', '', 'c'])

    def test_qualified_re_split(self):

        self.assertEqual(re.split(":", ":a:b::c", 2), ['', 'a', 'b::c'])

        self.assertEqual(re.split(':', 'a:b:c:d', 2), ['a', 'b', 'c:d'])

        self.assertEqual(re.split("(:)", ":a:b::c", 2),

                         ['', ':', 'a', ':', 'b::c'])

        self.assertEqual(re.split("(:*)", ":a:b::c", 2),

                         ['', ':', 'a', ':', 'b::c'])

    def test_re_findall(self):

        self.assertEqual(re.findall(":+", "abc"), [])

        self.assertEqual(re.findall(":+", "a:b::c:::d"), [":", "::", ":::"])

        self.assertEqual(re.findall("(:+)", "a:b::c:::d"), [":", "::", ":::"])

        self.assertEqual(re.findall("(:)(:*)", "a:b::c:::d"), [(":", ""),

                                                               (":", ":"),

                                                               (":", "::")])

    def test_bug_117612(self):

        self.assertEqual(re.findall(r"(a|(b))", "aba"),

                         [("a", ""),("b", "b"),("a", "")])

    def test_re_match(self):

        self.assertEqual(re.match('a', 'a').groups(), ())

        self.assertEqual(re.match('(a)', 'a').groups(), ('a',))

        self.assertEqual(re.match(r'(a)', 'a').group(0), 'a')

        self.assertEqual(re.match(r'(a)', 'a').group(1), 'a')

        self.assertEqual(re.match(r'(a)', 'a').group(1, 1), ('a', 'a'))

        pat = re.compile('((a)|(b))(c)?')

        self.assertEqual(pat.match('a').groups(), ('a', 'a', None, None))

        self.assertEqual(pat.match('b').groups(), ('b', None, 'b', None))

        self.assertEqual(pat.match('ac').groups(), ('a', 'a', None, 'c'))

        self.assertEqual(pat.match('bc').groups(), ('b', None, 'b', 'c'))

        self.assertEqual(pat.match('bc').groups(""), ('b', "", 'b', 'c'))

        # A single group

        m = re.match('(a)', 'a')

        self.assertEqual(m.group(0), 'a')

        self.assertEqual(m.group(0), 'a')

        self.assertEqual(m.group(1), 'a')

        self.assertEqual(m.group(1, 1), ('a', 'a'))

        pat = re.compile('(?:(?P<a1>a)|(?P<b2>b))(?P<c3>c)?')

        self.assertEqual(pat.match('a').group(1, 2, 3), ('a', None, None))

        self.assertEqual(pat.match('b').group('a1', 'b2', 'c3'),

                         (None, 'b', None))

        self.assertEqual(pat.match('ac').group(1, 'b2', 3), ('a', None, 'c'))

    def test_re_groupref_exists(self):

        self.assertEqual(re.match('^(\()?([^()]+)(?(1)\))$', '(a)').groups(),

                         ('(', 'a'))

        self.assertEqual(re.match('^(\()?([^()]+)(?(1)\))$', 'a').groups(),

                         (None, 'a'))

        self.assertEqual(re.match('^(\()?([^()]+)(?(1)\))$', 'a)'), None)

        self.assertEqual(re.match('^(\()?([^()]+)(?(1)\))$', '(a'), None)

        self.assertEqual(re.match('^(?:(a)|c)((?(1)b|d))$', 'ab').groups(),

                         ('a', 'b'))

        self.assertEqual(re.match('^(?:(a)|c)((?(1)b|d))$', 'cd').groups(),

                         (None, 'd'))

        self.assertEqual(re.match('^(?:(a)|c)((?(1)|d))$', 'cd').groups(),

                         (None, 'd'))

        self.assertEqual(re.match('^(?:(a)|c)((?(1)|d))$', 'a').groups(),

                         ('a', ''))

        # Tests for bug #1177831: exercise groups other than the first group

        p = re.compile('(?P<g1>a)(?P<g2>b)?((?(g2)c|d))')

        self.assertEqual(p.match('abc').groups(),

                         ('a', 'b', 'c'))

        self.assertEqual(p.match('ad').groups(),

                         ('a', None, 'd'))

        self.assertEqual(p.match('abd'), None)

        self.assertEqual(p.match('ac'), None)

    def test_re_groupref(self):

        self.assertEqual(re.match(r'^(\|)?([^()]+)\1$', '|a|').groups(),

                         ('|', 'a'))

        self.assertEqual(re.match(r'^(\|)?([^()]+)\1?$', 'a').groups(),

                         (None, 'a'))

        self.assertEqual(re.match(r'^(\|)?([^()]+)\1$', 'a|'), None)

        self.assertEqual(re.match(r'^(\|)?([^()]+)\1$', '|a'), None)

        self.assertEqual(re.match(r'^(?:(a)|c)(\1)$', 'aa').groups(),

                         ('a', 'a'))

        self.assertEqual(re.match(r'^(?:(a)|c)(\1)?$', 'c').groups(),

                         (None, None))

    def test_groupdict(self):

        self.assertEqual(re.match('(?P<first>first) (?P<second>second)',

                                  'first second').groupdict(),

                         {'first':'first', 'second':'second'})

    def test_expand(self):

        self.assertEqual(re.match("(?P<first>first) (?P<second>second)",

                                  "first second")

                                  .expand(r"\2 \1 \g<second> \g<first>"),

                         "second first second first")

    def test_repeat_minmax(self):

        self.assertEqual(re.match("^(\w){1}$", "abc"), None)

        self.assertEqual(re.match("^(\w){1}?$", "abc"), None)

        self.assertEqual(re.match("^(\w){1,2}$", "abc"), None)

        self.assertEqual(re.match("^(\w){1,2}?$", "abc"), None)

        self.assertEqual(re.match("^(\w){3}$", "abc").group(1), "c")

        self.assertEqual(re.match("^(\w){1,3}$", "abc").group(1), "c")

        self.assertEqual(re.match("^(\w){1,4}$", "abc").group(1), "c")

        self.assertEqual(re.match("^(\w){3,4}?$", "abc").group(1), "c")

        self.assertEqual(re.match("^(\w){3}?$", "abc").group(1), "c")

        self.assertEqual(re.match("^(\w){1,3}?$", "abc").group(1), "c")

        self.assertEqual(re.match("^(\w){1,4}?$", "abc").group(1), "c")

        self.assertEqual(re.match("^(\w){3,4}?$", "abc").group(1), "c")

        self.assertEqual(re.match("^x{1}$", "xxx"), None)

        self.assertEqual(re.match("^x{1}?$", "xxx"), None)

        self.assertEqual(re.match("^x{1,2}$", "xxx"), None)

        self.assertEqual(re.match("^x{1,2}?$", "xxx"), None)

        self.assertNotEqual(re.match("^x{3}$", "xxx"), None)

        self.assertNotEqual(re.match("^x{1,3}$", "xxx"), None)

        self.assertNotEqual(re.match("^x{1,4}$", "xxx"), None)

        self.assertNotEqual(re.match("^x{3,4}?$", "xxx"), None)

        self.assertNotEqual(re.match("^x{3}?$", "xxx"), None)

        self.assertNotEqual(re.match("^x{1,3}?$", "xxx"), None)

        self.assertNotEqual(re.match("^x{1,4}?$", "xxx"), None)

        self.assertNotEqual(re.match("^x{3,4}?$", "xxx"), None)

        self.assertEqual(re.match("^x{}$", "xxx"), None)

        self.assertNotEqual(re.match("^x{}$", "x{}"), None)

    def test_getattr(self):

        self.assertEqual(re.match("(a)", "a").pos, 0)

        self.assertEqual(re.match("(a)", "a").endpos, 1)

        self.assertEqual(re.match("(a)", "a").string, "a")

        self.assertEqual(re.match("(a)", "a").regs, ((0, 1), (0, 1)))

        self.assertNotEqual(re.match("(a)", "a").re, None)

    def test_special_escapes(self):

        self.assertEqual(re.search(r"\b(b.)\b",

                                   "abcd abc bcd bx").group(1), "bx")

        self.assertEqual(re.search(r"\B(b.)\B",

                                   "abc bcd bc abxd").group(1), "bx")

        self.assertEqual(re.search(r"\b(b.)\b",

                                   "abcd abc bcd bx", re.LOCALE).group(1), "bx")

        self.assertEqual(re.search(r"\B(b.)\B",

                                   "abc bcd bc abxd", re.LOCALE).group(1), "bx")

        self.assertEqual(re.search(r"\b(b.)\b",

                                   "abcd abc bcd bx", re.UNICODE).group(1), "bx")

        self.assertEqual(re.search(r"\B(b.)\B",

                                   "abc bcd bc abxd", re.UNICODE).group(1), "bx")

        self.assertEqual(re.search(r"^abc$", "\nabc\n", re.M).group(0), "abc")

        self.assertEqual(re.search(r"^\Aabc\Z$", "abc", re.M).group(0), "abc")

        self.assertEqual(re.search(r"^\Aabc\Z$", "\nabc\n", re.M), None)

        self.assertEqual(re.search(r"\b(b.)\b",

                                   u"abcd abc bcd bx").group(1), "bx")

        self.assertEqual(re.search(r"\B(b.)\B",

                                   u"abc bcd bc abxd").group(1), "bx")

        self.assertEqual(re.search(r"^abc$", u"\nabc\n", re.M).group(0), "abc")

        self.assertEqual(re.search(r"^\Aabc\Z$", u"abc", re.M).group(0), "abc")

        self.assertEqual(re.search(r"^\Aabc\Z$", u"\nabc\n", re.M), None)

        self.assertEqual(re.search(r"\d\D\w\W\s\S",

                                   "1aa! a").group(0), "1aa! a")

        self.assertEqual(re.search(r"\d\D\w\W\s\S",

                                   "1aa! a", re.LOCALE).group(0), "1aa! a")

        self.assertEqual(re.search(r"\d\D\w\W\s\S",

                                   "1aa! a", re.UNICODE).group(0), "1aa! a")

    def test_bigcharset(self):

        self.assertEqual(re.match(u"([\u2222\u2223])",

                                  u"\u2222").group(1), u"\u2222")

        self.assertEqual(re.match(u"([\u2222\u2223])",

                                  u"\u2222", re.UNICODE).group(1), u"\u2222")

    def test_anyall(self):

        self.assertEqual(re.match("a.b", "a\nb", re.DOTALL).group(0),

                         "a\nb")

        self.assertEqual(re.match("a.*b", "a\n\nb", re.DOTALL).group(0),

                         "a\n\nb")

    def test_non_consuming(self):

        self.assertEqual(re.match("(a(?=\s[^a]))", "a b").group(1), "a")

        self.assertEqual(re.match("(a(?=\s[^a]*))", "a b").group(1), "a")

        self.assertEqual(re.match("(a(?=\s[abc]))", "a b").group(1), "a")

        self.assertEqual(re.match("(a(?=\s[abc]*))", "a bc").group(1), "a")

        self.assertEqual(re.match(r"(a)(?=\s\1)", "a a").group(1), "a")

        self.assertEqual(re.match(r"(a)(?=\s\1*)", "a aa").group(1), "a")

        self.assertEqual(re.match(r"(a)(?=\s(abc|a))", "a a").group(1), "a")

        self.assertEqual(re.match(r"(a(?!\s[^a]))", "a a").group(1), "a")

        self.assertEqual(re.match(r"(a(?!\s[abc]))", "a d").group(1), "a")

        self.assertEqual(re.match(r"(a)(?!\s\1)", "a b").group(1), "a")

        self.assertEqual(re.match(r"(a)(?!\s(abc|a))", "a b").group(1), "a")

    def test_ignore_case(self):

        self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")

        self.assertEqual(re.match("abc", u"ABC", re.I).group(0), "ABC")

        self.assertEqual(re.match(r"(a\s[^a])", "a b", re.I).group(1), "a b")

        self.assertEqual(re.match(r"(a\s[^a]*)", "a bb", re.I).group(1), "a bb")

        self.assertEqual(re.match(r"(a\s[abc])", "a b", re.I).group(1), "a b")

        self.assertEqual(re.match(r"(a\s[abc]*)", "a bb", re.I).group(1), "a bb")

        self.assertEqual(re.match(r"((a)\s\2)", "a a", re.I).group(1), "a a")

        self.assertEqual(re.match(r"((a)\s\2*)", "a aa", re.I).group(1), "a aa")

        self.assertEqual(re.match(r"((a)\s(abc|a))", "a a", re.I).group(1), "a a")

        self.assertEqual(re.match(r"((a)\s(abc|a)*)", "a aa", re.I).group(1), "a aa")

    def test_category(self):

        self.assertEqual(re.match(r"(\s)", " ").group(1), " ")

    def test_getlower(self):

        import _sre

        self.assertEqual(_sre.getlower(ord('A'), 0), ord('a'))

        self.assertEqual(_sre.getlower(ord('A'), re.LOCALE), ord('a'))

        self.assertEqual(_sre.getlower(ord('A'), re.UNICODE), ord('a'))

        self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")

        self.assertEqual(re.match("abc", u"ABC", re.I).group(0), "ABC")

    def test_not_literal(self):

        self.assertEqual(re.search("\s([^a])", " b").group(1), "b")

        self.assertEqual(re.search("\s([^a]*)", " bb").group(1), "bb")

    def test_search_coverage(self):

        self.assertEqual(re.search("\s(b)", " b").group(1), "b")

        self.assertEqual(re.search("a\s", "a ").group(0), "a ")

    def test_re_escape(self):

        p=""

        for i in range(0, 256):

            p = p + chr(i)

            self.assertEqual(re.match(re.escape(chr(i)), chr(i)) is not None,

                             True)

            self.assertEqual(re.match(re.escape(chr(i)), chr(i)).span(), (0,1))

        pat=re.compile(re.escape(p))

        self.assertEqual(pat.match(p) is not None, True)

        self.assertEqual(pat.match(p).span(), (0,256))

    def test_pickling(self):

        import pickle

        self.pickle_test(pickle)

        import cPickle

        self.pickle_test(cPickle)

        # old pickles expect the _compile() reconstructor in sre module

        import warnings

        with warnings.catch_warnings():

            warnings.filterwarnings("ignore", "The sre module is deprecated",

                                    DeprecationWarning)

            from sre import _compile

    def pickle_test(self, pickle):

        oldpat = re.compile('a(?:b|(c|e){1,2}?|d)+?(.)')

        s = pickle.dumps(oldpat)

        newpat = pickle.loads(s)

        self.assertEqual(oldpat, newpat)

    def test_constants(self):

        self.assertEqual(re.I, re.IGNORECASE)

        self.assertEqual(re.L, re.LOCALE)

        self.assertEqual(re.M, re.MULTILINE)

        self.assertEqual(re.S, re.DOTALL)

        self.assertEqual(re.X, re.VERBOSE)

    def test_flags(self):

        for flag in [re.I, re.M, re.X, re.S, re.L]:

            self.assertNotEqual(re.compile('^pattern$', flag), None)

    def test_sre_character_literals(self):

        for i in [0, 8, 16, 32, 64, 127, 128, 255]:

            self.assertNotEqual(re.match(r"\%03o" % i, chr(i)), None)

            self.assertNotEqual(re.match(r"\%03o0" % i, chr(i)+"0"), None)

            self.assertNotEqual(re.match(r"\%03o8" % i, chr(i)+"8"), None)

            self.assertNotEqual(re.match(r"\x%02x" % i, chr(i)), None)

            self.assertNotEqual(re.match(r"\x%02x0" % i, chr(i)+"0"), None)

            self.assertNotEqual(re.match(r"\x%02xz" % i, chr(i)+"z"), None)

        self.assertRaises(re.error, re.match, "\911", "")

    def test_sre_character_class_literals(self):

        for i in [0, 8, 16, 32, 64, 127, 128, 255]:

            self.assertNotEqual(re.match(r"[\%03o]" % i, chr(i)), None)

            self.assertNotEqual(re.match(r"[\%03o0]" % i, chr(i)), None)

            self.assertNotEqual(re.match(r"[\%03o8]" % i, chr(i)), None)

            self.assertNotEqual(re.match(r"[\x%02x]" % i, chr(i)), None)

            self.assertNotEqual(re.match(r"[\x%02x0]" % i, chr(i)), None)

            self.assertNotEqual(re.match(r"[\x%02xz]" % i, chr(i)), None)

        self.assertRaises(re.error, re.match, "[\911]", "")

    def test_bug_113254(self):

        self.assertEqual(re.match(r'(a)|(b)', 'b').start(1), -1)

        self.assertEqual(re.match(r'(a)|(b)', 'b').end(1), -1)

        self.assertEqual(re.match(r'(a)|(b)', 'b').span(1), (-1, -1))

    def test_bug_527371(self):

        # bug described in patches 527371/672491

        self.assertEqual(re.match(r'(a)?a','a').lastindex, None)

        self.assertEqual(re.match(r'(a)(b)?b','ab').lastindex, 1)

        self.assertEqual(re.match(r'(?P<a>a)(?P<b>b)?b','ab').lastgroup, 'a')

        self.assertEqual(re.match("(?P<a>a(b))", "ab").lastgroup, 'a')

        self.assertEqual(re.match("((a))", "a").lastindex, 1)

    def test_bug_545855(self):

        # bug 545855 -- This pattern failed to cause a compile error as it

        # should, instead provoking a TypeError.

        self.assertRaises(re.error, re.compile, 'foo[a-')

    def test_bug_418626(self):

        # bugs 418626 at al. -- Testing Greg Chapman's addition of op code

        # SRE_OP_MIN_REPEAT_ONE for eliminating recursion on simple uses of

        # pattern '*?' on a long string.

        self.assertEqual(re.match('.*?c', 10000*'ab'+'cd').end(0), 20001)

        self.assertEqual(re.match('.*?cd', 5000*'ab'+'c'+5000*'ab'+'cde').end(0),

                         20003)

        self.assertEqual(re.match('.*?cd', 20000*'abc'+'de').end(0), 60001)

        # non-simple '*?' still used to hit the recursion limit, before the

        # non-recursive scheme was implemented.

        self.assertEqual(re.search('(a|b)*?c', 10000*'ab'+'cd').end(0), 20001)

    def test_bug_612074(self):

        pat=u"["+re.escape(u"\u2039")+u"]"

        self.assertEqual(re.compile(pat) and 1, 1)