test/713-varhandle-invokers/src/Main.java - LeafOS-Project/android_art - Gitiles

 /*
  * 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 static java.lang.invoke.MethodHandles.lookup;
 import static java.lang.invoke.MethodType.methodType;

 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.VarHandle;
 import java.lang.invoke.WrongMethodTypeException;

 public final class Main {
     static class TestSetupError extends Error {
         TestSetupError(String message, Throwable cause) {
             super(message, cause);
         }
     }

     private static void failAssertion(String message) {
         StringBuilder sb = new StringBuilder();
         sb.append("Test failure: ");
         sb.append(message);
         throw new AssertionError(sb.toString());
     }

     private static void assertUnreachable() throws Throwable {
         failAssertion("Unreachable");
     }

     private static void failAssertEquals(Object expected, Object actual) {
         StringBuilder sb = new StringBuilder();
         sb.append(expected);
         sb.append(" != ");
         sb.append(actual);
         failAssertion(sb.toString());
     }

     private static void assertEquals(boolean expected, boolean actual) {
         if (expected != actual) {
             failAssertEquals(expected, actual);
         }
     }

     private static void assertEquals(int expected, int actual) {
         if (expected != actual) {
             failAssertEquals(expected, actual);
         }
     }

     private static void assertEquals(long expected, long actual) {
         if (expected != actual) {
             failAssertEquals(expected, actual);
         }
     }

     private static void assertEquals(float expected, float actual) {
         if (expected != actual) {
             failAssertEquals(expected, actual);
         }
     }

     static class FieldVarHandleExactInvokerTest {
         private static final Class<?> THIS_CLASS = FieldVarHandleExactInvokerTest.class;
         private static final VarHandle fieldVarHandle;

         int field;

         static {
             try {
                 fieldVarHandle = lookup().findVarHandle(THIS_CLASS, "field", int.class);
             } catch (Exception e) {
                 throw new TestSetupError("Failed to lookup of field", e);
             }
         }

         void run() throws Throwable {
             System.out.println(THIS_CLASS.getName());

             MethodHandle invokerMethodHandle =
                     MethodHandles.varHandleExactInvoker(
                             VarHandle.AccessMode.GET_AND_SET,
                             methodType(int.class, THIS_CLASS, int.class));

             field = 3;
             assertEquals(3, (int) invokerMethodHandle.invokeExact(fieldVarHandle, this, 4));
             assertEquals(4, field);

             //
             // Check invocations with MethodHandle.invokeExact()
             //
             try {
                 // Check for unboxing
                 int i =
                         (int)
                                 invokerMethodHandle.invokeExact(
                                         fieldVarHandle, this, Integer.valueOf(3));
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
                 assertEquals(4, field);
             }
             try {
                 // Check for widening conversion
                 int i = (int) invokerMethodHandle.invokeExact(fieldVarHandle, this, (short) 3);
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
                 assertEquals(4, field);
             }
             try {
                 // Check for acceptance of void return type
                 invokerMethodHandle.invokeExact(fieldVarHandle, this, 77);
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
                 assertEquals(4, field);
             }
             try {
                 // Check for wider return type
                 long l = (long) invokerMethodHandle.invokeExact(fieldVarHandle, this, 77);
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
                 assertEquals(4, field);
             }
             try {
                 // Check null VarHandle instance fails
                 VarHandle vhNull = null;
                 int i = (int) invokerMethodHandle.invokeExact(vhNull, this, 777);
                 assertUnreachable();
             } catch (NullPointerException expected) {
                 assertEquals(4, field);
             }

             //
             // Check invocations with MethodHandle.invoke()
             //

             // Check for unboxing
             int i = (int) invokerMethodHandle.invoke(fieldVarHandle, this, Integer.valueOf(3));
             assertEquals(3, field);

             // Check for unboxing
             i = (int) invokerMethodHandle.invoke(fieldVarHandle, this, Short.valueOf((short) 4));
             assertEquals(4, field);

             // Check for widening conversion
             i = (int) invokerMethodHandle.invoke(fieldVarHandle, this, (short) 23);
             assertEquals(23, field);

             // Check for acceptance of void return type
             invokerMethodHandle.invoke(fieldVarHandle, this, 77);
             assertEquals(77, field);

             // Check for wider return type
             long l = (long) invokerMethodHandle.invoke(fieldVarHandle, this, 88);
             assertEquals(88, field);

             try {
                 // Check null VarHandle instance fails
                 VarHandle vhNull = null;
                 i = (int) invokerMethodHandle.invoke(vhNull, this, 888);
                 assertUnreachable();
             } catch (NullPointerException expected) {
                 assertEquals(88, field);
             }
         }
     }

     static class LongFieldVarHandleExactInvokerTest {
         private static final Class<?> THIS_CLASS = LongFieldVarHandleExactInvokerTest.class;

         private static final VarHandle fieldVarHandle;

         private static final long CANARY = 0x0123456789abcdefL;

         long field = 0L;

         static {
             try {
                 fieldVarHandle = lookup().findVarHandle(THIS_CLASS, "field", long.class);
             } catch (Exception e) {
                 throw new TestSetupError("Failed to lookup of field", e);
             }
         }

         void run() throws Throwable {
             System.out.println(THIS_CLASS.getName());

             MethodHandle invokerMethodHandle =
                     MethodHandles.varHandleExactInvoker(
                             VarHandle.AccessMode.COMPARE_AND_SET,
                             methodType(boolean.class, THIS_CLASS, long.class, long.class));
             checkCompareAndSet(invokerMethodHandle, 0L, CANARY);
             checkCompareAndSet(invokerMethodHandle, 1L, 1L);
             checkCompareAndSet(invokerMethodHandle, CANARY, ~CANARY);
             checkCompareAndSet(invokerMethodHandle, ~CANARY, 0L);
         }

         private void checkCompareAndSet(MethodHandle compareAndSet, long oldValue, long newValue)
                 throws Throwable {
             final boolean expectSuccess = (oldValue == field);
             final long oldFieldValue = field;
             assertEquals(
                     expectSuccess,
                     (boolean) compareAndSet.invoke(fieldVarHandle, this, oldValue, newValue));
             assertEquals(expectSuccess ? newValue : oldFieldValue, field);
         }
     }

     static class FieldVarHandleInvokerTest {
         private static final Class<?> THIS_CLASS = FieldVarHandleInvokerTest.class;
         private static final VarHandle fieldVarHandle;
         int field;

         static {
             try {
                 fieldVarHandle = lookup().findVarHandle(THIS_CLASS, "field", int.class);
             } catch (Exception e) {
                 throw new TestSetupError("Failed to lookup of field", e);
             }
         }

         void run() throws Throwable {
             System.out.println("fieldVarHandleInvokerTest");
             MethodHandle invokerMethodHandle =
                     MethodHandles.varHandleInvoker(
                             VarHandle.AccessMode.GET_AND_SET,
                             methodType(int.class, THIS_CLASS, int.class));

             field = 3;
             int oldField = (int) invokerMethodHandle.invoke(fieldVarHandle, this, 4);
             assertEquals(3, oldField);
             assertEquals(4, field);

             //
             // Check invocations with MethodHandle.invoke()
             //

             // Check for unboxing
             int i = (int) invokerMethodHandle.invoke(fieldVarHandle, this, Integer.valueOf(3));
             assertEquals(3, field);

             // Check for widening conversion
             i = (int) invokerMethodHandle.invoke(fieldVarHandle, this, (short) 33);
             assertEquals(33, field);

             // Check for widening conversion
             i = (int) invokerMethodHandle.invoke(fieldVarHandle, this, Byte.valueOf((byte) 34));
             assertEquals(34, field);

             // Check for acceptance of void return type
             invokerMethodHandle.invoke(fieldVarHandle, this, 77);
             assertEquals(77, field);

             // Check for wider return type
             long l = (long) invokerMethodHandle.invoke(fieldVarHandle, this, 88);
             assertEquals(88, field);
             try {
                 // Check narrowing conversion fails
                 i = (int) invokerMethodHandle.invoke(fieldVarHandle, this, 3.0);
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
             }
             try {
                 // Check reference type fails
                 i = (int) invokerMethodHandle.invoke(fieldVarHandle, this, "Bad");
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
             }
             try {
                 // Check null VarHandle instance fails
                 VarHandle vhNull = null;
                 i = (int) invokerMethodHandle.invoke(vhNull, this, 888);
                 assertUnreachable();
             } catch (NullPointerException expected) {
                 assertEquals(88, field);
             }

             //
             // Check invocations with MethodHandle.invokeExact()
             //
             field = -1;
             try {
                 // Check for unboxing
                 i = (int) invokerMethodHandle.invokeExact(fieldVarHandle, this, Integer.valueOf(3));
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
                 assertEquals(-1, field);
             }
             try {
                 // Check for widening conversion
                 i = (int) invokerMethodHandle.invokeExact(fieldVarHandle, this, (short) 33);
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
                 assertEquals(-1, field);
             }
             try {
                 // Check for acceptance of void return type
                 invokerMethodHandle.invokeExact(fieldVarHandle, this, 77);
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
                 assertEquals(-1, field);
             }
             try {
                 // Check for wider return type
                 l = (long) invokerMethodHandle.invokeExact(fieldVarHandle, this, 78);
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
                 assertEquals(-1, field);
             }
             try {
                 // Check narrowing conversion fails
                 i = (int) invokerMethodHandle.invokeExact(fieldVarHandle, this, 3.0);
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
             }
             try {
                 // Check reference type fails
                 i = (int) invokerMethodHandle.invokeExact(fieldVarHandle, this, "Bad");
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
             }
             try {
                 // Check null VarHandle instance fails
                 VarHandle vhNull = null;
                 i = (int) invokerMethodHandle.invokeExact(vhNull, this, 888);
                 assertUnreachable();
             } catch (NullPointerException expected) {
                 assertEquals(-1, field);
             }
         }
     }

     static class DivergenceExactInvokerTest {
         private static final VarHandle floatsArrayVarHandle;

         static {
             try {
                 floatsArrayVarHandle = MethodHandles.arrayElementVarHandle(float[].class);
             } catch (Exception e) {
                 throw new TestSetupError("Failed to create VarHandle", e);
             }
         }

         void run() throws Throwable {
             System.out.println("DivergenceExactInvokerTest");
             float[] floatsArray = new float[4];
             // Exact invoker of an accessor having the form:
             //  float accessor(float[] values, int index, Float current, float replacement)
             MethodHandle exactInvoker =
                     MethodHandles.varHandleExactInvoker(
                             VarHandle.AccessMode.COMPARE_AND_EXCHANGE,
                             methodType(
                                     float.class,
                                     float[].class,
                                     int.class,
                                     Float.class,
                                     float.class));
             floatsArray[2] = Float.valueOf(4.0f);
             // Callsite that is an exact match with exactInvoker.type().
             try {
                 // exactInvoker.type() is not compatible with floatsArrayVarHandle accessor.
                 float old =
                         (float)
                                 exactInvoker.invoke(
                                         floatsArrayVarHandle,
                                         floatsArray,
                                         2,
                                         Float.valueOf(4.0f),
                                         8.0f);
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
                 assertEquals(4.0f, floatsArray[2]);
             }

             // Callsites that are exact matches with exactInvoker.type()
             try {
                 // Mismatch between exactInvoker.type() and VarHandle type (Float != float)
                 float old =
                         (float)
                                 exactInvoker.invoke(
                                         floatsArrayVarHandle, floatsArray, 2, 8.0f, 16.0f);
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
                 assertEquals(4.0f, floatsArray[2]);
             }
             try {
                 // short not convertible to Float
                 float old =
                         (float)
                                 exactInvoker.invoke(
                                         floatsArrayVarHandle, floatsArray, 2, (short) 4, 13.0f);
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
                 assertEquals(4.0f, floatsArray[2]);
             }
             try {
                 // int not convertible to Float
                 float old =
                         (float) exactInvoker.invoke(floatsArrayVarHandle, floatsArray, 2, 8, -8.0f);
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
                 assertEquals(4.0f, floatsArray[2]);
             }
         }
     }

     static class DivergenceInvokerTest {
         private static final VarHandle floatsArrayVarHandle;

         static {
             try {
                 floatsArrayVarHandle = MethodHandles.arrayElementVarHandle(float[].class);
             } catch (Exception e) {
                 throw new TestSetupError("Failed to create VarHandle", e);
             }
         }

         void run() throws Throwable {
             System.out.println("DivergenceInvokerTest");
             float[] floatsArray = new float[4];
             // Invoker of an accessor having the form:
             //  float accessor(float[] values, int index, Float current, float replacement)
             MethodHandle invoker =
                     MethodHandles.varHandleInvoker(
                             VarHandle.AccessMode.COMPARE_AND_EXCHANGE,
                             methodType(
                                     float.class,
                                     float[].class,
                                     int.class,
                                     Float.class,
                                     float.class));
             floatsArray[2] = Float.valueOf(4.0f);
             // Callsite that is an exact match with invoker.type()
             float old =
                     (float)
                             invoker.invoke(
                                     floatsArrayVarHandle,
                                     floatsArray,
                                     2,
                                     Float.valueOf(4.0f),
                                     8.0f);
             assertEquals(4.0f, old);
             assertEquals(8.0f, floatsArray[2]);

             // Callsite that is convertible match to invoker.type()
             old = (float) invoker.invoke(floatsArrayVarHandle, floatsArray, 2, 8.0f, 16.0f);
             assertEquals(8.0f, old);
             assertEquals(16.0f, floatsArray[2]);

             // Callsites that are not convertible to invoker.type().
             try {
                 // short is not convertible to Float
                 old = (float) invoker.invoke(floatsArrayVarHandle, floatsArray, 2, (short) 4, 8.0f);
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
                 assertEquals(16.0f, floatsArray[2]);
             }
             try {
                 // int is not convertible to Float
                 old = (float) invoker.invoke(floatsArrayVarHandle, floatsArray, 2, 8, -8.0f);
                 assertUnreachable();
             } catch (WrongMethodTypeException expected) {
                 assertEquals(16.0f, floatsArray[2]);
             }

             try {
                 MethodHandle unsupportedInvoker =
                         MethodHandles.varHandleInvoker(
                                 VarHandle.AccessMode.GET_AND_BITWISE_OR,
                                 methodType(float.class, float[].class, int.class, float.class));
                 old =
                         (float)
                                 unsupportedInvoker.invoke(
                                         floatsArrayVarHandle, floatsArray, 0, 2.71f);
                 assertUnreachable();
             } catch (UnsupportedOperationException expected) {
             }
         }
     }

     public static void main(String[] args) throws Throwable {
         new FieldVarHandleExactInvokerTest().run();
         new LongFieldVarHandleExactInvokerTest().run();
         new FieldVarHandleInvokerTest().run();
         new DivergenceExactInvokerTest().run();
         new DivergenceInvokerTest().run();
     }
 }
	/*
	* 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 static java.lang.invoke.MethodHandles.lookup;
	import static java.lang.invoke.MethodType.methodType;

	import java.lang.invoke.MethodHandle;
	import java.lang.invoke.MethodHandles;
	import java.lang.invoke.VarHandle;
	import java.lang.invoke.WrongMethodTypeException;

	public final class Main {
	static class TestSetupError extends Error {
	TestSetupError(String message, Throwable cause) {
	super(message, cause);
	}
	}

	private static void failAssertion(String message) {
	StringBuilder sb = new StringBuilder();
	sb.append("Test failure: ");
	sb.append(message);
	throw new AssertionError(sb.toString());
	}

	private static void assertUnreachable() throws Throwable {
	failAssertion("Unreachable");
	}

	private static void failAssertEquals(Object expected, Object actual) {
	StringBuilder sb = new StringBuilder();
	sb.append(expected);
	sb.append(" != ");
	sb.append(actual);
	failAssertion(sb.toString());
	}

	private static void assertEquals(boolean expected, boolean actual) {
	if (expected != actual) {
	failAssertEquals(expected, actual);
	}
	}

	private static void assertEquals(int expected, int actual) {
	if (expected != actual) {
	failAssertEquals(expected, actual);
	}
	}

	private static void assertEquals(long expected, long actual) {
	if (expected != actual) {
	failAssertEquals(expected, actual);
	}
	}

	private static void assertEquals(float expected, float actual) {
	if (expected != actual) {
	failAssertEquals(expected, actual);
	}
	}

	static class FieldVarHandleExactInvokerTest {
	private static final Class<?> THIS_CLASS = FieldVarHandleExactInvokerTest.class;
	private static final VarHandle fieldVarHandle;

	int field;

	static {
	try {
	fieldVarHandle = lookup().findVarHandle(THIS_CLASS, "field", int.class);
	} catch (Exception e) {
	throw new TestSetupError("Failed to lookup of field", e);
	}
	}

	void run() throws Throwable {
	System.out.println(THIS_CLASS.getName());

	MethodHandle invokerMethodHandle =
	MethodHandles.varHandleExactInvoker(
	VarHandle.AccessMode.GET_AND_SET,
	methodType(int.class, THIS_CLASS, int.class));

	field = 3;
	assertEquals(3, (int) invokerMethodHandle.invokeExact(fieldVarHandle, this, 4));
	assertEquals(4, field);

	//
	// Check invocations with MethodHandle.invokeExact()
	//
	try {
	// Check for unboxing
	int i =
	(int)
	invokerMethodHandle.invokeExact(
	fieldVarHandle, this, Integer.valueOf(3));
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	assertEquals(4, field);
	}
	try {
	// Check for widening conversion
	int i = (int) invokerMethodHandle.invokeExact(fieldVarHandle, this, (short) 3);
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	assertEquals(4, field);
	}
	try {
	// Check for acceptance of void return type
	invokerMethodHandle.invokeExact(fieldVarHandle, this, 77);
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	assertEquals(4, field);
	}
	try {
	// Check for wider return type
	long l = (long) invokerMethodHandle.invokeExact(fieldVarHandle, this, 77);
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	assertEquals(4, field);
	}
	try {
	// Check null VarHandle instance fails
	VarHandle vhNull = null;
	int i = (int) invokerMethodHandle.invokeExact(vhNull, this, 777);
	assertUnreachable();
	} catch (NullPointerException expected) {
	assertEquals(4, field);
	}

	//
	// Check invocations with MethodHandle.invoke()
	//

	// Check for unboxing
	int i = (int) invokerMethodHandle.invoke(fieldVarHandle, this, Integer.valueOf(3));
	assertEquals(3, field);

	// Check for unboxing
	i = (int) invokerMethodHandle.invoke(fieldVarHandle, this, Short.valueOf((short) 4));
	assertEquals(4, field);

	// Check for widening conversion
	i = (int) invokerMethodHandle.invoke(fieldVarHandle, this, (short) 23);
	assertEquals(23, field);

	// Check for acceptance of void return type
	invokerMethodHandle.invoke(fieldVarHandle, this, 77);
	assertEquals(77, field);

	// Check for wider return type
	long l = (long) invokerMethodHandle.invoke(fieldVarHandle, this, 88);
	assertEquals(88, field);

	try {
	// Check null VarHandle instance fails
	VarHandle vhNull = null;
	i = (int) invokerMethodHandle.invoke(vhNull, this, 888);
	assertUnreachable();
	} catch (NullPointerException expected) {
	assertEquals(88, field);
	}
	}
	}

	static class LongFieldVarHandleExactInvokerTest {
	private static final Class<?> THIS_CLASS = LongFieldVarHandleExactInvokerTest.class;

	private static final VarHandle fieldVarHandle;

	private static final long CANARY = 0x0123456789abcdefL;

	long field = 0L;

	static {
	try {
	fieldVarHandle = lookup().findVarHandle(THIS_CLASS, "field", long.class);
	} catch (Exception e) {
	throw new TestSetupError("Failed to lookup of field", e);
	}
	}

	void run() throws Throwable {
	System.out.println(THIS_CLASS.getName());

	MethodHandle invokerMethodHandle =
	MethodHandles.varHandleExactInvoker(
	VarHandle.AccessMode.COMPARE_AND_SET,
	methodType(boolean.class, THIS_CLASS, long.class, long.class));
	checkCompareAndSet(invokerMethodHandle, 0L, CANARY);
	checkCompareAndSet(invokerMethodHandle, 1L, 1L);
	checkCompareAndSet(invokerMethodHandle, CANARY, ~CANARY);
	checkCompareAndSet(invokerMethodHandle, ~CANARY, 0L);
	}

	private void checkCompareAndSet(MethodHandle compareAndSet, long oldValue, long newValue)
	throws Throwable {
	final boolean expectSuccess = (oldValue == field);
	final long oldFieldValue = field;
	assertEquals(
	expectSuccess,
	(boolean) compareAndSet.invoke(fieldVarHandle, this, oldValue, newValue));
	assertEquals(expectSuccess ? newValue : oldFieldValue, field);
	}
	}

	static class FieldVarHandleInvokerTest {
	private static final Class<?> THIS_CLASS = FieldVarHandleInvokerTest.class;
	private static final VarHandle fieldVarHandle;
	int field;

	static {
	try {
	fieldVarHandle = lookup().findVarHandle(THIS_CLASS, "field", int.class);
	} catch (Exception e) {
	throw new TestSetupError("Failed to lookup of field", e);
	}
	}

	void run() throws Throwable {
	System.out.println("fieldVarHandleInvokerTest");
	MethodHandle invokerMethodHandle =
	MethodHandles.varHandleInvoker(
	VarHandle.AccessMode.GET_AND_SET,
	methodType(int.class, THIS_CLASS, int.class));

	field = 3;
	int oldField = (int) invokerMethodHandle.invoke(fieldVarHandle, this, 4);
	assertEquals(3, oldField);
	assertEquals(4, field);

	//
	// Check invocations with MethodHandle.invoke()
	//

	// Check for unboxing
	int i = (int) invokerMethodHandle.invoke(fieldVarHandle, this, Integer.valueOf(3));
	assertEquals(3, field);

	// Check for widening conversion
	i = (int) invokerMethodHandle.invoke(fieldVarHandle, this, (short) 33);
	assertEquals(33, field);

	// Check for widening conversion
	i = (int) invokerMethodHandle.invoke(fieldVarHandle, this, Byte.valueOf((byte) 34));
	assertEquals(34, field);

	// Check for acceptance of void return type
	invokerMethodHandle.invoke(fieldVarHandle, this, 77);
	assertEquals(77, field);

	// Check for wider return type
	long l = (long) invokerMethodHandle.invoke(fieldVarHandle, this, 88);
	assertEquals(88, field);
	try {
	// Check narrowing conversion fails
	i = (int) invokerMethodHandle.invoke(fieldVarHandle, this, 3.0);
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	}
	try {
	// Check reference type fails
	i = (int) invokerMethodHandle.invoke(fieldVarHandle, this, "Bad");
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	}
	try {
	// Check null VarHandle instance fails
	VarHandle vhNull = null;
	i = (int) invokerMethodHandle.invoke(vhNull, this, 888);
	assertUnreachable();
	} catch (NullPointerException expected) {
	assertEquals(88, field);
	}

	//
	// Check invocations with MethodHandle.invokeExact()
	//
	field = -1;
	try {
	// Check for unboxing
	i = (int) invokerMethodHandle.invokeExact(fieldVarHandle, this, Integer.valueOf(3));
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	assertEquals(-1, field);
	}
	try {
	// Check for widening conversion
	i = (int) invokerMethodHandle.invokeExact(fieldVarHandle, this, (short) 33);
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	assertEquals(-1, field);
	}
	try {
	// Check for acceptance of void return type
	invokerMethodHandle.invokeExact(fieldVarHandle, this, 77);
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	assertEquals(-1, field);
	}
	try {
	// Check for wider return type
	l = (long) invokerMethodHandle.invokeExact(fieldVarHandle, this, 78);
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	assertEquals(-1, field);
	}
	try {
	// Check narrowing conversion fails
	i = (int) invokerMethodHandle.invokeExact(fieldVarHandle, this, 3.0);
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	}
	try {
	// Check reference type fails
	i = (int) invokerMethodHandle.invokeExact(fieldVarHandle, this, "Bad");
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	}
	try {
	// Check null VarHandle instance fails
	VarHandle vhNull = null;
	i = (int) invokerMethodHandle.invokeExact(vhNull, this, 888);
	assertUnreachable();
	} catch (NullPointerException expected) {
	assertEquals(-1, field);
	}
	}
	}

	static class DivergenceExactInvokerTest {
	private static final VarHandle floatsArrayVarHandle;

	static {
	try {
	floatsArrayVarHandle = MethodHandles.arrayElementVarHandle(float[].class);
	} catch (Exception e) {
	throw new TestSetupError("Failed to create VarHandle", e);
	}
	}

	void run() throws Throwable {
	System.out.println("DivergenceExactInvokerTest");
	float[] floatsArray = new float[4];
	// Exact invoker of an accessor having the form:
	// float accessor(float[] values, int index, Float current, float replacement)
	MethodHandle exactInvoker =
	MethodHandles.varHandleExactInvoker(
	VarHandle.AccessMode.COMPARE_AND_EXCHANGE,
	methodType(
	float.class,
	float[].class,
	int.class,
	Float.class,
	float.class));
	floatsArray[2] = Float.valueOf(4.0f);
	// Callsite that is an exact match with exactInvoker.type().
	try {
	// exactInvoker.type() is not compatible with floatsArrayVarHandle accessor.
	float old =
	(float)
	exactInvoker.invoke(
	floatsArrayVarHandle,
	floatsArray,
	2,
	Float.valueOf(4.0f),
	8.0f);
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	assertEquals(4.0f, floatsArray[2]);
	}

	// Callsites that are exact matches with exactInvoker.type()
	try {
	// Mismatch between exactInvoker.type() and VarHandle type (Float != float)
	float old =
	(float)
	exactInvoker.invoke(
	floatsArrayVarHandle, floatsArray, 2, 8.0f, 16.0f);
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	assertEquals(4.0f, floatsArray[2]);
	}
	try {
	// short not convertible to Float
	float old =
	(float)
	exactInvoker.invoke(
	floatsArrayVarHandle, floatsArray, 2, (short) 4, 13.0f);
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	assertEquals(4.0f, floatsArray[2]);
	}
	try {
	// int not convertible to Float
	float old =
	(float) exactInvoker.invoke(floatsArrayVarHandle, floatsArray, 2, 8, -8.0f);
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	assertEquals(4.0f, floatsArray[2]);
	}
	}
	}

	static class DivergenceInvokerTest {
	private static final VarHandle floatsArrayVarHandle;

	static {
	try {
	floatsArrayVarHandle = MethodHandles.arrayElementVarHandle(float[].class);
	} catch (Exception e) {
	throw new TestSetupError("Failed to create VarHandle", e);
	}
	}

	void run() throws Throwable {
	System.out.println("DivergenceInvokerTest");
	float[] floatsArray = new float[4];
	// Invoker of an accessor having the form:
	// float accessor(float[] values, int index, Float current, float replacement)
	MethodHandle invoker =
	MethodHandles.varHandleInvoker(
	VarHandle.AccessMode.COMPARE_AND_EXCHANGE,
	methodType(
	float.class,
	float[].class,
	int.class,
	Float.class,
	float.class));
	floatsArray[2] = Float.valueOf(4.0f);
	// Callsite that is an exact match with invoker.type()
	float old =
	(float)
	invoker.invoke(
	floatsArrayVarHandle,
	floatsArray,
	2,
	Float.valueOf(4.0f),
	8.0f);
	assertEquals(4.0f, old);
	assertEquals(8.0f, floatsArray[2]);

	// Callsite that is convertible match to invoker.type()
	old = (float) invoker.invoke(floatsArrayVarHandle, floatsArray, 2, 8.0f, 16.0f);
	assertEquals(8.0f, old);
	assertEquals(16.0f, floatsArray[2]);

	// Callsites that are not convertible to invoker.type().
	try {
	// short is not convertible to Float
	old = (float) invoker.invoke(floatsArrayVarHandle, floatsArray, 2, (short) 4, 8.0f);
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	assertEquals(16.0f, floatsArray[2]);
	}
	try {
	// int is not convertible to Float
	old = (float) invoker.invoke(floatsArrayVarHandle, floatsArray, 2, 8, -8.0f);
	assertUnreachable();
	} catch (WrongMethodTypeException expected) {
	assertEquals(16.0f, floatsArray[2]);
	}

	try {
	MethodHandle unsupportedInvoker =
	MethodHandles.varHandleInvoker(
	VarHandle.AccessMode.GET_AND_BITWISE_OR,
	methodType(float.class, float[].class, int.class, float.class));
	old =
	(float)
	unsupportedInvoker.invoke(
	floatsArrayVarHandle, floatsArray, 0, 2.71f);
	assertUnreachable();
	} catch (UnsupportedOperationException expected) {
	}
	}
	}

	public static void main(String[] args) throws Throwable {
	new FieldVarHandleExactInvokerTest().run();
	new LongFieldVarHandleExactInvokerTest().run();
	new FieldVarHandleInvokerTest().run();
	new DivergenceExactInvokerTest().run();
	new DivergenceInvokerTest().run();
	}
	}