#2650: Refactor re.escape and its tests.

Lib/re.py

@@ -207,8 +207,7 @@ def escape(pattern):
     "Escape all non-alphanumeric characters in pattern."
     s = list(pattern)
     alphanum = _alphanum
-    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.test_support import verbose, run_unittest, import_module
 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
@@ -429,17 +431,61 @@ 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):
-        for i in range(0, 256):
+        if match is None and span is None:
-            p = p + chr(i)
+            # the pattern matches the whole text
-            self.assertEqual(re.match(re.escape(chr(i)), chr(i)) is not None,
+            match = text
-                             True)
+            span = (0, len(text))
-            self.assertEqual(re.match(re.escape(chr(i)), chr(i)).span(), (0,1))
+        elif match is None or span is None:
+            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 = u''.join(unichr(i) for i in range(256))
+        for c in p:
+            if c in alnum_chars:
+                self.assertEqual(re.escape(c), c)
+            elif c == u'\x00':
+                self.assertEqual(re.escape(c), u'\\000')
+            else:
+                self.assertEqual(re.escape(c), u'\\' + c)
+            self.assertMatch(re.escape(c), c)
+        self.assertMatch(re.escape(p), p)
+
+    def test_re_escape_byte(self):
+        alnum_chars = (string.ascii_letters + string.digits).encode('ascii')
+        p = ''.join(chr(i) for i in range(256))
+        for b in p:
+            if b in alnum_chars:
+                self.assertEqual(re.escape(b), b)
+            elif b == b'\x00':
+                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)
+
+    def test_re_escape_non_ascii(self):
+        s = u'xxx\u2620\u2620\u2620xxx'
+        s_escaped = re.escape(s)
+        self.assertEqual(s_escaped, u'xxx\\\u2620\\\u2620\\\u2620xxx')
+        self.assertMatch(s_escaped, s)
+        self.assertMatch(u'.%s+.' % re.escape(u'\u2620'), s,
+                         u'x\u2620\u2620\u2620x', (2, 7), re.search)
+
+    def test_re_escape_non_ascii_bytes(self):
+        b = u'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(u'\u2620'.encode('utf-8')), b)
+        self.assertEqual(len(res), 2)
 
     def test_pickling(self):
         import pickle