/*
* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
import org.testng.annotations.BeforeClass;
import org.testng.annotations.DataProvider;
import java.lang.invoke.VarHandle;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.List;
import java.util.function.Function;
public abstract class VarHandleBaseByteArrayTest extends VarHandleBaseTest {
enum MemoryMode {
ALIGNED(0, false), UNALIGNED(0, true),
BIG_ENDIAN(1, false), LITTLE_ENDIAN(1, true),
READ_WRITE(2, false), READ_ONLY(2, true),;
final int bit;
final int value;
MemoryMode(int bit, boolean value) {
this.bit = bit;
this.value = value ? 1 << bit : 0;
}
boolean isSet(int bitSet) {
return (bitSet & (1 << bit)) == value;
}
static int bitSet(MemoryMode... modes) {
if (modes == null) return 0;
int set = 0;
for (MemoryMode m : modes) {
set = (set & ~(1 << m.bit)) | m.value;
}
return set;
}
static EnumSet<MemoryMode> enumSet(int bitSet) {
EnumSet<MemoryMode> es = EnumSet.noneOf(MemoryMode.class);
for (MemoryMode m : values()) {
if (m.isSet(bitSet)) {
es.add(m);
}
}
return es;
}
}
static class Source<T> {
final T s;
final int memoryModes;
public Source(T s, MemoryMode... modes) {
this.s = s;
memoryModes = MemoryMode.bitSet(modes);
}
@Override
public String toString() {
return s.getClass().getCanonicalName() + " " + MemoryMode.enumSet(memoryModes);
}
}
static abstract class ByteArrayViewSource<T> extends Source<T> {
public ByteArrayViewSource(T t, MemoryMode... modes) {
super(t, modes);
}
abstract void fill(byte value);
abstract void fill(byte[] values);
}
static class ByteArraySource extends ByteArrayViewSource<byte[]> {
public ByteArraySource(byte[] bytes, MemoryMode... modes) {
super(bytes, modes);
}
void fill(byte value) {
Arrays.fill(s, value);
}
void fill(byte[] values) {
for (int i = 0; i < s.length; i++) {
s[i] = values[i % values.length];
}
}
}
static class ByteBufferSource extends ByteArrayViewSource<ByteBuffer> {
public ByteBufferSource(ByteBuffer buffer, MemoryMode... modes) {
super(buffer, modes);
}
void fill(byte value) {
for (int i = 0; i < s.limit(); i++) {
s.put(i, value);
}
}
void fill(byte[] values) {
for (int i = 0; i < s.limit(); i++) {
s.put(i, values[i % values.length]);
}
}
@Override
public String toString() {
return s + " " + MemoryMode.enumSet(memoryModes);
}
}
static class ByteBufferReadOnlySource extends ByteBufferSource {
final ByteBuffer rwSource;
public ByteBufferReadOnlySource(ByteBuffer roBuffer, ByteBuffer rwSource, MemoryMode... modes) {
super(roBuffer, modes);
this.rwSource = rwSource;
}
void fill(byte value) {
for (int i = 0; i < rwSource.limit(); i++) {
rwSource.put(i, value);
}
}
void fill(byte[] values) {
for (int i = 0; i < rwSource.limit(); i++) {
rwSource.put(i, values[i % values.length]);
}
}
}
static class VarHandleSource extends Source<VarHandle> {
VarHandleSource(VarHandle vh, MemoryMode... modes) {
super(vh, modes);
}
boolean matches(ByteArrayViewSource<?> bav) {
return s.coordinateTypes().get(0).isAssignableFrom(bav.s.getClass());
}
@Override
public String toString() {
return " VarHandle " + MemoryMode.enumSet(memoryModes);
}
}
static class VarHandleSourceAccessTestCase extends AccessTestCase<VarHandleSource> {
final ByteArrayViewSource<?> bs;
final VarHandleSource vhs;
VarHandleSourceAccessTestCase(String desc, ByteArrayViewSource<?> bs, VarHandleSource vhs, AccessTestAction<VarHandleSource> ata) {
this(desc, bs, vhs, ata, true);
}
VarHandleSourceAccessTestCase(String desc, ByteArrayViewSource<?> bs, VarHandleSource vhs, AccessTestAction<VarHandleSource> ata, boolean loop) {
super(vhs + " -> " + bs + " " + desc, ata, loop);
this.bs = bs;
this.vhs = vhs;
}
@Override
VarHandleSource get() {
return vhs;
}
}
static double rotateLeft(double i, int distance) {
return Double.longBitsToDouble(
Long.rotateLeft(Double.doubleToRawLongBits(i), distance));
}
static double rotateRight(double i, int distance) {
return Double.longBitsToDouble(
Long.rotateRight(Double.doubleToRawLongBits(i), distance));
}
static float rotateLeft(float i, int distance) {
return Float.intBitsToFloat(
Integer.rotateLeft(Float.floatToRawIntBits(i), distance));
}
static float rotateRight(float i, int distance) {
return Float.intBitsToFloat(
Integer.rotateRight(Float.floatToRawIntBits(i), distance));
}
static long rotateLeft(long i, int distance) {
return Long.rotateLeft(i, distance);
}
static long rotateRight(long i, int distance) {
return Long.rotateRight(i, distance);
}
static int rotateLeft(int i, int distance) {
return Integer.rotateLeft(i, distance);
}
static int rotateRight(int i, int distance) {
return Integer.rotateRight(i, distance);
}
static short rotateLeft(short i, int distance) {
int v = (i << 16) | i;
v = Integer.rotateLeft(v, distance);
return (short) v;
}
static short rotateRight(short i, int distance) {
int v = (i << 16) | i;
v = Integer.rotateRight(v, distance);
return (short) v;
}
static char rotateLeft(char i, int distance) {
int v = (i << 16) | i;
v = Integer.rotateLeft(v, distance);
return (char) v;
}
static char rotateRight(char i, int distance) {
int v = (i << 16) | i;
v = Integer.rotateRight(v, distance);
return (char) v;
}
static final int LENGTH_BYTES = 32;
byte[] array;
List<ByteArrayViewSource<?>> bavss;
List<VarHandleSource> vhss;
public void setupByteSources() {
array = new byte[LENGTH_BYTES];
// Native endianess
MemoryMode ne = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN
? MemoryMode.BIG_ENDIAN : MemoryMode.LITTLE_ENDIAN;
bavss = new ArrayList<>();
// byte[] source
ByteArraySource a =
new ByteArraySource(array,
ne, MemoryMode.READ_WRITE);
bavss.add(a);
// Combinations of ByteBuffer sources
ByteBufferSource hbb =
new ByteBufferSource(ByteBuffer.wrap(array),
MemoryMode.ALIGNED, ne, MemoryMode.READ_WRITE);
bavss.add(hbb);
ByteBufferReadOnlySource hbb_ro =
new ByteBufferReadOnlySource(hbb.s.asReadOnlyBuffer(), hbb.s,
MemoryMode.ALIGNED, ne, MemoryMode.READ_ONLY);
bavss.add(hbb_ro);
ByteBufferSource hbb_offset_aligned =
new ByteBufferSource(ByteBuffer.wrap(array, array.length / 4, array.length / 2).slice(),
MemoryMode.ALIGNED, ne, MemoryMode.READ_WRITE);
bavss.add(hbb_offset_aligned);
ByteBufferReadOnlySource hbb_offset_aligned_ro =
new ByteBufferReadOnlySource(hbb_offset_aligned.s.asReadOnlyBuffer(), hbb_offset_aligned.s,
MemoryMode.ALIGNED, ne, MemoryMode.READ_ONLY);
bavss.add(hbb_offset_aligned_ro);
ByteBufferSource hbb_offset_unaligned =
new ByteBufferSource(ByteBuffer.wrap(array, array.length / 4 - 1, array.length / 2).slice(),
MemoryMode.UNALIGNED, ne, MemoryMode.READ_WRITE);
bavss.add(hbb_offset_unaligned);
ByteBufferReadOnlySource hbb_offset_unaligned_ro =
new ByteBufferReadOnlySource(hbb_offset_unaligned.s.asReadOnlyBuffer(), hbb_offset_unaligned.s,
MemoryMode.UNALIGNED, ne, MemoryMode.READ_ONLY);
bavss.add(hbb_offset_unaligned_ro);
ByteBufferSource dbb =
new ByteBufferSource(ByteBuffer.allocateDirect(array.length),
MemoryMode.ALIGNED, ne, MemoryMode.READ_WRITE);
bavss.add(dbb);
ByteBufferReadOnlySource dbb_ro =
new ByteBufferReadOnlySource(dbb.s.asReadOnlyBuffer(), dbb.s,
MemoryMode.ALIGNED, ne, MemoryMode.READ_ONLY);
bavss.add(dbb_ro);
ByteBufferSource dbb_offset_aligned =
new ByteBufferSource(dbb.s.slice().position(array.length / 4).limit(array.length / 4 + array.length / 2).slice(),
MemoryMode.ALIGNED, ne, MemoryMode.READ_WRITE);
bavss.add(dbb_offset_aligned);
ByteBufferReadOnlySource dbb_offset_aligned_ro =
new ByteBufferReadOnlySource(dbb_offset_aligned.s.asReadOnlyBuffer(), dbb_offset_aligned.s,
MemoryMode.ALIGNED, ne, MemoryMode.READ_ONLY);
bavss.add(dbb_offset_aligned_ro);
ByteBufferSource dbb_offset_unaligned =
new ByteBufferSource(dbb.s.slice().position(array.length / 4 - 1).limit(array.length / 4 - 1 + array.length / 2).slice(),
MemoryMode.UNALIGNED, ne, MemoryMode.READ_WRITE);
bavss.add(dbb_offset_unaligned);
ByteBufferReadOnlySource dbb_offset_unaligned_ro =
new ByteBufferReadOnlySource(dbb_offset_unaligned.s.asReadOnlyBuffer(), dbb_offset_unaligned.s,
MemoryMode.UNALIGNED, ne, MemoryMode.READ_ONLY);
bavss.add(dbb_offset_unaligned_ro);
}
@BeforeClass
public void setup() {
setupByteSources();
setupVarHandleSources();
}
abstract void setupVarHandleSources();
@DataProvider
public Object[][] varHandlesProvider() throws Exception {
return vhss.stream().map(cvh -> new Object[]{cvh}).toArray(Object[][]::new);
}
@DataProvider
public Object[][] typesProvider() throws Exception {
List<java.lang.Class<?>> aepts = Arrays.asList(byte[].class, int.class);
List<java.lang.Class<?>> bbpts = Arrays.asList(ByteBuffer.class, int.class);
Function<VarHandle, List<Class<?>>> vhToPts = vh ->
vh.coordinateTypes().get(0) == byte[].class ? aepts : bbpts;
return vhss.stream().map(vh -> new Object[]{vh.s, vhToPts.apply(vh.s)}).toArray(Object[][]::new);
}
}