for op, dummy, dummy in pickletools.genops(pickle):

if op.code == code.decode("latin-1"):

return True

n = 0

for op, dummy, dummy in pickletools.genops(pickle):

if op.code == code.decode("latin-1"):

n += 1

# Produce geometrical increasing sequence from start to stop

# (inclusively) for tests.

size = start

while size < stop:

yield size

size <<= 1

def peek(self, *args):

raise NotImplementedError

def seekable(self):

return False

def seek(self, *args):

raise io.UnsupportedOperation

def tell(self):

"""

def __init__(self, *args):

self._bio = io.BytesIO(*args)

self.getvalue = self._bio.getvalue

self.read = self._bio.read

self.readline = self._bio.readline

# Remember current registration for code (if any), and remove it (if

# there is one).

def __init__(self, code):

self.code = code

if code in copyreg._inverted_registry:

self.pair = copyreg._inverted_registry[code]

copyreg.remove_extension(self.pair[0], self.pair[1], code)

else:

self.pair = None

# Restore previous registration for code.

def restore(self):

code = self.code

curpair = copyreg._inverted_registry.get(code)

if curpair is not None:

copyreg.remove_extension(curpair[0], curpair[1], code)

pair = self.pair

if pair is not None:

def __eq__(self, other):

return (type(self) == type(other) and

self.reduce_args == other.reduce_args)

def __reduce__(self):

# A not-really-zero-copy picklable ndarray, as the ndarray()

# constructor doesn't allow for it

zero_copy_reconstruct = False

def __init__(self, *args, **kwargs):

self.array = _testbuffer.ndarray(*args, **kwargs)

def __getitem__(self, idx):

cls = type(self)

new = cls.__new__(cls)

new.array = self.array[idx]

return new

@property

def readonly(self):

return self.array.readonly

@property

def c_contiguous(self):

return self.array.c_contiguous

@property

def f_contiguous(self):

return self.array.f_contiguous

def __eq__(self, other):

if not isinstance(other, PicklableNDArray):

return NotImplemented

return (other.array.format == self.array.format and

other.array.shape == self.array.shape and

other.array.strides == self.array.strides and

other.array.readonly == self.array.readonly and

other.array.tobytes() == self.array.tobytes())

def __ne__(self, other):

if not isinstance(other, PicklableNDArray):

return NotImplemented

return not (self == other)

def __repr__(self):

return ("{name}(shape={array.shape},"

"strides={array.strides}, "

"bytes={array.tobytes()})").format(

name=type(self).__name__, array=self.array.shape)

def __reduce_ex__(self, protocol):

if not self.array.contiguous:

raise NotImplementedError("Reconstructing a non-contiguous "

"ndarray does not seem possible")

ndarray_kwargs = {"shape": self.array.shape,

"strides": self.array.strides,

"format": self.array.format,

"flags": (0 if self.readonly

else _testbuffer.ND_WRITABLE)}

pb = pickle.PickleBuffer(self.array)

if protocol >= 5:

return (type(self)._reconstruct,

(pb, ndarray_kwargs))

else:

# Need to serialize the bytes in physical order

with pb.raw() as m:

return (type(self)._reconstruct,

(m.tobytes(), ndarray_kwargs))

@classmethod

def _reconstruct(cls, obj, kwargs):

with memoryview(obj) as m:

# For some reason, ndarray() wants a list of integers...

# XXX This only works if format == 'B'

items = list(m.tobytes())

b'(lp0\nL0L\naL1L\naF2.0\n'

b'ac__builtin__\ncomple'

b'x\np1\n(F3.0\nF0.0\ntp2\n'

b'Rp3\naL1L\naL-1L\naL255'

b'L\naL-255L\naL-256L\naL'

b'65535L\naL-65535L\naL-'

b'65536L\naL2147483647L'

b'\naL-2147483647L\naL-2'

b'147483648L\na(Vabc\np4'

b'\ng4\nccopy_reg\n_recon'

b'structor\np5\n(c__main'

b'__\nC\np6\nc__builtin__'

b'\nobject\np7\nNtp8\nRp9\n'

b'(dp10\nVfoo\np11\nL1L\ns'

b'Vbar\np12\nL2L\nsbg9\ntp'

b'13\nag13\naL5L\na.'

b']q\x00(K\x00K\x01G@\x00\x00\x00\x00\x00\x00\x00c__'

b'builtin__\ncomplex\nq\x01'

b'(G@\x08\x00\x00\x00\x00\x00\x00G\x00\x00\x00\x00\x00\x00\x00\x00t'

b'q\x02Rq\x03K\x01J\xff\xff\xff\xffK\xffJ\x01\xff\xff\xffJ'

b'\x00\xff\xff\xffM\xff\xffJ\x01\x00\xff\xffJ\x00\x00\xff\xffJ\xff\xff'

b'\xff\x7fJ\x01\x00\x00\x80J\x00\x00\x00\x80(X\x03\x00\x00\x00ab'

b'cq\x04h\x04ccopy_reg\n_reco'

b'nstructor\nq\x05(c__main'

b'__\nC\nq\x06c__builtin__\n'

b'object\nq\x07Ntq\x08Rq\t}q\n('

b'X\x03\x00\x00\x00fooq\x0bK\x01X\x03\x00\x00\x00bar'

b'q\x0cK\x02ubh\ttq\rh\rK\x05e.'

b'\x80\x02]q\x00(K\x00K\x01G@\x00\x00\x00\x00\x00\x00\x00c'

b'__builtin__\ncomplex\n'

b'q\x01G@\x08\x00\x00\x00\x00\x00\x00G\x00\x00\x00\x00\x00\x00\x00\x00'

b'\x86q\x02Rq\x03K\x01J\xff\xff\xff\xffK\xffJ\x01\xff\xff\xff'

b'J\x00\xff\xff\xffM\xff\xffJ\x01\x00\xff\xffJ\x00\x00\xff\xffJ\xff'

b'\xff\xff\x7fJ\x01\x00\x00\x80J\x00\x00\x00\x80(X\x03\x00\x00\x00a'

b'bcq\x04h\x04c__main__\nC\nq\x05'

b')\x81q\x06}q\x07(X\x03\x00\x00\x00fooq\x08K\x01'

b'X\x03\x00\x00\x00barq\tK\x02ubh\x06tq\nh'

b'\nK\x05e.'

b'\x80\x03]q\x00(K\x00K\x01G@\x00\x00\x00\x00\x00\x00\x00c'

b'builtins\ncomplex\nq\x01G'

b'@\x08\x00\x00\x00\x00\x00\x00G\x00\x00\x00\x00\x00\x00\x00\x00\x86q\x02'

b'Rq\x03K\x01J\xff\xff\xff\xffK\xffJ\x01\xff\xff\xffJ\x00\xff'

b'\xff\xffM\xff\xffJ\x01\x00\xff\xffJ\x00\x00\xff\xffJ\xff\xff\xff\x7f'

b'J\x01\x00\x00\x80J\x00\x00\x00\x80(X\x03\x00\x00\x00abcq'

b'\x04h\x04c__main__\nC\nq\x05)\x81q'

b'\x06}q\x07(X\x03\x00\x00\x00barq\x08K\x02X\x03\x00'

b'\x00\x00fooq\tK\x01ubh\x06tq\nh\nK\x05'

b'e.'

b'\x80\x04\x95\xa8\x00\x00\x00\x00\x00\x00\x00]\x94(K\x00K\x01G@'

b'\x00\x00\x00\x00\x00\x00\x00\x8c\x08builtins\x94\x8c\x07'

b'complex\x94\x93\x94G@\x08\x00\x00\x00\x00\x00\x00G'

b'\x00\x00\x00\x00\x00\x00\x00\x00\x86\x94R\x94K\x01J\xff\xff\xff\xffK'

b'\xffJ\x01\xff\xff\xffJ\x00\xff\xff\xffM\xff\xffJ\x01\x00\xff\xffJ'

b'\x00\x00\xff\xffJ\xff\xff\xff\x7fJ\x01\x00\x00\x80J\x00\x00\x00\x80('

b'\x8c\x03abc\x94h\x06\x8c\x08__main__\x94\x8c'

b'\x01C\x94\x93\x94)\x81\x94}\x94(\x8c\x03bar\x94K\x02\x8c'

b'\x03foo\x94K\x01ubh\nt\x94h\x0eK\x05e.'

b'q\x02cCookie\nMorsel\nq\x03)\x81q\x04(U\x07commentq\x05U'

b'\x00q\x06U\x06domainq\x07h\x06U\x06secureq\x08h\x06U\x07'

b'expiresq\th\x06U\x07max-ageq\nh\x06U\x07versionq\x0bh\x06U'

b'\x04pathq\x0ch\x06U\x08httponlyq\rh\x06u}q\x0e(U\x0b'

ArithmeticError,

AssertionError,

AttributeError,

BaseException,

BufferError,

BytesWarning,

DeprecationWarning,

EOFError,

EnvironmentError,

Exception,

FloatingPointError,

FutureWarning,

GeneratorExit,

IOError,

ImportError,

ImportWarning,

IndentationError,

IndexError,

KeyError,

KeyboardInterrupt,

LookupError,

MemoryError,

NameError,

NotImplementedError,

OSError,

OverflowError,

PendingDeprecationWarning,

ReferenceError,

RuntimeError,

RuntimeWarning,

# StandardError is gone in Python 3, we map it to Exception

StopIteration,

SyntaxError,

SyntaxWarning,

SystemError,

SystemExit,

TabError,

TypeError,

UnboundLocalError,

UnicodeError,

UnicodeWarning,

UserWarning,

ValueError,

Warning,

ZeroDivisionError,

c = C()

c.foo = 1

c.bar = 2

x = [0, 1, 2.0, 3.0+0j]

# Append some integer test cases at cPickle.c's internal size

# cutoffs.

uint1max = 0xff

uint2max = 0xffff

int4max = 0x7fffffff

x.extend([1, -1,

uint1max, -uint1max, -uint1max-1,

uint2max, -uint2max, -uint2max-1,

int4max, -int4max, -int4max-1])

y = ('abc', 'abc', c, c)

x.append(y)

x.append(y)

x.append(5)

# Subclass must define self.loads.

_testdata = create_data()

def assert_is_copy(self, obj, objcopy, msg=None):

"""Utility method to verify if two objects are copies of each others.

