import builtins

import collections

import copyreg

import dbm

import io

import functools

import os

import math

import pickle

import pickletools

import shutil

import struct

import sys

import threading

import types

import unittest

import weakref

from textwrap import dedent

from http.cookies import SimpleCookie

try:

import _testbuffer

except ImportError:

_testbuffer = None

from test import support

from test.support import os_helper

from test.support import (

TestFailed, run_with_locale, no_tracing,

_2G, _4G, bigmemtest

)

from test.support.import_helper import forget

from test.support.os_helper import TESTFN

from test.support import threading_helper

from test.support.warnings_helper import save_restore_warnings_filters

from pickle import bytes_types

# bpo-41003: Save/restore warnings filters to leave them unchanged.

# Ignore filters installed by numpy.

try:

with save_restore_warnings_filters():

import numpy as np

except ImportError:

np = None

requires_32b = unittest.skipUnless(sys.maxsize < 2**32,

"test is only meaningful on 32-bit builds")

# Tests that try a number of pickle protocols should have a

# for proto in protocols:

# kind of outer loop.

protocols = range(pickle.HIGHEST_PROTOCOL + 1)

# Return True if opcode code appears in the pickle, else False.

def opcode_in_pickle(code, pickle):

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

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

return True

return False

# Return the number of times opcode code appears in pickle.

def count_opcode(code, pickle):

n = 0

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

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

n += 1

return n

def identity(x):

return x

class UnseekableIO(io.BytesIO):

def peek(self, *args):

raise NotImplementedError

def seekable(self):

return False

def seek(self, *args):

raise io.UnsupportedOperation

def tell(self):

raise io.UnsupportedOperation

class MinimalIO(object):

"""

A file-like object that doesn't support readinto().

"""

def __init__(self, *args):

self._bio = io.BytesIO(*args)

self.getvalue = self._bio.getvalue

self.read = self._bio.read

self.readline = self._bio.readline

self.write = self._bio.write

# We can't very well test the extension registry without putting known stuff

# in it, but we have to be careful to restore its original state. Code

# should do this:

#

# e = ExtensionSaver(extension_code)

# try:

# fiddle w/ the extension registry's stuff for extension_code

# finally:

# e.restore()

class ExtensionSaver:

# 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:

copyreg.add_extension(pair[0], pair[1], code)

class C:

def __eq__(self, other):

return self.__dict__ == other.__dict__

class D(C):

def __init__(self, arg):

pass

class E(C):

def __getinitargs__(self):

return ()

# Simple mutable object.

class Object:

pass

# Hashable immutable key object containing unheshable mutable data.

class K:

def __init__(self, value):

self.value = value

def __reduce__(self):

# Shouldn't support the recursion itself

return K, (self.value,)

import __main__

__main__.C = C

C.__module__ = "__main__"

__main__.D = D

D.__module__ = "__main__"

__main__.E = E

E.__module__ = "__main__"

class myint(int):

def __init__(self, x):

self.str = str(x)

class initarg(C):

def __init__(self, a, b):

self.a = a

self.b = b

def __getinitargs__(self):

return self.a, self.b

class metaclass(type):

pass

class use_metaclass(object, metaclass=metaclass):

pass

class pickling_metaclass(type):

def __eq__(self, other):

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

self.reduce_args == other.reduce_args)

def __reduce__(self):

return (create_dynamic_class, self.reduce_args)

def create_dynamic_class(name, bases):

result = pickling_metaclass(name, bases, dict())

result.reduce_args = (name, bases)

return result

class ZeroCopyBytes(bytes):

readonly = True

c_contiguous = True

f_contiguous = True

zero_copy_reconstruct = True

def __reduce_ex__(self, protocol):

if protocol >= 5:

return type(self)._reconstruct, (pickle.PickleBuffer(self),), None

else:

return type(self)._reconstruct, (bytes(self),)

def __repr__(self):

return "{}({!r})".format(self.__class__.__name__, bytes(self))

__str__ = __repr__

@classmethod

def _reconstruct(cls, obj):

with memoryview(obj) as m:

obj = m.obj

if type(obj) is cls:

# Zero-copy

return obj

else:

return cls(obj)

class ZeroCopyBytearray(bytearray):

readonly = False

c_contiguous = True

f_contiguous = True

zero_copy_reconstruct = True

def __reduce_ex__(self, protocol):

