cpython: dfef42311c71 (original) (raw)

Mercurial > cpython

changeset 100424:dfef42311c71 3.5

Issue #26015: Added new tests for pickling iterators of mutable sequences. [#26015]

Serhiy Storchaka storchaka@gmail.com
date	Sun, 06 Mar 2016 14:10:24 +0200
parents	f3c54cbac3de
children	be96b2784f73 52d7a308e3b4
files	Lib/test/test_array.py Lib/test/test_bytes.py Lib/test/test_deque.py Lib/test/test_iter.py Lib/test/test_list.py Misc/NEWS
diffstat	6 files changed, 212 insertions(+), 46 deletions(-)[+] [-] Lib/test/test_array.py 45 Lib/test/test_bytes.py 42 Lib/test/test_deque.py 47 Lib/test/test_iter.py 36 Lib/test/test_list.py 86 Misc/NEWS 2

line wrap: on

line diff

--- a/Lib/test/test_array.py +++ b/Lib/test/test_array.py @@ -284,19 +284,42 @@ class BaseTest: self.assertEqual(type(a), type(b)) def test_iterator_pickle(self):

   data = array.array(self.typecode, self.example)[](#l1.7)

   orig = array.array(self.typecode, self.example)[](#l1.8)

```
   data = list(orig)[](#l1.9)
```

   data2 = data[::-1][](#l1.10)
   for proto in range(pickle.HIGHEST_PROTOCOL + 1):[](#l1.11)

```
       orgit = iter(data)[](#l1.12)
```

       d = pickle.dumps(orgit, proto)[](#l1.13)

```
       it = pickle.loads(d)[](#l1.14)
```

       self.assertEqual(type(orgit), type(it))[](#l1.15)

       self.assertEqual(list(it), list(data))[](#l1.16)

```
       # initial iterator[](#l1.17)
```
```
       itorig = iter(orig)[](#l1.18)
```

       d = pickle.dumps((itorig, orig), proto)[](#l1.19)

       it, a = pickle.loads(d)[](#l1.20)

```
       a.fromlist(data2)[](#l1.21)
```

       self.assertEqual(type(it), type(itorig))[](#l1.22)

       self.assertEqual(list(it), data + data2)[](#l1.23)

```
       # running iterator[](#l1.25)
```
```
       next(itorig)[](#l1.26)
```

       d = pickle.dumps((itorig, orig), proto)[](#l1.27)

       it, a = pickle.loads(d)[](#l1.28)

```
       a.fromlist(data2)[](#l1.29)
```

       self.assertEqual(type(it), type(itorig))[](#l1.30)

       self.assertEqual(list(it), data[1:] + data2)[](#l1.31)

```
       if len(data):[](#l1.33)
```

           it = pickle.loads(d)[](#l1.34)

```
           next(it)[](#l1.35)
```

           d = pickle.dumps(it, proto)[](#l1.36)

           self.assertEqual(list(it), list(data)[1:])[](#l1.37)

```
       # empty iterator[](#l1.38)
```

       for i in range(1, len(data)):[](#l1.39)

```
           next(itorig)[](#l1.40)
```

       d = pickle.dumps((itorig, orig), proto)[](#l1.41)

       it, a = pickle.loads(d)[](#l1.42)

```
       a.fromlist(data2)[](#l1.43)
```

       self.assertEqual(type(it), type(itorig))[](#l1.44)

       self.assertEqual(list(it), data2)[](#l1.45)

```
       # exhausted iterator[](#l1.47)
```

       self.assertRaises(StopIteration, next, itorig)[](#l1.48)

       d = pickle.dumps((itorig, orig), proto)[](#l1.49)

       it, a = pickle.loads(d)[](#l1.50)

```
       a.fromlist(data2)[](#l1.51)
```

       self.assertEqual(type(it), type(itorig))[](#l1.52)

       self.assertEqual(list(it), data2)[](#l1.53)

def test_insert(self): a = array.array(self.typecode, self.example)

--- a/Lib/test/test_bytes.py +++ b/Lib/test/test_bytes.py @@ -595,10 +595,9 @@ class BaseBytesTest: self.assertEqual(list(it), data) it = pickle.loads(d)

```
           try:[](#l2.7)
```
```
               next(it)[](#l2.8)
```

           except StopIteration:[](#l2.9)

           if not b:[](#l2.10)
               continue[](#l2.11)

           next(it)[](#l2.12)
           d = pickle.dumps(it, proto)[](#l2.13)
           it = pickle.loads(d)[](#l2.14)
           self.assertEqual(list(it), data[1:])[](#l2.15)

@@ -1284,6 +1283,43 @@ class ByteArrayTest(BaseBytesTest, unitt from _testcapi import getbuffer_with_null_view self.assertRaises(BufferError, getbuffer_with_null_view, bytearray())

def test_iterator_pickling2(self):
```
   orig = bytearray(b'abc')[](#l2.21)
```
```
   data = list(b'qwerty')[](#l2.22)
```

   for proto in range(pickle.HIGHEST_PROTOCOL + 1):[](#l2.23)

```
       # initial iterator[](#l2.24)
```
```
       itorig = iter(orig)[](#l2.25)
```

       d = pickle.dumps((itorig, orig), proto)[](#l2.26)

       it, b = pickle.loads(d)[](#l2.27)

```
       b[:] = data[](#l2.28)
```

       self.assertEqual(type(it), type(itorig))[](#l2.29)

       self.assertEqual(list(it), data)[](#l2.30)

```
       # running iterator[](#l2.32)
```
```
       next(itorig)[](#l2.33)
```

       d = pickle.dumps((itorig, orig), proto)[](#l2.34)

       it, b = pickle.loads(d)[](#l2.35)

```
       b[:] = data[](#l2.36)
```

       self.assertEqual(type(it), type(itorig))[](#l2.37)

       self.assertEqual(list(it), data[1:])[](#l2.38)

```
       # empty iterator[](#l2.40)
```

       for i in range(1, len(orig)):[](#l2.41)

```
           next(itorig)[](#l2.42)
```

       d = pickle.dumps((itorig, orig), proto)[](#l2.43)

       it, b = pickle.loads(d)[](#l2.44)

```
       b[:] = data[](#l2.45)
```

       self.assertEqual(type(it), type(itorig))[](#l2.46)

       self.assertEqual(list(it), data[len(orig):])[](#l2.47)

```
       # exhausted iterator[](#l2.49)
```

       self.assertRaises(StopIteration, next, itorig)[](#l2.50)

       d = pickle.dumps((itorig, orig), proto)[](#l2.51)

       it, b = pickle.loads(d)[](#l2.52)

```
       b[:] = data[](#l2.53)
```

       self.assertEqual(list(it), [])[](#l2.54)

+ + class AssortedBytesTest(unittest.TestCase): # # Test various combinations of bytes and bytearray

--- a/Lib/test/test_deque.py +++ b/Lib/test/test_deque.py @@ -638,18 +638,45 @@ class TestBasic(unittest.TestCase):

self.assertEqual(id(e), id(e[-1]))

def test_iterator_pickle(self):

```
   data = deque(range(200))[](#l3.7)
```

```
   orig = deque(range(200))[](#l3.8)
```

   data = [i*1.01 for i in orig][](#l3.9)
   for proto in range(pickle.HIGHEST_PROTOCOL + 1):[](#l3.10)

       it = itorg = iter(data)[](#l3.11)

       d = pickle.dumps(it, proto)[](#l3.12)

```
       it = pickle.loads(d)[](#l3.13)
```

       self.assertEqual(type(itorg), type(it))[](#l3.14)

       self.assertEqual(list(it), list(data))[](#l3.15)

```
       # initial iterator[](#l3.16)
```
```
       itorg = iter(orig)[](#l3.17)
```

       dump = pickle.dumps((itorg, orig), proto)[](#l3.18)

       it, d = pickle.loads(dump)[](#l3.19)

       for i, x in enumerate(data):[](#l3.20)

```
           d[i] = x[](#l3.21)
```

       self.assertEqual(type(it), type(itorg))[](#l3.22)

       self.assertEqual(list(it), data)[](#l3.23)

```
       # running iterator[](#l3.25)
```
```
       next(itorg)[](#l3.26)
```

       dump = pickle.dumps((itorg, orig), proto)[](#l3.27)

       it, d = pickle.loads(dump)[](#l3.28)

       for i, x in enumerate(data):[](#l3.29)

```
           d[i] = x[](#l3.30)
```

       self.assertEqual(type(it), type(itorg))[](#l3.31)

       self.assertEqual(list(it), data[1:])[](#l3.32)

```
       it = pickle.loads(d)[](#l3.34)
```
```
       next(it)[](#l3.35)
```

       d = pickle.dumps(it, proto)[](#l3.36)

       self.assertEqual(list(it), list(data)[1:])[](#l3.37)

```
       # empty iterator[](#l3.38)
```

       for i in range(1, len(data)):[](#l3.39)

```
           next(itorg)[](#l3.40)
```

       dump = pickle.dumps((itorg, orig), proto)[](#l3.41)

       it, d = pickle.loads(dump)[](#l3.42)

       for i, x in enumerate(data):[](#l3.43)

```
           d[i] = x[](#l3.44)
```

       self.assertEqual(type(it), type(itorg))[](#l3.45)

       self.assertEqual(list(it), [])[](#l3.46)

```
       # exhausted iterator[](#l3.48)
```

       self.assertRaises(StopIteration, next, itorg)[](#l3.49)

       dump = pickle.dumps((itorg, orig), proto)[](#l3.50)

       it, d = pickle.loads(dump)[](#l3.51)

       for i, x in enumerate(data):[](#l3.52)

```
           d[i] = x[](#l3.53)
```

       self.assertEqual(type(it), type(itorg))[](#l3.54)

       self.assertEqual(list(it), [])[](#l3.55)

def test_deepcopy(self): mut = [10]

--- a/Lib/test/test_iter.py +++ b/Lib/test/test_iter.py @@ -153,6 +153,42 @@ class TestCase(unittest.TestCase): def test_seq_class_iter(self): self.check_iterator(iter(SequenceClass(10)), list(range(10)))

def test_mutating_seq_class_iter_pickle(self):
```
   orig = SequenceClass(5)[](#l4.8)
```

   for proto in range(pickle.HIGHEST_PROTOCOL + 1):[](#l4.9)

```
       # initial iterator[](#l4.10)
```
```
       itorig = iter(orig)[](#l4.11)
```

       d = pickle.dumps((itorig, orig), proto)[](#l4.12)

       it, seq = pickle.loads(d)[](#l4.13)

```
       seq.n = 7[](#l4.14)
```

       self.assertIs(type(it), type(itorig))[](#l4.15)

       self.assertEqual(list(it), list(range(7)))[](#l4.16)

```
       # running iterator[](#l4.18)
```
```
       next(itorig)[](#l4.19)
```

       d = pickle.dumps((itorig, orig), proto)[](#l4.20)

       it, seq = pickle.loads(d)[](#l4.21)

```
       seq.n = 7[](#l4.22)
```

       self.assertIs(type(it), type(itorig))[](#l4.23)

       self.assertEqual(list(it), list(range(1, 7)))[](#l4.24)

```
       # empty iterator[](#l4.26)
```
```
       for i in range(1, 5):[](#l4.27)
```
```
           next(itorig)[](#l4.28)
```

       d = pickle.dumps((itorig, orig), proto)[](#l4.29)

       it, seq = pickle.loads(d)[](#l4.30)

```
       seq.n = 7[](#l4.31)
```

       self.assertIs(type(it), type(itorig))[](#l4.32)

       self.assertEqual(list(it), list(range(5, 7)))[](#l4.33)

```
       # exhausted iterator[](#l4.35)
```

       self.assertRaises(StopIteration, next, itorig)[](#l4.36)

       d = pickle.dumps((itorig, orig), proto)[](#l4.37)

       it, seq = pickle.loads(d)[](#l4.38)

```
       seq.n = 7[](#l4.39)
```

       self.assertTrue(isinstance(it, collections.abc.Iterator))[](#l4.40)

       self.assertEqual(list(it), [])[](#l4.41)

+ # Test a new_style class with iter but no next() method def test_new_style_iter_class(self): class IterClass(object):

--- a/Lib/test/test_list.py +++ b/Lib/test/test_list.py @@ -72,34 +72,76 @@ class ListTest(list_tests.CommonTest): check(1000000) def test_iterator_pickle(self):

   # Userlist iterators don't support pickling yet since[](#l5.7)

   # they are based on generators.[](#l5.8)

   data = self.type2test([4, 5, 6, 7])[](#l5.9)

   orig = self.type2test([4, 5, 6, 7])[](#l5.10)

   data = [10, 11, 12, 13, 14, 15][](#l5.11)
   for proto in range(pickle.HIGHEST_PROTOCOL + 1):[](#l5.12)

       it = itorg = iter(data)[](#l5.13)

       d = pickle.dumps(it, proto)[](#l5.14)

```
       it = pickle.loads(d)[](#l5.15)
```

       self.assertEqual(type(itorg), type(it))[](#l5.16)

       self.assertEqual(self.type2test(it), self.type2test(data))[](#l5.17)

```
       # initial iterator[](#l5.18)
```
```
       itorig = iter(orig)[](#l5.19)
```

       d = pickle.dumps((itorig, orig), proto)[](#l5.20)

       it, a = pickle.loads(d)[](#l5.21)

```
       a[:] = data[](#l5.22)
```

       self.assertEqual(type(it), type(itorig))[](#l5.23)

       self.assertEqual(list(it), data)[](#l5.24)

```
       # running iterator[](#l5.26)
```
```
       next(itorig)[](#l5.27)
```

       d = pickle.dumps((itorig, orig), proto)[](#l5.28)

       it, a = pickle.loads(d)[](#l5.29)

```
       a[:] = data[](#l5.30)
```

       self.assertEqual(type(it), type(itorig))[](#l5.31)

       self.assertEqual(list(it), data[1:])[](#l5.32)

```
       it = pickle.loads(d)[](#l5.34)
```
```
       next(it)[](#l5.35)
```

       d = pickle.dumps(it, proto)[](#l5.36)

       self.assertEqual(self.type2test(it), self.type2test(data)[1:])[](#l5.37)

```
       # empty iterator[](#l5.38)
```

       for i in range(1, len(orig)):[](#l5.39)

```
           next(itorig)[](#l5.40)
```

       d = pickle.dumps((itorig, orig), proto)[](#l5.41)

       it, a = pickle.loads(d)[](#l5.42)

```
       a[:] = data[](#l5.43)
```

       self.assertEqual(type(it), type(itorig))[](#l5.44)

       self.assertEqual(list(it), data[len(orig):])[](#l5.45)

```
       # exhausted iterator[](#l5.47)
```

       self.assertRaises(StopIteration, next, itorig)[](#l5.48)

       d = pickle.dumps((itorig, orig), proto)[](#l5.49)

       it, a = pickle.loads(d)[](#l5.50)

```
       a[:] = data[](#l5.51)
```

       self.assertEqual(list(it), [])[](#l5.52)

def test_reversed_pickle(self):

   data = self.type2test([4, 5, 6, 7])[](#l5.55)

   orig = self.type2test([4, 5, 6, 7])[](#l5.56)

   data = [10, 11, 12, 13, 14, 15][](#l5.57)
   for proto in range(pickle.HIGHEST_PROTOCOL + 1):[](#l5.58)

       it = itorg = reversed(data)[](#l5.59)

       d = pickle.dumps(it, proto)[](#l5.60)

```
       it = pickle.loads(d)[](#l5.61)
```

       self.assertEqual(type(itorg), type(it))[](#l5.62)

       self.assertEqual(self.type2test(it), self.type2test(reversed(data)))[](#l5.63)

```
       # initial iterator[](#l5.64)
```

       itorig = reversed(orig)[](#l5.65)

       d = pickle.dumps((itorig, orig), proto)[](#l5.66)

       it, a = pickle.loads(d)[](#l5.67)

```
       a[:] = data[](#l5.68)
```

       self.assertEqual(type(it), type(itorig))[](#l5.69)

       self.assertEqual(list(it), data[len(orig)-1::-1])[](#l5.70)

```
       # running iterator[](#l5.72)
```
```
       next(itorig)[](#l5.73)
```

       d = pickle.dumps((itorig, orig), proto)[](#l5.74)

       it, a = pickle.loads(d)[](#l5.75)

```
       a[:] = data[](#l5.76)
```

       self.assertEqual(type(it), type(itorig))[](#l5.77)

       self.assertEqual(list(it), data[len(orig)-2::-1])[](#l5.78)

```
       it = pickle.loads(d)[](#l5.80)
```
```
       next(it)[](#l5.81)
```

       d = pickle.dumps(it, proto)[](#l5.82)

       self.assertEqual(self.type2test(it), self.type2test(reversed(data))[1:])[](#l5.83)

```
       # empty iterator[](#l5.84)
```

       for i in range(1, len(orig)):[](#l5.85)

```
           next(itorig)[](#l5.86)
```

       d = pickle.dumps((itorig, orig), proto)[](#l5.87)

       it, a = pickle.loads(d)[](#l5.88)

```
       a[:] = data[](#l5.89)
```

       self.assertEqual(type(it), type(itorig))[](#l5.90)

       self.assertEqual(list(it), [])[](#l5.91)

```
       # exhausted iterator[](#l5.93)
```

       self.assertRaises(StopIteration, next, itorig)[](#l5.94)

       d = pickle.dumps((itorig, orig), proto)[](#l5.95)

       it, a = pickle.loads(d)[](#l5.96)

```
       a[:] = data[](#l5.97)
```

       self.assertEqual(list(it), [])[](#l5.98)

def test_no_comdat_folding(self): # Issue 8847: In the PGO build, the MSVC linker's COMDAT folding

--- a/Misc/NEWS +++ b/Misc/NEWS @@ -274,6 +274,8 @@ Documentation Tests ----- +- Issue #26015: Added new tests for pickling iterators of mutable sequences. +

Issue #26325: Added test.support.check_no_resource_warning() to check that no ResourceWarning is emitted.