jdk/test/java/lang/invoke/InvokeDynamicPrintArgs.java
changeset 8822 8145ab9f5f86
parent 8345 9e2483e6cfab
child 9033 a88f5656f05d
equal deleted inserted replaced
8821:2836ee97ee27 8822:8145ab9f5f86
       
     1 /*
       
     2  * Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
       
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
       
     4  *
       
     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
       
     7  * published by the Free Software Foundation.
       
     8  *
       
     9  * This code is distributed in the hope that it will be useful, but WITHOUT
       
    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
       
    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
       
    12  * version 2 for more details (a copy is included in the LICENSE file that
       
    13  * accompanied this code).
       
    14  *
       
    15  * You should have received a copy of the GNU General Public License version
       
    16  * 2 along with this work; if not, write to the Free Software Foundation,
       
    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
       
    18  *
       
    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
       
    20  * or visit www.oracle.com if you need additional information or have any
       
    21  * questions.
       
    22  */
       
    23 
       
    24 /* @test
       
    25  * @summary smoke test for invokedynamic instructions
       
    26  * @build indify.Indify
       
    27  * @compile InvokeDynamicPrintArgs.java
       
    28  * @run main/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableInvokeDynamic
       
    29  *      indify.Indify
       
    30  *      --verify-specifier-count=3 --transitionalJSR292=false
       
    31  *      --expand-properties --classpath ${test.classes}
       
    32  *      --java test.java.lang.invoke.InvokeDynamicPrintArgs --check-output
       
    33  */
       
    34 
       
    35 package test.java.lang.invoke;
       
    36 
       
    37 import org.junit.Test;
       
    38 
       
    39 import java.util.*;
       
    40 import java.io.*;
       
    41 
       
    42 import java.lang.invoke.*;
       
    43 import static java.lang.invoke.MethodHandles.*;
       
    44 import static java.lang.invoke.MethodType.*;
       
    45 
       
    46 public class InvokeDynamicPrintArgs {
       
    47     public static void main(String... av) throws Throwable {
       
    48         if (av.length > 0)  openBuf();  // --check-output mode
       
    49         System.out.println("Printing some argument lists, starting with a empty one:");
       
    50         INDY_nothing().invokeExact();                 // BSM specifier #0 = {bsm}
       
    51         INDY_bar().invokeExact("bar arg", 1);         // BSM specifier #1 = {bsm2, Void.class, "void type"}
       
    52         INDY_bar2().invokeExact("bar2 arg", 222);     // BSM specifier #1 = (same)
       
    53         INDY_baz().invokeExact("baz arg", 2, 3.14);   // BSM specifier #2 = {bsm2, 1234.5}
       
    54         INDY_foo().invokeExact("foo arg");            // BSM specifier #0 = (same)
       
    55         // Hence, BSM specifier count should be 3.  See "--verify-specifier-count=3" above.
       
    56         System.out.println("Done printing argument lists.");
       
    57         closeBuf();
       
    58     }
       
    59 
       
    60     @Test
       
    61     public void testInvokeDynamicPrintArgs() throws IOException {
       
    62         System.err.println(System.getProperties());
       
    63         String testClassPath = System.getProperty("build.test.classes.dir");
       
    64         if (testClassPath == null)  throw new RuntimeException();
       
    65         String[] args = new String[]{
       
    66             "--verify-specifier-count=3", "--transitionalJSR292=false",
       
    67             "--expand-properties", "--classpath", testClassPath,
       
    68             "--java", "test.java.lang.invoke.InvokeDynamicPrintArgs", "--check-output"
       
    69         };
       
    70         System.err.println("Indify: "+Arrays.toString(args));
       
    71         indify.Indify.main(args);
       
    72     }
       
    73 
       
    74     private static PrintStream oldOut;
       
    75     private static ByteArrayOutputStream buf;
       
    76     private static void openBuf() {
       
    77         oldOut = System.out;
       
    78         buf = new ByteArrayOutputStream();
       
    79         System.setOut(new PrintStream(buf));
       
    80     }
       
    81     private static void closeBuf() {
       
    82         if (buf == null)  return;
       
    83         System.out.flush();
       
    84         System.setOut(oldOut);
       
    85         String[] haveLines = new String(buf.toByteArray()).split("[\n\r]+");
       
    86         for (String line : haveLines)  System.out.println(line);
       
    87         Iterator<String> iter = Arrays.asList(haveLines).iterator();
       
    88         for (String want : EXPECT_OUTPUT) {
       
    89             String have = iter.hasNext() ? iter.next() : "[EOF]";
       
    90             if (want.equals(have))  continue;
       
    91             System.err.println("want line: "+want);
       
    92             System.err.println("have line: "+have);
       
    93             throw new AssertionError("unexpected output: "+have);
       
    94         }
       
    95         if (iter.hasNext())
       
    96             throw new AssertionError("unexpected output: "+iter.next());
       
    97     }
       
    98     private static final String[] EXPECT_OUTPUT = {
       
    99         "Printing some argument lists, starting with a empty one:",
       
   100         "[test.java.lang.invoke.InvokeDynamicPrintArgs, nothing, ()void][]",
       
   101         "[test.java.lang.invoke.InvokeDynamicPrintArgs, bar, (String,int)void, class java.lang.Void, void type!, 1, 234.5, 67.5, 89][bar arg, 1]",
       
   102         "[test.java.lang.invoke.InvokeDynamicPrintArgs, bar2, (String,int)void, class java.lang.Void, void type!, 1, 234.5, 67.5, 89][bar2 arg, 222]",
       
   103         "[test.java.lang.invoke.InvokeDynamicPrintArgs, baz, (String,int,double)void, 1234.5][baz arg, 2, 3.14]",
       
   104         "[test.java.lang.invoke.InvokeDynamicPrintArgs, foo, (String)void][foo arg]",
       
   105         "Done printing argument lists."
       
   106     };
       
   107 
       
   108     private static void printArgs(Object bsmInfo, Object... args) {
       
   109         System.out.println(bsmInfo+Arrays.deepToString(args));
       
   110     }
       
   111     private static MethodHandle MH_printArgs() throws ReflectiveOperationException {
       
   112         shouldNotCallThis();
       
   113         return lookup().findStatic(lookup().lookupClass(),
       
   114                                    "printArgs", methodType(void.class, Object.class, Object[].class));
       
   115     }
       
   116 
       
   117     private static CallSite bsm(Lookup caller, String name, MethodType type) throws ReflectiveOperationException {
       
   118         // ignore caller and name, but match the type:
       
   119         Object bsmInfo = Arrays.asList(caller, name, type);
       
   120         return new ConstantCallSite(MH_printArgs().bindTo(bsmInfo).asCollector(Object[].class, type.parameterCount()).asType(type));
       
   121     }
       
   122     private static MethodType MT_bsm() {
       
   123         shouldNotCallThis();
       
   124         return methodType(CallSite.class, Lookup.class, String.class, MethodType.class);
       
   125     }
       
   126     private static MethodHandle MH_bsm() throws ReflectiveOperationException {
       
   127         shouldNotCallThis();
       
   128         return lookup().findStatic(lookup().lookupClass(), "bsm", MT_bsm());
       
   129     }
       
   130 
       
   131     private static CallSite bsm2(Lookup caller, String name, MethodType type, Object... arg) throws ReflectiveOperationException {
       
   132         // ignore caller and name, but match the type:
       
   133         List<Object> bsmInfo = new ArrayList<>(Arrays.asList(caller, name, type));
       
   134         bsmInfo.addAll(Arrays.asList((Object[])arg));
       
   135         return new ConstantCallSite(MH_printArgs().bindTo(bsmInfo).asCollector(Object[].class, type.parameterCount()).asType(type));
       
   136     }
       
   137     private static MethodType MT_bsm2() {
       
   138         shouldNotCallThis();
       
   139         return methodType(CallSite.class, Lookup.class, String.class, MethodType.class, Object[].class);
       
   140     }
       
   141     private static MethodHandle MH_bsm2() throws ReflectiveOperationException {
       
   142         shouldNotCallThis();
       
   143         return lookup().findStatic(lookup().lookupClass(), "bsm2", MT_bsm2());
       
   144     }
       
   145 
       
   146     private static MethodHandle INDY_nothing() throws Throwable {
       
   147         shouldNotCallThis();
       
   148         return ((CallSite) MH_bsm().invokeGeneric(lookup(),
       
   149                                                   "nothing", methodType(void.class)
       
   150                                                   )).dynamicInvoker();
       
   151     }
       
   152     private static MethodHandle INDY_foo() throws Throwable {
       
   153         shouldNotCallThis();
       
   154         return ((CallSite) MH_bsm().invokeGeneric(lookup(),
       
   155                                                   "foo", methodType(void.class, String.class)
       
   156                                                   )).dynamicInvoker();
       
   157     }
       
   158     private static MethodHandle INDY_bar() throws Throwable {
       
   159         shouldNotCallThis();
       
   160         return ((CallSite) MH_bsm2().invokeGeneric(lookup(),
       
   161                                                   "bar", methodType(void.class, String.class, int.class)
       
   162                                                   , new Object[] { Void.class, "void type!",
       
   163                                                                    1, 234.5F, 67.5, (long)89 }
       
   164                                                   )).dynamicInvoker();
       
   165     }
       
   166     private static MethodHandle INDY_bar2() throws Throwable {
       
   167         shouldNotCallThis();
       
   168         return ((CallSite) MH_bsm2().invokeGeneric(lookup(),
       
   169                                                   "bar2", methodType(void.class, String.class, int.class)
       
   170                                                   , new Object[] { Void.class, "void type!",
       
   171                                                                    1, 234.5F, 67.5, (long)89 }
       
   172                                                   )).dynamicInvoker();
       
   173     }
       
   174     private static MethodHandle INDY_baz() throws Throwable {
       
   175         shouldNotCallThis();
       
   176         return ((CallSite) MH_bsm2().invokeGeneric(lookup(),
       
   177                                                   "baz", methodType(void.class, String.class, int.class, double.class)
       
   178                                                   , 1234.5
       
   179                                                   )).dynamicInvoker();
       
   180     }
       
   181 
       
   182     private static void shouldNotCallThis() {
       
   183         // if this gets called, the transformation has not taken place
       
   184         if (System.getProperty("InvokeDynamicPrintArgs.allow-untransformed") != null)  return;
       
   185         throw new AssertionError("this code should be statically transformed away by Indify");
       
   186     }
       
   187 }