if protocol >= 5:

return type(self)._reconstruct, (pickle.PickleBuffer(self),), None

else:

return type(self)._reconstruct, (bytes(self),)

def __repr__(self):

return "{}({!r})".format(self.__class__.__name__, bytes(self))

__str__ = __repr__

@classmethod

def _reconstruct(cls, obj):

with memoryview(obj) as m:

obj = m.obj

if type(obj) is cls:

# Zero-copy

return obj

else:

return cls(obj)

if _testbuffer is not None:

class PicklableNDArray:

# 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 (f"{type(self)}(shape={self.array.shape},"

f"strides={self.array.strides}, "

f"bytes={self.array.tobytes()})")

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())

return cls(items, **kwargs)

# DATA0 .. DATA4 are the pickles we expect under the various protocols, for

# the object returned by create_data().

DATA0 = (

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.'

)

# Disassembly of DATA0

DATA0_DIS = """\

0: ( MARK

1: l LIST (MARK at 0)

2: p PUT 0

5: L LONG 0

9: a APPEND

10: L LONG 1

14: a APPEND

15: F FLOAT 2.0

20: a APPEND

21: c GLOBAL '__builtin__ complex'

42: p PUT 1

45: ( MARK

46: F FLOAT 3.0

51: F FLOAT 0.0

56: t TUPLE (MARK at 45)

57: p PUT 2

60: R REDUCE

61: p PUT 3

64: a APPEND

65: L LONG 1

69: a APPEND

70: L LONG -1

75: a APPEND

76: L LONG 255

82: a APPEND

83: L LONG -255

90: a APPEND

91: L LONG -256

98: a APPEND

99: L LONG 65535

107: a APPEND

108: L LONG -65535

117: a APPEND

118: L LONG -65536

127: a APPEND

128: L LONG 2147483647

141: a APPEND

142: L LONG -2147483647

156: a APPEND

157: L LONG -2147483648

171: a APPEND

172: ( MARK

173: V UNICODE 'abc'

178: p PUT 4

181: g GET 4

184: c GLOBAL 'copy_reg _reconstructor'

209: p PUT 5

212: ( MARK

213: c GLOBAL '__main__ C'

225: p PUT 6

228: c GLOBAL '__builtin__ object'

248: p PUT 7

251: N NONE

252: t TUPLE (MARK at 212)

253: p PUT 8

256: R REDUCE

257: p PUT 9

260: ( MARK

261: d DICT (MARK at 260)

262: p PUT 10

266: V UNICODE 'foo'

271: p PUT 11

275: L LONG 1

279: s SETITEM

280: V UNICODE 'bar'

285: p PUT 12

289: L LONG 2

293: s SETITEM

294: b BUILD

295: g GET 9

298: t TUPLE (MARK at 172)

299: p PUT 13

303: a APPEND

304: g GET 13

308: a APPEND

309: L LONG 5

313: a APPEND

314: . STOP

highest protocol among opcodes = 0

"""

DATA1 = (

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.'

)

# Disassembly of DATA1

DATA1_DIS = """\

0: ] EMPTY_LIST

1: q BINPUT 0

3: ( MARK

4: K BININT1 0

6: K BININT1 1

8: G BINFLOAT 2.0

17: c GLOBAL '__builtin__ complex'

38: q BINPUT 1

40: ( MARK

41: G BINFLOAT 3.0

50: G BINFLOAT 0.0

59: t TUPLE (MARK at 40)

60: q BINPUT 2

62: R REDUCE

63: q BINPUT 3

65: K BININT1 1

67: J BININT -1

72: K BININT1 255

74: J BININT -255

79: J BININT -256

84: M BININT2 65535

87: J BININT -65535

92: J BININT -65536

97: J BININT 2147483647

102: J BININT -2147483647

107: J BININT -2147483648

112: ( MARK

113: X BINUNICODE 'abc'

121: q BINPUT 4

123: h BINGET 4

125: c GLOBAL 'copy_reg _reconstructor'

150: q BINPUT 5

152: ( MARK

153: c GLOBAL '__main__ C'

165: q BINPUT 6

167: c GLOBAL '__builtin__ object'

187: q BINPUT 7

189: N NONE

190: t TUPLE (MARK at 152)

191: q BINPUT 8

193: R REDUCE

194: q BINPUT 9

196: } EMPTY_DICT

197: q BINPUT 10

199: ( MARK

200: X BINUNICODE 'foo'

208: q BINPUT 11

210: K BININT1 1

212: X BINUNICODE 'bar'

220: q BINPUT 12

222: K BININT1 2

224: u SETITEMS (MARK at 199)

225: b BUILD

226: h BINGET 9

228: t TUPLE (MARK at 112)

229: q BINPUT 13

231: h BINGET 13

233: K BININT1 5

235: e APPENDS (MARK at 3)

236: . STOP

highest protocol among opcodes = 1

"""

