993128623

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/zopefoundation/zodbpickle/commit/<a class=hub.com/zopefoundation/zodbpickle/commit/<a class="double-link" href="https://git"><a class=hub.com/zopefoundation/zodbpickle/commit/<a class="double-link" href="https://git"><a class=hub.com/zopefoundation/zodbpickle/commit/<a class="double-link" href="https://git"><a class=hub.com/zopefoundation/zodbpickle/commit/5ba47773b986e847210076136bf5371ebd53c1db">5ba47773b">&lt;a href=&quot;https://github.com/zopefoundation/zodbpickle/commit/</a><a class="double-link" href="https://github.com/zopefoundation/zodbpickle/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/zopefoundation/zodbpickle/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/zopefoundation/zodbpickle/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/zopefoundation/zodbpickle/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/zopefoundation/zodbpickle/commit/5ba47773b986e847210076136bf5371ebd53c1db">5ba47773b</a><a href="https://github.com/zopefoundation/zodbpickle/commit/5ba47773b986e847210076136bf5371ebd53c1db">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/zopefoundation/zodbpickle/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/zopefoundation/zodbpickle/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/zopefoundation/zodbpickle/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/zopefoundation/zodbpickle/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/zopefoundation/zodbpickle/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/zopefoundation/zodbpickle/commit/5ba47773b986e847210076136bf5371ebd53c1db&quot;&gt;5ba47773b&lt;/a&gt;&lt;a href=&quot;https://github.com/zopefoundation/zodbpickle/commit/5ba47773b986e847210076136bf5371ebd53c1db&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/zopefoundation/zodbpickle/commit/&amp;lt;/a&... (continued)

Pull Request Pull Request #63: Config with c code

Run Details

626 of 874 branches covered (71.62%)

Branch coverage included in aggregate %.

95 of 133 new or added lines in 8 files covered. (71.43%)

2901 of 3347 relevant lines covered (86.67%)

4.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.19

/src/zodbpickle/tests/test_pickle_2.py

import cStringIO
import io
import unittest

from .pickletester_2 import (AbstractPickleTests,
                             AbstractPickleModuleTests,
                             AbstractPersistentPicklerTests,
                             AbstractPicklerUnpicklerObjectTests,
                             BigmemPickleTests,
                             has_c_implementation)

from test import test_support


class cStringIOMixin:
    output = input = cStringIO.StringIO

    def close(self, f):
        pass


class BytesIOMixin:
    output = input = io.BytesIO

    def close(self, f):
        pass


class FileIOMixin:

    def output(self):
        return open(test_support.TESTFN, 'wb+')

    def input(self, data):
        f = open(test_support.TESTFN, 'wb+')
        try:
            f.write(data)
            f.seek(0)
            return f
        except BaseException:
            f.close()
            raise

    def close(self, f):
        f.close()
        test_support.unlink(test_support.TESTFN)


class PickleTests(AbstractPickleTests, AbstractPickleModuleTests):

    def dumps(self, arg, proto=0, fast=0):
        from zodbpickle.pickle_2 import dumps
        # Ignore fast
        return dumps(arg, proto)

    def loads(self, buf):
        from zodbpickle.pickle_2 import loads
        # Ignore fast
        return loads(buf)

    @property
    def module(self):
        from zodbpickle import pickle_2
        return pickle_2

    error = KeyError


class PicklerTests(AbstractPickleTests):

    error = KeyError

    def dumps(self, arg, proto=0, fast=0):
        from zodbpickle.pickle_2 import Pickler
        f = cStringIO.StringIO()
        p = Pickler(f, proto)
        if fast:
            p.fast = fast
        p.dump(arg)
        f.seek(0)
        return f.read()

    def loads(self, buf):
        from zodbpickle.pickle_2 import Unpickler
        f = cStringIO.StringIO(buf)
        u = Unpickler(f)
        return u.load()


