1 /*

     2  * Copyright (c) 2017, 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 /*

    25  * @test

    26  * @bug 8186046

    27  * @summary Test dynamic constant bootstraps

    28  * @library /lib/testlibrary/bytecode /java/lang/invoke/common

    29  * @build jdk.experimental.bytecode.BasicClassBuilder test.java.lang.invoke.lib.InstructionHelper

    30  * @run testng ConstantBootstrapsTest

    31  * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 ConstantBootstrapsTest

    32  */

    33 

    34 import jdk.experimental.bytecode.PoolHelper;

    35 import org.testng.annotations.Test;

    36 import test.java.lang.invoke.lib.InstructionHelper;

    37 

    38 import java.lang.invoke.ConstantBootstraps;

    39 import java.lang.invoke.MethodHandle;

    40 import java.lang.invoke.MethodHandleInfo;

    41 import java.lang.invoke.MethodHandles;

    42 import java.lang.invoke.MethodType;

    43 import java.lang.invoke.VarHandle;

    44 import java.lang.invoke.WrongMethodTypeException;

    45 import java.math.BigInteger;

    46 import java.util.List;

    47 import java.util.Map;

    48 

    49 import static org.testng.Assert.assertEquals;

    50 import static org.testng.Assert.assertNull;

    51 

    52 @Test

    53 public class ConstantBootstrapsTest {

    54     static final MethodHandles.Lookup L = MethodHandles.lookup();

    55 

    56     static MethodType lookupMT(Class<?> ret, Class<?>... params) {

    57         return MethodType.methodType(ret, MethodHandles.Lookup.class, String.class, Class.class).

    58                 appendParameterTypes(params);

    59     }

    60 

    61     public void testNullConstant() throws Throwable {

    62         var handle = InstructionHelper.ldcDynamicConstant(L, "_", Object.class,

    63                                                           ConstantBootstraps.class, "nullConstant", lookupMT(Object.class),

    64                                                           S -> {});

    65         assertNull(handle.invoke());

    66 

    67         handle = InstructionHelper.ldcDynamicConstant(L, "_", MethodType.class,

    68                                                       ConstantBootstraps.class, "nullConstant", lookupMT(Object.class),

    69                                                       S -> {});

    70         assertNull(handle.invoke());

    71     }

    72 

    73     @Test(expectedExceptions = IllegalArgumentException.class)

    74     public void testNullConstantPrimitiveClass() {

    75         ConstantBootstraps.nullConstant(MethodHandles.lookup(), null, int.class);

    76     }

    77 

    78 

    79     public void testPrimitiveClass() throws Throwable {

    80         var pm = Map.of(

    81                 "I", int.class,

    82                 "J", long.class,

    83                 "S", short.class,

    84                 "B", byte.class,

    85                 "C", char.class,

    86                 "F", float.class,

    87                 "D", double.class,

    88                 "Z", boolean.class,

    89                 "V", void.class

    90         );

    91 

    92         for (var desc : pm.keySet()) {

    93             var handle = InstructionHelper.ldcDynamicConstant(L, desc, Class.class,

    94                                                               ConstantBootstraps.class, "primitiveClass", lookupMT(Class.class),

    95                                                               S -> {});

    96             assertEquals(handle.invoke(), pm.get(desc));

    97         }

    98     }

    99 

   100     @Test(expectedExceptions = NullPointerException.class)

   101     public void testPrimitiveClassNullName() {

   102         ConstantBootstraps.primitiveClass(MethodHandles.lookup(), null, Class.class);

   103     }

   104 

   105     @Test(expectedExceptions = NullPointerException.class)

   106     public void testPrimitiveClassNullType() {

   107         ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "I", null);

   108     }

   109 

   110     @Test(expectedExceptions = IllegalArgumentException.class)

   111     public void testPrimitiveClassEmptyName() {

   112         ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "", Class.class);

   113     }

   114 

   115     @Test(expectedExceptions = IllegalArgumentException.class)

   116     public void testPrimitiveClassWrongNameChar() {

   117         ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "L", Class.class);

   118     }

   119 

   120     @Test(expectedExceptions = IllegalArgumentException.class)

   121     public void testPrimitiveClassWrongNameString() {

   122         ConstantBootstraps.primitiveClass(MethodHandles.lookup(), "Ljava/lang/Object;", Class.class);

   123     }

   124 

   125 

   126     public void testEnumConstant() throws Throwable {

   127         for (var v : StackWalker.Option.values()) {

   128             var handle = InstructionHelper.ldcDynamicConstant(L, v.name(), StackWalker.Option.class,

   129                                                               ConstantBootstraps.class, "enumConstant", lookupMT(Enum.class),

   130                                                               S -> { });

   131             assertEquals(handle.invoke(), v);

   132         }

   133     }

   134 

   135     @Test(expectedExceptions = IllegalArgumentException.class)

   136     public void testEnumConstantUnknown() {

   137         ConstantBootstraps.enumConstant(MethodHandles.lookup(), "DOES_NOT_EXIST", StackWalker.Option.class);

   138     }

   139 

   140 

   141     public void testGetStaticDecl() throws Throwable {

   142         var handle = InstructionHelper.ldcDynamicConstant(L, "TYPE", Class.class,

   143                                                           ConstantBootstraps.class, "getStaticFinal", lookupMT(Object.class, Class.class),

   144                                                           S -> { S.add("java/lang/Integer", PoolHelper::putClass); });

   145         assertEquals(handle.invoke(), int.class);

   146     }

   147 

   148     public void testGetStaticSelf() throws Throwable {

   149         var handle = InstructionHelper.ldcDynamicConstant(L, "MAX_VALUE", int.class,

   150                                                           ConstantBootstraps.class, "getStaticFinal", lookupMT(Object.class),

   151                                                           S -> { });

   152         assertEquals(handle.invoke(), Integer.MAX_VALUE);

   153 

   154 

   155         handle = InstructionHelper.ldcDynamicConstant(L, "ZERO", BigInteger.class,

   156                                                       ConstantBootstraps.class, "getStaticFinal", lookupMT(Object.class),

   157                                                       S -> { });

   158         assertEquals(handle.invoke(), BigInteger.ZERO);

   159     }

   160 

   161 

   162     public void testInvoke() throws Throwable {

   163         var handle = InstructionHelper.ldcDynamicConstant(

   164                 L, "_", List.class,

   165                 ConstantBootstraps.class, "invoke", lookupMT(Object.class, MethodHandle.class, Object[].class),

   166                 S -> {

   167                     S.add("", (P, Z) -> {

   168                         return P.putHandle(MethodHandleInfo.REF_invokeStatic, "java/util/List", "of",

   169                                            MethodType.methodType(List.class, Object[].class).toMethodDescriptorString(),

   170                                            true);

   171                     });

   172                     S.add(1).add(2).add(3).add(4);

   173                 });

   174         assertEquals(handle.invoke(), List.of(1, 2, 3, 4));

   175     }

   176 

   177     public void testInvokeAsType() throws Throwable {

   178         var handle = InstructionHelper.ldcDynamicConstant(

   179                 L, "_", int.class,

   180                 ConstantBootstraps.class, "invoke", lookupMT(Object.class, MethodHandle.class, Object[].class),

   181                 S -> {

   182                     S.add("", (P, Z) -> {

   183                         return P.putHandle(MethodHandleInfo.REF_invokeStatic, "java/lang/Integer", "valueOf",

   184                                            MethodType.methodType(Integer.class, String.class).toMethodDescriptorString(),

   185                                            false);

   186                     });

   187                     S.add("42");

   188                 });

   189         assertEquals(handle.invoke(), 42);

   190     }

   191 

   192     @Test(expectedExceptions = ClassCastException.class)

   193     public void testInvokeAsTypeClassCast() throws Throwable {

   194         ConstantBootstraps.invoke(MethodHandles.lookup(), "_", String.class,

   195                                   MethodHandles.lookup().findStatic(Integer.class, "valueOf", MethodType.methodType(Integer.class, String.class)),

   196                                   "42");

   197     }

   198 

   199     @Test(expectedExceptions = WrongMethodTypeException.class)

   200     public void testInvokeAsTypeWrongReturnType() throws Throwable {

   201         ConstantBootstraps.invoke(MethodHandles.lookup(), "_", short.class,

   202                                   MethodHandles.lookup().findStatic(Integer.class, "parseInt", MethodType.methodType(int.class, String.class)),

   203                                   "42");

   204     }

   205 

   206 

   207     static class X {

   208         public String f;

   209         public static String sf;

   210     }

   211 

   212     public void testVarHandleField() throws Throwable {

   213         var handle = InstructionHelper.ldcDynamicConstant(

   214                 L, "f", VarHandle.class,

   215                 ConstantBootstraps.class, "fieldVarHandle", lookupMT(VarHandle.class, Class.class, Class.class),

   216                 S -> {

   217                     S.add(X.class.getName().replace('.', '/'), PoolHelper::putClass).

   218                             add("java/lang/String", PoolHelper::putClass);

   219                 });

   220 

   221         var vhandle = (VarHandle) handle.invoke();

   222         assertEquals(vhandle.varType(), String.class);

   223         assertEquals(vhandle.coordinateTypes(), List.of(X.class));

   224     }

   225 

   226     public void testVarHandleStaticField() throws Throwable {

   227         var handle = InstructionHelper.ldcDynamicConstant(

   228                 L, "sf", VarHandle.class,

   229                 ConstantBootstraps.class, "staticFieldVarHandle", lookupMT(VarHandle.class, Class.class, Class.class),

   230                 S -> {

   231                     S.add(X.class.getName().replace('.', '/'), PoolHelper::putClass).

   232                             add("java/lang/String", PoolHelper::putClass);

   233                 });

   234 

   235         var vhandle = (VarHandle) handle.invoke();

   236         assertEquals(vhandle.varType(), String.class);

   237         assertEquals(vhandle.coordinateTypes(), List.of());

   238     }

   239 

   240     public void testVarHandleArray() throws Throwable {

   241         var handle = InstructionHelper.ldcDynamicConstant(

   242                 L, "_", VarHandle.class,

   243                 ConstantBootstraps.class, "arrayVarHandle", lookupMT(VarHandle.class, Class.class),

   244                 S -> {

   245                     S.add(String[].class.getName().replace('.', '/'), PoolHelper::putClass);

   246                 });

   247 

   248         var vhandle = (VarHandle) handle.invoke();

   249         assertEquals(vhandle.varType(), String.class);

   250         assertEquals(vhandle.coordinateTypes(), List.of(String[].class, int.class));

   251     }

   252 }