DATA2 = (

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.'

)

# Disassembly of DATA2

DATA2_DIS = """\

0: \x80 PROTO 2

2: ] EMPTY_LIST

3: q BINPUT 0

5: ( MARK

6: K BININT1 0

8: K BININT1 1

10: G BINFLOAT 2.0

19: c GLOBAL '__builtin__ complex'

40: q BINPUT 1

42: G BINFLOAT 3.0

51: G BINFLOAT 0.0

60: \x86 TUPLE2

61: q BINPUT 2

63: R REDUCE

64: q BINPUT 3

66: K BININT1 1

68: J BININT -1

73: K BININT1 255

75: J BININT -255

80: J BININT -256

85: M BININT2 65535

88: J BININT -65535

93: J BININT -65536

98: J BININT 2147483647

103: J BININT -2147483647

108: J BININT -2147483648

113: ( MARK

114: X BINUNICODE 'abc'

122: q BINPUT 4

124: h BINGET 4

126: c GLOBAL '__main__ C'

138: q BINPUT 5

140: ) EMPTY_TUPLE

141: \x81 NEWOBJ

142: q BINPUT 6

144: } EMPTY_DICT

145: q BINPUT 7

147: ( MARK

148: X BINUNICODE 'foo'

156: q BINPUT 8

158: K BININT1 1

160: X BINUNICODE 'bar'

168: q BINPUT 9

170: K BININT1 2

172: u SETITEMS (MARK at 147)

173: b BUILD

174: h BINGET 6

176: t TUPLE (MARK at 113)

177: q BINPUT 10

179: h BINGET 10

181: K BININT1 5

183: e APPENDS (MARK at 5)

184: . STOP

highest protocol among opcodes = 2

"""

DATA3 = (

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.'

)

# Disassembly of DATA3

DATA3_DIS = """\

0: \x80 PROTO 3

2: ] EMPTY_LIST

3: q BINPUT 0

5: ( MARK

6: K BININT1 0

8: K BININT1 1

10: G BINFLOAT 2.0

19: c GLOBAL 'builtins complex'

37: q BINPUT 1

39: G BINFLOAT 3.0

48: G BINFLOAT 0.0

57: \x86 TUPLE2

58: q BINPUT 2

60: R REDUCE

61: q BINPUT 3

63: K BININT1 1

65: J BININT -1

70: K BININT1 255

72: J BININT -255

77: J BININT -256

82: M BININT2 65535

85: J BININT -65535

90: J BININT -65536

95: J BININT 2147483647

100: J BININT -2147483647

105: J BININT -2147483648

110: ( MARK

111: X BINUNICODE 'abc'

119: q BINPUT 4

121: h BINGET 4

123: c GLOBAL '__main__ C'

135: q BINPUT 5

137: ) EMPTY_TUPLE

138: \x81 NEWOBJ

139: q BINPUT 6

141: } EMPTY_DICT

142: q BINPUT 7

144: ( MARK

145: X BINUNICODE 'bar'

153: q BINPUT 8

155: K BININT1 2

157: X BINUNICODE 'foo'

165: q BINPUT 9

167: K BININT1 1

169: u SETITEMS (MARK at 144)

170: b BUILD

171: h BINGET 6

173: t TUPLE (MARK at 110)

174: q BINPUT 10

176: h BINGET 10

178: K BININT1 5

180: e APPENDS (MARK at 5)

181: . STOP

highest protocol among opcodes = 2

"""

DATA4 = (

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.'

)

# Disassembly of DATA4