class PersPicklerTests(AbstractPersistentPicklerTests):

    def dumps(self, arg, proto=0, fast=0):
        from zodbpickle.pickle_2 import Pickler

        class PersPickler(Pickler):
            def persistent_id(subself, obj):
                return self.persistent_id(obj)
        f = cStringIO.StringIO()
        p = PersPickler(f, proto)
        if fast:
            p.fast = fast
        p.dump(arg)
        f.seek(0)
        return f.read()

    def loads(self, buf):
        from zodbpickle.pickle_2 import Unpickler

        class PersUnpickler(Unpickler):
            def persistent_load(subself, obj):
                return self.persistent_load(obj)
        f = cStringIO.StringIO(buf)
        u = PersUnpickler(f)
        return u.load()


class PicklerUnpicklerObjectTests(AbstractPicklerUnpicklerObjectTests):

    @property
    def pickler_class(self):
        from zodbpickle.pickle_2 import Pickler
        return Pickler

    @property
    def unpickler_class(self):
        from zodbpickle.pickle_2 import Unpickler
        return Unpickler


class PickleBigmemPickleTests(BigmemPickleTests):

    def dumps(self, arg, proto=0, fast=0):
        from zodbpickle import pickle_2
        # Ignore fast
        return pickle_2.dumps(arg, proto)

    def loads(self, buf):
        from zodbpickle import pickle_2
        # Ignore fast
        return pickle_2.loads(buf)


class cPickleBase(object):

    @property
    def error(self):
        from zodbpickle._pickle import BadPickleGet
        return BadPickleGet


class cPickleTests(AbstractPickleTests,
                   AbstractPickleModuleTests,
                   cPickleBase,
                   ):
    def setUp(self):
        from zodbpickle._pickle import dumps
        from zodbpickle._pickle import loads
        self.dumps = dumps
        self.loads = loads

    @property
    def module(self):
        from zodbpickle import _pickle
        return _pickle


class cPicklePicklerTests(AbstractPickleTests, cPickleBase):

    def dumps(self, arg, proto=0):
        from zodbpickle import _pickle
        f = self.output()
        try:
            p = _pickle.Pickler(f, proto)
            p.dump(arg)
            f.seek(0)
            return f.read()
        finally:
            self.close(f)

    def loads(self, buf):
        from zodbpickle import _pickle
        f = self.input(buf)
        try:
            p = _pickle.Unpickler(f)
            return p.load()
        finally:
            self.close(f)


class cStringIOCPicklerTests(cStringIOMixin, cPicklePicklerTests):
    pass


class BytesIOCPicklerTests(BytesIOMixin, cPicklePicklerTests):
    pass


class FileIOCPicklerTests(FileIOMixin, cPicklePicklerTests):
    pass


class cPickleListPicklerTests(AbstractPickleTests, cPickleBase):

    def dumps(self, arg, proto=0):
        from zodbpickle import _pickle
        p = _pickle.Pickler(proto)
        p.dump(arg)
        return p.getvalue()

    def loads(self, *args):
        from zodbpickle import _pickle
        f = self.input(args[0])
        try:
            p = _pickle.Unpickler(f)
            return p.load()
        finally:
            self.close(f)


class cStringIOCPicklerListTests(cStringIOMixin, cPickleListPicklerTests):
    pass


class BytesIOCPicklerListTests(BytesIOMixin, cPickleListPicklerTests):
    pass


class FileIOCPicklerListTests(FileIOMixin, cPickleListPicklerTests):
    pass


class cPickleFastPicklerTests(AbstractPickleTests, cPickleBase):

    def dumps(self, arg, proto=0):
        from zodbpickle import _pickle
        f = self.output()
        try:
            p = _pickle.Pickler(f, proto)
            p.fast = 1
            p.dump(arg)
            f.seek(0)
            return f.read()
        finally:
            self.close(f)

    def loads(self, *args):
        from zodbpickle import _pickle
        f = self.input(args[0])
        try:
            p = _pickle.Unpickler(f)
            return p.load()
        finally:
            self.close(f)

    def test_recursive_list(self):
        self.assertRaises(ValueError,
                          AbstractPickleTests.test_recursive_list,
                          self)

    def test_recursive_tuple(self):
        self.assertRaises(ValueError,
                          AbstractPickleTests.test_recursive_tuple,
                          self)

    def test_recursive_inst(self):
        self.assertRaises(ValueError,
                          AbstractPickleTests.test_recursive_inst,
                          self)

    def test_recursive_dict(self):
        self.assertRaises(ValueError,
                          AbstractPickleTests.test_recursive_dict,
                          self)

    def test_recursive_multi(self):
        self.assertRaises(ValueError,
                          AbstractPickleTests.test_recursive_multi,
                          self)

    def test_nonrecursive_deep(self):
        # If it's not cyclic, it should pickle OK even if the nesting
        # depth exceeds PY_CPICKLE_FAST_LIMIT.  That happens to be
        # 50 today.  Jack Jansen reported stack overflow on Mac OS 9
        # at 64.
        a = []
        for i in range(60):
            a = [a]
        b = self.loads(self.dumps(a))
        self.assertEqual(a, b)


