Issue #22777: Test pickling with all protocols.

Author: serhiy-storchaka

Lib/ctypes/test/test_pickling.py

@@ -14,9 +14,9 @@ def __init__(self, *args, **kw):
 class Y(X):
     _fields_ = [("str", c_char_p)]
 
-class PickleTest(unittest.TestCase):
+class PickleTest:
     def dumps(self, item):
-        return pickle.dumps(item)
+        return pickle.dumps(item, self.proto)
 
     def loads(self, item):
         return pickle.loads(item)
@@ -67,17 +67,15 @@ def test_unpickable(self):
             self.assertRaises(ValueError, lambda: self.dumps(item))
 
     def test_wchar(self):
-        pickle.dumps(c_char(b"x"))
+        self.dumps(c_char(b"x"))
         # Issue 5049
-        pickle.dumps(c_wchar("x"))
+        self.dumps(c_wchar("x"))
 
-class PickleTest_1(PickleTest):
-    def dumps(self, item):
-        return pickle.dumps(item, 1)
-
-class PickleTest_2(PickleTest):
-    def dumps(self, item):
-        return pickle.dumps(item, 2)
+for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+    name = 'PickleTest_%s' % proto
+    globals()[name] = type(name,
+                           (PickleTest, unittest.TestCase),
+                           {'proto': proto})
 
 if __name__ == "__main__":
     unittest.main()

Lib/test/audiotests.py

