cpython: c852c7d8d681 (original) (raw)

--- a/Lib/test/pickletester.py +++ b/Lib/test/pickletester.py @@ -11,8 +11,9 @@ import unittest import weakref from http.cookies import SimpleCookie +from test import support from test.support import (

TestFailed, TESTFN, run_with_locale, no_tracing, captured_stdout,

TestFailed, TESTFN, run_with_locale, no_tracing, _2G, _4G, bigmemtest, ) @@ -679,6 +680,17 @@ class AbstractUnpickleTests(unittest.Tes self.assertEqual(getattr(obj, slot, None), getattr(objcopy, slot, None), msg=msg)

def check_unpickling_error(self, errors, data):

   with self.subTest(data=data), \[](#l1.19)

        self.assertRaises(errors):[](#l1.20)

```
       try:[](#l1.21)
```
```
           self.loads(data)[](#l1.22)
```

       except BaseException as exc:[](#l1.23)

           if support.verbose > 1:[](#l1.24)

               print('%-32r - %s: %s' %[](#l1.25)

                     (data, exc.__class__.__name__, exc))[](#l1.26)

```
           raise[](#l1.27)
```

+ def test_load_from_data0(self): self.assert_is_copy(self._testdata, self.loads(DATA0)) @@ -759,12 +771,7 @@ class AbstractUnpickleTests(unittest.Tes # Try too with a bogus literal. data = b'I' + str(maxint64).encode("ascii") + b'JUNK\n.'

   self.assertRaises(ValueError, self.loads, data)[](#l1.36)

def test_pop_empty_stack(self):
```
   # Test issue7455[](#l1.39)
```
```
   s = b'0'[](#l1.40)
```

   self.assertRaises((pickle.UnpicklingError, IndexError), self.loads, s)[](#l1.41)

   self.check_unpickling_error(ValueError, data)[](#l1.42)

def test_unpickle_from_2x(self): # Unpickle non-trivial data from Python 2.x. @@ -849,22 +856,22 @@ class AbstractUnpickleTests(unittest.Tes 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.'

   with self.assertRaises((pickle.UnpicklingError, OverflowError)):[](#l1.50)

```
       self.loads(dumped)[](#l1.51)
```

   self.check_unpickling_error((pickle.UnpicklingError, OverflowError),[](#l1.52)

                               dumped)[](#l1.53)

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

   with self.assertRaises((pickle.UnpicklingError, OverflowError)):[](#l1.59)

```
       self.loads(dumped)[](#l1.60)
```

   self.check_unpickling_error((pickle.UnpicklingError, OverflowError),[](#l1.61)

                               dumped)[](#l1.62)

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

   self.assertRaises(KeyError, self.loads, b'g0\np0')[](#l1.69)

   self.check_unpickling_error(KeyError, b'g0\np0')[](#l1.70)
   self.assert_is_copy([(100,), (100,)],[](#l1.71)
                       self.loads(b'((Kdtp0\nh\x00l.))'))[](#l1.72)

@@ -879,14 +886,14 @@ class AbstractUnpickleTests(unittest.Tes @requires_32b def test_large_32b_binbytes8(self): dumped = b'\x80\x04\x8e\4\0\0\0\1\0\0\0\xe2\x82\xac\x00.'

   with self.assertRaises((pickle.UnpicklingError, OverflowError)):[](#l1.78)

```
       self.loads(dumped)[](#l1.79)
```

   self.check_unpickling_error((pickle.UnpicklingError, OverflowError),[](#l1.80)

                               dumped)[](#l1.81)

@requires_32b def test_large_32b_binunicode8(self): dumped = b'\x80\x04\x8d\4\0\0\0\1\0\0\0\xe2\x82\xac\x00.'

   with self.assertRaises((pickle.UnpicklingError, OverflowError)):[](#l1.86)

```
       self.loads(dumped)[](#l1.87)
```

   self.check_unpickling_error((pickle.UnpicklingError, OverflowError),[](#l1.88)

                               dumped)[](#l1.89)

def test_get(self): pickled = b'((lp100000\ng100000\nt.' @@ -915,16 +922,16 @@ class AbstractUnpickleTests(unittest.Tes def test_negative_put(self): # Issue #12847 dumped = b'Va\np-1\n.'

   self.assertRaises(ValueError, self.loads, dumped)[](#l1.97)

   self.check_unpickling_error(ValueError, dumped)[](#l1.98)

@requires_32b def test_negative_32b_binput(self): # Issue #12847 dumped = b'\x80\x03X\x01\x00\x00\x00ar\xff\xff\xff\xff.'

   self.assertRaises(ValueError, self.loads, dumped)[](#l1.104)

   self.check_unpickling_error(ValueError, dumped)[](#l1.105)

def test_badly_escaped_string(self):

   self.assertRaises(ValueError, self.loads, b"S'\\'\n.")[](#l1.108)

   self.check_unpickling_error(ValueError, b"S'\\'\n.")[](#l1.109)

def test_badly_quoted_string(self): # Issue #17710 @@ -942,7 +949,7 @@ class AbstractUnpickleTests(unittest.Tes b'S\n.', b'S.'] for p in badpickles:

       self.assertRaises(pickle.UnpicklingError, self.loads, p)[](#l1.117)

       self.check_unpickling_error(pickle.UnpicklingError, p)[](#l1.118)

def test_correctly_quoted_string(self): goodpickles = [(b"S''\n.", ''), @@ -989,86 +996,183 @@ class AbstractUnpickleTests(unittest.Tes def test_bad_stack(self): badpickles = [

       b'0.',              # POP[](#l1.126)

       b'1.',              # POP_MARK[](#l1.127)

       b'2.',              # DUP[](#l1.128)

       # b'(2.',           # PyUnpickler doesn't raise[](#l1.129)

       b'R.',              # REDUCE[](#l1.130)

```
       b')R.',[](#l1.131)
```

       b'a.',              # APPEND[](#l1.132)

```
       b'Na.',[](#l1.133)
```

       b'b.',              # BUILD[](#l1.134)

```
       b'Nb.',[](#l1.135)
```

       b'd.',              # DICT[](#l1.136)

       b'e.',              # APPENDS[](#l1.137)

       # b'(e.',           # PyUnpickler raises AttributeError[](#l1.138)

       b'ibuiltins\nlist\n.',  # INST[](#l1.139)

       b'l.',              # LIST[](#l1.140)

       b'o.',              # OBJ[](#l1.141)

```
       b'(o.',[](#l1.142)
```

       b'p1\n.',           # PUT[](#l1.143)

       b'q\x00.',          # BINPUT[](#l1.144)

       b'r\x00\x00\x00\x00.',  # LONG_BINPUT[](#l1.145)

       b's.',              # SETITEM[](#l1.146)

```
       b'Ns.',[](#l1.147)
```
```
       b'NNs.',[](#l1.148)
```

       b't.',              # TUPLE[](#l1.149)

       b'u.',              # SETITEMS[](#l1.150)

```
       b'(u.',[](#l1.151)
```
```
       b'}(Nu.',[](#l1.152)
```

       b'\x81.',           # NEWOBJ[](#l1.153)

```
       b')\x81.',[](#l1.154)
```

       b'\x85.',           # TUPLE1[](#l1.155)

       b'\x86.',           # TUPLE2[](#l1.156)

```
       b'N\x86.',[](#l1.157)
```

       b'\x87.',           # TUPLE3[](#l1.158)

```
       b'N\x87.',[](#l1.159)
```
```
       b'NN\x87.',[](#l1.160)
```

       b'\x90.',           # ADDITEMS[](#l1.161)

       # b'(\x90.',        # PyUnpickler raises AttributeError[](#l1.162)

       b'\x91.',           # FROZENSET[](#l1.163)

       b'\x92.',           # NEWOBJ_EX[](#l1.164)

```
       b')}\x92.',[](#l1.165)
```

       b'\x93.',           # STACK_GLOBAL[](#l1.166)

```
       b'Vlist\n\x93.',[](#l1.167)
```

       b'\x94.',           # MEMOIZE[](#l1.168)

       b'.',                       # STOP[](#l1.169)

       b'0',                       # POP[](#l1.170)

       b'1',                       # POP_MARK[](#l1.171)

       b'2',                       # DUP[](#l1.172)

       # b'(2',                    # PyUnpickler doesn't raise[](#l1.173)

       b'R',                       # REDUCE[](#l1.174)

```
       b')R',[](#l1.175)
```

       b'a',                       # APPEND[](#l1.176)

```
       b'Na',[](#l1.177)
```

       b'b',                       # BUILD[](#l1.178)

```
       b'Nb',[](#l1.179)
```

       b'd',                       # DICT[](#l1.180)

       b'e',                       # APPENDS[](#l1.181)

       # b'(e',                    # PyUnpickler raises AttributeError[](#l1.182)

       b'ibuiltins\nlist\n',       # INST[](#l1.183)

       b'l',                       # LIST[](#l1.184)

       b'o',                       # OBJ[](#l1.185)

```
       b'(o',[](#l1.186)
```

       b'p1\n',                    # PUT[](#l1.187)

       b'q\x00',                   # BINPUT[](#l1.188)

       b'r\x00\x00\x00\x00',       # LONG_BINPUT[](#l1.189)

       b's',                       # SETITEM[](#l1.190)

```
       b'Ns',[](#l1.191)
```
```
       b'NNs',[](#l1.192)
```

       b't',                       # TUPLE[](#l1.193)

       b'u',                       # SETITEMS[](#l1.194)

       # b'(u',                    # PyUnpickler doesn't raise[](#l1.195)

```
       b'}(Nu',[](#l1.196)
```

       b'\x81',                    # NEWOBJ[](#l1.197)

```
       b')\x81',[](#l1.198)
```

       b'\x85',                    # TUPLE1[](#l1.199)

       b'\x86',                    # TUPLE2[](#l1.200)

```
       b'N\x86',[](#l1.201)
```

       b'\x87',                    # TUPLE3[](#l1.202)

```
       b'N\x87',[](#l1.203)
```
```
       b'NN\x87',[](#l1.204)
```

       b'\x90',                    # ADDITEMS[](#l1.205)

       # b'(\x90',                 # PyUnpickler raises AttributeError[](#l1.206)

       b'\x91',                    # FROZENSET[](#l1.207)

       b'\x92',                    # NEWOBJ_EX[](#l1.208)

```
       b')}\x92',[](#l1.209)
```

       b'\x93',                    # STACK_GLOBAL[](#l1.210)

```
       b'Vlist\n\x93',[](#l1.211)
```

       b'\x94',                    # MEMOIZE[](#l1.212)
   ][](#l1.213)
   for p in badpickles:[](#l1.214)

```
       with self.subTest(p):[](#l1.215)
```

           self.assertRaises(self.bad_stack_errors, self.loads, p)[](#l1.216)

       self.check_unpickling_error(self.bad_stack_errors, p)[](#l1.217)

def test_bad_mark(self): badpickles = [

       b'cbuiltins\nlist\n)(R.',           # REDUCE[](#l1.221)

       b'cbuiltins\nlist\n()R.',[](#l1.222)

       b']N(a.',                           # APPEND[](#l1.223)

       b'cbuiltins\nValueError\n)R}(b.',   # BUILD[](#l1.224)

       b'cbuiltins\nValueError\n)R(}b.',[](#l1.225)

       b'(Nd.',                            # DICT[](#l1.226)

       b'}NN(s.',                          # SETITEM[](#l1.227)

```
       b'}N(Ns.',[](#l1.228)
```

       b'cbuiltins\nlist\n)(\x81.',        # NEWOBJ[](#l1.229)

       b'cbuiltins\nlist\n()\x81.',[](#l1.230)

       b'N(\x85.',                         # TUPLE1[](#l1.231)

       b'NN(\x86.',                        # TUPLE2[](#l1.232)

```
       b'N(N\x86.',[](#l1.233)
```

       b'NNN(\x87.',                       # TUPLE3[](#l1.234)

```
       b'NN(N\x87.',[](#l1.235)
```
```
       b'N(NN\x87.',[](#l1.236)
```

       b'cbuiltins\nlist\n)}(\x92.',       # NEWOBJ_EX[](#l1.237)

       b'cbuiltins\nlist\n)(}\x92.',[](#l1.238)

       b'cbuiltins\nlist\n()}\x92.',[](#l1.239)

       b'Vbuiltins\n(Vlist\n\x93.',        # STACK_GLOBAL[](#l1.240)

       b'Vbuiltins\nVlist\n(\x93.',[](#l1.241)

       # b'N(.',                     # STOP[](#l1.242)

       b'N(2',                     # DUP[](#l1.243)

       b'cbuiltins\nlist\n)(R',    # REDUCE[](#l1.244)

       b'cbuiltins\nlist\n()R',[](#l1.245)

       b']N(a',                    # APPEND[](#l1.246)

                                   # BUILD[](#l1.247)

       b'cbuiltins\nValueError\n)R}(b',[](#l1.248)

       b'cbuiltins\nValueError\n)R(}b',[](#l1.249)

       b'(Nd',                     # DICT[](#l1.250)

       b'N(p1\n',                  # PUT[](#l1.251)

       b'N(q\x00',                 # BINPUT[](#l1.252)

       b'N(r\x00\x00\x00\x00',     # LONG_BINPUT[](#l1.253)

       b'}NN(s',                   # SETITEM[](#l1.254)

```
       b'}N(Ns',[](#l1.255)
```
```
       b'}(NNs',[](#l1.256)
```

       b'}((u',                    # SETITEMS[](#l1.257)

       b'cbuiltins\nlist\n)(\x81', # NEWOBJ[](#l1.258)

       b'cbuiltins\nlist\n()\x81',[](#l1.259)

       b'N(\x85',                  # TUPLE1[](#l1.260)

       b'NN(\x86',                 # TUPLE2[](#l1.261)

```
       b'N(N\x86',[](#l1.262)
```

       b'NNN(\x87',                # TUPLE3[](#l1.263)

```
       b'NN(N\x87',[](#l1.264)
```
```
       b'N(NN\x87',[](#l1.265)
```

       b']((\x90',                 # ADDITEMS[](#l1.266)

                                   # NEWOBJ_EX[](#l1.267)

       b'cbuiltins\nlist\n)}(\x92',[](#l1.268)

       b'cbuiltins\nlist\n)(}\x92',[](#l1.269)

       b'cbuiltins\nlist\n()}\x92',[](#l1.270)

                                   # STACK_GLOBAL[](#l1.271)

       b'Vbuiltins\n(Vlist\n\x93',[](#l1.272)

       b'Vbuiltins\nVlist\n(\x93',[](#l1.273)

       b'N(\x94',                  # MEMOIZE[](#l1.274)
   ][](#l1.275)
   for p in badpickles:[](#l1.276)

       # PyUnpickler prints reduce errors to stdout[](#l1.277)

       with self.subTest(p), captured_stdout():[](#l1.278)

```
           try:[](#l1.279)
```
```
               self.loads(p)[](#l1.280)
```

           except (IndexError, AttributeError, TypeError,[](#l1.281)

                   pickle.UnpicklingError):[](#l1.282)

```
               pass[](#l1.283)
```

       self.check_unpickling_error(self.bad_mark_errors, p)[](#l1.284)

def test_truncated_data(self):

   self.check_unpickling_error(EOFError, b'')[](#l1.287)

   self.check_unpickling_error(EOFError, b'N')[](#l1.288)

```
   badpickles = [[](#l1.289)
```

       b'B',                       # BINBYTES[](#l1.290)

```
       b'B\x03\x00\x00',[](#l1.291)
```
```
       b'B\x03\x00\x00\x00',[](#l1.292)
```

       b'B\x03\x00\x00\x00ab',[](#l1.293)

       b'C',                       # SHORT_BINBYTES[](#l1.294)

```
       b'C\x03',[](#l1.295)
```
```
       b'C\x03ab',[](#l1.296)
```

       b'F',                       # FLOAT[](#l1.297)

```
       b'F0.0',[](#l1.298)
```
```
       b'F0.00',[](#l1.299)
```

       b'G',                       # BINFLOAT[](#l1.300)

       b'G\x00\x00\x00\x00\x00\x00\x00',[](#l1.301)

       b'I',                       # INT[](#l1.302)

```
       b'I0',[](#l1.303)
```

       b'J',                       # BININT[](#l1.304)

```
       b'J\x00\x00\x00',[](#l1.305)
```

       b'K',                       # BININT1[](#l1.306)

       b'L',                       # LONG[](#l1.307)

```
       b'L0',[](#l1.308)
```
```
       b'L10',[](#l1.309)
```
```
       b'L0L',[](#l1.310)
```
```
       b'L10L',[](#l1.311)
```

       b'M',                       # BININT2[](#l1.312)

```
       b'M\x00',[](#l1.313)
```

       # b'P',                       # PERSID[](#l1.314)

```
       # b'Pabc',[](#l1.315)
```

       b'S',                       # STRING[](#l1.316)

```
       b"S'abc'",[](#l1.317)
```

       b'T',                       # BINSTRING[](#l1.318)

```
       b'T\x03\x00\x00',[](#l1.319)
```
```
       b'T\x03\x00\x00\x00',[](#l1.320)
```

       b'T\x03\x00\x00\x00ab',[](#l1.321)

       b'U',                       # SHORT_BINSTRING[](#l1.322)

```
       b'U\x03',[](#l1.323)
```
```
       b'U\x03ab',[](#l1.324)
```

       b'V',                       # UNICODE[](#l1.325)

```
       b'Vabc',[](#l1.326)
```

       b'X',                       # BINUNICODE[](#l1.327)

```
       b'X\x03\x00\x00',[](#l1.328)
```
```
       b'X\x03\x00\x00\x00',[](#l1.329)
```

       b'X\x03\x00\x00\x00ab',[](#l1.330)

       b'(c',                      # GLOBAL[](#l1.331)

```
       b'(cbuiltins',[](#l1.332)
```
```
       b'(cbuiltins\n',[](#l1.333)
```
```
       b'(cbuiltins\nlist',[](#l1.334)
```

       b'Ng',                      # GET[](#l1.335)

```
       b'Ng0',[](#l1.336)
```

       b'(i',                      # INST[](#l1.337)

```
       b'(ibuiltins',[](#l1.338)
```
```
       b'(ibuiltins\n',[](#l1.339)
```
```
       b'(ibuiltins\nlist',[](#l1.340)
```

       b'Nh',                      # BINGET[](#l1.341)

       b'Nj',                      # LONG_BINGET[](#l1.342)

```
       b'Nj\x00\x00\x00',[](#l1.343)
```

       b'Np',                      # PUT[](#l1.344)

```
       b'Np0',[](#l1.345)
```

       b'Nq',                      # BINPUT[](#l1.346)

       b'Nr',                      # LONG_BINPUT[](#l1.347)

```
       b'Nr\x00\x00\x00',[](#l1.348)
```

       b'\x80',                    # PROTO[](#l1.349)

       b'\x82',                    # EXT1[](#l1.350)

       b'\x83',                    # EXT2[](#l1.351)

```
       b'\x84\x01',[](#l1.352)
```

       b'\x84',                    # EXT4[](#l1.353)

```
       b'\x84\x01\x00\x00',[](#l1.354)
```

       b'\x8a',                    # LONG1[](#l1.355)

       b'\x8b',                    # LONG4[](#l1.356)

```
       b'\x8b\x00\x00\x00',[](#l1.357)
```

       b'\x8c',                    # SHORT_BINUNICODE[](#l1.358)

```
       b'\x8c\x03',[](#l1.359)
```
```
       b'\x8c\x03ab',[](#l1.360)
```

       b'\x8d',                    # BINUNICODE8[](#l1.361)

       b'\x8d\x03\x00\x00\x00\x00\x00\x00',[](#l1.362)

       b'\x8d\x03\x00\x00\x00\x00\x00\x00\x00',[](#l1.363)

       b'\x8d\x03\x00\x00\x00\x00\x00\x00\x00ab',[](#l1.364)

       b'\x8e',                    # BINBYTES8[](#l1.365)

       b'\x8e\x03\x00\x00\x00\x00\x00\x00',[](#l1.366)

       b'\x8e\x03\x00\x00\x00\x00\x00\x00\x00',[](#l1.367)

       b'\x8e\x03\x00\x00\x00\x00\x00\x00\x00ab',[](#l1.368)

       b'\x95',                    # FRAME[](#l1.369)

       b'\x95\x02\x00\x00\x00\x00\x00\x00',[](#l1.370)

       b'\x95\x02\x00\x00\x00\x00\x00\x00\x00',[](#l1.371)

       b'\x95\x02\x00\x00\x00\x00\x00\x00\x00N',[](#l1.372)

```
   ][](#l1.373)
```
```
   for p in badpickles:[](#l1.374)
```

       self.check_unpickling_error(self.truncated_errors, p)[](#l1.375)

class AbstractPickleTests(unittest.TestCase):

--- a/Lib/test/test_pickle.py +++ b/Lib/test/test_pickle.py @@ -33,6 +33,11 @@ class PyUnpicklerTests(AbstractUnpickleT unpickler = pickle._Unpickler bad_stack_errors = (IndexError,)

bad_mark_errors = (IndexError, pickle.UnpicklingError,

                  TypeError, AttributeError, EOFError)[](#l2.8)

truncated_errors = (pickle.UnpicklingError, EOFError,

                   AttributeError, ValueError,[](#l2.10)

                   struct.error, IndexError, ImportError)[](#l2.11)

def loads(self, buf, **kwds): f = io.BytesIO(buf) @@ -64,6 +69,11 @@ class InMemoryPickleTests(AbstractPickle pickler = pickle._Pickler unpickler = pickle._Unpickler bad_stack_errors = (pickle.UnpicklingError, IndexError)

bad_mark_errors = (pickle.UnpicklingError, IndexError,

                  TypeError, AttributeError, EOFError)[](#l2.20)

truncated_errors = (pickle.UnpicklingError, EOFError,

                   AttributeError, ValueError,[](#l2.22)

                   struct.error, IndexError, ImportError)[](#l2.23)

def dumps(self, arg, protocol=None): return pickle.dumps(arg, protocol) @@ -122,6 +132,9 @@ if has_c_implementation: class CUnpicklerTests(PyUnpicklerTests): unpickler = _pickle.Unpickler bad_stack_errors = (pickle.UnpicklingError,)

   bad_mark_errors = (EOFError,)[](#l2.31)

   truncated_errors = (pickle.UnpicklingError, EOFError,[](#l2.32)

                       AttributeError, ValueError)[](#l2.33)

class CPicklerTests(PyPicklerTests): pickler = _pickle.Pickler