4183N/A

4183N/Apackage test.sun.invoke.util;

4183N/A

4183N/Aimport sun.invoke.util.ValueConversions;

4183N/Aimport sun.invoke.util.Wrapper;

4183N/Aimport java.lang.invoke.MethodType;

4183N/Aimport java.lang.invoke.MethodHandle;

4183N/Aimport java.io.Serializable;

4183N/Aimport java.util.Arrays;

4183N/Aimport java.util.Collections;

4183N/Aimport org.junit.Test;

4183N/Aimport static org.junit.Assert.*;

4183N/A

4183N/A

4183N/A

4183N/Apublic class ValueConversionsTest {

5455N/A private static final Class<?> CLASS = ValueConversionsTest.class;

4183N/A private static final int MAX_ARITY = Integer.getInteger(CLASS.getSimpleName()+".MAX_ARITY", 40);

4183N/A private static final int START_ARITY = Integer.getInteger(CLASS.getSimpleName()+".START_ARITY", 0);

4183N/A private static final boolean EXHAUSTIVE = Boolean.getBoolean(CLASS.getSimpleName()+".EXHAUSTIVE");

4183N/A

4183N/A @Test

4183N/A public void testUnbox() throws Throwable {

4183N/A testUnbox(false);

4183N/A }

4183N/A

4183N/A @Test

4183N/A public void testUnboxCast() throws Throwable {

4183N/A testUnbox(true);

4183N/A }

4183N/A

4183N/A private void testUnbox(boolean doCast) throws Throwable {

4183N/A //System.out.println("unbox");

4183N/A for (Wrapper dst : Wrapper.values()) {

4183N/A //System.out.println(dst);

4183N/A for (Wrapper src : Wrapper.values()) {

4183N/A testUnbox(doCast, dst, src);

4183N/A }

4183N/A }

4183N/A }

4183N/A

4183N/A private void testUnbox(boolean doCast, Wrapper dst, Wrapper src) throws Throwable {

4183N/A boolean expectThrow = !doCast && !dst.isConvertibleFrom(src);

4183N/A if (dst == Wrapper.OBJECT || src == Wrapper.OBJECT) return; // must have prims

4183N/A if (dst == Wrapper.OBJECT)

4183N/A expectThrow = false; // everything (even VOID==null here) converts to OBJECT

4183N/A try {

4183N/A for (int n = -5; n < 10; n++) {

4183N/A Object box = src.wrap(n);

4183N/A switch (src) {

4183N/A case VOID: assertEquals(box, null); break;

4183N/A case OBJECT: box = box.toString(); break;

4183N/A case SHORT: assertEquals(box.getClass(), Short.class); break;

4183N/A default: assertEquals(box.getClass(), src.wrapperType()); break;

4183N/A }

4183N/A MethodHandle unboxer;

4183N/A if (doCast)

4183N/A unboxer = ValueConversions.unboxCast(dst.primitiveType());

4183N/A else

4183N/A unboxer = ValueConversions.unbox(dst.primitiveType());

4183N/A Object expResult = (box == null) ? dst.zero() : dst.wrap(box);

4183N/A Object result = null;

4183N/A switch (dst) {

4183N/A case INT: result = (int) unboxer.invokeExact(box); break;

4183N/A case LONG: result = (long) unboxer.invokeExact(box); break;

4183N/A case FLOAT: result = (float) unboxer.invokeExact(box); break;

4183N/A case DOUBLE: result = (double) unboxer.invokeExact(box); break;

4183N/A case CHAR: result = (char) unboxer.invokeExact(box); break;

4183N/A case BYTE: result = (byte) unboxer.invokeExact(box); break;

4183N/A case SHORT: result = (short) unboxer.invokeExact(box); break;

4183N/A case OBJECT: result = (Object) unboxer.invokeExact(box); break;

4183N/A case BOOLEAN: result = (boolean) unboxer.invokeExact(box); break;

4183N/A case VOID: result = null; unboxer.invokeExact(box); break;

4183N/A }

4183N/A if (expectThrow) {

4183N/A expResult = "(need an exception)";

4183N/A }

4183N/A assertEquals("(doCast,expectThrow,dst,src,n,box)="+Arrays.asList(doCast,expectThrow,dst,src,n,box),

4183N/A expResult, result);

4183N/A }

4183N/A } catch (RuntimeException ex) {

4183N/A if (expectThrow) return;

4183N/A System.out.println("Unexpected throw for (doCast,expectThrow,dst,src)="+Arrays.asList(doCast,expectThrow,dst,src));

4183N/A throw ex;

4183N/A }

4183N/A }

4183N/A

4183N/A @Test

4183N/A public void testBox() throws Throwable {

4183N/A //System.out.println("box");

4183N/A for (Wrapper w : Wrapper.values()) {

4183N/A if (w == Wrapper.VOID) continue; // skip this; no unboxed form

4183N/A //System.out.println(w);

4183N/A for (int n = -5; n < 10; n++) {

4183N/A Object box = w.wrap(n);

4183N/A MethodHandle boxer = ValueConversions.box(w.primitiveType());

4183N/A Object expResult = box;

4183N/A Object result = null;

4183N/A switch (w) {

5455N/A case INT: result = boxer.invokeExact(/*int*/n); break;

4183N/A case LONG: result = boxer.invokeExact((long)n); break;

4183N/A case FLOAT: result = boxer.invokeExact((float)n); break;

4183N/A case DOUBLE: result = boxer.invokeExact((double)n); break;

4183N/A case CHAR: result = boxer.invokeExact((char)n); break;

4183N/A case BYTE: result = boxer.invokeExact((byte)n); break;

4183N/A case SHORT: result = boxer.invokeExact((short)n); break;

4183N/A case OBJECT: result = boxer.invokeExact((Object)n); break;

4183N/A case BOOLEAN: result = boxer.invokeExact((n & 1) != 0); break;

4183N/A }

4183N/A assertEquals("(dst,src,n,box)="+Arrays.asList(w,w,n,box),

4183N/A expResult, result);

4183N/A }

4183N/A }

4183N/A }

4183N/A

4183N/A @Test

4183N/A public void testCast() throws Throwable {

4183N/A //System.out.println("cast");

4183N/A Class<?>[] types = { Object.class, Serializable.class, String.class, Number.class, Integer.class };

4183N/A Object[] objects = { new Object(), Boolean.FALSE, "hello", (Long)12L, (Integer)6 };

4183N/A for (Class<?> dst : types) {

4183N/A MethodHandle caster = ValueConversions.cast(dst);

4183N/A assertEquals(caster.type(), ValueConversions.identity().type());

4183N/A for (Object obj : objects) {

4183N/A Class<?> src = obj.getClass();

5462N/A boolean canCast = dst.isAssignableFrom(src);

5462N/A //System.out.println("obj="+obj+" <: dst="+dst+(canCast ? " (OK)" : " (will fail)"));

4183N/A try {

4183N/A Object result = caster.invokeExact(obj);

4183N/A if (canCast)

4183N/A assertEquals(obj, result);

4183N/A else

4183N/A assertEquals("cast should not have succeeded", dst, obj);

4183N/A } catch (ClassCastException ex) {

4183N/A if (canCast)

4183N/A throw ex;

4183N/A }

4183N/A }

4183N/A }

4183N/A }

4183N/A

4183N/A @Test

4183N/A public void testIdentity() throws Throwable {

4183N/A //System.out.println("identity");

4183N/A MethodHandle id = ValueConversions.identity();

4183N/A Object expResult = "foo";

4183N/A Object result = id.invokeExact(expResult);

4183N/A // compiler bug: ValueConversions.identity().invokeExact("bar");

4183N/A assertEquals(expResult, result);

4183N/A }

4183N/A

4183N/A @Test

5459N/A public void testConvert() throws Throwable {

5459N/A //System.out.println("convert");

5459N/A for (long tval = 0, ctr = 0;;) {

5459N/A if (++ctr > 99999) throw new AssertionError("too many test values");

5459N/A // next test value:

5459N/A //System.out.println(Long.toHexString(tval)); // prints 3776 test patterns

5459N/A tval = nextTestValue(tval);

5459N/A if (tval == 0) {

5459N/A //System.out.println("test value count = "+ctr); // 3776 = 8*59*8

5459N/A break; // repeat

5459N/A }

5459N/A }

5459N/A for (Wrapper src : Wrapper.values()) {

5459N/A for (Wrapper dst : Wrapper.values()) {

5459N/A testConvert(src, dst, 0);

5459N/A }

5459N/A }

5459N/A }

5459N/A static void testConvert(Wrapper src, Wrapper dst, long tval) throws Throwable {

5459N/A //System.out.println(src+" => "+dst);

5459N/A boolean testSingleCase = (tval != 0);

5459N/A final long tvalInit = tval;

5459N/A MethodHandle conv = ValueConversions.convertPrimitive(src, dst);

5459N/A MethodType convType;

5459N/A if (src == Wrapper.VOID)

5459N/A convType = MethodType.methodType(dst.primitiveType() /* , void */);

5459N/A else

5459N/A convType = MethodType.methodType(dst.primitiveType(), src.primitiveType());

5459N/A assertEquals(convType, conv.type());

5459N/A MethodHandle converter = conv.asType(conv.type().changeReturnType(Object.class));

5459N/A for (;;) {

5459N/A long n = tval;

5459N/A Object testValue = src.wrap(n);

5459N/A Object expResult = dst.cast(testValue, dst.primitiveType());

5459N/A Object result;

5459N/A switch (src) {

5459N/A case INT: result = converter.invokeExact((int)n); break;

5459N/A case LONG: result = converter.invokeExact(/*long*/n); break;

5459N/A case FLOAT: result = converter.invokeExact((float)n); break;

5459N/A case DOUBLE: result = converter.invokeExact((double)n); break;

5459N/A case CHAR: result = converter.invokeExact((char)n); break;

5459N/A case BYTE: result = converter.invokeExact((byte)n); break;

5459N/A case SHORT: result = converter.invokeExact((short)n); break;

5459N/A case OBJECT: result = converter.invokeExact((Object)n); break;

5459N/A case BOOLEAN: result = converter.invokeExact((n & 1) != 0); break;

5459N/A case VOID: result = converter.invokeExact(); break;

5459N/A default: throw new AssertionError();

5459N/A }

5459N/A assertEquals("(src,dst,n,testValue)="+Arrays.asList(src,dst,"0x"+Long.toHexString(n),testValue),

5459N/A expResult, result);

5459N/A if (testSingleCase) break;

5459N/A // next test value:

5459N/A tval = nextTestValue(tval);

5459N/A if (tval == tvalInit) break; // repeat

5459N/A }

5459N/A }

5459N/A static long tweakSign(long x) {

5459N/A // Assuming that x is mostly zeroes, make those zeroes follow bit #62 (just below the sign).

5459N/A // This function is self-inverse.

5459N/A final long MID_SIGN_BIT = 62;

5459N/A long sign = -((x >>> MID_SIGN_BIT) & 1); // all ones or all zeroes

5459N/A long flip = (sign >>> -MID_SIGN_BIT); // apply the sign below the mid-bit

5459N/A return x ^ flip;

5459N/A }

5459N/A static long nextTestValue(long x) {

5459N/A // Produce 64 bits with three component bitfields: [ high:3 | mid:58 | low:3 ].

5459N/A // The high and low fields vary through all possible bit patterns.

5459N/A // The middle field is either all zero or has a single bit set.

5459N/A // For better coverage of the neighborhood of zero, an internal sign bit is xored downward also.

5459N/A long ux = tweakSign(x); // unsign the middle field

5459N/A final long LOW_BITS = 3, LOW_BITS_MASK = (1L << LOW_BITS)-1;

5459N/A final long HIGH_BITS = 3, HIGH_BITS_MASK = ~(-1L >>> HIGH_BITS);

5459N/A if ((ux & LOW_BITS_MASK) != LOW_BITS_MASK) {

5459N/A ++ux;

5459N/A } else {

5459N/A ux &= ~LOW_BITS_MASK;

5459N/A long midBit = (ux & ~HIGH_BITS_MASK);

5459N/A if (midBit == 0)

5459N/A midBit = (1L<<LOW_BITS); // introduce a low bit

5459N/A ux += midBit;

5459N/A }

5459N/A return tweakSign(ux);

5459N/A }

5459N/A

5459N/A @Test

4183N/A public void testVarargsArray() throws Throwable {

4183N/A //System.out.println("varargsArray");

4183N/A final int MIN = START_ARITY;

4183N/A final int MAX = MAX_ARITY-2; // 253+1 would cause parameter overflow with 'this' added

4183N/A for (int nargs = MIN; nargs <= MAX; nargs = nextArgCount(nargs, 17, MAX)) {

4183N/A MethodHandle target = ValueConversions.varargsArray(nargs);

4183N/A Object[] args = new Object[nargs];

4183N/A for (int i = 0; i < nargs; i++)

4183N/A args[i] = "#"+i;

4183N/A Object res = target.invokeWithArguments(args);

4183N/A assertArrayEquals(args, (Object[])res);

4183N/A }

4183N/A }

4183N/A

4183N/A @Test

4183N/A public void testVarargsReferenceArray() throws Throwable {

4183N/A //System.out.println("varargsReferenceArray");

4183N/A testTypedVarargsArray(Object[].class);

4183N/A testTypedVarargsArray(String[].class);

4183N/A testTypedVarargsArray(Number[].class);

4183N/A }

4183N/A

4183N/A @Test

4183N/A public void testVarargsPrimitiveArray() throws Throwable {

4183N/A //System.out.println("varargsPrimitiveArray");

4183N/A testTypedVarargsArray(int[].class);

4183N/A testTypedVarargsArray(long[].class);

4183N/A testTypedVarargsArray(byte[].class);

4183N/A testTypedVarargsArray(boolean[].class);

4183N/A testTypedVarargsArray(short[].class);

4183N/A testTypedVarargsArray(char[].class);

4183N/A testTypedVarargsArray(float[].class);

4183N/A testTypedVarargsArray(double[].class);

4183N/A }

4183N/A

4183N/A private static int nextArgCount(int nargs, int density, int MAX) {

4183N/A if (EXHAUSTIVE) return nargs + 1;

4183N/A if (nargs >= MAX) return Integer.MAX_VALUE;

4183N/A int BOT = 20, TOP = MAX-5;

4183N/A if (density < 10) { BOT = 10; MAX = TOP-2; }

4183N/A if (nargs <= BOT || nargs >= TOP) {

4183N/A ++nargs;

4183N/A } else {

4183N/A int bump = Math.max(1, 100 / density);

4183N/A nargs += bump;

4183N/A if (nargs > TOP) nargs = TOP;

4183N/A }

4183N/A return nargs;

4183N/A }

4183N/A

4183N/A private void testTypedVarargsArray(Class<?> arrayType) throws Throwable {

5459N/A //System.out.println(arrayType.getSimpleName());

4183N/A Class<?> elemType = arrayType.getComponentType();

4183N/A int MIN = START_ARITY;

4183N/A int MAX = MAX_ARITY-2; // 253+1 would cause parameter overflow with 'this' added

4183N/A int density = 3;

4183N/A if (elemType == int.class || elemType == long.class) density = 7;

4183N/A if (elemType == long.class || elemType == double.class) { MAX /= 2; MIN /= 2; }

4183N/A for (int nargs = MIN; nargs <= MAX; nargs = nextArgCount(nargs, density, MAX)) {

4183N/A Object[] args = makeTestArray(elemType, nargs);

4183N/A MethodHandle varargsArray = ValueConversions.varargsArray(arrayType, nargs);

4183N/A MethodType vaType = varargsArray.type();

4183N/A assertEquals(arrayType, vaType.returnType());

4183N/A if (nargs != 0) {

4183N/A assertEquals(elemType, vaType.parameterType(0));

4183N/A assertEquals(elemType, vaType.parameterType(vaType.parameterCount()-1));

4183N/A }

4183N/A assertEquals(MethodType.methodType(arrayType, Collections.<Class<?>>nCopies(nargs, elemType)),

4183N/A vaType);

4183N/A Object res = varargsArray.invokeWithArguments(args);

4183N/A String resString = toArrayString(res);

4183N/A assertEquals(Arrays.toString(args), resString);

4183N/A

4183N/A MethodHandle spreader = varargsArray.asSpreader(arrayType, nargs);

4183N/A MethodType stype = spreader.type();

4183N/A assert(stype == MethodType.methodType(arrayType, arrayType));

4183N/A if (nargs <= 5) {

4183N/A // invoke target as a spreader also:

5455N/A @SuppressWarnings("cast")

4183N/A Object res2 = spreader.invokeWithArguments((Object)res);

4183N/A String res2String = toArrayString(res2);

4183N/A assertEquals(Arrays.toString(args), res2String);

4183N/A // invoke the spreader on a generic Object[] array; check for error

4183N/A try {

4183N/A Object res3 = spreader.invokeWithArguments((Object)args);

4183N/A String res3String = toArrayString(res3);

4183N/A assertTrue(arrayType.getName(), arrayType.isAssignableFrom(Object[].class));

4183N/A assertEquals(Arrays.toString(args), res3String);

4183N/A } catch (ClassCastException ex) {

4183N/A assertFalse(arrayType.getName(), arrayType.isAssignableFrom(Object[].class));

4183N/A }

4183N/A }

4183N/A if (nargs == 0) {

4183N/A // invoke spreader on null arglist

4183N/A Object res3 = spreader.invokeWithArguments((Object)null);

4183N/A String res3String = toArrayString(res3);

4183N/A assertEquals(Arrays.toString(args), res3String);

4183N/A }

4183N/A }

4183N/A }

4183N/A

4183N/A private static Object[] makeTestArray(Class<?> elemType, int len) {

4183N/A Wrapper elem = null;

4183N/A if (elemType.isPrimitive())

4183N/A elem = Wrapper.forPrimitiveType(elemType);

4183N/A else if (Wrapper.isWrapperType(elemType))

4183N/A elem = Wrapper.forWrapperType(elemType);

4183N/A Object[] args = new Object[len];

4183N/A for (int i = 0; i < len; i++) {

4183N/A Object arg = i * 100;

4183N/A if (elem == null) {

4183N/A if (elemType == String.class)

4183N/A arg = "#"+arg;

4183N/A arg = elemType.cast(arg); // just to make sure

4183N/A } else {

4183N/A switch (elem) {

4183N/A case BOOLEAN: arg = (i % 3 == 0); break;

4183N/A case CHAR: arg = 'a' + i; break;

4183N/A case LONG: arg = (long)i * 1000_000_000; break;

4183N/A case FLOAT: arg = (float)i / 100; break;

4183N/A case DOUBLE: arg = (double)i / 1000_000; break;

4183N/A }

4183N/A arg = elem.cast(arg, elemType);

4183N/A }

4183N/A args[i] = arg;

4183N/A }

4183N/A //System.out.println(elemType.getName()+Arrays.toString(args));

4183N/A return args;

4183N/A }

4183N/A

4183N/A private static String toArrayString(Object a) {

4183N/A if (a == null) return "null";

4183N/A Class<?> elemType = a.getClass().getComponentType();

4183N/A if (elemType == null) return a.toString();

4183N/A if (elemType.isPrimitive()) {

4183N/A switch (Wrapper.forPrimitiveType(elemType)) {

4183N/A case INT: return Arrays.toString((int[])a);

4183N/A case BYTE: return Arrays.toString((byte[])a);

4183N/A case BOOLEAN: return Arrays.toString((boolean[])a);

4183N/A case SHORT: return Arrays.toString((short[])a);

4183N/A case CHAR: return Arrays.toString((char[])a);

4183N/A case FLOAT: return Arrays.toString((float[])a);

4183N/A case LONG: return Arrays.toString((long[])a);

4183N/A case DOUBLE: return Arrays.toString((double[])a);

4183N/A }

4183N/A }

4183N/A return Arrays.toString((Object[])a);

4183N/A }

4183N/A

4183N/A @Test

4183N/A public void testVarargsList() throws Throwable {

4183N/A //System.out.println("varargsList");

4183N/A final int MIN = START_ARITY;

4183N/A final int MAX = MAX_ARITY-2; // 253+1 would cause parameter overflow with 'this' added

4183N/A for (int nargs = MIN; nargs <= MAX; nargs = nextArgCount(nargs, 7, MAX)) {

4183N/A MethodHandle target = ValueConversions.varargsList(nargs);

4183N/A Object[] args = new Object[nargs];

4183N/A for (int i = 0; i < nargs; i++)

4183N/A args[i] = "#"+i;

4183N/A Object res = target.invokeWithArguments(args);

4183N/A assertEquals(Arrays.asList(args), res);

4183N/A }

4183N/A }

4183N/A}