DATA4_DIS = """\

0: \x80 PROTO 4

2: \x95 FRAME 168

11: ] EMPTY_LIST

12: \x94 MEMOIZE

13: ( MARK

14: K BININT1 0

16: K BININT1 1

18: G BINFLOAT 2.0

27: \x8c SHORT_BINUNICODE 'builtins'

37: \x94 MEMOIZE

38: \x8c SHORT_BINUNICODE 'complex'

47: \x94 MEMOIZE

48: \x93 STACK_GLOBAL

49: \x94 MEMOIZE

50: G BINFLOAT 3.0

59: G BINFLOAT 0.0

68: \x86 TUPLE2

69: \x94 MEMOIZE

70: R REDUCE

71: \x94 MEMOIZE

72: K BININT1 1

74: J BININT -1

79: K BININT1 255

81: J BININT -255

86: J BININT -256

91: M BININT2 65535

94: J BININT -65535

99: J BININT -65536

104: J BININT 2147483647

109: J BININT -2147483647

114: J BININT -2147483648

119: ( MARK

120: \x8c SHORT_BINUNICODE 'abc'

125: \x94 MEMOIZE

126: h BINGET 6

128: \x8c SHORT_BINUNICODE '__main__'

138: \x94 MEMOIZE

139: \x8c SHORT_BINUNICODE 'C'

142: \x94 MEMOIZE

143: \x93 STACK_GLOBAL

144: \x94 MEMOIZE

145: ) EMPTY_TUPLE

146: \x81 NEWOBJ

147: \x94 MEMOIZE

148: } EMPTY_DICT

149: \x94 MEMOIZE

150: ( MARK

151: \x8c SHORT_BINUNICODE 'bar'

156: \x94 MEMOIZE

157: K BININT1 2

159: \x8c SHORT_BINUNICODE 'foo'

164: \x94 MEMOIZE

165: K BININT1 1

167: u SETITEMS (MARK at 150)

168: b BUILD

169: h BINGET 10

171: t TUPLE (MARK at 119)

172: \x94 MEMOIZE

173: h BINGET 14

175: K BININT1 5

177: e APPENDS (MARK at 13)

178: . STOP

highest protocol among opcodes = 4

"""

# set([1,2]) pickled from 2.x with protocol 2

DATA_SET = b'\x80\x02c__builtin__\nset\nq\x00]q\x01(K\x01K\x02e\x85q\x02Rq\x03.'

# xrange(5) pickled from 2.x with protocol 2

DATA_XRANGE = b'\x80\x02c__builtin__\nxrange\nq\x00K\x00K\x05K\x01\x87q\x01Rq\x02.'

# a SimpleCookie() object pickled from 2.x with protocol 2

DATA_COOKIE = (b'\x80\x02cCookie\nSimpleCookie\nq\x00)\x81q\x01U\x03key'

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'

b'coded_valueq\x0fU\x05valueq\x10h\x10h\x10h\x02h\x02ubs}q\x11b.')

# set([3]) pickled from 2.x with protocol 2

DATA_SET2 = b'\x80\x02c__builtin__\nset\nq\x00]q\x01K\x03a\x85q\x02Rq\x03.'

python2_exceptions_without_args = (

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,

)

exception_pickle = b'\x80\x02cexceptions\n?\nq\x00)Rq\x01.'

# UnicodeEncodeError object pickled from 2.x with protocol 2

DATA_UEERR = (b'\x80\x02cexceptions\nUnicodeEncodeError\n'

b'q\x00(U\x05asciiq\x01X\x03\x00\x00\x00fooq\x02K\x00K\x01'

b'U\x03badq\x03tq\x04Rq\x05.')

def create_data():

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)

return x

class AbstractUnpickleTests:

# 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(self, errors, data):

with self.subTest(data=data), \

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 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):

"""

0: ( MARK

1: i INST '__main__ X' (MARK at 0)

13: p PUT 0

16: ( MARK

17: d DICT (MARK at 16)

18: p PUT 1

21: b BUILD

22: . STOP

"""

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)

"""

0: ( MARK

1: c GLOBAL '__main__ X'

13: q BINPUT 0

15: o OBJ (MARK at 0)

16: q BINPUT 1

18: } EMPTY_DICT

19: q BINPUT 2

21: b BUILD

22: . STOP

"""

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)

"""

0: \x80 PROTO 2

2: ( MARK

3: c GLOBAL '__main__ X'

15: q BINPUT 0

17: o OBJ (MARK at 2)

18: q BINPUT 1

20: } EMPTY_DICT

21: q BINPUT 2

23: b BUILD

24: . STOP

"""

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_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"), 'π')