1 /*
2 * Copyright (c) 2016, 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 8152343
27 * @bug 8161068
28 * @requires vm.jvmci
29 * @library /test/lib /compiler/jvmci/jdk.vm.ci.hotspot.test/src
30 * @modules java.base/java.lang.invoke:+open
31 * @modules jdk.internal.vm.ci/jdk.vm.ci.meta
32 * jdk.internal.vm.ci/jdk.vm.ci.runtime
33 * @modules jdk.internal.vm.ci/jdk.vm.ci.hotspot:+open
34 * @run testng/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI
35 * -Djvmci.Compiler=null jdk.vm.ci.hotspot.test.MethodHandleAccessProviderTest
36 */
37
38 package jdk.vm.ci.hotspot.test;
39
40 import jdk.vm.ci.hotspot.HotSpotConstantReflectionProvider;
41 import jdk.vm.ci.meta.JavaConstant;
42 import jdk.vm.ci.meta.MetaAccessProvider;
43 import jdk.vm.ci.meta.MethodHandleAccessProvider;
44 import jdk.vm.ci.meta.MethodHandleAccessProvider.IntrinsicMethod;
45 import jdk.vm.ci.meta.ResolvedJavaMethod;
46 import jdk.vm.ci.runtime.JVMCI;
47 import org.testng.Assert;
48 import org.testng.annotations.Test;
49
50 import java.lang.invoke.MethodHandle;
51 import java.lang.invoke.MethodHandles;
52 import java.lang.reflect.Method;
53
54 public class MethodHandleAccessProviderTest {
55 private static final HotSpotConstantReflectionProvider CONSTANT_REFLECTION = (HotSpotConstantReflectionProvider) JVMCI.getRuntime().getHostJVMCIBackend().getConstantReflection();
56 private static final MethodHandleAccessProvider PROVIDER = CONSTANT_REFLECTION.getMethodHandleAccess();
57 private static final MetaAccessProvider META_ACCESS = JVMCI.getRuntime().getHostJVMCIBackend().getMetaAccess();
58
59 @Test(dataProvider = "intrinsicsPositive", dataProviderClass = MethodHandleAccessProviderData.class)
60 public void testLookupMethodHandleIntrinsic(ResolvedJavaMethod mtd, IntrinsicMethod expected) {
61 Assert.assertEquals(expected, PROVIDER.lookupMethodHandleIntrinsic(mtd), "Unexpected intrinsic returned for " + mtd);
62 }
63
64 @Test(dataProvider = "intrinsicsNegative", dataProviderClass = MethodHandleAccessProviderData.class)
65 public void testLookupMethodHandleIntrinsicNegative(ResolvedJavaMethod mtd) {
66 Assert.assertNull(PROVIDER.lookupMethodHandleIntrinsic(mtd), "Expected null return for " + mtd);
67 }
68
69 @Test(expectedExceptions = {NullPointerException.class})
70 public void testLookupMethodHandleIntrinsicNull() {
71 PROVIDER.lookupMethodHandleIntrinsic(null);
72 }
73
74 @Test(dataProvider = "invokeBasicPositive", dataProviderClass = MethodHandleAccessProviderData.class)
75 public void testResolveInvokeBasicTarget(JavaConstant javaConstantMethodHandle, boolean force, String expected) {
76 ResolvedJavaMethod mtd = PROVIDER.resolveInvokeBasicTarget(javaConstantMethodHandle, force);
77 Assert.assertTrue(mtd.getName().startsWith(expected), "Unexpected method resolved: " + mtd);
78 }
79
80 @Test(dataProvider = "invokeBasicNegative1", dataProviderClass = MethodHandleAccessProviderData.class)
81 public void testResolveInvokeBasicTargetNegative1(JavaConstant javaConstantMethodHandle, boolean force) {
82 Assert.assertNull(PROVIDER.resolveInvokeBasicTarget(javaConstantMethodHandle, force),
83 "Expected null return for " + javaConstantMethodHandle + " with force=" + force);
84 }
85
86 @Test(dataProvider = "invokeBasicNegative2", dataProviderClass = MethodHandleAccessProviderData.class, expectedExceptions = {NullPointerException.class})
87 public void testResolveInvokeBasicTargetNegative2(JavaConstant javaConstantMethodHandle, boolean force) {
88 PROVIDER.resolveInvokeBasicTarget(javaConstantMethodHandle, force);
89 }
90
91 @Test
92 public void testResolveLinkToTarget() {
93 Method self;
94 try {
95 self = getClass().getDeclaredMethod("testResolveLinkToTarget");
96 } catch (NoSuchMethodException e) {
97 throw new Error("TESTBUG: can't find method: " + e, e);
98 }
99 MethodHandle mh;
100 try {
101 mh = MethodHandles.lookup().unreflect(self);
102 } catch (IllegalAccessException e) {
103 throw new Error("TESTBUG: can't get MHandle: " + e, e);
104 }
105 Method internalMemberNameMethod;
106 try {
107 internalMemberNameMethod = mh.getClass().getDeclaredMethod("internalMemberName");
108 } catch (NoSuchMethodException e) {
109 throw new Error("TESTBUG: can't find method: " + e, e);
110 }
111 internalMemberNameMethod.setAccessible(true);
112 Object memberName;
113 try {
114 memberName = internalMemberNameMethod.invoke(mh);
115 } catch (ReflectiveOperationException e) {
116 throw new Error("TESTBUG: can't invoke internalMemberName method", e);
117 }
118 JavaConstant jcMemberName = CONSTANT_REFLECTION.forObject(memberName);
119 ResolvedJavaMethod mtd = PROVIDER.resolveLinkToTarget(jcMemberName);
120 Assert.assertEquals(mtd, META_ACCESS.lookupJavaMethod(self), "Got unexpected method: " + mtd);
121 }
122
123 @Test(expectedExceptions = {NullPointerException.class})
124 public void testResolveLinkToTargetNegativeNull() {
125 PROVIDER.resolveLinkToTarget(null);
126 }
127
128 @Test
129 public void testResolveLinkToTargetNegativeNullConstant() {
130 Assert.assertNull(PROVIDER.resolveLinkToTarget(JavaConstant.NULL_POINTER), "Expected null return");
131 }
132
133 @Test(expectedExceptions = {IllegalArgumentException.class})
134 public void testResolveLinkToTargetNegativeWrongConstant() {
135 PROVIDER.resolveLinkToTarget(CONSTANT_REFLECTION.forObject("42"));
136 }
137 }