class cStringIOCPicklerFastTests(cStringIOMixin, cPickleFastPicklerTests):
    pass


class BytesIOCPicklerFastTests(BytesIOMixin, cPickleFastPicklerTests):
    pass


class FileIOCPicklerFastTests(FileIOMixin, cPickleFastPicklerTests):
    pass


class cPicklePicklerUnpicklerObjectTests(AbstractPicklerUnpicklerObjectTests):

    @property
    def pickler_class(self):
        from zodbpickle._pickle import Pickler
        return Pickler

    @property
    def unpickler_class(self):
        from zodbpickle._pickle import Unpickler
        return Unpickler


class cPickleBigmemPickleTests(BigmemPickleTests):

    def dumps(self, arg, proto=0, fast=0):
        from zodbpickle import _pickle
        # Ignore fast
        return _pickle.dumps(arg, proto)

    def loads(self, buf):
        from zodbpickle import _pickle
        # Ignore fast
        return _pickle.loads(buf)


class Node(object):
    pass


class cPickleDeepRecursive(unittest.TestCase):

    def test_issue2702(self):
        # This should raise a RecursionLimit but in some
        # platforms (FreeBSD, win32) sometimes raises KeyError instead,
        # or just silently terminates the interpreter (=crashes).
        from zodbpickle import _pickle
        nodes = [Node() for i in range(500)]
        for n in nodes:
            n.connections = list(nodes)
            n.connections.remove(n)
        self.assertRaises((AttributeError, RuntimeError), _pickle.dumps, n)

    def test_issue3179(self):
        # Safe test, because I broke this case when fixing the
        # behaviour for the previous test.
        from zodbpickle import _pickle
        res = []
        for x in range(1, 2000):
            res.append(dict(doc=x, similar=[]))
        _pickle.dumps(res)


class BinaryTests(unittest.TestCase):

    def test_has_no_attrs(self):
        from zodbpickle import binary
        b = binary('abc')
        with self.assertRaises(AttributeError):
            setattr(b, 'attr', 42)

    def test_can_subclass(self):
        from zodbpickle import binary

        class MyBinary(binary):
            pass

        my = MyBinary('')
        my.attr = 42
        self.assertEqual(my, '')
        self.assertEqual(my.attr, 42)


class cBinaryTests(unittest.TestCase):

    def test_same_size(self):
        # PyPy doesn't support sys.getsizeof, but
        # we don't run these tests there.
        import sys
        from zodbpickle import binary

        s = b'abcdef'
        b = binary(s)
        self.assertEqual(sys.getsizeof(b), sys.getsizeof(s))

    def test_not_tracked_by_gc(self):
        # PyPy doesn't have gc.is_tracked, but we don't
        # run these tests there.
        import gc
        from zodbpickle import binary
        s = b'abcdef'
        b = binary(s)
        self.assertFalse(gc.is_tracked(s))
        self.assertFalse(gc.is_tracked(b))


