Add more comments.

python · serhiy-storchaka · Dec 5, 2025 · May 20, 2024 · May 20, 2024 · May 20, 2024
commit e89bfeabd717e91c3e5c159cabc8f865d291fc19
diff --git a/Lib/test/pickletester.py b/Lib/test/pickletester.py
@@ -74,6 +74,15 @@ def count_opcode(code, pickle):
 def identity(x):
     return x
 
+def itersize(start, stop):
+    # Produce geometrical increasing sequence from start to stop
+    # (inclusively) for tests.
+    size = start
+    while size < stop:
+        yield size
+        size <<= 1
+    yield stop
+
 
 class UnseekableIO(io.BytesIO):
     def peek(self, *args):
@@ -1118,28 +1127,38 @@ def test_negative_32b_binput(self):
         dumped = b'\x80\x03X\x01\x00\x00\x00ar\xff\xff\xff\xff.'
         self.check_unpickling_error(ValueError, dumped)
 
-    def itersize(self, start, stop):
-        # Produce geometrical increasing sequence from start to stop
-        # (inclusively) for tests.
-        size = start
-        while size < stop:
-            yield size
-            size <<= 1
-        yield stop
-
     def test_too_large_put(self):
+        # Test that PUT with large id does not cause allocation of
+        # too large memo table.
         data = lambda n: (b'((lp' + str(n).encode() + b'\n' +
                           b'g' + str(n).encode() + b'\nt.')
+        #    0: (    MARK
+        #    1: (        MARK
+        #    2: l            LIST       (MARK at 1)
+        #    3: p        PUT        1000000000000
+        #   18: g        GET        1000000000000
+        #   33: t        TUPLE      (MARK at 0)
+        #   34: .    STOP
         for idx in [10**6, 10**9, 10**12]:
             self.assertEqual(self.loads(data(idx)), ([],)*2)
 
     def test_too_large_long_binput(self):
+        # Test that LONG_BINPUT with large id does not cause allocation of
+        # too large memo table.
         data = lambda n: (b'(]r' + struct.pack('<I', n) +
                           b'j' + struct.pack('<I', n) + b't.')
-        for idx in self.itersize(1 << 20, min(sys.maxsize, (1 << 32) - 1)):
+        #    0: (    MARK
+        #    1: ]        EMPTY_LIST
+        #    2: r        LONG_BINPUT 4294967295
+        #    7: j        LONG_BINGET 4294967295
+        #   12: t        TUPLE      (MARK at 0)
+        #   13: .    STOP
+        for idx in itersize(1 << 20, min(sys.maxsize, (1 << 32) - 1)):
             self.assertEqual(self.loads(data(idx)), ([],)*2)
 
     def _test_truncated_data(self, dumped, expected_error=None):
+        # Test that instructions to read large data without providing
+        # such amount of data do not cause large memory usage.
         if expected_error is None:
             expected_error = self.truncated_data_error
         # BytesIO
@@ -1164,36 +1183,47 @@ def _test_truncated_data(self, dumped, expected_error=None):
 
     def test_truncated_large_binstring(self):
         data = lambda size: b'T' + struct.pack('<I', size) + b'.' * 5
+        #    0: T    BINSTRING  '....'
+        #    9: .    STOP
         self.assertEqual(self.loads(data(4)), '....') # self-testing
-        for size in self.itersize(1 << 10, min(sys.maxsize - 5, (1 << 31) - 1)):
+        for size in itersize(1 << 10, min(sys.maxsize - 5, (1 << 31) - 1)):
             self._test_truncated_data(data(size))
         self._test_truncated_data(data(1 << 31),
             (pickle.UnpicklingError, 'truncated|exceeds|negative byte count'))
 
     def test_truncated_large_binunicode(self):
         data = lambda size: b'X' + struct.pack('<I', size) + b'.' * 5
+        #    0: X    BINUNICODE '....'
+        #    9: .    STOP
         self.assertEqual(self.loads(data(4)), '....') # self-testing
