/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.lang.invoke.WrongMethodTypeException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
public class VarHandleBadCoordinateTests {
public static class FieldCoordinateTypeTest extends VarHandleUnitTest {
private static final VarHandle vh;
public static class A {
public byte field;
}
public static class B extends A {
private byte other_field;
}
public static class C {}
static {
try {
vh = MethodHandles.lookup().findVarHandle(A.class, "field", byte.class);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
protected void doTest() {
vh.compareAndSet(new A(), (byte) 0, (byte) 3);
vh.compareAndSet(new B(), (byte) 0, (byte) 3);
try {
vh.compareAndSet(new C(), (byte) 0, (byte) 3);
failUnreachable();
} catch (ClassCastException ex) {
}
try {
vh.compareAndSet(0xbad0bad0, (byte) 0, (byte) 3);
failUnreachable();
} catch (WrongMethodTypeException ex) {
}
try {
vh.compareAndSet(0xbad0bad0, (byte) 0, Integer.MAX_VALUE);
failUnreachable();
} catch (WrongMethodTypeException ex) {
}
try {
vh.compareAndSet(0xbad0bad0, (byte) 0);
failUnreachable();
} catch (WrongMethodTypeException ex) {
}
try {
vh.compareAndSet(new A(), (byte) 0, Integer.MAX_VALUE);
failUnreachable();
} catch (WrongMethodTypeException ex) {
}
try {
vh.compareAndSet((A) null, (byte) 0, (byte) 3);
failUnreachable();
} catch (NullPointerException ex) {
}
}
public static void main(String[] args) {
new FieldCoordinateTypeTest().run();
}
}
public static class ArrayElementOutOfBoundsIndexTest extends VarHandleUnitTest {
private static final VarHandle vh;
static {
try {
vh = MethodHandles.arrayElementVarHandle(long[].class);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
protected void doTest() {
long[] values = new long[33];
try {
vh.get(values, -1);
failUnreachable();
} catch (ArrayIndexOutOfBoundsException ex) {
}
try {
vh.get(values, values.length);
failUnreachable();
} catch (ArrayIndexOutOfBoundsException ex) {
}
try {
vh.get(values, Integer.MAX_VALUE - 1);
failUnreachable();
} catch (ArrayIndexOutOfBoundsException ex) {
}
}
public static void main(String[] args) {
new ArrayElementOutOfBoundsIndexTest().run();
}
}
public static class ArrayElementBadIndexTypeTest extends VarHandleUnitTest {
private static final VarHandle vh;
static {
try {
vh = MethodHandles.arrayElementVarHandle(long[].class);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
protected void doTest() {
long[] values = new long[33];
vh.set(values, Integer.valueOf(3), Long.MIN_VALUE);
vh.set(values, Byte.valueOf((byte) 0), Long.MIN_VALUE);
try {
vh.set(values, 3.3f, Long.MAX_VALUE);
failUnreachable();
} catch (WrongMethodTypeException ex) {
}
}
public static void main(String[] args) {
new ArrayElementBadIndexTypeTest().run();
}
}
public static class ArrayElementNullArrayTest extends VarHandleUnitTest {
private static final VarHandle vh;
static {
try {
vh = MethodHandles.arrayElementVarHandle(long[].class);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
protected void doTest() {
long[] values = null;
try {
vh.get(values);
failUnreachable();
} catch (WrongMethodTypeException ex) {
}
}
public static void main(String[] args) {
new ArrayElementNullArrayTest().run();
}
}
public static class ArrayElementWrongArrayTypeTest extends VarHandleUnitTest {
private static final VarHandle vh;
static {
try {
vh = MethodHandles.arrayElementVarHandle(long[].class);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
protected void doTest() {
try {
vh.get(new char[10], 0);
failUnreachable();
} catch (ClassCastException ex) {
}
}
public static void main(String[] args) {
new ArrayElementWrongArrayTypeTest().run();
}
}
public static class ArrayElementMissingIndexTest extends VarHandleUnitTest {
private static final VarHandle vh;
static {
try {
vh = MethodHandles.arrayElementVarHandle(long[].class);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
protected void doTest() {
long[] values = new long[33];
try {
vh.get(values);
failUnreachable();
} catch (WrongMethodTypeException ex) {
}
}
public static void main(String[] args) {
new ArrayElementMissingIndexTest().run();
}
}
public static class ByteArrayViewOutOfBoundsIndexTest extends VarHandleUnitTest {
private static final VarHandle vh;
static {
try {
vh = MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.BIG_ENDIAN);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
protected void doTest() {
byte[] bytes = new byte[16];
try {
vh.get(bytes, -1);
failUnreachable();
} catch (IndexOutOfBoundsException ex) {
}
try {
vh.get(bytes, bytes.length);
failUnreachable();
} catch (IndexOutOfBoundsException ex) {
}
try {
vh.get(bytes, Integer.MAX_VALUE - 1);
failUnreachable();
} catch (IndexOutOfBoundsException ex) {
}
try {
vh.get(bytes, bytes.length - Integer.SIZE / 8 + 1);
failUnreachable();
} catch (IndexOutOfBoundsException ex) {
}
vh.get(bytes, bytes.length - Integer.SIZE / 8);
}
public static void main(String[] args) {
new ByteArrayViewOutOfBoundsIndexTest().run();
}
}
public static class ByteArrayViewUnalignedAccessesIndexTest extends VarHandleUnitTest {
private static final VarHandle vh;
static {
try {
vh = MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.BIG_ENDIAN);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
protected void doTest() {
byte[] bytes = new byte[33];
int alignedIndex = VarHandleUnitTestHelpers.alignedOffset_int(bytes, 0);
for (int i = alignedIndex; i < Integer.SIZE / 8; ++i) {
// No exceptions are expected for GET and SET
// accessors irrespective of the access alignment.
vh.set(bytes, i, 380);
vh.get(bytes, i);
// Other accessors raise an IllegalStateException if
// the access is unaligned.
try {
vh.compareAndExchange(bytes, i, 777, 320);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.compareAndExchangeAcquire(bytes, i, 320, 767);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.compareAndExchangeRelease(bytes, i, 767, 321);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.compareAndSet(bytes, i, 767, 321);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAcquire(bytes, i);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndAdd(bytes, i, 117);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndAddAcquire(bytes, i, 117);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndAddRelease(bytes, i, 117);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseAnd(bytes, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseAndAcquire(bytes, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseAndRelease(bytes, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseOr(bytes, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseOrAcquire(bytes, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseOrRelease(bytes, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseXor(bytes, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseXorAcquire(bytes, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseXorRelease(bytes, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndSet(bytes, i, 117);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndSetAcquire(bytes, i, 117);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndSetRelease(bytes, i, 117);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getOpaque(bytes, i);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getVolatile(bytes, i);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.setOpaque(bytes, i, 777);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.setRelease(bytes, i, 319);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.setVolatile(bytes, i, 787);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.weakCompareAndSet(bytes, i, 787, 340);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.weakCompareAndSetAcquire(bytes, i, 787, 340);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.weakCompareAndSetPlain(bytes, i, 787, 340);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.weakCompareAndSetRelease(bytes, i, 787, 340);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
}
}
public static void main(String[] args) {
new ByteArrayViewUnalignedAccessesIndexTest().run();
}
}
public static class ByteArrayViewBadIndexTypeTest extends VarHandleUnitTest {
private static final VarHandle vh;
static {
try {
vh = MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
protected void doTest() {
byte[] bytes = new byte[16];
// Boxed index goes through argument conversion so no exception expected.
vh.get(bytes, Integer.valueOf(3));
vh.get(bytes, Short.valueOf((short) 3));
try {
vh.get(bytes, System.out);
failUnreachable();
} catch (WrongMethodTypeException ex) {
}
}
public static void main(String[] args) {
new ByteArrayViewBadIndexTypeTest().run();
}
}
public static class ByteArrayViewMissingIndexTest extends VarHandleUnitTest {
private static final VarHandle vh;
static {
try {
vh = MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
protected void doTest() {
byte[] bytes = new byte[16];
try {
vh.get(bytes);
failUnreachable();
} catch (WrongMethodTypeException ex) {
}
}
public static void main(String[] args) {
new ByteArrayViewMissingIndexTest().run();
}
}
public static class ByteArrayViewBadByteArrayTest extends VarHandleUnitTest {
private static final VarHandle vh;
static {
try {
vh = MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
protected void doTest() {
byte[] bytes = null;
try {
vh.get(bytes, Integer.valueOf(3));
failUnreachable();
} catch (NullPointerException ex) {
}
try {
vh.get(System.err, Integer.valueOf(3));
failUnreachable();
} catch (ClassCastException ex) {
}
}
public static void main(String[] args) {
new ByteArrayViewBadByteArrayTest().run();
}
}
public static class ByteBufferViewOutOfBoundsIndexTest extends VarHandleUnitTest {
private static final VarHandle vh;
static {
try {
vh = MethodHandles.byteBufferViewVarHandle(float[].class, ByteOrder.LITTLE_ENDIAN);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
protected void doTest() {
ByteBuffer[] buffers =
new ByteBuffer[] {
ByteBuffer.allocateDirect(16),
ByteBuffer.allocate(37),
ByteBuffer.wrap(new byte[27], 3, 27 - 3)
};
for (ByteBuffer buffer : buffers) {
try {
vh.get(buffer, -1);
failUnreachable();
} catch (IndexOutOfBoundsException ex) {
}
try {
vh.get(buffer, buffer.limit());
failUnreachable();
} catch (IndexOutOfBoundsException ex) {
}
try {
vh.get(buffer, Integer.MAX_VALUE - 1);
failUnreachable();
} catch (IndexOutOfBoundsException ex) {
}
try {
vh.get(buffer, buffer.limit() - Integer.SIZE / 8 + 1);
failUnreachable();
} catch (IndexOutOfBoundsException ex) {
}
vh.get(buffer, buffer.limit() - Integer.SIZE / 8);
}
}
public static void main(String[] args) {
new ByteBufferViewOutOfBoundsIndexTest().run();
}
}
public static class ByteBufferViewUnalignedAccessesIndexTest extends VarHandleUnitTest {
private static final VarHandle vh;
static {
try {
vh = MethodHandles.byteBufferViewVarHandle(int[].class, ByteOrder.BIG_ENDIAN);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
protected void doTest() {
ByteBuffer[] buffers =
new ByteBuffer[] {
ByteBuffer.allocateDirect(16),
ByteBuffer.allocate(37),
ByteBuffer.wrap(new byte[27], 3, 27 - 3)
};
for (ByteBuffer buffer : buffers) {
int alignedIndex = VarHandleUnitTestHelpers.alignedOffset_int(buffer, 0);
for (int i = alignedIndex; i < Integer.SIZE / 8; ++i) {
// No exceptions are expected for GET and SET
// accessors irrespective of the access alignment.
vh.set(buffer, i, 380);
vh.get(buffer, i);
// Other accessors raise an IllegalStateException if
// the access is unaligned.
try {
vh.compareAndExchange(buffer, i, 777, 320);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.compareAndExchangeAcquire(buffer, i, 320, 767);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.compareAndExchangeRelease(buffer, i, 767, 321);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.compareAndSet(buffer, i, 767, 321);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAcquire(buffer, i);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndAdd(buffer, i, 117);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndAddAcquire(buffer, i, 117);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndAddRelease(buffer, i, 117);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseAnd(buffer, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseAndAcquire(buffer, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseAndRelease(buffer, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseOr(buffer, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseOrAcquire(buffer, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseOrRelease(buffer, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseXor(buffer, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseXorAcquire(buffer, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndBitwiseXorRelease(buffer, i, 118);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndSet(buffer, i, 117);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndSetAcquire(buffer, i, 117);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getAndSetRelease(buffer, i, 117);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getOpaque(buffer, i);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.getVolatile(buffer, i);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.setOpaque(buffer, i, 777);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.setRelease(buffer, i, 319);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.setVolatile(buffer, i, 787);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.weakCompareAndSet(buffer, i, 787, 340);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.weakCompareAndSetAcquire(buffer, i, 787, 340);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.weakCompareAndSetPlain(buffer, i, 787, 340);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
try {
vh.weakCompareAndSetRelease(buffer, i, 787, 340);
assertTrue(i == alignedIndex);
} catch (IllegalStateException ex) {
assertFalse(i == alignedIndex);
}
}
}
}
public static void main(String[] args) {
new ByteBufferViewUnalignedAccessesIndexTest().run();
}
}
public static class ByteBufferViewBadIndexTypeTest extends VarHandleUnitTest {
private static final VarHandle vh;
static {
try {
vh = MethodHandles.byteBufferViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
protected void doTest() {
ByteBuffer[] buffers =
new ByteBuffer[] {
ByteBuffer.allocateDirect(16),
ByteBuffer.allocate(16),
ByteBuffer.wrap(new byte[32], 4, 32 - 4)
};
for (ByteBuffer buffer : buffers) {
// Boxed index goes through argument conversion so no exception expected.
vh.get(buffer, Integer.valueOf(3));
vh.get(buffer, Short.valueOf((short) 3));
vh.get(buffer, Byte.valueOf((byte) 7));
try {
vh.get(buffer, System.out);
failUnreachable();
} catch (WrongMethodTypeException ex) {
}
}
}
public static void main(String[] args) {
new ByteBufferViewBadIndexTypeTest().run();
}
}
public static class ByteBufferViewMissingIndexTest extends VarHandleUnitTest {
private static final VarHandle vh;
static {
try {
vh = MethodHandles.byteBufferViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
protected void doTest() {
ByteBuffer[] buffers =
new ByteBuffer[] {
ByteBuffer.allocateDirect(16),
ByteBuffer.allocate(16),
ByteBuffer.wrap(new byte[32], 4, 32 - 4)
};
for (ByteBuffer buffer : buffers) {
try {
vh.get(buffer);
failUnreachable();
} catch (WrongMethodTypeException ex) {
}
}
}
public static void main(String[] args) {
new ByteBufferViewMissingIndexTest().run();
}
}
public static class ByteBufferViewBadByteBufferTest extends VarHandleUnitTest {
private static final VarHandle vh;
static {
try {
vh = MethodHandles.byteBufferViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
protected void doTest() {
if (VarHandleUnitTestHelpers.isRunningOnAndroid()) {
ByteBuffer buffer = null;
// The RI does not like this test
try {
vh.get(buffer, 3);
failUnreachable();
} catch (NullPointerException ex) {
}
}
try {
vh.get(System.err, 3);
failUnreachable();
} catch (ClassCastException ex) {
}
}
public static void main(String[] args) {
new ByteBufferViewBadByteBufferTest().run();
}
}
public static void main(String[] args) {
FieldCoordinateTypeTest.main(args);
ArrayElementOutOfBoundsIndexTest.main(args);
ArrayElementBadIndexTypeTest.main(args);
ArrayElementNullArrayTest.main(args);
ArrayElementWrongArrayTypeTest.main(args);
ArrayElementMissingIndexTest.main(args);
ByteArrayViewOutOfBoundsIndexTest.main(args);
ByteArrayViewUnalignedAccessesIndexTest.main(args);
ByteArrayViewBadIndexTypeTest.main(args);
ByteArrayViewMissingIndexTest.main(args);
ByteArrayViewBadByteArrayTest.main(args);
ByteBufferViewOutOfBoundsIndexTest.main(args);
ByteBufferViewUnalignedAccessesIndexTest.main(args);
ByteBufferViewBadIndexTypeTest.main(args);
ByteBufferViewMissingIndexTest.main(args);
ByteBufferViewBadByteBufferTest.main(args);
}
}