def test_suite():
    tests = [
        unittest.makeSuite(PickleTests),
        unittest.makeSuite(PicklerTests),
        unittest.makeSuite(PersPicklerTests),
        unittest.makeSuite(PicklerUnpicklerObjectTests),
        unittest.makeSuite(PickleBigmemPickleTests),
        unittest.makeSuite(BinaryTests),
    ]

    if has_c_implementation:
        tests.extend([
            unittest.makeSuite(cPickleTests),
            unittest.makeSuite(cStringIOCPicklerTests),
            unittest.makeSuite(BytesIOCPicklerTests),
            unittest.makeSuite(FileIOCPicklerTests),
            unittest.makeSuite(cStringIOCPicklerListTests),
            unittest.makeSuite(BytesIOCPicklerListTests),
            unittest.makeSuite(FileIOCPicklerListTests),
            unittest.makeSuite(cStringIOCPicklerFastTests),
            unittest.makeSuite(BytesIOCPicklerFastTests),
            unittest.makeSuite(FileIOCPicklerFastTests),
            unittest.makeSuite(cPickleDeepRecursive),
            unittest.makeSuite(cPicklePicklerUnpicklerObjectTests),
            unittest.makeSuite(cPickleBigmemPickleTests),
            unittest.makeSuite(cBinaryTests),
        ])
    return unittest.TestSuite(tests)


if __name__ == '__main__':
    test_support.run_unittest(test_suite())

