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

/lib-python/2.7/test/test_re.py

https://bitbucket.org/ltratt/pypy
Python | 1264 lines | 1230 code | 17 blank | 17 comment | 3 complexity | f2fb91e482dc4113aeab2e34758d6163 MD5 | raw file
Possible License(s): Apache-2.0, AGPL-3.0, BSD-3-Clause

Large files files are truncated, but you can click here to view the full file

    

  1. # -*- coding: utf-8 -*-
    2. 

  2. from test.test_support import (
    3. 

  3.     verbose, run_unittest, import_module,
    4. 

  4.     precisionbigmemtest, _2G, cpython_only,
    5. 

  5.     captured_stdout, have_unicode, requires_unicode, u,
    6. 

  6.     check_warnings)
    7. 

  7. import locale
    8. 

  8. import re
    9. 

  9. from re import Scanner
    10. 

  10. import sre_constants
    11. 

  11. import sys
    12. 

  12. import string
    13. 

  13. import traceback
    14. 

  14. from weakref import proxy
    15. 

  15. 

  16. 

  17. # Misc tests from Tim Peters' re.doc
    18. 

    19. 

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

  20. # what you're doing. Some of these tests were carefully modeled to
    21. 

  21. # cover most of the code.
    22. 

  22. 

  23. import unittest
    24. 

  24. 

  25. class ReTests(unittest.TestCase):
    26. 

  26. 

  27.     def test_weakref(self):
    28. 

  28.         s = 'QabbbcR'
    29. 

  29.         x = re.compile('ab+c')
    30. 

  30.         y = proxy(x)
    31. 

  31.         self.assertEqual(x.findall('QabbbcR'), y.findall('QabbbcR'))
    32. 

  32. 

  33.     def test_search_star_plus(self):
    34. 

  34.         self.assertEqual(re.search('x*', 'axx').span(0), (0, 0))
    35. 

  35.         self.assertEqual(re.search('x*', 'axx').span(), (0, 0))
    36. 

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

  37.         self.assertEqual(re.search('x+', 'axx').span(), (1, 3))
    38. 

  38.         self.assertIsNone(re.search('x', 'aaa'))
    39. 

  39.         self.assertEqual(re.match('a*', 'xxx').span(0), (0, 0))
    40. 

  40.         self.assertEqual(re.match('a*', 'xxx').span(), (0, 0))
    41. 

  41.         self.assertEqual(re.match('x*', 'xxxa').span(0), (0, 3))
    42. 

  42.         self.assertEqual(re.match('x*', 'xxxa').span(), (0, 3))
    43. 

  43.         self.assertIsNone(re.match('a+', 'xxx'))
    44. 

  44. 

  45.     def bump_num(self, matchobj):
    46. 

  46.         int_value = int(matchobj.group(0))
    47. 

  47.         return str(int_value + 1)
    48. 

  48. 

  49.     def test_basic_re_sub(self):
    50. 

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

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

  52.                          '9.3 -3 24x100y')
    53. 

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

  54.                          '9.3 -3 23x99y')
    55. 

  55. 

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

  57.         self.assertEqual(re.sub('.', r"\n", 'x'), '\n')
    58. 

  58. 

  59.         s = r"\1\1"
    60. 

  60.         self.assertEqual(re.sub('(.)', s, 'x'), 'xx')
    61. 

  61.         self.assertEqual(re.sub('(.)', re.escape(s), 'x'), s)
    62. 

  62.         self.assertEqual(re.sub('(.)', lambda m: s, 'x'), s)
    63. 

  63. 

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

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

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

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

  68. 

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

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

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

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

  73.                          (chr(9)+chr(10)+chr(11)+chr(13)+chr(12)+chr(7)))
    74. 

  74. 

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

  76. 

  77.     def test_bug_449964(self):
    78. 

  78.         # fails for group followed by other escape
    79. 

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

  80.                          'xx\bxx\b')
    81. 

  81. 

  82.     def test_bug_449000(self):
    83. 

  83.         # Test for sub() on escaped characters
    84. 

  84.         self.assertEqual(re.sub(r'\r\n', r'\n', 'abc\r\ndef\r\n'),
    85. 

  85.                          'abc\ndef\n')
    86. 

  86.         self.assertEqual(re.sub('\r\n', r'\n', 'abc\r\ndef\r\n'),
    87. 

  87.                          'abc\ndef\n')
    88. 

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

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

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

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

  92. 

  93.     @requires_unicode
    94. 

  94.     def test_bug_1140(self):
    95. 

  95.         # re.sub(x, y, u'') should return u'', not '', and
    96. 

  96.         # re.sub(x, y, '') should return '', not u''.
    97. 

  97.         # Also:
    98. 

  98.         # re.sub(x, y, unicode(x)) should return unicode(y), and
    99. 

  99.         # re.sub(x, y, str(x)) should return
    100. 

  100.         #     str(y) if isinstance(y, str) else unicode(y).
    101. 

  101.         for x in 'x', u'x':
    102. 

  102.             for y in 'y', u'y':
    103. 

  103.                 z = re.sub(x, y, u'')
    104. 

  104.                 self.assertEqual(z, u'')
    105. 

  105.                 self.assertEqual(type(z), unicode)
    106. 

  106.                 #
    107. 

  107.                 z = re.sub(x, y, '')
    108. 

  108.                 self.assertEqual(z, '')
    109. 

  109.                 self.assertEqual(type(z), str)
    110. 

  110.                 #
    111. 

  111.                 z = re.sub(x, y, unicode(x))
    112. 

  112.                 self.assertEqual(z, y)
    113. 

  113.                 self.assertEqual(type(z), unicode)
    114. 

  114.                 #
    115. 

  115.                 z = re.sub(x, y, str(x))
    116. 

  116.                 self.assertEqual(z, y)
    117. 

  117.                 self.assertEqual(type(z), type(y))
    118. 

  118. 

  119.     def test_bug_1661(self):
    120. 

  120.         # Verify that flags do not get silently ignored with compiled patterns
    121. 

  121.         pattern = re.compile('.')
    122. 

  122.         self.assertRaises(ValueError, re.match, pattern, 'A', re.I)
    123. 

  123.         self.assertRaises(ValueError, re.search, pattern, 'A', re.I)
    124. 

  124.         self.assertRaises(ValueError, re.findall, pattern, 'A', re.I)
    125. 

  125.         self.assertRaises(ValueError, re.compile, pattern, re.I)
    126. 

  126. 

  127.     def test_bug_3629(self):
    128. 

  128.         # A regex that triggered a bug in the sre-code validator
    129. 

  129.         re.compile("(?P<quote>)(?(quote))")
    130. 

  130. 

  131.     def test_sub_template_numeric_escape(self):
    132. 

  132.         # bug 776311 and friends
    133. 

  133.         self.assertEqual(re.sub('x', r'\0', 'x'), '\0')
    134. 

  134.         self.assertEqual(re.sub('x', r'\000', 'x'), '\000')
    135. 

  135.         self.assertEqual(re.sub('x', r'\001', 'x'), '\001')
    136. 

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

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

  138.         self.assertEqual(re.sub('x', r'\111', 'x'), '\111')
    139. 

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

  140. 

  141.         self.assertEqual(re.sub('x', r'\1111', 'x'), '\1111')
    142. 

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

  143. 

  144.         self.assertEqual(re.sub('x', r'\00', 'x'), '\x00')
    145. 

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

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

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

  148.         self.assertEqual(re.sub('x', r'\0a', 'x'), '\0' + 'a')
    149. 

  149. 

  150.         self.assertEqual(re.sub('x', r'\400', 'x'), '\0')
    151. 

  151.         self.assertEqual(re.sub('x', r'\777', 'x'), '\377')
    152. 

  152. 

  153.         self.assertRaises(re.error, re.sub, 'x', r'\1', 'x')
    154. 

  154.         self.assertRaises(re.error, re.sub, 'x', r'\8', 'x')
    155. 

  155.         self.assertRaises(re.error, re.sub, 'x', r'\9', 'x')
    156. 

  156.         self.assertRaises(re.error, re.sub, 'x', r'\11', 'x')
    157. 

  157.         self.assertRaises(re.error, re.sub, 'x', r'\18', 'x')
    158. 

  158.         self.assertRaises(re.error, re.sub, 'x', r'\1a', 'x')
    159. 

  159.         self.assertRaises(re.error, re.sub, 'x', r'\90', 'x')
    160. 

  160.         self.assertRaises(re.error, re.sub, 'x', r'\99', 'x')
    161. 

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

  162.         self.assertRaises(re.error, re.sub, 'x', r'\11a', 'x')
    163. 

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

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

  165. 

  166.         # in python2.3 (etc), these loop endlessly in sre_parser.py
    167. 

  167.         self.assertEqual(re.sub('(((((((((((x)))))))))))', r'\11', 'x'), 'x')
    168. 

  168.         self.assertEqual(re.sub('((((((((((y))))))))))(.)', r'\118', 'xyz'),
    169. 

  169.                          'xz8')
    170. 

  170.         self.assertEqual(re.sub('((((((((((y))))))))))(.)', r'\11a', 'xyz'),
    171. 

  171.                          'xza')
    172. 

  172. 

  173.     def test_qualified_re_sub(self):
    174. 

  174.         self.assertEqual(re.sub('a', 'b', 'aaaaa'), 'bbbbb')
    175. 

  175.         self.assertEqual(re.sub('a', 'b', 'aaaaa', 1), 'baaaa')
    176. 

  176. 

  177.     def test_bug_114660(self):
    178. 

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

  179.                          'hello there')
    180. 

  180. 

  181.     def test_bug_462270(self):
    182. 

  182.         # Test for empty sub() behaviour, see SF bug #462270
    183. 

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

  184.         self.assertEqual(re.sub('x+', '-', 'abxd'), 'ab-d')
    185. 

  185. 

  186.     def test_symbolic_groups(self):
    187. 

  187.         re.compile('(?P<a>x)(?P=a)(?(a)y)')
    188. 

  188.         re.compile('(?P<a1>x)(?P=a1)(?(a1)y)')
    189. 

  189.         self.assertRaises(re.error, re.compile, '(?P<a>)(?P<a>)')
    190. 

  190.         self.assertRaises(re.error, re.compile, '(?Px)')
    191. 

  191.         self.assertRaises(re.error, re.compile, '(?P=)')
    192. 

  192.         self.assertRaises(re.error, re.compile, '(?P=1)')
    193. 

  193.         self.assertRaises(re.error, re.compile, '(?P=a)')
    194. 

  194.         self.assertRaises(re.error, re.compile, '(?P=a1)')
    195. 

  195.         self.assertRaises(re.error, re.compile, '(?P=a.)')
    196. 

  196.         self.assertRaises(re.error, re.compile, '(?P<)')
    197. 

  197.         self.assertRaises(re.error, re.compile, '(?P<>)')
    198. 

  198.         self.assertRaises(re.error, re.compile, '(?P<1>)')
    199. 

  199.         self.assertRaises(re.error, re.compile, '(?P<a.>)')
    200. 

  200.         self.assertRaises(re.error, re.compile, '(?())')
    201. 

  201.         self.assertRaises(re.error, re.compile, '(?(a))')
    202. 

  202.         self.assertRaises(re.error, re.compile, '(?(1a))')
    203. 

  203.         self.assertRaises(re.error, re.compile, '(?(a.))')
    204. 

  204. 

  205.     def test_symbolic_refs(self):
    206. 

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

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

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

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

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

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

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

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

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

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

  216. 

  217.     def test_re_subn(self):
    218. 

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

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

  220.         self.assertEqual(re.subn("b+", "x", "xyz"), ('xyz', 0))
    221. 

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

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

  223. 

  224.     def test_re_split(self):
    225. 

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

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

  227.         self.assertEqual(re.split("(:*)", ":a:b::c"),
    228. 

  228.                          ['', ':', 'a', ':', 'b', '::', 'c'])
    229. 

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

  230.         self.assertEqual(re.split("(:)*", ":a:b::c"),
    231. 

  231.                          ['', ':', 'a', ':', 'b', ':', 'c'])
    232. 

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

  233.                          ['', ':', 'a', ':b::', 'c'])
    234. 

  234.         self.assertEqual(re.split("(b)|(:+)", ":a:b::c"),
    235. 

  235.                          ['', None, ':', 'a', None, ':', '', 'b', None, '',
    236. 

  236.                           None, '::', 'c'])
    237. 

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

  238.                          ['', 'a', '', '', 'c'])
    239. 

  239. 

  240.     def test_qualified_re_split(self):
    241. 

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

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

  243.         self.assertEqual(re.split("(:)", ":a:b::c", 2),
    244. 

  244.                          ['', ':', 'a', ':', 'b::c'])
    245. 

  245.         self.assertEqual(re.split("(:*)", ":a:b::c", 2),
    246. 

  246.                          ['', ':', 'a', ':', 'b::c'])
    247. 

  247. 

  248.     def test_re_findall(self):
    249. 

  249.         self.assertEqual(re.findall(":+", "abc"), [])
    250. 

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

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

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

  253.                                                                (":", ":"),
    254. 

  254.                                                                (":", "::")])
    255. 

  255. 

  256.     def test_bug_117612(self):
    257. 

  257.         self.assertEqual(re.findall(r"(a|(b))", "aba"),
    258. 

  258.                          [("a", ""),("b", "b"),("a", "")])
    259. 

  259. 

  260.     def test_re_match(self):
    261. 

  261.         self.assertEqual(re.match('a', 'a').groups(), ())
    262. 

  262.         self.assertEqual(re.match('(a)', 'a').groups(), ('a',))
    263. 

  263.         self.assertEqual(re.match(r'(a)', 'a').group(0), 'a')
    264. 

  264.         self.assertEqual(re.match(r'(a)', 'a').group(1), 'a')
    265. 

  265.         self.assertEqual(re.match(r'(a)', 'a').group(1, 1), ('a', 'a'))
    266. 

  266. 

  267.         pat = re.compile('((a)|(b))(c)?')
    268. 

  268.         self.assertEqual(pat.match('a').groups(), ('a', 'a', None, None))
    269. 

  269.         self.assertEqual(pat.match('b').groups(), ('b', None, 'b', None))
    270. 

  270.         self.assertEqual(pat.match('ac').groups(), ('a', 'a', None, 'c'))
    271. 

  271.         self.assertEqual(pat.match('bc').groups(), ('b', None, 'b', 'c'))
    272. 

  272.         self.assertEqual(pat.match('bc').groups(""), ('b', "", 'b', 'c'))
    273. 

  273. 

  274.         # A single group
    275. 

  275.         m = re.match('(a)', 'a')
    276. 

  276.         self.assertEqual(m.group(0), 'a')
    277. 

  277.         self.assertEqual(m.group(0), 'a')
    278. 

  278.         self.assertEqual(m.group(1), 'a')
    279. 

  279.         self.assertEqual(m.group(1, 1), ('a', 'a'))
    280. 

  280. 

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

  282.         self.assertEqual(pat.match('a').group(1, 2, 3), ('a', None, None))
    283. 

  283.         self.assertEqual(pat.match('b').group('a1', 'b2', 'c3'),
    284. 

  284.                          (None, 'b', None))
    285. 

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

  286. 

  287.     def test_re_groupref_exists(self):
    288. 

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

  289.                          ('(', 'a'))
    290. 

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

  291.                          (None, 'a'))
    292. 

  292.         self.assertIsNone(re.match('^(\()?([^()]+)(?(1)\))$', 'a)'))
    293. 

  293.         self.assertIsNone(re.match('^(\()?([^()]+)(?(1)\))$', '(a'))
    294. 

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

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

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

  297.                          (None, 'd'))
    298. 

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

  299.                          (None, 'd'))
    300. 

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

  301.                          ('a', ''))
    302. 

  302. 

  303.         # Tests for bug #1177831: exercise groups other than the first group
    304. 

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

  305.         self.assertEqual(p.match('abc').groups(),
    306. 

  306.                          ('a', 'b', 'c'))
    307. 

  307.         self.assertEqual(p.match('ad').groups(),
    308. 

  308.                          ('a', None, 'd'))
    309. 

  309.         self.assertIsNone(p.match('abd'))
    310. 

  310.         self.assertIsNone(p.match('ac'))
    311. 

  311. 

  312. 

  313.     def test_re_groupref(self):
    314. 

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

  315.                          ('|', 'a'))
    316. 

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

  317.                          (None, 'a'))
    318. 

  318.         self.assertIsNone(re.match(r'^(\|)?([^()]+)\1$', 'a|'))
    319. 

  319.         self.assertIsNone(re.match(r'^(\|)?([^()]+)\1$', '|a'))
    320. 

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

  321.                          ('a', 'a'))
    322. 

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

  323.                          (None, None))
    324. 

  324. 

  325.     def test_groupdict(self):
    326. 

  326.         self.assertEqual(re.match('(?P<first>first) (?P<second>second)',
    327. 

  327.                                   'first second').groupdict(),
    328. 

  328.                          {'first':'first', 'second':'second'})
    329. 

  329. 

  330.     def test_expand(self):
    331. 

  331.         self.assertEqual(re.match("(?P<first>first) (?P<second>second)",
    332. 

  332.                                   "first second")
    333. 

  333.                                   .expand(r"\2 \1 \g<second> \g<first>"),
    334. 

  334.                          "second first second first")
    335. 

  335. 

  336.     def test_repeat_minmax(self):
    337. 

  337.         self.assertIsNone(re.match("^(\w){1}$", "abc"))
    338. 

  338.         self.assertIsNone(re.match("^(\w){1}?$", "abc"))
    339. 

  339.         self.assertIsNone(re.match("^(\w){1,2}$", "abc"))
    340. 

  340.         self.assertIsNone(re.match("^(\w){1,2}?$", "abc"))
    341. 

  341. 

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

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

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

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

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

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

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

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

  350. 

  351.         self.assertIsNone(re.match("^x{1}$", "xxx"))
    352. 

  352.         self.assertIsNone(re.match("^x{1}?$", "xxx"))
    353. 

  353.         self.assertIsNone(re.match("^x{1,2}$", "xxx"))
    354. 

  354.         self.assertIsNone(re.match("^x{1,2}?$", "xxx"))
    355. 

  355. 

  356.         self.assertTrue(re.match("^x{3}$", "xxx"))
    357. 

  357.         self.assertTrue(re.match("^x{1,3}$", "xxx"))
    358. 

  358.         self.assertTrue(re.match("^x{1,4}$", "xxx"))
    359. 

  359.         self.assertTrue(re.match("^x{3,4}?$", "xxx"))
    360. 

  360.         self.assertTrue(re.match("^x{3}?$", "xxx"))
    361. 

  361.         self.assertTrue(re.match("^x{1,3}?$", "xxx"))
    362. 

  362.         self.assertTrue(re.match("^x{1,4}?$", "xxx"))
    363. 

  363.         self.assertTrue(re.match("^x{3,4}?$", "xxx"))
    364. 

  364. 

  365.         self.assertIsNone(re.match("^x{}$", "xxx"))
    366. 

  366.         self.assertTrue(re.match("^x{}$", "x{}"))
    367. 

  367. 

  368.     def test_getattr(self):
    369. 

  369.         self.assertEqual(re.match("(a)", "a").pos, 0)
    370. 

  370.         self.assertEqual(re.match("(a)", "a").endpos, 1)
    371. 

  371.         self.assertEqual(re.match("(a)", "a").string, "a")
    372. 

  372.         self.assertEqual(re.match("(a)", "a").regs, ((0, 1), (0, 1)))
    373. 

  373.         self.assertTrue(re.match("(a)", "a").re)
    374. 

  374. 

  375.     def test_special_escapes(self):
    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"\b(b.)\b",
    381. 

  381.                                    "abcd abc bcd bx", re.LOCALE).group(1), "bx")
    382. 

  382.         self.assertEqual(re.search(r"\B(b.)\B",
    383. 

  383.                                    "abc bcd bc abxd", re.LOCALE).group(1), "bx")
    384. 

  384.         if have_unicode:
    385. 

  385.             self.assertEqual(re.search(r"\b(b.)\b",
    386. 

  386.                                        "abcd abc bcd bx", re.UNICODE).group(1), "bx")
    387. 

  387.             self.assertEqual(re.search(r"\B(b.)\B",
    388. 

  388.                                        "abc bcd bc abxd", re.UNICODE).group(1), "bx")
    389. 

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

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

  391.         self.assertIsNone(re.search(r"^\Aabc\Z$", "\nabc\n", re.M))
    392. 

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

  393.                                    u"abcd abc bcd bx").group(1), "bx")
    394. 

  394.         self.assertEqual(re.search(r"\B(b.)\B",
    395. 

  395.                                    u"abc bcd bc abxd").group(1), "bx")
    396. 

  396.         self.assertEqual(re.search(r"^abc$", u"\nabc\n", re.M).group(0), "abc")
    397. 

  397.         self.assertEqual(re.search(r"^\Aabc\Z$", u"abc", re.M).group(0), "abc")
    398. 

  398.         self.assertIsNone(re.search(r"^\Aabc\Z$", u"\nabc\n", re.M))
    399. 

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

  400.                                    "1aa! a").group(0), "1aa! a")
    401. 

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

  402.                                    "1aa! a", re.LOCALE).group(0), "1aa! a")
    403. 

  403.         if have_unicode:
    404. 

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

  405.                                        "1aa! a", re.UNICODE).group(0), "1aa! a")
    406. 

  406. 

  407.     def test_string_boundaries(self):
    408. 

  408.         # See http://bugs.python.org/issue10713
    409. 

  409.         self.assertEqual(re.search(r"\b(abc)\b", "abc").group(1),
    410. 

  410.                          "abc")
    411. 

  411.         # There's a word boundary at the start of a string.
    412. 

  412.         self.assertTrue(re.match(r"\b", "abc"))
    413. 

  413.         # A non-empty string includes a non-boundary zero-length match.
    414. 

  414.         self.assertTrue(re.search(r"\B", "abc"))
    415. 

  415.         # There is no non-boundary match at the start of a string.
    416. 

  416.         self.assertFalse(re.match(r"\B", "abc"))
    417. 

  417.         # However, an empty string contains no word boundaries, and also no
    418. 

  418.         # non-boundaries.
    419. 

  419.         self.assertIsNone(re.search(r"\B", ""))
    420. 

  420.         # This one is questionable and different from the perlre behaviour,
    421. 

  421.         # but describes current behavior.
    422. 

  422.         self.assertIsNone(re.search(r"\b", ""))
    423. 

  423.         # A single word-character string has two boundaries, but no
    424. 

  424.         # non-boundary gaps.
    425. 

  425.         self.assertEqual(len(re.findall(r"\b", "a")), 2)
    426. 

  426.         self.assertEqual(len(re.findall(r"\B", "a")), 0)
    427. 

  427.         # If there are no words, there are no boundaries
    428. 

  428.         self.assertEqual(len(re.findall(r"\b", " ")), 0)
    429. 

  429.         self.assertEqual(len(re.findall(r"\b", "   ")), 0)
    430. 

  430.         # Can match around the whitespace.
    431. 

  431.         self.assertEqual(len(re.findall(r"\B", " ")), 2)
    432. 

  432. 

  433.     @requires_unicode
    434. 

  434.     def test_bigcharset(self):
    435. 

  435.         self.assertEqual(re.match(u(r"([\u2222\u2223])"),
    436. 

  436.                                   unichr(0x2222)).group(1), unichr(0x2222))
    437. 

  437.         self.assertEqual(re.match(u(r"([\u2222\u2223])"),
    438. 

  438.                                   unichr(0x2222), re.UNICODE).group(1), unichr(0x2222))
    439. 

  439.         r = u'[%s]' % u''.join(map(unichr, range(256, 2**16, 255)))
    440. 

  440.         self.assertEqual(re.match(r, unichr(0xff01), re.UNICODE).group(), unichr(0xff01))
    441. 

  441. 

  442.     def test_big_codesize(self):
    443. 

  443.         # Issue #1160
    444. 

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

  445.         self.assertTrue(r.match('1000'))
    446. 

  446.         self.assertTrue(r.match('9999'))
    447. 

  447. 

  448.     def test_anyall(self):
    449. 

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

  450.                          "a\nb")
    451. 

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

  452.                          "a\n\nb")
    453. 

  453. 

  454.     def test_lookahead(self):
    455. 

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

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

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

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

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

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

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

  462. 

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

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

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

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

  467. 

  468.         # Group reference.
    469. 

  469.         self.assertTrue(re.match(r'(a)b(?=\1)a', 'aba'))
    470. 

  470.         self.assertIsNone(re.match(r'(a)b(?=\1)c', 'abac'))
    471. 

  471.         # Named group reference.
    472. 

  472.         self.assertTrue(re.match(r'(?P<g>a)b(?=(?P=g))a', 'aba'))
    473. 

  473.         self.assertIsNone(re.match(r'(?P<g>a)b(?=(?P=g))c', 'abac'))
    474. 

  474.         # Conditional group reference.
    475. 

  475.         self.assertTrue(re.match(r'(?:(a)|(x))b(?=(?(2)x|c))c', 'abc'))
    476. 

  476.         self.assertIsNone(re.match(r'(?:(a)|(x))b(?=(?(2)c|x))c', 'abc'))
    477. 

  477.         self.assertTrue(re.match(r'(?:(a)|(x))b(?=(?(2)x|c))c', 'abc'))
    478. 

  478.         self.assertIsNone(re.match(r'(?:(a)|(x))b(?=(?(1)b|x))c', 'abc'))
    479. 

  479.         self.assertTrue(re.match(r'(?:(a)|(x))b(?=(?(1)c|x))c', 'abc'))
    480. 

  480.         # Group used before defined.
    481. 

  481.         self.assertTrue(re.match(r'(a)b(?=(?(2)x|c))(c)', 'abc'))
    482. 

  482.         self.assertIsNone(re.match(r'(a)b(?=(?(2)b|x))(c)', 'abc'))
    483. 

  483.         self.assertTrue(re.match(r'(a)b(?=(?(1)c|x))(c)', 'abc'))
    484. 

  484. 

  485.     def test_lookbehind(self):
    486. 

  486.         self.assertTrue(re.match(r'ab(?<=b)c', 'abc'))
    487. 

  487.         self.assertIsNone(re.match(r'ab(?<=c)c', 'abc'))
    488. 

  488.         self.assertIsNone(re.match(r'ab(?<!b)c', 'abc'))
    489. 

  489.         self.assertTrue(re.match(r'ab(?<!c)c', 'abc'))
    490. 

  490.         # Group reference.
    491. 

  491.         with check_warnings(('', RuntimeWarning)):
    492. 

  492.             re.compile(r'(a)a(?<=\1)c')
    493. 

  493.         # Named group reference.
    494. 

  494.         with check_warnings(('', RuntimeWarning)):
    495. 

  495.             re.compile(r'(?P<g>a)a(?<=(?P=g))c')
    496. 

  496.         # Conditional group reference.
    497. 

  497.         with check_warnings(('', RuntimeWarning)):
    498. 

  498.             re.compile(r'(a)b(?<=(?(1)b|x))c')
    499. 

  499.         # Group used before defined.
    500. 

  500.         with check_warnings(('', RuntimeWarning)):
    501. 

  501.             re.compile(r'(a)b(?<=(?(2)b|x))(c)')
    502. 

  502. 

  503.     def test_ignore_case(self):
    504. 

  504.         self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
    505. 

  505.         self.assertEqual(re.match("abc", u"ABC", re.I).group(0), "ABC")
    506. 

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

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

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

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

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

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

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

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

  514. 

  515.         if have_unicode:
    516. 

  516.             assert u(r'\u212a').lower() == u'k' # 'K'
    517. 

  517.             self.assertTrue(re.match(ur'K', u(r'\u212a'), re.U | re.I))
    518. 

  518.             self.assertTrue(re.match(ur'k', u(r'\u212a'), re.U | re.I))
    519. 

  519.             self.assertTrue(re.match(u(r'\u212a'), u'K', re.U | re.I))
    520. 

  520.             self.assertTrue(re.match(u(r'\u212a'), u'k', re.U | re.I))
    521. 

  521.             assert u(r'\u017f').upper() == u'S' # 'ſ'
    522. 

  522.             self.assertTrue(re.match(ur'S', u(r'\u017f'), re.U | re.I))
    523. 

  523.             self.assertTrue(re.match(ur's', u(r'\u017f'), re.U | re.I))
    524. 

  524.             self.assertTrue(re.match(u(r'\u017f'), u'S', re.U | re.I))
    525. 

  525.             self.assertTrue(re.match(u(r'\u017f'), u's', re.U | re.I))
    526. 

  526. 

  527.     def test_ignore_case_set(self):
    528. 

  528.         self.assertTrue(re.match(r'[19A]', 'A', re.I))
    529. 

  529.         self.assertTrue(re.match(r'[19a]', 'a', re.I))
    530. 

  530.         self.assertTrue(re.match(r'[19a]', 'A', re.I))
    531. 

  531.         self.assertTrue(re.match(r'[19A]', 'a', re.I))
    532. 

  532.         if have_unicode:
    533. 

  533.             self.assertTrue(re.match(ur'[19A]', u'A', re.U | re.I))
    534. 

  534.             self.assertTrue(re.match(ur'[19a]', u'a', re.U | re.I))
    535. 

  535.             self.assertTrue(re.match(ur'[19a]', u'A', re.U | re.I))
    536. 

  536.             self.assertTrue(re.match(ur'[19A]', u'a', re.U | re.I))
    537. 

  537.             assert u(r'\u212a').lower() == u'k' # 'K'
    538. 

  538.             self.assertTrue(re.match(u(r'[19K]'), u(r'\u212a'), re.U | re.I))
    539. 

  539.             self.assertTrue(re.match(u(r'[19k]'), u(r'\u212a'), re.U | re.I))
    540. 

  540.             self.assertTrue(re.match(u(r'[19\u212a]'), u'K', re.U | re.I))
    541. 

  541.             self.assertTrue(re.match(u(r'[19\u212a]'), u'k', re.U | re.I))
    542. 

  542.             assert u(r'\u017f').upper() == u'S' # 'ſ'
    543. 

  543.             self.assertTrue(re.match(ur'[19S]', u(r'\u017f'), re.U | re.I))
    544. 

  544.             self.assertTrue(re.match(ur'[19s]', u(r'\u017f'), re.U | re.I))
    545. 

  545.             self.assertTrue(re.match(u(r'[19\u017f]'), u'S', re.U | re.I))
    546. 

  546.             self.assertTrue(re.match(u(r'[19\u017f]'), u's', re.U | re.I))
    547. 

  547. 

  548.     def test_ignore_case_range(self):
    549. 

  549.         # Issues #3511, #17381.
    550. 

  550.         self.assertTrue(re.match(r'[9-a]', '_', re.I))
    551. 

  551.         self.assertIsNone(re.match(r'[9-A]', '_', re.I))
    552. 

  552.         self.assertTrue(re.match(r'[\xc0-\xde]', '\xd7', re.I))
    553. 

  553.         self.assertIsNone(re.match(r'[\xc0-\xde]', '\xf7', re.I))
    554. 

  554.         self.assertTrue(re.match(r'[\xe0-\xfe]', '\xf7',re.I))
    555. 

  555.         self.assertIsNone(re.match(r'[\xe0-\xfe]', '\xd7', re.I))
    556. 

  556.         if have_unicode:
    557. 

  557.             self.assertTrue(re.match(u(r'[9-a]'), u(r'_'), re.U | re.I))
    558. 

  558.             self.assertIsNone(re.match(u(r'[9-A]'), u(r'_'), re.U | re.I))
    559. 

  559.             self.assertTrue(re.match(u(r'[\xc0-\xde]'),
    560. 

  560.                                      u(r'\xd7'), re.U | re.I))
    561. 

  561.             self.assertIsNone(re.match(u(r'[\xc0-\xde]'),
    562. 

  562.                                        u(r'\xf7'), re.U | re.I))
    563. 

  563.             self.assertTrue(re.match(u(r'[\xe0-\xfe]'),
    564. 

  564.                                      u(r'\xf7'), re.U | re.I))
    565. 

  565.             self.assertIsNone(re.match(u(r'[\xe0-\xfe]'),
    566. 

  566.                                        u(r'\xd7'), re.U | re.I))
    567. 

  567.             self.assertTrue(re.match(u(r'[\u0430-\u045f]'),
    568. 

  568.                                      u(r'\u0450'), re.U | re.I))
    569. 

  569.             self.assertTrue(re.match(u(r'[\u0430-\u045f]'),
    570. 

  570.                                      u(r'\u0400'), re.U | re.I))
    571. 

  571.             self.assertTrue(re.match(u(r'[\u0400-\u042f]'),
    572. 

  572.                                      u(r'\u0450'), re.U | re.I))
    573. 

  573.             self.assertTrue(re.match(u(r'[\u0400-\u042f]'),
    574. 

  574.                                      u(r'\u0400'), re.U | re.I))
    575. 

  575.             if sys.maxunicode > 0xffff:
    576. 

  576.                 self.assertTrue(re.match(u(r'[\U00010428-\U0001044f]'),
    577. 

  577.                                          u(r'\U00010428'), re.U | re.I))
    578. 

  578.                 self.assertTrue(re.match(u(r'[\U00010428-\U0001044f]'),
    579. 

  579.                                          u(r'\U00010400'), re.U | re.I))
    580. 

  580.                 self.assertTrue(re.match(u(r'[\U00010400-\U00010427]'),
    581. 

  581.                                          u(r'\U00010428'), re.U | re.I))
    582. 

  582.                 self.assertTrue(re.match(u(r'[\U00010400-\U00010427]'),
    583. 

  583.                                          u(r'\U00010400'), re.U | re.I))
    584. 

  584. 

  585.             assert u(r'\u212a').lower() == u'k' # 'K'
    586. 

  586.             self.assertTrue(re.match(ur'[J-M]', u(r'\u212a'), re.U | re.I))
    587. 

  587.             self.assertTrue(re.match(ur'[j-m]', u(r'\u212a'), re.U | re.I))
    588. 

  588.             self.assertTrue(re.match(u(r'[\u2129-\u212b]'), u'K', re.U | re.I))
    589. 

  589.             self.assertTrue(re.match(u(r'[\u2129-\u212b]'), u'k', re.U | re.I))
    590. 

  590.             assert u(r'\u017f').upper() == u'S' # 'ſ'
    591. 

  591.             self.assertTrue(re.match(ur'[R-T]', u(r'\u017f'), re.U | re.I))
    592. 

  592.             self.assertTrue(re.match(ur'[r-t]', u(r'\u017f'), re.U | re.I))
    593. 

  593.             self.assertTrue(re.match(u(r'[\u017e-\u0180]'), u'S', re.U | re.I))
    594. 

  594.             self.assertTrue(re.match(u(r'[\u017e-\u0180]'), u's', re.U | re.I))
    595. 

  595. 

  596.     def test_category(self):
    597. 

  597.         self.assertEqual(re.match(r"(\s)", " ").group(1), " ")
    598. 

  598. 

  599.     def test_getlower(self):
    600. 

  600.         import _sre
    601. 

  601.         self.assertEqual(_sre.getlower(ord('A'), 0), ord('a'))
    602. 

  602.         self.assertEqual(_sre.getlower(ord('A'), re.LOCALE), ord('a'))
    603. 

  603.         if have_unicode:
    604. 

  604.             self.assertEqual(_sre.getlower(ord('A'), re.UNICODE), ord('a'))
    605. 

  605. 

  606.         self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
    607. 

  607.         self.assertEqual(re.match("abc", u"ABC", re.I).group(0), "ABC")
    608. 

  608. 

  609.     def test_not_literal(self):
    610. 

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

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

  612. 

  613.     def test_search_coverage(self):
    614. 

  614.         self.assertEqual(re.search("\s(b)", " b").group(1), "b")
    615. 

  615.         self.assertEqual(re.search("a\s", "a ").group(0), "a ")
    616. 

  616. 

  617.     def assertMatch(self, pattern, text, match=None, span=None,
    618. 

  618.                     matcher=re.match):
    619. 

  619.         if match is None and span is None:
    620. 

  620.             # the pattern matches the whole text
    621. 

  621.             match = text
    622. 

  622.             span = (0, len(text))
    623. 

  623.         elif match is None or span is None:
    624. 

  624.             raise ValueError('If match is not None, span should be specified '
    625. 

  625.                              '(and vice versa).')
    626. 

  626.         m = matcher(pattern, text)
    627. 

  627.         self.assertTrue(m)
    628. 

  628.         self.assertEqual(m.group(), match)
    629. 

  629.         self.assertEqual(m.span(), span)
    630. 

  630. 

  631.     @requires_unicode
    632. 

  632.     def test_re_escape(self):
    633. 

  633.         alnum_chars = unicode(string.ascii_letters + string.digits)
    634. 

  634.         p = u''.join(unichr(i) for i in range(256))
    635. 

  635.         for c in p:
    636. 

  636.             if c in alnum_chars:
    637. 

  637.                 self.assertEqual(re.escape(c), c)
    638. 

  638.             elif c == u'\x00':
    639. 

  639.                 self.assertEqual(re.escape(c), u'\\000')
    640. 

  640.             else:
    641. 

  641.                 self.assertEqual(re.escape(c), u'\\' + c)
    642. 

  642.             self.assertMatch(re.escape(c), c)
    643. 

  643.         self.assertMatch(re.escape(p), p)
    644. 

  644. 

  645.     def test_re_escape_byte(self):
    646. 

  646.         alnum_chars = string.ascii_letters + string.digits
    647. 

  647.         p = ''.join(chr(i) for i in range(256))
    648. 

  648.         for b in p:
    649. 

  649.             if b in alnum_chars:
    650. 

  650.                 self.assertEqual(re.escape(b), b)
    651. 

  651.             elif b == b'\x00':
    652. 

  652.                 self.assertEqual(re.escape(b), b'\\000')
    653. 

  653.             else:
    654. 

  654.                 self.assertEqual(re.escape(b), b'\\' + b)
    655. 

  655.             self.assertMatch(re.escape(b), b)
    656. 

  656.         self.assertMatch(re.escape(p), p)
    657. 

  657. 

  658.     @requires_unicode
    659. 

  659.     def test_re_escape_non_ascii(self):
    660. 

  660.         s = u(r'xxx\u2620\u2620\u2620xxx')
    661. 

  661.         s_escaped = re.escape(s)
    662. 

  662.         self.assertEqual(s_escaped, u(r'xxx\\\u2620\\\u2620\\\u2620xxx'))
    663. 

  663.         self.assertMatch(s_escaped, s)
    664. 

  664.         self.assertMatch(u'.%s+.' % re.escape(unichr(0x2620)), s,
    665. 

  665.                          u(r'x\u2620\u2620\u2620x'), (2, 7), re.search)
    666. 

  666. 

  667.     def test_re_escape_non_ascii_bytes(self):
    668. 

  668.         b = b'y\xe2\x98\xa0y\xe2\x98\xa0y'
    669. 

  669.         b_escaped = re.escape(b)
    670. 

  670.         self.assertEqual(b_escaped, b'y\\\xe2\\\x98\\\xa0y\\\xe2\\\x98\\\xa0y')
    671. 

  671.         self.assertMatch(b_escaped, b)
    672. 

  672.         res = re.findall(re.escape(b'\xe2\x98\xa0'), b)
    673. 

  673.         self.assertEqual(len(res), 2)
    674. 

  674. 

  675.     def test_pickling(self):
    676. 

  676.         import pickle
    677. 

  677.         self.pickle_test(pickle)
    678. 

  678.         import cPickle
    679. 

  679.         self.pickle_test(cPickle)
    680. 

  680.         # old pickles expect the _compile() reconstructor in sre module
    681. 

  681.         import_module("sre", deprecated=True)
    682. 

  682.         from sre import _compile
    683. 

  683.         # current pickle expects the _compile() reconstructor in re module
    684. 

  684.         from re import _compile
    685. 

  685. 

  686.     def pickle_test(self, pickle):
    687. 

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

  688.         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
    689. 

  689.             pickled = pickle.dumps(oldpat, proto)
    690. 

  690.             newpat = pickle.loads(pickled)
    691. 

  691.             self.assertEqual(newpat, oldpat)
    692. 

  692. 

  693.     def test_constants(self):
    694. 

  694.         self.assertEqual(re.I, re.IGNORECASE)
    695. 

  695.         self.assertEqual(re.L, re.LOCALE)
    696. 

  696.         self.assertEqual(re.M, re.MULTILINE)
    697. 

  697.         self.assertEqual(re.S, re.DOTALL)
    698. 

  698.         self.assertEqual(re.X, re.VERBOSE)
    699. 

  699. 

  700.     def test_flags(self):
    701. 

  701.         for flag in [re.I, re.M, re.X, re.S, re.L]:
    702. 

  702.             self.assertTrue(re.compile('^pattern$', flag))
    703. 

  703. 

  704.     def test_sre_character_literals(self):
    705. 

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

  706.             self.assertTrue(re.match(r"\%03o" % i, chr(i)))
    707. 

  707.             self.assertTrue(re.match(r"\%03o0" % i, chr(i)+"0"))
    708. 

  708.             self.assertTrue(re.match(r"\%03o8" % i, chr(i)+"8"))
    709. 

  709.             self.assertTrue(re.match(r"\x%02x" % i, chr(i)))
    710. 

  710.             self.assertTrue(re.match(r"\x%02x0" % i, chr(i)+"0"))
    711. 

  711.             self.assertTrue(re.match(r"\x%02xz" % i, chr(i)+"z"))
    712. 

  712.         self.assertRaises(re.error, re.match, "\911", "")
    713. 

  713. 

  714.     def test_sre_character_class_literals(self):
    715. 

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

  716.             self.assertTrue(re.match(r"[\%03o]" % i, chr(i)))
    717. 

  717.             self.assertTrue(re.match(r"[\%03o0]" % i, chr(i)))
    718. 

  718.             self.assertTrue(re.match(r"[\%03o8]" % i, chr(i)))
    719. 

  719.             self.assertTrue(re.match(r"[\x%02x]" % i, chr(i)))
    720. 

  720.             self.assertTrue(re.match(r"[\x%02x0]" % i, chr(i)))
    721. 

  721.             self.assertTrue(re.match(r"[\x%02xz]" % i, chr(i)))
    722. 

  722.         self.assertRaises(re.error, re.match, "[\911]", "")
    723. 

  723. 

  724.     def test_bug_113254(self):
    725. 

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

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

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

  728. 

  729.     def test_bug_527371(self):
    730. 

  730.         # bug described in patches 527371/672491
    731. 

  731.         self.assertIsNone(re.match(r'(a)?a','a').lastindex)
    732. 

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

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

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

  735.         self.assertEqual(re.match("((a))", "a").lastindex, 1)
    736. 

  736. 

  737.     def test_bug_545855(self):
    738. 

  738.         # bug 545855 -- This pattern failed to cause a compile error as it
    739. 

  739.         # should, instead provoking a TypeError.
    740. 

  740.         self.assertRaises(re.error, re.compile, 'foo[a-')
    741. 

  741. 

  742.     def test_bug_418626(self):
    743. 

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

  744.         # SRE_OP_MIN_REPEAT_ONE for eliminating recursion on simple uses of
    745. 

  745.         # pattern '*?' on a long string.
    746. 

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

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

  748.                          20003)
    749. 

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

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

  751.         # non-recursive scheme was implemented.
    752. 

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

  753. 

  754.     @requires_unicode
    755. 

  755.     def test_bug_612074(self):
    756. 

  756.         pat=u"["+re.escape(unichr(0x2039))+u"]"
    757. 

  757.         self.assertEqual(re.compile(pat) and 1, 1)
    758. 

  758. 

  759.     def test_stack_overflow(self):
    760. 

  760.         # nasty cases that used to overflow the straightforward recursive
    761. 

  761.         # implementation of repeated groups.
    762. 

  762.         self.assertEqual(re.match('(x)*', 50000*'x').group(1), 'x')
    763. 

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

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

  765. 

  766.     def test_unlimited_zero_width_repeat(self):
    767. 

  767.         # Issue #9669
    768. 

  768.         self.assertIsNone(re.match(r'(?:a?)*y', 'z'))
    769. 

  769.         self.assertIsNone(re.match(r'(?:a?)+y', 'z'))
    770. 

  770.         self.assertIsNone(re.match(r'(?:a?){2,}y', 'z'))
    771. 

  771.         self.assertIsNone(re.match(r'(?:a?)*?y', 'z'))
    772. 

  772.         self.assertIsNone(re.match(r'(?:a?)+?y', 'z'))
    773. 

  773.         self.assertIsNone(re.match(r'(?:a?){2,}?y', 'z'))
    774. 

  774. 

  775.     def test_scanner(self):
    776. 

  776.         def s_ident(scanner, token): return token
    777. 

  777.         def s_operator(scanner, token): return "op%s" % token
    778. 

  778.         def s_float(scanner, token): return float(token)
    779. 

  779.         def s_int(scanner, token): return int(token)
    780. 

  780. 

  781.         scanner = Scanner([
    782. 

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

  783.             (r"\d+\.\d*", s_float),
    784. 

  784.             (r"\d+", s_int),
    785. 

  785.             (r"=|\+|-|\*|/", s_operator),
    786. 

  786.             (r"\s+", None),
    787. 

  787.             ])
    788. 

  788. 

  789.         self.assertTrue(scanner.scanner.scanner("").pattern)
    790. 

  790. 

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

  792.                          (['sum', 'op=', 3, 'op*', 'foo', 'op+', 312.5,
    793. 

  793.                            'op+', 'bar'], ''))
    794. 

  794. 

  795.     def test_bug_448951(self):
    796. 

  796.         # bug 448951 (similar to 429357, but with single char match)
    797. 

  797.         # (Also test greedy matches.)
    798. 

  798.         for op in '','?','*':
    799. 

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

  800.                              (None, None))
    801. 

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

  802.                              ('a:', 'a'))
    803. 

  803. 

  804.     def test_bug_725106(self):
    805. 

  805.         # capturing groups in alternatives in repeats
    806. 

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

  807.                          ('b', 'a'))
    808. 

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

  809.                          ('c', 'b'))
    810. 

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

  811.                          ('b', None))
    812. 

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

  813.                          ('b', None))
    814. 

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

  815.                          ('b', 'a'))
    816. 

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

  817.                          ('c', 'b'))
    818. 

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

  819.                          ('b', None))
    820. 

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

  821.                          ('b', None))
    822. 

  822. 

  823.     def test_bug_725149(self):
    824. 

  824.         # mark_stack_base restoring before restoring marks
    825. 

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

  826.                          ('a', None))
    827. 

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

  828.                          ('a', None, None))
    829. 

  829. 

  830.     @requires_unicode
    831. 

  831.     def test_bug_764548(self):
    832. 

  832.         # bug 764548, re.compile() barfs on str/unicode subclasses
    833. 

  833.         class my_unicode(unicode): pass
    834. 

  834.         pat = re.compile(my_unicode("abc"))
    835. 

  835.         self.assertIsNone(pat.match("xyz"))
    836. 

  836. 

  837.     def test_finditer(self):
    838. 

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

  839.         self.assertEqual([item.group(0) for item in iter],
    840. 

  840.                          [":", "::", ":::"])
    841. 

  841. 

  842.     @requires_unicode
    843. 

  843.     def test_bug_926075(self):
    844. 

  844.         self.assertIsNot(re.compile('bug_926075'),
    845. 

  845.                          re.compile(u'bug_926075'))
    846. 

  846. 

  847.     @requires_unicode
    848. 

  848.     def test_bug_931848(self):
    849. 

  849.         pattern = u(r"[\u002E\u3002\uFF0E\uFF61]")
    850. 

  850.         self.assertEqual(re.compile(pattern).split("a.b.c"),
    851. 

  851.                          ['a','b','c'])
    852. 

  852. 

  853.     def test_bug_581080(self):
    854. 

  854.         iter = re.finditer(r"\s", "a b")
    855. 

  855.         self.assertEqual(iter.next().span(), (1,2))
    856. 

  856.         self.assertRaises(StopIteration, iter.next)
    857. 

  857. 

  858.         scanner = re.compile(r"\s").scanner("a b")
    859. 

  859.         self.assertEqual(scanner.search().span(), (1, 2))
    860. 

  860.         self.assertIsNone(scanner.search())
    861. 

  861. 

  862.     def test_bug_817234(self):
    863. 

  863.         iter = re.finditer(r".*", "asdf")
    864. 

  864.         self.assertEqual(iter.next().span(), (0, 4))
    865. 

  865.         self.assertEqual(iter.next().span(), (4, 4))
    866. 

  866.         self.assertRaises(StopIteration, iter.next)
    867. 

  867. 

  868.     @requires_unicode
    869. 

  869.     def test_bug_6561(self):
    870. 

  870.         # '\d' should match characters in Unicode category 'Nd'
    871. 

  871.         # (Number, Decimal Digit), but not those in 'Nl' (Number,
    872. 

  872.         # Letter) or 'No' (Number, Other).
    873. 

  873.         decimal_digits = [
    874. 

  874.             unichr(0x0037), # '\N{DIGIT SEVEN}', category 'Nd'
    875. 

  875.             unichr(0x0e58), # '\N{THAI DIGIT SIX}', category 'Nd'
    876. 

  876.             unichr(0xff10), # '\N{FULLWIDTH DIGIT ZERO}', category 'Nd'
    877. 

  877.             ]
    878. 

  878.         for x in decimal_digits:
    879. 

  879.             self.assertEqual(re.match('^\d$', x, re.UNICODE).group(0), x)
    880. 

  880. 

  881.         not_decimal_digits = [
    882. 

  882.             unichr(0x2165), # '\N{ROMAN NUMERAL SIX}', category 'Nl'
    883. 

  883.             unichr(0x3039), # '\N{HANGZHOU NUMERAL TWENTY}', category 'Nl'
    884. 

  884.             unichr(0x2082), # '\N{SUBSCRIPT TWO}', category 'No'
    885. 

  885.             unichr(0x32b4), # '\N{CIRCLED NUMBER THIRTY NINE}', category 'No'
    886. 

  886.             ]
    887. 

  887.         for x in not_decimal_digits:
    888. 

  888.             self.assertIsNone(re.match('^\d$', x, re.UNICODE))
    889. 

  889. 

  890.     def test_empty_array(self):
    891. 

  891.         # SF buf 1647541
    892. 

  892.         import array
    893. 

  893.         typecodes = 'cbBhHiIlLfd'
    894. 

  894.         if have_unicode:
    895. 

  895.             typecodes += 'u'
    896. 

  896.         for typecode in typecodes:
    897. 

  897.             a = array.array(typecode)
    898. 

  898.             self.assertIsNone(re.compile("bla").match(a))
    899. 

  899.             self.assertEqual(re.compile("").match(a).groups(), ())
    900. 

  900. 

  901.     @requires_unicode
    902. 

  902.     def test_inline_flags(self):
    903. 

  903.         # Bug #1700
    904. 

  904.         upper_char = unichr(0x1ea0) # Latin Capital Letter A with Dot Bellow
    905. 

  905.         lower_char = unichr(0x1ea1) # Latin Small Letter A with Dot Bellow
    906. 

  906. 

  907.         p = re.compile(upper_char, re.I | re.U)
    908. 

  908.         q = p.match(lower_char)
    909. 

  909.         self.assertTrue(q)
    910. 

  910. 

  911.         p = re.compile(lower_char, re.I | re.U)
    912. 

  912.         q = p.match(upper_char)
    913. 

  913.         self.assertTrue(q)
    914. 

  914. 

  915.         p = re.compile('(?i)' + upper_char, re.U)
    916. 

  916.         q = p.match(lower_char)
    917. 

  917.         self.assertTrue(q)
    918. 

  918. 

  919.         p = re.compile('(?i)' + lower_char, re.U)
    920. 

  920.         q = p.match(upper_char)
    921. 

  921.         self.assertTrue(q)
    922. 

  922. 

  923.         p = re.compile('(?iu)' + upper_char)
    924. 

  924.         q = p.match(lower_char)
    925. 

  925.         self.assertTrue(q)
    926. 

  926. 

  927.         p = re.compile('(?iu)' + lower_char)
    928. 

  928.         q = p.match(upper_char)
    929. 

  929.         self.assertTrue(q)
    930. 

  930. 

  931.     def test_dollar_matches_twice(self):
    932. 

  932.         "$ matches the end of string, and just before the terminating \n"
    933. 

  933.         pattern = re.compile('$')
    934. 

  934.         self.assertEqual(pattern.sub('#', 'a\nb\n'), 'a\nb#\n#')
    935. 

  935.         self.assertEqual(pattern.sub('#', 'a\nb\nc'), 'a\nb\nc#')
    936. 

  936.         self.assertEqual(pattern.sub('#', '\n'), '#\n#')
    937. 

  937. 

  938.         pattern = re.compile('$', re.MULTILINE)
    939. 

  939.         self.assertEqual(pattern.sub('#', 'a\nb\n' ), 'a#\nb#\n#' )
    940. 

  940.         self.assertEqual(pattern.sub('#', 'a\nb\nc'), 'a#\nb#\nc#')
    941. 

  941.         self.assertEqual(pattern.sub('#', '\n'), '#\n#')
    942. 

  942. 

  943.     def test_dealloc(self):
    944. 

  944.         # issue 3299: check for segfault in debug build
    945. 

  945.         import _sre
    946. 

  946.         # the overflow limit is different on wide and narrow builds and it
    947. 

  947.         # depends on the definition of SRE_CODE (see sre.h).
    948. 

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

  949.         # a RuntimeError is raised instead of OverflowError.
    950. 

  950.         long_overflow = 2**128
    951. 

  951.         self.assertRaises(TypeError, re.finditer, "a", {})
    952. 

  952.         self.assertRaises(OverflowError, _sre.compile, "abc", 0, [long_overflow])
    953. 

  953. 

  954.     def test_compile(self):
    955. 

  955.         # Test return value when given string and pattern as parameter
    956. 

  956.         pattern = re.compile('random pattern')
    957. 

  957.         self.assertIsInstance(pattern, re._pattern_type)
    958. 

  958.         same_pattern = re.compile(pattern)
    959. 

  959.         self.assertIsInstance(same_pattern, re._pattern_type)
    960. 

  960.         self.assertIs(same_pattern, pattern)
    961. 

  961.         # Test behaviour when not given a string or pattern as parameter
    962. 

  962.         self.assertRaises(TypeError, re.compile, 0)
    963. 

  963. 

  964.     def test_bug_13899(self):
    965. 

  965.         # Issue #13899: re pattern r"[\A]" should work like "A" but matches
    966. 

  966.         # nothing. Ditto B and Z.
    967. 

  967.         self.assertEqual(re.findall(r'[\A\B\b\C\Z]', 'AB\bCZ'),
    968. 

  968.                          ['A', 'B', '\b', 'C', 'Z'])
    969. 

  969. 

  970.     @precisionbigmemtest(size=_2G, memuse=1)
    971. 

  971.     def test_large_search(self, size):
    972. 

  972.         # Issue #10182: indices were 32-bit-truncated.
    973. 

  973.         s = 'a' * size
    974. 

  974.         m = re.search('$', s)
    975. 

  975.         self.assertIsNotNone(m)
    976. 

  976.         self.assertEqual(m.start(), size)
    977. 

  977.         self.assertEqual(m.end(), size)
    978. 

  978. 

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

  980.     # to create the replacement result.
    981. 

  981.     @precisionbigmemtest(size=_2G, memuse=16 + 2)
    982. 

  982.     def test_large_subn(self, size):
    983. 

  983.         # Issue #10182: indices were 32-bit-truncated.
    984. 

  984.         s = 'a' * size
    985. 

  985.         r, n = re.subn('', '', s)
    986. 

  986.         self.assertEqual(r, s)
    987. 

  987.         self.assertEqual(n, size + 1)
    988. 

  988. 

  989. 

  990.     def test_repeat_minmax_overflow(self):
    991. 

  991.         # Issue #13169
    992. 

  992.         string = "x" * 100000
    993. 

  993.         self.assertEqual(re.match(r".{65535}", string).span(), (0, 65535))
    994. 

  994.         self.assertEqual(re.match(r".{,65535}", string).span(), (0, 65535))
    995. 

  995.         self.assertEqual(re.match(r".{65535,}?", string).span(), (0, 65535))
    996. 

  996.         self.assertEqual(re.match(r".{65536}", string).span(), (0, 65536))
    997. 

  997.         self.assertEqual(re.match(r".{,65536}", string).span(), (0, 65536))
    998. 

  998.         self.assertEqual(re.match(r".{65536,}?", string).span(), (0, 65536))
    999. 

  999.         # 2**128 should be big enough to overflow both SRE_CODE and Py_ssize_t.
    1000. 

  1000.         self.assertRaises(OverflowError, re.compile, r".{%d}" % 2**128)
    1001. 

  1001.         self.assertRaises(OverflowError, re.compile, r".{,%d}" % 2**128)
    1002. 

  1002.         self.assertRaises(OverflowError, re.compile, r".{%d,}?" % 2**128)
    1003. 

  1003.         self.assertRaises(OverflowError, re.compile, r".{%d,%d}" % (2**129, 2**128))
    1004. 

  1004. 

  1005.     @cpython_only
    1006. 

  1006.     def test_repeat_minmax_overflow_maxrepeat(self):
    1007. 

  1007.         try:
    1008. 

  1008.             from _sre import MAXREPEAT
    1009. 

  1009.         except ImportError:
    1010. 

  1010.             self.skipTest('requires _sre.MAXREPEAT constant')
    1011. 

  1011.         string = "x" * 100000
    1012. 

  1012.         self.assertIsNone(re.match(r".{%d}" % (MAXREPEAT - 1), string))
    1013. 

  1013.         self.assertEqual(re.match(r".{,%d}" % (MAXREPEAT - 1), string).span(),
    1014. 

  1014.                          (0, 100000))
    1015. 

  1015.         self.assertIsNone(re.match(r".{%d,}?" % (MAXREPEAT - 1), string))
    1016. 

  1016.         self.assertRaises(OverflowError, re.compile, r".{%d}" % MAXREPEAT)
    1017. 

  1017.         self.assertRaises(OverflowError, re.compile, r".{,%d}" % MAXREPEAT)
    1018. 

  1018.         self.assertRaises(OverflowError, re.compile, r".{%d,}?" % MAXREPEAT)
    1019. 

  1019. 

  1020.     def test_backref_group_name_in_exception(self):
    1021. 

  1021.         # Issue 17341: Poor error message when compiling invalid regex
    1022. 

  1022.         with self.assertRaisesRegexp(sre_constants.error, '<foo>'):
    1023. 

  1023.             re.compile('(?P=<foo>)')
    1024. 

  1024. 

  1025.     def test_group_name_in_exception(self):
    1026. 

  1026.         # Issue 17341: Poor error message when compiling invalid regex
    1027. 

  1027.         with self.assertRaisesRegexp(sre_constants.error, '\?foo'):
    1028. 

  1028.             re.compile('(?P<?foo>)')
    1029. 

  1029. 

  1030.     def test_issue17998(self):
    1031. 

  1031.         for reps in '*', '+', '?', '{1}':
    1032. 

  1032.             for mod in '', '?':
    1033. 

  1033.                 pattern = '.' + reps + mod + 'yz'
    1034. 

  1034.                 self.assertEqual(re.compile(pattern, re.S).findall('xyz'),
    1035. 

  1035.                                  ['xyz'], msg=pattern)
    1036. 

  1036.                 if have_unicode:
    1037. 

  1037.                     pattern = unicode(pattern)
    1038. 

  1038.                     self.assertEqual(re.compile(pattern, re.S).findall(u'xyz'),
    1039. 

  1039.                                      [u'xyz'], msg=pattern)
    1040. 

  1040. 

  1041. 

  1042.     def test_bug_2537(self):
    1043. 

  1043.         # issue 2537: empty submatches
    1044. 

  1044.         for outer_op in ('{0,}', '*', '+', '{1,187}'):
    1045. 

  1045.             for inner_op in ('{0,}', '*', '?'):
    1046. 

  1046.                 r = re.compile("^((x|y)%s)%s" % (inner_op, outer_op))
    1047. 

  1047.                 m = r.match("xyyzy")
    1048. 

  1048.                 self.assertEqual(m.group(0), "xyy")
    1049. 

  1049.                 self.assertEqual(m.group(1), "")
    1050. 

  1050.                 self.assertEqual(m.group(2), "y")
    1051. 

  1051. 

  1052.     def test_debug_flag(self):
    1053. 

  1053.         pat = r'(\.)(?:[ch]|py)(?(1)$|: )'
    1054. 

  1054.         with captured_stdout() as out:
    1055. 

  1055.             re.compile(pat, re.DEBUG)
    1056. 

  1056.         dump = '''\
    1057. 

  1057. subpattern 1
    1058. 

  1058.   literal 46
    1059. 

  1059. subpattern None
    1060. 

  1060.   branch
    1061. 

  1061.     in
    1062. 

  1062.       literal 99
    1063. 

  1063.       literal 104
    1064. 

  1064.   or
    1065. 

  1065.     literal 112
    1066. 

  1066.     literal 121
    1067. 

  1067. subpattern None
    1068. 

  1068.   groupref_exists 1
    1069. 

  1069.     at at_end
    1070. 

  1070.   else
    1071. 

  1071.     literal 58
    1072. 

  1072.     literal 32
    1073. 

  1073. '''
    1074. 

  1074.         self.assertEqual(out.getvalue(), dump)
    1075. 

  1075.         # Debug output is output again even a second time (bypassing
    1076. 

  1076.       …
    1077.

Large files files are truncated, but you can click here to view the full file