1268735164

Build Type

push

github

Committed by GitHub

Commit Message

Config with c code (#63)

Run Details

565 of 724 branches covered (78.04%)

Branch coverage included in aggregate %.

19 of 19 new or added lines in 2 files covered. (100.0%)

7 existing lines in 1 file now uncovered.

2680 of 2991 relevant lines covered (89.6%)

4.91 hits per line

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

93.21

/src/zodbpickle/tests/test_pickle_2.py

import cStringIO
import io
import unittest
from cStringIO import StringIO

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

zopefoundation / zodbpickle / 1268735164

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