Lines Matching refs:self
768 def setUp(self):
770 self.sizeof_void_p = get_sizeof_void_p()
772 def verify(self, result, *, obj,
789 self.assertGreater(ndim, 0)
801 stride0 = self.sizeof_void_p
806 self.assertIs(result.obj, obj)
807 self.assertEqual(result.nbytes, expected_len)
808 self.assertEqual(result.itemsize, itemsize)
809 self.assertEqual(result.format, fmt)
810 self.assertIs(result.readonly, readonly)
811 self.assertEqual(result.ndim, ndim)
812 self.assertEqual(result.shape, tuple(shape))
814 self.assertEqual(result.strides, tuple(strides))
815 self.assertEqual(result.suboffsets, tuple(suboffsets))
819 self.assertEqual(rep, lst)
845 self.assertEqual(item1, item2)
849 self.assertEqual(result.tobytes(), b)
854 self.assertEqual(m.hex(), h)
881 self.assertEqual(contig.tobytes(), b)
882 self.assertTrue(cmp_contig(contig, expected))
895 self.assertEqual(len(contig), nmemb * itemsize)
902 self.assertEqual(memoryview(y), memoryview(result))
905 self.assertEqual(contig_bytes, contig)
908 self.assertEqual(contig_bytes, contig)
911 self.assertEqual(contig_bytes, contig)
915 self.assertEqual(len(contig), nmemb * itemsize)
923 self.assertEqual(memoryview(y), memoryview(result))
926 self.assertEqual(contig_bytes, contig)
930 self.assertEqual(len(contig), nmemb * itemsize)
938 self.assertEqual(memoryview(y), memoryview(result))
941 self.assertEqual(contig_bytes, contig)
951 self.assertIs(m.obj, ex)
952 self.assertEqual(m.nbytes, expected_len)
953 self.assertEqual(m.itemsize, itemsize)
954 self.assertEqual(m.format, fmt)
955 self.assertEqual(m.readonly, expected_readonly)
956 self.assertEqual(m.ndim, ndim)
957 self.assertEqual(m.shape, tuple(shape))
959 self.assertEqual(m.strides, tuple(strides))
960 self.assertEqual(m.suboffsets, tuple(suboffsets))
963 self.assertEqual(len(m), n)
966 self.assertEqual(rep, lst)
967 self.assertEqual(m, result)
974 def verify_getbuf(self, orig_ex, ex, req, sliced=False):
991 self.assertRaises(BufferError, ndarray, ex, getbuf=req)
1017 self.verify(nd, obj=ex,
1022 def test_ndarray_getbuf(self):
1083 self.assertEqual(m1, ex1)
1085 self.assertEqual(m2, ex2)
1089 self.verify_getbuf(ex1, ex1, req|bits)
1090 self.verify_getbuf(ex1, m1, req|bits)
1092 self.verify_getbuf(ex2, ex2, req|bits,
1094 self.verify_getbuf(ex2, m2, req|bits,
1101 self.assertRaises(BufferError, ndarray, ex)
1107 self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_WRITABLE)
1108 self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_ND)
1109 self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_STRIDES)
1110 self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_C_CONTIGUOUS)
1111 self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_F_CONTIGUOUS)
1112 self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_ANY_CONTIGUOUS)
1119 self.assertTrue(is_contiguous(ex, 'F'))
1120 self.assertTrue(is_contiguous(ex, 'C'))
1124 self.assertTrue(is_contiguous(nd, 'F'))
1125 self.assertTrue(is_contiguous(nd, 'C'))
1127 def test_ndarray_exceptions(self):
1134 self.assertRaises(TypeError, c, {1,2,3})
1135 self.assertRaises(TypeError, c, [1,2,'3'])
1136 self.assertRaises(TypeError, c, [1,2,(3,4)])
1137 self.assertRaises(TypeError, c, [1,2,3], shape={3})
1138 self.assertRaises(TypeError, c, [1,2,3], shape=[3], strides={1})
1139 self.assertRaises(TypeError, c, [1,2,3], shape=[3], offset=[])
1140 self.assertRaises(TypeError, c, [1], shape=[1], format={})
1141 self.assertRaises(TypeError, c, [1], shape=[1], flags={})
1142 self.assertRaises(TypeError, c, [1], shape=[1], getbuf={})
1145 self.assertRaises(TypeError, c, [1], shape=[1], strides=[1],
1149 self.assertRaises(TypeError, c, [1], shape=[], flags=ND_PIL)
1152 self.assertRaises(ValueError, c, [], shape=[1])
1153 self.assertRaises(ValueError, c, ['XXX'], shape=[1], format="L")
1155 self.assertRaises(struct.error, c, [1000], shape=[1], format="B")
1156 self.assertRaises(ValueError, c, [1,(2,3)], shape=[2], format="B")
1157 self.assertRaises(ValueError, c, [1,2,3], shape=[3], format="QL")
1161 self.assertRaises(ValueError, c, [1]*n, shape=[1]*n)
1164 self.assertRaises(ValueError, c, [1], shape=[-1])
1165 self.assertRaises(ValueError, c, [1,2,3], shape=['3'])
1166 self.assertRaises(OverflowError, c, [1], shape=[2**128])
1168 self.assertRaises(ValueError, c, [1,2,3,4,5], shape=[2,2], offset=3)
1171 self.assertRaises(ValueError, c, [1,2,3], shape=[3], strides=['1'])
1172 self.assertRaises(OverflowError, c, [1], shape=[1],
1176 self.assertRaises(ValueError, c, [1,2], shape=[2,1], strides=[1])
1178 self.assertRaises(ValueError, c, [1,2,3,4], shape=[2], strides=[3],
1182 self.assertRaises(ValueError, c, [1,2,3], shape=[3], offset=4)
1183 self.assertRaises(ValueError, c, [1,2,3], shape=[1], offset=3,
1187 self.assertRaises(ValueError, c, [1,2,3], shape=[3], format="")
1188 self.assertRaises(struct.error, c, [(1,2,3)], shape=[1],
1193 self.assertRaises(ValueError, c, items, shape=[2,3],
1197 self.assertRaises(TypeError, c, bytearray(), format="Q")
1200 self.assertRaises(TypeError, c, [1], shape=[1], getbuf=PyBUF_FULL)
1203 self.assertRaises(TypeError, c, [1])
1207 self.assertRaises(BufferError, ndarray, b'123', getbuf=PyBUF_WRITABLE)
1211 self.assertRaises(ValueError, nd.push, [1], [1], flags=ND_VAREXPORT)
1215 self.assertRaises(BufferError, nd.push, [1], [1])
1216 self.assertRaises(BufferError, nd.pop)
1222 self.assertRaises(BufferError, nd.push, [1], [1])
1223 self.assertRaises(BufferError, nd.pop)
1228 self.assertRaises(BufferError, nd.pop)
1232 self.assertRaises(TypeError, get_pointer, {}, [1,2,3])
1233 self.assertRaises(TypeError, get_pointer, b'123', {})
1236 self.assertRaises(ValueError, get_pointer, nd, [5])
1239 self.assertRaises(ValueError, get_pointer, nd, [2,3,4])
1240 self.assertRaises(ValueError, get_pointer, nd, [3,3])
1241 self.assertRaises(ValueError, get_pointer, nd, [-3,3])
1242 self.assertRaises(OverflowError, get_pointer, nd, [1<<64,3])
1247 self.assertRaises(ValueError, nd.tolist)
1253 self.assertRaises(TypeError, nd.memoryview_from_buffer)
1256 self.assertRaises(TypeError, nd.memoryview_from_buffer)
1260 self.assertRaises(ValueError, nd.memoryview_from_buffer)
1264 self.assertRaises(TypeError, get_contiguous, 1, 2, 3, 4, 5)
1265 self.assertRaises(TypeError, get_contiguous, nd, "xyz", 'C')
1266 self.assertRaises(OverflowError, get_contiguous, nd, 2**64, 'C')
1267 self.assertRaises(TypeError, get_contiguous, nd, PyBUF_READ, 961)
1268 self.assertRaises(UnicodeEncodeError, get_contiguous, nd, PyBUF_READ,
1270 self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'Z')
1271 self.assertRaises(ValueError, get_contiguous, nd, 255, 'A')
1275 self.assertRaises(TypeError, cmp_contig, 1, 2, 3, 4, 5)
1276 self.assertRaises(TypeError, cmp_contig, {}, nd)
1277 self.assertRaises(TypeError, cmp_contig, nd, {})
1281 self.assertRaises(TypeError, is_contiguous, 1, 2, 3, 4, 5)
1282 self.assertRaises(TypeError, is_contiguous, {}, 'A')
1283 self.assertRaises(TypeError, is_contiguous, nd, 201)
1285 def test_ndarray_linked_list(self):
1298 self.assertRaises(BufferError, nd.pop)
1301 def test_ndarray_format_scalar(self):
1306 self.verify(nd, obj=None,
1311 def test_ndarray_format_shape(self):
1318 self.verify(nd, obj=None,
1323 def test_ndarray_format_strides(self):
1339 self.verify(nd, obj=None,
1344 def test_ndarray_fortran(self):
1348 self.assertEqual(nd.tolist(), farray(items, (3, 4)))
1350 def test_ndarray_multidim(self):
1368 self.verify(nd, obj=None,
1377 self.assertTrue(nd.strides == ())
1379 self.verify(mv, obj=None,
1390 self.verify(nd, obj=None,
1395 def test_ndarray_index_invalid(self):
1398 self.assertRaises(TypeError, nd.__setitem__, 1, 8)
1400 self.assertEqual(mv, nd)
1401 self.assertRaises(TypeError, mv.__setitem__, 1, 8)
1405 self.assertRaises(TypeError, nd.__delitem__, 1)
1407 self.assertEqual(mv, nd)
1408 self.assertRaises(TypeError, mv.__delitem__, 1)
1412 self.assertRaises(OverflowError, nd.__getitem__, 1<<64)
1413 self.assertRaises(OverflowError, nd.__setitem__, 1<<64, 8)
1415 self.assertEqual(mv, nd)
1416 self.assertRaises(IndexError, mv.__getitem__, 1<<64)
1417 self.assertRaises(IndexError, mv.__setitem__, 1<<64, 8)
1422 self.assertRaises(struct.error, nd.__setitem__, 2, 300)
1423 self.assertRaises(ValueError, nd.__setitem__, 1, (100, 200))
1425 self.assertEqual(mv, nd)
1426 self.assertRaises(ValueError, mv.__setitem__, 2, 300)
1427 self.assertRaises(TypeError, mv.__setitem__, 1, (100, 200))
1431 self.assertRaises(ValueError, nd.__setitem__, 2, 300)
1432 self.assertRaises(struct.error, nd.__setitem__, 1, (b'\x001', 200))
1434 def test_ndarray_index_scalar(self):
1438 self.assertEqual(mv, nd)
1440 x = nd[()]; self.assertEqual(x, 1)
1441 x = nd[...]; self.assertEqual(x.tolist(), nd.tolist())
1443 x = mv[()]; self.assertEqual(x, 1)
1444 x = mv[...]; self.assertEqual(x.tolist(), nd.tolist())
1446 self.assertRaises(TypeError, nd.__getitem__, 0)
1447 self.assertRaises(TypeError, mv.__getitem__, 0)
1448 self.assertRaises(TypeError, nd.__setitem__, 0, 8)
1449 self.assertRaises(TypeError, mv.__setitem__, 0, 8)
1451 self.assertEqual(nd.tolist(), 1)
1452 self.assertEqual(mv.tolist(), 1)
1454 nd[()] = 9; self.assertEqual(nd.tolist(), 9)
1455 mv[()] = 9; self.assertEqual(mv.tolist(), 9)
1457 nd[...] = 5; self.assertEqual(nd.tolist(), 5)
1458 mv[...] = 5; self.assertEqual(mv.tolist(), 5)
1460 def test_ndarray_index_null_strides(self):
1465 self.assertRaises(BufferError, nd.__getitem__, 1)
1467 self.assertRaises(BufferError, nd.__getitem__, slice(3,5,1))
1469 def test_ndarray_index_getitem_single(self):
1474 self.assertEqual(nd[i], items[i])
1476 self.assertRaises(IndexError, nd.__getitem__, -6)
1477 self.assertRaises(IndexError, nd.__getitem__, 5)
1481 self.assertEqual(mv, nd)
1483 self.assertEqual(mv[i], items[i])
1485 self.assertRaises(IndexError, mv.__getitem__, -6)
1486 self.assertRaises(IndexError, mv.__getitem__, 5)
1494 self.assertEqual(nd[i], items[i])
1498 self.assertIs(mv.__eq__(nd), NotImplemented)
1500 self.assertEqual(mv[i], items[i])
1507 self.assertEqual(nd[i], items[i])
1515 self.assertEqual(nd[i], items[i])
1517 def test_ndarray_index_setitem_single(self):
1524 self.assertEqual(nd.tolist(), items)
1526 self.assertRaises(IndexError, nd.__setitem__, -6, single_item)
1527 self.assertRaises(IndexError, nd.__setitem__, 5, single_item)
1534 self.assertEqual(mv, nd)
1538 self.assertEqual(mv.tolist(), items)
1540 self.assertRaises(IndexError, mv.__setitem__, -6, single_item)
1541 self.assertRaises(IndexError, mv.__setitem__, 5, single_item)
1550 self.assertEqual(nd.tolist(), items)
1557 self.assertEqual(mv, nd)
1561 self.assertEqual(mv.tolist(), items)
1563 def test_ndarray_index_getitem_multidim(self):
1576 self.assertEqual(lst[i], nd[i].tolist())
1578 self.assertEqual(lst[i][j], nd[i][j].tolist())
1580 self.assertEqual(lst[i][j][k], nd[i][j][k])
1588 self.assertEqual(lst[i], nd[i].tolist())
1590 self.assertEqual(lst[i][j], nd[i][j].tolist())
1592 self.assertEqual(lst[i][j][k], nd[i][j][k])
1594 def test_ndarray_sequence(self):
1596 self.assertRaises(TypeError, eval, "1 in nd", locals())
1598 self.assertEqual(mv, nd)
1599 self.assertRaises(TypeError, eval, "1 in mv", locals())
1604 self.assertEqual(v, items[i])
1605 self.assertTrue(v in nd)
1610 self.assertEqual(v, items[i])
1611 self.assertTrue(v in mv)
1613 def test_ndarray_slice_invalid(self):
1619 self.assertRaises(TypeError, xl.__setitem__, slice(0,8,1), items)
1620 self.assertRaises(TypeError, ml.__setitem__, slice(0,8,1), items)
1626 self.assertRaises(BufferError, xl.__setitem__, slice(0,8,1), xr)
1631 self.assertRaises(ValueError, nd.__getitem__, slice(0,1,0))
1632 self.assertRaises(ValueError, mv.__getitem__, slice(0,1,0))
1637 self.assertRaises(ValueError, nd.__getitem__,
1639 self.assertRaises(ValueError, nd.__getitem__,
1641 self.assertRaises(TypeError, nd.__getitem__, "@%$")
1642 self.assertRaises(TypeError, nd.__getitem__, ("@%$", slice(0,1,1)))
1643 self.assertRaises(TypeError, nd.__getitem__, (slice(0,1,1), {}))
1646 self.assertRaises(NotImplementedError, mv.__getitem__,
1648 self.assertRaises(TypeError, mv.__getitem__, "@%$")
1655 self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8])
1656 self.assertEqual(xl.tolist(), items)
1657 self.assertRaises(ValueError, ml.__setitem__, slice(0,1,1), mr[7:8])
1658 self.assertEqual(ml.tolist(), items)
1665 self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8])
1666 self.assertEqual(xl.tolist(), items)
1667 self.assertRaises(ValueError, ml.__setitem__, slice(0,1,1), mr[7:8])
1668 self.assertEqual(ml.tolist(), items)
1675 self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8])
1676 self.assertEqual(xl.tolist(), [[1,2,3,4], [5,6,7,8]])
1677 self.assertRaises(NotImplementedError, ml.__setitem__, slice(0,1,1),
1685 self.assertRaises(ValueError, xl.__setitem__, slice(0,2,1), xr[7:8])
1686 self.assertEqual(xl.tolist(), items)
1687 self.assertRaises(ValueError, ml.__setitem__, slice(0,2,1), mr[7:8])
1688 self.assertEqual(ml.tolist(), items)
1691 self.assertRaises(TypeError, slice_indices, slice(0,1,2), {})
1692 self.assertRaises(TypeError, slice_indices, "###########", 1)
1693 self.assertRaises(ValueError, slice_indices, slice(0,1,0), 4)
1696 self.assertRaises(TypeError, x.add_suboffsets)
1700 self.assertRaises(TypeError, x.add_suboffsets)
1702 def test_ndarray_slice_zero_shape(self):
1708 self.assertEqual(x.tolist(), items)
1712 self.assertEqual(ml, x)
1713 self.assertEqual(ml, y)
1715 self.assertEqual(ml.tolist(), items)
1720 self.assertEqual(x.tolist(), carray(items, [3, 4]))
1722 def test_ndarray_slice_multidim(self):
1750 self.assertIs(nderr, listerr)
1752 self.assertEqual(ndsliced.tolist(), sliced)
1754 def test_ndarray_slice_redundant_suboffsets(self):
1785 self.assertIs(nderr, listerr)
1787 self.assertEqual(ndsliced.tolist(), sliced)
1789 def test_ndarray_slice_assign_single(self):
1818 self.assertIs(nderr, ValueError)
1820 self.assertEqual(nd.tolist(), lst)
1821 self.assertIs(nderr, lsterr)
1833 self.assertIs(mverr, ValueError)
1835 self.assertEqual(mv.tolist(), lst)
1836 self.assertEqual(mv, nd)
1837 self.assertIs(mverr, lsterr)
1838 self.verify(mv, obj=ex,
1843 def test_ndarray_slice_assign_multidim(self):
1872 self.assertIs(nderr, listerr)
1874 self.assertEqual(nd.tolist(), result)
1876 def test_ndarray_random(self):
1884 self.assertTrue(verify_structure(*t))
1893 self.assertEqual(mvlist, xlist)
1899 self.assertEqual(xlist, ylist)
1903 self.assertEqual(mv, y)
1905 self.assertEqual(mvlist, ylist)
1912 self.verify(x, obj=None,
1917 def test_ndarray_random_invalid(self):
1925 self.assertFalse(verify_structure(*t))
1933 self.assertTrue(nderr)
1943 self.assertTrue(numpy_err)
1945 def test_ndarray_random_slice_assign(self):
1955 self.assertTrue(verify_structure(*tl))
1956 self.assertTrue(verify_structure(*tr))
1968 self.assertEqual(ml.tolist(), xllist)
1969 self.assertEqual(mr.tolist(), xrlist)
1978 self.assertEqual(xllist, yllist)
1979 self.assertEqual(xrlist, yrlist)
1983 self.assertEqual(ml.tolist(), yllist)
1984 self.assertEqual(mr.tolist(), yrlist)
1997 self.verify(xl, obj=None,
2002 self.verify(xr, obj=None,
2007 def test_ndarray_re_export(self):
2013 self.assertTrue(ex.flags & ND_PIL)
2014 self.assertIs(ex.obj, nd)
2015 self.assertEqual(ex.suboffsets, (0, -1))
2016 self.assertFalse(ex.c_contiguous)
2017 self.assertFalse(ex.f_contiguous)
2018 self.assertFalse(ex.contiguous)
2020 def test_ndarray_zero_shape(self):
2025 self.assertEqual(mv, nd)
2026 self.assertEqual(nd.tolist(), [])
2027 self.assertEqual(mv.tolist(), [])
2030 self.assertEqual(nd.tolist(), [])
2033 self.assertEqual(nd.tolist(), [[], [], []])
2036 self.assertEqual(nd.tolist(),
2039 def test_ndarray_zero_strides(self):
2044 self.assertEqual(mv, nd)
2045 self.assertEqual(nd.tolist(), [1, 1, 1, 1, 1])
2046 self.assertEqual(mv.tolist(), [1, 1, 1, 1, 1])
2048 def test_ndarray_offset(self):
2050 self.assertEqual(nd.offset, 7)
2051 self.assertEqual(nd.tolist(), [7,8,9])
2053 def test_ndarray_memoryview_from_buffer(self):
2057 self.assertEqual(m, nd)
2059 def test_ndarray_get_pointer(self):
2063 self.assertEqual(nd[i], get_pointer(nd, [i]))
2065 def test_ndarray_tolist_null_strides(self):
2069 self.assertEqual(nd.tolist(), ex.tolist())
2072 self.assertEqual(m.tolist(), ex.tolist())
2074 def test_ndarray_cmp_contig(self):
2076 self.assertFalse(cmp_contig(b"123", b"456"))
2080 self.assertFalse(cmp_contig(x, y))
2083 self.assertTrue(cmp_contig(x, b'\x01'))
2084 self.assertTrue(cmp_contig(b'\x01', x))
2086 def test_ndarray_hash(self):
2090 self.assertRaises(ValueError, hash, nd)
2096 self.assertEqual(hash(nd), hash(b))
2100 self.assertEqual(hash(nd), hash(b))
2103 self.assertEqual(hash(nd), hash(b))
2108 self.assertEqual(hash(nd), hash(b))
2112 self.assertEqual(hash(nd), hash(b))
2117 self.assertEqual(hash(nd), hash(b))
2121 self.assertEqual(hash(nd), hash(nd.tobytes()))
2123 def test_py_buffer_to_contiguous(self):
2138 self.assertRaises(TypeError, py_buffer_to_contiguous, {}, 'F',
2146 self.assertEqual(b, nd.tobytes())
2153 self.assertEqual(b, b'')
2160 self.assertEqual(b, b'')
2172 self.assertEqual(b, ndbytes)
2179 self.assertEqual(b, ndbytes)
2187 self.assertEqual(b, ndbytes)
2197 self.assertEqual(b, ndbytes)
2284 self.assertEqual(b, expected)
2289 self.assertEqual(memoryview(y), memoryview(nd))
2292 self.assertEqual(b, na.tostring(order='C'))
2307 self.assertEqual(b, expected)
2312 self.assertEqual(memoryview(y), memoryview(nd))
2315 self.assertEqual(b, na.tostring(order='F'))
2330 self.assertEqual(b, expected)
2336 self.assertEqual(memoryview(y), memoryview(nd))
2339 self.assertEqual(b, na.tostring(order='A'))
2346 self.assertEqual(b, nd.tobytes())
2348 self.assertEqual(memoryview(y), memoryview(nd))
2353 self.assertEqual(b, x.tobytes())
2355 self.assertEqual(memoryview(y), memoryview(nd))
2359 self.assertEqual(b, nd.tobytes())
2361 self.assertEqual(memoryview(y), memoryview(nd))
2363 def test_memoryview_construction(self):
2373 self.assertTrue(m.c_contiguous)
2374 self.assertTrue(m.contiguous)
2380 self.verify(m, obj=ex,
2387 self.verify(m2, obj=ex,
2394 self.assertEqual(nd.strides, ())
2396 self.verify(m, obj=None,
2403 self.assertEqual(nd.format, '')
2404 self.assertEqual(nd.shape, ())
2405 self.assertEqual(nd.strides, ())
2409 self.verify(m, obj=None,
2420 self.assertTrue(m.f_contiguous)
2421 self.assertTrue(m.contiguous)
2427 self.verify(m, obj=ex,
2434 self.verify(m2, obj=ex,
2449 self.verify(m, obj=ex,
2456 self.verify(m2, obj=ex,
2462 self.assertRaises(TypeError, memoryview, b'9', 'x')
2464 self.assertRaises(TypeError, memoryview, {})
2468 self.assertRaises(BufferError, memoryview, nd)
2470 self.assertRaises(BufferError, memoryview, nd)
2474 self.assertRaises(ValueError, memoryview, nd)
2475 self.assertRaises(ValueError, nd.memoryview_from_buffer)
2476 self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'C')
2477 self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'F')
2478 self.assertRaises(ValueError, get_contiguous, nd[::-1], PyBUF_READ, 'C')
2480 def test_memoryview_cast_zero_shape(self):
2488 self.assertTrue(ex.c_contiguous)
2490 self.assertRaises(TypeError, msrc.cast, 'c')
2495 self.assertEqual(m.tobytes(), b'')
2496 self.assertEqual(m.tolist(), [])
2500 def test_memoryview_sizeof(self):
2501 check = self.check_sizeof
2513 def test_memoryview_struct_module(self):
2516 def __init__(self, val):
2517 self.val = val
2518 def __int__(self):
2519 return self.val
2522 def __init__(self, val):
2523 self.val = val
2524 def __index__(self):
2525 return self.val
2544 self.assertEqual(m[0], nd[0])
2564 self.assertIsNot(struct_err, None)
2565 self.assertIsNot(mv_err, None)
2567 self.assertEqual(m[1], nd[1])
2569 def test_memoryview_cast_zero_strides(self):
2574 self.assertFalse(ex.c_contiguous)
2576 self.assertRaises(TypeError, msrc.cast, 'c')
2578 def test_memoryview_cast_invalid(self):
2588 self.assertRaises(TypeError, msrc.cast, dfmt, [32//dsize])
2595 self.assertRaises(ValueError, msrc.cast, dfmt,
2599 self.assertRaises(TypeError, msrc.cast, dfmt,
2607 self.assertRaises(TypeError, msrc.cast, shape=[2,2,size_h], format='d')
2613 self.assertRaises(TypeError, m.cast)
2614 self.assertRaises(TypeError, m.cast, 1, 2, 3)
2617 self.assertRaises(TypeError, m.cast, {})
2620 self.assertRaises(ValueError, m.cast, "X")
2621 self.assertRaises(ValueError, m.cast, "@X")
2622 self.assertRaises(ValueError, m.cast, "@XY")
2625 self.assertRaises(ValueError, m.cast, "=B")
2626 self.assertRaises(ValueError, m.cast, "!L")
2627 self.assertRaises(ValueError, m.cast, "<P")
2628 self.assertRaises(ValueError, m.cast, ">l")
2629 self.assertRaises(ValueError, m.cast, "BI")
2630 self.assertRaises(ValueError, m.cast, "xBI")
2635 self.assertRaises(NotImplementedError, m.__getitem__, 0)
2636 self.assertRaises(NotImplementedError, m.__setitem__, 0, 8)
2637 self.assertRaises(NotImplementedError, m.tolist)
2642 self.assertRaises(TypeError, m.cast, "B", shape={})
2647 self.assertRaises(OverflowError, m.cast, "B", shape=[2**64])
2648 self.assertRaises(ValueError, m.cast, "B", shape=[-1])
2649 self.assertRaises(ValueError, m.cast, "B", shape=[2,3,4,5,6,7,-1])
2650 self.assertRaises(ValueError, m.cast, "B", shape=[2,3,4,5,6,7,0])
2651 self.assertRaises(TypeError, m.cast, "B", shape=[2,3,4,5,6,7,'x'])
2656 self.assertRaises(TypeError, m.cast, "I", shape=[2,3,4,5])
2661 self.assertRaises(ValueError, m.cast, 'I', [1]*128)
2666 self.assertRaises(TypeError, m.cast, "I", shape=[2,3,4,5])
2671 self.assertRaises(TypeError, m.cast, "B", shape=[2,3,4,5])
2679 self.assertRaises(TypeError, m1.cast, 'B',
2681 self.assertRaises(ValueError, m1.cast, 'B',
2683 self.assertRaises(ValueError, m2.cast, 'I',
2686 self.assertRaises(TypeError, m1.cast, 'B',
2688 self.assertRaises(ValueError, m1.cast, 'B',
2690 self.assertRaises(ValueError, m2.cast, 'I',
2693 def test_memoryview_cast(self):
2706 self.verify(m2, obj=ex,
2712 self.assertEqual(m3, ex)
2714 self.verify(m3, obj=ex,
2725 self.verify(m2, obj=ex,
2736 self.verify(m2, obj=ex,
2753 def test_memoryview_cast_1D_ND(self):
2777 self.assertRaises(TypeError, m.cast, tfmt, tshape)
2789 self.verify(m2, obj=ex,
2801 self.verify(m3, obj=ex,
2806 self.verify(m4, obj=ex,
2818 self.assertEqual(m2.obj, point)
2819 self.assertEqual(m2.itemsize, 1)
2820 self.assertIs(m2.readonly, False)
2821 self.assertEqual(m2.ndim, 1)
2822 self.assertEqual(m2.shape, (m2.nbytes,))
2823 self.assertEqual(m2.strides, (1,))
2824 self.assertEqual(m2.suboffsets, ())
2829 self.assertEqual(m2.obj, x)
2830 self.assertEqual(m2.itemsize, 1)
2831 self.assertIs(m2.readonly, False)
2832 self.assertEqual(m2.ndim, 1)
2833 self.assertEqual(m2.shape, (m2.nbytes,))
2834 self.assertEqual(m2.strides, (1,))
2835 self.assertEqual(m2.suboffsets, ())
2837 def test_memoryview_tolist(self):
2839 # Most tolist() tests are in self.verify() etc.
2843 self.assertEqual(m, a)
2844 self.assertEqual(m.tolist(), a.tolist())
2848 self.assertEqual(m, a)
2849 self.assertEqual(m.tolist(), a.tolist())
2853 self.assertEqual(m.tolist(), ex.tolist())
2857 self.assertRaises(NotImplementedError, m.tolist)
2861 self.assertRaises(NotImplementedError, m.tolist)
2865 self.assertRaises(NotImplementedError, m.tolist)
2867 def test_memoryview_repr(self):
2870 self.assertTrue(r.startswith("<memory"))
2874 self.assertTrue(r.startswith("<released"))
2876 def test_memoryview_sequence(self):
2882 self.assertIn(1.0, m)
2883 self.assertIn(5e700, m)
2884 self.assertIn(3.0, m)
2888 self.assertRaises(TypeError, eval, "9.0 in m", locals())
2891 def assert_out_of_bounds_error(self, dim):
2892 with self.assertRaises(IndexError) as cm:
2894 self.assertEqual(str(cm.exception),
2897 def test_memoryview_index(self):
2902 self.assertEqual(m[()], 12.5)
2903 self.assertEqual(m[...], m)
2904 self.assertEqual(m[...], ex)
2905 self.assertRaises(TypeError, m.__getitem__, 0)
2909 self.assertRaises(NotImplementedError, m.__getitem__, ())
2915 self.assertRaises(IndexError, m.__getitem__, 2**64)
2916 self.assertRaises(TypeError, m.__getitem__, 2.0)
2917 self.assertRaises(TypeError, m.__getitem__, 0.0)
2920 self.assertRaises(IndexError, m.__getitem__, -8)
2921 self.assertRaises(IndexError, m.__getitem__, 8)
2927 self.assertEqual(m[0, 0], 0)
2928 self.assertEqual(m[2, 0], 8)
2929 self.assertEqual(m[2, 3], 11)
2930 self.assertEqual(m[-1, -1], 11)
2931 self.assertEqual(m[-3, -4], 0)
2935 with self.assert_out_of_bounds_error(dim=1):
2938 with self.assert_out_of_bounds_error(dim=2):
2940 self.assertRaises(IndexError, m.__getitem__, (2**64, 0))
2941 self.assertRaises(IndexError, m.__getitem__, (0, 2**64))
2943 self.assertRaises(TypeError, m.__getitem__, (0, 0, 0))
2944 self.assertRaises(TypeError, m.__getitem__, (0.0, 0.0))
2947 self.assertRaises(NotImplementedError, m.__getitem__, ())
2948 self.assertRaises(NotImplementedError, m.__getitem__, 0)
2950 def test_memoryview_assign(self):
2956 self.assertEqual(m[()], 22.5)
2958 self.assertEqual(m[()], 23.5)
2959 self.assertRaises(TypeError, m.__setitem__, 0, 24.7)
2964 self.assertRaises(TypeError, m.__setitem__, 2, 10)
2970 self.assertRaises(IndexError, m.__setitem__, 2**64, 9)
2971 self.assertRaises(TypeError, m.__setitem__, 2.0, 10)
2972 self.assertRaises(TypeError, m.__setitem__, 0.0, 11)
2975 self.assertRaises(IndexError, m.__setitem__, -8, 20)
2976 self.assertRaises(IndexError, m.__setitem__, 8, 25)
2986 self.assertEqual(m[i], 8)
2987 self.assertEqual(m[i], ex[i])
2993 self.assertEqual(m[2], b'9')
2999 self.assertIs(m[1], True)
3004 self.assertRaises(TypeError, m.__setitem__, 0, 100)
3019 self.assertRaises(ValueError, m2.__setitem__, 0, lo-1)
3020 self.assertRaises(TypeError, m2.__setitem__, 0, "xyz")
3021 self.assertRaises(ValueError, m2.__setitem__, 0, hi)
3025 self.assertRaises(ValueError, m2.__setitem__, 0, b'\xff\xff')
3030 self.assertRaises(NotImplementedError, m.__setitem__, 0, 1)
3034 self.assertRaises(NotImplementedError, m.__setitem__, 0, 1)
3040 self.assertEqual(ex[0][1], 42)
3042 self.assertEqual(ex[2][3], 43)
3045 with self.assert_out_of_bounds_error(dim=1):
3048 with self.assert_out_of_bounds_error(dim=2):
3050 self.assertRaises(IndexError, m.__setitem__, (2**64, 0), 0)
3051 self.assertRaises(IndexError, m.__setitem__, (0, 2**64), 0)
3053 self.assertRaises(TypeError, m.__setitem__, (0, 0, 0), 0)
3054 self.assertRaises(TypeError, m.__setitem__, (0.0, 0.0), 0)
3057 self.assertRaises(NotImplementedError, m.__setitem__, 0, [2, 3])
3059 def test_memoryview_slice(self):
3065 self.assertRaises(ValueError, m.__getitem__, slice(0,2,0))
3066 self.assertRaises(ValueError, m.__setitem__, slice(0,2,0),
3070 self.assertRaises(NotImplementedError, m.__getitem__, ())
3076 self.assertRaises(NotImplementedError, m.__getitem__,
3078 self.assertRaises(NotImplementedError, m.__setitem__,
3082 self.assertRaises(TypeError, m.__getitem__, (slice(0,2,1), {}))
3083 self.assertRaises(TypeError, m.__setitem__, (slice(0,2,1), {}),
3087 self.assertRaises(TypeError, m.__setitem__, slice(0,1,1), [1])
3100 self.assertEqual(m1, ex1)
3101 self.assertEqual(m2, ex2)
3106 self.assertEqual(m1, ex1)
3107 self.assertEqual(m2, ex2)
3112 self.assertEqual(m1, ex1)
3113 self.assertEqual(m2, ex2)
3115 def test_memoryview_array(self):
3144 self.assertEqual(m, a)
3145 self.assertEqual(m.tolist(), a.tolist())
3146 self.assertEqual(m.tobytes(), a.tobytes())
3147 self.assertEqual(len(m), len(a))
3149 cmptest(self, a, b, m, singleitem)
3168 self.assertIs(m_err, ValueError)
3170 self.assertIs(m_err, array_err)
3172 self.assertEqual(m, a)
3173 self.assertEqual(m.tolist(), a.tolist())
3174 self.assertEqual(m.tobytes(), a.tobytes())
3175 cmptest(self, a, b, m, singleitem)
3177 def test_memoryview_compare_special_cases(self):
3186 self.assertIs(getattr(v, attr)(w), NotImplemented)
3187 self.assertIs(getattr(a, attr)(v), NotImplemented)
3192 self.assertEqual(v, v)
3193 self.assertNotEqual(v, a)
3194 self.assertNotEqual(a, v)
3199 self.assertNotEqual(v, w)
3200 self.assertNotEqual(w, v)
3204 self.assertNotEqual(v, [1, 2, 3])
3209 self.assertNotEqual(memoryview(nd), nd)
3214 self.assertNotEqual(a, v)
3215 self.assertNotEqual(v, a)
3225 self.assertNotEqual(a, b)
3226 self.assertNotEqual(a, point)
3227 self.assertNotEqual(point, a)
3228 self.assertRaises(NotImplementedError, a.tolist)
3230 def test_memoryview_compare_ndim_zero(self):
3236 self.assertEqual(v, w)
3237 self.assertEqual(w, v)
3238 self.assertEqual(v, nd2)
3239 self.assertEqual(nd2, v)
3240 self.assertEqual(w, nd1)
3241 self.assertEqual(nd1, w)
3243 self.assertFalse(v.__ne__(w))
3244 self.assertFalse(w.__ne__(v))
3247 self.assertNotEqual(v, w)
3248 self.assertNotEqual(w, v)
3249 self.assertNotEqual(v, nd2)
3250 self.assertNotEqual(nd2, v)
3251 self.assertNotEqual(w, nd1)
3252 self.assertNotEqual(nd1, w)
3254 self.assertFalse(v.__eq__(w))
3255 self.assertFalse(w.__eq__(v))
3261 self.assertEqual(m, nd)
3263 self.assertNotEqual(m, nd)
3271 self.assertEqual(v, w)
3272 self.assertEqual(w, v)
3273 self.assertEqual(v, nd2)
3274 self.assertEqual(nd2, v)
3275 self.assertEqual(w, nd1)
3276 self.assertEqual(nd1, w)
3284 self.assertNotEqual(v, w)
3285 self.assertNotEqual(w, v)
3286 self.assertNotEqual(v, nd2)
3287 self.assertNotEqual(nd2, v)
3288 self.assertNotEqual(w, nd1)
3289 self.assertNotEqual(nd1, w)
3290 self.assertEqual(v, nd1)
3291 self.assertEqual(w, nd2)
3293 def test_memoryview_compare_ndim_one(self):
3301 self.assertEqual(v, nd1)
3302 self.assertEqual(w, nd2)
3303 self.assertNotEqual(v, nd2)
3304 self.assertNotEqual(w, nd1)
3305 self.assertNotEqual(v, w)
3313 self.assertEqual(v, nd1)
3314 self.assertEqual(w, nd2)
3315 self.assertNotEqual(v, nd2)
3316 self.assertNotEqual(w, nd1)
3317 self.assertNotEqual(v, w)
3325 self.assertEqual(v, nd2[::2])
3326 self.assertEqual(w[::2], nd1)
3327 self.assertEqual(v, w[::2])
3328 self.assertEqual(v[::-1], w[::-2])
3336 self.assertEqual(v, nd2[::2])
3337 self.assertEqual(w[::2], nd1)
3338 self.assertEqual(v, w[::2])
3339 self.assertEqual(v[::-1], w[::-2])
3348 self.assertEqual(v, nd2[::2])
3349 self.assertEqual(w[::2], nd1)
3350 self.assertEqual(v, w[::2])
3351 self.assertEqual(v[::-1], w[::-2])
3360 self.assertEqual(v, nd2[::2])
3361 self.assertEqual(w[::2], nd1)
3362 self.assertEqual(v, w[::2])
3363 self.assertEqual(v[::-1], w[::-2])
3365 def test_memoryview_compare_zero_shape(self):
3373 self.assertEqual(v, nd1)
3374 self.assertEqual(w, nd2)
3375 self.assertEqual(v, nd2)
3376 self.assertEqual(w, nd1)
3377 self.assertEqual(v, w)
3385 self.assertEqual(v, nd1)
3386 self.assertEqual(w, nd2)
3387 self.assertEqual(v, nd2)
3388 self.assertEqual(w, nd1)
3389 self.assertEqual(v, w)
3391 def test_memoryview_compare_zero_strides(self):
3399 self.assertEqual(v, nd1)
3400 self.assertEqual(w, nd2)
3401 self.assertEqual(v, nd2)
3402 self.assertEqual(w, nd1)
3403 self.assertEqual(v, w)
3411 self.assertEqual(v, nd1)
3412 self.assertEqual(w, nd2)
3413 self.assertEqual(v, nd2)
3414 self.assertEqual(w, nd1)
3415 self.assertEqual(v, w)
3417 def test_memoryview_compare_random_formats(self):
3426 self.assertEqual(m, nd)
3430 self.assertEqual(m, nd)
3439 self.assertEqual(m, nd)
3443 self.assertEqual(m, nd)
3445 def test_memoryview_compare_multidim_c(self):
3453 self.assertEqual(v, nd1)
3454 self.assertEqual(w, nd2)
3455 self.assertNotEqual(v, nd2)
3456 self.assertNotEqual(w, nd1)
3457 self.assertNotEqual(v, w)
3465 self.assertEqual(v, nd1)
3466 self.assertEqual(w, nd2)
3467 self.assertNotEqual(v, nd2)
3468 self.assertNotEqual(w, nd1)
3469 self.assertNotEqual(v, w)
3477 self.assertEqual(v, nd1)
3478 self.assertEqual(w, nd2)
3479 self.assertNotEqual(v, nd2)
3480 self.assertNotEqual(w, nd1)
3481 self.assertNotEqual(v, w)
3489 self.assertEqual(v, nd1)
3490 self.assertEqual(w, nd2)
3491 self.assertNotEqual(v, nd2)
3492 self.assertNotEqual(w, nd1)
3493 self.assertNotEqual(v, w)
3501 self.assertEqual(v, nd1)
3502 self.assertEqual(w, nd2)
3503 self.assertEqual(v, nd2)
3504 self.assertEqual(w, nd1)
3505 self.assertEqual(v, w)
3507 def test_memoryview_compare_multidim_fortran(self):
3517 self.assertEqual(v, nd1)
3518 self.assertEqual(w, nd2)
3519 self.assertNotEqual(v, nd2)
3520 self.assertNotEqual(w, nd1)
3521 self.assertNotEqual(v, w)
3531 self.assertEqual(v, nd1)
3532 self.assertEqual(w, nd2)
3533 self.assertNotEqual(v, nd2)
3534 self.assertNotEqual(w, nd1)
3535 self.assertNotEqual(v, w)
3545 self.assertEqual(v, nd1)
3546 self.assertEqual(w, nd2)
3547 self.assertNotEqual(v, nd2)
3548 self.assertNotEqual(w, nd1)
3549 self.assertNotEqual(v, w)
3559 self.assertEqual(v, nd1)
3560 self.assertEqual(w, nd2)
3561 self.assertNotEqual(v, nd2)
3562 self.assertNotEqual(w, nd1)
3563 self.assertNotEqual(v, w)
3573 self.assertEqual(v, nd1)
3574 self.assertEqual(w, nd2)
3575 self.assertEqual(v, nd2)
3576 self.assertEqual(w, nd1)
3577 self.assertEqual(v, w)
3579 def test_memoryview_compare_multidim_mixed(self):
3589 self.assertEqual(v, nd1)
3590 self.assertEqual(w, nd2)
3591 self.assertEqual(v, w)
3602 self.assertEqual(v, nd1)
3603 self.assertEqual(w, nd2)
3604 self.assertEqual(v, w)
3614 self.assertEqual(v, nd1)
3615 self.assertEqual(w, nd2)
3616 self.assertNotEqual(v, nd2)
3617 self.assertNotEqual(w, nd1)
3618 self.assertNotEqual(v, w)
3628 self.assertEqual(v, nd1)
3629 self.assertEqual(w, nd2)
3630 self.assertEqual(v, nd2)
3631 self.assertEqual(w, nd1)
3632 self.assertEqual(v, w)
3642 self.assertEqual(v, nd1)
3643 self.assertEqual(w, nd2)
3644 self.assertNotEqual(v, nd2)
3645 self.assertNotEqual(w, nd1)
3646 self.assertNotEqual(v, w)
3656 self.assertEqual(v, nd1)
3657 self.assertEqual(w, nd2)
3658 self.assertNotEqual(v, nd2)
3659 self.assertNotEqual(w, nd1)
3660 self.assertNotEqual(v, w)
3670 self.assertEqual(v, nd1)
3671 self.assertEqual(w, nd2)
3672 self.assertNotEqual(v, nd2)
3673 self.assertNotEqual(w, nd1)
3674 self.assertNotEqual(v, w)
3676 def test_memoryview_compare_multidim_zero_shape(self):
3684 self.assertEqual(v, nd1)
3685 self.assertEqual(w, nd2)
3686 self.assertNotEqual(v, nd2)
3687 self.assertNotEqual(w, nd1)
3688 self.assertNotEqual(v, w)
3696 self.assertEqual(v, nd1)
3697 self.assertEqual(w, nd2)
3698 self.assertNotEqual(v, nd2)
3699 self.assertNotEqual(w, nd1)
3700 self.assertNotEqual(v, w)
3702 def test_memoryview_compare_multidim_zero_strides(self):
3710 self.assertEqual(v, nd1)
3711 self.assertEqual(w, nd2)
3712 self.assertEqual(v, nd2)
3713 self.assertEqual(w, nd1)
3714 self.assertEqual(v, w)
3715 self.assertEqual(v.tolist(), w.tolist())
3723 self.assertEqual(v, nd1)
3724 self.assertEqual(w, nd2)
3725 self.assertEqual(v, nd2)
3726 self.assertEqual(w, nd1)
3727 self.assertEqual(v, w)
3729 def test_memoryview_compare_multidim_suboffsets(self):
3739 self.assertEqual(v, nd1)
3740 self.assertEqual(w, nd2)
3741 self.assertNotEqual(v, nd2)
3742 self.assertNotEqual(w, nd1)
3743 self.assertNotEqual(v, w)
3759 self.assertEqual(v, nd1)
3760 self.assertEqual(w, nd2)
3761 self.assertEqual(v, nd2)
3762 self.assertEqual(w, nd1)
3763 self.assertEqual(v, w)
3774 self.assertEqual(v, nd1)
3775 self.assertEqual(w, nd2)
3776 self.assertNotEqual(v, nd2)
3777 self.assertNotEqual(w, nd1)
3778 self.assertNotEqual(v, w)
3791 self.assertEqual(v, nd1)
3792 self.assertEqual(w, nd2)
3793 self.assertNotEqual(v, nd2)
3794 self.assertNotEqual(w, nd1)
3795 self.assertNotEqual(v, w)
3805 self.assertEqual(v, nd1)
3806 self.assertEqual(w, nd2)
3807 self.assertEqual(v, nd2)
3808 self.assertEqual(w, nd1)
3809 self.assertEqual(v, w)
3825 self.assertEqual(v, nd1)
3826 self.assertEqual(w, nd2)
3827 self.assertNotEqual(v, nd2)
3828 self.assertNotEqual(w, nd1)
3829 self.assertNotEqual(v, w)
3839 self.assertEqual(v, nd1)
3840 self.assertEqual(w, nd2)
3841 self.assertEqual(v, w)
3854 self.assertEqual(v, nd1)
3855 self.assertEqual(w, nd2)
3856 self.assertEqual(v, w)
3858 def test_memoryview_compare_not_equal(self):
3868 self.assertEqual(a, x)
3869 self.assertEqual(b, y)
3870 self.assertNotEqual(a, b)
3871 self.assertNotEqual(a, y)
3872 self.assertNotEqual(b, x)
3881 self.assertEqual(a, x)
3882 self.assertEqual(b, y)
3883 self.assertNotEqual(a, b)
3884 self.assertNotEqual(a, y)
3885 self.assertNotEqual(b, x)
3887 def test_memoryview_check_released(self):
3895 self.assertRaises(ValueError, memoryview, m)
3897 self.assertRaises(ValueError, m.cast, 'c')
3899 self.assertRaises(ValueError, ndarray, m)
3901 self.assertRaises(ValueError, m.tolist)
3903 self.assertRaises(ValueError, m.tobytes)
3905 self.assertRaises(ValueError, eval, "1.0 in m", locals())
3907 self.assertRaises(ValueError, m.__getitem__, 0)
3909 self.assertRaises(ValueError, m.__setitem__, 0, 1)
3914 self.assertRaises(ValueError, m.__getattribute__, attr)
3921 self.assertEqual(m1, m2)
3923 self.assertNotEqual(m1, m2)
3924 self.assertNotEqual(m1, a)
3925 self.assertEqual(m1, m1)
3927 def test_memoryview_tobytes(self):
3928 # Many implicit tests are already in self.verify().
3934 self.assertEqual(m, nd)
3935 self.assertEqual(m.tobytes(), nd.tobytes())
3939 self.assertEqual(m, nd)
3940 self.assertEqual(m.tobytes(), nd.tobytes())
3944 self.assertEqual(m, nd)
3945 self.assertEqual(m.tobytes(), nd.tobytes())
3950 self.assertEqual(m, nd)
3951 self.assertEqual(m.tobytes(), nd.tobytes())
3960 self.assertEqual(a.tobytes(), bytes(point))
3962 def test_memoryview_get_contiguous(self):
3963 # Many implicit tests are already in self.verify().
3966 self.assertRaises(TypeError, get_contiguous, {}, PyBUF_READ, 'F')
3969 self.assertRaises(BufferError, get_contiguous, b'x', PyBUF_WRITE, 'C')
3973 self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'A')
3979 self.assertEqual(m, nd)
3980 self.assertEqual(m[()], 9)
3986 self.assertEqual(m, nd)
3987 self.assertEqual(m[()], 9)
3993 self.assertEqual(m, nd)
3994 self.assertEqual(m[()], 9)
3997 self.assertEqual(m[()], 10)
3998 self.assertEqual(nd[()], 10)
4004 self.assertRaises(IndexError, m.__getitem__, 0)
4005 self.assertEqual(m, nd)
4006 self.assertEqual(m.tolist(), [])
4012 self.assertEqual(ndarray(m).tolist(), [[], []])
4018 self.assertEqual(m, nd)
4019 self.assertEqual(m.tolist(), nd.tolist())
4024 self.assertEqual(m, nd)
4025 self.assertEqual(m.tolist(), nd.tolist())
4031 self.assertEqual(m, nd)
4032 self.assertEqual(m.tolist(), nd.tolist())
4033 self.assertRaises(TypeError, m.__setitem__, 1, 20)
4034 self.assertEqual(m[1], 3)
4035 self.assertEqual(nd[1], 3)
4040 self.assertEqual(m, nd)
4041 self.assertEqual(m.tolist(), nd.tolist())
4042 self.assertRaises(TypeError, m.__setitem__, 1, 20)
4043 self.assertEqual(m[1], 1)
4044 self.assertEqual(nd[1], 1)
4050 self.assertEqual(ndarray(m).tolist(), nd.tolist())
4052 self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'F')
4054 self.assertEqual(ndarray(m).tolist(), nd.tolist())
4060 self.assertEqual(ndarray(m).tolist(), nd.tolist())
4062 self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'C')
4064 self.assertEqual(ndarray(m).tolist(), nd.tolist())
4069 self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE,
4072 self.assertEqual(ndarray(m).tolist(), nd.tolist())
4077 self.assertTrue(m.c_contiguous)
4079 def test_memoryview_serializing(self):
4088 self.assertEqual(m.tobytes(), b)
4097 self.assertEqual(m.tobytes(), b)
4107 #self.assertEqual(m.tobytes(), b)
4109 def test_memoryview_hash(self):
4114 self.assertEqual(hash(b), hash(m))
4118 self.assertEqual(hash(mc), hash(b))
4123 self.assertEqual(hash(mx), hash(b))
4128 self.assertEqual(hash(m), hash(nd))
4134 self.assertEqual(hash(m), hash(x))
4140 self.assertEqual(hash(m), hash(x))
4149 self.assertEqual(a, b)
4150 self.assertEqual(hash(a), hash(b))
4155 self.assertRaises(ValueError, m.__hash__)
4159 self.assertRaises(ValueError, m.__hash__)
4163 self.assertRaises(ValueError, m.__hash__)
4167 self.assertRaises(ValueError, m.__hash__)
4169 def test_memoryview_release(self):
4175 self.assertRaises(BufferError, m.release)
4183 self.assertIs(nd2.obj, m)
4184 self.assertRaises(BufferError, m.release)
4194 self.assertRaises(BufferError, m2.release)
4203 self.assertIs(nd2.obj, m2)
4205 self.assertRaises(BufferError, m2.release)
4217 self.assertEqual(x.tolist(), m1.tolist())
4220 self.assertEqual(y.tolist(), m2.tolist())
4221 self.assertEqual(y.tolist(), nd.tolist())
4226 self.assertEqual(x.tolist(), nd.tolist())
4242 self.assertEqual(m1[0], ord(b'1'))
4247 self.assertIs(z.obj, x)
4250 self.assertEqual(m[0:1].tolist(), [[[0, 1, 2], [3, 4, 5]]])
4266 self.assertEqual(m1[0], ord(b'1'))
4267 self.assertEqual(m2[1], ord(b'2'))
4268 self.assertEqual(m3[2], ord(b'3'))
4285 self.assertEqual(m1[0], ord(b'1'))
4286 self.assertEqual(m2[1], ord(b'2'))
4287 self.assertEqual(m3[2], ord(b'3'))
4292 with self.assertRaises(BufferError):
4297 def test_memoryview_redirect(self):
4307 self.assertIs(y.obj, x)
4308 self.assertIs(z.obj, x)
4309 self.assertIs(m.obj, x)
4311 self.assertEqual(m, x)
4312 self.assertEqual(m, y)
4313 self.assertEqual(m, z)
4315 self.assertEqual(m[1:3], x[1:3])
4316 self.assertEqual(m[1:3], y[1:3])
4317 self.assertEqual(m[1:3], z[1:3])
4319 self.assertEqual(m[1:3], x[1:3])
4321 def test_memoryview_from_static_exporter(self):
4327 self.assertRaises(TypeError, staticarray, 1, 2, 3)
4332 self.verify(y, obj=x,
4337 self.assertEqual(y[i], i)
4350 self.assertIs(y.obj, x)
4351 self.assertIs(m.obj, z)
4352 self.verify(m, obj=z,
4362 self.assertIs(y.obj, x)
4363 self.assertIs(z.obj, x)
4364 self.assertIs(m.obj, x)
4365 self.verify(m, obj=x,
4374 self.verify(y, obj=None,
4379 self.assertEqual(y[i], i)
4392 self.assertIs(y.obj, None)
4393 self.assertIs(m.obj, z)
4394 self.verify(m, obj=z,
4406 self.assertIs(y.obj, None)
4407 self.assertIs(z.obj, y)
4408 self.assertIs(m.obj, y)
4409 self.verify(m, obj=y,
4415 def test_memoryview_getbuffer_undefined(self):
4419 self.assertRaises(BufferError, memoryview, nd)
4421 def test_issue_7385(self):
4423 self.assertRaises(BufferError, memoryview, x)
4426 def test_pybuffer_size_from_format(self):
4429 self.assertEqual(_testcapi.PyBuffer_SizeFromFormat(format),