Lines Matching refs:re
3 import re
4 from re import Scanner
12 # Misc tests from Tim Peters' re.doc
15 # what you're doing. Some of these tests were carefully modeled to
24 x = re.compile('ab+c')
29 self.assertEqual(re.search('x*', 'axx').span(0), (0, 0))
30 self.assertEqual(re.search('x*', 'axx').span(), (0, 0))
31 self.assertEqual(re.search('x+', 'axx').span(0), (1, 3))
32 self.assertEqual(re.search('x+', 'axx').span(), (1, 3))
33 self.assertEqual(re.search('x', 'aaa'), None)
34 self.assertEqual(re.match('a*', 'xxx').span(0), (0, 0))
35 self.assertEqual(re.match('a*', 'xxx').span(), (0, 0))
36 self.assertEqual(re.match('x*', 'xxxa').span(0), (0, 3))
37 self.assertEqual(re.match('x*', 'xxxa').span(), (0, 3))
38 self.assertEqual(re.match('a+', 'xxx'), None)
45 self.assertEqual(re.sub("(?i)b+", "x", "bbbb BBBB"), 'x x')
46 self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y'),
48 self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y', 3),
51 self.assertEqual(re.sub('.', lambda m: r"\n", 'x'), '\\n')
52 self.assertEqual(re.sub('.', r"\n", 'x'), '\n')
55 self.assertEqual(re.sub('(.)', s, 'x'), 'xx')
56 self.assertEqual(re.sub('(.)', re.escape(s), 'x'), s)
57 self.assertEqual(re.sub('(.)', lambda m: s, 'x'), s)
59 self.assertEqual(re.sub('(?P<a>x)', '\g<a>\g<a>', 'xx'), 'xxxx')
60 self.assertEqual(re.sub('(?P<a>x)', '\g<a>\g<1>', 'xx'), 'xxxx')
61 self.assertEqual(re.sub('(?P<unk>x)', '\g<unk>\g<unk>', 'xx'), 'xxxx')
62 self.assertEqual(re.sub('(?P<unk>x)', '\g<1>\g<1>', 'xx'), 'xxxx')
64 self.assertEqual(re.sub('a',r'\t\n\v\r\f\a\b\B\Z\a\A\w\W\s\S\d\D','a'),
66 self.assertEqual(re.sub('a', '\t\n\v\r\f\a', 'a'), '\t\n\v\r\f\a')
67 self.assertEqual(re.sub('a', '\t\n\v\r\f\a', 'a'),
70 self.assertEqual(re.sub('^\s*', 'X', 'test'), 'Xtest')
74 self.assertEqual(re.sub(r'(?P<unk>x)', '\g<1>\g<1>\\b', 'xx'),
79 self.assertEqual(re.sub(r'\r\n', r'\n', 'abc\r\ndef\r\n'),
81 self.assertEqual(re.sub('\r\n', r'\n', 'abc\r\ndef\r\n'),
83 self.assertEqual(re.sub(r'\r\n', '\n', 'abc\r\ndef\r\n'),
85 self.assertEqual(re.sub('\r\n', '\n', 'abc\r\ndef\r\n'),
89 # re.sub(x, y, u'') should return u'', not '', and
90 # re.sub(x, y, '') should return '', not u''.
92 # re.sub(x, y, unicode(x)) should return unicode(y), and
93 # re.sub(x, y, str(x)) should return
97 z = re.sub(x, y, u'')
101 z = re.sub(x, y, '')
105 z = re.sub(x, y, unicode(x))
109 z = re.sub(x, y, str(x))
115 pattern = re.compile('.')
116 self.assertRaises(ValueError, re.match, pattern, 'A', re.I)
117 self.assertRaises(ValueError, re.search, pattern, 'A', re.I)
118 self.assertRaises(ValueError, re.findall, pattern, 'A', re.I)
119 self.assertRaises(ValueError, re.compile, pattern, re.I)
123 re.compile("(?P<quote>)(?(quote))")
127 self.assertEqual(re.sub('x', r'\0', 'x'), '\0')
128 self.assertEqual(re.sub('x', r'\000', 'x'), '\000')
129 self.assertEqual(re.sub('x', r'\001', 'x'), '\001')
130 self.assertEqual(re.sub('x', r'\008', 'x'), '\0' + '8')
131 self.assertEqual(re.sub('x', r'\009', 'x'), '\0' + '9')
132 self.assertEqual(re.sub('x', r'\111', 'x'), '\111')
133 self.assertEqual(re.sub('x', r'\117', 'x'), '\117')
135 self.assertEqual(re.sub('x', r'\1111', 'x'), '\1111')
136 self.assertEqual(re.sub('x', r'\1111', 'x'), '\111' + '1')
138 self.assertEqual(re.sub('x', r'\00', 'x'), '\x00')
139 self.assertEqual(re.sub('x', r'\07', 'x'), '\x07')
140 self.assertEqual(re.sub('x', r'\08', 'x'), '\0' + '8')
141 self.assertEqual(re.sub('x', r'\09', 'x'), '\0' + '9')
142 self.assertEqual(re.sub('x', r'\0a', 'x'), '\0' + 'a')
144 self.assertEqual(re.sub('x', r'\400', 'x'), '\0')
145 self.assertEqual(re.sub('x', r'\777', 'x'), '\377')
147 self.assertRaises(re.error, re.sub, 'x', r'\1', 'x')
148 self.assertRaises(re.error, re.sub, 'x', r'\8', 'x')
149 self.assertRaises(re.error, re.sub, 'x', r'\9', 'x')
150 self.assertRaises(re.error, re.sub, 'x', r'\11', 'x')
151 self.assertRaises(re.error, re.sub, 'x', r'\18', 'x')
152 self.assertRaises(re.error, re.sub, 'x', r'\1a', 'x')
153 self.assertRaises(re.error, re.sub, 'x', r'\90', 'x')
154 self.assertRaises(re.error, re.sub, 'x', r'\99', 'x')
155 self.assertRaises(re.error, re.sub, 'x', r'\118', 'x') # r'\11' + '8'
156 self.assertRaises(re.error, re.sub, 'x', r'\11a', 'x')
157 self.assertRaises(re.error, re.sub, 'x', r'\181', 'x') # r'\18' + '1'
158 self.assertRaises(re.error, re.sub, 'x', r'\800', 'x') # r'\80' + '0'
161 self.assertEqual(re.sub('(((((((((((x)))))))))))', r'\11', 'x'), 'x')
162 self.assertEqual(re.sub('((((((((((y))))))))))(.)', r'\118', 'xyz'),
164 self.assertEqual(re.sub('((((((((((y))))))))))(.)', r'\11a', 'xyz'),
168 self.assertEqual(re.sub('a', 'b', 'aaaaa'), 'bbbbb')
169 self.assertEqual(re.sub('a', 'b', 'aaaaa', 1), 'baaaa')
172 self.assertEqual(re.sub(r'(\S)\s+(\S)', r'\1 \2', 'hello there'),
177 self.assertEqual(re.sub('x*', '-', 'abxd'), '-a-b-d-')
178 self.assertEqual(re.sub('x+', '-', 'abxd'), 'ab-d')
181 re.compile('(?P<a>x)(?P=a)(?(a)y)')
182 re.compile('(?P<a1>x)(?P=a1)(?(a1)y)')
183 self.assertRaises(re.error, re.compile, '(?P<a>)(?P<a>)')
184 self.assertRaises(re.error, re.compile, '(?Px)')
185 self.assertRaises(re.error, re.compile, '(?P=)')
186 self.assertRaises(re.error, re.compile, '(?P=1)')
187 self.assertRaises(re.error, re.compile, '(?P=a)')
188 self.assertRaises(re.error, re.compile, '(?P=a1)')
189 self.assertRaises(re.error, re.compile, '(?P=a.)')
190 self.assertRaises(re.error, re.compile, '(?P<)')
191 self.assertRaises(re.error, re.compile, '(?P<>)')
192 self.assertRaises(re.error, re.compile, '(?P<1>)')
193 self.assertRaises(re.error, re.compile, '(?P<a.>)')
194 self.assertRaises(re.error, re.compile, '(?())')
195 self.assertRaises(re.error, re.compile, '(?(a))')
196 self.assertRaises(re.error, re.compile, '(?(1a))')
197 self.assertRaises(re.error, re.compile, '(?(a.))')
200 self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<a', 'xx')
201 self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<', 'xx')
202 self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g', 'xx')
203 self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<a a>', 'xx')
204 self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<>', 'xx')
205 self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<1a1>', 'xx')
206 self.assertRaises(IndexError, re.sub, '(?P<a>x)', '\g<ab>', 'xx')
207 self.assertRaises(re.error, re.sub, '(?P<a>x)|(?P<b>y)', '\g<b>', 'xx')
208 self.assertRaises(re.error, re.sub, '(?P<a>x)|(?P<b>y)', '\\2', 'xx')
209 self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<-1>', 'xx')
212 self.assertEqual(re.subn("(?i)b+", "x", "bbbb BBBB"), ('x x', 2))
213 self.assertEqual(re.subn("b+", "x", "bbbb BBBB"), ('x BBBB', 1))
214 self.assertEqual(re.subn("b+", "x", "xyz"), ('xyz', 0))
215 self.assertEqual(re.subn("b*", "x", "xyz"), ('xxxyxzx', 4))
216 self.assertEqual(re.subn("b*", "x", "xyz", 2), ('xxxyz', 2))
219 self.assertEqual(re.split(":", ":a:b::c"), ['', 'a', 'b', '', 'c'])
220 self.assertEqual(re.split(":*", ":a:b::c"), ['', 'a', 'b', 'c'])
221 self.assertEqual(re.split("(:*)", ":a:b::c"),
223 self.assertEqual(re.split("(?::*)", ":a:b::c"), ['', 'a', 'b', 'c'])
224 self.assertEqual(re.split("(:)*", ":a:b::c"),
226 self.assertEqual(re.split("([b:]+)", ":a:b::c"),
228 self.assertEqual(re.split("(b)|(:+)", ":a:b::c"),
231 self.assertEqual(re.split("(?:b)|(?::+)", ":a:b::c"),
235 self.assertEqual(re.split(":", ":a:b::c", 2), ['', 'a', 'b::c'])
236 self.assertEqual(re.split(':', 'a:b:c:d', 2), ['a', 'b', 'c:d'])
237 self.assertEqual(re.split("(:)", ":a:b::c", 2),
239 self.assertEqual(re.split("(:*)", ":a:b::c", 2),
243 self.assertEqual(re.findall(":+", "abc"), [])
244 self.assertEqual(re.findall(":+", "a:b::c:::d"), [":", "::", ":::"])
245 self.assertEqual(re.findall("(:+)", "a:b::c:::d"), [":", "::", ":::"])
246 self.assertEqual(re.findall("(:)(:*)", "a:b::c:::d"), [(":", ""),
251 self.assertEqual(re.findall(r"(a|(b))", "aba"),
255 self.assertEqual(re.match('a', 'a').groups(), ())
256 self.assertEqual(re.match('(a)', 'a').groups(), ('a',))
257 self.assertEqual(re.match(r'(a)', 'a').group(0), 'a')
258 self.assertEqual(re.match(r'(a)', 'a').group(1), 'a')
259 self.assertEqual(re.match(r'(a)', 'a').group(1, 1), ('a', 'a'))
261 pat = re.compile('((a)|(b))(c)?')
269 m = re.match('(a)', 'a')
275 pat = re.compile('(?:(?P<a1>a)|(?P<b2>b))(?P<c3>c)?')
282 self.assertEqual(re.match('^(\()?([^()]+)(?(1)\))$', '(a)').groups(),
284 self.assertEqual(re.match('^(\()?([^()]+)(?(1)\))$', 'a').groups(),
286 self.assertEqual(re.match('^(\()?([^()]+)(?(1)\))$', 'a)'), None)
287 self.assertEqual(re.match('^(\()?([^()]+)(?(1)\))$', '(a'), None)
288 self.assertEqual(re.match('^(?:(a)|c)((?(1)b|d))$', 'ab').groups(),
290 self.assertEqual(re.match('^(?:(a)|c)((?(1)b|d))$', 'cd').groups(),
292 self.assertEqual(re.match('^(?:(a)|c)((?(1)|d))$', 'cd').groups(),
294 self.assertEqual(re.match('^(?:(a)|c)((?(1)|d))$', 'a').groups(),
298 p = re.compile('(?P<g1>a)(?P<g2>b)?((?(g2)c|d))')
308 self.assertEqual(re.match(r'^(\|)?([^()]+)\1$', '|a|').groups(),
310 self.assertEqual(re.match(r'^(\|)?([^()]+)\1?$', 'a').groups(),
312 self.assertEqual(re.match(r'^(\|)?([^()]+)\1$', 'a|'), None)
313 self.assertEqual(re.match(r'^(\|)?([^()]+)\1$', '|a'), None)
314 self.assertEqual(re.match(r'^(?:(a)|c)(\1)$', 'aa').groups(),
316 self.assertEqual(re.match(r'^(?:(a)|c)(\1)?$', 'c').groups(),
320 self.assertEqual(re.match('(?P<first>first) (?P<second>second)',
325 self.assertEqual(re.match("(?P<first>first) (?P<second>second)",
331 self.assertEqual(re.match("^(\w){1}$", "abc"), None)
332 self.assertEqual(re.match("^(\w){1}?$", "abc"), None)
333 self.assertEqual(re.match("^(\w){1,2}$", "abc"), None)
334 self.assertEqual(re.match("^(\w){1,2}?$", "abc"), None)
336 self.assertEqual(re.match("^(\w){3}$", "abc").group(1), "c")
337 self.assertEqual(re.match("^(\w){1,3}$", "abc").group(1), "c")
338 self.assertEqual(re.match("^(\w){1,4}$", "abc").group(1), "c")
339 self.assertEqual(re.match("^(\w){3,4}?$", "abc").group(1), "c")
340 self.assertEqual(re.match("^(\w){3}?$", "abc").group(1), "c")
341 self.assertEqual(re.match("^(\w){1,3}?$", "abc").group(1), "c")
342 self.assertEqual(re.match("^(\w){1,4}?$", "abc").group(1), "c")
343 self.assertEqual(re.match("^(\w){3,4}?$", "abc").group(1), "c")
345 self.assertEqual(re.match("^x{1}$", "xxx"), None)
346 self.assertEqual(re.match("^x{1}?$", "xxx"), None)
347 self.assertEqual(re.match("^x{1,2}$", "xxx"), None)
348 self.assertEqual(re.match("^x{1,2}?$", "xxx"), None)
350 self.assertNotEqual(re.match("^x{3}$", "xxx"), None)
351 self.assertNotEqual(re.match("^x{1,3}$", "xxx"), None)
352 self.assertNotEqual(re.match("^x{1,4}$", "xxx"), None)
353 self.assertNotEqual(re.match("^x{3,4}?$", "xxx"), None)
354 self.assertNotEqual(re.match("^x{3}?$", "xxx"), None)
355 self.assertNotEqual(re.match("^x{1,3}?$", "xxx"), None)
356 self.assertNotEqual(re.match("^x{1,4}?$", "xxx"), None)
357 self.assertNotEqual(re.match("^x{3,4}?$", "xxx"), None)
359 self.assertEqual(re.match("^x{}$", "xxx"), None)
360 self.assertNotEqual(re.match("^x{}$", "x{}"), None)
363 self.assertEqual(re.match("(a)", "a").pos, 0)
364 self.assertEqual(re.match("(a)", "a").endpos, 1)
365 self.assertEqual(re.match("(a)", "a").string, "a")
366 self.assertEqual(re.match("(a)", "a").regs, ((0, 1), (0, 1)))
367 self.assertNotEqual(re.match("(a)", "a").re, None)
370 self.assertEqual(re.search(r"\b(b.)\b",
372 self.assertEqual(re.search(r"\B(b.)\B",
374 self.assertEqual(re.search(r"\b(b.)\b",
375 "abcd abc bcd bx", re.LOCALE).group(1), "bx")
376 self.assertEqual(re.search(r"\B(b.)\B",
377 "abc bcd bc abxd", re.LOCALE).group(1), "bx")
378 self.assertEqual(re.search(r"\b(b.)\b",
379 "abcd abc bcd bx", re.UNICODE).group(1), "bx")
380 self.assertEqual(re.search(r"\B(b.)\B",
381 "abc bcd bc abxd", re.UNICODE).group(1), "bx")
382 self.assertEqual(re.search(r"^abc$", "\nabc\n", re.M).group(0), "abc")
383 self.assertEqual(re.search(r"^\Aabc\Z$", "abc", re.M).group(0), "abc")
384 self.assertEqual(re.search(r"^\Aabc\Z$", "\nabc\n", re.M), None)
385 self.assertEqual(re.search(r"\b(b.)\b",
387 self.assertEqual(re.search(r"\B(b.)\B",
389 self.assertEqual(re.search(r"^abc$", u"\nabc\n", re.M).group(0), "abc")
390 self.assertEqual(re.search(r"^\Aabc\Z$", u"abc", re.M).group(0), "abc")
391 self.assertEqual(re.search(r"^\Aabc\Z$", u"\nabc\n", re.M), None)
392 self.assertEqual(re.search(r"\d\D\w\W\s\S",
394 self.assertEqual(re.search(r"\d\D\w\W\s\S",
395 "1aa! a", re.LOCALE).group(0), "1aa! a")
396 self.assertEqual(re.search(r"\d\D\w\W\s\S",
397 "1aa! a", re.UNICODE).group(0), "1aa! a")
401 self.assertEqual(re.search(r"\b(abc)\b", "abc").group(1),
404 self.assertTrue(re.match(r"\b", "abc"))
406 self.assertTrue(re.search(r"\B", "abc"))
408 self.assertFalse(re.match(r"\B", "abc"))
411 self.assertEqual(re.search(r"\B", ""), None)
414 self.assertEqual(re.search(r"\b", ""), None)
417 self.assertEqual(len(re.findall(r"\b", "a")), 2)
418 self.assertEqual(len(re.findall(r"\B", "a")), 0)
420 self.assertEqual(len(re.findall(r"\b", " ")), 0)
421 self.assertEqual(len(re.findall(r"\b", " ")), 0)
423 self.assertEqual(len(re.findall(r"\B", " ")), 2)
426 self.assertEqual(re.match(u"([\u2222\u2223])",
428 self.assertEqual(re.match(u"([\u2222\u2223])",
429 u"\u2222", re.UNICODE).group(1), u"\u2222")
433 r = re.compile('|'.join(('%d'%x for x in range(10000))))
438 self.assertEqual(re.match("a.b", "a\nb", re.DOTALL).group(0),
440 self.assertEqual(re.match("a.*b", "a\n\nb", re.DOTALL).group(0),
444 self.assertEqual(re.match("(a(?=\s[^a]))", "a b").group(1), "a")
445 self.assertEqual(re.match("(a(?=\s[^a]*))", "a b").group(1), "a")
446 self.assertEqual(re.match("(a(?=\s[abc]))", "a b").group(1), "a")
447 self.assertEqual(re.match("(a(?=\s[abc]*))", "a bc").group(1), "a")
448 self.assertEqual(re.match(r"(a)(?=\s\1)", "a a").group(1), "a")
449 self.assertEqual(re.match(r"(a)(?=\s\1*)", "a aa").group(1), "a")
450 self.assertEqual(re.match(r"(a)(?=\s(abc|a))", "a a").group(1), "a")
452 self.assertEqual(re.match(r"(a(?!\s[^a]))", "a a").group(1), "a")
453 self.assertEqual(re.match(r"(a(?!\s[abc]))", "a d").group(1), "a")
454 self.assertEqual(re.match(r"(a)(?!\s\1)", "a b").group(1), "a")
455 self.assertEqual(re.match(r"(a)(?!\s(abc|a))", "a b").group(1), "a")
458 self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
459 self.assertEqual(re.match("abc", u"ABC", re.I).group(0), "ABC")
460 self.assertEqual(re.match(r"(a\s[^a])", "a b", re.I).group(1), "a b")
461 self.assertEqual(re.match(r"(a\s[^a]*)", "a bb", re.I).group(1), "a bb")
462 self.assertEqual(re.match(r"(a\s[abc])", "a b", re.I).group(1), "a b")
463 self.assertEqual(re.match(r"(a\s[abc]*)", "a bb", re.I).group(1), "a bb")
464 self.assertEqual(re.match(r"((a)\s\2)", "a a", re.I).group(1), "a a")
465 self.assertEqual(re.match(r"((a)\s\2*)", "a aa", re.I).group(1), "a aa")
466 self.assertEqual(re.match(r"((a)\s(abc|a))", "a a", re.I).group(1), "a a")
467 self.assertEqual(re.match(r"((a)\s(abc|a)*)", "a aa", re.I).group(1), "a aa")
470 self.assertEqual(re.match(r"(\s)", " ").group(1), " ")
475 self.assertEqual(_sre.getlower(ord('A'), re.LOCALE), ord('a'))
476 self.assertEqual(_sre.getlower(ord('A'), re.UNICODE), ord('a'))
478 self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
479 self.assertEqual(re.match("abc", u"ABC", re.I).group(0), "ABC")
482 self.assertEqual(re.search("\s([^a])", " b").group(1), "b")
483 self.assertEqual(re.search("\s([^a]*)", " bb").group(1), "bb")
486 self.assertEqual(re.search("\s(b)", " b").group(1), "b")
487 self.assertEqual(re.search("a\s", "a ").group(0), "a ")
490 matcher=re.match):
508 self.assertEqual(re.escape(c), c)
510 self.assertEqual(re.escape(c), u'\\000')
512 self.assertEqual(re.escape(c), u'\\' + c)
513 self.assertMatch(re.escape(c), c)
514 self.assertMatch(re.escape(p), p)
521 self.assertEqual(re.escape(b), b)
523 self.assertEqual(re.escape(b), b'\\000')
525 self.assertEqual(re.escape(b), b'\\' + b)
526 self.assertMatch(re.escape(b), b)
527 self.assertMatch(re.escape(p), p)
531 s_escaped = re.escape(s)
534 self.assertMatch(u'.%s+.' % re.escape(u'\u2620'), s,
535 u'x\u2620\u2620\u2620x', (2, 7), re.search)
539 b_escaped = re.escape(b)
542 res = re.findall(re.escape(u'\u2620'.encode('utf-8')), b)
555 oldpat = re.compile('a(?:b|(c|e){1,2}?|d)+?(.)')
561 self.assertEqual(re.I, re.IGNORECASE)
562 self.assertEqual(re.L, re.LOCALE)
563 self.assertEqual(re.M, re.MULTILINE)
564 self.assertEqual(re.S, re.DOTALL)
565 self.assertEqual(re.X, re.VERBOSE)
568 for flag in [re.I, re.M, re.X, re.S, re.L]:
569 self.assertNotEqual(re.compile('^pattern$', flag), None)
573 self.assertNotEqual(re.match(r"\%03o" % i, chr(i)), None)
574 self.assertNotEqual(re.match(r"\%03o0" % i, chr(i)+"0"), None)
575 self.assertNotEqual(re.match(r"\%03o8" % i, chr(i)+"8"), None)
576 self.assertNotEqual(re.match(r"\x%02x" % i, chr(i)), None)
577 self.assertNotEqual(re.match(r"\x%02x0" % i, chr(i)+"0"), None)
578 self.assertNotEqual(re.match(r"\x%02xz" % i, chr(i)+"z"), None)
579 self.assertRaises(re.error, re.match, "\911", "")
583 self.assertNotEqual(re.match(r"[\%03o]" % i, chr(i)), None)
584 self.assertNotEqual(re.match(r"[\%03o0]" % i, chr(i)), None)
585 self.assertNotEqual(re.match(r"[\%03o8]" % i, chr(i)), None)
586 self.assertNotEqual(re.match(r"[\x%02x]" % i, chr(i)), None)
587 self.assertNotEqual(re.match(r"[\x%02x0]" % i, chr(i)), None)
588 self.assertNotEqual(re.match(r"[\x%02xz]" % i, chr(i)), None)
589 self.assertRaises(re.error, re.match, "[\911]", "")
592 self.assertEqual(re.match(r'(a)|(b)', 'b').start(1), -1)
593 self.assertEqual(re.match(r'(a)|(b)', 'b').end(1), -1)
594 self.assertEqual(re.match(r'(a)|(b)', 'b').span(1), (-1, -1))
598 self.assertEqual(re.match(r'(a)?a','a').lastindex, None)
599 self.assertEqual(re.match(r'(a)(b)?b','ab').lastindex, 1)
600 self.assertEqual(re.match(r'(?P<a>a)(?P<b>b)?b','ab').lastgroup, 'a')
601 self.assertEqual(re.match("(?P<a>a(b))", "ab").lastgroup, 'a')
602 self.assertEqual(re.match("((a))", "a").lastindex, 1)
607 self.assertRaises(re.error, re.compile, 'foo[a-')
613 self.assertEqual(re.match('.*?c', 10000*'ab'+'cd').end(0), 20001)
614 self.assertEqual(re.match('.*?cd', 5000*'ab'+'c'+5000*'ab'+'cde').end(0),
616 self.assertEqual(re.match('.*?cd', 20000*'abc'+'de').end(0), 60001)
619 self.assertEqual(re.search('(a|b)*?c', 10000*'ab'+'cd').end(0), 20001)
622 pat=u"["+re.escape(u"\u2039")+u"]"
623 self.assertEqual(re.compile(pat) and 1, 1)
628 self.assertEqual(re.match('(x)*', 50000*'x').group(1), 'x')
629 self.assertEqual(re.match('(x)*y', 50000*'x'+'y').group(1), 'x')
630 self.assertEqual(re.match('(x)*?y', 50000*'x'+'y').group(1), 'x')
634 self.assertIsNone(re.match(r'(?:a?)*y', 'z'))
635 self.assertIsNone(re.match(r'(?:a?)+y', 'z'))
636 self.assertIsNone(re.match(r'(?:a?){2,}y', 'z'))
637 self.assertIsNone(re.match(r'(?:a?)*?y', 'z'))
638 self.assertIsNone(re.match(r'(?:a?)+?y', 'z'))
639 self.assertIsNone(re.match(r'(?:a?){2,}?y', 'z'))
665 self.assertEqual(re.match(r'((.%s):)?z'%op, 'z').groups(),
667 self.assertEqual(re.match(r'((.%s):)?z'%op, 'a:z').groups(),
672 self.assertEqual(re.match('^((a)|b)*', 'abc').groups(),
674 self.assertEqual(re.match('^(([ab])|c)*', 'abc').groups(),
676 self.assertEqual(re.match('^((d)|[ab])*', 'abc').groups(),
678 self.assertEqual(re.match('^((a)c|[ab])*', 'abc').groups(),
680 self.assertEqual(re.match('^((a)|b)*?c', 'abc').groups(),
682 self.assertEqual(re.match('^(([ab])|c)*?d', 'abcd').groups(),
684 self.assertEqual(re.match('^((d)|[ab])*?c', 'abc').groups(),
686 self.assertEqual(re.match('^((a)c|[ab])*?c', 'abc').groups(),
691 self.assertEqual(re.match('(a)(?:(?=(b)*)c)*', 'abb').groups(),
693 self.assertEqual(re.match('(a)((?!(b)*))*', 'abb').groups(),
697 # bug 764548, re.compile() barfs on str/unicode subclasses
703 pat = re.compile(my_unicode("abc"))
707 iter = re.finditer(r":+", "a:b::c:::d")
716 self.assertTrue(re.compile('bug_926075') is not
717 re.compile(eval("u'bug_926075'")))
725 self.assertEqual(re.compile(pattern).split("a.b.c"),
729 iter = re.finditer(r"\s", "a b")
733 scanner = re.compile(r"\s").scanner("a b")
738 iter = re.finditer(r".*", "asdf")
753 self.assertEqual(re.match('^\d$', x, re.UNICODE).group(0), x)
762 self.assertIsNone(re.match('^\d$', x, re.UNICODE))
769 self.assertEqual(re.compile("bla").match(a), None)
770 self.assertEqual(re.compile("").match(a).groups(), ())
777 p = re.compile(upper_char, re.I | re.U)
781 p = re.compile(lower_char, re.I | re.U)
785 p = re.compile('(?i)' + upper_char, re.U)
789 p = re.compile('(?i)' + lower_char, re.U)
793 p = re.compile('(?iu)' + upper_char)
797 p = re.compile('(?iu)' + lower_char)
803 pattern = re.compile('$')
808 pattern = re.compile('$', re.MULTILINE)
821 self.assertRaises(TypeError, re.finditer, "a", {})
826 pattern = re.compile('random pattern')
827 self.assertIsInstance(pattern, re._pattern_type)
828 same_pattern = re.compile(pattern)
829 self.assertIsInstance(same_pattern, re._pattern_type)
832 self.assertRaises(TypeError, re.compile, 0)
835 # Issue #13899: re pattern r"[\A]" should work like "A" but matches
837 self.assertEqual(re.findall(r'[\A\B\b\C\Z]', 'AB\bCZ'),
844 m = re.search('$', s)
849 # The huge memuse is because of re.sub() using a list and a join()
855 r, n = re.subn('', '', s)
863 self.assertEqual(re.match(r".{65535}", string).span(), (0, 65535))
864 self.assertEqual(re.match(r".{,65535}", string).span(), (0, 65535))
865 self.assertEqual(re.match(r".{65535,}?", string).span(), (0, 65535))
866 self.assertEqual(re.match(r".{65536}", string).span(), (0, 65536))
867 self.assertEqual(re.match(r".{,65536}", string).span(), (0, 65536))
868 self.assertEqual(re.match(r".{65536,}?", string).span(), (0, 65536))
870 self.assertRaises(OverflowError, re.compile, r".{%d}" % 2**128)
871 self.assertRaises(OverflowError, re.compile, r".{,%d}" % 2**128)
872 self.assertRaises(OverflowError, re.compile, r".{%d,}?" % 2**128)
873 self.assertRaises(OverflowError, re.compile, r".{%d,%d}" % (2**129, 2**128))
882 self.assertIsNone(re.match(r".{%d}" % (MAXREPEAT - 1), string))
883 self.assertEqual(re.match(r".{,%d}" % (MAXREPEAT - 1), string).span(),
885 self.assertIsNone(re.match(r".{%d,}?" % (MAXREPEAT - 1), string))
886 self.assertRaises(OverflowError, re.compile, r".{%d}" % MAXREPEAT)
887 self.assertRaises(OverflowError, re.compile, r".{,%d}" % MAXREPEAT)
888 self.assertRaises(OverflowError, re.compile, r".{%d,}?" % MAXREPEAT)
893 re.compile('(?P=<foo>)')
898 re.compile('(?P<?foo>)')
921 obj = re.compile(pattern)
922 except re.error:
934 except re.error, msg:
949 'flags': result.re.flags}
959 for i in result.re.groupindex.keys():
987 obj=re.compile(unicode(pattern, "latin-1"))
999 obj = re.compile(pattern)
1006 obj = re.compile(pattern, re.IGNORECASE)
1013 obj = re.compile(pattern, re.LOCALE)
1020 obj = re.compile(pattern, re.UNICODE)