Lines Matching full: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.PatternError) as cm:
51 re.compile(pattern)
59 with self.assertRaises(re.PatternError) as cm:
60 re.sub(pattern, repl, string)
68 assert re.error is re.PatternError
73 it = re.finditer(b'a', b)
83 x = re.compile('ab+c')
88 self.assertEqual(re.search('x*', 'axx').span(0), (0, 0))
89 self.assertEqual(re.search('x*', 'axx').span(), (0, 0))
90 self.assertEqual(re.search('x+', 'axx').span(0), (1, 3))
91 self.assertEqual(re.search('x+', 'axx').span(), (1, 3))
92 self.assertIsNone(re.search('x', 'aaa'))
93 self.assertEqual(re.match('a*', 'xxx').span(0), (0, 0))
94 self.assertEqual(re.match('a*', 'xxx').span(), (0, 0))
95 self.assertEqual(re.match('x*', 'xxxa').span(0), (0, 3))
96 self.assertEqual(re.match('x*', 'xxxa').span(), (0, 3))
97 self.assertIsNone(re.match('a+', 'xxx'))
102 self.assertEqual(re.match('(ab|ba)', 'ab').span(), (0, 2))
103 self.assertEqual(re.match('(ab|ba)', 'ba').span(), (0, 2))
104 self.assertEqual(re.match('(abc|bac|ca|cb)', 'abc').span(),
106 self.assertEqual(re.match('(abc|bac|ca|cb)', 'bac').span(),
108 self.assertEqual(re.match('(abc|bac|ca|cb)', 'ca').span(),
110 self.assertEqual(re.match('(abc|bac|ca|cb)', 'cb').span(),
112 self.assertEqual(re.match('((a)|(b)|(c))', 'a').span(), (0, 1))
113 self.assertEqual(re.match('((a)|(b)|(c))', 'b').span(), (0, 1))
114 self.assertEqual(re.match('((a)|(b)|(c))', 'c').span(), (0, 1))
121 self.assertTypedEqual(re.sub('y', 'a', 'xyz'), 'xaz')
122 self.assertTypedEqual(re.sub('y', S('a'), S('xyz')), 'xaz')
123 self.assertTypedEqual(re.sub(b'y', b'a', b'xyz'), b'xaz')
124 self.assertTypedEqual(re.sub(b'y', B(b'a'), B(b'xyz')), b'xaz')
125 self.assertTypedEqual(re.sub(b'y', bytearray(b'a'), bytearray(b'xyz')), b'xaz')
126 self.assertTypedEqual(re.sub(b'y', memoryview(b'a'), memoryview(b'xyz')), b'xaz')
128 self.assertEqual(re.sub(y, 'a', 'x%sz' % y), 'xaz')
130 self.assertEqual(re.sub("(?i)b+", "x", "bbbb BBBB"), 'x x')
131 self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y'),
134 self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y', 3),
137 self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y', count=3),
140 self.assertEqual(re.sub('.', lambda m: r"\n", 'x'), '\\n')
141 self.assertEqual(re.sub('.', r"\n", 'x'), '\n')
144 self.assertEqual(re.sub('(.)', s, 'x'), 'xx')
145 self.assertEqual(re.sub('(.)', s.replace('\\', r'\\'), 'x'), s)
146 self.assertEqual(re.sub('(.)', lambda m: s, 'x'), s)
148 self.assertEqual(re.sub('(?P<a>x)', r'\g<a>\g<a>', 'xx'), 'xxxx')
149 self.assertEqual(re.sub('(?P<a>x)', r'\g<a>\g<1>', 'xx'), 'xxxx')
150 self.assertEqual(re.sub('(?P<unk>x)', r'\g<unk>\g<unk>', 'xx'), 'xxxx')
151 self.assertEqual(re.sub('(?P<unk>x)', r'\g<1>\g<1>', 'xx'), 'xxxx')
152 self.assertEqual(re.sub('()x', r'\g<0>\g<0>', 'xx'), 'xxxx')
154 self.assertEqual(re.sub('a', r'\t\n\v\r\f\a\b', 'a'), '\t\n\v\r\f\a\b')
155 self.assertEqual(re.sub('a', '\t\n\v\r\f\a\b', 'a'), '\t\n\v\r\f\a\b')
156 self.assertEqual(re.sub('a', '\t\n\v\r\f\a\b', 'a'),
160 with self.assertRaises(re.PatternError):
161 self.assertEqual(re.sub('a', '\\' + c, 'a'), '\\' + c)
163 self.assertEqual(re.sub(r'^\s*', 'X', 'test'), 'Xtest')
167 self.assertEqual(re.sub(r'(?P<unk>x)', r'\g<1>\g<1>\b', 'xx'),
172 self.assertEqual(re.sub(r'\r\n', r'\n', 'abc\r\ndef\r\n'),
174 self.assertEqual(re.sub('\r\n', r'\n', 'abc\r\ndef\r\n'),
176 self.assertEqual(re.sub(r'\r\n', '\n', 'abc\r\ndef\r\n'),
178 self.assertEqual(re.sub('\r\n', '\n', 'abc\r\ndef\r\n'),
183 pattern = re.compile('.')
184 self.assertRaises(ValueError, re.match, pattern, 'A', re.I)
185 self.assertRaises(ValueError, re.search, pattern, 'A', re.I)
186 self.assertRaises(ValueError, re.findall, pattern, 'A', re.I)
187 self.assertRaises(ValueError, re.compile, pattern, re.I)
191 re.compile("(?P<quote>)(?(quote))")
195 self.assertEqual(re.sub('x', r'\0', 'x'), '\0')
196 self.assertEqual(re.sub('x', r'\000', 'x'), '\000')
197 self.assertEqual(re.sub('x', r'\001', 'x'), '\001')
198 self.assertEqual(re.sub('x', r'\008', 'x'), '\0' + '8')
199 self.assertEqual(re.sub('x', r'\009', 'x'), '\0' + '9')
200 self.assertEqual(re.sub('x', r'\111', 'x'), '\111')
201 self.assertEqual(re.sub('x', r'\117', 'x'), '\117')
202 self.assertEqual(re.sub('x', r'\377', 'x'), '\377')
204 self.assertEqual(re.sub('x', r'\1111', 'x'), '\1111')
205 self.assertEqual(re.sub('x', r'\1111', 'x'), '\111' + '1')
207 self.assertEqual(re.sub('x', r'\00', 'x'), '\x00')
208 self.assertEqual(re.sub('x', r'\07', 'x'), '\x07')
209 self.assertEqual(re.sub('x', r'\08', 'x'), '\0' + '8')
210 self.assertEqual(re.sub('x', r'\09', 'x'), '\0' + '9')
211 self.assertEqual(re.sub('x', r'\0a', 'x'), '\0' + 'a')
235 self.assertEqual(re.sub('(((((((((((x)))))))))))', r'\11', 'x'), 'x')
236 self.assertEqual(re.sub('((((((((((y))))))))))(.)', r'\118', 'xyz'),
238 self.assertEqual(re.sub('((((((((((y))))))))))(.)', r'\11a', 'xyz'),
242 self.assertEqual(re.sub('a', 'b', 'aaaaa'), 'bbbbb')
244 self.assertEqual(re.sub('a', 'b', 'aaaaa', 1), 'baaaa')
246 self.assertEqual(re.sub('a', 'b', 'aaaaa', count=1), 'baaaa')
250 re.sub('a', 'b', 'aaaaa', 1, count=1)
253 re.sub('a', 'b', 'aaaaa', 1, 0, flags=0)
257 re.sub('a', 'b', 'aaaaa', 1, 0, 0)
261 result = re.sub('a', 'b', 'aaaaa', re.I)
262 self.assertEqual(result, re.sub('a', 'b', 'aaaaa', count=int(re.I)))
267 result = re.subn("b*", "x", "xyz", re.I)
268 self.assertEqual(result, re.subn("b*", "x", "xyz", count=int(re.I)))
273 result = re.split(":", ":a:b::c", re.I)
274 self.assertEqual(result, re.split(":", ":a:b::c", maxsplit=int(re.I)))
280 self.assertEqual(re.sub(r'(\S)\s+(\S)', r'\1 \2', 'hello there'),
284 re.compile(r'(?P<a>x)(?P=a)(?(a)y)')
285 re.compile(r'(?P<a1>x)(?P=a1)(?(a1)y)')
286 re.compile(r'(?P<a1>x)\1(?(1)y)')
287 re.compile(b'(?P<a1>x)(?P=a1)(?(a1)y)')
289 re.compile('(?P<µ>x)(?P=µ)(?(µ)y)')
290 re.compile('(?P<��������������>x)(?P=��������������)(?(��������������)y)')
294 self.assertEqual(re.match(pat, 'xc8yz').span(), (0, 5))
333 self.assertEqual(re.sub('(?P<a>x)|(?P<b>y)', r'\g<b>', 'xx'), '')
334 self.assertEqual(re.sub('(?P<a>x)|(?P<b>y)', r'\2', 'xx'), '')
335 self.assertEqual(re.sub(b'(?P<a1>x)', br'\g<a1>', b'xx'), b'xx')
337 self.assertEqual(re.sub('(?P<µ>x)', r'\g<µ>', 'xx'), 'xx')
338 self.assertEqual(re.sub('(?P<��������������>x)', r'\g<��������������>', 'xx'), 'xx')
341 self.assertEqual(re.sub(pat, r'\g<200>', 'xc8yzxc8y'), 'c8zc8')
360 re.sub('(?P<a>x)', r'\g<ab>', 'xx')
381 self.assertEqual(re.subn("(?i)b+", "x", "bbbb BBBB"), ('x x', 2))
382 self.assertEqual(re.subn("b+", "x", "bbbb BBBB"), ('x BBBB', 1))
383 self.assertEqual(re.subn("b+", "x", "xyz"), ('xyz', 0))
384 self.assertEqual(re.subn("b*", "x", "xyz"), ('xxxyxzx', 4))
386 self.assertEqual(re.subn("b*", "x", "xyz", 2), ('xxxyz', 2))
388 self.assertEqual(re.subn("b*", "x", "xyz", count=2), ('xxxyz', 2))
392 re.subn('a', 'b', 'aaaaa', 1, count=1)
395 re.subn('a', 'b', 'aaaaa', 1, 0, flags=0)
399 re.subn('a', 'b', 'aaaaa', 1, 0, 0)
403 self.assertTypedEqual(re.split(":", string),
405 self.assertTypedEqual(re.split(":+", string),
407 self.assertTypedEqual(re.split("(:+)", string),
411 self.assertTypedEqual(re.split(b":", string),
413 self.assertTypedEqual(re.split(b":+", string),
415 self.assertTypedEqual(re.split(b"(:+)", string),
420 self.assertEqual(re.split(":", string), ['', a, b, '', c])
421 self.assertEqual(re.split(":+", string), ['', a, b, c])
422 self.assertEqual(re.split("(:+)", string),
425 self.assertEqual(re.split("(?::+)", ":a:b::c"), ['', 'a', 'b', 'c'])
426 self.assertEqual(re.split("(:)+", ":a:b::c"),
428 self.assertEqual(re.split("([b:]+)", ":a:b::c"),
430 self.assertEqual(re.split("(b)|(:+)", ":a:b::c"),
433 self.assertEqual(re.split("(?:b)|(?::+)", ":a:b::c"),
443 self.assertTypedEqual(re.split(sep, ':a:b::c'), expected)
452 self.assertTypedEqual(re.split(sep, ':a:b::c'), expected)
456 self.assertEqual(re.split(":", ":a:b::c", 2), ['', 'a', 'b::c'])
458 self.assertEqual(re.split(":", ":a:b::c", maxsplit=2), ['', 'a', 'b::c'])
459 self.assertEqual(re.split(':', 'a:b:c:d', maxsplit=2), ['a', 'b', 'c:d'])
460 self.assertEqual(re.split("(:)", ":a:b::c", maxsplit=2),
462 self.assertEqual(re.split("(:+)", ":a:b::c", maxsplit=2),
464 self.assertEqual(re.split("(:*)", ":a:b::c", maxsplit=2),
469 re.split(":", ":a:b::c", 2, maxsplit=2)
472 re.split(":", ":a:b::c", 2, 0, flags=0)
476 re.split(":", ":a:b::c", 2, 0, 0)
479 self.assertEqual(re.findall(":+", "abc"), [])
481 self.assertTypedEqual(re.findall(":+", string),
483 self.assertTypedEqual(re.findall("(:+)", string),
485 self.assertTypedEqual(re.findall("(:)(:*)", string),
489 self.assertTypedEqual(re.findall(b":+", string),
491 self.assertTypedEqual(re.findall(b"(:+)", string),
493 self.assertTypedEqual(re.findall(b"(:)(:*)", string),
499 self.assertEqual(re.findall("%s+" % x, string), [x, xx, xxx])
500 self.assertEqual(re.findall("(%s+)" % x, string), [x, xx, xxx])
501 self.assertEqual(re.findall("(%s)(%s*)" % (x, x), string),
505 self.assertEqual(re.findall(r"(a|(b))", "aba"),
510 self.assertEqual(re.match('a', string).groups(), ())
511 self.assertEqual(re.match('(a)', string).groups(), ('a',))
512 self.assertEqual(re.match('(a)', string).group(0), 'a')
513 self.assertEqual(re.match('(a)', string).group(1), 'a')
514 self.assertEqual(re.match('(a)', string).group(1, 1), ('a', 'a'))
516 self.assertEqual(re.match(b'a', string).groups(), ())
517 self.assertEqual(re.match(b'(a)', string).groups(), (b'a',))
518 self.assertEqual(re.match(b'(a)', string).group(0), b'a')
519 self.assertEqual(re.match(b'(a)', string).group(1), b'a')
520 self.assertEqual(re.match(b'(a)', string).group(1, 1), (b'a', b'a'))
522 self.assertEqual(re.match(a, a).groups(), ())
523 self.assertEqual(re.match('(%s)' % a, a).groups(), (a,))
524 self.assertEqual(re.match('(%s)' % a, a).group(0), a)
525 self.assertEqual(re.match('(%s)' % a, a).group(1), a)
526 self.assertEqual(re.match('(%s)' % a, a).group(1, 1), (a, a))
528 pat = re.compile('((a)|(b))(c)?')
535 pat = re.compile('(?:(?P<a1>a)|(?P<b2>b))(?P<c3>c)?')
548 m = re.match('(a)(b)', 'ab')
563 pat = re.compile('(?:(?P<a1>a)|(?P<b2>b))(?P<c3>c)?')
607 # Issue 16203: Proposal: add re.fullmatch() method.
608 self.assertEqual(re.fullmatch(r"a", "a").span(), (0, 1))
610 self.assertEqual(re.fullmatch(r"a|ab", string).span(), (0, 2))
612 self.assertEqual(re.fullmatch(br"a|ab", string).span(), (0, 2))
615 self.assertEqual(re.fullmatch(r, a + b).span(), (0, 2))
616 self.assertEqual(re.fullmatch(r".*?$", "abc").span(), (0, 3))
617 self.assertEqual(re.fullmatch(r".*?", "abc").span(), (0, 3))
618 self.assertEqual(re.fullmatch(r"a.*?b", "ab").span(), (0, 2))
619 self.assertEqual(re.fullmatch(r"a.*?b", "abb").span(), (0, 3))
620 self.assertEqual(re.fullmatch(r"a.*?b", "axxb").span(), (0, 4))
621 self.assertIsNone(re.fullmatch(r"a+", "ab"))
622 self.assertIsNone(re.fullmatch(r"abc$", "abc\n"))
623 self.assertIsNone(re.fullmatch(r"abc\Z", "abc\n"))
624 self.assertIsNone(re.fullmatch(r"(?m)abc$", "abc\n"))
625 self.assertEqual(re.fullmatch(r"ab(?=c)cd", "abcd").span(), (0, 4))
626 self.assertEqual(re.fullmatch(r"ab(?<=b)cd", "abcd").span(), (0, 4))
627 self.assertEqual(re.fullmatch(r"(?=a|ab)ab", "ab").span(), (0, 2))
630 re.compile(r"bc").fullmatch("abcd", pos=1, endpos=3).span(), (1, 3))
632 re.compile(r".*?$").fullmatch("abcd", pos=1, endpos=3).span(), (1, 3))
634 re.compile(r".*?").fullmatch("abcd", pos=1, endpos=3).span(), (1, 3))
637 self.assertEqual(re.match(r'^(\()?([^()]+)(?(1)\))$', '(a)').groups(),
639 self.assertEqual(re.match(r'^(\()?([^()]+)(?(1)\))$', 'a').groups(),
641 self.assertIsNone(re.match(r'^(\()?([^()]+)(?(1)\))$', 'a)'))
642 self.assertIsNone(re.match(r'^(\()?([^()]+)(?(1)\))$', '(a'))
643 self.assertEqual(re.match('^(?:(a)|c)((?(1)b|d))$', 'ab').groups(),
645 self.assertEqual(re.match(r'^(?:(a)|c)((?(1)b|d))$', 'cd').groups(),
647 self.assertEqual(re.match(r'^(?:(a)|c)((?(1)|d))$', 'cd').groups(),
649 self.assertEqual(re.match(r'^(?:(a)|c)((?(1)|d))$', 'a').groups(),
653 p = re.compile('(?P<g1>a)(?P<g2>b)?((?(g2)c|d))')
664 self.assertEqual(re.match(pat, 'xc8yz').span(), (0, 5))
700 re.compile(r'()(?(1)\x%02x?)' % i)
703 from re._constants import MAXGROUPS
710 self.assertEqual(re.match(r'^(\|)?([^()]+)\1$', '|a|').groups(),
712 self.assertEqual(re.match(r'^(\|)?([^()]+)\1?$', 'a').groups(),
714 self.assertIsNone(re.match(r'^(\|)?([^()]+)\1$', 'a|'))
715 self.assertIsNone(re.match(r'^(\|)?([^()]+)\1$', '|a'))
716 self.assertEqual(re.match(r'^(?:(a)|c)(\1)$', 'aa').groups(),
718 self.assertEqual(re.match(r'^(?:(a)|c)(\1)?$', 'c').groups(),
724 self.assertEqual(re.match('(?P<first>first) (?P<second>second)',
729 self.assertEqual(re.match("(?P<first>first) (?P<second>second)",
733 self.assertEqual(re.match("(?P<first>first)|(?P<second>second)",
739 self.assertIsNone(re.match(r"^(\w){1}$", "abc"))
740 self.assertIsNone(re.match(r"^(\w){1}?$", "abc"))
741 self.assertIsNone(re.match(r"^(\w){1,2}$", "abc"))
742 self.assertIsNone(re.match(r"^(\w){1,2}?$", "abc"))
744 self.assertEqual(re.match(r"^(\w){3}$", "abc").group(1), "c")
745 self.assertEqual(re.match(r"^(\w){1,3}$", "abc").group(1), "c")
746 self.assertEqual(re.match(r"^(\w){1,4}$", "abc").group(1), "c")
747 self.assertEqual(re.match(r"^(\w){3,4}?$", "abc").group(1), "c")
748 self.assertEqual(re.match(r"^(\w){3}?$", "abc").group(1), "c")
749 self.assertEqual(re.match(r"^(\w){1,3}?$", "abc").group(1), "c")
750 self.assertEqual(re.match(r"^(\w){1,4}?$", "abc").group(1), "c")
751 self.assertEqual(re.match(r"^(\w){3,4}?$", "abc").group(1), "c")
753 self.assertIsNone(re.match(r"^x{1}$", "xxx"))
754 self.assertIsNone(re.match(r"^x{1}?$", "xxx"))
755 self.assertIsNone(re.match(r"^x{1,2}$", "xxx"))
756 self.assertIsNone(re.match(r"^x{1,2}?$", "xxx"))
758 self.assertTrue(re.match(r"^x{3}$", "xxx"))
759 self.assertTrue(re.match(r"^x{1,3}$", "xxx"))
760 self.assertTrue(re.match(r"^x{3,3}$", "xxx"))
761 self.assertTrue(re.match(r"^x{1,4}$", "xxx"))
762 self.assertTrue(re.match(r"^x{3,4}?$", "xxx"))
763 self.assertTrue(re.match(r"^x{3}?$", "xxx"))
764 self.assertTrue(re.match(r"^x{1,3}?$", "xxx"))
765 self.assertTrue(re.match(r"^x{1,4}?$", "xxx"))
766 self.assertTrue(re.match(r"^x{3,4}?$", "xxx"))
768 self.assertIsNone(re.match(r"^x{}$", "xxx"))
769 self.assertTrue(re.match(r"^x{}$", "x{}"))
775 self.assertEqual(re.compile("(?i)(a)(b)").pattern, "(?i)(a)(b)")
776 self.assertEqual(re.compile("(?i)(a)(b)").flags, re.I | re.U)
777 self.assertEqual(re.compile("(?i)(a)(b)").groups, 2)
778 self.assertEqual(re.compile("(?i)(a)(b)").groupindex, {})
779 self.assertEqual(re.compile("(?i)(?P<first>a)(?P<other>b)").groupindex,
782 self.assertEqual(re.match("(a)", "a").pos, 0)
783 self.assertEqual(re.match("(a)", "a").endpos, 1)
784 self.assertEqual(re.match("(a)", "a").string, "a")
785 self.assertEqual(re.match("(a)", "a").regs, ((0, 1), (0, 1)))
786 self.assertTrue(re.match("(a)", "a").re)
789 p = re.compile(r'(?i)(?P<first>a)(?P<other>b)')
797 self.assertEqual(re.search(r"\b(b.)\b",
799 self.assertEqual(re.search(r"\B(b.)\B",
801 self.assertEqual(re.search(r"\b(b.)\b",
802 "abcd abc bcd bx", re.ASCII).group(1), "bx")
803 self.assertEqual(re.search(r"\B(b.)\B",
804 "abc bcd bc abxd", re.ASCII).group(1), "bx")
805 self.assertEqual(re.search(r"^abc$", "\nabc\n", re.M).group(0), "abc")
806 self.assertEqual(re.search(r"^\Aabc\Z$", "abc", re.M).group(0), "abc")
807 self.assertIsNone(re.search(r"^\Aabc\Z$", "\nabc\n", re.M))
808 self.assertEqual(re.search(br"\b(b.)\b",
810 self.assertEqual(re.search(br"\B(b.)\B",
812 self.assertEqual(re.search(br"\b(b.)\b",
813 b"abcd abc bcd bx", re.LOCALE).group(1), b"bx")
814 self.assertEqual(re.search(br"\B(b.)\B",
815 b"abc bcd bc abxd", re.LOCALE).group(1), b"bx")
816 self.assertEqual(re.search(br"^abc$", b"\nabc\n", re.M).group(0), b"abc")
817 self.assertEqual(re.search(br"^\Aabc\Z$", b"abc", re.M).group(0), b"abc")
818 self.assertIsNone(re.search(br"^\Aabc\Z$", b"\nabc\n", re.M))
819 self.assertEqual(re.search(r"\d\D\w\W\s\S",
821 self.assertEqual(re.search(br"\d\D\w\W\s\S",
823 self.assertEqual(re.search(r"\d\D\w\W\s\S",
824 "1aa! a", re.ASCII).group(0), "1aa! a")
825 self.assertEqual(re.search(br"\d\D\w\W\s\S",
826 b"1aa! a", re.LOCALE).group(0), b"1aa! a")
830 self.assertEqual(re.match(r"\(", '(').group(), '(')
831 self.assertIsNone(re.match(r"\(", ')'))
832 self.assertEqual(re.match(r"\\", '\\').group(), '\\')
833 self.assertEqual(re.match(r"[\]]", ']').group(), ']')
834 self.assertIsNone(re.match(r"[\]]", '['))
835 self.assertEqual(re.match(r"[a\-c]", '-').group(), '-')
836 self.assertIsNone(re.match(r"[a\-c]", 'b'))
837 self.assertEqual(re.match(r"[\^a]+", 'a^').group(), 'a^')
838 self.assertIsNone(re.match(r"[\^a]+", 'b'))
839 re.purge() # for warnings
842 self.assertRaises(re.PatternError, re.compile, '\\%c' % c)
845 self.assertRaises(re.PatternError, re.compile, '[\\%c]' % c)
849 self.assertTrue(re.match(r'\N{LESS-THAN SIGN}', '<'))
850 self.assertTrue(re.match(r'\N{less-than sign}', '<'))
851 self.assertIsNone(re.match(r'\N{LESS-THAN SIGN}', '>'))
852 self.assertTrue(re.match(r'\N{SNAKE}', '\U0001f40d'))
853 self.assertTrue(re.match(r'\N{ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH '
856 self.assertTrue(re.match(r'[\N{LESS-THAN SIGN}-\N{GREATER-THAN SIGN}]',
858 self.assertIsNone(re.match(r'[\N{LESS-THAN SIGN}-\N{GREATER-THAN SIGN}]',
889 self.assertEqual(re.search(r"\b(abc)\b", "abc").group(1), "abc")
890 self.assertEqual(re.search(r"\b(abc)\b", "abc", re.ASCII).group(1), "abc")
891 self.assertEqual(re.search(br"\b(abc)\b", b"abc").group(1), b"abc")
892 self.assertEqual(re.search(br"\b(abc)\b", b"abc", re.LOCALE).group(1), b"abc")
893 self.assertEqual(re.search(r"\b(ьюя)\b", "ьюя").group(1), "ьюя")
894 self.assertIsNone(re.search(r"\b(ьюя)\b", "ьюя", re.ASCII))
896 self.assertTrue(re.match(r".\b", "a="))
897 self.assertTrue(re.match(r".\b", "a=", re.ASCII))
898 self.assertTrue(re.match(br".\b", b"a="))
899 self.assertTrue(re.match(br".\b", b"a=", re.LOCALE))
900 self.assertTrue(re.match(r".\b", "я="))
901 self.assertIsNone(re.match(r".\b", "я=", re.ASCII))
903 self.assertTrue(re.match(r".\b", "=a"))
904 self.assertTrue(re.match(r".\b", "=a", re.ASCII))
905 self.assertTrue(re.match(br".\b", b"=a"))
906 self.assertTrue(re.match(br".\b", b"=a", re.LOCALE))
907 self.assertTrue(re.match(r".\b", "=я"))
908 self.assertIsNone(re.match(r".\b", "=я", re.ASCII))
910 self.assertIsNone(re.match(r".\b", "ab"))
911 self.assertIsNone(re.match(r".\b", "ab", re.ASCII))
912 self.assertIsNone(re.match(br".\b", b"ab"))
913 self.assertIsNone(re.match(br".\b", b"ab", re.LOCALE))
914 self.assertIsNone(re.match(r".\b", "юя"))
915 self.assertIsNone(re.match(r".\b", "юя", re.ASCII))
917 self.assertIsNone(re.match(r".\b", "=-"))
918 self.assertIsNone(re.match(r".\b", "=-", re.ASCII))
919 self.assertIsNone(re.match(br".\b", b"=-"))
920 self.assertIsNone(re.match(br".\b", b"=-", re.LOCALE))
922 self.assertIsNone(re.match(r".\B", "a="))
923 self.assertIsNone(re.match(r".\B", "a=", re.ASCII))
924 self.assertIsNone(re.match(br".\B", b"a="))
925 self.assertIsNone(re.match(br".\B", b"a=", re.LOCALE))
926 self.assertIsNone(re.match(r".\B", "я="))
927 self.assertTrue(re.match(r".\B", "я=", re.ASCII))
929 self.assertIsNone(re.match(r".\B", "=a"))
930 self.assertIsNone(re.match(r".\B", "=a", re.ASCII))
931 self.assertIsNone(re.match(br".\B", b"=a"))
932 self.assertIsNone(re.match(br".\B", b"=a", re.LOCALE))
933 self.assertIsNone(re.match(r".\B", "=я"))
934 self.assertTrue(re.match(r".\B", "=я", re.ASCII))
936 self.assertTrue(re.match(r".\B", "ab"))
937 self.assertTrue(re.match(r".\B", "ab", re.ASCII))
938 self.assertTrue(re.match(br".\B", b"ab"))
939 self.assertTrue(re.match(br".\B", b"ab", re.LOCALE))
940 self.assertTrue(re.match(r".\B", "юя"))
941 self.assertTrue(re.match(r".\B", "юя", re.ASCII))
943 self.assertTrue(re.match(r".\B", "=-"))
944 self.assertTrue(re.match(r".\B", "=-", re.ASCII))
945 self.assertTrue(re.match(br".\B", b"=-"))
946 self.assertTrue(re.match(br".\B", b"=-", re.LOCALE))
948 self.assertTrue(re.match(r"\b", "abc"))
949 self.assertTrue(re.match(r"\b", "abc", re.ASCII))
950 self.assertTrue(re.match(br"\b", b"abc"))
951 self.assertTrue(re.match(br"\b", b"abc", re.LOCALE))
952 self.assertTrue(re.match(r"\b", "ьюя"))
953 self.assertIsNone(re.match(r"\b", "ьюя", re.ASCII))
955 self.assertTrue(re.fullmatch(r".+\b", "abc"))
956 self.assertTrue(re.fullmatch(r".+\b", "abc", re.ASCII))
957 self.assertTrue(re.fullmatch(br".+\b", b"abc"))
958 self.assertTrue(re.fullmatch(br".+\b", b"abc", re.LOCALE))
959 self.assertTrue(re.fullmatch(r".+\b", "ьюя"))
960 self.assertIsNone(re.search(r"\b", "ьюя", re.ASCII))
962 self.assertEqual(re.search(r"\B", "abc").span(), (1, 1))
963 self.assertEqual(re.search(r"\B", "abc", re.ASCII).span(), (1, 1))
964 self.assertEqual(re.search(br"\B", b"abc").span(), (1, 1))
965 self.assertEqual(re.search(br"\B", b"abc", re.LOCALE).span(), (1, 1))
966 self.assertEqual(re.search(r"\B", "ьюя").span(), (1, 1))
967 self.assertEqual(re.search(r"\B", "ьюя", re.ASCII).span(), (0, 0))
969 self.assertIsNone(re.match(r"\B", "abc"))
970 self.assertIsNone(re.match(r"\B", "abc", re.ASCII))
971 self.assertIsNone(re.match(br"\B", b"abc"))
972 self.assertIsNone(re.match(br"\B", b"abc", re.LOCALE))
973 self.assertIsNone(re.match(r"\B", "ьюя"))
974 self.assertTrue(re.match(r"\B", "ьюя", re.ASCII))
976 self.assertIsNone(re.fullmatch(r".+\B", "abc"))
977 self.assertIsNone(re.fullmatch(r".+\B", "abc", re.ASCII))
978 self.assertIsNone(re.fullmatch(br".+\B", b"abc"))
979 self.assertIsNone(re.fullmatch(br".+\B", b"abc", re.LOCALE))
980 self.assertIsNone(re.fullmatch(r".+\B", "ьюя"))
981 self.assertTrue(re.fullmatch(r".+\B", "ьюя", re.ASCII))
984 self.assertIsNone(re.search(r"\b", ""))
985 self.assertIsNone(re.search(r"\b", "", re.ASCII))
986 self.assertIsNone(re.search(br"\b", b""))
987 self.assertIsNone(re.search(br"\b", b"", re.LOCALE))
990 self.assertIsNone(re.search(r"\B", ""))
991 self.assertIsNone(re.search(r"\B", "", re.ASCII))
992 self.assertIsNone(re.search(br"\B", b""))
993 self.assertIsNone(re.search(br"\B", b"", re.LOCALE))
996 self.assertEqual(len(re.findall(r"\b", "a")), 2)
997 self.assertEqual(len(re.findall(r"\b", "a", re.ASCII)), 2)
998 self.assertEqual(len(re.findall(br"\b", b"a")), 2)
999 self.assertEqual(len(re.findall(br"\b", b"a", re.LOCALE)), 2)
1000 self.assertEqual(len(re.findall(r"\B", "a")), 0)
1001 self.assertEqual(len(re.findall(r"\B", "a", re.ASCII)), 0)
1002 self.assertEqual(len(re.findall(br"\B", b"a")), 0)
1003 self.assertEqual(len(re.findall(br"\B", b"a", re.LOCALE)), 0)
1005 self.assertEqual(len(re.findall(r"\b", " ")), 0)
1006 self.assertEqual(len(re.findall(r"\b", " ", re.ASCII)), 0)
1007 self.assertEqual(len(re.findall(br"\b", b" ")), 0)
1008 self.assertEqual(len(re.findall(br"\b", b" ", re.LOCALE)), 0)
1009 self.assertEqual(len(re.findall(r"\b", " ")), 0)
1010 self.assertEqual(len(re.findall(r"\b", " ", re.ASCII)), 0)
1011 self.assertEqual(len(re.findall(br"\b", b" ")), 0)
1012 self.assertEqual(len(re.findall(br"\b", b" ", re.LOCALE)), 0)
1014 self.assertEqual(len(re.findall(r"\B", " ")), 2)
1015 self.assertEqual(len(re.findall(r"\B", " ", re.ASCII)), 2)
1016 self.assertEqual(len(re.findall(br"\B", b" ")), 2)
1017 self.assertEqual(len(re.findall(br"\B", b" ", re.LOCALE)), 2)
1020 self.assertEqual(re.match("([\u2222\u2223])",
1023 self.assertEqual(re.match(r, "\uff01").group(), "\uff01")
1027 r = re.compile('|'.join(('%d'%x for x in range(10000))))
1032 self.assertEqual(re.match("a.b", "a\nb", re.DOTALL).group(0),
1034 self.assertEqual(re.match("a.*b", "a\n\nb", re.DOTALL).group(0),
1038 self.assertEqual(re.match(r"(a(?=\s[^a]))", "a b").group(1), "a")
1039 self.assertEqual(re.match(r"(a(?=\s[^a]*))", "a b").group(1), "a")
1040 self.assertEqual(re.match(r"(a(?=\s[abc]))", "a b").group(1), "a")
1041 self.assertEqual(re.match(r"(a(?=\s[abc]*))", "a bc").group(1), "a")
1042 self.assertEqual(re.match(r"(a)(?=\s\1)", "a a").group(1), "a")
1043 self.assertEqual(re.match(r"(a)(?=\s\1*)", "a aa").group(1), "a")
1044 self.assertEqual(re.match(r"(a)(?=\s(abc|a))", "a a").group(1), "a")
1046 self.assertEqual(re.match(r"(a(?!\s[^a]))", "a a").group(1), "a")
1047 self.assertEqual(re.match(r"(a(?!\s[abc]))", "a d").group(1), "a")
1048 self.assertEqual(re.match(r"(a)(?!\s\1)", "a b").group(1), "a")
1049 self.assertEqual(re.match(r"(a)(?!\s(abc|a))", "a b").group(1), "a")
1052 self.assertTrue(re.match(r'(a)b(?=\1)a', 'aba'))
1053 self.assertIsNone(re.match(r'(a)b(?=\1)c', 'abac'))
1055 self.assertTrue(re.match(r'(?:(a)|(x))b(?=(?(2)x|c))c', 'abc'))
1056 self.assertIsNone(re.match(r'(?:(a)|(x))b(?=(?(2)c|x))c', 'abc'))
1057 self.assertTrue(re.match(r'(?:(a)|(x))b(?=(?(2)x|c))c', 'abc'))
1058 self.assertIsNone(re.match(r'(?:(a)|(x))b(?=(?(1)b|x))c', 'abc'))
1059 self.assertTrue(re.match(r'(?:(a)|(x))b(?=(?(1)c|x))c', 'abc'))
1061 self.assertTrue(re.match(r'(a)b(?=(?(2)x|c))(c)', 'abc'))
1062 self.assertIsNone(re.match(r'(a)b(?=(?(2)b|x))(c)', 'abc'))
1063 self.assertTrue(re.match(r'(a)b(?=(?(1)c|x))(c)', 'abc'))
1066 self.assertTrue(re.match(r'ab(?<=b)c', 'abc'))
1067 self.assertIsNone(re.match(r'ab(?<=c)c', 'abc'))
1068 self.assertIsNone(re.match(r'ab(?<!b)c', 'abc'))
1069 self.assertTrue(re.match(r'ab(?<!c)c', 'abc'))
1071 self.assertTrue(re.match(r'(a)a(?<=\1)c', 'aac'))
1072 self.assertIsNone(re.match(r'(a)b(?<=\1)a', 'abaa'))
1073 self.assertIsNone(re.match(r'(a)a(?<!\1)c', 'aac'))
1074 self.assertTrue(re.match(r'(a)b(?<!\1)a', 'abaa'))
1076 self.assertIsNone(re.match(r'(?:(a)|(x))b(?<=(?(2)x|c))c', 'abc'))
1077 self.assertIsNone(re.match(r'(?:(a)|(x))b(?<=(?(2)b|x))c', 'abc'))
1078 self.assertTrue(re.match(r'(?:(a)|(x))b(?<=(?(2)x|b))c', 'abc'))
1079 self.assertIsNone(re.match(r'(?:(a)|(x))b(?<=(?(1)c|x))c', 'abc'))
1080 self.assertTrue(re.match(r'(?:(a)|(x))b(?<=(?(1)b|x))c', 'abc'))
1082 self.assertRaises(re.PatternError, re.compile, r'(a)b(?<=(?(2)b|x))(c)')
1083 self.assertIsNone(re.match(r'(a)b(?<=(?(1)c|x))(c)', 'abc'))
1084 self.assertTrue(re.match(r'(a)b(?<=(?(1)b|x))(c)', 'abc'))
1086 self.assertRaises(re.PatternError, re.compile, r'(a)b(?<=(.)\2)(c)')
1087 self.assertRaises(re.PatternError, re.compile, r'(a)b(?<=(?P<a>.)(?P=a))(c)')
1088 self.assertRaises(re.PatternError, re.compile, r'(a)b(?<=(a)(?(2)b|x))(c)')
1089 self.assertRaises(re.PatternError, re.compile, r'(a)b(?<=(.)(?<=\2))(c)')
1092 self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
1093 self.assertEqual(re.match(b"abc", b"ABC", re.I).group(0), b"ABC")
1094 self.assertEqual(re.match(r"(a\s[^a])", "a b", re.I).group(1), "a b")
1095 self.assertEqual(re.match(r"(a\s[^a]*)", "a bb", re.I).group(1), "a bb")
1096 self.assertEqual(re.match(r"(a\s[abc])", "a b", re.I).group(1), "a b")
1097 self.assertEqual(re.match(r"(a\s[abc]*)", "a bb", re.I).group(1), "a bb")
1098 self.assertEqual(re.match(r"((a)\s\2)", "a a", re.I).group(1), "a a")
1099 self.assertEqual(re.match(r"((a)\s\2*)", "a aa", re.I).group(1), "a aa")
1100 self.assertEqual(re.match(r"((a)\s(abc|a))", "a a", re.I).group(1), "a a")
1101 self.assertEqual(re.match(r"((a)\s(abc|a)*)", "a aa", re.I).group(1), "a aa")
1105 self.assertTrue(re.match(r'K', '\u212a', re.I))
1106 self.assertTrue(re.match(r'k', '\u212a', re.I))
1107 self.assertTrue(re.match(r'\u212a', 'K', re.I))
1108 self.assertTrue(re.match(r'\u212a', 'k', re.I))
1112 self.assertTrue(re.match(r'S', '\u017f', re.I))
1113 self.assertTrue(re.match(r's', '\u017f', re.I))
1114 self.assertTrue(re.match(r'\u017f', 'S', re.I))
1115 self.assertTrue(re.match(r'\u017f', 's', re.I))
1119 self.assertTrue(re.match(r'\u0412', '\u0432', re.I))
1120 self.assertTrue(re.match(r'\u0412', '\u1c80', re.I))
1121 self.assertTrue(re.match(r'\u0432', '\u0412', re.I))
1122 self.assertTrue(re.match(r'\u0432', '\u1c80', re.I))
1123 self.assertTrue(re.match(r'\u1c80', '\u0412', re.I))
1124 self.assertTrue(re.match(r'\u1c80', '\u0432', re.I))
1128 self.assertTrue(re.match(r'\ufb05', '\ufb06', re.I))
1129 self.assertTrue(re.match(r'\ufb06', '\ufb05', re.I))
1132 self.assertTrue(re.match(r'[19A]', 'A', re.I))
1133 self.assertTrue(re.match(r'[19a]', 'a', re.I))
1134 self.assertTrue(re.match(r'[19a]', 'A', re.I))
1135 self.assertTrue(re.match(r'[19A]', 'a', re.I))
1136 self.assertTrue(re.match(br'[19A]', b'A', re.I))
1137 self.assertTrue(re.match(br'[19a]', b'a', re.I))
1138 self.assertTrue(re.match(br'[19a]', b'A', re.I))
1139 self.assertTrue(re.match(br'[19A]', b'a', re.I))
1140 self.assertTrue(re.match(r'[19\xc7]', '\xc7', re.I))
1141 self.assertTrue(re.match(r'[19\xc7]', '\xe7', re.I))
1142 self.assertTrue(re.match(r'[19\xe7]', '\xc7', re.I))
1143 self.assertTrue(re.match(r'[19\xe7]', '\xe7', re.I))
1144 self.assertTrue(re.match(r'[19\u0400]', '\u0400', re.I))
1145 self.assertTrue(re.match(r'[19\u0400]', '\u0450', re.I))
1146 self.assertTrue(re.match(r'[19\u0450]', '\u0400', re.I))
1147 self.assertTrue(re.match(r'[19\u0450]', '\u0450', re.I))
1148 self.assertTrue(re.match(r'[19\U00010400]', '\U00010400', re.I))
1149 self.assertTrue(re.match(r'[19\U00010400]', '\U00010428', re.I))
1150 self.assertTrue(re.match(r'[19\U00010428]', '\U00010400', re.I))
1151 self.assertTrue(re.match(r'[19\U00010428]', '\U00010428', re.I))
1153 self.assertTrue(re.match(br'[19A]', b'A', re.I))
1154 self.assertTrue(re.match(br'[19a]', b'a', re.I))
1155 self.assertTrue(re.match(br'[19a]', b'A', re.I))
1156 self.assertTrue(re.match(br'[19A]', b'a', re.I))
1157 self.assertTrue(re.match(r'[19A]', 'A', re.I|re.A))
1158 self.assertTrue(re.match(r'[19a]', 'a', re.I|re.A))
1159 self.assertTrue(re.match(r'[19a]', 'A', re.I|re.A))
1160 self.assertTrue(re.match(r'[19A]', 'a', re.I|re.A))
1161 self.assertTrue(re.match(r'[19\xc7]', '\xc7', re.I|re.A))
1162 self.assertIsNone(re.match(r'[19\xc7]', '\xe7', re.I|re.A))
1163 self.assertIsNone(re.match(r'[19\xe7]', '\xc7', re.I|re.A))
1164 self.assertTrue(re.match(r'[19\xe7]', '\xe7', re.I|re.A))
1165 self.assertTrue(re.match(r'[19\u0400]', '\u0400', re.I|re.A))
1166 self.assertIsNone(re.match(r'[19\u0400]', '\u0450', re.I|re.A))
1167 self.assertIsNone(re.match(r'[19\u0450]', '\u0400', re.I|re.A))
1168 self.assertTrue(re.match(r'[19\u0450]', '\u0450', re.I|re.A))
1169 self.assertTrue(re.match(r'[19\U00010400]', '\U00010400', re.I|re.A))
1170 self.assertIsNone(re.match(r'[19\U00010400]', '\U00010428', re.I|re.A))
1171 self.assertIsNone(re.match(r'[19\U00010428]', '\U00010400', re.I|re.A))
1172 self.assertTrue(re.match(r'[19\U00010428]', '\U00010428', re.I|re.A))
1176 self.assertTrue(re.match(r'[19K]', '\u212a', re.I))
1177 self.assertTrue(re.match(r'[19k]', '\u212a', re.I))
1178 self.assertTrue(re.match(r'[19\u212a]', 'K', re.I))
1179 self.assertTrue(re.match(r'[19\u212a]', 'k', re.I))
1183 self.assertTrue(re.match(r'[19S]', '\u017f', re.I))
1184 self.assertTrue(re.match(r'[19s]', '\u017f', re.I))
1185 self.assertTrue(re.match(r'[19\u017f]', 'S', re.I))
1186 self.assertTrue(re.match(r'[19\u017f]', 's', re.I))
1190 self.assertTrue(re.match(r'[19\u0412]', '\u0432', re.I))
1191 self.assertTrue(re.match(r'[19\u0412]', '\u1c80', re.I))
1192 self.assertTrue(re.match(r'[19\u0432]', '\u0412', re.I))
1193 self.assertTrue(re.match(r'[19\u0432]', '\u1c80', re.I))
1194 self.assertTrue(re.match(r'[19\u1c80]', '\u0412', re.I))
1195 self.assertTrue(re.match(r'[19\u1c80]', '\u0432', re.I))
1199 self.assertTrue(re.match(r'[19\ufb05]', '\ufb06', re.I))
1200 self.assertTrue(re.match(r'[19\ufb06]', '\ufb05', re.I))
1204 self.assertTrue(re.match(r'[9-a]', '_', re.I))
1205 self.assertIsNone(re.match(r'[9-A]', '_', re.I))
1206 self.assertTrue(re.match(br'[9-a]', b'_', re.I))
1207 self.assertIsNone(re.match(br'[9-A]', b'_', re.I))
1208 self.assertTrue(re.match(r'[\xc0-\xde]', '\xd7', re.I))
1209 self.assertTrue(re.match(r'[\xc0-\xde]', '\xe7', re.I))
1210 self.assertIsNone(re.match(r'[\xc0-\xde]', '\xf7', re.I))
1211 self.assertTrue(re.match(r'[\xe0-\xfe]', '\xf7', re.I))
1212 self.assertTrue(re.match(r'[\xe0-\xfe]', '\xc7', re.I))
1213 self.assertIsNone(re.match(r'[\xe0-\xfe]', '\xd7', re.I))
1214 self.assertTrue(re.match(r'[\u0430-\u045f]', '\u0450', re.I))
1215 self.assertTrue(re.match(r'[\u0430-\u045f]', '\u0400', re.I))
1216 self.assertTrue(re.match(r'[\u0400-\u042f]', '\u0450', re.I))
1217 self.assertTrue(re.match(r'[\u0400-\u042f]', '\u0400', re.I))
1218 self.assertTrue(re.match(r'[\U00010428-\U0001044f]', '\U00010428', re.I))
1219 self.assertTrue(re.match(r'[\U00010428-\U0001044f]', '\U00010400', re.I))
1220 self.assertTrue(re.match(r'[\U00010400-\U00010427]', '\U00010428', re.I))
1221 self.assertTrue(re.match(r'[\U00010400-\U00010427]', '\U00010400', re.I))
1223 self.assertTrue(re.match(r'[\xc0-\xde]', '\xd7', re.I|re.A))
1224 self.assertIsNone(re.match(r'[\xc0-\xde]', '\xe7', re.I|re.A))
1225 self.assertTrue(re.match(r'[\xe0-\xfe]', '\xf7', re.I|re.A))
1226 self.assertIsNone(re.match(r'[\xe0-\xfe]', '\xc7', re.I|re.A))
1227 self.assertTrue(re.match(r'[\u0430-\u045f]', '\u0450', re.I|re.A))
1228 self.assertIsNone(re.match(r'[\u0430-\u045f]', '\u0400', re.I|re.A))
1229 self.assertIsNone(re.match(r'[\u0400-\u042f]', '\u0450', re.I|re.A))
1230 self.assertTrue(re.match(r'[\u0400-\u042f]', '\u0400', re.I|re.A))
1231 self.assertTrue(re.match(r'[\U00010428-\U0001044f]', '\U00010428', re.I|re.A))
1232 self.assertIsNone(re.match(r'[\U00010428-\U0001044f]', '\U00010400', re.I|re.A))
1233 self.assertIsNone(re.match(r'[\U00010400-\U00010427]', '\U00010428', re.I|re.A))
1234 self.assertTrue(re.match(r'[\U00010400-\U00010427]', '\U00010400', re.I|re.A))
1236 self.assertTrue(re.match(r'[N-\x7f]', 'A', re.I|re.A))
1237 self.assertTrue(re.match(r'[n-\x7f]', 'Z', re.I|re.A))
1238 self.assertTrue(re.match(r'[N-\uffff]', 'A', re.I|re.A))
1239 self.assertTrue(re.match(r'[n-\uffff]', 'Z', re.I|re.A))
1240 self.assertTrue(re.match(r'[N-\U00010000]', 'A', re.I|re.A))
1241 self.assertTrue(re.match(r'[n-\U00010000]', 'Z', re.I|re.A))
1245 self.assertTrue(re.match(r'[J-M]', '\u212a', re.I))
1246 self.assertTrue(re.match(r'[j-m]', '\u212a', re.I))
1247 self.assertTrue(re.match(r'[\u2129-\u212b]', 'K', re.I))
1248 self.assertTrue(re.match(r'[\u2129-\u212b]', 'k', re.I))
1252 self.assertTrue(re.match(r'[R-T]', '\u017f', re.I))
1253 self.assertTrue(re.match(r'[r-t]', '\u017f', re.I))
1254 self.assertTrue(re.match(r'[\u017e-\u0180]', 'S', re.I))
1255 self.assertTrue(re.match(r'[\u017e-\u0180]', 's', re.I))
1259 self.assertTrue(re.match(r'[\u0411-\u0413]', '\u0432', re.I))
1260 self.assertTrue(re.match(r'[\u0411-\u0413]', '\u1c80', re.I))
1261 self.assertTrue(re.match(r'[\u0431-\u0433]', '\u0412', re.I))
1262 self.assertTrue(re.match(r'[\u0431-\u0433]', '\u1c80', re.I))
1263 self.assertTrue(re.match(r'[\u1c80-\u1c82]', '\u0412', re.I))
1264 self.assertTrue(re.match(r'[\u1c80-\u1c82]', '\u0432', re.I))
1268 self.assertTrue(re.match(r'[\ufb04-\ufb05]', '\ufb06', re.I))
1269 self.assertTrue(re.match(r'[\ufb06-\ufb07]', '\ufb05', re.I))
1272 self.assertEqual(re.match(r"(\s)", " ").group(1), " ")
1275 self.assertEqual(re.search(r"\s([^a])", " b").group(1), "b")
1276 self.assertEqual(re.search(r"\s([^a]*)", " bb").group(1), "bb")
1281 p = re.compile(r'[0-9--1]')
1285 self.assertEqual(re.findall(r'[0-9--2]', s), list('-./0123456789'))
1288 self.assertEqual(re.findall(r'[--1]', s), list('-./01'))
1291 p = re.compile(r'[%--1]')
1296 p = re.compile(r'[%--]')
1301 p = re.compile(r'[0-9&&1]')
1305 self.assertEqual(re.findall(r'[0-8&&1]', s), list('&012345678'))
1309 p = re.compile(r'[\d&&1]')
1313 self.assertEqual(re.findall(r'[&&1]', s), list('&1'))
1316 p = re.compile(r'[0-9||a]')
1321 p = re.compile(r'[\d||a]')
1325 self.assertEqual(re.findall(r'[||1]', s), list('1|'))
1328 p = re.compile(r'[0-9~~1]')
1333 p = re.compile(r'[\d~~1]')
1337 self.assertEqual(re.findall(r'[~~1]', s), list('1~'))
1340 p = re.compile(r'[[0-9]|]')
1344 self.assertEqual(re.findall(r'[[0-8]|]', s), list('012345678[]'))
1348 p = re.compile(r'[[:digit:]|]')
1353 self.assertEqual(re.search(r"\s(b)", " b").group(1), "b")
1354 self.assertEqual(re.search(r"a\s", "a ").group(0), "a ")
1357 matcher=re.fullmatch):
1375 self.assertMatch(re.escape(c), c)
1376 self.assertMatch('[' + re.escape(c) + ']', c)
1377 self.assertMatch('(?x)' + re.escape(c), c)
1378 self.assertMatch(re.escape(p), p)
1380 self.assertEqual(re.escape(c)[:1], '\\')
1382 self.assertEqual(re.escape(literal_chars), literal_chars)
1388 self.assertMatch(re.escape(b), b)
1389 self.assertMatch(b'[' + re.escape(b) + b']', b)
1390 self.assertMatch(b'(?x)' + re.escape(b), b)
1391 self.assertMatch(re.escape(p), p)
1394 self.assertEqual(re.escape(b)[:1], b'\\')
1396 self.assertEqual(re.escape(literal_chars), literal_chars)
1400 s_escaped = re.escape(s)
1403 self.assertMatch('.%s+.' % re.escape('\u2620'), s,
1404 'x\u2620\u2620\u2620x', (2, 7), re.search)
1408 b_escaped = re.escape(b)
1411 res = re.findall(re.escape('\u2620'.encode('utf-8')), b)
1416 oldpat = re.compile('a(?:b|(c|e){1,2}?|d)+?(.)', re.UNICODE)
1421 # current pickle expects the _compile() reconstructor in re module
1422 from re import _compile
1426 p = re.compile(r'(?P<int>\d+)(?:\.(?P<frac>\d*))?')
1434 self.assertEqual(re.I, re.IGNORECASE)
1435 self.assertEqual(re.L, re.LOCALE)
1436 self.assertEqual(re.M, re.MULTILINE)
1437 self.assertEqual(re.S, re.DOTALL)
1438 self.assertEqual(re.X, re.VERBOSE)
1441 for flag in [re.I, re.M, re.X, re.S, re.A, re.U]:
1442 self.assertTrue(re.compile('^pattern$', flag))
1443 for flag in [re.I, re.M, re.X, re.S, re.A, re.L]:
1444 self.assertTrue(re.compile(b'^pattern$', flag))
1449 self.assertTrue(re.match(r"\%03o" % i, chr(i)))
1450 self.assertTrue(re.match(r"\%03o0" % i, chr(i)+"0"))
1451 self.assertTrue(re.match(r"\%03o8" % i, chr(i)+"8"))
1452 self.assertTrue(re.match(r"\x%02x" % i, chr(i)))
1453 self.assertTrue(re.match(r"\x%02x0" % i, chr(i)+"0"))
1454 self.assertTrue(re.match(r"\x%02xz" % i, chr(i)+"z"))
1456 self.assertTrue(re.match(r"\u%04x" % i, chr(i)))
1457 self.assertTrue(re.match(r"\u%04x0" % i, chr(i)+"0"))
1458 self.assertTrue(re.match(r"\u%04xz" % i, chr(i)+"z"))
1459 self.assertTrue(re.match(r"\U%08x" % i, chr(i)))
1460 self.assertTrue(re.match(r"\U%08x0" % i, chr(i)+"0"))
1461 self.assertTrue(re.match(r"\U%08xz" % i, chr(i)+"z"))
1462 self.assertTrue(re.match(r"\0", "\000"))
1463 self.assertTrue(re.match(r"\08", "\0008"))
1464 self.assertTrue(re.match(r"\01", "\001"))
1465 self.assertTrue(re.match(r"\018", "\0018"))
1481 self.assertTrue(re.match(r"[\%o]" % i, chr(i)))
1482 self.assertTrue(re.match(r"[\%o8]" % i, chr(i)))
1483 self.assertTrue(re.match(r"[\%03o]" % i, chr(i)))
1484 self.assertTrue(re.match(r"[\%03o0]" % i, chr(i)))
1485 self.assertTrue(re.match(r"[\%03o8]" % i, chr(i)))
1486 self.assertTrue(re.match(r"[\x%02x]" % i, chr(i)))
1487 self.assertTrue(re.match(r"[\x%02x0]" % i, chr(i)))
1488 self.assertTrue(re.match(r"[\x%02xz]" % i, chr(i)))
1490 self.assertTrue(re.match(r"[\u%04x]" % i, chr(i)))
1491 self.assertTrue(re.match(r"[\u%04x0]" % i, chr(i)))
1492 self.assertTrue(re.match(r"[\u%04xz]" % i, chr(i)))
1493 self.assertTrue(re.match(r"[\U%08x]" % i, chr(i)))
1494 self.assertTrue(re.match(r"[\U%08x0]" % i, chr(i)+"0"))
1495 self.assertTrue(re.match(r"[\U%08xz]" % i, chr(i)+"z"))
1504 self.assertTrue(re.match(r"[\U0001d49c-\U0001d4b5]", "\U0001d49e"))
1508 self.assertTrue(re.match((r"\%03o" % i).encode(), bytes([i])))
1509 self.assertTrue(re.match((r"\%03o0" % i).encode(), bytes([i])+b"0"))
1510 self.assertTrue(re.match((r"\%03o8" % i).encode(), bytes([i])+b"8"))
1511 self.assertTrue(re.match((r"\x%02x" % i).encode(), bytes([i])))
1512 self.assertTrue(re.match((r"\x%02x0" % i).encode(), bytes([i])+b"0"))
1513 self.assertTrue(re.match((r"\x%02xz" % i).encode(), bytes([i])+b"z"))
1514 self.assertRaises(re.PatternError, re.compile, br"\u1234")
1515 self.assertRaises(re.PatternError, re.compile, br"\U00012345")
1516 self.assertTrue(re.match(br"\0", b"\000"))
1517 self.assertTrue(re.match(br"\08", b"\0008"))
1518 self.assertTrue(re.match(br"\01", b"\001"))
1519 self.assertTrue(re.match(br"\018", b"\0018"))
1529 self.assertTrue(re.match((r"[\%o]" % i).encode(), bytes([i])))
1530 self.assertTrue(re.match((r"[\%o8]" % i).encode(), bytes([i])))
1531 self.assertTrue(re.match((r"[\%03o]" % i).encode(), bytes([i])))
1532 self.assertTrue(re.match((r"[\%03o0]" % i).encode(), bytes([i])))
1533 self.assertTrue(re.match((r"[\%03o8]" % i).encode(), bytes([i])))
1534 self.assertTrue(re.match((r"[\x%02x]" % i).encode(), bytes([i])))
1535 self.assertTrue(re.match((r"[\x%02x0]" % i).encode(), bytes([i])))
1536 self.assertTrue(re.match((r"[\x%02xz]" % i).encode(), bytes([i])))
1537 self.assertRaises(re.PatternError, re.compile, br"[\u1234]")
1538 self.assertRaises(re.PatternError, re.compile, br"[\U00012345]")
1557 self.assertEqual(re.match(r'(a)|(b)', 'b').start(1), -1)
1558 self.assertEqual(re.match(r'(a)|(b)', 'b').end(1), -1)
1559 self.assertEqual(re.match(r'(a)|(b)', 'b').span(1), (-1, -1))
1563 self.assertIsNone(re.match(r'(a)?a','a').lastindex)
1564 self.assertEqual(re.match(r'(a)(b)?b','ab').lastindex, 1)
1565 self.assertEqual(re.match(r'(?P<a>a)(?P<b>b)?b','ab').lastgroup, 'a')
1566 self.assertEqual(re.match(r"(?P<a>a(b))", "ab").lastgroup, 'a')
1567 self.assertEqual(re.match(r"((a))", "a").lastindex, 1)
1573 self.assertEqual(re.match('.*?c', 10000*'ab'+'cd').end(0), 20001)
1574 self.assertEqual(re.match('.*?cd', 5000*'ab'+'c'+5000*'ab'+'cde').end(0),
1576 self.assertEqual(re.match('.*?cd', 20000*'abc'+'de').end(0), 60001)
1579 self.assertEqual(re.search('(a|b)*?c', 10000*'ab'+'cd').end(0), 20001)
1582 pat="["+re.escape("\u2039")+"]"
1583 self.assertEqual(re.compile(pat) and 1, 1)
1588 self.assertEqual(re.match('(x)*', 50000*'x').group(1), 'x')
1589 self.assertEqual(re.match('(x)*y', 50000*'x'+'y').group(1), 'x')
1590 self.assertEqual(re.match('(x)*?y', 50000*'x'+'y').group(1), 'x')
1614 self.assertIsNone(re.match(r'(?:a?)*y', 'z'))
1615 self.assertIsNone(re.match(r'(?:a?)+y', 'z'))
1616 self.assertIsNone(re.match(r'(?:a?){2,}y', 'z'))
1617 self.assertIsNone(re.match(r'(?:a?)*?y', 'z'))
1618 self.assertIsNone(re.match(r'(?:a?)+?y', 'z'))
1619 self.assertIsNone(re.match(r'(?:a?){2,}?y', 'z'))
1645 self.assertEqual(re.match(r'((.%s):)?z'%op, 'z').groups(),
1647 self.assertEqual(re.match(r'((.%s):)?z'%op, 'a:z').groups(),
1652 self.assertEqual(re.match('^((a)|b)*', 'abc').groups(),
1654 self.assertEqual(re.match('^(([ab])|c)*', 'abc').groups(),
1656 self.assertEqual(re.match('^((d)|[ab])*', 'abc').groups(),
1658 self.assertEqual(re.match('^((a)c|[ab])*', 'abc').groups(),
1660 self.assertEqual(re.match('^((a)|b)*?c', 'abc').groups(),
1662 self.assertEqual(re.match('^(([ab])|c)*?d', 'abcd').groups(),
1664 self.assertEqual(re.match('^((d)|[ab])*?c', 'abc').groups(),
1666 self.assertEqual(re.match('^((a)c|[ab])*?c', 'abc').groups(),
1671 self.assertEqual(re.match('(a)(?:(?=(b)*)c)*', 'abb').groups(),
1673 self.assertEqual(re.match('(a)((?!(b)*))*', 'abb').groups(),
1677 # bug 764548, re.compile() barfs on str/unicode subclasses
1679 pat = re.compile(my_unicode("abc"))
1683 iter = re.finditer(r":+", "a:b::c:::d")
1687 pat = re.compile(r":+")
1692 pat = re.compile(r":+")
1697 pat = re.compile(r":+")
1702 pat = re.compile(r":+")
1708 self.assertIsNot(re.compile('bug_926075'),
1709 re.compile(b'bug_926075'))
1713 self.assertEqual(re.compile(pattern).split("a.b.c"),
1717 iter = re.finditer(r"\s", "a b")
1721 scanner = re.compile(r"\s").scanner("a b")
1726 iter = re.finditer(r".*", "asdf")
1741 self.assertEqual(re.match(r'^\d$', x).group(0), x)
1750 self.assertIsNone(re.match(r'^\d$', x))
1758 self.assertIsNone(re.compile(b"bla").match(a))
1759 self.assertEqual(re.compile(b"").match(a).groups(), ())
1766 p = re.compile('.' + upper_char, re.I | re.S)
1770 p = re.compile('.' + lower_char, re.I | re.S)
1774 p = re.compile('(?i).' + upper_char, re.S)
1778 p = re.compile('(?i).' + lower_char, re.S)
1782 p = re.compile('(?is).' + upper_char)
1786 p = re.compile('(?is).' + lower_char)
1790 p = re.compile('(?s)(?i).' + upper_char)
1794 p = re.compile('(?s)(?i).' + lower_char)
1798 self.assertTrue(re.match('(?ix) ' + upper_char, lower_char))
1799 self.assertTrue(re.match('(?ix) ' + lower_char, upper_char))
1800 self.assertTrue(re.match(' (?i) ' + upper_char, lower_char, re.X))
1801 self.assertTrue(re.match('(?x) (?i) ' + upper_char, lower_char))
1802 self.assertTrue(re.match(' (?x) (?i) ' + upper_char, lower_char, re.X))
1825 pattern = re.compile('$')
1830 pattern = re.compile('$', re.MULTILINE)
1837 pat = re.compile('.')
1838 bpat = re.compile(b'.')
1850 for flags in (0, re.UNICODE):
1851 pat = re.compile('\xc0', flags | re.IGNORECASE)
1853 pat = re.compile(r'\w', flags)
1855 pat = re.compile('\xc0', re.ASCII | re.IGNORECASE)
1857 pat = re.compile('(?a)\xc0', re.IGNORECASE)
1859 pat = re.compile(r'\w', re.ASCII)
1861 pat = re.compile(r'(?a)\w')
1864 for flags in (0, re.ASCII):
1865 pat = re.compile(b'\xc0', flags | re.IGNORECASE)
1867 pat = re.compile(br'\w', flags)
1870 self.assertRaises(ValueError, re.compile, br'\w', re.UNICODE)
1871 self.assertRaises(re.PatternError, re.compile, br'(?u)\w')
1872 self.assertRaises(ValueError, re.compile, r'\w', re.UNICODE | re.ASCII)
1873 self.assertRaises(ValueError, re.compile, r'(?u)\w', re.ASCII)
1874 self.assertRaises(ValueError, re.compile, r'(?a)\w', re.UNICODE)
1875 self.assertRaises(re.PatternError, re.compile, r'(?au)\w')
1888 bpat = re.escape(bytes([i]))
1896 pat = re.compile(bpat, re.LOCALE | re.IGNORECASE)
1899 pat = re.compile(b'(?L)' + bpat, re.IGNORECASE)
1902 pat = re.compile(bpat, re.IGNORECASE)
1905 pat = re.compile(br'\w', re.LOCALE)
1908 pat = re.compile(br'(?L)\w')
1911 pat = re.compile(br'\w')
1915 self.assertRaises(ValueError, re.compile, '', re.LOCALE)
1916 self.assertRaises(re.PatternError, re.compile, '(?L)')
1917 self.assertRaises(ValueError, re.compile, b'', re.LOCALE | re.ASCII)
1918 self.assertRaises(ValueError, re.compile, b'(?L)', re.ASCII)
1919 self.assertRaises(ValueError, re.compile, b'(?a)', re.LOCALE)
1920 self.assertRaises(re.PatternError, re.compile, b'(?aL)')
1923 self.assertTrue(re.match(r'(?i:a)b', 'Ab'))
1924 self.assertIsNone(re.match(r'(?i:a)b', 'aB'))
1925 self.assertIsNone(re.match(r'(?-i:a)b', 'Ab', re.IGNORECASE))
1926 self.assertTrue(re.match(r'(?-i:a)b', 'aB', re.IGNORECASE))
1927 self.assertIsNone(re.match(r'(?i:(?-i:a)b)', 'Ab'))
1928 self.assertTrue(re.match(r'(?i:(?-i:a)b)', 'aB'))
1930 self.assertTrue(re.match(r'\w(?a:\W)\w', '\xe0\xe0\xe0'))
1931 self.assertTrue(re.match(r'(?a:\W(?u:\w)\W)', '\xe0\xe0\xe0'))
1932 self.assertTrue(re.match(r'\W(?u:\w)\W', '\xe0\xe0\xe0', re.ASCII))
1957 self.assertTrue(re.fullmatch(space + 'a', 'a', re.VERBOSE))
1959 self.assertTrue(re.fullmatch(space + b'a', b'a', re.VERBOSE))
1960 self.assertTrue(re.fullmatch('(?x) a', 'a'))
1961 self.assertTrue(re.fullmatch(' (?x) a', 'a', re.VERBOSE))
1962 self.assertTrue(re.fullmatch('(?x) (?x) a', 'a'))
1963 self.assertTrue(re.fullmatch(' a(?x: b) c', ' ab c'))
1964 self.assertTrue(re.fullmatch(' a(?-x: b) c', 'a bc', re.VERBOSE))
1965 self.assertTrue(re.fullmatch('(?x) a(?-x: b) c', 'a bc'))
1966 self.assertTrue(re.fullmatch('(?x) a| b', 'a'))
1967 self.assertTrue(re.fullmatch('(?x) a| b', 'b'))
1970 self.assertTrue(re.fullmatch('#x\na', 'a', re.VERBOSE))
1971 self.assertTrue(re.fullmatch(b'#x\na', b'a', re.VERBOSE))
1972 self.assertTrue(re.fullmatch('(?x)#x\na', 'a'))
1973 self.assertTrue(re.fullmatch('#x\n(?x)#y\na', 'a', re.VERBOSE))
1974 self.assertTrue(re.fullmatch('(?x)#x\n(?x)#y\na', 'a'))
1975 self.assertTrue(re.fullmatch('#x\na(?x:#y\nb)#z\nc', '#x\nab#z\nc'))
1976 self.assertTrue(re.fullmatch('#x\na(?-x:#y\nb)#z\nc', 'a#y\nbc',
1977 re.VERBOSE))
1978 self.assertTrue(re.fullmatch('(?x)#x\na(?-x:#y\nb)#z\nc', 'a#y\nbc'))
1979 self.assertTrue(re.fullmatch('(?x)#x\na|#y\nb', 'a'))
1980 self.assertTrue(re.fullmatch('(?x)#x\na|#y\nb', 'b'))
1985 pat = re.compile(r'a(\w)')
1987 pat = re.compile('a(.)')
1989 pat = re.compile('..')
1993 pat = re.compile(br'a(\w)')
1995 pat = re.compile(b'a(.)')
1997 pat = re.compile(b'..')
2001 self.assertTrue(re.search("123.*-", '123abc-'))
2002 self.assertTrue(re.search("123.*-", '123\xe9-'))
2003 self.assertTrue(re.search("123.*-", '123\u20ac-'))
2004 self.assertTrue(re.search("123.*-", '123\U0010ffff-'))
2005 self.assertTrue(re.search("123.*-", '123\xe9\u20ac\U0010ffff-'))
2009 pattern = re.compile('random pattern')
2010 self.assertIsInstance(pattern, re.Pattern)
2011 same_pattern = re.compile(pattern)
2012 self.assertIsInstance(same_pattern, re.Pattern)
2015 self.assertRaises(TypeError, re.compile, 0)
2021 m = re.search('$', s)
2026 # The huge memuse is because of re.sub() using a list and a join()
2032 r, n = re.subn('', '', s)
2039 self.assertEqual(re.findall(r"(?i)(a)\1", "aa \u0100"), ['a'])
2040 self.assertEqual(re.match(r"(?s).{1,3}", "\u0100\u0100").span(), (0, 2))
2045 self.assertEqual(re.match(r".{65535}", string).span(), (0, 65535))
2046 self.assertEqual(re.match(r".{,65535}", string).span(), (0, 65535))
2047 self.assertEqual(re.match(r".{65535,}?", string).span(), (0, 65535))
2048 self.assertEqual(re.match(r".{65536}", string).span(), (0, 65536))
2049 self.assertEqual(re.match(r".{,65536}", string).span(), (0, 65536))
2050 self.assertEqual(re.match(r".{65536,}?", string).span(), (0, 65536))
2052 self.assertRaises(OverflowError, re.compile, r".{%d}" % 2**128)
2053 self.assertRaises(OverflowError, re.compile, r".{,%d}" % 2**128)
2054 self.assertRaises(OverflowError, re.compile, r".{%d,}?" % 2**128)
2055 self.assertRaises(OverflowError, re.compile, r".{%d,%d}" % (2**129, 2**128))
2063 self.assertEqual(re.search(p1 % (2**7, 2**7, 2**7), string).span(),
2065 self.assertEqual(re.search(p2 % (2**7, 2**7, 2**7), string).span(),
2069 re.compile(p1 % (2**22, 1, 1))
2070 re.compile(p1 % (1, 2**22, 1))
2071 re.compile(p1 % (1, 1, 2**22))
2072 re.compile(p2 % (2**22, 1, 1))
2073 re.compile(p2 % (1, 2**22, 1))
2074 re.compile(p2 % (1, 1, 2**22))
2077 self.assertRaisesRegex(re.error, errmsg, re.compile, p1 % (2**22, 2**22, 2**22))
2078 self.assertRaisesRegex(re.error, errmsg, re.compile, p2 % (2**22, 2**22, 2**22))
2094 self.assertEqual(re.compile(pattern, re.S).findall('xyz'),
2097 self.assertEqual(re.compile(pattern, re.S).findall(b'xyz'),
2102 m = re.search(r'(.+)(.*?)\1', string)
2110 m = re.search(br'(.+)(.*?)\1', string)
2116 first, second = list(re.finditer("(aa)|(bb)", "aa bb"))
2128 self.assertEqual(re.split(r"\b", "a::bc"), ['', 'a', '::', 'bc', ''])
2129 self.assertEqual(re.split(r"\b|:+", "a::bc"), ['', 'a', '', '', 'bc', ''])
2130 self.assertEqual(re.split(r"(?<!\w)(?=\w)|:+", "a::bc"), ['', 'a', '', 'bc'])
2131 self.assertEqual(re.split(r"(?<=\w)(?!\w)|:+", "a::bc"), ['a', '', 'bc', ''])
2133 self.assertEqual(re.sub(r"\b", "-", "a::bc"), '-a-::-bc-')
2134 self.assertEqual(re.sub(r"\b|:+", "-", "a::bc"), '-a---bc-')
2135 self.assertEqual(re.sub(r"(\b|:+)", r"[\1]", "a::bc"), '[]a[][::][]bc[]')
2137 self.assertEqual(re.findall(r"\b|:+", "a::bc"), ['', '', '::', '', ''])
2138 self.assertEqual(re.findall(r"\b|\w+", "a::bc"),
2141 self.assertEqual([m.span() for m in re.finditer(r"\b|:+", "a::bc")],
2143 self.assertEqual([m.span() for m in re.finditer(r"\b|\w+", "a::bc")],
2150 r = re.compile("^((x|y)%s)%s" % (inner_op, outer_op))
2158 pat = re.compile(r'(ab)')
2177 self.assertEqual(re.fullmatch('[a-c]+', 'ABC', re.I).span(), (0, 3))
2194 re.purge()
2197 re.purge()
2203 self.assertTrue(re.match(b'\xc5\xe5', b'\xc5\xe5', re.L|re.I))
2204 self.assertTrue(re.match(b'\xc5', b'\xe5', re.L|re.I))
2205 self.assertTrue(re.match(b'\xe5', b'\xc5', re.L|re.I))
2206 self.assertTrue(re.match(b'(?Li)\xc5\xe5', b'\xc5\xe5'))
2207 self.assertTrue(re.match(b'(?Li)\xc5', b'\xe5'))
2208 self.assertTrue(re.match(b'(?Li)\xe5', b'\xc5'))
2212 self.assertTrue(re.match(b'\xc5\xe5', b'\xc5\xe5', re.L|re.I))
2213 self.assertIsNone(re.match(b'\xc5', b'\xe5', re.L|re.I))
2214 self.assertIsNone(re.match(b'\xe5', b'\xc5', re.L|re.I))
2215 self.assertTrue(re.match(b'(?Li)\xc5\xe5', b'\xc5\xe5'))
2216 self.assertIsNone(re.match(b'(?Li)\xc5', b'\xe5'))
2217 self.assertIsNone(re.match(b'(?Li)\xe5', b'\xc5'))
2234 p1 = re.compile(b'\xc5\xe5', re.L|re.I)
2235 p2 = re.compile(b'[a\xc5][a\xe5]', re.L|re.I)
2236 p3 = re.compile(b'[az\xc5][az\xe5]', re.L|re.I)
2237 p4 = re.compile(b'[^\xc5][^\xe5]', re.L|re.I)
2256 with self.assertRaises(re.PatternError) as cm:
2257 re.compile('(\u20ac))')
2268 with self.assertRaises(re.PatternError) as cm:
2269 re.compile(b'(\xa4))')
2275 with self.assertRaises(re.PatternError) as cm:
2276 re.compile("""
2282 """, re.VERBOSE)
2307 self.assertIn('ASCII', str(re.A))
2308 self.assertIn('DOTALL', str(re.S))
2311 pattern1 = re.compile('abc', re.IGNORECASE)
2318 re.purge()
2319 pattern2 = re.compile('abc', re.IGNORECASE)
2324 re.purge()
2325 pattern3 = re.compile('XYZ', re.IGNORECASE)
2331 re.purge()
2332 pattern4 = re.compile('abc')
2340 pattern1 = re.compile(b'abc')
2343 re.purge()
2344 pattern2 = re.compile(b'abc')
2350 re.purge()
2351 pattern3 = re.compile('abc')
2358 m = re.search(b'[a-h]+', s)
2359 m2 = re.search(b'[e-h]+', s)
2372 self.assertEqual(re.search(p, s).groups(), (None, 'x'))
2377 self.assertEqual(re.findall(p, s),
2379 self.assertEqual([m.groups() for m in re.finditer(p, s)],
2385 self.assertEqual(re.findall(p, s),
2387 self.assertEqual([m.groupdict() for m in re.finditer(p, s)],
2391 self.assertEqual([m.groupdict() for m in re.finditer(p, s)],
2395 self.assertEqual([m.groupdict() for m in re.finditer(p, s)],
2403 self.assertEqual(re.match(r'(ab|a)*?b', 'ab').groups(), ('a',))
2404 self.assertEqual(re.match(r'(ab|a)+?b', 'ab').groups(), ('a',))
2405 self.assertEqual(re.match(r'(ab|a){0,2}?b', 'ab').groups(), ('a',))
2406 self.assertEqual(re.match(r'(.b|a)*?b', 'ab').groups(), ('a',))
2413 self.assertEqual(re.match(p, s).groups(), ('xx',))
2418 m = re.match(p, s)
2428 m = re.match(p, s)
2436 m = re.match(p, s)
2441 self.assertEqual(re.match(r'(ab?)*?b', 'ab').groups(), ('a',))
2448 m = re.match(p, s)
2455 self.assertEqual(re.match(p, s).groups(), ('xx',))
2460 self.assertEqual(re.match(r'(?!(..)c)', 'ab').groups(), (None,))
2463 m = re.match(r'((?!(ab)c)(.))*', 'abab')
2471 re.search("x*", 5)
2473 re.search("x*", type)
2482 self.assertIsNone(re.search(p, s))
2483 self.assertEqual(re.split(p, s), [s])
2484 self.assertEqual(re.findall(p, s), [])
2485 self.assertEqual(list(re.finditer(p, s)), [])
2486 self.assertEqual(re.sub(p, '', s), s)
2497 self.assertIsNone(re.match('e*+e', 'eeee'))
2498 self.assertEqual(re.match('e++a', 'eeea').group(0), 'eeea')
2499 self.assertEqual(re.match('e?+a', 'ea').group(0), 'ea')
2500 self.assertEqual(re.match('e{2,4}+a', 'eeea').group(0), 'eeea')
2501 self.assertIsNone(re.match('(.)++.', 'ee'))
2502 self.assertEqual(re.match('(ae)*+a', 'aea').groups(), ('ae',))
2503 self.assertEqual(re.match('([ae][ae])?+a', 'aea').groups(),
2505 self.assertEqual(re.match('(e?){2,4}+a', 'eeea').groups(),
2507 self.assertEqual(re.match('()*+a', 'a').groups(), ('',))
2508 self.assertEqual(re.search('x*+', 'axx').span(), (0, 0))
2509 self.assertEqual(re.search('x++', 'axx').span(), (1, 3))
2510 self.assertEqual(re.match('a*+', 'xxx').span(), (0, 0))
2511 self.assertEqual(re.match('x*+', 'xxxa').span(), (0, 3))
2512 self.assertIsNone(re.match('a++', 'xxx'))
2513 self.assertIsNone(re.match(r"^(\w){1}+$", "abc"))
2514 self.assertIsNone(re.match(r"^(\w){1,2}+$", "abc"))
2516 self.assertEqual(re.match(r"^(\w){3}+$", "abc").group(1), "c")
2517 self.assertEqual(re.match(r"^(\w){1,3}+$", "abc").group(1), "c")
2518 self.assertEqual(re.match(r"^(\w){1,4}+$", "abc").group(1), "c")
2520 self.assertIsNone(re.match("^x{1}+$", "xxx"))
2521 self.assertIsNone(re.match("^x{1,2}+$", "xxx"))
2523 self.assertTrue(re.match("^x{3}+$", "xxx"))
2524 self.assertTrue(re.match("^x{1,3}+$", "xxx"))
2525 self.assertTrue(re.match("^x{1,4}+$", "xxx"))
2527 self.assertIsNone(re.match("^x{}+$", "xxx"))
2528 self.assertTrue(re.match("^x{}+$", "x{}"))
2531 self.assertTrue(re.fullmatch(r'a++', 'a'))
2532 self.assertTrue(re.fullmatch(r'a*+', 'a'))
2533 self.assertTrue(re.fullmatch(r'a?+', 'a'))
2534 self.assertTrue(re.fullmatch(r'a{1,3}+', 'a'))
2535 self.assertIsNone(re.fullmatch(r'a++', 'ab'))
2536 self.assertIsNone(re.fullmatch(r'a*+', 'ab'))
2537 self.assertIsNone(re.fullmatch(r'a?+', 'ab'))
2538 self.assertIsNone(re.fullmatch(r'a{1,3}+', 'ab'))
2539 self.assertTrue(re.fullmatch(r'a++b', 'ab'))
2540 self.assertTrue(re.fullmatch(r'a*+b', 'ab'))
2541 self.assertTrue(re.fullmatch(r'a?+b', 'ab'))
2542 self.assertTrue(re.fullmatch(r'a{1,3}+b', 'ab'))
2544 self.assertTrue(re.fullmatch(r'(?:ab)++', 'ab'))
2545 self.assertTrue(re.fullmatch(r'(?:ab)*+', 'ab'))
2546 self.assertTrue(re.fullmatch(r'(?:ab)?+', 'ab'))
2547 self.assertTrue(re.fullmatch(r'(?:ab){1,3}+', 'ab'))
2548 self.assertIsNone(re.fullmatch(r'(?:ab)++', 'abc'))
2549 self.assertIsNone(re.fullmatch(r'(?:ab)*+', 'abc'))
2550 self.assertIsNone(re.fullmatch(r'(?:ab)?+', 'abc'))
2551 self.assertIsNone(re.fullmatch(r'(?:ab){1,3}+', 'abc'))
2552 self.assertTrue(re.fullmatch(r'(?:ab)++c', 'abc'))
2553 self.assertTrue(re.fullmatch(r'(?:ab)*+c', 'abc'))
2554 self.assertTrue(re.fullmatch(r'(?:ab)?+c', 'abc'))
2555 self.assertTrue(re.fullmatch(r'(?:ab){1,3}+c', 'abc'))
2558 self.assertEqual(re.findall(r'a++', 'aab'), ['aa'])
2559 self.assertEqual(re.findall(r'a*+', 'aab'), ['aa', '', ''])
2560 self.assertEqual(re.findall(r'a?+', 'aab'), ['a', 'a', '', ''])
2561 self.assertEqual(re.findall(r'a{1,3}+', 'aab'), ['aa'])
2563 self.assertEqual(re.findall(r'(?:ab)++', 'ababc'), ['abab'])
2564 self.assertEqual(re.findall(r'(?:ab)*+', 'ababc'), ['abab', '', ''])
2565 self.assertEqual(re.findall(r'(?:ab)?+', 'ababc'), ['ab', 'ab', '', ''])
2566 self.assertEqual(re.findall(r'(?:ab){1,3}+', 'ababc'), ['abab'])
2573 pattern1 = re.compile(r'a(?>bc|b)c')
2576 self.assertIsNone(re.match(r'(?>.*).', 'abc'))
2577 self.assertTrue(re.match(r'(?>x)++', 'xxx'))
2578 self.assertTrue(re.match(r'(?>x++)', 'xxx'))
2579 self.assertIsNone(re.match(r'(?>x)++x', 'xxx'))
2580 self.assertIsNone(re.match(r'(?>x++)x', 'xxx'))
2583 self.assertTrue(re.fullmatch(r'(?>a+)', 'a'))
2584 self.assertTrue(re.fullmatch(r'(?>a*)', 'a'))
2585 self.assertTrue(re.fullmatch(r'(?>a?)', 'a'))
2586 self.assertTrue(re.fullmatch(r'(?>a{1,3})', 'a'))
2587 self.assertIsNone(re.fullmatch(r'(?>a+)', 'ab'))
2588 self.assertIsNone(re.fullmatch(r'(?>a*)', 'ab'))
2589 self.assertIsNone(re.fullmatch(r'(?>a?)', 'ab'))
2590 self.assertIsNone(re.fullmatch(r'(?>a{1,3})', 'ab'))
2591 self.assertTrue(re.fullmatch(r'(?>a+)b', 'ab'))
2592 self.assertTrue(re.fullmatch(r'(?>a*)b', 'ab'))
2593 self.assertTrue(re.fullmatch(r'(?>a?)b', 'ab'))
2594 self.assertTrue(re.fullmatch(r'(?>a{1,3})b', 'ab'))
2596 self.assertTrue(re.fullmatch(r'(?>(?:ab)+)', 'ab'))
2597 self.assertTrue(re.fullmatch(r'(?>(?:ab)*)', 'ab'))
2598 self.assertTrue(re.fullmatch(r'(?>(?:ab)?)', 'ab'))
2599 self.assertTrue(re.fullmatch(r'(?>(?:ab){1,3})', 'ab'))
2600 self.assertIsNone(re.fullmatch(r'(?>(?:ab)+)', 'abc'))
2601 self.assertIsNone(re.fullmatch(r'(?>(?:ab)*)', 'abc'))
2602 self.assertIsNone(re.fullmatch(r'(?>(?:ab)?)', 'abc'))
2603 self.assertIsNone(re.fullmatch(r'(?>(?:ab){1,3})', 'abc'))
2604 self.assertTrue(re.fullmatch(r'(?>(?:ab)+)c', 'abc'))
2605 self.assertTrue(re.fullmatch(r'(?>(?:ab)*)c', 'abc'))
2606 self.assertTrue(re.fullmatch(r'(?>(?:ab)?)c', 'abc'))
2607 self.assertTrue(re.fullmatch(r'(?>(?:ab){1,3})c', 'abc'))
2610 self.assertEqual(re.findall(r'(?>a+)', 'aab'), ['aa'])
2611 self.assertEqual(re.findall(r'(?>a*)', 'aab'), ['aa', '', ''])
2612 self.assertEqual(re.findall(r'(?>a?)', 'aab'), ['a', 'a', '', ''])
2613 self.assertEqual(re.findall(r'(?>a{1,3})', 'aab'), ['aa'])
2615 self.assertEqual(re.findall(r'(?>(?:ab)+)', 'ababc'), ['abab'])
2616 self.assertEqual(re.findall(r'(?>(?:ab)*)', 'ababc'), ['abab', '', ''])
2617 self.assertEqual(re.findall(r'(?>(?:ab)?)', 'ababc'), ['ab', 'ab', '', ''])
2618 self.assertEqual(re.findall(r'(?>(?:ab){1,3})', 'ababc'), ['abab'])
2621 self.assertTrue(re.fullmatch(r'(?s:(?>.*?\.).*)\Z', "a.txt")) # reproducer
2622 self.assertTrue(re.fullmatch(r'(?s:(?=(?P<g0>.*?\.))(?P=g0).*)\Z', "a.txt"))
2626 self.assertEqual(re.match('(?>(?:.(?!D))+)', 'ABCDE').span(), (0, 2))
2627 self.assertEqual(re.match('(?:.(?!D))++', 'ABCDE').span(), (0, 2))
2628 self.assertEqual(re.match('(?>(?:.(?!D))*)', 'ABCDE').span(), (0, 2))
2629 self.assertEqual(re.match('(?:.(?!D))*+', 'ABCDE').span(), (0, 2))
2630 self.assertEqual(re.match('(?>(?:.(?!D))?)', 'CDE').span(), (0, 0))
2631 self.assertEqual(re.match('(?:.(?!D))?+', 'CDE').span(), (0, 0))
2632 self.assertEqual(re.match('(?>(?:.(?!D)){1,3})', 'ABCDE').span(), (0, 2))
2633 self.assertEqual(re.match('(?:.(?!D)){1,3}+', 'ABCDE').span(), (0, 2))
2635 self.assertEqual(re.match("(?>(?:ab?c)+)", "aca").span(), (0, 2))
2636 self.assertEqual(re.match("(?:ab?c)++", "aca").span(), (0, 2))
2637 self.assertEqual(re.match("(?>(?:ab?c)*)", "aca").span(), (0, 2))
2638 self.assertEqual(re.match("(?:ab?c)*+", "aca").span(), (0, 2))
2639 self.assertEqual(re.match("(?>(?:ab?c)?)", "a").span(), (0, 0))
2640 self.assertEqual(re.match("(?:ab?c)?+", "a").span(), (0, 0))
2641 self.assertEqual(re.match("(?>(?:ab?c){1,3})", "aca").span(), (0, 2))
2642 self.assertEqual(re.match("(?:ab?c){1,3}+", "aca").span(), (0, 2))
2646 self.assertEqual(re.match('((x)|y|z)*+', 'xyz').groups(), ('z', 'x'))
2647 self.assertEqual(re.match('((x)|y|z){3}+', 'xyz').groups(), ('z', 'x'))
2648 self.assertEqual(re.match('((x)|y|z){3,}+', 'xyz').groups(), ('z', 'x'))
2652 pattern = re.compile(r'(?<=[({}])(((//[^\n]*)?[\n])([\000-\040])*)*'
2671 self.assertEqual(re.search(r'12(?!)|3', '123')[0], '3')
2679 self.assertEqual(re.findall(p, s), list(s))
2680 self.assertEqual(re.fullmatch('(?:' + p + ')+', s).group(), s)
2688 self.assertIsNone(re.search(p, s))
2689 self.assertIsNone(re.search('(?s:.)' + p, s))
2694 p = re.compile(pattern)
2705 @unittest.skipUnless(hasattr(re.Pattern, '_fail_after'), 'requires debug build')
2717 re.compile(pat, re.DEBUG)
2819 self.assertEqual(repr(re.compile(pattern)), expected)
2822 self.assertEqual(repr(re.compile(pattern, flags)), expected)
2826 "re.compile('random pattern')")
2829 self.check_flags('random pattern', re.IGNORECASE,
2830 "re.compile('random pattern', re.IGNORECASE)")
2833 self.check_flags('random pattern', re.I|re.S|re.X,
2834 "re.compile('random pattern', "
2835 "re.IGNORECASE|re.DOTALL|re.VERBOSE)")
2838 self.check_flags('random pattern', re.U,
2839 "re.compile('random pattern')")
2840 self.check_flags('random pattern', re.I|re.S|re.U,
2841 "re.compile('random pattern', "
2842 "re.IGNORECASE|re.DOTALL)")
2846 "re.compile('(?i)pattern', re.IGNORECASE)")
2850 "re.compile('random pattern', 0x123000)")
2851 self.check_flags('random pattern', 0x123000|re.I,
2852 "re.compile('random pattern', re.IGNORECASE|0x123000)")
2856 "re.compile(b'bytes pattern')")
2857 self.check_flags(b'bytes pattern', re.A,
2858 "re.compile(b'bytes pattern', re.ASCII)")
2861 self.check_flags(b'bytes pattern', re.L,
2862 "re.compile(b'bytes pattern', re.LOCALE)")
2866 '''re.compile('random "double quoted" pattern')''')
2868 '''re.compile("random 'single quoted' pattern")''')
2870 '''re.compile('both \\'single\\' and "double" quotes')''')
2874 r = repr(re.compile(pattern))
2876 self.assertEqual(r[:30], "re.compile('Very long long lon")
2877 r = repr(re.compile(pattern, re.I))
2879 self.assertEqual(r[:30], "re.compile('Very long long lon")
2880 self.assertEqual(r[-16:], ", re.IGNORECASE)")
2883 self.assertEqual(repr(re.I), "re.IGNORECASE")
2884 self.assertEqual(repr(re.I|re.S|re.X),
2885 "re.IGNORECASE|re.DOTALL|re.VERBOSE")
2886 self.assertEqual(repr(re.I|re.S|re.X|(1<<20)),
2887 "re.IGNORECASE|re.DOTALL|re.VERBOSE|0x100000")
2889 repr(~re.I),
2890 "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.DOTALL|re.VERBOSE|re.DEBUG|0x1")
2891 self.assertEqual(repr(~(re.I|re.S|re.X)),
2892 "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.DEBUG|0x1")
2893 self.assertEqual(repr(~(re.I|re.S|re.X|(1<<20))),
2894 "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.DEBUG|0xffe01")
2899 Test implementation details of the re module.
2904 # bpo-43908: check that re types are immutable
2906 re.Match.foo = 1
2908 re.Pattern.foo = 1
2910 pat = re.compile("")
2915 f = re._compiler._generate_overlap_table
2924 self.assertGreaterEqual(re._compiler.MAXREPEAT, 0)
2925 self.assertGreaterEqual(re._compiler.MAXGROUPS, 0)
2930 check_disallow_instantiation(self, re.Match)
2931 check_disallow_instantiation(self, re.Pattern)
2932 pat = re.compile("")
2998 self.assertRaises(TypeError, re.finditer, "a", {})
3014 self.assertIsNone(re.match(r".{%d}" % (MAXREPEAT - 1), string))
3015 self.assertEqual(re.match(r".{,%d}" % (MAXREPEAT - 1), string).span(),
3017 self.assertIsNone(re.match(r".{%d,}?" % (MAXREPEAT - 1), string))
3018 self.assertRaises(OverflowError, re.compile, r".{%d}" % MAXREPEAT)
3019 self.assertRaises(OverflowError, re.compile, r".{,%d}" % MAXREPEAT)
3020 self.assertRaises(OverflowError, re.compile, r".{%d,}?" % MAXREPEAT)
3041 p = re.compile(pattern)
3065 with self.assertRaises(re.PatternError):
3066 re.compile(pattern)
3069 obj = re.compile(pattern)
3082 'flags': result.re.flags}
3092 for i in result.re.groupindex.keys():
3113 obj = re.compile(bpat)
3119 obj = re.compile(bpat, re.LOCALE)
3131 obj = re.compile(pattern)
3137 obj = re.compile(pattern, re.IGNORECASE)
3143 obj = re.compile(pattern, re.UNICODE)