cpython-lru_cache-weakref: Lib/test/test

annotate Lib/test/test_buffer.py @ 81343:3a7cd8efc19f

#16852: merge with 3.3.

author	Ezio Melotti <ezio.melotti@gmail.com>
date	Thu, 10 Jan 2013 03:29:45 +0200
parents	fc8f1b1c76bf
children	b08e092df155 05f7883ee92d

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):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2435 # Casts are undefined if shape contains zeros. These arrays are
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2436 # regarded as C-contiguous by Numpy and PyBuffer_GetContiguous(),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2437 # so they are not caught by the test for C-contiguity in memory_cast().
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2438 items = [1,2,3]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2439 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	2440 ex = ndarray(items, shape=shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2441 self.assertTrue(ex.c_contiguous)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2442 msrc = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2443 self.assertRaises(TypeError, msrc.cast, 'c')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2444
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2445 def test_memoryview_struct_module(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2446
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2447 class INT(object):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2448 def __init__(self, val):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2449 self.val = val
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2450 def __int__(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2451 return self.val
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2452
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2453 class IDX(object):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2454 def __init__(self, val):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2455 self.val = val
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2456 def __index__(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2457 return self.val
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2458
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2459 def f(): return 7
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2460
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2461 values = [INT(9), IDX(9),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2462 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	2463 [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	2464 True, False, None, NotImplemented,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2465 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	2466 'a', 'abc', r'a', r'abc',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2467 f, lambda x: x]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2468
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2469 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	2470 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	2471 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	2472 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2473
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2474 struct.pack_into(fmt, nd, 0, item)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2475 m[0] = item
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2476 self.assertEqual(m[0], nd[0])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2477
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2478 itemsize = struct.calcsize(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2479 if 'P' in fmt:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2480 continue
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2481
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2482 for v in values:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2483 struct_err = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2484 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2485 struct.pack_into(fmt, nd, itemsize, v)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2486 except struct.error:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2487 struct_err = struct.error
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 mv_err = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2490 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2491 m[1] = v
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2492 except (TypeError, ValueError) as e:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2493 mv_err = e.__class__
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2494
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2495 if struct_err or mv_err:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2496 self.assertIsNot(struct_err, None)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2497 self.assertIsNot(mv_err, None)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2498 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2499 self.assertEqual(m[1], nd[1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2500
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2501 def test_memoryview_cast_zero_strides(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2502 # 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	2503 # (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	2504 # PyBuffer_GetContiguous().
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2505 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	2506 self.assertFalse(ex.c_contiguous)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2507 msrc = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2508 self.assertRaises(TypeError, msrc.cast, 'c')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2509
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2510 def test_memoryview_cast_invalid(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2511 # invalid format
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2512 for sfmt in NON_BYTE_FORMAT:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2513 sformat = '@' + sfmt if randrange(2) else sfmt
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2514 ssize = struct.calcsize(sformat)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2515 for dfmt in NON_BYTE_FORMAT:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2516 dformat = '@' + dfmt if randrange(2) else dfmt
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2517 dsize = struct.calcsize(dformat)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2518 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	2519 msrc = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2520 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	2521
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2522 for sfmt, sitems, _ in iter_format(1):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2523 ex = ndarray(sitems, shape=[1], format=sfmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2524 msrc = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2525 for dfmt, _, _ in iter_format(1):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2526 if (not is_memoryview_format(sfmt) or
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2527 not is_memoryview_format(dfmt)):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2528 self.assertRaises(ValueError, msrc.cast, dfmt,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2529 [32//dsize])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2530 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2531 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	2532 self.assertRaises(TypeError, msrc.cast, dfmt,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2533 [32//dsize])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2534
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2535 # invalid shape
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2536 size_h = struct.calcsize('h')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2537 size_d = struct.calcsize('d')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2538 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	2539 msrc = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2540 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	2541
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2542 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	2543 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2544
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2545 # incorrect number of args
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2546 self.assertRaises(TypeError, m.cast)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2547 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	2548
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2549 # incorrect dest format type
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2550 self.assertRaises(TypeError, m.cast, {})
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 dest format
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2553 self.assertRaises(ValueError, m.cast, "X")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2554 self.assertRaises(ValueError, m.cast, "@X")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2555 self.assertRaises(ValueError, m.cast, "@XY")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2556
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2557 # dest format not implemented
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2558 self.assertRaises(ValueError, m.cast, "=B")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2559 self.assertRaises(ValueError, m.cast, "!L")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2560 self.assertRaises(ValueError, m.cast, "<P")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2561 self.assertRaises(ValueError, m.cast, ">l")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2562 self.assertRaises(ValueError, m.cast, "BI")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2563 self.assertRaises(ValueError, m.cast, "xBI")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2564
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2565 # src format not implemented
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2566 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	2567 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2568 self.assertRaises(NotImplementedError, m.__getitem__, 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2569 self.assertRaises(NotImplementedError, m.__setitem__, 0, 8)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2570 self.assertRaises(NotImplementedError, m.tolist)
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 # incorrect shape type
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2573 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	2574 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2575 self.assertRaises(TypeError, m.cast, "B", shape={})
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2576
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2577 # incorrect shape elements
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2578 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	2579 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2580 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	2581 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	2582 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	2583 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	2584 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	2585
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2586 # N-D -> N-D cast
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2587 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	2588 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2589 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	2590
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2591 # cast with ndim > 64
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2592 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	2593 m = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2594 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	2595
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2596 # view->len not a multiple of itemsize
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2597 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	2598 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2599 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	2600
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2601 # product(shape) * itemsize != buffer size
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2602 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	2603 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2604 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	2605
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2606 # product(shape) * itemsize overflow
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2607 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	2608 m1 = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2609 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	2610 m2 = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2611 if sys.maxsize == 2**63-1:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2612 self.assertRaises(TypeError, m1.cast, 'B',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2613 [7, 7, 73, 127, 337, 92737, 649657])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2614 self.assertRaises(ValueError, m1.cast, 'B',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2615 [220, 220, 210, 210, 2**3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2616 self.assertRaises(ValueError, m2.cast, 'I',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2617 [220, 220, 210, 210, 2**1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2618 else:
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 [1, 2147483647])
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 [210, 210, 25, 25, 2**1])
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 [210, 210, 25, 23, 2**1])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2625
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2626 def test_memoryview_cast(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2627 bytespec = (
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2628 ('B', lambda ex: list(ex.tobytes())),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2629 ('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	2630 ('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	2631 )
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 iter_roundtrip(ex, m, items, fmt):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2634 srcsize = struct.calcsize(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2635 for bytefmt, to_bytelist in bytespec:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2636
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2637 m2 = m.cast(bytefmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2638 lst = to_bytelist(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2639 self.verify(m2, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2640 itemsize=1, fmt=bytefmt, readonly=0,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2641 ndim=1, shape=[31*srcsize], strides=(1,),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2642 lst=lst, cast=True)
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 m3 = m2.cast(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2645 self.assertEqual(m3, ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2646 lst = ex.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2647 self.verify(m3, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2648 itemsize=srcsize, fmt=fmt, readonly=0,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2649 ndim=1, shape=[31], strides=(srcsize,),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2650 lst=lst, cast=True)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2651
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2652 # cast from ndim = 0 to ndim = 1
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2653 srcsize = struct.calcsize('I')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2654 ex = ndarray(9, shape=[], format='I')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2655 destitems, destshape = cast_items(ex, 'B', 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2656 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2657 m2 = m.cast('B')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2658 self.verify(m2, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2659 itemsize=1, fmt='B', readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2660 ndim=1, shape=destshape, strides=(1,),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2661 lst=destitems, cast=True)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2662
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2663 # cast from ndim = 1 to ndim = 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2664 destsize = struct.calcsize('I')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2665 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	2666 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	2667 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2668 m2 = m.cast('I', shape=[])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2669 self.verify(m2, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2670 itemsize=destsize, fmt='I', readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2671 ndim=0, shape=(), strides=(),
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2672 lst=destitems, cast=True)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2673
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2674 # array.array: roundtrip to/from bytes
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2675 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	2676 ex = array.array(fmt, items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2677 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2678 iter_roundtrip(ex, m, items, fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2679
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2680 # ndarray: roundtrip to/from bytes
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2681 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	2682 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	2683 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2684 iter_roundtrip(ex, m, items, fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2685
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2686 def test_memoryview_cast_1D_ND(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2687 # 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	2688 # 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	2689 for _tshape in gencastshapes():
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2690 for char in fmtdict['@']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2691 tfmt = ('', '@')[randrange(2)] + char
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2692 tsize = struct.calcsize(tfmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2693 n = prod(_tshape) * tsize
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2694 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	2695 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	2696 size = struct.calcsize(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2697 shape = [n] if n > 0 else []
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2698 tshape = _tshape + [size]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2699
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2700 ex = ndarray(items, shape=shape, format=fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2701 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2702
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2703 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	2704
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2705 if titems is None:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2706 self.assertRaises(TypeError, m.cast, tfmt, tshape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2707 continue
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2708 if titems == 'nan':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2709 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	2710
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2711 # 1D -> ND
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2712 nd = ndarray(titems, shape=tshape, format=tfmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2713
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2714 m2 = m.cast(tfmt, shape=tshape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2715 ndim = len(tshape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2716 strides = nd.strides
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2717 lst = nd.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2718 self.verify(m2, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2719 itemsize=tsize, fmt=tfmt, readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2720 ndim=ndim, shape=tshape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2721 lst=lst, cast=True)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2722
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2723 # ND -> 1D
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2724 m3 = m2.cast(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2725 m4 = m2.cast(fmt, shape=shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2726 ndim = len(shape)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2727 strides = ex.strides
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2728 lst = ex.tolist()
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 self.verify(m3, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2731 itemsize=size, fmt=fmt, readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2732 ndim=ndim, shape=shape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2733 lst=lst, cast=True)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2734
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2735 self.verify(m4, obj=ex,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2736 itemsize=size, fmt=fmt, readonly=1,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2737 ndim=ndim, shape=shape, strides=strides,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2738 lst=lst, cast=True)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2739
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2740 def test_memoryview_tolist(self):
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 # 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	2743
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2744 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	2745 m = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2746 self.assertEqual(m, a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2747 self.assertEqual(m.tolist(), a.tolist())
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 a = a[2::3]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2750 m = m[2::3]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2751 self.assertEqual(m, a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2752 self.assertEqual(m.tolist(), a.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2753
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2754 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	2755 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2756 self.assertEqual(m.tolist(), ex.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2757
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2758 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	2759 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2760 self.assertRaises(NotImplementedError, m.tolist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2761
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2762 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	2763 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2764 self.assertRaises(NotImplementedError, m.tolist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2765
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2766 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	2767 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2768 self.assertRaises(NotImplementedError, m.tolist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2769
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2770 def test_memoryview_repr(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2771 m = memoryview(bytearray(9))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2772 r = m.__repr__()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2773 self.assertTrue(r.startswith("<memory"))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2774
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2775 m.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2776 r = m.__repr__()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2777 self.assertTrue(r.startswith("<released"))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2778
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2779 def test_memoryview_sequence(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2780
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2781 for fmt in ('d', 'f'):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2782 inf = float(3e400)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2783 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	2784 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2785 self.assertIn(1.0, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2786 self.assertIn(5e700, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2787 self.assertIn(3.0, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2788
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2789 ex = ndarray(9.0, [], format='f')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2790 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2791 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	2792
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2793 def test_memoryview_index(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2794
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2795 # ndim = 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2796 ex = ndarray(12.5, shape=[], format='d')
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.assertEqual(m[()], 12.5)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2799 self.assertEqual(m[...], m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2800 self.assertEqual(m[...], ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2801 self.assertRaises(TypeError, m.__getitem__, 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2802
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2803 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	2804 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2805 self.assertRaises(NotImplementedError, m.__getitem__, ())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2806
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2807 # range
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2808 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	2809 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2810
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2811 self.assertRaises(IndexError, m.__getitem__, 2**64)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2812 self.assertRaises(TypeError, m.__getitem__, 2.0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2813 self.assertRaises(TypeError, m.__getitem__, 0.0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2814
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2815 # out of bounds
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2816 self.assertRaises(IndexError, m.__getitem__, -8)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2817 self.assertRaises(IndexError, m.__getitem__, 8)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2818
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2819 # Not implemented: multidimensional sub-views
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2820 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	2821 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2822
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2823 self.assertRaises(NotImplementedError, m.__getitem__, 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2824 self.assertRaises(NotImplementedError, m.__setitem__, 0, 9)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2825 self.assertRaises(NotImplementedError, m.__getitem__, 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2826
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2827 def test_memoryview_assign(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2828
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2829 # ndim = 0
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2830 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	2831 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2832 m[()] = 22.5
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2833 self.assertEqual(m[()], 22.5)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2834 m[...] = 23.5
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2835 self.assertEqual(m[()], 23.5)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2836 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	2837
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2838 # read-only
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2839 ex = ndarray(list(range(7)), shape=[7])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2840 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2841 self.assertRaises(TypeError, m.__setitem__, 2, 10)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2842
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2843 # range
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2844 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	2845 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2846
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2847 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	2848 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	2849 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	2850
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2851 # out of bounds
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2852 self.assertRaises(IndexError, m.__setitem__, -8, 20)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2853 self.assertRaises(IndexError, m.__setitem__, 8, 25)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2854
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2855 # pack_single() success:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2856 for fmt in fmtdict['@']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2857 if fmt == 'c' or fmt == '?':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2858 continue
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2859 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	2860 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2861 i = randrange(-3, 3)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2862 m[i] = 8
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2863 self.assertEqual(m[i], 8)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2864 self.assertEqual(m[i], ex[i])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2865
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2866 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	2867 flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2868 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2869 m[2] = b'9'
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2870 self.assertEqual(m[2], b'9')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2871
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2872 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	2873 flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2874 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2875 m[1] = True
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2876 self.assertEqual(m[1], True)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2877
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2878 # pack_single() exceptions:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2879 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	2880 m = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2881 self.assertRaises(TypeError, m.__setitem__, 0, 100)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2882
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2883 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	2884 m1 = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2885
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2886 for fmt, _range in fmtdict['@'].items():
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2887 if (fmt == '?'): # PyObject_IsTrue() accepts anything
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2888 continue
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2889 if fmt == 'c': # special case tested above
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2890 continue
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2891 m2 = m1.cast(fmt)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2892 lo, hi = _range
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2893 if fmt == 'd' or fmt == 'f':
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2894 lo, hi = -21024, 21024
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2895 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	2896 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	2897 self.assertRaises(TypeError, m2.__setitem__, 0, "xyz")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2898 self.assertRaises(ValueError, m2.__setitem__, 0, hi)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2899
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2900 # invalid item
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2901 m2 = m1.cast('c')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2902 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	2903
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2904 # format not implemented
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2905 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	2906 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2907 self.assertRaises(NotImplementedError, m.__setitem__, 0, 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2908
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2909 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	2910 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2911 self.assertRaises(NotImplementedError, m.__setitem__, 0, 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2912
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2913 # Not implemented: multidimensional sub-views
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2914 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	2915 m = memoryview(ex)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2916
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2917 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	2918
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2919 def test_memoryview_slice(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2920
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2921 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	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 # zero step
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2925 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	2926 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	2927 bytearray([1,2]))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2928
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2929 # invalid slice key
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2930 self.assertRaises(TypeError, m.__getitem__, ())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2931
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2932 # multidimensional slices
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2933 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	2934 m = memoryview(ex)
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 self.assertRaises(NotImplementedError, m.__getitem__,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2937 (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	2938 self.assertRaises(NotImplementedError, m.__setitem__,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2939 (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	2940
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2941 # invalid slice tuple
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2942 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	2943 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	2944 bytearray([1,2]))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2945
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2946 # rvalue is not an exporter
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2947 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	2948
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2949 # non-contiguous slice assignment
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2950 for flags in (0, ND_PIL):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2951 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	2952 flags=ND_WRITABLE\|flags)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2953 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	2954 m1 = memoryview(ex1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2955 m2 = memoryview(ex2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2956
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2957 ex1[2:5] = ex1[2:5]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2958 m1[2:5] = m2[2:5]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2959
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2960 self.assertEqual(m1, ex1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2961 self.assertEqual(m2, ex2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2962
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2963 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	2964 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	2965
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2966 self.assertEqual(m1, ex1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2967 self.assertEqual(m2, ex2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2968
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2969 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	2970 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	2971
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2972 self.assertEqual(m1, ex1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2973 self.assertEqual(m2, ex2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2974
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2975 def test_memoryview_array(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2976
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2977 def cmptest(testcase, a, b, m, singleitem):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2978 for i, _ in enumerate(a):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2979 ai = a[i]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2980 mi = m[i]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2981 testcase.assertEqual(ai, mi)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2982 a[i] = singleitem
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2983 if singleitem != ai:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2984 testcase.assertNotEqual(a, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2985 testcase.assertNotEqual(a, b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2986 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2987 testcase.assertEqual(a, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2988 testcase.assertEqual(a, b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2989 m[i] = singleitem
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2990 testcase.assertEqual(a, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2991 testcase.assertEqual(b, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2992 a[i] = ai
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2993 m[i] = mi
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2994
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2995 for n in range(1, 5):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2996 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	2997 for lslice in genslices(n):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2998 for rslice in genslices(n):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	2999
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3000 a = array.array(fmt, items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3001 b = array.array(fmt, items)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3002 m = memoryview(b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3003
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3004 self.assertEqual(m, a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3005 self.assertEqual(m.tolist(), a.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3006 self.assertEqual(m.tobytes(), a.tobytes())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3007 self.assertEqual(len(m), len(a))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3008
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3009 cmptest(self, a, b, m, singleitem)
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 array_err = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3012 have_resize = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3013 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3014 al = a[lslice]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3015 ar = a[rslice]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3016 a[lslice] = a[rslice]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3017 have_resize = len(al) != len(ar)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3018 except Exception as e:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3019 array_err = e.__class__
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3020
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3021 m_err = None
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3022 try:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3023 m[lslice] = m[rslice]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3024 except Exception as e:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3025 m_err = e.__class__
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3026
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3027 if have_resize: # memoryview cannot change shape
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3028 self.assertIs(m_err, ValueError)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3029 elif m_err or array_err:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3030 self.assertIs(m_err, array_err)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3031 else:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3032 self.assertEqual(m, a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3033 self.assertEqual(m.tolist(), a.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3034 self.assertEqual(m.tobytes(), a.tobytes())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3035 cmptest(self, a, b, m, singleitem)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3036
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3037 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	3038
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3039 a = array.array('L', [1, 2, 3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3040 b = array.array('L', [1, 2, 7])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3041
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3042 # Ordering comparisons raise:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3043 v = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3044 w = memoryview(b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3045 for attr in ('__lt__', '__le__', '__gt__', '__ge__'):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3046 self.assertIs(getattr(v, attr)(w), NotImplemented)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3047 self.assertIs(getattr(a, attr)(v), NotImplemented)
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 # Released views compare equal to themselves:
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 v.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3052 self.assertEqual(v, v)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3053 self.assertNotEqual(v, a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3054 self.assertNotEqual(a, v)
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 v = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3057 w = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3058 w.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3059 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3060 self.assertNotEqual(w, v)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3061
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3062 # Operand does not implement the buffer protocol:
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 self.assertNotEqual(v, [1, 2, 3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3065
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3066 # NaNs
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3067 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	3068 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	3069 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	3070
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3071 # 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	3072 a = array.array('u', 'xyz')
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3073 v = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3074 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	3075 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	3076
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3077 # 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	3078 if ctypes:
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3079 # 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	3080 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	3081 _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	3082 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	3083 a = memoryview(point)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3084 b = memoryview(point)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3085 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	3086 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	3087 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	3088 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	3089
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3090 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	3091
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3092 nd1 = ndarray(1729, shape=[], format='@L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3093 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	3094 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3095 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3096 self.assertEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3097 self.assertEqual(w, v)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3098 self.assertEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3099 self.assertEqual(nd2, v)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3100 self.assertEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3101 self.assertEqual(nd1, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3102
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3103 self.assertFalse(v.__ne__(w))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3104 self.assertFalse(w.__ne__(v))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3105
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3106 w[()] = 1728
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3107 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3108 self.assertNotEqual(w, v)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3109 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3110 self.assertNotEqual(nd2, v)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3111 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3112 self.assertNotEqual(nd1, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3113
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3114 self.assertFalse(v.__eq__(w))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3115 self.assertFalse(w.__eq__(v))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3116
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3117 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	3118 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	3119 m = memoryview(ex)
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.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3122 m[9] = 100
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3123 self.assertNotEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3124
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3125 # struct module: equal
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3126 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	3127 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	3128 flags=ND_WRITABLE)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3129 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3130 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3131 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	3132 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	3133 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	3134 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	3135 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	3136 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	3137
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3138 # 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	3139 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	3140 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	3141 flags=ND_WRITABLE)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3142 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3143 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3144 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	3145 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	3146 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	3147 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	3148 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	3149 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	3150 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	3151 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	3152
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3153 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	3154
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3155 # contiguous
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3156 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	3157 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	3158 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3159 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3160
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3161 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3162 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3163 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3164 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3165 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3166
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3167 # contiguous, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3168 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	3169 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	3170 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3171 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3172
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3173 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	3174 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	3175 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	3176 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	3177 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	3178
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3179 # non-contiguous
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3180 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	3181 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	3182 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3183 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3184
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3185 self.assertEqual(v, nd2[::2])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3186 self.assertEqual(w[::2], nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3187 self.assertEqual(v, w[::2])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3188 self.assertEqual(v[::-1], w[::-2])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3189
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3190 # 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	3191 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	3192 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	3193 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3194 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3195
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3196 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	3197 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	3198 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	3199 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	3200
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3201 # non-contiguous, suboffsets
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3202 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	3203 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	3204 flags=ND_PIL)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3205 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3206 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3207
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3208 self.assertEqual(v, nd2[::2])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3209 self.assertEqual(w[::2], nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3210 self.assertEqual(v, w[::2])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3211 self.assertEqual(v[::-1], w[::-2])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3212
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3213 # 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	3214 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	3215 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	3216 flags=ND_PIL)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3217 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3218 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3219
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3220 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	3221 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	3222 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	3223 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	3224
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3225 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	3226
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3227 # zeros in shape
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3228 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	3229 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	3230 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3231 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3232
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3233 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3234 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3235 self.assertEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3236 self.assertEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3237 self.assertEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3238
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3239 # 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	3240 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	3241 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	3242 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3243 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3244
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3245 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	3246 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	3247 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	3248 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	3249 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	3250
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3251 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	3252
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3253 # zero strides
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3254 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	3255 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	3256 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3257 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3258
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3259 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3260 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3261 self.assertEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3262 self.assertEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3263 self.assertEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3264
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3265 # 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	3266 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	3267 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	3268 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3269 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3270
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3271 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	3272 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	3273 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	3274 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	3275 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	3276
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3277 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	3278
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3279 # random single character native formats
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3280 n = 10
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3281 for char in fmtdict['@m']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3282 fmt, items, singleitem = randitems(n, 'memoryview', '@', char)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3283 for flags in (0, ND_PIL):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3284 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	3285 m = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3286 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3287
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3288 nd = nd[::-3]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3289 m = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3290 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3291
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3292 # random formats
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3293 n = 10
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3294 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	3295 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	3296 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	3297 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	3298 m = memoryview(nd)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3299 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	3300
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3301 nd = nd[::-3]
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3302 m = memoryview(nd)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3303 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	3304
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3305 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	3306
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3307 # C-contiguous, different values
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3308 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	3309 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	3310 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3311 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3312
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3313 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3314 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3315 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3316 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3317 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3318
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3319 # 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	3320 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	3321 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	3322 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3323 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3324
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3325 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	3326 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	3327 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	3328 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	3329 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	3330
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3331 # C-contiguous, different shape
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3332 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	3333 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	3334 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3335 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3336
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3337 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3338 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3339 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3340 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3341 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3342
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3343 # 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	3344 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	3345 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	3346 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3347 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3348
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3349 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3350 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3351 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3352 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3353 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3354
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3355 # 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	3356 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	3357 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	3358 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3359 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3360
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3361 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	3362 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	3363 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	3364 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	3365 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	3366
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3367 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	3368
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3369 # Fortran-contiguous, different values
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3370 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	3371 flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3372 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	3373 flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3374 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3375 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3376
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3377 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3378 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3379 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3380 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3381 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3382
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3383 # 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	3384 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	3385 flags=ND_FORTRAN)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3386 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	3387 flags=ND_FORTRAN)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3388 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3389 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3390
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3391 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	3392 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	3393 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	3394 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	3395 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	3396
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3397 # Fortran-contiguous, different shape
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3398 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	3399 flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3400 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	3401 flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3402 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3403 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3404
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3405 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3406 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3407 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3408 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3409 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3410
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3411 # 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	3412 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	3413 flags=ND_FORTRAN)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3414 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	3415 flags=ND_FORTRAN)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3416 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3417 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3418
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3419 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	3420 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	3421 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	3422 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	3423 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	3424
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3425 # Fortran-contiguous, different format, struct module
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3426 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	3427 flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3428 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	3429 flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3430 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3431 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3432
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3433 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3434 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	3435 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	3436 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	3437 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	3438
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3439 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	3440
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3441 # mixed C/Fortran contiguous
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3442 lst1 = list(range(-15, 15))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3443 lst2 = transpose(lst1, [3, 2, 5])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3444 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	3445 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	3446 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3447 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3448
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3449 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3450 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3451 self.assertEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3452
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3453 # 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	3454 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	3455 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	3456 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	3457 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	3458 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	3459 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3460 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3461
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3462 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	3463 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	3464 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	3465
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3466 # different values, non-contiguous
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3467 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	3468 nd1 = ex1[3:1:-1, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3469 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	3470 nd2 = ex2[1:3:1, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3471 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3472 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3473
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3474 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3475 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3476 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3477 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3478 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3479
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3480 # 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	3481 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	3482 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	3483 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	3484 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	3485 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3486 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3487
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3488 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	3489 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	3490 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	3491 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	3492 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	3493
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3494 # different shape
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3495 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	3496 nd1 = ex1[1:3:, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3497 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	3498 nd2 = ex2[1:3:, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3499 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3500 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3501
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3502 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3503 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3504 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3505 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3506 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3507
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3508 # 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	3509 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	3510 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	3511 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	3512 nd2 = ex2[1:3:, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3513 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3514 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3515
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3516 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3517 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3518 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3519 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3520 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3521
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3522 # 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	3523 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	3524 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	3525 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	3526 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	3527 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3528 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3529
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3530 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	3531 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	3532 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	3533 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	3534 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	3535
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3536 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	3537
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3538 # zeros in shape
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3539 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	3540 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	3541 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3542 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3543
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3544 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3545 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3546 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3547 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3548 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3549
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3550 # 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	3551 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	3552 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	3553 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3554 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3555
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3556 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	3557 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	3558 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	3559 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	3560 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	3561
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3562 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	3563
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3564 # zero strides
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3565 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	3566 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	3567 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3568 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3569
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3570 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3571 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3572 self.assertEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3573 self.assertEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3574 self.assertEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3575 self.assertEqual(v.tolist(), w.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3576
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3577 # 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	3578 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	3579 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	3580 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3581 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3582
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3583 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	3584 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	3585 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	3586 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	3587 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	3588
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3589 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	3590
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3591 # suboffsets
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3592 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	3593 nd1 = ex1[3:1:-1, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3594 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	3595 nd2 = ex2[1:3:1, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3596 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3597 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3598
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3599 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3600 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3601 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3602 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3603 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3604
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3605 # suboffsets, struct module
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3606 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	3607 flags=ND_WRITABLE)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3608 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	3609 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	3610
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3611 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	3612 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	3613 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	3614 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	3615
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3616 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3617 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3618
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3619 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	3620 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	3621 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	3622 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	3623 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	3624
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3625 # suboffsets, different shape
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3626 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	3627 flags=ND_PIL)
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3628 nd1 = ex1[1:3:, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3629 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	3630 nd2 = ex2[1:3:, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3631 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3632 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3633
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3634 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3635 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3636 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3637 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3638 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3639
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3640 # 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	3641 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	3642 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	3643 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	3644
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3645 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	3646 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	3647
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3648 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3649 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3650
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3651 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	3652 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	3653 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	3654 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	3655 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	3656
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3657 # suboffsets, different format
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3658 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	3659 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	3660 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	3661 nd2 = ex2[1:3:, ::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3662 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3663 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3664
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3665 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3666 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	3667 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	3668 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	3669 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	3670
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3671 # 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	3672 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	3673 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	3674 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	3675 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	3676
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3677 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	3678 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	3679 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	3680 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	3681
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3682 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3683 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3684
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3685 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	3686 self.assertEqual(w, nd2)
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3687 self.assertNotEqual(v, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3688 self.assertNotEqual(w, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3689 self.assertNotEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3690
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3691 # initialize mixed C/Fortran + suboffsets
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3692 lst1 = list(range(-15, 15))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3693 lst2 = transpose(lst1, [3, 2, 5])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3694 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	3695 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	3696 v = memoryview(nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3697 w = memoryview(nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3698
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3699 self.assertEqual(v, nd1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3700 self.assertEqual(w, nd2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3701 self.assertEqual(v, w)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3702
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3703 # 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	3704 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	3705 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	3706 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	3707
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3708 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	3709 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	3710 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	3711 v = memoryview(nd1)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3712 w = memoryview(nd2)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3713
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3714 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	3715 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	3716 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	3717
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3718 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	3719
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3720 # items not equal
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3721 for byteorder in ['=', '<', '>', '!']:
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3722 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	3723 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	3724 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	3725 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	3726 a = memoryview(x)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3727 b = memoryview(y)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3728 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	3729 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	3730 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	3731 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	3732 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	3733
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3734 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	3735 format=byteorder+'QLH')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3736 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	3737 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	3738 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	3739 a = memoryview(x)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3740 b = memoryview(y)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3741 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	3742 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	3743 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	3744 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	3745 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	3746
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3747 def test_memoryview_check_released(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3748
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3749 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	3750
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3751 m = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3752 m.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3753
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3754 # PyMemoryView_FromObject()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3755 self.assertRaises(ValueError, memoryview, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3756 # memoryview.cast()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3757 self.assertRaises(ValueError, m.cast, 'c')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3758 # getbuffer()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3759 self.assertRaises(ValueError, ndarray, m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3760 # memoryview.tolist()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3761 self.assertRaises(ValueError, m.tolist)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3762 # memoryview.tobytes()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3763 self.assertRaises(ValueError, m.tobytes)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3764 # sequence
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3765 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	3766 # subscript
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3767 self.assertRaises(ValueError, m.__getitem__, 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3768 # assignment
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3769 self.assertRaises(ValueError, m.__setitem__, 0, 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3770
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3771 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	3772 'shape', 'strides', 'suboffsets', 'c_contiguous',
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3773 'f_contiguous', 'contiguous'):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3774 self.assertRaises(ValueError, m.__getattribute__, attr)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3775
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3776 # richcompare
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3777 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	3778 m1 = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3779 m2 = memoryview(b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3780
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3781 self.assertEqual(m1, m2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3782 m1.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3783 self.assertNotEqual(m1, m2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3784 self.assertNotEqual(m1, a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3785 self.assertEqual(m1, m1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3786
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3787 def test_memoryview_tobytes(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3788 # 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	3789
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3790 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	3791
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3792 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	3793 m = memoryview(nd)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3794 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	3795 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	3796
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3797 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	3798 m = memoryview(nd)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3799 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	3800 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	3801
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3802 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	3803 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	3804 self.assertEqual(m, nd)
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3805 self.assertEqual(m.tobytes(), nd.tobytes())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3806
78760 afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3807 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	3808 format='<hQiLl')
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3809 m = memoryview(nd)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3810 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	3811 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	3812
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3813 # 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	3814 if ctypes:
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3815 # 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	3816 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	3817 _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	3818 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	3819 a = memoryview(point)
afa3dedfee18 Close #15573: use value-based memoryview comparisons (patch by Stefan Krah) Nick Coghlan <ncoghlan@gmail.com> parents: 78720 diff changeset	3820 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	3821
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3822 def test_memoryview_get_contiguous(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3823 # 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	3824
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3825 # no buffer interface
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3826 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	3827
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3828 # writable request to read-only object
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3829 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	3830
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3831 # writable request to non-contiguous object
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3832 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	3833 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	3834
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3835 # 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	3836 nd = ndarray(9, shape=(), format="L")
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3837 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3838 m = get_contiguous(nd, PyBUF_READ, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3839 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3840 self.assertEqual(m[()], 9)
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 writable 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", flags=ND_WRITABLE)
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, writable request
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3850 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3851 nd[()] = 9
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3852 m = get_contiguous(nd, PyBUF_WRITE, 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 m[()] = 10
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3857 self.assertEqual(m[()], 10)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3858 self.assertEqual(nd[()], 10)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3859
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3860 # zeros in shape
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3861 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	3862 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3863 m = get_contiguous(nd, PyBUF_READ, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3864 self.assertRaises(IndexError, m.__getitem__, 0)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3865 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3866 self.assertEqual(m.tolist(), [])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3867
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3868 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	3869 flags=ND_WRITABLE)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3870 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3871 m = get_contiguous(nd, PyBUF_READ, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3872 self.assertEqual(ndarray(m).tolist(), [[], []])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3873
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3874 # one-dimensional
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3875 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	3876 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3877 m = get_contiguous(nd, PyBUF_WRITE, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3878 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3879 self.assertEqual(m.tolist(), nd.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 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	3882 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3883 m = get_contiguous(nd, PyBUF_WRITE, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3884 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3885 self.assertEqual(m.tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3886
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3887 # one-dimensional, non-contiguous
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3888 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	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_READ, 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 self.assertRaises(TypeError, m.__setitem__, 1, 20)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3894 self.assertEqual(m[1], 3)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3895 self.assertEqual(nd[1], 3)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3896
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3897 nd = nd[::-1]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3898 for order in ['C', 'F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3899 m = get_contiguous(nd, PyBUF_READ, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3900 self.assertEqual(m, nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3901 self.assertEqual(m.tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3902 self.assertRaises(TypeError, m.__setitem__, 1, 20)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3903 self.assertEqual(m[1], 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3904 self.assertEqual(nd[1], 1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3905
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3906 # multi-dimensional, contiguous input
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3907 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	3908 for order in ['C', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3909 m = get_contiguous(nd, PyBUF_WRITE, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3910 self.assertEqual(ndarray(m).tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3911
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3912 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	3913 m = get_contiguous(nd, PyBUF_READ, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3914 self.assertEqual(ndarray(m).tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3915
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3916 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	3917 flags=ND_WRITABLE\|ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3918 for order in ['F', 'A']:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3919 m = get_contiguous(nd, PyBUF_WRITE, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3920 self.assertEqual(ndarray(m).tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3921
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3922 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	3923 m = get_contiguous(nd, PyBUF_READ, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3924 self.assertEqual(ndarray(m).tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3925
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3926 # multi-dimensional, non-contiguous input
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3927 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	3928 for order in ['C', 'F', 'A']:
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,
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3930 order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3931 m = get_contiguous(nd, PyBUF_READ, order)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3932 self.assertEqual(ndarray(m).tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3933
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3934 # flags
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3935 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	3936 m = get_contiguous(nd, PyBUF_READ, 'C')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3937 self.assertTrue(m.c_contiguous)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3938
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3939 def test_memoryview_serializing(self):
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 # C-contiguous
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3942 size = struct.calcsize('i')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3943 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	3944 m = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3945 buf = io.BytesIO(m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3946 b = bytearray(5*size)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3947 buf.readinto(b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3948 self.assertEqual(m.tobytes(), b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3949
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3950 # C-contiguous, multi-dimensional
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3951 size = struct.calcsize('L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3952 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	3953 m = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3954 buf = io.BytesIO(m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3955 b = bytearray(232*size)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3956 buf.readinto(b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3957 self.assertEqual(m.tobytes(), b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3958
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3959 # Fortran contiguous, multi-dimensional
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3960 #size = struct.calcsize('L')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3961 #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	3962 # flags=ND_FORTRAN)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3963 #m = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3964 #buf = io.BytesIO(m)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3965 #b = bytearray(232*size)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3966 #buf.readinto(b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3967 #self.assertEqual(m.tobytes(), b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3968
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3969 def test_memoryview_hash(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3970
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3971 # bytes exporter
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3972 b = bytes(list(range(12)))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3973 m = memoryview(b)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3974 self.assertEqual(hash(b), hash(m))
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 # C-contiguous
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3977 mc = m.cast('c', shape=[3,4])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3978 self.assertEqual(hash(mc), hash(b))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3979
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3980 # non-contiguous
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3981 mx = m[::-2]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3982 b = bytes(list(range(12))[::-2])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3983 self.assertEqual(hash(mx), hash(b))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3984
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3985 # Fortran contiguous
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3986 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	3987 m = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3988 self.assertEqual(hash(m), hash(nd))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3989
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3990 # multi-dimensional slice
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3991 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	3992 x = nd[::2, ::, ::-1]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3993 m = memoryview(x)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3994 self.assertEqual(hash(m), hash(x))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3995
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3996 # multi-dimensional slice with suboffsets
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3997 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	3998 x = nd[::2, ::, ::-1]
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	3999 m = memoryview(x)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4000 self.assertEqual(hash(m), hash(x))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4001
80182 969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4002 # equality-hash invariant
969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4003 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	4004 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	4005
969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4006 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	4007 b = memoryview(y)
fc8f1b1c76bf Fix copy&paste errors and reformulate the tests. Stefan Krah <skrah@bytereef.org> parents: 80182 diff changeset	4008
fc8f1b1c76bf Fix copy&paste errors and reformulate the tests. Stefan Krah <skrah@bytereef.org> parents: 80182 diff changeset	4009 self.assertEqual(a, b)
fc8f1b1c76bf Fix copy&paste errors and reformulate the tests. Stefan Krah <skrah@bytereef.org> parents: 80182 diff changeset	4010 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	4011
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4012 # non-byte formats
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4013 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	4014 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	4015 self.assertRaises(ValueError, m.__hash__)
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4016
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4017 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	4018 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	4019 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	4020
969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4021 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	4022 m = memoryview(nd)
969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4023 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	4024
969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4025 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	4026 m = memoryview(nd)
969069d464bc Issue #15814: Use hash function that is compatible with the equality Stefan Krah <skrah@bytereef.org> parents: 78760 diff changeset	4027 self.assertRaises(ValueError, m.__hash__)
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4028
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4029 def test_memoryview_release(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4030
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4031 # 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	4032 a = bytearray([1,2,3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4033 m = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4034 nd = ndarray(m) # re-exporter
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4035 self.assertRaises(BufferError, m.release)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4036 del nd
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4037 m.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4038
75409 f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4039 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	4040 m = memoryview(a)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4041 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	4042 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	4043 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	4044 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	4045 del nd1, nd2
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4046 m.release()
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4047
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4048 # chained views
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4049 a = bytearray([1,2,3])
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4050 m1 = memoryview(a)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4051 m2 = memoryview(m1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4052 nd = ndarray(m2) # re-exporter
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4053 m1.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4054 self.assertRaises(BufferError, m2.release)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4055 del nd
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4056 m2.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4057
75409 f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4058 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	4059 m1 = memoryview(a)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4060 m2 = memoryview(m1)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4061 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	4062 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	4063 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	4064 m1.release()
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4065 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	4066 del nd1, nd2
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4067 m2.release()
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4068
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4069 # Allow changing layout while buffers are exported.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4070 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	4071 m1 = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4072
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4073 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	4074 m2 = memoryview(nd)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4075
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4076 x = memoryview(m1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4077 self.assertEqual(x.tolist(), m1.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4078
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4079 y = memoryview(m2)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4080 self.assertEqual(y.tolist(), m2.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4081 self.assertEqual(y.tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4082 m2.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4083 y.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4084
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4085 nd.pop() # pop the current view
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4086 self.assertEqual(x.tolist(), nd.tolist())
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4087
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4088 del nd
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4089 m1.release()
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4090 x.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 # 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	4093 # 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	4094 # work.
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4095 def catch22(b):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4096 with memoryview(b) as m2:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4097 pass
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 x = bytearray(b'123')
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4100 with memoryview(x) as m1:
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4101 catch22(m1)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4102 self.assertEqual(m1[0], ord(b'1'))
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4103
75409 f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4104 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	4105 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	4106 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	4107 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	4108 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	4109 catch22(m)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4110 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	4111
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4112 # Test garbage collection.
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4113 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	4114 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	4115 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	4116 del x
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4117 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	4118 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	4119 del y
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4120 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	4121 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	4122 del z
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4123 catch22(m3)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4124 catch22(m2)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4125 catch22(m1)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4126 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	4127 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	4128 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	4129 del m3
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4130 del m2
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4131 del m1
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4132
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4133 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	4134 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	4135 del x
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4136 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	4137 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	4138 del y
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4139 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	4140 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	4141 del z
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4142 catch22(m1)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4143 catch22(m2)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4144 catch22(m3)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4145 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	4146 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	4147 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	4148 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	4149
75414 373f6cdc6d08 Issue #10181: The decision was to raise a buffer error in memory_exit() Stefan Krah <skrah@bytereef.org> parents: 75409 diff changeset	4150 # 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	4151 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	4152 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	4153 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	4154 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	4155 m[0] == ord(b'1')
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4156
75409 f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4157 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	4158
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4159 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	4160 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	4161
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4162 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	4163 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	4164 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	4165 m = memoryview(z)
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4166
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4167 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	4168 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	4169 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	4170
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4171 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	4172 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	4173 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	4174
f1441971b621 Issue #14181: Allow memoryview construction from an object that uses the Stefan Krah <skrah@bytereef.org> parents: 75254 diff changeset	4175 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	4176 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	4177 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	4178 del y, z
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[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	4180
75420 3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4181 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	4182
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4183 fmt = 'B'
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4184 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	4185
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4186 # exceptions
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4187 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	4188
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4189 # view.obj==x
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4190 x = staticarray()
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4191 y = memoryview(x)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4192 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	4193 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	4194 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	4195 lst=lst)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4196 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	4197 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	4198 del x
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4199 del y
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4200
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4201 x = staticarray()
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4202 y = memoryview(x)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4203 del y
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4204 del x
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4205
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4206 x = staticarray()
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4207 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	4208 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	4209 m = memoryview(z)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4210 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	4211 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	4212 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	4213 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	4214 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	4215 lst=lst)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4216 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	4217
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4218 x = staticarray()
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4219 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	4220 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	4221 m = memoryview(z)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4222 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	4223 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	4224 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	4225 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	4226 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	4227 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	4228 lst=lst)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4229 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	4230
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4231 # view.obj==NULL
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4232 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	4233 y = memoryview(x)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4234 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	4235 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	4236 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	4237 lst=lst)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4238 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	4239 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	4240 del x
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4241 del y
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4242
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4243 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	4244 y = memoryview(x)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4245 del y
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4246 del x
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4247
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4248 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	4249 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	4250 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	4251 m = memoryview(z)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4252 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	4253 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	4254 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	4255 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	4256 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	4257 lst=lst)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4258 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	4259
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4260 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	4261 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	4262 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	4263 m = memoryview(z)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4264 # 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	4265 # 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	4266 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	4267 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	4268 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	4269 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	4270 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	4271 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	4272 lst=lst)
3a1f7c9f0b25 Issue #14181: Test creating memoryviews from a static exporter with both Stefan Krah <skrah@bytereef.org> parents: 75414 diff changeset	4273 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	4274
75440 9f7d06a9eabe Issue #14181: Preserve backwards compatibility for getbufferprocs that a) do Stefan Krah <skrah@bytereef.org> parents: 75420 diff changeset	4275 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	4276
9f7d06a9eabe Issue #14181: Preserve backwards compatibility for getbufferprocs that a) do Stefan Krah <skrah@bytereef.org> parents: 75420 diff changeset	4277 # 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	4278 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	4279 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	4280
75254 3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4281 def test_issue_7385(self):
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4282 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	4283 self.assertRaises(BufferError, memoryview, x)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4284
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4285
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4286 def test_main():
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4287 support.run_unittest(TestBufferProtocol)
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4288
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4289
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4290 if __name__ == "__main__":
3f9b3b6f7ff0 - Issue #10181: New memoryview implementation fixes multiple ownership Stefan Krah <skrah@bytereef.org> parents: diff changeset	4291 test_main()

Mercurial > cpython-lru_cache-weakref

annotate Lib/test/test_buffer.py @ 81343:3a7cd8efc19f