if msg is None:

msg = "{!r} is not a copy of {!r}".format(obj, objcopy)

self.assertEqual(obj, objcopy, msg=msg)

self.assertIs(type(obj), type(objcopy), msg=msg)

if hasattr(obj, '__dict__'):

self.assertDictEqual(obj.__dict__, objcopy.__dict__, msg=msg)

self.assertIsNot(obj.__dict__, objcopy.__dict__, msg=msg)

if hasattr(obj, '__slots__'):

self.assertListEqual(obj.__slots__, objcopy.__slots__, msg=msg)

for slot in obj.__slots__:

self.assertEqual(

hasattr(obj, slot), hasattr(objcopy, slot), msg=msg)

self.assertEqual(getattr(obj, slot, None),

getattr(objcopy, slot, None), msg=msg)

def check_unpickling_error_strict(self, errors, data):

with self.assertRaises(errors):

try:

self.loads(data)

except BaseException as exc:

if support.verbose > 1:

print('%-32r - %s: %s' %

(data, exc.__class__.__name__, exc))

raise

def check_unpickling_error(self, errors, data):

with self.subTest(data=data):

self.check_unpickling_error_strict(errors, data)

def test_load_from_data0(self):

self.assert_is_copy(self._testdata, self.loads(DATA0))

def test_load_from_data1(self):

