1import sys
2from test import list_tests
3import pickle
4import unittest
5
6class ListTest(list_tests.CommonTest):
7    type2test = list
8
9    def test_basic(self):
10        self.assertEqual(list([]), [])
11        l0_3 = [0, 1, 2, 3]
12        l0_3_bis = list(l0_3)
13        self.assertEqual(l0_3, l0_3_bis)
14        self.assertTrue(l0_3 is not l0_3_bis)
15        self.assertEqual(list(()), [])
16        self.assertEqual(list((0, 1, 2, 3)), [0, 1, 2, 3])
17        self.assertEqual(list(''), [])
18        self.assertEqual(list('spam'), ['s', 'p', 'a', 'm'])
19
20        if sys.maxsize == 0x7fffffff:
21            # This test can currently only work on 32-bit machines.
22            # XXX If/when PySequence_Length() returns a ssize_t, it should be
23            # XXX re-enabled.
24            # Verify clearing of bug #556025.
25            # This assumes that the max data size (sys.maxint) == max
26            # address size this also assumes that the address size is at
27            # least 4 bytes with 8 byte addresses, the bug is not well
28            # tested
29            #
30            # Note: This test is expected to SEGV under Cygwin 1.3.12 or
31            # earlier due to a newlib bug.  See the following mailing list
32            # thread for the details:
33
34            #     http://sources.redhat.com/ml/newlib/2002/msg00369.html
35            self.assertRaises(MemoryError, list, range(sys.maxsize // 2))
36
37        # This code used to segfault in Py2.4a3
38        x = []
39        x.extend(-y for y in x)
40        self.assertEqual(x, [])
41
42    def test_truth(self):
43        super().test_truth()
44        self.assertTrue(not [])
45        self.assertTrue([42])
46
47    def test_identity(self):
48        self.assertTrue([] is not [])
49
50    def test_len(self):
51        super().test_len()
52        self.assertEqual(len([]), 0)
53        self.assertEqual(len([0]), 1)
54        self.assertEqual(len([0, 1, 2]), 3)
55
56    def test_overflow(self):
57        lst = [4, 5, 6, 7]
58        n = int((sys.maxsize*2+2) // len(lst))
59        def mul(a, b): return a * b
60        def imul(a, b): a *= b
61        self.assertRaises((MemoryError, OverflowError), mul, lst, n)
62        self.assertRaises((MemoryError, OverflowError), imul, lst, n)
63
64    def test_repr_large(self):
65        # Check the repr of large list objects
66        def check(n):
67            l = [0] * n
68            s = repr(l)
69            self.assertEqual(s,
70                '[' + ', '.join(['0'] * n) + ']')
71        check(10)       # check our checking code
72        check(1000000)
73
74    def test_iterator_pickle(self):
75        orig = self.type2test([4, 5, 6, 7])
76        data = [10, 11, 12, 13, 14, 15]
77        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
78            # initial iterator
79            itorig = iter(orig)
80            d = pickle.dumps((itorig, orig), proto)
81            it, a = pickle.loads(d)
82            a[:] = data
83            self.assertEqual(type(it), type(itorig))
84            self.assertEqual(list(it), data)
85
86            # running iterator
87            next(itorig)
88            d = pickle.dumps((itorig, orig), proto)
89            it, a = pickle.loads(d)
90            a[:] = data
91            self.assertEqual(type(it), type(itorig))
92            self.assertEqual(list(it), data[1:])
93
94            # empty iterator
95            for i in range(1, len(orig)):
96                next(itorig)
97            d = pickle.dumps((itorig, orig), proto)
98            it, a = pickle.loads(d)
99            a[:] = data
100            self.assertEqual(type(it), type(itorig))
101            self.assertEqual(list(it), data[len(orig):])
102
103            # exhausted iterator
104            self.assertRaises(StopIteration, next, itorig)
105            d = pickle.dumps((itorig, orig), proto)
106            it, a = pickle.loads(d)
107            a[:] = data
108            self.assertEqual(list(it), [])
109
110    def test_reversed_pickle(self):
111        orig = self.type2test([4, 5, 6, 7])
112        data = [10, 11, 12, 13, 14, 15]
113        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
114            # initial iterator
115            itorig = reversed(orig)
116            d = pickle.dumps((itorig, orig), proto)
117            it, a = pickle.loads(d)
118            a[:] = data
119            self.assertEqual(type(it), type(itorig))
120            self.assertEqual(list(it), data[len(orig)-1::-1])
121
122            # running iterator
123            next(itorig)
124            d = pickle.dumps((itorig, orig), proto)
125            it, a = pickle.loads(d)
126            a[:] = data
127            self.assertEqual(type(it), type(itorig))
128            self.assertEqual(list(it), data[len(orig)-2::-1])
129
130            # empty iterator
131            for i in range(1, len(orig)):
132                next(itorig)
133            d = pickle.dumps((itorig, orig), proto)
134            it, a = pickle.loads(d)
135            a[:] = data
136            self.assertEqual(type(it), type(itorig))
137            self.assertEqual(list(it), [])
138
139            # exhausted iterator
140            self.assertRaises(StopIteration, next, itorig)
141            d = pickle.dumps((itorig, orig), proto)
142            it, a = pickle.loads(d)
143            a[:] = data
144            self.assertEqual(list(it), [])
145
146    def test_no_comdat_folding(self):
147        # Issue 8847: In the PGO build, the MSVC linker's COMDAT folding
148        # optimization causes failures in code that relies on distinct
149        # function addresses.
150        class L(list): pass
151        with self.assertRaises(TypeError):
152            (3,) + L([1,2])
153
154if __name__ == "__main__":
155    unittest.main()
156