Add tests exercising the ensure_ascii=False encoder paths

Cover long runs that cross the scan windows and the short-string guard, with
a special character at every offset in 1-byte and wider strings, plus the
no-escape verbatim fast path and the escaped fallback.

Author: gaborbernat

Lib/copy.py

@@ -174,12 +174,15 @@ def _deepcopy_list(x, memo, deepcopy=deepcopy):
     memo[id(x)] = y
     append = y.append
     for a in x:
-        append(deepcopy(a, memo))
+        # Inline the atomic-type check so atomic elements (int, str, None, ...)
+        # skip the deepcopy() call overhead entirely; deepcopy() would just
+        # return them unchanged after the same check.
+        append(a if type(a) in _atomic_types else deepcopy(a, memo))
     return y
 d[list] = _deepcopy_list
 
 def _deepcopy_tuple(x, memo, deepcopy=deepcopy):
-    y = [deepcopy(a, memo) for a in x]
+    y = [a if type(a) in _atomic_types else deepcopy(a, memo) for a in x]
     # We're not going to put the tuple in the memo, but it's still important we
     # check for it, in case the tuple contains recursive mutable structures.
     try:
@@ -199,7 +202,11 @@ def _deepcopy_dict(x, memo, deepcopy=deepcopy):
     y = {}
     memo[id(x)] = y
     for key, value in x.items():
-        y[deepcopy(key, memo)] = deepcopy(value, memo)
+        # Inline the atomic-type check for keys and values: atomic objects
+        # (str keys, int/str/None values, ...) are returned as-is by
+        # deepcopy(), so skip the per-item call in that common case.
+        y[key if type(key) in _atomic_types else deepcopy(key, memo)] = (
+            value if type(value) in _atomic_types else deepcopy(value, memo))
     return y
 d[dict] = _deepcopy_dict
 

Lib/test/test_json/test_unicode.py

@@ -39,6 +39,31 @@ def test_ascii_non_printable_encode(self):
         self.assertEqual(self.dumps(u, ensure_ascii=False),
                          '"\\b\\t\\n\\f\\r\\u0000\\u001f\x7f"')
 
+    def test_ensure_ascii_false_long_string_paths(self):
+        # Exercise the encoder's escape-size scan for ensure_ascii=False over
+        # long runs that cross the 8-byte scan windows and the short-string
+        # guard: a special character at every offset, in 1-byte (ASCII and
+        # Latin-1) and wider (BMP, astral) strings.
+        dumps, loads = self.dumps, self.loads
+        for n in range(40):
+            run = "a" * n
+            for tail in ('"', "\\", "\n", "\x00", "\x1f", "\x7f", "\xe9",
+                         "中", "\U0001f600"):
+                s = run + tail + "tail"
+                self.assertEqual(loads(dumps(s, ensure_ascii=False)), s)
+        # The no-escape fast path returns the string verbatim between quotes,
+        # including kept-as-is Latin-1 and 0x7f.
+        for s in ("x" * 20, "\xe9" * 20, "kept latin1 \xe9\xff \x7f text " * 3):
+            self.assertEqual(dumps(s, ensure_ascii=False), '"' + s + '"')
+        # The structural escapes and control chars are still escaped after a
+        # long no-escape run.
+        self.assertEqual(dumps("a" * 20 + '"', ensure_ascii=False),
+                         '"' + "a" * 20 + '\\""')
+        self.assertEqual(dumps("a" * 20 + "\\", ensure_ascii=False),
+                         '"' + "a" * 20 + '\\\\"')
+        self.assertEqual(dumps("a" * 20 + "\x01", ensure_ascii=False),
+                         '"' + "a" * 20 + '\\u0001"')
+
     def test_ascii_non_printable_decode(self):
         self.assertEqual(self.loads('"\\b\\t\\n\\f\\r"'),
                          '\b\t\n\f\r')