1	import cStringIO	2✔
2	import io	2✔
3	import unittest	2✔
4
5	from .pickletester_2 import (AbstractPickleTests,	2✔
6	AbstractPickleModuleTests,
7	AbstractPersistentPicklerTests,
8	AbstractPicklerUnpicklerObjectTests,
9	BigmemPickleTests,
10	has_c_implementation)
11
12	from test import test_support	2✔
13
14
15	class cStringIOMixin:	2✔
16	output = input = cStringIO.StringIO	2✔
17
18	def close(self, f):	2✔
19	pass	1✔
20
21
22	class BytesIOMixin:	2✔
23	output = input = io.BytesIO	2✔
24
25	def close(self, f):	2✔
26	pass	1✔
27
28
29	class FileIOMixin:	2✔
30
31	def output(self):	2✔
32	return open(test_support.TESTFN, 'wb+')	1✔
33
34	def input(self, data):	2✔
35	f = open(test_support.TESTFN, 'wb+')	1✔
36	try:	1✔
37	f.write(data)	1✔
38	f.seek(0)	1✔
39	return f	1✔
NEW 40	except BaseException:	×
41	f.close()	×
42	raise	×
43
44	def close(self, f):	2✔
45	f.close()	1✔
46	test_support.unlink(test_support.TESTFN)	1✔
47
48
49	class PickleTests(AbstractPickleTests, AbstractPickleModuleTests):	2✔
50
51	def dumps(self, arg, proto=0, fast=0):	2✔
52	from zodbpickle.pickle_2 import dumps	2✔
53	# Ignore fast
54	return dumps(arg, proto)	2✔
55
56	def loads(self, buf):	2✔
57	from zodbpickle.pickle_2 import loads	2✔
58	# Ignore fast
59	return loads(buf)	2✔
60
61	@property	2✔
62	def module(self):	×
63	from zodbpickle import pickle_2	2✔
64	return pickle_2	2✔
65
66	error = KeyError	2✔
67
68
69	class PicklerTests(AbstractPickleTests):	2✔
70
71	error = KeyError	2✔
72
73	def dumps(self, arg, proto=0, fast=0):	2✔
74	from zodbpickle.pickle_2 import Pickler	2✔
75	f = cStringIO.StringIO()	2✔
76	p = Pickler(f, proto)	2✔
77	if fast:	2!
78	p.fast = fast	×
79	p.dump(arg)	2✔
80	f.seek(0)	2✔
81	return f.read()	2✔
82
83	def loads(self, buf):	2✔
84	from zodbpickle.pickle_2 import Unpickler	2✔
85	f = cStringIO.StringIO(buf)	2✔
86	u = Unpickler(f)	2✔
87	return u.load()	2✔
88
89
90	class PersPicklerTests(AbstractPersistentPicklerTests):	2✔
91
92	def dumps(self, arg, proto=0, fast=0):	2✔
93	from zodbpickle.pickle_2 import Pickler	2✔
94
95	class PersPickler(Pickler):	2✔
96	def persistent_id(subself, obj):	2✔
97	return self.persistent_id(obj)	2✔
98	f = cStringIO.StringIO()	2✔
99	p = PersPickler(f, proto)	2✔
100	if fast:	2!
101	p.fast = fast	×
102	p.dump(arg)	2✔
103	f.seek(0)	2✔
104	return f.read()	2✔
105
106	def loads(self, buf):	2✔
107	from zodbpickle.pickle_2 import Unpickler	2✔
108
109	class PersUnpickler(Unpickler):	2✔
110	def persistent_load(subself, obj):	2✔
111	return self.persistent_load(obj)	2✔
112	f = cStringIO.StringIO(buf)	2✔
113	u = PersUnpickler(f)	2✔
114	return u.load()	2✔
115
116
117	class PicklerUnpicklerObjectTests(AbstractPicklerUnpicklerObjectTests):	2✔
118
119	@property	2✔
120	def pickler_class(self):	×
121	from zodbpickle.pickle_2 import Pickler	2✔
122	return Pickler	2✔
123
124	@property	2✔
125	def unpickler_class(self):	×
126	from zodbpickle.pickle_2 import Unpickler	2✔
127	return Unpickler	2✔
128
129
130	class PickleBigmemPickleTests(BigmemPickleTests):	2✔
131
132	def dumps(self, arg, proto=0, fast=0):	2✔
133	from zodbpickle import pickle_2	2✔
134	# Ignore fast
135	return pickle_2.dumps(arg, proto)	2✔
136
137	def loads(self, buf):	2✔
138	from zodbpickle import pickle_2	2✔
139	# Ignore fast
140	return pickle_2.loads(buf)	2✔
141
142
143	class cPickleBase(object):	2✔
144
145	@property	2✔
146	def error(self):	×
147	from zodbpickle._pickle import BadPickleGet	1✔
148	return BadPickleGet	1✔
149
150
151	class cPickleTests(AbstractPickleTests,	2✔
152	AbstractPickleModuleTests,
153	cPickleBase,
154	):
155	def setUp(self):	2✔
156	from zodbpickle._pickle import dumps	1✔
157	from zodbpickle._pickle import loads	1✔
158	self.dumps = dumps	1✔
159	self.loads = loads	1✔
160
161	@property	2✔
162	def module(self):	×
163	from zodbpickle import _pickle	1✔
164	return _pickle	1✔
165
166
167	class cPicklePicklerTests(AbstractPickleTests, cPickleBase):	2✔
168
169	def dumps(self, arg, proto=0):	2✔
170	from zodbpickle import _pickle	1✔
171	f = self.output()	1✔
172	try:	1✔
173	p = _pickle.Pickler(f, proto)	1✔
174	p.dump(arg)	1✔
175	f.seek(0)	1✔
176	return f.read()	1!
177	finally:
178	self.close(f)	1✔
179
180	def loads(self, buf):	2✔
181	from zodbpickle import _pickle	1✔
182	f = self.input(buf)	1✔
183	try:	1✔
184	p = _pickle.Unpickler(f)	1✔
185	return p.load()	1!
186	finally:
187	self.close(f)	1✔
188
189
190	class cStringIOCPicklerTests(cStringIOMixin, cPicklePicklerTests):	2✔
191	pass	2✔
192
193
194	class BytesIOCPicklerTests(BytesIOMixin, cPicklePicklerTests):	2✔
195	pass	2✔
196
197
198	class FileIOCPicklerTests(FileIOMixin, cPicklePicklerTests):	2✔
199	pass	2✔
200
201
202	class cPickleListPicklerTests(AbstractPickleTests, cPickleBase):	2✔
203
204	def dumps(self, arg, proto=0):	2✔
205	from zodbpickle import _pickle	1✔
206	p = _pickle.Pickler(proto)	1✔
207	p.dump(arg)	1✔
208	return p.getvalue()	1✔
209
210	def loads(self, *args):	2✔
211	from zodbpickle import _pickle	1✔
212	f = self.input(args[0])	1✔
213	try:	1✔
214	p = _pickle.Unpickler(f)	1✔
215	return p.load()	1!
216	finally:
217	self.close(f)	1✔
218
219
220	class cStringIOCPicklerListTests(cStringIOMixin, cPickleListPicklerTests):	2✔
221	pass	2✔
222
223
224	class BytesIOCPicklerListTests(BytesIOMixin, cPickleListPicklerTests):	2✔
225	pass	2✔
226
227
228	class FileIOCPicklerListTests(FileIOMixin, cPickleListPicklerTests):	2✔
229	pass	2✔
230
231
232	class cPickleFastPicklerTests(AbstractPickleTests, cPickleBase):	2✔
233
234	def dumps(self, arg, proto=0):	2✔
235	from zodbpickle import _pickle	1✔
236	f = self.output()	1✔
237	try:	1✔
238	p = _pickle.Pickler(f, proto)	1✔
239	p.fast = 1	1✔
240	p.dump(arg)	1✔
241	f.seek(0)	1✔
242	return f.read()	1!
243	finally:
244	self.close(f)	1✔
245
246	def loads(self, *args):	2✔
247	from zodbpickle import _pickle	1✔
248	f = self.input(args[0])	1✔
249	try:	1✔
250	p = _pickle.Unpickler(f)	1✔
251	return p.load()	1!
252	finally:
253	self.close(f)	1✔
254
255	def test_recursive_list(self):	2✔
256	self.assertRaises(ValueError,	1✔
257	AbstractPickleTests.test_recursive_list,
258	self)
259
260	def test_recursive_tuple(self):	2✔
261	self.assertRaises(ValueError,	1✔
262	AbstractPickleTests.test_recursive_tuple,
263	self)
264
265	def test_recursive_inst(self):	2✔
266	self.assertRaises(ValueError,	1✔
267	AbstractPickleTests.test_recursive_inst,
268	self)
269
270	def test_recursive_dict(self):	2✔
271	self.assertRaises(ValueError,	1✔
272	AbstractPickleTests.test_recursive_dict,
273	self)
274
275	def test_recursive_multi(self):	2✔
276	self.assertRaises(ValueError,	1✔
277	AbstractPickleTests.test_recursive_multi,
278	self)
279
280	def test_nonrecursive_deep(self):	2✔
281	# If it's not cyclic, it should pickle OK even if the nesting
282	# depth exceeds PY_CPICKLE_FAST_LIMIT. That happens to be
283	# 50 today. Jack Jansen reported stack overflow on Mac OS 9
284	# at 64.
285	a = []	1✔
286	for i in range(60):	1✔
287	a = [a]	1✔
288	b = self.loads(self.dumps(a))	1✔
289	self.assertEqual(a, b)	1✔
290
291
292	class cStringIOCPicklerFastTests(cStringIOMixin, cPickleFastPicklerTests):	2✔
293	pass	2✔
294
295
296	class BytesIOCPicklerFastTests(BytesIOMixin, cPickleFastPicklerTests):	2✔
297	pass	2✔
298
299
300	class FileIOCPicklerFastTests(FileIOMixin, cPickleFastPicklerTests):	2✔
301	pass	2✔
302
303
304	class cPicklePicklerUnpicklerObjectTests(AbstractPicklerUnpicklerObjectTests):	2✔
305
306	@property	2✔
307	def pickler_class(self):	×
308	from zodbpickle._pickle import Pickler	1✔
309	return Pickler	1✔
310
311	@property	2✔
312	def unpickler_class(self):	×
313	from zodbpickle._pickle import Unpickler	1✔
314	return Unpickler	1✔
315
316
317	class cPickleBigmemPickleTests(BigmemPickleTests):	2✔
318
319	def dumps(self, arg, proto=0, fast=0):	2✔
320	from zodbpickle import _pickle	1✔
321	# Ignore fast
322	return _pickle.dumps(arg, proto)	1✔
323
324	def loads(self, buf):	2✔
325	from zodbpickle import _pickle	1✔
326	# Ignore fast
327	return _pickle.loads(buf)	1✔
328
329
330	class Node(object):	2✔
331	pass	2✔
332
333
334	class cPickleDeepRecursive(unittest.TestCase):	2✔
335
336	def test_issue2702(self):	2✔
337	# This should raise a RecursionLimit but in some
338	# platforms (FreeBSD, win32) sometimes raises KeyError instead,
339	# or just silently terminates the interpreter (=crashes).
340	from zodbpickle import _pickle	1✔
341	nodes = [Node() for i in range(500)]	1!
342	for n in nodes:	1✔
343	n.connections = list(nodes)	1✔
344	n.connections.remove(n)	1✔
345	self.assertRaises((AttributeError, RuntimeError), _pickle.dumps, n)	1✔
346
347	def test_issue3179(self):	2✔
348	# Safe test, because I broke this case when fixing the
349	# behaviour for the previous test.
350	from zodbpickle import _pickle	1✔
351	res = []	1✔
352	for x in range(1, 2000):	1✔
353	res.append(dict(doc=x, similar=[]))	1✔
354	_pickle.dumps(res)	1✔
355
356
357	class BinaryTests(unittest.TestCase):	2✔
358
359	def test_has_no_attrs(self):	2✔
360	from zodbpickle import binary	2✔
361	b = binary('abc')	2✔
362	with self.assertRaises(AttributeError):	2✔
363	setattr(b, 'attr', 42)	2✔
364
365	def test_can_subclass(self):	2✔
366	from zodbpickle import binary	2✔
367
368	class MyBinary(binary):	2✔
369	pass	2✔
370
371	my = MyBinary('')	2✔
372	my.attr = 42	2✔
373	self.assertEqual(my, '')	2✔
374	self.assertEqual(my.attr, 42)	2✔
375
376
377	class cBinaryTests(unittest.TestCase):	2✔
378
379	def test_same_size(self):	2✔
380	# PyPy doesn't support sys.getsizeof, but
381	# we don't run these tests there.
382	import sys	1✔
383	from zodbpickle import binary	1✔
384
385	s = b'abcdef'	1✔
386	b = binary(s)	1✔
387	self.assertEqual(sys.getsizeof(b), sys.getsizeof(s))	1✔
388
389	def test_not_tracked_by_gc(self):	2✔
390	# PyPy doesn't have gc.is_tracked, but we don't
391	# run these tests there.
392	import gc	1✔
393	from zodbpickle import binary	1✔
394	s = b'abcdef'	1✔
395	b = binary(s)	1✔
396	self.assertFalse(gc.is_tracked(s))	1✔
397	self.assertFalse(gc.is_tracked(b))	1✔
398
399
400	def test_suite():	2✔
401	tests = [	2✔
402	unittest.makeSuite(PickleTests),
403	unittest.makeSuite(PicklerTests),
404	unittest.makeSuite(PersPicklerTests),
405	unittest.makeSuite(PicklerUnpicklerObjectTests),
406	unittest.makeSuite(PickleBigmemPickleTests),
407	unittest.makeSuite(BinaryTests),
408	]
409
410	if has_c_implementation:	2✔
411	tests.extend([	1✔
412	unittest.makeSuite(cPickleTests),
413	unittest.makeSuite(cStringIOCPicklerTests),
414	unittest.makeSuite(BytesIOCPicklerTests),
415	unittest.makeSuite(FileIOCPicklerTests),
416	unittest.makeSuite(cStringIOCPicklerListTests),
417	unittest.makeSuite(BytesIOCPicklerListTests),
418	unittest.makeSuite(FileIOCPicklerListTests),
419	unittest.makeSuite(cStringIOCPicklerFastTests),
420	unittest.makeSuite(BytesIOCPicklerFastTests),
421	unittest.makeSuite(FileIOCPicklerFastTests),
422	unittest.makeSuite(cPickleDeepRecursive),
423	unittest.makeSuite(cPicklePicklerUnpicklerObjectTests),
424	unittest.makeSuite(cPickleBigmemPickleTests),
425	unittest.makeSuite(cBinaryTests),
426	])
427	return unittest.TestSuite(tests)	2✔
428
429
430	if __name__ == '__main__':
431	test_support.run_unittest(test_suite())

zopefoundation / zodbpickle / 993128623

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous