#2650: Merge with 3.1.

Lib/re.py

@@ -224,8 +224,7 @@ def escape(pattern):
     if isinstance(pattern, str):
         alphanum = _alphanum_str
         s = list(pattern)
-        for i in range(len(pattern)):
+        for i, c in enumerate(pattern):
-            c = pattern[i]
             if c not in alphanum:
                 if c == "\000":
                     s[i] = "\\000"

Lib/test/test_re.py

@@ -1,7 +1,9 @@
 from test.support import verbose, run_unittest
 import re
 from re import Scanner
-import sys, traceback
+import sys
+import string
+import traceback
 from weakref import proxy
 
 # Misc tests from Tim Peters' re.doc
@@ -411,31 +413,62 @@ class ReTests(unittest.TestCase):
         self.assertEqual(re.search("\s(b)", " b").group(1), "b")
         self.assertEqual(re.search("a\s", "a ").group(0), "a ")
 
-    def test_re_escape(self):
+    def assertMatch(self, pattern, text, match=None, span=None,
-        p=""
+                    matcher=re.match):
-        self.assertEqual(re.escape(p), p)
+        if match is None and span is None:
-        for i in range(0, 256):
+            # the pattern matches the whole text
-            p = p + chr(i)
+            match = text
-            self.assertEqual(re.match(re.escape(chr(i)), chr(i)) is not None,
+            span = (0, len(text))
-                             True)
+        elif match is None or span is None:
-            self.assertEqual(re.match(re.escape(chr(i)), chr(i)).span(), (0,1))
+            raise ValueError('If match is not None, span should be specified '
+                             '(and vice versa).')
+        m = matcher(pattern, text)
+        self.assertTrue(m)
+        self.assertEqual(m.group(), match)
+        self.assertEqual(m.span(), span)
 
-        pat=re.compile(re.escape(p))
+    def test_re_escape(self):
-        self.assertEqual(pat.match(p) is not None, True)
+        alnum_chars = string.ascii_letters + string.digits
-        self.assertEqual(pat.match(p).span(), (0,256))
+        p = ''.join(chr(i) for i in range(256))
+        for c in p:
+            if c in alnum_chars:
+                self.assertEqual(re.escape(c), c)
+            elif c == '\x00':
+                self.assertEqual(re.escape(c), '\\000')
+            else:
+                self.assertEqual(re.escape(c), '\\' + c)
+            self.assertMatch(re.escape(c), c)
+        self.assertMatch(re.escape(p), p)
 
     def test_re_escape_byte(self):
-        p=b""
+        alnum_chars = (string.ascii_letters + string.digits).encode('ascii')
-        self.assertEqual(re.escape(p), p)
+        p = bytes(range(256))
-        for i in range(0, 256):
+        for i in p:
             b = bytes([i])
-            p += b
+            if b in alnum_chars:
-            self.assertEqual(re.match(re.escape(b), b) is not None, True)
+                self.assertEqual(re.escape(b), b)
-            self.assertEqual(re.match(re.escape(b), b).span(), (0,1))
+            elif i == 0:
+                self.assertEqual(re.escape(b), b'\\000')
+            else:
+                self.assertEqual(re.escape(b), b'\\' + b)
+            self.assertMatch(re.escape(b), b)
+        self.assertMatch(re.escape(p), p)
 
-        pat=re.compile(re.escape(p))
+    def test_re_escape_non_ascii(self):
-        self.assertEqual(pat.match(p) is not None, True)
+        s = 'xxx\u2620\u2620\u2620xxx'
-        self.assertEqual(pat.match(p).span(), (0,256))
+        s_escaped = re.escape(s)
+        self.assertEqual(s_escaped, 'xxx\\\u2620\\\u2620\\\u2620xxx')
+        self.assertMatch(s_escaped, s)
+        self.assertMatch('.%s+.' % re.escape('\u2620'), s,
+                         'x\u2620\u2620\u2620x', (2, 7), re.search)
+
+    def test_re_escape_non_ascii_bytes(self):
+        b = 'y\u2620y\u2620y'.encode('utf-8')
+        b_escaped = re.escape(b)
+        self.assertEqual(b_escaped, b'y\\\xe2\\\x98\\\xa0y\\\xe2\\\x98\\\xa0y')
+        self.assertMatch(b_escaped, b)
+        res = re.findall(re.escape('\u2620'.encode('utf-8')), b)
+        self.assertEqual(len(res), 2)
 
     def pickle_test(self, pickle):
         oldpat = re.compile('a(?:b|(c|e){1,2}?|d)+?(.)')