home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2004 #2 / K-CD-2-2004.ISO / OpenOffice Sv / f_0397 / python-core-2.2.2 / lib / test / pickletester.py < prev    next >
Encoding:
Python Source  |  2003-07-18  |  6.9 KB  |  286 lines
  1. import unittest
  2. from test_support import TestFailed, have_unicode
  3.  
  4. class C:
  5.     def __cmp__(self, other):
  6.         return cmp(self.__dict__, other.__dict__)
  7.  
  8. import __main__
  9. __main__.C = C
  10. C.__module__ = "__main__"
  11.  
  12. class myint(int):
  13.     def __init__(self, x):
  14.         self.str = str(x)
  15.  
  16. class initarg(C):
  17.  
  18.     __safe_for_unpickling__ = 1
  19.  
  20.     def __init__(self, a, b):
  21.         self.a = a
  22.         self.b = b
  23.  
  24.     def __getinitargs__(self):
  25.         return self.a, self.b
  26.  
  27. class metaclass(type):
  28.     pass
  29.  
  30. class use_metaclass(object):
  31.     __metaclass__ = metaclass
  32.  
  33. # break into multiple strings to avoid confusing font-lock-mode
  34. DATA = """(lp1
  35. I0
  36. aL1L
  37. aF2
  38. ac__builtin__
  39. complex
  40. p2
  41. """ + \
  42. """(F3
  43. F0
  44. tRp3
  45. aI1
  46. aI-1
  47. aI255
  48. aI-255
  49. aI-256
  50. aI65535
  51. aI-65535
  52. aI-65536
  53. aI2147483647
  54. aI-2147483647
  55. aI-2147483648
  56. a""" + \
  57. """(S'abc'
  58. p4
  59. g4
  60. """ + \
  61. """(i__main__
  62. C
  63. p5
  64. """ + \
  65. """(dp6
  66. S'foo'
  67. p7
  68. I1
  69. sS'bar'
  70. p8
  71. I2
  72. sbg5
  73. tp9
  74. ag9
  75. aI5
  76. a.
  77. """
  78.  
  79. BINDATA = ']q\x01(K\x00L1L\nG@\x00\x00\x00\x00\x00\x00\x00' + \
  80.           'c__builtin__\ncomplex\nq\x02(G@\x08\x00\x00\x00\x00\x00' + \
  81.           '\x00G\x00\x00\x00\x00\x00\x00\x00\x00tRq\x03K\x01J\xff\xff' + \
  82.           '\xff\xffK\xffJ\x01\xff\xff\xffJ\x00\xff\xff\xffM\xff\xff' + \
  83.           'J\x01\x00\xff\xffJ\x00\x00\xff\xffJ\xff\xff\xff\x7fJ\x01\x00' + \
  84.           '\x00\x80J\x00\x00\x00\x80(U\x03abcq\x04h\x04(c__main__\n' + \
  85.           'C\nq\x05oq\x06}q\x07(U\x03fooq\x08K\x01U\x03barq\tK\x02ubh' + \
  86.           '\x06tq\nh\nK\x05e.'
  87.  
  88. def create_data():
  89.     c = C()
  90.     c.foo = 1
  91.     c.bar = 2
  92.     x = [0, 1L, 2.0, 3.0+0j]
  93.     # Append some integer test cases at cPickle.c's internal size
  94.     # cutoffs.
  95.     uint1max = 0xff
  96.     uint2max = 0xffff
  97.     int4max = 0x7fffffff
  98.     x.extend([1, -1,
  99.               uint1max, -uint1max, -uint1max-1,
  100.               uint2max, -uint2max, -uint2max-1,
  101.                int4max,  -int4max,  -int4max-1])
  102.     y = ('abc', 'abc', c, c)
  103.     x.append(y)
  104.     x.append(y)
  105.     x.append(5)
  106.     return x
  107.  
  108. class AbstractPickleTests(unittest.TestCase):
  109.  
  110.     _testdata = create_data()
  111.  
  112.     def setUp(self):
  113.         # subclass must define self.dumps, self.loads, self.error
  114.         pass
  115.  
  116.     def test_misc(self):
  117.         # test various datatypes not tested by testdata
  118.         x = myint(4)
  119.         s = self.dumps(x)
  120.         y = self.loads(s)
  121.         self.assertEqual(x, y)
  122.  
  123.         x = (1, ())
  124.         s = self.dumps(x)
  125.         y = self.loads(s)
  126.         self.assertEqual(x, y)
  127.  
  128.         x = initarg(1, x)
  129.         s = self.dumps(x)
  130.         y = self.loads(s)
  131.         self.assertEqual(x, y)
  132.  
  133.         # XXX test __reduce__ protocol?
  134.  
  135.     def test_identity(self):
  136.         s = self.dumps(self._testdata)
  137.         x = self.loads(s)
  138.         self.assertEqual(x, self._testdata)
  139.  
  140.     def test_constant(self):
  141.         x = self.loads(DATA)
  142.         self.assertEqual(x, self._testdata)
  143.         x = self.loads(BINDATA)
  144.         self.assertEqual(x, self._testdata)
  145.  
  146.     def test_binary(self):
  147.         s = self.dumps(self._testdata, 1)
  148.         x = self.loads(s)
  149.         self.assertEqual(x, self._testdata)
  150.  
  151.     def test_recursive_list(self):
  152.         l = []
  153.         l.append(l)
  154.         s = self.dumps(l)
  155.         x = self.loads(s)
  156.         self.assertEqual(x, l)
  157.         self.assertEqual(x, x[0])
  158.         self.assertEqual(id(x), id(x[0]))
  159.  
  160.     def test_recursive_dict(self):
  161.         d = {}
  162.         d[1] = d
  163.         s = self.dumps(d)
  164.         x = self.loads(s)
  165.         self.assertEqual(x, d)
  166.         self.assertEqual(x[1], x)
  167.         self.assertEqual(id(x[1]), id(x))
  168.  
  169.     def test_recursive_inst(self):
  170.         i = C()
  171.         i.attr = i
  172.         s = self.dumps(i)
  173.         x = self.loads(s)
  174.         self.assertEqual(x, i)
  175.         self.assertEqual(x.attr, x)
  176.         self.assertEqual(id(x.attr), id(x))
  177.  
  178.     def test_recursive_multi(self):
  179.         l = []
  180.         d = {1:l}
  181.         i = C()
  182.         i.attr = d
  183.         l.append(i)
  184.         s = self.dumps(l)
  185.         x = self.loads(s)
  186.         self.assertEqual(x, l)
  187.         self.assertEqual(x[0], i)
  188.         self.assertEqual(x[0].attr, d)
  189.         self.assertEqual(x[0].attr[1], x)
  190.         self.assertEqual(x[0].attr[1][0], i)
  191.         self.assertEqual(x[0].attr[1][0].attr, d)
  192.  
  193.     def test_garyp(self):
  194.         self.assertRaises(self.error, self.loads, 'garyp')
  195.  
  196.     def test_insecure_strings(self):
  197.         insecure = ["abc", "2 + 2", # not quoted
  198.                     "'abc' + 'def'", # not a single quoted string
  199.                     "'abc", # quote is not closed
  200.                     "'abc\"", # open quote and close quote don't match
  201.                     "'abc'   ?", # junk after close quote
  202.                     # some tests of the quoting rules
  203.                     "'abc\"\''",
  204.                     "'\\\\a\'\'\'\\\'\\\\\''",
  205.                     ]
  206.         for s in insecure:
  207.             buf = "S" + s + "\012p0\012."
  208.             self.assertRaises(ValueError, self.loads, buf)
  209.  
  210.     if have_unicode:
  211.         def test_unicode(self):
  212.             endcases = [unicode(''), unicode('<\\u>'), unicode('<\\\u1234>'),
  213.                         unicode('<\n>'),  unicode('<\\>')]
  214.             for u in endcases:
  215.                 p = self.dumps(u)
  216.                 u2 = self.loads(p)
  217.                 self.assertEqual(u2, u)
  218.  
  219.     def test_ints(self):
  220.         import sys
  221.         n = sys.maxint
  222.         while n:
  223.             for expected in (-n, n):
  224.                 s = self.dumps(expected)
  225.                 n2 = self.loads(s)
  226.                 self.assertEqual(expected, n2)
  227.             n = n >> 1
  228.  
  229.     def test_maxint64(self):
  230.         maxint64 = (1L << 63) - 1
  231.         data = 'I' + str(maxint64) + '\n.'
  232.         got = self.loads(data)
  233.         self.assertEqual(got, maxint64)
  234.  
  235.         # Try too with a bogus literal.
  236.         data = 'I' + str(maxint64) + 'JUNK\n.'
  237.         self.assertRaises(ValueError, self.loads, data)
  238.  
  239.     def test_reduce(self):
  240.         pass
  241.  
  242.     def test_getinitargs(self):
  243.         pass
  244.  
  245.     def test_metaclass(self):
  246.         a = use_metaclass()
  247.         s = self.dumps(a)
  248.         b = self.loads(s)
  249.         self.assertEqual(a.__class__, b.__class__)
  250.  
  251.     def test_structseq(self):
  252.         import time
  253.         t = time.localtime()
  254.         s = self.dumps(t)
  255.         u = self.loads(s)
  256.         self.assertEqual(t, u)
  257.         import os
  258.         if hasattr(os, "stat"):
  259.             t = os.stat(os.curdir)
  260.             s = self.dumps(t)
  261.             u = self.loads(s)
  262.             self.assertEqual(t, u)
  263.         if hasattr(os, "statvfs"):
  264.             t = os.statvfs(os.curdir)
  265.             s = self.dumps(t)
  266.             u = self.loads(s)
  267.             self.assertEqual(t, u)
  268.  
  269. class AbstractPickleModuleTests(unittest.TestCase):
  270.  
  271.     def test_dump_closed_file(self):
  272.         import tempfile, os
  273.         fn = tempfile.mktemp()
  274.         f = open(fn, "w")
  275.         f.close()
  276.         self.assertRaises(ValueError, self.module.dump, 123, f)
  277.         os.remove(fn)
  278.  
  279.     def test_load_closed_file(self):
  280.         import tempfile, os
  281.         fn = tempfile.mktemp()
  282.         f = open(fn, "w")
  283.         f.close()
  284.         self.assertRaises(ValueError, self.module.dump, 123, f)
  285.         os.remove(fn)
  286.