@@ -45,8 +45,9 @@ def check_params(self, f, nchannels, sampwidth, framerate, nframes,
         self.assertEqual(params.comptype, comptype)
         self.assertEqual(params.compname, compname)
 
-        dump = pickle.dumps(params)
-        self.assertEqual(pickle.loads(dump), params)
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            dump = pickle.dumps(params, proto)
+            self.assertEqual(pickle.loads(dump), params)
 
 
 class AudioWriteTests(AudioTests):

Lib/test/datetimetester.py

@@ -1682,11 +1682,12 @@ def test_pickling(self):
 
     def test_more_pickling(self):
         a = self.theclass(2003, 2, 7, 16, 48, 37, 444116)
-        s = pickle.dumps(a)
-        b = pickle.loads(s)
-        self.assertEqual(b.year, 2003)
-        self.assertEqual(b.month, 2)
-        self.assertEqual(b.day, 7)
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            s = pickle.dumps(a, proto)
+            b = pickle.loads(s)
+            self.assertEqual(b.year, 2003)
+            self.assertEqual(b.month, 2)
+            self.assertEqual(b.day, 7)
 
     def test_pickling_subclass_datetime(self):
         args = 6, 7, 23, 20, 59, 1, 64**2

Lib/test/seq_tests.py

@@ -392,6 +392,7 @@ def __eq__(self, other):
 
     def test_pickle(self):
         lst = self.type2test([4, 5, 6, 7])
-        lst2 = pickle.loads(pickle.dumps(lst))
-        self.assertEqual(lst2, lst)
-        self.assertNotEqual(id(lst2), id(lst))
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            lst2 = pickle.loads(pickle.dumps(lst, proto))
+            self.assertEqual(lst2, lst)
+            self.assertNotEqual(id(lst2), id(lst))

Lib/test/test_array.py

@@ -285,17 +285,18 @@ def test_pickle_for_empty_array(self):
 
     def test_iterator_pickle(self):
         data = array.array(self.typecode, self.example)
-        orgit = iter(data)
-        d = pickle.dumps(orgit)
-        it = pickle.loads(d)
-        self.assertEqual(type(orgit), type(it))
-        self.assertEqual(list(it), list(data))
-
-        if len(data):
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            orgit = iter(data)
+            d = pickle.dumps(orgit, proto)
             it = pickle.loads(d)
-            next(it)
-            d = pickle.dumps(it)
-            self.assertEqual(list(it), list(data)[1:])
+            self.assertEqual(type(orgit), type(it))
+            self.assertEqual(list(it), list(data))
+
+            if len(data):
+                it = pickle.loads(d)
+                next(it)
+                d = pickle.dumps(it, proto)
+                self.assertEqual(list(it), list(data)[1:])
 
     def test_insert(self):
         a = array.array(self.typecode, self.example)

Lib/test/test_bool.py

@@ -269,10 +269,9 @@ def test_marshal(self):
 
     def test_pickle(self):
         import pickle
-        self.assertIs(pickle.loads(pickle.dumps(True)), True)
-        self.assertIs(pickle.loads(pickle.dumps(False)), False)
-        self.assertIs(pickle.loads(pickle.dumps(True, True)), True)
-        self.assertIs(pickle.loads(pickle.dumps(False, True)), False)
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            self.assertIs(pickle.loads(pickle.dumps(True, proto)), True)
+            self.assertIs(pickle.loads(pickle.dumps(False, proto)), False)
 
     def test_picklevalues(self):
         # Test for specific backwards-compatible pickle values

Lib/test/test_builtin.py

@@ -121,9 +121,9 @@ def map_char(arg):
 
 class BuiltinTest(unittest.TestCase):
     # Helper to check picklability
-    def check_iter_pickle(self, it, seq):
+    def check_iter_pickle(self, it, seq, proto):
         itorg = it
-        d = pickle.dumps(it)
+        d = pickle.dumps(it, proto)
         it = pickle.loads(d)
         self.assertEqual(type(itorg), type(it))
         self.assertEqual(list(it), seq)
@@ -134,7 +134,7 @@ def check_iter_pickle(self, it, seq):
             next(it)
         except StopIteration:
             return
-        d = pickle.dumps(it)
+        d = pickle.dumps(it, proto)
         it = pickle.loads(d)
         self.assertEqual(list(it), seq[1:])
 
@@ -636,9 +636,10 @@ def badfunc():
         self.assertRaises(TypeError, list, filter(42, (1, 2)))
 
     def test_filter_pickle(self):
-        f1 = filter(filter_char, "abcdeabcde")
-        f2 = filter(filter_char, "abcdeabcde")
-        self.check_iter_pickle(f1, list(f2))
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            f1 = filter(filter_char, "abcdeabcde")
+            f2 = filter(filter_char, "abcdeabcde")
+            self.check_iter_pickle(f1, list(f2), proto)
 
     def test_getattr(self):
         self.assertTrue(getattr(sys, 'stdout') is sys.stdout)
@@ -834,9 +835,10 @@ def badfunc(x):
         self.assertRaises(RuntimeError, list, map(badfunc, range(5)))
 
     def test_map_pickle(self):
-        m1 = map(map_char, "Is this the real life?")
-        m2 = map(map_char, "Is this the real life?")
-        self.check_iter_pickle(m1, list(m2))
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            m1 = map(map_char, "Is this the real life?")
+            m2 = map(map_char, "Is this the real life?")
+            self.check_iter_pickle(m1, list(m2), proto)
 
     def test_max(self):
         self.assertEqual(max('123123'), '3')
@@ -1433,8 +1435,9 @@ def test_zip_pickle(self):
         a = (1, 2, 3)
         b = (4, 5, 6)
         t = [(1, 4), (2, 5), (3, 6)]
-        z1 = zip(a, b)
-        self.check_iter_pickle(z1, t)
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            z1 = zip(a, b)
+            self.check_iter_pickle(z1, t, proto)
 
     def test_format(self):
         # Test the basic machinery of the format() builtin.  Don't test

Lib/test/test_bytes.py

@@ -555,22 +555,23 @@ def test_pickling(self):
                 self.assertEqual(b, q)
 
     def test_iterator_pickling(self):
-        for b in b"", b"a", b"abc", b"\xffab\x80", b"\0\0\377\0\0":
-            it = itorg = iter(self.type2test(b))
-            data = list(self.type2test(b))
-            d = pickle.dumps(it)
-            it = pickle.loads(d)
-            self.assertEqual(type(itorg), type(it))
-            self.assertEqual(list(it), data)
-
-            it = pickle.loads(d)
-            try:
-                next(it)
-            except StopIteration:
-                continue
-            d = pickle.dumps(it)
-            it = pickle.loads(d)
-            self.assertEqual(list(it), data[1:])
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            for b in b"", b"a", b"abc", b"\xffab\x80", b"\0\0\377\0\0":
+                it = itorg = iter(self.type2test(b))
+                data = list(self.type2test(b))
+                d = pickle.dumps(it, proto)
+                it = pickle.loads(d)
+                self.assertEqual(type(itorg), type(it))
+                self.assertEqual(list(it), data)
+
+                it = pickle.loads(d)
+                try:
+                    next(it)
+                except StopIteration:
+                    continue
+                d = pickle.dumps(it, proto)
+                it = pickle.loads(d)
+                self.assertEqual(list(it), data[1:])
 
     def test_strip(self):
         b = self.type2test(b'mississippi')

Lib/test/test_bz2.py

@@ -646,8 +646,9 @@ def testCompress4G(self, size):
             data = None
 
     def testPickle(self):
-        with self.assertRaises(TypeError):
-            pickle.dumps(BZ2Compressor())
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.assertRaises(TypeError):
+                pickle.dumps(BZ2Compressor(), proto)
 
 
 class BZ2DecompressorTest(BaseTest):
@@ -702,8 +703,9 @@ def testDecompress4G(self, size):
             decompressed = None
 
     def testPickle(self):
-        with self.assertRaises(TypeError):
-            pickle.dumps(BZ2Decompressor())
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.assertRaises(TypeError):
+                pickle.dumps(BZ2Decompressor(), proto)
 
 
 class CompressDecompressTest(BaseTest):

Lib/test/test_collections.py

@@ -63,10 +63,17 @@ def test_basics(self):
             for m1, m2 in zip(d.maps[1:], e.maps[1:]):
                 self.assertIs(m1, m2)
 
-        for e in [pickle.loads(pickle.dumps(d)),
-                  copy.deepcopy(d),
+        # check deep copies
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            e = pickle.loads(pickle.dumps(d, proto))
+            self.assertEqual(d, e)
+            self.assertEqual(d.maps, e.maps)
+            self.assertIsNot(d, e)
+            for m1, m2 in zip(d.maps, e.maps):
+                self.assertIsNot(m1, m2, e)
+        for e in [copy.deepcopy(d),
                   eval(repr(d))
-                ]:                                                    # check deep copies
+                ]:
             self.assertEqual(d, e)
             self.assertEqual(d.maps, e.maps)
             self.assertIsNot(d, e)
@@ -1110,28 +1117,21 @@ def test_copying(self):
         # Check that counters are copyable, deepcopyable, picklable, and
         #have a repr/eval round-trip
         words = Counter('which witch had which witches wrist watch'.split())
+        def check(dup):
+            msg = "\ncopy: %s\nwords: %s" % (dup, words)
+            self.assertIsNot(dup, words, msg)
+            self.assertEqual(dup, words)
+        check(words.copy())
+        check(copy.copy(words))
+        check(copy.deepcopy(words))
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.subTest(proto=proto):
+                check(pickle.loads(pickle.dumps(words, proto)))
+        check(eval(repr(words)))
         update_test = Counter()
         update_test.update(words)
-        for label, dup in [
-                    ('words.copy()', words.copy()),
-                    ('copy.copy(words)', copy.copy(words)),
-                    ('copy.deepcopy(words)', copy.deepcopy(words)),
-                    ('pickle.loads(pickle.dumps(words, 0))',
-                        pickle.loads(pickle.dumps(words, 0))),
-                    ('pickle.loads(pickle.dumps(words, 1))',
-                        pickle.loads(pickle.dumps(words, 1))),
-                    ('pickle.loads(pickle.dumps(words, 2))',
-                        pickle.loads(pickle.dumps(words, 2))),
-                    ('pickle.loads(pickle.dumps(words, -1))',
-                        pickle.loads(pickle.dumps(words, -1))),
-                    ('eval(repr(words))', eval(repr(words))),
-                    ('update_test', update_test),
-                    ('Counter(words)', Counter(words)),
-                    ]:
-            with self.subTest(label=label):
-                msg = "\ncopy: %s\nwords: %s" % (dup, words)
-                self.assertIsNot(dup, words, msg)
-                self.assertEqual(dup, words)
+        check(update_test)
+        check(Counter(words))
 
     def test_copy_subclass(self):
         class MyCounter(Counter):
@@ -1433,30 +1433,21 @@ def test_copying(self):
         # and have a repr/eval round-trip
         pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
         od = OrderedDict(pairs)
+        def check(dup):
+            msg = "\ncopy: %s\nod: %s" % (dup, od)
+            self.assertIsNot(dup, od, msg)
+            self.assertEqual(dup, od)
+        check(od.copy())
+        check(copy.copy(od))
+        check(copy.deepcopy(od))
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.subTest(proto=proto):
+                check(pickle.loads(pickle.dumps(od, proto)))
+        check(eval(repr(od)))
         update_test = OrderedDict()
         update_test.update(od)
-        for label, dup in [
-                    ('od.copy()', od.copy()),
-                    ('copy.copy(od)', copy.copy(od)),
-                    ('copy.deepcopy(od)', copy.deepcopy(od)),
-                    ('pickle.loads(pickle.dumps(od, 0))',
-                        pickle.loads(pickle.dumps(od, 0))),
-                    ('pickle.loads(pickle.dumps(od, 1))',
-                        pickle.loads(pickle.dumps(od, 1))),
-                    ('pickle.loads(pickle.dumps(od, 2))',
-                        pickle.loads(pickle.dumps(od, 2))),
-                    ('pickle.loads(pickle.dumps(od, 3))',
-                        pickle.loads(pickle.dumps(od, 3))),
-                    ('pickle.loads(pickle.dumps(od, -1))',
-                        pickle.loads(pickle.dumps(od, -1))),
-                    ('eval(repr(od))', eval(repr(od))),
-                    ('update_test', update_test),
-                    ('OrderedDict(od)', OrderedDict(od)),
-                    ]:
-            with self.subTest(label=label):
-                msg = "\ncopy: %s\nod: %s" % (dup, od)
-                self.assertIsNot(dup, od, msg)
-                self.assertEqual(dup, od)
+        check(update_test)
+        check(OrderedDict(od))
 
     def test_yaml_linkage(self):
         # Verify that __reduce__ is setup in a way that supports PyYAML's dump() feature.