content: /*
   * Copyright (C) 2016 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.MethodHandle;
  import java.lang.invoke.MethodHandleInfo;
  import java.lang.invoke.MethodHandles;
  import java.lang.invoke.MethodHandles.Lookup;
  import java.lang.invoke.MethodType;
  import java.lang.invoke.WrongMethodTypeException;
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Field;
  import java.lang.reflect.Method;
  import java.nio.charset.Charset;
  import java.nio.charset.StandardCharsets;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  
  public class Main {
  
    public static class A {
      public A() {}
  
      public void foo() {
        System.out.println("foo_A");
      }
  
      public static final Lookup lookup = MethodHandles.lookup();
    }
  
    public static class B extends A {
      public void foo() {
        System.out.println("foo_B");
      }
  
      public static final Lookup lookup = MethodHandles.lookup();
    }
  
    public static class C extends B {
      public static final Lookup lookup = MethodHandles.lookup();
    }
  
    public static class D {
      private final void privateRyan() {
        System.out.println("privateRyan_D");
      }
  
      public static final Lookup lookup = MethodHandles.lookup();
    }
  
    public static class E extends D {
      public static final Lookup lookup = MethodHandles.lookup();
    }
  
    public static void main(String[] args) throws Throwable {
      testfindSpecial_invokeSuperBehaviour();
      testfindSpecial_invokeDirectBehaviour();
      testExceptionDetailMessages();
      testfindVirtual();
      testfindStatic();
      testUnreflects();
      testAsType();
      testConstructors();
      testStringConstructors();
      testReturnValueConversions();
      testVariableArity();
      testVariableArity_MethodHandles_bind();
      testRevealDirect();
    }
  
    public static void testfindSpecial_invokeSuperBehaviour() throws Throwable {
      // This is equivalent to an invoke-super instruction where the referrer
      // is B.class.
      MethodHandle mh1 = B.lookup.findSpecial(A.class /* refC */, "foo",
          MethodType.methodType(void.class), B.class /* specialCaller */);
  
      A aInstance = new A();
      B bInstance = new B();
      C cInstance = new C();
  
      // This should be as if an invoke-super was called from one of B's methods.
      mh1.invokeExact(bInstance);
      mh1.invoke(bInstance);
  
      // This should not work. The receiver type in the handle will be suitably
      // restricted to B and subclasses.
      try {
        mh1.invoke(aInstance);
        System.out.println("mh1.invoke(aInstance) should not succeeed");
      } catch (ClassCastException expected) {
      }
  
      try {
        mh1.invokeExact(aInstance);
        System.out.println("mh1.invoke(aInstance) should not succeeed");
      } catch (WrongMethodTypeException expected) {
      }
  
      // This should *still* be as if an invoke-super was called from one of C's
      // methods, despite the fact that we're operating on a C.
      mh1.invoke(cInstance);
  
      // Now that C is the special caller, the next invoke will call B.foo.
      MethodHandle mh2 = C.lookup.findSpecial(A.class /* refC */, "foo",
          MethodType.methodType(void.class), C.class /* specialCaller */);
      mh2.invokeExact(cInstance);
  
      // Shouldn't allow invoke-super semantics from an unrelated special caller.
      try {
        C.lookup.findSpecial(A.class, "foo",
          MethodType.methodType(void.class), D.class /* specialCaller */);
        System.out.println("findSpecial(A.class, foo, .. D.class) unexpectedly succeeded.");
      } catch (IllegalAccessException expected) {
      }
  
      // Check return type matches for find.
      try {
        B.lookup.findSpecial(A.class /* refC */, "foo",
                             MethodType.methodType(int.class), B.class /* specialCaller */);
        fail();
      } catch (NoSuchMethodException e) {}
      // Check constructors
      try {
        B.lookup.findSpecial(A.class /* refC */, "<init>",
                             MethodType.methodType(void.class), B.class /* specialCaller */);
        fail();
      } catch (NoSuchMethodException e) {}
    }
  
    public static void testfindSpecial_invokeDirectBehaviour() throws Throwable {
      D dInstance = new D();
  
      MethodHandle mh3 = D.lookup.findSpecial(D.class, "privateRyan",
          MethodType.methodType(void.class), D.class /* specialCaller */);
      mh3.invoke(dInstance);
  
      // The private method shouldn't be accessible from any special caller except
      // itself...
      try {
        D.lookup.findSpecial(D.class, "privateRyan", MethodType.methodType(void.class), C.class);
        System.out.println("findSpecial(privateRyan, C.class) unexpectedly succeeded");
      } catch (IllegalAccessException expected) {
      }
  
      // ... or from any lookup context except its own.
      try {
        E.lookup.findSpecial(D.class, "privateRyan", MethodType.methodType(void.class), E.class);
        System.out.println("findSpecial(privateRyan, E.class) unexpectedly succeeded");
      } catch (IllegalAccessException expected) {
      }
    }
  
    public static void testExceptionDetailMessages() throws Throwable {
      MethodHandle handle = MethodHandles.lookup().findVirtual(String.class, "concat",
          MethodType.methodType(String.class, String.class));
  
      try {
        handle.invokeExact("a", new Object());
        System.out.println("invokeExact(\"a\", new Object()) unexpectedly succeeded.");
      } catch (WrongMethodTypeException ex) {
        System.out.println("Received exception: " + ex.getMessage());
      }
    }
  
    public interface Foo {
      public String foo();
    }
  
    public interface Bar extends Foo {
      public String bar();
    }
  
    public static abstract class BarAbstractSuper {
      public abstract String abstractSuperPublicMethod();
    }
  
    public static class BarSuper extends BarAbstractSuper {
      public String superPublicMethod() {
        return "superPublicMethod";
      }
  
      protected String superProtectedMethod() {
        return "superProtectedMethod";
      }
  
      public String abstractSuperPublicMethod() {
        return "abstractSuperPublicMethod";
      }
  
      String superPackageMethod() {
        return "superPackageMethod";
      }
    }
  
    public static class BarImpl extends BarSuper implements Bar {
      public BarImpl() {
      }
  
      @Override
      public String foo() {
        return "foo";
      }
  
      @Override
      public String bar() {
        return "bar";
      }
  
      public String add(int x, int y) {
        return Arrays.toString(new int[] { x, y });
      }
  
      private String privateMethod() { return "privateMethod"; }
  
      public static String staticMethod() { return staticString; }
  
      private static String staticString;
  
      {
        // Static constructor
        staticString = Long.toString(System.currentTimeMillis());
      }
  
      static final MethodHandles.Lookup lookup = MethodHandles.lookup();
    }
  
    public static void testfindVirtual() throws Throwable {
      // Virtual lookups on static methods should not succeed.
      try {
          MethodHandles.lookup().findVirtual(
              BarImpl.class,  "staticMethod", MethodType.methodType(String.class));
          System.out.println("findVirtual(staticMethod) unexpectedly succeeded");
      } catch (IllegalAccessException expected) {
      }
  
      // Virtual lookups on private methods should not succeed, unless the Lookup
      // context had sufficient privileges.
      try {
          MethodHandles.lookup().findVirtual(
              BarImpl.class,  "privateMethod", MethodType.methodType(String.class));
          System.out.println("findVirtual(privateMethod) unexpectedly succeeded");
      } catch (IllegalAccessException expected) {
      }
  
      // Virtual lookup on a private method with a context that *does* have sufficient
      // privileges.
      MethodHandle mh = BarImpl.lookup.findVirtual(
              BarImpl.class,  "privateMethod", MethodType.methodType(String.class));
      String str = (String) mh.invoke(new BarImpl());
      if (!"privateMethod".equals(str)) {
        System.out.println("Unexpected return value for BarImpl#privateMethod: " + str);
      }
  
      // Find virtual must find interface methods defined by interfaces implemented
      // by the class.
      mh = MethodHandles.lookup().findVirtual(BarImpl.class, "foo",
          MethodType.methodType(String.class));
      str = (String) mh.invoke(new BarImpl());
      if (!"foo".equals(str)) {
        System.out.println("Unexpected return value for BarImpl#foo: " + str);
      }
  
      // Find virtual should check rtype.
      try {
        mh = MethodHandles.lookup().findVirtual(BarImpl.class, "foo",
                                                MethodType.methodType(void.class));
        fail();
      } catch (NoSuchMethodException e) {}
  
      // And ptypes
      mh = MethodHandles.lookup().findVirtual(
          BarImpl.class, "add", MethodType.methodType(String.class, int.class, int.class));
      try {
        mh = MethodHandles.lookup().findVirtual(
            BarImpl.class, "add", MethodType.methodType(String.class, Integer.class, int.class));
      } catch (NoSuchMethodException e) {}
  
      // .. and their super-interfaces.
      mh = MethodHandles.lookup().findVirtual(BarImpl.class, "bar",
          MethodType.methodType(String.class));
      str = (String) mh.invoke(new BarImpl());
      if (!"bar".equals(str)) {
        System.out.println("Unexpected return value for BarImpl#bar: " + str);
      }
  
      mh = MethodHandles.lookup().findVirtual(Bar.class, "bar",
                                              MethodType.methodType(String.class));
      str = (String) mh.invoke(new BarImpl());
      if (!"bar".equals(str)) {
        System.out.println("Unexpected return value for BarImpl#bar: " + str);
      }
  
      mh = MethodHandles.lookup().findVirtual(BarAbstractSuper.class, "abstractSuperPublicMethod",
          MethodType.methodType(String.class));
      str = (String) mh.invoke(new BarImpl());
      if (!"abstractSuperPublicMethod".equals(str)) {
        System.out.println("Unexpected return value for BarImpl#abstractSuperPublicMethod: " + str);
      }
  
      // We should also be able to lookup public / protected / package methods in
      // the super class, given sufficient access privileges.
      mh = MethodHandles.lookup().findVirtual(BarImpl.class, "superPublicMethod",
          MethodType.methodType(String.class));
      str = (String) mh.invoke(new BarImpl());
      if (!"superPublicMethod".equals(str)) {
        System.out.println("Unexpected return value for BarImpl#superPublicMethod: " + str);
      }
  
      mh = MethodHandles.lookup().findVirtual(BarImpl.class, "superProtectedMethod",
          MethodType.methodType(String.class));
      str = (String) mh.invoke(new BarImpl());
      if (!"superProtectedMethod".equals(str)) {
        System.out.println("Unexpected return value for BarImpl#superProtectedMethod: " + str);
      }
  
      mh = MethodHandles.lookup().findVirtual(BarImpl.class, "superPackageMethod",
          MethodType.methodType(String.class));
      str = (String) mh.invoke(new BarImpl());
      if (!"superPackageMethod".equals(str)) {
        System.out.println("Unexpected return value for BarImpl#superPackageMethod: " + str);
      }
  
      try {
        MethodHandles.lookup().findVirtual(BarImpl.class, "<init>",
                                          MethodType.methodType(void.class));
        fail();
      } catch (NoSuchMethodException e) {}
    }
  
    public static void testfindStatic() throws Throwable {
      MethodHandles.lookup().findStatic(BarImpl.class, "staticMethod",
                                        MethodType.methodType(String.class));
      try {
        MethodHandles.lookup().findStatic(BarImpl.class, "staticMethod",
                                          MethodType.methodType(void.class));
        fail();
      } catch (NoSuchMethodException e) {}
      try {
        MethodHandles.lookup().findStatic(BarImpl.class, "staticMethod",
                                          MethodType.methodType(String.class, int.class));
        fail();
      } catch (NoSuchMethodException e) {}
      try {
        MethodHandles.lookup().findStatic(BarImpl.class, "<clinit>",
                                          MethodType.methodType(void.class));
        fail();
      } catch (NoSuchMethodException e) {}
      try {
        MethodHandles.lookup().findStatic(BarImpl.class, "<init>",
                                          MethodType.methodType(void.class));
        fail();
      } catch (NoSuchMethodException e) {}
    }
  
    static class UnreflectTester {
      public String publicField;
      private String privateField;
  
      public static String publicStaticField = "publicStaticValue";
      private static String privateStaticField = "privateStaticValue";
  
      private UnreflectTester(String val) {
        publicField = val;
        privateField = val;
      }
  
      // NOTE: The boolean constructor argument only exists to give this a
      // different signature.
      public UnreflectTester(String val, boolean unused) {
        this(val);
      }
  
      private static String privateStaticMethod() {
        return "privateStaticMethod";
      }
  
      private String privateMethod() {
        return "privateMethod";
      }
  
      public static String publicStaticMethod() {
        return "publicStaticMethod";
      }
  
      public String publicMethod() {
        return "publicMethod";
      }
  
      public String publicVarArgsMethod(String... args) {
        return "publicVarArgsMethod";
      }
    }
  
    public static void testUnreflects() throws Throwable {
      UnreflectTester instance = new UnreflectTester("unused");
      Method publicMethod = UnreflectTester.class.getMethod("publicMethod");
  
      MethodHandle mh = MethodHandles.lookup().unreflect(publicMethod);
      assertEquals("publicMethod", (String) mh.invoke(instance));
      assertEquals("publicMethod", (String) mh.invokeExact(instance));
  
      Method publicStaticMethod = UnreflectTester.class.getMethod("publicStaticMethod");
      mh = MethodHandles.lookup().unreflect(publicStaticMethod);
      assertEquals("publicStaticMethod", (String) mh.invoke());
      assertEquals("publicStaticMethod", (String) mh.invokeExact());
  
      Method privateMethod = UnreflectTester.class.getDeclaredMethod("privateMethod");
      try {
        mh = MethodHandles.lookup().unreflect(privateMethod);
        fail();
      } catch (IllegalAccessException expected) {}
  
      privateMethod.setAccessible(true);
      mh = MethodHandles.lookup().unreflect(privateMethod);
      assertEquals("privateMethod", (String) mh.invoke(instance));
      assertEquals("privateMethod", (String) mh.invokeExact(instance));
  
      Method privateStaticMethod = UnreflectTester.class.getDeclaredMethod("privateStaticMethod");
      try {
        mh = MethodHandles.lookup().unreflect(privateStaticMethod);
        fail();
      } catch (IllegalAccessException expected) {}
  
      privateStaticMethod.setAccessible(true);
      mh = MethodHandles.lookup().unreflect(privateStaticMethod);
      assertEquals("privateStaticMethod", (String) mh.invoke());
      assertEquals("privateStaticMethod", (String) mh.invokeExact());
  
      Constructor privateConstructor = UnreflectTester.class.getDeclaredConstructor(String.class);
      try {
        mh = MethodHandles.lookup().unreflectConstructor(privateConstructor);
        fail();
      } catch (IllegalAccessException expected) {}
  
      privateConstructor.setAccessible(true);
      mh = MethodHandles.lookup().unreflectConstructor(privateConstructor);
      instance = (UnreflectTester) mh.invokeExact("abc");
      assertEquals("abc", instance.publicField);
      instance = (UnreflectTester) mh.invoke("def");
      assertEquals("def", instance.publicField);
      Constructor publicConstructor = UnreflectTester.class.getConstructor(String.class,
          boolean.class);
      mh = MethodHandles.lookup().unreflectConstructor(publicConstructor);
      instance = (UnreflectTester) mh.invokeExact("abc", false);
      assertEquals("abc", instance.publicField);
      instance = (UnreflectTester) mh.invoke("def", true);
      assertEquals("def", instance.publicField);
  
      // TODO(narayan): Non exact invokes for field sets/gets are not implemented yet.
      //
      // assertEquals("instanceValue", (String) mh.invoke(new UnreflectTester("instanceValue")));
      Field publicField = UnreflectTester.class.getField("publicField");
      mh = MethodHandles.lookup().unreflectGetter(publicField);
      instance = new UnreflectTester("instanceValue");
      assertEquals("instanceValue", (String) mh.invokeExact(instance));
  
      mh = MethodHandles.lookup().unreflectSetter(publicField);
      instance = new UnreflectTester("instanceValue");
      mh.invokeExact(instance, "updatedInstanceValue");
      assertEquals("updatedInstanceValue", instance.publicField);
  
      Field publicStaticField = UnreflectTester.class.getField("publicStaticField");
      mh = MethodHandles.lookup().unreflectGetter(publicStaticField);
      UnreflectTester.publicStaticField = "updatedStaticValue";
      assertEquals("updatedStaticValue", (String) mh.invokeExact());
  
      mh = MethodHandles.lookup().unreflectSetter(publicStaticField);
      UnreflectTester.publicStaticField = "updatedStaticValue";
      mh.invokeExact("updatedStaticValue2");
      assertEquals("updatedStaticValue2", UnreflectTester.publicStaticField);
  
      Field privateField = UnreflectTester.class.getDeclaredField("privateField");
      try {
        mh = MethodHandles.lookup().unreflectGetter(privateField);
        fail();
      } catch (IllegalAccessException expected) {
      }
      try {
        mh = MethodHandles.lookup().unreflectSetter(privateField);
        fail();
      } catch (IllegalAccessException expected) {
      }
  
      privateField.setAccessible(true);
  
      mh = MethodHandles.lookup().unreflectGetter(privateField);
      instance = new UnreflectTester("instanceValue");
      assertEquals("instanceValue", (String) mh.invokeExact(instance));
  
      mh = MethodHandles.lookup().unreflectSetter(privateField);
      instance = new UnreflectTester("instanceValue");
      mh.invokeExact(instance, "updatedInstanceValue");
      assertEquals("updatedInstanceValue", instance.privateField);
  
      Field privateStaticField = UnreflectTester.class.getDeclaredField("privateStaticField");
      try {
        mh = MethodHandles.lookup().unreflectGetter(privateStaticField);
        fail();
      } catch (IllegalAccessException expected) {
      }
      try {
        mh = MethodHandles.lookup().unreflectSetter(privateStaticField);
        fail();
      } catch (IllegalAccessException expected) {
      }
  
      privateStaticField.setAccessible(true);
      mh = MethodHandles.lookup().unreflectGetter(privateStaticField);
      privateStaticField.set(null, "updatedStaticValue");
      assertEquals("updatedStaticValue", (String) mh.invokeExact());
  
      mh = MethodHandles.lookup().unreflectSetter(privateStaticField);
      privateStaticField.set(null, "updatedStaticValue");
      mh.invokeExact("updatedStaticValue2");
      assertEquals("updatedStaticValue2", (String) privateStaticField.get(null));
    }
  
    // This method only exists to fool Jack's handling of types. See b/32536744.
    public static CharSequence getSequence() {
      return "foo";
    }
  
    public static void testAsType() throws Throwable {
      // The type of this handle is (String, String)String.
      MethodHandle mh = MethodHandles.lookup().findVirtual(String.class,
          "concat", MethodType.methodType(String.class, String.class));
  
      // Change it to (CharSequence, String)Object.
      MethodHandle asType = mh.asType(
          MethodType.methodType(Object.class, CharSequence.class, String.class));
  
      Object obj = asType.invokeExact((CharSequence) getSequence(), "bar");
      assertEquals("foobar", (String) obj);
  
      // Should fail due to a wrong return type.
      try {
        String str = (String) asType.invokeExact((CharSequence) getSequence(), "bar");
        fail();
      } catch (WrongMethodTypeException expected) {
      }
  
      // Should fail due to a wrong argument type (String instead of Charsequence).
      try {
        String str = (String) asType.invokeExact("baz", "bar");
        fail();
      } catch (WrongMethodTypeException expected) {
      }
  
      // Calls to asType should fail if the types are not convertible.
      //
      // Bad return type conversion.
      try {
        mh.asType(MethodType.methodType(int.class, String.class, String.class));
        fail();
      } catch (WrongMethodTypeException expected) {
      }
  
      // Bad argument conversion.
      try {
        mh.asType(MethodType.methodType(String.class, int.class, String.class));
        fail();
      } catch (WrongMethodTypeException expected) {
      }
    }
  
    public static void assertTrue(boolean value) {
      if (!value) {
        throw new AssertionError("assertTrue value: " + value);
      }
    }
  
    public static void assertFalse(boolean value) {
      if (value) {
        throw new AssertionError("assertTrue value: " + value);
      }
    }
  
    public static void assertEquals(int i1, int i2) {
      if (i1 == i2) { return; }
      throw new AssertionError("assertEquals i1: " + i1 + ", i2: " + i2);
    }
  
    public static void assertEquals(long i1, long i2) {
      if (i1 == i2) { return; }
      throw new AssertionError("assertEquals l1: " + i1 + ", l2: " + i2);
    }
  
    public static void assertEquals(Object o, Object p) {
      if (o == p) { return; }
      if (o != null && p != null && o.equals(p)) { return; }
      throw new AssertionError("assertEquals: o1: " + o + ", o2: " + p);
    }
  
    public static void assertEquals(String s1, String s2) {
      if (s1 == s2) {
        return;
      }
  
      if (s1 != null && s2 != null && s1.equals(s2)) {
        return;
      }
  
      throw new AssertionError("assertEquals s1: " + s1 + ", s2: " + s2);
    }
  
    public static void fail() {
      System.out.println("fail");
      Thread.dumpStack();
    }
  
    public static void fail(String message) {
      System.out.println("fail: " + message);
      Thread.dumpStack();
    }
  
    public static void testConstructors() throws Throwable {
      MethodHandle mh =
          MethodHandles.lookup().findConstructor(Float.class,
                                                 MethodType.methodType(void.class,
                                                                       float.class));
      Float value = (Float) mh.invokeExact(0.33f);
      if (value.floatValue() != 0.33f) {
        fail("Unexpected float value from invokeExact " + value.floatValue());
      }
  
      value = (Float) mh.invoke(3.34f);
      if (value.floatValue() != 3.34f) {
        fail("Unexpected float value from invoke " + value.floatValue());
      }
  
      mh = MethodHandles.lookup().findConstructor(Double.class,
                                                  MethodType.methodType(void.class, String.class));
      Double d = (Double) mh.invoke("8.45e3");
      if (d.doubleValue() != 8.45e3) {
        fail("Unexpected double value from Double(String) " + value.doubleValue());
      }
  
      mh = MethodHandles.lookup().findConstructor(Double.class,
                                                  MethodType.methodType(void.class, double.class));
      d = (Double) mh.invoke(8.45e3);
      if (d.doubleValue() != 8.45e3) {
        fail("Unexpected double value from Double(double) " + value.doubleValue());
      }
  
      // Primitive type
      try {
        mh = MethodHandles.lookup().findConstructor(int.class, MethodType.methodType(void.class));
        fail("Unexpected lookup success for primitive constructor");
      } catch (NoSuchMethodException e) {}
  
      // Interface
      try {
        mh = MethodHandles.lookup().findConstructor(Readable.class,
                                                    MethodType.methodType(void.class));
        fail("Unexpected lookup success for interface constructor");
      } catch (NoSuchMethodException e) {}
  
      // Abstract
      mh = MethodHandles.lookup().findConstructor(Process.class, MethodType.methodType(void.class));
      try {
        mh.invoke();
        fail("Unexpected ability to instantiate an abstract class");
      } catch (InstantiationException e) {}
  
      // Non-existent
      try {
          MethodHandle bad = MethodHandles.lookup().findConstructor(
              String.class, MethodType.methodType(String.class, Float.class));
          fail("Unexpected success for non-existent constructor");
      } catch (NoSuchMethodException e) {}
  
      // Non-void constructor search. (I)I instead of (I)V.
      try {
          MethodHandle foo = MethodHandles.lookup().findConstructor(
              Integer.class, MethodType.methodType(Integer.class, Integer.class));
          fail("Unexpected success for non-void type for findConstructor");
      } catch (NoSuchMethodException e) {}
  
      // Array class constructor.
      try {
          MethodHandle foo = MethodHandles.lookup().findConstructor(
              Object[].class, MethodType.methodType(void.class));
          fail("Unexpected success for array class type for findConstructor");
      } catch (NoSuchMethodException e) {}
    }
  
    public static void testStringConstructors() throws Throwable {
      final String testPattern = "The system as we know it is broken";
  
      // String()
      MethodHandle mh = MethodHandles.lookup().findConstructor(
          String.class, MethodType.methodType(void.class));
      String s = (String) mh.invokeExact();
      if (!s.equals("")) {
        fail("Unexpected empty string constructor result: '" + s + "'");
      }
  
      // String(String)
      mh = MethodHandles.lookup().findConstructor(
          String.class, MethodType.methodType(void.class, String.class));
      s = (String) mh.invokeExact(testPattern);
      if (!s.equals(testPattern)) {
        fail("Unexpected string constructor result: '" + s + "'");
      }
  
      // String(char[])
      mh = MethodHandles.lookup().findConstructor(
          String.class, MethodType.methodType(void.class, char[].class));
      s = (String) mh.invokeExact(testPattern.toCharArray());
      if (!s.equals(testPattern)) {
        fail("Unexpected string constructor result: '" + s + "'");
      }
  
      // String(char[], int, int)
      mh = MethodHandles.lookup().findConstructor(
          String.class, MethodType.methodType(void.class, char[].class, int.class, int.class));
      s = (String) mh.invokeExact(new char [] { 'a', 'b', 'c', 'd', 'e'}, 2, 3);
      if (!s.equals("cde")) {
        fail("Unexpected string constructor result: '" + s + "'");
      }
  
      // String(int[] codePoints, int offset, int count)
      StringBuffer sb = new StringBuffer(testPattern);
      int[] codePoints = new int[sb.codePointCount(0, sb.length())];
      for (int i = 0; i < sb.length(); ++i) {
        codePoints[i] = sb.codePointAt(i);
      }
      mh = MethodHandles.lookup().findConstructor(
          String.class, MethodType.methodType(void.class, int[].class, int.class, int.class));
      s = (String) mh.invokeExact(codePoints, 0, codePoints.length);
      if (!s.equals(testPattern)) {
        fail("Unexpected string constructor result: '" + s + "'");
      }
  
      // String(byte ascii[], int hibyte, int offset, int count)
      byte [] ascii = testPattern.getBytes(StandardCharsets.US_ASCII);
      mh = MethodHandles.lookup().findConstructor(
          String.class, MethodType.methodType(void.class, byte[].class, int.class, int.class));
      s = (String) mh.invokeExact(ascii, 0, ascii.length);
      if (!s.equals(testPattern)) {
        fail("Unexpected string constructor result: '" + s + "'");
      }
  
      // String(byte bytes[], int offset, int length, String charsetName)
      mh = MethodHandles.lookup().findConstructor(
          String.class,
          MethodType.methodType(void.class, byte[].class, int.class, int.class, String.class));
      s = (String) mh.invokeExact(ascii, 0, 5, StandardCharsets.US_ASCII.name());
      if (!s.equals(testPattern.substring(0, 5))) {
        fail("Unexpected string constructor result: '" + s + "'");
      }
  
      // String(byte bytes[], int offset, int length, Charset charset)
      mh = MethodHandles.lookup().findConstructor(
          String.class,
          MethodType.methodType(void.class, byte[].class, int.class, int.class, Charset.class));
      s = (String) mh.invokeExact(ascii, 0, 5, StandardCharsets.US_ASCII);
      if (!s.equals(testPattern.substring(0, 5))) {
        fail("Unexpected string constructor result: '" + s + "'");
      }
  
      // String(byte bytes[], String charsetName)
      mh = MethodHandles.lookup().findConstructor(
          String.class,
          MethodType.methodType(void.class, byte[].class, String.class));
      s = (String) mh.invokeExact(ascii, StandardCharsets.US_ASCII.name());
      if (!s.equals(testPattern)) {
        fail("Unexpected string constructor result: '" + s + "'");
      }
  
      // String(byte bytes[], Charset charset)
      mh = MethodHandles.lookup().findConstructor(
          String.class, MethodType.methodType(void.class, byte[].class, Charset.class));
      s = (String) mh.invokeExact(ascii, StandardCharsets.US_ASCII);
      if (!s.equals(testPattern)) {
        fail("Unexpected string constructor result: '" + s + "'");
      }
  
      // String(byte bytes[], int offset, int length)
      mh = MethodHandles.lookup().findConstructor(
          String.class, MethodType.methodType(void.class, byte[].class, int.class, int.class));
      s = (String) mh.invokeExact(ascii, 1, ascii.length - 2);
      s = testPattern.charAt(0) + s + testPattern.charAt(testPattern.length() - 1);
      if (!s.equals(testPattern)) {
        fail("Unexpected string constructor result: '" + s + "'");
      }
  
      // String(byte bytes[])
      mh = MethodHandles.lookup().findConstructor(
          String.class, MethodType.methodType(void.class, byte[].class));
      s = (String) mh.invokeExact(ascii);
      if (!s.equals(testPattern)) {
        fail("Unexpected string constructor result: '" + s + "'");
      }
  
      // String(StringBuffer buffer)
      mh = MethodHandles.lookup().findConstructor(
          String.class, MethodType.methodType(void.class, StringBuffer.class));
      s = (String) mh.invokeExact(sb);
      if (!s.equals(testPattern)) {
        fail("Unexpected string constructor result: '" + s + "'");
      }
  
      System.out.println("String constructors done.");
    }
  
    private static void testReferenceReturnValueConversions() throws Throwable {
      MethodHandle mh = MethodHandles.lookup().findStatic(
          Float.class, "valueOf", MethodType.methodType(Float.class, String.class));
  
      // No conversion
      Float f = (Float) mh.invokeExact("1.375");
      if (f.floatValue() != 1.375) {
        fail();
      }
      f = (Float) mh.invoke("1.875");
      if (f.floatValue() != 1.875) {
        fail();
      }
  
      // Bad conversion
      try {
        int i = (int) mh.invokeExact("7.77");
        fail();
      } catch (WrongMethodTypeException e) {}
  
      try {
        int i = (int) mh.invoke("7.77");
        fail();
      } catch (WrongMethodTypeException e) {}
  
      // Assignment to super-class.
      Number n = (Number) mh.invoke("1.11");
      try {
        Number o = (Number) mh.invokeExact("1.11");
        fail();
      } catch (WrongMethodTypeException e) {}
  
      // Assignment to widened boxed primitive class.
      try {
        Double u = (Double) mh.invoke("1.11");
        fail();
      } catch (ClassCastException e) {}
  
      try {
        Double v = (Double) mh.invokeExact("1.11");
        fail();
      } catch (WrongMethodTypeException e) {}
  
      // Unboxed
      float p = (float) mh.invoke("1.11");
      if (p != 1.11f) {
        fail();
      }
  
      // Unboxed and widened
      double d = (double) mh.invoke("2.5");
      if (d != 2.5) {
        fail();
      }
  
      // Interface
      Comparable<Float> c = (Comparable<Float>) mh.invoke("2.125");
      if (c.compareTo(new Float(2.125f)) != 0) {
        fail();
      }
  
      System.out.println("testReferenceReturnValueConversions done.");
    }
  
    private static void testPrimitiveReturnValueConversions() throws Throwable {
      MethodHandle mh = MethodHandles.lookup().findStatic(
          Math.class, "min", MethodType.methodType(int.class, int.class, int.class));
  
      final int SMALL = -8972;
      final int LARGE = 7932529;
  
      // No conversion
      if ((int) mh.invokeExact(LARGE, SMALL) != SMALL) {
        fail();
      } else if ((int) mh.invoke(LARGE, SMALL) != SMALL) {
        fail();
      } else if ((int) mh.invokeExact(SMALL, LARGE) != SMALL) {
        fail();
      } else if ((int) mh.invoke(SMALL, LARGE) != SMALL) {
        fail();
      }
  
      // int -> long
      try {
        if ((long) mh.invokeExact(LARGE, SMALL) != (long) SMALL) {}
          fail();
      } catch (WrongMethodTypeException e) {}
  
      if ((long) mh.invoke(LARGE, SMALL) != (long) SMALL) {
        fail();
      }
  
      // int -> short
      try {
        if ((short) mh.invokeExact(LARGE, SMALL) != (short) SMALL) {}
        fail();
      } catch (WrongMethodTypeException e) {}
  
      try {
        if ((short) mh.invoke(LARGE, SMALL) != (short) SMALL) {
          fail();
        }
      } catch (WrongMethodTypeException e) {}
  
      // int -> Integer
      try {
        if (!((Integer) mh.invokeExact(LARGE, SMALL)).equals(new Integer(SMALL))) {}
        fail();
      } catch (WrongMethodTypeException e) {}
  
      if (!((Integer) mh.invoke(LARGE, SMALL)).equals(new Integer(SMALL))) {
        fail();
      }
  
      // int -> Long
      try {
        Long l = (Long) mh.invokeExact(LARGE, SMALL);
        fail();
      } catch (WrongMethodTypeException e) {}
  
      try {
        Long l = (Long) mh.invoke(LARGE, SMALL);
        fail();
      } catch (WrongMethodTypeException e) {}
  
      // int -> Short
      try {
        Short s = (Short) mh.invokeExact(LARGE, SMALL);
        fail();
      } catch (WrongMethodTypeException e) {}
  
      try {
        Short s = (Short) mh.invoke(LARGE, SMALL);
        fail();
      } catch (WrongMethodTypeException e) {}
  
      // int -> Process
      try {
        Process p = (Process) mh.invokeExact(LARGE, SMALL);
        fail();
      } catch (WrongMethodTypeException e) {}
  
      try {
        Process p = (Process) mh.invoke(LARGE, SMALL);
        fail();
      } catch (WrongMethodTypeException e) {}
  
      // void -> Object
      mh = MethodHandles.lookup().findStatic(System.class, "gc", MethodType.methodType(void.class));
      Object o = (Object) mh.invoke();
      if (o != null) fail();
  
      // void -> long
      long l = (long) mh.invoke();
      if (l != 0) fail();
  
      // boolean -> Boolean
      mh = MethodHandles.lookup().findStatic(Boolean.class, "parseBoolean",
                                             MethodType.methodType(boolean.class, String.class));
      Boolean z = (Boolean) mh.invoke("True");
      if (!z.booleanValue()) fail();
  
      // boolean -> int
      try {
          int dummy = (int) mh.invoke("True");
          fail();
      } catch (WrongMethodTypeException e) {}
  
      // boolean -> Integer
      try {
          Integer dummy = (Integer) mh.invoke("True");
          fail();
      } catch (WrongMethodTypeException e) {}
  
      // Boolean -> boolean
      mh = MethodHandles.lookup().findStatic(Boolean.class, "valueOf",
                                             MethodType.methodType(Boolean.class, boolean.class));
      boolean w = (boolean) mh.invoke(false);
      if (w) fail();
  
      // Boolean -> int
      try {
          int dummy = (int) mh.invoke(false);
          fail();
      } catch (WrongMethodTypeException e) {}
  
      // Boolean -> Integer
      try {
          Integer dummy = (Integer) mh.invoke("True");
          fail();
      } catch (WrongMethodTypeException e) {}
  
      System.out.println("testPrimitiveReturnValueConversions done.");
    }
  
    public static void testReturnValueConversions() throws Throwable {
      testReferenceReturnValueConversions();
      testPrimitiveReturnValueConversions();
    }
  
    public static class BaseVariableArityTester {
      public String update(Float f0, Float... floats) {
        return "base " + f0 + ", " + Arrays.toString(floats);
      }
    }
  
    public static class VariableArityTester extends BaseVariableArityTester {
      private String lastResult;
  
      // Constructors
      public VariableArityTester() {}
      public VariableArityTester(boolean... booleans) { update(booleans); }
      public VariableArityTester(byte... bytes) { update(bytes); }
      public VariableArityTester(char... chars) { update(chars); }
      public VariableArityTester(short... shorts) { update(shorts); }
      public VariableArityTester(int... ints) { update(ints); }
      public VariableArityTester(long... longs) { update(longs); }
      public VariableArityTester(float... floats) { update(floats); }
      public VariableArityTester(double... doubles) { update(doubles); }
      public VariableArityTester(Float f0, Float... floats) { update(f0, floats); }
      public VariableArityTester(String s0, String... strings) { update(s0, strings); }
      public VariableArityTester(char c, Number... numbers) { update(c, numbers); }
      @SafeVarargs
      public VariableArityTester(ArrayList<Integer> l0, ArrayList<Integer>... lists) {
        update(l0, lists);
      }
      public VariableArityTester(List l0, List... lists) { update(l0, lists); }
  
      // Methods
      public String update(boolean... booleans) { return lastResult = tally(booleans); }
      public String update(byte... bytes) { return lastResult = tally(bytes); }
      public String update(char... chars) { return lastResult = tally(chars); }
      public String update(short... shorts) { return lastResult = tally(shorts); }
      public String update(int... ints) {
        lastResult = tally(ints);
        return lastResult;
      }
      public String update(long... longs) { return lastResult = tally(longs); }
      public String update(float... floats) { return lastResult = tally(floats); }
      public String update(double... doubles) { return lastResult = tally(doubles); }
      @Override
      public String update(Float f0, Float... floats) { return lastResult = tally(f0, floats); }
      public String update(String s0, String... strings) { return lastResult = tally(s0, strings); }
      public String update(char c, Number... numbers) { return lastResult = tally(c, numbers); }
      @SafeVarargs
      public final String update(ArrayList<Integer> l0, ArrayList<Integer>... lists) {
        lastResult = tally(l0, lists);
        return lastResult;
      }
      public String update(List l0, List... lists) { return lastResult = tally(l0, lists); }
  
      public String arrayMethod(Object[] o) {
        return Arrays.deepToString(o);
      }
  
      public String lastResult() { return lastResult; }
  
      // Static Methods
      public static String tally(boolean... booleans) { return Arrays.toString(booleans); }
      public static String tally(byte... bytes) { return Arrays.toString(bytes); }
      public static String tally(char... chars) { return Arrays.toString(chars); }
      public static String tally(short... shorts) { return Arrays.toString(shorts); }
      public static String tally(int... ints) { return Arrays.toString(ints); }
      public static String tally(long... longs) { return Arrays.toString(longs); }
      public static String tally(float... floats) { return Arrays.toString(floats); }
      public static String tally(double... doubles) { return Arrays.toString(doubles); }
      public static String tally(Float f0, Float... floats) {
        return f0 + ", " + Arrays.toString(floats);
      }
      public static String tally(String s0, String... strings) {
        return s0 + ", " + Arrays.toString(strings);
      }
      public static String tally(char c, Number... numbers) {
        return c + ", " + Arrays.toString(numbers);
      }
      @SafeVarargs
      public static String tally(ArrayList<Integer> l0, ArrayList<Integer>... lists) {
        return Arrays.toString(l0.toArray()) + ", " + Arrays.deepToString(lists);
      }
      public static String tally(List l0, List... lists) {
        return Arrays.deepToString(l0.toArray()) + ", " + Arrays.deepToString(lists);
      }
      public static void foo(int... ints) { System.out.println(Arrays.toString(ints)); }
      public static long sumToPrimitive(int... ints) {
        long result = 0;
        for (int i : ints) result += i;
        return result;
      }
      public static Long sumToReference(int... ints) {
        System.out.println("Hi");
        return new Long(sumToPrimitive(ints));
      }
      public static MethodHandles.Lookup lookup() {
        return MethodHandles.lookup();
      }
    }
  
    // This method only exists to fool Jack's handling of types. See b/32536744.
    public static Object getAsObject(String[] strings) {
      return (Object) strings;
    }
  
    public static void testVariableArity() throws Throwable {
      MethodHandle mh;
      VariableArityTester vat = new VariableArityTester();
  
      assertEquals("[1]", vat.update(1));
      assertEquals("[1, 1]", vat.update(1, 1));
      assertEquals("[1, 1, 1]", vat.update(1, 1, 1));
  
      // Methods - boolean
      mh = MethodHandles.lookup().findVirtual(VariableArityTester.class, "update",
                                              MethodType.methodType(String.class, boolean[].class));
      assertTrue(mh.isVarargsCollector());
      assertFalse(mh.asFixedArity().isVarargsCollector());
      assertEquals("[]", mh.invoke(vat));
      assertEquals("[true, false, true]", mh.invoke(vat, true, false, true));
      assertEquals("[true, false, true]", mh.invoke(vat, new boolean[] { true, false, true}));
      assertEquals("[false, true]", mh.invoke(vat, Boolean.valueOf(false), Boolean.valueOf(true)));
      try {
        mh.invoke(vat, true, true, 0);
        fail();
      } catch (WrongMethodTypeException e) {}
      try {
        assertEquals("[false, true]", mh.invoke(vat, Boolean.valueOf(false), (Boolean) null));
        fail();
      } catch (NullPointerException e) {}
  
      // Methods - byte
      mh = MethodHandles.lookup().findVirtual(VariableArityTester.class, "update",
                                              MethodType.methodType(String.class, byte[].class));
      assertTrue(mh.isVarargsCollector());
      assertEquals("[]", mh.invoke(vat));
      assertEquals("[32, 64, 97]", mh.invoke(vat, (byte) 32, Byte.valueOf((byte) 64), (byte) 97));
      assertEquals("[32, 64, 97]", mh.invoke(vat, new byte[] {(byte) 32, (byte) 64, (byte) 97}));
      try {
        mh.invoke(vat, (byte) 1, Integer.valueOf(3), (byte) 0);
        fail();
      } catch (WrongMethodTypeException e) {}
  
      // Methods - char
      mh = MethodHandles.lookup().findVirtual(VariableArityTester.class, "update",
                                              MethodType.methodType(String.class, char[].class));
      assertTrue(mh.isVarargsCollector());
      assertEquals("[]", mh.invoke(vat));
      assertEquals("[A, B, C]", mh.invoke(vat, 'A', Character.valueOf('B'), 'C'));
      assertEquals("[W, X, Y, Z]", mh.invoke(vat, new char[] { 'W', 'X', 'Y', 'Z' }));
  
      // Methods - short
      mh = MethodHandles.lookup().findVirtual(VariableArityTester.class, "update",
                                              MethodType.methodType(String.class, short[].class));
      assertTrue(mh.isVarargsCollector());
      assertEquals("[]", mh.invoke(vat));
      assertEquals("[32767, -32768, 0]",
                   mh.invoke(vat, Short.MAX_VALUE, Short.MIN_VALUE, Short.valueOf((short) 0)));
      assertEquals("[1, -1]", mh.invoke(vat, new short[] { (short) 1, (short) -1 }));
  
      // Methods - int
      mh = MethodHandles.lookup().findVirtual(VariableArityTester.class, "update",
                                              MethodType.methodType(String.class, int[].class));
      assertTrue(mh.isVarargsCollector());
      assertEquals("[]", mh.invoke(vat));
      assertEquals("[0, 2147483647, -2147483648, 0]",
                   mh.invoke(vat, Integer.valueOf(0), Integer.MAX_VALUE, Integer.MIN_VALUE, 0));
      assertEquals("[0, -1, 1, 0]", mh.invoke(vat, new int[] { 0, -1, 1, 0 }));
  
      assertEquals("[5, 4, 3, 2, 1]", (String) mh.invokeExact(vat, new int [] { 5, 4, 3, 2, 1 }));
      try {
        assertEquals("[5, 4, 3, 2, 1]", (String) mh.invokeExact(vat, 5, 4, 3, 2, 1));
        fail();
      } catch (WrongMethodTypeException e) {}
      assertEquals("[5, 4, 3, 2, 1]", (String) mh.invoke(vat, 5, 4, 3, 2, 1));
  
      // Methods - long
      mh = MethodHandles.lookup().findVirtual(VariableArityTester.class, "update",
                                              MethodType.methodType(String.class, long[].class));
      assertTrue(mh.isVarargsCollector());
      assertEquals("[]", mh.invoke(vat));
      assertEquals("[0, 9223372036854775807, -9223372036854775808]",
                   mh.invoke(vat, Long.valueOf(0), Long.MAX_VALUE, Long.MIN_VALUE));
      assertEquals("[0, -1, 1, 0]", mh.invoke(vat, new long[] { 0, -1, 1, 0 }));
  
      // Methods - float
      mh = MethodHandles.lookup().findVirtual(VariableArityTester.class, "update",
                                              MethodType.methodType(String.class, float[].class));
      assertTrue(mh.isVarargsCollector());
      assertEquals("[]", mh.invoke(vat));
      assertEquals("[0.0, 1.25, -1.25]",
                   mh.invoke(vat, 0.0f, Float.valueOf(1.25f), Float.valueOf(-1.25f)));
      assertEquals("[0.0, -1.0, 1.0, 0.0]",
                   mh.invoke(vat, new float[] { 0.0f, -1.0f, 1.0f, 0.0f }));
  
      // Methods - double
      mh = MethodHandles.lookup().findVirtual(VariableArityTester.class, "update",
                                              MethodType.methodType(String.class, double[].class));
      assertTrue(mh.isVarargsCollector());
      assertEquals("[]", mh.invoke(vat));
      assertEquals("[0.0, 1.25, -1.25]",
                   mh.invoke(vat, 0.0, Double.valueOf(1.25), Double.valueOf(-1.25)));
      assertEquals("[0.0, -1.0, 1.0, 0.0]",
                   mh.invoke(vat, new double[] { 0.0, -1.0, 1.0, 0.0 }));
      mh.invoke(vat, 0.3f, 1.33, 1.33);
  
      // Methods - String
      mh = MethodHandles.lookup().
          findVirtual(VariableArityTester.class, "update",
                      MethodType.methodType(String.class, String.class, String[].class));
      assertTrue(mh.isVarargsCollector());
      assertEquals("Echidna, []", mh.invoke(vat, "Echidna"));
      assertEquals("Bongo, [Jerboa, Okapi]",
                   mh.invoke(vat, "Bongo", "Jerboa", "Okapi"));
  
      // Methods - Float
      mh = MethodHandles.lookup().
          findVirtual(VariableArityTester.class, "update",
                      MethodType.methodType(String.class, Float.class, Float[].class));
      assertTrue(mh.isVarargsCollector());
      assertEquals("9.99, [0.0, 0.1, 1.1]",
                   (String) mh.invoke(vat, Float.valueOf(9.99f),
                                      new Float[] { Float.valueOf(0.0f),
                                                    Float.valueOf(0.1f),
                                                    Float.valueOf(1.1f) }));
      assertEquals("9.99, [0.0, 0.1, 1.1]",
                   (String) mh.invoke(vat, Float.valueOf(9.99f), Float.valueOf(0.0f),
                                      Float.valueOf(0.1f), Float.valueOf(1.1f)));
      assertEquals("9.99, [0.0, 0.1, 1.1]",
                   (String) mh.invoke(vat, Float.valueOf(9.99f), 0.0f, 0.1f, 1.1f));
      try {
        assertEquals("9.99, [77.0, 33.0, 64.0]",
                     (String) mh.invoke(vat, Float.valueOf(9.99f), 77, 33, 64));
        fail();
      } catch (WrongMethodTypeException e) {}
      assertEquals("9.99, [0.0, 0.1, 1.1]",
                   (String) mh.invokeExact(vat, Float.valueOf(9.99f),
                                           new Float[] { Float.valueOf(0.0f),
                                                         Float.valueOf(0.1f),
                                                         Float.valueOf(1.1f) }));
      assertEquals("9.99, [0.0, null, 1.1]",
                   (String) mh.invokeExact(vat, Float.valueOf(9.99f),
                                           new Float[] { Float.valueOf(0.0f),
                                                         null,
                                                         Float.valueOf(1.1f) }));
      try {
        assertEquals("9.99, [0.0, 0.1, 1.1]",
                     (String) mh.invokeExact(vat, Float.valueOf(9.99f), 0.0f, 0.1f, 1.1f));
        fail();
      } catch (WrongMethodTypeException e) {}
  
      // Methods - Number
      mh = MethodHandles.lookup().
          findVirtual(VariableArityTester.class, "update",
                      MethodType.methodType(String.class, char.class, Number[].class));
      assertTrue(mh.isVarargsCollector());
      assertFalse(mh.asFixedArity().isVarargsCollector());
      assertEquals("x, []",  (String) mh.invoke(vat, 'x'));
      assertEquals("x, [3.141]", (String) mh.invoke(vat, 'x', 3.141));
      assertEquals("x, [null, 3.131, 37]",
                   (String) mh.invoke(vat, 'x', null, 3.131, new Integer(37)));
      try {
        assertEquals("x, [null, 3.131, bad, 37]",
                     (String) mh.invoke(vat, 'x', null, 3.131, "bad", new Integer(37)));
        assertTrue(false);
        fail();
      } catch (ClassCastException e) {}
      try {
        assertEquals("x, [null, 3.131, bad, 37]",
                     (String) mh.invoke(
                         vat, 'x', (Process) null, 3.131, "bad", new Integer(37)));
        assertTrue(false);
        fail();
      } catch (ClassCastException e) {}
  
      // Methods - an array method that is not variable arity.
      mh = MethodHandles.lookup().findVirtual(
          VariableArityTester.class, "arrayMethod",
          MethodType.methodType(String.class, Object[].class));
      assertFalse(mh.isVarargsCollector());
      mh.invoke(vat, new Object[] { "123" });
      try {
        assertEquals("-", mh.invoke(vat, new Float(3), new Float(4)));
        fail();
      } catch (WrongMethodTypeException e) {}
      mh = mh.asVarargsCollector(Object[].class);
      assertTrue(mh.isVarargsCollector());
      assertEquals("[3.0, 4.0]", (String) mh.invoke(vat, new Float(3), new Float(4)));
  
      // Constructors - default
      mh = MethodHandles.lookup().findConstructor(
          VariableArityTester.class, MethodType.methodType(void.class));
      assertFalse(mh.isVarargsCollector());
  
      // Constructors - boolean
      mh = MethodHandles.lookup().findConstructor(
          VariableArityTester.class, MethodType.methodType(void.class, boolean[].class));
      assertTrue(mh.isVarargsCollector());
      assertEquals("[true, true, false]",
                   ((VariableArityTester) mh.invoke(new boolean[] {true, true, false})).lastResult());
      assertEquals("[true, true, false]",
                   ((VariableArityTester) mh.invoke(true, true, false)).lastResult());
      try {
        assertEquals("[true, true, false]",
                     ((VariableArityTester) mh.invokeExact(true, true, false)).lastResult());
        fail();
      } catch (WrongMethodTypeException e) {}
  
      // Constructors - byte
      mh = MethodHandles.lookup().findConstructor(
          VariableArityTester.class, MethodType.methodType(void.class, byte[].class));
      assertTrue(mh.isVarargsCollector());
      assertEquals("[55, 66, 60]",
                   ((VariableArityTester)
                    mh.invoke(new byte[] {(byte) 55, (byte) 66, (byte) 60})).lastResult());
      assertEquals("[55, 66, 60]",
                   ((VariableArityTester) mh.invoke(
                       (byte) 55, (byte) 66, (byte) 60)).lastResult());
      try {
        assertEquals("[55, 66, 60]",
                     ((VariableArityTester) mh.invokeExact(
                         (byte) 55, (byte) 66, (byte) 60)).lastResult());
        fail();
      } catch (WrongMethodTypeException e) {}
      try {
        assertEquals("[3, 3]",
                     ((VariableArityTester) mh.invoke(
                         new Number[] { Byte.valueOf((byte) 3), (byte) 3})).lastResult());
        fail();
      } catch (WrongMethodTypeException e) {}
  
      // Constructors - String (have a different path than other reference types).
      mh = MethodHandles.lookup().findConstructor(
          VariableArityTester.class, MethodType.methodType(void.class, String.class, String[].class));
      assertTrue(mh.isVarargsCollector());
      assertEquals("x, []", ((VariableArityTester) mh.invoke("x")).lastResult());
      assertEquals("x, [y]", ((VariableArityTester) mh.invoke("x", "y")).lastResult());
      assertEquals("x, [y, z]",
                   ((VariableArityTester) mh.invoke("x", new String[] { "y", "z" })).lastResult());
      try {
        assertEquals("x, [y]", ((VariableArityTester) mh.invokeExact("x", "y")).lastResult());
        fail();
      } catch (WrongMethodTypeException e) {}
      assertEquals("x, [null, z]",
                   ((VariableArityTester) mh.invoke("x", new String[] { null, "z" })).lastResult());
  
      // Constructors - Number
      mh = MethodHandles.lookup().findConstructor(
          VariableArityTester.class, MethodType.methodType(void.class, char.class, Number[].class));
      assertTrue(mh.isVarargsCollector());
      assertFalse(mh.asFixedArity().isVarargsCollector());
      assertEquals("x, []", ((VariableArityTester) mh.invoke('x')).lastResult());
      assertEquals("x, [3.141]", ((VariableArityTester) mh.invoke('x', 3.141)).lastResult());
      assertEquals("x, [null, 3.131, 37]",
                   ((VariableArityTester) mh.invoke('x', null, 3.131, new Integer(37))).lastResult());
      try {
        assertEquals("x, [null, 3.131, bad, 37]",
                     ((VariableArityTester) mh.invoke(
                         'x', null, 3.131, "bad", new Integer(37))).lastResult());
        assertTrue(false);
        fail();
      } catch (ClassCastException e) {}
      try {
        assertEquals("x, [null, 3.131, bad, 37]",
                     ((VariableArityTester) mh.invoke(
                         'x', (Process) null, 3.131, "bad", new Integer(37))).lastResult());
        assertTrue(false);
        fail();
      } catch (ClassCastException e) {}
  
      // Static Methods - Float
      mh = MethodHandles.lookup().
          findStatic(VariableArityTester.class, "tally",
                     MethodType.methodType(String.class, Float.class, Float[].class));
      assertTrue(mh.isVarargsCollector());
      assertEquals("9.99, [0.0, 0.1, 1.1]",
                   (String) mh.invoke(Float.valueOf(9.99f),
                                      new Float[] { Float.valueOf(0.0f),
                                                    Float.valueOf(0.1f),
                                                    Float.valueOf(1.1f) }));
      assertEquals("9.99, [0.0, 0.1, 1.1]",
                   (String) mh.invoke(Float.valueOf(9.99f), Float.valueOf(0.0f),
                                      Float.valueOf(0.1f), Float.valueOf(1.1f)));
      assertEquals("9.99, [0.0, 0.1, 1.1]",
                   (String) mh.invoke(Float.valueOf(9.99f), 0.0f, 0.1f, 1.1f));
      try {
        assertEquals("9.99, [77.0, 33.0, 64.0]",
                     (String) mh.invoke(Float.valueOf(9.99f), 77, 33, 64));
        fail();
      } catch (WrongMethodTypeException e) {}
      assertEquals("9.99, [0.0, 0.1, 1.1]",
                   (String) mh.invokeExact(Float.valueOf(9.99f),
                                           new Float[] { Float.valueOf(0.0f),
                                                         Float.valueOf(0.1f),
                                                         Float.valueOf(1.1f) }));
      assertEquals("9.99, [0.0, null, 1.1]",
                   (String) mh.invokeExact(Float.valueOf(9.99f),
                                           new Float[] { Float.valueOf(0.0f),
                                                         null,
                                                         Float.valueOf(1.1f) }));
      try {
        assertEquals("9.99, [0.0, 0.1, 1.1]",
                     (String) mh.invokeExact(Float.valueOf(9.99f), 0.0f, 0.1f, 1.1f));
        fail();
      } catch (WrongMethodTypeException e) {}
  
      // Special methods - Float
      mh = VariableArityTester.lookup().
              findSpecial(BaseVariableArityTester.class, "update",
                          MethodType.methodType(String.class, Float.class, Float[].class),
                          VariableArityTester.class);
      assertTrue(mh.isVarargsCollector());
      assertEquals("base 9.99, [0.0, 0.1, 1.1]",
      (String) mh.invoke(vat,
                         Float.valueOf(9.99f),
                         new Float[] { Float.valueOf(0.0f),
                                       Float.valueOf(0.1f),
                                       Float.valueOf(1.1f) }));
      assertEquals("base 9.99, [0.0, 0.1, 1.1]",
      (String) mh.invoke(vat, Float.valueOf(9.99f), Float.valueOf(0.0f),
                         Float.valueOf(0.1f), Float.valueOf(1.1f)));
  
      // Return value conversions.
      mh = MethodHandles.lookup().findVirtual(VariableArityTester.class, "update",
                                              MethodType.methodType(String.class, int[].class));
      assertEquals("[1, 2, 3]", (String) mh.invoke(vat, 1, 2, 3));
      assertEquals("[1, 2, 3]", (Object) mh.invoke(vat, 1, 2, 3));
      try {
        assertEquals("[1, 2, 3, 4]", (long) mh.invoke(vat, 1, 2, 3));
        fail();
      } catch (WrongMethodTypeException e) {}
      assertEquals("[1, 2, 3]", vat.lastResult());
      mh = MethodHandles.lookup().findStatic(VariableArityTester.class, "sumToPrimitive",
                                             MethodType.methodType(long.class, int[].class));
      assertEquals(10l, (long) mh.invoke(1, 2, 3, 4));
      assertEquals(Long.valueOf(10l), (Long) mh.invoke(1, 2, 3, 4));
      mh = MethodHandles.lookup().findStatic(VariableArityTester.class, "sumToReference",
                                             MethodType.methodType(Long.class, int[].class));
      Object o = mh.invoke(1, 2, 3, 4);
      long l = (long) mh.invoke(1, 2, 3, 4);
      assertEquals(10l, (long) mh.invoke(1, 2, 3, 4));
      assertEquals(Long.valueOf(10l), (Long) mh.invoke(1, 2, 3, 4));
      try {
        // WrongMethodTypeException should be raised before invoke here.
        System.out.print("Expect Hi here: ");
        assertEquals(Long.valueOf(10l), (Byte) mh.invoke(1, 2, 3, 4));
        fail();
      } catch (ClassCastException e) {}
      try {
        // WrongMethodTypeException should be raised before invoke here.
        System.out.println("Don't expect Hi now");
        byte b = (byte) mh.invoke(1, 2, 3, 4);
        fail();
      } catch (WrongMethodTypeException e) {}
  
      // Return void produces 0 / null.
      mh = MethodHandles.lookup().findStatic(VariableArityTester.class, "foo",
                                             MethodType.methodType(void.class, int[].class));
      assertEquals(null, (Object) mh.invoke(3, 2, 1));
      assertEquals(0l, (long) mh.invoke(1, 2, 3));
  
      // Combinators
      mh = MethodHandles.lookup().findVirtual(VariableArityTester.class, "update",
                                              MethodType.methodType(String.class, boolean[].class));
      assertTrue(mh.isVarargsCollector());
      mh = mh.bindTo(vat);
      assertFalse(mh.isVarargsCollector());
      mh = mh.asVarargsCollector(boolean[].class);
      assertTrue(mh.isVarargsCollector());
      assertEquals("[]", mh.invoke());
      assertEquals("[true, false, true]", mh.invoke(true, false, true));
      assertEquals("[true, false, true]", mh.invoke(new boolean[] { true, false, true}));
      assertEquals("[false, true]", mh.invoke(Boolean.valueOf(false), Boolean.valueOf(true)));
      try {
        mh.invoke(true, true, 0);
        fail();
      } catch (WrongMethodTypeException e) {}
    }
  
    // The same tests as the above, except that we use use MethodHandles.bind instead of
    // MethodHandle.bindTo.
    public static void testVariableArity_MethodHandles_bind() throws Throwable {
      VariableArityTester vat = new VariableArityTester();
      MethodHandle mh = MethodHandles.lookup().bind(vat, "update",
              MethodType.methodType(String.class, boolean[].class));
      assertTrue(mh.isVarargsCollector());
  
      assertEquals("[]", mh.invoke());
      assertEquals("[true, false, true]", mh.invoke(true, false, true));
      assertEquals("[true, false, true]", mh.invoke(new boolean[] { true, false, true}));
      assertEquals("[false, true]", mh.invoke(Boolean.valueOf(false), Boolean.valueOf(true)));
  
      try {
        mh.invoke(true, true, 0);
        fail();
      } catch (WrongMethodTypeException e) {}
    }
  
    public static void testRevealDirect() throws Throwable {
      // Test with a virtual method :
      MethodType type = MethodType.methodType(String.class);
      MethodHandle handle = MethodHandles.lookup().findVirtual(
          UnreflectTester.class, "publicMethod", type);
  
      // Comparisons with an equivalent member obtained via reflection :
      MethodHandleInfo info = MethodHandles.lookup().revealDirect(handle);
      Method meth = UnreflectTester.class.getMethod("publicMethod");
  
      assertEquals(MethodHandleInfo.REF_invokeVirtual, info.getReferenceKind());
      assertEquals("publicMethod", info.getName());
      assertTrue(UnreflectTester.class == info.getDeclaringClass());
      assertFalse(info.isVarArgs());
      assertEquals(meth, info.reflectAs(Method.class, MethodHandles.lookup()));
      assertEquals(type, info.getMethodType());
  
      // Resolution via a public lookup should fail because the method in question
      // isn't public.
      try {
        info.reflectAs(Method.class, MethodHandles.publicLookup());
        fail();
      } catch (IllegalArgumentException expected) {
      }
  
      // Test with a static method :
      handle = MethodHandles.lookup().findStatic(UnreflectTester.class,
          "publicStaticMethod",
          MethodType.methodType(String.class));
  
      info = MethodHandles.lookup().revealDirect(handle);
      meth = UnreflectTester.class.getMethod("publicStaticMethod");
      assertEquals(MethodHandleInfo.REF_invokeStatic, info.getReferenceKind());
      assertEquals("publicStaticMethod", info.getName());
      assertTrue(UnreflectTester.class == info.getDeclaringClass());
      assertFalse(info.isVarArgs());
      assertEquals(meth, info.reflectAs(Method.class, MethodHandles.lookup()));
      assertEquals(type, info.getMethodType());
  
      // Test with a var-args method :
      type = MethodType.methodType(String.class, String[].class);
      handle = MethodHandles.lookup().findVirtual(UnreflectTester.class,
          "publicVarArgsMethod", type);
  
      info = MethodHandles.lookup().revealDirect(handle);
      meth = UnreflectTester.class.getMethod("publicVarArgsMethod", String[].class);
      assertEquals(MethodHandleInfo.REF_invokeVirtual, info.getReferenceKind());
      assertEquals("publicVarArgsMethod", info.getName());
      assertTrue(UnreflectTester.class == info.getDeclaringClass());
      assertTrue(info.isVarArgs());
      assertEquals(meth, info.reflectAs(Method.class, MethodHandles.lookup()));
      assertEquals(type, info.getMethodType());
  
      // Test with a constructor :
      Constructor cons = UnreflectTester.class.getConstructor(String.class, boolean.class);
      type = MethodType.methodType(void.class, String.class, boolean.class);
      handle = MethodHandles.lookup().findConstructor(UnreflectTester.class, type);
  
      info = MethodHandles.lookup().revealDirect(handle);
      assertEquals(MethodHandleInfo.REF_newInvokeSpecial, info.getReferenceKind());
      assertEquals("<init>", info.getName());
      assertTrue(UnreflectTester.class == info.getDeclaringClass());
      assertFalse(info.isVarArgs());
      assertEquals(cons, info.reflectAs(Constructor.class, MethodHandles.lookup()));
      assertEquals(type, info.getMethodType());
  
      // Test with a static field :
      Field field = UnreflectTester.class.getField("publicStaticField");
  
      handle = MethodHandles.lookup().findStaticSetter(
          UnreflectTester.class, "publicStaticField", String.class);
  
      info = MethodHandles.lookup().revealDirect(handle);
      assertEquals(MethodHandleInfo.REF_putStatic, info.getReferenceKind());
      assertEquals("publicStaticField", info.getName());
      assertTrue(UnreflectTester.class == info.getDeclaringClass());
      assertFalse(info.isVarArgs());
      assertEquals(field, info.reflectAs(Field.class, MethodHandles.lookup()));
      assertEquals(MethodType.methodType(void.class, String.class), info.getMethodType());
  
      // Test with a setter on the same field, the type of the handle should change
      // but everything else must remain the same.
      handle = MethodHandles.lookup().findStaticGetter(
          UnreflectTester.class, "publicStaticField", String.class);
      info = MethodHandles.lookup().revealDirect(handle);
      assertEquals(MethodHandleInfo.REF_getStatic, info.getReferenceKind());
      assertEquals(field, info.reflectAs(Field.class, MethodHandles.lookup()));
      assertEquals(MethodType.methodType(String.class), info.getMethodType());
  
      // Test with an instance field :
      field = UnreflectTester.class.getField("publicField");
  
      handle = MethodHandles.lookup().findSetter(
          UnreflectTester.class, "publicField", String.class);
  
      info = MethodHandles.lookup().revealDirect(handle);
      assertEquals(MethodHandleInfo.REF_putField, info.getReferenceKind());
      assertEquals("publicField", info.getName());
      assertTrue(UnreflectTester.class == info.getDeclaringClass());
      assertFalse(info.isVarArgs());
      assertEquals(field, info.reflectAs(Field.class, MethodHandles.lookup()));
      assertEquals(MethodType.methodType(void.class, String.class), info.getMethodType());
  
      // Test with a setter on the same field, the type of the handle should change
      // but everything else must remain the same.
      handle = MethodHandles.lookup().findGetter(
          UnreflectTester.class, "publicField", String.class);
      info = MethodHandles.lookup().revealDirect(handle);
      assertEquals(MethodHandleInfo.REF_getField, info.getReferenceKind());
      assertEquals(field, info.reflectAs(Field.class, MethodHandles.lookup()));
      assertEquals(MethodType.methodType(String.class), info.getMethodType());
    }
  }
  