Lib/test/test_cpickle.py

   1 import cPickle
   2 import unittest
   3 from cStringIO import StringIO
   4 from pickletester import AbstractPickleTests, AbstractPickleModuleTests
   5 from test import test_support
   6
   7 class cPickleTests(AbstractPickleTests, AbstractPickleModuleTests):
   8
   9     def setUp(self):
  10         self.dumps = cPickle.dumps
  11         self.loads = cPickle.loads
  12
  13     error = cPickle.BadPickleGet
  14     module = cPickle
  15
  16 class cPicklePicklerTests(AbstractPickleTests):
  17
  18     def dumps(self, arg, proto=0):
  19         f = StringIO()
  20         p = cPickle.Pickler(f, proto)
  21         p.dump(arg)
  22         f.seek(0)
  23         return f.read()
  24
  25     def loads(self, buf):
  26         f = StringIO(buf)
  27         p = cPickle.Unpickler(f)
  28         return p.load()
  29
  30     error = cPickle.BadPickleGet
  31
  32 class cPickleListPicklerTests(AbstractPickleTests):
  33
  34     def dumps(self, arg, proto=0):
  35         p = cPickle.Pickler(proto)
  36         p.dump(arg)
  37         return p.getvalue()
  38
  39     def loads(self, *args):
  40         f = StringIO(args[0])
  41         p = cPickle.Unpickler(f)
  42         return p.load()
  43
  44     error = cPickle.BadPickleGet
  45
  46 class cPickleFastPicklerTests(AbstractPickleTests):
  47
  48     def dumps(self, arg, proto=0):
  49         f = StringIO()
  50         p = cPickle.Pickler(f, proto)
  51         p.fast = 1
  52         p.dump(arg)
  53         f.seek(0)
  54         return f.read()
  55
  56     def loads(self, *args):
  57         f = StringIO(args[0])
  58         p = cPickle.Unpickler(f)
  59         return p.load()
  60
  61     error = cPickle.BadPickleGet
  62
  63     def test_recursive_list(self):
  64         self.assertRaises(ValueError,
  65                           AbstractPickleTests.test_recursive_list,
  66                           self)
  67
  68     def test_recursive_inst(self):
  69         self.assertRaises(ValueError,
  70                           AbstractPickleTests.test_recursive_inst,
  71                           self)
  72
  73     def test_recursive_dict(self):
  74         self.assertRaises(ValueError,
  75                           AbstractPickleTests.test_recursive_dict,
  76                           self)
  77
  78     def test_recursive_multi(self):
  79         self.assertRaises(ValueError,
  80                           AbstractPickleTests.test_recursive_multi,
  81                           self)
  82
  83     def test_nonrecursive_deep(self):
  84         # If it's not cyclic, it should pickle OK even if the nesting
  85         # depth exceeds PY_CPICKLE_FAST_LIMIT.  That happens to be
  86         # 50 today.  Jack Jansen reported stack overflow on Mac OS 9
  87         # at 64.
  88         a = []
  89         for i in range(60):
  90             a = [a]
  91         b = self.loads(self.dumps(a))
  92         self.assertEqual(a, b)
  93
  94 def test_main():
  95     loader = unittest.TestLoader()
  96     suite = unittest.TestSuite()
  97     suite.addTest(loader.loadTestsFromTestCase(cPickleTests))
  98     suite.addTest(loader.loadTestsFromTestCase(cPicklePicklerTests))
  99     suite.addTest(loader.loadTestsFromTestCase(cPickleListPicklerTests))
 100     suite.addTest(loader.loadTestsFromTestCase(cPickleFastPicklerTests))
 101     test_support.run_suite(suite)
 102
 103 if __name__ == "__main__":
 104     test_main()