cpython-lru_cache-weakref: Lib/test/test

annotate Lib/test/test_buffer.py @ 87690:66c1c9f32567 default tip

Add use_weakref option to functools.lru_cache The use_weakref option makes lru_cache create weak references to the function arguments when creating the cache key, which prevents them from staying in the memory forever even after all other references to them are gone. This is a proof of concept for http://bugs.python.org/issue19859

author	Radomir Dopieralski <devel@sheep.art.pl>
date	Tue, 03 Dec 2013 16:02:48 +0100
parents	1e13a58c1b92
children

rev	line source
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1 #
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2 # The ndarray object from _testbuffer.c is a complete implementation of
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3 # a PEP-3118 buffer provider. It is independent from NumPy's ndarray
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4 # and the tests don't require NumPy.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	5 #
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	6 # If NumPy is present, some tests check both ndarray implementations
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	7 # against each other.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	8 #
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	9 # Most ndarray tests also check that memoryview(ndarray) behaves in
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	10 # the same way as the original. Thus, a substantial part of the
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	11 # memoryview tests is now in this module.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	12 #
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	13
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	14 import unittest
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	15 from test import support
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	16 from itertools import permutations, product
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	17 from random import randrange, sample, choice
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	18 from sysconfig import get_config_var
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	19 import warnings
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	20 import sys, array, io
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	21 from decimal import Decimal
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	22 from fractions import Fraction
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	23
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	24 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	25 from _testbuffer import *
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	26 except ImportError:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	27 ndarray = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	28
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	29 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	30 import struct
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	31 except ImportError:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	32 struct = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	33
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	34 try:
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	35 import ctypes
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	36 except ImportError:
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	37 ctypes = None
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	38
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	39 try:
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	40 with warnings.catch_warnings():
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	41 from numpy import ndarray as numpy_array
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	42 except ImportError:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	43 numpy_array = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	44
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	45
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	46 SHORT_TEST = True
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	47
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	48
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	49 # ======================================================================
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	50 # Random lists by format specifier
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	51 # ======================================================================
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	52
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	53 # Native format chars and their ranges.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	54 NATIVE = {
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	55 '?':0, 'c':0, 'b':0, 'B':0,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	56 'h':0, 'H':0, 'i':0, 'I':0,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	57 'l':0, 'L':0, 'n':0, 'N':0,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	58 'f':0, 'd':0, 'P':0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	59 }
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	60
78301 8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	61 # NumPy does not have 'n' or 'N':
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	62 if numpy_array:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	63 del NATIVE['n']
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	64 del NATIVE['N']
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	65
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	66 if struct:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	67 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	68 # Add "qQ" if present in native mode.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	69 struct.pack('Q', 2**64-1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	70 NATIVE['q'] = 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	71 NATIVE['Q'] = 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	72 except struct.error:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	73 pass
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	74
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	75 # Standard format chars and their ranges.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	76 STANDARD = {
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	77 '?':(0, 2), 'c':(0, 1<<8),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	78 'b':(-(1<<7), 1<<7), 'B':(0, 1<<8),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	79 'h':(-(1<<15), 1<<15), 'H':(0, 1<<16),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	80 'i':(-(1<<31), 1<<31), 'I':(0, 1<<32),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	81 'l':(-(1<<31), 1<<31), 'L':(0, 1<<32),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	82 'q':(-(1<<63), 1<<63), 'Q':(0, 1<<64),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	83 'f':(-(1<<63), 1<<63), 'd':(-(1<<1023), 1<<1023)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	84 }
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	85
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	86 def native_type_range(fmt):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	87 """Return range of a native type."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	88 if fmt == 'c':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	89 lh = (0, 256)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	90 elif fmt == '?':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	91 lh = (0, 2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	92 elif fmt == 'f':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	93 lh = (-(1<<63), 1<<63)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	94 elif fmt == 'd':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	95 lh = (-(1<<1023), 1<<1023)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	96 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	97 for exp in (128, 127, 64, 63, 32, 31, 16, 15, 8, 7):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	98 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	99 struct.pack(fmt, (1<<exp)-1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	100 break
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	101 except struct.error:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	102 pass
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	103 lh = (-(1<<exp), 1<<exp) if exp & 1 else (0, 1<<exp)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	104 return lh
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	105
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	106 fmtdict = {
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	107 '':NATIVE,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	108 '@':NATIVE,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	109 '<':STANDARD,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	110 '>':STANDARD,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	111 '=':STANDARD,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	112 '!':STANDARD
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	113 }
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	114
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	115 if struct:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	116 for fmt in fmtdict['@']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	117 fmtdict['@'][fmt] = native_type_range(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	118
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	119 MEMORYVIEW = NATIVE.copy()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	120 ARRAY = NATIVE.copy()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	121 for k in NATIVE:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	122 if not k in "bBhHiIlLfd":
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	123 del ARRAY[k]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	124
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	125 BYTEFMT = NATIVE.copy()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	126 for k in NATIVE:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	127 if not k in "Bbc":
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	128 del BYTEFMT[k]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	129
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	130 fmtdict['m'] = MEMORYVIEW
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	131 fmtdict['@m'] = MEMORYVIEW
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	132 fmtdict['a'] = ARRAY
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	133 fmtdict['b'] = BYTEFMT
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	134 fmtdict['@b'] = BYTEFMT
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	135
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	136 # Capabilities of the test objects:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	137 MODE = 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	138 MULT = 1
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	139 cap = { # format chars # multiplier
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	140 'ndarray': (['', '@', '<', '>', '=', '!'], ['', '1', '2', '3']),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	141 'array': (['a'], ['']),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	142 'numpy': ([''], ['']),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	143 'memoryview': (['@m', 'm'], ['']),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	144 'bytefmt': (['@b', 'b'], ['']),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	145 }
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	146
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	147 def randrange_fmt(mode, char, obj):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	148 """Return random item for a type specified by a mode and a single
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	149 format character."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	150 x = randrange(*fmtdict[mode][char])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	151 if char == 'c':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	152 x = bytes(chr(x), 'latin1')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	153 if char == '?':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	154 x = bool(x)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	155 if char == 'f' or char == 'd':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	156 x = struct.pack(char, x)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	157 x = struct.unpack(char, x)[0]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	158 if obj == 'numpy' and x == b'\x00':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	159 # http://projects.scipy.org/numpy/ticket/1925
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	160 x = b'\x01'
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	161 return x
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	162
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	163 def gen_item(fmt, obj):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	164 """Return single random item."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	165 mode, chars = fmt.split('#')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	166 x = []
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	167 for c in chars:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	168 x.append(randrange_fmt(mode, c, obj))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	169 return x[0] if len(x) == 1 else tuple(x)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	170
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	171 def gen_items(n, fmt, obj):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	172 """Return a list of random items (or a scalar)."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	173 if n == 0:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	174 return gen_item(fmt, obj)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	175 lst = [0] * n
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	176 for i in range(n):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	177 lst[i] = gen_item(fmt, obj)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	178 return lst
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	179
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	180 def struct_items(n, obj):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	181 mode = choice(cap[obj][MODE])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	182 xfmt = mode + '#'
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	183 fmt = mode.strip('amb')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	184 nmemb = randrange(2, 10) # number of struct members
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	185 for _ in range(nmemb):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	186 char = choice(tuple(fmtdict[mode]))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	187 multiplier = choice(cap[obj][MULT])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	188 xfmt += (char * int(multiplier if multiplier else 1))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	189 fmt += (multiplier + char)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	190 items = gen_items(n, xfmt, obj)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	191 item = gen_item(xfmt, obj)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	192 return fmt, items, item
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	193
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	194 def randitems(n, obj='ndarray', mode=None, char=None):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	195 """Return random format, items, item."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	196 if mode is None:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	197 mode = choice(cap[obj][MODE])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	198 if char is None:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	199 char = choice(tuple(fmtdict[mode]))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	200 multiplier = choice(cap[obj][MULT])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	201 fmt = mode + '#' + char * int(multiplier if multiplier else 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	202 items = gen_items(n, fmt, obj)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	203 item = gen_item(fmt, obj)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	204 fmt = mode.strip('amb') + multiplier + char
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	205 return fmt, items, item
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	206
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	207 def iter_mode(n, obj='ndarray'):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	208 """Iterate through supported mode/char combinations."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	209 for mode in cap[obj][MODE]:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	210 for char in fmtdict[mode]:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	211 yield randitems(n, obj, mode, char)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	212
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	213 def iter_format(nitems, testobj='ndarray'):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	214 """Yield (format, items, item) for all possible modes and format
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	215 characters plus one random compound format string."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	216 for t in iter_mode(nitems, testobj):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	217 yield t
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	218 if testobj != 'ndarray':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	219 raise StopIteration
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	220 yield struct_items(nitems, testobj)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	221
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	222
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	223 def is_byte_format(fmt):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	224 return 'c' in fmt or 'b' in fmt or 'B' in fmt
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	225
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	226 def is_memoryview_format(fmt):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	227 """format suitable for memoryview"""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	228 x = len(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	229 return ((x == 1 or (x == 2 and fmt[0] == '@')) and
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	230 fmt[x-1] in MEMORYVIEW)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	231
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	232 NON_BYTE_FORMAT = [c for c in fmtdict['@'] if not is_byte_format(c)]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	233
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	234
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	235 # ======================================================================
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	236 # Multi-dimensional tolist(), slicing and slice assignments
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	237 # ======================================================================
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	238
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	239 def atomp(lst):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	240 """Tuple items (representing structs) are regarded as atoms."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	241 return not isinstance(lst, list)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	242
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	243 def listp(lst):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	244 return isinstance(lst, list)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	245
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	246 def prod(lst):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	247 """Product of list elements."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	248 if len(lst) == 0:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	249 return 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	250 x = lst[0]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	251 for v in lst[1:]:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	252 x *= v
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	253 return x
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	254
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	255 def strides_from_shape(ndim, shape, itemsize, layout):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	256 """Calculate strides of a contiguous array. Layout is 'C' or
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	257 'F' (Fortran)."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	258 if ndim == 0:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	259 return ()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	260 if layout == 'C':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	261 strides = list(shape[1:]) + [itemsize]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	262 for i in range(ndim-2, -1, -1):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	263 strides[i] *= strides[i+1]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	264 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	265 strides = [itemsize] + list(shape[:-1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	266 for i in range(1, ndim):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	267 strides[i] *= strides[i-1]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	268 return strides
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	269
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	270 def _ca(items, s):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	271 """Convert flat item list to the nested list representation of a
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	272 multidimensional C array with shape 's'."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	273 if atomp(items):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	274 return items
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	275 if len(s) == 0:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	276 return items[0]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	277 lst = [0] * s[0]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	278 stride = len(items) // s[0] if s[0] else 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	279 for i in range(s[0]):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	280 start = i*stride
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	281 lst[i] = _ca(items[start:start+stride], s[1:])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	282 return lst
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	283
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	284 def _fa(items, s):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	285 """Convert flat item list to the nested list representation of a
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	286 multidimensional Fortran array with shape 's'."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	287 if atomp(items):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	288 return items
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	289 if len(s) == 0:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	290 return items[0]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	291 lst = [0] * s[0]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	292 stride = s[0]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	293 for i in range(s[0]):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	294 lst[i] = _fa(items[i::stride], s[1:])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	295 return lst
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	296
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	297 def carray(items, shape):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	298 if listp(items) and not 0 in shape and prod(shape) != len(items):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	299 raise ValueError("prod(shape) != len(items)")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	300 return _ca(items, shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	301
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	302 def farray(items, shape):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	303 if listp(items) and not 0 in shape and prod(shape) != len(items):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	304 raise ValueError("prod(shape) != len(items)")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	305 return _fa(items, shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	306
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	307 def indices(shape):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	308 """Generate all possible tuples of indices."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	309 iterables = [range(v) for v in shape]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	310 return product(*iterables)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	311
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	312 def getindex(ndim, ind, strides):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	313 """Convert multi-dimensional index to the position in the flat list."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	314 ret = 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	315 for i in range(ndim):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	316 ret += strides[i] * ind[i]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	317 return ret
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	318
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	319 def transpose(src, shape):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	320 """Transpose flat item list that is regarded as a multi-dimensional
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	321 matrix defined by shape: dest...[k][j][i] = src[i][j][k]... """
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	322 if not shape:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	323 return src
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	324 ndim = len(shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	325 sstrides = strides_from_shape(ndim, shape, 1, 'C')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	326 dstrides = strides_from_shape(ndim, shape[::-1], 1, 'C')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	327 dest = [0] * len(src)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	328 for ind in indices(shape):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	329 fr = getindex(ndim, ind, sstrides)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	330 to = getindex(ndim, ind[::-1], dstrides)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	331 dest[to] = src[fr]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	332 return dest
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	333
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	334 def _flatten(lst):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	335 """flatten list"""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	336 if lst == []:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	337 return lst
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	338 if atomp(lst):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	339 return [lst]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	340 return _flatten(lst[0]) + _flatten(lst[1:])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	341
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	342 def flatten(lst):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	343 """flatten list or return scalar"""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	344 if atomp(lst): # scalar
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	345 return lst
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	346 return _flatten(lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	347
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	348 def slice_shape(lst, slices):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	349 """Get the shape of lst after slicing: slices is a list of slice
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	350 objects."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	351 if atomp(lst):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	352 return []
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	353 return [len(lst[slices[0]])] + slice_shape(lst[0], slices[1:])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	354
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	355 def multislice(lst, slices):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	356 """Multi-dimensional slicing: slices is a list of slice objects."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	357 if atomp(lst):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	358 return lst
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	359 return [multislice(sublst, slices[1:]) for sublst in lst[slices[0]]]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	360
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	361 def m_assign(llst, rlst, lslices, rslices):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	362 """Multi-dimensional slice assignment: llst and rlst are the operands,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	363 lslices and rslices are lists of slice objects. llst and rlst must
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	364 have the same structure.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	365
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	366 For a two-dimensional example, this is not implemented in Python:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	367
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	368 llst[0:3:2, 0:3:2] = rlst[1:3:1, 1:3:1]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	369
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	370 Instead we write:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	371
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	372 lslices = [slice(0,3,2), slice(0,3,2)]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	373 rslices = [slice(1,3,1), slice(1,3,1)]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	374 multislice_assign(llst, rlst, lslices, rslices)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	375 """
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	376 if atomp(rlst):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	377 return rlst
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	378 rlst = [m_assign(l, r, lslices[1:], rslices[1:])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	379 for l, r in zip(llst[lslices[0]], rlst[rslices[0]])]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	380 llst[lslices[0]] = rlst
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	381 return llst
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	382
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	383 def cmp_structure(llst, rlst, lslices, rslices):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	384 """Compare the structure of llst[lslices] and rlst[rslices]."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	385 lshape = slice_shape(llst, lslices)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	386 rshape = slice_shape(rlst, rslices)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	387 if (len(lshape) != len(rshape)):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	388 return -1
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	389 for i in range(len(lshape)):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	390 if lshape[i] != rshape[i]:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	391 return -1
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	392 if lshape[i] == 0:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	393 return 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	394 return 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	395
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	396 def multislice_assign(llst, rlst, lslices, rslices):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	397 """Return llst after assigning: llst[lslices] = rlst[rslices]"""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	398 if cmp_structure(llst, rlst, lslices, rslices) < 0:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	399 raise ValueError("lvalue and rvalue have different structures")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	400 return m_assign(llst, rlst, lslices, rslices)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	401
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	402
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	403 # ======================================================================
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	404 # Random structures
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	405 # ======================================================================
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	406
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	407 #
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	408 # PEP-3118 is very permissive with respect to the contents of a
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	409 # Py_buffer. In particular:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	410 #
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	411 # - shape can be zero
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	412 # - strides can be any integer, including zero
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	413 # - offset can point to any location in the underlying
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	414 # memory block, provided that it is a multiple of
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	415 # itemsize.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	416 #
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	417 # The functions in this section test and verify random structures
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	418 # in full generality. A structure is valid iff it fits in the
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	419 # underlying memory block.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	420 #
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	421 # The structure 't' (short for 'tuple') is fully defined by:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	422 #
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	423 # t = (memlen, itemsize, ndim, shape, strides, offset)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	424 #
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	425
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	426 def verify_structure(memlen, itemsize, ndim, shape, strides, offset):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	427 """Verify that the parameters represent a valid array within
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	428 the bounds of the allocated memory:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	429 char *mem: start of the physical memory block
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	430 memlen: length of the physical memory block
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	431 offset: (char *)buf - mem
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	432 """
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	433 if offset % itemsize:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	434 return False
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	435 if offset < 0 or offset+itemsize > memlen:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	436 return False
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	437 if any(v % itemsize for v in strides):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	438 return False
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	439
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	440 if ndim <= 0:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	441 return ndim == 0 and not shape and not strides
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	442 if 0 in shape:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	443 return True
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	444
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	445 imin = sum(strides[j]*(shape[j]-1) for j in range(ndim)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	446 if strides[j] <= 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	447 imax = sum(strides[j]*(shape[j]-1) for j in range(ndim)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	448 if strides[j] > 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	449
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	450 return 0 <= offset+imin and offset+imax+itemsize <= memlen
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	451
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	452 def get_item(lst, indices):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	453 for i in indices:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	454 lst = lst[i]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	455 return lst
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	456
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	457 def memory_index(indices, t):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	458 """Location of an item in the underlying memory."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	459 memlen, itemsize, ndim, shape, strides, offset = t
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	460 p = offset
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	461 for i in range(ndim):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	462 p += strides[i]*indices[i]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	463 return p
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	464
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	465 def is_overlapping(t):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	466 """The structure 't' is overlapping if at least one memory location
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	467 is visited twice while iterating through all possible tuples of
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	468 indices."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	469 memlen, itemsize, ndim, shape, strides, offset = t
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	470 visited = 1<<memlen
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	471 for ind in indices(shape):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	472 i = memory_index(ind, t)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	473 bit = 1<<i
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	474 if visited & bit:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	475 return True
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	476 visited \|= bit
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	477 return False
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	478
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	479 def rand_structure(itemsize, valid, maxdim=5, maxshape=16, shape=()):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	480 """Return random structure:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	481 (memlen, itemsize, ndim, shape, strides, offset)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	482 If 'valid' is true, the returned structure is valid, otherwise invalid.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	483 If 'shape' is given, use that instead of creating a random shape.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	484 """
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	485 if not shape:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	486 ndim = randrange(maxdim+1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	487 if (ndim == 0):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	488 if valid:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	489 return itemsize, itemsize, ndim, (), (), 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	490 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	491 nitems = randrange(1, 16+1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	492 memlen = nitems * itemsize
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	493 offset = -itemsize if randrange(2) == 0 else memlen
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	494 return memlen, itemsize, ndim, (), (), offset
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	495
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	496 minshape = 2
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	497 n = randrange(100)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	498 if n >= 95 and valid:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	499 minshape = 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	500 elif n >= 90:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	501 minshape = 1
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	502 shape = [0] * ndim
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	503
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	504 for i in range(ndim):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	505 shape[i] = randrange(minshape, maxshape+1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	506 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	507 ndim = len(shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	508
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	509 maxstride = 5
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	510 n = randrange(100)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	511 zero_stride = True if n >= 95 and n & 1 else False
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	512
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	513 strides = [0] * ndim
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	514 strides[ndim-1] = itemsize * randrange(-maxstride, maxstride+1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	515 if not zero_stride and strides[ndim-1] == 0:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	516 strides[ndim-1] = itemsize
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	517
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	518 for i in range(ndim-2, -1, -1):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	519 maxstride *= shape[i+1] if shape[i+1] else 1
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	520 if zero_stride:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	521 strides[i] = itemsize * randrange(-maxstride, maxstride+1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	522 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	523 strides[i] = ((1,-1)[randrange(2)] *
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	524 itemsize * randrange(1, maxstride+1))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	525
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	526 imin = imax = 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	527 if not 0 in shape:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	528 imin = sum(strides[j]*(shape[j]-1) for j in range(ndim)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	529 if strides[j] <= 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	530 imax = sum(strides[j]*(shape[j]-1) for j in range(ndim)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	531 if strides[j] > 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	532
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	533 nitems = imax - imin
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	534 if valid:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	535 offset = -imin * itemsize
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	536 memlen = offset + (imax+1) * itemsize
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	537 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	538 memlen = (-imin + imax) * itemsize
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	539 offset = -imin-itemsize if randrange(2) == 0 else memlen
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	540 return memlen, itemsize, ndim, shape, strides, offset
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	541
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	542 def randslice_from_slicelen(slicelen, listlen):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	543 """Create a random slice of len slicelen that fits into listlen."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	544 maxstart = listlen - slicelen
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	545 start = randrange(maxstart+1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	546 maxstep = (listlen - start) // slicelen if slicelen else 1
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	547 step = randrange(1, maxstep+1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	548 stop = start + slicelen * step
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	549 s = slice(start, stop, step)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	550 _, _, _, control = slice_indices(s, listlen)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	551 if control != slicelen:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	552 raise RuntimeError
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	553 return s
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	554
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	555 def randslice_from_shape(ndim, shape):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	556 """Create two sets of slices for an array x with shape 'shape'
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	557 such that shapeof(x[lslices]) == shapeof(x[rslices])."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	558 lslices = [0] * ndim
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	559 rslices = [0] * ndim
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	560 for n in range(ndim):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	561 l = shape[n]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	562 slicelen = randrange(1, l+1) if l > 0 else 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	563 lslices[n] = randslice_from_slicelen(slicelen, l)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	564 rslices[n] = randslice_from_slicelen(slicelen, l)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	565 return tuple(lslices), tuple(rslices)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	566
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	567 def rand_aligned_slices(maxdim=5, maxshape=16):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	568 """Create (lshape, rshape, tuple(lslices), tuple(rslices)) such that
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	569 shapeof(x[lslices]) == shapeof(y[rslices]), where x is an array
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	570 with shape 'lshape' and y is an array with shape 'rshape'."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	571 ndim = randrange(1, maxdim+1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	572 minshape = 2
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	573 n = randrange(100)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	574 if n >= 95:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	575 minshape = 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	576 elif n >= 90:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	577 minshape = 1
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	578 all_random = True if randrange(100) >= 80 else False
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	579 lshape = [0]ndim; rshape = [0]ndim
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	580 lslices = [0]ndim; rslices = [0]ndim
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	581
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	582 for n in range(ndim):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	583 small = randrange(minshape, maxshape+1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	584 big = randrange(minshape, maxshape+1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	585 if big < small:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	586 big, small = small, big
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	587
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	588 # Create a slice that fits the smaller value.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	589 if all_random:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	590 start = randrange(-small, small+1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	591 stop = randrange(-small, small+1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	592 step = (1,-1)[randrange(2)] * randrange(1, small+2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	593 s_small = slice(start, stop, step)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	594 _, _, _, slicelen = slice_indices(s_small, small)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	595 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	596 slicelen = randrange(1, small+1) if small > 0 else 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	597 s_small = randslice_from_slicelen(slicelen, small)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	598
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	599 # Create a slice of the same length for the bigger value.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	600 s_big = randslice_from_slicelen(slicelen, big)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	601 if randrange(2) == 0:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	602 rshape[n], lshape[n] = big, small
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	603 rslices[n], lslices[n] = s_big, s_small
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	604 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	605 rshape[n], lshape[n] = small, big
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	606 rslices[n], lslices[n] = s_small, s_big
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	607
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	608 return lshape, rshape, tuple(lslices), tuple(rslices)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	609
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	610 def randitems_from_structure(fmt, t):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	611 """Return a list of random items for structure 't' with format
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	612 'fmtchar'."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	613 memlen, itemsize, _, _, _, _ = t
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	614 return gen_items(memlen//itemsize, '#'+fmt, 'numpy')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	615
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	616 def ndarray_from_structure(items, fmt, t, flags=0):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	617 """Return ndarray from the tuple returned by rand_structure()"""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	618 memlen, itemsize, ndim, shape, strides, offset = t
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	619 return ndarray(items, shape=shape, strides=strides, format=fmt,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	620 offset=offset, flags=ND_WRITABLE\|flags)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	621
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	622 def numpy_array_from_structure(items, fmt, t):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	623 """Return numpy_array from the tuple returned by rand_structure()"""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	624 memlen, itemsize, ndim, shape, strides, offset = t
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	625 buf = bytearray(memlen)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	626 for j, v in enumerate(items):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	627 struct.pack_into(fmt, buf, j*itemsize, v)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	628 return numpy_array(buffer=buf, shape=shape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	629 dtype=fmt, offset=offset)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	630
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	631
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	632 # ======================================================================
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	633 # memoryview casts
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	634 # ======================================================================
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	635
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	636 def cast_items(exporter, fmt, itemsize, shape=None):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	637 """Interpret the raw memory of 'exporter' as a list of items with
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	638 size 'itemsize'. If shape=None, the new structure is assumed to
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	639 be 1-D with n * itemsize = bytelen. If shape is given, the usual
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	640 constraint for contiguous arrays prod(shape) * itemsize = bytelen
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	641 applies. On success, return (items, shape). If the constraints
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	642 cannot be met, return (None, None). If a chunk of bytes is interpreted
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	643 as NaN as a result of float conversion, return ('nan', None)."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	644 bytelen = exporter.nbytes
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	645 if shape:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	646 if prod(shape) * itemsize != bytelen:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	647 return None, shape
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	648 elif shape == []:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	649 if exporter.ndim == 0 or itemsize != bytelen:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	650 return None, shape
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	651 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	652 n, r = divmod(bytelen, itemsize)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	653 shape = [n]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	654 if r != 0:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	655 return None, shape
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	656
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	657 mem = exporter.tobytes()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	658 byteitems = [mem[i:i+itemsize] for i in range(0, len(mem), itemsize)]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	659
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	660 items = []
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	661 for v in byteitems:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	662 item = struct.unpack(fmt, v)[0]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	663 if item != item:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	664 return 'nan', shape
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	665 items.append(item)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	666
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	667 return (items, shape) if shape != [] else (items[0], shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	668
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	669 def gencastshapes():
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	670 """Generate shapes to test casting."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	671 for n in range(32):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	672 yield [n]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	673 ndim = randrange(4, 6)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	674 minshape = 1 if randrange(100) > 80 else 2
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	675 yield [randrange(minshape, 5) for _ in range(ndim)]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	676 ndim = randrange(2, 4)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	677 minshape = 1 if randrange(100) > 80 else 2
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	678 yield [randrange(minshape, 5) for _ in range(ndim)]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	679
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	680
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	681 # ======================================================================
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	682 # Actual tests
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	683 # ======================================================================
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	684
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	685 def genslices(n):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	686 """Generate all possible slices for a single dimension."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	687 return product(range(-n, n+1), range(-n, n+1), range(-n, n+1))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	688
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	689 def genslices_ndim(ndim, shape):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	690 """Generate all possible slice tuples for 'shape'."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	691 iterables = [genslices(shape[n]) for n in range(ndim)]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	692 return product(*iterables)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	693
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	694 def rslice(n, allow_empty=False):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	695 """Generate random slice for a single dimension of length n.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	696 If zero=True, the slices may be empty, otherwise they will
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	697 be non-empty."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	698 minlen = 0 if allow_empty or n == 0 else 1
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	699 slicelen = randrange(minlen, n+1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	700 return randslice_from_slicelen(slicelen, n)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	701
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	702 def rslices(n, allow_empty=False):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	703 """Generate random slices for a single dimension."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	704 for _ in range(5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	705 yield rslice(n, allow_empty)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	706
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	707 def rslices_ndim(ndim, shape, iterations=5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	708 """Generate random slice tuples for 'shape'."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	709 # non-empty slices
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	710 for _ in range(iterations):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	711 yield tuple(rslice(shape[n]) for n in range(ndim))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	712 # possibly empty slices
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	713 for _ in range(iterations):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	714 yield tuple(rslice(shape[n], allow_empty=True) for n in range(ndim))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	715 # invalid slices
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	716 yield tuple(slice(0,1,0) for _ in range(ndim))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	717
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	718 def rpermutation(iterable, r=None):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	719 pool = tuple(iterable)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	720 r = len(pool) if r is None else r
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	721 yield tuple(sample(pool, r))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	722
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	723 def ndarray_print(nd):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	724 """Print ndarray for debugging."""
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	725 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	726 x = nd.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	727 except (TypeError, NotImplementedError):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	728 x = nd.tobytes()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	729 if isinstance(nd, ndarray):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	730 offset = nd.offset
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	731 flags = nd.flags
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	732 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	733 offset = 'unknown'
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	734 flags = 'unknown'
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	735 print("ndarray(%s, shape=%s, strides=%s, suboffsets=%s, offset=%s, "
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	736 "format='%s', itemsize=%s, flags=%s)" %
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	737 (x, nd.shape, nd.strides, nd.suboffsets, offset,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	738 nd.format, nd.itemsize, flags))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	739 sys.stdout.flush()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	740
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	741
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	742 ITERATIONS = 100
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	743 MAXDIM = 5
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	744 MAXSHAPE = 10
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	745
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	746 if SHORT_TEST:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	747 ITERATIONS = 10
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	748 MAXDIM = 3
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	749 MAXSHAPE = 4
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	750 genslices = rslices
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	751 genslices_ndim = rslices_ndim
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	752 permutations = rpermutation
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	753
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	754
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	755 @unittest.skipUnless(struct, 'struct module required for this test.')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	756 @unittest.skipUnless(ndarray, 'ndarray object required for this test')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	757 class TestBufferProtocol(unittest.TestCase):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	758
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	759 def setUp(self):
77006 967b06d56a69 Issue #14779: Get sizeof(void ) directly rather than relying on sysconfig. Stefan Krah <skrah@bytereef.org>* parents: 76885 diff changeset	760 # The suboffsets tests need sizeof(void *).
967b06d56a69 Issue #14779: Get sizeof(void ) directly rather than relying on sysconfig. Stefan Krah <skrah@bytereef.org>* parents: 76885 diff changeset	761 self.sizeof_void_p = get_sizeof_void_p()
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	762
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	763 def verify(self, result, obj=-1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	764 itemsize={1}, fmt=-1, readonly={1},
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	765 ndim={1}, shape=-1, strides=-1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	766 lst=-1, sliced=False, cast=False):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	767 # Verify buffer contents against expected values. Default values
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	768 # are deliberately initialized to invalid types.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	769 if shape:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	770 expected_len = prod(shape)*itemsize
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	771 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	772 if not fmt: # array has been implicitly cast to unsigned bytes
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	773 expected_len = len(lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	774 else: # ndim = 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	775 expected_len = itemsize
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	776
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	777 # Reconstruct suboffsets from strides. Support for slicing
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	778 # could be added, but is currently only needed for test_getbuf().
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	779 suboffsets = ()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	780 if result.suboffsets:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	781 self.assertGreater(ndim, 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	782
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	783 suboffset0 = 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	784 for n in range(1, ndim):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	785 if shape[n] == 0:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	786 break
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	787 if strides[n] <= 0:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	788 suboffset0 += -strides[n] * (shape[n]-1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	789
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	790 suboffsets = [suboffset0] + [-1 for v in range(ndim-1)]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	791
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	792 # Not correct if slicing has occurred in the first dimension.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	793 stride0 = self.sizeof_void_p
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	794 if strides[0] < 0:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	795 stride0 = -stride0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	796 strides = [stride0] + list(strides[1:])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	797
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	798 self.assertIs(result.obj, obj)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	799 self.assertEqual(result.nbytes, expected_len)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	800 self.assertEqual(result.itemsize, itemsize)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	801 self.assertEqual(result.format, fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	802 self.assertEqual(result.readonly, readonly)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	803 self.assertEqual(result.ndim, ndim)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	804 self.assertEqual(result.shape, tuple(shape))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	805 if not (sliced and suboffsets):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	806 self.assertEqual(result.strides, tuple(strides))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	807 self.assertEqual(result.suboffsets, tuple(suboffsets))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	808
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	809 if isinstance(result, ndarray) or is_memoryview_format(fmt):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	810 rep = result.tolist() if fmt else result.tobytes()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	811 self.assertEqual(rep, lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	812
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	813 if not fmt: # array has been cast to unsigned bytes,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	814 return # the remaining tests won't work.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	815
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	816 # PyBuffer_GetPointer() is the definition how to access an item.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	817 # If PyBuffer_GetPointer(indices) is correct for all possible
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	818 # combinations of indices, the buffer is correct.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	819 #
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	820 # Also test tobytes() against the flattened 'lst', with all items
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	821 # packed to bytes.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	822 if not cast: # casts chop up 'lst' in different ways
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	823 b = bytearray()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	824 buf_err = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	825 for ind in indices(shape):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	826 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	827 item1 = get_pointer(result, ind)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	828 item2 = get_item(lst, ind)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	829 if isinstance(item2, tuple):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	830 x = struct.pack(fmt, *item2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	831 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	832 x = struct.pack(fmt, item2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	833 b.extend(x)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	834 except BufferError:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	835 buf_err = True # re-exporter does not provide full buffer
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	836 break
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	837 self.assertEqual(item1, item2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	838
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	839 if not buf_err:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	840 # test tobytes()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	841 self.assertEqual(result.tobytes(), b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	842
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	843 # lst := expected multi-dimensional logical representation
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	844 # flatten(lst) := elements in C-order
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	845 ff = fmt if fmt else 'B'
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	846 flattened = flatten(lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	847
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	848 # Rules for 'A': if the array is already contiguous, return
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	849 # the array unaltered. Otherwise, return a contiguous 'C'
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	850 # representation.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	851 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	852 expected = result
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	853 if order == 'F':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	854 if not is_contiguous(result, 'A') or \
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	855 is_contiguous(result, 'C'):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	856 # For constructing the ndarray, convert the
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	857 # flattened logical representation to Fortran order.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	858 trans = transpose(flattened, shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	859 expected = ndarray(trans, shape=shape, format=ff,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	860 flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	861 else: # 'C', 'A'
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	862 if not is_contiguous(result, 'A') or \
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	863 is_contiguous(result, 'F') and order == 'C':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	864 # The flattened list is already in C-order.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	865 expected = ndarray(flattened, shape=shape, format=ff)
78301 8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	866
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	867 contig = get_contiguous(result, PyBUF_READ, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	868 self.assertEqual(contig.tobytes(), b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	869 self.assertTrue(cmp_contig(contig, expected))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	870
78301 8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	871 if ndim == 0:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	872 continue
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	873
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	874 nmemb = len(flattened)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	875 ro = 0 if readonly else ND_WRITABLE
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	876
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	877 ### See comment in test_py_buffer_to_contiguous for an
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	878 ### explanation why these tests are valid.
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	879
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	880 # To 'C'
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	881 contig = py_buffer_to_contiguous(result, 'C', PyBUF_FULL_RO)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	882 self.assertEqual(len(contig), nmemb * itemsize)
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	883 initlst = [struct.unpack_from(fmt, contig, n*itemsize)
78301 8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	884 for n in range(nmemb)]
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	885 if len(initlst[0]) == 1:
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	886 initlst = [v[0] for v in initlst]
78301 8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	887
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	888 y = ndarray(initlst, shape=shape, flags=ro, format=fmt)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	889 self.assertEqual(memoryview(y), memoryview(result))
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	890
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	891 # To 'F'
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	892 contig = py_buffer_to_contiguous(result, 'F', PyBUF_FULL_RO)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	893 self.assertEqual(len(contig), nmemb * itemsize)
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	894 initlst = [struct.unpack_from(fmt, contig, n*itemsize)
78301 8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	895 for n in range(nmemb)]
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	896 if len(initlst[0]) == 1:
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	897 initlst = [v[0] for v in initlst]
78301 8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	898
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	899 y = ndarray(initlst, shape=shape, flags=ro\|ND_FORTRAN,
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	900 format=fmt)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	901 self.assertEqual(memoryview(y), memoryview(result))
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	902
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	903 # To 'A'
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	904 contig = py_buffer_to_contiguous(result, 'A', PyBUF_FULL_RO)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	905 self.assertEqual(len(contig), nmemb * itemsize)
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	906 initlst = [struct.unpack_from(fmt, contig, n*itemsize)
78301 8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	907 for n in range(nmemb)]
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	908 if len(initlst[0]) == 1:
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	909 initlst = [v[0] for v in initlst]
78301 8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	910
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	911 f = ND_FORTRAN if is_contiguous(result, 'F') else 0
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	912 y = ndarray(initlst, shape=shape, flags=f\|ro, format=fmt)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	913 self.assertEqual(memoryview(y), memoryview(result))
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	914
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	915 if is_memoryview_format(fmt):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	916 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	917 m = memoryview(result)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	918 except BufferError: # re-exporter does not provide full information
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	919 return
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	920 ex = result.obj if isinstance(result, memoryview) else result
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	921 self.assertIs(m.obj, ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	922 self.assertEqual(m.nbytes, expected_len)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	923 self.assertEqual(m.itemsize, itemsize)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	924 self.assertEqual(m.format, fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	925 self.assertEqual(m.readonly, readonly)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	926 self.assertEqual(m.ndim, ndim)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	927 self.assertEqual(m.shape, tuple(shape))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	928 if not (sliced and suboffsets):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	929 self.assertEqual(m.strides, tuple(strides))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	930 self.assertEqual(m.suboffsets, tuple(suboffsets))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	931
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	932 n = 1 if ndim == 0 else len(lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	933 self.assertEqual(len(m), n)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	934
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	935 rep = result.tolist() if fmt else result.tobytes()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	936 self.assertEqual(rep, lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	937 self.assertEqual(m, result)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	938
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	939 def verify_getbuf(self, orig_ex, ex, req, sliced=False):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	940 def simple_fmt(ex):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	941 return ex.format == '' or ex.format == 'B'
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	942 def match(req, flag):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	943 return ((req&flag) == flag)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	944
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	945 if (# writable request to read-only exporter
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	946 (ex.readonly and match(req, PyBUF_WRITABLE)) or
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	947 # cannot match explicit contiguity request
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	948 (match(req, PyBUF_C_CONTIGUOUS) and not ex.c_contiguous) or
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	949 (match(req, PyBUF_F_CONTIGUOUS) and not ex.f_contiguous) or
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	950 (match(req, PyBUF_ANY_CONTIGUOUS) and not ex.contiguous) or
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	951 # buffer needs suboffsets
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	952 (not match(req, PyBUF_INDIRECT) and ex.suboffsets) or
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	953 # buffer without strides must be C-contiguous
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	954 (not match(req, PyBUF_STRIDES) and not ex.c_contiguous) or
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	955 # PyBUF_SIMPLE\|PyBUF_FORMAT and PyBUF_WRITABLE\|PyBUF_FORMAT
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	956 (not match(req, PyBUF_ND) and match(req, PyBUF_FORMAT))):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	957
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	958 self.assertRaises(BufferError, ndarray, ex, getbuf=req)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	959 return
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	960
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	961 if isinstance(ex, ndarray) or is_memoryview_format(ex.format):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	962 lst = ex.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	963 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	964 nd = ndarray(ex, getbuf=PyBUF_FULL_RO)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	965 lst = nd.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	966
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	967 # The consumer may have requested default values or a NULL format.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	968 ro = 0 if match(req, PyBUF_WRITABLE) else ex.readonly
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	969 fmt = ex.format
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	970 itemsize = ex.itemsize
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	971 ndim = ex.ndim
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	972 if not match(req, PyBUF_FORMAT):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	973 # itemsize refers to the original itemsize before the cast.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	974 # The equality product(shape) * itemsize = len still holds.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	975 # The equality calcsize(format) = itemsize does _not_ hold.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	976 fmt = ''
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	977 lst = orig_ex.tobytes() # Issue 12834
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	978 if not match(req, PyBUF_ND):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	979 ndim = 1
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	980 shape = orig_ex.shape if match(req, PyBUF_ND) else ()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	981 strides = orig_ex.strides if match(req, PyBUF_STRIDES) else ()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	982
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	983 nd = ndarray(ex, getbuf=req)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	984 self.verify(nd, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	985 itemsize=itemsize, fmt=fmt, readonly=ro,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	986 ndim=ndim, shape=shape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	987 lst=lst, sliced=sliced)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	988
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	989 def test_ndarray_getbuf(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	990 requests = (
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	991 # distinct flags
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	992 PyBUF_INDIRECT, PyBUF_STRIDES, PyBUF_ND, PyBUF_SIMPLE,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	993 PyBUF_C_CONTIGUOUS, PyBUF_F_CONTIGUOUS, PyBUF_ANY_CONTIGUOUS,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	994 # compound requests
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	995 PyBUF_FULL, PyBUF_FULL_RO,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	996 PyBUF_RECORDS, PyBUF_RECORDS_RO,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	997 PyBUF_STRIDED, PyBUF_STRIDED_RO,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	998 PyBUF_CONTIG, PyBUF_CONTIG_RO,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	999 )
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1000 # items and format
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1001 items_fmt = (
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1002 ([True if x % 2 else False for x in range(12)], '?'),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1003 ([1,2,3,4,5,6,7,8,9,10,11,12], 'b'),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1004 ([1,2,3,4,5,6,7,8,9,10,11,12], 'B'),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1005 ([(231-x) if x % 2 else (-231+x) for x in range(12)], 'l')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1006 )
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1007 # shape, strides, offset
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1008 structure = (
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1009 ([], [], 0),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1010 ([12], [], 0),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1011 ([12], [-1], 11),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1012 ([6], [2], 0),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1013 ([6], [-2], 11),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1014 ([3, 4], [], 0),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1015 ([3, 4], [-4, -1], 11),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1016 ([2, 2], [4, 1], 4),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1017 ([2, 2], [-4, -1], 8)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1018 )
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1019 # ndarray creation flags
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1020 ndflags = (
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1021 0, ND_WRITABLE, ND_FORTRAN, ND_FORTRAN\|ND_WRITABLE,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1022 ND_PIL, ND_PIL\|ND_WRITABLE
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1023 )
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1024 # flags that can actually be used as flags
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1025 real_flags = (0, PyBUF_WRITABLE, PyBUF_FORMAT,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1026 PyBUF_WRITABLE\|PyBUF_FORMAT)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1027
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1028 for items, fmt in items_fmt:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1029 itemsize = struct.calcsize(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1030 for shape, strides, offset in structure:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1031 strides = [v * itemsize for v in strides]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1032 offset *= itemsize
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1033 for flags in ndflags:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1034
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1035 if strides and (flags&ND_FORTRAN):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1036 continue
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1037 if not shape and (flags&ND_PIL):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1038 continue
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1039
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1040 _items = items if shape else items[0]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1041 ex1 = ndarray(_items, format=fmt, flags=flags,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1042 shape=shape, strides=strides, offset=offset)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1043 ex2 = ex1[::-2] if shape else None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1044
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1045 m1 = memoryview(ex1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1046 if ex2:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1047 m2 = memoryview(ex2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1048 if ex1.ndim == 0 or (ex1.ndim == 1 and shape and strides):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1049 self.assertEqual(m1, ex1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1050 if ex2 and ex2.ndim == 1 and shape and strides:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1051 self.assertEqual(m2, ex2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1052
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1053 for req in requests:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1054 for bits in real_flags:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1055 self.verify_getbuf(ex1, ex1, req\|bits)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1056 self.verify_getbuf(ex1, m1, req\|bits)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1057 if ex2:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1058 self.verify_getbuf(ex2, ex2, req\|bits,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1059 sliced=True)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1060 self.verify_getbuf(ex2, m2, req\|bits,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1061 sliced=True)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1062
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1063 items = [1,2,3,4,5,6,7,8,9,10,11,12]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1064
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1065 # ND_GETBUF_FAIL
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1066 ex = ndarray(items, shape=[12], flags=ND_GETBUF_FAIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1067 self.assertRaises(BufferError, ndarray, ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1068
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1069 # Request complex structure from a simple exporter. In this
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1070 # particular case the test object is not PEP-3118 compliant.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1071 base = ndarray([9], [1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1072 ex = ndarray(base, getbuf=PyBUF_SIMPLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1073 self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1074 self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_ND)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1075 self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_STRIDES)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1076 self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_C_CONTIGUOUS)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1077 self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_F_CONTIGUOUS)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1078 self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_ANY_CONTIGUOUS)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1079 nd = ndarray(ex, getbuf=PyBUF_SIMPLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1080
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1081 def test_ndarray_exceptions(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1082 nd = ndarray([9], [1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1083 ndm = ndarray([9], [1], flags=ND_VAREXPORT)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1084
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1085 # Initialization of a new ndarray or mutation of an existing array.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1086 for c in (ndarray, nd.push, ndm.push):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1087 # Invalid types.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1088 self.assertRaises(TypeError, c, {1,2,3})
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1089 self.assertRaises(TypeError, c, [1,2,'3'])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1090 self.assertRaises(TypeError, c, [1,2,(3,4)])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1091 self.assertRaises(TypeError, c, [1,2,3], shape={3})
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1092 self.assertRaises(TypeError, c, [1,2,3], shape=[3], strides={1})
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1093 self.assertRaises(TypeError, c, [1,2,3], shape=[3], offset=[])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1094 self.assertRaises(TypeError, c, [1], shape=[1], format={})
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1095 self.assertRaises(TypeError, c, [1], shape=[1], flags={})
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1096 self.assertRaises(TypeError, c, [1], shape=[1], getbuf={})
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1097
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1098 # ND_FORTRAN flag is only valid without strides.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1099 self.assertRaises(TypeError, c, [1], shape=[1], strides=[1],
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1100 flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1101
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1102 # ND_PIL flag is only valid with ndim > 0.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1103 self.assertRaises(TypeError, c, [1], shape=[], flags=ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1104
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1105 # Invalid items.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1106 self.assertRaises(ValueError, c, [], shape=[1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1107 self.assertRaises(ValueError, c, ['XXX'], shape=[1], format="L")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1108 # Invalid combination of items and format.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1109 self.assertRaises(struct.error, c, [1000], shape=[1], format="B")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1110 self.assertRaises(ValueError, c, [1,(2,3)], shape=[2], format="B")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1111 self.assertRaises(ValueError, c, [1,2,3], shape=[3], format="QL")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1112
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1113 # Invalid ndim.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1114 n = ND_MAX_NDIM+1
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1115 self.assertRaises(ValueError, c, [1]n, shape=[1]n)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1116
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1117 # Invalid shape.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1118 self.assertRaises(ValueError, c, [1], shape=[-1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1119 self.assertRaises(ValueError, c, [1,2,3], shape=['3'])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1120 self.assertRaises(OverflowError, c, [1], shape=[2**128])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1121 # prod(shape) * itemsize != len(items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1122 self.assertRaises(ValueError, c, [1,2,3,4,5], shape=[2,2], offset=3)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1123
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1124 # Invalid strides.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1125 self.assertRaises(ValueError, c, [1,2,3], shape=[3], strides=['1'])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1126 self.assertRaises(OverflowError, c, [1], shape=[1],
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1127 strides=[2**128])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1128
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1129 # Invalid combination of strides and shape.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1130 self.assertRaises(ValueError, c, [1,2], shape=[2,1], strides=[1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1131 # Invalid combination of strides and format.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1132 self.assertRaises(ValueError, c, [1,2,3,4], shape=[2], strides=[3],
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1133 format="L")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1134
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1135 # Invalid offset.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1136 self.assertRaises(ValueError, c, [1,2,3], shape=[3], offset=4)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1137 self.assertRaises(ValueError, c, [1,2,3], shape=[1], offset=3,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1138 format="L")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1139
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1140 # Invalid format.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1141 self.assertRaises(ValueError, c, [1,2,3], shape=[3], format="")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1142 self.assertRaises(struct.error, c, [(1,2,3)], shape=[1],
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1143 format="@#$")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1144
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1145 # Striding out of the memory bounds.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1146 items = [1,2,3,4,5,6,7,8,9,10]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1147 self.assertRaises(ValueError, c, items, shape=[2,3],
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1148 strides=[-3, -2], offset=5)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1149
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1150 # Constructing consumer: format argument invalid.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1151 self.assertRaises(TypeError, c, bytearray(), format="Q")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1152
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1153 # Constructing original base object: getbuf argument invalid.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1154 self.assertRaises(TypeError, c, [1], shape=[1], getbuf=PyBUF_FULL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1155
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1156 # Shape argument is mandatory for original base objects.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1157 self.assertRaises(TypeError, c, [1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1158
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1159
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1160 # PyBUF_WRITABLE request to read-only provider.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1161 self.assertRaises(BufferError, ndarray, b'123', getbuf=PyBUF_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1162
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1163 # ND_VAREXPORT can only be specified during construction.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1164 nd = ndarray([9], [1], flags=ND_VAREXPORT)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1165 self.assertRaises(ValueError, nd.push, [1], [1], flags=ND_VAREXPORT)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1166
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1167 # Invalid operation for consumers: push/pop
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1168 nd = ndarray(b'123')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1169 self.assertRaises(BufferError, nd.push, [1], [1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1170 self.assertRaises(BufferError, nd.pop)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1171
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1172 # ND_VAREXPORT not set: push/pop fail with exported buffers
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1173 nd = ndarray([9], [1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1174 nd.push([1], [1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1175 m = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1176 self.assertRaises(BufferError, nd.push, [1], [1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1177 self.assertRaises(BufferError, nd.pop)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1178 m.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1179 nd.pop()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1180
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1181 # Single remaining buffer: pop fails
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1182 self.assertRaises(BufferError, nd.pop)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1183 del nd
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1184
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1185 # get_pointer()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1186 self.assertRaises(TypeError, get_pointer, {}, [1,2,3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1187 self.assertRaises(TypeError, get_pointer, b'123', {})
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1188
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1189 nd = ndarray(list(range(100)), shape=[1]*100)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1190 self.assertRaises(ValueError, get_pointer, nd, [5])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1191
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1192 nd = ndarray(list(range(12)), shape=[3,4])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1193 self.assertRaises(ValueError, get_pointer, nd, [2,3,4])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1194 self.assertRaises(ValueError, get_pointer, nd, [3,3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1195 self.assertRaises(ValueError, get_pointer, nd, [-3,3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1196 self.assertRaises(OverflowError, get_pointer, nd, [1<<64,3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1197
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1198 # tolist() needs format
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1199 ex = ndarray([1,2,3], shape=[3], format='L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1200 nd = ndarray(ex, getbuf=PyBUF_SIMPLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1201 self.assertRaises(ValueError, nd.tolist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1202
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1203 # memoryview_from_buffer()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1204 ex1 = ndarray([1,2,3], shape=[3], format='L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1205 ex2 = ndarray(ex1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1206 nd = ndarray(ex2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1207 self.assertRaises(TypeError, nd.memoryview_from_buffer)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1208
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1209 nd = ndarray([(1,)200], shape=[1], format='L'200)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1210 self.assertRaises(TypeError, nd.memoryview_from_buffer)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1211
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1212 n = ND_MAX_NDIM
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1213 nd = ndarray(list(range(n)), shape=[1]*n)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1214 self.assertRaises(ValueError, nd.memoryview_from_buffer)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1215
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1216 # get_contiguous()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1217 nd = ndarray([1], shape=[1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1218 self.assertRaises(TypeError, get_contiguous, 1, 2, 3, 4, 5)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1219 self.assertRaises(TypeError, get_contiguous, nd, "xyz", 'C')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1220 self.assertRaises(OverflowError, get_contiguous, nd, 2**64, 'C')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1221 self.assertRaises(TypeError, get_contiguous, nd, PyBUF_READ, 961)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1222 self.assertRaises(UnicodeEncodeError, get_contiguous, nd, PyBUF_READ,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1223 '\u2007')
78720 fa745ed89b7a Issue #15770: Check invalid arguments in test function. Patch by Victor Stinner. Stefan Krah <skrah@bytereef.org> parents: 78651 diff changeset	1224 self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'Z')
fa745ed89b7a Issue #15770: Check invalid arguments in test function. Patch by Victor Stinner. Stefan Krah <skrah@bytereef.org> parents: 78651 diff changeset	1225 self.assertRaises(ValueError, get_contiguous, nd, 255, 'A')
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1226
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1227 # cmp_contig()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1228 nd = ndarray([1], shape=[1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1229 self.assertRaises(TypeError, cmp_contig, 1, 2, 3, 4, 5)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1230 self.assertRaises(TypeError, cmp_contig, {}, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1231 self.assertRaises(TypeError, cmp_contig, nd, {})
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1232
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1233 # is_contiguous()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1234 nd = ndarray([1], shape=[1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1235 self.assertRaises(TypeError, is_contiguous, 1, 2, 3, 4, 5)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1236 self.assertRaises(TypeError, is_contiguous, {}, 'A')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1237 self.assertRaises(TypeError, is_contiguous, nd, 201)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1238
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1239 def test_ndarray_linked_list(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1240 for perm in permutations(range(5)):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1241 m = [0]*5
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1242 nd = ndarray([1,2,3], shape=[3], flags=ND_VAREXPORT)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1243 m[0] = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1244
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1245 for i in range(1, 5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1246 nd.push([1,2,3], shape=[3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1247 m[i] = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1248
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1249 for i in range(5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1250 m[perm[i]].release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1251
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1252 self.assertRaises(BufferError, nd.pop)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1253 del nd
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1254
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1255 def test_ndarray_format_scalar(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1256 # ndim = 0: scalar
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1257 for fmt, scalar, _ in iter_format(0):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1258 itemsize = struct.calcsize(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1259 nd = ndarray(scalar, shape=(), format=fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1260 self.verify(nd, obj=None,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1261 itemsize=itemsize, fmt=fmt, readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1262 ndim=0, shape=(), strides=(),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1263 lst=scalar)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1264
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1265 def test_ndarray_format_shape(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1266 # ndim = 1, shape = [n]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1267 nitems = randrange(1, 10)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1268 for fmt, items, _ in iter_format(nitems):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1269 itemsize = struct.calcsize(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1270 for flags in (0, ND_PIL):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1271 nd = ndarray(items, shape=[nitems], format=fmt, flags=flags)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1272 self.verify(nd, obj=None,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1273 itemsize=itemsize, fmt=fmt, readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1274 ndim=1, shape=(nitems,), strides=(itemsize,),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1275 lst=items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1276
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1277 def test_ndarray_format_strides(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1278 # ndim = 1, strides
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1279 nitems = randrange(1, 30)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1280 for fmt, items, _ in iter_format(nitems):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1281 itemsize = struct.calcsize(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1282 for step in range(-5, 5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1283 if step == 0:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1284 continue
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1285
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1286 shape = [len(items[::step])]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1287 strides = [step*itemsize]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1288 offset = itemsize*(nitems-1) if step < 0 else 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1289
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1290 for flags in (0, ND_PIL):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1291 nd = ndarray(items, shape=shape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1292 format=fmt, offset=offset, flags=flags)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1293 self.verify(nd, obj=None,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1294 itemsize=itemsize, fmt=fmt, readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1295 ndim=1, shape=shape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1296 lst=items[::step])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1297
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1298 def test_ndarray_fortran(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1299 items = [1,2,3,4,5,6,7,8,9,10,11,12]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1300 ex = ndarray(items, shape=(3, 4), strides=(1, 3))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1301 nd = ndarray(ex, getbuf=PyBUF_F_CONTIGUOUS\|PyBUF_FORMAT)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1302 self.assertEqual(nd.tolist(), farray(items, (3, 4)))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1303
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1304 def test_ndarray_multidim(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1305 for ndim in range(5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1306 shape_t = [randrange(2, 10) for _ in range(ndim)]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1307 nitems = prod(shape_t)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1308 for shape in permutations(shape_t):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1309
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1310 fmt, items, _ = randitems(nitems)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1311 itemsize = struct.calcsize(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1312
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1313 for flags in (0, ND_PIL):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1314 if ndim == 0 and flags == ND_PIL:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1315 continue
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1316
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1317 # C array
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1318 nd = ndarray(items, shape=shape, format=fmt, flags=flags)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1319
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1320 strides = strides_from_shape(ndim, shape, itemsize, 'C')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1321 lst = carray(items, shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1322 self.verify(nd, obj=None,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1323 itemsize=itemsize, fmt=fmt, readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1324 ndim=ndim, shape=shape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1325 lst=lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1326
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1327 if is_memoryview_format(fmt):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1328 # memoryview: reconstruct strides
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1329 ex = ndarray(items, shape=shape, format=fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1330 nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO\|PyBUF_FORMAT)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1331 self.assertTrue(nd.strides == ())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1332 mv = nd.memoryview_from_buffer()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1333 self.verify(mv, obj=None,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1334 itemsize=itemsize, fmt=fmt, readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1335 ndim=ndim, shape=shape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1336 lst=lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1337
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1338 # Fortran array
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1339 nd = ndarray(items, shape=shape, format=fmt,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1340 flags=flags\|ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1341
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1342 strides = strides_from_shape(ndim, shape, itemsize, 'F')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1343 lst = farray(items, shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1344 self.verify(nd, obj=None,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1345 itemsize=itemsize, fmt=fmt, readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1346 ndim=ndim, shape=shape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1347 lst=lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1348
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1349 def test_ndarray_index_invalid(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1350 # not writable
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1351 nd = ndarray([1], shape=[1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1352 self.assertRaises(TypeError, nd.__setitem__, 1, 8)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1353 mv = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1354 self.assertEqual(mv, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1355 self.assertRaises(TypeError, mv.__setitem__, 1, 8)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1356
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1357 # cannot be deleted
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1358 nd = ndarray([1], shape=[1], flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1359 self.assertRaises(TypeError, nd.__delitem__, 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1360 mv = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1361 self.assertEqual(mv, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1362 self.assertRaises(TypeError, mv.__delitem__, 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1363
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1364 # overflow
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1365 nd = ndarray([1], shape=[1], flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1366 self.assertRaises(OverflowError, nd.__getitem__, 1<<64)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1367 self.assertRaises(OverflowError, nd.__setitem__, 1<<64, 8)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1368 mv = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1369 self.assertEqual(mv, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1370 self.assertRaises(IndexError, mv.__getitem__, 1<<64)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1371 self.assertRaises(IndexError, mv.__setitem__, 1<<64, 8)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1372
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1373 # format
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1374 items = [1,2,3,4,5,6,7,8]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1375 nd = ndarray(items, shape=[len(items)], format="B", flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1376 self.assertRaises(struct.error, nd.__setitem__, 2, 300)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1377 self.assertRaises(ValueError, nd.__setitem__, 1, (100, 200))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1378 mv = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1379 self.assertEqual(mv, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1380 self.assertRaises(ValueError, mv.__setitem__, 2, 300)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1381 self.assertRaises(TypeError, mv.__setitem__, 1, (100, 200))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1382
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1383 items = [(1,2), (3,4), (5,6)]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1384 nd = ndarray(items, shape=[len(items)], format="LQ", flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1385 self.assertRaises(ValueError, nd.__setitem__, 2, 300)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1386 self.assertRaises(struct.error, nd.__setitem__, 1, (b'\x001', 200))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1387
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1388 def test_ndarray_index_scalar(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1389 # scalar
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1390 nd = ndarray(1, shape=(), flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1391 mv = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1392 self.assertEqual(mv, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1393
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1394 x = nd[()]; self.assertEqual(x, 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1395 x = nd[...]; self.assertEqual(x.tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1396
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1397 x = mv[()]; self.assertEqual(x, 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1398 x = mv[...]; self.assertEqual(x.tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1399
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1400 self.assertRaises(TypeError, nd.__getitem__, 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1401 self.assertRaises(TypeError, mv.__getitem__, 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1402 self.assertRaises(TypeError, nd.__setitem__, 0, 8)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1403 self.assertRaises(TypeError, mv.__setitem__, 0, 8)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1404
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1405 self.assertEqual(nd.tolist(), 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1406 self.assertEqual(mv.tolist(), 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1407
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1408 nd[()] = 9; self.assertEqual(nd.tolist(), 9)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1409 mv[()] = 9; self.assertEqual(mv.tolist(), 9)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1410
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1411 nd[...] = 5; self.assertEqual(nd.tolist(), 5)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1412 mv[...] = 5; self.assertEqual(mv.tolist(), 5)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1413
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1414 def test_ndarray_index_null_strides(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1415 ex = ndarray(list(range(2*4)), shape=[2, 4], flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1416 nd = ndarray(ex, getbuf=PyBUF_CONTIG)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1417
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1418 # Sub-views are only possible for full exporters.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1419 self.assertRaises(BufferError, nd.__getitem__, 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1420 # Same for slices.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1421 self.assertRaises(BufferError, nd.__getitem__, slice(3,5,1))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1422
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1423 def test_ndarray_index_getitem_single(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1424 # getitem
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1425 for fmt, items, _ in iter_format(5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1426 nd = ndarray(items, shape=[5], format=fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1427 for i in range(-5, 5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1428 self.assertEqual(nd[i], items[i])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1429
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1430 self.assertRaises(IndexError, nd.__getitem__, -6)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1431 self.assertRaises(IndexError, nd.__getitem__, 5)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1432
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1433 if is_memoryview_format(fmt):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1434 mv = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1435 self.assertEqual(mv, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1436 for i in range(-5, 5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1437 self.assertEqual(mv[i], items[i])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1438
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1439 self.assertRaises(IndexError, mv.__getitem__, -6)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1440 self.assertRaises(IndexError, mv.__getitem__, 5)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1441
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1442 # getitem with null strides
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1443 for fmt, items, _ in iter_format(5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1444 ex = ndarray(items, shape=[5], flags=ND_WRITABLE, format=fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1445 nd = ndarray(ex, getbuf=PyBUF_CONTIG\|PyBUF_FORMAT)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1446
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1447 for i in range(-5, 5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1448 self.assertEqual(nd[i], items[i])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1449
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1450 if is_memoryview_format(fmt):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1451 mv = nd.memoryview_from_buffer()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1452 self.assertIs(mv.__eq__(nd), NotImplemented)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1453 for i in range(-5, 5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1454 self.assertEqual(mv[i], items[i])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1455
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1456 # getitem with null format
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1457 items = [1,2,3,4,5]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1458 ex = ndarray(items, shape=[5])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1459 nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1460 for i in range(-5, 5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1461 self.assertEqual(nd[i], items[i])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1462
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1463 # getitem with null shape/strides/format
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1464 items = [1,2,3,4,5]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1465 ex = ndarray(items, shape=[5])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1466 nd = ndarray(ex, getbuf=PyBUF_SIMPLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1467
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1468 for i in range(-5, 5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1469 self.assertEqual(nd[i], items[i])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1470
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1471 def test_ndarray_index_setitem_single(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1472 # assign single value
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1473 for fmt, items, single_item in iter_format(5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1474 nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1475 for i in range(5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1476 items[i] = single_item
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1477 nd[i] = single_item
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1478 self.assertEqual(nd.tolist(), items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1479
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1480 self.assertRaises(IndexError, nd.__setitem__, -6, single_item)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1481 self.assertRaises(IndexError, nd.__setitem__, 5, single_item)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1482
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1483 if not is_memoryview_format(fmt):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1484 continue
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1485
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1486 nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1487 mv = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1488 self.assertEqual(mv, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1489 for i in range(5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1490 items[i] = single_item
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1491 mv[i] = single_item
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1492 self.assertEqual(mv.tolist(), items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1493
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1494 self.assertRaises(IndexError, mv.__setitem__, -6, single_item)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1495 self.assertRaises(IndexError, mv.__setitem__, 5, single_item)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1496
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1497
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1498 # assign single value: lobject = robject
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1499 for fmt, items, single_item in iter_format(5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1500 nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1501 for i in range(-5, 4):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1502 items[i] = items[i+1]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1503 nd[i] = nd[i+1]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1504 self.assertEqual(nd.tolist(), items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1505
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1506 if not is_memoryview_format(fmt):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1507 continue
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1508
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1509 nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1510 mv = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1511 self.assertEqual(mv, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1512 for i in range(-5, 4):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1513 items[i] = items[i+1]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1514 mv[i] = mv[i+1]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1515 self.assertEqual(mv.tolist(), items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1516
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1517 def test_ndarray_index_getitem_multidim(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1518 shape_t = (2, 3, 5)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1519 nitems = prod(shape_t)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1520 for shape in permutations(shape_t):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1521
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1522 fmt, items, _ = randitems(nitems)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1523
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1524 for flags in (0, ND_PIL):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1525 # C array
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1526 nd = ndarray(items, shape=shape, format=fmt, flags=flags)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1527 lst = carray(items, shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1528
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1529 for i in range(-shape[0], shape[0]):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1530 self.assertEqual(lst[i], nd[i].tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1531 for j in range(-shape[1], shape[1]):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1532 self.assertEqual(lst[i][j], nd[i][j].tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1533 for k in range(-shape[2], shape[2]):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1534 self.assertEqual(lst[i][j][k], nd[i][j][k])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1535
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1536 # Fortran array
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1537 nd = ndarray(items, shape=shape, format=fmt,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1538 flags=flags\|ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1539 lst = farray(items, shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1540
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1541 for i in range(-shape[0], shape[0]):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1542 self.assertEqual(lst[i], nd[i].tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1543 for j in range(-shape[1], shape[1]):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1544 self.assertEqual(lst[i][j], nd[i][j].tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1545 for k in range(shape[2], shape[2]):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1546 self.assertEqual(lst[i][j][k], nd[i][j][k])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1547
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1548 def test_ndarray_sequence(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1549 nd = ndarray(1, shape=())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1550 self.assertRaises(TypeError, eval, "1 in nd", locals())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1551 mv = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1552 self.assertEqual(mv, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1553 self.assertRaises(TypeError, eval, "1 in mv", locals())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1554
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1555 for fmt, items, _ in iter_format(5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1556 nd = ndarray(items, shape=[5], format=fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1557 for i, v in enumerate(nd):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1558 self.assertEqual(v, items[i])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1559 self.assertTrue(v in nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1560
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1561 if is_memoryview_format(fmt):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1562 mv = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1563 for i, v in enumerate(mv):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1564 self.assertEqual(v, items[i])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1565 self.assertTrue(v in mv)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1566
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1567 def test_ndarray_slice_invalid(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1568 items = [1,2,3,4,5,6,7,8]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1569
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1570 # rvalue is not an exporter
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1571 xl = ndarray(items, shape=[8], flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1572 ml = memoryview(xl)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1573 self.assertRaises(TypeError, xl.__setitem__, slice(0,8,1), items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1574 self.assertRaises(TypeError, ml.__setitem__, slice(0,8,1), items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1575
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1576 # rvalue is not a full exporter
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1577 xl = ndarray(items, shape=[8], flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1578 ex = ndarray(items, shape=[8], flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1579 xr = ndarray(ex, getbuf=PyBUF_ND)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1580 self.assertRaises(BufferError, xl.__setitem__, slice(0,8,1), xr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1581
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1582 # zero step
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1583 nd = ndarray(items, shape=[8], format="L", flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1584 mv = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1585 self.assertRaises(ValueError, nd.__getitem__, slice(0,1,0))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1586 self.assertRaises(ValueError, mv.__getitem__, slice(0,1,0))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1587
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1588 nd = ndarray(items, shape=[2,4], format="L", flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1589 mv = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1590
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1591 self.assertRaises(ValueError, nd.__getitem__,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1592 (slice(0,1,1), slice(0,1,0)))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1593 self.assertRaises(ValueError, nd.__getitem__,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1594 (slice(0,1,0), slice(0,1,1)))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1595 self.assertRaises(TypeError, nd.__getitem__, "@%$")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1596 self.assertRaises(TypeError, nd.__getitem__, ("@%$", slice(0,1,1)))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1597 self.assertRaises(TypeError, nd.__getitem__, (slice(0,1,1), {}))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1598
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1599 # memoryview: not implemented
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1600 self.assertRaises(NotImplementedError, mv.__getitem__,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1601 (slice(0,1,1), slice(0,1,0)))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1602 self.assertRaises(TypeError, mv.__getitem__, "@%$")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1603
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1604 # differing format
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1605 xl = ndarray(items, shape=[8], format="B", flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1606 xr = ndarray(items, shape=[8], format="b")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1607 ml = memoryview(xl)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1608 mr = memoryview(xr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1609 self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1610 self.assertEqual(xl.tolist(), items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1611 self.assertRaises(ValueError, ml.__setitem__, slice(0,1,1), mr[7:8])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1612 self.assertEqual(ml.tolist(), items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1613
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1614 # differing itemsize
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1615 xl = ndarray(items, shape=[8], format="B", flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1616 yr = ndarray(items, shape=[8], format="L")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1617 ml = memoryview(xl)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1618 mr = memoryview(xr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1619 self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1620 self.assertEqual(xl.tolist(), items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1621 self.assertRaises(ValueError, ml.__setitem__, slice(0,1,1), mr[7:8])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1622 self.assertEqual(ml.tolist(), items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1623
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1624 # differing ndim
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1625 xl = ndarray(items, shape=[2, 4], format="b", flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1626 xr = ndarray(items, shape=[8], format="b")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1627 ml = memoryview(xl)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1628 mr = memoryview(xr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1629 self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1630 self.assertEqual(xl.tolist(), [[1,2,3,4], [5,6,7,8]])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1631 self.assertRaises(NotImplementedError, ml.__setitem__, slice(0,1,1),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1632 mr[7:8])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1633
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1634 # differing shape
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1635 xl = ndarray(items, shape=[8], format="b", flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1636 xr = ndarray(items, shape=[8], format="b")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1637 ml = memoryview(xl)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1638 mr = memoryview(xr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1639 self.assertRaises(ValueError, xl.__setitem__, slice(0,2,1), xr[7:8])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1640 self.assertEqual(xl.tolist(), items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1641 self.assertRaises(ValueError, ml.__setitem__, slice(0,2,1), mr[7:8])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1642 self.assertEqual(ml.tolist(), items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1643
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1644 # _testbuffer.c module functions
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1645 self.assertRaises(TypeError, slice_indices, slice(0,1,2), {})
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1646 self.assertRaises(TypeError, slice_indices, "###########", 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1647 self.assertRaises(ValueError, slice_indices, slice(0,1,0), 4)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1648
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1649 x = ndarray(items, shape=[8], format="b", flags=ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1650 self.assertRaises(TypeError, x.add_suboffsets)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1651
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1652 ex = ndarray(items, shape=[8], format="B")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1653 x = ndarray(ex, getbuf=PyBUF_SIMPLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1654 self.assertRaises(TypeError, x.add_suboffsets)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1655
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1656 def test_ndarray_slice_zero_shape(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1657 items = [1,2,3,4,5,6,7,8,9,10,11,12]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1658
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1659 x = ndarray(items, shape=[12], format="L", flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1660 y = ndarray(items, shape=[12], format="L")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1661 x[4:4] = y[9:9]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1662 self.assertEqual(x.tolist(), items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1663
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1664 ml = memoryview(x)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1665 mr = memoryview(y)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1666 self.assertEqual(ml, x)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1667 self.assertEqual(ml, y)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1668 ml[4:4] = mr[9:9]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1669 self.assertEqual(ml.tolist(), items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1670
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1671 x = ndarray(items, shape=[3, 4], format="L", flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1672 y = ndarray(items, shape=[4, 3], format="L")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1673 x[1:2, 2:2] = y[1:2, 3:3]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1674 self.assertEqual(x.tolist(), carray(items, [3, 4]))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1675
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1676 def test_ndarray_slice_multidim(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1677 shape_t = (2, 3, 5)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1678 ndim = len(shape_t)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1679 nitems = prod(shape_t)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1680 for shape in permutations(shape_t):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1681
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1682 fmt, items, _ = randitems(nitems)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1683 itemsize = struct.calcsize(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1684
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1685 for flags in (0, ND_PIL):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1686 nd = ndarray(items, shape=shape, format=fmt, flags=flags)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1687 lst = carray(items, shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1688
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1689 for slices in rslices_ndim(ndim, shape):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1690
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1691 listerr = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1692 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1693 sliced = multislice(lst, slices)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1694 except Exception as e:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1695 listerr = e.__class__
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1696
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1697 nderr = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1698 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1699 ndsliced = nd[slices]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1700 except Exception as e:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1701 nderr = e.__class__
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1702
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1703 if nderr or listerr:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1704 self.assertIs(nderr, listerr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1705 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1706 self.assertEqual(ndsliced.tolist(), sliced)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1707
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1708 def test_ndarray_slice_redundant_suboffsets(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1709 shape_t = (2, 3, 5, 2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1710 ndim = len(shape_t)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1711 nitems = prod(shape_t)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1712 for shape in permutations(shape_t):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1713
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1714 fmt, items, _ = randitems(nitems)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1715 itemsize = struct.calcsize(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1716
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1717 nd = ndarray(items, shape=shape, format=fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1718 nd.add_suboffsets()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1719 ex = ndarray(items, shape=shape, format=fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1720 ex.add_suboffsets()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1721 mv = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1722 lst = carray(items, shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1723
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1724 for slices in rslices_ndim(ndim, shape):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1725
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1726 listerr = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1727 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1728 sliced = multislice(lst, slices)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1729 except Exception as e:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1730 listerr = e.__class__
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1731
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1732 nderr = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1733 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1734 ndsliced = nd[slices]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1735 except Exception as e:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1736 nderr = e.__class__
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1737
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1738 if nderr or listerr:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1739 self.assertIs(nderr, listerr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1740 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1741 self.assertEqual(ndsliced.tolist(), sliced)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1742
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1743 def test_ndarray_slice_assign_single(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1744 for fmt, items, _ in iter_format(5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1745 for lslice in genslices(5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1746 for rslice in genslices(5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1747 for flags in (0, ND_PIL):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1748
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1749 f = flags\|ND_WRITABLE
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1750 nd = ndarray(items, shape=[5], format=fmt, flags=f)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1751 ex = ndarray(items, shape=[5], format=fmt, flags=f)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1752 mv = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1753
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1754 lsterr = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1755 diff_structure = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1756 lst = items[:]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1757 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1758 lval = lst[lslice]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1759 rval = lst[rslice]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1760 lst[lslice] = lst[rslice]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1761 diff_structure = len(lval) != len(rval)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1762 except Exception as e:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1763 lsterr = e.__class__
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1764
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1765 nderr = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1766 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1767 nd[lslice] = nd[rslice]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1768 except Exception as e:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1769 nderr = e.__class__
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1770
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1771 if diff_structure: # ndarray cannot change shape
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1772 self.assertIs(nderr, ValueError)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1773 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1774 self.assertEqual(nd.tolist(), lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1775 self.assertIs(nderr, lsterr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1776
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1777 if not is_memoryview_format(fmt):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1778 continue
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1779
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1780 mverr = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1781 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1782 mv[lslice] = mv[rslice]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1783 except Exception as e:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1784 mverr = e.__class__
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1785
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1786 if diff_structure: # memoryview cannot change shape
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1787 self.assertIs(mverr, ValueError)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1788 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1789 self.assertEqual(mv.tolist(), lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1790 self.assertEqual(mv, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1791 self.assertIs(mverr, lsterr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1792 self.verify(mv, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1793 itemsize=nd.itemsize, fmt=fmt, readonly=0,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1794 ndim=nd.ndim, shape=nd.shape, strides=nd.strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1795 lst=nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1796
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1797 def test_ndarray_slice_assign_multidim(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1798 shape_t = (2, 3, 5)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1799 ndim = len(shape_t)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1800 nitems = prod(shape_t)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1801 for shape in permutations(shape_t):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1802
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1803 fmt, items, _ = randitems(nitems)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1804
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1805 for flags in (0, ND_PIL):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1806 for _ in range(ITERATIONS):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1807 lslices, rslices = randslice_from_shape(ndim, shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1808
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1809 nd = ndarray(items, shape=shape, format=fmt,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1810 flags=flags\|ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1811 lst = carray(items, shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1812
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1813 listerr = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1814 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1815 result = multislice_assign(lst, lst, lslices, rslices)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1816 except Exception as e:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1817 listerr = e.__class__
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1818
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1819 nderr = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1820 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1821 nd[lslices] = nd[rslices]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1822 except Exception as e:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1823 nderr = e.__class__
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1824
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1825 if nderr or listerr:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1826 self.assertIs(nderr, listerr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1827 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1828 self.assertEqual(nd.tolist(), result)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1829
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1830 def test_ndarray_random(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1831 # construction of valid arrays
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1832 for _ in range(ITERATIONS):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1833 for fmt in fmtdict['@']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1834 itemsize = struct.calcsize(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1835
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1836 t = rand_structure(itemsize, True, maxdim=MAXDIM,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1837 maxshape=MAXSHAPE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1838 self.assertTrue(verify_structure(*t))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1839 items = randitems_from_structure(fmt, t)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1840
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1841 x = ndarray_from_structure(items, fmt, t)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1842 xlist = x.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1843
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1844 mv = memoryview(x)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1845 if is_memoryview_format(fmt):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1846 mvlist = mv.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1847 self.assertEqual(mvlist, xlist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1848
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1849 if t[2] > 0:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1850 # ndim > 0: test against suboffsets representation.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1851 y = ndarray_from_structure(items, fmt, t, flags=ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1852 ylist = y.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1853 self.assertEqual(xlist, ylist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1854
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1855 mv = memoryview(y)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1856 if is_memoryview_format(fmt):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1857 self.assertEqual(mv, y)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1858 mvlist = mv.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1859 self.assertEqual(mvlist, ylist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1860
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1861 if numpy_array:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1862 shape = t[3]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1863 if 0 in shape:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1864 continue # http://projects.scipy.org/numpy/ticket/1910
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1865 z = numpy_array_from_structure(items, fmt, t)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1866 self.verify(x, obj=None,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1867 itemsize=z.itemsize, fmt=fmt, readonly=0,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1868 ndim=z.ndim, shape=z.shape, strides=z.strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1869 lst=z.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1870
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1871 def test_ndarray_random_invalid(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1872 # exceptions during construction of invalid arrays
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1873 for _ in range(ITERATIONS):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1874 for fmt in fmtdict['@']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1875 itemsize = struct.calcsize(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1876
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1877 t = rand_structure(itemsize, False, maxdim=MAXDIM,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1878 maxshape=MAXSHAPE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1879 self.assertFalse(verify_structure(*t))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1880 items = randitems_from_structure(fmt, t)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1881
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1882 nderr = False
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1883 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1884 x = ndarray_from_structure(items, fmt, t)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1885 except Exception as e:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1886 nderr = e.__class__
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1887 self.assertTrue(nderr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1888
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1889 if numpy_array:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1890 numpy_err = False
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1891 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1892 y = numpy_array_from_structure(items, fmt, t)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1893 except Exception as e:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1894 numpy_err = e.__class__
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1895
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1896 if 0: # http://projects.scipy.org/numpy/ticket/1910
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1897 self.assertTrue(numpy_err)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1898
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1899 def test_ndarray_random_slice_assign(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1900 # valid slice assignments
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1901 for _ in range(ITERATIONS):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1902 for fmt in fmtdict['@']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1903 itemsize = struct.calcsize(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1904
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1905 lshape, rshape, lslices, rslices = \
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1906 rand_aligned_slices(maxdim=MAXDIM, maxshape=MAXSHAPE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1907 tl = rand_structure(itemsize, True, shape=lshape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1908 tr = rand_structure(itemsize, True, shape=rshape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1909 self.assertTrue(verify_structure(*tl))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1910 self.assertTrue(verify_structure(*tr))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1911 litems = randitems_from_structure(fmt, tl)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1912 ritems = randitems_from_structure(fmt, tr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1913
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1914 xl = ndarray_from_structure(litems, fmt, tl)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1915 xr = ndarray_from_structure(ritems, fmt, tr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1916 xl[lslices] = xr[rslices]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1917 xllist = xl.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1918 xrlist = xr.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1919
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1920 ml = memoryview(xl)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1921 mr = memoryview(xr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1922 self.assertEqual(ml.tolist(), xllist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1923 self.assertEqual(mr.tolist(), xrlist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1924
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1925 if tl[2] > 0 and tr[2] > 0:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1926 # ndim > 0: test against suboffsets representation.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1927 yl = ndarray_from_structure(litems, fmt, tl, flags=ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1928 yr = ndarray_from_structure(ritems, fmt, tr, flags=ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1929 yl[lslices] = yr[rslices]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1930 yllist = yl.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1931 yrlist = yr.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1932 self.assertEqual(xllist, yllist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1933 self.assertEqual(xrlist, yrlist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1934
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1935 ml = memoryview(yl)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1936 mr = memoryview(yr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1937 self.assertEqual(ml.tolist(), yllist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1938 self.assertEqual(mr.tolist(), yrlist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1939
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1940 if numpy_array:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1941 if 0 in lshape or 0 in rshape:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1942 continue # http://projects.scipy.org/numpy/ticket/1910
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1943
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1944 zl = numpy_array_from_structure(litems, fmt, tl)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1945 zr = numpy_array_from_structure(ritems, fmt, tr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1946 zl[lslices] = zr[rslices]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1947
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1948 if not is_overlapping(tl) and not is_overlapping(tr):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1949 # Slice assignment of overlapping structures
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1950 # is undefined in NumPy.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1951 self.verify(xl, obj=None,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1952 itemsize=zl.itemsize, fmt=fmt, readonly=0,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1953 ndim=zl.ndim, shape=zl.shape,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1954 strides=zl.strides, lst=zl.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1955
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1956 self.verify(xr, obj=None,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1957 itemsize=zr.itemsize, fmt=fmt, readonly=0,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1958 ndim=zr.ndim, shape=zr.shape,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1959 strides=zr.strides, lst=zr.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1960
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1961 def test_ndarray_re_export(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1962 items = [1,2,3,4,5,6,7,8,9,10,11,12]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1963
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1964 nd = ndarray(items, shape=[3,4], flags=ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1965 ex = ndarray(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1966
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1967 self.assertTrue(ex.flags & ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1968 self.assertIs(ex.obj, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1969 self.assertEqual(ex.suboffsets, (0, -1))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1970 self.assertFalse(ex.c_contiguous)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1971 self.assertFalse(ex.f_contiguous)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1972 self.assertFalse(ex.contiguous)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1973
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1974 def test_ndarray_zero_shape(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1975 # zeros in shape
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1976 for flags in (0, ND_PIL):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1977 nd = ndarray([1,2,3], shape=[0], flags=flags)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1978 mv = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1979 self.assertEqual(mv, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1980 self.assertEqual(nd.tolist(), [])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1981 self.assertEqual(mv.tolist(), [])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1982
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1983 nd = ndarray([1,2,3], shape=[0,3,3], flags=flags)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1984 self.assertEqual(nd.tolist(), [])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1985
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1986 nd = ndarray([1,2,3], shape=[3,0,3], flags=flags)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1987 self.assertEqual(nd.tolist(), [[], [], []])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1988
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1989 nd = ndarray([1,2,3], shape=[3,3,0], flags=flags)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1990 self.assertEqual(nd.tolist(),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1991 [[[], [], []], [[], [], []], [[], [], []]])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1992
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1993 def test_ndarray_zero_strides(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1994 # zero strides
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1995 for flags in (0, ND_PIL):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1996 nd = ndarray([1], shape=[5], strides=[0], flags=flags)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1997 mv = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1998 self.assertEqual(mv, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	1999 self.assertEqual(nd.tolist(), [1, 1, 1, 1, 1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2000 self.assertEqual(mv.tolist(), [1, 1, 1, 1, 1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2001
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2002 def test_ndarray_offset(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2003 nd = ndarray(list(range(20)), shape=[3], offset=7)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2004 self.assertEqual(nd.offset, 7)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2005 self.assertEqual(nd.tolist(), [7,8,9])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2006
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2007 def test_ndarray_memoryview_from_buffer(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2008 for flags in (0, ND_PIL):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2009 nd = ndarray(list(range(3)), shape=[3], flags=flags)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2010 m = nd.memoryview_from_buffer()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2011 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2012
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2013 def test_ndarray_get_pointer(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2014 for flags in (0, ND_PIL):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2015 nd = ndarray(list(range(3)), shape=[3], flags=flags)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2016 for i in range(3):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2017 self.assertEqual(nd[i], get_pointer(nd, [i]))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2018
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2019 def test_ndarray_tolist_null_strides(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2020 ex = ndarray(list(range(20)), shape=[2,2,5])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2021
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2022 nd = ndarray(ex, getbuf=PyBUF_ND\|PyBUF_FORMAT)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2023 self.assertEqual(nd.tolist(), ex.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2024
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2025 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2026 self.assertEqual(m.tolist(), ex.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2027
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2028 def test_ndarray_cmp_contig(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2029
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2030 self.assertFalse(cmp_contig(b"123", b"456"))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2031
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2032 x = ndarray(list(range(12)), shape=[3,4])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2033 y = ndarray(list(range(12)), shape=[4,3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2034 self.assertFalse(cmp_contig(x, y))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2035
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2036 x = ndarray([1], shape=[1], format="B")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2037 self.assertTrue(cmp_contig(x, b'\x01'))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2038 self.assertTrue(cmp_contig(b'\x01', x))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2039
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2040 def test_ndarray_hash(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2041
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2042 a = array.array('L', [1,2,3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2043 nd = ndarray(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2044 self.assertRaises(ValueError, hash, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2045
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2046 # one-dimensional
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2047 b = bytes(list(range(12)))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2048
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2049 nd = ndarray(list(range(12)), shape=[12])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2050 self.assertEqual(hash(nd), hash(b))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2051
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2052 # C-contiguous
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2053 nd = ndarray(list(range(12)), shape=[3,4])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2054 self.assertEqual(hash(nd), hash(b))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2055
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2056 nd = ndarray(list(range(12)), shape=[3,2,2])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2057 self.assertEqual(hash(nd), hash(b))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2058
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2059 # Fortran contiguous
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2060 b = bytes(transpose(list(range(12)), shape=[4,3]))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2061 nd = ndarray(list(range(12)), shape=[3,4], flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2062 self.assertEqual(hash(nd), hash(b))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2063
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2064 b = bytes(transpose(list(range(12)), shape=[2,3,2]))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2065 nd = ndarray(list(range(12)), shape=[2,3,2], flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2066 self.assertEqual(hash(nd), hash(b))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2067
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2068 # suboffsets
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2069 b = bytes(list(range(12)))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2070 nd = ndarray(list(range(12)), shape=[2,2,3], flags=ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2071 self.assertEqual(hash(nd), hash(b))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2072
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2073 # non-byte formats
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2074 nd = ndarray(list(range(12)), shape=[2,2,3], format='L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2075 self.assertEqual(hash(nd), hash(nd.tobytes()))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2076
78301 8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2077 def test_py_buffer_to_contiguous(self):
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2078
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2079 # The requests are used in _testbuffer.c:py_buffer_to_contiguous
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2080 # to generate buffers without full information for testing.
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2081 requests = (
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2082 # distinct flags
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2083 PyBUF_INDIRECT, PyBUF_STRIDES, PyBUF_ND, PyBUF_SIMPLE,
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2084 # compound requests
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2085 PyBUF_FULL, PyBUF_FULL_RO,
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2086 PyBUF_RECORDS, PyBUF_RECORDS_RO,
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2087 PyBUF_STRIDED, PyBUF_STRIDED_RO,
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2088 PyBUF_CONTIG, PyBUF_CONTIG_RO,
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2089 )
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2090
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2091 # no buffer interface
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2092 self.assertRaises(TypeError, py_buffer_to_contiguous, {}, 'F',
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2093 PyBUF_FULL_RO)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2094
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2095 # scalar, read-only request
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2096 nd = ndarray(9, shape=(), format="L", flags=ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2097 for order in ['C', 'F', 'A']:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2098 for request in requests:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2099 b = py_buffer_to_contiguous(nd, order, request)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2100 self.assertEqual(b, nd.tobytes())
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2101
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2102 # zeros in shape
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2103 nd = ndarray([1], shape=[0], format="L", flags=ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2104 for order in ['C', 'F', 'A']:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2105 for request in requests:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2106 b = py_buffer_to_contiguous(nd, order, request)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2107 self.assertEqual(b, b'')
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2108
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2109 nd = ndarray(list(range(8)), shape=[2, 0, 7], format="L",
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2110 flags=ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2111 for order in ['C', 'F', 'A']:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2112 for request in requests:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2113 b = py_buffer_to_contiguous(nd, order, request)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2114 self.assertEqual(b, b'')
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2115
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2116 ### One-dimensional arrays are trivial, since Fortran and C order
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2117 ### are the same.
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2118
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2119 # one-dimensional
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2120 for f in [0, ND_FORTRAN]:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2121 nd = ndarray([1], shape=[1], format="h", flags=f\|ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2122 ndbytes = nd.tobytes()
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2123 for order in ['C', 'F', 'A']:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2124 for request in requests:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2125 b = py_buffer_to_contiguous(nd, order, request)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2126 self.assertEqual(b, ndbytes)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2127
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2128 nd = ndarray([1, 2, 3], shape=[3], format="b", flags=f\|ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2129 ndbytes = nd.tobytes()
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2130 for order in ['C', 'F', 'A']:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2131 for request in requests:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2132 b = py_buffer_to_contiguous(nd, order, request)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2133 self.assertEqual(b, ndbytes)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2134
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2135 # one-dimensional, non-contiguous input
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2136 nd = ndarray([1, 2, 3], shape=[2], strides=[2], flags=ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2137 ndbytes = nd.tobytes()
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2138 for order in ['C', 'F', 'A']:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2139 for request in [PyBUF_STRIDES, PyBUF_FULL]:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2140 b = py_buffer_to_contiguous(nd, order, request)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2141 self.assertEqual(b, ndbytes)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2142
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2143 nd = nd[::-1]
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2144 ndbytes = nd.tobytes()
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2145 for order in ['C', 'F', 'A']:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2146 for request in requests:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2147 try:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2148 b = py_buffer_to_contiguous(nd, order, request)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2149 except BufferError:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2150 continue
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2151 self.assertEqual(b, ndbytes)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2152
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2153 ###
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2154 ### Multi-dimensional arrays:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2155 ###
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2156 ### The goal here is to preserve the logical representation of the
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2157 ### input array but change the physical representation if necessary.
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2158 ###
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2159 ### _testbuffer example:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2160 ### ====================
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2161 ###
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2162 ### C input array:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2163 ### --------------
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2164 ### >>> nd = ndarray(list(range(12)), shape=[3, 4])
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2165 ### >>> nd.tolist()
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2166 ### [[0, 1, 2, 3],
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2167 ### [4, 5, 6, 7],
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2168 ### [8, 9, 10, 11]]
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2169 ###
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2170 ### Fortran output:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2171 ### ---------------
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2172 ### >>> py_buffer_to_contiguous(nd, 'F', PyBUF_FULL_RO)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2173 ### >>> b'\x00\x04\x08\x01\x05\t\x02\x06\n\x03\x07\x0b'
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2174 ###
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2175 ### The return value corresponds to this input list for
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2176 ### _testbuffer's ndarray:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2177 ### >>> nd = ndarray([0,4,8,1,5,9,2,6,10,3,7,11], shape=[3,4],
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2178 ### flags=ND_FORTRAN)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2179 ### >>> nd.tolist()
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2180 ### [[0, 1, 2, 3],
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2181 ### [4, 5, 6, 7],
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2182 ### [8, 9, 10, 11]]
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2183 ###
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2184 ### The logical array is the same, but the values in memory are now
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2185 ### in Fortran order.
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2186 ###
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2187 ### NumPy example:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2188 ### ==============
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2189 ### _testbuffer's ndarray takes lists to initialize the memory.
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2190 ### Here's the same sequence in NumPy:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2191 ###
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2192 ### C input:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2193 ### --------
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2194 ### >>> nd = ndarray(buffer=bytearray(list(range(12))),
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2195 ### shape=[3, 4], dtype='B')
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2196 ### >>> nd
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2197 ### array([[ 0, 1, 2, 3],
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2198 ### [ 4, 5, 6, 7],
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2199 ### [ 8, 9, 10, 11]], dtype=uint8)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2200 ###
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2201 ### Fortran output:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2202 ### ---------------
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2203 ### >>> fortran_buf = nd.tostring(order='F')
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2204 ### >>> fortran_buf
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2205 ### b'\x00\x04\x08\x01\x05\t\x02\x06\n\x03\x07\x0b'
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2206 ###
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2207 ### >>> nd = ndarray(buffer=fortran_buf, shape=[3, 4],
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2208 ### dtype='B', order='F')
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2209 ###
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2210 ### >>> nd
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2211 ### array([[ 0, 1, 2, 3],
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2212 ### [ 4, 5, 6, 7],
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2213 ### [ 8, 9, 10, 11]], dtype=uint8)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2214 ###
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2215
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2216 # multi-dimensional, contiguous input
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2217 lst = list(range(12))
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2218 for f in [0, ND_FORTRAN]:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2219 nd = ndarray(lst, shape=[3, 4], flags=f\|ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2220 if numpy_array:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2221 na = numpy_array(buffer=bytearray(lst),
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2222 shape=[3, 4], dtype='B',
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2223 order='C' if f == 0 else 'F')
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2224
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2225 # 'C' request
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2226 if f == ND_FORTRAN: # 'F' to 'C'
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2227 x = ndarray(transpose(lst, [4, 3]), shape=[3, 4],
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2228 flags=ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2229 expected = x.tobytes()
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2230 else:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2231 expected = nd.tobytes()
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2232 for request in requests:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2233 try:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2234 b = py_buffer_to_contiguous(nd, 'C', request)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2235 except BufferError:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2236 continue
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2237
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2238 self.assertEqual(b, expected)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2239
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2240 # Check that output can be used as the basis for constructing
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2241 # a C array that is logically identical to the input array.
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2242 y = ndarray([v for v in b], shape=[3, 4], flags=ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2243 self.assertEqual(memoryview(y), memoryview(nd))
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2244
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2245 if numpy_array:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2246 self.assertEqual(b, na.tostring(order='C'))
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2247
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2248 # 'F' request
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2249 if f == 0: # 'C' to 'F'
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2250 x = ndarray(transpose(lst, [3, 4]), shape=[4, 3],
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2251 flags=ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2252 else:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2253 x = ndarray(lst, shape=[3, 4], flags=ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2254 expected = x.tobytes()
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2255 for request in [PyBUF_FULL, PyBUF_FULL_RO, PyBUF_INDIRECT,
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2256 PyBUF_STRIDES, PyBUF_ND]:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2257 try:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2258 b = py_buffer_to_contiguous(nd, 'F', request)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2259 except BufferError:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2260 continue
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2261 self.assertEqual(b, expected)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2262
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2263 # Check that output can be used as the basis for constructing
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2264 # a Fortran array that is logically identical to the input array.
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2265 y = ndarray([v for v in b], shape=[3, 4], flags=ND_FORTRAN\|ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2266 self.assertEqual(memoryview(y), memoryview(nd))
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2267
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2268 if numpy_array:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2269 self.assertEqual(b, na.tostring(order='F'))
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2270
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2271 # 'A' request
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2272 if f == ND_FORTRAN:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2273 x = ndarray(lst, shape=[3, 4], flags=ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2274 expected = x.tobytes()
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2275 else:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2276 expected = nd.tobytes()
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2277 for request in [PyBUF_FULL, PyBUF_FULL_RO, PyBUF_INDIRECT,
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2278 PyBUF_STRIDES, PyBUF_ND]:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2279 try:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2280 b = py_buffer_to_contiguous(nd, 'A', request)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2281 except BufferError:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2282 continue
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2283
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2284 self.assertEqual(b, expected)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2285
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2286 # Check that output can be used as the basis for constructing
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2287 # an array with order=f that is logically identical to the input
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2288 # array.
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2289 y = ndarray([v for v in b], shape=[3, 4], flags=f\|ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2290 self.assertEqual(memoryview(y), memoryview(nd))
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2291
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2292 if numpy_array:
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2293 self.assertEqual(b, na.tostring(order='A'))
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2294
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2295 # multi-dimensional, non-contiguous input
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2296 nd = ndarray(list(range(12)), shape=[3, 4], flags=ND_WRITABLE\|ND_PIL)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2297
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2298 # 'C'
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2299 b = py_buffer_to_contiguous(nd, 'C', PyBUF_FULL_RO)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2300 self.assertEqual(b, nd.tobytes())
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2301 y = ndarray([v for v in b], shape=[3, 4], flags=ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2302 self.assertEqual(memoryview(y), memoryview(nd))
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2303
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2304 # 'F'
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2305 b = py_buffer_to_contiguous(nd, 'F', PyBUF_FULL_RO)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2306 x = ndarray(transpose(lst, [3, 4]), shape=[4, 3], flags=ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2307 self.assertEqual(b, x.tobytes())
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2308 y = ndarray([v for v in b], shape=[3, 4], flags=ND_FORTRAN\|ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2309 self.assertEqual(memoryview(y), memoryview(nd))
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2310
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2311 # 'A'
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2312 b = py_buffer_to_contiguous(nd, 'A', PyBUF_FULL_RO)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2313 self.assertEqual(b, nd.tobytes())
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2314 y = ndarray([v for v in b], shape=[3, 4], flags=ND_WRITABLE)
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2315 self.assertEqual(memoryview(y), memoryview(nd))
8fbbc7c8748e Issue #12834: Fix PyBuffer_ToContiguous() for non-contiguous arrays. Stefan Krah <skrah@bytereef.org> parents: 77006 diff changeset	2316
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2317 def test_memoryview_construction(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2318
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2319 items_shape = [(9, []), ([1,2,3], [3]), (list(range(235)), [2,3,5])]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2320
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2321 # NumPy style, C-contiguous:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2322 for items, shape in items_shape:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2323
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2324 # From PEP-3118 compliant exporter:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2325 ex = ndarray(items, shape=shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2326 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2327 self.assertTrue(m.c_contiguous)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2328 self.assertTrue(m.contiguous)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2329
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2330 ndim = len(shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2331 strides = strides_from_shape(ndim, shape, 1, 'C')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2332 lst = carray(items, shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2333
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2334 self.verify(m, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2335 itemsize=1, fmt='B', readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2336 ndim=ndim, shape=shape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2337 lst=lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2338
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2339 # From memoryview:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2340 m2 = memoryview(m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2341 self.verify(m2, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2342 itemsize=1, fmt='B', readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2343 ndim=ndim, shape=shape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2344 lst=lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2345
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2346 # PyMemoryView_FromBuffer(): no strides
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2347 nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO\|PyBUF_FORMAT)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2348 self.assertEqual(nd.strides, ())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2349 m = nd.memoryview_from_buffer()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2350 self.verify(m, obj=None,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2351 itemsize=1, fmt='B', readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2352 ndim=ndim, shape=shape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2353 lst=lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2354
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2355 # PyMemoryView_FromBuffer(): no format, shape, strides
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2356 nd = ndarray(ex, getbuf=PyBUF_SIMPLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2357 self.assertEqual(nd.format, '')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2358 self.assertEqual(nd.shape, ())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2359 self.assertEqual(nd.strides, ())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2360 m = nd.memoryview_from_buffer()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2361
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2362 lst = [items] if ndim == 0 else items
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2363 self.verify(m, obj=None,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2364 itemsize=1, fmt='B', readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2365 ndim=1, shape=[ex.nbytes], strides=(1,),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2366 lst=lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2367
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2368 # NumPy style, Fortran contiguous:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2369 for items, shape in items_shape:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2370
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2371 # From PEP-3118 compliant exporter:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2372 ex = ndarray(items, shape=shape, flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2373 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2374 self.assertTrue(m.f_contiguous)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2375 self.assertTrue(m.contiguous)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2376
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2377 ndim = len(shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2378 strides = strides_from_shape(ndim, shape, 1, 'F')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2379 lst = farray(items, shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2380
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2381 self.verify(m, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2382 itemsize=1, fmt='B', readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2383 ndim=ndim, shape=shape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2384 lst=lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2385
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2386 # From memoryview:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2387 m2 = memoryview(m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2388 self.verify(m2, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2389 itemsize=1, fmt='B', readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2390 ndim=ndim, shape=shape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2391 lst=lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2392
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2393 # PIL style:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2394 for items, shape in items_shape[1:]:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2395
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2396 # From PEP-3118 compliant exporter:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2397 ex = ndarray(items, shape=shape, flags=ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2398 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2399
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2400 ndim = len(shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2401 lst = carray(items, shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2402
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2403 self.verify(m, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2404 itemsize=1, fmt='B', readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2405 ndim=ndim, shape=shape, strides=ex.strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2406 lst=lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2407
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2408 # From memoryview:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2409 m2 = memoryview(m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2410 self.verify(m2, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2411 itemsize=1, fmt='B', readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2412 ndim=ndim, shape=shape, strides=ex.strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2413 lst=lst)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2414
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2415 # Invalid number of arguments:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2416 self.assertRaises(TypeError, memoryview, b'9', 'x')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2417 # Not a buffer provider:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2418 self.assertRaises(TypeError, memoryview, {})
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2419 # Non-compliant buffer provider:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2420 ex = ndarray([1,2,3], shape=[3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2421 nd = ndarray(ex, getbuf=PyBUF_SIMPLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2422 self.assertRaises(BufferError, memoryview, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2423 nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO\|PyBUF_FORMAT)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2424 self.assertRaises(BufferError, memoryview, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2425
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2426 # ndim > 64
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2427 nd = ndarray([1]128, shape=[1]128, format='L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2428 self.assertRaises(ValueError, memoryview, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2429 self.assertRaises(ValueError, nd.memoryview_from_buffer)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2430 self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'C')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2431 self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'F')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2432 self.assertRaises(ValueError, get_contiguous, nd[::-1], PyBUF_READ, 'C')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2433
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2434 def test_memoryview_cast_zero_shape(self):
85939 b08e092df155 Issue #19014: memoryview.cast() is now allowed on zero-length views. Antoine Pitrou <solipsis@pitrou.net> parents: 80245 diff changeset	2435 # Casts are undefined if buffer is multidimensional and shape
b08e092df155 Issue #19014: memoryview.cast() is now allowed on zero-length views. Antoine Pitrou <solipsis@pitrou.net> parents: 80245 diff changeset	2436 # contains zeros. These arrays are regarded as C-contiguous by
b08e092df155 Issue #19014: memoryview.cast() is now allowed on zero-length views. Antoine Pitrou <solipsis@pitrou.net> parents: 80245 diff changeset	2437 # Numpy and PyBuffer_GetContiguous(), so they are not caught by
b08e092df155 Issue #19014: memoryview.cast() is now allowed on zero-length views. Antoine Pitrou <solipsis@pitrou.net> parents: 80245 diff changeset	2438 # the test for C-contiguity in memory_cast().
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2439 items = [1,2,3]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2440 for shape in ([0,3,3], [3,0,3], [0,3,3]):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2441 ex = ndarray(items, shape=shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2442 self.assertTrue(ex.c_contiguous)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2443 msrc = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2444 self.assertRaises(TypeError, msrc.cast, 'c')
85939 b08e092df155 Issue #19014: memoryview.cast() is now allowed on zero-length views. Antoine Pitrou <solipsis@pitrou.net> parents: 80245 diff changeset	2445 # Monodimensional empty view can be cast (issue #19014).
b08e092df155 Issue #19014: memoryview.cast() is now allowed on zero-length views. Antoine Pitrou <solipsis@pitrou.net> parents: 80245 diff changeset	2446 for fmt, _, _ in iter_format(1, 'memoryview'):
b08e092df155 Issue #19014: memoryview.cast() is now allowed on zero-length views. Antoine Pitrou <solipsis@pitrou.net> parents: 80245 diff changeset	2447 msrc = memoryview(b'')
b08e092df155 Issue #19014: memoryview.cast() is now allowed on zero-length views. Antoine Pitrou <solipsis@pitrou.net> parents: 80245 diff changeset	2448 m = msrc.cast(fmt)
b08e092df155 Issue #19014: memoryview.cast() is now allowed on zero-length views. Antoine Pitrou <solipsis@pitrou.net> parents: 80245 diff changeset	2449 self.assertEqual(m.tobytes(), b'')
b08e092df155 Issue #19014: memoryview.cast() is now allowed on zero-length views. Antoine Pitrou <solipsis@pitrou.net> parents: 80245 diff changeset	2450 self.assertEqual(m.tolist(), [])
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2451
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2452 def test_memoryview_struct_module(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2453
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2454 class INT(object):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2455 def __init__(self, val):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2456 self.val = val
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2457 def __int__(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2458 return self.val
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2459
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2460 class IDX(object):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2461 def __init__(self, val):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2462 self.val = val
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2463 def __index__(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2464 return self.val
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2465
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2466 def f(): return 7
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2467
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2468 values = [INT(9), IDX(9),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2469 2.2+3j, Decimal("-21.1"), 12.2, Fraction(5, 2),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2470 [1,2,3], {4,5,6}, {7:8}, (), (9,),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2471 True, False, None, NotImplemented,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2472 b'a', b'abc', bytearray(b'a'), bytearray(b'abc'),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2473 'a', 'abc', r'a', r'abc',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2474 f, lambda x: x]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2475
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2476 for fmt, items, item in iter_format(10, 'memoryview'):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2477 ex = ndarray(items, shape=[10], format=fmt, flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2478 nd = ndarray(items, shape=[10], format=fmt, flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2479 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2480
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2481 struct.pack_into(fmt, nd, 0, item)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2482 m[0] = item
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2483 self.assertEqual(m[0], nd[0])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2484
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2485 itemsize = struct.calcsize(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2486 if 'P' in fmt:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2487 continue
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2488
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2489 for v in values:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2490 struct_err = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2491 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2492 struct.pack_into(fmt, nd, itemsize, v)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2493 except struct.error:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2494 struct_err = struct.error
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2495
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2496 mv_err = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2497 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2498 m[1] = v
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2499 except (TypeError, ValueError) as e:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2500 mv_err = e.__class__
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2501
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2502 if struct_err or mv_err:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2503 self.assertIsNot(struct_err, None)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2504 self.assertIsNot(mv_err, None)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2505 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2506 self.assertEqual(m[1], nd[1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2507
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2508 def test_memoryview_cast_zero_strides(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2509 # Casts are undefined if strides contains zeros. These arrays are
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2510 # (sometimes!) regarded as C-contiguous by Numpy, but not by
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2511 # PyBuffer_GetContiguous().
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2512 ex = ndarray([1,2,3], shape=[3], strides=[0])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2513 self.assertFalse(ex.c_contiguous)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2514 msrc = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2515 self.assertRaises(TypeError, msrc.cast, 'c')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2516
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2517 def test_memoryview_cast_invalid(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2518 # invalid format
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2519 for sfmt in NON_BYTE_FORMAT:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2520 sformat = '@' + sfmt if randrange(2) else sfmt
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2521 ssize = struct.calcsize(sformat)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2522 for dfmt in NON_BYTE_FORMAT:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2523 dformat = '@' + dfmt if randrange(2) else dfmt
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2524 dsize = struct.calcsize(dformat)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2525 ex = ndarray(list(range(32)), shape=[32//ssize], format=sformat)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2526 msrc = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2527 self.assertRaises(TypeError, msrc.cast, dfmt, [32//dsize])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2528
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2529 for sfmt, sitems, _ in iter_format(1):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2530 ex = ndarray(sitems, shape=[1], format=sfmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2531 msrc = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2532 for dfmt, _, _ in iter_format(1):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2533 if (not is_memoryview_format(sfmt) or
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2534 not is_memoryview_format(dfmt)):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2535 self.assertRaises(ValueError, msrc.cast, dfmt,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2536 [32//dsize])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2537 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2538 if not is_byte_format(sfmt) and not is_byte_format(dfmt):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2539 self.assertRaises(TypeError, msrc.cast, dfmt,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2540 [32//dsize])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2541
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2542 # invalid shape
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2543 size_h = struct.calcsize('h')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2544 size_d = struct.calcsize('d')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2545 ex = ndarray(list(range(22size_d)), shape=[2,2,size_d], format='h')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2546 msrc = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2547 self.assertRaises(TypeError, msrc.cast, shape=[2,2,size_h], format='d')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2548
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2549 ex = ndarray(list(range(120)), shape=[1,2,3,4,5])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2550 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2551
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2552 # incorrect number of args
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2553 self.assertRaises(TypeError, m.cast)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2554 self.assertRaises(TypeError, m.cast, 1, 2, 3)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2555
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2556 # incorrect dest format type
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2557 self.assertRaises(TypeError, m.cast, {})
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2558
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2559 # incorrect dest format
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2560 self.assertRaises(ValueError, m.cast, "X")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2561 self.assertRaises(ValueError, m.cast, "@X")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2562 self.assertRaises(ValueError, m.cast, "@XY")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2563
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2564 # dest format not implemented
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2565 self.assertRaises(ValueError, m.cast, "=B")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2566 self.assertRaises(ValueError, m.cast, "!L")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2567 self.assertRaises(ValueError, m.cast, "<P")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2568 self.assertRaises(ValueError, m.cast, ">l")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2569 self.assertRaises(ValueError, m.cast, "BI")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2570 self.assertRaises(ValueError, m.cast, "xBI")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2571
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2572 # src format not implemented
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2573 ex = ndarray([(1,2), (3,4)], shape=[2], format="II")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2574 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2575 self.assertRaises(NotImplementedError, m.__getitem__, 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2576 self.assertRaises(NotImplementedError, m.__setitem__, 0, 8)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2577 self.assertRaises(NotImplementedError, m.tolist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2578
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2579 # incorrect shape type
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2580 ex = ndarray(list(range(120)), shape=[1,2,3,4,5])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2581 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2582 self.assertRaises(TypeError, m.cast, "B", shape={})
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2583
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2584 # incorrect shape elements
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2585 ex = ndarray(list(range(120)), shape=[234*5])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2586 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2587 self.assertRaises(OverflowError, m.cast, "B", shape=[2**64])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2588 self.assertRaises(ValueError, m.cast, "B", shape=[-1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2589 self.assertRaises(ValueError, m.cast, "B", shape=[2,3,4,5,6,7,-1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2590 self.assertRaises(ValueError, m.cast, "B", shape=[2,3,4,5,6,7,0])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2591 self.assertRaises(TypeError, m.cast, "B", shape=[2,3,4,5,6,7,'x'])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2592
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2593 # N-D -> N-D cast
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2594 ex = ndarray(list([9 for _ in range(357*11)]), shape=[3,5,7,11])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2595 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2596 self.assertRaises(TypeError, m.cast, "I", shape=[2,3,4,5])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2597
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2598 # cast with ndim > 64
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2599 nd = ndarray(list(range(128)), shape=[128], format='I')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2600 m = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2601 self.assertRaises(ValueError, m.cast, 'I', [1]*128)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2602
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2603 # view->len not a multiple of itemsize
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2604 ex = ndarray(list([9 for _ in range(35711)]), shape=[35711])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2605 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2606 self.assertRaises(TypeError, m.cast, "I", shape=[2,3,4,5])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2607
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2608 # product(shape) * itemsize != buffer size
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2609 ex = ndarray(list([9 for _ in range(35711)]), shape=[35711])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2610 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2611 self.assertRaises(TypeError, m.cast, "B", shape=[2,3,4,5])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2612
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2613 # product(shape) * itemsize overflow
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2614 nd = ndarray(list(range(128)), shape=[128], format='I')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2615 m1 = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2616 nd = ndarray(list(range(128)), shape=[128], format='B')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2617 m2 = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2618 if sys.maxsize == 2**63-1:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2619 self.assertRaises(TypeError, m1.cast, 'B',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2620 [7, 7, 73, 127, 337, 92737, 649657])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2621 self.assertRaises(ValueError, m1.cast, 'B',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2622 [220, 220, 210, 210, 2**3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2623 self.assertRaises(ValueError, m2.cast, 'I',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2624 [220, 220, 210, 210, 2**1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2625 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2626 self.assertRaises(TypeError, m1.cast, 'B',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2627 [1, 2147483647])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2628 self.assertRaises(ValueError, m1.cast, 'B',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2629 [210, 210, 25, 25, 2**1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2630 self.assertRaises(ValueError, m2.cast, 'I',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2631 [210, 210, 25, 23, 2**1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2632
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2633 def test_memoryview_cast(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2634 bytespec = (
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2635 ('B', lambda ex: list(ex.tobytes())),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2636 ('b', lambda ex: [x-256 if x > 127 else x for x in list(ex.tobytes())]),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2637 ('c', lambda ex: [bytes(chr(x), 'latin-1') for x in list(ex.tobytes())]),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2638 )
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2639
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2640 def iter_roundtrip(ex, m, items, fmt):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2641 srcsize = struct.calcsize(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2642 for bytefmt, to_bytelist in bytespec:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2643
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2644 m2 = m.cast(bytefmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2645 lst = to_bytelist(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2646 self.verify(m2, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2647 itemsize=1, fmt=bytefmt, readonly=0,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2648 ndim=1, shape=[31*srcsize], strides=(1,),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2649 lst=lst, cast=True)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2650
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2651 m3 = m2.cast(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2652 self.assertEqual(m3, ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2653 lst = ex.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2654 self.verify(m3, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2655 itemsize=srcsize, fmt=fmt, readonly=0,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2656 ndim=1, shape=[31], strides=(srcsize,),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2657 lst=lst, cast=True)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2658
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2659 # cast from ndim = 0 to ndim = 1
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2660 srcsize = struct.calcsize('I')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2661 ex = ndarray(9, shape=[], format='I')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2662 destitems, destshape = cast_items(ex, 'B', 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2663 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2664 m2 = m.cast('B')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2665 self.verify(m2, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2666 itemsize=1, fmt='B', readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2667 ndim=1, shape=destshape, strides=(1,),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2668 lst=destitems, cast=True)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2669
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2670 # cast from ndim = 1 to ndim = 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2671 destsize = struct.calcsize('I')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2672 ex = ndarray([9]*destsize, shape=[destsize], format='B')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2673 destitems, destshape = cast_items(ex, 'I', destsize, shape=[])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2674 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2675 m2 = m.cast('I', shape=[])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2676 self.verify(m2, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2677 itemsize=destsize, fmt='I', readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2678 ndim=0, shape=(), strides=(),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2679 lst=destitems, cast=True)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2680
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2681 # array.array: roundtrip to/from bytes
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2682 for fmt, items, _ in iter_format(31, 'array'):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2683 ex = array.array(fmt, items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2684 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2685 iter_roundtrip(ex, m, items, fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2686
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2687 # ndarray: roundtrip to/from bytes
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2688 for fmt, items, _ in iter_format(31, 'memoryview'):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2689 ex = ndarray(items, shape=[31], format=fmt, flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2690 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2691 iter_roundtrip(ex, m, items, fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2692
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2693 def test_memoryview_cast_1D_ND(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2694 # Cast between C-contiguous buffers. At least one buffer must
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2695 # be 1D, at least one format must be 'c', 'b' or 'B'.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2696 for _tshape in gencastshapes():
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2697 for char in fmtdict['@']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2698 tfmt = ('', '@')[randrange(2)] + char
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2699 tsize = struct.calcsize(tfmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2700 n = prod(_tshape) * tsize
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2701 obj = 'memoryview' if is_byte_format(tfmt) else 'bytefmt'
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2702 for fmt, items, _ in iter_format(n, obj):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2703 size = struct.calcsize(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2704 shape = [n] if n > 0 else []
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2705 tshape = _tshape + [size]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2706
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2707 ex = ndarray(items, shape=shape, format=fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2708 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2709
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2710 titems, tshape = cast_items(ex, tfmt, tsize, shape=tshape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2711
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2712 if titems is None:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2713 self.assertRaises(TypeError, m.cast, tfmt, tshape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2714 continue
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2715 if titems == 'nan':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2716 continue # NaNs in lists are a recipe for trouble.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2717
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2718 # 1D -> ND
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2719 nd = ndarray(titems, shape=tshape, format=tfmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2720
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2721 m2 = m.cast(tfmt, shape=tshape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2722 ndim = len(tshape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2723 strides = nd.strides
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2724 lst = nd.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2725 self.verify(m2, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2726 itemsize=tsize, fmt=tfmt, readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2727 ndim=ndim, shape=tshape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2728 lst=lst, cast=True)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2729
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2730 # ND -> 1D
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2731 m3 = m2.cast(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2732 m4 = m2.cast(fmt, shape=shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2733 ndim = len(shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2734 strides = ex.strides
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2735 lst = ex.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2736
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2737 self.verify(m3, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2738 itemsize=size, fmt=fmt, readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2739 ndim=ndim, shape=shape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2740 lst=lst, cast=True)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2741
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2742 self.verify(m4, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2743 itemsize=size, fmt=fmt, readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2744 ndim=ndim, shape=shape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2745 lst=lst, cast=True)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2746
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2747 def test_memoryview_tolist(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2748
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2749 # Most tolist() tests are in self.verify() etc.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2750
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2751 a = array.array('h', list(range(-6, 6)))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2752 m = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2753 self.assertEqual(m, a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2754 self.assertEqual(m.tolist(), a.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2755
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2756 a = a[2::3]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2757 m = m[2::3]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2758 self.assertEqual(m, a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2759 self.assertEqual(m.tolist(), a.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2760
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2761 ex = ndarray(list(range(235711)), shape=[11,2,7,3,5], format='L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2762 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2763 self.assertEqual(m.tolist(), ex.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2764
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2765 ex = ndarray([(2, 5), (7, 11)], shape=[2], format='lh')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2766 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2767 self.assertRaises(NotImplementedError, m.tolist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2768
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2769 ex = ndarray([b'12345'], shape=[1], format="s")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2770 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2771 self.assertRaises(NotImplementedError, m.tolist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2772
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2773 ex = ndarray([b"a",b"b",b"c",b"d",b"e",b"f"], shape=[2,3], format='s')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2774 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2775 self.assertRaises(NotImplementedError, m.tolist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2776
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2777 def test_memoryview_repr(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2778 m = memoryview(bytearray(9))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2779 r = m.__repr__()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2780 self.assertTrue(r.startswith("<memory"))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2781
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2782 m.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2783 r = m.__repr__()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2784 self.assertTrue(r.startswith("<released"))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2785
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2786 def test_memoryview_sequence(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2787
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2788 for fmt in ('d', 'f'):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2789 inf = float(3e400)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2790 ex = array.array(fmt, [1.0, inf, 3.0])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2791 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2792 self.assertIn(1.0, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2793 self.assertIn(5e700, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2794 self.assertIn(3.0, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2795
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2796 ex = ndarray(9.0, [], format='f')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2797 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2798 self.assertRaises(TypeError, eval, "9.0 in m", locals())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2799
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2800 def test_memoryview_index(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2801
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2802 # ndim = 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2803 ex = ndarray(12.5, shape=[], format='d')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2804 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2805 self.assertEqual(m[()], 12.5)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2806 self.assertEqual(m[...], m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2807 self.assertEqual(m[...], ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2808 self.assertRaises(TypeError, m.__getitem__, 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2809
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2810 ex = ndarray((1,2,3), shape=[], format='iii')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2811 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2812 self.assertRaises(NotImplementedError, m.__getitem__, ())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2813
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2814 # range
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2815 ex = ndarray(list(range(7)), shape=[7], flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2816 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2817
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2818 self.assertRaises(IndexError, m.__getitem__, 2**64)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2819 self.assertRaises(TypeError, m.__getitem__, 2.0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2820 self.assertRaises(TypeError, m.__getitem__, 0.0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2821
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2822 # out of bounds
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2823 self.assertRaises(IndexError, m.__getitem__, -8)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2824 self.assertRaises(IndexError, m.__getitem__, 8)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2825
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2826 # Not implemented: multidimensional sub-views
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2827 ex = ndarray(list(range(12)), shape=[3,4], flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2828 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2829
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2830 self.assertRaises(NotImplementedError, m.__getitem__, 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2831 self.assertRaises(NotImplementedError, m.__setitem__, 0, 9)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2832 self.assertRaises(NotImplementedError, m.__getitem__, 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2833
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2834 def test_memoryview_assign(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2835
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2836 # ndim = 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2837 ex = ndarray(12.5, shape=[], format='f', flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2838 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2839 m[()] = 22.5
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2840 self.assertEqual(m[()], 22.5)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2841 m[...] = 23.5
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2842 self.assertEqual(m[()], 23.5)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2843 self.assertRaises(TypeError, m.__setitem__, 0, 24.7)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2844
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2845 # read-only
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2846 ex = ndarray(list(range(7)), shape=[7])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2847 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2848 self.assertRaises(TypeError, m.__setitem__, 2, 10)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2849
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2850 # range
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2851 ex = ndarray(list(range(7)), shape=[7], flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2852 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2853
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2854 self.assertRaises(IndexError, m.__setitem__, 2**64, 9)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2855 self.assertRaises(TypeError, m.__setitem__, 2.0, 10)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2856 self.assertRaises(TypeError, m.__setitem__, 0.0, 11)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2857
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2858 # out of bounds
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2859 self.assertRaises(IndexError, m.__setitem__, -8, 20)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2860 self.assertRaises(IndexError, m.__setitem__, 8, 25)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2861
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2862 # pack_single() success:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2863 for fmt in fmtdict['@']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2864 if fmt == 'c' or fmt == '?':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2865 continue
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2866 ex = ndarray([1,2,3], shape=[3], format=fmt, flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2867 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2868 i = randrange(-3, 3)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2869 m[i] = 8
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2870 self.assertEqual(m[i], 8)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2871 self.assertEqual(m[i], ex[i])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2872
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2873 ex = ndarray([b'1', b'2', b'3'], shape=[3], format='c',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2874 flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2875 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2876 m[2] = b'9'
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2877 self.assertEqual(m[2], b'9')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2878
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2879 ex = ndarray([True, False, True], shape=[3], format='?',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2880 flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2881 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2882 m[1] = True
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2883 self.assertEqual(m[1], True)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2884
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2885 # pack_single() exceptions:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2886 nd = ndarray([b'x'], shape=[1], format='c', flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2887 m = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2888 self.assertRaises(TypeError, m.__setitem__, 0, 100)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2889
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2890 ex = ndarray(list(range(120)), shape=[1,2,3,4,5], flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2891 m1 = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2892
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2893 for fmt, _range in fmtdict['@'].items():
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2894 if (fmt == '?'): # PyObject_IsTrue() accepts anything
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2895 continue
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2896 if fmt == 'c': # special case tested above
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2897 continue
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2898 m2 = m1.cast(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2899 lo, hi = _range
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2900 if fmt == 'd' or fmt == 'f':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2901 lo, hi = -21024, 21024
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2902 if fmt != 'P': # PyLong_AsVoidPtr() accepts negative numbers
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2903 self.assertRaises(ValueError, m2.__setitem__, 0, lo-1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2904 self.assertRaises(TypeError, m2.__setitem__, 0, "xyz")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2905 self.assertRaises(ValueError, m2.__setitem__, 0, hi)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2906
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2907 # invalid item
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2908 m2 = m1.cast('c')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2909 self.assertRaises(ValueError, m2.__setitem__, 0, b'\xff\xff')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2910
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2911 # format not implemented
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2912 ex = ndarray(list(range(1)), shape=[1], format="xL", flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2913 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2914 self.assertRaises(NotImplementedError, m.__setitem__, 0, 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2915
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2916 ex = ndarray([b'12345'], shape=[1], format="s", flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2917 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2918 self.assertRaises(NotImplementedError, m.__setitem__, 0, 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2919
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2920 # Not implemented: multidimensional sub-views
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2921 ex = ndarray(list(range(12)), shape=[3,4], flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2922 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2923
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2924 self.assertRaises(NotImplementedError, m.__setitem__, 0, [2, 3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2925
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2926 def test_memoryview_slice(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2927
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2928 ex = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2929 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2930
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2931 # zero step
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2932 self.assertRaises(ValueError, m.__getitem__, slice(0,2,0))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2933 self.assertRaises(ValueError, m.__setitem__, slice(0,2,0),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2934 bytearray([1,2]))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2935
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2936 # invalid slice key
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2937 self.assertRaises(TypeError, m.__getitem__, ())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2938
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2939 # multidimensional slices
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2940 ex = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2941 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2942
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2943 self.assertRaises(NotImplementedError, m.__getitem__,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2944 (slice(0,2,1), slice(0,2,1)))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2945 self.assertRaises(NotImplementedError, m.__setitem__,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2946 (slice(0,2,1), slice(0,2,1)), bytearray([1,2]))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2947
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2948 # invalid slice tuple
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2949 self.assertRaises(TypeError, m.__getitem__, (slice(0,2,1), {}))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2950 self.assertRaises(TypeError, m.__setitem__, (slice(0,2,1), {}),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2951 bytearray([1,2]))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2952
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2953 # rvalue is not an exporter
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2954 self.assertRaises(TypeError, m.__setitem__, slice(0,1,1), [1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2955
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2956 # non-contiguous slice assignment
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2957 for flags in (0, ND_PIL):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2958 ex1 = ndarray(list(range(12)), shape=[12], strides=[-1], offset=11,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2959 flags=ND_WRITABLE\|flags)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2960 ex2 = ndarray(list(range(24)), shape=[12], strides=[2], flags=flags)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2961 m1 = memoryview(ex1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2962 m2 = memoryview(ex2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2963
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2964 ex1[2:5] = ex1[2:5]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2965 m1[2:5] = m2[2:5]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2966
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2967 self.assertEqual(m1, ex1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2968 self.assertEqual(m2, ex2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2969
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2970 ex1[1:3][::-1] = ex2[0:2][::1]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2971 m1[1:3][::-1] = m2[0:2][::1]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2972
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2973 self.assertEqual(m1, ex1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2974 self.assertEqual(m2, ex2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2975
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2976 ex1[4:1:-2][::-1] = ex1[1:4:2][::1]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2977 m1[4:1:-2][::-1] = m1[1:4:2][::1]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2978
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2979 self.assertEqual(m1, ex1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2980 self.assertEqual(m2, ex2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2981
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2982 def test_memoryview_array(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2983
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2984 def cmptest(testcase, a, b, m, singleitem):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2985 for i, _ in enumerate(a):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2986 ai = a[i]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2987 mi = m[i]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2988 testcase.assertEqual(ai, mi)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2989 a[i] = singleitem
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2990 if singleitem != ai:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2991 testcase.assertNotEqual(a, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2992 testcase.assertNotEqual(a, b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2993 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2994 testcase.assertEqual(a, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2995 testcase.assertEqual(a, b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2996 m[i] = singleitem
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2997 testcase.assertEqual(a, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2998 testcase.assertEqual(b, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2999 a[i] = ai
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3000 m[i] = mi
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3001
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3002 for n in range(1, 5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3003 for fmt, items, singleitem in iter_format(n, 'array'):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3004 for lslice in genslices(n):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3005 for rslice in genslices(n):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3006
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3007 a = array.array(fmt, items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3008 b = array.array(fmt, items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3009 m = memoryview(b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3010
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3011 self.assertEqual(m, a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3012 self.assertEqual(m.tolist(), a.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3013 self.assertEqual(m.tobytes(), a.tobytes())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3014 self.assertEqual(len(m), len(a))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3015
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3016 cmptest(self, a, b, m, singleitem)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3017
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3018 array_err = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3019 have_resize = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3020 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3021 al = a[lslice]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3022 ar = a[rslice]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3023 a[lslice] = a[rslice]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3024 have_resize = len(al) != len(ar)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3025 except Exception as e:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3026 array_err = e.__class__
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3027
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3028 m_err = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3029 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3030 m[lslice] = m[rslice]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3031 except Exception as e:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3032 m_err = e.__class__
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3033
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3034 if have_resize: # memoryview cannot change shape
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3035 self.assertIs(m_err, ValueError)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3036 elif m_err or array_err:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3037 self.assertIs(m_err, array_err)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3038 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3039 self.assertEqual(m, a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3040 self.assertEqual(m.tolist(), a.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3041 self.assertEqual(m.tobytes(), a.tobytes())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3042 cmptest(self, a, b, m, singleitem)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3043
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3044 def test_memoryview_compare_special_cases(self):
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3045
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3046 a = array.array('L', [1, 2, 3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3047 b = array.array('L', [1, 2, 7])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3048
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3049 # Ordering comparisons raise:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3050 v = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3051 w = memoryview(b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3052 for attr in ('__lt__', '__le__', '__gt__', '__ge__'):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3053 self.assertIs(getattr(v, attr)(w), NotImplemented)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3054 self.assertIs(getattr(a, attr)(v), NotImplemented)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3055
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3056 # Released views compare equal to themselves:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3057 v = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3058 v.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3059 self.assertEqual(v, v)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3060 self.assertNotEqual(v, a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3061 self.assertNotEqual(a, v)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3062
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3063 v = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3064 w = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3065 w.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3066 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3067 self.assertNotEqual(w, v)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3068
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3069 # Operand does not implement the buffer protocol:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3070 v = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3071 self.assertNotEqual(v, [1, 2, 3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3072
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3073 # NaNs
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3074 nd = ndarray([(0, 0)], shape=[1], format='l x d x', flags=ND_WRITABLE)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3075 nd[0] = (-1, float('nan'))
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3076 self.assertNotEqual(memoryview(nd), nd)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3077
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3078 # Depends on issue #15625: the struct module does not understand 'u'.
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3079 a = array.array('u', 'xyz')
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3080 v = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3081 self.assertNotEqual(a, v)
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3082 self.assertNotEqual(v, a)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3083
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3084 # Some ctypes format strings are unknown to the struct module.
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3085 if ctypes:
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3086 # format: "T{>l:x:>l:y:}"
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3087 class BEPoint(ctypes.BigEndianStructure):
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3088 _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)]
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3089 point = BEPoint(100, 200)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3090 a = memoryview(point)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3091 b = memoryview(point)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3092 self.assertNotEqual(a, b)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3093 self.assertNotEqual(a, point)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3094 self.assertNotEqual(point, a)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3095 self.assertRaises(NotImplementedError, a.tolist)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3096
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3097 def test_memoryview_compare_ndim_zero(self):
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3098
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3099 nd1 = ndarray(1729, shape=[], format='@L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3100 nd2 = ndarray(1729, shape=[], format='L', flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3101 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3102 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3103 self.assertEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3104 self.assertEqual(w, v)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3105 self.assertEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3106 self.assertEqual(nd2, v)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3107 self.assertEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3108 self.assertEqual(nd1, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3109
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3110 self.assertFalse(v.__ne__(w))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3111 self.assertFalse(w.__ne__(v))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3112
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3113 w[()] = 1728
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3114 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3115 self.assertNotEqual(w, v)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3116 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3117 self.assertNotEqual(nd2, v)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3118 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3119 self.assertNotEqual(nd1, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3120
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3121 self.assertFalse(v.__eq__(w))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3122 self.assertFalse(w.__eq__(v))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3123
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3124 nd = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE\|ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3125 ex = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE\|ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3126 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3127
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3128 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3129 m[9] = 100
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3130 self.assertNotEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3131
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3132 # struct module: equal
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3133 nd1 = ndarray((1729, 1.2, b'12345'), shape=[], format='Lf5s')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3134 nd2 = ndarray((1729, 1.2, b'12345'), shape=[], format='hf5s',
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3135 flags=ND_WRITABLE)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3136 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3137 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3138 self.assertEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3139 self.assertEqual(w, v)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3140 self.assertEqual(v, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3141 self.assertEqual(nd2, v)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3142 self.assertEqual(w, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3143 self.assertEqual(nd1, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3144
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3145 # struct module: not equal
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3146 nd1 = ndarray((1729, 1.2, b'12345'), shape=[], format='Lf5s')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3147 nd2 = ndarray((-1729, 1.2, b'12345'), shape=[], format='hf5s',
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3148 flags=ND_WRITABLE)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3149 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3150 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3151 self.assertNotEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3152 self.assertNotEqual(w, v)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3153 self.assertNotEqual(v, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3154 self.assertNotEqual(nd2, v)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3155 self.assertNotEqual(w, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3156 self.assertNotEqual(nd1, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3157 self.assertEqual(v, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3158 self.assertEqual(w, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3159
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3160 def test_memoryview_compare_ndim_one(self):
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3161
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3162 # contiguous
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3163 nd1 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='@h')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3164 nd2 = ndarray([-529, 576, -625, 676, 729], shape=[5], format='@h')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3165 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3166 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3167
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3168 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3169 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3170 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3171 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3172 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3173
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3174 # contiguous, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3175 nd1 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='<i')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3176 nd2 = ndarray([-529, 576, -625, 676, 729], shape=[5], format='>h')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3177 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3178 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3179
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3180 self.assertEqual(v, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3181 self.assertEqual(w, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3182 self.assertNotEqual(v, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3183 self.assertNotEqual(w, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3184 self.assertNotEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3185
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3186 # non-contiguous
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3187 nd1 = ndarray([-529, -625, -729], shape=[3], format='@h')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3188 nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='@h')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3189 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3190 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3191
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3192 self.assertEqual(v, nd2[::2])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3193 self.assertEqual(w[::2], nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3194 self.assertEqual(v, w[::2])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3195 self.assertEqual(v[::-1], w[::-2])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3196
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3197 # non-contiguous, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3198 nd1 = ndarray([-529, -625, -729], shape=[3], format='!h')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3199 nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='<l')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3200 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3201 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3202
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3203 self.assertEqual(v, nd2[::2])
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3204 self.assertEqual(w[::2], nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3205 self.assertEqual(v, w[::2])
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3206 self.assertEqual(v[::-1], w[::-2])
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3207
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3208 # non-contiguous, suboffsets
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3209 nd1 = ndarray([-529, -625, -729], shape=[3], format='@h')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3210 nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='@h',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3211 flags=ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3212 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3213 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3214
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3215 self.assertEqual(v, nd2[::2])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3216 self.assertEqual(w[::2], nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3217 self.assertEqual(v, w[::2])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3218 self.assertEqual(v[::-1], w[::-2])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3219
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3220 # non-contiguous, suboffsets, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3221 nd1 = ndarray([-529, -625, -729], shape=[3], format='h 0c')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3222 nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='> h',
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3223 flags=ND_PIL)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3224 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3225 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3226
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3227 self.assertEqual(v, nd2[::2])
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3228 self.assertEqual(w[::2], nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3229 self.assertEqual(v, w[::2])
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3230 self.assertEqual(v[::-1], w[::-2])
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3231
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3232 def test_memoryview_compare_zero_shape(self):
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3233
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3234 # zeros in shape
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3235 nd1 = ndarray([900, 961], shape=[0], format='@h')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3236 nd2 = ndarray([-900, -961], shape=[0], format='@h')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3237 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3238 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3239
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3240 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3241 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3242 self.assertEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3243 self.assertEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3244 self.assertEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3245
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3246 # zeros in shape, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3247 nd1 = ndarray([900, 961], shape=[0], format='= h0c')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3248 nd2 = ndarray([-900, -961], shape=[0], format='@ i')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3249 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3250 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3251
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3252 self.assertEqual(v, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3253 self.assertEqual(w, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3254 self.assertEqual(v, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3255 self.assertEqual(w, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3256 self.assertEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3257
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3258 def test_memoryview_compare_zero_strides(self):
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3259
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3260 # zero strides
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3261 nd1 = ndarray([900, 900, 900, 900], shape=[4], format='@L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3262 nd2 = ndarray([900], shape=[4], strides=[0], format='L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3263 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3264 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3265
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3266 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3267 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3268 self.assertEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3269 self.assertEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3270 self.assertEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3271
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3272 # zero strides, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3273 nd1 = ndarray([(900, 900)]*4, shape=[4], format='@ Li')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3274 nd2 = ndarray([(900, 900)], shape=[4], strides=[0], format='!L h')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3275 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3276 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3277
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3278 self.assertEqual(v, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3279 self.assertEqual(w, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3280 self.assertEqual(v, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3281 self.assertEqual(w, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3282 self.assertEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3283
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3284 def test_memoryview_compare_random_formats(self):
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3285
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3286 # random single character native formats
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3287 n = 10
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3288 for char in fmtdict['@m']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3289 fmt, items, singleitem = randitems(n, 'memoryview', '@', char)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3290 for flags in (0, ND_PIL):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3291 nd = ndarray(items, shape=[n], format=fmt, flags=flags)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3292 m = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3293 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3294
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3295 nd = nd[::-3]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3296 m = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3297 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3298
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3299 # random formats
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3300 n = 10
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3301 for _ in range(100):
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3302 fmt, items, singleitem = randitems(n)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3303 for flags in (0, ND_PIL):
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3304 nd = ndarray(items, shape=[n], format=fmt, flags=flags)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3305 m = memoryview(nd)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3306 self.assertEqual(m, nd)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3307
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3308 nd = nd[::-3]
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3309 m = memoryview(nd)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3310 self.assertEqual(m, nd)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3311
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3312 def test_memoryview_compare_multidim_c(self):
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3313
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3314 # C-contiguous, different values
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3315 nd1 = ndarray(list(range(-15, 15)), shape=[3, 2, 5], format='@h')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3316 nd2 = ndarray(list(range(0, 30)), shape=[3, 2, 5], format='@h')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3317 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3318 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3319
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3320 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3321 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3322 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3323 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3324 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3325
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3326 # C-contiguous, different values, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3327 nd1 = ndarray([(0, 1, 2)]*30, shape=[3, 2, 5], format='=f q xxL')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3328 nd2 = ndarray([(-1.2, 1, 2)]*30, shape=[3, 2, 5], format='< f 2Q')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3329 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3330 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3331
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3332 self.assertEqual(v, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3333 self.assertEqual(w, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3334 self.assertNotEqual(v, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3335 self.assertNotEqual(w, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3336 self.assertNotEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3337
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3338 # C-contiguous, different shape
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3339 nd1 = ndarray(list(range(30)), shape=[2, 3, 5], format='L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3340 nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3341 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3342 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3343
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3344 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3345 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3346 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3347 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3348 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3349
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3350 # C-contiguous, different shape, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3351 nd1 = ndarray([(0, 1, 2)]*21, shape=[3, 7], format='! b B xL')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3352 nd2 = ndarray([(0, 1, 2)]*21, shape=[7, 3], format='= Qx l xxL')
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3353 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3354 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3355
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3356 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3357 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3358 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3359 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3360 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3361
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3362 # C-contiguous, different format, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3363 nd1 = ndarray(list(range(30)), shape=[2, 3, 5], format='L')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3364 nd2 = ndarray(list(range(30)), shape=[2, 3, 5], format='l')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3365 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3366 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3367
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3368 self.assertEqual(v, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3369 self.assertEqual(w, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3370 self.assertEqual(v, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3371 self.assertEqual(w, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3372 self.assertEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3373
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3374 def test_memoryview_compare_multidim_fortran(self):
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3375
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3376 # Fortran-contiguous, different values
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3377 nd1 = ndarray(list(range(-15, 15)), shape=[5, 2, 3], format='@h',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3378 flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3379 nd2 = ndarray(list(range(0, 30)), shape=[5, 2, 3], format='@h',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3380 flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3381 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3382 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3383
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3384 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3385 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3386 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3387 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3388 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3389
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3390 # Fortran-contiguous, different values, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3391 nd1 = ndarray([(2*64-1, -1)]6, shape=[2, 3], format='=Qq',
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3392 flags=ND_FORTRAN)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3393 nd2 = ndarray([(-1, 2*64-1)]6, shape=[2, 3], format='=qQ',
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3394 flags=ND_FORTRAN)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3395 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3396 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3397
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3398 self.assertEqual(v, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3399 self.assertEqual(w, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3400 self.assertNotEqual(v, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3401 self.assertNotEqual(w, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3402 self.assertNotEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3403
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3404 # Fortran-contiguous, different shape
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3405 nd1 = ndarray(list(range(-15, 15)), shape=[2, 3, 5], format='l',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3406 flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3407 nd2 = ndarray(list(range(-15, 15)), shape=[3, 2, 5], format='l',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3408 flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3409 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3410 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3411
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3412 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3413 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3414 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3415 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3416 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3417
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3418 # Fortran-contiguous, different shape, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3419 nd1 = ndarray(list(range(-15, 15)), shape=[2, 3, 5], format='0ll',
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3420 flags=ND_FORTRAN)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3421 nd2 = ndarray(list(range(-15, 15)), shape=[3, 2, 5], format='l',
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3422 flags=ND_FORTRAN)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3423 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3424 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3425
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3426 self.assertEqual(v, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3427 self.assertEqual(w, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3428 self.assertNotEqual(v, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3429 self.assertNotEqual(w, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3430 self.assertNotEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3431
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3432 # Fortran-contiguous, different format, struct module
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3433 nd1 = ndarray(list(range(30)), shape=[5, 2, 3], format='@h',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3434 flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3435 nd2 = ndarray(list(range(30)), shape=[5, 2, 3], format='@b',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3436 flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3437 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3438 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3439
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3440 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3441 self.assertEqual(w, nd2)
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3442 self.assertEqual(v, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3443 self.assertEqual(w, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3444 self.assertEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3445
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3446 def test_memoryview_compare_multidim_mixed(self):
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3447
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3448 # mixed C/Fortran contiguous
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3449 lst1 = list(range(-15, 15))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3450 lst2 = transpose(lst1, [3, 2, 5])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3451 nd1 = ndarray(lst1, shape=[3, 2, 5], format='@l')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3452 nd2 = ndarray(lst2, shape=[3, 2, 5], format='l', flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3453 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3454 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3455
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3456 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3457 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3458 self.assertEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3459
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3460 # mixed C/Fortran contiguous, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3461 lst1 = [(-3.3, -22, b'x')]*30
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3462 lst1[5] = (-2.2, -22, b'x')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3463 lst2 = transpose(lst1, [3, 2, 5])
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3464 nd1 = ndarray(lst1, shape=[3, 2, 5], format='d b c')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3465 nd2 = ndarray(lst2, shape=[3, 2, 5], format='d h c', flags=ND_FORTRAN)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3466 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3467 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3468
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3469 self.assertEqual(v, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3470 self.assertEqual(w, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3471 self.assertEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3472
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3473 # different values, non-contiguous
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3474 ex1 = ndarray(list(range(40)), shape=[5, 8], format='@I')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3475 nd1 = ex1[3:1:-1, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3476 ex2 = ndarray(list(range(40)), shape=[5, 8], format='I')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3477 nd2 = ex2[1:3:1, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3478 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3479 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3480
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3481 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3482 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3483 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3484 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3485 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3486
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3487 # same values, non-contiguous, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3488 ex1 = ndarray([(231-1, -231)]*22, shape=[11, 2], format='=ii')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3489 nd1 = ex1[3:1:-1, ::-2]
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3490 ex2 = ndarray([(231-1, -231)]*22, shape=[11, 2], format='>ii')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3491 nd2 = ex2[1:3:1, ::-2]
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3492 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3493 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3494
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3495 self.assertEqual(v, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3496 self.assertEqual(w, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3497 self.assertEqual(v, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3498 self.assertEqual(w, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3499 self.assertEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3500
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3501 # different shape
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3502 ex1 = ndarray(list(range(30)), shape=[2, 3, 5], format='b')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3503 nd1 = ex1[1:3:, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3504 nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='b')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3505 nd2 = ex2[1:3:, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3506 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3507 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3508
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3509 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3510 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3511 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3512 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3513 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3514
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3515 # different shape, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3516 ex1 = ndarray(list(range(30)), shape=[2, 3, 5], format='B')
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3517 nd1 = ex1[1:3:, ::-2]
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3518 nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='b')
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3519 nd2 = ex2[1:3:, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3520 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3521 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3522
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3523 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3524 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3525 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3526 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3527 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3528
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3529 # different format, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3530 ex1 = ndarray([(2, b'123')]*30, shape=[5, 3, 2], format='b3s')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3531 nd1 = ex1[1:3:, ::-2]
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3532 nd2 = ndarray([(2, b'123')]*30, shape=[5, 3, 2], format='i3s')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3533 nd2 = ex2[1:3:, ::-2]
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3534 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3535 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3536
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3537 self.assertEqual(v, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3538 self.assertEqual(w, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3539 self.assertNotEqual(v, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3540 self.assertNotEqual(w, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3541 self.assertNotEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3542
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3543 def test_memoryview_compare_multidim_zero_shape(self):
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3544
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3545 # zeros in shape
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3546 nd1 = ndarray(list(range(30)), shape=[0, 3, 2], format='i')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3547 nd2 = ndarray(list(range(30)), shape=[5, 0, 2], format='@i')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3548 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3549 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3550
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3551 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3552 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3553 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3554 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3555 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3556
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3557 # zeros in shape, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3558 nd1 = ndarray(list(range(30)), shape=[0, 3, 2], format='i')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3559 nd2 = ndarray(list(range(30)), shape=[5, 0, 2], format='@i')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3560 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3561 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3562
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3563 self.assertEqual(v, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3564 self.assertEqual(w, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3565 self.assertNotEqual(v, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3566 self.assertNotEqual(w, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3567 self.assertNotEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3568
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3569 def test_memoryview_compare_multidim_zero_strides(self):
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3570
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3571 # zero strides
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3572 nd1 = ndarray([900]*80, shape=[4, 5, 4], format='@L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3573 nd2 = ndarray([900], shape=[4, 5, 4], strides=[0, 0, 0], format='L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3574 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3575 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3576
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3577 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3578 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3579 self.assertEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3580 self.assertEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3581 self.assertEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3582 self.assertEqual(v.tolist(), w.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3583
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3584 # zero strides, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3585 nd1 = ndarray([(1, 2)]*10, shape=[2, 5], format='=lQ')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3586 nd2 = ndarray([(1, 2)], shape=[2, 5], strides=[0, 0], format='<lQ')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3587 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3588 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3589
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3590 self.assertEqual(v, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3591 self.assertEqual(w, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3592 self.assertEqual(v, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3593 self.assertEqual(w, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3594 self.assertEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3595
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3596 def test_memoryview_compare_multidim_suboffsets(self):
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3597
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3598 # suboffsets
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3599 ex1 = ndarray(list(range(40)), shape=[5, 8], format='@I')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3600 nd1 = ex1[3:1:-1, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3601 ex2 = ndarray(list(range(40)), shape=[5, 8], format='I', flags=ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3602 nd2 = ex2[1:3:1, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3603 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3604 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3605
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3606 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3607 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3608 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3609 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3610 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3611
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3612 # suboffsets, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3613 ex1 = ndarray([(2*64-1, -1)]40, shape=[5, 8], format='=Qq',
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3614 flags=ND_WRITABLE)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3615 ex1[2][7] = (1, -2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3616 nd1 = ex1[3:1:-1, ::-2]
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3617
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3618 ex2 = ndarray([(2*64-1, -1)]40, shape=[5, 8], format='>Qq',
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3619 flags=ND_PIL\|ND_WRITABLE)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3620 ex2[2][7] = (1, -2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3621 nd2 = ex2[1:3:1, ::-2]
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3622
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3623 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3624 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3625
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3626 self.assertEqual(v, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3627 self.assertEqual(w, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3628 self.assertEqual(v, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3629 self.assertEqual(w, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3630 self.assertEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3631
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3632 # suboffsets, different shape
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3633 ex1 = ndarray(list(range(30)), shape=[2, 3, 5], format='b',
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3634 flags=ND_PIL)
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3635 nd1 = ex1[1:3:, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3636 nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='b')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3637 nd2 = ex2[1:3:, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3638 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3639 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3640
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3641 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3642 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3643 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3644 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3645 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3646
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3647 # suboffsets, different shape, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3648 ex1 = ndarray([(2*8-1, -1)]40, shape=[2, 3, 5], format='Bb',
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3649 flags=ND_PIL\|ND_WRITABLE)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3650 nd1 = ex1[1:2:, ::-2]
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3651
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3652 ex2 = ndarray([(2*8-1, -1)]40, shape=[3, 2, 5], format='Bb')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3653 nd2 = ex2[1:2:, ::-2]
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3654
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3655 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3656 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3657
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3658 self.assertEqual(v, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3659 self.assertEqual(w, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3660 self.assertNotEqual(v, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3661 self.assertNotEqual(w, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3662 self.assertNotEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3663
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3664 # suboffsets, different format
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3665 ex1 = ndarray(list(range(30)), shape=[5, 3, 2], format='i', flags=ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3666 nd1 = ex1[1:3:, ::-2]
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3667 ex2 = ndarray(list(range(30)), shape=[5, 3, 2], format='@I', flags=ND_PIL)
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3668 nd2 = ex2[1:3:, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3669 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3670 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3671
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3672 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3673 self.assertEqual(w, nd2)
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3674 self.assertEqual(v, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3675 self.assertEqual(w, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3676 self.assertEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3677
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3678 # suboffsets, different format, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3679 ex1 = ndarray([(b'hello', b'', 1)]*27, shape=[3, 3, 3], format='5s0sP',
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3680 flags=ND_PIL\|ND_WRITABLE)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3681 ex1[1][2][2] = (b'sushi', b'', 1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3682 nd1 = ex1[1:3:, ::-2]
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3683
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3684 ex2 = ndarray([(b'hello', b'', 1)]*27, shape=[3, 3, 3], format='5s0sP',
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3685 flags=ND_PIL\|ND_WRITABLE)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3686 ex1[1][2][2] = (b'sushi', b'', 1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3687 nd2 = ex2[1:3:, ::-2]
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3688
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3689 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3690 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3691
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3692 self.assertEqual(v, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3693 self.assertEqual(w, nd2)
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3694 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3695 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3696 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3697
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3698 # initialize mixed C/Fortran + suboffsets
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3699 lst1 = list(range(-15, 15))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3700 lst2 = transpose(lst1, [3, 2, 5])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3701 nd1 = ndarray(lst1, shape=[3, 2, 5], format='@l', flags=ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3702 nd2 = ndarray(lst2, shape=[3, 2, 5], format='l', flags=ND_FORTRAN\|ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3703 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3704 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3705
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3706 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3707 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3708 self.assertEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3709
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3710 # initialize mixed C/Fortran + suboffsets, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3711 lst1 = [(b'sashimi', b'sliced', 20.05)]*30
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3712 lst1[11] = (b'ramen', b'spicy', 9.45)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3713 lst2 = transpose(lst1, [3, 2, 5])
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3714
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3715 nd1 = ndarray(lst1, shape=[3, 2, 5], format='< 10p 9p d', flags=ND_PIL)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3716 nd2 = ndarray(lst2, shape=[3, 2, 5], format='> 10p 9p d',
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3717 flags=ND_FORTRAN\|ND_PIL)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3718 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3719 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3720
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3721 self.assertEqual(v, nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3722 self.assertEqual(w, nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3723 self.assertEqual(v, w)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3724
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3725 def test_memoryview_compare_not_equal(self):
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3726
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3727 # items not equal
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3728 for byteorder in ['=', '<', '>', '!']:
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3729 x = ndarray([2*63]120, shape=[3,5,2,2,2], format=byteorder+'Q')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3730 y = ndarray([2*63]120, shape=[3,5,2,2,2], format=byteorder+'Q',
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3731 flags=ND_WRITABLE\|ND_FORTRAN)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3732 y[2][3][1][1][1] = 1
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3733 a = memoryview(x)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3734 b = memoryview(y)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3735 self.assertEqual(a, x)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3736 self.assertEqual(b, y)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3737 self.assertNotEqual(a, b)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3738 self.assertNotEqual(a, y)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3739 self.assertNotEqual(b, x)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3740
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3741 x = ndarray([(263, 231, 2*15)]120, shape=[3,5,2,2,2],
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3742 format=byteorder+'QLH')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3743 y = ndarray([(263, 231, 2*15)]120, shape=[3,5,2,2,2],
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3744 format=byteorder+'QLH', flags=ND_WRITABLE\|ND_FORTRAN)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3745 y[2][3][1][1][1] = (1, 1, 1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3746 a = memoryview(x)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3747 b = memoryview(y)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3748 self.assertEqual(a, x)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3749 self.assertEqual(b, y)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3750 self.assertNotEqual(a, b)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3751 self.assertNotEqual(a, y)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3752 self.assertNotEqual(b, x)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3753
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3754 def test_memoryview_check_released(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3755
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3756 a = array.array('d', [1.1, 2.2, 3.3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3757
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3758 m = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3759 m.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3760
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3761 # PyMemoryView_FromObject()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3762 self.assertRaises(ValueError, memoryview, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3763 # memoryview.cast()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3764 self.assertRaises(ValueError, m.cast, 'c')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3765 # getbuffer()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3766 self.assertRaises(ValueError, ndarray, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3767 # memoryview.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3768 self.assertRaises(ValueError, m.tolist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3769 # memoryview.tobytes()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3770 self.assertRaises(ValueError, m.tobytes)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3771 # sequence
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3772 self.assertRaises(ValueError, eval, "1.0 in m", locals())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3773 # subscript
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3774 self.assertRaises(ValueError, m.__getitem__, 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3775 # assignment
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3776 self.assertRaises(ValueError, m.__setitem__, 0, 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3777
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3778 for attr in ('obj', 'nbytes', 'readonly', 'itemsize', 'format', 'ndim',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3779 'shape', 'strides', 'suboffsets', 'c_contiguous',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3780 'f_contiguous', 'contiguous'):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3781 self.assertRaises(ValueError, m.__getattribute__, attr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3782
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3783 # richcompare
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3784 b = array.array('d', [1.1, 2.2, 3.3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3785 m1 = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3786 m2 = memoryview(b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3787
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3788 self.assertEqual(m1, m2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3789 m1.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3790 self.assertNotEqual(m1, m2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3791 self.assertNotEqual(m1, a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3792 self.assertEqual(m1, m1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3793
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3794 def test_memoryview_tobytes(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3795 # Many implicit tests are already in self.verify().
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3796
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3797 t = (-529, 576, -625, 676, -729)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3798
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3799 nd = ndarray(t, shape=[5], format='@h')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3800 m = memoryview(nd)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3801 self.assertEqual(m, nd)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3802 self.assertEqual(m.tobytes(), nd.tobytes())
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3803
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3804 nd = ndarray([t], shape=[1], format='>hQiLl')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3805 m = memoryview(nd)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3806 self.assertEqual(m, nd)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3807 self.assertEqual(m.tobytes(), nd.tobytes())
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3808
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3809 nd = ndarray([t for _ in range(12)], shape=[2,2,3], format='=hQiLl')
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3810 m = memoryview(nd)
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3811 self.assertEqual(m, nd)
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3812 self.assertEqual(m.tobytes(), nd.tobytes())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3813
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3814 nd = ndarray([t for _ in range(120)], shape=[5,2,2,3,2],
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3815 format='<hQiLl')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3816 m = memoryview(nd)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3817 self.assertEqual(m, nd)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3818 self.assertEqual(m.tobytes(), nd.tobytes())
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3819
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3820 # Unknown formats are handled: tobytes() purely depends on itemsize.
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3821 if ctypes:
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3822 # format: "T{>l:x:>l:y:}"
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3823 class BEPoint(ctypes.BigEndianStructure):
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3824 _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)]
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3825 point = BEPoint(100, 200)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3826 a = memoryview(point)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3827 self.assertEqual(a.tobytes(), bytes(point))
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3828
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3829 def test_memoryview_get_contiguous(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3830 # Many implicit tests are already in self.verify().
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3831
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3832 # no buffer interface
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3833 self.assertRaises(TypeError, get_contiguous, {}, PyBUF_READ, 'F')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3834
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3835 # writable request to read-only object
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3836 self.assertRaises(BufferError, get_contiguous, b'x', PyBUF_WRITE, 'C')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3837
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3838 # writable request to non-contiguous object
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3839 nd = ndarray([1, 2, 3], shape=[2], strides=[2])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3840 self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'A')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3841
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3842 # scalar, read-only request from read-only exporter
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3843 nd = ndarray(9, shape=(), format="L")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3844 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3845 m = get_contiguous(nd, PyBUF_READ, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3846 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3847 self.assertEqual(m[()], 9)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3848
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3849 # scalar, read-only request from writable exporter
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3850 nd = ndarray(9, shape=(), format="L", flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3851 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3852 m = get_contiguous(nd, PyBUF_READ, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3853 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3854 self.assertEqual(m[()], 9)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3855
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3856 # scalar, writable request
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3857 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3858 nd[()] = 9
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3859 m = get_contiguous(nd, PyBUF_WRITE, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3860 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3861 self.assertEqual(m[()], 9)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3862
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3863 m[()] = 10
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3864 self.assertEqual(m[()], 10)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3865 self.assertEqual(nd[()], 10)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3866
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3867 # zeros in shape
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3868 nd = ndarray([1], shape=[0], format="L", flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3869 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3870 m = get_contiguous(nd, PyBUF_READ, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3871 self.assertRaises(IndexError, m.__getitem__, 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3872 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3873 self.assertEqual(m.tolist(), [])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3874
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3875 nd = ndarray(list(range(8)), shape=[2, 0, 7], format="L",
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3876 flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3877 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3878 m = get_contiguous(nd, PyBUF_READ, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3879 self.assertEqual(ndarray(m).tolist(), [[], []])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3880
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3881 # one-dimensional
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3882 nd = ndarray([1], shape=[1], format="h", flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3883 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3884 m = get_contiguous(nd, PyBUF_WRITE, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3885 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3886 self.assertEqual(m.tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3887
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3888 nd = ndarray([1, 2, 3], shape=[3], format="b", flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3889 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3890 m = get_contiguous(nd, PyBUF_WRITE, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3891 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3892 self.assertEqual(m.tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3893
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3894 # one-dimensional, non-contiguous
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3895 nd = ndarray([1, 2, 3], shape=[2], strides=[2], flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3896 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3897 m = get_contiguous(nd, PyBUF_READ, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3898 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3899 self.assertEqual(m.tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3900 self.assertRaises(TypeError, m.__setitem__, 1, 20)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3901 self.assertEqual(m[1], 3)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3902 self.assertEqual(nd[1], 3)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3903
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3904 nd = nd[::-1]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3905 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3906 m = get_contiguous(nd, PyBUF_READ, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3907 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3908 self.assertEqual(m.tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3909 self.assertRaises(TypeError, m.__setitem__, 1, 20)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3910 self.assertEqual(m[1], 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3911 self.assertEqual(nd[1], 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3912
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3913 # multi-dimensional, contiguous input
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3914 nd = ndarray(list(range(12)), shape=[3, 4], flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3915 for order in ['C', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3916 m = get_contiguous(nd, PyBUF_WRITE, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3917 self.assertEqual(ndarray(m).tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3918
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3919 self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'F')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3920 m = get_contiguous(nd, PyBUF_READ, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3921 self.assertEqual(ndarray(m).tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3922
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3923 nd = ndarray(list(range(12)), shape=[3, 4],
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3924 flags=ND_WRITABLE\|ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3925 for order in ['F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3926 m = get_contiguous(nd, PyBUF_WRITE, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3927 self.assertEqual(ndarray(m).tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3928
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3929 self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'C')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3930 m = get_contiguous(nd, PyBUF_READ, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3931 self.assertEqual(ndarray(m).tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3932
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3933 # multi-dimensional, non-contiguous input
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3934 nd = ndarray(list(range(12)), shape=[3, 4], flags=ND_WRITABLE\|ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3935 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3936 self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3937 order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3938 m = get_contiguous(nd, PyBUF_READ, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3939 self.assertEqual(ndarray(m).tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3940
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3941 # flags
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3942 nd = ndarray([1,2,3,4,5], shape=[3], strides=[2])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3943 m = get_contiguous(nd, PyBUF_READ, 'C')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3944 self.assertTrue(m.c_contiguous)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3945
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3946 def test_memoryview_serializing(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3947
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3948 # C-contiguous
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3949 size = struct.calcsize('i')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3950 a = array.array('i', [1,2,3,4,5])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3951 m = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3952 buf = io.BytesIO(m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3953 b = bytearray(5*size)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3954 buf.readinto(b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3955 self.assertEqual(m.tobytes(), b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3956
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3957 # C-contiguous, multi-dimensional
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3958 size = struct.calcsize('L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3959 nd = ndarray(list(range(12)), shape=[2,3,2], format="L")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3960 m = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3961 buf = io.BytesIO(m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3962 b = bytearray(232*size)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3963 buf.readinto(b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3964 self.assertEqual(m.tobytes(), b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3965
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3966 # Fortran contiguous, multi-dimensional
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3967 #size = struct.calcsize('L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3968 #nd = ndarray(list(range(12)), shape=[2,3,2], format="L",
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3969 # flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3970 #m = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3971 #buf = io.BytesIO(m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3972 #b = bytearray(232*size)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3973 #buf.readinto(b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3974 #self.assertEqual(m.tobytes(), b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3975
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3976 def test_memoryview_hash(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3977
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3978 # bytes exporter
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3979 b = bytes(list(range(12)))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3980 m = memoryview(b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3981 self.assertEqual(hash(b), hash(m))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3982
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3983 # C-contiguous
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3984 mc = m.cast('c', shape=[3,4])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3985 self.assertEqual(hash(mc), hash(b))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3986
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3987 # non-contiguous
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3988 mx = m[::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3989 b = bytes(list(range(12))[::-2])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3990 self.assertEqual(hash(mx), hash(b))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3991
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3992 # Fortran contiguous
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3993 nd = ndarray(list(range(30)), shape=[3,2,5], flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3994 m = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3995 self.assertEqual(hash(m), hash(nd))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3996
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3997 # multi-dimensional slice
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3998 nd = ndarray(list(range(30)), shape=[3,2,5])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3999 x = nd[::2, ::, ::-1]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4000 m = memoryview(x)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4001 self.assertEqual(hash(m), hash(x))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4002
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4003 # multi-dimensional slice with suboffsets
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4004 nd = ndarray(list(range(30)), shape=[2,5,3], flags=ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4005 x = nd[::2, ::, ::-1]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4006 m = memoryview(x)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4007 self.assertEqual(hash(m), hash(x))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4008
80182 969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4009 # equality-hash invariant
969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4010 x = ndarray(list(range(12)), shape=[12], format='B')
80245 fc8f1b1c76bf Fix copy&paste errors and reformulate the tests. Stefan Krah <skrah@bytereef.org> parents: 80182 diff changeset	4011 a = memoryview(x)
80182 969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4012
969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4013 y = ndarray(list(range(12)), shape=[12], format='b')
80245 fc8f1b1c76bf Fix copy&paste errors and reformulate the tests. Stefan Krah <skrah@bytereef.org> parents: 80182 diff changeset	4014 b = memoryview(y)
fc8f1b1c76bf Fix copy&paste errors and reformulate the tests. Stefan Krah <skrah@bytereef.org> parents: 80182 diff changeset	4015
fc8f1b1c76bf Fix copy&paste errors and reformulate the tests. Stefan Krah <skrah@bytereef.org> parents: 80182 diff changeset	4016 self.assertEqual(a, b)
fc8f1b1c76bf Fix copy&paste errors and reformulate the tests. Stefan Krah <skrah@bytereef.org> parents: 80182 diff changeset	4017 self.assertEqual(hash(a), hash(b))
80182 969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4018
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4019 # non-byte formats
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4020 nd = ndarray(list(range(12)), shape=[2,2,3], format='L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4021 m = memoryview(nd)
80182 969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4022 self.assertRaises(ValueError, m.__hash__)
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4023
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4024 nd = ndarray(list(range(-6, 6)), shape=[2,2,3], format='h')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4025 m = memoryview(nd)
80182 969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4026 self.assertRaises(ValueError, m.__hash__)
969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4027
969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4028 nd = ndarray(list(range(12)), shape=[2,2,3], format='= L')
969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4029 m = memoryview(nd)
969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4030 self.assertRaises(ValueError, m.__hash__)
969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4031
969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4032 nd = ndarray(list(range(-6, 6)), shape=[2,2,3], format='< h')
969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4033 m = memoryview(nd)
969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4034 self.assertRaises(ValueError, m.__hash__)
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4035
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4036 def test_memoryview_release(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4037
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4038 # Create re-exporter from getbuffer(memoryview), then release the view.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4039 a = bytearray([1,2,3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4040 m = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4041 nd = ndarray(m) # re-exporter
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4042 self.assertRaises(BufferError, m.release)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4043 del nd
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4044 m.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4045
75409 f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4046 a = bytearray([1,2,3])
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4047 m = memoryview(a)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4048 nd1 = ndarray(m, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4049 nd2 = ndarray(nd1, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4050 self.assertIs(nd2.obj, m)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4051 self.assertRaises(BufferError, m.release)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4052 del nd1, nd2
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4053 m.release()
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4054
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4055 # chained views
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4056 a = bytearray([1,2,3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4057 m1 = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4058 m2 = memoryview(m1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4059 nd = ndarray(m2) # re-exporter
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4060 m1.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4061 self.assertRaises(BufferError, m2.release)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4062 del nd
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4063 m2.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4064
75409 f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4065 a = bytearray([1,2,3])
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4066 m1 = memoryview(a)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4067 m2 = memoryview(m1)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4068 nd1 = ndarray(m2, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4069 nd2 = ndarray(nd1, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4070 self.assertIs(nd2.obj, m2)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4071 m1.release()
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4072 self.assertRaises(BufferError, m2.release)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4073 del nd1, nd2
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4074 m2.release()
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4075
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4076 # Allow changing layout while buffers are exported.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4077 nd = ndarray([1,2,3], shape=[3], flags=ND_VAREXPORT)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4078 m1 = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4079
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4080 nd.push([4,5,6,7,8], shape=[5]) # mutate nd
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4081 m2 = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4082
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4083 x = memoryview(m1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4084 self.assertEqual(x.tolist(), m1.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4085
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4086 y = memoryview(m2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4087 self.assertEqual(y.tolist(), m2.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4088 self.assertEqual(y.tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4089 m2.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4090 y.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4091
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4092 nd.pop() # pop the current view
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4093 self.assertEqual(x.tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4094
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4095 del nd
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4096 m1.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4097 x.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4098
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4099 # If multiple memoryviews share the same managed buffer, implicit
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4100 # release() in the context manager's __exit__() method should still
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4101 # work.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4102 def catch22(b):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4103 with memoryview(b) as m2:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4104 pass
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4105
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4106 x = bytearray(b'123')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4107 with memoryview(x) as m1:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4108 catch22(m1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4109 self.assertEqual(m1[0], ord(b'1'))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4110
75409 f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4111 x = ndarray(list(range(12)), shape=[2,2,3], format='l')
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4112 y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4113 z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4114 self.assertIs(z.obj, x)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4115 with memoryview(z) as m:
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4116 catch22(m)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4117 self.assertEqual(m[0:1].tolist(), [[[0, 1, 2], [3, 4, 5]]])
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4118
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4119 # Test garbage collection.
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4120 for flags in (0, ND_REDIRECT):
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4121 x = bytearray(b'123')
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4122 with memoryview(x) as m1:
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4123 del x
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4124 y = ndarray(m1, getbuf=PyBUF_FULL_RO, flags=flags)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4125 with memoryview(y) as m2:
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4126 del y
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4127 z = ndarray(m2, getbuf=PyBUF_FULL_RO, flags=flags)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4128 with memoryview(z) as m3:
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4129 del z
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4130 catch22(m3)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4131 catch22(m2)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4132 catch22(m1)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4133 self.assertEqual(m1[0], ord(b'1'))
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4134 self.assertEqual(m2[1], ord(b'2'))
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4135 self.assertEqual(m3[2], ord(b'3'))
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4136 del m3
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4137 del m2
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4138 del m1
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4139
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4140 x = bytearray(b'123')
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4141 with memoryview(x) as m1:
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4142 del x
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4143 y = ndarray(m1, getbuf=PyBUF_FULL_RO, flags=flags)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4144 with memoryview(y) as m2:
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4145 del y
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4146 z = ndarray(m2, getbuf=PyBUF_FULL_RO, flags=flags)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4147 with memoryview(z) as m3:
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4148 del z
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4149 catch22(m1)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4150 catch22(m2)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4151 catch22(m3)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4152 self.assertEqual(m1[0], ord(b'1'))
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4153 self.assertEqual(m2[1], ord(b'2'))
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4154 self.assertEqual(m3[2], ord(b'3'))
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4155 del m1, m2, m3
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4156
75414 373f6cdc6d08 Issue #10181: The decision was to raise a buffer error in memory_exit() Stefan Krah <skrah@bytereef.org> parents: 75409 diff changeset	4157 # memoryview.release() fails if the view has exported buffers.
373f6cdc6d08 Issue #10181: The decision was to raise a buffer error in memory_exit() Stefan Krah <skrah@bytereef.org> parents: 75409 diff changeset	4158 x = bytearray(b'123')
373f6cdc6d08 Issue #10181: The decision was to raise a buffer error in memory_exit() Stefan Krah <skrah@bytereef.org> parents: 75409 diff changeset	4159 with self.assertRaises(BufferError):
373f6cdc6d08 Issue #10181: The decision was to raise a buffer error in memory_exit() Stefan Krah <skrah@bytereef.org> parents: 75409 diff changeset	4160 with memoryview(x) as m:
373f6cdc6d08 Issue #10181: The decision was to raise a buffer error in memory_exit() Stefan Krah <skrah@bytereef.org> parents: 75409 diff changeset	4161 ex = ndarray(m)
373f6cdc6d08 Issue #10181: The decision was to raise a buffer error in memory_exit() Stefan Krah <skrah@bytereef.org> parents: 75409 diff changeset	4162 m[0] == ord(b'1')
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4163
75409 f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4164 def test_memoryview_redirect(self):
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4165
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4166 nd = ndarray([1.0 * x for x in range(12)], shape=[12], format='d')
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4167 a = array.array('d', [1.0 * x for x in range(12)])
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4168
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4169 for x in (nd, a):
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4170 y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4171 z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4172 m = memoryview(z)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4173
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4174 self.assertIs(y.obj, x)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4175 self.assertIs(z.obj, x)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4176 self.assertIs(m.obj, x)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4177
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4178 self.assertEqual(m, x)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4179 self.assertEqual(m, y)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4180 self.assertEqual(m, z)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4181
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4182 self.assertEqual(m[1:3], x[1:3])
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4183 self.assertEqual(m[1:3], y[1:3])
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4184 self.assertEqual(m[1:3], z[1:3])
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4185 del y, z
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4186 self.assertEqual(m[1:3], x[1:3])
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4187
75420 3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4188 def test_memoryview_from_static_exporter(self):
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4189
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4190 fmt = 'B'
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4191 lst = [0,1,2,3,4,5,6,7,8,9,10,11]
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4192
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4193 # exceptions
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4194 self.assertRaises(TypeError, staticarray, 1, 2, 3)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4195
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4196 # view.obj==x
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4197 x = staticarray()
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4198 y = memoryview(x)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4199 self.verify(y, obj=x,
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4200 itemsize=1, fmt=fmt, readonly=1,
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4201 ndim=1, shape=[12], strides=[1],
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4202 lst=lst)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4203 for i in range(12):
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4204 self.assertEqual(y[i], i)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4205 del x
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4206 del y
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4207
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4208 x = staticarray()
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4209 y = memoryview(x)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4210 del y
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4211 del x
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4212
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4213 x = staticarray()
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4214 y = ndarray(x, getbuf=PyBUF_FULL_RO)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4215 z = ndarray(y, getbuf=PyBUF_FULL_RO)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4216 m = memoryview(z)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4217 self.assertIs(y.obj, x)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4218 self.assertIs(m.obj, z)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4219 self.verify(m, obj=z,
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4220 itemsize=1, fmt=fmt, readonly=1,
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4221 ndim=1, shape=[12], strides=[1],
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4222 lst=lst)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4223 del x, y, z, m
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4224
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4225 x = staticarray()
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4226 y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4227 z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4228 m = memoryview(z)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4229 self.assertIs(y.obj, x)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4230 self.assertIs(z.obj, x)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4231 self.assertIs(m.obj, x)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4232 self.verify(m, obj=x,
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4233 itemsize=1, fmt=fmt, readonly=1,
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4234 ndim=1, shape=[12], strides=[1],
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4235 lst=lst)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4236 del x, y, z, m
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4237
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4238 # view.obj==NULL
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4239 x = staticarray(legacy_mode=True)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4240 y = memoryview(x)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4241 self.verify(y, obj=None,
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4242 itemsize=1, fmt=fmt, readonly=1,
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4243 ndim=1, shape=[12], strides=[1],
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4244 lst=lst)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4245 for i in range(12):
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4246 self.assertEqual(y[i], i)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4247 del x
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4248 del y
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4249
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4250 x = staticarray(legacy_mode=True)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4251 y = memoryview(x)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4252 del y
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4253 del x
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4254
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4255 x = staticarray(legacy_mode=True)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4256 y = ndarray(x, getbuf=PyBUF_FULL_RO)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4257 z = ndarray(y, getbuf=PyBUF_FULL_RO)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4258 m = memoryview(z)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4259 self.assertIs(y.obj, None)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4260 self.assertIs(m.obj, z)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4261 self.verify(m, obj=z,
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4262 itemsize=1, fmt=fmt, readonly=1,
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4263 ndim=1, shape=[12], strides=[1],
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4264 lst=lst)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4265 del x, y, z, m
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4266
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4267 x = staticarray(legacy_mode=True)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4268 y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4269 z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4270 m = memoryview(z)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4271 # Clearly setting view.obj==NULL is inferior, since it
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4272 # messes up the redirection chain:
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4273 self.assertIs(y.obj, None)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4274 self.assertIs(z.obj, y)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4275 self.assertIs(m.obj, y)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4276 self.verify(m, obj=y,
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4277 itemsize=1, fmt=fmt, readonly=1,
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4278 ndim=1, shape=[12], strides=[1],
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4279 lst=lst)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4280 del x, y, z, m
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4281
75440 9f7d06a9eabe Issue #14181: Preserve backwards compatibility for getbufferprocs that a) do Stefan Krah <skrah@bytereef.org> parents: 75420 diff changeset	4282 def test_memoryview_getbuffer_undefined(self):
9f7d06a9eabe Issue #14181: Preserve backwards compatibility for getbufferprocs that a) do Stefan Krah <skrah@bytereef.org> parents: 75420 diff changeset	4283
9f7d06a9eabe Issue #14181: Preserve backwards compatibility for getbufferprocs that a) do Stefan Krah <skrah@bytereef.org> parents: 75420 diff changeset	4284 # getbufferproc does not adhere to the new documentation
9f7d06a9eabe Issue #14181: Preserve backwards compatibility for getbufferprocs that a) do Stefan Krah <skrah@bytereef.org> parents: 75420 diff changeset	4285 nd = ndarray([1,2,3], [3], flags=ND_GETBUF_FAIL\|ND_GETBUF_UNDEFINED)
9f7d06a9eabe Issue #14181: Preserve backwards compatibility for getbufferprocs that a) do Stefan Krah <skrah@bytereef.org> parents: 75420 diff changeset	4286 self.assertRaises(BufferError, memoryview, nd)
9f7d06a9eabe Issue #14181: Preserve backwards compatibility for getbufferprocs that a) do Stefan Krah <skrah@bytereef.org> parents: 75420 diff changeset	4287
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4288 def test_issue_7385(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4289 x = ndarray([1,2,3], shape=[3], flags=ND_GETBUF_FAIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4290 self.assertRaises(BufferError, memoryview, x)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4291
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4292
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4293 if __name__ == "__main__":
84108 05f7883ee92d Update various test modules to use unittest.main() for test discovery Brett Cannon <brett@python.org> parents: 80245 diff changeset	4294 unittest.main()

Mercurial > cpython-lru_cache-weakref

annotate Lib/test/test_buffer.py @ 87690:66c1c9f32567 default tip