Lines Matching refs:self
79 def peek(self, *args):
82 def seekable(self):
85 def seek(self, *args):
88 def tell(self):
96 def __init__(self, *args):
97 self._bio = io.BytesIO(*args)
98 self.getvalue = self._bio.getvalue
99 self.read = self._bio.read
100 self.readline = self._bio.readline
101 self.write = self._bio.write
117 def __init__(self, code):
118 self.code = code
120 self.pair = copyreg._inverted_registry[code]
121 copyreg.remove_extension(self.pair[0], self.pair[1], code)
123 self.pair = None
126 def restore(self):
127 code = self.code
131 pair = self.pair
136 def __eq__(self, other):
137 return self.__dict__ == other.__dict__
140 def __init__(self, arg):
144 def __getinitargs__(self):
153 def __init__(self, value):
154 self.value = value
156 def __reduce__(self):
158 return K, (self.value,)
169 def __init__(self, x):
170 self.str = str(x)
174 def __init__(self, a, b):
175 self.a = a
176 self.b = b
178 def __getinitargs__(self):
179 return self.a, self.b
188 def __eq__(self, other):
189 return (type(self) == type(other) and
190 self.reduce_args == other.reduce_args)
192 def __reduce__(self):
193 return (create_dynamic_class, self.reduce_args)
207 def __reduce_ex__(self, protocol):
209 return type(self)._reconstruct, (pickle.PickleBuffer(self),), None
211 return type(self)._reconstruct, (bytes(self),)
213 def __repr__(self):
214 return "{}({!r})".format(self.__class__.__name__, bytes(self))
235 def __reduce_ex__(self, protocol):
237 return type(self)._reconstruct, (pickle.PickleBuffer(self),), None
239 return type(self)._reconstruct, (bytes(self),)
241 def __repr__(self):
242 return "{}({!r})".format(self.__class__.__name__, bytes(self))
265 def __init__(self, *args, **kwargs):
266 self.array = _testbuffer.ndarray(*args, **kwargs)
268 def __getitem__(self, idx):
269 cls = type(self)
271 new.array = self.array[idx]
275 def readonly(self):
276 return self.array.readonly
279 def c_contiguous(self):
280 return self.array.c_contiguous
283 def f_contiguous(self):
284 return self.array.f_contiguous
286 def __eq__(self, other):
289 return (other.array.format == self.array.format and
290 other.array.shape == self.array.shape and
291 other.array.strides == self.array.strides and
292 other.array.readonly == self.array.readonly and
293 other.array.tobytes() == self.array.tobytes())
295 def __ne__(self, other):
298 return not (self == other)
300 def __repr__(self):
301 return (f"{type(self)}(shape={self.array.shape},"
302 f"strides={self.array.strides}, "
303 f"bytes={self.array.tobytes()})")
305 def __reduce_ex__(self, protocol):
306 if not self.array.contiguous:
309 ndarray_kwargs = {"shape": self.array.shape,
310 "strides": self.array.strides,
311 "format": self.array.format,
312 "flags": (0 if self.readonly
314 pb = pickle.PickleBuffer(self.array)
316 return (type(self)._reconstruct,
321 return (type(self)._reconstruct,
834 # Subclass must define self.loads.
838 def assert_is_copy(self, obj, objcopy, msg=None):
843 self.assertEqual(obj, objcopy, msg=msg)
844 self.assertIs(type(obj), type(objcopy), msg=msg)
846 self.assertDictEqual(obj.__dict__, objcopy.__dict__, msg=msg)
847 self.assertIsNot(obj.__dict__, objcopy.__dict__, msg=msg)
849 self.assertListEqual(obj.__slots__, objcopy.__slots__, msg=msg)
851 self.assertEqual(
853 self.assertEqual(getattr(obj, slot, None),
856 def check_unpickling_error(self, errors, data):
857 with self.subTest(data=data), \
858 self.assertRaises(errors):
860 self.loads(data)
867 def test_load_from_data0(self):
868 self.assert_is_copy(self._testdata, self.loads(DATA0))
870 def test_load_from_data1(self):
871 self.assert_is_copy(self._testdata, self.loads(DATA1))
873 def test_load_from_data2(self):
874 self.assert_is_copy(self._testdata, self.loads(DATA2))
876 def test_load_from_data3(self):
877 self.assert_is_copy(self._testdata, self.loads(DATA3))
879 def test_load_from_data4(self):
880 self.assert_is_copy(self._testdata, self.loads(DATA4))
882 def test_load_classic_instance(self):
902 self.assert_is_copy(X(*args), self.loads(pickle0))
919 self.assert_is_copy(X(*args), self.loads(pickle1))
937 self.assert_is_copy(X(*args), self.loads(pickle2))
939 def test_maxint64(self):
942 got = self.loads(data)
943 self.assert_is_copy(maxint64, got)
947 self.check_unpickling_error(ValueError, data)
949 def test_unpickle_from_2x(self):
951 loaded = self.loads(DATA_SET)
952 self.assertEqual(loaded, set([1, 2]))
953 loaded = self.loads(DATA_XRANGE)
954 self.assertEqual(type(loaded), type(range(0)))
955 self.assertEqual(list(loaded), list(range(5)))
956 loaded = self.loads(DATA_COOKIE)
957 self.assertEqual(type(loaded), SimpleCookie)
958 self.assertEqual(list(loaded.keys()), ["key"])
959 self.assertEqual(loaded["key"].value, "value")
964 loaded = self.loads(data)
965 self.assertIs(type(loaded), exc)
968 loaded = self.loads(exception_pickle.replace(b'?', b'StandardError'))
969 self.assertIs(type(loaded), Exception)
971 loaded = self.loads(DATA_UEERR)
972 self.assertIs(type(loaded), UnicodeEncodeError)
973 self.assertEqual(loaded.object, "foo")
974 self.assertEqual(loaded.encoding, "ascii")
975 self.assertEqual(loaded.start, 0)
976 self.assertEqual(loaded.end, 1)
977 self.assertEqual(loaded.reason, "bad")
979 def test_load_python2_str_as_bytes(self):
981 self.assertEqual(self.loads(b"S'a\\x00\\xa0'\n.",
984 self.assertEqual(self.loads(b'U\x03a\x00\xa0.',
987 self.assertEqual(self.loads(b'\x80\x02U\x03a\x00\xa0.',
990 def test_load_python2_unicode_as_str(self):
992 self.assertEqual(self.loads(b'V\\u03c0\n.',
995 self.assertEqual(self.loads(b'X\x02\x00\x00\x00\xcf\x80.',
998 self.assertEqual(self.loads(b'\x80\x02X\x02\x00\x00\x00\xcf\x80.',
1001 def test_load_long_python2_str_as_bytes(self):
1003 self.assertEqual(self.loads(pickle.BINSTRING +
1008 def test_constants(self):
1009 self.assertIsNone(self.loads(b'N.'))
1010 self.assertIs(self.loads(b'\x88.'), True)
1011 self.assertIs(self.loads(b'\x89.'), False)
1012 self.assertIs(self.loads(b'I01\n.'), True)
1013 self.assertIs(self.loads(b'I00\n.'), False)
1015 def test_empty_bytestring(self):
1017 empty = self.loads(b'\x80\x03U\x00q\x00.', encoding='koi8-r')
1018 self.assertEqual(empty, '')
1020 def test_short_binbytes(self):
1022 self.assertEqual(self.loads(dumped), b'\xe2\x82\xac\x00')
1024 def test_binbytes(self):
1026 self.assertEqual(self.loads(dumped), b'\xe2\x82\xac\x00')
1029 def test_negative_32b_binbytes(self):
1032 self.check_unpickling_error((pickle.UnpicklingError, OverflowError),
1036 def test_negative_32b_binunicode(self):
1039 self.check_unpickling_error((pickle.UnpicklingError, OverflowError),
1042 def test_short_binunicode(self):
1044 self.assertEqual(self.loads(dumped), '\u20ac\x00')
1046 def test_misc_get(self):
1047 self.check_unpickling_error(pickle.UnpicklingError, b'g0\np0')
1048 self.check_unpickling_error(pickle.UnpicklingError, b'jens:')
1049 self.check_unpickling_error(pickle.UnpicklingError, b'hens:')
1050 self.assert_is_copy([(100,), (100,)],
1051 self.loads(b'((Kdtp0\nh\x00l.))'))
1053 def test_binbytes8(self):
1055 self.assertEqual(self.loads(dumped), b'\xe2\x82\xac\x00')
1057 def test_binunicode8(self):
1059 self.assertEqual(self.loads(dumped), '\u20ac\x00')
1061 def test_bytearray8(self):
1063 self.assertEqual(self.loads(dumped), bytearray(b'xxx'))
1066 def test_large_32b_binbytes8(self):
1068 self.check_unpickling_error((pickle.UnpicklingError, OverflowError),
1072 def test_large_32b_bytearray8(self):
1074 self.check_unpickling_error((pickle.UnpicklingError, OverflowError),
1078 def test_large_32b_binunicode8(self):
1080 self.check_unpickling_error((pickle.UnpicklingError, OverflowError),
1083 def test_get(self):
1085 unpickled = self.loads(pickled)
1086 self.assertEqual(unpickled, ([],)*2)
1087 self.assertIs(unpickled[0], unpickled[1])
1089 def test_binget(self):
1091 unpickled = self.loads(pickled)
1092 self.assertEqual(unpickled, ([],)*2)
1093 self.assertIs(unpickled[0], unpickled[1])
1095 def test_long_binget(self):
1097 unpickled = self.loads(pickled)
1098 self.assertEqual(unpickled, ([],)*2)
1099 self.assertIs(unpickled[0], unpickled[1])
1101 def test_dup(self):
1103 unpickled = self.loads(pickled)
1104 self.assertEqual(unpickled, ([],)*2)
1105 self.assertIs(unpickled[0], unpickled[1])
1107 def test_negative_put(self):
1110 self.check_unpickling_error(ValueError, dumped)
1113 def test_negative_32b_binput(self):
1116 self.check_unpickling_error(ValueError, dumped)
1118 def test_badly_escaped_string(self):
1119 self.check_unpickling_error(ValueError, b"S'\\'\n.")
1121 def test_badly_quoted_string(self):
1137 self.check_unpickling_error(pickle.UnpicklingError, p)
1139 def test_correctly_quoted_string(self):
1145 self.assertEqual(self.loads(p), expected)
1147 def test_frame_readline(self):
1153 self.assertEqual(self.loads(pickled), 42)
1155 def test_compat_unpickle(self):
1158 unpickled = self.loads(pickled)
1159 self.assertIs(type(unpickled), range)
1160 self.assertEqual(unpickled, range(1, 7))
1161 self.assertEqual(list(unpickled), [1, 2, 3, 4, 5, 6])
1164 self.assertIs(self.loads(pickled), functools.reduce)
1167 self.assertIs(self.loads(pickled), dbm.whichdb)
1171 unpickled = self.loads(pickled)
1172 self.assertIs(type(unpickled), Exception)
1173 self.assertEqual(str(unpickled), 'ugh')
1178 unpickled = self.loads(pickled)
1179 self.assertIs(type(unpickled), collections.UserDict)
1180 self.assertEqual(unpickled, collections.UserDict({1: 2}))
1182 def test_bad_reduce(self):
1183 self.assertEqual(self.loads(b'cbuiltins\nint\n)R.'), 0)
1184 self.check_unpickling_error(TypeError, b'N)R.')
1185 self.check_unpickling_error(TypeError, b'cbuiltins\nint\nNR.')
1187 def test_bad_newobj(self):
1189 self.assertEqual(self.loads(b'cbuiltins\nint\n)\x81.'), 0)
1190 self.check_unpickling_error(error, b'cbuiltins\nlen\n)\x81.')
1191 self.check_unpickling_error(error, b'cbuiltins\nint\nN\x81.')
1193 def test_bad_newobj_ex(self):
1195 self.assertEqual(self.loads(b'cbuiltins\nint\n)}\x92.'), 0)
1196 self.check_unpickling_error(error, b'cbuiltins\nlen\n)}\x92.')
1197 self.check_unpickling_error(error, b'cbuiltins\nint\nN}\x92.')
1198 self.check_unpickling_error(error, b'cbuiltins\nint\n)N\x92.')
1200 def test_bad_stack(self):
1248 self.check_unpickling_error(self.bad_stack_errors, p)
1250 def test_bad_mark(self):
1287 self.check_unpickling_error(self.bad_stack_errors, p)
1289 def test_truncated_data(self):
1290 self.check_unpickling_error(EOFError, b'')
1291 self.check_unpickling_error(EOFError, b'N')
1382 self.check_unpickling_error(self.truncated_errors, p)
1386 def test_unpickle_module_race(self):
1400 self.addCleanup(shutil.rmtree, TESTFN)
1402 self.addCleanup(sys.path.remove, TESTFN)
1407 self.addCleanup(forget, "locker")
1408 self.addCleanup(forget, "locking_import")
1441 self.assertEqual(
1448 # Subclass must define self.dumps, self.loads.
1454 def setUp(self):
1459 def test_misc(self):
1463 s = self.dumps(x, proto)
1464 y = self.loads(s)
1465 self.assert_is_copy(x, y)
1468 s = self.dumps(x, proto)
1469 y = self.loads(s)
1470 self.assert_is_copy(x, y)
1473 s = self.dumps(x, proto)
1474 y = self.loads(s)
1475 self.assert_is_copy(x, y)
1479 def test_roundtrip_equality(self):
1480 expected = self._testdata
1482 s = self.dumps(expected, proto)
1483 got = self.loads(s)
1484 self.assert_is_copy(expected, got)
1492 def dont_test_disassembly(self):
1497 s = self.dumps(self._testdata, proto)
1501 self.assertEqual(expected, got)
1503 def _test_recursive_list(self, cls, aslist=identity, minprotocol=0):
1508 s = self.dumps(l, proto)
1509 x = self.loads(s)
1510 self.assertIsInstance(x, cls)
1512 self.assertEqual(len(y), 1)
1513 self.assertIs(y[0], x)
1515 def test_recursive_list(self):
1516 self._test_recursive_list(list)
1518 def test_recursive_list_subclass(self):
1519 self._test_recursive_list(MyList, minprotocol=2)
1521 def test_recursive_list_like(self):
1522 self._test_recursive_list(REX_six, aslist=lambda x: x.items)
1524 def _test_recursive_tuple_and_list(self, cls, aslist=identity, minprotocol=0):
1529 s = self.dumps(t, proto)
1530 x = self.loads(s)
1531 self.assertIsInstance(x, tuple)
1532 self.assertEqual(len(x), 1)
1533 self.assertIsInstance(x[0], cls)
1535 self.assertEqual(len(y), 1)
1536 self.assertIs(y[0], x)
1541 s = self.dumps(t, proto)
1542 x = self.loads(s)
1543 self.assertIsInstance(x, cls)
1545 self.assertEqual(len(y), 1)
1546 self.assertIsInstance(y[0], tuple)
1547 self.assertEqual(len(y[0]), 1)
1548 self.assertIs(y[0][0], x)
1550 def test_recursive_tuple_and_list(self):
1551 self._test_recursive_tuple_and_list(list)
1553 def test_recursive_tuple_and_list_subclass(self):
1554 self._test_recursive_tuple_and_list(MyList, minprotocol=2)
1556 def test_recursive_tuple_and_list_like(self):
1557 self._test_recursive_tuple_and_list(REX_six, aslist=lambda x: x.items)
1559 def _test_recursive_dict(self, cls, asdict=identity, minprotocol=0):
1564 s = self.dumps(d, proto)
1565 x = self.loads(s)
1566 self.assertIsInstance(x, cls)
1568 self.assertEqual(list(y.keys()), [1])
1569 self.assertIs(y[1], x)
1571 def test_recursive_dict(self):
1572 self._test_recursive_dict(dict)
1574 def test_recursive_dict_subclass(self):
1575 self._test_recursive_dict(MyDict, minprotocol=2)
1577 def test_recursive_dict_like(self):
1578 self._test_recursive_dict(REX_seven, asdict=lambda x: x.table)
1580 def _test_recursive_tuple_and_dict(self, cls, asdict=identity, minprotocol=0):
1585 s = self.dumps(t, proto)
1586 x = self.loads(s)
1587 self.assertIsInstance(x, tuple)
1588 self.assertEqual(len(x), 1)
1589 self.assertIsInstance(x[0], cls)
1591 self.assertEqual(list(y), [1])
1592 self.assertIs(y[1], x)
1597 s = self.dumps(t, proto)
1598 x = self.loads(s)
1599 self.assertIsInstance(x, cls)
1601 self.assertEqual(list(y), [1])
1602 self.assertIsInstance(y[1], tuple)
1603 self.assertEqual(len(y[1]), 1)
1604 self.assertIs(y[1][0], x)
1606 def test_recursive_tuple_and_dict(self):
1607 self._test_recursive_tuple_and_dict(dict)
1609 def test_recursive_tuple_and_dict_subclass(self):
1610 self._test_recursive_tuple_and_dict(MyDict, minprotocol=2)
1612 def test_recursive_tuple_and_dict_like(self):
1613 self._test_recursive_tuple_and_dict(REX_seven, asdict=lambda x: x.table)
1615 def _test_recursive_dict_key(self, cls, asdict=identity, minprotocol=0):
1621 s = self.dumps(d, proto)
1622 x = self.loads(s)
1623 self.assertIsInstance(x, cls)
1625 self.assertEqual(len(y.keys()), 1)
1626 self.assertIsInstance(list(y.keys())[0], K)
1627 self.assertIs(list(y.keys())[0].value, x)
1629 def test_recursive_dict_key(self):
1630 self._test_recursive_dict_key(dict)
1632 def test_recursive_dict_subclass_key(self):
1633 self._test_recursive_dict_key(MyDict, minprotocol=2)
1635 def test_recursive_dict_like_key(self):
1636 self._test_recursive_dict_key(REX_seven, asdict=lambda x: x.table)
1638 def _test_recursive_tuple_and_dict_key(self, cls, asdict=identity, minprotocol=0):
1644 s = self.dumps(t, proto)
1645 x = self.loads(s)
1646 self.assertIsInstance(x, tuple)
1647 self.assertEqual(len(x), 1)
1648 self.assertIsInstance(x[0], cls)
1650 self.assertEqual(len(y), 1)
1651 self.assertIsInstance(list(y.keys())[0], K)
1652 self.assertIs(list(y.keys())[0].value, x)
1658 s = self.dumps(t, proto)
1659 x = self.loads(s)
1660 self.assertIsInstance(x, cls)
1662 self.assertEqual(len(y), 1)
1663 self.assertIsInstance(list(y.keys())[0], K)
1664 self.assertIs(list(y.keys())[0].value[0], x)
1666 def test_recursive_tuple_and_dict_key(self):
1667 self._test_recursive_tuple_and_dict_key(dict)
1669 def test_recursive_tuple_and_dict_subclass_key(self):
1670 self._test_recursive_tuple_and_dict_key(MyDict, minprotocol=2)
1672 def test_recursive_tuple_and_dict_like_key(self):
1673 self._test_recursive_tuple_and_dict_key(REX_seven, asdict=lambda x: x.table)
1675 def test_recursive_set(self):
1680 s = self.dumps(y, proto)
1681 x = self.loads(s)
1682 self.assertIsInstance(x, set)
1683 self.assertEqual(len(x), 1)
1684 self.assertIsInstance(list(x)[0], K)
1685 self.assertIs(list(x)[0].value, x)
1690 s = self.dumps(y, proto)
1691 x = self.loads(s)
1692 self.assertIsInstance(x, K)
1693 self.assertIsInstance(x.value, set)
1694 self.assertEqual(len(x.value), 1)
1695 self.assertIs(list(x.value)[0], x)
1697 def test_recursive_inst(self):
1702 s = self.dumps(i, proto)
1703 x = self.loads(s)
1704 self.assertIsInstance(x, Object)
1705 self.assertEqual(dir(x), dir(i))
1706 self.assertIs(x.attr, x)
1708 def test_recursive_multi(self):
1715 s = self.dumps(l, proto)
1716 x = self.loads(s)
1717 self.assertIsInstance(x, list)
1718 self.assertEqual(len(x), 1)
1719 self.assertEqual(dir(x[0]), dir(i))
1720 self.assertEqual(list(x[0].attr.keys()), [1])
1721 self.assertIs(x[0].attr[1], x)
1723 def _test_recursive_collection_and_inst(self, factory):
1730 s = self.dumps(o, proto)
1731 x = self.loads(s)
1732 self.assertIsInstance(x.attr, t)
1733 self.assertEqual(len(x.attr), 1)
1734 self.assertIsInstance(list(x.attr)[0], Object)
1735 self.assertIs(list(x.attr)[0], x)
1741 s = self.dumps(o, proto)
1742 x = self.loads(s)
1743 self.assertIsInstance(x, t)
1744 self.assertEqual(len(x), 1)
1745 self.assertIsInstance(list(x)[0], Object)
1746 self.assertIs(list(x)[0].attr, x)
1748 def test_recursive_list_and_inst(self):
1749 self._test_recursive_collection_and_inst(list)
1751 def test_recursive_tuple_and_inst(self):
1752 self._test_recursive_collection_and_inst(tuple)
1754 def test_recursive_dict_and_inst(self):
1755 self._test_recursive_collection_and_inst(dict.fromkeys)
1757 def test_recursive_set_and_inst(self):
1758 self._test_recursive_collection_and_inst(set)
1760 def test_recursive_frozenset_and_inst(self):
1761 self._test_recursive_collection_and_inst(frozenset)
1763 def test_recursive_list_subclass_and_inst(self):
1764 self._test_recursive_collection_and_inst(MyList)
1766 def test_recursive_tuple_subclass_and_inst(self):
1767 self._test_recursive_collection_and_inst(MyTuple)
1769 def test_recursive_dict_subclass_and_inst(self):
1770 self._test_recursive_collection_and_inst(MyDict.fromkeys)
1772 def test_recursive_set_subclass_and_inst(self):
1773 self._test_recursive_collection_and_inst(MySet)
1775 def test_recursive_frozenset_subclass_and_inst(self):
1776 self._test_recursive_collection_and_inst(MyFrozenSet)
1778 def test_recursive_inst_state(self):
1783 s = self.dumps(y, proto)
1784 x = self.loads(s)
1785 self.assertIsInstance(x, REX_state)
1786 self.assertIs(x.state, x)
1788 def test_recursive_tuple_and_inst_state(self):
1793 s = self.dumps(t, proto)
1794 x = self.loads(s)
1795 self.assertIsInstance(x, tuple)
1796 self.assertEqual(len(x), 1)
1797 self.assertIsInstance(x[0], REX_state)
1798 self.assertIs(x[0].state, x)
1803 s = self.dumps(t, proto)
1804 x = self.loads(s)
1805 self.assertIsInstance(x, REX_state)
1806 self.assertIsInstance(x.state, tuple)
1807 self.assertEqual(len(x.state), 1)
1808 self.assertIs(x.state[0], x)
1810 def test_unicode(self):
1817 p = self.dumps(u, proto)
1818 u2 = self.loads(p)
1819 self.assert_is_copy(u, u2)
1821 def test_unicode_high_plane(self):
1824 p = self.dumps(t, proto)
1825 t2 = self.loads(p)
1826 self.assert_is_copy(t, t2)
1828 def test_bytes(self):
1831 p = self.dumps(s, proto)
1832 self.assert_is_copy(s, self.loads(p))
1834 p = self.dumps(s, proto)
1835 self.assert_is_copy(s, self.loads(p))
1837 p = self.dumps(s, proto)
1838 self.assert_is_copy(s, self.loads(p))
1840 def test_bytearray(self):
1844 p = self.dumps(b, proto)
1845 bb = self.loads(p)
1846 self.assertIsNot(bb, b)
1847 self.assert_is_copy(b, bb)
1850 self.assertIn(b'bytearray', p)
1851 self.assertTrue(opcode_in_pickle(pickle.GLOBAL, p))
1853 self.assertIn(b'bytearray', p)
1854 self.assertTrue(opcode_in_pickle(pickle.STACK_GLOBAL, p))
1856 self.assertNotIn(b'bytearray', p)
1857 self.assertTrue(opcode_in_pickle(pickle.BYTEARRAY8, p))
1859 def test_bytearray_memoization_bug(self):
1863 p = self.dumps((b, b), proto)
1864 b1, b2 = self.loads(p)
1865 self.assertIs(b1, b2)
1867 def test_ints(self):
1872 s = self.dumps(expected, proto)
1873 n2 = self.loads(s)
1874 self.assert_is_copy(expected, n2)
1877 def test_long(self):
1884 pickle = self.dumps(n, proto)
1885 got = self.loads(pickle)
1886 self.assert_is_copy(n, got)
1892 p = self.dumps(n, 2)
1893 got = self.loads(p)
1897 self.assertIs(type(got), int)
1898 self.assertEqual(n, got)
1900 def test_float(self):
1906 pickle = self.dumps(value, proto)
1907 got = self.loads(pickle)
1908 self.assert_is_copy(value, got)
1911 def test_float_format(self):
1913 self.assertEqual(self.dumps(1.2, 0)[0:3], b'F1.')
1915 def test_reduce(self):
1918 dumped = self.dumps(inst, proto)
1919 loaded = self.loads(dumped)
1920 self.assertEqual(loaded, REDUCE_A)
1922 def test_getinitargs(self):
1925 dumped = self.dumps(inst, proto)
1926 loaded = self.loads(dumped)
1927 self.assert_is_copy(inst, loaded)
1929 def test_metaclass(self):
1932 s = self.dumps(a, proto)
1933 b = self.loads(s)
1934 self.assertEqual(a.__class__, b.__class__)
1936 def test_dynamic_class(self):
1940 s = self.dumps(a, proto)
1941 b = self.loads(s)
1942 self.assertEqual(a, b)
1943 self.assertIs(type(a), type(b))
1945 def test_structseq(self):
1951 s = self.dumps(t, proto)
1952 u = self.loads(s)
1953 self.assert_is_copy(t, u)
1955 s = self.dumps(t, proto)
1956 u = self.loads(s)
1957 self.assert_is_copy(t, u)
1960 s = self.dumps(t, proto)
1961 u = self.loads(s)
1962 self.assert_is_copy(t, u)
1964 def test_ellipsis(self):
1966 s = self.dumps(..., proto)
1967 u = self.loads(s)
1968 self.assertIs(..., u)
1970 def test_notimplemented(self):
1972 s = self.dumps(NotImplemented, proto)
1973 u = self.loads(s)
1974 self.assertIs(NotImplemented, u)
1976 def test_singleton_types(self):
1981 s = self.dumps(type(singleton), proto)
1982 u = self.loads(s)
1983 self.assertIs(type(singleton), u)
1985 def test_builtin_types(self):
1989 s = self.dumps(t, proto)
1990 self.assertIs(self.loads(s), t)
1992 def test_builtin_exceptions(self):
1996 s = self.dumps(t, proto)
1997 u = self.loads(s)
1999 self.assertIs(u, OSError)
2001 self.assertIs(u, ImportError)
2003 self.assertIs(u, t)
2005 def test_builtin_functions(self):
2009 s = self.dumps(t, proto)
2010 self.assertIs(self.loads(s), t)
2014 def test_proto(self):
2016 pickled = self.dumps(None, proto)
2019 self.assertTrue(pickled.startswith(proto_header))
2021 self.assertEqual(count_opcode(pickle.PROTO, pickled), 0)
2027 self.loads(badpickle)
2029 self.assertIn("unsupported pickle protocol", str(err))
2031 self.fail("expected bad protocol number to raise ValueError")
2033 def test_long1(self):
2036 s = self.dumps(x, proto)
2037 y = self.loads(s)
2038 self.assert_is_copy(x, y)
2039 self.assertEqual(opcode_in_pickle(pickle.LONG1, s), proto >= 2)
2041 def test_long4(self):
2044 s = self.dumps(x, proto)
2045 y = self.loads(s)
2046 self.assert_is_copy(x, y)
2047 self.assertEqual(opcode_in_pickle(pickle.LONG4, s), proto >= 2)
2049 def test_short_tuples(self):
2082 s = self.dumps(x, proto)
2083 y = self.loads(s)
2084 self.assert_is_copy(x, y)
2086 self.assertTrue(opcode_in_pickle(expected, s))
2088 def test_singletons(self):
2107 s = self.dumps(x, proto)
2108 y = self.loads(s)
2109 self.assertTrue(x is y, (proto, x, s, y))
2111 self.assertTrue(opcode_in_pickle(expected, s))
2113 def test_newobj_tuple(self):
2118 s = self.dumps(x, proto)
2119 y = self.loads(s)
2120 self.assert_is_copy(x, y)
2122 def test_newobj_list(self):
2127 s = self.dumps(x, proto)
2128 y = self.loads(s)
2129 self.assert_is_copy(x, y)
2131 def test_newobj_generic(self):
2137 s = self.dumps(x, proto)
2138 y = self.loads(s)
2140 self.assert_is_copy(x, y) # XXX revisit
2141 self.assertEqual(B(x), B(y), detail)
2142 self.assertEqual(x.__dict__, y.__dict__, detail)
2144 def test_newobj_proxies(self):
2156 s = self.dumps(p, proto)
2157 y = self.loads(s)
2158 self.assertEqual(type(y), type(x)) # rather than type(p)
2160 self.assertEqual(B(x), B(y), detail)
2161 self.assertEqual(x.__dict__, y.__dict__, detail)
2163 def test_newobj_overridden_new(self):
2168 s = self.dumps(x, proto)
2169 y = self.loads(s)
2170 self.assertIs(type(y), MyIntWithNew2)
2171 self.assertEqual(int(y), 1)
2172 self.assertEqual(y.foo, 42)
2174 def test_newobj_not_class(self):
2179 b = self.dumps(o, 4)
2182 self.assertRaises((TypeError, pickle.UnpicklingError), self.loads, b)
2190 def produce_global_ext(self, extcode, opcode):
2199 s1 = self.dumps(x, 1)
2200 self.assertIn(__name__.encode("utf-8"), s1)
2201 self.assertIn(b"MyList", s1)
2202 self.assertFalse(opcode_in_pickle(opcode, s1))
2204 y = self.loads(s1)
2205 self.assert_is_copy(x, y)
2208 s2 = self.dumps(x, 2)
2209 self.assertNotIn(__name__.encode("utf-8"), s2)
2210 self.assertNotIn(b"MyList", s2)
2211 self.assertEqual(opcode_in_pickle(opcode, s2), True, repr(s2))
2213 y = self.loads(s2)
2214 self.assert_is_copy(x, y)
2218 def test_global_ext1(self):
2219 self.produce_global_ext(0x00000001, pickle.EXT1) # smallest EXT1 code
2220 self.produce_global_ext(0x000000ff, pickle.EXT1) # largest EXT1 code
2222 def test_global_ext2(self):
2223 self.produce_global_ext(0x00000100, pickle.EXT2) # smallest EXT2 code
2224 self.produce_global_ext(0x0000ffff, pickle.EXT2) # largest EXT2 code
2225 self.produce_global_ext(0x0000abcd, pickle.EXT2) # check endianness
2227 def test_global_ext4(self):
2228 self.produce_global_ext(0x00010000, pickle.EXT4) # smallest EXT4 code
2229 self.produce_global_ext(0x7fffffff, pickle.EXT4) # largest EXT4 code
2230 self.produce_global_ext(0x12abcdef, pickle.EXT4) # check endianness
2232 def test_list_chunking(self):
2236 s = self.dumps(x, proto)
2237 y = self.loads(s)
2238 self.assert_is_copy(x, y)
2240 self.assertEqual(num_appends, proto > 0)
2245 s = self.dumps(x, proto)
2246 y = self.loads(s)
2247 self.assert_is_copy(x, y)
2250 self.assertEqual(num_appends, 0)
2252 self.assertTrue(num_appends >= 2)
2254 def test_dict_chunking(self):
2258 s = self.dumps(x, proto)
2259 self.assertIsInstance(s, bytes_types)
2260 y = self.loads(s)
2261 self.assert_is_copy(x, y)
2263 self.assertEqual(num_setitems, proto > 0)
2268 s = self.dumps(x, proto)
2269 y = self.loads(s)
2270 self.assert_is_copy(x, y)
2273 self.assertEqual(num_setitems, 0)
2275 self.assertTrue(num_setitems >= 2)
2277 def test_set_chunking(self):
2281 s = self.dumps(x, proto)
2282 y = self.loads(s)
2283 self.assert_is_copy(x, y)
2286 self.assertEqual(num_additems, 0)
2288 self.assertEqual(num_additems, 1)
2293 s = self.dumps(x, proto)
2294 y = self.loads(s)
2295 self.assert_is_copy(x, y)
2298 self.assertEqual(num_additems, 0)
2300 self.assertGreaterEqual(num_additems, 2)
2302 def test_simple_newobj(self):
2306 with self.subTest(proto=proto):
2307 s = self.dumps(x, proto)
2309 self.assertIn(b'\nI64206', s) # INT
2311 self.assertIn(b'M\xce\xfa', s) # BININT2
2312 self.assertEqual(opcode_in_pickle(pickle.NEWOBJ, s),
2314 self.assertFalse(opcode_in_pickle(pickle.NEWOBJ_EX, s))
2315 y = self.loads(s) # will raise TypeError if __init__ called
2316 self.assert_is_copy(x, y)
2318 def test_complex_newobj(self):
2322 with self.subTest(proto=proto):
2323 s = self.dumps(x, proto)
2325 self.assertIn(b'\nI64206', s) # INT
2327 self.assertIn(b'M\xce\xfa', s) # BININT2
2329 self.assertIn(b'X\x04\x00\x00\x00FACE', s) # BINUNICODE
2331 self.assertIn(b'\x8c\x04FACE', s) # SHORT_BINUNICODE
2332 self.assertEqual(opcode_in_pickle(pickle.NEWOBJ, s),
2334 self.assertFalse(opcode_in_pickle(pickle.NEWOBJ_EX, s))
2335 y = self.loads(s) # will raise TypeError if __init__ called
2336 self.assert_is_copy(x, y)
2338 def test_complex_newobj_ex(self):
2342 with self.subTest(proto=proto):
2343 s = self.dumps(x, proto)
2345 self.assertIn(b'\nI64206', s) # INT
2347 self.assertIn(b'M\xce\xfa', s) # BININT2
2349 self.assertIn(b'X\x04\x00\x00\x00FACE', s) # BINUNICODE
2351 self.assertIn(b'\x8c\x04FACE', s) # SHORT_BINUNICODE
2352 self.assertFalse(opcode_in_pickle(pickle.NEWOBJ, s))
2353 self.assertEqual(opcode_in_pickle(pickle.NEWOBJ_EX, s),
2355 y = self.loads(s) # will raise TypeError if __init__ called
2356 self.assert_is_copy(x, y)
2358 def test_newobj_list_slots(self):
2362 s = self.dumps(x, 2)
2363 y = self.loads(s)
2364 self.assert_is_copy(x, y)
2366 def test_reduce_overrides_default_reduce_ex(self):
2369 self.assertEqual(x._reduce_called, 0)
2370 s = self.dumps(x, proto)
2371 self.assertEqual(x._reduce_called, 1)
2372 y = self.loads(s)
2373 self.assertEqual(y._reduce_called, 0)
2375 def test_reduce_ex_called(self):
2378 self.assertEqual(x._proto, None)
2379 s = self.dumps(x, proto)
2380 self.assertEqual(x._proto, proto)
2381 y = self.loads(s)
2382 self.assertEqual(y._proto, None)
2384 def test_reduce_ex_overrides_reduce(self):
2387 self.assertEqual(x._proto, None)
2388 s = self.dumps(x, proto)
2389 self.assertEqual(x._proto, proto)
2390 y = self.loads(s)
2391 self.assertEqual(y._proto, None)
2393 def test_reduce_ex_calls_base(self):
2396 self.assertEqual(x._proto, None)
2397 s = self.dumps(x, proto)
2398 self.assertEqual(x._proto, proto)
2399 y = self.loads(s)
2400 self.assertEqual(y._proto, proto)
2402 def test_reduce_calls_base(self):
2405 self.assertEqual(x._reduce_called, 0)
2406 s = self.dumps(x, proto)
2407 self.assertEqual(x._reduce_called, 1)
2408 y = self.loads(s)
2409 self.assertEqual(y._reduce_called, 1)
2412 def test_bad_getattr(self):
2417 self.assertRaises(RuntimeError, self.dumps, x, proto)
2419 s = self.dumps(x, proto)
2421 def test_reduce_bad_iterator(self):
2425 def __reduce__(self):
2429 def __reduce__(self):
2436 self.dumps(C(), proto)
2440 self.dumps(D(), proto)
2444 def test_many_puts_and_gets(self):
2452 with self.subTest(proto=proto):
2453 dumped = self.dumps(obj, proto)
2454 loaded = self.loads(dumped)
2455 self.assert_is_copy(obj, loaded)
2457 def test_attribute_name_interning(self):
2464 s = self.dumps(x, proto)
2465 y = self.loads(s)
2469 self.assertIs(x_key, y_key)
2471 def test_pickle_to_2x(self):
2476 dumped = self.dumps(range(5), 2)
2477 self.assertEqual(dumped, DATA_XRANGE)
2478 dumped = self.dumps(set([3]), 2)
2479 self.assertEqual(dumped, DATA_SET2)
2481 def test_large_pickles(self):
2486 dumped = self.dumps(data, proto)
2487 loaded = self.loads(dumped)
2488 self.assertEqual(len(loaded), len(data))
2489 self.assertEqual(loaded, data)
2491 def test_int_pickling_efficiency(self):
2494 with self.subTest(proto=proto):
2495 pickles = [self.dumps(2**n, proto) for n in range(70)]
2498 self.assertEqual(sorted(sizes), sizes)
2501 self.assertFalse(opcode_in_pickle(pickle.LONG, p))
2503 def _check_pickling_with_opcode(self, obj, opcode, proto):
2504 pickled = self.dumps(obj, proto)
2505 self.assertTrue(opcode_in_pickle(opcode, pickled))
2506 unpickled = self.loads(pickled)
2507 self.assertEqual(obj, unpickled)
2509 def test_appends_on_non_lists(self):
2514 self._check_pickling_with_opcode(obj, pickle.APPEND, proto)
2516 self._check_pickling_with_opcode(obj, pickle.APPENDS, proto)
2518 def test_setitems_on_non_dicts(self):
2522 self._check_pickling_with_opcode(obj, pickle.SETITEM, proto)
2524 self._check_pickling_with_opcode(obj, pickle.SETITEMS, proto)
2531 def check_frame_opcodes(self, pickled):
2544 self.assertLessEqual(pos, frame_end)
2549 self.assertNotEqual(op.name, 'FRAME')
2553 self.assertLessEqual(len(arg), self.FRAME_SIZE_TARGET)
2558 len(arg) > self.FRAME_SIZE_TARGET)):
2562 self.assertLess(pos - frameless_start,
2563 self.FRAME_SIZE_MIN)
2569 self.assertGreaterEqual(arg, self.FRAME_SIZE_MIN)
2574 self.assertEqual(frame_end, pos)
2576 self.assertLess(pos - frameless_start, self.FRAME_SIZE_MIN)
2579 def test_framing_many_objects(self):
2582 with self.subTest(proto=proto):
2583 pickled = self.dumps(obj, proto)
2584 unpickled = self.loads(pickled)
2585 self.assertEqual(obj, unpickled)
2588 self.assertGreater(bytes_per_frame,
2589 self.FRAME_SIZE_TARGET / 2)
2590 self.assertLessEqual(bytes_per_frame,
2591 self.FRAME_SIZE_TARGET * 1)
2592 self.check_frame_opcodes(pickled)
2594 def test_framing_large_objects(self):
2600 with self.subTest(proto=proto, fast=fast):
2604 pickled = self.dumps(obj, proto)
2607 if not hasattr(self, 'pickler'):
2610 pickler = self.pickler(buf, protocol=proto)
2614 unpickled = self.loads(pickled)
2616 self.assertEqual([len(x) for x in obj],
2619 self.assertEqual(obj, unpickled)
2623 self.assertEqual(n_frames, 1)
2624 self.check_frame_opcodes(pickled)
2626 def test_optional_frames(self):
2649 frame_size = self.FRAME_SIZE_TARGET
2657 pickled = self.dumps(obj, proto)
2660 self.assertEqual(count_opcode(pickle.FRAME, frameless_pickle), 0)
2661 self.assertEqual(obj, self.loads(frameless_pickle))
2664 self.assertLess(count_opcode(pickle.FRAME, some_frames_pickle),
2666 self.assertEqual(obj, self.loads(some_frames_pickle))
2669 def test_framed_write_sizes_with_delayed_writer(self):
2672 def __init__(self):
2673 self.chunks = []
2674 def write(self, chunk):
2675 self.chunks.append(chunk)
2676 def concatenate_chunks(self):
2677 return b"".join(self.chunks)
2684 (self.FRAME_SIZE_TARGET // 16 + 1))
2692 self.pickler(writer, proto).dump(objects)
2698 reconstructed = self.loads(pickled)
2699 self.assertEqual(reconstructed, objects)
2700 self.assertGreater(len(writer.chunks), 1)
2705 self.assertEqual(writer.concatenate_chunks(), pickled)
2707 n_frames = (len(pickled) - 1) // self.FRAME_SIZE_TARGET + 1
2709 self.assertGreaterEqual(len(writer.chunks), n_frames)
2714 self.assertLessEqual(len(writer.chunks), 2 * n_frames + 3)
2718 if s >= self.FRAME_SIZE_TARGET]
2720 if 9 < s < self.FRAME_SIZE_TARGET]
2725 self.assertLess(chunk_size, 2 * self.FRAME_SIZE_TARGET,
2730 self.assertLessEqual(len(small_sizes),
2734 def test_nested_names(self):
2743 with self.subTest(proto=proto, obj=obj):
2744 unpickled = self.loads(self.dumps(obj, proto))
2745 self.assertIs(obj, unpickled)
2747 def test_recursive_nested_names(self):
2754 with self.subTest(proto=proto):
2755 unpickled = self.loads(self.dumps(Recursive, proto))
2756 self.assertIs(unpickled, Recursive)
2759 def test_py_methods(self):
2769 def biscuits(self):
2770 assert isinstance(self, PyMethodsTest)
2781 def pie(self):
2782 assert isinstance(self, PyMethodsTest.Nested)
2799 with self.subTest(proto=proto, method=method):
2800 unpickled = self.loads(self.dumps(method, proto))
2801 self.assertEqual(method(), unpickled())
2804 with self.subTest(proto=proto, method=method):
2805 unpickled = self.loads(self.dumps(method, proto))
2806 self.assertEqual(method(obj), unpickled(obj))
2814 with self.subTest(proto=proto, descr=descr):
2815 self.assertRaises(TypeError, self.dumps, descr, proto)
2817 def test_c_methods(self):
2848 with self.subTest(proto=proto, method=method):
2849 unpickled = self.loads(self.dumps(method, proto))
2850 self.assertEqual(method(*args), unpickled(*args))
2858 with self.subTest(proto=proto, descr=descr):
2859 self.assertRaises(TypeError, self.dumps, descr, proto)
2861 def test_compat_pickle(self):
2874 with self.subTest(type=type(val), proto=proto):
2875 pickled = self.dumps(val, proto)
2876 self.assertIn(('c%s\n%s' % (mod, name)).encode(), pickled)
2877 self.assertIs(type(self.loads(pickled)), type(val))
2879 def test_local_lookup_error(self):
2886 with self.assertRaises((AttributeError, pickle.PicklingError)):
2887 pickletools.dis(self.dumps(f, proto))
2892 with self.assertRaises((AttributeError, pickle.PicklingError)):
2893 pickletools.dis(self.dumps(f, proto))
2897 with self.assertRaises((AttributeError, pickle.PicklingError)):
2898 pickletools.dis(self.dumps(f, proto))
2904 def buffer_like_objects(self):
2924 def test_in_band_buffers(self):
2926 for obj in self.buffer_like_objects():
2928 data = self.dumps(obj, proto)
2931 self.assertIn(b"abcdefgh", data)
2932 self.assertEqual(count_opcode(pickle.NEXT_BUFFER, data), 0)
2934 self.assertEqual(count_opcode(pickle.SHORT_BINBYTES, data),
2936 self.assertEqual(count_opcode(pickle.BYTEARRAY8, data),
2942 data2 = self.dumps(obj, proto,
2944 self.assertEqual(data2, data)
2946 new = self.loads(data)
2948 self.assertIsNot(new, obj)
2949 self.assertIs(type(new), type(obj))
2950 self.assertEqual(new, obj)
2955 def test_oob_buffers(self):
2957 for obj in self.buffer_like_objects():
2960 with self.assertRaises(ValueError):
2961 self.dumps(obj, proto,
2966 data = self.dumps(obj, proto,
2968 self.assertNotIn(b"abcdefgh", data)
2969 self.assertEqual(count_opcode(pickle.SHORT_BINBYTES, data), 0)
2970 self.assertEqual(count_opcode(pickle.BYTEARRAY8, data), 0)
2971 self.assertEqual(count_opcode(pickle.NEXT_BUFFER, data), 1)
2972 self.assertEqual(count_opcode(pickle.READONLY_BUFFER, data),
2976 self.assertEqual(bytes(buffers[0]), b"abcdefgh")
2978 with self.assertRaises(pickle.UnpicklingError):
2979 self.loads(data)
2981 new = self.loads(data, buffers=buffers)
2984 self.assertIs(new, obj)
2986 self.assertIs(type(new), type(obj))
2987 self.assertEqual(new, obj)
2989 new = self.loads(data, buffers=iter(buffers))
2992 self.assertIs(new, obj)
2994 self.assertIs(type(new), type(obj))
2995 self.assertEqual(new, obj)
2997 def test_oob_buffers_writable_to_readonly(self):
3003 data = self.dumps(obj, proto, buffer_callback=buffer_callback)
3006 new = self.loads(data, buffers=buffers)
3007 self.assertIs(type(new), type(obj))
3008 self.assertEqual(new, obj)
3010 def test_picklebuffer_error(self):
3014 with self.assertRaises(pickle.PickleError):
3015 self.dumps(pb, proto)
3017 def test_buffer_callback_error(self):
3021 with self.assertRaises(ZeroDivisionError):
3022 self.dumps(pb, 5, buffer_callback=buffer_callback)
3024 def test_buffers_error(self):
3027 data = self.dumps(pb, proto, buffer_callback=[].append)
3029 with self.assertRaises(TypeError):
3030 self.loads(data, buffers=object())
3032 with self.assertRaises(pickle.UnpicklingError):
3033 self.loads(data, buffers=[])
3035 def test_inband_accept_default_buffers_argument(self):
3037 data_pickled = self.dumps(1, proto, buffer_callback=None)
3038 data = self.loads(data_pickled, buffers=None)
3041 def test_buffers_numpy(self):
3044 self.assertEqual(x.ctypes.data, y.ctypes.data)
3048 self.assertNotEqual(x.ctypes.data, y.ctypes.data)
3053 data = self.dumps(arr, proto)
3054 new = self.loads(data)
3058 data = self.dumps(arr, proto, buffer_callback=buffer_callback)
3059 new = self.loads(data)
3065 data = self.dumps(arr, proto, buffer_callback=buffer_callback)
3066 new = self.loads(data, buffers=buffers)
3085 def test_evil_class_mutating_dict(self):
3091 def __eq__(self, other):
3093 def __hash__(self):
3095 def __reduce__(self):
3109 data = self.dumps(collection, proto)
3110 self.loads(data)
3113 self.assertIn(expected, str(e))
3115 def test_evil_pickler_mutating_collection(self):
3117 if not hasattr(self, "pickler"):
3118 raise self.skipTest(f"{type(self)} has no associated pickler type")
3125 class EvilPickler(self.pickler):
3126 def persistent_id(self, obj):
3135 self.assertIn(expected, str(e))
3152 def test_huge_long_32b(self, size):
3158 with self.subTest(proto=proto):
3159 with self.assertRaises((ValueError, OverflowError)):
3160 self.dumps(data, protocol=proto)
3169 def test_huge_bytes_32b(self, size):
3175 with self.subTest(proto=proto):
3177 pickled = self.dumps(data, protocol=proto)
3181 self.assertEqual(
3190 def test_huge_bytes_64b(self, size):
3196 with self.subTest(proto=proto):
3200 with self.assertRaises((ValueError, OverflowError)):
3201 self.dumps(data, protocol=proto)
3204 pickled = self.dumps(data, protocol=proto)
3208 self.assertEqual(
3220 def test_huge_str_32b(self, size):
3226 with self.subTest(proto=proto):
3228 pickled = self.dumps(data, protocol=proto)
3232 self.assertEqual(
3235 self.assertEqual((pickled.rindex(b"abcd") + len(b"abcd") -
3247 def test_huge_str_64b(self, size):
3253 with self.subTest(proto=proto):
3255 with self.assertRaises((ValueError, OverflowError)):
3256 self.dumps(data, protocol=proto)
3259 pickled = self.dumps(data, protocol=proto)
3263 self.assertEqual(
3266 self.assertEqual((pickled.rindex(b"abcd") + len(b"abcd") -
3279 def __reduce__(self):
3280 self._reduce_called = 1
3286 def __reduce_ex__(self, proto):
3287 self._proto = proto
3292 def __reduce_ex__(self, proto):
3293 self._proto = proto
3295 def __reduce__(self):
3301 def __reduce_ex__(self, proto):
3302 self._proto = proto
3303 return object.__reduce_ex__(self, proto)
3308 def __reduce__(self):
3309 self._reduce_called = 1
3310 return object.__reduce__(self)
3316 def __init__(self, items=None):
3317 self.items = items if items is not None else []
3318 def __eq__(self, other):
3319 return type(self) is type(other) and self.items == other.items
3320 def append(self, item):
3321 self.items.append(item)
3322 def __reduce__(self):
3323 return type(self), (), None, iter(self.items), None
3329 def __init__(self, table=None):
3330 self.table = table if table is not None else {}
3331 def __eq__(self, other):
3332 return type(self) is type(other) and self.table == other.table
3333 def __setitem__(self, key, value):
3334 self.table[key] = value
3335 def __reduce__(self):
3336 return type(self), (), None, None, iter(self.table.items())
3342 def __init__(self, state=None):
3343 self.state = state
3344 def __eq__(self, other):
3345 return type(self) is type(other) and self.state == other.state
3346 def __setstate__(self, state):
3347 self.state = state
3348 def __reduce__(self):
3349 return type(self), (), self.state
3401 def __init__(self, *args, **kwargs):
3404 def __eq__(self, other):
3405 return int(self) == int(other) and self.__dict__ == other.__dict__
3408 def __getnewargs__(self):
3409 return ('%X' % self, 16)
3412 def __getnewargs_ex__(self):
3413 return ('%X' % self,), {'base': 16}
3416 def __getattr__(self, key):
3417 self.foo
3422 def test_dump_closed_file(self):
3426 self.assertRaises(ValueError, self.dump, 123, f)
3430 def test_load_closed_file(self):
3434 self.assertRaises(ValueError, self.dump, 123, f)
3438 def test_load_from_and_dump_to_file(self):
3441 self.dump(data, stream)
3443 unpickled = self.load(stream)
3444 self.assertEqual(unpickled, data)
3446 def test_highest_protocol(self):
3448 self.assertEqual(pickle.HIGHEST_PROTOCOL, 5)
3450 def test_callapi(self):
3453 self.dump(123, f, -1)
3454 self.dump(123, file=f, protocol=-1)
3455 self.dumps(123, -1)
3456 self.dumps(123, protocol=-1)
3457 self.Pickler(f, -1)
3458 self.Pickler(f, protocol=-1)
3460 def test_dump_text_file(self):
3464 self.assertRaises(TypeError, self.dump, 123, f, proto)
3469 def test_incomplete_input(self):
3471 self.assertRaises((EOFError, struct.error, pickle.UnpicklingError), self.load, s)
3473 def test_bad_init(self):
3476 class BadPickler(self.Pickler):
3477 def __init__(self): pass
3479 class BadUnpickler(self.Unpickler):
3480 def __init__(self): pass
3482 self.assertRaises(pickle.PicklingError, BadPickler().dump, 0)
3483 self.assertRaises(pickle.UnpicklingError, BadUnpickler().load)
3485 def check_dumps_loads_oob_buffers(self, dumps, loads):
3493 with self.assertRaises(ValueError):
3501 self.assertNotIn(b"foo", data)
3502 self.assertEqual(bytes(buffers[0]), b"foo")
3504 with self.assertRaises(pickle.UnpicklingError):
3507 self.assertIs(new, obj)
3509 def test_dumps_loads_oob_buffers(self):
3511 self.check_dumps_loads_oob_buffers(self.dumps, self.loads)
3513 def test_dump_load_oob_buffers(self):
3517 self.dump(obj, f, **kwargs)
3522 return self.load(f, **kwargs)
3524 self.check_dumps_loads_oob_buffers(dumps, loads)
3533 def persistent_id(self, object):
3535 self.id_count += 1
3538 self.false_count += 1
3543 def persistent_load(self, oid):
3545 self.load_false_count += 1
3548 self.load_count += 1
3553 def test_persistence(self):
3556 self.id_count = 0
3557 self.false_count = 0
3558 self.load_false_count = 0
3559 self.load_count = 0
3560 self.assertEqual(self.loads(self.dumps(L, proto)), L)
3561 self.assertEqual(self.id_count, 5)
3562 self.assertEqual(self.false_count, 1)
3563 self.assertEqual(self.load_count, 5)
3564 self.assertEqual(self.load_false_count, 1)
3569 def persistent_id(self, obj):
3572 def persistent_load(self, pid):
3575 def _check_return_correct_type(self, obj, proto):
3576 unpickled = self.loads(self.dumps(obj, proto))
3577 self.assertIsInstance(unpickled, type(obj))
3578 self.assertEqual(unpickled, obj)
3580 def test_return_correct_type(self):
3584 self._check_return_correct_type("abc", 0)
3587 self._check_return_correct_type(obj, proto)
3589 def test_protocol0_is_ascii_only(self):
3591 self.assertRaises(pickle.PicklingError, self.dumps, non_ascii_str, 0)
3593 self.assertRaises(pickle.UnpicklingError, self.loads, pickled)
3601 def setUp(self):
3602 assert self.pickler_class
3603 assert self.unpickler_class
3605 def test_clear_pickler_memo(self):
3614 pickler = self.pickler_class(f, proto)
3634 self.assertNotEqual(first_pickled, second_pickled)
3635 self.assertEqual(first_pickled, third_pickled)
3637 def test_priming_pickler_memo(self):
3641 pickler = self.pickler_class(f)
3647 primed = self.pickler_class(f)
3653 self.assertNotEqual(first_pickled, primed_pickled)
3655 def test_priming_unpickler_memo(self):
3659 pickler = self.pickler_class(f)
3665 primed = self.pickler_class(f)
3671 unpickler = self.unpickler_class(io.BytesIO(first_pickled))
3674 self.assertEqual(unpickled_data1, data)
3676 primed = self.unpickler_class(io.BytesIO(primed_pickled))
3682 self.assertEqual(unpickled_data2, data)
3683 self.assertTrue(unpickled_data2 is unpickled_data1)
3685 def test_reusing_unpickler_objects(self):
3688 pickler = self.pickler_class(f)
3694 pickler = self.pickler_class(f)
3701 unpickler = self.unpickler_class(f)
3702 self.assertEqual(unpickler.load(), data1)
3708 self.assertEqual(unpickler.load(), data2)
3710 def _check_multiple_unpicklings(self, ioclass, *, seekable=True):
3712 with self.subTest(proto=proto):
3715 pickler = self.pickler_class(f, protocol=proto)
3721 unpickler = self.unpickler_class(f)
3725 self.assertEqual(unpickler.load(), data1)
3727 self.assertEqual(f.tell(), pos + len(pickled))
3728 self.assertRaises(EOFError, unpickler.load)
3730 def test_multiple_unpicklings_seekable(self):
3731 self._check_multiple_unpicklings(io.BytesIO)
3733 def test_multiple_unpicklings_unseekable(self):
3734 self._check_multiple_unpicklings(UnseekableIO, seekable=False)
3736 def test_multiple_unpicklings_minimal(self):
3739 self._check_multiple_unpicklings(MinimalIO, seekable=False)
3741 def test_unpickling_buffering_readline(self):
3748 pickler = self.pickler_class(f, protocol=proto)
3751 unpickler = self.unpickler_class(f)
3752 self.assertEqual(unpickler.load(), data)
3760 def __reduce__(self):
3764 def __init__(self):
3767 self.a = "some attribute"
3769 def __setstate__(self, state):
3770 self.a = "BBB.__setstate__"
3788 def reducer_override(self, obj):
3811 def test_pickler_hook(self):
3829 with self.subTest(proto=proto):
3831 p = self.pickler_class(bio, proto)
3836 self.assertEqual(new_f, 5)
3837 self.assertEqual(some_str, 'some str')
3842 self.assertIs(math_log, math.log)
3844 with self.assertRaises(pickle.PicklingError):
3847 with self.assertRaisesRegex(
3852 def test_reducer_override_no_reference_cycle(self):
3858 with self.subTest(proto=proto):
3865 p = self.pickler_class(bio, proto)
3873 self.assertIsNone(wr())
3878 def test_default_dispatch_table(self):
3881 p = self.pickler_class(f, 0)
3882 with self.assertRaises(AttributeError):
3884 self.assertFalse(hasattr(p, 'dispatch_table'))
3886 def test_class_dispatch_table(self):
3888 dt = self.get_dispatch_table()
3890 class MyPickler(self.pickler_class):
3896 self.assertEqual(p.dispatch_table, dt)
3900 self._test_dispatch_table(dumps, dt)
3902 def test_instance_dispatch_table(self):
3904 dt = self.get_dispatch_table()
3908 p = self.pickler_class(f, protocol)
3910 self.assertEqual(p.dispatch_table, dt)
3914 self._test_dispatch_table(dumps, dt)
3916 def _test_dispatch_table(self, dumps, dispatch_table):
3926 self.assertEqual(custom_load_dump(z), z)
3927 self.assertEqual(default_load_dump(z), z)
3934 self.assertEqual(custom_load_dump(z), REDUCE_1)
3935 self.assertEqual(default_load_dump(z), z)
3940 self.assertEqual(custom_load_dump(a), REDUCE_A)
3941 self.assertIsInstance(custom_load_dump(b), BBB)
3942 self.assertEqual(default_load_dump(a), REDUCE_A)
3943 self.assertIsInstance(default_load_dump(b), BBB)
3947 self.assertEqual(custom_load_dump(a), REDUCE_A)
3948 self.assertEqual(custom_load_dump(b), REDUCE_1)
3949 self.assertEqual(default_load_dump(a), REDUCE_A)
3950 self.assertIsInstance(default_load_dump(b), BBB)
3958 self.assertEqual(custom_load_dump(a), REDUCE_2)
3959 self.assertIsInstance(custom_load_dump(b), BBB)
3960 self.assertEqual(default_load_dump(a), REDUCE_A)
3961 self.assertIsInstance(default_load_dump(b), BBB)
3971 self.assertEqual(default_load_dump(b).a, "BBB.__setstate__")
3980 self.assertEqual(custom_load_dump(b).a, "custom state_setter")