Debian Codegraph @

Lib/test/test_capi/test_tuple.py

raw
1 import unittest
2 import gc
3 from test.support import import_helper
4
5 _testcapi = import_helper.import_module('_testcapi')
6 _testlimitedcapi = import_helper.import_module('_testlimitedcapi')
7
8 NULL = None
9 PY_SSIZE_T_MIN = _testcapi.PY_SSIZE_T_MIN
10 PY_SSIZE_T_MAX = _testcapi.PY_SSIZE_T_MAX
11
12 class TupleSubclass(tuple):
13 pass
14
15
16 class CAPITest(unittest.TestCase):
17 def _not_tracked(self, t):
18 self.assertFalse(gc.is_tracked(t), t)
19
20 def _tracked(self, t):
21 self.assertTrue(gc.is_tracked(t), t)
22
23 def test_check(self):
24 # Test PyTuple_Check()
25 check = _testlimitedcapi.tuple_check
26
27 self.assertTrue(check((1, 2)))
28 self.assertTrue(check(()))
29 self.assertTrue(check(TupleSubclass((1, 2))))
30 self.assertFalse(check({1: 2}))
31 self.assertFalse(check([1, 2]))
32 self.assertFalse(check(42))
33 self.assertFalse(check(object()))
34
35 # CRASHES check(NULL)
36
37 def test_tuple_checkexact(self):
38 # Test PyTuple_CheckExact()
39 check = _testlimitedcapi.tuple_checkexact
40
41 self.assertTrue(check((1, 2)))
42 self.assertTrue(check(()))
43 self.assertFalse(check(TupleSubclass((1, 2))))
44 self.assertFalse(check({1: 2}))
45 self.assertFalse(check([1, 2]))
46 self.assertFalse(check(42))
47 self.assertFalse(check(object()))
48
49 # CRASHES check(NULL)
50
51 def test_tuple_new(self):
52 # Test PyTuple_New()
53 tuple_new = _testlimitedcapi.tuple_new
54 size = _testlimitedcapi.tuple_size
55 checknull = _testcapi._check_tuple_item_is_NULL
56
57 tup1 = tuple_new(0)
58 self.assertEqual(tup1, ())
59 self.assertEqual(size(tup1), 0)
60 self.assertIs(type(tup1), tuple)
61 self._not_tracked(tup1)
62
63 tup2 = tuple_new(1)
64 self.assertIs(type(tup2), tuple)
65 self.assertEqual(size(tup2), 1)
66 self.assertIsNot(tup2, tup1)
67 self.assertTrue(checknull(tup2, 0))
68 self._tracked(tup2)
69
70 self.assertRaises(SystemError, tuple_new, -1)
71 self.assertRaises(SystemError, tuple_new, PY_SSIZE_T_MIN)
72 self.assertRaises(MemoryError, tuple_new, PY_SSIZE_T_MAX)
73
74 def test_tuple_pack(self):
75 # Test PyTuple_Pack()
76 pack = _testlimitedcapi.tuple_pack
77
78 self.assertEqual(pack(0), ())
79 self.assertEqual(pack(1, [1]), ([1],))
80 self.assertEqual(pack(2, [1], [2]), ([1], [2]))
81
82 self._tracked(pack(1, [1]))
83 self._tracked(pack(2, [1], b'abc'))
84 self._not_tracked(pack(2, 42, b'abc'))
85
86 self.assertRaises(SystemError, pack, PY_SSIZE_T_MIN)
87 self.assertRaises(SystemError, pack, -1)
88 self.assertRaises(MemoryError, pack, PY_SSIZE_T_MAX)
89
90 # CRASHES pack(1, NULL)
91 # CRASHES pack(2, [1])
92
93 def test_tuple_size(self):
94 # Test PyTuple_Size()
95 size = _testlimitedcapi.tuple_size
96
97 self.assertEqual(size(()), 0)
98 self.assertEqual(size((1, 2)), 2)
99 self.assertEqual(size(TupleSubclass((1, 2))), 2)
100
101 self.assertRaises(SystemError, size, [])
102 self.assertRaises(SystemError, size, 42)
103 self.assertRaises(SystemError, size, object())
104
105 # CRASHES size(NULL)
106
107 def test_tuple_get_size(self):
108 # Test PyTuple_GET_SIZE()
109 size = _testcapi.tuple_get_size
110
111 self.assertEqual(size(()), 0)
112 self.assertEqual(size((1, 2)), 2)
113 self.assertEqual(size(TupleSubclass((1, 2))), 2)
114
115 def test_tuple_getitem(self):
116 # Test PyTuple_GetItem()
117 getitem = _testlimitedcapi.tuple_getitem
118
119 tup = ([1], [2], [3])
120 self.assertEqual(getitem(tup, 0), [1])
121 self.assertEqual(getitem(tup, 2), [3])
122
123 tup2 = TupleSubclass(([1], [2], [3]))
124 self.assertEqual(getitem(tup2, 0), [1])
125 self.assertEqual(getitem(tup2, 2), [3])
126
127 self.assertRaises(IndexError, getitem, tup, PY_SSIZE_T_MIN)
128 self.assertRaises(IndexError, getitem, tup, -1)
129 self.assertRaises(IndexError, getitem, tup, len(tup))
130 self.assertRaises(IndexError, getitem, tup, PY_SSIZE_T_MAX)
131 self.assertRaises(SystemError, getitem, [1, 2, 3], 1)
132 self.assertRaises(SystemError, getitem, 42, 1)
133
134 # CRASHES getitem(NULL, 0)
135
136 def test_tuple_get_item(self):
137 # Test PyTuple_GET_ITEM()
138 get_item = _testcapi.tuple_get_item
139
140 tup = ([1], [2], [3])
141 self.assertEqual(get_item(tup, 0), [1])
142 self.assertEqual(get_item(tup, 2), [3])
143
144 tup2 = TupleSubclass(([1], [2], [3]))
145 self.assertEqual(get_item(tup2, 0), [1])
146 self.assertEqual(get_item(tup2, 2), [3])
147
148 # CRASHES get_item(NULL, 0)
149
150 def test_tuple_getslice(self):
151 # Test PyTuple_GetSlice()
152 getslice = _testlimitedcapi.tuple_getslice
153
154 # empty
155 tup = ([1], [2], [3])
156 self.assertEqual(getslice(tup, PY_SSIZE_T_MIN, 0), ())
157 self.assertEqual(getslice(tup, -1, 0), ())
158 self.assertEqual(getslice(tup, 3, PY_SSIZE_T_MAX), ())
159 self.assertEqual(getslice(tup, 1, 1), ())
160 self.assertEqual(getslice(tup, 2, 1), ())
161 tup = TupleSubclass(([1], [2], [3]))
162 self.assertEqual(getslice(tup, PY_SSIZE_T_MIN, 0), ())
163 self.assertEqual(getslice(tup, -1, 0), ())
164 self.assertEqual(getslice(tup, 3, PY_SSIZE_T_MAX), ())
165 self.assertEqual(getslice(tup, 1, 1), ())
166 self.assertEqual(getslice(tup, 2, 1), ())
167
168 # slice
169 tup = ([1], [2], [3], [4])
170 self.assertEqual(getslice(tup, 1, 3), ([2], [3]))
171 tup = TupleSubclass(([1], [2], [3], [4]))
172 self.assertEqual(getslice(tup, 1, 3), ([2], [3]))
173
174 # whole
175 tup = ([1], [2], [3])
176 self.assertEqual(getslice(tup, 0, 3), tup)
177 self.assertEqual(getslice(tup, 0, 100), tup)
178 self.assertEqual(getslice(tup, -100, 100), tup)
179 tup = TupleSubclass(([1], [2], [3]))
180 self.assertEqual(getslice(tup, 0, 3), tup)
181 self.assertEqual(getslice(tup, 0, 100), tup)
182 self.assertEqual(getslice(tup, -100, 100), tup)
183
184 self.assertRaises(SystemError, getslice, [[1], [2], [3]], 0, 0)
185 self.assertRaises(SystemError, getslice, 42, 0, 0)
186
187 # CRASHES getslice(NULL, 0, 0)
188
189 def test_tuple_setitem(self):
190 # Test PyTuple_SetItem()
191 setitem = _testlimitedcapi.tuple_setitem
192 checknull = _testcapi._check_tuple_item_is_NULL
193
194 tup = ([1], [2])
195 self.assertEqual(setitem(tup, 0, []), ([], [2]))
196 self.assertEqual(setitem(tup, 1, []), ([1], []))
197
198 tup2 = setitem(tup, 1, NULL)
199 self.assertTrue(checknull(tup2, 1))
200
201 tup2 = TupleSubclass(([1], [2]))
202 self.assertRaises(SystemError, setitem, tup2, 0, [])
203
204 self.assertRaises(IndexError, setitem, tup, PY_SSIZE_T_MIN, [])
205 self.assertRaises(IndexError, setitem, tup, -1, [])
206 self.assertRaises(IndexError, setitem, tup, len(tup), [])
207 self.assertRaises(IndexError, setitem, tup, PY_SSIZE_T_MAX, [])
208 self.assertRaises(SystemError, setitem, [1], 0, [])
209 self.assertRaises(SystemError, setitem, 42, 0, [])
210
211 # CRASHES setitem(NULL, 0, [])
212
213 def test_tuple_set_item(self):
214 # Test PyTuple_SET_ITEM()
215 set_item = _testcapi.tuple_set_item
216 checknull = _testcapi._check_tuple_item_is_NULL
217
218 tup = ([1], [2])
219 self.assertEqual(set_item(tup, 0, []), ([], [2]))
220 self.assertEqual(set_item(tup, 1, []), ([1], []))
221
222 tup2 = set_item(tup, 1, NULL)
223 self.assertTrue(checknull(tup2, 1))
224
225 tup2 = TupleSubclass(([1], [2]))
226 self.assertIs(set_item(tup2, 0, []), tup2)
227 self.assertEqual(tup2, ([], [2]))
228
229 # CRASHES set_item(tup, -1, [])
230 # CRASHES set_item(tup, len(tup), [])
231 # CRASHES set_item([1], 0, [])
232 # CRASHES set_item(NULL, 0, [])
233
234 def test__tuple_resize(self):
235 # Test _PyTuple_Resize()
236 resize = _testcapi._tuple_resize
237 checknull = _testcapi._check_tuple_item_is_NULL
238
239 a = ()
240 b = resize(a, 0, False)
241 self.assertEqual(len(a), 0)
242 self.assertEqual(len(b), 0)
243 b = resize(a, 2, False)
244 self.assertEqual(len(a), 0)
245 self.assertEqual(len(b), 2)
246 self.assertTrue(checknull(b, 0))
247 self.assertTrue(checknull(b, 1))
248
249 a = ([1], [2], [3])
250 b = resize(a, 3)
251 self.assertEqual(b, a)
252 b = resize(a, 2)
253 self.assertEqual(b, a[:2])
254 b = resize(a, 5)
255 self.assertEqual(len(b), 5)
256 self.assertEqual(b[:3], a)
257 self.assertTrue(checknull(b, 3))
258 self.assertTrue(checknull(b, 4))
259
260 a = ()
261 self.assertRaises(MemoryError, resize, a, PY_SSIZE_T_MAX)
262 self.assertRaises(SystemError, resize, a, -1)
263 self.assertRaises(SystemError, resize, a, PY_SSIZE_T_MIN)
264 # refcount > 1
265 a = (1, 2, 3)
266 self.assertRaises(SystemError, resize, a, 3, False)
267 self.assertRaises(SystemError, resize, a, 0, False)
268 # non-tuple
269 self.assertRaises(SystemError, resize, [1, 2, 3], 0, False)
270 self.assertRaises(SystemError, resize, NULL, 0, False)
271
272 def test_bug_59313(self):
273 # Before 3.14, the C-API function PySequence_Tuple
274 # would create incomplete tuples which were visible to
275 # the cycle GC, and this test would crash the interpeter.
276 TAG = object()
277 tuples = []
278
279 def referrer_tuples():
280 return [x for x in gc.get_referrers(TAG)
281 if isinstance(x, tuple)]
282
283 def my_iter():
284 nonlocal tuples
285 yield TAG # 'tag' gets stored in the result tuple
286 tuples += referrer_tuples()
287 for x in range(10):
288 tuples += referrer_tuples()
289 # Prior to 3.13 would raise a SystemError when the tuple needs to be resized
290 yield x
291
292 self.assertEqual(tuple(my_iter()), (TAG, *range(10)))
293 self.assertEqual(tuples, [])
294
295 def test_uninitialized_tuple_repr(self):
296 tup = _testlimitedcapi.tuple_new(3)
297 self.assertEqual(repr(tup), '(<NULL>, <NULL>, <NULL>)')
298
299
300 if __name__ == "__main__":
301 unittest.main()