From 655720e2758a15c85effb340ff65f4b93e7cc7a7 Mon Sep 17 00:00:00 2001 From: Serhiy Storchaka Date: Mon, 15 Dec 2014 14:02:43 +0200 Subject: [PATCH] Issue #22777: Test pickling with all protocols. --- Lib/ctypes/test/test_pickling.py | 20 ++--- Lib/test/audiotests.py | 5 +- Lib/test/test_bool.py | 48 +++++------ Lib/test/test_cfgparser.py | 144 +++++++++++++++++-------------- Lib/test/test_datetime.py | 11 +-- Lib/test/test_decimal.py | 20 +++-- Lib/test/test_deque.py | 22 ++--- Lib/test/test_descr.py | 91 ++++++++++--------- Lib/test/test_functools.py | 5 +- Lib/test/test_itertools.py | 3 +- Lib/test/test_memoryio.py | 3 +- Lib/test/test_minidom.py | 75 ++++++++-------- Lib/test/test_random.py | 14 +-- Lib/test/test_set.py | 11 +-- Lib/test/test_sets.py | 9 +- 15 files changed, 253 insertions(+), 228 deletions(-) diff --git a/Lib/ctypes/test/test_pickling.py b/Lib/ctypes/test/test_pickling.py index 136cbe928e..73528d46b1 100644 --- a/Lib/ctypes/test/test_pickling.py +++ b/Lib/ctypes/test/test_pickling.py @@ -14,9 +14,9 @@ class X(Structure): 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 @@ class PickleTest(unittest.TestCase): self.assertRaises(ValueError, lambda: self.dumps(item)) def test_wchar(self): - pickle.dumps(c_char("x")) + self.dumps(c_char(b"x")) # Issue 5049 - pickle.dumps(c_wchar(u"x")) + self.dumps(c_wchar(u"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() diff --git a/Lib/test/audiotests.py b/Lib/test/audiotests.py index f4abd2a81c..7ed04140d9 100644 --- a/Lib/test/audiotests.py +++ b/Lib/test/audiotests.py @@ -61,8 +61,9 @@ class AudioTests: self.assertEqual(params, (nchannels, sampwidth, framerate, nframes, comptype, 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): diff --git a/Lib/test/test_bool.py b/Lib/test/test_bool.py index 16cd1aa1ff..e3b477552b 100644 --- a/Lib/test/test_bool.py +++ b/Lib/test/test_bool.py @@ -305,42 +305,40 @@ class BoolTest(unittest.TestCase): 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_cpickle(self): import cPickle - self.assertIs(cPickle.loads(cPickle.dumps(True)), True) - self.assertIs(cPickle.loads(cPickle.dumps(False)), False) - self.assertIs(cPickle.loads(cPickle.dumps(True, True)), True) - self.assertIs(cPickle.loads(cPickle.dumps(False, True)), False) + for proto in range(cPickle.HIGHEST_PROTOCOL + 1): + self.assertIs(cPickle.loads(cPickle.dumps(True, proto)), True) + self.assertIs(cPickle.loads(cPickle.dumps(False, proto)), False) def test_mixedpickle(self): import pickle, cPickle - self.assertIs(pickle.loads(cPickle.dumps(True)), True) - self.assertIs(pickle.loads(cPickle.dumps(False)), False) - self.assertIs(pickle.loads(cPickle.dumps(True, True)), True) - self.assertIs(pickle.loads(cPickle.dumps(False, True)), False) - - self.assertIs(cPickle.loads(pickle.dumps(True)), True) - self.assertIs(cPickle.loads(pickle.dumps(False)), False) - self.assertIs(cPickle.loads(pickle.dumps(True, True)), True) - self.assertIs(cPickle.loads(pickle.dumps(False, True)), False) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + self.assertIs(pickle.loads(cPickle.dumps(True, proto)), True) + self.assertIs(pickle.loads(cPickle.dumps(False, proto)), False) + self.assertIs(cPickle.loads(pickle.dumps(True, proto)), True) + self.assertIs(cPickle.loads(pickle.dumps(False, proto)), False) def test_picklevalues(self): import pickle, cPickle # Test for specific backwards-compatible pickle values - self.assertEqual(pickle.dumps(True), "I01\n.") - self.assertEqual(pickle.dumps(False), "I00\n.") - self.assertEqual(cPickle.dumps(True), "I01\n.") - self.assertEqual(cPickle.dumps(False), "I00\n.") - self.assertEqual(pickle.dumps(True, True), "I01\n.") - self.assertEqual(pickle.dumps(False, True), "I00\n.") - self.assertEqual(cPickle.dumps(True, True), "I01\n.") - self.assertEqual(cPickle.dumps(False, True), "I00\n.") + self.assertEqual(pickle.dumps(True, protocol=0), "I01\n.") + self.assertEqual(pickle.dumps(False, protocol=0), "I00\n.") + self.assertEqual(cPickle.dumps(True, protocol=0), "I01\n.") + self.assertEqual(cPickle.dumps(False, protocol=0), "I00\n.") + self.assertEqual(pickle.dumps(True, protocol=1), "I01\n.") + self.assertEqual(pickle.dumps(False, protocol=1), "I00\n.") + self.assertEqual(cPickle.dumps(True, protocol=1), "I01\n.") + self.assertEqual(cPickle.dumps(False, protocol=1), "I00\n.") + self.assertEqual(pickle.dumps(True, protocol=2), b'\x80\x02\x88.') + self.assertEqual(pickle.dumps(False, protocol=2), b'\x80\x02\x89.') + self.assertEqual(cPickle.dumps(True, protocol=2), b'\x80\x02\x88.') + self.assertEqual(cPickle.dumps(False, protocol=2), b'\x80\x02\x89.') def test_convert_to_bool(self): # Verify that TypeError occurs when bad things are returned diff --git a/Lib/test/test_cfgparser.py b/Lib/test/test_cfgparser.py index df65f6e9b8..906e9cf123 100644 --- a/Lib/test/test_cfgparser.py +++ b/Lib/test/test_cfgparser.py @@ -614,88 +614,96 @@ class ExceptionPicklingTestCase(unittest.TestCase): def test_error(self): import pickle e1 = ConfigParser.Error('value') - pickled = pickle.dumps(e1) - e2 = pickle.loads(pickled) - self.assertEqual(e1.message, e2.message) - self.assertEqual(repr(e1), repr(e2)) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + pickled = pickle.dumps(e1, proto) + e2 = pickle.loads(pickled) + self.assertEqual(e1.message, e2.message) + self.assertEqual(repr(e1), repr(e2)) def test_nosectionerror(self): import pickle e1 = ConfigParser.NoSectionError('section') - pickled = pickle.dumps(e1) - e2 = pickle.loads(pickled) - self.assertEqual(e1.message, e2.message) - self.assertEqual(e1.args, e2.args) - self.assertEqual(e1.section, e2.section) - self.assertEqual(repr(e1), repr(e2)) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + pickled = pickle.dumps(e1, proto) + e2 = pickle.loads(pickled) + self.assertEqual(e1.message, e2.message) + self.assertEqual(e1.args, e2.args) + self.assertEqual(e1.section, e2.section) + self.assertEqual(repr(e1), repr(e2)) def test_nooptionerror(self): import pickle e1 = ConfigParser.NoOptionError('option', 'section') - pickled = pickle.dumps(e1) - e2 = pickle.loads(pickled) - self.assertEqual(e1.message, e2.message) - self.assertEqual(e1.args, e2.args) - self.assertEqual(e1.section, e2.section) - self.assertEqual(e1.option, e2.option) - self.assertEqual(repr(e1), repr(e2)) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + pickled = pickle.dumps(e1, proto) + e2 = pickle.loads(pickled) + self.assertEqual(e1.message, e2.message) + self.assertEqual(e1.args, e2.args) + self.assertEqual(e1.section, e2.section) + self.assertEqual(e1.option, e2.option) + self.assertEqual(repr(e1), repr(e2)) def test_duplicatesectionerror(self): import pickle e1 = ConfigParser.DuplicateSectionError('section') - pickled = pickle.dumps(e1) - e2 = pickle.loads(pickled) - self.assertEqual(e1.message, e2.message) - self.assertEqual(e1.args, e2.args) - self.assertEqual(e1.section, e2.section) - self.assertEqual(repr(e1), repr(e2)) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + pickled = pickle.dumps(e1, proto) + e2 = pickle.loads(pickled) + self.assertEqual(e1.message, e2.message) + self.assertEqual(e1.args, e2.args) + self.assertEqual(e1.section, e2.section) + self.assertEqual(repr(e1), repr(e2)) def test_interpolationerror(self): import pickle e1 = ConfigParser.InterpolationError('option', 'section', 'msg') - pickled = pickle.dumps(e1) - e2 = pickle.loads(pickled) - self.assertEqual(e1.message, e2.message) - self.assertEqual(e1.args, e2.args) - self.assertEqual(e1.section, e2.section) - self.assertEqual(e1.option, e2.option) - self.assertEqual(repr(e1), repr(e2)) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + pickled = pickle.dumps(e1, proto) + e2 = pickle.loads(pickled) + self.assertEqual(e1.message, e2.message) + self.assertEqual(e1.args, e2.args) + self.assertEqual(e1.section, e2.section) + self.assertEqual(e1.option, e2.option) + self.assertEqual(repr(e1), repr(e2)) def test_interpolationmissingoptionerror(self): import pickle e1 = ConfigParser.InterpolationMissingOptionError('option', 'section', 'rawval', 'reference') - pickled = pickle.dumps(e1) - e2 = pickle.loads(pickled) - self.assertEqual(e1.message, e2.message) - self.assertEqual(e1.args, e2.args) - self.assertEqual(e1.section, e2.section) - self.assertEqual(e1.option, e2.option) - self.assertEqual(e1.reference, e2.reference) - self.assertEqual(repr(e1), repr(e2)) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + pickled = pickle.dumps(e1, proto) + e2 = pickle.loads(pickled) + self.assertEqual(e1.message, e2.message) + self.assertEqual(e1.args, e2.args) + self.assertEqual(e1.section, e2.section) + self.assertEqual(e1.option, e2.option) + self.assertEqual(e1.reference, e2.reference) + self.assertEqual(repr(e1), repr(e2)) def test_interpolationsyntaxerror(self): import pickle e1 = ConfigParser.InterpolationSyntaxError('option', 'section', 'msg') - pickled = pickle.dumps(e1) - e2 = pickle.loads(pickled) - self.assertEqual(e1.message, e2.message) - self.assertEqual(e1.args, e2.args) - self.assertEqual(e1.section, e2.section) - self.assertEqual(e1.option, e2.option) - self.assertEqual(repr(e1), repr(e2)) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + pickled = pickle.dumps(e1, proto) + e2 = pickle.loads(pickled) + self.assertEqual(e1.message, e2.message) + self.assertEqual(e1.args, e2.args) + self.assertEqual(e1.section, e2.section) + self.assertEqual(e1.option, e2.option) + self.assertEqual(repr(e1), repr(e2)) def test_interpolationdeptherror(self): import pickle e1 = ConfigParser.InterpolationDepthError('option', 'section', 'rawval') - pickled = pickle.dumps(e1) - e2 = pickle.loads(pickled) - self.assertEqual(e1.message, e2.message) - self.assertEqual(e1.args, e2.args) - self.assertEqual(e1.section, e2.section) - self.assertEqual(e1.option, e2.option) - self.assertEqual(repr(e1), repr(e2)) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + pickled = pickle.dumps(e1, proto) + e2 = pickle.loads(pickled) + self.assertEqual(e1.message, e2.message) + self.assertEqual(e1.args, e2.args) + self.assertEqual(e1.section, e2.section) + self.assertEqual(e1.option, e2.option) + self.assertEqual(repr(e1), repr(e2)) def test_parsingerror(self): import pickle @@ -703,25 +711,27 @@ class ExceptionPicklingTestCase(unittest.TestCase): e1.append(1, 'line1') e1.append(2, 'line2') e1.append(3, 'line3') - pickled = pickle.dumps(e1) - e2 = pickle.loads(pickled) - self.assertEqual(e1.message, e2.message) - self.assertEqual(e1.args, e2.args) - self.assertEqual(e1.filename, e2.filename) - self.assertEqual(e1.errors, e2.errors) - self.assertEqual(repr(e1), repr(e2)) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + pickled = pickle.dumps(e1, proto) + e2 = pickle.loads(pickled) + self.assertEqual(e1.message, e2.message) + self.assertEqual(e1.args, e2.args) + self.assertEqual(e1.filename, e2.filename) + self.assertEqual(e1.errors, e2.errors) + self.assertEqual(repr(e1), repr(e2)) def test_missingsectionheadererror(self): import pickle e1 = ConfigParser.MissingSectionHeaderError('filename', 123, 'line') - pickled = pickle.dumps(e1) - e2 = pickle.loads(pickled) - self.assertEqual(e1.message, e2.message) - self.assertEqual(e1.args, e2.args) - self.assertEqual(e1.line, e2.line) - self.assertEqual(e1.filename, e2.filename) - self.assertEqual(e1.lineno, e2.lineno) - self.assertEqual(repr(e1), repr(e2)) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + pickled = pickle.dumps(e1, proto) + e2 = pickle.loads(pickled) + self.assertEqual(e1.message, e2.message) + self.assertEqual(e1.args, e2.args) + self.assertEqual(e1.line, e2.line) + self.assertEqual(e1.filename, e2.filename) + self.assertEqual(e1.lineno, e2.lineno) + self.assertEqual(repr(e1), repr(e2)) def test_main(): diff --git a/Lib/test/test_datetime.py b/Lib/test/test_datetime.py index 7caa40818f..19ffbcd572 100644 --- a/Lib/test/test_datetime.py +++ b/Lib/test/test_datetime.py @@ -1421,11 +1421,12 @@ class TestDateTime(TestDate): 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 diff --git a/Lib/test/test_decimal.py b/Lib/test/test_decimal.py index 4dbe62d256..de309ba327 100644 --- a/Lib/test/test_decimal.py +++ b/Lib/test/test_decimal.py @@ -1664,9 +1664,10 @@ class DecimalPythonAPItests(unittest.TestCase): def test_pickle(self): d = Decimal('-3.141590000') - p = pickle.dumps(d) - e = pickle.loads(p) - self.assertEqual(d, e) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + p = pickle.dumps(d, proto) + e = pickle.loads(p) + self.assertEqual(d, e) def test_int(self): for x in range(-250, 250): @@ -1750,12 +1751,13 @@ class DecimalPythonAPItests(unittest.TestCase): class ContextAPItests(unittest.TestCase): def test_pickle(self): - c = Context() - e = pickle.loads(pickle.dumps(c)) - for k in vars(c): - v1 = vars(c)[k] - v2 = vars(e)[k] - self.assertEqual(v1, v2) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + c = Context() + e = pickle.loads(pickle.dumps(c, proto)) + for k in vars(c): + v1 = vars(c)[k] + v2 = vars(e)[k] + self.assertEqual(v1, v2) def test_equality_with_other_types(self): self.assertIn(Decimal(10), ['a', 1.0, Decimal(10), (1,2), {}]) diff --git a/Lib/test/test_deque.py b/Lib/test/test_deque.py index 595a0c4a35..13ea02fe47 100644 --- a/Lib/test/test_deque.py +++ b/Lib/test/test_deque.py @@ -600,11 +600,12 @@ class TestSubclass(unittest.TestCase): self.assertEqual(type(d), type(e)) self.assertEqual(list(d), list(e)) - s = pickle.dumps(d) - e = pickle.loads(s) - self.assertNotEqual(id(d), id(e)) - self.assertEqual(type(d), type(e)) - self.assertEqual(list(d), list(e)) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + s = pickle.dumps(d, proto) + e = pickle.loads(s) + self.assertNotEqual(id(d), id(e)) + self.assertEqual(type(d), type(e)) + self.assertEqual(list(d), list(e)) d = Deque('abcde', maxlen=4) @@ -616,11 +617,12 @@ class TestSubclass(unittest.TestCase): self.assertEqual(type(d), type(e)) self.assertEqual(list(d), list(e)) - s = pickle.dumps(d) - e = pickle.loads(s) - self.assertNotEqual(id(d), id(e)) - self.assertEqual(type(d), type(e)) - self.assertEqual(list(d), list(e)) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + s = pickle.dumps(d, proto) + e = pickle.loads(s) + self.assertNotEqual(id(d), id(e)) + self.assertEqual(type(d), type(e)) + self.assertEqual(list(d), list(e)) ## def test_pickle(self): ## d = Deque('abc') diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py index 6f918427e4..9d62779fae 100644 --- a/Lib/test/test_descr.py +++ b/Lib/test/test_descr.py @@ -3300,7 +3300,7 @@ order (MRO) for bases """ pass for p in pickle, cPickle: - for bin in 0, 1: + for bin in range(p.HIGHEST_PROTOCOL + 1): for cls in C, C1, C2: s = p.dumps(cls, bin) cls2 = p.loads(s) @@ -3358,30 +3358,31 @@ order (MRO) for bases """ __slots__ = ['a'] class D(C): pass - try: - pickle.dumps(C()) - except TypeError: - pass - else: - self.fail("should fail: pickle C instance - %s" % base) - try: - cPickle.dumps(C()) - except TypeError: - pass - else: - self.fail("should fail: cPickle C instance - %s" % base) - try: - pickle.dumps(C()) - except TypeError: - pass - else: - self.fail("should fail: pickle D instance - %s" % base) - try: - cPickle.dumps(D()) - except TypeError: - pass - else: - self.fail("should fail: cPickle D instance - %s" % base) + for proto in range(2): + try: + pickle.dumps(C(), proto) + except TypeError: + pass + else: + self.fail("should fail: pickle C instance - %s" % base) + try: + cPickle.dumps(C(), proto) + except TypeError: + pass + else: + self.fail("should fail: cPickle C instance - %s" % base) + try: + pickle.dumps(C(), proto) + except TypeError: + pass + else: + self.fail("should fail: pickle D instance - %s" % base) + try: + cPickle.dumps(D(), proto) + except TypeError: + pass + else: + self.fail("should fail: cPickle D instance - %s" % base) # Give C a nice generic __getstate__ and __setstate__ class C(base): __slots__ = ['a'] @@ -3404,34 +3405,38 @@ order (MRO) for bases """ pass # Now it should work x = C() - y = pickle.loads(pickle.dumps(x)) - self.assertNotHasAttr(y, 'a') - y = cPickle.loads(cPickle.dumps(x)) - self.assertNotHasAttr(y, 'a') + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + y = pickle.loads(pickle.dumps(x, proto)) + self.assertNotHasAttr(y, 'a') + y = cPickle.loads(cPickle.dumps(x, proto)) + self.assertNotHasAttr(y, 'a') x.a = 42 - y = pickle.loads(pickle.dumps(x)) - self.assertEqual(y.a, 42) - y = cPickle.loads(cPickle.dumps(x)) - self.assertEqual(y.a, 42) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + y = pickle.loads(pickle.dumps(x, proto)) + self.assertEqual(y.a, 42) + y = cPickle.loads(cPickle.dumps(x, proto)) + self.assertEqual(y.a, 42) x = D() x.a = 42 x.b = 100 - y = pickle.loads(pickle.dumps(x)) - self.assertEqual(y.a + y.b, 142) - y = cPickle.loads(cPickle.dumps(x)) - self.assertEqual(y.a + y.b, 142) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + y = pickle.loads(pickle.dumps(x, proto)) + self.assertEqual(y.a + y.b, 142) + y = cPickle.loads(cPickle.dumps(x, proto)) + self.assertEqual(y.a + y.b, 142) # A subclass that adds a slot should also work class E(C): __slots__ = ['b'] x = E() x.a = 42 x.b = "foo" - y = pickle.loads(pickle.dumps(x)) - self.assertEqual(y.a, x.a) - self.assertEqual(y.b, x.b) - y = cPickle.loads(cPickle.dumps(x)) - self.assertEqual(y.a, x.a) - self.assertEqual(y.b, x.b) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + y = pickle.loads(pickle.dumps(x, proto)) + self.assertEqual(y.a, x.a) + self.assertEqual(y.b, x.b) + y = cPickle.loads(cPickle.dumps(x, proto)) + self.assertEqual(y.a, x.a) + self.assertEqual(y.b, x.b) def test_binary_operator_override(self): # Testing overrides of binary operations... diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py index 445ad9ee08..c0a9a3b8f5 100644 --- a/Lib/test/test_functools.py +++ b/Lib/test/test_functools.py @@ -146,8 +146,9 @@ class TestPartial(unittest.TestCase): def test_pickle(self): f = self.thetype(signature, 'asdf', bar=True) f.add_something_to__dict__ = True - f_copy = pickle.loads(pickle.dumps(f)) - self.assertEqual(signature(f), signature(f_copy)) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + f_copy = pickle.loads(pickle.dumps(f, proto)) + self.assertEqual(signature(f), signature(f_copy)) # Issue 6083: Reference counting bug def test_setstate_refcount(self): diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py index 5da4a6f312..e5225f2a66 100644 --- a/Lib/test/test_itertools.py +++ b/Lib/test/test_itertools.py @@ -358,7 +358,8 @@ class TestBasicOps(unittest.TestCase): c = count(value) self.assertEqual(next(copy.copy(c)), value) self.assertEqual(next(copy.deepcopy(c)), value) - self.assertEqual(next(pickle.loads(pickle.dumps(c))), value) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + self.assertEqual(next(pickle.loads(pickle.dumps(c, proto))), value) def test_count_with_stride(self): self.assertEqual(zip('abc',count(2,3)), [('a', 2), ('b', 5), ('c', 8)]) diff --git a/Lib/test/test_memoryio.py b/Lib/test/test_memoryio.py index 74a9ffb350..fdd642b3b1 100644 --- a/Lib/test/test_memoryio.py +++ b/Lib/test/test_memoryio.py @@ -376,13 +376,14 @@ class MemoryTestMixin: # the module-level. import __main__ PickleTestMemIO.__module__ = '__main__' + PickleTestMemIO.__qualname__ = PickleTestMemIO.__name__ __main__.PickleTestMemIO = PickleTestMemIO submemio = PickleTestMemIO(buf, 80) submemio.seek(2) # We only support pickle protocol 2 and onward since we use extended # __reduce__ API of PEP 307 to provide pickling support. - for proto in range(2, pickle.HIGHEST_PROTOCOL): + for proto in range(2, pickle.HIGHEST_PROTOCOL + 1): for obj in (memio, submemio): obj2 = pickle.loads(pickle.dumps(obj, protocol=proto)) self.assertEqual(obj.getvalue(), obj2.getvalue()) diff --git a/Lib/test/test_minidom.py b/Lib/test/test_minidom.py index 66973ed8a8..a962ddc1d0 100644 --- a/Lib/test/test_minidom.py +++ b/Lib/test/test_minidom.py @@ -1385,43 +1385,44 @@ class MinidomTest(unittest.TestCase): " \n" "]> text\n" " ") - s = pickle.dumps(doc) - doc2 = pickle.loads(s) - stack = [(doc, doc2)] - while stack: - n1, n2 = stack.pop() - self.confirm(n1.nodeType == n2.nodeType - and len(n1.childNodes) == len(n2.childNodes) - and n1.nodeName == n2.nodeName - and not n1.isSameNode(n2) - and not n2.isSameNode(n1)) - if n1.nodeType == Node.DOCUMENT_TYPE_NODE: - len(n1.entities) - len(n2.entities) - len(n1.notations) - len(n2.notations) - self.confirm(len(n1.entities) == len(n2.entities) - and len(n1.notations) == len(n2.notations)) - for i in range(len(n1.notations)): - # XXX this loop body doesn't seem to be executed? - no1 = n1.notations.item(i) - no2 = n1.notations.item(i) - self.confirm(no1.name == no2.name - and no1.publicId == no2.publicId - and no1.systemId == no2.systemId) - stack.append((no1, no2)) - for i in range(len(n1.entities)): - e1 = n1.entities.item(i) - e2 = n2.entities.item(i) - self.confirm(e1.notationName == e2.notationName - and e1.publicId == e2.publicId - and e1.systemId == e2.systemId) - stack.append((e1, e2)) - if n1.nodeType != Node.DOCUMENT_NODE: - self.confirm(n1.ownerDocument.isSameNode(doc) - and n2.ownerDocument.isSameNode(doc2)) - for i in range(len(n1.childNodes)): - stack.append((n1.childNodes[i], n2.childNodes[i])) + for proto in range(2, pickle.HIGHEST_PROTOCOL + 1): + s = pickle.dumps(doc, proto) + doc2 = pickle.loads(s) + stack = [(doc, doc2)] + while stack: + n1, n2 = stack.pop() + self.confirm(n1.nodeType == n2.nodeType + and len(n1.childNodes) == len(n2.childNodes) + and n1.nodeName == n2.nodeName + and not n1.isSameNode(n2) + and not n2.isSameNode(n1)) + if n1.nodeType == Node.DOCUMENT_TYPE_NODE: + len(n1.entities) + len(n2.entities) + len(n1.notations) + len(n2.notations) + self.confirm(len(n1.entities) == len(n2.entities) + and len(n1.notations) == len(n2.notations)) + for i in range(len(n1.notations)): + # XXX this loop body doesn't seem to be executed? + no1 = n1.notations.item(i) + no2 = n1.notations.item(i) + self.confirm(no1.name == no2.name + and no1.publicId == no2.publicId + and no1.systemId == no2.systemId) + stack.append((no1, no2)) + for i in range(len(n1.entities)): + e1 = n1.entities.item(i) + e2 = n2.entities.item(i) + self.confirm(e1.notationName == e2.notationName + and e1.publicId == e2.publicId + and e1.systemId == e2.systemId) + stack.append((e1, e2)) + if n1.nodeType != Node.DOCUMENT_NODE: + self.confirm(n1.ownerDocument.isSameNode(doc) + and n2.ownerDocument.isSameNode(doc2)) + for i in range(len(n1.childNodes)): + stack.append((n1.childNodes[i], n2.childNodes[i])) def testSerializeCommentNodeWithDoubleHyphen(self): doc = create_doc_without_doctype() diff --git a/Lib/test/test_random.py b/Lib/test/test_random.py index 1a5a86b9e2..250f443d16 100644 --- a/Lib/test/test_random.py +++ b/Lib/test/test_random.py @@ -140,11 +140,12 @@ class TestBasicOps(unittest.TestCase): self.assertEqual(y1, y2) def test_pickling(self): - state = pickle.dumps(self.gen) - origseq = [self.gen.random() for i in xrange(10)] - newgen = pickle.loads(state) - restoredseq = [newgen.random() for i in xrange(10)] - self.assertEqual(origseq, restoredseq) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + state = pickle.dumps(self.gen, proto) + origseq = [self.gen.random() for i in xrange(10)] + newgen = pickle.loads(state) + restoredseq = [newgen.random() for i in xrange(10)] + self.assertEqual(origseq, restoredseq) def test_bug_1727780(self): # verify that version-2-pickles can be loaded @@ -226,7 +227,8 @@ class SystemRandom_TestBasicOps(TestBasicOps): self.assertEqual(self.gen.gauss_next, None) def test_pickling(self): - self.assertRaises(NotImplementedError, pickle.dumps, self.gen) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + self.assertRaises(NotImplementedError, pickle.dumps, self.gen, proto) def test_53_bits_per_float(self): # This should pass whenever a C double has 53 bit precision. diff --git a/Lib/test/test_set.py b/Lib/test/test_set.py index 610be7c436..dd652023ee 100644 --- a/Lib/test/test_set.py +++ b/Lib/test/test_set.py @@ -233,7 +233,7 @@ class TestJointOps(unittest.TestCase): self.assertEqual(self.s, dup, "%s != %s" % (self.s, dup)) if type(self.s) not in (set, frozenset): self.s.x = 10 - p = pickle.dumps(self.s) + p = pickle.dumps(self.s, i) dup = pickle.loads(p) self.assertEqual(self.s.x, dup.x) @@ -786,10 +786,11 @@ class TestBasicOps(unittest.TestCase): self.assertEqual(setiter.__length_hint__(), len(self.set)) def test_pickling(self): - p = pickle.dumps(self.set) - copy = pickle.loads(p) - self.assertEqual(self.set, copy, - "%s != %s" % (self.set, copy)) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + p = pickle.dumps(self.set, proto) + copy = pickle.loads(p) + self.assertEqual(self.set, copy, + "%s != %s" % (self.set, copy)) #------------------------------------------------------------------------------ diff --git a/Lib/test/test_sets.py b/Lib/test/test_sets.py index 319bdcb5fb..0a899081f2 100644 --- a/Lib/test/test_sets.py +++ b/Lib/test/test_sets.py @@ -75,10 +75,11 @@ class TestBasicOps(unittest.TestCase): self.assertIn(v, self.values) def test_pickling(self): - p = pickle.dumps(self.set) - copy = pickle.loads(p) - self.assertEqual(self.set, copy, - "%s != %s" % (self.set, copy)) + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + p = pickle.dumps(self.set, proto) + copy = pickle.loads(p) + self.assertEqual(self.set, copy, + "%s != %s" % (self.set, copy)) #------------------------------------------------------------------------------ -- 2.50.1