Lines Matching refs:re
6 import re
12 from re import Scanner
23 # Misc tests from Tim Peters' re.doc
26 # what you're doing. Some of these tests were carefully modeled to
50 with self.assertRaises(re.error) as cm:
51 re.compile(pattern)
59 with self.assertRaises(re.error) as cm:
60 re.sub(pattern, repl, string)
70 it = re.finditer(b'a', b)
80 x = re.compile('ab+c')
85 self.assertEqual(re.search('x*', 'axx').span(0), (0, 0))
86 self.assertEqual(re.search('x*', 'axx').span(), (0, 0))
87 self.assertEqual(re.search('x+', 'axx').span(0), (1, 3))
88 self.assertEqual(re.search('x+', 'axx').span(), (1, 3))
89 self.assertIsNone(re.search('x', 'aaa'))
90 self.assertEqual(re.match('a*', 'xxx').span(0), (0, 0))
91 self.assertEqual(re.match('a*', 'xxx').span(), (0, 0))
92 self.assertEqual(re.match('x*', 'xxxa').span(0), (0, 3))
93 self.assertEqual(re.match('x*', 'xxxa').span(), (0, 3))
94 self.assertIsNone(re.match('a+', 'xxx'))
99 self.assertEqual(re.match('(ab|ba)', 'ab').span(), (0, 2))
100 self.assertEqual(re.match('(ab|ba)', 'ba').span(), (0, 2))
101 self.assertEqual(re.match('(abc|bac|ca|cb)', 'abc').span(),
103 self.assertEqual(re.match('(abc|bac|ca|cb)', 'bac').span(),
105 self.assertEqual(re.match('(abc|bac|ca|cb)', 'ca').span(),
107 self.assertEqual(re.match('(abc|bac|ca|cb)', 'cb').span(),
109 self.assertEqual(re.match('((a)|(b)|(c))', 'a').span(), (0, 1))
110 self.assertEqual(re.match('((a)|(b)|(c))', 'b').span(), (0, 1))
111 self.assertEqual(re.match('((a)|(b)|(c))', 'c').span(), (0, 1))
118 self.assertTypedEqual(re.sub('y', 'a', 'xyz'), 'xaz')
119 self.assertTypedEqual(re.sub('y', S('a'), S('xyz')), 'xaz')
120 self.assertTypedEqual(re.sub(b'y', b'a', b'xyz'), b'xaz')
121 self.assertTypedEqual(re.sub(b'y', B(b'a'), B(b'xyz')), b'xaz')
122 self.assertTypedEqual(re.sub(b'y', bytearray(b'a'), bytearray(b'xyz')), b'xaz')
123 self.assertTypedEqual(re.sub(b'y', memoryview(b'a'), memoryview(b'xyz')), b'xaz')
125 self.assertEqual(re.sub(y, 'a', 'x%sz' % y), 'xaz')
127 self.assertEqual(re.sub("(?i)b+", "x", "bbbb BBBB"), 'x x')
128 self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y'),
130 self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y', 3),
132 self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y', count=3),
135 self.assertEqual(re.sub('.', lambda m: r"\n", 'x'), '\\n')
136 self.assertEqual(re.sub('.', r"\n", 'x'), '\n')
139 self.assertEqual(re.sub('(.)', s, 'x'), 'xx')
140 self.assertEqual(re.sub('(.)', s.replace('\\', r'\\'), 'x'), s)
141 self.assertEqual(re.sub('(.)', lambda m: s, 'x'), s)
143 self.assertEqual(re.sub('(?P<a>x)', r'\g<a>\g<a>', 'xx'), 'xxxx')
144 self.assertEqual(re.sub('(?P<a>x)', r'\g<a>\g<1>', 'xx'), 'xxxx')
145 self.assertEqual(re.sub('(?P<unk>x)', r'\g<unk>\g<unk>', 'xx'), 'xxxx')
146 self.assertEqual(re.sub('(?P<unk>x)', r'\g<1>\g<1>', 'xx'), 'xxxx')
147 self.assertEqual(re.sub('()x', r'\g<0>\g<0>', 'xx'), 'xxxx')
149 self.assertEqual(re.sub('a', r'\t\n\v\r\f\a\b', 'a'), '\t\n\v\r\f\a\b')
150 self.assertEqual(re.sub('a', '\t\n\v\r\f\a\b', 'a'), '\t\n\v\r\f\a\b')
151 self.assertEqual(re.sub('a', '\t\n\v\r\f\a\b', 'a'),
155 with self.assertRaises(re.error):
156 self.assertEqual(re.sub('a', '\\' + c, 'a'), '\\' + c)
158 self.assertEqual(re.sub(r'^\s*', 'X', 'test'), 'Xtest')
162 self.assertEqual(re.sub(r'(?P<unk>x)', r'\g<1>\g<1>\b', 'xx'),
167 self.assertEqual(re.sub(r'\r\n', r'\n', 'abc\r\ndef\r\n'),
169 self.assertEqual(re.sub('\r\n', r'\n', 'abc\r\ndef\r\n'),
171 self.assertEqual(re.sub(r'\r\n', '\n', 'abc\r\ndef\r\n'),
173 self.assertEqual(re.sub('\r\n', '\n', 'abc\r\ndef\r\n'),
178 pattern = re.compile('.')
179 self.assertRaises(ValueError, re.match, pattern, 'A', re.I)
180 self.assertRaises(ValueError, re.search, pattern, 'A', re.I)
181 self.assertRaises(ValueError, re.findall, pattern, 'A', re.I)
182 self.assertRaises(ValueError, re.compile, pattern, re.I)
186 re.compile("(?P<quote>)(?(quote))")
190 self.assertEqual(re.sub('x', r'\0', 'x'), '\0')
191 self.assertEqual(re.sub('x', r'\000', 'x'), '\000')
192 self.assertEqual(re.sub('x', r'\001', 'x'), '\001')
193 self.assertEqual(re.sub('x', r'\008', 'x'), '\0' + '8')
194 self.assertEqual(re.sub('x', r'\009', 'x'), '\0' + '9')
195 self.assertEqual(re.sub('x', r'\111', 'x'), '\111')
196 self.assertEqual(re.sub('x', r'\117', 'x'), '\117')
197 self.assertEqual(re.sub('x', r'\377', 'x'), '\377')
199 self.assertEqual(re.sub('x', r'\1111', 'x'), '\1111')
200 self.assertEqual(re.sub('x', r'\1111', 'x'), '\111' + '1')
202 self.assertEqual(re.sub('x', r'\00', 'x'), '\x00')
203 self.assertEqual(re.sub('x', r'\07', 'x'), '\x07')
204 self.assertEqual(re.sub('x', r'\08', 'x'), '\0' + '8')
205 self.assertEqual(re.sub('x', r'\09', 'x'), '\0' + '9')
206 self.assertEqual(re.sub('x', r'\0a', 'x'), '\0' + 'a')
230 self.assertEqual(re.sub('(((((((((((x)))))))))))', r'\11', 'x'), 'x')
231 self.assertEqual(re.sub('((((((((((y))))))))))(.)', r'\118', 'xyz'),
233 self.assertEqual(re.sub('((((((((((y))))))))))(.)', r'\11a', 'xyz'),
237 self.assertEqual(re.sub('a', 'b', 'aaaaa'), 'bbbbb')
238 self.assertEqual(re.sub('a', 'b', 'aaaaa', 1), 'baaaa')
239 self.assertEqual(re.sub('a', 'b', 'aaaaa', count=1), 'baaaa')
242 self.assertEqual(re.sub(r'(\S)\s+(\S)', r'\1 \2', 'hello there'),
246 re.compile(r'(?P<a>x)(?P=a)(?(a)y)')
247 re.compile(r'(?P<a1>x)(?P=a1)(?(a1)y)')
248 re.compile(r'(?P<a1>x)\1(?(1)y)')
249 re.compile(b'(?P<a1>x)(?P=a1)(?(a1)y)')
251 re.compile('(?P<µ>x)(?P=µ)(?(µ)y)')
252 re.compile('(?P<???????>x)(?P=???????)(?(???????)y)')
256 self.assertEqual(re.match(pat, 'xc8yz').span(), (0, 5))
290 re.compile(b'(?P<\xc2\xb5>x)')
304 self.assertEqual(re.sub('(?P<a>x)|(?P<b>y)', r'\g<b>', 'xx'), '')
305 self.assertEqual(re.sub('(?P<a>x)|(?P<b>y)', r'\2', 'xx'), '')
306 self.assertEqual(re.sub(b'(?P<a1>x)', br'\g<a1>', b'xx'), b'xx')
308 self.assertEqual(re.sub('(?P<µ>x)', r'\g<µ>', 'xx'), 'xx')
309 self.assertEqual(re.sub('(?P<???????>x)', r'\g<???????>', 'xx'), 'xx')
312 self.assertEqual(re.sub(pat, r'\g<200>', 'xc8yzxc8y'), 'c8zc8')
331 re.sub('(?P<a>x)', r'\g<ab>', 'xx')
337 re.sub('(?P<a>x)', r'\g<+1>', 'xx')
342 re.sub('()'*10, r'\g<1_0>', 'xx')
346 re.sub('(?P<a>x)', r'\g< 1 >', 'xx')
353 re.sub(b'(?P<a>x)', b'\\g<\xc2\xb5>', b'xx')
362 re.sub('(?P<a>x)', r'\g<१>', 'xx')
365 self.assertEqual(re.subn("(?i)b+", "x", "bbbb BBBB"), ('x x', 2))
366 self.assertEqual(re.subn("b+", "x", "bbbb BBBB"), ('x BBBB', 1))
367 self.assertEqual(re.subn("b+", "x", "xyz"), ('xyz', 0))
368 self.assertEqual(re.subn("b*", "x", "xyz"), ('xxxyxzx', 4))
369 self.assertEqual(re.subn("b*", "x", "xyz", 2), ('xxxyz', 2))
370 self.assertEqual(re.subn("b*", "x", "xyz", count=2), ('xxxyz', 2))
374 self.assertTypedEqual(re.split(":", string),
376 self.assertTypedEqual(re.split(":+", string),
378 self.assertTypedEqual(re.split("(:+)", string),
382 self.assertTypedEqual(re.split(b":", string),
384 self.assertTypedEqual(re.split(b":+", string),
386 self.assertTypedEqual(re.split(b"(:+)", string),
391 self.assertEqual(re.split(":", string), ['', a, b, '', c])
392 self.assertEqual(re.split(":+", string), ['', a, b, c])
393 self.assertEqual(re.split("(:+)", string),
396 self.assertEqual(re.split("(?::+)", ":a:b::c"), ['', 'a', 'b', 'c'])
397 self.assertEqual(re.split("(:)+", ":a:b::c"),
399 self.assertEqual(re.split("([b:]+)", ":a:b::c"),
401 self.assertEqual(re.split("(b)|(:+)", ":a:b::c"),
404 self.assertEqual(re.split("(?:b)|(?::+)", ":a:b::c"),
414 self.assertTypedEqual(re.split(sep, ':a:b::c'), expected)
423 self.assertTypedEqual(re.split(sep, ':a:b::c'), expected)
426 self.assertEqual(re.split(":", ":a:b::c", 2), ['', 'a', 'b::c'])
427 self.assertEqual(re.split(":", ":a:b::c", maxsplit=2), ['', 'a', 'b::c'])
428 self.assertEqual(re.split(':', 'a:b:c:d', maxsplit=2), ['a', 'b', 'c:d'])
429 self.assertEqual(re.split("(:)", ":a:b::c", maxsplit=2),
431 self.assertEqual(re.split("(:+)", ":a:b::c", maxsplit=2),
433 self.assertEqual(re.split("(:*)", ":a:b::c", maxsplit=2),
437 self.assertEqual(re.findall(":+", "abc"), [])
439 self.assertTypedEqual(re.findall(":+", string),
441 self.assertTypedEqual(re.findall("(:+)", string),
443 self.assertTypedEqual(re.findall("(:)(:*)", string),
447 self.assertTypedEqual(re.findall(b":+", string),
449 self.assertTypedEqual(re.findall(b"(:+)", string),
451 self.assertTypedEqual(re.findall(b"(:)(:*)", string),
457 self.assertEqual(re.findall("%s+" % x, string), [x, xx, xxx])
458 self.assertEqual(re.findall("(%s+)" % x, string), [x, xx, xxx])
459 self.assertEqual(re.findall("(%s)(%s*)" % (x, x), string),
463 self.assertEqual(re.findall(r"(a|(b))", "aba"),
468 self.assertEqual(re.match('a', string).groups(), ())
469 self.assertEqual(re.match('(a)', string).groups(), ('a',))
470 self.assertEqual(re.match('(a)', string).group(0), 'a')
471 self.assertEqual(re.match('(a)', string).group(1), 'a')
472 self.assertEqual(re.match('(a)', string).group(1, 1), ('a', 'a'))
474 self.assertEqual(re.match(b'a', string).groups(), ())
475 self.assertEqual(re.match(b'(a)', string).groups(), (b'a',))
476 self.assertEqual(re.match(b'(a)', string).group(0), b'a')
477 self.assertEqual(re.match(b'(a)', string).group(1), b'a')
478 self.assertEqual(re.match(b'(a)', string).group(1, 1), (b'a', b'a'))
480 self.assertEqual(re.match(a, a).groups(), ())
481 self.assertEqual(re.match('(%s)' % a, a).groups(), (a,))
482 self.assertEqual(re.match('(%s)' % a, a).group(0), a)
483 self.assertEqual(re.match('(%s)' % a, a).group(1), a)
484 self.assertEqual(re.match('(%s)' % a, a).group(1, 1), (a, a))
486 pat = re.compile('((a)|(b))(c)?')
493 pat = re.compile('(?:(?P<a1>a)|(?P<b2>b))(?P<c3>c)?')
506 m = re.match('(a)(b)', 'ab')
521 pat = re.compile('(?:(?P<a1>a)|(?P<b2>b))(?P<c3>c)?')
565 # Issue 16203: Proposal: add re.fullmatch() method.
566 self.assertEqual(re.fullmatch(r"a", "a").span(), (0, 1))
568 self.assertEqual(re.fullmatch(r"a|ab", string).span(), (0, 2))
570 self.assertEqual(re.fullmatch(br"a|ab", string).span(), (0, 2))
573 self.assertEqual(re.fullmatch(r, a + b).span(), (0, 2))
574 self.assertEqual(re.fullmatch(r".*?$", "abc").span(), (0, 3))
575 self.assertEqual(re.fullmatch(r".*?", "abc").span(), (0, 3))
576 self.assertEqual(re.fullmatch(r"a.*?b", "ab").span(), (0, 2))
577 self.assertEqual(re.fullmatch(r"a.*?b", "abb").span(), (0, 3))
578 self.assertEqual(re.fullmatch(r"a.*?b", "axxb").span(), (0, 4))
579 self.assertIsNone(re.fullmatch(r"a+", "ab"))
580 self.assertIsNone(re.fullmatch(r"abc$", "abc\n"))
581 self.assertIsNone(re.fullmatch(r"abc\Z", "abc\n"))
582 self.assertIsNone(re.fullmatch(r"(?m)abc$", "abc\n"))
583 self.assertEqual(re.fullmatch(r"ab(?=c)cd", "abcd").span(), (0, 4))
584 self.assertEqual(re.fullmatch(r"ab(?<=b)cd", "abcd").span(), (0, 4))
585 self.assertEqual(re.fullmatch(r"(?=a|ab)ab", "ab").span(), (0, 2))
588 re.compile(r"bc").fullmatch("abcd", pos=1, endpos=3).span(), (1, 3))
590 re.compile(r".*?$").fullmatch("abcd", pos=1, endpos=3).span(), (1, 3))
592 re.compile(r".*?").fullmatch("abcd", pos=1, endpos=3).span(), (1, 3))
595 self.assertEqual(re.match(r'^(\()?([^()]+)(?(1)\))$', '(a)').groups(),
597 self.assertEqual(re.match(r'^(\()?([^()]+)(?(1)\))$', 'a').groups(),
599 self.assertIsNone(re.match(r'^(\()?([^()]+)(?(1)\))$', 'a)'))
600 self.assertIsNone(re.match(r'^(\()?([^()]+)(?(1)\))$', '(a'))
601 self.assertEqual(re.match('^(?:(a)|c)((?(1)b|d))$', 'ab').groups(),
603 self.assertEqual(re.match(r'^(?:(a)|c)((?(1)b|d))$', 'cd').groups(),
605 self.assertEqual(re.match(r'^(?:(a)|c)((?(1)|d))$', 'cd').groups(),
607 self.assertEqual(re.match(r'^(?:(a)|c)((?(1)|d))$', 'a').groups(),
611 p = re.compile('(?P<g1>a)(?P<g2>b)?((?(g2)c|d))')
622 self.assertEqual(re.match(pat, 'xc8yz').span(), (0, 5))
631 re.compile(r'()(?(+1)a|b)')
636 re.compile(r'()'*10 + r'(?(1_0)a|b)')
640 re.compile(r'()(?( 1 )a|b)')
648 re.compile(r'()(?(१)a|b)')
667 re.compile(r'()(?(1)\x%02x?)' % i)
670 from re._constants import MAXGROUPS
677 self.assertEqual(re.match(r'^(\|)?([^()]+)\1$', '|a|').groups(),
679 self.assertEqual(re.match(r'^(\|)?([^()]+)\1?$', 'a').groups(),
681 self.assertIsNone(re.match(r'^(\|)?([^()]+)\1$', 'a|'))
682 self.assertIsNone(re.match(r'^(\|)?([^()]+)\1$', '|a'))
683 self.assertEqual(re.match(r'^(?:(a)|c)(\1)$', 'aa').groups(),
685 self.assertEqual(re.match(r'^(?:(a)|c)(\1)?$', 'c').groups(),
691 self.assertEqual(re.match('(?P<first>first) (?P<second>second)',
696 self.assertEqual(re.match("(?P<first>first) (?P<second>second)",
700 self.assertEqual(re.match("(?P<first>first)|(?P<second>second)",
706 self.assertIsNone(re.match(r"^(\w){1}$", "abc"))
707 self.assertIsNone(re.match(r"^(\w){1}?$", "abc"))
708 self.assertIsNone(re.match(r"^(\w){1,2}$", "abc"))
709 self.assertIsNone(re.match(r"^(\w){1,2}?$", "abc"))
711 self.assertEqual(re.match(r"^(\w){3}$", "abc").group(1), "c")
712 self.assertEqual(re.match(r"^(\w){1,3}$", "abc").group(1), "c")
713 self.assertEqual(re.match(r"^(\w){1,4}$", "abc").group(1), "c")
714 self.assertEqual(re.match(r"^(\w){3,4}?$", "abc").group(1), "c")
715 self.assertEqual(re.match(r"^(\w){3}?$", "abc").group(1), "c")
716 self.assertEqual(re.match(r"^(\w){1,3}?$", "abc").group(1), "c")
717 self.assertEqual(re.match(r"^(\w){1,4}?$", "abc").group(1), "c")
718 self.assertEqual(re.match(r"^(\w){3,4}?$", "abc").group(1), "c")
720 self.assertIsNone(re.match(r"^x{1}$", "xxx"))
721 self.assertIsNone(re.match(r"^x{1}?$", "xxx"))
722 self.assertIsNone(re.match(r"^x{1,2}$", "xxx"))
723 self.assertIsNone(re.match(r"^x{1,2}?$", "xxx"))
725 self.assertTrue(re.match(r"^x{3}$", "xxx"))
726 self.assertTrue(re.match(r"^x{1,3}$", "xxx"))
727 self.assertTrue(re.match(r"^x{3,3}$", "xxx"))
728 self.assertTrue(re.match(r"^x{1,4}$", "xxx"))
729 self.assertTrue(re.match(r"^x{3,4}?$", "xxx"))
730 self.assertTrue(re.match(r"^x{3}?$", "xxx"))
731 self.assertTrue(re.match(r"^x{1,3}?$", "xxx"))
732 self.assertTrue(re.match(r"^x{1,4}?$", "xxx"))
733 self.assertTrue(re.match(r"^x{3,4}?$", "xxx"))
735 self.assertIsNone(re.match(r"^x{}$", "xxx"))
736 self.assertTrue(re.match(r"^x{}$", "x{}"))
742 self.assertEqual(re.compile("(?i)(a)(b)").pattern, "(?i)(a)(b)")
743 self.assertEqual(re.compile("(?i)(a)(b)").flags, re.I | re.U)
744 self.assertEqual(re.compile("(?i)(a)(b)").groups, 2)
745 self.assertEqual(re.compile("(?i)(a)(b)").groupindex, {})
746 self.assertEqual(re.compile("(?i)(?P<first>a)(?P<other>b)").groupindex,
749 self.assertEqual(re.match("(a)", "a").pos, 0)
750 self.assertEqual(re.match("(a)", "a").endpos, 1)
751 self.assertEqual(re.match("(a)", "a").string, "a")
752 self.assertEqual(re.match("(a)", "a").regs, ((0, 1), (0, 1)))
753 self.assertTrue(re.match("(a)", "a").re)
756 p = re.compile(r'(?i)(?P<first>a)(?P<other>b)')
764 self.assertEqual(re.search(r"\b(b.)\b",
766 self.assertEqual(re.search(r"\B(b.)\B",
768 self.assertEqual(re.search(r"\b(b.)\b",
769 "abcd abc bcd bx", re.ASCII).group(1), "bx")
770 self.assertEqual(re.search(r"\B(b.)\B",
771 "abc bcd bc abxd", re.ASCII).group(1), "bx")
772 self.assertEqual(re.search(r"^abc$", "\nabc\n", re.M).group(0), "abc")
773 self.assertEqual(re.search(r"^\Aabc\Z$", "abc", re.M).group(0), "abc")
774 self.assertIsNone(re.search(r"^\Aabc\Z$", "\nabc\n", re.M))
775 self.assertEqual(re.search(br"\b(b.)\b",
777 self.assertEqual(re.search(br"\B(b.)\B",
779 self.assertEqual(re.search(br"\b(b.)\b",
780 b"abcd abc bcd bx", re.LOCALE).group(1), b"bx")
781 self.assertEqual(re.search(br"\B(b.)\B",
782 b"abc bcd bc abxd", re.LOCALE).group(1), b"bx")
783 self.assertEqual(re.search(br"^abc$", b"\nabc\n", re.M).group(0), b"abc")
784 self.assertEqual(re.search(br"^\Aabc\Z$", b"abc", re.M).group(0), b"abc")
785 self.assertIsNone(re.search(br"^\Aabc\Z$", b"\nabc\n", re.M))
786 self.assertEqual(re.search(r"\d\D\w\W\s\S",
788 self.assertEqual(re.search(br"\d\D\w\W\s\S",
790 self.assertEqual(re.search(r"\d\D\w\W\s\S",
791 "1aa! a", re.ASCII).group(0), "1aa! a")
792 self.assertEqual(re.search(br"\d\D\w\W\s\S",
793 b"1aa! a", re.LOCALE).group(0), b"1aa! a")
797 self.assertEqual(re.match(r"\(", '(').group(), '(')
798 self.assertIsNone(re.match(r"\(", ')'))
799 self.assertEqual(re.match(r"\\", '\\').group(), '\\')
800 self.assertEqual(re.match(r"[\]]", ']').group(), ']')
801 self.assertIsNone(re.match(r"[\]]", '['))
802 self.assertEqual(re.match(r"[a\-c]", '-').group(), '-')
803 self.assertIsNone(re.match(r"[a\-c]", 'b'))
804 self.assertEqual(re.match(r"[\^a]+", 'a^').group(), 'a^')
805 self.assertIsNone(re.match(r"[\^a]+", 'b'))
806 re.purge() # for warnings
809 self.assertRaises(re.error, re.compile, '\\%c' % c)
812 self.assertRaises(re.error, re.compile, '[\\%c]' % c)
816 self.assertTrue(re.match(r'\N{LESS-THAN SIGN}', '<'))
817 self.assertTrue(re.match(r'\N{less-than sign}', '<'))
818 self.assertIsNone(re.match(r'\N{LESS-THAN SIGN}', '>'))
819 self.assertTrue(re.match(r'\N{SNAKE}', '\U0001f40d'))
820 self.assertTrue(re.match(r'\N{ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH '
823 self.assertTrue(re.match(r'[\N{LESS-THAN SIGN}-\N{GREATER-THAN SIGN}]',
825 self.assertIsNone(re.match(r'[\N{LESS-THAN SIGN}-\N{GREATER-THAN SIGN}]',
856 self.assertEqual(re.search(r"\b(abc)\b", "abc").group(1),
859 self.assertTrue(re.match(r"\b", "abc"))
861 self.assertTrue(re.search(r"\B", "abc"))
863 self.assertFalse(re.match(r"\B", "abc"))
866 self.assertIsNone(re.search(r"\B", ""))
869 self.assertIsNone(re.search(r"\b", ""))
872 self.assertEqual(len(re.findall(r"\b", "a")), 2)
873 self.assertEqual(len(re.findall(r"\B", "a")), 0)
875 self.assertEqual(len(re.findall(r"\b", " ")), 0)
876 self.assertEqual(len(re.findall(r"\b", " ")), 0)
878 self.assertEqual(len(re.findall(r"\B", " ")), 2)
881 self.assertEqual(re.match("([\u2222\u2223])",
884 self.assertEqual(re.match(r, "\uff01").group(), "\uff01")
888 r = re.compile('|'.join(('%d'%x for x in range(10000))))
893 self.assertEqual(re.match("a.b", "a\nb", re.DOTALL).group(0),
895 self.assertEqual(re.match("a.*b", "a\n\nb", re.DOTALL).group(0),
899 self.assertEqual(re.match(r"(a(?=\s[^a]))", "a b").group(1), "a")
900 self.assertEqual(re.match(r"(a(?=\s[^a]*))", "a b").group(1), "a")
901 self.assertEqual(re.match(r"(a(?=\s[abc]))", "a b").group(1), "a")
902 self.assertEqual(re.match(r"(a(?=\s[abc]*))", "a bc").group(1), "a")
903 self.assertEqual(re.match(r"(a)(?=\s\1)", "a a").group(1), "a")
904 self.assertEqual(re.match(r"(a)(?=\s\1*)", "a aa").group(1), "a")
905 self.assertEqual(re.match(r"(a)(?=\s(abc|a))", "a a").group(1), "a")
907 self.assertEqual(re.match(r"(a(?!\s[^a]))", "a a").group(1), "a")
908 self.assertEqual(re.match(r"(a(?!\s[abc]))", "a d").group(1), "a")
909 self.assertEqual(re.match(r"(a)(?!\s\1)", "a b").group(1), "a")
910 self.assertEqual(re.match(r"(a)(?!\s(abc|a))", "a b").group(1), "a")
913 self.assertTrue(re.match(r'(a)b(?=\1)a', 'aba'))
914 self.assertIsNone(re.match(r'(a)b(?=\1)c', 'abac'))
916 self.assertTrue(re.match(r'(?:(a)|(x))b(?=(?(2)x|c))c', 'abc'))
917 self.assertIsNone(re.match(r'(?:(a)|(x))b(?=(?(2)c|x))c', 'abc'))
918 self.assertTrue(re.match(r'(?:(a)|(x))b(?=(?(2)x|c))c', 'abc'))
919 self.assertIsNone(re.match(r'(?:(a)|(x))b(?=(?(1)b|x))c', 'abc'))
920 self.assertTrue(re.match(r'(?:(a)|(x))b(?=(?(1)c|x))c', 'abc'))
922 self.assertTrue(re.match(r'(a)b(?=(?(2)x|c))(c)', 'abc'))
923 self.assertIsNone(re.match(r'(a)b(?=(?(2)b|x))(c)', 'abc'))
924 self.assertTrue(re.match(r'(a)b(?=(?(1)c|x))(c)', 'abc'))
927 self.assertTrue(re.match(r'ab(?<=b)c', 'abc'))
928 self.assertIsNone(re.match(r'ab(?<=c)c', 'abc'))
929 self.assertIsNone(re.match(r'ab(?<!b)c', 'abc'))
930 self.assertTrue(re.match(r'ab(?<!c)c', 'abc'))
932 self.assertTrue(re.match(r'(a)a(?<=\1)c', 'aac'))
933 self.assertIsNone(re.match(r'(a)b(?<=\1)a', 'abaa'))
934 self.assertIsNone(re.match(r'(a)a(?<!\1)c', 'aac'))
935 self.assertTrue(re.match(r'(a)b(?<!\1)a', 'abaa'))
937 self.assertIsNone(re.match(r'(?:(a)|(x))b(?<=(?(2)x|c))c', 'abc'))
938 self.assertIsNone(re.match(r'(?:(a)|(x))b(?<=(?(2)b|x))c', 'abc'))
939 self.assertTrue(re.match(r'(?:(a)|(x))b(?<=(?(2)x|b))c', 'abc'))
940 self.assertIsNone(re.match(r'(?:(a)|(x))b(?<=(?(1)c|x))c', 'abc'))
941 self.assertTrue(re.match(r'(?:(a)|(x))b(?<=(?(1)b|x))c', 'abc'))
943 self.assertRaises(re.error, re.compile, r'(a)b(?<=(?(2)b|x))(c)')
944 self.assertIsNone(re.match(r'(a)b(?<=(?(1)c|x))(c)', 'abc'))
945 self.assertTrue(re.match(r'(a)b(?<=(?(1)b|x))(c)', 'abc'))
947 self.assertRaises(re.error, re.compile, r'(a)b(?<=(.)\2)(c)')
948 self.assertRaises(re.error, re.compile, r'(a)b(?<=(?P<a>.)(?P=a))(c)')
949 self.assertRaises(re.error, re.compile, r'(a)b(?<=(a)(?(2)b|x))(c)')
950 self.assertRaises(re.error, re.compile, r'(a)b(?<=(.)(?<=\2))(c)')
953 self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
954 self.assertEqual(re.match(b"abc", b"ABC", re.I).group(0), b"ABC")
955 self.assertEqual(re.match(r"(a\s[^a])", "a b", re.I).group(1), "a b")
956 self.assertEqual(re.match(r"(a\s[^a]*)", "a bb", re.I).group(1), "a bb")
957 self.assertEqual(re.match(r"(a\s[abc])", "a b", re.I).group(1), "a b")
958 self.assertEqual(re.match(r"(a\s[abc]*)", "a bb", re.I).group(1), "a bb")
959 self.assertEqual(re.match(r"((a)\s\2)", "a a", re.I).group(1), "a a")
960 self.assertEqual(re.match(r"((a)\s\2*)", "a aa", re.I).group(1), "a aa")
961 self.assertEqual(re.match(r"((a)\s(abc|a))", "a a", re.I).group(1), "a a")
962 self.assertEqual(re.match(r"((a)\s(abc|a)*)", "a aa", re.I).group(1), "a aa")
966 self.assertTrue(re.match(r'K', '\u212a', re.I))
967 self.assertTrue(re.match(r'k', '\u212a', re.I))
968 self.assertTrue(re.match(r'\u212a', 'K', re.I))
969 self.assertTrue(re.match(r'\u212a', 'k', re.I))
973 self.assertTrue(re.match(r'S', '\u017f', re.I))
974 self.assertTrue(re.match(r's', '\u017f', re.I))
975 self.assertTrue(re.match(r'\u017f', 'S', re.I))
976 self.assertTrue(re.match(r'\u017f', 's', re.I))
980 self.assertTrue(re.match(r'\u0412', '\u0432', re.I))
981 self.assertTrue(re.match(r'\u0412', '\u1c80', re.I))
982 self.assertTrue(re.match(r'\u0432', '\u0412', re.I))
983 self.assertTrue(re.match(r'\u0432', '\u1c80', re.I))
984 self.assertTrue(re.match(r'\u1c80', '\u0412', re.I))
985 self.assertTrue(re.match(r'\u1c80', '\u0432', re.I))
989 self.assertTrue(re.match(r'\ufb05', '\ufb06', re.I))
990 self.assertTrue(re.match(r'\ufb06', '\ufb05', re.I))
993 self.assertTrue(re.match(r'[19A]', 'A', re.I))
994 self.assertTrue(re.match(r'[19a]', 'a', re.I))
995 self.assertTrue(re.match(r'[19a]', 'A', re.I))
996 self.assertTrue(re.match(r'[19A]', 'a', re.I))
997 self.assertTrue(re.match(br'[19A]', b'A', re.I))
998 self.assertTrue(re.match(br'[19a]', b'a', re.I))
999 self.assertTrue(re.match(br'[19a]', b'A', re.I))
1000 self.assertTrue(re.match(br'[19A]', b'a', re.I))
1004 self.assertTrue(re.match(r'[19K]', '\u212a', re.I))
1005 self.assertTrue(re.match(r'[19k]', '\u212a', re.I))
1006 self.assertTrue(re.match(r'[19\u212a]', 'K', re.I))
1007 self.assertTrue(re.match(r'[19\u212a]', 'k', re.I))
1011 self.assertTrue(re.match(r'[19S]', '\u017f', re.I))
1012 self.assertTrue(re.match(r'[19s]', '\u017f', re.I))
1013 self.assertTrue(re.match(r'[19\u017f]', 'S', re.I))
1014 self.assertTrue(re.match(r'[19\u017f]', 's', re.I))
1018 self.assertTrue(re.match(r'[19\u0412]', '\u0432', re.I))
1019 self.assertTrue(re.match(r'[19\u0412]', '\u1c80', re.I))
1020 self.assertTrue(re.match(r'[19\u0432]', '\u0412', re.I))
1021 self.assertTrue(re.match(r'[19\u0432]', '\u1c80', re.I))
1022 self.assertTrue(re.match(r'[19\u1c80]', '\u0412', re.I))
1023 self.assertTrue(re.match(r'[19\u1c80]', '\u0432', re.I))
1027 self.assertTrue(re.match(r'[19\ufb05]', '\ufb06', re.I))
1028 self.assertTrue(re.match(r'[19\ufb06]', '\ufb05', re.I))
1032 self.assertTrue(re.match(r'[9-a]', '_', re.I))
1033 self.assertIsNone(re.match(r'[9-A]', '_', re.I))
1034 self.assertTrue(re.match(br'[9-a]', b'_', re.I))
1035 self.assertIsNone(re.match(br'[9-A]', b'_', re.I))
1036 self.assertTrue(re.match(r'[\xc0-\xde]', '\xd7', re.I))
1037 self.assertIsNone(re.match(r'[\xc0-\xde]', '\xf7', re.I))
1038 self.assertTrue(re.match(r'[\xe0-\xfe]', '\xf7', re.I))
1039 self.assertIsNone(re.match(r'[\xe0-\xfe]', '\xd7', re.I))
1040 self.assertTrue(re.match(r'[\u0430-\u045f]', '\u0450', re.I))
1041 self.assertTrue(re.match(r'[\u0430-\u045f]', '\u0400', re.I))
1042 self.assertTrue(re.match(r'[\u0400-\u042f]', '\u0450', re.I))
1043 self.assertTrue(re.match(r'[\u0400-\u042f]', '\u0400', re.I))
1044 self.assertTrue(re.match(r'[\U00010428-\U0001044f]', '\U00010428', re.I))
1045 self.assertTrue(re.match(r'[\U00010428-\U0001044f]', '\U00010400', re.I))
1046 self.assertTrue(re.match(r'[\U00010400-\U00010427]', '\U00010428', re.I))
1047 self.assertTrue(re.match(r'[\U00010400-\U00010427]', '\U00010400', re.I))
1051 self.assertTrue(re.match(r'[J-M]', '\u212a', re.I))
1052 self.assertTrue(re.match(r'[j-m]', '\u212a', re.I))
1053 self.assertTrue(re.match(r'[\u2129-\u212b]', 'K', re.I))
1054 self.assertTrue(re.match(r'[\u2129-\u212b]', 'k', re.I))
1058 self.assertTrue(re.match(r'[R-T]', '\u017f', re.I))
1059 self.assertTrue(re.match(r'[r-t]', '\u017f', re.I))
1060 self.assertTrue(re.match(r'[\u017e-\u0180]', 'S', re.I))
1061 self.assertTrue(re.match(r'[\u017e-\u0180]', 's', re.I))
1065 self.assertTrue(re.match(r'[\u0411-\u0413]', '\u0432', re.I))
1066 self.assertTrue(re.match(r'[\u0411-\u0413]', '\u1c80', re.I))
1067 self.assertTrue(re.match(r'[\u0431-\u0433]', '\u0412', re.I))
1068 self.assertTrue(re.match(r'[\u0431-\u0433]', '\u1c80', re.I))
1069 self.assertTrue(re.match(r'[\u1c80-\u1c82]', '\u0412', re.I))
1070 self.assertTrue(re.match(r'[\u1c80-\u1c82]', '\u0432', re.I))
1074 self.assertTrue(re.match(r'[\ufb04-\ufb05]', '\ufb06', re.I))
1075 self.assertTrue(re.match(r'[\ufb06-\ufb07]', '\ufb05', re.I))
1078 self.assertEqual(re.match(r"(\s)", " ").group(1), " ")
1108 self.assertEqual(re.search(r"\s([^a])", " b").group(1), "b")
1109 self.assertEqual(re.search(r"\s([^a]*)", " bb").group(1), "bb")
1114 p = re.compile(r'[0-9--1]')
1116 self.assertEqual(re.findall(r'[--1]', s), list('-./01'))
1118 p = re.compile(r'[%--1]')
1121 p = re.compile(r'[%--]')
1125 p = re.compile(r'[0-9&&1]')
1128 p = re.compile(r'[\d&&1]')
1130 self.assertEqual(re.findall(r'[&&1]', s), list('&1'))
1133 p = re.compile(r'[0-9||a]')
1136 p = re.compile(r'[\d||a]')
1138 self.assertEqual(re.findall(r'[||1]', s), list('1|'))
1141 p = re.compile(r'[0-9~~1]')
1144 p = re.compile(r'[\d~~1]')
1146 self.assertEqual(re.findall(r'[~~1]', s), list('1~'))
1149 p = re.compile(r'[[0-9]|]')
1153 p = re.compile(r'[[:digit:]|]')
1157 self.assertEqual(re.search(r"\s(b)", " b").group(1), "b")
1158 self.assertEqual(re.search(r"a\s", "a ").group(0), "a ")
1161 matcher=re.fullmatch):
1179 self.assertMatch(re.escape(c), c)
1180 self.assertMatch('[' + re.escape(c) + ']', c)
1181 self.assertMatch('(?x)' + re.escape(c), c)
1182 self.assertMatch(re.escape(p), p)
1184 self.assertEqual(re.escape(c)[:1], '\\')
1186 self.assertEqual(re.escape(literal_chars), literal_chars)
1192 self.assertMatch(re.escape(b), b)
1193 self.assertMatch(b'[' + re.escape(b) + b']', b)
1194 self.assertMatch(b'(?x)' + re.escape(b), b)
1195 self.assertMatch(re.escape(p), p)
1198 self.assertEqual(re.escape(b)[:1], b'\\')
1200 self.assertEqual(re.escape(literal_chars), literal_chars)
1204 s_escaped = re.escape(s)
1207 self.assertMatch('.%s+.' % re.escape('\u2620'), s,
1208 'x\u2620\u2620\u2620x', (2, 7), re.search)
1212 b_escaped = re.escape(b)
1215 res = re.findall(re.escape('\u2620'.encode('utf-8')), b)
1220 oldpat = re.compile('a(?:b|(c|e){1,2}?|d)+?(.)', re.UNICODE)
1225 # current pickle expects the _compile() reconstructor in re module
1226 from re import _compile
1230 p = re.compile(r'(?P<int>\d+)(?:\.(?P<frac>\d*))?')
1238 self.assertEqual(re.I, re.IGNORECASE)
1239 self.assertEqual(re.L, re.LOCALE)
1240 self.assertEqual(re.M, re.MULTILINE)
1241 self.assertEqual(re.S, re.DOTALL)
1242 self.assertEqual(re.X, re.VERBOSE)
1245 for flag in [re.I, re.M, re.X, re.S, re.A, re.U]:
1246 self.assertTrue(re.compile('^pattern$', flag))
1247 for flag in [re.I, re.M, re.X, re.S, re.A, re.L]:
1248 self.assertTrue(re.compile(b'^pattern$', flag))
1253 self.assertTrue(re.match(r"\%03o" % i, chr(i)))
1254 self.assertTrue(re.match(r"\%03o0" % i, chr(i)+"0"))
1255 self.assertTrue(re.match(r"\%03o8" % i, chr(i)+"8"))
1256 self.assertTrue(re.match(r"\x%02x" % i, chr(i)))
1257 self.assertTrue(re.match(r"\x%02x0" % i, chr(i)+"0"))
1258 self.assertTrue(re.match(r"\x%02xz" % i, chr(i)+"z"))
1260 self.assertTrue(re.match(r"\u%04x" % i, chr(i)))
1261 self.assertTrue(re.match(r"\u%04x0" % i, chr(i)+"0"))
1262 self.assertTrue(re.match(r"\u%04xz" % i, chr(i)+"z"))
1263 self.assertTrue(re.match(r"\U%08x" % i, chr(i)))
1264 self.assertTrue(re.match(r"\U%08x0" % i, chr(i)+"0"))
1265 self.assertTrue(re.match(r"\U%08xz" % i, chr(i)+"z"))
1266 self.assertTrue(re.match(r"\0", "\000"))
1267 self.assertTrue(re.match(r"\08", "\0008"))
1268 self.assertTrue(re.match(r"\01", "\001"))
1269 self.assertTrue(re.match(r"\018", "\0018"))
1285 self.assertTrue(re.match(r"[\%o]" % i, chr(i)))
1286 self.assertTrue(re.match(r"[\%o8]" % i, chr(i)))
1287 self.assertTrue(re.match(r"[\%03o]" % i, chr(i)))
1288 self.assertTrue(re.match(r"[\%03o0]" % i, chr(i)))
1289 self.assertTrue(re.match(r"[\%03o8]" % i, chr(i)))
1290 self.assertTrue(re.match(r"[\x%02x]" % i, chr(i)))
1291 self.assertTrue(re.match(r"[\x%02x0]" % i, chr(i)))
1292 self.assertTrue(re.match(r"[\x%02xz]" % i, chr(i)))
1294 self.assertTrue(re.match(r"[\u%04x]" % i, chr(i)))
1295 self.assertTrue(re.match(r"[\u%04x0]" % i, chr(i)))
1296 self.assertTrue(re.match(r"[\u%04xz]" % i, chr(i)))
1297 self.assertTrue(re.match(r"[\U%08x]" % i, chr(i)))
1298 self.assertTrue(re.match(r"[\U%08x0]" % i, chr(i)+"0"))
1299 self.assertTrue(re.match(r"[\U%08xz]" % i, chr(i)+"z"))
1308 self.assertTrue(re.match(r"[\U0001d49c-\U0001d4b5]", "\U0001d49e"))
1312 self.assertTrue(re.match((r"\%03o" % i).encode(), bytes([i])))
1313 self.assertTrue(re.match((r"\%03o0" % i).encode(), bytes([i])+b"0"))
1314 self.assertTrue(re.match((r"\%03o8" % i).encode(), bytes([i])+b"8"))
1315 self.assertTrue(re.match((r"\x%02x" % i).encode(), bytes([i])))
1316 self.assertTrue(re.match((r"\x%02x0" % i).encode(), bytes([i])+b"0"))
1317 self.assertTrue(re.match((r"\x%02xz" % i).encode(), bytes([i])+b"z"))
1318 self.assertRaises(re.error, re.compile, br"\u1234")
1319 self.assertRaises(re.error, re.compile, br"\U00012345")
1320 self.assertTrue(re.match(br"\0", b"\000"))
1321 self.assertTrue(re.match(br"\08", b"\0008"))
1322 self.assertTrue(re.match(br"\01", b"\001"))
1323 self.assertTrue(re.match(br"\018", b"\0018"))
1333 self.assertTrue(re.match((r"[\%o]" % i).encode(), bytes([i])))
1334 self.assertTrue(re.match((r"[\%o8]" % i).encode(), bytes([i])))
1335 self.assertTrue(re.match((r"[\%03o]" % i).encode(), bytes([i])))
1336 self.assertTrue(re.match((r"[\%03o0]" % i).encode(), bytes([i])))
1337 self.assertTrue(re.match((r"[\%03o8]" % i).encode(), bytes([i])))
1338 self.assertTrue(re.match((r"[\x%02x]" % i).encode(), bytes([i])))
1339 self.assertTrue(re.match((r"[\x%02x0]" % i).encode(), bytes([i])))
1340 self.assertTrue(re.match((r"[\x%02xz]" % i).encode(), bytes([i])))
1341 self.assertRaises(re.error, re.compile, br"[\u1234]")
1342 self.assertRaises(re.error, re.compile, br"[\U00012345]")
1361 self.assertEqual(re.match(r'(a)|(b)', 'b').start(1), -1)
1362 self.assertEqual(re.match(r'(a)|(b)', 'b').end(1), -1)
1363 self.assertEqual(re.match(r'(a)|(b)', 'b').span(1), (-1, -1))
1367 self.assertIsNone(re.match(r'(a)?a','a').lastindex)
1368 self.assertEqual(re.match(r'(a)(b)?b','ab').lastindex, 1)
1369 self.assertEqual(re.match(r'(?P<a>a)(?P<b>b)?b','ab').lastgroup, 'a')
1370 self.assertEqual(re.match(r"(?P<a>a(b))", "ab").lastgroup, 'a')
1371 self.assertEqual(re.match(r"((a))", "a").lastindex, 1)
1377 self.assertEqual(re.match('.*?c', 10000*'ab'+'cd').end(0), 20001)
1378 self.assertEqual(re.match('.*?cd', 5000*'ab'+'c'+5000*'ab'+'cde').end(0),
1380 self.assertEqual(re.match('.*?cd', 20000*'abc'+'de').end(0), 60001)
1383 self.assertEqual(re.search('(a|b)*?c', 10000*'ab'+'cd').end(0), 20001)
1386 pat="["+re.escape("\u2039")+"]"
1387 self.assertEqual(re.compile(pat) and 1, 1)
1392 self.assertEqual(re.match('(x)*', 50000*'x').group(1), 'x')
1393 self.assertEqual(re.match('(x)*y', 50000*'x'+'y').group(1), 'x')
1394 self.assertEqual(re.match('(x)*?y', 50000*'x'+'y').group(1), 'x')
1418 self.assertIsNone(re.match(r'(?:a?)*y', 'z'))
1419 self.assertIsNone(re.match(r'(?:a?)+y', 'z'))
1420 self.assertIsNone(re.match(r'(?:a?){2,}y', 'z'))
1421 self.assertIsNone(re.match(r'(?:a?)*?y', 'z'))
1422 self.assertIsNone(re.match(r'(?:a?)+?y', 'z'))
1423 self.assertIsNone(re.match(r'(?:a?){2,}?y', 'z'))
1449 self.assertEqual(re.match(r'((.%s):)?z'%op, 'z').groups(),
1451 self.assertEqual(re.match(r'((.%s):)?z'%op, 'a:z').groups(),
1456 self.assertEqual(re.match('^((a)|b)*', 'abc').groups(),
1458 self.assertEqual(re.match('^(([ab])|c)*', 'abc').groups(),
1460 self.assertEqual(re.match('^((d)|[ab])*', 'abc').groups(),
1462 self.assertEqual(re.match('^((a)c|[ab])*', 'abc').groups(),
1464 self.assertEqual(re.match('^((a)|b)*?c', 'abc').groups(),
1466 self.assertEqual(re.match('^(([ab])|c)*?d', 'abcd').groups(),
1468 self.assertEqual(re.match('^((d)|[ab])*?c', 'abc').groups(),
1470 self.assertEqual(re.match('^((a)c|[ab])*?c', 'abc').groups(),
1475 self.assertEqual(re.match('(a)(?:(?=(b)*)c)*', 'abb').groups(),
1477 self.assertEqual(re.match('(a)((?!(b)*))*', 'abb').groups(),
1481 # bug 764548, re.compile() barfs on str/unicode subclasses
1483 pat = re.compile(my_unicode("abc"))
1487 iter = re.finditer(r":+", "a:b::c:::d")
1491 pat = re.compile(r":+")
1496 pat = re.compile(r":+")
1501 pat = re.compile(r":+")
1506 pat = re.compile(r":+")
1512 self.assertIsNot(re.compile('bug_926075'),
1513 re.compile(b'bug_926075'))
1517 self.assertEqual(re.compile(pattern).split("a.b.c"),
1521 iter = re.finditer(r"\s", "a b")
1525 scanner = re.compile(r"\s").scanner("a b")
1530 iter = re.finditer(r".*", "asdf")
1545 self.assertEqual(re.match(r'^\d$', x).group(0), x)
1554 self.assertIsNone(re.match(r'^\d$', x))
1561 self.assertIsNone(re.compile(b"bla").match(a))
1562 self.assertEqual(re.compile(b"").match(a).groups(), ())
1569 p = re.compile('.' + upper_char, re.I | re.S)
1573 p = re.compile('.' + lower_char, re.I | re.S)
1577 p = re.compile('(?i).' + upper_char, re.S)
1581 p = re.compile('(?i).' + lower_char, re.S)
1585 p = re.compile('(?is).' + upper_char)
1589 p = re.compile('(?is).' + lower_char)
1593 p = re.compile('(?s)(?i).' + upper_char)
1597 p = re.compile('(?s)(?i).' + lower_char)
1601 self.assertTrue(re.match('(?ix) ' + upper_char, lower_char))
1602 self.assertTrue(re.match('(?ix) ' + lower_char, upper_char))
1603 self.assertTrue(re.match(' (?i) ' + upper_char, lower_char, re.X))
1604 self.assertTrue(re.match('(?x) (?i) ' + upper_char, lower_char))
1605 self.assertTrue(re.match(' (?x) (?i) ' + upper_char, lower_char, re.X))
1628 pattern = re.compile('$')
1633 pattern = re.compile('$', re.MULTILINE)
1640 pat = re.compile('.')
1641 bpat = re.compile(b'.')
1653 for flags in (0, re.UNICODE):
1654 pat = re.compile('\xc0', flags | re.IGNORECASE)
1656 pat = re.compile(r'\w', flags)
1658 pat = re.compile('\xc0', re.ASCII | re.IGNORECASE)
1660 pat = re.compile('(?a)\xc0', re.IGNORECASE)
1662 pat = re.compile(r'\w', re.ASCII)
1664 pat = re.compile(r'(?a)\w')
1667 for flags in (0, re.ASCII):
1668 pat = re.compile(b'\xc0', flags | re.IGNORECASE)
1670 pat = re.compile(br'\w', flags)
1673 self.assertRaises(ValueError, re.compile, br'\w', re.UNICODE)
1674 self.assertRaises(re.error, re.compile, br'(?u)\w')
1675 self.assertRaises(ValueError, re.compile, r'\w', re.UNICODE | re.ASCII)
1676 self.assertRaises(ValueError, re.compile, r'(?u)\w', re.ASCII)
1677 self.assertRaises(ValueError, re.compile, r'(?a)\w', re.UNICODE)
1678 self.assertRaises(re.error, re.compile, r'(?au)\w')
1691 bpat = re.escape(bytes([i]))
1699 pat = re.compile(bpat, re.LOCALE | re.IGNORECASE)
1702 pat = re.compile(b'(?L)' + bpat, re.IGNORECASE)
1705 pat = re.compile(bpat, re.IGNORECASE)
1708 pat = re.compile(br'\w', re.LOCALE)
1711 pat = re.compile(br'(?L)\w')
1714 pat = re.compile(br'\w')
1718 self.assertRaises(ValueError, re.compile, '', re.LOCALE)
1719 self.assertRaises(re.error, re.compile, '(?L)')
1720 self.assertRaises(ValueError, re.compile, b'', re.LOCALE | re.ASCII)
1721 self.assertRaises(ValueError, re.compile, b'(?L)', re.ASCII)
1722 self.assertRaises(ValueError, re.compile, b'(?a)', re.LOCALE)
1723 self.assertRaises(re.error, re.compile, b'(?aL)')
1726 self.assertTrue(re.match(r'(?i:a)b', 'Ab'))
1727 self.assertIsNone(re.match(r'(?i:a)b', 'aB'))
1728 self.assertIsNone(re.match(r'(?-i:a)b', 'Ab', re.IGNORECASE))
1729 self.assertTrue(re.match(r'(?-i:a)b', 'aB', re.IGNORECASE))
1730 self.assertIsNone(re.match(r'(?i:(?-i:a)b)', 'Ab'))
1731 self.assertTrue(re.match(r'(?i:(?-i:a)b)', 'aB'))
1733 self.assertTrue(re.match(r'\w(?a:\W)\w', '\xe0\xe0\xe0'))
1734 self.assertTrue(re.match(r'(?a:\W(?u:\w)\W)', '\xe0\xe0\xe0'))
1735 self.assertTrue(re.match(r'\W(?u:\w)\W', '\xe0\xe0\xe0', re.ASCII))
1760 self.assertTrue(re.fullmatch(space + 'a', 'a', re.VERBOSE))
1762 self.assertTrue(re.fullmatch(space + b'a', b'a', re.VERBOSE))
1763 self.assertTrue(re.fullmatch('(?x) a', 'a'))
1764 self.assertTrue(re.fullmatch(' (?x) a', 'a', re.VERBOSE))
1765 self.assertTrue(re.fullmatch('(?x) (?x) a', 'a'))
1766 self.assertTrue(re.fullmatch(' a(?x: b) c', ' ab c'))
1767 self.assertTrue(re.fullmatch(' a(?-x: b) c', 'a bc', re.VERBOSE))
1768 self.assertTrue(re.fullmatch('(?x) a(?-x: b) c', 'a bc'))
1769 self.assertTrue(re.fullmatch('(?x) a| b', 'a'))
1770 self.assertTrue(re.fullmatch('(?x) a| b', 'b'))
1773 self.assertTrue(re.fullmatch('#x\na', 'a', re.VERBOSE))
1774 self.assertTrue(re.fullmatch(b'#x\na', b'a', re.VERBOSE))
1775 self.assertTrue(re.fullmatch('(?x)#x\na', 'a'))
1776 self.assertTrue(re.fullmatch('#x\n(?x)#y\na', 'a', re.VERBOSE))
1777 self.assertTrue(re.fullmatch('(?x)#x\n(?x)#y\na', 'a'))
1778 self.assertTrue(re.fullmatch('#x\na(?x:#y\nb)#z\nc', '#x\nab#z\nc'))
1779 self.assertTrue(re.fullmatch('#x\na(?-x:#y\nb)#z\nc', 'a#y\nbc',
1780 re.VERBOSE))
1781 self.assertTrue(re.fullmatch('(?x)#x\na(?-x:#y\nb)#z\nc', 'a#y\nbc'))
1782 self.assertTrue(re.fullmatch('(?x)#x\na|#y\nb', 'a'))
1783 self.assertTrue(re.fullmatch('(?x)#x\na|#y\nb', 'b'))
1788 pat = re.compile(r'a(\w)')
1790 pat = re.compile('a(.)')
1792 pat = re.compile('..')
1796 pat = re.compile(br'a(\w)')
1798 pat = re.compile(b'a(.)')
1800 pat = re.compile(b'..')
1811 self.assertRaises(TypeError, re.finditer, "a", {})
1818 self.assertTrue(re.search("123.*-", '123abc-'))
1819 self.assertTrue(re.search("123.*-", '123\xe9-'))
1820 self.assertTrue(re.search("123.*-", '123\u20ac-'))
1821 self.assertTrue(re.search("123.*-", '123\U0010ffff-'))
1822 self.assertTrue(re.search("123.*-", '123\xe9\u20ac\U0010ffff-'))
1826 pattern = re.compile('random pattern')
1827 self.assertIsInstance(pattern, re.Pattern)
1828 same_pattern = re.compile(pattern)
1829 self.assertIsInstance(same_pattern, re.Pattern)
1832 self.assertRaises(TypeError, re.compile, 0)
1838 m = re.search('$', s)
1843 # The huge memuse is because of re.sub() using a list and a join()
1849 r, n = re.subn('', '', s)
1856 self.assertEqual(re.findall(r"(?i)(a)\1", "aa \u0100"), ['a'])
1857 self.assertEqual(re.match(r"(?s).{1,3}", "\u0100\u0100").span(), (0, 2))
1862 self.assertEqual(re.match(r".{65535}", string).span(), (0, 65535))
1863 self.assertEqual(re.match(r".{,65535}", string).span(), (0, 65535))
1864 self.assertEqual(re.match(r".{65535,}?", string).span(), (0, 65535))
1865 self.assertEqual(re.match(r".{65536}", string).span(), (0, 65536))
1866 self.assertEqual(re.match(r".{,65536}", string).span(), (0, 65536))
1867 self.assertEqual(re.match(r".{65536,}?", string).span(), (0, 65536))
1869 self.assertRaises(OverflowError, re.compile, r".{%d}" % 2**128)
1870 self.assertRaises(OverflowError, re.compile, r".{,%d}" % 2**128)
1871 self.assertRaises(OverflowError, re.compile, r".{%d,}?" % 2**128)
1872 self.assertRaises(OverflowError, re.compile, r".{%d,%d}" % (2**129, 2**128))
1881 self.assertIsNone(re.match(r".{%d}" % (MAXREPEAT - 1), string))
1882 self.assertEqual(re.match(r".{,%d}" % (MAXREPEAT - 1), string).span(),
1884 self.assertIsNone(re.match(r".{%d,}?" % (MAXREPEAT - 1), string))
1885 self.assertRaises(OverflowError, re.compile, r".{%d}" % MAXREPEAT)
1886 self.assertRaises(OverflowError, re.compile, r".{,%d}" % MAXREPEAT)
1887 self.assertRaises(OverflowError, re.compile, r".{%d,}?" % MAXREPEAT)
1903 self.assertEqual(re.compile(pattern, re.S).findall('xyz'),
1906 self.assertEqual(re.compile(pattern, re.S).findall(b'xyz'),
1911 m = re.search(r'(.+)(.*?)\1', string)
1919 m = re.search(br'(.+)(.*?)\1', string)
1925 first, second = list(re.finditer("(aa)|(bb)", "aa bb"))
1937 self.assertEqual(re.split(r"\b", "a::bc"), ['', 'a', '::', 'bc', ''])
1938 self.assertEqual(re.split(r"\b|:+", "a::bc"), ['', 'a', '', '', 'bc', ''])
1939 self.assertEqual(re.split(r"(?<!\w)(?=\w)|:+", "a::bc"), ['', 'a', '', 'bc'])
1940 self.assertEqual(re.split(r"(?<=\w)(?!\w)|:+", "a::bc"), ['a', '', 'bc', ''])
1942 self.assertEqual(re.sub(r"\b", "-", "a::bc"), '-a-::-bc-')
1943 self.assertEqual(re.sub(r"\b|:+", "-", "a::bc"), '-a---bc-')
1944 self.assertEqual(re.sub(r"(\b|:+)", r"[\1]", "a::bc"), '[]a[][::][]bc[]')
1946 self.assertEqual(re.findall(r"\b|:+", "a::bc"), ['', '', '::', '', ''])
1947 self.assertEqual(re.findall(r"\b|\w+", "a::bc"),
1950 self.assertEqual([m.span() for m in re.finditer(r"\b|:+", "a::bc")],
1952 self.assertEqual([m.span() for m in re.finditer(r"\b|\w+", "a::bc")],
1959 r = re.compile("^((x|y)%s)%s" % (inner_op, outer_op))
1967 pat = re.compile(r'(ab)')
1986 self.assertEqual(re.fullmatch('[a-c]+', 'ABC', re.I).span(), (0, 3))
2003 re.purge()
2006 re.purge()
2012 self.assertTrue(re.match(b'\xc5\xe5', b'\xc5\xe5', re.L|re.I))
2013 self.assertTrue(re.match(b'\xc5', b'\xe5', re.L|re.I))
2014 self.assertTrue(re.match(b'\xe5', b'\xc5', re.L|re.I))
2015 self.assertTrue(re.match(b'(?Li)\xc5\xe5', b'\xc5\xe5'))
2016 self.assertTrue(re.match(b'(?Li)\xc5', b'\xe5'))
2017 self.assertTrue(re.match(b'(?Li)\xe5', b'\xc5'))
2021 self.assertTrue(re.match(b'\xc5\xe5', b'\xc5\xe5', re.L|re.I))
2022 self.assertIsNone(re.match(b'\xc5', b'\xe5', re.L|re.I))
2023 self.assertIsNone(re.match(b'\xe5', b'\xc5', re.L|re.I))
2024 self.assertTrue(re.match(b'(?Li)\xc5\xe5', b'\xc5\xe5'))
2025 self.assertIsNone(re.match(b'(?Li)\xc5', b'\xe5'))
2026 self.assertIsNone(re.match(b'(?Li)\xe5', b'\xc5'))
2043 p1 = re.compile(b'\xc5\xe5', re.L|re.I)
2044 p2 = re.compile(b'[a\xc5][a\xe5]', re.L|re.I)
2045 p3 = re.compile(b'[az\xc5][az\xe5]', re.L|re.I)
2046 p4 = re.compile(b'[^\xc5][^\xe5]', re.L|re.I)
2065 with self.assertRaises(re.error) as cm:
2066 re.compile('(\u20ac))')
2077 with self.assertRaises(re.error) as cm:
2078 re.compile(b'(\xa4))')
2084 with self.assertRaises(re.error) as cm:
2085 re.compile("""
2091 """, re.VERBOSE)
2116 self.assertIn('ASCII', str(re.A))
2117 self.assertIn('DOTALL', str(re.S))
2120 pattern1 = re.compile('abc', re.IGNORECASE)
2127 re.purge()
2128 pattern2 = re.compile('abc', re.IGNORECASE)
2133 re.purge()
2134 pattern3 = re.compile('XYZ', re.IGNORECASE)
2140 re.purge()
2141 pattern4 = re.compile('abc')
2149 pattern1 = re.compile(b'abc')
2152 re.purge()
2153 pattern2 = re.compile(b'abc')
2159 re.purge()
2160 pattern3 = re.compile('abc')
2167 m = re.search(b'[a-h]+', s)
2168 m2 = re.search(b'[e-h]+', s)
2181 self.assertEqual(re.search(p, s).groups(), (None, 'x'))
2186 self.assertEqual(re.findall(p, s),
2188 self.assertEqual([m.groups() for m in re.finditer(p, s)],
2194 self.assertEqual(re.findall(p, s),
2196 self.assertEqual([m.groupdict() for m in re.finditer(p, s)],
2200 self.assertEqual([m.groupdict() for m in re.finditer(p, s)],
2204 self.assertEqual([m.groupdict() for m in re.finditer(p, s)],
2212 self.assertEqual(re.match(r'(ab|a)*?b', 'ab').groups(), ('a',))
2213 self.assertEqual(re.match(r'(ab|a)+?b', 'ab').groups(), ('a',))
2214 self.assertEqual(re.match(r'(ab|a){0,2}?b', 'ab').groups(), ('a',))
2215 self.assertEqual(re.match(r'(.b|a)*?b', 'ab').groups(), ('a',))
2222 self.assertEqual(re.match(p, s).groups(), ('xx',))
2227 m = re.match(p, s)
2237 m = re.match(p, s)
2245 m = re.match(p, s)
2250 self.assertEqual(re.match(r'(ab?)*?b', 'ab').groups(), ('a',))
2257 m = re.match(p, s)
2264 self.assertEqual(re.match(p, s).groups(), ('xx',))
2269 self.assertEqual(re.match(r'(?!(..)c)', 'ab').groups(), (None,))
2272 m = re.match(r'((?!(ab)c)(.))*', 'abab')
2280 re.search("x*", 5)
2282 re.search("x*", type)
2288 self.assertIsNone(re.search(p, s))
2289 self.assertEqual(re.split(p, s), [s])
2290 self.assertEqual(re.findall(p, s), [])
2291 self.assertEqual(list(re.finditer(p, s)), [])
2292 self.assertEqual(re.sub(p, '', s), s)
2304 self.assertIsNone(re.match('e*+e', 'eeee'))
2305 self.assertEqual(re.match('e++a', 'eeea').group(0), 'eeea')
2306 self.assertEqual(re.match('e?+a', 'ea').group(0), 'ea')
2307 self.assertEqual(re.match('e{2,4}+a', 'eeea').group(0), 'eeea')
2308 self.assertIsNone(re.match('(.)++.', 'ee'))
2309 self.assertEqual(re.match('(ae)*+a', 'aea').groups(), ('ae',))
2310 self.assertEqual(re.match('([ae][ae])?+a', 'aea').groups(),
2312 self.assertEqual(re.match('(e?){2,4}+a', 'eeea').groups(),
2314 self.assertEqual(re.match('()*+a', 'a').groups(), ('',))
2315 self.assertEqual(re.search('x*+', 'axx').span(), (0, 0))
2316 self.assertEqual(re.search('x++', 'axx').span(), (1, 3))
2317 self.assertEqual(re.match('a*+', 'xxx').span(), (0, 0))
2318 self.assertEqual(re.match('x*+', 'xxxa').span(), (0, 3))
2319 self.assertIsNone(re.match('a++', 'xxx'))
2320 self.assertIsNone(re.match(r"^(\w){1}+$", "abc"))
2321 self.assertIsNone(re.match(r"^(\w){1,2}+$", "abc"))
2323 self.assertEqual(re.match(r"^(\w){3}+$", "abc").group(1), "c")
2324 self.assertEqual(re.match(r"^(\w){1,3}+$", "abc").group(1), "c")
2325 self.assertEqual(re.match(r"^(\w){1,4}+$", "abc").group(1), "c")
2327 self.assertIsNone(re.match("^x{1}+$", "xxx"))
2328 self.assertIsNone(re.match("^x{1,2}+$", "xxx"))
2330 self.assertTrue(re.match("^x{3}+$", "xxx"))
2331 self.assertTrue(re.match("^x{1,3}+$", "xxx"))
2332 self.assertTrue(re.match("^x{1,4}+$", "xxx"))
2334 self.assertIsNone(re.match("^x{}+$", "xxx"))
2335 self.assertTrue(re.match("^x{}+$", "x{}"))
2338 self.assertTrue(re.fullmatch(r'a++', 'a'))
2339 self.assertTrue(re.fullmatch(r'a*+', 'a'))
2340 self.assertTrue(re.fullmatch(r'a?+', 'a'))
2341 self.assertTrue(re.fullmatch(r'a{1,3}+', 'a'))
2342 self.assertIsNone(re.fullmatch(r'a++', 'ab'))
2343 self.assertIsNone(re.fullmatch(r'a*+', 'ab'))
2344 self.assertIsNone(re.fullmatch(r'a?+', 'ab'))
2345 self.assertIsNone(re.fullmatch(r'a{1,3}+', 'ab'))
2346 self.assertTrue(re.fullmatch(r'a++b', 'ab'))
2347 self.assertTrue(re.fullmatch(r'a*+b', 'ab'))
2348 self.assertTrue(re.fullmatch(r'a?+b', 'ab'))
2349 self.assertTrue(re.fullmatch(r'a{1,3}+b', 'ab'))
2351 self.assertTrue(re.fullmatch(r'(?:ab)++', 'ab'))
2352 self.assertTrue(re.fullmatch(r'(?:ab)*+', 'ab'))
2353 self.assertTrue(re.fullmatch(r'(?:ab)?+', 'ab'))
2354 self.assertTrue(re.fullmatch(r'(?:ab){1,3}+', 'ab'))
2355 self.assertIsNone(re.fullmatch(r'(?:ab)++', 'abc'))
2356 self.assertIsNone(re.fullmatch(r'(?:ab)*+', 'abc'))
2357 self.assertIsNone(re.fullmatch(r'(?:ab)?+', 'abc'))
2358 self.assertIsNone(re.fullmatch(r'(?:ab){1,3}+', 'abc'))
2359 self.assertTrue(re.fullmatch(r'(?:ab)++c', 'abc'))
2360 self.assertTrue(re.fullmatch(r'(?:ab)*+c', 'abc'))
2361 self.assertTrue(re.fullmatch(r'(?:ab)?+c', 'abc'))
2362 self.assertTrue(re.fullmatch(r'(?:ab){1,3}+c', 'abc'))
2365 self.assertEqual(re.findall(r'a++', 'aab'), ['aa'])
2366 self.assertEqual(re.findall(r'a*+', 'aab'), ['aa', '', ''])
2367 self.assertEqual(re.findall(r'a?+', 'aab'), ['a', 'a', '', ''])
2368 self.assertEqual(re.findall(r'a{1,3}+', 'aab'), ['aa'])
2370 self.assertEqual(re.findall(r'(?:ab)++', 'ababc'), ['abab'])
2371 self.assertEqual(re.findall(r'(?:ab)*+', 'ababc'), ['abab', '', ''])
2372 self.assertEqual(re.findall(r'(?:ab)?+', 'ababc'), ['ab', 'ab', '', ''])
2373 self.assertEqual(re.findall(r'(?:ab){1,3}+', 'ababc'), ['abab'])
2380 pattern1 = re.compile(r'a(?>bc|b)c')
2383 self.assertIsNone(re.match(r'(?>.*).', 'abc'))
2384 self.assertTrue(re.match(r'(?>x)++', 'xxx'))
2385 self.assertTrue(re.match(r'(?>x++)', 'xxx'))
2386 self.assertIsNone(re.match(r'(?>x)++x', 'xxx'))
2387 self.assertIsNone(re.match(r'(?>x++)x', 'xxx'))
2390 self.assertTrue(re.fullmatch(r'(?>a+)', 'a'))
2391 self.assertTrue(re.fullmatch(r'(?>a*)', 'a'))
2392 self.assertTrue(re.fullmatch(r'(?>a?)', 'a'))
2393 self.assertTrue(re.fullmatch(r'(?>a{1,3})', 'a'))
2394 self.assertIsNone(re.fullmatch(r'(?>a+)', 'ab'))
2395 self.assertIsNone(re.fullmatch(r'(?>a*)', 'ab'))
2396 self.assertIsNone(re.fullmatch(r'(?>a?)', 'ab'))
2397 self.assertIsNone(re.fullmatch(r'(?>a{1,3})', 'ab'))
2398 self.assertTrue(re.fullmatch(r'(?>a+)b', 'ab'))
2399 self.assertTrue(re.fullmatch(r'(?>a*)b', 'ab'))
2400 self.assertTrue(re.fullmatch(r'(?>a?)b', 'ab'))
2401 self.assertTrue(re.fullmatch(r'(?>a{1,3})b', 'ab'))
2403 self.assertTrue(re.fullmatch(r'(?>(?:ab)+)', 'ab'))
2404 self.assertTrue(re.fullmatch(r'(?>(?:ab)*)', 'ab'))
2405 self.assertTrue(re.fullmatch(r'(?>(?:ab)?)', 'ab'))
2406 self.assertTrue(re.fullmatch(r'(?>(?:ab){1,3})', 'ab'))
2407 self.assertIsNone(re.fullmatch(r'(?>(?:ab)+)', 'abc'))
2408 self.assertIsNone(re.fullmatch(r'(?>(?:ab)*)', 'abc'))
2409 self.assertIsNone(re.fullmatch(r'(?>(?:ab)?)', 'abc'))
2410 self.assertIsNone(re.fullmatch(r'(?>(?:ab){1,3})', 'abc'))
2411 self.assertTrue(re.fullmatch(r'(?>(?:ab)+)c', 'abc'))
2412 self.assertTrue(re.fullmatch(r'(?>(?:ab)*)c', 'abc'))
2413 self.assertTrue(re.fullmatch(r'(?>(?:ab)?)c', 'abc'))
2414 self.assertTrue(re.fullmatch(r'(?>(?:ab){1,3})c', 'abc'))
2417 self.assertEqual(re.findall(r'(?>a+)', 'aab'), ['aa'])
2418 self.assertEqual(re.findall(r'(?>a*)', 'aab'), ['aa', '', ''])
2419 self.assertEqual(re.findall(r'(?>a?)', 'aab'), ['a', 'a', '', ''])
2420 self.assertEqual(re.findall(r'(?>a{1,3})', 'aab'), ['aa'])
2422 self.assertEqual(re.findall(r'(?>(?:ab)+)', 'ababc'), ['abab'])
2423 self.assertEqual(re.findall(r'(?>(?:ab)*)', 'ababc'), ['abab', '', ''])
2424 self.assertEqual(re.findall(r'(?>(?:ab)?)', 'ababc'), ['ab', 'ab', '', ''])
2425 self.assertEqual(re.findall(r'(?>(?:ab){1,3})', 'ababc'), ['abab'])
2428 self.assertTrue(re.fullmatch(r'(?s:(?>.*?\.).*)\Z', "a.txt")) # reproducer
2429 self.assertTrue(re.fullmatch(r'(?s:(?=(?P<g0>.*?\.))(?P=g0).*)\Z', "a.txt"))
2433 template_re1 = re.template(r'a')
2434 self.assertIn('re.template()', str(cm.warning))
2444 template_re2 = re.compile(r'a', flags=re.TEMPLATE|re.UNICODE)
2445 self.assertIn('re.TEMPLATE', str(cm.warning))
2457 pattern = re.compile(r'(?<=[({}])(((//[^\n]*)?[\n])([\000-\040])*)*'
2478 re.compile(pat, re.DEBUG)
2577 self.assertEqual(repr(re.compile(pattern)), expected)
2580 self.assertEqual(repr(re.compile(pattern, flags)), expected)
2584 "re.compile('random pattern')")
2587 self.check_flags('random pattern', re.IGNORECASE,
2588 "re.compile('random pattern', re.IGNORECASE)")
2591 self.check_flags('random pattern', re.I|re.S|re.X,
2592 "re.compile('random pattern', "
2593 "re.IGNORECASE|re.DOTALL|re.VERBOSE)")
2596 self.check_flags('random pattern', re.U,
2597 "re.compile('random pattern')")
2598 self.check_flags('random pattern', re.I|re.S|re.U,
2599 "re.compile('random pattern', "
2600 "re.IGNORECASE|re.DOTALL)")
2604 "re.compile('(?i)pattern', re.IGNORECASE)")
2608 "re.compile('random pattern', 0x123000)")
2609 self.check_flags('random pattern', 0x123000|re.I,
2610 "re.compile('random pattern', re.IGNORECASE|0x123000)")
2614 "re.compile(b'bytes pattern')")
2615 self.check_flags(b'bytes pattern', re.A,
2616 "re.compile(b'bytes pattern', re.ASCII)")
2619 self.check_flags(b'bytes pattern', re.L,
2620 "re.compile(b'bytes pattern', re.LOCALE)")
2624 '''re.compile('random "double quoted" pattern')''')
2626 '''re.compile("random 'single quoted' pattern")''')
2628 '''re.compile('both \\'single\\' and "double" quotes')''')
2632 r = repr(re.compile(pattern))
2634 self.assertEqual(r[:30], "re.compile('Very long long lon")
2635 r = repr(re.compile(pattern, re.I))
2637 self.assertEqual(r[:30], "re.compile('Very long long lon")
2638 self.assertEqual(r[-16:], ", re.IGNORECASE)")
2641 self.assertEqual(repr(re.I), "re.IGNORECASE")
2642 self.assertEqual(repr(re.I|re.S|re.X),
2643 "re.IGNORECASE|re.DOTALL|re.VERBOSE")
2644 self.assertEqual(repr(re.I|re.S|re.X|(1<<20)),
2645 "re.IGNORECASE|re.DOTALL|re.VERBOSE|0x100000")
2647 repr(~re.I),
2648 "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.DOTALL|re.VERBOSE|re.TEMPLATE|re.DEBUG")
2649 self.assertEqual(repr(~(re.I|re.S|re.X)),
2650 "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.TEMPLATE|re.DEBUG")
2651 self.assertEqual(repr(~(re.I|re.S|re.X|(1<<20))),
2652 "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.TEMPLATE|re.DEBUG|0xffe00")
2657 Test implementation details of the re module.
2662 # bpo-43908: check that re types are immutable
2664 re.Match.foo = 1
2666 re.Pattern.foo = 1
2668 pat = re.compile("")
2673 f = re._compiler._generate_overlap_table
2682 self.assertGreaterEqual(re._compiler.MAXREPEAT, 0)
2683 self.assertGreaterEqual(re._compiler.MAXGROUPS, 0)
2688 check_disallow_instantiation(self, re.Match)
2689 check_disallow_instantiation(self, re.Pattern)
2690 pat = re.compile("")
2727 p = re.compile(pattern)
2751 with self.assertRaises(re.error):
2752 re.compile(pattern)
2755 obj = re.compile(pattern)
2768 'flags': result.re.flags}
2778 for i in result.re.groupindex.keys():
2799 obj = re.compile(bpat)
2805 obj = re.compile(bpat, re.LOCALE)
2817 obj = re.compile(pattern)
2823 obj = re.compile(pattern, re.IGNORECASE)
2829 obj = re.compile(pattern, re.UNICODE)