-        for size in self.itersize(1 << 10, min(sys.maxsize - 5, (1 << 32) - 1)):
+        for size in itersize(1 << 10, min(sys.maxsize - 5, (1 << 32) - 1)):
             self._test_truncated_data(data(size))
 
     def test_truncated_large_binbytes(self):
         data = lambda size: b'B' + struct.pack('<I', size) + b'.' * 5
+        #    0: B    BINBYTES   b'....'
+        #    9: .    STOP
         self.assertEqual(self.loads(data(4)), b'....') # self-testing
-        for size in self.itersize(1 << 10, min(sys.maxsize, 1 << 31)):
+        for size in itersize(1 << 10, min(sys.maxsize, 1 << 31)):
             self._test_truncated_data(data(size))
 
     def test_truncated_large_long4(self):
         data = lambda size: b'\x8b' + struct.pack('<I', size) + b'.' * 5
+        #    0: \x8b LONG4      0x2e2e2e2e
+        #    9: .    STOP
         self.assertEqual(self.loads(data(4)), 0x2e2e2e2e) # self-testing
-        for size in self.itersize(1 << 10, min(sys.maxsize - 5, (1 << 31) - 1)):
+        for size in itersize(1 << 10, min(sys.maxsize - 5, (1 << 31) - 1)):
             self._test_truncated_data(data(size))
         self._test_truncated_data(data(1 << 31),
             (pickle.UnpicklingError, 'LONG pickle has negative byte count'))
 
     def test_truncated_large_frame(self):
         data = lambda size: b'\x95' + struct.pack('<Q', size) + b'N.'
+        #    0: \x95 FRAME      2
+        #    9: N    NONE
+        #   10: .    STOP
         self.assertIsNone(self.loads(data(2))) # self-testing
-        for size in self.itersize(1 << 10, sys.maxsize - 9):
+        for size in itersize(1 << 10, sys.maxsize - 9):
             self._test_truncated_data(data(size))
         if sys.maxsize + 1 < 1 << 64:
             self._test_truncated_data(data(sys.maxsize + 1),
@@ -1202,24 +1232,30 @@ def test_truncated_large_frame(self):
 
     def test_truncated_large_binunicode8(self):
         data = lambda size: b'\x8d' + struct.pack('<Q', size) + b'.' * 5
+        #    0: \x8d BINUNICODE8 '....'
+        #   13: .    STOP
         self.assertEqual(self.loads(data(4)), '....') # self-testing
-        for size in self.itersize(1 << 10, sys.maxsize - 9):
+        for size in itersize(1 << 10, sys.maxsize - 9):
             self._test_truncated_data(data(size))
         if sys.maxsize + 1 < 1 << 64:
             self._test_truncated_data(data(sys.maxsize + 1), self.size_overflow_error)
 
     def test_truncated_large_binbytes8(self):
         data = lambda size: b'\x8e' + struct.pack('<Q', size) + b'.' * 5
+        #    0: \x8e BINBYTES8  b'....'
+        #   13: .    STOP
         self.assertEqual(self.loads(data(4)), b'....') # self-testing
-        for size in self.itersize(1 << 10, sys.maxsize):
+        for size in itersize(1 << 10, sys.maxsize):
             self._test_truncated_data(data(size))
         if sys.maxsize + 1 < 1 << 64:
             self._test_truncated_data(data(sys.maxsize + 1), self.size_overflow_error)
 
     def test_truncated_large_bytearray8(self):
         data = lambda size: b'\x96' + struct.pack('<Q', size) + b'.' * 5
+        #    0: \x96 BYTEARRAY8 bytearray(b'....')
+        #   13: .    STOP
         self.assertEqual(self.loads(data(4)), bytearray(b'....')) # self-testing
-        for size in self.itersize(1 << 10, sys.maxsize):
+        for size in itersize(1 << 10, sys.maxsize):
             self._test_truncated_data(data(size))
         if sys.maxsize + 1 < 1 << 64:
             self._test_truncated_data(data(sys.maxsize + 1), self.size_overflow_error)