self.assert_is_copy(self._testdata, self.loads(DATA1))

def test_load_from_data2(self):

self.assert_is_copy(self._testdata, self.loads(DATA2))

def test_load_from_data3(self):

self.assert_is_copy(self._testdata, self.loads(DATA3))

def test_load_from_data4(self):

self.assert_is_copy(self._testdata, self.loads(DATA4))

def test_load_classic_instance(self):

# See issue5180. Test loading 2.x pickles that

# contain an instance of old style class.

for X, args in [(C, ()), (D, ('x',)), (E, ())]:

xname = X.__name__.encode('ascii')

# Protocol 0 (text mode pickle):

"""

pickle0 = (b"(i__main__\n"

b"X\n"

b"p0\n"

b"(dp1\nb.").replace(b'X', xname)

self.assert_is_copy(X(*args), self.loads(pickle0))

# Protocol 1 (binary mode pickle)

"""

pickle1 = (b'(c__main__\n'

b'X\n'

b'q\x00oq\x01}q\x02b.').replace(b'X', xname)

self.assert_is_copy(X(*args), self.loads(pickle1))

# Protocol 2 (pickle2 = b'\x80\x02' + pickle1)

"""

pickle2 = (b'\x80\x02(c__main__\n'

b'X\n'

b'q\x00oq\x01}q\x02b.').replace(b'X', xname)

self.assert_is_copy(X(*args), self.loads(pickle2))

def test_load_bad_constructor(self):

# gh-154002: a TypeError raised by an old-style instance constructor

# during INST/OBJ unpickling propagates unchanged. The pure-Python

# unpickler used to replace it with one that carried the traceback

# object in its args.

# 0: ( MARK

# 1: I INT 1

# 4: i INST '__main__ BadConstructor' (MARK at 0)

# 28: . STOP

data = b'(I1\ni__main__\nBadConstructor\n.'

with self.assertRaises(TypeError) as cm:

self.loads(data)

self.assertEqual(cm.exception.args, ("bad constructor",))

def test_maxint64(self):

maxint64 = (1 << 63) - 1

data = b'I' + str(maxint64).encode("ascii") + b'\n.'

got = self.loads(data)

self.assert_is_copy(maxint64, got)

# Try too with a bogus literal.

data = b'I' + str(maxint64).encode("ascii") + b'JUNK\n.'

self.check_unpickling_error(ValueError, data)

def test_unpickle_from_2x(self):

# Unpickle non-trivial data from Python 2.x.

loaded = self.loads(DATA_SET)

self.assertEqual(loaded, set([1, 2]))

loaded = self.loads(DATA_XRANGE)

self.assertEqual(type(loaded), type(range(0)))

self.assertEqual(list(loaded), list(range(5)))

loaded = self.loads(DATA_COOKIE)

self.assertEqual(type(loaded), SimpleCookie)

self.assertEqual(list(loaded.keys()), ["key"])

self.assertEqual(loaded["key"].value, "value")

# Exception objects without arguments pickled from 2.x with protocol 2

for exc in python2_exceptions_without_args:

data = exception_pickle.replace(b'?', exc.__name__.encode("ascii"))

loaded = self.loads(data)

self.assertIs(type(loaded), exc)

# StandardError is mapped to Exception, test that separately

loaded = self.loads(exception_pickle.replace(b'?', b'StandardError'))

self.assertIs(type(loaded), Exception)

loaded = self.loads(DATA_UEERR)

self.assertIs(type(loaded), UnicodeEncodeError)

self.assertEqual(loaded.object, "foo")

self.assertEqual(loaded.encoding, "ascii")

self.assertEqual(loaded.start, 0)

self.assertEqual(loaded.end, 1)

self.assertEqual(loaded.reason, "bad")

def test_load_python2_str_as_bytes(self):

# From Python 2: pickle.dumps('a\x00\xa0', protocol=0)

self.assertEqual(self.loads(b"S'a\\x00\\xa0'\n.",

encoding="bytes"), b'a\x00\xa0')

# From Python 2: pickle.dumps('a\x00\xa0', protocol=1)

self.assertEqual(self.loads(b'U\x03a\x00\xa0.',

encoding="bytes"), b'a\x00\xa0')

# From Python 2: pickle.dumps('a\x00\xa0', protocol=2)

self.assertEqual(self.loads(b'\x80\x02U\x03a\x00\xa0.',

encoding="bytes"), b'a\x00\xa0')

def test_load_python2_unicode_as_str(self):

# From Python 2: pickle.dumps(u'π', protocol=0)

self.assertEqual(self.loads(b'V\\u03c0\n.',

encoding='bytes'), 'π')

# From Python 2: pickle.dumps(u'π', protocol=1)

self.assertEqual(self.loads(b'X\x02\x00\x00\x00\xcf\x80.',

encoding="bytes"), 'π')

# From Python 2: pickle.dumps(u'π', protocol=2)

self.assertEqual(self.loads(b'\x80\x02X\x02\x00\x00\x00\xcf\x80.',

encoding="bytes"), 'π')

def test_load_long_python2_str_as_bytes(self):

# From Python 2: pickle.dumps('x' * 300, protocol=1)

self.assertEqual(self.loads(pickle.BINSTRING +

struct.pack("<I", 300) +

b'x' * 300 + pickle.STOP,

encoding='bytes'), b'x' * 300)

def test_constants(self):

self.assertIsNone(self.loads(b'N.'))

self.assertIs(self.loads(b'\x88.'), True)

self.assertIs(self.loads(b'\x89.'), False)

self.assertIs(self.loads(b'I01\n.'), True)

self.assertIs(self.loads(b'I00\n.'), False)

def test_issue135241(self):

# C implementation should check for hardcoded values 00 and 01

# when getting booleans from the INT opcode. Doing a str comparison

# to bypass truthy/falsy comparisons. These payloads should return

# 0, not False.

out1 = self.loads(b'I+0\n.')

self.assertEqual(str(out1), '0')

out2 = self.loads(b'I 0\n.')

self.assertEqual(str(out2), '0')

def test_zero_padded_integers(self):

self.assertEqual(self.loads(b'I010\n.'), 10)

self.assertEqual(self.loads(b'I-010\n.'), -10)

self.assertEqual(self.loads(b'I0010\n.'), 10)

self.assertEqual(self.loads(b'I-0010\n.'), -10)

self.assertEqual(self.loads(b'L010\n.'), 10)

self.assertEqual(self.loads(b'L-010\n.'), -10)

self.assertEqual(self.loads(b'L0010\n.'), 10)

self.assertEqual(self.loads(b'L-0010\n.'), -10)

self.assertEqual(self.loads(b'L010L\n.'), 10)

self.assertEqual(self.loads(b'L-010L\n.'), -10)

def test_nondecimal_integers(self):

self.assertRaises(ValueError, self.loads, b'I0b10\n.')

self.assertRaises(ValueError, self.loads, b'I0o10\n.')

self.assertRaises(ValueError, self.loads, b'I0x10\n.')

self.assertRaises(ValueError, self.loads, b'L0b10L\n.')

self.assertRaises(ValueError, self.loads, b'L0o10L\n.')

self.assertRaises(ValueError, self.loads, b'L0x10L\n.')

def test_empty_bytestring(self):

# issue 11286

empty = self.loads(b'\x80\x03U\x00q\x00.', encoding='koi8-r')

self.assertEqual(empty, '')

def test_short_binbytes(self):

dumped = b'\x80\x03C\x04\xe2\x82\xac\x00.'

self.assertEqual(self.loads(dumped), b'\xe2\x82\xac\x00')

def test_binbytes(self):

dumped = b'\x80\x03B\x04\x00\x00\x00\xe2\x82\xac\x00.'

self.assertEqual(self.loads(dumped), b'\xe2\x82\xac\x00')

@requires_32b

def test_negative_32b_binbytes(self):

# On 32-bit builds, a BINBYTES of 2**31 or more is refused

dumped = b'\x80\x03B\xff\xff\xff\xffxyzq\x00.'

self.check_unpickling_error((pickle.UnpicklingError, OverflowError),

dumped)

@requires_32b

def test_negative_32b_binunicode(self):

# On 32-bit builds, a BINUNICODE of 2**31 or more is refused

dumped = b'\x80\x03X\xff\xff\xff\xffxyzq\x00.'

self.check_unpickling_error((pickle.UnpicklingError, OverflowError),

dumped)

def test_short_binunicode(self):

dumped = b'\x80\x04\x8c\x04\xe2\x82\xac\x00.'

self.assertEqual(self.loads(dumped), '\u20ac\x00')

def test_misc_get(self):