Lines Matching refs:self

24     def _source(self):
25 return self.source_bytes
28 def _types(self):
29 return filter(None, [self.ro_type, self.rw_type])
31 def check_getitem_with_type(self, tp):
32 b = tp(self._source)
34 m = self._view(b)
35 self.assertEqual(m[0], ord(b"a"))
36 self.assertIsInstance(m[0], int)
37 self.assertEqual(m[5], ord(b"f"))
38 self.assertEqual(m[-1], ord(b"f"))
39 self.assertEqual(m[-6], ord(b"a"))
41 self.assertRaises(IndexError, lambda: m[6])
42 self.assertRaises(IndexError, lambda: m[-7])
43 self.assertRaises(IndexError, lambda: m[sys.maxsize])
44 self.assertRaises(IndexError, lambda: m[-sys.maxsize])
46 self.assertRaises(TypeError, lambda: m[None])
47 self.assertRaises(TypeError, lambda: m[0.0])
48 self.assertRaises(TypeError, lambda: m["a"])
50 self.assertEqual(sys.getrefcount(b), oldrefcount)
52 def test_getitem(self):
53 for tp in self._types:
54 self.check_getitem_with_type(tp)
56 def test_iter(self):
57 for tp in self._types:
58 b = tp(self._source)
59 m = self._view(b)
60 self.assertEqual(list(m), [m[i] for i in range(len(m))])
62 def test_setitem_readonly(self):
63 if not self.ro_type:
64 self.skipTest("no read-only type to test")
65 b = self.ro_type(self._source)
67 m = self._view(b)
70 self.assertRaises(TypeError, setitem, b"a")
71 self.assertRaises(TypeError, setitem, 65)
72 self.assertRaises(TypeError, setitem, memoryview(b"a"))
74 self.assertEqual(sys.getrefcount(b), oldrefcount)
76 def test_setitem_writable(self):
77 if not self.rw_type:
78 self.skipTest("no writable type to test")
79 tp = self.rw_type
80 b = self.rw_type(self._source)
82 m = self._view(b)
84 self._check_contents(tp, b, b"1bcdef")
86 self._check_contents(tp, b, b"0bcdef")
88 self._check_contents(tp, b, b"012def")
90 self._check_contents(tp, b, b"012def")
92 self._check_contents(tp, b, b"abcdef")
96 self._check_contents(tp, b, b"cdedef")
99 self._check_contents(tp, b, b"ababcf")
104 self.assertRaises(IndexError, setitem, 6, b"a")
105 self.assertRaises(IndexError, setitem, -7, b"a")
106 self.assertRaises(IndexError, setitem, sys.maxsize, b"a")
107 self.assertRaises(IndexError, setitem, -sys.maxsize, b"a")
109 self.assertRaises(TypeError, setitem, 0.0, b"a")
110 self.assertRaises(TypeError, setitem, (0,), b"a")
111 self.assertRaises(TypeError, setitem, (slice(0,1,1), 0), b"a")
112 self.assertRaises(TypeError, setitem, (0, slice(0,1,1)), b"a")
113 self.assertRaises(TypeError, setitem, (0,), b"a")
114 self.assertRaises(TypeError, setitem, "a", b"a")
117 self.assertRaises(NotImplementedError, setitem, slices, b"a")
120 self.assertRaises(exc, setitem, 0, b"")
121 self.assertRaises(exc, setitem, 0, b"ab")
122 self.assertRaises(ValueError, setitem, slice(1,1), b"a")
123 self.assertRaises(ValueError, setitem, slice(0,2), b"a")
126 self.assertEqual(sys.getrefcount(b), oldrefcount)
128 def test_delitem(self):
129 for tp in self._types:
130 b = tp(self._source)
131 m = self._view(b)
132 with self.assertRaises(TypeError):
134 with self.assertRaises(TypeError):
137 def test_tobytes(self):
138 for tp in self._types:
139 m = self._view(tp(self._source))
141 # This calls self.getitem_type() on each separate byte of b"abcdef"
143 self.getitem_type(bytes([c])) for c in b"abcdef")
144 self.assertEqual(b, expected)
145 self.assertIsInstance(b, bytes)
147 def test_tolist(self):
148 for tp in self._types:
149 m = self._view(tp(self._source))
151 self.assertEqual(l, list(b"abcdef"))
153 def test_compare(self):
156 for tp in self._types:
157 m = self._view(tp(self._source))
158 for tp_comp in self._types:
159 self.assertTrue(m == tp_comp(b"abcdef"))
160 self.assertFalse(m != tp_comp(b"abcdef"))
161 self.assertFalse(m == tp_comp(b"abcde"))
162 self.assertTrue(m != tp_comp(b"abcde"))
163 self.assertFalse(m == tp_comp(b"abcde1"))
164 self.assertTrue(m != tp_comp(b"abcde1"))
165 self.assertTrue(m == m)
166 self.assertTrue(m == m[:])
167 self.assertTrue(m[0:6] == m[:])
168 self.assertFalse(m[0:5] == m)
171 self.assertFalse(m == "abcdef")
172 self.assertTrue(m != "abcdef")
173 self.assertFalse("abcdef" == m)
174 self.assertTrue("abcdef" != m)
178 self.assertRaises(TypeError, lambda: m < c)
179 self.assertRaises(TypeError, lambda: c <= m)
180 self.assertRaises(TypeError, lambda: m >= c)
181 self.assertRaises(TypeError, lambda: c > m)
183 def check_attributes_with_type(self, tp):
184 m = self._view(tp(self._source))
185 self.assertEqual(m.format, self.format)
186 self.assertEqual(m.itemsize, self.itemsize)
187 self.assertEqual(m.ndim, 1)
188 self.assertEqual(m.shape, (6,))
189 self.assertEqual(len(m), 6)
190 self.assertEqual(m.strides, (self.itemsize,))
191 self.assertEqual(m.suboffsets, ())
194 def test_attributes_readonly(self):
195 if not self.ro_type:
196 self.skipTest("no read-only type to test")
197 m = self.check_attributes_with_type(self.ro_type)
198 self.assertEqual(m.readonly, True)
200 def test_attributes_writable(self):
201 if not self.rw_type:
202 self.skipTest("no writable type to test")
203 m = self.check_attributes_with_type(self.rw_type)
204 self.assertEqual(m.readonly, False)
206 def test_getbuffer(self):
208 for tp in self._types:
209 b = tp(self._source)
211 m = self._view(b)
214 self._check_contents(tp, b, s.encode("utf-8"))
215 self.assertEqual(sys.getrefcount(m), oldviewrefcount)
217 self.assertEqual(sys.getrefcount(b), oldrefcount)
219 def test_gc(self):
220 for tp in self._types:
226 def __init__(self, base):
227 self.m = memoryview(base)
236 m = self._view(b)
244 self.assertTrue(wr() is None, wr())
255 self.assertTrue(wr() is None, wr())
257 def _check_released(self, m, tp):
258 check = self.assertRaisesRegex(ValueError, "released")
275 self.assertIn("released memory", str(m))
276 self.assertIn("released memory", repr(m))
277 self.assertEqual(m, m)
278 self.assertNotEqual(m, memoryview(tp(self._source)))
279 self.assertNotEqual(m, tp(self._source))
281 def test_contextmanager(self):
282 for tp in self._types:
283 b = tp(self._source)
284 m = self._view(b)
286 self.assertIs(cm, m)
287 self._check_released(m, tp)
288 m = self._view(b)
293 def test_release(self):
294 for tp in self._types:
295 b = tp(self._source)
296 m = self._view(b)
298 self._check_released(m, tp)
301 self._check_released(m, tp)
303 def test_writable_readonly(self):
306 tp = self.ro_type
308 self.skipTest("no read-only type to test")
309 b = tp(self._source)
310 m = self._view(b)
312 self.assertRaises(TypeError, i.readinto, m)
314 def test_getbuf_fail(self):
315 self.assertRaises(TypeError, self._view, {})
317 def test_hash(self):
320 tp = self.ro_type
322 self.skipTest("no read-only type to test")
323 b = tp(self._source)
324 m = self._view(b)
325 self.assertEqual(hash(m), hash(b"abcdef"))
328 self.assertEqual(hash(m), hash(b"abcdef"))
331 m = self._view(b)
333 self.assertRaises(ValueError, hash, m)
335 def test_hash_writable(self):
337 tp = self.rw_type
339 self.skipTest("no writable type to test")
340 b = tp(self._source)
341 m = self._view(b)
342 self.assertRaises(ValueError, hash, m)
344 def test_weakref(self):
346 for tp in self._types:
347 b = tp(self._source)
348 m = self._view(b)
353 self.assertIs(wr(), m)
356 self.assertIs(wr(), None)
357 self.assertIs(L[0], b)
359 def test_reversed(self):
360 for tp in self._types:
361 b = tp(self._source)
362 m = self._view(b)
364 self.assertEqual(list(reversed(m)), aslist)
365 self.assertEqual(list(reversed(m)), list(m[::-1]))
367 def test_toreadonly(self):
368 for tp in self._types:
369 b = tp(self._source)
370 m = self._view(b)
372 self.assertTrue(mm.readonly)
373 self.assertTrue(memoryview(mm).readonly)
374 self.assertEqual(mm.tolist(), m.tolist())
378 def test_issue22668(self):
388 self.assertEqual(c[0], 256)
389 self.assertEqual(d[0], 256)
390 self.assertEqual(c.format, "H")
391 self.assertEqual(d.format, "H")
394 self.assertEqual(c[0], 256)
395 self.assertEqual(d[0], 256)
396 self.assertEqual(c.format, "H")
397 self.assertEqual(d.format, "H")
413 rw_type = lambda self, b: array.array('i', list(b))
414 getitem_type = lambda self, b: array.array('i', list(b)).tobytes()
419 def test_getbuffer(self):
423 def test_tolist(self):
432 def _view(self, obj):
435 def _check_contents(self, tp, obj, contents):
436 self.assertEqual(obj, tp(contents))
441 def _view(self, obj):
445 def _check_contents(self, tp, obj, contents):
446 self.assertEqual(obj[1:7], tp(contents))
448 def test_refs(self):
449 for tp in self._types:
450 m = memoryview(tp(self._source))
453 self.assertEqual(sys.getrefcount(m), oldrefcount)
458 def _view(self, obj):
462 def _check_contents(self, tp, obj, contents):
463 self.assertEqual(obj[1:7], tp(contents))
471 def test_constructor(self):
472 for tp in self._types:
473 ob = tp(self._source)
474 self.assertTrue(memoryview(ob))
475 self.assertTrue(memoryview(object=ob))
476 self.assertRaises(TypeError, memoryview)
477 self.assertRaises(TypeError, memoryview, ob, ob)
478 self.assertRaises(TypeError, memoryview, argument=ob)
479 self.assertRaises(TypeError, memoryview, ob, argument=True)
484 def test_array_assign(self):
490 self.assertEqual(a, new_a)
511 def test_ctypes_cast(self):
520 self.assertEqual(d.value, 0.6)
523 with self.subTest(format):
528 self.assertEqual(d.value, 0.6)
530 def test_memoryview_hex(self):
535 self.assertEqual(m2.hex(), '30' * 200000)
537 def test_copy(self):
539 with self.assertRaises(TypeError):
542 def test_pickle(self):
545 with self.assertRaises(TypeError):
548 def test_use_released_memory(self):
558 def __index__(self):
562 def __float__(self):
566 def __bool__(self):
572 with self.assertRaises(ValueError):
577 self.assertEqual(list(m[:MyIndex()]), [255] * 4)
581 self.assertEqual(list(m[MyIndex():8]), [255] * 4)
585 with self.assertRaisesRegex(ValueError, "operation forbidden"):
590 with self.assertRaisesRegex(ValueError, "operation forbidden"):
595 with self.assertRaisesRegex(ValueError, "operation forbidden"):
597 self.assertEqual(ba[:8], b'\0'*8)
601 with self.assertRaisesRegex(ValueError, "operation forbidden"):
603 self.assertEqual(ba[:8], b'\0'*8)
607 with self.assertRaisesRegex(ValueError, "operation forbidden"):
609 self.assertEqual(ba[:8], b'\0'*8)
613 with self.assertRaisesRegex(ValueError, "operation forbidden"):
615 self.assertEqual(ba[8:16], b'\0'*8)
618 with self.assertRaisesRegex(ValueError, "operation forbidden"):
620 self.assertEqual(ba[:8], b'\0'*8)
624 with self.assertRaisesRegex(ValueError, "operation forbidden"):
626 self.assertEqual(ba[:8], b'\0'*8)
629 with self.subTest(fmt=fmt):
632 with self.assertRaisesRegex(ValueError, "operation forbidden"):
634 self.assertEqual(ba[:8], b'\0'*8)
637 with self.subTest(fmt=fmt):
640 with self.assertRaisesRegex(ValueError, "operation forbidden"):
642 self.assertEqual(ba[:8], b'\0'*8)
646 with self.assertRaisesRegex(ValueError, "operation forbidden"):
648 self.assertEqual(ba[:8], b'\0'*8)