sys
.path
= ['.'] + sys
.path
from test
.test_support
import verbose
, run_unittest
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.
class ReTests(unittest
.TestCase
):
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'),
self
.assertEqual(re
.sub(r
'\d+', self
.bump_num
, '08.2 -2 23x99y', 3),
self
.assertEqual(re
.sub('.', lambda m
: r
"\n", 'x'), '\\n')
self
.assertEqual(re
.sub('.', r
"\n", 'x'), '\n')
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'),
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'),
self
.assertEqual(re
.sub('\r\n', r
'\n', 'abc\r\ndef\r\n'),
self
.assertEqual(re
.sub(r
'\r\n', '\n', 'abc\r\ndef\r\n'),
self
.assertEqual(re
.sub('\r\n', '\n', 'abc\r\ndef\r\n'),
def test_sub_template_numeric_escape(self
):
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'),
self
.assertEqual(re
.sub('((((((((((y))))))))))(.)', r
'\11a', 'xyz'),
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'),
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')
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))
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, '',
self
.assertEqual(re
.split("(?:b)|(?::+)", ":a:b::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", "")])
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'))
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'),
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(),
self
.assertEqual(re
.match('^(\()?([^()]+)(?(1)\))$', 'a').groups(),
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(),
self
.assertEqual(re
.match('^(?:(a)|c)((?(1)b|d))$', 'cd').groups(),
self
.assertEqual(re
.match('^(?:(a)|c)((?(1)|d))$', 'cd').groups(),
self
.assertEqual(re
.match('^(?:(a)|c)((?(1)|d))$', 'a').groups(),
# 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(),
self
.assertEqual(p
.match('ad').groups(),
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(),
self
.assertEqual(re
.match(r
'^(\|)?([^()]+)\1?$', 'a').groups(),
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(),
self
.assertEqual(re
.match(r
'^(?:(a)|c)(\1)?$', 'c').groups(),
def test_groupdict(self
):
self
.assertEqual(re
.match('(?P<first>first) (?P<second>second)',
'first second').groupdict(),
{'first':'first', 'second':'second'})
self
.assertEqual(re
.match("(?P<first>first) (?P<second>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)
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_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")
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")
self
.assertEqual(re
.match("a.b", "a\nb", re
.DOTALL
).group(0),
self
.assertEqual(re
.match("a.*b", "a\n\nb", re
.DOTALL
).group(0),
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(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")
self
.assertEqual(re
.match(r
"(\s)", " ").group(1), " ")
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
):
self
.assertEqual(re
.match(re
.escape(chr(i
)), chr(i
)) is not None,
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))
self
.pickle_test(cPickle
)
def pickle_test(self
, pickle
):
oldpat
= re
.compile('a(?:b|(c|e){1,2}?|d)+?(.)')
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
)
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),
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)
def test_stack_overflow(self
):
# nasty cases that used to overflow the straightforward recursive
# implementation of repeated groups.
self
.assertEqual(re
.match('(x)*', 50000*'x').group(1), 'x')
self
.assertEqual(re
.match('(x)*y', 50000*'x'+'y').group(1), 'x')
self
.assertEqual(re
.match('(x)*?y', 50000*'x'+'y').group(1), 'x')
def s_ident(scanner
, token
): return token
def s_operator(scanner
, token
): return "op%s" % token
def s_float(scanner
, token
): return float(token
)
def s_int(scanner
, token
): return int(token
)
(r
"[a-zA-Z_]\w*", s_ident
),
(r
"=|\+|-|\*|/", s_operator
),
self
.assertNotEqual(scanner
.scanner
.scanner("").pattern
, None)
self
.assertEqual(scanner
.scan("sum = 3*foo + 312.50 + bar"),
(['sum', 'op=', 3, 'op*', 'foo', 'op+', 312.5,
def test_bug_448951(self
):
# bug 448951 (similar to 429357, but with single char match)
# (Also test greedy matches.)
self
.assertEqual(re
.match(r
'((.%s):)?z'%op
, 'z').groups(),
self
.assertEqual(re
.match(r
'((.%s):)?z'%op
, 'a:z').groups(),
def test_bug_725106(self
):
# capturing groups in alternatives in repeats
self
.assertEqual(re
.match('^((a)|b)*', 'abc').groups(),
self
.assertEqual(re
.match('^(([ab])|c)*', 'abc').groups(),
self
.assertEqual(re
.match('^((d)|[ab])*', 'abc').groups(),
self
.assertEqual(re
.match('^((a)c|[ab])*', 'abc').groups(),
self
.assertEqual(re
.match('^((a)|b)*?c', 'abc').groups(),
self
.assertEqual(re
.match('^(([ab])|c)*?d', 'abcd').groups(),
self
.assertEqual(re
.match('^((d)|[ab])*?c', 'abc').groups(),
self
.assertEqual(re
.match('^((a)c|[ab])*?c', 'abc').groups(),
def test_bug_725149(self
):
# mark_stack_base restoring before restoring marks
self
.assertEqual(re
.match('(a)(?:(?=(b)*)c)*', 'abb').groups(),
self
.assertEqual(re
.match('(a)((?!(b)*))*', 'abb').groups(),
def test_bug_764548(self
):
# bug 764548, re.compile() barfs on str/unicode subclasses
return # no problem if we have no unicode
class my_unicode(unicode): pass
pat
= re
.compile(my_unicode("abc"))
self
.assertEqual(pat
.match("xyz"), None)
iter = re
.finditer(r
":+", "a:b::c:::d")
self
.assertEqual([item
.group(0) for item
in iter],
def test_bug_926075(self
):
return # no problem if we have no unicode
self
.assert_(re
.compile('bug_926075') is not
re
.compile(eval("u'bug_926075'")))
def test_bug_931848(self
):
pattern
= eval('u"[\u002E\u3002\uFF0E\uFF61]"')
self
.assertEqual(re
.compile(pattern
).split("a.b.c"),
def test_bug_581080(self
):
iter = re
.finditer(r
"\s", "a b")
self
.assertEqual(iter.next().span(), (1,2))
self
.assertRaises(StopIteration, iter.next
)
scanner
= re
.compile(r
"\s").scanner("a b")
self
.assertEqual(scanner
.search().span(), (1, 2))
self
.assertEqual(scanner
.search(), None)
def test_bug_817234(self
):
iter = re
.finditer(r
".*", "asdf")
self
.assertEqual(iter.next().span(), (0, 4))
self
.assertEqual(iter.next().span(), (4, 4))
self
.assertRaises(StopIteration, iter.next
)
from test
.re_tests
import benchmarks
, tests
, SUCCEED
, FAIL
, SYNTAX_ERROR
print 'Running re_tests test suite'
# To save time, only run the first and last 10 tests
#tests = tests[:10] + tests[-10:]
pattern
= s
= outcome
= repl
= expected
= None
pattern
, s
, outcome
, repl
, expected
= t
raise ValueError, ('Test tuples should have 3 or 5 fields', t
)
obj
= re
.compile(pattern
)
if outcome
== SYNTAX_ERROR
: pass # Expected a syntax error
print '=== Syntax error:', t
except KeyboardInterrupt: raise KeyboardInterrupt
print '*** Unexpected error ***', t
traceback
.print_exc(file=sys
.stdout
)
print '=== Unexpected exception', t
, repr(msg
)
if outcome
== SYNTAX_ERROR
:
# This should have been a syntax error; forget it.
if result
is None: pass # No match, as expected
else: print '=== Succeeded incorrectly', t
# Matched, as expected, so now we compute the
# result string and compare it to our expected result.
start
, end
= result
.span(0)
vardict
={'found': result
.group(0),
'groups': result
.group(),
'flags': result
.re
.flags
}
# Special hack because else the string concat fails:
for i
in result
.re
.groupindex
.keys():
repl
= eval(repl
, vardict
)
print '=== grouping error', t
,
print repr(repl
) + ' should be ' + repr(expected
)
print '=== Failed incorrectly', t
# Try the match on a unicode string, and check that it
result
= obj
.search(unicode(s
, "latin-1"))
print '=== Fails on unicode match', t
continue # unicode test case
# Try the match on a unicode pattern, and check that it
obj
=re
.compile(unicode(pattern
, "latin-1"))
print '=== Fails on unicode pattern match', t
# Try the match with the search area limited to the extent
# of the match and see if it still succeeds. \B will
# break (because it won't match at the end or start of a
# string), so we'll ignore patterns that feature it.
if pattern
[:2] != '\\B' and pattern
[-2:] != '\\B' \
obj
= re
.compile(pattern
)
result
= obj
.search(s
, result
.start(0), result
.end(0) + 1)
print '=== Failed on range-limited match', t
# Try the match with IGNORECASE enabled, and check that it
obj
= re
.compile(pattern
, re
.IGNORECASE
)
print '=== Fails on case-insensitive match', t
# Try the match with LOCALE enabled, and check that it
obj
= re
.compile(pattern
, re
.LOCALE
)
print '=== Fails on locale-sensitive match', t
# Try the match with UNICODE locale enabled, and check
# that it still succeeds.
obj
= re
.compile(pattern
, re
.UNICODE
)
print '=== Fails on unicode-sensitive match', t
if __name__
== "__main__":