test_buffer.py revision b716f84880fb719be417e9b49f8bb55bfd0106b8
19a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 29a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# The ndarray object from _testbuffer.c is a complete implementation of 39a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# a PEP-3118 buffer provider. It is independent from NumPy's ndarray 49a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# and the tests don't require NumPy. 59a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 69a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# If NumPy is present, some tests check both ndarray implementations 79a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# against each other. 89a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 99a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Most ndarray tests also check that memoryview(ndarray) behaves in 109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# the same way as the original. Thus, a substantial part of the 119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# memoryview tests is now in this module. 129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahimport unittest 159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfrom test import support 169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfrom itertools import permutations, product 179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfrom random import randrange, sample, choice 189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfrom sysconfig import get_config_var 199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahimport warnings 209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahimport sys, array, io 219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfrom decimal import Decimal 229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfrom fractions import Fraction 239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahtry: 259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah from _testbuffer import * 269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahexcept ImportError: 279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndarray = None 289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahtry: 309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah import struct 319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahexcept ImportError: 329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct = None 339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahtry: 3506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan import ctypes 3606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlanexcept ImportError: 3706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ctypes = None 3806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 3906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlantry: 409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah with warnings.catch_warnings(): 419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah from numpy import ndarray as numpy_array 429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahexcept ImportError: 439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah numpy_array = None 449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 469a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahSHORT_TEST = True 479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Random lists by format specifier 519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Native format chars and their ranges. 549a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahNATIVE = { 559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '?':0, 'c':0, 'b':0, 'B':0, 569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'h':0, 'H':0, 'i':0, 'I':0, 579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'l':0, 'L':0, 'n':0, 'N':0, 589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'f':0, 'd':0, 'P':0 599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah} 609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 617d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah# NumPy does not have 'n' or 'N': 627d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krahif numpy_array: 637d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah del NATIVE['n'] 647d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah del NATIVE['N'] 657d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahif struct: 679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Add "qQ" if present in native mode. 699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct.pack('Q', 2**64-1) 709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah NATIVE['q'] = 0 719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah NATIVE['Q'] = 0 729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except struct.error: 739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah pass 749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Standard format chars and their ranges. 769a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahSTANDARD = { 779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '?':(0, 2), 'c':(0, 1<<8), 789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'b':(-(1<<7), 1<<7), 'B':(0, 1<<8), 799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'h':(-(1<<15), 1<<15), 'H':(0, 1<<16), 809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'i':(-(1<<31), 1<<31), 'I':(0, 1<<32), 819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'l':(-(1<<31), 1<<31), 'L':(0, 1<<32), 829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'q':(-(1<<63), 1<<63), 'Q':(0, 1<<64), 839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'f':(-(1<<63), 1<<63), 'd':(-(1<<1023), 1<<1023) 849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah} 859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef native_type_range(fmt): 879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return range of a native type.""" 889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt == 'c': 899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lh = (0, 256) 909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif fmt == '?': 919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lh = (0, 2) 929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif fmt == 'f': 939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lh = (-(1<<63), 1<<63) 949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif fmt == 'd': 959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lh = (-(1<<1023), 1<<1023) 969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for exp in (128, 127, 64, 63, 32, 31, 16, 15, 8, 7): 989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct.pack(fmt, (1<<exp)-1) 1009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah break 1019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except struct.error: 1029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah pass 1039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lh = (-(1<<exp), 1<<exp) if exp & 1 else (0, 1<<exp) 1049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lh 1059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict = { 1079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '':NATIVE, 1089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '@':NATIVE, 1099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '<':STANDARD, 1109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '>':STANDARD, 1119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '=':STANDARD, 1129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '!':STANDARD 1139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah} 1149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahif struct: 1169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 1179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmtdict['@'][fmt] = native_type_range(fmt) 1189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1199a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahMEMORYVIEW = NATIVE.copy() 1209a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahARRAY = NATIVE.copy() 1219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfor k in NATIVE: 1229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not k in "bBhHiIlLfd": 1239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del ARRAY[k] 1249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1259a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahBYTEFMT = NATIVE.copy() 1269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfor k in NATIVE: 1279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not k in "Bbc": 1289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del BYTEFMT[k] 1299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict['m'] = MEMORYVIEW 1319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict['@m'] = MEMORYVIEW 1329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict['a'] = ARRAY 1339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict['b'] = BYTEFMT 1349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict['@b'] = BYTEFMT 1359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Capabilities of the test objects: 1379a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahMODE = 0 1389a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahMULT = 1 1399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahcap = { # format chars # multiplier 1409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'ndarray': (['', '@', '<', '>', '=', '!'], ['', '1', '2', '3']), 1419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'array': (['a'], ['']), 1429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'numpy': ([''], ['']), 1439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'memoryview': (['@m', 'm'], ['']), 1449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'bytefmt': (['@b', 'b'], ['']), 1459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah} 1469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef randrange_fmt(mode, char, obj): 1489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return random item for a type specified by a mode and a single 1499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format character.""" 1509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = randrange(*fmtdict[mode][char]) 1519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if char == 'c': 1529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = bytes(chr(x), 'latin1') 1539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if char == '?': 1549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = bool(x) 1559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if char == 'f' or char == 'd': 1569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = struct.pack(char, x) 1579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = struct.unpack(char, x)[0] 1589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if obj == 'numpy' and x == b'\x00': 1599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # http://projects.scipy.org/numpy/ticket/1925 1609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = b'\x01' 1619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return x 1629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef gen_item(fmt, obj): 1649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return single random item.""" 1659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mode, chars = fmt.split('#') 1669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = [] 1679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for c in chars: 1689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x.append(randrange_fmt(mode, c, obj)) 1699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return x[0] if len(x) == 1 else tuple(x) 1709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef gen_items(n, fmt, obj): 1729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return a list of random items (or a scalar).""" 1739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if n == 0: 1749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return gen_item(fmt, obj) 1759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = [0] * n 1769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(n): 1779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst[i] = gen_item(fmt, obj) 1789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 1799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef struct_items(n, obj): 1819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mode = choice(cap[obj][MODE]) 1829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xfmt = mode + '#' 1839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt = mode.strip('amb') 1849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nmemb = randrange(2, 10) # number of struct members 1859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(nmemb): 1869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah char = choice(tuple(fmtdict[mode])) 1879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah multiplier = choice(cap[obj][MULT]) 1889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xfmt += (char * int(multiplier if multiplier else 1)) 1899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt += (multiplier + char) 1909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = gen_items(n, xfmt, obj) 1919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah item = gen_item(xfmt, obj) 1929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return fmt, items, item 1939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef randitems(n, obj='ndarray', mode=None, char=None): 1959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return random format, items, item.""" 1969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if mode is None: 1979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mode = choice(cap[obj][MODE]) 1989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if char is None: 1999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah char = choice(tuple(fmtdict[mode])) 2009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah multiplier = choice(cap[obj][MULT]) 2019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt = mode + '#' + char * int(multiplier if multiplier else 1) 2029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = gen_items(n, fmt, obj) 2039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah item = gen_item(fmt, obj) 2049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt = mode.strip('amb') + multiplier + char 2059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return fmt, items, item 2069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef iter_mode(n, obj='ndarray'): 2089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Iterate through supported mode/char combinations.""" 2099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for mode in cap[obj][MODE]: 2109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for char in fmtdict[mode]: 2119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield randitems(n, obj, mode, char) 2129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef iter_format(nitems, testobj='ndarray'): 2149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Yield (format, items, item) for all possible modes and format 2159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah characters plus one random compound format string.""" 2169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for t in iter_mode(nitems, testobj): 2179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield t 2189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if testobj != 'ndarray': 2199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah raise StopIteration 2209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield struct_items(nitems, testobj) 2219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef is_byte_format(fmt): 2249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 'c' in fmt or 'b' in fmt or 'B' in fmt 2259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef is_memoryview_format(fmt): 2279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """format suitable for memoryview""" 2289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = len(fmt) 2299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ((x == 1 or (x == 2 and fmt[0] == '@')) and 2309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt[x-1] in MEMORYVIEW) 2319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2329a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahNON_BYTE_FORMAT = [c for c in fmtdict['@'] if not is_byte_format(c)] 2339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 2369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Multi-dimensional tolist(), slicing and slice assignments 2379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 2389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef atomp(lst): 2409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Tuple items (representing structs) are regarded as atoms.""" 2419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return not isinstance(lst, list) 2429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef listp(lst): 2449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return isinstance(lst, list) 2459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef prod(lst): 2479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Product of list elements.""" 2489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if len(lst) == 0: 2499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 0 2509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = lst[0] 2519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for v in lst[1:]: 2529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x *= v 2539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return x 2549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef strides_from_shape(ndim, shape, itemsize, layout): 2569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Calculate strides of a contiguous array. Layout is 'C' or 2579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'F' (Fortran).""" 2589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ndim == 0: 2599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return () 2609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if layout == 'C': 2619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = list(shape[1:]) + [itemsize] 2629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(ndim-2, -1, -1): 2639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[i] *= strides[i+1] 2649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 2659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = [itemsize] + list(shape[:-1]) 2669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(1, ndim): 2679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[i] *= strides[i-1] 2689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return strides 2699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef _ca(items, s): 2719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Convert flat item list to the nested list representation of a 2729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah multidimensional C array with shape 's'.""" 2739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(items): 2749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return items 2759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if len(s) == 0: 2769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return items[0] 2779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = [0] * s[0] 2789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stride = len(items) // s[0] if s[0] else 0 2799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(s[0]): 2809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah start = i*stride 2819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst[i] = _ca(items[start:start+stride], s[1:]) 2829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 2839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef _fa(items, s): 2859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Convert flat item list to the nested list representation of a 2869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah multidimensional Fortran array with shape 's'.""" 2879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(items): 2889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return items 2899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if len(s) == 0: 2909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return items[0] 2919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = [0] * s[0] 2929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stride = s[0] 2939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(s[0]): 2949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst[i] = _fa(items[i::stride], s[1:]) 2959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 2969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef carray(items, shape): 2989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if listp(items) and not 0 in shape and prod(shape) != len(items): 2999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah raise ValueError("prod(shape) != len(items)") 3009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return _ca(items, shape) 3019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef farray(items, shape): 3039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if listp(items) and not 0 in shape and prod(shape) != len(items): 3049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah raise ValueError("prod(shape) != len(items)") 3059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return _fa(items, shape) 3069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef indices(shape): 3089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate all possible tuples of indices.""" 3099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah iterables = [range(v) for v in shape] 3109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return product(*iterables) 3119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef getindex(ndim, ind, strides): 3139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Convert multi-dimensional index to the position in the flat list.""" 3149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ret = 0 3159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(ndim): 3169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ret += strides[i] * ind[i] 3179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ret 3189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef transpose(src, shape): 3209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Transpose flat item list that is regarded as a multi-dimensional 3219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah matrix defined by shape: dest...[k][j][i] = src[i][j][k]... """ 3229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not shape: 3239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return src 3249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 3259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sstrides = strides_from_shape(ndim, shape, 1, 'C') 3269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dstrides = strides_from_shape(ndim, shape[::-1], 1, 'C') 3279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dest = [0] * len(src) 3289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for ind in indices(shape): 3299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fr = getindex(ndim, ind, sstrides) 3309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah to = getindex(ndim, ind[::-1], dstrides) 3319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dest[to] = src[fr] 3329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return dest 3339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef _flatten(lst): 3359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """flatten list""" 3369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if lst == []: 3379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 3389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(lst): 3399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return [lst] 3409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return _flatten(lst[0]) + _flatten(lst[1:]) 3419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef flatten(lst): 3439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """flatten list or return scalar""" 3449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(lst): # scalar 3459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 3469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return _flatten(lst) 3479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef slice_shape(lst, slices): 3499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Get the shape of lst after slicing: slices is a list of slice 3509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah objects.""" 3519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(lst): 3529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return [] 3539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return [len(lst[slices[0]])] + slice_shape(lst[0], slices[1:]) 3549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef multislice(lst, slices): 3569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Multi-dimensional slicing: slices is a list of slice objects.""" 3579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(lst): 3589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 3599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return [multislice(sublst, slices[1:]) for sublst in lst[slices[0]]] 3609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef m_assign(llst, rlst, lslices, rslices): 3629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Multi-dimensional slice assignment: llst and rlst are the operands, 3639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices and rslices are lists of slice objects. llst and rlst must 3649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah have the same structure. 3659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah For a two-dimensional example, this is not implemented in Python: 3679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah llst[0:3:2, 0:3:2] = rlst[1:3:1, 1:3:1] 3699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah Instead we write: 3719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices = [slice(0,3,2), slice(0,3,2)] 3739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rslices = [slice(1,3,1), slice(1,3,1)] 3749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah multislice_assign(llst, rlst, lslices, rslices) 3759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """ 3769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(rlst): 3779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return rlst 3789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rlst = [m_assign(l, r, lslices[1:], rslices[1:]) 3799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for l, r in zip(llst[lslices[0]], rlst[rslices[0]])] 3809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah llst[lslices[0]] = rlst 3819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return llst 3829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef cmp_structure(llst, rlst, lslices, rslices): 3849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Compare the structure of llst[lslices] and rlst[rslices].""" 3859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lshape = slice_shape(llst, lslices) 3869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rshape = slice_shape(rlst, rslices) 3879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if (len(lshape) != len(rshape)): 3889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return -1 3899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(len(lshape)): 3909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if lshape[i] != rshape[i]: 3919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return -1 3929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if lshape[i] == 0: 3939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 0 3949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 0 3959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef multislice_assign(llst, rlst, lslices, rslices): 3979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return llst after assigning: llst[lslices] = rlst[rslices]""" 3989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if cmp_structure(llst, rlst, lslices, rslices) < 0: 3999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah raise ValueError("lvalue and rvalue have different structures") 4009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return m_assign(llst, rlst, lslices, rslices) 4019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 4049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Random structures 4059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 4069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# PEP-3118 is very permissive with respect to the contents of a 4099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Py_buffer. In particular: 4109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# - shape can be zero 4129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# - strides can be any integer, including zero 4139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# - offset can point to any location in the underlying 4149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# memory block, provided that it is a multiple of 4159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# itemsize. 4169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# The functions in this section test and verify random structures 4189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# in full generality. A structure is valid iff it fits in the 4199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# underlying memory block. 4209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# The structure 't' (short for 'tuple') is fully defined by: 4229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# t = (memlen, itemsize, ndim, shape, strides, offset) 4249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef verify_structure(memlen, itemsize, ndim, shape, strides, offset): 4279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Verify that the parameters represent a valid array within 4289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah the bounds of the allocated memory: 4299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah char *mem: start of the physical memory block 4309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen: length of the physical memory block 4319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset: (char *)buf - mem 4329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """ 4339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if offset % itemsize: 4349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return False 4359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if offset < 0 or offset+itemsize > memlen: 4369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return False 4379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if any(v % itemsize for v in strides): 4389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return False 4399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ndim <= 0: 4419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ndim == 0 and not shape and not strides 4429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 0 in shape: 4439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return True 4449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah imin = sum(strides[j]*(shape[j]-1) for j in range(ndim) 4469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[j] <= 0) 4479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah imax = sum(strides[j]*(shape[j]-1) for j in range(ndim) 4489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[j] > 0) 4499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 0 <= offset+imin and offset+imax+itemsize <= memlen 4519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef get_item(lst, indices): 4539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in indices: 4549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = lst[i] 4559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 4569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef memory_index(indices, t): 4589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Location of an item in the underlying memory.""" 4599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen, itemsize, ndim, shape, strides, offset = t 4609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah p = offset 4619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(ndim): 4629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah p += strides[i]*indices[i] 4639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return p 4649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef is_overlapping(t): 4669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """The structure 't' is overlapping if at least one memory location 4679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah is visited twice while iterating through all possible tuples of 4689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah indices.""" 4699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen, itemsize, ndim, shape, strides, offset = t 4709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah visited = 1<<memlen 4719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for ind in indices(shape): 4729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah i = memory_index(ind, t) 4739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bit = 1<<i 4749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if visited & bit: 4759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return True 4769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah visited |= bit 4779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return False 4789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rand_structure(itemsize, valid, maxdim=5, maxshape=16, shape=()): 4809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return random structure: 4819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (memlen, itemsize, ndim, shape, strides, offset) 4829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah If 'valid' is true, the returned structure is valid, otherwise invalid. 4839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah If 'shape' is given, use that instead of creating a random shape. 4849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """ 4859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not shape: 4869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = randrange(maxdim+1) 4879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if (ndim == 0): 4889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if valid: 4899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return itemsize, itemsize, ndim, (), (), 0 4909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 4919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = randrange(1, 16+1) 4929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen = nitems * itemsize 4939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = -itemsize if randrange(2) == 0 else memlen 4949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return memlen, itemsize, ndim, (), (), offset 4959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 2 4979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = randrange(100) 4989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if n >= 95 and valid: 4999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 0 5009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif n >= 90: 5019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 1 5029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = [0] * ndim 5039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(ndim): 5059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape[i] = randrange(minshape, maxshape+1) 5069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 5079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 5089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxstride = 5 5109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = randrange(100) 5119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah zero_stride = True if n >= 95 and n & 1 else False 5129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = [0] * ndim 5149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[ndim-1] = itemsize * randrange(-maxstride, maxstride+1) 5159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not zero_stride and strides[ndim-1] == 0: 5169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[ndim-1] = itemsize 5179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(ndim-2, -1, -1): 5199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxstride *= shape[i+1] if shape[i+1] else 1 5209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if zero_stride: 5219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[i] = itemsize * randrange(-maxstride, maxstride+1) 5229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 5239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[i] = ((1,-1)[randrange(2)] * 5249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize * randrange(1, maxstride+1)) 5259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah imin = imax = 0 5279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not 0 in shape: 5289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah imin = sum(strides[j]*(shape[j]-1) for j in range(ndim) 5299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[j] <= 0) 5309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah imax = sum(strides[j]*(shape[j]-1) for j in range(ndim) 5319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[j] > 0) 5329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = imax - imin 5349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if valid: 5359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = -imin * itemsize 5369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen = offset + (imax+1) * itemsize 5379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 5389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen = (-imin + imax) * itemsize 5399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = -imin-itemsize if randrange(2) == 0 else memlen 5409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return memlen, itemsize, ndim, shape, strides, offset 5419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef randslice_from_slicelen(slicelen, listlen): 5439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Create a random slice of len slicelen that fits into listlen.""" 5449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxstart = listlen - slicelen 5459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah start = randrange(maxstart+1) 5469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxstep = (listlen - start) // slicelen if slicelen else 1 5479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah step = randrange(1, maxstep+1) 5489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stop = start + slicelen * step 5499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah s = slice(start, stop, step) 5509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah _, _, _, control = slice_indices(s, listlen) 5519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if control != slicelen: 5529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah raise RuntimeError 5539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return s 5549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef randslice_from_shape(ndim, shape): 5569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Create two sets of slices for an array x with shape 'shape' 5579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah such that shapeof(x[lslices]) == shapeof(x[rslices]).""" 5589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices = [0] * ndim 5599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rslices = [0] * ndim 5609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for n in range(ndim): 5619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah l = shape[n] 5629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah slicelen = randrange(1, l+1) if l > 0 else 0 5639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices[n] = randslice_from_slicelen(slicelen, l) 5649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rslices[n] = randslice_from_slicelen(slicelen, l) 5659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return tuple(lslices), tuple(rslices) 5669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rand_aligned_slices(maxdim=5, maxshape=16): 5689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Create (lshape, rshape, tuple(lslices), tuple(rslices)) such that 5699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shapeof(x[lslices]) == shapeof(y[rslices]), where x is an array 5709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah with shape 'lshape' and y is an array with shape 'rshape'.""" 5719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = randrange(1, maxdim+1) 5729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 2 5739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = randrange(100) 5749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if n >= 95: 5759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 0 5769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif n >= 90: 5779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 1 5789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah all_random = True if randrange(100) >= 80 else False 5799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lshape = [0]*ndim; rshape = [0]*ndim 5809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices = [0]*ndim; rslices = [0]*ndim 5819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for n in range(ndim): 5839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah small = randrange(minshape, maxshape+1) 5849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah big = randrange(minshape, maxshape+1) 5859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if big < small: 5869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah big, small = small, big 5879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Create a slice that fits the smaller value. 5899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if all_random: 5909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah start = randrange(-small, small+1) 5919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stop = randrange(-small, small+1) 5929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah step = (1,-1)[randrange(2)] * randrange(1, small+2) 5939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah s_small = slice(start, stop, step) 5949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah _, _, _, slicelen = slice_indices(s_small, small) 5959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 5969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah slicelen = randrange(1, small+1) if small > 0 else 0 5979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah s_small = randslice_from_slicelen(slicelen, small) 5989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Create a slice of the same length for the bigger value. 6009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah s_big = randslice_from_slicelen(slicelen, big) 6019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if randrange(2) == 0: 6029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rshape[n], lshape[n] = big, small 6039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rslices[n], lslices[n] = s_big, s_small 6049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 6059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rshape[n], lshape[n] = small, big 6069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rslices[n], lslices[n] = s_small, s_big 6079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lshape, rshape, tuple(lslices), tuple(rslices) 6099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef randitems_from_structure(fmt, t): 6119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return a list of random items for structure 't' with format 6129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'fmtchar'.""" 6139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen, itemsize, _, _, _, _ = t 6149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return gen_items(memlen//itemsize, '#'+fmt, 'numpy') 6159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef ndarray_from_structure(items, fmt, t, flags=0): 6179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return ndarray from the tuple returned by rand_structure()""" 6189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen, itemsize, ndim, shape, strides, offset = t 6199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ndarray(items, shape=shape, strides=strides, format=fmt, 6209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset=offset, flags=ND_WRITABLE|flags) 6219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef numpy_array_from_structure(items, fmt, t): 6239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return numpy_array from the tuple returned by rand_structure()""" 6249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen, itemsize, ndim, shape, strides, offset = t 6259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf = bytearray(memlen) 6269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for j, v in enumerate(items): 6279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct.pack_into(fmt, buf, j*itemsize, v) 6289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return numpy_array(buffer=buf, shape=shape, strides=strides, 6299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dtype=fmt, offset=offset) 6309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 6339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# memoryview casts 6349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 6359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef cast_items(exporter, fmt, itemsize, shape=None): 6379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Interpret the raw memory of 'exporter' as a list of items with 6389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size 'itemsize'. If shape=None, the new structure is assumed to 6399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah be 1-D with n * itemsize = bytelen. If shape is given, the usual 6409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah constraint for contiguous arrays prod(shape) * itemsize = bytelen 6419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah applies. On success, return (items, shape). If the constraints 6429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah cannot be met, return (None, None). If a chunk of bytes is interpreted 6439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah as NaN as a result of float conversion, return ('nan', None).""" 6449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bytelen = exporter.nbytes 6459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if shape: 6469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if prod(shape) * itemsize != bytelen: 6479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return None, shape 6489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif shape == []: 6499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if exporter.ndim == 0 or itemsize != bytelen: 6509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return None, shape 6519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 6529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n, r = divmod(bytelen, itemsize) 6539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = [n] 6549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if r != 0: 6559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return None, shape 6569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mem = exporter.tobytes() 6589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah byteitems = [mem[i:i+itemsize] for i in range(0, len(mem), itemsize)] 6599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [] 6619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for v in byteitems: 6629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah item = struct.unpack(fmt, v)[0] 6639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if item != item: 6649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 'nan', shape 6659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items.append(item) 6669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return (items, shape) if shape != [] else (items[0], shape) 6689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef gencastshapes(): 6709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate shapes to test casting.""" 6719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for n in range(32): 6729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield [n] 6739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = randrange(4, 6) 6749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 1 if randrange(100) > 80 else 2 6759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield [randrange(minshape, 5) for _ in range(ndim)] 6769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = randrange(2, 4) 6779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 1 if randrange(100) > 80 else 2 6789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield [randrange(minshape, 5) for _ in range(ndim)] 6799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 6829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Actual tests 6839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 6849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef genslices(n): 6869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate all possible slices for a single dimension.""" 6879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return product(range(-n, n+1), range(-n, n+1), range(-n, n+1)) 6889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef genslices_ndim(ndim, shape): 6909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate all possible slice tuples for 'shape'.""" 6919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah iterables = [genslices(shape[n]) for n in range(ndim)] 6929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return product(*iterables) 6939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rslice(n, allow_empty=False): 6959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate random slice for a single dimension of length n. 6969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah If zero=True, the slices may be empty, otherwise they will 6979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah be non-empty.""" 6989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minlen = 0 if allow_empty or n == 0 else 1 6999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah slicelen = randrange(minlen, n+1) 7009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return randslice_from_slicelen(slicelen, n) 7019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rslices(n, allow_empty=False): 7039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate random slices for a single dimension.""" 7049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(5): 7059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield rslice(n, allow_empty) 7069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rslices_ndim(ndim, shape, iterations=5): 7089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate random slice tuples for 'shape'.""" 7099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-empty slices 7109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(iterations): 7119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield tuple(rslice(shape[n]) for n in range(ndim)) 7129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # possibly empty slices 7139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(iterations): 7149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield tuple(rslice(shape[n], allow_empty=True) for n in range(ndim)) 7159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid slices 7169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield tuple(slice(0,1,0) for _ in range(ndim)) 7179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rpermutation(iterable, r=None): 7199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah pool = tuple(iterable) 7209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah r = len(pool) if r is None else r 7219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield tuple(sample(pool, r)) 7229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef ndarray_print(nd): 7249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Print ndarray for debugging.""" 7259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 7269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd.tolist() 7279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except (TypeError, NotImplementedError): 7289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd.tobytes() 7299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if isinstance(nd, ndarray): 7309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = nd.offset 7319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags = nd.flags 7329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 7339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = 'unknown' 7349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags = 'unknown' 7359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah print("ndarray(%s, shape=%s, strides=%s, suboffsets=%s, offset=%s, " 7369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah "format='%s', itemsize=%s, flags=%s)" % 7379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (x, nd.shape, nd.strides, nd.suboffsets, offset, 7389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.format, nd.itemsize, flags)) 7399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sys.stdout.flush() 7409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7429a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahITERATIONS = 100 7439a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahMAXDIM = 5 7449a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahMAXSHAPE = 10 7459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahif SHORT_TEST: 7479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ITERATIONS = 10 7489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah MAXDIM = 3 7499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah MAXSHAPE = 4 7509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah genslices = rslices 7519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah genslices_ndim = rslices_ndim 7529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah permutations = rpermutation 7539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah@unittest.skipUnless(struct, 'struct module required for this test.') 7569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah@unittest.skipUnless(ndarray, 'ndarray object required for this test') 7579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahclass TestBufferProtocol(unittest.TestCase): 7589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def setUp(self): 7605d953184a6fae25bf27e769c90b419d9b2aa1af9Stefan Krah # The suboffsets tests need sizeof(void *). 7615d953184a6fae25bf27e769c90b419d9b2aa1af9Stefan Krah self.sizeof_void_p = get_sizeof_void_p() 7629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def verify(self, result, obj=-1, 7649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize={1}, fmt=-1, readonly={1}, 7659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim={1}, shape=-1, strides=-1, 7669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=-1, sliced=False, cast=False): 7679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Verify buffer contents against expected values. Default values 7689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # are deliberately initialized to invalid types. 7699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if shape: 7709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected_len = prod(shape)*itemsize 7719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 7729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not fmt: # array has been implicitly cast to unsigned bytes 7739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected_len = len(lst) 7749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: # ndim = 0 7759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected_len = itemsize 7769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Reconstruct suboffsets from strides. Support for slicing 7789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # could be added, but is currently only needed for test_getbuf(). 7799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah suboffsets = () 7809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if result.suboffsets: 7819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertGreater(ndim, 0) 7829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah suboffset0 = 0 7849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for n in range(1, ndim): 7859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if shape[n] == 0: 7869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah break 7879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[n] <= 0: 7889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah suboffset0 += -strides[n] * (shape[n]-1) 7899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah suboffsets = [suboffset0] + [-1 for v in range(ndim-1)] 7919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Not correct if slicing has occurred in the first dimension. 7939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stride0 = self.sizeof_void_p 7949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[0] < 0: 7959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stride0 = -stride0 7969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = [stride0] + list(strides[1:]) 7979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(result.obj, obj) 7999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.nbytes, expected_len) 8009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.itemsize, itemsize) 8019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.format, fmt) 8029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.readonly, readonly) 8039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.ndim, ndim) 8049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.shape, tuple(shape)) 8059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not (sliced and suboffsets): 8069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.strides, tuple(strides)) 8079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.suboffsets, tuple(suboffsets)) 8089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if isinstance(result, ndarray) or is_memoryview_format(fmt): 8109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rep = result.tolist() if fmt else result.tobytes() 8119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(rep, lst) 8129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not fmt: # array has been cast to unsigned bytes, 8149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return # the remaining tests won't work. 8159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyBuffer_GetPointer() is the definition how to access an item. 8179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # If PyBuffer_GetPointer(indices) is correct for all possible 8189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # combinations of indices, the buffer is correct. 8199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # 8209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Also test tobytes() against the flattened 'lst', with all items 8219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # packed to bytes. 8229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not cast: # casts chop up 'lst' in different ways 8239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytearray() 8249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf_err = None 8259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for ind in indices(shape): 8269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 8279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah item1 = get_pointer(result, ind) 8289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah item2 = get_item(lst, ind) 8299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if isinstance(item2, tuple): 8309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = struct.pack(fmt, *item2) 8319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 8329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = struct.pack(fmt, item2) 8339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b.extend(x) 8349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except BufferError: 8359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf_err = True # re-exporter does not provide full buffer 8369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah break 8379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(item1, item2) 8389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not buf_err: 8409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # test tobytes() 8419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.tobytes(), b) 8429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # lst := expected multi-dimensional logical representation 8449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flatten(lst) := elements in C-order 8459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ff = fmt if fmt else 'B' 8469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flattened = flatten(lst) 8479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Rules for 'A': if the array is already contiguous, return 8499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # the array unaltered. Otherwise, return a contiguous 'C' 8509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # representation. 8519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 8529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected = result 8539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if order == 'F': 8549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_contiguous(result, 'A') or \ 8559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah is_contiguous(result, 'C'): 8569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # For constructing the ndarray, convert the 8579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flattened logical representation to Fortran order. 8589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah trans = transpose(flattened, shape) 8599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected = ndarray(trans, shape=shape, format=ff, 8609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 8619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: # 'C', 'A' 8629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_contiguous(result, 'A') or \ 8639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah is_contiguous(result, 'F') and order == 'C': 8649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # The flattened list is already in C-order. 8659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected = ndarray(flattened, shape=shape, format=ff) 8667d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah contig = get_contiguous(result, PyBUF_READ, order) 8689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(contig.tobytes(), b) 8699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(cmp_contig(contig, expected)) 8709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8717d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if ndim == 0: 8727d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 8737d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8747d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nmemb = len(flattened) 8757d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ro = 0 if readonly else ND_WRITABLE 8767d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8777d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### See comment in test_py_buffer_to_contiguous for an 8787d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### explanation why these tests are valid. 8797d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8807d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # To 'C' 8817d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah contig = py_buffer_to_contiguous(result, 'C', PyBUF_FULL_RO) 8827d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(len(contig), nmemb * itemsize) 88306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [struct.unpack_from(fmt, contig, n*itemsize) 8847d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for n in range(nmemb)] 88506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if len(initlst[0]) == 1: 88606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [v[0] for v in initlst] 8877d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8887d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray(initlst, shape=shape, flags=ro, format=fmt) 8897d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(result)) 8907d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8917d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # To 'F' 8927d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah contig = py_buffer_to_contiguous(result, 'F', PyBUF_FULL_RO) 8937d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(len(contig), nmemb * itemsize) 89406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [struct.unpack_from(fmt, contig, n*itemsize) 8957d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for n in range(nmemb)] 89606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if len(initlst[0]) == 1: 89706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [v[0] for v in initlst] 8987d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8997d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray(initlst, shape=shape, flags=ro|ND_FORTRAN, 9007d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah format=fmt) 9017d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(result)) 9027d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 9037d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # To 'A' 9047d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah contig = py_buffer_to_contiguous(result, 'A', PyBUF_FULL_RO) 9057d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(len(contig), nmemb * itemsize) 90606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [struct.unpack_from(fmt, contig, n*itemsize) 9077d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for n in range(nmemb)] 90806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if len(initlst[0]) == 1: 90906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [v[0] for v in initlst] 9107d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 9117d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah f = ND_FORTRAN if is_contiguous(result, 'F') else 0 9127d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray(initlst, shape=shape, flags=f|ro, format=fmt) 9137d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(result)) 9147d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 9159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 9169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 9179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(result) 9189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except BufferError: # re-exporter does not provide full information 9199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 9209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = result.obj if isinstance(result, memoryview) else result 9219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(m.obj, ex) 9229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.nbytes, expected_len) 9239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.itemsize, itemsize) 9249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.format, fmt) 9259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.readonly, readonly) 9269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.ndim, ndim) 9279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.shape, tuple(shape)) 9289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not (sliced and suboffsets): 9299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.strides, tuple(strides)) 9309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.suboffsets, tuple(suboffsets)) 9319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = 1 if ndim == 0 else len(lst) 9339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(len(m), n) 9349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rep = result.tolist() if fmt else result.tobytes() 9369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(rep, lst) 9379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, result) 9389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def verify_getbuf(self, orig_ex, ex, req, sliced=False): 9409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def simple_fmt(ex): 9419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ex.format == '' or ex.format == 'B' 9429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def match(req, flag): 9439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ((req&flag) == flag) 9449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if (# writable request to read-only exporter 9469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (ex.readonly and match(req, PyBUF_WRITABLE)) or 9479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cannot match explicit contiguity request 9489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (match(req, PyBUF_C_CONTIGUOUS) and not ex.c_contiguous) or 9499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (match(req, PyBUF_F_CONTIGUOUS) and not ex.f_contiguous) or 9509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (match(req, PyBUF_ANY_CONTIGUOUS) and not ex.contiguous) or 9519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # buffer needs suboffsets 9529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (not match(req, PyBUF_INDIRECT) and ex.suboffsets) or 9539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # buffer without strides must be C-contiguous 9549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (not match(req, PyBUF_STRIDES) and not ex.c_contiguous) or 9559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyBUF_SIMPLE|PyBUF_FORMAT and PyBUF_WRITABLE|PyBUF_FORMAT 9569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (not match(req, PyBUF_ND) and match(req, PyBUF_FORMAT))): 9579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=req) 9599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 9609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if isinstance(ex, ndarray) or is_memoryview_format(ex.format): 9629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = ex.tolist() 9639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 9649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_FULL_RO) 9659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = nd.tolist() 9669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # The consumer may have requested default values or a NULL format. 9689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ro = 0 if match(req, PyBUF_WRITABLE) else ex.readonly 9699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt = ex.format 9709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = ex.itemsize 9719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = ex.ndim 9729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not match(req, PyBUF_FORMAT): 9739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # itemsize refers to the original itemsize before the cast. 9749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # The equality product(shape) * itemsize = len still holds. 9759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # The equality calcsize(format) = itemsize does _not_ hold. 9769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt = '' 9779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = orig_ex.tobytes() # Issue 12834 9789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not match(req, PyBUF_ND): 9799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = 1 9809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = orig_ex.shape if match(req, PyBUF_ND) else () 9819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = orig_ex.strides if match(req, PyBUF_STRIDES) else () 9829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=req) 9849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=ex, 9859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=ro, 9869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 9879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, sliced=sliced) 9889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_getbuf(self): 9909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah requests = ( 9919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # distinct flags 9929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_INDIRECT, PyBUF_STRIDES, PyBUF_ND, PyBUF_SIMPLE, 9939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_C_CONTIGUOUS, PyBUF_F_CONTIGUOUS, PyBUF_ANY_CONTIGUOUS, 9949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # compound requests 9959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_FULL, PyBUF_FULL_RO, 9969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_RECORDS, PyBUF_RECORDS_RO, 9979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_STRIDED, PyBUF_STRIDED_RO, 9989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_CONTIG, PyBUF_CONTIG_RO, 9999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 10009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # items and format 10019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items_fmt = ( 10029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([True if x % 2 else False for x in range(12)], '?'), 10039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([1,2,3,4,5,6,7,8,9,10,11,12], 'b'), 10049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([1,2,3,4,5,6,7,8,9,10,11,12], 'B'), 10059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([(2**31-x) if x % 2 else (-2**31+x) for x in range(12)], 'l') 10069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 10079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # shape, strides, offset 10089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah structure = ( 10099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([], [], 0), 10109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([12], [], 0), 10119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([12], [-1], 11), 10129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([6], [2], 0), 10139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([6], [-2], 11), 10149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([3, 4], [], 0), 10159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([3, 4], [-4, -1], 11), 10169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([2, 2], [4, 1], 4), 10179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([2, 2], [-4, -1], 8) 10189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 10199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndarray creation flags 10209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndflags = ( 10219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 0, ND_WRITABLE, ND_FORTRAN, ND_FORTRAN|ND_WRITABLE, 10229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ND_PIL, ND_PIL|ND_WRITABLE 10239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 10249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flags that can actually be used as flags 10259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah real_flags = (0, PyBUF_WRITABLE, PyBUF_FORMAT, 10269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_WRITABLE|PyBUF_FORMAT) 10279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for items, fmt in items_fmt: 10299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 10309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape, strides, offset in structure: 10319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = [v * itemsize for v in strides] 10329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset *= itemsize 10339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in ndflags: 10349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides and (flags&ND_FORTRAN): 10369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 10379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not shape and (flags&ND_PIL): 10389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 10399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah _items = items if shape else items[0] 10419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(_items, format=fmt, flags=flags, 10429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape=shape, strides=strides, offset=offset) 10439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ex1[::-2] if shape else None 10449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(ex1) 10469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ex2: 10479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(ex2) 10489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ex1.ndim == 0 or (ex1.ndim == 1 and shape and strides): 10499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, ex1) 10509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ex2 and ex2.ndim == 1 and shape and strides: 10519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m2, ex2) 10529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for req in requests: 10549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for bits in real_flags: 10559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify_getbuf(ex1, ex1, req|bits) 10569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify_getbuf(ex1, m1, req|bits) 10579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ex2: 10589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify_getbuf(ex2, ex2, req|bits, 10599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sliced=True) 10609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify_getbuf(ex2, m2, req|bits, 10619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sliced=True) 10629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10,11,12] 10649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_GETBUF_FAIL 10669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[12], flags=ND_GETBUF_FAIL) 10679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex) 10689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Request complex structure from a simple exporter. In this 10709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # particular case the test object is not PEP-3118 compliant. 10719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah base = ndarray([9], [1]) 10729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(base, getbuf=PyBUF_SIMPLE) 10739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_WRITABLE) 10749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_ND) 10759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_STRIDES) 10769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_C_CONTIGUOUS) 10779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_F_CONTIGUOUS) 10789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_ANY_CONTIGUOUS) 10799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 10809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_exceptions(self): 10829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([9], [1]) 10839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndm = ndarray([9], [1], flags=ND_VAREXPORT) 10849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Initialization of a new ndarray or mutation of an existing array. 10869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for c in (ndarray, nd.push, ndm.push): 10879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid types. 10889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, {1,2,3}) 10899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,'3']) 10909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,(3,4)]) 10919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,3], shape={3}) 10929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,3], shape=[3], strides={1}) 10939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,3], shape=[3], offset=[]) 10949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], format={}) 10959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], flags={}) 10969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], getbuf={}) 10979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_FORTRAN flag is only valid without strides. 10999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], strides=[1], 11009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 11019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_PIL flag is only valid with ndim > 0. 11039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[], flags=ND_PIL) 11049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid items. 11069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [], shape=[1]) 11079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, ['XXX'], shape=[1], format="L") 11089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid combination of items and format. 11099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(struct.error, c, [1000], shape=[1], format="B") 11109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,(2,3)], shape=[2], format="B") 11119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[3], format="QL") 11129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid ndim. 11149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = ND_MAX_NDIM+1 11159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1]*n, shape=[1]*n) 11169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid shape. 11189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1], shape=[-1]) 11199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=['3']) 11209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, c, [1], shape=[2**128]) 11219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # prod(shape) * itemsize != len(items) 11229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3,4,5], shape=[2,2], offset=3) 11239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid strides. 11259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[3], strides=['1']) 11269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, c, [1], shape=[1], 11279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides=[2**128]) 11289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid combination of strides and shape. 11309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2], shape=[2,1], strides=[1]) 11319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid combination of strides and format. 11329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3,4], shape=[2], strides=[3], 11339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format="L") 11349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid offset. 11369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[3], offset=4) 11379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[1], offset=3, 11389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format="L") 11399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid format. 11419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[3], format="") 11429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(struct.error, c, [(1,2,3)], shape=[1], 11439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format="@#$") 11449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Striding out of the memory bounds. 11469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10] 11479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, items, shape=[2,3], 11489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides=[-3, -2], offset=5) 11499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Constructing consumer: format argument invalid. 11519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, bytearray(), format="Q") 11529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Constructing original base object: getbuf argument invalid. 11549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], getbuf=PyBUF_FULL) 11559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Shape argument is mandatory for original base objects. 11579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1]) 11589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyBUF_WRITABLE request to read-only provider. 11619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, b'123', getbuf=PyBUF_WRITABLE) 11629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_VAREXPORT can only be specified during construction. 11649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([9], [1], flags=ND_VAREXPORT) 11659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.push, [1], [1], flags=ND_VAREXPORT) 11669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid operation for consumers: push/pop 11689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(b'123') 11699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.push, [1], [1]) 11709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.pop) 11719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_VAREXPORT not set: push/pop fail with exported buffers 11739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([9], [1]) 11749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.push([1], [1]) 11759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 11769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.push, [1], [1]) 11779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.pop) 11789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m.release() 11799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.pop() 11809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Single remaining buffer: pop fails 11829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.pop) 11839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 11849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # get_pointer() 11869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_pointer, {}, [1,2,3]) 11879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_pointer, b'123', {}) 11889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(100)), shape=[1]*100) 11909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_pointer, nd, [5]) 11919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3,4]) 11939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_pointer, nd, [2,3,4]) 11949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_pointer, nd, [3,3]) 11959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_pointer, nd, [-3,3]) 11969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, get_pointer, nd, [1<<64,3]) 11979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # tolist() needs format 11999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([1,2,3], shape=[3], format='L') 12009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 12019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.tolist) 12029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview_from_buffer() 12049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray([1,2,3], shape=[3], format='L') 12059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ndarray(ex1) 12069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex2) 12079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.memoryview_from_buffer) 12089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([(1,)*200], shape=[1], format='L'*200) 12109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.memoryview_from_buffer) 12119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = ND_MAX_NDIM 12139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(n)), shape=[1]*n) 12149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.memoryview_from_buffer) 12159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # get_contiguous() 12179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1]) 12189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_contiguous, 1, 2, 3, 4, 5) 12199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_contiguous, nd, "xyz", 'C') 12209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, get_contiguous, nd, 2**64, 'C') 12219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_contiguous, nd, PyBUF_READ, 961) 12229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(UnicodeEncodeError, get_contiguous, nd, PyBUF_READ, 12239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '\u2007') 122466e63170d9aa8cf41a772b0d22b20c47636d24f5Stefan Krah self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'Z') 122566e63170d9aa8cf41a772b0d22b20c47636d24f5Stefan Krah self.assertRaises(ValueError, get_contiguous, nd, 255, 'A') 12269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cmp_contig() 12289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1]) 12299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, cmp_contig, 1, 2, 3, 4, 5) 12309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, cmp_contig, {}, nd) 12319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, cmp_contig, nd, {}) 12329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # is_contiguous() 12349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1]) 12359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, is_contiguous, 1, 2, 3, 4, 5) 12369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, is_contiguous, {}, 'A') 12379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, is_contiguous, nd, 201) 12389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_linked_list(self): 12409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for perm in permutations(range(5)): 12419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = [0]*5 12429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[3], flags=ND_VAREXPORT) 12439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[0] = memoryview(nd) 12449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(1, 5): 12469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.push([1,2,3], shape=[3]) 12479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[i] = memoryview(nd) 12489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(5): 12509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[perm[i]].release() 12519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.pop) 12539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 12549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_format_scalar(self): 12569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 0: scalar 12579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, scalar, _ in iter_format(0): 12589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 12599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(scalar, shape=(), format=fmt) 12609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 12619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 12629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=0, shape=(), strides=(), 12639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=scalar) 12649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_format_shape(self): 12669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 1, shape = [n] 12679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = randrange(1, 10) 12689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(nitems): 12699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 12709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 12719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[nitems], format=fmt, flags=flags) 12729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 12739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 12749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=(nitems,), strides=(itemsize,), 12759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=items) 12769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_format_strides(self): 12789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 1, strides 12799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = randrange(1, 30) 12809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(nitems): 12819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 12829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for step in range(-5, 5): 12839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if step == 0: 12849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 12859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = [len(items[::step])] 12879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = [step*itemsize] 12889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = itemsize*(nitems-1) if step < 0 else 0 12899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 12919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, strides=strides, 12929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format=fmt, offset=offset, flags=flags) 12939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 12949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 12959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=shape, strides=strides, 12969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=items[::step]) 12979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_fortran(self): 12999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10,11,12] 13009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=(3, 4), strides=(1, 3)) 13019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_F_CONTIGUOUS|PyBUF_FORMAT) 13029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), farray(items, (3, 4))) 13039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_multidim(self): 13059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for ndim in range(5): 13069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = [randrange(2, 10) for _ in range(ndim)] 13079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 13089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 13099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 13119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 13129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 13149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ndim == 0 and flags == ND_PIL: 13159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 13169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C array 13189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, flags=flags) 13199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = strides_from_shape(ndim, shape, itemsize, 'C') 13219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 13229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 13239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 13249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 13259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 13269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 13289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview: reconstruct strides 13299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, format=fmt) 13309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO|PyBUF_FORMAT) 13319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(nd.strides == ()) 13329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = nd.memoryview_from_buffer() 13339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(mv, obj=None, 13349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 13359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 13369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 13379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran array 13399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, 13409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=flags|ND_FORTRAN) 13419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = strides_from_shape(ndim, shape, itemsize, 'F') 13439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = farray(items, shape) 13449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 13459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 13469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 13479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 13489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_invalid(self): 13509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # not writable 13519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1]) 13529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__setitem__, 1, 8) 13539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 13549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 13559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__setitem__, 1, 8) 13569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cannot be deleted 13589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1], flags=ND_WRITABLE) 13599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__delitem__, 1) 13609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 13619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 13629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__delitem__, 1) 13639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # overflow 13659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1], flags=ND_WRITABLE) 13669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, nd.__getitem__, 1<<64) 13679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, nd.__setitem__, 1<<64, 8) 13689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 13699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 13709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__getitem__, 1<<64) 13719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__setitem__, 1<<64, 8) 13729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # format 13749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8] 13759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[len(items)], format="B", flags=ND_WRITABLE) 13769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(struct.error, nd.__setitem__, 2, 300) 13779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__setitem__, 1, (100, 200)) 13789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 13799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 13809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, mv.__setitem__, 2, 300) 13819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__setitem__, 1, (100, 200)) 13829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [(1,2), (3,4), (5,6)] 13849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[len(items)], format="LQ", flags=ND_WRITABLE) 13859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__setitem__, 2, 300) 13869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(struct.error, nd.__setitem__, 1, (b'\x001', 200)) 13879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_scalar(self): 13899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # scalar 13909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(1, shape=(), flags=ND_WRITABLE) 13919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 13929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 13939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd[()]; self.assertEqual(x, 1) 13959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd[...]; self.assertEqual(x.tolist(), nd.tolist()) 13969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = mv[()]; self.assertEqual(x, 1) 13989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = mv[...]; self.assertEqual(x.tolist(), nd.tolist()) 13999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__getitem__, 0) 14019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__getitem__, 0) 14029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__setitem__, 0, 8) 14039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__setitem__, 0, 8) 14049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), 1) 14069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), 1) 14079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[()] = 9; self.assertEqual(nd.tolist(), 9) 14099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[()] = 9; self.assertEqual(mv.tolist(), 9) 14109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[...] = 5; self.assertEqual(nd.tolist(), 5) 14129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[...] = 5; self.assertEqual(mv.tolist(), 5) 14139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_null_strides(self): 14159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(2*4)), shape=[2, 4], flags=ND_WRITABLE) 14169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG) 14179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Sub-views are only possible for full exporters. 14199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.__getitem__, 1) 14209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Same for slices. 14219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.__getitem__, slice(3,5,1)) 14229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_getitem_single(self): 14249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getitem 14259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(5): 14269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt) 14279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], items[i]) 14299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, nd.__getitem__, -6) 14319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, nd.__getitem__, 5) 14329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 14349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 14359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 14369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv[i], items[i]) 14389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__getitem__, -6) 14409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__getitem__, 5) 14419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getitem with null strides 14439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(5): 14449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[5], flags=ND_WRITABLE, format=fmt) 14459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG|PyBUF_FORMAT) 14469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], items[i]) 14499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 14519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = nd.memoryview_from_buffer() 14529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(mv.__eq__(nd), NotImplemented) 14539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv[i], items[i]) 14559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getitem with null format 14579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5] 14589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[5]) 14599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO) 14609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], items[i]) 14629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getitem with null shape/strides/format 14649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5] 14659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[5]) 14669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 14679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], items[i]) 14709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_setitem_single(self): 14729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # assign single value 14739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, single_item in iter_format(5): 14749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE) 14759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(5): 14769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items[i] = single_item 14779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[i] = single_item 14789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), items) 14799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, nd.__setitem__, -6, single_item) 14819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, nd.__setitem__, 5, single_item) 14829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_memoryview_format(fmt): 14849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 14859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE) 14879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 14889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 14899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(5): 14909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items[i] = single_item 14919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[i] = single_item 14929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), items) 14939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__setitem__, -6, single_item) 14959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__setitem__, 5, single_item) 14969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # assign single value: lobject = robject 14999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, single_item in iter_format(5): 15009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE) 15019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 4): 15029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items[i] = items[i+1] 15039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[i] = nd[i+1] 15049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), items) 15059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_memoryview_format(fmt): 15079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 15089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE) 15109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 15129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 4): 15139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items[i] = items[i+1] 15149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[i] = mv[i+1] 15159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), items) 15169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_getitem_multidim(self): 15189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = (2, 3, 5) 15199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 15209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 15219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 15239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 15259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C array 15269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, flags=flags) 15279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 15289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-shape[0], shape[0]): 15309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i], nd[i].tolist()) 15319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for j in range(-shape[1], shape[1]): 15329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i][j], nd[i][j].tolist()) 15339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for k in range(-shape[2], shape[2]): 15349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i][j][k], nd[i][j][k]) 15359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran array 15379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, 15389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=flags|ND_FORTRAN) 15399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = farray(items, shape) 15409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-shape[0], shape[0]): 15429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i], nd[i].tolist()) 15439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for j in range(-shape[1], shape[1]): 15449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i][j], nd[i][j].tolist()) 15459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for k in range(shape[2], shape[2]): 15469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i][j][k], nd[i][j][k]) 15479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_sequence(self): 15499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(1, shape=()) 15509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, eval, "1 in nd", locals()) 15519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 15539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, eval, "1 in mv", locals()) 15549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(5): 15569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt) 15579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i, v in enumerate(nd): 15589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, items[i]) 15599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(v in nd) 15609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 15629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i, v in enumerate(mv): 15649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, items[i]) 15659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(v in mv) 15669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_invalid(self): 15689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8] 15699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # rvalue is not an exporter 15719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], flags=ND_WRITABLE) 15729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 15739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, xl.__setitem__, slice(0,8,1), items) 15749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, ml.__setitem__, slice(0,8,1), items) 15759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # rvalue is not a full exporter 15779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], flags=ND_WRITABLE) 15789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[8], flags=ND_WRITABLE) 15799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray(ex, getbuf=PyBUF_ND) 15809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, xl.__setitem__, slice(0,8,1), xr) 15819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zero step 15839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[8], format="L", flags=ND_WRITABLE) 15849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__getitem__, slice(0,1,0)) 15869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, mv.__getitem__, slice(0,1,0)) 15879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[2,4], format="L", flags=ND_WRITABLE) 15899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__getitem__, 15929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,1,1), slice(0,1,0))) 15939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__getitem__, 15949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,1,0), slice(0,1,1))) 15959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__getitem__, "@%$") 15969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__getitem__, ("@%$", slice(0,1,1))) 15979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__getitem__, (slice(0,1,1), {})) 15989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview: not implemented 16009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, mv.__getitem__, 16019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,1,1), slice(0,1,0))) 16029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__getitem__, "@%$") 16039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # differing format 16059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], format="B", flags=ND_WRITABLE) 16069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray(items, shape=[8], format="b") 16079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 16089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 16099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8]) 16109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xl.tolist(), items) 16119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, ml.__setitem__, slice(0,1,1), mr[7:8]) 16129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), items) 16139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # differing itemsize 16159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], format="B", flags=ND_WRITABLE) 16169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yr = ndarray(items, shape=[8], format="L") 16179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 16189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 16199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8]) 16209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xl.tolist(), items) 16219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, ml.__setitem__, slice(0,1,1), mr[7:8]) 16229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), items) 16239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # differing ndim 16259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[2, 4], format="b", flags=ND_WRITABLE) 16269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray(items, shape=[8], format="b") 16279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 16289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 16299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8]) 16309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xl.tolist(), [[1,2,3,4], [5,6,7,8]]) 16319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, ml.__setitem__, slice(0,1,1), 16329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr[7:8]) 16339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # differing shape 16359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], format="b", flags=ND_WRITABLE) 16369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray(items, shape=[8], format="b") 16379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 16389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 16399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, xl.__setitem__, slice(0,2,1), xr[7:8]) 16409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xl.tolist(), items) 16419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, ml.__setitem__, slice(0,2,1), mr[7:8]) 16429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), items) 16439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # _testbuffer.c module functions 16459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, slice_indices, slice(0,1,2), {}) 16469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, slice_indices, "###########", 1) 16479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, slice_indices, slice(0,1,0), 4) 16489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(items, shape=[8], format="b", flags=ND_PIL) 16509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, x.add_suboffsets) 16519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[8], format="B") 16539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(ex, getbuf=PyBUF_SIMPLE) 16549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, x.add_suboffsets) 16559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_zero_shape(self): 16579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10,11,12] 16589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(items, shape=[12], format="L", flags=ND_WRITABLE) 16609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = ndarray(items, shape=[12], format="L") 16619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x[4:4] = y[9:9] 16629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(x.tolist(), items) 16639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(x) 16659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(y) 16669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml, x) 16679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml, y) 16689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml[4:4] = mr[9:9] 16699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), items) 16709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(items, shape=[3, 4], format="L", flags=ND_WRITABLE) 16729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = ndarray(items, shape=[4, 3], format="L") 16739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x[1:2, 2:2] = y[1:2, 3:3] 16749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(x.tolist(), carray(items, [3, 4])) 16759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_multidim(self): 16779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = (2, 3, 5) 16789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape_t) 16799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 16809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 16819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 16839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 16849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 16869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, flags=flags) 16879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 16889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for slices in rslices_ndim(ndim, shape): 16909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = None 16929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 16939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sliced = multislice(lst, slices) 16949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 16959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = e.__class__ 16969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = None 16989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 16999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndsliced = nd[slices] 17009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 17029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if nderr or listerr: 17049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, listerr) 17059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 17069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndsliced.tolist(), sliced) 17079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_redundant_suboffsets(self): 17099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = (2, 3, 5, 2) 17109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape_t) 17119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 17129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 17139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 17159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 17169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt) 17189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.add_suboffsets() 17199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, format=fmt) 17209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex.add_suboffsets() 17219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(ex) 17229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 17239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for slices in rslices_ndim(ndim, shape): 17259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = None 17279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sliced = multislice(lst, slices) 17299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = e.__class__ 17319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = None 17339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndsliced = nd[slices] 17359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 17379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if nderr or listerr: 17399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, listerr) 17409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 17419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndsliced.tolist(), sliced) 17429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_assign_single(self): 17449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(5): 17459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for lslice in genslices(5): 17469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for rslice in genslices(5): 17479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 17489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah f = flags|ND_WRITABLE 17509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=f) 17519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[5], format=fmt, flags=f) 17529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(ex) 17539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lsterr = None 17559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah diff_structure = None 17569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = items[:] 17579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lval = lst[lslice] 17599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rval = lst[rslice] 17609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst[lslice] = lst[rslice] 17619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah diff_structure = len(lval) != len(rval) 17629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lsterr = e.__class__ 17649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = None 17669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[lslice] = nd[rslice] 17689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 17709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if diff_structure: # ndarray cannot change shape 17729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, ValueError) 17739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 17749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), lst) 17759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, lsterr) 17769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_memoryview_format(fmt): 17789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 17799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mverr = None 17819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[lslice] = mv[rslice] 17839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mverr = e.__class__ 17859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if diff_structure: # memoryview cannot change shape 17879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(mverr, ValueError) 17889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 17899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), lst) 17909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 17919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(mverr, lsterr) 17929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(mv, obj=ex, 17939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=nd.itemsize, fmt=fmt, readonly=0, 17949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=nd.ndim, shape=nd.shape, strides=nd.strides, 17959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=nd.tolist()) 17969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_assign_multidim(self): 17989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = (2, 3, 5) 17999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape_t) 18009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 18019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 18029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 18049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 18069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(ITERATIONS): 18079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices, rslices = randslice_from_shape(ndim, shape) 18089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, 18109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=flags|ND_WRITABLE) 18119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 18129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = None 18149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 18159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah result = multislice_assign(lst, lst, lslices, rslices) 18169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 18179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = e.__class__ 18189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = None 18209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 18219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[lslices] = nd[rslices] 18229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 18239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 18249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if nderr or listerr: 18269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, listerr) 18279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 18289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), result) 18299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_random(self): 18319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # construction of valid arrays 18329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(ITERATIONS): 18339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 18349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 18359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah t = rand_structure(itemsize, True, maxdim=MAXDIM, 18379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxshape=MAXSHAPE) 18389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(verify_structure(*t)) 18399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = randitems_from_structure(fmt, t) 18409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray_from_structure(items, fmt, t) 18429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xlist = x.tolist() 18439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(x) 18459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 18469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mvlist = mv.tolist() 18479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mvlist, xlist) 18489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if t[2] > 0: 18509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim > 0: test against suboffsets representation. 18519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = ndarray_from_structure(items, fmt, t, flags=ND_PIL) 18529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ylist = y.tolist() 18539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xlist, ylist) 18549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(y) 18569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 18579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, y) 18589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mvlist = mv.tolist() 18599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mvlist, ylist) 18609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if numpy_array: 18629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = t[3] 18639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 0 in shape: 18649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue # http://projects.scipy.org/numpy/ticket/1910 18659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah z = numpy_array_from_structure(items, fmt, t) 18669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(x, obj=None, 18679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=z.itemsize, fmt=fmt, readonly=0, 18689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=z.ndim, shape=z.shape, strides=z.strides, 18699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=z.tolist()) 18709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_random_invalid(self): 18729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # exceptions during construction of invalid arrays 18739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(ITERATIONS): 18749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 18759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 18769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah t = rand_structure(itemsize, False, maxdim=MAXDIM, 18789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxshape=MAXSHAPE) 18799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(verify_structure(*t)) 18809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = randitems_from_structure(fmt, t) 18819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = False 18839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 18849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray_from_structure(items, fmt, t) 18859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 18869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 18879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(nderr) 18889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if numpy_array: 18909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah numpy_err = False 18919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 18929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = numpy_array_from_structure(items, fmt, t) 18939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 18949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah numpy_err = e.__class__ 18959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 0: # http://projects.scipy.org/numpy/ticket/1910 18979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(numpy_err) 18989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_random_slice_assign(self): 19009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # valid slice assignments 19019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(ITERATIONS): 19029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 19039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 19049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lshape, rshape, lslices, rslices = \ 19069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rand_aligned_slices(maxdim=MAXDIM, maxshape=MAXSHAPE) 19079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tl = rand_structure(itemsize, True, shape=lshape) 19089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tr = rand_structure(itemsize, True, shape=rshape) 19099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(verify_structure(*tl)) 19109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(verify_structure(*tr)) 19119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah litems = randitems_from_structure(fmt, tl) 19129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ritems = randitems_from_structure(fmt, tr) 19139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray_from_structure(litems, fmt, tl) 19159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray_from_structure(ritems, fmt, tr) 19169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl[lslices] = xr[rslices] 19179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xllist = xl.tolist() 19189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xrlist = xr.tolist() 19199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 19219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 19229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), xllist) 19239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mr.tolist(), xrlist) 19249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if tl[2] > 0 and tr[2] > 0: 19269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim > 0: test against suboffsets representation. 19279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yl = ndarray_from_structure(litems, fmt, tl, flags=ND_PIL) 19289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yr = ndarray_from_structure(ritems, fmt, tr, flags=ND_PIL) 19299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yl[lslices] = yr[rslices] 19309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yllist = yl.tolist() 19319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yrlist = yr.tolist() 19329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xllist, yllist) 19339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xrlist, yrlist) 19349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(yl) 19369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(yr) 19379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), yllist) 19389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mr.tolist(), yrlist) 19399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if numpy_array: 19419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 0 in lshape or 0 in rshape: 19429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue # http://projects.scipy.org/numpy/ticket/1910 19439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah zl = numpy_array_from_structure(litems, fmt, tl) 19459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah zr = numpy_array_from_structure(ritems, fmt, tr) 19469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah zl[lslices] = zr[rslices] 19479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_overlapping(tl) and not is_overlapping(tr): 19499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Slice assignment of overlapping structures 19509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # is undefined in NumPy. 19519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(xl, obj=None, 19529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=zl.itemsize, fmt=fmt, readonly=0, 19539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=zl.ndim, shape=zl.shape, 19549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides=zl.strides, lst=zl.tolist()) 19559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(xr, obj=None, 19579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=zr.itemsize, fmt=fmt, readonly=0, 19589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=zr.ndim, shape=zr.shape, 19599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides=zr.strides, lst=zr.tolist()) 19609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_re_export(self): 19629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10,11,12] 19639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[3,4], flags=ND_PIL) 19659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(nd) 19669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(ex.flags & ND_PIL) 19689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(ex.obj, nd) 19699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ex.suboffsets, (0, -1)) 19709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(ex.c_contiguous) 19719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(ex.f_contiguous) 19729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(ex.contiguous) 19739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_zero_shape(self): 19759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zeros in shape 19769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 19779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[0], flags=flags) 19789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 19799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 19809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), []) 19819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), []) 19829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[0,3,3], flags=flags) 19849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), []) 19859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[3,0,3], flags=flags) 19879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), [[], [], []]) 19889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[3,3,0], flags=flags) 19909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), 19919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [[[], [], []], [[], [], []], [[], [], []]]) 19929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_zero_strides(self): 19949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zero strides 19959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 19969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[5], strides=[0], flags=flags) 19979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 19989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 19999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), [1, 1, 1, 1, 1]) 20009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), [1, 1, 1, 1, 1]) 20019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_offset(self): 20039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(20)), shape=[3], offset=7) 20049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.offset, 7) 20059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), [7,8,9]) 20069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_memoryview_from_buffer(self): 20089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 20099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(3)), shape=[3], flags=flags) 20109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = nd.memoryview_from_buffer() 20119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 20129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_get_pointer(self): 20149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 20159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(3)), shape=[3], flags=flags) 20169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(3): 20179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], get_pointer(nd, [i])) 20189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_tolist_null_strides(self): 20209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(20)), shape=[2,2,5]) 20219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_ND|PyBUF_FORMAT) 20239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), ex.tolist()) 20249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 20269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), ex.tolist()) 20279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_cmp_contig(self): 20299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(cmp_contig(b"123", b"456")) 20319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(list(range(12)), shape=[3,4]) 20339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = ndarray(list(range(12)), shape=[4,3]) 20349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(cmp_contig(x, y)) 20359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray([1], shape=[1], format="B") 20379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(cmp_contig(x, b'\x01')) 20389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(cmp_contig(b'\x01', x)) 20399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_hash(self): 20419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('L', [1,2,3]) 20439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(a) 20449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, hash, nd) 20459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # one-dimensional 20479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(list(range(12))) 20489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[12]) 20509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C-contiguous 20539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3,4]) 20549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3,2,2]) 20579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran contiguous 20609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(transpose(list(range(12)), shape=[4,3])) 20619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3,4], flags=ND_FORTRAN) 20629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(transpose(list(range(12)), shape=[2,3,2])) 20659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,3,2], flags=ND_FORTRAN) 20669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # suboffsets 20699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(list(range(12))) 20709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,2,3], flags=ND_PIL) 20719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-byte formats 20749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,2,3], format='L') 20759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(nd.tobytes())) 20769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20777d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah def test_py_buffer_to_contiguous(self): 20787d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 20797d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # The requests are used in _testbuffer.c:py_buffer_to_contiguous 20807d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # to generate buffers without full information for testing. 20817d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah requests = ( 20827d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # distinct flags 20837d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_INDIRECT, PyBUF_STRIDES, PyBUF_ND, PyBUF_SIMPLE, 20847d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # compound requests 20857d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_FULL, PyBUF_FULL_RO, 20867d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_RECORDS, PyBUF_RECORDS_RO, 20877d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_STRIDED, PyBUF_STRIDED_RO, 20887d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_CONTIG, PyBUF_CONTIG_RO, 20897d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ) 20907d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 20917d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # no buffer interface 20927d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertRaises(TypeError, py_buffer_to_contiguous, {}, 'F', 20937d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_FULL_RO) 20947d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 20957d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # scalar, read-only request 20967d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray(9, shape=(), format="L", flags=ND_WRITABLE) 20977d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 20987d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 20997d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21007d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, nd.tobytes()) 21017d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21027d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # zeros in shape 21037d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray([1], shape=[0], format="L", flags=ND_WRITABLE) 21047d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21057d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21067d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21077d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, b'') 21087d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21097d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray(list(range(8)), shape=[2, 0, 7], format="L", 21107d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah flags=ND_WRITABLE) 21117d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21127d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21137d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21147d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, b'') 21157d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21167d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### One-dimensional arrays are trivial, since Fortran and C order 21177d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### are the same. 21187d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21197d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # one-dimensional 21207d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for f in [0, ND_FORTRAN]: 21217d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray([1], shape=[1], format="h", flags=f|ND_WRITABLE) 21227d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ndbytes = nd.tobytes() 21237d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21247d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21257d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21267d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, ndbytes) 21277d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21287d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray([1, 2, 3], shape=[3], format="b", flags=f|ND_WRITABLE) 21297d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ndbytes = nd.tobytes() 21307d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21317d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21327d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21337d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, ndbytes) 21347d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21357d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # one-dimensional, non-contiguous input 21367d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray([1, 2, 3], shape=[2], strides=[2], flags=ND_WRITABLE) 21377d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ndbytes = nd.tobytes() 21387d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21397d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in [PyBUF_STRIDES, PyBUF_FULL]: 21407d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21417d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, ndbytes) 21427d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21437d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = nd[::-1] 21447d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ndbytes = nd.tobytes() 21457d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21467d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21477d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah try: 21487d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21497d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah except BufferError: 21507d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 21517d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, ndbytes) 21527d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21537d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21547d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### Multi-dimensional arrays: 21557d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21567d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### The goal here is to preserve the logical representation of the 21577d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### input array but change the physical representation if necessary. 21587d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21597d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### _testbuffer example: 21607d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### ==================== 21617d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21627d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### C input array: 21637d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### -------------- 21647d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd = ndarray(list(range(12)), shape=[3, 4]) 21657d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd.tolist() 21667d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [[0, 1, 2, 3], 21677d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [4, 5, 6, 7], 21687d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [8, 9, 10, 11]] 21697d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21707d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### Fortran output: 21717d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### --------------- 21727d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> py_buffer_to_contiguous(nd, 'F', PyBUF_FULL_RO) 21737d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> b'\x00\x04\x08\x01\x05\t\x02\x06\n\x03\x07\x0b' 21747d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21757d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### The return value corresponds to this input list for 21767d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### _testbuffer's ndarray: 21777d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd = ndarray([0,4,8,1,5,9,2,6,10,3,7,11], shape=[3,4], 21787d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### flags=ND_FORTRAN) 21797d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd.tolist() 21807d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [[0, 1, 2, 3], 21817d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [4, 5, 6, 7], 21827d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [8, 9, 10, 11]] 21837d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21847d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### The logical array is the same, but the values in memory are now 21857d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### in Fortran order. 21867d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21877d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### NumPy example: 21887d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### ============== 21897d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### _testbuffer's ndarray takes lists to initialize the memory. 21907d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### Here's the same sequence in NumPy: 21917d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21927d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### C input: 21937d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### -------- 21947d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd = ndarray(buffer=bytearray(list(range(12))), 21957d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### shape=[3, 4], dtype='B') 21967d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd 21977d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### array([[ 0, 1, 2, 3], 21987d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [ 4, 5, 6, 7], 21997d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [ 8, 9, 10, 11]], dtype=uint8) 22007d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22017d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### Fortran output: 22027d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### --------------- 22037d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> fortran_buf = nd.tostring(order='F') 22047d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> fortran_buf 22057d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### b'\x00\x04\x08\x01\x05\t\x02\x06\n\x03\x07\x0b' 22067d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22077d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd = ndarray(buffer=fortran_buf, shape=[3, 4], 22087d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### dtype='B', order='F') 22097d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22107d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd 22117d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### array([[ 0, 1, 2, 3], 22127d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [ 4, 5, 6, 7], 22137d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [ 8, 9, 10, 11]], dtype=uint8) 22147d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22157d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22167d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # multi-dimensional, contiguous input 22177d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah lst = list(range(12)) 22187d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for f in [0, ND_FORTRAN]: 22197d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray(lst, shape=[3, 4], flags=f|ND_WRITABLE) 22207d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if numpy_array: 22217d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah na = numpy_array(buffer=bytearray(lst), 22227d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah shape=[3, 4], dtype='B', 22237d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah order='C' if f == 0 else 'F') 22247d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22257d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'C' request 22267d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if f == ND_FORTRAN: # 'F' to 'C' 22277d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(transpose(lst, [4, 3]), shape=[3, 4], 22287d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah flags=ND_WRITABLE) 22297d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = x.tobytes() 22307d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah else: 22317d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = nd.tobytes() 22327d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 22337d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah try: 22347d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'C', request) 22357d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah except BufferError: 22367d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 22377d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22387d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, expected) 22397d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22407d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # Check that output can be used as the basis for constructing 22417d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # a C array that is logically identical to the input array. 22427d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_WRITABLE) 22437d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 22447d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22457d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if numpy_array: 22467d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, na.tostring(order='C')) 22477d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22487d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'F' request 22497d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if f == 0: # 'C' to 'F' 22507d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(transpose(lst, [3, 4]), shape=[4, 3], 22517d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah flags=ND_WRITABLE) 22527d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah else: 22537d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(lst, shape=[3, 4], flags=ND_WRITABLE) 22547d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = x.tobytes() 22557d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in [PyBUF_FULL, PyBUF_FULL_RO, PyBUF_INDIRECT, 22567d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_STRIDES, PyBUF_ND]: 22577d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah try: 22587d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'F', request) 22597d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah except BufferError: 22607d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 22617d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, expected) 22627d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22637d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # Check that output can be used as the basis for constructing 22647d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # a Fortran array that is logically identical to the input array. 22657d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_FORTRAN|ND_WRITABLE) 22667d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 22677d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22687d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if numpy_array: 22697d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, na.tostring(order='F')) 22707d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22717d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'A' request 22727d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if f == ND_FORTRAN: 22737d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(lst, shape=[3, 4], flags=ND_WRITABLE) 22747d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = x.tobytes() 22757d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah else: 22767d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = nd.tobytes() 22777d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in [PyBUF_FULL, PyBUF_FULL_RO, PyBUF_INDIRECT, 22787d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_STRIDES, PyBUF_ND]: 22797d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah try: 22807d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'A', request) 22817d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah except BufferError: 22827d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 22837d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22847d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, expected) 22857d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22867d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # Check that output can be used as the basis for constructing 22877d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # an array with order=f that is logically identical to the input 22887d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # array. 22897d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=f|ND_WRITABLE) 22907d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 22917d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22927d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if numpy_array: 22937d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, na.tostring(order='A')) 22947d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22957d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # multi-dimensional, non-contiguous input 22967d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray(list(range(12)), shape=[3, 4], flags=ND_WRITABLE|ND_PIL) 22977d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22987d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'C' 22997d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'C', PyBUF_FULL_RO) 23007d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, nd.tobytes()) 23017d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_WRITABLE) 23027d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 23037d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23047d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'F' 23057d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'F', PyBUF_FULL_RO) 23067d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(transpose(lst, [3, 4]), shape=[4, 3], flags=ND_WRITABLE) 23077d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, x.tobytes()) 23087d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_FORTRAN|ND_WRITABLE) 23097d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 23107d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23117d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'A' 23127d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'A', PyBUF_FULL_RO) 23137d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, nd.tobytes()) 23147d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_WRITABLE) 23157d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 23167d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_construction(self): 23189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items_shape = [(9, []), ([1,2,3], [3]), (list(range(2*3*5)), [2,3,5])] 23209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # NumPy style, C-contiguous: 23229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for items, shape in items_shape: 23239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From PEP-3118 compliant exporter: 23259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape) 23269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 23279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.c_contiguous) 23289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.contiguous) 23299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 23319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = strides_from_shape(ndim, shape, 1, 'C') 23329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 23339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=ex, 23359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 23379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From memoryview: 23409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(m) 23419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 23429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 23449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyMemoryView_FromBuffer(): no strides 23479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO|PyBUF_FORMAT) 23489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.strides, ()) 23499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = nd.memoryview_from_buffer() 23509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=None, 23519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 23539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyMemoryView_FromBuffer(): no format, shape, strides 23569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 23579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.format, '') 23589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.shape, ()) 23599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.strides, ()) 23609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = nd.memoryview_from_buffer() 23619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = [items] if ndim == 0 else items 23639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=None, 23649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=[ex.nbytes], strides=(1,), 23669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # NumPy style, Fortran contiguous: 23699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for items, shape in items_shape: 23709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From PEP-3118 compliant exporter: 23729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, flags=ND_FORTRAN) 23739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 23749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.f_contiguous) 23759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.contiguous) 23769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 23789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = strides_from_shape(ndim, shape, 1, 'F') 23799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = farray(items, shape) 23809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=ex, 23829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 23849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From memoryview: 23879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(m) 23889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 23899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 23919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PIL style: 23949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for items, shape in items_shape[1:]: 23959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From PEP-3118 compliant exporter: 23979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, flags=ND_PIL) 23989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 23999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 24019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 24029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=ex, 24049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 24059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=ex.strides, 24069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 24079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From memoryview: 24099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(m) 24109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 24119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 24129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=ex.strides, 24139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 24149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid number of arguments: 24169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, memoryview, b'9', 'x') 24179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Not a buffer provider: 24189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, memoryview, {}) 24199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Non-compliant buffer provider: 24209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([1,2,3], shape=[3]) 24219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 24229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, memoryview, nd) 24239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO|PyBUF_FORMAT) 24249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, memoryview, nd) 24259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim > 64 24279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1]*128, shape=[1]*128, format='L') 24289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, memoryview, nd) 24299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.memoryview_from_buffer) 24309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'C') 24319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'F') 24329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_contiguous, nd[::-1], PyBUF_READ, 'C') 24339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast_zero_shape(self): 24359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Casts are undefined if shape contains zeros. These arrays are 24369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # regarded as C-contiguous by Numpy and PyBuffer_GetContiguous(), 24379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # so they are not caught by the test for C-contiguity in memory_cast(). 24389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3] 24399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in ([0,3,3], [3,0,3], [0,3,3]): 24409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape) 24419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(ex.c_contiguous) 24429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 24439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, 'c') 24449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_struct_module(self): 24469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah class INT(object): 24489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def __init__(self, val): 24499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.val = val 24509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def __int__(self): 24519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return self.val 24529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah class IDX(object): 24549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def __init__(self, val): 24559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.val = val 24569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def __index__(self): 24579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return self.val 24589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def f(): return 7 24609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah values = [INT(9), IDX(9), 24629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2.2+3j, Decimal("-21.1"), 12.2, Fraction(5, 2), 24639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [1,2,3], {4,5,6}, {7:8}, (), (9,), 24649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah True, False, None, NotImplemented, 24659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b'a', b'abc', bytearray(b'a'), bytearray(b'abc'), 24669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'a', 'abc', r'a', r'abc', 24679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah f, lambda x: x] 24689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, item in iter_format(10, 'memoryview'): 24709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[10], format=fmt, flags=ND_WRITABLE) 24719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[10], format=fmt, flags=ND_WRITABLE) 24729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 24739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct.pack_into(fmt, nd, 0, item) 24759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[0] = item 24769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[0], nd[0]) 24779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 24799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 'P' in fmt: 24809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 24819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for v in values: 24839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct_err = None 24849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 24859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct.pack_into(fmt, nd, itemsize, v) 24869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except struct.error: 24879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct_err = struct.error 24889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv_err = None 24909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 24919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[1] = v 24929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except (TypeError, ValueError) as e: 24939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv_err = e.__class__ 24949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if struct_err or mv_err: 24969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIsNot(struct_err, None) 24979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIsNot(mv_err, None) 24989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 24999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[1], nd[1]) 25009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast_zero_strides(self): 25029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Casts are undefined if strides contains zeros. These arrays are 25039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # (sometimes!) regarded as C-contiguous by Numpy, but not by 25049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyBuffer_GetContiguous(). 25059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([1,2,3], shape=[3], strides=[0]) 25069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(ex.c_contiguous) 25079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 25089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, 'c') 25099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast_invalid(self): 25119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid format 25129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for sfmt in NON_BYTE_FORMAT: 25139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sformat = '@' + sfmt if randrange(2) else sfmt 25149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ssize = struct.calcsize(sformat) 25159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for dfmt in NON_BYTE_FORMAT: 25169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dformat = '@' + dfmt if randrange(2) else dfmt 25179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dsize = struct.calcsize(dformat) 25189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(32)), shape=[32//ssize], format=sformat) 25199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 25209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, dfmt, [32//dsize]) 25219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for sfmt, sitems, _ in iter_format(1): 25239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(sitems, shape=[1], format=sfmt) 25249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 25259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for dfmt, _, _ in iter_format(1): 25269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if (not is_memoryview_format(sfmt) or 25279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah not is_memoryview_format(dfmt)): 25289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, msrc.cast, dfmt, 25299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [32//dsize]) 25309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 25319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_byte_format(sfmt) and not is_byte_format(dfmt): 25329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, dfmt, 25339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [32//dsize]) 25349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid shape 25369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size_h = struct.calcsize('h') 25379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size_d = struct.calcsize('d') 25389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(2*2*size_d)), shape=[2,2,size_d], format='h') 25399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 25409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, shape=[2,2,size_h], format='d') 25419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(120)), shape=[1,2,3,4,5]) 25439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 25449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect number of args 25469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast) 25479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, 1, 2, 3) 25489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect dest format type 25509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, {}) 25519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect dest format 25539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "X") 25549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "@X") 25559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "@XY") 25569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # dest format not implemented 25589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "=B") 25599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "!L") 25609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "<P") 25619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, ">l") 25629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "BI") 25639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "xBI") 25649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # src format not implemented 25669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([(1,2), (3,4)], shape=[2], format="II") 25679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 25689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__getitem__, 0) 25699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 0, 8) 25709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.tolist) 25719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect shape type 25739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(120)), shape=[1,2,3,4,5]) 25749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 25759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "B", shape={}) 25769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect shape elements 25789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(120)), shape=[2*3*4*5]) 25799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 25809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, m.cast, "B", shape=[2**64]) 25819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "B", shape=[-1]) 25829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "B", shape=[2,3,4,5,6,7,-1]) 25839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "B", shape=[2,3,4,5,6,7,0]) 25849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "B", shape=[2,3,4,5,6,7,'x']) 25859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # N-D -> N-D cast 25879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list([9 for _ in range(3*5*7*11)]), shape=[3,5,7,11]) 25889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 25899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "I", shape=[2,3,4,5]) 25909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cast with ndim > 64 25929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(128)), shape=[128], format='I') 25939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 25949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, 'I', [1]*128) 25959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # view->len not a multiple of itemsize 25979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list([9 for _ in range(3*5*7*11)]), shape=[3*5*7*11]) 25989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 25999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "I", shape=[2,3,4,5]) 26009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # product(shape) * itemsize != buffer size 26029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list([9 for _ in range(3*5*7*11)]), shape=[3*5*7*11]) 26039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "B", shape=[2,3,4,5]) 26059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # product(shape) * itemsize overflow 26079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(128)), shape=[128], format='I') 26089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(nd) 26099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(128)), shape=[128], format='B') 26109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(nd) 26119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if sys.maxsize == 2**63-1: 26129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m1.cast, 'B', 26139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [7, 7, 73, 127, 337, 92737, 649657]) 26149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m1.cast, 'B', 26159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [2**20, 2**20, 2**10, 2**10, 2**3]) 26169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.cast, 'I', 26179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [2**20, 2**20, 2**10, 2**10, 2**1]) 26189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 26199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m1.cast, 'B', 26209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [1, 2147483647]) 26219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m1.cast, 'B', 26229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [2**10, 2**10, 2**5, 2**5, 2**1]) 26239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.cast, 'I', 26249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [2**10, 2**10, 2**5, 2**3, 2**1]) 26259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast(self): 26279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bytespec = ( 26289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ('B', lambda ex: list(ex.tobytes())), 26299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ('b', lambda ex: [x-256 if x > 127 else x for x in list(ex.tobytes())]), 26309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ('c', lambda ex: [bytes(chr(x), 'latin-1') for x in list(ex.tobytes())]), 26319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 26329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def iter_roundtrip(ex, m, items, fmt): 26349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah srcsize = struct.calcsize(fmt) 26359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for bytefmt, to_bytelist in bytespec: 26369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m.cast(bytefmt) 26389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = to_bytelist(ex) 26399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 26409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt=bytefmt, readonly=0, 26419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=[31*srcsize], strides=(1,), 26429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 26439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m3 = m2.cast(fmt) 26459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m3, ex) 26469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = ex.tolist() 26479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m3, obj=ex, 26489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=srcsize, fmt=fmt, readonly=0, 26499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=[31], strides=(srcsize,), 26509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 26519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cast from ndim = 0 to ndim = 1 26539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah srcsize = struct.calcsize('I') 26549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(9, shape=[], format='I') 26559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah destitems, destshape = cast_items(ex, 'B', 1) 26569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m.cast('B') 26589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 26599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 26609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=destshape, strides=(1,), 26619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=destitems, cast=True) 26629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cast from ndim = 1 to ndim = 0 26649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah destsize = struct.calcsize('I') 26659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([9]*destsize, shape=[destsize], format='B') 26669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah destitems, destshape = cast_items(ex, 'I', destsize, shape=[]) 26679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m.cast('I', shape=[]) 26699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 26709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=destsize, fmt='I', readonly=1, 26719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=0, shape=(), strides=(), 26729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=destitems, cast=True) 26739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # array.array: roundtrip to/from bytes 26759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(31, 'array'): 26769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = array.array(fmt, items) 26779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah iter_roundtrip(ex, m, items, fmt) 26799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndarray: roundtrip to/from bytes 26819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(31, 'memoryview'): 26829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[31], format=fmt, flags=ND_WRITABLE) 26839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah iter_roundtrip(ex, m, items, fmt) 26859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast_1D_ND(self): 26879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Cast between C-contiguous buffers. At least one buffer must 26889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # be 1D, at least one format must be 'c', 'b' or 'B'. 26899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _tshape in gencastshapes(): 26909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for char in fmtdict['@']: 26919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tfmt = ('', '@')[randrange(2)] + char 26929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tsize = struct.calcsize(tfmt) 26939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = prod(_tshape) * tsize 26949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah obj = 'memoryview' if is_byte_format(tfmt) else 'bytefmt' 26959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(n, obj): 26969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size = struct.calcsize(fmt) 26979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = [n] if n > 0 else [] 26989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tshape = _tshape + [size] 26999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, format=fmt) 27019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah titems, tshape = cast_items(ex, tfmt, tsize, shape=tshape) 27049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if titems is None: 27069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, tfmt, tshape) 27079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 27089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if titems == 'nan': 27099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue # NaNs in lists are a recipe for trouble. 27109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # 1D -> ND 27129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(titems, shape=tshape, format=tfmt) 27139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m.cast(tfmt, shape=tshape) 27159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(tshape) 27169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = nd.strides 27179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = nd.tolist() 27189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 27199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=tsize, fmt=tfmt, readonly=1, 27209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=tshape, strides=strides, 27219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 27229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND -> 1D 27249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m3 = m2.cast(fmt) 27259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m4 = m2.cast(fmt, shape=shape) 27269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 27279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = ex.strides 27289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = ex.tolist() 27299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m3, obj=ex, 27319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=size, fmt=fmt, readonly=1, 27329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 27339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 27349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m4, obj=ex, 27369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=size, fmt=fmt, readonly=1, 27379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 27389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 27399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_tolist(self): 27419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Most tolist() tests are in self.verify() etc. 27439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('h', list(range(-6, 6))) 27459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(a) 27469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, a) 27479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), a.tolist()) 27489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = a[2::3] 27509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = m[2::3] 27519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, a) 27529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), a.tolist()) 27539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(2*3*5*7*11)), shape=[11,2,7,3,5], format='L') 27559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), ex.tolist()) 27579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([(2, 5), (7, 11)], shape=[2], format='lh') 27599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.tolist) 27619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([b'12345'], shape=[1], format="s") 27639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.tolist) 27659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([b"a",b"b",b"c",b"d",b"e",b"f"], shape=[2,3], format='s') 27679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.tolist) 27699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_repr(self): 27719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(bytearray(9)) 27729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah r = m.__repr__() 27739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(r.startswith("<memory")) 27749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m.release() 27769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah r = m.__repr__() 27779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(r.startswith("<released")) 27789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_sequence(self): 27809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in ('d', 'f'): 27829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah inf = float(3e400) 27839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = array.array(fmt, [1.0, inf, 3.0]) 27849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIn(1.0, m) 27869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIn(5e700, m) 27879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIn(3.0, m) 27889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(9.0, [], format='f') 27909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, eval, "9.0 in m", locals()) 27929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_index(self): 27949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 0 27969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(12.5, shape=[], format='d') 27979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 12.5) 27999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[...], m) 28009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[...], ex) 28019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__getitem__, 0) 28029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray((1,2,3), shape=[], format='iii') 28049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__getitem__, ()) 28069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # range 28089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(7)), shape=[7], flags=ND_WRITABLE) 28099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__getitem__, 2**64) 28129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__getitem__, 2.0) 28139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__getitem__, 0.0) 28149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # out of bounds 28169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__getitem__, -8) 28179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__getitem__, 8) 28189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Not implemented: multidimensional sub-views 28209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[3,4], flags=ND_WRITABLE) 28219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__getitem__, 0) 28249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 0, 9) 28259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__getitem__, 0) 28269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_assign(self): 28289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 0 28309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(12.5, shape=[], format='f', flags=ND_WRITABLE) 28319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[()] = 22.5 28339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 22.5) 28349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[...] = 23.5 28359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 23.5) 28369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 0, 24.7) 28379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # read-only 28399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(7)), shape=[7]) 28409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 2, 10) 28429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # range 28449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(7)), shape=[7], flags=ND_WRITABLE) 28459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__setitem__, 2**64, 9) 28489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 2.0, 10) 28499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 0.0, 11) 28509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # out of bounds 28529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__setitem__, -8, 20) 28539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__setitem__, 8, 25) 28549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # pack_single() success: 28569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 28579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt == 'c' or fmt == '?': 28589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 28599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([1,2,3], shape=[3], format=fmt, flags=ND_WRITABLE) 28609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah i = randrange(-3, 3) 28629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[i] = 8 28639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[i], 8) 28649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[i], ex[i]) 28659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([b'1', b'2', b'3'], shape=[3], format='c', 28679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE) 28689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[2] = b'9' 28709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[2], b'9') 28719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([True, False, True], shape=[3], format='?', 28739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE) 28749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[1] = True 28769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[1], True) 28779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # pack_single() exceptions: 28799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([b'x'], shape=[1], format='c', flags=ND_WRITABLE) 28809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 28819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 0, 100) 28829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(120)), shape=[1,2,3,4,5], flags=ND_WRITABLE) 28849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(ex) 28859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, _range in fmtdict['@'].items(): 28879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if (fmt == '?'): # PyObject_IsTrue() accepts anything 28889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 28899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt == 'c': # special case tested above 28909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 28919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m1.cast(fmt) 28929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lo, hi = _range 28939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt == 'd' or fmt == 'f': 28949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lo, hi = -2**1024, 2**1024 28959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt != 'P': # PyLong_AsVoidPtr() accepts negative numbers 28969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.__setitem__, 0, lo-1) 28979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m2.__setitem__, 0, "xyz") 28989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.__setitem__, 0, hi) 28999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid item 29019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m1.cast('c') 29029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.__setitem__, 0, b'\xff\xff') 29039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # format not implemented 29059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(1)), shape=[1], format="xL", flags=ND_WRITABLE) 29069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 0, 1) 29089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([b'12345'], shape=[1], format="s", flags=ND_WRITABLE) 29109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 0, 1) 29129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Not implemented: multidimensional sub-views 29149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[3,4], flags=ND_WRITABLE) 29159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 0, [2, 3]) 29189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_slice(self): 29209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE) 29229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zero step 29259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__getitem__, slice(0,2,0)) 29269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__setitem__, slice(0,2,0), 29279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bytearray([1,2])) 29289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid slice key 29309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__getitem__, ()) 29319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multidimensional slices 29339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE) 29349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__getitem__, 29379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,2,1), slice(0,2,1))) 29389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 29399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,2,1), slice(0,2,1)), bytearray([1,2])) 29409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid slice tuple 29429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__getitem__, (slice(0,2,1), {})) 29439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, (slice(0,2,1), {}), 29449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bytearray([1,2])) 29459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # rvalue is not an exporter 29479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, slice(0,1,1), [1]) 29489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-contiguous slice assignment 29509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 29519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(12)), shape=[12], strides=[-1], offset=11, 29529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE|flags) 29539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ndarray(list(range(24)), shape=[12], strides=[2], flags=flags) 29549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(ex1) 29559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(ex2) 29569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1[2:5] = ex1[2:5] 29589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1[2:5] = m2[2:5] 29599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, ex1) 29619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m2, ex2) 29629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1[1:3][::-1] = ex2[0:2][::1] 29649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1[1:3][::-1] = m2[0:2][::1] 29659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, ex1) 29679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m2, ex2) 29689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1[4:1:-2][::-1] = ex1[1:4:2][::1] 29709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1[4:1:-2][::-1] = m1[1:4:2][::1] 29719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, ex1) 29739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m2, ex2) 29749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_array(self): 29769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def cmptest(testcase, a, b, m, singleitem): 29789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i, _ in enumerate(a): 29799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ai = a[i] 29809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mi = m[i] 29819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(ai, mi) 29829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a[i] = singleitem 29839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if singleitem != ai: 29849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertNotEqual(a, m) 29859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertNotEqual(a, b) 29869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 29879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(a, m) 29889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(a, b) 29899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[i] = singleitem 29909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(a, m) 29919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(b, m) 29929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a[i] = ai 29939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[i] = mi 29949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for n in range(1, 5): 29969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, singleitem in iter_format(n, 'array'): 29979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for lslice in genslices(n): 29989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for rslice in genslices(n): 29999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array(fmt, items) 30019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = array.array(fmt, items) 30029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(b) 30039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, a) 30059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), a.tolist()) 30069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), a.tobytes()) 30079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(len(m), len(a)) 30089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah cmptest(self, a, b, m, singleitem) 30109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah array_err = None 30129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah have_resize = None 30139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 30149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah al = a[lslice] 30159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ar = a[rslice] 30169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a[lslice] = a[rslice] 30179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah have_resize = len(al) != len(ar) 30189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 30199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah array_err = e.__class__ 30209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m_err = None 30229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 30239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[lslice] = m[rslice] 30249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 30259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m_err = e.__class__ 30269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if have_resize: # memoryview cannot change shape 30289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(m_err, ValueError) 30299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif m_err or array_err: 30309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(m_err, array_err) 30319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 30329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, a) 30339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), a.tolist()) 30349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), a.tobytes()) 30359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah cmptest(self, a, b, m, singleitem) 30369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 303706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_special_cases(self): 30389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('L', [1, 2, 3]) 30409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = array.array('L', [1, 2, 7]) 30419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Ordering comparisons raise: 30439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 30449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(b) 30459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for attr in ('__lt__', '__le__', '__gt__', '__ge__'): 30469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(getattr(v, attr)(w), NotImplemented) 30479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(getattr(a, attr)(v), NotImplemented) 30489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Released views compare equal to themselves: 30509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 30519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v.release() 30529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, v) 30539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, a) 30549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(a, v) 30559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 30579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(a) 30589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w.release() 30599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 30609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, v) 30619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Operand does not implement the buffer protocol: 30639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 30649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, [1, 2, 3]) 30659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 306606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # NaNs 306706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray([(0, 0)], shape=[1], format='l x d x', flags=ND_WRITABLE) 306806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd[0] = (-1, float('nan')) 306906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(memoryview(nd), nd) 30709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 307106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Depends on issue #15625: the struct module does not understand 'u'. 307206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = array.array('u', 'xyz') 30739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 30749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(a, v) 30759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, a) 30769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 307706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Some ctypes format strings are unknown to the struct module. 307806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if ctypes: 307906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # format: "T{>l:x:>l:y:}" 308006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan class BEPoint(ctypes.BigEndianStructure): 308106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)] 308206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan point = BEPoint(100, 200) 308306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = memoryview(point) 308406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan b = memoryview(point) 308506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, b) 308606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, point) 308706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(point, a) 308806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertRaises(NotImplementedError, a.tolist) 308906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 309006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_ndim_zero(self): 30919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(1729, shape=[], format='@L') 30939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(1729, shape=[], format='L', flags=ND_WRITABLE) 30949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 30959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 30969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 30979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, v) 30989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2) 30999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd2, v) 31009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd1) 31019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd1, w) 31029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(v.__ne__(w)) 31049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(w.__ne__(v)) 31059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w[()] = 1728 31079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 31089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, v) 31099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 31109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(nd2, v) 31119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 31129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(nd1, w) 31139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(v.__eq__(w)) 31159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(w.__eq__(v)) 31169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE|ND_PIL) 31189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE|ND_PIL) 31199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 31209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 31229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[9] = 100 31239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(m, nd) 31249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 312506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # struct module: equal 312606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray((1729, 1.2, b'12345'), shape=[], format='Lf5s') 312706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray((1729, 1.2, b'12345'), shape=[], format='hf5s', 312806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_WRITABLE) 312906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 313006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 313106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 313206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, v) 313306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 313406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(nd2, v) 313506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 313606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(nd1, w) 313706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 313806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # struct module: not equal 313906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray((1729, 1.2, b'12345'), shape=[], format='Lf5s') 314006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray((-1729, 1.2, b'12345'), shape=[], format='hf5s', 314106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_WRITABLE) 314206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 314306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 314406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 314506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, v) 314606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 314706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(nd2, v) 314806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 314906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(nd1, w) 315006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 315106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 315206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 315306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_ndim_one(self): 315406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 315506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # contiguous 31569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='@h') 31579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([-529, 576, -625, 676, 729], shape=[5], format='@h') 31589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 31599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 31609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 31629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 31639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 31649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 31659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 31669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 316706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # contiguous, struct module 316806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='<i') 316906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([-529, 576, -625, 676, 729], shape=[5], format='>h') 317006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 317106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 317206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 317306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 317406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 317506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 317606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 317706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 317806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 317906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # non-contiguous 31809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([-529, -625, -729], shape=[3], format='@h') 31819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='@h') 31829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 31839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 31849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2[::2]) 31869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w[::2], nd1) 31879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w[::2]) 31889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v[::-1], w[::-2]) 31899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 319006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # non-contiguous, struct module 319106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([-529, -625, -729], shape=[3], format='!h') 319206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='<l') 319306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 319406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 319506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 319606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2[::2]) 319706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w[::2], nd1) 319806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w[::2]) 319906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v[::-1], w[::-2]) 320006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 320106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # non-contiguous, suboffsets 32029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([-529, -625, -729], shape=[3], format='@h') 32039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='@h', 32049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_PIL) 32059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 32069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 32079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2[::2]) 32099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w[::2], nd1) 32109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w[::2]) 32119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v[::-1], w[::-2]) 32129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 321306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # non-contiguous, suboffsets, struct module 321406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([-529, -625, -729], shape=[3], format='h 0c') 321506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='> h', 321606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL) 321706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 321806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 321906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 322006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2[::2]) 322106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w[::2], nd1) 322206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w[::2]) 322306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v[::-1], w[::-2]) 322406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 322506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_zero_shape(self): 322606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 322706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zeros in shape 32289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([900, 961], shape=[0], format='@h') 32299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([-900, -961], shape=[0], format='@h') 32309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 32319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 32329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 32349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 32359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2) 32369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd1) 32379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 32389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 323906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zeros in shape, struct module 324006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([900, 961], shape=[0], format='= h0c') 324106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([-900, -961], shape=[0], format='@ i') 324206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 324306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 324406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 324506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 324606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 324706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 324806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 324906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 325006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 325106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_zero_strides(self): 325206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 325306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zero strides 32549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([900, 900, 900, 900], shape=[4], format='@L') 32559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([900], shape=[4], strides=[0], format='L') 32569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 32579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 32589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 32609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 32619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2) 32629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd1) 32639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 32649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 326506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zero strides, struct module 326606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(900, 900)]*4, shape=[4], format='@ Li') 326706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(900, 900)], shape=[4], strides=[0], format='!L h') 326806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 326906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 327006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 327106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 327206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 327306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 327406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 327506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 327606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 327706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_random_formats(self): 327806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 327906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # random single character native formats 32809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = 10 32819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for char in fmtdict['@m']: 32829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, singleitem = randitems(n, 'memoryview', '@', char) 32839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 32849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[n], format=fmt, flags=flags) 32859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 32869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 32879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = nd[::-3] 32899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 32909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 32919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 329206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # random formats 329306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan n = 10 329406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan for _ in range(100): 329506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan fmt, items, singleitem = randitems(n) 329606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan for flags in (0, ND_PIL): 329706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray(items, shape=[n], format=fmt, flags=flags) 329806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 329906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 330006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 330106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = nd[::-3] 330206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 330306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 330406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 330506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_c(self): 330606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 330706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different values 33089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(-15, 15)), shape=[3, 2, 5], format='@h') 33099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(0, 30)), shape=[3, 2, 5], format='@h') 33109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 33119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 33129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 33139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 33149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 33159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 33169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 33179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 33189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 331906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different values, struct module 332006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(0, 1, 2)]*30, shape=[3, 2, 5], format='=f q xxL') 332106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(-1.2, 1, 2)]*30, shape=[3, 2, 5], format='< f 2Q') 332206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 332306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 332406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 332506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 332606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 332706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 332806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 332906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 333006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 333106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different shape 33329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(30)), shape=[2, 3, 5], format='L') 33339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='L') 33349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 33359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 33369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 33379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 33389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 33399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 33409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 33419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 33429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 334306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different shape, struct module 334406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(0, 1, 2)]*21, shape=[3, 7], format='! b B xL') 334506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(0, 1, 2)]*21, shape=[7, 3], format='= Qx l xxL') 33469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 33479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 33489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 33499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 33509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 33519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 33529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 33539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 33549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 335506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different format, struct module 335606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(list(range(30)), shape=[2, 3, 5], format='L') 335706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(30)), shape=[2, 3, 5], format='l') 335806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 335906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 336006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 336106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 336206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 336306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 336406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 336506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 336606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 336706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_fortran(self): 336806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 336906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different values 33709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(-15, 15)), shape=[5, 2, 3], format='@h', 33719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 33729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(0, 30)), shape=[5, 2, 3], format='@h', 33739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 33749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 33759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 33769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 33779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 33789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 33799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 33809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 33819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 33829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 338306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different values, struct module 338406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(2**64-1, -1)]*6, shape=[2, 3], format='=Qq', 338506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN) 338606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(-1, 2**64-1)]*6, shape=[2, 3], format='=qQ', 338706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN) 338806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 338906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 339006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 339106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 339206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 339306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 339406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 339506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 339606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 339706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different shape 33989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(-15, 15)), shape=[2, 3, 5], format='l', 33999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 34009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(-15, 15)), shape=[3, 2, 5], format='l', 34019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 34029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 34039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 34049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 34059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 34069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 34079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 34089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 34099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 34109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 341106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different shape, struct module 341206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(list(range(-15, 15)), shape=[2, 3, 5], format='0ll', 34139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 341406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(-15, 15)), shape=[3, 2, 5], format='l', 34159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 34169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 34179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 34189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 34199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 34209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 34219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 34229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 34239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 34249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 342506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different format, struct module 342606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(list(range(30)), shape=[5, 2, 3], format='@h', 342706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN) 342806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(30)), shape=[5, 2, 3], format='@b', 342906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN) 343006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 343106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 343206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 343306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 343406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 343506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 343606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 343706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 343806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 343906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_mixed(self): 344006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 344106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # mixed C/Fortran contiguous 34429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst1 = list(range(-15, 15)) 34439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst2 = transpose(lst1, [3, 2, 5]) 34449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(lst1, shape=[3, 2, 5], format='@l') 34459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(lst2, shape=[3, 2, 5], format='l', flags=ND_FORTRAN) 34469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 34479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 34489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 34499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 34509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 34519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 34529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 345306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # mixed C/Fortran contiguous, struct module 345406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst1 = [(-3.3, -22, b'x')]*30 345506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst1[5] = (-2.2, -22, b'x') 345606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst2 = transpose(lst1, [3, 2, 5]) 345706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(lst1, shape=[3, 2, 5], format='d b c') 345806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(lst2, shape=[3, 2, 5], format='d h c', flags=ND_FORTRAN) 345906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 346006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 346106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 346206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 346306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 346406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 346506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 346606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # different values, non-contiguous 34679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(40)), shape=[5, 8], format='@I') 34689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[3:1:-1, ::-2] 34699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ndarray(list(range(40)), shape=[5, 8], format='I') 34709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:1, ::-2] 34719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 34729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 34739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 34749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 34759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 34769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 34779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 34789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 34799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 348006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # same values, non-contiguous, struct module 348106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(2**31-1, -2**31)]*22, shape=[11, 2], format='=ii') 348206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[3:1:-1, ::-2] 348306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray([(2**31-1, -2**31)]*22, shape=[11, 2], format='>ii') 348406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:3:1, ::-2] 348506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 348606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 348706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 348806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 348906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 349006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 349106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 349206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 349306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 34949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # different shape 34959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(30)), shape=[2, 3, 5], format='b') 34969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[1:3:, ::-2] 34979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='b') 34989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:, ::-2] 34999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 35009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 35019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 35029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 35039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 35049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 35059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 35069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 35079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 350806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # different shape, struct module 350906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray(list(range(30)), shape=[2, 3, 5], format='B') 35109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[1:3:, ::-2] 351106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='b') 35129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:, ::-2] 35139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 35149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 35159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 35169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 35179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 35189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 35199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 35209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 35219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 352206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # different format, struct module 352306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(2, b'123')]*30, shape=[5, 3, 2], format='b3s') 352406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[1:3:, ::-2] 352506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(2, b'123')]*30, shape=[5, 3, 2], format='i3s') 352606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:3:, ::-2] 352706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 352806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 352906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 353006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 353106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 353206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 353306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 353406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 353506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 353606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_zero_shape(self): 353706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 353806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zeros in shape 353906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(list(range(30)), shape=[0, 3, 2], format='i') 354006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(30)), shape=[5, 0, 2], format='@i') 354106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 354206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 354306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 354406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 354506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 354606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 354706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 354806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 354906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 355006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zeros in shape, struct module 35519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(30)), shape=[0, 3, 2], format='i') 35529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(30)), shape=[5, 0, 2], format='@i') 35539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 35549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 35559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 35569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 35579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 35589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 35599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 35609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 35619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 356206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_zero_strides(self): 356306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 356406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zero strides 35659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([900]*80, shape=[4, 5, 4], format='@L') 35669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([900], shape=[4, 5, 4], strides=[0, 0, 0], format='L') 35679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 35689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 35699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 35709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 35719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 35729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2) 35739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd1) 35749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 35759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v.tolist(), w.tolist()) 35769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 357706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zero strides, struct module 357806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(1, 2)]*10, shape=[2, 5], format='=lQ') 357906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(1, 2)], shape=[2, 5], strides=[0, 0], format='<lQ') 358006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 358106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 358206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 358306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 358406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 358506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 358606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 358706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 358806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 358906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_suboffsets(self): 359006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 359106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets 35929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(40)), shape=[5, 8], format='@I') 35939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[3:1:-1, ::-2] 35949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ndarray(list(range(40)), shape=[5, 8], format='I', flags=ND_PIL) 35959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:1, ::-2] 35969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 35979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 35989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 35999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 36009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 36019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 36029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 36039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 36049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 360506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, struct module 360606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(2**64-1, -1)]*40, shape=[5, 8], format='=Qq', 360706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_WRITABLE) 360806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1[2][7] = (1, -2) 360906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[3:1:-1, ::-2] 361006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 361106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray([(2**64-1, -1)]*40, shape=[5, 8], format='>Qq', 361206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL|ND_WRITABLE) 361306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2[2][7] = (1, -2) 361406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:3:1, ::-2] 361506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 361606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 361706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 361806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 361906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 362006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 362106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 362206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 362306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 362406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 362506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, different shape 362606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray(list(range(30)), shape=[2, 3, 5], format='b', 362706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL) 36289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[1:3:, ::-2] 36299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='b') 36309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:, ::-2] 36319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 36329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 36339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 36349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 36359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 36369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 36379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 36389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 36399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 364006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, different shape, struct module 364106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(2**8-1, -1)]*40, shape=[2, 3, 5], format='Bb', 364206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL|ND_WRITABLE) 364306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[1:2:, ::-2] 364406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 364506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray([(2**8-1, -1)]*40, shape=[3, 2, 5], format='Bb') 364606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:2:, ::-2] 364706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 364806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 364906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 365006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 365106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 365206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 365306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 365406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 365506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 365606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 365706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, different format 36589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(30)), shape=[5, 3, 2], format='i', flags=ND_PIL) 36599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[1:3:, ::-2] 366006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray(list(range(30)), shape=[5, 3, 2], format='@I', flags=ND_PIL) 366106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:3:, ::-2] 366206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 366306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 366406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 366506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 366606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 366706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 366806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 366906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 367006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 367106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, different format, struct module 367206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(b'hello', b'', 1)]*27, shape=[3, 3, 3], format='5s0sP', 367306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL|ND_WRITABLE) 367406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1[1][2][2] = (b'sushi', b'', 1) 367506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[1:3:, ::-2] 367606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 367706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray([(b'hello', b'', 1)]*27, shape=[3, 3, 3], format='5s0sP', 367806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL|ND_WRITABLE) 367906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1[1][2][2] = (b'sushi', b'', 1) 36809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:, ::-2] 368106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 36829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 36839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 36849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 36859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 36869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 36879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 36889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 36899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 36909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 36919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # initialize mixed C/Fortran + suboffsets 36929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst1 = list(range(-15, 15)) 36939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst2 = transpose(lst1, [3, 2, 5]) 36949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(lst1, shape=[3, 2, 5], format='@l', flags=ND_PIL) 36959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(lst2, shape=[3, 2, 5], format='l', flags=ND_FORTRAN|ND_PIL) 36969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 36979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 36989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 36999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 37009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 37019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 37029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 370306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # initialize mixed C/Fortran + suboffsets, struct module 370406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst1 = [(b'sashimi', b'sliced', 20.05)]*30 370506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst1[11] = (b'ramen', b'spicy', 9.45) 370606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst2 = transpose(lst1, [3, 2, 5]) 370706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 370806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(lst1, shape=[3, 2, 5], format='< 10p 9p d', flags=ND_PIL) 370906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(lst2, shape=[3, 2, 5], format='> 10p 9p d', 371006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN|ND_PIL) 371106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 371206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 371306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 371406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 371506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 371606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 371706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 371806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_not_equal(self): 371906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 372006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # items not equal 372106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan for byteorder in ['=', '<', '>', '!']: 372206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan x = ndarray([2**63]*120, shape=[3,5,2,2,2], format=byteorder+'Q') 372306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan y = ndarray([2**63]*120, shape=[3,5,2,2,2], format=byteorder+'Q', 372406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_WRITABLE|ND_FORTRAN) 372506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan y[2][3][1][1][1] = 1 372606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = memoryview(x) 372706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan b = memoryview(y) 372806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(a, x) 372906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(b, y) 373006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, b) 373106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, y) 373206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(b, x) 373306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 373406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan x = ndarray([(2**63, 2**31, 2**15)]*120, shape=[3,5,2,2,2], 373506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan format=byteorder+'QLH') 373606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan y = ndarray([(2**63, 2**31, 2**15)]*120, shape=[3,5,2,2,2], 373706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan format=byteorder+'QLH', flags=ND_WRITABLE|ND_FORTRAN) 373806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan y[2][3][1][1][1] = (1, 1, 1) 373906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = memoryview(x) 374006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan b = memoryview(y) 374106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(a, x) 374206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(b, y) 374306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, b) 374406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, y) 374506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(b, x) 374606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 37479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_check_released(self): 37489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('d', [1.1, 2.2, 3.3]) 37509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(a) 37529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m.release() 37539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyMemoryView_FromObject() 37559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, memoryview, m) 37569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview.cast() 37579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, 'c') 37589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getbuffer() 37599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, ndarray, m) 37609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview.tolist() 37619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.tolist) 37629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview.tobytes() 37639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.tobytes) 37649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # sequence 37659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, eval, "1.0 in m", locals()) 37669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # subscript 37679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__getitem__, 0) 37689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # assignment 37699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__setitem__, 0, 1) 37709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for attr in ('obj', 'nbytes', 'readonly', 'itemsize', 'format', 'ndim', 37729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'shape', 'strides', 'suboffsets', 'c_contiguous', 37739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'f_contiguous', 'contiguous'): 37749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__getattribute__, attr) 37759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # richcompare 37779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = array.array('d', [1.1, 2.2, 3.3]) 37789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(a) 37799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(b) 37809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, m2) 37829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1.release() 37839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(m1, m2) 37849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(m1, a) 37859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, m1) 37869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_tobytes(self): 37889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Many implicit tests are already in self.verify(). 37899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 379006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan t = (-529, 576, -625, 676, -729) 37919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 379206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray(t, shape=[5], format='@h') 37939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 379406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 37959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), nd.tobytes()) 37969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 379706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray([t], shape=[1], format='>hQiLl') 379806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 379906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 380006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m.tobytes(), nd.tobytes()) 380106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 380206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray([t for _ in range(12)], shape=[2,2,3], format='=hQiLl') 380306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 380406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 380506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m.tobytes(), nd.tobytes()) 380606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 380706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray([t for _ in range(120)], shape=[5,2,2,3,2], 380806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan format='<hQiLl') 380906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 381006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 381106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m.tobytes(), nd.tobytes()) 381206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 381306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Unknown formats are handled: tobytes() purely depends on itemsize. 381406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if ctypes: 381506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # format: "T{>l:x:>l:y:}" 381606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan class BEPoint(ctypes.BigEndianStructure): 381706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)] 381806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan point = BEPoint(100, 200) 381906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = memoryview(point) 382006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(a.tobytes(), bytes(point)) 382106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 38229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_get_contiguous(self): 38239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Many implicit tests are already in self.verify(). 38249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # no buffer interface 38269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_contiguous, {}, PyBUF_READ, 'F') 38279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # writable request to read-only object 38299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, b'x', PyBUF_WRITE, 'C') 38309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # writable request to non-contiguous object 38329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1, 2, 3], shape=[2], strides=[2]) 38339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'A') 38349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # scalar, read-only request from read-only exporter 38369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(9, shape=(), format="L") 38379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 38389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 38399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 38409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 9) 38419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # scalar, read-only request from writable exporter 38439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(9, shape=(), format="L", flags=ND_WRITABLE) 38449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 38459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 38469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 38479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 9) 38489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # scalar, writable request 38509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 38519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[()] = 9 38529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 38539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 38549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 9) 38559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[()] = 10 38579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 10) 38589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[()], 10) 38599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zeros in shape 38619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[0], format="L", flags=ND_WRITABLE) 38629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 38639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 38649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__getitem__, 0) 38659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 38669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), []) 38679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(8)), shape=[2, 0, 7], format="L", 38699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE) 38709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 38719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 38729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), [[], []]) 38739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # one-dimensional 38759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1], format="h", flags=ND_WRITABLE) 38769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 38779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 38789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 38799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), nd.tolist()) 38809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1, 2, 3], shape=[3], format="b", flags=ND_WRITABLE) 38829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 38839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 38849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 38859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), nd.tolist()) 38869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # one-dimensional, non-contiguous 38889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1, 2, 3], shape=[2], strides=[2], flags=ND_WRITABLE) 38899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 38909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 38919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 38929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), nd.tolist()) 38939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 1, 20) 38949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[1], 3) 38959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[1], 3) 38969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = nd[::-1] 38989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 38999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), nd.tolist()) 39029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 1, 20) 39039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[1], 1) 39049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[1], 1) 39059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multi-dimensional, contiguous input 39079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3, 4], flags=ND_WRITABLE) 39089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'A']: 39099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 39109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 39119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'F') 39139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 39159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3, 4], 39179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE|ND_FORTRAN) 39189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['F', 'A']: 39199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 39209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 39219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'C') 39239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 39259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multi-dimensional, non-contiguous input 39279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3, 4], flags=ND_WRITABLE|ND_PIL) 39289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 39309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah order) 39319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 39339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flags 39359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3,4,5], shape=[3], strides=[2]) 39369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, 'C') 39379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.c_contiguous) 39389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_serializing(self): 39409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C-contiguous 39429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size = struct.calcsize('i') 39439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('i', [1,2,3,4,5]) 39449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(a) 39459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf = io.BytesIO(m) 39469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytearray(5*size) 39479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf.readinto(b) 39489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), b) 39499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C-contiguous, multi-dimensional 39519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size = struct.calcsize('L') 39529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,3,2], format="L") 39539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 39549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf = io.BytesIO(m) 39559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytearray(2*3*2*size) 39569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf.readinto(b) 39579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), b) 39589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran contiguous, multi-dimensional 39609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #size = struct.calcsize('L') 39619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #nd = ndarray(list(range(12)), shape=[2,3,2], format="L", 39629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flags=ND_FORTRAN) 39639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #m = memoryview(nd) 39649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #buf = io.BytesIO(m) 39659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #b = bytearray(2*3*2*size) 39669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #buf.readinto(b) 39679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #self.assertEqual(m.tobytes(), b) 39689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_hash(self): 39709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # bytes exporter 39729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(list(range(12))) 39739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(b) 39749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(b), hash(m)) 39759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C-contiguous 39779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mc = m.cast('c', shape=[3,4]) 39789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(mc), hash(b)) 39799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-contiguous 39819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mx = m[::-2] 39829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(list(range(12))[::-2]) 39839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(mx), hash(b)) 39849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran contiguous 39869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(30)), shape=[3,2,5], flags=ND_FORTRAN) 39879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 39889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(m), hash(nd)) 39899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multi-dimensional slice 39919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(30)), shape=[3,2,5]) 39929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd[::2, ::, ::-1] 39939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(x) 39949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(m), hash(x)) 39959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multi-dimensional slice with suboffsets 39979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(30)), shape=[2,5,3], flags=ND_PIL) 39989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd[::2, ::, ::-1] 39999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(x) 40009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(m), hash(x)) 40019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40024af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah # equality-hash invariant 40034af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah x = ndarray(list(range(12)), shape=[12], format='B') 4004b716f84880fb719be417e9b49f8bb55bfd0106b8Stefan Krah a = memoryview(x) 40054af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 40064af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah y = ndarray(list(range(12)), shape=[12], format='b') 4007b716f84880fb719be417e9b49f8bb55bfd0106b8Stefan Krah b = memoryview(y) 40084af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 4009b716f84880fb719be417e9b49f8bb55bfd0106b8Stefan Krah self.assertEqual(a, b) 4010b716f84880fb719be417e9b49f8bb55bfd0106b8Stefan Krah self.assertEqual(hash(a), hash(b)) 40114af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 40129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-byte formats 40139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,2,3], format='L') 40149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 40154af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah self.assertRaises(ValueError, m.__hash__) 40169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(-6, 6)), shape=[2,2,3], format='h') 40189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 40194af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah self.assertRaises(ValueError, m.__hash__) 40204af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 40214af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah nd = ndarray(list(range(12)), shape=[2,2,3], format='= L') 40224af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah m = memoryview(nd) 40234af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah self.assertRaises(ValueError, m.__hash__) 40244af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 40254af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah nd = ndarray(list(range(-6, 6)), shape=[2,2,3], format='< h') 40264af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah m = memoryview(nd) 40274af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah self.assertRaises(ValueError, m.__hash__) 40289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_release(self): 40309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Create re-exporter from getbuffer(memoryview), then release the view. 40329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = bytearray([1,2,3]) 40339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(a) 40349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(m) # re-exporter 40359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, m.release) 40369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 40379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m.release() 40389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40394e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah a = bytearray([1,2,3]) 40404e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m = memoryview(a) 40414e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd1 = ndarray(m, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 40424e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd2 = ndarray(nd1, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 40434e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(nd2.obj, m) 40444e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertRaises(BufferError, m.release) 40454e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del nd1, nd2 40464e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m.release() 40474e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 40489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # chained views 40499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = bytearray([1,2,3]) 40509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(a) 40519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(m1) 40529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(m2) # re-exporter 40539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1.release() 40549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, m2.release) 40559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 40569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2.release() 40579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40584e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah a = bytearray([1,2,3]) 40594e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m1 = memoryview(a) 40604e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m2 = memoryview(m1) 40614e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd1 = ndarray(m2, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 40624e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd2 = ndarray(nd1, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 40634e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(nd2.obj, m2) 40644e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m1.release() 40654e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertRaises(BufferError, m2.release) 40664e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del nd1, nd2 40674e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m2.release() 40684e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 40699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Allow changing layout while buffers are exported. 40709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[3], flags=ND_VAREXPORT) 40719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(nd) 40729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.push([4,5,6,7,8], shape=[5]) # mutate nd 40749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(nd) 40759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = memoryview(m1) 40779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(x.tolist(), m1.tolist()) 40789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = memoryview(m2) 40809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(y.tolist(), m2.tolist()) 40819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(y.tolist(), nd.tolist()) 40829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2.release() 40839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y.release() 40849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.pop() # pop the current view 40869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(x.tolist(), nd.tolist()) 40879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 40899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1.release() 40909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x.release() 40919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # If multiple memoryviews share the same managed buffer, implicit 40939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # release() in the context manager's __exit__() method should still 40949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # work. 40959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def catch22(b): 40969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah with memoryview(b) as m2: 40979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah pass 40989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = bytearray(b'123') 41009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah with memoryview(x) as m1: 41019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah catch22(m1) 41029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1[0], ord(b'1')) 41039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41044e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah x = ndarray(list(range(12)), shape=[2,2,3], format='l') 41054e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 41064e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 41074e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(z.obj, x) 41084e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(z) as m: 41094e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m) 41104e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[0:1].tolist(), [[[0, 1, 2], [3, 4, 5]]]) 41114e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 41124e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah # Test garbage collection. 41134e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah for flags in (0, ND_REDIRECT): 41144e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah x = bytearray(b'123') 41154e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(x) as m1: 41164e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del x 41174e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah y = ndarray(m1, getbuf=PyBUF_FULL_RO, flags=flags) 41184e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(y) as m2: 41194e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del y 41204e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah z = ndarray(m2, getbuf=PyBUF_FULL_RO, flags=flags) 41214e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(z) as m3: 41224e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del z 41234e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m3) 41244e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m2) 41254e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m1) 41264e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m1[0], ord(b'1')) 41274e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m2[1], ord(b'2')) 41284e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m3[2], ord(b'3')) 41294e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del m3 41304e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del m2 41314e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del m1 41324e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 41334e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah x = bytearray(b'123') 41344e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(x) as m1: 41354e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del x 41364e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah y = ndarray(m1, getbuf=PyBUF_FULL_RO, flags=flags) 41374e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(y) as m2: 41384e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del y 41394e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah z = ndarray(m2, getbuf=PyBUF_FULL_RO, flags=flags) 41404e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(z) as m3: 41414e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del z 41424e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m1) 41434e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m2) 41444e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m3) 41454e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m1[0], ord(b'1')) 41464e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m2[1], ord(b'2')) 41474e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m3[2], ord(b'3')) 41484e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del m1, m2, m3 41494e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 4150fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah # memoryview.release() fails if the view has exported buffers. 4151fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah x = bytearray(b'123') 4152fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah with self.assertRaises(BufferError): 4153fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah with memoryview(x) as m: 4154fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah ex = ndarray(m) 4155fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah m[0] == ord(b'1') 41569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41574e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah def test_memoryview_redirect(self): 41584e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 41594e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd = ndarray([1.0 * x for x in range(12)], shape=[12], format='d') 41604e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah a = array.array('d', [1.0 * x for x in range(12)]) 41614e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 41624e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah for x in (nd, a): 41634e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 41644e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 41654e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m = memoryview(z) 41664e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 41674e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(y.obj, x) 41684e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(z.obj, x) 41694e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(m.obj, x) 41704e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 41714e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m, x) 41724e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m, y) 41734e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m, z) 41744e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 41754e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[1:3], x[1:3]) 41764e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[1:3], y[1:3]) 41774e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[1:3], z[1:3]) 41784e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del y, z 41794e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[1:3], x[1:3]) 41804e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 4181bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah def test_memoryview_from_static_exporter(self): 4182bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4183bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah fmt = 'B' 4184bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst = [0,1,2,3,4,5,6,7,8,9,10,11] 4185bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4186bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # exceptions 4187bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertRaises(TypeError, staticarray, 1, 2, 3) 4188bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4189bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # view.obj==x 4190bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray() 4191bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = memoryview(x) 4192bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(y, obj=x, 4193bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4194bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4195bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4196bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah for i in range(12): 4197bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertEqual(y[i], i) 4198bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x 4199bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del y 4200bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4201bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray() 4202bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = memoryview(x) 4203bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del y 4204bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x 4205bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4206bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray() 4207bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO) 4208bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO) 4209bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah m = memoryview(z) 4210bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(y.obj, x) 4211bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(m.obj, z) 4212bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(m, obj=z, 4213bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4214bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4215bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4216bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x, y, z, m 4217bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4218bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray() 4219bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 4220bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 4221bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah m = memoryview(z) 4222bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(y.obj, x) 4223bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(z.obj, x) 4224bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(m.obj, x) 4225bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(m, obj=x, 4226bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4227bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4228bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4229bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x, y, z, m 4230bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4231bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # view.obj==NULL 4232bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray(legacy_mode=True) 4233bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = memoryview(x) 4234bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(y, obj=None, 4235bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4236bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4237bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4238bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah for i in range(12): 4239bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertEqual(y[i], i) 4240bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x 4241bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del y 4242bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4243bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray(legacy_mode=True) 4244bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = memoryview(x) 4245bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del y 4246bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x 4247bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4248bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray(legacy_mode=True) 4249bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO) 4250bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO) 4251bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah m = memoryview(z) 4252bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(y.obj, None) 4253bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(m.obj, z) 4254bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(m, obj=z, 4255bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4256bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4257bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4258bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x, y, z, m 4259bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4260bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray(legacy_mode=True) 4261bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 4262bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 4263bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah m = memoryview(z) 4264bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # Clearly setting view.obj==NULL is inferior, since it 4265bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # messes up the redirection chain: 4266bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(y.obj, None) 4267bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(z.obj, y) 4268bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(m.obj, y) 4269bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(m, obj=y, 4270bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4271bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4272bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4273bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x, y, z, m 4274bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 42751649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah def test_memoryview_getbuffer_undefined(self): 42761649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah 42771649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah # getbufferproc does not adhere to the new documentation 42781649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah nd = ndarray([1,2,3], [3], flags=ND_GETBUF_FAIL|ND_GETBUF_UNDEFINED) 42791649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah self.assertRaises(BufferError, memoryview, nd) 42801649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah 42819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_issue_7385(self): 42829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray([1,2,3], shape=[3], flags=ND_GETBUF_FAIL) 42839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, memoryview, x) 42849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 42859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 42869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef test_main(): 42879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah support.run_unittest(TestBufferProtocol) 42889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 42899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 42909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahif __name__ == "__main__": 42919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah test_main() 4292