Debian Codegraph @

Lib/test/test_memoryview.py

raw
1 """Unit tests for the memoryview
2
3 Some tests are in test_bytes. Many tests that require _testbuffer.ndarray
4 are in test_buffer.
5 """
6
7 import unittest
8 import test.support
9 import sys
10 import gc
11 import weakref
12 import array
13 import io
14 import copy
15 import pickle
16 import struct
17
18 from itertools import product
19 from test import support
20 from test.support import import_helper, threading_helper
21
22
23 class MyObject:
24 pass
25
26
27 class AbstractMemoryTests:
28 source_bytes = b"abcdef"
29
30 @property
31 def _source(self):
32 return self.source_bytes
33
34 @property
35 def _types(self):
36 return filter(None, [self.ro_type, self.rw_type])
37
38 def check_getitem_with_type(self, tp):
39 b = tp(self._source)
40 oldrefcount = sys.getrefcount(b)
41 m = self._view(b)
42 self.assertEqual(m[0], ord(b"a"))
43 self.assertIsInstance(m[0], int)
44 self.assertEqual(m[5], ord(b"f"))
45 self.assertEqual(m[-1], ord(b"f"))
46 self.assertEqual(m[-6], ord(b"a"))
47 # Bounds checking
48 self.assertRaises(IndexError, lambda: m[6])
49 self.assertRaises(IndexError, lambda: m[-7])
50 self.assertRaises(IndexError, lambda: m[sys.maxsize])
51 self.assertRaises(IndexError, lambda: m[-sys.maxsize])
52 # Type checking
53 self.assertRaises(TypeError, lambda: m[None])
54 self.assertRaises(TypeError, lambda: m[0.0])
55 self.assertRaises(TypeError, lambda: m["a"])
56 m = None
57 self.assertEqual(sys.getrefcount(b), oldrefcount)
58
59 def test_getitem(self):
60 for tp in self._types:
61 self.check_getitem_with_type(tp)
62
63 def test_index(self):
64 for tp in self._types:
65 b = tp(self._source)
66 m = self._view(b) # may be a sub-view
67 l = m.tolist()
68 k = 2 * len(self._source)
69
70 for chi in self._source:
71 if chi in l:
72 self.assertEqual(m.index(chi), l.index(chi))
73 else:
74 self.assertRaises(ValueError, m.index, chi)
75
76 for start, stop in product(range(-k, k), range(-k, k)):
77 index = -1
78 try:
79 index = l.index(chi, start, stop)
80 except ValueError:
81 pass
82
83 if index == -1:
84 self.assertRaises(ValueError, m.index, chi, start, stop)
85 else:
86 self.assertEqual(m.index(chi, start, stop), index)
87
88 def test_iter(self):
89 for tp in self._types:
90 b = tp(self._source)
91 m = self._view(b)
92 self.assertEqual(list(m), [m[i] for i in range(len(m))])
93
94 def test_count(self):
95 for tp in self._types:
96 b = tp(self._source)
97 m = self._view(b)
98 l = m.tolist()
99 for ch in list(m):
100 self.assertEqual(m.count(ch), l.count(ch))
101
102 b = tp((b'a' * 5) + (b'c' * 3))
103 m = self._view(b) # may be sliced
104 l = m.tolist()
105 with self.subTest('count', buffer=b):
106 self.assertEqual(m.count(ord('a')), l.count(ord('a')))
107 self.assertEqual(m.count(ord('b')), l.count(ord('b')))
108 self.assertEqual(m.count(ord('c')), l.count(ord('c')))
109
110 def test_setitem_readonly(self):
111 if not self.ro_type:
112 self.skipTest("no read-only type to test")
113 b = self.ro_type(self._source)
114 oldrefcount = sys.getrefcount(b)
115 m = self._view(b)
116 def setitem(value):
117 m[0] = value
118 self.assertRaises(TypeError, setitem, b"a")
119 self.assertRaises(TypeError, setitem, 65)
120 self.assertRaises(TypeError, setitem, memoryview(b"a"))
121 m = None
122 self.assertEqual(sys.getrefcount(b), oldrefcount)
123
124 def test_setitem_writable(self):
125 if not self.rw_type:
126 self.skipTest("no writable type to test")
127 tp = self.rw_type
128 b = self.rw_type(self._source)
129 oldrefcount = sys.getrefcount(b)
130 m = self._view(b)
131 m[0] = ord(b'1')
132 self._check_contents(tp, b, b"1bcdef")
133 m[0:1] = tp(b"0")
134 self._check_contents(tp, b, b"0bcdef")
135 m[1:3] = tp(b"12")
136 self._check_contents(tp, b, b"012def")
137 m[1:1] = tp(b"")
138 self._check_contents(tp, b, b"012def")
139 m[:] = tp(b"abcdef")
140 self._check_contents(tp, b, b"abcdef")
141
142 # Overlapping copies of a view into itself
143 m[0:3] = m[2:5]
144 self._check_contents(tp, b, b"cdedef")
145 m[:] = tp(b"abcdef")
146 m[2:5] = m[0:3]
147 self._check_contents(tp, b, b"ababcf")
148
149 def setitem(key, value):
150 m[key] = tp(value)
151 # Bounds checking
152 self.assertRaises(IndexError, setitem, 6, b"a")
153 self.assertRaises(IndexError, setitem, -7, b"a")
154 self.assertRaises(IndexError, setitem, sys.maxsize, b"a")
155 self.assertRaises(IndexError, setitem, -sys.maxsize, b"a")
156 # Wrong index/slice types
157 self.assertRaises(TypeError, setitem, 0.0, b"a")
158 self.assertRaises(TypeError, setitem, (0,), b"a")
159 self.assertRaises(TypeError, setitem, (slice(0,1,1), 0), b"a")
160 self.assertRaises(TypeError, setitem, (0, slice(0,1,1)), b"a")
161 self.assertRaises(TypeError, setitem, (0,), b"a")
162 self.assertRaises(TypeError, setitem, "a", b"a")
163 # Not implemented: multidimensional slices
164 slices = (slice(0,1,1), slice(0,1,2))
165 self.assertRaises(NotImplementedError, setitem, slices, b"a")
166 # Trying to resize the memory object
167 exc = ValueError if m.format == 'c' else TypeError
168 self.assertRaises(exc, setitem, 0, b"")
169 self.assertRaises(exc, setitem, 0, b"ab")
170 self.assertRaises(ValueError, setitem, slice(1,1), b"a")
171 self.assertRaises(ValueError, setitem, slice(0,2), b"a")
172
173 m = None
174 self.assertEqual(sys.getrefcount(b), oldrefcount)
175
176 def test_delitem(self):
177 for tp in self._types:
178 b = tp(self._source)
179 m = self._view(b)
180 with self.assertRaises(TypeError):
181 del m[1]
182 with self.assertRaises(TypeError):
183 del m[1:4]
184
185 def test_tobytes(self):
186 for tp in self._types:
187 m = self._view(tp(self._source))
188 b = m.tobytes()
189 # This calls self.getitem_type() on each separate byte of b"abcdef"
190 expected = b"".join(
191 self.getitem_type(bytes([c])) for c in b"abcdef")
192 self.assertEqual(b, expected)
193 self.assertIsInstance(b, bytes)
194
195 def test_tolist(self):
196 for tp in self._types:
197 m = self._view(tp(self._source))
198 l = m.tolist()
199 self.assertEqual(l, list(b"abcdef"))
200
201 def test_compare(self):
202 # memoryviews can compare for equality with other objects
203 # having the buffer interface.
204 for tp in self._types:
205 m = self._view(tp(self._source))
206 for tp_comp in self._types:
207 self.assertTrue(m == tp_comp(b"abcdef"))
208 self.assertFalse(m != tp_comp(b"abcdef"))
209 self.assertFalse(m == tp_comp(b"abcde"))
210 self.assertTrue(m != tp_comp(b"abcde"))
211 self.assertFalse(m == tp_comp(b"abcde1"))
212 self.assertTrue(m != tp_comp(b"abcde1"))
213 self.assertTrue(m == m)
214 self.assertTrue(m == m[:])
215 self.assertTrue(m[0:6] == m[:])
216 self.assertFalse(m[0:5] == m)
217
218 # Comparison with objects which don't support the buffer API
219 self.assertFalse(m == "abcdef")
220 self.assertTrue(m != "abcdef")
221 self.assertFalse("abcdef" == m)
222 self.assertTrue("abcdef" != m)
223
224 # Unordered comparisons
225 for c in (m, b"abcdef"):
226 self.assertRaises(TypeError, lambda: m < c)
227 self.assertRaises(TypeError, lambda: c <= m)
228 self.assertRaises(TypeError, lambda: m >= c)
229 self.assertRaises(TypeError, lambda: c > m)
230
231 def check_attributes_with_type(self, tp):
232 m = self._view(tp(self._source))
233 self.assertEqual(m.format, self.format)
234 self.assertEqual(m.itemsize, self.itemsize)
235 self.assertEqual(m.ndim, 1)
236 self.assertEqual(m.shape, (6,))
237 self.assertEqual(len(m), 6)
238 self.assertEqual(m.strides, (self.itemsize,))
239 self.assertEqual(m.suboffsets, ())
240 return m
241
242 def test_attributes_readonly(self):
243 if not self.ro_type:
244 self.skipTest("no read-only type to test")
245 m = self.check_attributes_with_type(self.ro_type)
246 self.assertEqual(m.readonly, True)
247
248 def test_attributes_writable(self):
249 if not self.rw_type:
250 self.skipTest("no writable type to test")
251 m = self.check_attributes_with_type(self.rw_type)
252 self.assertEqual(m.readonly, False)
253
254 def test_getbuffer(self):
255 # Test PyObject_GetBuffer() on a memoryview object.
256 for tp in self._types:
257 b = tp(self._source)
258 oldrefcount = sys.getrefcount(b)
259 m = self._view(b)
260 oldviewrefcount = sys.getrefcount(m)
261 s = str(m, "utf-8")
262 self._check_contents(tp, b, s.encode("utf-8"))
263 self.assertEqual(sys.getrefcount(m), oldviewrefcount)
264 m = None
265 self.assertEqual(sys.getrefcount(b), oldrefcount)
266
267 def test_gc(self):
268 for tp in self._types:
269 if not isinstance(tp, type):
270 # If tp is a factory rather than a plain type, skip
271 continue
272
273 class MyView():
274 def __init__(self, base):
275 self.m = memoryview(base)
276 class MySource(tp):
277 pass
278
279 # Create a reference cycle through a memoryview object.
280 # This exercises mbuf_clear().
281 b = MySource(tp(b'abc'))
282 m = self._view(b)
283 o = MyObject()
284 b.m = m
285 b.o = o
286 wr = weakref.ref(o)
287 b = m = o = None
288 # The cycle must be broken
289 gc.collect()
290 self.assertTrue(wr() is None, wr())
291
292 # This exercises memory_clear().
293 m = MyView(tp(b'abc'))
294 o = MyObject()
295 m.x = m
296 m.o = o
297 wr = weakref.ref(o)
298 m = o = None
299 # The cycle must be broken
300 gc.collect()
301 self.assertTrue(wr() is None, wr())
302
303 def _check_released(self, m, tp):
304 check = self.assertRaisesRegex(ValueError, "released")
305 with check: bytes(m)
306 with check: m.tobytes()
307 with check: m.tolist()
308 with check: m[0]
309 with check: m[0] = b'x'
310 with check: len(m)
311 with check: m.format
312 with check: m.itemsize
313 with check: m.ndim
314 with check: m.readonly
315 with check: m.shape
316 with check: m.strides
317 with check:
318 with m:
319 pass
320 # str() and repr() still function
321 self.assertIn("released memory", str(m))
322 self.assertIn("released memory", repr(m))
323 self.assertEqual(m, m)
324 self.assertNotEqual(m, memoryview(tp(self._source)))
325 self.assertNotEqual(m, tp(self._source))
326
327 def test_contextmanager(self):
328 for tp in self._types:
329 b = tp(self._source)
330 m = self._view(b)
331 with m as cm:
332 self.assertIs(cm, m)
333 self._check_released(m, tp)
334 m = self._view(b)
335 # Can release explicitly inside the context manager
336 with m:
337 m.release()
338
339 def test_release(self):
340 for tp in self._types:
341 b = tp(self._source)
342 m = self._view(b)
343 m.release()
344 self._check_released(m, tp)
345 # Can be called a second time (it's a no-op)
346 m.release()
347 self._check_released(m, tp)
348
349 def test_writable_readonly(self):
350 # Issue #10451: memoryview incorrectly exposes a readonly
351 # buffer as writable causing a segfault if using mmap
352 tp = self.ro_type
353 if tp is None:
354 self.skipTest("no read-only type to test")
355 b = tp(self._source)
356 m = self._view(b)
357 i = io.BytesIO(b'ZZZZ')
358 self.assertRaises(TypeError, i.readinto, m)
359
360 def test_getbuf_fail(self):
361 self.assertRaises(TypeError, self._view, {})
362
363 def test_hash(self):
364 # Memoryviews of readonly (hashable) types are hashable, and they
365 # hash as hash(obj.tobytes()).
366 tp = self.ro_type
367 if tp is None:
368 self.skipTest("no read-only type to test")
369 b = tp(self._source)
370 m = self._view(b)
371 self.assertEqual(hash(m), hash(b"abcdef"))
372 # Releasing the memoryview keeps the stored hash value (as with weakrefs)
373 m.release()
374 self.assertEqual(hash(m), hash(b"abcdef"))
375 # Hashing a memoryview for the first time after it is released
376 # results in an error (as with weakrefs).
377 m = self._view(b)
378 m.release()
379 self.assertRaises(ValueError, hash, m)
380
381 def test_hash_writable(self):
382 # Memoryviews of writable types are unhashable
383 tp = self.rw_type
384 if tp is None:
385 self.skipTest("no writable type to test")
386 b = tp(self._source)
387 m = self._view(b)
388 self.assertRaises(ValueError, hash, m)
389
390 def test_hash_use_after_free(self):
391 # Prevent crash in memoryview(v).__hash__ with re-entrant v.__hash__.
392 # Regression test for https://github.com/python/cpython/issues/142664.
393 class E(array.array):
394 def __hash__(self):
395 mv.release()
396 self.clear()
397 return 123
398
399 v = E('B', b'A' * 4096)
400 mv = memoryview(v).toreadonly() # must be read-only for hash()
401 self.assertRaises(BufferError, hash, mv)
402 self.assertRaises(BufferError, mv.__hash__)
403
404 def test_weakref(self):
405 # Check memoryviews are weakrefable
406 for tp in self._types:
407 b = tp(self._source)
408 m = self._view(b)
409 L = []
410 def callback(wr, b=b):
411 L.append(b)
412 wr = weakref.ref(m, callback)
413 self.assertIs(wr(), m)
414 del m
415 test.support.gc_collect()
416 self.assertIs(wr(), None)
417 self.assertIs(L[0], b)
418
419 def test_reversed(self):
420 for tp in self._types:
421 b = tp(self._source)
422 m = self._view(b)
423 aslist = list(reversed(m.tolist()))
424 self.assertEqual(list(reversed(m)), aslist)
425 self.assertEqual(list(reversed(m)), list(m[::-1]))
426
427 def test_toreadonly(self):
428 for tp in self._types:
429 b = tp(self._source)
430 m = self._view(b)
431 mm = m.toreadonly()
432 self.assertTrue(mm.readonly)
433 self.assertTrue(memoryview(mm).readonly)
434 self.assertEqual(mm.tolist(), m.tolist())
435 mm.release()
436 m.tolist()
437
438 def test_issue22668(self):
439 a = array.array('H', [256, 256, 256, 256])
440 x = memoryview(a)
441 m = x.cast('B')
442 b = m.cast('H')
443 c = b[0:2]
444 d = memoryview(b)
445
446 del b
447
448 self.assertEqual(c[0], 256)
449 self.assertEqual(d[0], 256)
450 self.assertEqual(c.format, "H")
451 self.assertEqual(d.format, "H")
452
453 _ = m.cast('I')
454 self.assertEqual(c[0], 256)
455 self.assertEqual(d[0], 256)
456 self.assertEqual(c.format, "H")
457 self.assertEqual(d.format, "H")
458
459 def test_hex_use_after_free(self):
460 # Prevent UAF in memoryview.hex(sep) with re-entrant sep.__len__.
461 # Regression test for https://github.com/python/cpython/issues/143195.
462 ba = bytearray(b'A' * 1024)
463 mv = memoryview(ba)
464
465 class S(bytes):
466 def __len__(self):
467 mv.release()
468 ba.clear()
469 return 1
470
471 self.assertRaises(BufferError, mv.hex, S(b':'))
472
473
474 # Variations on source objects for the buffer: bytes-like objects, then arrays
475 # with itemsize > 1.
476 # NOTE: support for multi-dimensional objects is unimplemented.
477
478 class BaseBytesMemoryTests(AbstractMemoryTests):
479 ro_type = bytes
480 rw_type = bytearray
481 getitem_type = bytes
482 itemsize = 1
483 format = 'B'
484
485 class BaseArrayMemoryTests(AbstractMemoryTests):
486 ro_type = None
487 rw_type = lambda self, b: array.array('i', list(b))
488 getitem_type = lambda self, b: array.array('i', list(b)).tobytes()
489 itemsize = array.array('i').itemsize
490 format = 'i'
491
492 @unittest.skip('XXX test should be adapted for non-byte buffers')
493 def test_getbuffer(self):
494 pass
495
496 @unittest.skip('XXX NotImplementedError: tolist() only supports byte views')
497 def test_tolist(self):
498 pass
499
500
501 # Variations on indirection levels: memoryview, slice of memoryview,
502 # slice of slice of memoryview.
503 # This is important to test allocation subtleties.
504
505 class BaseMemoryviewTests:
506 def _view(self, obj):
507 return memoryview(obj)
508
509 def _check_contents(self, tp, obj, contents):
510 self.assertEqual(obj, tp(contents))
511
512 def test_count(self):
513 super().test_count()
514 for tp in self._types:
515 b = tp((b'a' * 5) + (b'c' * 3))
516 m = self._view(b) # should not be sliced
517 self.assertEqual(len(b), len(m))
518 with self.subTest('count', buffer=b):
519 self.assertEqual(m.count(ord('a')), 5)
520 self.assertEqual(m.count(ord('b')), 0)
521 self.assertEqual(m.count(ord('c')), 3)
522
523
524 class BaseMemorySliceTests:
525 source_bytes = b"XabcdefY"
526
527 def _view(self, obj):
528 m = memoryview(obj)
529 return m[1:7]
530
531 def _check_contents(self, tp, obj, contents):
532 self.assertEqual(obj[1:7], tp(contents))
533
534 def test_refs(self):
535 for tp in self._types:
536 m = memoryview(tp(self._source))
537 oldrefcount = sys.getrefcount(m)
538 m[1:2]
539 self.assertEqual(sys.getrefcount(m), oldrefcount)
540
541 class BaseMemorySliceSliceTests:
542 source_bytes = b"XabcdefY"
543
544 def _view(self, obj):
545 m = memoryview(obj)
546 return m[:7][1:]
547
548 def _check_contents(self, tp, obj, contents):
549 self.assertEqual(obj[1:7], tp(contents))
550
551
552 # Concrete test classes
553
554 class BytesMemoryviewTest(unittest.TestCase,
555 BaseMemoryviewTests, BaseBytesMemoryTests):
556
557 def test_constructor(self):
558 for tp in self._types:
559 ob = tp(self._source)
560 self.assertTrue(memoryview(ob))
561 self.assertTrue(memoryview(object=ob))
562 self.assertRaises(TypeError, memoryview)
563 self.assertRaises(TypeError, memoryview, ob, ob)
564 self.assertRaises(TypeError, memoryview, argument=ob)
565 self.assertRaises(TypeError, memoryview, ob, argument=True)
566
567 class ArrayMemoryviewTest(unittest.TestCase,
568 BaseMemoryviewTests, BaseArrayMemoryTests):
569
570 def test_array_assign(self):
571 # Issue #4569: segfault when mutating a memoryview with itemsize != 1
572 a = array.array('i', range(10))
573 m = memoryview(a)
574 new_a = array.array('i', range(9, -1, -1))
575 m[:] = new_a
576 self.assertEqual(a, new_a)
577
578 def test_boolean_format(self):
579 # Test '?' format (keep all the checks below for UBSan)
580 # See github.com/python/cpython/issues/148390.
581
582 # m1a and m1b are equivalent to [False, True, False]
583 m1a = memoryview(b'\0\2\0').cast('?')
584 self.assertEqual(m1a.tolist(), [False, True, False])
585 m1b = memoryview(b'\0\4\0').cast('?')
586 self.assertEqual(m1b.tolist(), [False, True, False])
587 self.assertEqual(m1a, m1b)
588
589 # m2a and m2b are equivalent to [True, True, True]
590 m2a = memoryview(b'\1\3\5').cast('?')
591 self.assertEqual(m2a.tolist(), [True, True, True])
592 m2b = memoryview(b'\2\4\6').cast('?')
593 self.assertEqual(m2b.tolist(), [True, True, True])
594 self.assertEqual(m2a, m2b)
595
596 allbytes = bytes(range(256))
597 allbytes = memoryview(allbytes).cast('?')
598 self.assertEqual(allbytes.tolist(), [False] + [True] * 255)
599
600
601 class BytesMemorySliceTest(unittest.TestCase,
602 BaseMemorySliceTests, BaseBytesMemoryTests):
603 pass
604
605 class ArrayMemorySliceTest(unittest.TestCase,
606 BaseMemorySliceTests, BaseArrayMemoryTests):
607 pass
608
609 class BytesMemorySliceSliceTest(unittest.TestCase,
610 BaseMemorySliceSliceTests, BaseBytesMemoryTests):
611 pass
612
613 class ArrayMemorySliceSliceTest(unittest.TestCase,
614 BaseMemorySliceSliceTests, BaseArrayMemoryTests):
615 pass
616
617
618 class OtherTest(unittest.TestCase):
619 def test_ctypes_cast(self):
620 # Issue 15944: Allow all source formats when casting to bytes.
621 ctypes = import_helper.import_module("ctypes")
622 p6 = bytes(ctypes.c_double(0.6))
623
624 d = ctypes.c_double()
625 m = memoryview(d).cast("B")
626 m[:2] = p6[:2]
627 m[2:] = p6[2:]
628 self.assertEqual(d.value, 0.6)
629
630 for format in "Bbc":
631 with self.subTest(format):
632 d = ctypes.c_double()
633 m = memoryview(d).cast(format)
634 m[:2] = memoryview(p6).cast(format)[:2]
635 m[2:] = memoryview(p6).cast(format)[2:]
636 self.assertEqual(d.value, 0.6)
637
638 def test_half_float(self):
639 half_data = struct.pack('eee', 0.0, -1.5, 1.5)
640 float_data = struct.pack('fff', 0.0, -1.5, 1.5)
641 half_view = memoryview(half_data).cast('e')
642 float_view = memoryview(float_data).cast('f')
643 self.assertEqual(half_view.nbytes * 2, float_view.nbytes)
644 self.assertListEqual(half_view.tolist(), float_view.tolist())
645
646 def test_memoryview_hex(self):
647 # Issue #9951: memoryview.hex() segfaults with non-contiguous buffers.
648 x = b'0' * 200000
649 m1 = memoryview(x)
650 m2 = m1[::-1]
651 self.assertEqual(m2.hex(), '30' * 200000)
652
653 def test_memoryview_hex_separator(self):
654 x = bytes(range(97, 102))
655 m1 = memoryview(x)
656 m2 = m1[::-1]
657 self.assertEqual(m2.hex(':'), '65:64:63:62:61')
658 self.assertEqual(m2.hex(':', 2), '65:6463:6261')
659 self.assertEqual(m2.hex(':', -2), '6564:6362:61')
660 self.assertEqual(m2.hex(sep=':', bytes_per_sep=2), '65:6463:6261')
661 self.assertEqual(m2.hex(sep=':', bytes_per_sep=-2), '6564:6362:61')
662 for bytes_per_sep in 5, -5, 2**31-1, -(2**31-1):
663 with self.subTest(bytes_per_sep=bytes_per_sep):
664 self.assertEqual(m2.hex(':', bytes_per_sep), '6564636261')
665 for bytes_per_sep in 2**31, -2**31, 2**1000, -2**1000:
666 with self.subTest(bytes_per_sep=bytes_per_sep):
667 try:
668 self.assertEqual(m2.hex(':', bytes_per_sep), '6564636261')
669 except OverflowError:
670 pass
671
672 def test_copy(self):
673 m = memoryview(b'abc')
674 with self.assertRaises(TypeError):
675 copy.copy(m)
676
677 def test_pickle(self):
678 m = memoryview(b'abc')
679 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
680 with self.assertRaises(TypeError):
681 pickle.dumps(m, proto)
682
683 def test_use_released_memory(self):
684 # gh-92888: Previously it was possible to use a memoryview even after
685 # backing buffer is freed in certain cases. This tests that those
686 # cases raise an exception.
687 size = 128
688 def release():
689 m.release()
690 nonlocal ba
691 ba = bytearray(size)
692 class MyIndex:
693 def __index__(self):
694 release()
695 return 4
696 class MyFloat:
697 def __float__(self):
698 release()
699 return 4.25
700 class MyBool:
701 def __bool__(self):
702 release()
703 return True
704
705 ba = None
706 m = memoryview(bytearray(b'\xff'*size))
707 with self.assertRaises(ValueError):
708 m[MyIndex()]
709
710 ba = None
711 m = memoryview(bytearray(b'\xff'*size))
712 self.assertEqual(list(m[:MyIndex()]), [255] * 4)
713
714 ba = None
715 m = memoryview(bytearray(b'\xff'*size))
716 self.assertEqual(list(m[MyIndex():8]), [255] * 4)
717
718 ba = None
719 m = memoryview(bytearray(b'\xff'*size)).cast('B', (64, 2))
720 with self.assertRaisesRegex(ValueError, "operation forbidden"):
721 m[MyIndex(), 0]
722
723 ba = None
724 m = memoryview(bytearray(b'\xff'*size)).cast('B', (2, 64))
725 with self.assertRaisesRegex(ValueError, "operation forbidden"):
726 m[0, MyIndex()]
727
728 ba = None
729 m = memoryview(bytearray(b'\xff'*size))
730 with self.assertRaisesRegex(ValueError, "operation forbidden"):
731 m[MyIndex()] = 42
732 self.assertEqual(ba[:8], b'\0'*8)
733
734 ba = None
735 m = memoryview(bytearray(b'\xff'*size))
736 with self.assertRaisesRegex(ValueError, "operation forbidden"):
737 m[:MyIndex()] = b'spam'
738 self.assertEqual(ba[:8], b'\0'*8)
739
740 ba = None
741 m = memoryview(bytearray(b'\xff'*size))
742 with self.assertRaisesRegex(ValueError, "operation forbidden"):
743 m[MyIndex():8] = b'spam'
744 self.assertEqual(ba[:8], b'\0'*8)
745
746 ba = None
747 m = memoryview(bytearray(b'\xff'*size)).cast('B', (64, 2))
748 with self.assertRaisesRegex(ValueError, "operation forbidden"):
749 m[MyIndex(), 0] = 42
750 self.assertEqual(ba[8:16], b'\0'*8)
751 ba = None
752 m = memoryview(bytearray(b'\xff'*size)).cast('B', (2, 64))
753 with self.assertRaisesRegex(ValueError, "operation forbidden"):
754 m[0, MyIndex()] = 42
755 self.assertEqual(ba[:8], b'\0'*8)
756
757 ba = None
758 m = memoryview(bytearray(b'\xff'*size))
759 with self.assertRaisesRegex(ValueError, "operation forbidden"):
760 m[0] = MyIndex()
761 self.assertEqual(ba[:8], b'\0'*8)
762
763 for fmt in 'bhilqnBHILQN':
764 with self.subTest(fmt=fmt):
765 ba = None
766 m = memoryview(bytearray(b'\xff'*size)).cast(fmt)
767 with self.assertRaisesRegex(ValueError, "operation forbidden"):
768 m[0] = MyIndex()
769 self.assertEqual(ba[:8], b'\0'*8)
770
771 for fmt in 'fd':
772 with self.subTest(fmt=fmt):
773 ba = None
774 m = memoryview(bytearray(b'\xff'*size)).cast(fmt)
775 with self.assertRaisesRegex(ValueError, "operation forbidden"):
776 m[0] = MyFloat()
777 self.assertEqual(ba[:8], b'\0'*8)
778
779 ba = None
780 m = memoryview(bytearray(b'\xff'*size)).cast('?')
781 with self.assertRaisesRegex(ValueError, "operation forbidden"):
782 m[0] = MyBool()
783 self.assertEqual(ba[:8], b'\0'*8)
784
785 def test_buffer_reference_loop(self):
786 m = memoryview(b'abc').__buffer__(0)
787 o = MyObject()
788 o.m = m
789 o.o = o
790 wr = weakref.ref(o)
791 del m, o
792 gc.collect()
793 self.assertIsNone(wr())
794
795 def test_picklebuffer_reference_loop(self):
796 pb = pickle.PickleBuffer(memoryview(b'abc'))
797 o = MyObject()
798 o.pb = pb
799 o.o = o
800 wr = weakref.ref(o)
801 del pb, o
802 gc.collect()
803 self.assertIsNone(wr())
804
805
806 @threading_helper.requires_working_threading()
807 @support.requires_resource("cpu")
808 class RacingTest(unittest.TestCase):
809 def test_racing_getbuf_and_releasebuf(self):
810 """Repeatly access the memoryview for racing."""
811 try:
812 from multiprocessing.managers import SharedMemoryManager
813 except ImportError:
814 self.skipTest("Test requires multiprocessing")
815 from threading import Thread, Event
816
817 start = Event()
818 with SharedMemoryManager() as smm:
819 obj = smm.ShareableList(range(100))
820 def test():
821 # Issue gh-127085, the `ShareableList.count` is just a
822 # convenient way to mess the `exports` counter of `memoryview`,
823 # this issue has no direct relation with `ShareableList`.
824 start.wait(support.SHORT_TIMEOUT)
825 for i in range(10):
826 obj.count(1)
827 threads = [Thread(target=test) for _ in range(10)]
828 with threading_helper.start_threads(threads):
829 start.set()
830
831 del obj
832
833
834 if __name__ == "__main__":
835 unittest.main()