From 4d2cf5587cd02e9642b0abea8450ab1ee5e5fde8 Mon Sep 17 00:00:00 2001 From: Serhiy Storchaka Date: Tue, 29 Sep 2015 15:36:28 +0300 Subject: Moved unpickling tests with prepickled data to separate class. --- Lib/test/pickletester.py | 83 ++++++++++++++++++++++++++---------------------- Lib/test/test_cpickle.py | 35 ++++++++++++++++---- Lib/test/test_pickle.py | 17 ++++++++-- 3 files changed, 88 insertions(+), 47 deletions(-) diff --git a/Lib/test/pickletester.py b/Lib/test/pickletester.py index 1599893..7c1f403 100644 --- a/Lib/test/pickletester.py +++ b/Lib/test/pickletester.py @@ -420,11 +420,54 @@ def create_data(): x.append(5) return x -class AbstractPickleTests(unittest.TestCase): - # Subclass must define self.dumps, self.loads, self.error. + +class AbstractUnpickleTests(unittest.TestCase): + # Subclass must define self.loads, self.error. _testdata = create_data() + def test_load_from_canned_string(self): + expected = self._testdata + for canned in DATA0, DATA1, DATA2: + got = self.loads(canned) + self.assertEqual(expected, got) + + def test_garyp(self): + self.assertRaises(self.error, self.loads, 'garyp') + + def test_maxint64(self): + maxint64 = (1L << 63) - 1 + data = 'I' + str(maxint64) + '\n.' + got = self.loads(data) + self.assertEqual(got, maxint64) + + # Try too with a bogus literal. + data = 'I' + str(maxint64) + 'JUNK\n.' + self.assertRaises(ValueError, self.loads, data) + + def test_insecure_strings(self): + insecure = ["abc", "2 + 2", # not quoted + #"'abc' + 'def'", # not a single quoted string + "'abc", # quote is not closed + "'abc\"", # open quote and close quote don't match + "'abc' ?", # junk after close quote + "'\\'", # trailing backslash + "'", # issue #17710 + "' ", # issue #17710 + # some tests of the quoting rules + #"'abc\"\''", + #"'\\\\a\'\'\'\\\'\\\\\''", + ] + for s in insecure: + buf = "S" + s + "\012p0\012." + self.assertRaises(ValueError, self.loads, buf) + + +class AbstractPickleTests(unittest.TestCase): + # Subclass must define self.dumps, self.loads. + + _testdata = AbstractUnpickleTests._testdata + def setUp(self): pass @@ -455,12 +498,6 @@ class AbstractPickleTests(unittest.TestCase): got = self.loads(s) self.assertEqual(expected, got) - def test_load_from_canned_string(self): - expected = self._testdata - for canned in DATA0, DATA1, DATA2: - got = self.loads(canned) - self.assertEqual(expected, got) - # There are gratuitous differences between pickles produced by # pickle and cPickle, largely because cPickle starts PUT indices at # 1 and pickle starts them at 0. See XXX comment in cPickle's put2() -- @@ -528,26 +565,6 @@ class AbstractPickleTests(unittest.TestCase): self.assertEqual(x[0].attr.keys(), [1]) self.assertTrue(x[0].attr[1] is x) - def test_garyp(self): - self.assertRaises(self.error, self.loads, 'garyp') - - def test_insecure_strings(self): - insecure = ["abc", "2 + 2", # not quoted - #"'abc' + 'def'", # not a single quoted string - "'abc", # quote is not closed - "'abc\"", # open quote and close quote don't match - "'abc' ?", # junk after close quote - "'\\'", # trailing backslash - "'", # issue #17710 - "' ", # issue #17710 - # some tests of the quoting rules - #"'abc\"\''", - #"'\\\\a\'\'\'\\\'\\\\\''", - ] - for s in insecure: - buf = "S" + s + "\012p0\012." - self.assertRaises(ValueError, self.loads, buf) - if have_unicode: def test_unicode(self): endcases = [u'', u'<\\u>', u'<\\\u1234>', u'<\n>', @@ -576,16 +593,6 @@ class AbstractPickleTests(unittest.TestCase): self.assertEqual(expected, n2) n = n >> 1 - def test_maxint64(self): - maxint64 = (1L << 63) - 1 - data = 'I' + str(maxint64) + '\n.' - got = self.loads(data) - self.assertEqual(got, maxint64) - - # Try too with a bogus literal. - data = 'I' + str(maxint64) + 'JUNK\n.' - self.assertRaises(ValueError, self.loads, data) - def test_long(self): for proto in protocols: # 256 bytes is where LONG4 begins. diff --git a/Lib/test/test_cpickle.py b/Lib/test/test_cpickle.py index 3bc700b..f6b3347 100644 --- a/Lib/test/test_cpickle.py +++ b/Lib/test/test_cpickle.py @@ -2,7 +2,8 @@ import cPickle import cStringIO import io import unittest -from test.pickletester import (AbstractPickleTests, +from test.pickletester import (AbstractUnpickleTests, + AbstractPickleTests, AbstractPickleModuleTests, AbstractPicklerUnpicklerObjectTests, BigmemPickleTests) @@ -40,7 +41,8 @@ class FileIOMixin: test_support.unlink(test_support.TESTFN) -class cPickleTests(AbstractPickleTests, AbstractPickleModuleTests): +class cPickleTests(AbstractUnpickleTests, AbstractPickleTests, + AbstractPickleModuleTests): def setUp(self): self.dumps = cPickle.dumps @@ -49,6 +51,28 @@ class cPickleTests(AbstractPickleTests, AbstractPickleModuleTests): error = cPickle.BadPickleGet module = cPickle +class cPickleUnpicklerTests(AbstractUnpickleTests): + + def loads(self, buf): + f = self.input(buf) + try: + p = cPickle.Unpickler(f) + return p.load() + finally: + self.close(f) + + error = cPickle.BadPickleGet + +class cStringIOCUnpicklerTests(cStringIOMixin, cPickleUnpicklerTests): + pass + +class BytesIOCUnpicklerTests(BytesIOMixin, cPickleUnpicklerTests): + pass + +class FileIOCUnpicklerTests(FileIOMixin, cPickleUnpicklerTests): + pass + + class cPicklePicklerTests(AbstractPickleTests): def dumps(self, arg, proto=0): @@ -69,8 +93,6 @@ class cPicklePicklerTests(AbstractPickleTests): finally: self.close(f) - error = cPickle.BadPickleGet - class cStringIOCPicklerTests(cStringIOMixin, cPicklePicklerTests): pass @@ -129,8 +151,6 @@ class cPickleFastPicklerTests(AbstractPickleTests): finally: self.close(f) - error = cPickle.BadPickleGet - def test_recursive_list(self): self.assertRaises(ValueError, AbstractPickleTests.test_recursive_list, @@ -219,6 +239,9 @@ class cPickleDeepRecursive(unittest.TestCase): def test_main(): test_support.run_unittest( cPickleTests, + cStringIOCUnpicklerTests, + BytesIOCUnpicklerTests, + FileIOCUnpicklerTests, cStringIOCPicklerTests, BytesIOCPicklerTests, FileIOCPicklerTests, diff --git a/Lib/test/test_pickle.py b/Lib/test/test_pickle.py index c312649..2db7589 100644 --- a/Lib/test/test_pickle.py +++ b/Lib/test/test_pickle.py @@ -3,13 +3,15 @@ from cStringIO import StringIO from test import test_support -from test.pickletester import (AbstractPickleTests, +from test.pickletester import (AbstractUnpickleTests, + AbstractPickleTests, AbstractPickleModuleTests, AbstractPersistentPicklerTests, AbstractPicklerUnpicklerObjectTests, BigmemPickleTests) -class PickleTests(AbstractPickleTests, AbstractPickleModuleTests): +class PickleTests(AbstractUnpickleTests, AbstractPickleTests, + AbstractPickleModuleTests): def dumps(self, arg, proto=0, fast=0): # Ignore fast @@ -22,10 +24,18 @@ class PickleTests(AbstractPickleTests, AbstractPickleModuleTests): module = pickle error = KeyError -class PicklerTests(AbstractPickleTests): +class UnpicklerTests(AbstractUnpickleTests): error = KeyError + def loads(self, buf): + f = StringIO(buf) + u = pickle.Unpickler(f) + return u.load() + + +class PicklerTests(AbstractPickleTests): + def dumps(self, arg, proto=0, fast=0): f = StringIO() p = pickle.Pickler(f, proto) @@ -81,6 +91,7 @@ class PickleBigmemPickleTests(BigmemPickleTests): def test_main(): test_support.run_unittest( PickleTests, + UnpicklerTests, PicklerTests, PersPicklerTests, PicklerUnpicklerObjectTests, -- cgit v0.12