/** Control amount of output. Instance variable so can be adjusted temporarily in test. */

protected int verbosity = 0;

/**

public PyBufferTest(String name) {

super(name);

}

/** Sometimes we need the interpreter to be initialised **/

PythonInterpreter interp;

/*

private static final ByteMaterial byteMaterial = new ByteMaterial(0, 16, 17);

private static final ByteMaterial abcMaterial = new ByteMaterial("abcdefgh");

private static final ByteMaterial stringMaterial = new ByteMaterial("Mon côté fâcheux");

private static final ByteMaterial emptyMaterial = new ByteMaterial(new byte[0]);

public static final int LONG = 1000;

private static final ByteMaterial longMaterial = new ByteMaterial(0, LONG, 5);

@Override

protected void setUp() throws Exception {

super.setUp();

// Exception raising requires the Jython interpreter

interp = new PythonInterpreter();

// Tests using local types of exporter

genWritable(new SimpleWritableExporter(abcMaterial.getBytes()), abcMaterial);

genReadonly(new SimpleExporter(byteMaterial.getBytes()), byteMaterial);

genReadonly(new StringExporter(stringMaterial.string), stringMaterial);

genWritable(new SimpleWritableExporter(emptyMaterial.getBytes()), emptyMaterial);

// Tests with PyByteArray

genWritable(new PyByteArray(abcMaterial.getBytes()), abcMaterial);

genWritable(new PyByteArray(longMaterial.getBytes()), longMaterial);

genWritable(new PyByteArray(), emptyMaterial);

// Tests with PyBytes

genReadonly(new PyBytes(abcMaterial.string), abcMaterial);

genReadonly(new PyBytes(), emptyMaterial);

// Ensure case is tested where PyByteArray has an internal offset

PyByteArray truncated = new PyByteArray(stringMaterial.getBytes());

truncated.delRange(0, 4);

ByteMaterial truncatedMaterial = new ByteMaterial(stringMaterial.string.substring(4));

assert truncated.__alloc__() > truncatedMaterial.length;

genWritable(truncated, truncatedMaterial);

}

/** Generate a series of test material for a writable object. */

private void genWritable(BufferProtocol exporter, ByteMaterial material) {

generate(exporter, material, false);

}

/** Generate a series of test material for a read-only object. */

private void genReadonly(BufferProtocol exporter, ByteMaterial material) {

generate(exporter, material, true);

}

/** Lengths we will use if we can when slicing view */

private static final int[] sliceLengths = {1, 2, 5, 0, LONG / 4};

/** Step sizes we will use if we can when slicing view */

private static final int[] sliceSteps = {1, 2, 3, 7};

/**

private void generate(BufferProtocol exporter, ByteMaterial material, boolean readonly) {

// Generate a test using the buffer directly exported by the exporter

PyBuffer direct = queue(exporter, material, readonly);

// Generate some slices from the material and this direct view

int N = material.length;

int M = (N + 4) / 4; // At least one and about N/4

// For a range of start positions up to one beyond the end

for (int start = 0; start <= N; start += M) {

// For a range of lengths

for (int length : sliceLengths) {

if (length == 0) {

queue(direct, material, start, 0, 1, readonly);

queue(direct, material, start, 0, 2, readonly);

} else if (length == 1 && start < N) {

queue(direct, material, start, 1, 1, readonly);

queue(direct, material, start, 1, 2, readonly);

} else if (start < N) {

// And for a range of step sizes

for (int step : sliceSteps) {

// Check this is a feasible slice

if (start + (length - 1) * step < N) {

queue(direct, material, start, length, step, readonly);

}

}

// Now use all the step sizes negatively

for (int step : sliceSteps) {

// Check this is a feasible slice

if (start - (length - 1) * step >= 0) {

queue(direct, material, start, length, -step, readonly);

}

}

}

}

}

}

/** Generate and queue one test of non-slice type (if getting a buffer succeeds). */

private PyBuffer queue(BufferProtocol exporter, ByteMaterial material, boolean readonly) {

if (verbosity > 2) {

System.out.printf("queue non-slice: length=%d, readonly=%s\n", material.length,

readonly);

}

BufferTestPair pair = new BufferTestPair(exporter, material, readonly);

queue(pair);

return pair.view;

}

/** Generate and queue one test of slice type (if getting a buffer succeeds). */

