Lines Matching refs:re
8 import re
9 from re import Scanner
29 x = re.compile('ab+c')
34 self.assertEqual(re.search('x*', 'axx').span(0), (0, 0))
35 self.assertEqual(re.search('x*', 'axx').span(), (0, 0))
36 self.assertEqual(re.search('x+', 'axx').span(0), (1, 3))
37 self.assertEqual(re.search('x+', 'axx').span(), (1, 3))
38 self.assertIsNone(re.search('x', 'aaa'))
39 self.assertEqual(re.match('a*', 'xxx').span(0), (0, 0))
40 self.assertEqual(re.match('a*', 'xxx').span(), (0, 0))
41 self.assertEqual(re.match('x*', 'xxxa').span(0), (0, 3))
42 self.assertEqual(re.match('x*', 'xxxa').span(), (0, 3))
43 self.assertIsNone(re.match('a+', 'xxx'))
50 self.assertEqual(re.sub("(?i)b+", "x", "bbbb BBBB"), 'x x')
51 self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y'),
53 self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y', 3),
56 self.assertEqual(re.sub('.', lambda m: r"\n", 'x'), '\\n')
57 self.assertEqual(re.sub('.', r"\n", 'x'), '\n')
60 self.assertEqual(re.sub('(.)', s, 'x'), 'xx')
61 self.assertEqual(re.sub('(.)', re.escape(s), 'x'), s)
62 self.assertEqual(re.sub('(.)', lambda m: s, 'x'), s)
64 self.assertEqual(re.sub('(?P<a>x)', '\g<a>\g<a>', 'xx'), 'xxxx')
65 self.assertEqual(re.sub('(?P<a>x)', '\g<a>\g<1>', 'xx'), 'xxxx')
66 self.assertEqual(re.sub('(?P<unk>x)', '\g<unk>\g<unk>', 'xx'), 'xxxx')
67 self.assertEqual(re.sub('(?P<unk>x)', '\g<1>\g<1>', 'xx'), 'xxxx')
69 self.assertEqual(re.sub('a',r'\t\n\v\r\f\a\b\B\Z\a\A\w\W\s\S\d\D','a'),
71 self.assertEqual(re.sub('a', '\t\n\v\r\f\a', 'a'), '\t\n\v\r\f\a')
72 self.assertEqual(re.sub('a', '\t\n\v\r\f\a', 'a'),
75 self.assertEqual(re.sub('^\s*', 'X', 'test'), 'Xtest')
79 self.assertEqual(re.sub(r'(?P<unk>x)', '\g<1>\g<1>\\b', 'xx'),
84 self.assertEqual(re.sub(r'\r\n', r'\n', 'abc\r\ndef\r\n'),
86 self.assertEqual(re.sub('\r\n', r'\n', 'abc\r\ndef\r\n'),
88 self.assertEqual(re.sub(r'\r\n', '\n', 'abc\r\ndef\r\n'),
90 self.assertEqual(re.sub('\r\n', '\n', 'abc\r\ndef\r\n'),
103 z = re.sub(x, y, u'')
107 z = re.sub(x, y, '')
111 z = re.sub(x, y, unicode(x))
115 z = re.sub(x, y, str(x))
121 pattern = re.compile('.')
122 self.assertRaises(ValueError, re.match, pattern, 'A', re.I)
123 self.assertRaises(ValueError, re.search, pattern, 'A', re.I)
124 self.assertRaises(ValueError, re.findall, pattern, 'A', re.I)
125 self.assertRaises(ValueError, re.compile, pattern, re.I)
129 re.compile("(?P<quote>)(?(quote))")
133 self.assertEqual(re.sub('x', r'\0', 'x'), '\0')
134 self.assertEqual(re.sub('x', r'\000', 'x'), '\000')
135 self.assertEqual(re.sub('x', r'\001', 'x'), '\001')
136 self.assertEqual(re.sub('x', r'\008', 'x'), '\0' + '8')
137 self.assertEqual(re.sub('x', r'\009', 'x'), '\0' + '9')
138 self.assertEqual(re.sub('x', r'\111', 'x'), '\111')
139 self.assertEqual(re.sub('x', r'\117', 'x'), '\117')
141 self.assertEqual(re.sub('x', r'\1111', 'x'), '\1111')
142 self.assertEqual(re.sub('x', r'\1111', 'x'), '\111' + '1')
144 self.assertEqual(re.sub('x', r'\00', 'x'), '\x00')
145 self.assertEqual(re.sub('x', r'\07', 'x'), '\x07')
146 self.assertEqual(re.sub('x', r'\08', 'x'), '\0' + '8')
147 self.assertEqual(re.sub('x', r'\09', 'x'), '\0' + '9')
148 self.assertEqual(re.sub('x', r'\0a', 'x'), '\0' + 'a')
150 self.assertEqual(re.sub('x', r'\400', 'x'), '\0')
151 self.assertEqual(re.sub('x', r'\777', 'x'), '\377')
153 self.assertRaises(re.error, re.sub, 'x', r'\1', 'x')
154 self.assertRaises(re.error, re.sub, 'x', r'\8', 'x')
155 self.assertRaises(re.error, re.sub, 'x', r'\9', 'x')
156 self.assertRaises(re.error, re.sub, 'x', r'\11', 'x')
157 self.assertRaises(re.error, re.sub, 'x', r'\18', 'x')
158 self.assertRaises(re.error, re.sub, 'x', r'\1a', 'x')
159 self.assertRaises(re.error, re.sub, 'x', r'\90', 'x')
160 self.assertRaises(re.error, re.sub, 'x', r'\99', 'x')
161 self.assertRaises(re.error, re.sub, 'x', r'\118', 'x') # r'\11' + '8'
162 self.assertRaises(re.error, re.sub, 'x', r'\11a', 'x')
163 self.assertRaises(re.error, re.sub, 'x', r'\181', 'x') # r'\18' + '1'
164 self.assertRaises(re.error, re.sub, 'x', r'\800', 'x') # r'\80' + '0'
167 self.assertEqual(re.sub('(((((((((((x)))))))))))', r'\11', 'x'), 'x')
168 self.assertEqual(re.sub('((((((((((y))))))))))(.)', r'\118', 'xyz'),
170 self.assertEqual(re.sub('((((((((((y))))))))))(.)', r'\11a', 'xyz'),
174 self.assertEqual(re.sub('a', 'b', 'aaaaa'), 'bbbbb')
175 self.assertEqual(re.sub('a', 'b', 'aaaaa', 1), 'baaaa')
178 self.assertEqual(re.sub(r'(\S)\s+(\S)', r'\1 \2', 'hello there'),
183 self.assertEqual(re.sub('x*', '-', 'abxd'), '-a-b-d-')
184 self.assertEqual(re.sub('x+', '-', 'abxd'), 'ab-d')
187 re.compile('(?P<a>x)(?P=a)(?(a)y)')
188 re.compile('(?P<a1>x)(?P=a1)(?(a1)y)')
189 self.assertRaises(re.error, re.compile, '(?P<a>)(?P<a>)')
190 self.assertRaises(re.error, re.compile, '(?Px)')
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, '(?P=a1)')
195 self.assertRaises(re.error, re.compile, '(?P=a.)')
196 self.assertRaises(re.error, re.compile, '(?P<)')
197 self.assertRaises(re.error, re.compile, '(?P<>)')
198 self.assertRaises(re.error, re.compile, '(?P<1>)')
199 self.assertRaises(re.error, re.compile, '(?P<a.>)')
200 self.assertRaises(re.error, re.compile, '(?())')
201 self.assertRaises(re.error, re.compile, '(?(a))')
202 self.assertRaises(re.error, re.compile, '(?(1a))')
203 self.assertRaises(re.error, re.compile, '(?(a.))')
206 self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<a', 'xx')
207 self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<', 'xx')
208 self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g', 'xx')
209 self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<a a>', 'xx')
210 self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<>', 'xx')
211 self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<1a1>', 'xx')
212 self.assertRaises(IndexError, re.sub, '(?P<a>x)', '\g<ab>', 'xx')
213 self.assertRaises(re.error, re.sub, '(?P<a>x)|(?P<b>y)', '\g<b>', 'xx')
214 self.assertRaises(re.error, re.sub, '(?P<a>x)|(?P<b>y)', '\\2', 'xx')
215 self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<-1>', 'xx')
218 self.assertEqual(re.subn("(?i)b+", "x", "bbbb BBBB"), ('x x', 2))
219 self.assertEqual(re.subn("b+", "x", "bbbb BBBB"), ('x BBBB', 1))
220 self.assertEqual(re.subn("b+", "x", "xyz"), ('xyz', 0))
221 self.assertEqual(re.subn("b*", "x", "xyz"), ('xxxyxzx', 4))
222 self.assertEqual(re.subn("b*", "x", "xyz", 2), ('xxxyz', 2))
225 self.assertEqual(re.split(":", ":a:b::c"), ['', 'a', 'b', '', 'c'])
226 self.assertEqual(re.split(":*", ":a:b::c"), ['', 'a', 'b', 'c'])
227 self.assertEqual(re.split("(:*)", ":a:b::c"),
229 self.assertEqual(re.split("(?::*)", ":a:b::c"), ['', 'a', 'b', 'c'])
230 self.assertEqual(re.split("(:)*", ":a:b::c"),
232 self.assertEqual(re.split("([b:]+)", ":a:b::c"),
234 self.assertEqual(re.split("(b)|(:+)", ":a:b::c"),
237 self.assertEqual(re.split("(?:b)|(?::+)", ":a:b::c"),
241 self.assertEqual(re.split(":", ":a:b::c", 2), ['', 'a', 'b::c'])
242 self.assertEqual(re.split(':', 'a:b:c:d', 2), ['a', 'b', 'c:d'])
243 self.assertEqual(re.split("(:)", ":a:b::c", 2),
245 self.assertEqual(re.split("(:*)", ":a:b::c", 2),
249 self.assertEqual(re.findall(":+", "abc"), [])
250 self.assertEqual(re.findall(":+", "a:b::c:::d"), [":", "::", ":::"])
251 self.assertEqual(re.findall("(:+)", "a:b::c:::d"), [":", "::", ":::"])
252 self.assertEqual(re.findall("(:)(:*)", "a:b::c:::d"), [(":", ""),
257 self.assertEqual(re.findall(r"(a|(b))", "aba"),
261 self.assertEqual(re.match('a', 'a').groups(), ())
262 self.assertEqual(re.match('(a)', 'a').groups(), ('a',))
263 self.assertEqual(re.match(r'(a)', 'a').group(0), 'a')
264 self.assertEqual(re.match(r'(a)', 'a').group(1), 'a')
265 self.assertEqual(re.match(r'(a)', 'a').group(1, 1), ('a', 'a'))
267 pat = re.compile('((a)|(b))(c)?')
275 m = re.match('(a)', 'a')
281 pat = re.compile('(?:(?P<a1>a)|(?P<b2>b))(?P<c3>c)?')
288 self.assertEqual(re.match('^(\()?([^()]+)(?(1)\))$', '(a)').groups(),
290 self.assertEqual(re.match('^(\()?([^()]+)(?(1)\))$', 'a').groups(),
292 self.assertIsNone(re.match('^(\()?([^()]+)(?(1)\))$', 'a)'))
293 self.assertIsNone(re.match('^(\()?([^()]+)(?(1)\))$', '(a'))
294 self.assertEqual(re.match('^(?:(a)|c)((?(1)b|d))$', 'ab').groups(),
296 self.assertEqual(re.match('^(?:(a)|c)((?(1)b|d))$', 'cd').groups(),
298 self.assertEqual(re.match('^(?:(a)|c)((?(1)|d))$', 'cd').groups(),
300 self.assertEqual(re.match('^(?:(a)|c)((?(1)|d))$', 'a').groups(),
304 p = re.compile('(?P<g1>a)(?P<g2>b)?((?(g2)c|d))')
314 self.assertEqual(re.match(r'^(\|)?([^()]+)\1$', '|a|').groups(),
316 self.assertEqual(re.match(r'^(\|)?([^()]+)\1?$', 'a').groups(),
318 self.assertIsNone(re.match(r'^(\|)?([^()]+)\1$', 'a|'))
319 self.assertIsNone(re.match(r'^(\|)?([^()]+)\1$', '|a'))
320 self.assertEqual(re.match(r'^(?:(a)|c)(\1)$', 'aa').groups(),
322 self.assertEqual(re.match(r'^(?:(a)|c)(\1)?$', 'c').groups(),
326 self.assertEqual(re.match('(?P<first>first) (?P<second>second)',
331 self.assertEqual(re.match("(?P<first>first) (?P<second>second)",
337 self.assertIsNone(re.match("^(\w){1}$", "abc"))
338 self.assertIsNone(re.match("^(\w){1}?$", "abc"))
339 self.assertIsNone(re.match("^(\w){1,2}$", "abc"))
340 self.assertIsNone(re.match("^(\w){1,2}?$", "abc"))
342 self.assertEqual(re.match("^(\w){3}$", "abc").group(1), "c")
343 self.assertEqual(re.match("^(\w){1,3}$", "abc").group(1), "c")
344 self.assertEqual(re.match("^(\w){1,4}$", "abc").group(1), "c")
345 self.assertEqual(re.match("^(\w){3,4}?$", "abc").group(1), "c")
346 self.assertEqual(re.match("^(\w){3}?$", "abc").group(1), "c")
347 self.assertEqual(re.match("^(\w){1,3}?$", "abc").group(1), "c")
348 self.assertEqual(re.match("^(\w){1,4}?$", "abc").group(1), "c")
349 self.assertEqual(re.match("^(\w){3,4}?$", "abc").group(1), "c")
351 self.assertIsNone(re.match("^x{1}$", "xxx"))
352 self.assertIsNone(re.match("^x{1}?$", "xxx"))
353 self.assertIsNone(re.match("^x{1,2}$", "xxx"))
354 self.assertIsNone(re.match("^x{1,2}?$", "xxx"))
356 self.assertTrue(re.match("^x{3}$", "xxx"))
357 self.assertTrue(re.match("^x{1,3}$", "xxx"))
358 self.assertTrue(re.match("^x{1,4}$", "xxx"))
359 self.assertTrue(re.match("^x{3,4}?$", "xxx"))
360 self.assertTrue(re.match("^x{3}?$", "xxx"))
361 self.assertTrue(re.match("^x{1,3}?$", "xxx"))
362 self.assertTrue(re.match("^x{1,4}?$", "xxx"))
363 self.assertTrue(re.match("^x{3,4}?$", "xxx"))
365 self.assertIsNone(re.match("^x{}$", "xxx"))
366 self.assertTrue(re.match("^x{}$", "x{}"))
369 self.assertEqual(re.match("(a)", "a").pos, 0)
370 self.assertEqual(re.match("(a)", "a").endpos, 1)
371 self.assertEqual(re.match("(a)", "a").string, "a")
372 self.assertEqual(re.match("(a)", "a").regs, ((0, 1), (0, 1)))
373 self.assertTrue(re.match("(a)", "a").re)
376 self.assertEqual(re.search(r"\b(b.)\b",
378 self.assertEqual(re.search(r"\B(b.)\B",
380 self.assertEqual(re.search(r"\b(b.)\b",
381 "abcd abc bcd bx", re.LOCALE).group(1), "bx")
382 self.assertEqual(re.search(r"\B(b.)\B",
383 "abc bcd bc abxd", re.LOCALE).group(1), "bx")
385 self.assertEqual(re.search(r"\b(b.)\b",
386 "abcd abc bcd bx", re.UNICODE).group(1), "bx")
387 self.assertEqual(re.search(r"\B(b.)\B",
388 "abc bcd bc abxd", re.UNICODE).group(1), "bx")
389 self.assertEqual(re.search(r"^abc$", "\nabc\n", re.M).group(0), "abc")
390 self.assertEqual(re.search(r"^\Aabc\Z$", "abc", re.M).group(0), "abc")
391 self.assertIsNone(re.search(r"^\Aabc\Z$", "\nabc\n", re.M))
392 self.assertEqual(re.search(r"\b(b.)\b",
394 self.assertEqual(re.search(r"\B(b.)\B",
396 self.assertEqual(re.search(r"^abc$", u"\nabc\n", re.M).group(0), "abc")
397 self.assertEqual(re.search(r"^\Aabc\Z$", u"abc", re.M).group(0), "abc")
398 self.assertIsNone(re.search(r"^\Aabc\Z$", u"\nabc\n", re.M))
399 self.assertEqual(re.search(r"\d\D\w\W\s\S",
401 self.assertEqual(re.search(r"\d\D\w\W\s\S",
402 "1aa! a", re.LOCALE).group(0), "1aa! a")
404 self.assertEqual(re.search(r"\d\D\w\W\s\S",
405 "1aa! a", re.UNICODE).group(0), "1aa! a")
409 self.assertEqual(re.search(r"\b(abc)\b", "abc").group(1),
412 self.assertTrue(re.match(r"\b", "abc"))
414 self.assertTrue(re.search(r"\B", "abc"))
416 self.assertFalse(re.match(r"\B", "abc"))
419 self.assertIsNone(re.search(r"\B", ""))
422 self.assertIsNone(re.search(r"\b", ""))
425 self.assertEqual(len(re.findall(r"\b", "a")), 2)
426 self.assertEqual(len(re.findall(r"\B", "a")), 0)
428 self.assertEqual(len(re.findall(r"\b", " ")), 0)
429 self.assertEqual(len(re.findall(r"\b", " ")), 0)
431 self.assertEqual(len(re.findall(r"\B", " ")), 2)
435 self.assertEqual(re.match(u(r"([\u2222\u2223])"),
437 self.assertEqual(re.match(u(r"([\u2222\u2223])"),
438 unichr(0x2222), re.UNICODE).group(1), unichr(0x2222))
440 self.assertEqual(re.match(r, unichr(0xff01), re.UNICODE).group(), unichr(0xff01))
444 r = re.compile('|'.join(('%d'%x for x in range(10000))))
449 self.assertEqual(re.match("a.b", "a\nb", re.DOTALL).group(0),
451 self.assertEqual(re.match("a.*b", "a\n\nb", re.DOTALL).group(0),
455 self.assertEqual(re.match("(a(?=\s[^a]))", "a b").group(1), "a")
456 self.assertEqual(re.match("(a(?=\s[^a]*))", "a b").group(1), "a")
457 self.assertEqual(re.match("(a(?=\s[abc]))", "a b").group(1), "a")
458 self.assertEqual(re.match("(a(?=\s[abc]*))", "a bc").group(1), "a")
459 self.assertEqual(re.match(r"(a)(?=\s\1)", "a a").group(1), "a")
460 self.assertEqual(re.match(r"(a)(?=\s\1*)", "a aa").group(1), "a")
461 self.assertEqual(re.match(r"(a)(?=\s(abc|a))", "a a").group(1), "a")
463 self.assertEqual(re.match(r"(a(?!\s[^a]))", "a a").group(1), "a")
464 self.assertEqual(re.match(r"(a(?!\s[abc]))", "a d").group(1), "a")
465 self.assertEqual(re.match(r"(a)(?!\s\1)", "a b").group(1), "a")
466 self.assertEqual(re.match(r"(a)(?!\s(abc|a))", "a b").group(1), "a")
469 self.assertTrue(re.match(r'(a)b(?=\1)a', 'aba'))
470 self.assertIsNone(re.match(r'(a)b(?=\1)c', 'abac'))
472 self.assertTrue(re.match(r'(?P<g>a)b(?=(?P=g))a', 'aba'))
473 self.assertIsNone(re.match(r'(?P<g>a)b(?=(?P=g))c', 'abac'))
475 self.assertTrue(re.match(r'(?:(a)|(x))b(?=(?(2)x|c))c', 'abc'))
476 self.assertIsNone(re.match(r'(?:(a)|(x))b(?=(?(2)c|x))c', 'abc'))
477 self.assertTrue(re.match(r'(?:(a)|(x))b(?=(?(2)x|c))c', 'abc'))
478 self.assertIsNone(re.match(r'(?:(a)|(x))b(?=(?(1)b|x))c', 'abc'))
479 self.assertTrue(re.match(r'(?:(a)|(x))b(?=(?(1)c|x))c', 'abc'))
481 self.assertTrue(re.match(r'(a)b(?=(?(2)x|c))(c)', 'abc'))
482 self.assertIsNone(re.match(r'(a)b(?=(?(2)b|x))(c)', 'abc'))
483 self.assertTrue(re.match(r'(a)b(?=(?(1)c|x))(c)', 'abc'))
486 self.assertTrue(re.match(r'ab(?<=b)c', 'abc'))
487 self.assertIsNone(re.match(r'ab(?<=c)c', 'abc'))
488 self.assertIsNone(re.match(r'ab(?<!b)c', 'abc'))
489 self.assertTrue(re.match(r'ab(?<!c)c', 'abc'))
492 re.compile(r'(a)a(?<=\1)c')
495 re.compile(r'(?P<g>a)a(?<=(?P=g))c')
498 re.compile(r'(a)b(?<=(?(1)b|x))c')
501 re.compile(r'(a)b(?<=(?(2)b|x))(c)')
504 self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
505 self.assertEqual(re.match("abc", u"ABC", re.I).group(0), "ABC")
506 self.assertEqual(re.match(r"(a\s[^a])", "a b", re.I).group(1), "a b")
507 self.assertEqual(re.match(r"(a\s[^a]*)", "a bb", re.I).group(1), "a bb")
508 self.assertEqual(re.match(r"(a\s[abc])", "a b", re.I).group(1), "a b")
509 self.assertEqual(re.match(r"(a\s[abc]*)", "a bb", re.I).group(1), "a bb")
510 self.assertEqual(re.match(r"((a)\s\2)", "a a", re.I).group(1), "a a")
511 self.assertEqual(re.match(r"((a)\s\2*)", "a aa", re.I).group(1), "a aa")
512 self.assertEqual(re.match(r"((a)\s(abc|a))", "a a", re.I).group(1), "a a")
513 self.assertEqual(re.match(r"((a)\s(abc|a)*)", "a aa", re.I).group(1), "a aa")
517 self.assertTrue(re.match(ur'K', u(r'\u212a'), re.U | re.I))
518 self.assertTrue(re.match(ur'k', u(r'\u212a'), re.U | re.I))
519 self.assertTrue(re.match(u(r'\u212a'), u'K', re.U | re.I))
520 self.assertTrue(re.match(u(r'\u212a'), u'k', re.U | re.I))
522 self.assertTrue(re.match(ur'S', u(r'\u017f'), re.U | re.I))
523 self.assertTrue(re.match(ur's', u(r'\u017f'), re.U | re.I))
524 self.assertTrue(re.match(u(r'\u017f'), u'S', re.U | re.I))
525 self.assertTrue(re.match(u(r'\u017f'), u's', re.U | re.I))
528 self.assertTrue(re.match(r'[19A]', 'A', re.I))
529 self.assertTrue(re.match(r'[19a]', 'a', re.I))
530 self.assertTrue(re.match(r'[19a]', 'A', re.I))
531 self.assertTrue(re.match(r'[19A]', 'a', re.I))
533 self.assertTrue(re.match(ur'[19A]', u'A', re.U | re.I))
534 self.assertTrue(re.match(ur'[19a]', u'a', re.U | re.I))
535 self.assertTrue(re.match(ur'[19a]', u'A', re.U | re.I))
536 self.assertTrue(re.match(ur'[19A]', u'a', re.U | re.I))
538 self.assertTrue(re.match(u(r'[19K]'), u(r'\u212a'), re.U | re.I))
539 self.assertTrue(re.match(u(r'[19k]'), u(r'\u212a'), re.U | re.I))
540 self.assertTrue(re.match(u(r'[19\u212a]'), u'K', re.U | re.I))
541 self.assertTrue(re.match(u(r'[19\u212a]'), u'k', re.U | re.I))
543 self.assertTrue(re.match(ur'[19S]', u(r'\u017f'), re.U | re.I))
544 self.assertTrue(re.match(ur'[19s]', u(r'\u017f'), re.U | re.I))
545 self.assertTrue(re.match(u(r'[19\u017f]'), u'S', re.U | re.I))
546 self.assertTrue(re.match(u(r'[19\u017f]'), u's', re.U | re.I))
550 self.assertTrue(re.match(r'[9-a]', '_', re.I))
551 self.assertIsNone(re.match(r'[9-A]', '_', re.I))
552 self.assertTrue(re.match(r'[\xc0-\xde]', '\xd7', re.I))
553 self.assertIsNone(re.match(r'[\xc0-\xde]', '\xf7', re.I))
554 self.assertTrue(re.match(r'[\xe0-\xfe]', '\xf7',re.I))
555 self.assertIsNone(re.match(r'[\xe0-\xfe]', '\xd7', re.I))
557 self.assertTrue(re.match(u(r'[9-a]'), u(r'_'), re.U | re.I))
558 self.assertIsNone(re.match(u(r'[9-A]'), u(r'_'), re.U | re.I))
559 self.assertTrue(re.match(u(r'[\xc0-\xde]'),
560 u(r'\xd7'), re.U | re.I))
561 self.assertIsNone(re.match(u(r'[\xc0-\xde]'),
562 u(r'\xf7'), re.U | re.I))
563 self.assertTrue(re.match(u(r'[\xe0-\xfe]'),
564 u(r'\xf7'), re.U | re.I))
565 self.assertIsNone(re.match(u(r'[\xe0-\xfe]'),
566 u(r'\xd7'), re.U | re.I))
567 self.assertTrue(re.match(u(r'[\u0430-\u045f]'),
568 u(r'\u0450'), re.U | re.I))
569 self.assertTrue(re.match(u(r'[\u0430-\u045f]'),
570 u(r'\u0400'), re.U | re.I))
571 self.assertTrue(re.match(u(r'[\u0400-\u042f]'),
572 u(r'\u0450'), re.U | re.I))
573 self.assertTrue(re.match(u(r'[\u0400-\u042f]'),
574 u(r'\u0400'), re.U | re.I))
576 self.assertTrue(re.match(u(r'[\U00010428-\U0001044f]'),
577 u(r'\U00010428'), re.U | re.I))
578 self.assertTrue(re.match(u(r'[\U00010428-\U0001044f]'),
579 u(r'\U00010400'), re.U | re.I))
580 self.assertTrue(re.match(u(r'[\U00010400-\U00010427]'),
581 u(r'\U00010428'), re.U | re.I))
582 self.assertTrue(re.match(u(r'[\U00010400-\U00010427]'),
583 u(r'\U00010400'), re.U | re.I))
586 self.assertTrue(re.match(ur'[J-M]', u(r'\u212a'), re.U | re.I))
587 self.assertTrue(re.match(ur'[j-m]', u(r'\u212a'), re.U | re.I))
588 self.assertTrue(re.match(u(r'[\u2129-\u212b]'), u'K', re.U | re.I))
589 self.assertTrue(re.match(u(r'[\u2129-\u212b]'), u'k', re.U | re.I))
591 self.assertTrue(re.match(ur'[R-T]', u(r'\u017f'), re.U | re.I))
592 self.assertTrue(re.match(ur'[r-t]', u(r'\u017f'), re.U | re.I))
593 self.assertTrue(re.match(u(r'[\u017e-\u0180]'), u'S', re.U | re.I))
594 self.assertTrue(re.match(u(r'[\u017e-\u0180]'), u's', re.U | re.I))
597 self.assertEqual(re.match(r"(\s)", " ").group(1), " ")
602 self.assertEqual(_sre.getlower(ord('A'), re.LOCALE), ord('a'))
604 self.assertEqual(_sre.getlower(ord('A'), re.UNICODE), ord('a'))
606 self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
607 self.assertEqual(re.match("abc", u"ABC", re.I).group(0), "ABC")
610 self.assertEqual(re.search("\s([^a])", " b").group(1), "b")
611 self.assertEqual(re.search("\s([^a]*)", " bb").group(1), "bb")
614 self.assertEqual(re.search("\s(b)", " b").group(1), "b")
615 self.assertEqual(re.search("a\s", "a ").group(0), "a ")
618 matcher=re.match):
637 self.assertEqual(re.escape(c), c)
639 self.assertEqual(re.escape(c), u'\\000')
641 self.assertEqual(re.escape(c), u'\\' + c)
642 self.assertMatch(re.escape(c), c)
643 self.assertMatch(re.escape(p), p)
650 self.assertEqual(re.escape(b), b)
652 self.assertEqual(re.escape(b), b'\\000')
654 self.assertEqual(re.escape(b), b'\\' + b)
655 self.assertMatch(re.escape(b), b)
656 self.assertMatch(re.escape(p), p)
661 s_escaped = re.escape(s)
664 self.assertMatch(u'.%s+.' % re.escape(unichr(0x2620)), s,
665 u(r'x\u2620\u2620\u2620x'), (2, 7), re.search)
669 b_escaped = re.escape(b)
672 res = re.findall(re.escape(b'\xe2\x98\xa0'), b)
684 from re import _compile
687 oldpat = re.compile('a(?:b|(c|e){1,2}?|d)+?(.)')
694 self.assertEqual(re.I, re.IGNORECASE)
695 self.assertEqual(re.L, re.LOCALE)
696 self.assertEqual(re.M, re.MULTILINE)
697 self.assertEqual(re.S, re.DOTALL)
698 self.assertEqual(re.X, re.VERBOSE)
701 for flag in [re.I, re.M, re.X, re.S, re.L]:
702 self.assertTrue(re.compile('^pattern$', flag))
706 self.assertTrue(re.match(r"\%03o" % i, chr(i)))
707 self.assertTrue(re.match(r"\%03o0" % i, chr(i)+"0"))
708 self.assertTrue(re.match(r"\%03o8" % i, chr(i)+"8"))
709 self.assertTrue(re.match(r"\x%02x" % i, chr(i)))
710 self.assertTrue(re.match(r"\x%02x0" % i, chr(i)+"0"))
711 self.assertTrue(re.match(r"\x%02xz" % i, chr(i)+"z"))
712 self.assertRaises(re.error, re.match, "\911", "")
716 self.assertTrue(re.match(r"[\%03o]" % i, chr(i)))
717 self.assertTrue(re.match(r"[\%03o0]" % i, chr(i)))
718 self.assertTrue(re.match(r"[\%03o8]" % i, chr(i)))
719 self.assertTrue(re.match(r"[\x%02x]" % i, chr(i)))
720 self.assertTrue(re.match(r"[\x%02x0]" % i, chr(i)))
721 self.assertTrue(re.match(r"[\x%02xz]" % i, chr(i)))
722 self.assertRaises(re.error, re.match, "[\911]", "")
725 self.assertEqual(re.match(r'(a)|(b)', 'b').start(1), -1)
726 self.assertEqual(re.match(r'(a)|(b)', 'b').end(1), -1)
727 self.assertEqual(re.match(r'(a)|(b)', 'b').span(1), (-1, -1))
731 self.assertIsNone(re.match(r'(a)?a','a').lastindex)
732 self.assertEqual(re.match(r'(a)(b)?b','ab').lastindex, 1)
733 self.assertEqual(re.match(r'(?P<a>a)(?P<b>b)?b','ab').lastgroup, 'a')
734 self.assertEqual(re.match("(?P<a>a(b))", "ab").lastgroup, 'a')
735 self.assertEqual(re.match("((a))", "a").lastindex, 1)
740 self.assertRaises(re.error, re.compile, 'foo[a-')
746 self.assertEqual(re.match('.*?c', 10000*'ab'+'cd').end(0), 20001)
747 self.assertEqual(re.match('.*?cd', 5000*'ab'+'c'+5000*'ab'+'cde').end(0),
749 self.assertEqual(re.match('.*?cd', 20000*'abc'+'de').end(0), 60001)
752 self.assertEqual(re.search('(a|b)*?c', 10000*'ab'+'cd').end(0), 20001)
756 pat=u"["+re.escape(unichr(0x2039))+u"]"
757 self.assertEqual(re.compile(pat) and 1, 1)
762 self.assertEqual(re.match('(x)*', 50000*'x').group(1), 'x')
763 self.assertEqual(re.match('(x)*y', 50000*'x'+'y').group(1), 'x')
764 self.assertEqual(re.match('(x)*?y', 50000*'x'+'y').group(1), 'x')
768 self.assertIsNone(re.match(r'(?:a?)*y', 'z'))
769 self.assertIsNone(re.match(r'(?:a?)+y', 'z'))
770 self.assertIsNone(re.match(r'(?:a?){2,}y', 'z'))
771 self.assertIsNone(re.match(r'(?:a?)*?y', 'z'))
772 self.assertIsNone(re.match(r'(?:a?)+?y', 'z'))
773 self.assertIsNone(re.match(r'(?:a?){2,}?y', 'z'))
799 self.assertEqual(re.match(r'((.%s):)?z'%op, 'z').groups(),
801 self.assertEqual(re.match(r'((.%s):)?z'%op, 'a:z').groups(),
806 self.assertEqual(re.match('^((a)|b)*', 'abc').groups(),
808 self.assertEqual(re.match('^(([ab])|c)*', 'abc').groups(),
810 self.assertEqual(re.match('^((d)|[ab])*', 'abc').groups(),
812 self.assertEqual(re.match('^((a)c|[ab])*', 'abc').groups(),
814 self.assertEqual(re.match('^((a)|b)*?c', 'abc').groups(),
816 self.assertEqual(re.match('^(([ab])|c)*?d', 'abcd').groups(),
818 self.assertEqual(re.match('^((d)|[ab])*?c', 'abc').groups(),
820 self.assertEqual(re.match('^((a)c|[ab])*?c', 'abc').groups(),
825 self.assertEqual(re.match('(a)(?:(?=(b)*)c)*', 'abb').groups(),
827 self.assertEqual(re.match('(a)((?!(b)*))*', 'abb').groups(),
834 pat = re.compile(my_unicode("abc"))
838 iter = re.finditer(r":+", "a:b::c:::d")
844 self.assertIsNot(re.compile('bug_926075'),
845 re.compile(u'bug_926075'))
850 self.assertEqual(re.compile(pattern).split("a.b.c"),
854 iter = re.finditer(r"\s", "a b")
858 scanner = re.compile(r"\s").scanner("a b")
863 iter = re.finditer(r".*", "asdf")
879 self.assertEqual(re.match('^\d$', x, re.UNICODE).group(0), x)
888 self.assertIsNone(re.match('^\d$', x, re.UNICODE))
898 self.assertIsNone(re.compile("bla").match(a))
899 self.assertEqual(re.compile("").match(a).groups(), ())
907 p = re.compile(upper_char, re.I | re.U)
911 p = re.compile(lower_char, re.I | re.U)
915 p = re.compile('(?i)' + upper_char, re.U)
919 p = re.compile('(?i)' + lower_char, re.U)
923 p = re.compile('(?iu)' + upper_char)
927 p = re.compile('(?iu)' + lower_char)
931 self.assertTrue(re.match('(?ixu) ' + upper_char, lower_char))
932 self.assertTrue(re.match('(?ixu) ' + lower_char, upper_char))
936 pattern = re.compile('$')
941 pattern = re.compile('$', re.MULTILINE)
954 self.assertRaises(TypeError, re.finditer, "a", {})
959 pattern = re.compile('random pattern')
960 self.assertIsInstance(pattern, re._pattern_type)
961 same_pattern = re.compile(pattern)
962 self.assertIsInstance(same_pattern, re._pattern_type)
965 self.assertRaises(TypeError, re.compile, 0)
970 self.assertEqual(re.findall(r'[\A\B\b\C\Z]', 'AB\bCZ'),
977 m = re.search('$', s)
988 r, n = re.subn('', '', s)
996 self.assertEqual(re.match(r".{65535}", string).span(), (0, 65535))
997 self.assertEqual(re.match(r".{,65535}", string).span(), (0, 65535))
998 self.assertEqual(re.match(r".{65535,}?", string).span(), (0, 65535))
999 self.assertEqual(re.match(r".{65536}", string).span(), (0, 65536))
1000 self.assertEqual(re.match(r".{,65536}", string).span(), (0, 65536))
1001 self.assertEqual(re.match(r".{65536,}?", string).span(), (0, 65536))
1003 self.assertRaises(OverflowError, re.compile, r".{%d}" % 2**128)
1004 self.assertRaises(OverflowError, re.compile, r".{,%d}" % 2**128)
1005 self.assertRaises(OverflowError, re.compile, r".{%d,}?" % 2**128)
1006 self.assertRaises(OverflowError, re.compile, r".{%d,%d}" % (2**129, 2**128))
1015 self.assertIsNone(re.match(r".{%d}" % (MAXREPEAT - 1), string))
1016 self.assertEqual(re.match(r".{,%d}" % (MAXREPEAT - 1), string).span(),
1018 self.assertIsNone(re.match(r".{%d,}?" % (MAXREPEAT - 1), string))
1019 self.assertRaises(OverflowError, re.compile, r".{%d}" % MAXREPEAT)
1020 self.assertRaises(OverflowError, re.compile, r".{,%d}" % MAXREPEAT)
1021 self.assertRaises(OverflowError, re.compile, r".{%d,}?" % MAXREPEAT)
1026 re.compile('(?P=<foo>)')
1031 re.compile('(?P<?foo>)')
1037 self.assertEqual(re.compile(pattern, re.S).findall('xyz'),
1041 self.assertEqual(re.compile(pattern, re.S).findall(u'xyz'),
1049 r = re.compile("^((x|y)%s)%s" % (inner_op, outer_op))
1058 re.compile(pat, re.DEBUG)
1081 re.compile(pat, re.DEBUG)
1086 pat = re.compile(r'(ab)')
1098 self.assertEqual(re.match("(foo)", "foo").group(1L), "foo")
1099 self.assertRaises(IndexError, re.match("", "").group, sys.maxint + 1)
1112 re.purge()
1115 re.purge()
1121 self.assertTrue(re.match(b'\xc5\xe5', b'\xc5\xe5', re.L|re.I))
1122 self.assertTrue(re.match(b'\xc5', b'\xe5', re.L|re.I))
1123 self.assertTrue(re.match(b'\xe5', b'\xc5', re.L|re.I))
1124 self.assertTrue(re.match(b'(?Li)\xc5\xe5', b'\xc5\xe5'))
1125 self.assertTrue(re.match(b'(?Li)\xc5', b'\xe5'))
1126 self.assertTrue(re.match(b'(?Li)\xe5', b'\xc5'))
1130 self.assertTrue(re.match(b'\xc5\xe5', b'\xc5\xe5', re.L|re.I))
1131 self.assertIsNone(re.match(b'\xc5', b'\xe5', re.L|re.I))
1132 self.assertIsNone(re.match(b'\xe5', b'\xc5', re.L|re.I))
1133 self.assertTrue(re.match(b'(?Li)\xc5\xe5', b'\xc5\xe5'))
1134 self.assertIsNone(re.match(b'(?Li)\xc5', b'\xe5'))
1135 self.assertIsNone(re.match(b'(?Li)\xe5', b'\xc5'))
1158 obj = re.compile(pattern)
1159 except re.error:
1171 except re.error, msg:
1186 'flags': result.re.flags}
1196 for i in result.re.groupindex.keys():
1224 obj=re.compile(unicode(pattern, "latin-1"))
1236 obj = re.compile(pattern)
1243 obj = re.compile(pattern, re.IGNORECASE)
1250 obj = re.compile(pattern, re.LOCALE)
1257 obj = re.compile(pattern, re.UNICODE)