PageRenderTime 65ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 0ms

/Lib/test/test_re.py

https://bitbucket.org/pombredanne/cpython
Python | 1110 lines | 1063 code | 31 blank | 16 comment | 2 complexity | 395972a2a495db64925205f302d3a2d7 MD5 | raw file
Possible License(s): 0BSD 
    

  1. from test.support import verbose, run_unittest, gc_collect, bigmemtest, _2G
    2. 

  2. import io
    3. 

  3. import re
    4. 

  4. from re import Scanner
    5. 

  5. import sys
    6. 

  6. import string
    7. 

  7. import traceback
    8. 

  8. from weakref import proxy
    9. 

  9. 

  10. # Misc tests from Tim Peters' re.doc
    11. 

    12. 

  12. # WARNING: Don't change details in these tests if you don't know
    13. 

  13. # what you're doing. Some of these tests were carefully modeled to
    14. 

  14. # cover most of the code.
    15. 

  15. 

  16. import unittest
    17. 

  17. 

  18. class ReTests(unittest.TestCase):
    19. 

  19. 

  20.     def test_keep_buffer(self):
    21. 

  21.         # See bug 14212
    22. 

  22.         b = bytearray(b'x')
    23. 

  23.         it = re.finditer(b'a', b)
    24. 

  24.         with self.assertRaises(BufferError):
    25. 

  25.             b.extend(b'x'*400)
    26. 

  26.         list(it)
    27. 

  27.         del it
    28. 

  28.         gc_collect()
    29. 

  29.         b.extend(b'x'*400)
    30. 

  30. 

  31.     def test_weakref(self):
    32. 

  32.         s = 'QabbbcR'
    33. 

  33.         x = re.compile('ab+c')
    34. 

  34.         y = proxy(x)
    35. 

  35.         self.assertEqual(x.findall('QabbbcR'), y.findall('QabbbcR'))
    36. 

  36. 

  37.     def test_search_star_plus(self):
    38. 

  38.         self.assertEqual(re.search('x*', 'axx').span(0), (0, 0))
    39. 

  39.         self.assertEqual(re.search('x*', 'axx').span(), (0, 0))
    40. 

  40.         self.assertEqual(re.search('x+', 'axx').span(0), (1, 3))
    41. 

  41.         self.assertEqual(re.search('x+', 'axx').span(), (1, 3))
    42. 

  42.         self.assertEqual(re.search('x', 'aaa'), None)
    43. 

  43.         self.assertEqual(re.match('a*', 'xxx').span(0), (0, 0))
    44. 

  44.         self.assertEqual(re.match('a*', 'xxx').span(), (0, 0))
    45. 

  45.         self.assertEqual(re.match('x*', 'xxxa').span(0), (0, 3))
    46. 

  46.         self.assertEqual(re.match('x*', 'xxxa').span(), (0, 3))
    47. 

  47.         self.assertEqual(re.match('a+', 'xxx'), None)
    48. 

  48. 

  49.     def bump_num(self, matchobj):
    50. 

  50.         int_value = int(matchobj.group(0))
    51. 

  51.         return str(int_value + 1)
    52. 

  52. 

  53.     def test_basic_re_sub(self):
    54. 

  54.         self.assertEqual(re.sub("(?i)b+", "x", "bbbb BBBB"), 'x x')
    55. 

  55.         self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y'),
    56. 

  56.                          '9.3 -3 24x100y')
    57. 

  57.         self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y', 3),
    58. 

  58.                          '9.3 -3 23x99y')
    59. 

  59. 

  60.         self.assertEqual(re.sub('.', lambda m: r"\n", 'x'), '\\n')
    61. 

  61.         self.assertEqual(re.sub('.', r"\n", 'x'), '\n')
    62. 

  62. 

  63.         s = r"\1\1"
    64. 

  64.         self.assertEqual(re.sub('(.)', s, 'x'), 'xx')
    65. 

  65.         self.assertEqual(re.sub('(.)', re.escape(s), 'x'), s)
    66. 

  66.         self.assertEqual(re.sub('(.)', lambda m: s, 'x'), s)
    67. 

  67. 

  68.         self.assertEqual(re.sub('(?P<a>x)', '\g<a>\g<a>', 'xx'), 'xxxx')
    69. 

  69.         self.assertEqual(re.sub('(?P<a>x)', '\g<a>\g<1>', 'xx'), 'xxxx')
    70. 

  70.         self.assertEqual(re.sub('(?P<unk>x)', '\g<unk>\g<unk>', 'xx'), 'xxxx')
    71. 

  71.         self.assertEqual(re.sub('(?P<unk>x)', '\g<1>\g<1>', 'xx'), 'xxxx')
    72. 

  72. 

  73.         self.assertEqual(re.sub('a',r'\t\n\v\r\f\a\b\B\Z\a\A\w\W\s\S\d\D','a'),
    74. 

  74.                          '\t\n\v\r\f\a\b\\B\\Z\a\\A\\w\\W\\s\\S\\d\\D')
    75. 

  75.         self.assertEqual(re.sub('a', '\t\n\v\r\f\a', 'a'), '\t\n\v\r\f\a')
    76. 

  76.         self.assertEqual(re.sub('a', '\t\n\v\r\f\a', 'a'),
    77. 

  77.                          (chr(9)+chr(10)+chr(11)+chr(13)+chr(12)+chr(7)))
    78. 

  78. 

  79.         self.assertEqual(re.sub('^\s*', 'X', 'test'), 'Xtest')
    80. 

  80. 

  81.     def test_bug_449964(self):
    82. 

  82.         # fails for group followed by other escape
    83. 

  83.         self.assertEqual(re.sub(r'(?P<unk>x)', '\g<1>\g<1>\\b', 'xx'),
    84. 

  84.                          'xx\bxx\b')
    85. 

  85. 

  86.     def test_bug_449000(self):
    87. 

  87.         # Test for sub() on escaped characters
    88. 

  88.         self.assertEqual(re.sub(r'\r\n', r'\n', 'abc\r\ndef\r\n'),
    89. 

  89.                          'abc\ndef\n')
    90. 

  90.         self.assertEqual(re.sub('\r\n', r'\n', 'abc\r\ndef\r\n'),
    91. 

  91.                          'abc\ndef\n')
    92. 

  92.         self.assertEqual(re.sub(r'\r\n', '\n', 'abc\r\ndef\r\n'),
    93. 

  93.                          'abc\ndef\n')
    94. 

  94.         self.assertEqual(re.sub('\r\n', '\n', 'abc\r\ndef\r\n'),
    95. 

  95.                          'abc\ndef\n')
    96. 

  96. 

  97.     def test_bug_1661(self):
    98. 

  98.         # Verify that flags do not get silently ignored with compiled patterns
    99. 

  99.         pattern = re.compile('.')
    100. 

  100.         self.assertRaises(ValueError, re.match, pattern, 'A', re.I)
    101. 

  101.         self.assertRaises(ValueError, re.search, pattern, 'A', re.I)
    102. 

  102.         self.assertRaises(ValueError, re.findall, pattern, 'A', re.I)
    103. 

  103.         self.assertRaises(ValueError, re.compile, pattern, re.I)
    104. 

  104. 

  105.     def test_bug_3629(self):
    106. 

  106.         # A regex that triggered a bug in the sre-code validator
    107. 

  107.         re.compile("(?P<quote>)(?(quote))")
    108. 

  108. 

  109.     def test_sub_template_numeric_escape(self):
    110. 

  110.         # bug 776311 and friends
    111. 

  111.         self.assertEqual(re.sub('x', r'\0', 'x'), '\0')
    112. 

  112.         self.assertEqual(re.sub('x', r'\000', 'x'), '\000')
    113. 

  113.         self.assertEqual(re.sub('x', r'\001', 'x'), '\001')
    114. 

  114.         self.assertEqual(re.sub('x', r'\008', 'x'), '\0' + '8')
    115. 

  115.         self.assertEqual(re.sub('x', r'\009', 'x'), '\0' + '9')
    116. 

  116.         self.assertEqual(re.sub('x', r'\111', 'x'), '\111')
    117. 

  117.         self.assertEqual(re.sub('x', r'\117', 'x'), '\117')
    118. 

  118. 

  119.         self.assertEqual(re.sub('x', r'\1111', 'x'), '\1111')
    120. 

  120.         self.assertEqual(re.sub('x', r'\1111', 'x'), '\111' + '1')
    121. 

  121. 

  122.         self.assertEqual(re.sub('x', r'\00', 'x'), '\x00')
    123. 

  123.         self.assertEqual(re.sub('x', r'\07', 'x'), '\x07')
    124. 

  124.         self.assertEqual(re.sub('x', r'\08', 'x'), '\0' + '8')
    125. 

  125.         self.assertEqual(re.sub('x', r'\09', 'x'), '\0' + '9')
    126. 

  126.         self.assertEqual(re.sub('x', r'\0a', 'x'), '\0' + 'a')
    127. 

  127. 

  128.         self.assertEqual(re.sub('x', r'\400', 'x'), '\0')
    129. 

  129.         self.assertEqual(re.sub('x', r'\777', 'x'), '\377')
    130. 

  130. 

  131.         self.assertRaises(re.error, re.sub, 'x', r'\1', 'x')
    132. 

  132.         self.assertRaises(re.error, re.sub, 'x', r'\8', 'x')
    133. 

  133.         self.assertRaises(re.error, re.sub, 'x', r'\9', 'x')
    134. 

  134.         self.assertRaises(re.error, re.sub, 'x', r'\11', 'x')
    135. 

  135.         self.assertRaises(re.error, re.sub, 'x', r'\18', 'x')
    136. 

  136.         self.assertRaises(re.error, re.sub, 'x', r'\1a', 'x')
    137. 

  137.         self.assertRaises(re.error, re.sub, 'x', r'\90', 'x')
    138. 

  138.         self.assertRaises(re.error, re.sub, 'x', r'\99', 'x')
    139. 

  139.         self.assertRaises(re.error, re.sub, 'x', r'\118', 'x') # r'\11' + '8'
    140. 

  140.         self.assertRaises(re.error, re.sub, 'x', r'\11a', 'x')
    141. 

  141.         self.assertRaises(re.error, re.sub, 'x', r'\181', 'x') # r'\18' + '1'
    142. 

  142.         self.assertRaises(re.error, re.sub, 'x', r'\800', 'x') # r'\80' + '0'
    143. 

  143. 

  144.         # in python2.3 (etc), these loop endlessly in sre_parser.py
    145. 

  145.         self.assertEqual(re.sub('(((((((((((x)))))))))))', r'\11', 'x'), 'x')
    146. 

  146.         self.assertEqual(re.sub('((((((((((y))))))))))(.)', r'\118', 'xyz'),
    147. 

  147.                          'xz8')
    148. 

  148.         self.assertEqual(re.sub('((((((((((y))))))))))(.)', r'\11a', 'xyz'),
    149. 

  149.                          'xza')
    150. 

  150. 

  151.     def test_qualified_re_sub(self):
    152. 

  152.         self.assertEqual(re.sub('a', 'b', 'aaaaa'), 'bbbbb')
    153. 

  153.         self.assertEqual(re.sub('a', 'b', 'aaaaa', 1), 'baaaa')
    154. 

  154. 

  155.     def test_bug_114660(self):
    156. 

  156.         self.assertEqual(re.sub(r'(\S)\s+(\S)', r'\1 \2', 'hello  there'),
    157. 

  157.                          'hello there')
    158. 

  158. 

  159.     def test_bug_462270(self):
    160. 

  160.         # Test for empty sub() behaviour, see SF bug #462270
    161. 

  161.         self.assertEqual(re.sub('x*', '-', 'abxd'), '-a-b-d-')
    162. 

  162.         self.assertEqual(re.sub('x+', '-', 'abxd'), 'ab-d')
    163. 

  163. 

  164.     def test_symbolic_groups(self):
    165. 

  165.         re.compile('(?P<a>x)(?P=a)(?(a)y)')
    166. 

  166.         re.compile('(?P<a1>x)(?P=a1)(?(a1)y)')
    167. 

  167.         self.assertRaises(re.error, re.compile, '(?P<a>)(?P<a>)')
    168. 

  168.         self.assertRaises(re.error, re.compile, '(?Px)')
    169. 

  169.         self.assertRaises(re.error, re.compile, '(?P=)')
    170. 

  170.         self.assertRaises(re.error, re.compile, '(?P=1)')
    171. 

  171.         self.assertRaises(re.error, re.compile, '(?P=a)')
    172. 

  172.         self.assertRaises(re.error, re.compile, '(?P=a1)')
    173. 

  173.         self.assertRaises(re.error, re.compile, '(?P=a.)')
    174. 

  174.         self.assertRaises(re.error, re.compile, '(?P<)')
    175. 

  175.         self.assertRaises(re.error, re.compile, '(?P<>)')
    176. 

  176.         self.assertRaises(re.error, re.compile, '(?P<1>)')
    177. 

  177.         self.assertRaises(re.error, re.compile, '(?P<a.>)')
    178. 

  178.         self.assertRaises(re.error, re.compile, '(?())')
    179. 

  179.         self.assertRaises(re.error, re.compile, '(?(a))')
    180. 

  180.         self.assertRaises(re.error, re.compile, '(?(1a))')
    181. 

  181.         self.assertRaises(re.error, re.compile, '(?(a.))')
    182. 

  182. 

  183.     def test_symbolic_refs(self):
    184. 

  184.         self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<a', 'xx')
    185. 

  185.         self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<', 'xx')
    186. 

  186.         self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g', 'xx')
    187. 

  187.         self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<a a>', 'xx')
    188. 

  188.         self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<>', 'xx')
    189. 

  189.         self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<1a1>', 'xx')
    190. 

  190.         self.assertRaises(IndexError, re.sub, '(?P<a>x)', '\g<ab>', 'xx')
    191. 

  191.         self.assertRaises(re.error, re.sub, '(?P<a>x)|(?P<b>y)', '\g<b>', 'xx')
    192. 

  192.         self.assertRaises(re.error, re.sub, '(?P<a>x)|(?P<b>y)', '\\2', 'xx')
    193. 

  193.         self.assertRaises(re.error, re.sub, '(?P<a>x)', '\g<-1>', 'xx')
    194. 

  194. 

  195.     def test_re_subn(self):
    196. 

  196.         self.assertEqual(re.subn("(?i)b+", "x", "bbbb BBBB"), ('x x', 2))
    197. 

  197.         self.assertEqual(re.subn("b+", "x", "bbbb BBBB"), ('x BBBB', 1))
    198. 

  198.         self.assertEqual(re.subn("b+", "x", "xyz"), ('xyz', 0))
    199. 

  199.         self.assertEqual(re.subn("b*", "x", "xyz"), ('xxxyxzx', 4))
    200. 

  200.         self.assertEqual(re.subn("b*", "x", "xyz", 2), ('xxxyz', 2))
    201. 

  201. 

  202.     def test_re_split(self):
    203. 

  203.         self.assertEqual(re.split(":", ":a:b::c"), ['', 'a', 'b', '', 'c'])
    204. 

  204.         self.assertEqual(re.split(":*", ":a:b::c"), ['', 'a', 'b', 'c'])
    205. 

  205.         self.assertEqual(re.split("(:*)", ":a:b::c"),
    206. 

  206.                          ['', ':', 'a', ':', 'b', '::', 'c'])
    207. 

  207.         self.assertEqual(re.split("(?::*)", ":a:b::c"), ['', 'a', 'b', 'c'])
    208. 

  208.         self.assertEqual(re.split("(:)*", ":a:b::c"),
    209. 

  209.                          ['', ':', 'a', ':', 'b', ':', 'c'])
    210. 

  210.         self.assertEqual(re.split("([b:]+)", ":a:b::c"),
    211. 

  211.                          ['', ':', 'a', ':b::', 'c'])
    212. 

  212.         self.assertEqual(re.split("(b)|(:+)", ":a:b::c"),
    213. 

  213.                          ['', None, ':', 'a', None, ':', '', 'b', None, '',
    214. 

  214.                           None, '::', 'c'])
    215. 

  215.         self.assertEqual(re.split("(?:b)|(?::+)", ":a:b::c"),
    216. 

  216.                          ['', 'a', '', '', 'c'])
    217. 

  217. 

  218.     def test_qualified_re_split(self):
    219. 

  219.         self.assertEqual(re.split(":", ":a:b::c", 2), ['', 'a', 'b::c'])
    220. 

  220.         self.assertEqual(re.split(':', 'a:b:c:d', 2), ['a', 'b', 'c:d'])
    221. 

  221.         self.assertEqual(re.split("(:)", ":a:b::c", 2),
    222. 

  222.                          ['', ':', 'a', ':', 'b::c'])
    223. 

  223.         self.assertEqual(re.split("(:*)", ":a:b::c", 2),
    224. 

  224.                          ['', ':', 'a', ':', 'b::c'])
    225. 

  225. 

  226.     def test_re_findall(self):
    227. 

  227.         self.assertEqual(re.findall(":+", "abc"), [])
    228. 

  228.         self.assertEqual(re.findall(":+", "a:b::c:::d"), [":", "::", ":::"])
    229. 

  229.         self.assertEqual(re.findall("(:+)", "a:b::c:::d"), [":", "::", ":::"])
    230. 

  230.         self.assertEqual(re.findall("(:)(:*)", "a:b::c:::d"), [(":", ""),
    231. 

  231.                                                                (":", ":"),
    232. 

  232.                                                                (":", "::")])
    233. 

  233. 

  234.     def test_bug_117612(self):
    235. 

  235.         self.assertEqual(re.findall(r"(a|(b))", "aba"),
    236. 

  236.                          [("a", ""),("b", "b"),("a", "")])
    237. 

  237. 

  238.     def test_re_match(self):
    239. 

  239.         self.assertEqual(re.match('a', 'a').groups(), ())
    240. 

  240.         self.assertEqual(re.match('(a)', 'a').groups(), ('a',))
    241. 

  241.         self.assertEqual(re.match(r'(a)', 'a').group(0), 'a')
    242. 

  242.         self.assertEqual(re.match(r'(a)', 'a').group(1), 'a')
    243. 

  243.         self.assertEqual(re.match(r'(a)', 'a').group(1, 1), ('a', 'a'))
    244. 

  244. 

  245.         pat = re.compile('((a)|(b))(c)?')
    246. 

  246.         self.assertEqual(pat.match('a').groups(), ('a', 'a', None, None))
    247. 

  247.         self.assertEqual(pat.match('b').groups(), ('b', None, 'b', None))
    248. 

  248.         self.assertEqual(pat.match('ac').groups(), ('a', 'a', None, 'c'))
    249. 

  249.         self.assertEqual(pat.match('bc').groups(), ('b', None, 'b', 'c'))
    250. 

  250.         self.assertEqual(pat.match('bc').groups(""), ('b', "", 'b', 'c'))
    251. 

  251. 

  252.         # A single group
    253. 

  253.         m = re.match('(a)', 'a')
    254. 

  254.         self.assertEqual(m.group(0), 'a')
    255. 

  255.         self.assertEqual(m.group(0), 'a')
    256. 

  256.         self.assertEqual(m.group(1), 'a')
    257. 

  257.         self.assertEqual(m.group(1, 1), ('a', 'a'))
    258. 

  258. 

  259.         pat = re.compile('(?:(?P<a1>a)|(?P<b2>b))(?P<c3>c)?')
    260. 

  260.         self.assertEqual(pat.match('a').group(1, 2, 3), ('a', None, None))
    261. 

  261.         self.assertEqual(pat.match('b').group('a1', 'b2', 'c3'),
    262. 

  262.                          (None, 'b', None))
    263. 

  263.         self.assertEqual(pat.match('ac').group(1, 'b2', 3), ('a', None, 'c'))
    264. 

  264. 

  265.     def test_re_groupref_exists(self):
    266. 

  266.         self.assertEqual(re.match('^(\()?([^()]+)(?(1)\))$', '(a)').groups(),
    267. 

  267.                          ('(', 'a'))
    268. 

  268.         self.assertEqual(re.match('^(\()?([^()]+)(?(1)\))$', 'a').groups(),
    269. 

  269.                          (None, 'a'))
    270. 

  270.         self.assertEqual(re.match('^(\()?([^()]+)(?(1)\))$', 'a)'), None)
    271. 

  271.         self.assertEqual(re.match('^(\()?([^()]+)(?(1)\))$', '(a'), None)
    272. 

  272.         self.assertEqual(re.match('^(?:(a)|c)((?(1)b|d))$', 'ab').groups(),
    273. 

  273.                          ('a', 'b'))
    274. 

  274.         self.assertEqual(re.match('^(?:(a)|c)((?(1)b|d))$', 'cd').groups(),
    275. 

  275.                          (None, 'd'))
    276. 

  276.         self.assertEqual(re.match('^(?:(a)|c)((?(1)|d))$', 'cd').groups(),
    277. 

  277.                          (None, 'd'))
    278. 

  278.         self.assertEqual(re.match('^(?:(a)|c)((?(1)|d))$', 'a').groups(),
    279. 

  279.                          ('a', ''))
    280. 

  280. 

  281.         # Tests for bug #1177831: exercise groups other than the first group
    282. 

  282.         p = re.compile('(?P<g1>a)(?P<g2>b)?((?(g2)c|d))')
    283. 

  283.         self.assertEqual(p.match('abc').groups(),
    284. 

  284.                          ('a', 'b', 'c'))
    285. 

  285.         self.assertEqual(p.match('ad').groups(),
    286. 

  286.                          ('a', None, 'd'))
    287. 

  287.         self.assertEqual(p.match('abd'), None)
    288. 

  288.         self.assertEqual(p.match('ac'), None)
    289. 

  289. 

  290. 

  291.     def test_re_groupref(self):
    292. 

  292.         self.assertEqual(re.match(r'^(\|)?([^()]+)\1$', '|a|').groups(),
    293. 

  293.                          ('|', 'a'))
    294. 

  294.         self.assertEqual(re.match(r'^(\|)?([^()]+)\1?$', 'a').groups(),
    295. 

  295.                          (None, 'a'))
    296. 

  296.         self.assertEqual(re.match(r'^(\|)?([^()]+)\1$', 'a|'), None)
    297. 

  297.         self.assertEqual(re.match(r'^(\|)?([^()]+)\1$', '|a'), None)
    298. 

  298.         self.assertEqual(re.match(r'^(?:(a)|c)(\1)$', 'aa').groups(),
    299. 

  299.                          ('a', 'a'))
    300. 

  300.         self.assertEqual(re.match(r'^(?:(a)|c)(\1)?$', 'c').groups(),
    301. 

  301.                          (None, None))
    302. 

  302. 

  303.     def test_groupdict(self):
    304. 

  304.         self.assertEqual(re.match('(?P<first>first) (?P<second>second)',
    305. 

  305.                                   'first second').groupdict(),
    306. 

  306.                          {'first':'first', 'second':'second'})
    307. 

  307. 

  308.     def test_expand(self):
    309. 

  309.         self.assertEqual(re.match("(?P<first>first) (?P<second>second)",
    310. 

  310.                                   "first second")
    311. 

  311.                                   .expand(r"\2 \1 \g<second> \g<first>"),
    312. 

  312.                          "second first second first")
    313. 

  313. 

  314.     def test_repeat_minmax(self):
    315. 

  315.         self.assertEqual(re.match("^(\w){1}$", "abc"), None)
    316. 

  316.         self.assertEqual(re.match("^(\w){1}?$", "abc"), None)
    317. 

  317.         self.assertEqual(re.match("^(\w){1,2}$", "abc"), None)
    318. 

  318.         self.assertEqual(re.match("^(\w){1,2}?$", "abc"), None)
    319. 

  319. 

  320.         self.assertEqual(re.match("^(\w){3}$", "abc").group(1), "c")
    321. 

  321.         self.assertEqual(re.match("^(\w){1,3}$", "abc").group(1), "c")
    322. 

  322.         self.assertEqual(re.match("^(\w){1,4}$", "abc").group(1), "c")
    323. 

  323.         self.assertEqual(re.match("^(\w){3,4}?$", "abc").group(1), "c")
    324. 

  324.         self.assertEqual(re.match("^(\w){3}?$", "abc").group(1), "c")
    325. 

  325.         self.assertEqual(re.match("^(\w){1,3}?$", "abc").group(1), "c")
    326. 

  326.         self.assertEqual(re.match("^(\w){1,4}?$", "abc").group(1), "c")
    327. 

  327.         self.assertEqual(re.match("^(\w){3,4}?$", "abc").group(1), "c")
    328. 

  328. 

  329.         self.assertEqual(re.match("^x{1}$", "xxx"), None)
    330. 

  330.         self.assertEqual(re.match("^x{1}?$", "xxx"), None)
    331. 

  331.         self.assertEqual(re.match("^x{1,2}$", "xxx"), None)
    332. 

  332.         self.assertEqual(re.match("^x{1,2}?$", "xxx"), None)
    333. 

  333. 

  334.         self.assertNotEqual(re.match("^x{3}$", "xxx"), None)
    335. 

  335.         self.assertNotEqual(re.match("^x{1,3}$", "xxx"), None)
    336. 

  336.         self.assertNotEqual(re.match("^x{1,4}$", "xxx"), None)
    337. 

  337.         self.assertNotEqual(re.match("^x{3,4}?$", "xxx"), None)
    338. 

  338.         self.assertNotEqual(re.match("^x{3}?$", "xxx"), None)
    339. 

  339.         self.assertNotEqual(re.match("^x{1,3}?$", "xxx"), None)
    340. 

  340.         self.assertNotEqual(re.match("^x{1,4}?$", "xxx"), None)
    341. 

  341.         self.assertNotEqual(re.match("^x{3,4}?$", "xxx"), None)
    342. 

  342. 

  343.         self.assertEqual(re.match("^x{}$", "xxx"), None)
    344. 

  344.         self.assertNotEqual(re.match("^x{}$", "x{}"), None)
    345. 

  345. 

  346.     def test_getattr(self):
    347. 

  347.         self.assertEqual(re.compile("(?i)(a)(b)").pattern, "(?i)(a)(b)")
    348. 

  348.         self.assertEqual(re.compile("(?i)(a)(b)").flags, re.I | re.U)
    349. 

  349.         self.assertEqual(re.compile("(?i)(a)(b)").groups, 2)
    350. 

  350.         self.assertEqual(re.compile("(?i)(a)(b)").groupindex, {})
    351. 

  351.         self.assertEqual(re.compile("(?i)(?P<first>a)(?P<other>b)").groupindex,
    352. 

  352.                          {'first': 1, 'other': 2})
    353. 

  353. 

  354.         self.assertEqual(re.match("(a)", "a").pos, 0)
    355. 

  355.         self.assertEqual(re.match("(a)", "a").endpos, 1)
    356. 

  356.         self.assertEqual(re.match("(a)", "a").string, "a")
    357. 

  357.         self.assertEqual(re.match("(a)", "a").regs, ((0, 1), (0, 1)))
    358. 

  358.         self.assertNotEqual(re.match("(a)", "a").re, None)
    359. 

  359. 

  360.     def test_special_escapes(self):
    361. 

  361.         self.assertEqual(re.search(r"\b(b.)\b",
    362. 

  362.                                    "abcd abc bcd bx").group(1), "bx")
    363. 

  363.         self.assertEqual(re.search(r"\B(b.)\B",
    364. 

  364.                                    "abc bcd bc abxd").group(1), "bx")
    365. 

  365.         self.assertEqual(re.search(r"\b(b.)\b",
    366. 

  366.                                    "abcd abc bcd bx", re.LOCALE).group(1), "bx")
    367. 

  367.         self.assertEqual(re.search(r"\B(b.)\B",
    368. 

  368.                                    "abc bcd bc abxd", re.LOCALE).group(1), "bx")
    369. 

  369.         self.assertEqual(re.search(r"\b(b.)\b",
    370. 

  370.                                    "abcd abc bcd bx", re.UNICODE).group(1), "bx")
    371. 

  371.         self.assertEqual(re.search(r"\B(b.)\B",
    372. 

  372.                                    "abc bcd bc abxd", re.UNICODE).group(1), "bx")
    373. 

  373.         self.assertEqual(re.search(r"^abc$", "\nabc\n", re.M).group(0), "abc")
    374. 

  374.         self.assertEqual(re.search(r"^\Aabc\Z$", "abc", re.M).group(0), "abc")
    375. 

  375.         self.assertEqual(re.search(r"^\Aabc\Z$", "\nabc\n", re.M), None)
    376. 

  376.         self.assertEqual(re.search(r"\b(b.)\b",
    377. 

  377.                                    "abcd abc bcd bx").group(1), "bx")
    378. 

  378.         self.assertEqual(re.search(r"\B(b.)\B",
    379. 

  379.                                    "abc bcd bc abxd").group(1), "bx")
    380. 

  380.         self.assertEqual(re.search(r"^abc$", "\nabc\n", re.M).group(0), "abc")
    381. 

  381.         self.assertEqual(re.search(r"^\Aabc\Z$", "abc", re.M).group(0), "abc")
    382. 

  382.         self.assertEqual(re.search(r"^\Aabc\Z$", "\nabc\n", re.M), None)
    383. 

  383.         self.assertEqual(re.search(r"\d\D\w\W\s\S",
    384. 

  384.                                    "1aa! a").group(0), "1aa! a")
    385. 

  385.         self.assertEqual(re.search(r"\d\D\w\W\s\S",
    386. 

  386.                                    "1aa! a", re.LOCALE).group(0), "1aa! a")
    387. 

  387.         self.assertEqual(re.search(r"\d\D\w\W\s\S",
    388. 

  388.                                    "1aa! a", re.UNICODE).group(0), "1aa! a")
    389. 

  389. 

  390.     def test_string_boundaries(self):
    391. 

  391.         # See http://bugs.python.org/issue10713
    392. 

  392.         self.assertEqual(re.search(r"\b(abc)\b", "abc").group(1),
    393. 

  393.                          "abc")
    394. 

  394.         # There's a word boundary at the start of a string.
    395. 

  395.         self.assertTrue(re.match(r"\b", "abc"))
    396. 

  396.         # A non-empty string includes a non-boundary zero-length match.
    397. 

  397.         self.assertTrue(re.search(r"\B", "abc"))
    398. 

  398.         # There is no non-boundary match at the start of a string.
    399. 

  399.         self.assertFalse(re.match(r"\B", "abc"))
    400. 

  400.         # However, an empty string contains no word boundaries, and also no
    401. 

  401.         # non-boundaries.
    402. 

  402.         self.assertEqual(re.search(r"\B", ""), None)
    403. 

  403.         # This one is questionable and different from the perlre behaviour,
    404. 

  404.         # but describes current behavior.
    405. 

  405.         self.assertEqual(re.search(r"\b", ""), None)
    406. 

  406.         # A single word-character string has two boundaries, but no
    407. 

  407.         # non-boundary gaps.
    408. 

  408.         self.assertEqual(len(re.findall(r"\b", "a")), 2)
    409. 

  409.         self.assertEqual(len(re.findall(r"\B", "a")), 0)
    410. 

  410.         # If there are no words, there are no boundaries
    411. 

  411.         self.assertEqual(len(re.findall(r"\b", " ")), 0)
    412. 

  412.         self.assertEqual(len(re.findall(r"\b", "   ")), 0)
    413. 

  413.         # Can match around the whitespace.
    414. 

  414.         self.assertEqual(len(re.findall(r"\B", " ")), 2)
    415. 

  415. 

  416.     def test_bigcharset(self):
    417. 

  417.         self.assertEqual(re.match("([\u2222\u2223])",
    418. 

  418.                                   "\u2222").group(1), "\u2222")
    419. 

  419.         self.assertEqual(re.match("([\u2222\u2223])",
    420. 

  420.                                   "\u2222", re.UNICODE).group(1), "\u2222")
    421. 

  421. 

  422.     def test_big_codesize(self):
    423. 

  423.         # Issue #1160
    424. 

  424.         r = re.compile('|'.join(('%d'%x for x in range(10000))))
    425. 

  425.         self.assertIsNotNone(r.match('1000'))
    426. 

  426.         self.assertIsNotNone(r.match('9999'))
    427. 

  427. 

  428.     def test_anyall(self):
    429. 

  429.         self.assertEqual(re.match("a.b", "a\nb", re.DOTALL).group(0),
    430. 

  430.                          "a\nb")
    431. 

  431.         self.assertEqual(re.match("a.*b", "a\n\nb", re.DOTALL).group(0),
    432. 

  432.                          "a\n\nb")
    433. 

  433. 

  434.     def test_non_consuming(self):
    435. 

  435.         self.assertEqual(re.match("(a(?=\s[^a]))", "a b").group(1), "a")
    436. 

  436.         self.assertEqual(re.match("(a(?=\s[^a]*))", "a b").group(1), "a")
    437. 

  437.         self.assertEqual(re.match("(a(?=\s[abc]))", "a b").group(1), "a")
    438. 

  438.         self.assertEqual(re.match("(a(?=\s[abc]*))", "a bc").group(1), "a")
    439. 

  439.         self.assertEqual(re.match(r"(a)(?=\s\1)", "a a").group(1), "a")
    440. 

  440.         self.assertEqual(re.match(r"(a)(?=\s\1*)", "a aa").group(1), "a")
    441. 

  441.         self.assertEqual(re.match(r"(a)(?=\s(abc|a))", "a a").group(1), "a")
    442. 

  442. 

  443.         self.assertEqual(re.match(r"(a(?!\s[^a]))", "a a").group(1), "a")
    444. 

  444.         self.assertEqual(re.match(r"(a(?!\s[abc]))", "a d").group(1), "a")
    445. 

  445.         self.assertEqual(re.match(r"(a)(?!\s\1)", "a b").group(1), "a")
    446. 

  446.         self.assertEqual(re.match(r"(a)(?!\s(abc|a))", "a b").group(1), "a")
    447. 

  447. 

  448.     def test_ignore_case(self):
    449. 

  449.         self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
    450. 

  450.         self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
    451. 

  451.         self.assertEqual(re.match(r"(a\s[^a])", "a b", re.I).group(1), "a b")
    452. 

  452.         self.assertEqual(re.match(r"(a\s[^a]*)", "a bb", re.I).group(1), "a bb")
    453. 

  453.         self.assertEqual(re.match(r"(a\s[abc])", "a b", re.I).group(1), "a b")
    454. 

  454.         self.assertEqual(re.match(r"(a\s[abc]*)", "a bb", re.I).group(1), "a bb")
    455. 

  455.         self.assertEqual(re.match(r"((a)\s\2)", "a a", re.I).group(1), "a a")
    456. 

  456.         self.assertEqual(re.match(r"((a)\s\2*)", "a aa", re.I).group(1), "a aa")
    457. 

  457.         self.assertEqual(re.match(r"((a)\s(abc|a))", "a a", re.I).group(1), "a a")
    458. 

  458.         self.assertEqual(re.match(r"((a)\s(abc|a)*)", "a aa", re.I).group(1), "a aa")
    459. 

  459. 

  460.     def test_category(self):
    461. 

  461.         self.assertEqual(re.match(r"(\s)", " ").group(1), " ")
    462. 

  462. 

  463.     def test_getlower(self):
    464. 

  464.         import _sre
    465. 

  465.         self.assertEqual(_sre.getlower(ord('A'), 0), ord('a'))
    466. 

  466.         self.assertEqual(_sre.getlower(ord('A'), re.LOCALE), ord('a'))
    467. 

  467.         self.assertEqual(_sre.getlower(ord('A'), re.UNICODE), ord('a'))
    468. 

  468. 

  469.         self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
    470. 

  470.         self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
    471. 

  471. 

  472.     def test_not_literal(self):
    473. 

  473.         self.assertEqual(re.search("\s([^a])", " b").group(1), "b")
    474. 

  474.         self.assertEqual(re.search("\s([^a]*)", " bb").group(1), "bb")
    475. 

  475. 

  476.     def test_search_coverage(self):
    477. 

  477.         self.assertEqual(re.search("\s(b)", " b").group(1), "b")
    478. 

  478.         self.assertEqual(re.search("a\s", "a ").group(0), "a ")
    479. 

  479. 

  480.     def assertMatch(self, pattern, text, match=None, span=None,
    481. 

  481.                     matcher=re.match):
    482. 

  482.         if match is None and span is None:
    483. 

  483.             # the pattern matches the whole text
    484. 

  484.             match = text
    485. 

  485.             span = (0, len(text))
    486. 

  486.         elif match is None or span is None:
    487. 

  487.             raise ValueError('If match is not None, span should be specified '
    488. 

  488.                              '(and vice versa).')
    489. 

  489.         m = matcher(pattern, text)
    490. 

  490.         self.assertTrue(m)
    491. 

  491.         self.assertEqual(m.group(), match)
    492. 

  492.         self.assertEqual(m.span(), span)
    493. 

  493. 

  494.     def test_re_escape(self):
    495. 

  495.         alnum_chars = string.ascii_letters + string.digits + '_'
    496. 

  496.         p = ''.join(chr(i) for i in range(256))
    497. 

  497.         for c in p:
    498. 

  498.             if c in alnum_chars:
    499. 

  499.                 self.assertEqual(re.escape(c), c)
    500. 

  500.             elif c == '\x00':
    501. 

  501.                 self.assertEqual(re.escape(c), '\\000')
    502. 

  502.             else:
    503. 

  503.                 self.assertEqual(re.escape(c), '\\' + c)
    504. 

  504.             self.assertMatch(re.escape(c), c)
    505. 

  505.         self.assertMatch(re.escape(p), p)
    506. 

  506. 

  507.     def test_re_escape_byte(self):
    508. 

  508.         alnum_chars = (string.ascii_letters + string.digits + '_').encode('ascii')
    509. 

  509.         p = bytes(range(256))
    510. 

  510.         for i in p:
    511. 

  511.             b = bytes([i])
    512. 

  512.             if b in alnum_chars:
    513. 

  513.                 self.assertEqual(re.escape(b), b)
    514. 

  514.             elif i == 0:
    515. 

  515.                 self.assertEqual(re.escape(b), b'\\000')
    516. 

  516.             else:
    517. 

  517.                 self.assertEqual(re.escape(b), b'\\' + b)
    518. 

  518.             self.assertMatch(re.escape(b), b)
    519. 

  519.         self.assertMatch(re.escape(p), p)
    520. 

  520. 

  521.     def test_re_escape_non_ascii(self):
    522. 

  522.         s = 'xxx\u2620\u2620\u2620xxx'
    523. 

  523.         s_escaped = re.escape(s)
    524. 

  524.         self.assertEqual(s_escaped, 'xxx\\\u2620\\\u2620\\\u2620xxx')
    525. 

  525.         self.assertMatch(s_escaped, s)
    526. 

  526.         self.assertMatch('.%s+.' % re.escape('\u2620'), s,
    527. 

  527.                          'x\u2620\u2620\u2620x', (2, 7), re.search)
    528. 

  528. 

  529.     def test_re_escape_non_ascii_bytes(self):
    530. 

  530.         b = 'y\u2620y\u2620y'.encode('utf-8')
    531. 

  531.         b_escaped = re.escape(b)
    532. 

  532.         self.assertEqual(b_escaped, b'y\\\xe2\\\x98\\\xa0y\\\xe2\\\x98\\\xa0y')
    533. 

  533.         self.assertMatch(b_escaped, b)
    534. 

  534.         res = re.findall(re.escape('\u2620'.encode('utf-8')), b)
    535. 

  535.         self.assertEqual(len(res), 2)
    536. 

  536. 

  537.     def pickle_test(self, pickle):
    538. 

  538.         oldpat = re.compile('a(?:b|(c|e){1,2}?|d)+?(.)')
    539. 

  539.         s = pickle.dumps(oldpat)
    540. 

  540.         newpat = pickle.loads(s)
    541. 

  541.         self.assertEqual(oldpat, newpat)
    542. 

  542. 

  543.     def test_constants(self):
    544. 

  544.         self.assertEqual(re.I, re.IGNORECASE)
    545. 

  545.         self.assertEqual(re.L, re.LOCALE)
    546. 

  546.         self.assertEqual(re.M, re.MULTILINE)
    547. 

  547.         self.assertEqual(re.S, re.DOTALL)
    548. 

  548.         self.assertEqual(re.X, re.VERBOSE)
    549. 

  549. 

  550.     def test_flags(self):
    551. 

  551.         for flag in [re.I, re.M, re.X, re.S, re.L]:
    552. 

  552.             self.assertNotEqual(re.compile('^pattern$', flag), None)
    553. 

  553. 

  554.     def test_sre_character_literals(self):
    555. 

  555.         for i in [0, 8, 16, 32, 64, 127, 128, 255, 256, 0xFFFF, 0x10000, 0x10FFFF]:
    556. 

  556.             if i < 256:
    557. 

  557.                 self.assertIsNotNone(re.match(r"\%03o" % i, chr(i)))
    558. 

  558.                 self.assertIsNotNone(re.match(r"\%03o0" % i, chr(i)+"0"))
    559. 

  559.                 self.assertIsNotNone(re.match(r"\%03o8" % i, chr(i)+"8"))
    560. 

  560.                 self.assertIsNotNone(re.match(r"\x%02x" % i, chr(i)))
    561. 

  561.                 self.assertIsNotNone(re.match(r"\x%02x0" % i, chr(i)+"0"))
    562. 

  562.                 self.assertIsNotNone(re.match(r"\x%02xz" % i, chr(i)+"z"))
    563. 

  563.             if i < 0x10000:
    564. 

  564.                 self.assertIsNotNone(re.match(r"\u%04x" % i, chr(i)))
    565. 

  565.                 self.assertIsNotNone(re.match(r"\u%04x0" % i, chr(i)+"0"))
    566. 

  566.                 self.assertIsNotNone(re.match(r"\u%04xz" % i, chr(i)+"z"))
    567. 

  567.             self.assertIsNotNone(re.match(r"\U%08x" % i, chr(i)))
    568. 

  568.             self.assertIsNotNone(re.match(r"\U%08x0" % i, chr(i)+"0"))
    569. 

  569.             self.assertIsNotNone(re.match(r"\U%08xz" % i, chr(i)+"z"))
    570. 

  570.         self.assertIsNotNone(re.match(r"\0", "\000"))
    571. 

  571.         self.assertIsNotNone(re.match(r"\08", "\0008"))
    572. 

  572.         self.assertIsNotNone(re.match(r"\01", "\001"))
    573. 

  573.         self.assertIsNotNone(re.match(r"\018", "\0018"))
    574. 

  574.         self.assertIsNotNone(re.match(r"\567", chr(0o167)))
    575. 

  575.         self.assertRaises(re.error, re.match, r"\911", "")
    576. 

  576.         self.assertRaises(re.error, re.match, r"\x1", "")
    577. 

  577.         self.assertRaises(re.error, re.match, r"\x1z", "")
    578. 

  578.         self.assertRaises(re.error, re.match, r"\u123", "")
    579. 

  579.         self.assertRaises(re.error, re.match, r"\u123z", "")
    580. 

  580.         self.assertRaises(re.error, re.match, r"\U0001234", "")
    581. 

  581.         self.assertRaises(re.error, re.match, r"\U0001234z", "")
    582. 

  582.         self.assertRaises(re.error, re.match, r"\U00110000", "")
    583. 

  583. 

  584.     def test_sre_character_class_literals(self):
    585. 

  585.         for i in [0, 8, 16, 32, 64, 127, 128, 255, 256, 0xFFFF, 0x10000, 0x10FFFF]:
    586. 

  586.             if i < 256:
    587. 

  587.                 self.assertIsNotNone(re.match(r"[\%o]" % i, chr(i)))
    588. 

  588.                 self.assertIsNotNone(re.match(r"[\%o8]" % i, chr(i)))
    589. 

  589.                 self.assertIsNotNone(re.match(r"[\%03o]" % i, chr(i)))
    590. 

  590.                 self.assertIsNotNone(re.match(r"[\%03o0]" % i, chr(i)))
    591. 

  591.                 self.assertIsNotNone(re.match(r"[\%03o8]" % i, chr(i)))
    592. 

  592.                 self.assertIsNotNone(re.match(r"[\x%02x]" % i, chr(i)))
    593. 

  593.                 self.assertIsNotNone(re.match(r"[\x%02x0]" % i, chr(i)))
    594. 

  594.                 self.assertIsNotNone(re.match(r"[\x%02xz]" % i, chr(i)))
    595. 

  595.             if i < 0x10000:
    596. 

  596.                 self.assertIsNotNone(re.match(r"[\u%04x]" % i, chr(i)))
    597. 

  597.                 self.assertIsNotNone(re.match(r"[\u%04x0]" % i, chr(i)))
    598. 

  598.                 self.assertIsNotNone(re.match(r"[\u%04xz]" % i, chr(i)))
    599. 

  599.             self.assertIsNotNone(re.match(r"[\U%08x]" % i, chr(i)))
    600. 

  600.             self.assertIsNotNone(re.match(r"[\U%08x0]" % i, chr(i)+"0"))
    601. 

  601.             self.assertIsNotNone(re.match(r"[\U%08xz]" % i, chr(i)+"z"))
    602. 

  602.         self.assertRaises(re.error, re.match, r"[\911]", "")
    603. 

  603.         self.assertRaises(re.error, re.match, r"[\x1z]", "")
    604. 

  604.         self.assertRaises(re.error, re.match, r"[\u123z]", "")
    605. 

  605.         self.assertRaises(re.error, re.match, r"[\U0001234z]", "")
    606. 

  606.         self.assertRaises(re.error, re.match, r"[\U00110000]", "")
    607. 

  607. 

  608.     def test_sre_byte_literals(self):
    609. 

  609.         for i in [0, 8, 16, 32, 64, 127, 128, 255]:
    610. 

  610.             self.assertIsNotNone(re.match((r"\%03o" % i).encode(), bytes([i])))
    611. 

  611.             self.assertIsNotNone(re.match((r"\%03o0" % i).encode(), bytes([i])+b"0"))
    612. 

  612.             self.assertIsNotNone(re.match((r"\%03o8" % i).encode(), bytes([i])+b"8"))
    613. 

  613.             self.assertIsNotNone(re.match((r"\x%02x" % i).encode(), bytes([i])))
    614. 

  614.             self.assertIsNotNone(re.match((r"\x%02x0" % i).encode(), bytes([i])+b"0"))
    615. 

  615.             self.assertIsNotNone(re.match((r"\x%02xz" % i).encode(), bytes([i])+b"z"))
    616. 

  616.         self.assertIsNotNone(re.match(br"\u", b'u'))
    617. 

  617.         self.assertIsNotNone(re.match(br"\U", b'U'))
    618. 

  618.         self.assertIsNotNone(re.match(br"\0", b"\000"))
    619. 

  619.         self.assertIsNotNone(re.match(br"\08", b"\0008"))
    620. 

  620.         self.assertIsNotNone(re.match(br"\01", b"\001"))
    621. 

  621.         self.assertIsNotNone(re.match(br"\018", b"\0018"))
    622. 

  622.         self.assertIsNotNone(re.match(br"\567", bytes([0o167])))
    623. 

  623.         self.assertRaises(re.error, re.match, br"\911", b"")
    624. 

  624.         self.assertRaises(re.error, re.match, br"\x1", b"")
    625. 

  625.         self.assertRaises(re.error, re.match, br"\x1z", b"")
    626. 

  626. 

  627.     def test_sre_byte_class_literals(self):
    628. 

  628.         for i in [0, 8, 16, 32, 64, 127, 128, 255]:
    629. 

  629.             self.assertIsNotNone(re.match((r"[\%o]" % i).encode(), bytes([i])))
    630. 

  630.             self.assertIsNotNone(re.match((r"[\%o8]" % i).encode(), bytes([i])))
    631. 

  631.             self.assertIsNotNone(re.match((r"[\%03o]" % i).encode(), bytes([i])))
    632. 

  632.             self.assertIsNotNone(re.match((r"[\%03o0]" % i).encode(), bytes([i])))
    633. 

  633.             self.assertIsNotNone(re.match((r"[\%03o8]" % i).encode(), bytes([i])))
    634. 

  634.             self.assertIsNotNone(re.match((r"[\x%02x]" % i).encode(), bytes([i])))
    635. 

  635.             self.assertIsNotNone(re.match((r"[\x%02x0]" % i).encode(), bytes([i])))
    636. 

  636.             self.assertIsNotNone(re.match((r"[\x%02xz]" % i).encode(), bytes([i])))
    637. 

  637.         self.assertIsNotNone(re.match(br"[\u]", b'u'))
    638. 

  638.         self.assertIsNotNone(re.match(br"[\U]", b'U'))
    639. 

  639.         self.assertRaises(re.error, re.match, br"[\911]", "")
    640. 

  640.         self.assertRaises(re.error, re.match, br"[\x1z]", "")
    641. 

  641. 

  642.     def test_bug_113254(self):
    643. 

  643.         self.assertEqual(re.match(r'(a)|(b)', 'b').start(1), -1)
    644. 

  644.         self.assertEqual(re.match(r'(a)|(b)', 'b').end(1), -1)
    645. 

  645.         self.assertEqual(re.match(r'(a)|(b)', 'b').span(1), (-1, -1))
    646. 

  646. 

  647.     def test_bug_527371(self):
    648. 

  648.         # bug described in patches 527371/672491
    649. 

  649.         self.assertEqual(re.match(r'(a)?a','a').lastindex, None)
    650. 

  650.         self.assertEqual(re.match(r'(a)(b)?b','ab').lastindex, 1)
    651. 

  651.         self.assertEqual(re.match(r'(?P<a>a)(?P<b>b)?b','ab').lastgroup, 'a')
    652. 

  652.         self.assertEqual(re.match("(?P<a>a(b))", "ab").lastgroup, 'a')
    653. 

  653.         self.assertEqual(re.match("((a))", "a").lastindex, 1)
    654. 

  654. 

  655.     def test_bug_545855(self):
    656. 

  656.         # bug 545855 -- This pattern failed to cause a compile error as it
    657. 

  657.         # should, instead provoking a TypeError.
    658. 

  658.         self.assertRaises(re.error, re.compile, 'foo[a-')
    659. 

  659. 

  660.     def test_bug_418626(self):
    661. 

  661.         # bugs 418626 at al. -- Testing Greg Chapman's addition of op code
    662. 

  662.         # SRE_OP_MIN_REPEAT_ONE for eliminating recursion on simple uses of
    663. 

  663.         # pattern '*?' on a long string.
    664. 

  664.         self.assertEqual(re.match('.*?c', 10000*'ab'+'cd').end(0), 20001)
    665. 

  665.         self.assertEqual(re.match('.*?cd', 5000*'ab'+'c'+5000*'ab'+'cde').end(0),
    666. 

  666.                          20003)
    667. 

  667.         self.assertEqual(re.match('.*?cd', 20000*'abc'+'de').end(0), 60001)
    668. 

  668.         # non-simple '*?' still used to hit the recursion limit, before the
    669. 

  669.         # non-recursive scheme was implemented.
    670. 

  670.         self.assertEqual(re.search('(a|b)*?c', 10000*'ab'+'cd').end(0), 20001)
    671. 

  671. 

  672.     def test_bug_612074(self):
    673. 

  673.         pat="["+re.escape("\u2039")+"]"
    674. 

  674.         self.assertEqual(re.compile(pat) and 1, 1)
    675. 

  675. 

  676.     def test_stack_overflow(self):
    677. 

  677.         # nasty cases that used to overflow the straightforward recursive
    678. 

  678.         # implementation of repeated groups.
    679. 

  679.         self.assertEqual(re.match('(x)*', 50000*'x').group(1), 'x')
    680. 

  680.         self.assertEqual(re.match('(x)*y', 50000*'x'+'y').group(1), 'x')
    681. 

  681.         self.assertEqual(re.match('(x)*?y', 50000*'x'+'y').group(1), 'x')
    682. 

  682. 

  683.     def test_scanner(self):
    684. 

  684.         def s_ident(scanner, token): return token
    685. 

  685.         def s_operator(scanner, token): return "op%s" % token
    686. 

  686.         def s_float(scanner, token): return float(token)
    687. 

  687.         def s_int(scanner, token): return int(token)
    688. 

  688. 

  689.         scanner = Scanner([
    690. 

  690.             (r"[a-zA-Z_]\w*", s_ident),
    691. 

  691.             (r"\d+\.\d*", s_float),
    692. 

  692.             (r"\d+", s_int),
    693. 

  693.             (r"=|\+|-|\*|/", s_operator),
    694. 

  694.             (r"\s+", None),
    695. 

  695.             ])
    696. 

  696. 

  697.         self.assertNotEqual(scanner.scanner.scanner("").pattern, None)
    698. 

  698. 

  699.         self.assertEqual(scanner.scan("sum = 3*foo + 312.50 + bar"),
    700. 

  700.                          (['sum', 'op=', 3, 'op*', 'foo', 'op+', 312.5,
    701. 

  701.                            'op+', 'bar'], ''))
    702. 

  702. 

  703.     def test_bug_448951(self):
    704. 

  704.         # bug 448951 (similar to 429357, but with single char match)
    705. 

  705.         # (Also test greedy matches.)
    706. 

  706.         for op in '','?','*':
    707. 

  707.             self.assertEqual(re.match(r'((.%s):)?z'%op, 'z').groups(),
    708. 

  708.                              (None, None))
    709. 

  709.             self.assertEqual(re.match(r'((.%s):)?z'%op, 'a:z').groups(),
    710. 

  710.                              ('a:', 'a'))
    711. 

  711. 

  712.     def test_bug_725106(self):
    713. 

  713.         # capturing groups in alternatives in repeats
    714. 

  714.         self.assertEqual(re.match('^((a)|b)*', 'abc').groups(),
    715. 

  715.                          ('b', 'a'))
    716. 

  716.         self.assertEqual(re.match('^(([ab])|c)*', 'abc').groups(),
    717. 

  717.                          ('c', 'b'))
    718. 

  718.         self.assertEqual(re.match('^((d)|[ab])*', 'abc').groups(),
    719. 

  719.                          ('b', None))
    720. 

  720.         self.assertEqual(re.match('^((a)c|[ab])*', 'abc').groups(),
    721. 

  721.                          ('b', None))
    722. 

  722.         self.assertEqual(re.match('^((a)|b)*?c', 'abc').groups(),
    723. 

  723.                          ('b', 'a'))
    724. 

  724.         self.assertEqual(re.match('^(([ab])|c)*?d', 'abcd').groups(),
    725. 

  725.                          ('c', 'b'))
    726. 

  726.         self.assertEqual(re.match('^((d)|[ab])*?c', 'abc').groups(),
    727. 

  727.                          ('b', None))
    728. 

  728.         self.assertEqual(re.match('^((a)c|[ab])*?c', 'abc').groups(),
    729. 

  729.                          ('b', None))
    730. 

  730. 

  731.     def test_bug_725149(self):
    732. 

  732.         # mark_stack_base restoring before restoring marks
    733. 

  733.         self.assertEqual(re.match('(a)(?:(?=(b)*)c)*', 'abb').groups(),
    734. 

  734.                          ('a', None))
    735. 

  735.         self.assertEqual(re.match('(a)((?!(b)*))*', 'abb').groups(),
    736. 

  736.                          ('a', None, None))
    737. 

  737. 

  738.     def test_bug_764548(self):
    739. 

  739.         # bug 764548, re.compile() barfs on str/unicode subclasses
    740. 

  740.         class my_unicode(str): pass
    741. 

  741.         pat = re.compile(my_unicode("abc"))
    742. 

  742.         self.assertEqual(pat.match("xyz"), None)
    743. 

  743. 

  744.     def test_finditer(self):
    745. 

  745.         iter = re.finditer(r":+", "a:b::c:::d")
    746. 

  746.         self.assertEqual([item.group(0) for item in iter],
    747. 

  747.                          [":", "::", ":::"])
    748. 

  748. 

  749.         pat = re.compile(r":+")
    750. 

  750.         iter = pat.finditer("a:b::c:::d", 1, 10)
    751. 

  751.         self.assertEqual([item.group(0) for item in iter],
    752. 

  752.                          [":", "::", ":::"])
    753. 

  753. 

  754.         pat = re.compile(r":+")
    755. 

  755.         iter = pat.finditer("a:b::c:::d", pos=1, endpos=10)
    756. 

  756.         self.assertEqual([item.group(0) for item in iter],
    757. 

  757.                          [":", "::", ":::"])
    758. 

  758. 

  759.         pat = re.compile(r":+")
    760. 

  760.         iter = pat.finditer("a:b::c:::d", endpos=10, pos=1)
    761. 

  761.         self.assertEqual([item.group(0) for item in iter],
    762. 

  762.                          [":", "::", ":::"])
    763. 

  763. 

  764.         pat = re.compile(r":+")
    765. 

  765.         iter = pat.finditer("a:b::c:::d", pos=3, endpos=8)
    766. 

  766.         self.assertEqual([item.group(0) for item in iter],
    767. 

  767.                          ["::", "::"])
    768. 

  768. 

  769.     def test_bug_926075(self):
    770. 

  770.         self.assertTrue(re.compile('bug_926075') is not
    771. 

  771.                      re.compile(b'bug_926075'))
    772. 

  772. 

  773.     def test_bug_931848(self):
    774. 

  774.         pattern = eval('"[\u002E\u3002\uFF0E\uFF61]"')
    775. 

  775.         self.assertEqual(re.compile(pattern).split("a.b.c"),
    776. 

  776.                          ['a','b','c'])
    777. 

  777. 

  778.     def test_bug_581080(self):
    779. 

  779.         iter = re.finditer(r"\s", "a b")
    780. 

  780.         self.assertEqual(next(iter).span(), (1,2))
    781. 

  781.         self.assertRaises(StopIteration, next, iter)
    782. 

  782. 

  783.         scanner = re.compile(r"\s").scanner("a b")
    784. 

  784.         self.assertEqual(scanner.search().span(), (1, 2))
    785. 

  785.         self.assertEqual(scanner.search(), None)
    786. 

  786. 

  787.     def test_bug_817234(self):
    788. 

  788.         iter = re.finditer(r".*", "asdf")
    789. 

  789.         self.assertEqual(next(iter).span(), (0, 4))
    790. 

  790.         self.assertEqual(next(iter).span(), (4, 4))
    791. 

  791.         self.assertRaises(StopIteration, next, iter)
    792. 

  792. 

  793.     def test_bug_6561(self):
    794. 

  794.         # '\d' should match characters in Unicode category 'Nd'
    795. 

  795.         # (Number, Decimal Digit), but not those in 'Nl' (Number,
    796. 

  796.         # Letter) or 'No' (Number, Other).
    797. 

  797.         decimal_digits = [
    798. 

  798.             '\u0037', # '\N{DIGIT SEVEN}', category 'Nd'
    799. 

  799.             '\u0e58', # '\N{THAI DIGIT SIX}', category 'Nd'
    800. 

  800.             '\uff10', # '\N{FULLWIDTH DIGIT ZERO}', category 'Nd'
    801. 

  801.             ]
    802. 

  802.         for x in decimal_digits:
    803. 

  803.             self.assertEqual(re.match('^\d$', x).group(0), x)
    804. 

  804. 

  805.         not_decimal_digits = [
    806. 

  806.             '\u2165', # '\N{ROMAN NUMERAL SIX}', category 'Nl'
    807. 

  807.             '\u3039', # '\N{HANGZHOU NUMERAL TWENTY}', category 'Nl'
    808. 

  808.             '\u2082', # '\N{SUBSCRIPT TWO}', category 'No'
    809. 

  809.             '\u32b4', # '\N{CIRCLED NUMBER THIRTY NINE}', category 'No'
    810. 

  810.             ]
    811. 

  811.         for x in not_decimal_digits:
    812. 

  812.             self.assertIsNone(re.match('^\d$', x))
    813. 

  813. 

  814.     def test_empty_array(self):
    815. 

  815.         # SF buf 1647541
    816. 

  816.         import array
    817. 

  817.         for typecode in 'bBuhHiIlLfd':
    818. 

  818.             a = array.array(typecode)
    819. 

  819.             self.assertEqual(re.compile(b"bla").match(a), None)
    820. 

  820.             self.assertEqual(re.compile(b"").match(a).groups(), ())
    821. 

  821. 

  822.     def test_inline_flags(self):
    823. 

  823.         # Bug #1700
    824. 

  824.         upper_char = chr(0x1ea0) # Latin Capital Letter A with Dot Bellow
    825. 

  825.         lower_char = chr(0x1ea1) # Latin Small Letter A with Dot Bellow
    826. 

  826. 

  827.         p = re.compile(upper_char, re.I | re.U)
    828. 

  828.         q = p.match(lower_char)
    829. 

  829.         self.assertNotEqual(q, None)
    830. 

  830. 

  831.         p = re.compile(lower_char, re.I | re.U)
    832. 

  832.         q = p.match(upper_char)
    833. 

  833.         self.assertNotEqual(q, None)
    834. 

  834. 

  835.         p = re.compile('(?i)' + upper_char, re.U)
    836. 

  836.         q = p.match(lower_char)
    837. 

  837.         self.assertNotEqual(q, None)
    838. 

  838. 

  839.         p = re.compile('(?i)' + lower_char, re.U)
    840. 

  840.         q = p.match(upper_char)
    841. 

  841.         self.assertNotEqual(q, None)
    842. 

  842. 

  843.         p = re.compile('(?iu)' + upper_char)
    844. 

  844.         q = p.match(lower_char)
    845. 

  845.         self.assertNotEqual(q, None)
    846. 

  846. 

  847.         p = re.compile('(?iu)' + lower_char)
    848. 

  848.         q = p.match(upper_char)
    849. 

  849.         self.assertNotEqual(q, None)
    850. 

  850. 

  851.     def test_dollar_matches_twice(self):
    852. 

  852.         "$ matches the end of string, and just before the terminating \n"
    853. 

  853.         pattern = re.compile('$')
    854. 

  854.         self.assertEqual(pattern.sub('#', 'a\nb\n'), 'a\nb#\n#')
    855. 

  855.         self.assertEqual(pattern.sub('#', 'a\nb\nc'), 'a\nb\nc#')
    856. 

  856.         self.assertEqual(pattern.sub('#', '\n'), '#\n#')
    857. 

  857. 

  858.         pattern = re.compile('$', re.MULTILINE)
    859. 

  859.         self.assertEqual(pattern.sub('#', 'a\nb\n' ), 'a#\nb#\n#' )
    860. 

  860.         self.assertEqual(pattern.sub('#', 'a\nb\nc'), 'a#\nb#\nc#')
    861. 

  861.         self.assertEqual(pattern.sub('#', '\n'), '#\n#')
    862. 

  862. 

  863.     def test_bytes_str_mixing(self):
    864. 

  864.         # Mixing str and bytes is disallowed
    865. 

  865.         pat = re.compile('.')
    866. 

  866.         bpat = re.compile(b'.')
    867. 

  867.         self.assertRaises(TypeError, pat.match, b'b')
    868. 

  868.         self.assertRaises(TypeError, bpat.match, 'b')
    869. 

  869.         self.assertRaises(TypeError, pat.sub, b'b', 'c')
    870. 

  870.         self.assertRaises(TypeError, pat.sub, 'b', b'c')
    871. 

  871.         self.assertRaises(TypeError, pat.sub, b'b', b'c')
    872. 

  872.         self.assertRaises(TypeError, bpat.sub, b'b', 'c')
    873. 

  873.         self.assertRaises(TypeError, bpat.sub, 'b', b'c')
    874. 

  874.         self.assertRaises(TypeError, bpat.sub, 'b', 'c')
    875. 

  875. 

  876.     def test_ascii_and_unicode_flag(self):
    877. 

  877.         # String patterns
    878. 

  878.         for flags in (0, re.UNICODE):
    879. 

  879.             pat = re.compile('\xc0', flags | re.IGNORECASE)
    880. 

  880.             self.assertNotEqual(pat.match('\xe0'), None)
    881. 

  881.             pat = re.compile('\w', flags)
    882. 

  882.             self.assertNotEqual(pat.match('\xe0'), None)
    883. 

  883.         pat = re.compile('\xc0', re.ASCII | re.IGNORECASE)
    884. 

  884.         self.assertEqual(pat.match('\xe0'), None)
    885. 

  885.         pat = re.compile('(?a)\xc0', re.IGNORECASE)
    886. 

  886.         self.assertEqual(pat.match('\xe0'), None)
    887. 

  887.         pat = re.compile('\w', re.ASCII)
    888. 

  888.         self.assertEqual(pat.match('\xe0'), None)
    889. 

  889.         pat = re.compile('(?a)\w')
    890. 

  890.         self.assertEqual(pat.match('\xe0'), None)
    891. 

  891.         # Bytes patterns
    892. 

  892.         for flags in (0, re.ASCII):
    893. 

  893.             pat = re.compile(b'\xc0', re.IGNORECASE)
    894. 

  894.             self.assertEqual(pat.match(b'\xe0'), None)
    895. 

  895.             pat = re.compile(b'\w')
    896. 

  896.             self.assertEqual(pat.match(b'\xe0'), None)
    897. 

  897.         # Incompatibilities
    898. 

  898.         self.assertRaises(ValueError, re.compile, b'\w', re.UNICODE)
    899. 

  899.         self.assertRaises(ValueError, re.compile, b'(?u)\w')
    900. 

  900.         self.assertRaises(ValueError, re.compile, '\w', re.UNICODE | re.ASCII)
    901. 

  901.         self.assertRaises(ValueError, re.compile, '(?u)\w', re.ASCII)
    902. 

  902.         self.assertRaises(ValueError, re.compile, '(?a)\w', re.UNICODE)
    903. 

  903.         self.assertRaises(ValueError, re.compile, '(?au)\w')
    904. 

  904. 

  905.     def test_bug_6509(self):
    906. 

  906.         # Replacement strings of both types must parse properly.
    907. 

  907.         # all strings
    908. 

  908.         pat = re.compile('a(\w)')
    909. 

  909.         self.assertEqual(pat.sub('b\\1', 'ac'), 'bc')
    910. 

  910.         pat = re.compile('a(.)')
    911. 

  911.         self.assertEqual(pat.sub('b\\1', 'a\u1234'), 'b\u1234')
    912. 

  912.         pat = re.compile('..')
    913. 

  913.         self.assertEqual(pat.sub(lambda m: 'str', 'a5'), 'str')
    914. 

  914. 

  915.         # all bytes
    916. 

  916.         pat = re.compile(b'a(\w)')
    917. 

  917.         self.assertEqual(pat.sub(b'b\\1', b'ac'), b'bc')
    918. 

  918.         pat = re.compile(b'a(.)')
    919. 

  919.         self.assertEqual(pat.sub(b'b\\1', b'a\xCD'), b'b\xCD')
    920. 

  920.         pat = re.compile(b'..')
    921. 

  921.         self.assertEqual(pat.sub(lambda m: b'bytes', b'a5'), b'bytes')
    922. 

  922. 

  923.     def test_dealloc(self):
    924. 

  924.         # issue 3299: check for segfault in debug build
    925. 

  925.         import _sre
    926. 

  926.         # the overflow limit is different on wide and narrow builds and it
    927. 

  927.         # depends on the definition of SRE_CODE (see sre.h).
    928. 

  928.         # 2**128 should be big enough to overflow on both. For smaller values
    929. 

  929.         # a RuntimeError is raised instead of OverflowError.
    930. 

  930.         long_overflow = 2**128
    931. 

  931.         self.assertRaises(TypeError, re.finditer, "a", {})
    932. 

  932.         self.assertRaises(OverflowError, _sre.compile, "abc", 0, [long_overflow])
    933. 

  933.         self.assertRaises(TypeError, _sre.compile, {}, 0, [])
    934. 

  934. 

  935.     def test_search_dot_unicode(self):
    936. 

  936.         self.assertIsNotNone(re.search("123.*-", '123abc-'))
    937. 

  937.         self.assertIsNotNone(re.search("123.*-", '123\xe9-'))
    938. 

  938.         self.assertIsNotNone(re.search("123.*-", '123\u20ac-'))
    939. 

  939.         self.assertIsNotNone(re.search("123.*-", '123\U0010ffff-'))
    940. 

  940.         self.assertIsNotNone(re.search("123.*-", '123\xe9\u20ac\U0010ffff-'))
    941. 

  941. 

  942.     def test_compile(self):
    943. 

  943.         # Test return value when given string and pattern as parameter
    944. 

  944.         pattern = re.compile('random pattern')
    945. 

  945.         self.assertIsInstance(pattern, re._pattern_type)
    946. 

  946.         same_pattern = re.compile(pattern)
    947. 

  947.         self.assertIsInstance(same_pattern, re._pattern_type)
    948. 

  948.         self.assertIs(same_pattern, pattern)
    949. 

  949.         # Test behaviour when not given a string or pattern as parameter
    950. 

  950.         self.assertRaises(TypeError, re.compile, 0)
    951. 

  951. 

  952.     @bigmemtest(size=_2G, memuse=1)
    953. 

  953.     def test_large_search(self, size):
    954. 

  954.         # Issue #10182: indices were 32-bit-truncated.
    955. 

  955.         s = 'a' * size
    956. 

  956.         m = re.search('$', s)
    957. 

  957.         self.assertIsNotNone(m)
    958. 

  958.         self.assertEqual(m.start(), size)
    959. 

  959.         self.assertEqual(m.end(), size)
    960. 

  960. 

  961.     # The huge memuse is because of re.sub() using a list and a join()
    962. 

  962.     # to create the replacement result.
    963. 

  963.     @bigmemtest(size=_2G, memuse=16 + 2)
    964. 

  964.     def test_large_subn(self, size):
    965. 

  965.         # Issue #10182: indices were 32-bit-truncated.
    966. 

  966.         s = 'a' * size
    967. 

  967.         r, n = re.subn('', '', s)
    968. 

  968.         self.assertEqual(r, s)
    969. 

  969.         self.assertEqual(n, size + 1)
    970. 

  970. 

  971.     def test_bug_16688(self):
    972. 

  972.         # Issue 16688: Backreferences make case-insensitive regex fail on
    973. 

  973.         # non-ASCII strings.
    974. 

  974.         self.assertEqual(re.findall(r"(?i)(a)\1", "aa \u0100"), ['a'])
    975. 

  975.         self.assertEqual(re.match(r"(?s).{1,3}", "\u0100\u0100").span(), (0, 2))
    976. 

  976. 

  977. def run_re_tests():
    978. 

  978.     from test.re_tests import tests, SUCCEED, FAIL, SYNTAX_ERROR
    979. 

  979.     if verbose:
    980. 

  980.         print('Running re_tests test suite')
    981. 

  981.     else:
    982. 

  982.         # To save time, only run the first and last 10 tests
    983. 

  983.         #tests = tests[:10] + tests[-10:]
    984. 

  984.         pass
    985. 

  985. 

  986.     for t in tests:
    987. 

  987.         sys.stdout.flush()
    988. 

  988.         pattern = s = outcome = repl = expected = None
    989. 

  989.         if len(t) == 5:
    990. 

  990.             pattern, s, outcome, repl, expected = t
    991. 

  991.         elif len(t) == 3:
    992. 

  992.             pattern, s, outcome = t
    993. 

  993.         else:
    994. 

  994.             raise ValueError('Test tuples should have 3 or 5 fields', t)
    995. 

  995. 

  996.         try:
    997. 

  997.             obj = re.compile(pattern)
    998. 

  998.         except re.error:
    999. 

  999.             if outcome == SYNTAX_ERROR: pass  # Expected a syntax error
    1000. 

  1000.             else:
    1001. 

  1001.                 print('=== Syntax error:', t)
    1002. 

  1002.         except KeyboardInterrupt: raise KeyboardInterrupt
    1003. 

  1003.         except:
    1004. 

  1004.             print('*** Unexpected error ***', t)
    1005. 

  1005.             if verbose:
    1006. 

  1006.                 traceback.print_exc(file=sys.stdout)
    1007. 

  1007.         else:
    1008. 

  1008.             try:
    1009. 

  1009.                 result = obj.search(s)
    1010. 

  1010.             except re.error as msg:
    1011. 

  1011.                 print('=== Unexpected exception', t, repr(msg))
    1012. 

  1012.             if outcome == SYNTAX_ERROR:
    1013. 

  1013.                 # This should have been a syntax error; forget it.
    1014. 

  1014.                 pass
    1015. 

  1015.             elif outcome == FAIL:
    1016. 

  1016.                 if result is None: pass   # No match, as expected
    1017. 

  1017.                 else: print('=== Succeeded incorrectly', t)
    1018. 

  1018.             elif outcome == SUCCEED:
    1019. 

  1019.                 if result is not None:
    1020. 

  1020.                     # Matched, as expected, so now we compute the
    1021. 

  1021.                     # result string and compare it to our expected result.
    1022. 

  1022.                     start, end = result.span(0)
    1023. 

  1023.                     vardict={'found': result.group(0),
    1024. 

  1024.                              'groups': result.group(),
    1025. 

  1025.                              'flags': result.re.flags}
    1026. 

  1026.                     for i in range(1, 100):
    1027. 

  1027.                         try:
    1028. 

  1028.                             gi = result.group(i)
    1029. 

  1029.                             # Special hack because else the string concat fails:
    1030. 

  1030.                             if gi is None:
    1031. 

  1031.                                 gi = "None"
    1032. 

  1032.                         except IndexError:
    1033. 

  1033.                             gi = "Error"
    1034. 

  1034.                         vardict['g%d' % i] = gi
    1035. 

  1035.                     for i in result.re.groupindex.keys():
    1036. 

  1036.                         try:
    1037. 

  1037.                             gi = result.group(i)
    1038. 

  1038.                             if gi is None:
    1039. 

  1039.                                 gi = "None"
    1040. 

  1040.                         except IndexError:
    1041. 

  1041.                             gi = "Error"
    1042. 

  1042.                         vardict[i] = gi
    1043. 

  1043.                     repl = eval(repl, vardict)
    1044. 

  1044.                     if repl != expected:
    1045. 

  1045.                         print('=== grouping error', t, end=' ')
    1046. 

  1046.                         print(repr(repl) + ' should be ' + repr(expected))
    1047. 

  1047.                 else:
    1048. 

  1048.                     print('=== Failed incorrectly', t)
    1049. 

  1049. 

  1050.                 # Try the match with both pattern and string converted to
    1051. 

  1051.                 # bytes, and check that it still succeeds.
    1052. 

  1052.                 try:
    1053. 

  1053.                     bpat = bytes(pattern, "ascii")
    1054. 

  1054.                     bs = bytes(s, "ascii")
    1055. 

  1055.                 except UnicodeEncodeError:
    1056. 

  1056.                     # skip non-ascii tests
    1057. 

  1057.                     pass
    1058. 

  1058.                 else:
    1059. 

  1059.                     try:
    1060. 

  1060.                         bpat = re.compile(bpat)
    1061. 

  1061.                     except Exception:
    1062. 

  1062.                         print('=== Fails on bytes pattern compile', t)
    1063. 

  1063.                         if verbose:
    1064. 

  1064.                             traceback.print_exc(file=sys.stdout)
    1065. 

  1065.                     else:
    1066. 

  1066.                         bytes_result = bpat.search(bs)
    1067. 

  1067.                         if bytes_result is None:
    1068. 

  1068.                             print('=== Fails on bytes pattern match', t)
    1069. 

  1069. 

  1070.                 # Try the match with the search area limited to the extent
    1071. 

  1071.                 # of the match and see if it still succeeds.  \B will
    1072. 

  1072.                 # break (because it won't match at the end or start of a
    1073. 

  1073.                 # string), so we'll ignore patterns that feature it.
    1074. 

    1075. 

  1075.                 if pattern[:2] != '\\B' and pattern[-2:] != '\\B' \
    1076. 

  1076.                                and result is not None:
    1077. 

  1077.                     obj = re.compile(pattern)
    1078. 

  1078.                     result = obj.search(s, result.start(0), result.end(0) + 1)
    1079. 

  1079.                     if result is None:
    1080. 

  1080.                         print('=== Failed on range-limited match', t)
    1081. 

  1081. 

  1082.                 # Try the match with IGNORECASE enabled, and check that it
    1083. 

  1083.                 # still succeeds.
    1084. 

  1084.                 obj = re.compile(pattern, re.IGNORECASE)
    1085. 

  1085.                 result = obj.search(s)
    1086. 

  1086.                 if result is None:
    1087. 

  1087.                     print('=== Fails on case-insensitive match', t)
    1088. 

  1088. 

  1089.                 # Try the match with LOCALE enabled, and check that it
    1090. 

  1090.                 # still succeeds.
    1091. 

  1091.                 if '(?u)' not in pattern:
    1092. 

  1092.                     obj = re.compile(pattern, re.LOCALE)
    1093. 

  1093.                     result = obj.search(s)
    1094. 

  1094.                     if result is None:
    1095. 

  1095.                         print('=== Fails on locale-sensitive match', t)
    1096. 

  1096. 

  1097.                 # Try the match with UNICODE locale enabled, and check
    1098. 

  1098.                 # that it still succeeds.
    1099. 

  1099.                 obj = re.compile(pattern, re.UNICODE)
    1100. 

  1100.                 result = obj.search(s)
    1101. 

  1101.                 if result is None:
    1102. 

  1102.                     print('=== Fails on unicode-sensitive match', t)
    1103. 

  1103. 

  1104. 

  1105. def test_main():
    1106. 

  1106.     run_unittest(ReTests)
    1107. 

  1107.     run_re_tests()
    1108. 

  1108. 

  1109. if __name__ == "__main__":
    1110. 

  1110.     test_main()
    1111. 

  1111.