private PyBuffer queue(PyBuffer direct, ByteMaterial material, int start, int length, int step,

boolean readonly) {

int flags = readonly ? PyBUF.FULL_RO : PyBUF.FULL;

PyBuffer subject = null;

/*

try {

if (verbosity > 2) {

System.out.printf(" queue slice: start=%4d, length=%4d, step=%4d\n", start,

length, step);

}

subject = direct.getBufferSlice(flags, start, length, step);

ByteMaterial sliceMaterial = material.slice(start, length, step);

BufferTestPair pair = new BufferTestPair(subject, sliceMaterial, step, readonly);

queue(pair);

} catch (Exception e) {

/*

if (verbosity > 2) {

System.out.printf("*** SKIP %s\n", e);

}

}

return subject;

}

/** Queue one instance of test material for a read-only or writable object. */

private void queue(BufferTestPair pair) {

buffersToRead.add(pair);

if (pair.readonly) {

buffersToFailToWrite.add(pair);

} else {

buffersToWrite.add(pair);

}

}

/** Read operations should succeed on all these objects. */

private List<BufferTestPair> buffersToRead = new LinkedList<BufferTestPair>();

/** Write operations should succeed on all these objects. */

private List<BufferTestPair> buffersToWrite = new LinkedList<BufferTestPair>();

/** Write operations should fail on all these objects. */

private List<BufferTestPair> buffersToFailToWrite = new LinkedList<BufferTestPair>();

/**

private static final int[] simpleFlags = {PyBUF.SIMPLE, PyBUF.ND, PyBUF.STRIDES,

PyBUF.INDIRECT, PyBUF.FULL_RO};

/** To {@link #simpleFlags} we can add any of these */

private static final int[] simpleTassles = {0, PyBUF.FORMAT, PyBUF.C_CONTIGUOUS,

PyBUF.F_CONTIGUOUS, PyBUF.ANY_CONTIGUOUS};

/**

private static final int[] strided1DFlags = {PyBUF.STRIDES, PyBUF.INDIRECT, PyBUF.FULL_RO};

/** To {@link #strided1DFlags} we can add any of these */

private static final int[] strided1DTassles = {0, PyBUF.FORMAT};

/**

public void testIsReadonly() {

for (BufferTestPair test : buffersToWrite) {

if (verbosity > 0) {

System.out.println("isReadonly: " + test);

}

assertFalse(test.view.isReadonly());

}

for (BufferTestPair test : buffersToFailToWrite) {

if (verbosity > 0) {

System.out.println("isReadonly: " + test);

}

assertTrue(test.view.isReadonly());

}

}

/**

public void testGetNdim() {

for (BufferTestPair test : buffersToRead) {

if (verbosity > 0) {

System.out.println("getNdim: " + test);

}

assertEquals("unexpected ndim", test.shape.length, test.view.getNdim());

}

}

/**

public void testGetShape() {

for (BufferTestPair test : buffersToRead) {

if (verbosity > 0) {

System.out.println("getShape: " + test);

}

int[] shape = test.view.getShape();

assertNotNull("shape[] should always be provided", shape);

assertIntsEqual("unexpected shape", test.shape, shape);

}

}

/**

public void testGetLen() {

for (BufferTestPair test : buffersToRead) {

if (verbosity > 0) {

System.out.println("getLen: " + test);

}

assertEquals("unexpected length", test.material.length, test.view.getLen());

}

}

/**

public void testByteAt() {

for (BufferTestPair test : buffersToRead) {

if (verbosity > 0) {

System.out.println("byteAt: " + test);

}

int n = test.material.length;

byte[] exp = test.material.bytes;

for (int i = 0; i < n; i++) {

assertEquals(exp[i], test.view.byteAt(i));

}

}

}

/**

public void testByteAtNdim() {

int[] index = new int[1];

for (BufferTestPair test : buffersToRead) {

if (verbosity > 0) {

System.out.println("byteAt(array): " + test);

}

if (test.view.getShape().length != 1) {

fail("Test not implemented if dimensions != 1");

}

byte[] exp = test.material.bytes;

int n = test.material.length;

// Run through 1D index for view

for (int i = 0; i < n; i++) {

index[0] = i;

assertEquals(exp[i], test.view.byteAt(index));

}

// Check 2D index throws

try {

test.view.byteAt(0, 0);

fail("Use of 2D index did not raise exception");

} catch (PyException pye) {

// Expect BufferError

assertEquals(Py.BufferError, pye.type);

}

}

}

/**

public void testIntAt() {

for (BufferTestPair test : buffersToRead) {

if (verbosity > 0) {

System.out.println("intAt: " + test);

}

int n = test.material.length;

int[] exp = test.material.ints;

for (int i = 0; i < n; i++) {

assertEquals(exp[i], test.view.intAt(i));

}

}

}

/**

public void testIntAtNdim() {

int[] index = new int[1];

for (BufferTestPair test : buffersToRead) {

if (verbosity > 0) {

System.out.println("intAt(array): " + test);

}

if (test.view.getShape().length != 1) {

fail("Test not implemented for dimensions != 1");

}

int[] exp = test.material.ints;

int n = test.material.length;

// Run through 1D index for view

for (int i = 0; i < n; i++) {

index[0] = i;

assertEquals(exp[i], test.view.intAt(index));

}

// Check 2D index throws

try {

test.view.intAt(0, 0);

fail("Use of 2D index did not raise exception");

} catch (PyException pye) {

// Expect BufferError

assertEquals(Py.BufferError, pye.type);

}

}

}

/**

public void testStoreAt() {

for (BufferTestPair test : buffersToWrite) {

if (verbosity > 0) {

System.out.println("storeAt: " + test);

}

int n = test.material.length;

int[] exp = test.material.ints;

// Write modified test material into each location using storeAt()

for (int i = 0; i < n; i++) {

byte v = (byte)(exp[i] ^ 3); // twiddle some bits

test.view.storeAt(v, i);

}

// Compare each location with modified test data using intAt()

for (int i = 0; i < n; i++) {

assertEquals(exp[i] ^ 3, test.view.intAt(i));

}

}

}

/**

public void testStoreAtNdim() {

for (BufferTestPair test : buffersToWrite) {

if (verbosity > 0) {

System.out.println("storeAt: " + test);

}

int n = test.material.length;

int[] exp = test.material.ints;

// Write modified test material into each location using storeAt()

for (int i = 0; i < n; i++) {

byte v = (byte)(exp[i] ^ 3); // twiddle some bits

test.view.storeAt(v, i);

}

// Compare each location with modified test data using intAt()

for (int i = 0; i < n; i++) {

assertEquals(exp[i] ^ 3, test.view.intAt(i));

}

// Check 2D index throws

try {

test.view.storeAt((byte)1, 0, 0);

fail("Use of 2D index did not raise exception");

} catch (PyException pye) {

// Expect BufferError

assertEquals(Py.BufferError, pye.type);

}

}

}

/**

public void testCopyTo() {

final int OFFSET = 5;

for (BufferTestPair test : buffersToRead) {

if (verbosity > 0) {

System.out.println("copyTo: " + test);

}

int n = test.material.length;

// Try with zero offset

byte[] actual = new byte[n];

test.view.copyTo(actual, 0);

assertBytesEqual("copyTo() incorrect", test.material.bytes, actual, 0);

// Try to middle of array

actual = new byte[n + 2 * OFFSET];

test.view.copyTo(actual, OFFSET);

assertBytesEqual("copyTo(offset) incorrect", test.material.bytes, actual, OFFSET);

assertEquals("data before destination", 0, actual[OFFSET - 1]);

assertEquals("data after destination", 0, actual[OFFSET + n]);

}

}

/**

public void testSliceCopyTo() {

final int OFFSET = 5;

final byte BLANK = 7;

for (BufferTestPair test : buffersToRead) {

if (verbosity > 0) {

System.out.println("copyTo(from slice): " + test);

}

PyBuffer view = test.view;

int n = test.material.length;

byte[] actual = new byte[n + 2 * OFFSET];

// Try destination positions in actual[] of 0 and OFFSET

for (int destPos = 0; destPos <= OFFSET; destPos += OFFSET) {

// Try source positions in 0 and OFFSET

for (int srcIndex = 0; srcIndex <= OFFSET; srcIndex += OFFSET) {

// A variety of lengths from zero to (n-srcIndex)-ish

for (int length = 0; srcIndex + length <= n; length = 2 * length + 1) {

if (verbosity > 1) {

System.out.printf(" copy src[%d:%d] (%d) to dst[%d:%d] (%d)\n",

srcIndex, srcIndex + length, n, destPos, destPos + length,

actual.length);

}

Arrays.fill(actual, BLANK);

// Test the method

view.copyTo(srcIndex, actual, destPos, length);

// Check changed part of destination

assertBytesEqual("copyTo(slice) incorrect", test.material.bytes, srcIndex,

length, actual, destPos);

if (destPos > 0) {

assertEquals("data before destination", BLANK, actual[destPos - 1]);

}

assertEquals("data after destination", BLANK, actual[destPos + length]);

}

// And from exactly n-srcIndex down to zero-ish

for (int trim = 0; srcIndex + trim <= n; trim = 2 * trim + 1) {

int length = n - srcIndex - trim;

if (verbosity > 1) {

System.out.printf(" copy src[%d:%d] (%d) to dst[%d:%d] (%d)\n",

srcIndex, srcIndex + length, n, destPos, destPos + length,

actual.length);

}

Arrays.fill(actual, BLANK);

// Test the method

view.copyTo(srcIndex, actual, destPos, length);

// Check changed part of destination

assertBytesEqual("copyTo(slice) incorrect", test.material.bytes, srcIndex,

length, actual, destPos);

if (destPos > 0) {

assertEquals("data before destination", BLANK, actual[destPos - 1]);

}

assertEquals("data after destination", BLANK, actual[destPos + length]);

}

}

}

}

}

/**

public void testCopyFrom() {

final int OFFSET = 5;

final byte BLANK = 7;

for (BufferTestPair test : buffersToWrite) {

if (verbosity > 0) {

System.out.println("copyFrom(): " + test);

}

PyBuffer view = test.view;

int n = test.material.length;

byte[] actual = new byte[n];

byte[] expected = new byte[n];

// Make some source material for copies (need to test at OFFSET too).

byte[] src = new byte[n + OFFSET];

for (int i = 0; i < src.length; i++) {

src[i] = (byte)i;

}

// Try destination positions in test object of 0 and OFFSET

for (int destIndex = 0; destIndex <= OFFSET; destIndex += OFFSET) {

// Try source positions in 0 and OFFSET

for (int srcPos = 0; srcPos <= OFFSET; srcPos += OFFSET) {

// A variety of lengths from zero to (n-destIndex)-ish

for (int length = 0; destIndex + length <= n; length = 2 * length + 1) {

if (verbosity > 1) {

System.out.printf(" copy src[%d:%d] (%d) to dst[%d:%d] (%d)\n",

srcPos, srcPos + length, n, destIndex, destIndex + length,

actual.length);

}

// Initialise the object (have to do each time) and expected value

for (int i = 0; i < n; i++) {

expected[i] = BLANK;

view.storeAt(BLANK, i);

}

// Test the method and extract the result to actual[]

view.copyFrom(src, srcPos, destIndex, length);

view.copyTo(actual, 0);

// Complete what is should be in expected[]

for (int i = 0; i < length; i++) {

expected[destIndex + i] = src[srcPos + i];

}

assertBytesEqual("copyFrom() incorrect", expected, actual, 0);

}

// And from exactly n-destIndex down to zero-ish

for (int trim = 0; destIndex + trim <= n; trim = 2 * trim + 1) {

int length = n - destIndex - trim;

if (verbosity > 1) {

System.out.printf(" copy src[%d:%d] (%d) to dst[%d:%d] (%d)\n",

srcPos, srcPos + length, n, destIndex, destIndex + length,

actual.length);

}

// Initialise the object (have to do each time) and expected value

for (int i = 0; i < n; i++) {

expected[i] = BLANK;

view.storeAt(BLANK, i);

}

// Test the method and extract the result to actual[]

view.copyFrom(src, srcPos, destIndex, length);

view.copyTo(actual, 0);

// Complete what is should be in expected[]

for (int i = 0; i < length; i++) {

expected[destIndex + i] = src[srcPos + i];

}

assertBytesEqual("copyFrom() incorrect", expected, actual, 0);

}

}

}

}

}

/**

public void testGetBuffer() {

for (BufferTestPair test : buffersToRead) {

if (verbosity > 0) {

System.out.println("getBuffer(): " + test);

}

for (int flags : test.validFlags) {

for (int tassle : test.validTassles) {

PyBuffer view = test.subject.getBuffer(flags | tassle);

assertNotNull(view);

}

}

}

for (BufferTestPair test : buffersToWrite) {

if (verbosity > 0) {

System.out.println("getBuffer(WRITABLE): " + test);

}

for (int flags : test.validFlags) {

for (int tassle : test.validTassles) {

PyBuffer view = test.subject.getBuffer(flags | tassle | PyBUF.WRITABLE);

assertNotNull(view);

}

}

}

for (BufferTestPair test : buffersToFailToWrite) {

if (verbosity > 0) {

System.out.println("getBuffer(WRITABLE): " + test);

}

for (int flags : test.validFlags) {

try {

test.subject.getBuffer(flags | PyBUF.WRITABLE);

fail("Write access not prevented: " + test);

} catch (PyException pye) {

// Expect BufferError

assertEquals(Py.BufferError, pye.type);

}

}

}

}

/**

public void testRelease() {

/*

Set<PyBuffer> uniqueBuffers = new HashSet<PyBuffer>();

// Test a balanced sequence of acquire and release using try-with-resources

for (BufferTestPair test : buffersToRead) {

doTestTryWithResources(test);

}

// Now test a pattern of acquire and release with one more release than acquire

for (BufferTestPair test : buffersToRead) {

doTestRelease(test);

uniqueBuffers.add(test.view);

}

// All buffers are released: test that any further release is detected as an error.

for (PyBuffer view : uniqueBuffers) {

doTestOverRelease(view);

}

// All exporters are currently not exporting buffers

for (BufferTestPair test : buffersToRead) {

if (!(test.subject instanceof PyBuffer)) {

doTestGetAfterRelease(test);

}

}

}

/**

private void doTestTryWithResources(BufferTestPair test) {

if (verbosity > 0) {

System.out.println("try with resources: " + test);

}

int flags = PyBUF.STRIDES | PyBUF.FORMAT;

BufferProtocol sub = test.subject;

// The object will be exporting test.view and N other views we don't know about

try (PyBuffer c = sub.getBuffer(flags)) { // = N+1 exports

try (PyBuffer b = sub.getBuffer(PyBUF.FULL_RO); PyBuffer d =c.getBuffer(flags)) {

checkExporting(sub);// = N+3 exports

}

checkExporting(sub); // = N+1 exports

}

checkExporting(sub); // = N export

}

/**

private void doTestRelease(BufferTestPair test) {

if (verbosity > 0) {

System.out.println("release: " + test);

}

int flags = PyBUF.STRIDES | PyBUF.FORMAT;

BufferProtocol sub = test.subject;

// The object will be exporting test.view and N other views we don't know about

PyBuffer a = test.view; // = N+1 exports

PyBuffer b = sub.getBuffer(PyBUF.FULL_RO); // = N+2 export

PyBuffer c = sub.getBuffer(flags); // = N+3 exports

checkExporting(sub);

// Now see that releasing in some other order works correctly

b.release(); // = N+2 exports

a.release(); // = N+1 exports

checkExporting(sub);

// You can get a buffer from a buffer (c is unreleased)

PyBuffer d = c.getBuffer(flags); // = N+2 exports

c.release(); // = N+1 export

checkExporting(sub);

d.release(); // = N exports

}

/**

private void doTestOverRelease(PyBuffer view) {

// Was it released finally?

assertTrue("Buffer not finally released as expected", view.isReleased());

// Further releases are an error

try {

view.release(); // = -1 exports (oops)

fail("excess release not detected");

} catch (Exception e) {

// Success

}

}

/**

private void doTestGetAfterRelease(BufferTestPair test) {

if (verbosity > 0) {

System.out.println("get again: " + test);

}

BufferProtocol sub = test.subject;

// Fail here if doTestRelease did not fully release, or

checkNotExporting(sub);

// Further gets via the released buffer are an error

try {

test.view.getBuffer(PyBUF.FULL_RO);

fail("PyBuffer.getBuffer after final release not detected");

} catch (Exception e) {

// Detected *and* prevented?

checkNotExporting(sub);

}

// And so are sliced gets

try {

test.view.getBufferSlice(PyBUF.FULL_RO, 0, 0);

fail("PyBuffer.getBufferSlice after final release not detected");

} catch (Exception e) {

// Detected *and* prevented?

checkNotExporting(sub);

}

/*

PyBuffer b = sub.getBuffer(PyBUF.FULL_RO); // = 1 export

checkExporting(sub);

b.release(); // = 0 exports

checkNotExporting(sub);

}

/**

private void checkExporting(BufferProtocol subject) {

if (subject instanceof TestableExporter) {

assertTrue("exports not being counted", ((TestableExporter)subject).isExporting());

} else if (subject instanceof PyBuffer) {

assertFalse("exports not being counted (PyBuffer)", ((PyBuffer)subject).isReleased());

} else if (subject instanceof PyByteArray) {

// Size-changing access should fail

try {

((PyByteArray)subject).bytearray_extend(Py.One); // Appends one zero byte

fail("bytearray_extend with exports should fail");

} catch (Exception e) {

// Success

}

}

// Other types cannot be checked

}

/**

private void checkNotExporting(BufferProtocol subject) {

if (subject instanceof TestableExporter) {

assertFalse("exports counted incorrectly", ((TestableExporter)subject).isExporting());

} else if (subject instanceof PyBuffer) {

assertTrue("exports counted incorrectly (PyBuffer)", ((PyBuffer)subject).isReleased());

} else if (subject instanceof PyByteArray) {

// Size-changing access should succeed

try {

PyByteArray sub = ((PyByteArray)subject);

sub.bytearray_append(Py.Zero);

sub.del(sub.__len__() - 1);

} catch (Exception e) {

fail("bytearray unexpectedly locked");

}

}

// Other types cannot be checked

}

/**

public void testGetBufferSliceWithStride() {

for (BufferTestPair test : buffersToRead) {

if (verbosity > 0) {

System.out.println("getBufferSliceWithStride: " + test);

}

ByteMaterial material = test.material;

PyBuffer view = test.view;

boolean readonly = test.readonly;

// Generate some slices from the material and the test view

int N = material.length;

int M = (N + 4) / 4; // At least one and about N/4

// For a range of start positions up to one beyond the end

for (int start = 0; start <= N; start += M) {

// For a range of lengths

for (int length : sliceLengths) {

if (length == 0) {

checkSlice(view, material, start, 0, 1, readonly);

checkSlice(view, material, start, 0, 2, readonly);

} else if (length == 1 && start < N) {

checkSlice(view, material, start, 1, 1, readonly);

checkSlice(view, material, start, 1, 2, readonly);

} else if (start < N) {

// And for a range of step sizes

for (int step : sliceSteps) {

// Check this is a feasible slice

if (start + (length - 1) * step < N) {

checkSlice(view, material, start, length, step, readonly);

}

}

// Now use all the step sizes negatively

for (int step : sliceSteps) {

// Check this is a feasible slice

if (start - (length - 1) * step >= 0) {

checkSlice(view, material, start, length, -step, readonly);

}

}

}

}

}

}

}

/**

private void checkSlice(PyBuffer view, ByteMaterial material, int start, int length, int step,

boolean readonly) {

int flags = readonly ? PyBUF.FULL_RO : PyBUF.FULL;

if (verbosity > 1) {

System.out.printf(" checkSlice: start=%4d, length=%4d, step=%4d \n", start, length,

step);

}

byte[] expected = sliceBytes(material.bytes, start, length, step);

PyBuffer sliceView = view.getBufferSlice(flags, start, length, step);

byte[] result = bytesFromByteAt(sliceView);

assertBytesEqual(" testGetBufferSliceWithStride failure: ", expected, result);

}

/**

public void testGetBuf() {

for (BufferTestPair test : buffersToRead) {

if (verbosity > 0) {

System.out.println("getBuf: " + test);

}

int stride = test.strides[0];

if (stride == 1) {

// The client should not have to support navigation with the strides array

int flags = test.readonly ? PyBUF.SIMPLE : PyBUF.SIMPLE + PyBUF.WRITABLE;

PyBuffer view = test.subject.getBuffer(flags);

PyBuffer.Pointer bp = view.getBuf();

assertBytesEqual("buffer does not match reference", test.material.bytes, bp);

} else {

// The client will have to navigate with the strides array

int flags = test.readonly ? PyBUF.STRIDED_RO : PyBUF.STRIDED;

PyBuffer view = test.subject.getBuffer(flags);

stride = view.getStrides()[0]; // Just possibly != test.strides when length<=1

PyBuffer.Pointer bp = view.getBuf();

assertBytesEqual("buffer does not match reference", test.material.bytes, bp, stride);

}

}

}

/**

public void testGetPointer() {

for (BufferTestPair test : buffersToRead) {

if (verbosity > 0) {