1 /*

     1 /*

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Sun designates this

     7  * published by the Free Software Foundation.  Sun designates this

    24  */

    24  */

    25 

    25 

    26 /* @test

    26 /* @test

    27  * @summary unit tests for java.dyn.MethodHandles

    27  * @summary unit tests for java.dyn.MethodHandles

    28  * @compile -XDinvokedynamic MethodHandlesTest.java

    28  * @compile -XDinvokedynamic MethodHandlesTest.java

    30  */

    30  */

    31 

    31 

    33 

    33 

    34 import java.dyn.*;

    34 import java.dyn.*;

    35 import java.dyn.MethodHandles.Lookup;

    35 import java.dyn.MethodHandles.Lookup;

    36 import java.lang.reflect.*;

    36 import java.lang.reflect.*;

    37 import java.util.*;

    37 import java.util.*;

    40 import org.junit.*;

    38 import org.junit.*;

    41 import static org.junit.Assert.*;

    39 import static org.junit.Assert.*;

    42 

    41 

    43 

    42 

    44 /**

    43 /**

    45  *

    44  *

    46  * @author jrose

    45  * @author jrose

    47  */

    46  */

    48 public class MethodHandlesTest {

    47 public class MethodHandlesTest {

    49     // How much output?

    48     // How much output?

    51 

    50 

    52     // Set this true during development if you want to fast-forward to

    51     // Set this true during development if you want to fast-forward to

    53     // a particular new, non-working test.  Tests which are known to

    52     // a particular new, non-working test.  Tests which are known to

    54     // work (or have recently worked) test this flag and return on true.

    53     // work (or have recently worked) test this flag and return on true.

    55     static boolean CAN_SKIP_WORKING = false;

    54     static boolean CAN_SKIP_WORKING = false;

    56     //static { CAN_SKIP_WORKING = true; }

    55     //static { CAN_SKIP_WORKING = true; }

    57 

    56 

    58     // Set true to test more calls.  If false, some tests are just

    57     // Set true to test more calls.  If false, some tests are just

    59     // lookups, without exercising the actual method handle.

    58     // lookups, without exercising the actual method handle.

    61 

    60 

    62 

    61 

    63     @Test

    62     @Test

    64     public void testFirst() throws Throwable {

    63     public void testFirst() throws Throwable {

    65         verbosity += 9; try {

    64         verbosity += 9; try {

    66             // left blank for debugging

    65             // left blank for debugging

    68     }

    67     }

    69 

    68 

    70     // current failures

    69     // current failures

    71     @Test @Ignore("failure in call to makeRawRetypeOnly in ToGeneric")

    70     @Test @Ignore("failure in call to makeRawRetypeOnly in ToGeneric")

    72     public void testFail_1() throws Throwable {

    71     public void testFail_1() throws Throwable {

    73         testSpreadArguments(int.class, 0, 6);

    73         testSpreadArguments(int.class, 0, 6);

    74     }

    74     }

    76     public void testFail_2() throws Throwable {

    76     public void testFail_2() throws Throwable {

    77         // if CONV_OP_IMPLEMENTED_MASK includes OP_SPREAD_ARGS, this crashes:

    77         // if CONV_OP_IMPLEMENTED_MASK includes OP_SPREAD_ARGS, this crashes:

    78         testSpreadArguments(Object.class, 0, 2);

    78         testSpreadArguments(Object.class, 0, 2);

    79     }

    79     }

    80     @Test @Ignore("IllArgEx failure in call to ToGeneric.make")

    80     @Test @Ignore("IllArgEx failure in call to ToGeneric.make")

    81     public void testFail_3() throws Throwable {

    81     public void testFail_3() throws Throwable {

    82         testSpreadArguments(int.class, 1, 2);

    83         testSpreadArguments(int.class, 1, 2);

    83     }

    84     }

    84     @Test @Ignore("IllArgEx failure in call to ToGeneric.make")

    85     @Test @Ignore("IllArgEx failure in call to ToGeneric.make")

    85     public void testFail_4() throws Throwable {

    86     public void testFail_4() throws Throwable {

    86         testCollectArguments(int.class, 1, 2);

    88         testCollectArguments(int.class, 1, 2);

    87     }

    89     }

    88     @Test @Ignore("cannot collect leading primitive types")

    90     @Test @Ignore("cannot collect leading primitive types")

    89     public void testFail_5() throws Throwable {

    91     public void testFail_5() throws Throwable {

    90         testInvokers(MethodType.genericMethodType(2).changeParameterType(0, int.class));

    93         testInvokers(MethodType.genericMethodType(2).changeParameterType(0, int.class));

    91     }

    94     }

    92     @Test @Ignore("should not insert arguments beyond MethodHandlePushLimit")

    95     @Test @Ignore("should not insert arguments beyond MethodHandlePushLimit")

    93     public void testFail_6() throws Throwable {

    96     public void testFail_6() throws Throwable {

    95     }

    99     }

    96     static final int MAX_ARG_INCREASE = 3;

   100     static final int MAX_ARG_INCREASE = 3;

    97 

   101 

    98     public MethodHandlesTest() {

   102     public MethodHandlesTest() {

    99     }

   121     }

   100 

   122 

   101     String testName;

   123     String testName;

   102     int posTests, negTests;

   124     int posTests, negTests;

   103     @After

   125     @After

   104     public void printCounts() {

   126     public void printCounts() {

   106             System.out.println();

   128             System.out.println();

   107             if (posTests != 0)  System.out.println("=== "+testName+": "+posTests+" positive test cases run");

   129             if (posTests != 0)  System.out.println("=== "+testName+": "+posTests+" positive test cases run");

   108             if (negTests != 0)  System.out.println("=== "+testName+": "+negTests+" negative test cases run");

   130             if (negTests != 0)  System.out.println("=== "+testName+": "+negTests+" negative test cases run");

   109         }

   132         }

   110     }

   133     }

   111     void countTest(boolean positive) {

   134     void countTest(boolean positive) {

   112         if (positive) ++posTests;

   135         if (positive) ++posTests;

   113         else          ++negTests;

   136         else          ++negTests;

   114     }

   137     }

   115     void countTest() { countTest(true); }

   138     void countTest() { countTest(true); }

   116     void startTest(String name) {

   139     void startTest(String name) {

   117         if (testName != null)  printCounts();

   140         if (testName != null)  printCounts();

   119             System.out.println(name);

   142             System.out.println(name);

   120         posTests = negTests = 0;

   143         posTests = negTests = 0;

   121         testName = name;

   144         testName = name;

   122     }

   145     }

   123 

   146 

   124     @BeforeClass

   147     @BeforeClass

   125     public static void setUpClass() throws Exception {

   148     public static void setUpClass() throws Exception {

   126         calledLog.clear();

   149         calledLog.clear();

   127         calledLog.add(null);

   150         calledLog.add(null);

   129     }

   152     }

   130 

   153 

   131     @AfterClass

   154     @AfterClass

   132     public static void tearDownClass() throws Exception {

   155     public static void tearDownClass() throws Exception {

   133     }

   156     }

   142         return entry;

   165         return entry;

   143     }

   166     }

   144     static void assertCalled(String name, Object... args) {

   167     static void assertCalled(String name, Object... args) {

   145         Object expected = logEntry(name, args);

   168         Object expected = logEntry(name, args);

   146         Object actual   = calledLog.get(calledLog.size() - 1);

   169         Object actual   = calledLog.get(calledLog.size() - 1);

   148         System.out.println("assertCalled "+name+":");

   171         System.out.println("assertCalled "+name+":");

   149         System.out.println("expected:   "+expected);

   172         System.out.println("expected:   "+expected);

   150         System.out.println("actual:     "+actual);

   173         System.out.println("actual:     "+actual);

   151         System.out.println("ex. types:  "+getClasses(expected));

   174         System.out.println("ex. types:  "+getClasses(expected));

   152         System.out.println("act. types: "+getClasses(actual));

   175         System.out.println("act. types: "+getClasses(actual));

   154         assertEquals("previous method call", expected, actual);

   176         assertEquals("previous method call", expected, actual);

   155     }

   177     }

   156     static void printCalled(MethodHandle target, String name, Object... args) {

   178     static void printCalled(MethodHandle target, String name, Object... args) {

   159     }

   181     }

   160 

   182 

   161     static Object castToWrapper(Object value, Class<?> dst) {

   183     static Object castToWrapper(Object value, Class<?> dst) {

   162         Object wrap = null;

   184         Object wrap = null;

   163         if (value instanceof Number)

   185         if (value instanceof Number)

   186         if (dst == boolean.class || dst == boolean.class)

   208         if (dst == boolean.class || dst == boolean.class)

   187             return ((value % 29) & 1) == 0;

   209             return ((value % 29) & 1) == 0;

   188         return null;

   210         return null;

   189     }

   211     }

   190 

   212 

   192     static Object randomArg(Class<?> param) {

   244     static Object randomArg(Class<?> param) {

   194         if (wrap != null) {

   246         if (wrap != null) {

   196             return wrap;

   247             return wrap;

   197         }

   248         }

   198 //        import sun.dyn.util.Wrapper;

   249 //        import sun.dyn.util.Wrapper;

   199 //        Wrapper wrap = Wrapper.forBasicType(dst);

   250 //        Wrapper wrap = Wrapper.forBasicType(dst);

   200 //        if (wrap == Wrapper.OBJECT && Wrapper.isWrapperType(dst))

   251 //        if (wrap == Wrapper.OBJECT && Wrapper.isWrapperType(dst))

   201 //            wrap = Wrapper.forWrapperType(dst);

   252 //            wrap = Wrapper.forWrapperType(dst);

   202 //        if (wrap != Wrapper.OBJECT)

   253 //        if (wrap != Wrapper.OBJECT)

   203 //            return wrap.wrap(nextArg++);

   254 //            return wrap.wrap(nextArg++);

   204         if (param.isInterface() || param.isAssignableFrom(String.class))

   255         if (param.isInterface() || param.isAssignableFrom(String.class))

   206         else

   257         else

   207             try {

   258             try {

   208                 return param.newInstance();

   259                 return param.newInstance();

   209             } catch (InstantiationException ex) {

   260             } catch (InstantiationException ex) {

   210             } catch (IllegalAccessException ex) {

   261             } catch (IllegalAccessException ex) {

   275     static final Lookup PUBLIC  = MethodHandles.publicLookup();

   326     static final Lookup PUBLIC  = MethodHandles.publicLookup();

   276 

   327 

   277     // Subject methods...

   328     // Subject methods...

   278     static class Example implements IntExample {

   329     static class Example implements IntExample {

   279         final String name;

   330         final String name;

   281         protected Example(String name) { this.name = name; }

   332         protected Example(String name) { this.name = name; }

   282         protected Example(int x) { this(); called("protected <init>", this, x); }

   333         protected Example(int x) { this(); called("protected <init>", this, x); }

   283         @Override public String toString() { return name; }

   334         @Override public String toString() { return name; }

   284 

   335 

   285         public void            v0()     { called("v0", this); }

   336         public void            v0()     { called("v0", this); }

   299         public static Object   s3(long x)   { return called("s3", x); }

   350         public static Object   s3(long x)   { return called("s3", x); }

   300         public static Object   s4(int x, int y) { return called("s4", x, y); }

   351         public static Object   s4(int x, int y) { return called("s4", x, y); }

   301         public static Object   s5(long x, int y) { return called("s5", x, y); }

   352         public static Object   s5(long x, int y) { return called("s5", x, y); }

   302         public static Object   s6(int x, long y) { return called("s6", x, y); }

   353         public static Object   s6(int x, long y) { return called("s6", x, y); }

   303         public static Object   s7(float x, double y) { return called("s7", x, y); }

   354         public static Object   s7(float x, double y) { return called("s7", x, y); }

   305     public static class PubExample extends Example {

   359     public static class PubExample extends Example {

   306     }

   361     }

   307     static class SubExample extends Example {

   362     static class SubExample extends Example {

   308         @Override public void  v0()     { called("Sub/v0", this); }

   363         @Override public void  v0()     { called("Sub/v0", this); }

   309         @Override void         pkg_v0() { called("Sub/pkg_v0", this); }

   364         @Override void         pkg_v0() { called("Sub/pkg_v0", this); }

   310         private      SubExample(int x)  { called("<init>", this, x); }

   365         private      SubExample(int x)  { called("<init>", this, x); }

   312     }

   367     }

   313     public static interface IntExample {

   368     public static interface IntExample {

   314         public void            v0();

   369         public void            v0();

   315         static class Impl implements IntExample {

   370         static class Impl implements IntExample {

   316             public void        v0()     { called("Int/v0", this); }

   371             public void        v0()     { called("Int/v0", this); }

   317             final String name;

   372             final String name;

   319         }

   375         }

   320     }

   376     }

   321 

   377 

   322     static final Object[][][] ACCESS_CASES = {

   378     static final Object[][][] ACCESS_CASES = {

   327     };

   383     };

   328 

   384 

   334         } else {

   391         } else {

   335             assertTrue(name.indexOf('_') < 0);

   392             assertTrue(name.indexOf('_') < 0);

   336             boolean pubc = Modifier.isPublic(defc.getModifiers());

   393             boolean pubc = Modifier.isPublic(defc.getModifiers());

   337             if (pubc)

   394             if (pubc)

   341     }

   405     }

   342 

   406 

   343     @Test

   407     @Test

   344     public void testFindStatic() throws Throwable {

   408     public void testFindStatic() throws Throwable {

   345         if (CAN_SKIP_WORKING)  return;

   409         if (CAN_SKIP_WORKING)  return;

   372         countTest(positive);

   436         countTest(positive);

   373         MethodType type = MethodType.methodType(ret, params);

   437         MethodType type = MethodType.methodType(ret, params);

   374         MethodHandle target = null;

   438         MethodHandle target = null;

   375         RuntimeException noAccess = null;

   439         RuntimeException noAccess = null;

   376         try {

   440         try {

   377             target = lookup.findStatic(defc, name, type);

   442             target = lookup.findStatic(defc, name, type);

   378         } catch (NoAccessException ex) {

   443         } catch (NoAccessException ex) {

   379             noAccess = ex;

   444             noAccess = ex;

   380         }

   445         }

   383                     +(noAccess == null ? "" : " !! "+noAccess));

   448                     +(noAccess == null ? "" : " !! "+noAccess));

   384         if (positive && noAccess != null)  throw noAccess;

   449         if (positive && noAccess != null)  throw noAccess;

   385         assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);

   450         assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);

   386         if (!positive)  return; // negative test failed as expected

   451         if (!positive)  return; // negative test failed as expected

   387         assertEquals(type, target.type());

   452         assertEquals(type, target.type());

   389         if (!DO_MORE_CALLS && lookup != PRIVATE)  return;

   454         if (!DO_MORE_CALLS && lookup != PRIVATE)  return;

   390         Object[] args = randomArgs(params);

   455         Object[] args = randomArgs(params);

   391         printCalled(target, name, args);

   456         printCalled(target, name, args);

   392         target.invokeVarargs(args);

   457         target.invokeVarargs(args);

   393         assertCalled(name, args);

   458         assertCalled(name, args);

   395     }

   461     }

   396 

   462 

   397     @Test

   463     @Test

   398     public void testFindVirtual() throws Throwable {

   464     public void testFindVirtual() throws Throwable {

   399         if (CAN_SKIP_WORKING)  return;

   465         if (CAN_SKIP_WORKING)  return;

   434         String methodName = name.substring(1 + name.indexOf('/'));  // foo/bar => foo

   500         String methodName = name.substring(1 + name.indexOf('/'));  // foo/bar => foo

   435         MethodType type = MethodType.methodType(ret, params);

   501         MethodType type = MethodType.methodType(ret, params);

   436         MethodHandle target = null;

   502         MethodHandle target = null;

   437         RuntimeException noAccess = null;

   503         RuntimeException noAccess = null;

   438         try {

   504         try {

   439             target = lookup.findVirtual(defc, methodName, type);

   506             target = lookup.findVirtual(defc, methodName, type);

   440         } catch (NoAccessException ex) {

   507         } catch (NoAccessException ex) {

   441             noAccess = ex;

   508             noAccess = ex;

   442         }

   509         }

   445                     +(noAccess == null ? "" : " !! "+noAccess));

   512                     +(noAccess == null ? "" : " !! "+noAccess));

   446         if (positive && noAccess != null)  throw noAccess;

   513         if (positive && noAccess != null)  throw noAccess;

   447         assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);

   514         assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);

   448         if (!positive)  return; // negative test failed as expected

   515         if (!positive)  return; // negative test failed as expected

   449         Class<?>[] paramsWithSelf = cat(array(Class[].class, (Class)defc), params);

   516         Class<?>[] paramsWithSelf = cat(array(Class[].class, (Class)defc), params);

   450         MethodType typeWithSelf = MethodType.methodType(ret, paramsWithSelf);

   517         MethodType typeWithSelf = MethodType.methodType(ret, paramsWithSelf);

   454         assertTrue(target.toString().contains(methodName));  // rough check

   523         assertTrue(target.toString().contains(methodName));  // rough check

   455         if (!DO_MORE_CALLS && lookup != PRIVATE)  return;

   524         if (!DO_MORE_CALLS && lookup != PRIVATE)  return;

   456         Object[] argsWithSelf = randomArgs(paramsWithSelf);

   525         Object[] argsWithSelf = randomArgs(paramsWithSelf);

   457         if (rcvc != defc)  argsWithSelf[0] = randomArg(rcvc);

   526         if (rcvc != defc)  argsWithSelf[0] = randomArg(rcvc);

   458         printCalled(target, name, argsWithSelf);

   527         printCalled(target, name, argsWithSelf);

   459         target.invokeVarargs(argsWithSelf);

   528         target.invokeVarargs(argsWithSelf);

   460         assertCalled(name, argsWithSelf);

   529         assertCalled(name, argsWithSelf);

   462     }

   532     }

   463 

   533 

   464     @Test

   534     @Test

   465     public void testFindSpecial() throws Throwable {

   535     public void testFindSpecial() throws Throwable {

   466         if (CAN_SKIP_WORKING)  return;

   536         if (CAN_SKIP_WORKING)  return;

   467         startTest("findSpecial");

   537         startTest("findSpecial");

   480         countTest(positive);

   558         countTest(positive);

   481         MethodType type = MethodType.methodType(ret, params);

   559         MethodType type = MethodType.methodType(ret, params);

   482         MethodHandle target = null;

   560         MethodHandle target = null;

   483         RuntimeException noAccess = null;

   561         RuntimeException noAccess = null;

   484         try {

   562         try {

   486         } catch (NoAccessException ex) {

   565         } catch (NoAccessException ex) {

   487             noAccess = ex;

   566             noAccess = ex;

   488         }

   567         }

   492         if (positive && noAccess != null)  throw noAccess;

   572         if (positive && noAccess != null)  throw noAccess;

   493         assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);

   573         assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);

   494         if (!positive)  return; // negative test failed as expected

   574         if (!positive)  return; // negative test failed as expected

   496         MethodType typeWithSelf = MethodType.methodType(ret, paramsWithSelf);

   578         MethodType typeWithSelf = MethodType.methodType(ret, paramsWithSelf);

   500         assertTrue(target.toString().contains(name));  // rough check

   579         assertTrue(target.toString().contains(name));  // rough check

   502         Object[] args = randomArgs(paramsWithSelf);

   581         Object[] args = randomArgs(paramsWithSelf);

   503         printCalled(target, name, args);

   582         printCalled(target, name, args);

   504         target.invokeVarargs(args);

   583         target.invokeVarargs(args);

   505         assertCalled(name, args);

   584         assertCalled(name, args);

   507     }

   585     }

   508 

   586 

   509     @Test

   587     @Test

   510     public void testBind() throws Throwable {

   588     public void testBind() throws Throwable {

   511         if (CAN_SKIP_WORKING)  return;

   589         if (CAN_SKIP_WORKING)  return;

   536         MethodType type = MethodType.methodType(ret, params);

   614         MethodType type = MethodType.methodType(ret, params);

   537         Object receiver = randomArg(defc);

   615         Object receiver = randomArg(defc);

   538         MethodHandle target = null;

   616         MethodHandle target = null;

   539         RuntimeException noAccess = null;

   617         RuntimeException noAccess = null;

   540         try {

   618         try {

   541             target = lookup.bind(receiver, methodName, type);

   620             target = lookup.bind(receiver, methodName, type);

   542         } catch (NoAccessException ex) {

   621         } catch (NoAccessException ex) {

   543             noAccess = ex;

   622             noAccess = ex;

   544         }

   623         }

   546             System.out.println("bind "+receiver+"."+name+"/"+type+" => "+target

   625             System.out.println("bind "+receiver+"."+name+"/"+type+" => "+target

   547                     +(noAccess == null ? "" : " !! "+noAccess));

   626                     +(noAccess == null ? "" : " !! "+noAccess));

   548         if (positive && noAccess != null)  throw noAccess;

   627         if (positive && noAccess != null)  throw noAccess;

   549         assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);

   628         assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);

   550         if (!positive)  return; // negative test failed as expected

   629         if (!positive)  return; // negative test failed as expected

   552         Object[] args = randomArgs(params);

   631         Object[] args = randomArgs(params);

   553         printCalled(target, name, args);

   632         printCalled(target, name, args);

   554         target.invokeVarargs(args);

   633         target.invokeVarargs(args);

   555         Object[] argsWithReceiver = cat(array(Object[].class, receiver), args);

   634         Object[] argsWithReceiver = cat(array(Object[].class, receiver), args);

   556         assertCalled(name, argsWithReceiver);

   635         assertCalled(name, argsWithReceiver);

   558     }

   638     }

   559 

   639 

   560     @Test

   640     @Test

   561     public void testUnreflect() throws Throwable {

   641     public void testUnreflect() throws Throwable {

   562         if (CAN_SKIP_WORKING)  return;

   642         if (CAN_SKIP_WORKING)  return;

   565         testUnreflect(Example.class, true, void.class, "pkg_s0");

   645         testUnreflect(Example.class, true, void.class, "pkg_s0");

   566         testUnreflect(Example.class, true, void.class, "pri_s0");

   646         testUnreflect(Example.class, true, void.class, "pri_s0");

   567 

   647 

   568         testUnreflect(Example.class, true, Object.class, "s1", Object.class);

   648         testUnreflect(Example.class, true, Object.class, "s1", Object.class);

   569         testUnreflect(Example.class, true, Object.class, "s2", int.class);

   649         testUnreflect(Example.class, true, Object.class, "s2", int.class);

   574 

   654 

   575         testUnreflect(Example.class, false, void.class, "v0");

   655         testUnreflect(Example.class, false, void.class, "v0");

   576         testUnreflect(Example.class, false, void.class, "pkg_v0");

   656         testUnreflect(Example.class, false, void.class, "pkg_v0");

   577         testUnreflect(Example.class, false, void.class, "pri_v0");

   657         testUnreflect(Example.class, false, void.class, "pri_v0");

   578         testUnreflect(Example.class, false, Object.class, "v1", Object.class);

   658         testUnreflect(Example.class, false, Object.class, "v1", Object.class);

   582         testUnreflect(Example.class, false, Object.class, "v2", int.class, int.class);

   662         testUnreflect(Example.class, false, Object.class, "v2", int.class, int.class);

   583     }

   663     }

   584 

   664 

   585     void testUnreflect(Class<?> defc, boolean isStatic, Class<?> ret, String name, Class<?>... params) throws Throwable {

   665     void testUnreflect(Class<?> defc, boolean isStatic, Class<?> ret, String name, Class<?>... params) throws Throwable {

   586         for (Object[] ac : accessCases(defc, name)) {

   666         for (Object[] ac : accessCases(defc, name)) {

   591         countTest(positive);

   678         countTest(positive);

   592         MethodType type = MethodType.methodType(ret, params);

   679         MethodType type = MethodType.methodType(ret, params);

   593         Method rmethod = null;

   680         Method rmethod = null;

   594         MethodHandle target = null;

   681         MethodHandle target = null;

   595         RuntimeException noAccess = null;

   682         RuntimeException noAccess = null;

   596         try {

   683         try {

   597             rmethod = defc.getDeclaredMethod(name, params);

   684             rmethod = defc.getDeclaredMethod(name, params);

   598         } catch (NoSuchMethodException ex) {

   685         } catch (NoSuchMethodException ex) {

   599             throw new NoAccessException(ex);

   686             throw new NoAccessException(ex);

   600         }

   687         }

   602         try {

   690         try {

   604         } catch (NoAccessException ex) {

   696         } catch (NoAccessException ex) {

   605             noAccess = ex;

   697             noAccess = ex;

   606         }

   698         }

   610         if (positive && noAccess != null)  throw noAccess;

   705         if (positive && noAccess != null)  throw noAccess;

   611         assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);

   706         assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);

   612         if (!positive)  return; // negative test failed as expected

   707         if (!positive)  return; // negative test failed as expected

   613         Class<?>[] paramsMaybeWithSelf = params;

   709         Class<?>[] paramsMaybeWithSelf = params;

   614         if (!isStatic) {

   710         if (!isStatic) {

   616         }

   712         }

   617         MethodType typeMaybeWithSelf = MethodType.methodType(ret, paramsMaybeWithSelf);

   713         MethodType typeMaybeWithSelf = MethodType.methodType(ret, paramsMaybeWithSelf);

   622         Object[] argsMaybeWithSelf = randomArgs(paramsMaybeWithSelf);

   727         Object[] argsMaybeWithSelf = randomArgs(paramsMaybeWithSelf);

   623         printCalled(target, name, argsMaybeWithSelf);

   728         printCalled(target, name, argsMaybeWithSelf);

   624         target.invokeVarargs(argsMaybeWithSelf);

   729         target.invokeVarargs(argsMaybeWithSelf);

   625         assertCalled(name, argsMaybeWithSelf);

   730         assertCalled(name, argsMaybeWithSelf);

   630     public void testUnreflectSpecial() throws Throwable {

   743     public void testUnreflectSpecial() throws Throwable {

   632         startTest("unreflectSpecial");

   745         startTest("unreflectSpecial");

   638     }

   753     }

   639 

   754 

   640     public static class HasFields {

   755     public static class HasFields {

   641         boolean fZ = false;

   756         boolean fZ = false;

   642         byte fB = (byte)'B';

   757         byte fB = (byte)'B';

   733         mh = MethodHandles.convertArguments(mh, mh.type().generic().changeReturnType(rtype));

   848         mh = MethodHandles.convertArguments(mh, mh.type().generic().changeReturnType(rtype));

   734         Object expValue = value;

   849         Object expValue = value;

   735         for (int i = 0; i <= 1; i++) {

   850         for (int i = 0; i <= 1; i++) {

   736             if (isStatic) {

   851             if (isStatic) {

   737                 if (type == int.class)

   852                 if (type == int.class)

   739                 else

   854                 else

   741             } else {

   856             } else {

   742                 if (type == int.class)

   857                 if (type == int.class)

   744                 else

   859                 else

   746             }

   861             }

   747             assertEquals(sawValue, expValue);

   862             assertEquals(sawValue, expValue);

   748             Object random = randomArg(type);

   863             Object random = randomArg(type);

   749             f.set(fields, random);

   864             f.set(fields, random);

   750             expValue = random;

   865             expValue = random;

   784         assertEquals(f.get(fields), value);  // clean to start with

   899         assertEquals(f.get(fields), value);  // clean to start with

   785         for (int i = 0; i <= 1; i++) {

   900         for (int i = 0; i <= 1; i++) {

   786             Object putValue = randomArg(type);

   901             Object putValue = randomArg(type);

   787             if (isStatic) {

   902             if (isStatic) {

   788                 if (type == int.class)

   903                 if (type == int.class)

   790                 else

   905                 else

   792             } else {

   907             } else {

   793                 if (type == int.class)

   908                 if (type == int.class)

   795                 else

   910                 else

   797             }

   912             }

   798             assertEquals(f.get(fields), putValue);

   913             assertEquals(f.get(fields), putValue);

   799         }

   914         }

   800         f.set(fields, value);  // put it back

   915         f.set(fields, value);  // put it back

   801     }

   916     }

   802 

   917 

   803     @Test

   918     @Test

   804     public void testArrayElementGetter() throws Throwable {

   919     public void testArrayElementGetter() throws Throwable {

   805         startTest("arrayElementGetter");

   920         startTest("arrayElementGetter");

   811     }

   922     }

   812 

   923 

   813     @Test

   924     @Test

   814     public void testArrayElementSetter() throws Throwable {

   925     public void testArrayElementSetter() throws Throwable {

   815         startTest("arrayElementSetter");

   926         startTest("arrayElementSetter");

   821     }

   941     }

   822 

   942 

   823     public void testArrayElementGetterSetter(Object array, boolean testSetter) throws Throwable {

   943     public void testArrayElementGetterSetter(Object array, boolean testSetter) throws Throwable {

   824         countTest(true);

   944         countTest(true);

   825         Class<?> arrayType = array.getClass();

   946         Class<?> arrayType = array.getClass();

   826         Class<?> elemType = arrayType.getComponentType();

   947         Class<?> elemType = arrayType.getComponentType();

   827         MethodType expType = !testSetter

   948         MethodType expType = !testSetter

   828                 ? MethodType.methodType(elemType,   arrayType, int.class)

   949                 ? MethodType.methodType(elemType,   arrayType, int.class)

   829                 : MethodType.methodType(void.class, arrayType, int.class, elemType);

   950                 : MethodType.methodType(void.class, arrayType, int.class, elemType);

   830         MethodHandle mh = !testSetter

   951         MethodHandle mh = !testSetter

   831                 ? MethodHandles.arrayElementGetter(arrayType)

   952                 ? MethodHandles.arrayElementGetter(arrayType)

   832                 : MethodHandles.arrayElementSetter(arrayType);

   953                 : MethodHandles.arrayElementSetter(arrayType);

   833         assertSame(mh.type(), expType);

   954         assertSame(mh.type(), expType);

   835         Object sawValue, expValue;

   968         Object sawValue, expValue;

   836         List<Object> model = array2list(array);

   969         List<Object> model = array2list(array);

   837         int length = Array.getLength(array);

   970         int length = Array.getLength(array);

   838         for (int i = 0; i < length; i++) {

   971         for (int i = 0; i < length; i++) {

   839             // update array element

   972             // update array element

   840             Object random = randomArg(elemType);

   973             Object random = randomArg(elemType);

   841             model.set(i, random);

   974             model.set(i, random);

   842             if (testSetter) {

   975             if (testSetter) {

   843                 if (elemType == int.class)

   976                 if (elemType == int.class)

   845                 else

   980                 else

   847                 assertEquals(model, array2list(array));

   982                 assertEquals(model, array2list(array));

   848             } else {

   983             } else {

   849                 Array.set(array, i, random);

   984                 Array.set(array, i, random);

   851             }

   991             }

   852             // observe array element

   992             // observe array element

   853             sawValue = Array.get(array, i);

   993             sawValue = Array.get(array, i);

   854             if (!testSetter) {

   994             if (!testSetter) {

   855                 expValue = sawValue;

   995                 expValue = sawValue;

   856                 if (elemType == int.class)

   996                 if (elemType == int.class)

   858                 else

  1000                 else

   860                 assertEquals(sawValue, expValue);

  1002                 assertEquals(sawValue, expValue);

   861                 assertEquals(model, array2list(array));

  1003                 assertEquals(model, array2list(array));

   862             }

  1004             }

   863         }

  1005         }

   864     }

  1006     }

   904         startTest("convertArguments");

  1046         startTest("convertArguments");

   905         testConvert(Callee.ofType(1), null, "id", int.class);

  1047         testConvert(Callee.ofType(1), null, "id", int.class);

   906         testConvert(Callee.ofType(1), null, "id", String.class);

  1048         testConvert(Callee.ofType(1), null, "id", String.class);

   907         testConvert(Callee.ofType(1), null, "id", Integer.class);

  1049         testConvert(Callee.ofType(1), null, "id", Integer.class);

   908         testConvert(Callee.ofType(1), null, "id", short.class);

  1050         testConvert(Callee.ofType(1), null, "id", short.class);

   909     }

  1053     }

   910 

  1054 

   911     void testConvert(MethodHandle id, Class<?> rtype, String name, Class<?>... params) throws Throwable {

  1055     void testConvert(MethodHandle id, Class<?> rtype, String name, Class<?>... params) throws Throwable {

   912         testConvert(true, id, rtype, name, params);

  1056         testConvert(true, id, rtype, name, params);

   913     }

  1057     }

   941         try {

  1085         try {

   942             target = MethodHandles.convertArguments(id, newType);

  1086             target = MethodHandles.convertArguments(id, newType);

   943         } catch (RuntimeException ex) {

  1087         } catch (RuntimeException ex) {

   944             error = ex;

  1088             error = ex;

   945         }

  1089         }

   947             System.out.println("convert "+id+ " to "+newType+" => "+target

  1091             System.out.println("convert "+id+ " to "+newType+" => "+target

   948                     +(error == null ? "" : " !! "+error));

  1092                     +(error == null ? "" : " !! "+error));

   949         if (positive && error != null)  throw error;

  1093         if (positive && error != null)  throw error;

   950         assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);

  1094         assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);

   951         if (!positive)  return; // negative test failed as expected

  1095         if (!positive)  return; // negative test failed as expected

   952         assertEquals(newType, target.type());

  1096         assertEquals(newType, target.type());

   953         printCalled(target, id.toString(), args);

  1097         printCalled(target, id.toString(), args);

   954         Object result = target.invokeVarargs(args);

  1098         Object result = target.invokeVarargs(args);

   955         assertCalled(name, convArgs);

  1099         assertCalled(name, convArgs);

   956         assertEquals(convResult, result);

  1100         assertEquals(convResult, result);

   958     }

  1103     }

   959 

  1104 

   960     @Test

  1105     @Test

   961     public void testPermuteArguments() throws Throwable {

  1106     public void testPermuteArguments() throws Throwable {

   962         if (CAN_SKIP_WORKING)  return;

  1107         if (CAN_SKIP_WORKING)  return;

   964         testPermuteArguments(4, Integer.class,  2, String.class,  0);

  1109         testPermuteArguments(4, Integer.class,  2, String.class,  0);

   965         //testPermuteArguments(6, Integer.class,  0, null,         30);

  1110         //testPermuteArguments(6, Integer.class,  0, null,         30);

   966         //testPermuteArguments(4, Integer.class,  1, int.class,     6);

  1111         //testPermuteArguments(4, Integer.class,  1, int.class,     6);

   967     }

  1112     }

   968     public void testPermuteArguments(int max, Class<?> type1, int t2c, Class<?> type2, int dilution) throws Throwable {

  1113     public void testPermuteArguments(int max, Class<?> type1, int t2c, Class<?> type2, int dilution) throws Throwable {

   970             System.out.println("permuteArguments "+max+"*"+type1.getName()

  1115             System.out.println("permuteArguments "+max+"*"+type1.getName()

   971                     +(t2c==0?"":"/"+t2c+"*"+type2.getName())

  1116                     +(t2c==0?"":"/"+t2c+"*"+type2.getName())

   972                     +(dilution > 0 ? " with dilution "+dilution : ""));

  1117                     +(dilution > 0 ? " with dilution "+dilution : ""));

   973         int t2pos = t2c == 0 ? 0 : 1;

  1118         int t2pos = t2c == 0 ? 0 : 1;

   974         for (int inargs = t2pos+1; inargs <= max; inargs++) {

  1119         for (int inargs = t2pos+1; inargs <= max; inargs++) {

  1052             for (int i = 0; i < args.length; i++)

  1197             for (int i = 0; i < args.length; i++)

  1053                 types[i] = args[i].getClass();

  1198                 types[i] = args[i].getClass();

  1054         }

  1199         }

  1055         int inargs = args.length, outargs = reorder.length;

  1200         int inargs = args.length, outargs = reorder.length;

  1056         assert(inargs == types.length);

  1201         assert(inargs == types.length);

  1058             System.out.println("permuteArguments "+Arrays.toString(reorder));

  1203             System.out.println("permuteArguments "+Arrays.toString(reorder));

  1059         Object[] permArgs = new Object[outargs];

  1204         Object[] permArgs = new Object[outargs];

  1060         Class<?>[] permTypes = new Class<?>[outargs];

  1205         Class<?>[] permTypes = new Class<?>[outargs];

  1061         for (int i = 0; i < outargs; i++) {

  1206         for (int i = 0; i < outargs; i++) {

  1062             permArgs[i] = args[reorder[i]];

  1207             permArgs[i] = args[reorder[i]];

  1063             permTypes[i] = types[reorder[i]];

  1208             permTypes[i] = types[reorder[i]];

  1064         }

  1209         }

  1066             System.out.println("in args:   "+Arrays.asList(args));

  1211             System.out.println("in args:   "+Arrays.asList(args));

  1067             System.out.println("out args:  "+Arrays.asList(permArgs));

  1212             System.out.println("out args:  "+Arrays.asList(permArgs));

  1068             System.out.println("in types:  "+Arrays.asList(types));

  1213             System.out.println("in types:  "+Arrays.asList(types));

  1069             System.out.println("out types: "+Arrays.asList(permTypes));

  1214             System.out.println("out types: "+Arrays.asList(permTypes));

  1070         }

  1215         }

  1081     @Test

  1226     @Test

  1082     public void testSpreadArguments() throws Throwable {

  1227     public void testSpreadArguments() throws Throwable {

  1083         if (CAN_SKIP_WORKING)  return;

  1228         if (CAN_SKIP_WORKING)  return;

  1084         startTest("spreadArguments");

  1229         startTest("spreadArguments");

  1085         for (Class<?> argType : new Class[]{Object.class, Integer.class, int.class}) {

  1230         for (Class<?> argType : new Class[]{Object.class, Integer.class, int.class}) {

  1087                 System.out.println("spreadArguments "+argType);

  1232                 System.out.println("spreadArguments "+argType);

  1088             for (int nargs = 0; nargs < 10; nargs++) {

  1234             for (int nargs = 0; nargs < 10; nargs++) {

  1089                 if (argType == int.class && nargs >= 6)  continue; // FIXME Fail_1

  1235                 if (argType == int.class && nargs >= 6)  continue; // FIXME Fail_1

  1090                 for (int pos = 0; pos < nargs; pos++) {

  1236                 for (int pos = 0; pos < nargs; pos++) {

  1091                     if (argType == int.class && pos > 0)  continue; // FIXME Fail_3

  1237                     if (argType == int.class && pos > 0)  continue; // FIXME Fail_3

  1093                 }

  1239                 }

  1094             }

  1240             }

  1095         }

  1241         }

  1096     }

  1242     }

  1097     public void testSpreadArguments(Class<?> argType, int pos, int nargs) throws Throwable {

  1243     public void testSpreadArguments(Class<?> argType, int pos, int nargs) throws Throwable {

  1098         countTest();

  1244         countTest();

  1099         MethodHandle target = ValueConversions.varargsArray(nargs);

  1245         MethodHandle target = ValueConversions.varargsArray(nargs);

  1100         MethodHandle target2 = changeArgTypes(target, argType);

  1246         MethodHandle target2 = changeArgTypes(target, argType);

  1102             System.out.println("spread into "+target2+" ["+pos+".."+nargs+"]");

  1248             System.out.println("spread into "+target2+" ["+pos+".."+nargs+"]");

  1103         Object[] args = randomArgs(target2.type().parameterArray());

  1249         Object[] args = randomArgs(target2.type().parameterArray());

  1104         // make sure the target does what we think it does:

  1250         // make sure the target does what we think it does:

  1105         if (pos == 0 && nargs < 5) {

  1251         if (pos == 0 && nargs < 5) {

  1106             Object[] check = (Object[]) target.invokeVarargs(args);

  1252             Object[] check = (Object[]) target.invokeVarargs(args);

  1107             assertArrayEquals(args, check);

  1253             assertArrayEquals(args, check);

  1108             switch (nargs) {

  1254             switch (nargs) {

  1109                 case 0:

  1255                 case 0:

  1111                     assertArrayEquals(args, check);

  1257                     assertArrayEquals(args, check);

  1112                     break;

  1258                     break;

  1113                 case 1:

  1259                 case 1:

  1115                     assertArrayEquals(args, check);

  1261                     assertArrayEquals(args, check);

  1116                     break;

  1262                     break;

  1117                 case 2:

  1263                 case 2:

  1119                     assertArrayEquals(args, check);

  1265                     assertArrayEquals(args, check);

  1120                     break;

  1266                     break;

  1121             }

  1267             }

  1122         }

  1268         }

  1123         List<Class<?>> newParams = new ArrayList<Class<?>>(target2.type().parameterList());

  1269         List<Class<?>> newParams = new ArrayList<Class<?>>(target2.type().parameterList());

  1127         }

  1273         }

  1128         MethodType newType = MethodType.methodType(Object.class, newParams);

  1274         MethodType newType = MethodType.methodType(Object.class, newParams);

  1129         MethodHandle result = MethodHandles.spreadArguments(target2, newType);

  1275         MethodHandle result = MethodHandles.spreadArguments(target2, newType);

  1130         Object[] returnValue;

  1276         Object[] returnValue;

  1131         if (pos == 0) {

  1277         if (pos == 0) {

  1133         } else {

  1279         } else {

  1134             Object[] args1 = Arrays.copyOfRange(args, 0, pos+1);

  1280             Object[] args1 = Arrays.copyOfRange(args, 0, pos+1);

  1135             args1[pos] = Arrays.copyOfRange(args, pos, args.length);

  1281             args1[pos] = Arrays.copyOfRange(args, pos, args.length);

  1136             returnValue = (Object[]) result.invokeVarargs(args1);

  1282             returnValue = (Object[]) result.invokeVarargs(args1);

  1137         }

  1283         }

  1141     @Test

  1287     @Test

  1142     public void testCollectArguments() throws Throwable {

  1288     public void testCollectArguments() throws Throwable {

  1143         if (CAN_SKIP_WORKING)  return;

  1289         if (CAN_SKIP_WORKING)  return;

  1144         startTest("collectArguments");

  1290         startTest("collectArguments");

  1145         for (Class<?> argType : new Class[]{Object.class, Integer.class, int.class}) {

  1291         for (Class<?> argType : new Class[]{Object.class, Integer.class, int.class}) {

  1147                 System.out.println("collectArguments "+argType);

  1293                 System.out.println("collectArguments "+argType);

  1148             for (int nargs = 0; nargs < 10; nargs++) {

  1294             for (int nargs = 0; nargs < 10; nargs++) {

  1149                 for (int pos = 0; pos < nargs; pos++) {

  1295                 for (int pos = 0; pos < nargs; pos++) {

  1150                     if (argType == int.class)  continue; // FIXME Fail_4

  1296                     if (argType == int.class)  continue; // FIXME Fail_4

  1151                     testCollectArguments(argType, pos, nargs);

  1297                     testCollectArguments(argType, pos, nargs);

  1165         collectedArgs[pos] = Arrays.copyOfRange(args, pos, args.length);

  1311         collectedArgs[pos] = Arrays.copyOfRange(args, pos, args.length);

  1166         // here is the MH which will witness the collected argument tail:

  1312         // here is the MH which will witness the collected argument tail:

  1167         MethodHandle target = ValueConversions.varargsArray(pos+1);

  1313         MethodHandle target = ValueConversions.varargsArray(pos+1);

  1168         target = changeArgTypes(target, 0, pos, argType);

  1314         target = changeArgTypes(target, 0, pos, argType);

  1169         target = changeArgTypes(target, pos, pos+1, Object[].class);

  1315         target = changeArgTypes(target, pos, pos+1, Object[].class);

  1171             System.out.println("collect from "+Arrays.asList(args)+" ["+pos+".."+nargs+"]");

  1317             System.out.println("collect from "+Arrays.asList(args)+" ["+pos+".."+nargs+"]");

  1172         MethodHandle result = MethodHandles.collectArguments(target, newType);

  1318         MethodHandle result = MethodHandles.collectArguments(target, newType);

  1173         Object[] returnValue = (Object[]) result.invokeVarargs(args);

  1319         Object[] returnValue = (Object[]) result.invokeVarargs(args);

  1174 //        assertTrue(returnValue.length == pos+1 && returnValue[pos] instanceof Object[]);

  1320 //        assertTrue(returnValue.length == pos+1 && returnValue[pos] instanceof Object[]);

  1175 //        returnValue[pos] = Arrays.asList((Object[]) returnValue[pos]);

  1321 //        returnValue[pos] = Arrays.asList((Object[]) returnValue[pos]);

  1196         MethodHandle target = ValueConversions.varargsArray(nargs + ins);

  1342         MethodHandle target = ValueConversions.varargsArray(nargs + ins);

  1197         Object[] args = randomArgs(target.type().parameterArray());

  1343         Object[] args = randomArgs(target.type().parameterArray());

  1198         List<Object> resList = Arrays.asList(args);

  1344         List<Object> resList = Arrays.asList(args);

  1199         List<Object> argsToPass = new ArrayList<Object>(resList);

  1345         List<Object> argsToPass = new ArrayList<Object>(resList);

  1200         List<Object> argsToInsert = argsToPass.subList(pos, pos + ins);

  1346         List<Object> argsToInsert = argsToPass.subList(pos, pos + ins);

  1202             System.out.println("insert: "+argsToInsert+" into "+target);

  1348             System.out.println("insert: "+argsToInsert+" into "+target);

  1203         MethodHandle target2 = MethodHandles.insertArguments(target, pos,

  1349         MethodHandle target2 = MethodHandles.insertArguments(target, pos,

  1204                 (Object[]) argsToInsert.toArray());

  1350                 (Object[]) argsToInsert.toArray());

  1205         argsToInsert.clear();  // remove from argsToInsert

  1351         argsToInsert.clear();  // remove from argsToInsert

  1206         Object res2 = target2.invokeVarargs(argsToPass);

  1352         Object res2 = target2.invokeVarargs(argsToPass);

  1207         Object res2List = Arrays.asList((Object[])res2);

  1353         Object res2List = Arrays.asList((Object[])res2);

  1209             System.out.println("result: "+res2List);

  1355             System.out.println("result: "+res2List);

  1210         //if (!resList.equals(res2List))

  1356         //if (!resList.equals(res2List))

  1211         //    System.out.println("*** fail at n/p/i = "+nargs+"/"+pos+"/"+ins+": "+resList+" => "+res2List);

  1357         //    System.out.println("*** fail at n/p/i = "+nargs+"/"+pos+"/"+ins+": "+resList+" => "+res2List);

  1212         assertEquals(resList, res2List);

  1358         assertEquals(resList, res2List);

  1213     }

  1359     }

  1227         countTest();

  1373         countTest();

  1228         MethodHandle target = ValueConversions.varargsList(nargs);

  1374         MethodHandle target = ValueConversions.varargsList(nargs);

  1229         MethodHandle filter = ValueConversions.varargsList(1);

  1375         MethodHandle filter = ValueConversions.varargsList(1);

  1230         filter = MethodHandles.convertArguments(filter, filter.type().generic());

  1376         filter = MethodHandles.convertArguments(filter, filter.type().generic());

  1231         Object[] argsToPass = randomArgs(nargs, Object.class);

  1377         Object[] argsToPass = randomArgs(nargs, Object.class);

  1233             System.out.println("filter "+target+" at "+pos+" with "+filter);

  1379             System.out.println("filter "+target+" at "+pos+" with "+filter);

  1234         MethodHandle[] filters = new MethodHandle[pos*2+1];

  1380         MethodHandle[] filters = new MethodHandle[pos*2+1];

  1235         filters[pos] = filter;

  1381         filters[pos] = filter;

  1236         MethodHandle target2 = MethodHandles.filterArguments(target, filters);

  1382         MethodHandle target2 = MethodHandles.filterArguments(target, filters);

  1237         // Simulate expected effect of filter on arglist:

  1383         // Simulate expected effect of filter on arglist:

  1238         Object[] filteredArgs = argsToPass.clone();

  1384         Object[] filteredArgs = argsToPass.clone();

  1240         List<Object> expected = Arrays.asList(filteredArgs);

  1386         List<Object> expected = Arrays.asList(filteredArgs);

  1241         Object result = target2.invokeVarargs(argsToPass);

  1387         Object result = target2.invokeVarargs(argsToPass);

  1243             System.out.println("result: "+result);

  1389             System.out.println("result: "+result);

  1244         if (!expected.equals(result))

  1390         if (!expected.equals(result))

  1245             System.out.println("*** fail at n/p = "+nargs+"/"+pos+": "+argsToPass+" => "+result);

  1391             System.out.println("*** fail at n/p = "+nargs+"/"+pos+": "+argsToPass+" => "+result);

  1246         assertEquals(expected, result);

  1392         assertEquals(expected, result);

  1247     }

  1393     }

  1263         if (pos != 0)  return;  // can fold only at pos=0 for now

  1409         if (pos != 0)  return;  // can fold only at pos=0 for now

  1264         countTest();

  1410         countTest();

  1265         MethodHandle target = ValueConversions.varargsList(1 + nargs);

  1411         MethodHandle target = ValueConversions.varargsList(1 + nargs);

  1266         MethodHandle combine = ValueConversions.varargsList(fold);

  1412         MethodHandle combine = ValueConversions.varargsList(fold);

  1267         List<Object> argsToPass = Arrays.asList(randomArgs(nargs, Object.class));

  1413         List<Object> argsToPass = Arrays.asList(randomArgs(nargs, Object.class));

  1269             System.out.println("fold "+target+" with "+combine);

  1415             System.out.println("fold "+target+" with "+combine);

  1270         MethodHandle target2 = MethodHandles.foldArguments(target, combine);

  1416         MethodHandle target2 = MethodHandles.foldArguments(target, combine);

  1271         // Simulate expected effect of combiner on arglist:

  1417         // Simulate expected effect of combiner on arglist:

  1272         List<Object> expected = new ArrayList<Object>(argsToPass);

  1418         List<Object> expected = new ArrayList<Object>(argsToPass);

  1273         List<Object> argsToFold = expected.subList(pos, pos + fold);

  1419         List<Object> argsToFold = expected.subList(pos, pos + fold);

  1275             System.out.println("fold: "+argsToFold+" into "+target2);

  1421             System.out.println("fold: "+argsToFold+" into "+target2);

  1276         Object foldedArgs = combine.invokeVarargs(argsToFold);

  1422         Object foldedArgs = combine.invokeVarargs(argsToFold);

  1277         argsToFold.add(0, foldedArgs);

  1423         argsToFold.add(0, foldedArgs);

  1278         Object result = target2.invokeVarargs(argsToPass);

  1424         Object result = target2.invokeVarargs(argsToPass);

  1280             System.out.println("result: "+result);

  1426             System.out.println("result: "+result);

  1281         if (!expected.equals(result))

  1427         if (!expected.equals(result))

  1282             System.out.println("*** fail at n/p/f = "+nargs+"/"+pos+"/"+fold+": "+argsToPass+" => "+result);

  1428             System.out.println("*** fail at n/p/f = "+nargs+"/"+pos+"/"+fold+": "+argsToPass+" => "+result);

  1283         assertEquals(expected, result);

  1429         assertEquals(expected, result);

  1284     }

  1430     }

  1341             }

  1487             }

  1342         }

  1488         }

  1343     }

  1489     }

  1344 

  1490 

  1345     public void testInvokers(MethodType type) throws Throwable {

  1491     public void testInvokers(MethodType type) throws Throwable {

  1347             System.out.println("test invokers for "+type);

  1493             System.out.println("test invokers for "+type);

  1348         int nargs = type.parameterCount();

  1494         int nargs = type.parameterCount();

  1349         boolean testRetCode = type.returnType() != void.class;

  1495         boolean testRetCode = type.returnType() != void.class;

  1350         MethodHandle target = PRIVATE.findStatic(MethodHandlesTest.class, "invokee",

  1496         MethodHandle target = PRIVATE.findStatic(MethodHandlesTest.class, "invokee",

  1351                                 MethodType.genericMethodType(0, true));

  1497                                 MethodType.genericMethodType(0, true));

  1371         inv = MethodHandles.genericInvoker(type);

  1517         inv = MethodHandles.genericInvoker(type);

  1372         if (nargs <= 3) {

  1518         if (nargs <= 3) {

  1373             calledLog.clear();

  1519             calledLog.clear();

  1374             switch (nargs) {

  1520             switch (nargs) {

  1375             case 0:

  1521             case 0:

  1377                 break;

  1523                 break;

  1378             case 1:

  1524             case 1:

  1380                 break;

  1526                 break;

  1381             case 2:

  1527             case 2:

  1383                 break;

  1529                 break;

  1384             case 3:

  1530             case 3:

  1386                 break;

  1532                 break;

  1387             }

  1533             }

  1388             if (testRetCode)  assertEquals(code, result);

  1534             if (testRetCode)  assertEquals(code, result);

  1389             assertCalled("invokee", args);

  1535             assertCalled("invokee", args);

  1390         }

  1536         }

  1393         if (testRetCode)  assertEquals(code, result);

  1539         if (testRetCode)  assertEquals(code, result);

  1394         assertCalled("invokee", args);

  1540         assertCalled("invokee", args);

  1395         // varargs invoker #0

  1541         // varargs invoker #0

  1396         calledLog.clear();

  1542         calledLog.clear();

  1397         inv = MethodHandles.varargsInvoker(type, 0);

  1543         inv = MethodHandles.varargsInvoker(type, 0);

  1399         if (testRetCode)  assertEquals(code, result);

  1545         if (testRetCode)  assertEquals(code, result);

  1400         assertCalled("invokee", args);

  1546         assertCalled("invokee", args);

  1401         if (nargs >= 1) {

  1547         if (nargs >= 1) {

  1402             // varargs invoker #1

  1548             // varargs invoker #1

  1403             calledLog.clear();

  1549             calledLog.clear();

  1404             inv = MethodHandles.varargsInvoker(type, 1);

  1550             inv = MethodHandles.varargsInvoker(type, 1);

  1406             if (testRetCode)  assertEquals(code, result);

  1552             if (testRetCode)  assertEquals(code, result);

  1407             assertCalled("invokee", args);

  1553             assertCalled("invokee", args);

  1408         }

  1554         }

  1409         if (nargs >= 2) {

  1555         if (nargs >= 2) {

  1410             // varargs invoker #2

  1556             // varargs invoker #2

  1411             calledLog.clear();

  1557             calledLog.clear();

  1412             inv = MethodHandles.varargsInvoker(type, 2);

  1558             inv = MethodHandles.varargsInvoker(type, 2);

  1414             if (testRetCode)  assertEquals(code, result);

  1560             if (testRetCode)  assertEquals(code, result);

  1415             assertCalled("invokee", args);

  1561             assertCalled("invokee", args);

  1416         }

  1562         }

  1417         if (nargs >= 3) {

  1563         if (nargs >= 3) {

  1418             // varargs invoker #3

  1564             // varargs invoker #3

  1419             calledLog.clear();

  1565             calledLog.clear();

  1420             inv = MethodHandles.varargsInvoker(type, 3);

  1566             inv = MethodHandles.varargsInvoker(type, 3);

  1422             if (testRetCode)  assertEquals(code, result);

  1568             if (testRetCode)  assertEquals(code, result);

  1423             assertCalled("invokee", args);

  1569             assertCalled("invokee", args);

  1424         }

  1570         }

  1425         for (int k = 0; k <= nargs; k++) {

  1571         for (int k = 0; k <= nargs; k++) {

  1426             // varargs invoker #0..N

  1572             // varargs invoker #0..N

  1521             case 0:   equals = true; break;

  1667             case 0:   equals = true; break;

  1522             case 1:   equals = MISSING_ARG.equals(argList[0]); break;

  1668             case 1:   equals = MISSING_ARG.equals(argList[0]); break;

  1523             default:  equals = argList[0].equals(argList[1]); break;

  1669             default:  equals = argList[0].equals(argList[1]); break;

  1524             }

  1670             }

  1525             String willCall = (equals ? "targetIfEquals" : "fallbackIfNotEquals");

  1671             String willCall = (equals ? "targetIfEquals" : "fallbackIfNotEquals");

  1527                 System.out.println(logEntry(willCall, argList));

  1673                 System.out.println(logEntry(willCall, argList));

  1528             Object result = mh.invokeVarargs(argList);

  1674             Object result = mh.invokeVarargs(argList);

  1529             assertCalled(willCall, argList);

  1675             assertCalled(willCall, argList);

  1530         }

  1676         }

  1531     }

  1677     }

  1550         return normal;

  1696         return normal;

  1551     }

  1697     }

  1552 

  1698 

  1553     void testCatchException(Class<?> returnType, Throwable thrown, boolean throwIt, int nargs) throws Throwable {

  1699     void testCatchException(Class<?> returnType, Throwable thrown, boolean throwIt, int nargs) throws Throwable {

  1554         countTest();

  1700         countTest();

  1556             System.out.println("catchException rt="+returnType+" throw="+throwIt+" nargs="+nargs);

  1702             System.out.println("catchException rt="+returnType+" throw="+throwIt+" nargs="+nargs);

  1557         Class<? extends Throwable> exType = thrown.getClass();

  1703         Class<? extends Throwable> exType = thrown.getClass();

  1558         MethodHandle throwOrReturn

  1704         MethodHandle throwOrReturn

  1559                 = PRIVATE.findStatic(MethodHandlesTest.class, "throwOrReturn",

  1705                 = PRIVATE.findStatic(MethodHandlesTest.class, "throwOrReturn",

  1560                     MethodType.methodType(Object.class, Object.class, Throwable.class));

  1706                     MethodType.methodType(Object.class, Object.class, Throwable.class));

  1592         Class<? extends Throwable> exType = thrown.getClass();

  1738         Class<? extends Throwable> exType = thrown.getClass();

  1593         MethodHandle target = MethodHandles.throwException(returnType, exType);

  1739         MethodHandle target = MethodHandles.throwException(returnType, exType);

  1594         //System.out.println("throwing with "+target+" : "+thrown);

  1740         //System.out.println("throwing with "+target+" : "+thrown);

  1595         MethodType expectedType = MethodType.methodType(returnType, exType);

  1741         MethodType expectedType = MethodType.methodType(returnType, exType);

  1596         assertEquals(expectedType, target.type());

  1742         assertEquals(expectedType, target.type());

  1597         Throwable caught = null;

  1744         Throwable caught = null;

  1598         try {

  1745         try {

  1600             fail("got "+res+" instead of throwing "+thrown);

  1747             fail("got "+res+" instead of throwing "+thrown);

  1601         } catch (Throwable ex) {

  1748         } catch (Throwable ex) {

  1602             if (ex != thrown) {

  1749             if (ex != thrown) {

  1603                 if (ex instanceof Error)  throw (Error)ex;

  1750                 if (ex instanceof Error)  throw (Error)ex;

  1604                 if (ex instanceof RuntimeException)  throw (RuntimeException)ex;

  1751                 if (ex instanceof RuntimeException)  throw (RuntimeException)ex;

  1645                     MethodType.methodType(int.class, int.class));

  1792                     MethodType.methodType(int.class, int.class));

  1646     }

  1793     }

  1647 

  1794 

  1648     void testCastFailure(String mode, int okCount) throws Throwable {

  1795     void testCastFailure(String mode, int okCount) throws Throwable {

  1649         countTest(false);

  1796         countTest(false);

  1651         Surprise boo = new Surprise();

  1798         Surprise boo = new Surprise();

  1652         MethodHandle identity = Surprise.REF_IDENTITY, surprise = boo;

  1799         MethodHandle identity = Surprise.REF_IDENTITY, surprise = boo;

  1653         if (mode.endsWith("/return")) {

  1800         if (mode.endsWith("/return")) {

  1654             if (mode.equals("unbox/return")) {

  1801             if (mode.equals("unbox/return")) {

  1655                 // fail on return to ((Integer)surprise).intValue

  1802                 // fail on return to ((Integer)surprise).intValue

  1678         assertNotSame(mode, surprise, boo);

  1825         assertNotSame(mode, surprise, boo);

  1679         identity = MethodHandles.convertArguments(identity, MethodType.genericMethodType(1));

  1826         identity = MethodHandles.convertArguments(identity, MethodType.genericMethodType(1));

  1680         surprise = MethodHandles.convertArguments(surprise, MethodType.genericMethodType(1));

  1827         surprise = MethodHandles.convertArguments(surprise, MethodType.genericMethodType(1));

  1681         Object x = 42;

  1828         Object x = 42;

  1682         for (int i = 0; i < okCount; i++) {

  1829         for (int i = 0; i < okCount; i++) {

  1684             assertEquals(x, y);

  1831             assertEquals(x, y);

  1686             assertEquals(x, z);

  1833             assertEquals(x, z);

  1687         }

  1834         }

  1688         boo.boo("Boo!");

  1835         boo.boo("Boo!");

  1690         assertEquals(x, y);

  1837         assertEquals(x, y);

  1691         try {

  1838         try {

  1693             System.out.println("Failed to throw; got z="+z);

  1840             System.out.println("Failed to throw; got z="+z);

  1694             assertTrue(false);

  1841             assertTrue(false);

  1695         } catch (Exception ex) {

  1842         } catch (Exception ex) {

  1697                 System.out.println("caught "+ex);

  1844                 System.out.println("caught "+ex);

  1699                 ex.printStackTrace();

  1846                 ex.printStackTrace();

  1700             assertTrue(ex instanceof ClassCastException

  1847             assertTrue(ex instanceof ClassCastException

  1701                     // FIXME: accept only one of the two for any given unit test

  1848                     // FIXME: accept only one of the two for any given unit test

  1702                     || ex instanceof WrongMethodTypeException

  1849                     || ex instanceof WrongMethodTypeException

  1703                     );

  1850                     );

  1764      */

  1911      */

  1765     public static MethodHandle varargsArray(int nargs) {

  1912     public static MethodHandle varargsArray(int nargs) {

  1766         if (nargs < ARRAYS.length)

  1913         if (nargs < ARRAYS.length)

  1767             return ARRAYS[nargs];

  1914             return ARRAYS[nargs];

  1768         // else need to spin bytecode or do something else fancy

  1915         // else need to spin bytecode or do something else fancy

  1770     }

  1917     }

  1771 

  1918 

  1772     private static final List<Object> NO_ARGS_LIST = Arrays.asList(NO_ARGS_ARRAY);

  1919     private static final List<Object> NO_ARGS_LIST = Arrays.asList(NO_ARGS_ARRAY);

  1773     private static List<Object> makeList(Object... args) { return Arrays.asList(args); }

  1920     private static List<Object> makeList(Object... args) { return Arrays.asList(args); }

  1774     private static List<Object> list() { return NO_ARGS_LIST; }

  1921     private static List<Object> list() { return NO_ARGS_LIST; }