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 /*
26 * @test compiler.jvmci.constantReflectionProviderTest.HotSpotConstantReflectionProviderTest
27 * @requires (os.simpleArch == "x64" | os.simpleArch == "sparcv9" | os.simpleArch == "aarch64")
28 * @modules jdk.vm.ci/jdk.vm.ci.runtime
29 * jdk.vm.ci/jdk.vm.ci.meta
30 * jdk.vm.ci/jdk.vm.ci.hotspot
31 * @library /testlibrary /test/lib /
32 * @build compiler.jvmci.constantReflectionProviderTest.DummyClass
33 * @run driver ClassFileInstaller compiler.jvmci.constantReflectionProviderTest.DummyClass
34 * @run testng/othervm/timeout=300 -Xbootclasspath/a:.
35 * -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI
36 * compiler.jvmci.constantReflectionProviderTest.HotSpotConstantReflectionProviderTest
37 */
38
39 package compiler.jvmci.constantReflectionProviderTest;
40
41 import static compiler.jvmci.constantReflectionProviderTest.TestHelper.CONSTANT_REFLECTION_PROVIDER;
42 import java.lang.reflect.Method;
43 import jdk.vm.ci.hotspot.HotSpotResolvedJavaField;
44 import jdk.vm.ci.meta.JavaConstant;
45 import jdk.vm.ci.meta.Constant;
46 import jdk.vm.ci.meta.MemoryAccessProvider;
47 import jdk.vm.ci.meta.MethodHandleAccessProvider;
48 import jdk.vm.ci.meta.ResolvedJavaField;
49 import jdk.vm.ci.meta.ResolvedJavaType;
50 import org.testng.Assert;
51 import org.testng.annotations.Test;
52
53 public class HotSpotConstantReflectionProviderTest {
54
55 @Test(dataProvider = "forObjectDataProvider",
56 dataProviderClass = ForObjectDataProvider.class)
57 public void testForObject(Object obj, String expected) {
58 JavaConstant jConst = TestHelper.CONSTANT_REFLECTION_PROVIDER.forObject(obj);
59 Assert.assertNotNull(jConst, "An instance of JavaConstant returned by"
60 + " \"forObject\" method should not be null");
61 Assert.assertEquals(jConst.toString(), expected, "Unexpected result:");
62 }
63
64 @Test(dataProvider = "forStringDataProvider",
65 dataProviderClass = ForStringDataProvider.class)
66 public void testForString(String string, String expected) {
67 JavaConstant jConst = CONSTANT_REFLECTION_PROVIDER.forString(string);
68 Assert.assertNotNull(jConst, "An instance of JavaConstant returned by"
69 + " \"forString\" method should not be null");
70 Assert.assertEquals(jConst.toString(), expected, "Unexpected result:");
71 }
72
73 @Test(dataProvider = "constantEqualsDataProvider",
74 dataProviderClass = ConstantEqualsDataProvider.class)
75 public void testConstantEquals(Constant const1, Constant const2, Boolean expected) {
76 Assert.assertEquals(CONSTANT_REFLECTION_PROVIDER.constantEquals(const1, const2),
77 expected, "Unexpected result:");
78 }
79
80 @Test(dataProvider = "readArrayLengthDataProvider",
81 dataProviderClass = ReadArrayLengthDataProvider.class)
82 public void testReadArrayLength(JavaConstant array, Integer expected) {
83 Assert.assertEquals(CONSTANT_REFLECTION_PROVIDER.readArrayLength(array),
84 expected, "Unexpected result:");
85 }
86
87 @Test(dataProvider = "readArrayElementDataProvider",
88 dataProviderClass = ReadArrayElementDataProvider.class)
89 public void testReadArrayElement(JavaConstant array, int index, Object expected) {
90 Assert.assertEquals(CONSTANT_REFLECTION_PROVIDER.readArrayElement(array, index),
91 expected, "Unexpected result:");
92 }
93
94 @Test(dataProvider = "readFieldValueDataProvider",
95 dataProviderClass = ReadFieldValueDataProvider.class)
96 public void testReadFieldValue(ResolvedJavaField field,
97 JavaConstant receiver,
98 JavaConstant expected) {
99 JavaConstant actual = CONSTANT_REFLECTION_PROVIDER.readFieldValue(field, receiver);
100 Assert.assertEquals(actual == null ? "null" : actual.toString(),
101 expected == null ? "null" : expected.toString(),
102 "Unexpected result:");
103 }
104
105 @Test(dataProvider = "readFieldValueNegativeDataProvider",
106 dataProviderClass = ReadFieldValueDataProvider.class,
107 expectedExceptions = {NullPointerException.class})
108 public void testNegativeReadFieldValue(ResolvedJavaField field, JavaConstant receiver) {
109 CONSTANT_REFLECTION_PROVIDER.readFieldValue(field, receiver);
110 }
111
112 @Test(dataProvider = "readStableFieldValueDataProvider",
113 dataProviderClass = ReadStableFieldValueDataProvider.class)
114 public void testReadStableFieldValue(ResolvedJavaField field,
115 JavaConstant receiver,
116 boolean isDefStab,
117 JavaConstant expected) {
118 Assert.assertEquals(CONSTANT_REFLECTION_PROVIDER.readStableFieldValue(field,
119 receiver,
120 isDefStab),
121 expected, "Unexpected result:");
122 }
123
124 @Test(dataProvider = "readStableFieldValueArrayDataProvider",
125 dataProviderClass = ReadStableFieldValueDataProvider.class)
126 public void testReadStableFieldValueForArray(ResolvedJavaField field,
127 JavaConstant receiver,
128 boolean isDefStab,
129 int arrayDim,
130 JavaConstant expected) {
131 JavaConstant result = CONSTANT_REFLECTION_PROVIDER.readStableFieldValue(field,
132 receiver,
133 isDefStab);
134 boolean resultDefStab = false;
135 int resultStableDim = -1;
136 try {
137 Class<?> hotSpotObjectConstantImplClass
138 = Class.forName("jdk.vm.ci.hotspot.HotSpotObjectConstantImpl");
139 Method getStableDimensionMethod
140 = hotSpotObjectConstantImplClass.getDeclaredMethod("getStableDimension");
141 Method isDefaultStableMethod
142 = hotSpotObjectConstantImplClass.getDeclaredMethod("isDefaultStable");
143 getStableDimensionMethod.setAccessible(true);
144 isDefaultStableMethod.setAccessible(true);
145 resultDefStab = (boolean) isDefaultStableMethod.invoke(result);
146 resultStableDim = (int) getStableDimensionMethod.invoke(result);
147 } catch (ReflectiveOperationException e) {
148 throw new Error("Unexpected error: " + e, e);
149 }
150 Assert.assertEquals(resultDefStab,
151 isDefStab,
152 "Wrong default stable value for " + result.toString());
153 Assert.assertEquals(resultStableDim, arrayDim, "Wrong array dimension for " + result.toString());
154 Assert.assertEquals(result.toString(), expected.toString(), "Unexpected result:");
155 }
156
157 @Test(dataProvider = "readStableFieldValueNegativeDataProvider",
158 dataProviderClass = ReadStableFieldValueDataProvider.class,
159 expectedExceptions = {NullPointerException.class})
160 public void testNegativeReadStableFieldValue(ResolvedJavaField field,
161 JavaConstant receiver,
162 boolean isDefStab) {
163 CONSTANT_REFLECTION_PROVIDER.readStableFieldValue(field, receiver, isDefStab);
164 }
165
166 @Test(dataProvider = "readConstantFieldValueDataProvider",
167 dataProviderClass = ReadConstantFieldValueDataProvider.class)
168 public void testReadConstantFieldValue(ResolvedJavaField field,
169 JavaConstant receiver,
170 JavaConstant expected,
171 String testInfo) {
172 String msg = String.format("Unexpected result for %s. Field is stable = %s.",
173 testInfo, ((HotSpotResolvedJavaField) field).isStable());
174 Assert.assertEquals(CONSTANT_REFLECTION_PROVIDER.readConstantFieldValue(field, receiver),
175 expected, msg);
176 }
177
178 @Test(dataProvider = "readConstantFieldValueNegativeDataProvider",
179 dataProviderClass = ReadConstantFieldValueDataProvider.class,
180 expectedExceptions = {NullPointerException.class})
181 public void testNegativeReadConstantFieldValue(ResolvedJavaField field, JavaConstant receiver) {
182 CONSTANT_REFLECTION_PROVIDER.readConstantFieldValue(field, receiver);
183 }
184
185 @Test(dataProvider = "readConstantArrayElementDataProvider",
186 dataProviderClass = ReadConstantArrayElementDataProvider.class)
187 public void testReadConstantArrayElement(JavaConstant array,
188 int index,
189 JavaConstant expected,
190 String testInfo) {
191 JavaConstant actual = CONSTANT_REFLECTION_PROVIDER.readConstantArrayElement(array, index);
192 Assert.assertEquals(actual == null ? "null" : actual.toString(),
193 expected == null ? "null" : expected.toString(),
194 String.format("Unexpected result while testing %s:", testInfo));
195 }
196
197 @Test(dataProvider = "readConstantArrayElementForOffsetDataProvider",
198 dataProviderClass = ReadConstantArrayElementDataProvider.class)
199 public void testReadConstantArrayElementForOffset(JavaConstant array,
200 long offset,
201 JavaConstant expected,
202 String testInfo) {
203 JavaConstant actual = CONSTANT_REFLECTION_PROVIDER
204 .readConstantArrayElementForOffset(array, offset);
205 Assert.assertEquals(actual == null ? "null" : actual.toString(),
206 expected == null ? "null" : expected.toString(),
207 String.format("Unexpected result while testing %s:", testInfo));
208 }
209
210 @Test(dataProvider = "asJavaTypeDataProvider", dataProviderClass = AsJavaTypeDataProvider.class)
211 public void testAsJavaType(JavaConstant constant, String expected) {
212 ResolvedJavaType actual = CONSTANT_REFLECTION_PROVIDER.asJavaType(constant);
213 Assert.assertEquals(actual == null ? "null" : actual.toJavaName(),
214 expected == null ? "null" : expected,
215 "Unexpected result, wrong type returned:");
216 }
217
218 @Test(dataProvider = "boxPrimitiveDataProvider", dataProviderClass = BoxPrimitiveDataProvider.class)
219 public void testBoxPrimitive(JavaConstant constant, JavaConstant expected) {
220 JavaConstant actual = CONSTANT_REFLECTION_PROVIDER.boxPrimitive(constant);
221 Assert.assertEquals(actual, expected, "Unexpected result:");
222 }
223
224 @Test(dataProvider = "unboxPrimitiveDataProvider",
225 dataProviderClass = UnboxPrimitiveDataProvider.class)
226 public void testUnboxPrimitive(JavaConstant constant, JavaConstant expected) {
227 JavaConstant actual = CONSTANT_REFLECTION_PROVIDER.unboxPrimitive(constant);
228 Assert.assertEquals(actual, expected, "Unexpected result:");
229 }
230
231 @Test(dataProvider = "isEmbeddableDataProvider", dataProviderClass = IsEmbeddableDataProvider.class)
232 public void testIsEmbeddable(JavaConstant constant, boolean expected) {
233 boolean actual = CONSTANT_REFLECTION_PROVIDER.isEmbeddable(constant);
234 Assert.assertEquals(actual, expected, "Unexpected result:");
235 }
236
237 @Test
238 public void testGetMemoryAccessProvider() {
239 MemoryAccessProvider actual = CONSTANT_REFLECTION_PROVIDER.getMemoryAccessProvider();
240 Assert.assertNotNull(actual, "Returned MemoryAccessProvider instance should not be null");
241 }
242
243 @Test
244 public void testGetMethodHandleAccess() {
245 MethodHandleAccessProvider actual = CONSTANT_REFLECTION_PROVIDER.getMethodHandleAccess();
246 Assert.assertNotNull(actual, "Returned MethodHandleAccessProvider instance should not be null");
247 }
248 }