Lines Matching refs:match
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))
179 self.assertRaises(ValueError, re.match, pattern, 'A', re.I)
256 self.assertEqual(re.match(pat, 'xc8yz').span(), (0, 5))
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))
487 self.assertEqual(pat.match('a').groups(), ('a', 'a', None, None))
488 self.assertEqual(pat.match('b').groups(), ('b', None, 'b', None))
489 self.assertEqual(pat.match('ac').groups(), ('a', 'a', None, 'c'))
490 self.assertEqual(pat.match('bc').groups(), ('b', None, 'b', 'c'))
491 self.assertEqual(pat.match('bc').groups(""), ('b', "", 'b', 'c'))
494 self.assertEqual(pat.match('a').group(1, 2, 3), ('a', None, None))
495 self.assertEqual(pat.match('b').group('a1', 'b2', 'c3'),
497 self.assertEqual(pat.match('ac').group(1, 'b2', 3), ('a', None, 'c'))
506 m = re.match('(a)(b)', 'ab')
523 m = pat.match('a')
547 m = pat.match('ac')
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(),
612 self.assertEqual(p.match('abc').groups(),
614 self.assertEqual(p.match('ad').groups(),
616 self.assertIsNone(p.match('abd'))
617 self.assertIsNone(p.match('ac'))
622 self.assertEqual(re.match(pat, 'xc8yz').span(), (0, 5))
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{}"))
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)
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'))
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}]',
859 self.assertTrue(re.match(r"\b", "abc"))
860 # A non-empty string includes a non-boundary zero-length match.
862 # There is no non-boundary match at the start of a string.
863 self.assertFalse(re.match(r"\B", "abc"))
877 # Can match around the whitespace.
881 self.assertEqual(re.match("([\u2222\u2223])",
884 self.assertEqual(re.match(r, "\uff01").group(), "\uff01")
889 self.assertTrue(r.match('1000'))
890 self.assertTrue(r.match('9999'))
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'))
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'))
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), " ")
1160 def assertMatch(self, pattern, text, match=None, span=None,
1162 if match is None and span is None:
1164 match = text
1166 elif match is None or span is None:
1167 raise ValueError('If match is not None, span should be specified '
1171 self.assertEqual(m.group(), match)
1233 m = p.match('12.34')
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"))
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])))
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)
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'))
1446 # bug 448951 (similar to 429357, but with single char match)
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(),
1484 self.assertIsNone(pat.match("xyz"))
1536 # '\d' should match characters in Unicode category 'Nd'
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(), ())
1570 q = p.match('\n' + lower_char)
1574 q = p.match('\n' + upper_char)
1578 q = p.match('\n' + lower_char)
1582 q = p.match('\n' + upper_char)
1586 q = p.match('\n' + lower_char)
1590 q = p.match('\n' + upper_char)
1594 q = p.match('\n' + lower_char)
1598 q = p.match('\n' + upper_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))
1642 self.assertRaises(TypeError, pat.match, b'b')
1643 self.assertRaises(TypeError, bpat.match, 'b')
1655 self.assertTrue(pat.match('\xe0'))
1657 self.assertTrue(pat.match('\xe0'))
1659 self.assertIsNone(pat.match('\xe0'))
1661 self.assertIsNone(pat.match('\xe0'))
1663 self.assertIsNone(pat.match('\xe0'))
1665 self.assertIsNone(pat.match('\xe0'))
1669 self.assertIsNone(pat.match(b'\xe0'))
1671 self.assertIsNone(pat.match(b'\xe0'))
1701 self.assertTrue(pat.match(bletter))
1704 self.assertTrue(pat.match(bletter))
1707 self.assertIsNone(pat.match(bletter))
1710 self.assertTrue(pat.match(bletter))
1713 self.assertTrue(pat.match(bletter))
1716 self.assertIsNone(pat.match(bletter))
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))
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))
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))
1912 pattern = r"<(%s\.)?%s object; span=\(1, 12\), match='abracadabra'>" % (
1920 pattern = r"<(%s\.)?%s object; span=\(1, 12\), match=b'abracadabra'>" % (
1926 pattern = r"<(%s\.)?%s object; span=\(0, 2\), match='aa'>" % (
1930 pattern = r"<(%s\.)?%s object; span=\(3, 5\), match='bb'>" % (
1960 m = r.match("xyyzy")
1969 pat.match(string='abracadabra', pos=7, endpos=10).span(), (7, 9))
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'))
2048 self.assertTrue(p.match(b'\xc5\xe5'))
2049 self.assertTrue(p.match(b'\xe5\xe5'))
2050 self.assertTrue(p.match(b'\xc5\xc5'))
2051 self.assertIsNone(p4.match(b'\xe5\xc5'))
2052 self.assertIsNone(p4.match(b'\xe5\xe5'))
2053 self.assertIsNone(p4.match(b'\xc5\xc5'))
2057 self.assertTrue(p.match(b'\xc5\xe5'))
2058 self.assertIsNone(p.match(b'\xe5\xe5'))
2059 self.assertIsNone(p.match(b'\xc5\xc5'))
2060 self.assertTrue(p4.match(b'\xe5\xc5'))
2061 self.assertIsNone(p4.match(b'\xe5\xe5'))
2062 self.assertIsNone(p4.match(b'\xc5\xc5'))
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')
2301 e.g. x{3,5}+ meaning match from 3 to 5 greadily and proceed
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(), ('',))
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{}"))
2381 self.assertIsNone(pattern1.match('abc'))
2382 self.assertTrue(pattern1.match('abcc'))
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'))
2452 self.assertTrue(template_re1.match('ahoy'))
2453 self.assertFalse(template_re1.match('nope'))
2729 self.assertTrue(p.match(s))
2733 self.assertTrue(p.match(s2, 10000))
2734 self.assertTrue(p.match(s2, 10000, 10000 + len(s)))
2789 # Try the match with both pattern and string converted to
2798 with self.subTest('bytes pattern match'):
2802 # Try the match with LOCALE enabled, and check that it
2804 with self.subTest('locale-sensitive match'):
2808 print('=== Fails on locale-sensitive match', t)
2810 # Try the match with the search area limited to the extent
2811 # of the match and see if it still succeeds. \B will
2812 # break (because it won't match at the end or start of a
2816 with self.subTest('range-limited match'):
2820 # Try the match with IGNORECASE enabled, and check that it
2822 with self.subTest('case-insensitive match'):
2826 # Try the match with UNICODE locale enabled, and check
2828 with self.subTest('unicode-sensitive match'):