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
27 * @summary test reflection on inline types
28 * @compile -XDallowWithFieldOperator Point.java Line.java NonFlattenValue.java
29 * @run main/othervm -XX:+EnableValhalla Reflection
30 */
31
32 import java.lang.reflect.*;
33 import java.util.Arrays;
34 import java.util.stream.Collectors;
35
36 public class Reflection {
37 public static void main(String... args) throws Exception {
38 testPointClass();
39 testLineClass();
40 testNonFlattenValue();
41 testMirrors();
42 testClassName();
43 }
44
45 static void testPointClass() throws Exception {
46 Point o = Point.makePoint(10, 20);
47 Reflection test = new Reflection(Point.class, "Point", o);
48 test.newInstance();
49 test.constructor();
50 test.accessFieldX(o.x);
51 test.setAccessible();
52 test.trySetAccessible();
53 test.staticField();
54 }
55
56 static void testLineClass() throws Exception {
57 Line l = Line.makeLine(10, 20, 30, 40);
58 Reflection test = new Reflection(Line.class, "Line", l);
59 test.checkField("public final Point Line.p1", "p1", Point.class);
60 test.checkField("public final Point Line.p2", "p2", Point.class);
61 test.checkMethod("public Point Line.p1()", "p1", Point.class);
62 test.checkMethod("public Point Line.p2()", "p2", Point.class);
63 }
64
65 static void testNonFlattenValue() throws Exception {
66 NonFlattenValue nfv = NonFlattenValue.make(10, 20);
67 Reflection test = new Reflection(NonFlattenValue.class, "NonFlattenValue", nfv);
68 test.checkField("final Point? NonFlattenValue.nfp", "nfp", Point.class.asNullableType());
69 test.checkMethod("public Point NonFlattenValue.pointValue()", "pointValue", Point.class);
70 test.checkMethod("public Point? NonFlattenValue.point()", "point", Point.class.asNullableType());
71 test.checkMethod("public boolean NonFlattenValue.has(Point,Point?)", "has", boolean.class, Point.class, Point.class.asNullableType());
72 }
73
74 /*
75 * Tests reflection APIs with the primary and nullable mirror
76 */
77 static void testMirrors() throws Exception {
78 Class<?> primary = Point.class;
79 Class<?> nullable = Point.class.asNullableType();
80
81 assertEquals(primary, Point.class);
82 assertTrue(primary.isInlineClass());
83 assertTrue(nullable.isInlineClass());
84
85 Point o = Point.makePoint(10, 20);
86 assertTrue(primary.isInstance(o));
87 assertTrue(nullable.isInstance(o));
88
89 // V <: V? and V <: Object
90 assertTrue(nullable.isAssignableFrom(primary));
91 assertTrue(Object.class.isAssignableFrom(primary));
156 assertEquals(arrayType.asNullableType(), arrayType);
157 if (array[0] == null) {
158 System.out.println("array[0] = null");
159 } else {
160 System.out.println("array[0] = " + array[0]);
161 }
162 }
163
164 void accessFieldX(int x) throws Exception {
165 Field field = c.getField("x");
166 if (field.getInt(o) != x) {
167 throw new RuntimeException("Unexpected Point.x value: " + field.getInt(o));
168 }
169
170 try {
171 field.setInt(o, 100);
172 throw new RuntimeException("IllegalAccessException not thrown");
173 } catch (IllegalAccessException e) {}
174 }
175
176 void newInstance() throws Exception {
177 try {
178 Object o = c.newInstance();
179 throw new RuntimeException("newInstance expected to be unsupported on inline class");
180 } catch (IllegalAccessException e) {}
181 }
182
183 void constructor() throws Exception {
184 try {
185 ctor.newInstance();
186 throw new RuntimeException("IllegalAccessException not thrown");
187 } catch (IllegalAccessException e) { }
188 }
189
190 void setAccessible() throws Exception {
191 try {
192 ctor.setAccessible(true);
193 throw new RuntimeException("InaccessibleObjectException not thrown");
194 } catch (InaccessibleObjectException e) { e.printStackTrace(); }
195 Field field = c.getField("x");
196 try {
197 field.setAccessible(true);
198 throw new RuntimeException("InaccessibleObjectException not thrown");
199 } catch (InaccessibleObjectException e) { e.printStackTrace(); }
200 }
201
202 void trySetAccessible() throws Exception {
203 if (ctor.trySetAccessible()) {
204 throw new RuntimeException("trySetAccessible should not succeed");
205 }
206 Field field = c.getField("x");
207 if (field.trySetAccessible()) {
208 throw new RuntimeException("trySetAccessible should not succeed");
209 }
210 }
211
212 void staticField() throws Exception {
213 Field f = c.getDeclaredField("STATIC_FIELD");
214 if (f.trySetAccessible()) {
215 throw new RuntimeException("trySetAccessible should not succeed");
216 }
217 try {
218 f.setAccessible(true);
219 throw new RuntimeException("IllegalAccessException not thrown");
220 } catch (InaccessibleObjectException e) { }
221 }
222
223 void checkField(String source, String name, Class<?> type) throws Exception {
224 Field f = c.getDeclaredField(name);
225 assertEquals(f.getType(), type);
226 assertEquals(f.toString(), source);
227 }
228
229 void checkMethod(String source, String name, Class<?> returnType, Class<?>... params) throws Exception {
230 Method m = c.getDeclaredMethod(name, params);
231 assertEquals(m.toString(), source);
232 }
233
234 static void assertEquals(Object o1, Object o2) {
235 if (o1 == o2 || o1.equals(o2))
236 return;
237
238 throw new AssertionError(o1 + " != " + o2);
239 }
240
241 static void assertTrue(boolean value) {
242 if (!value)
243 throw new AssertionError("expected true");
244 }
245
246 static void assertFalse(boolean value) {
247 if (value)
248 throw new AssertionError("expected false");
249 }
250 }
|
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
27 * @summary test reflection on inline types
28 * @compile -XDallowWithFieldOperator Point.java Line.java NonFlattenValue.java
29 * @run main/othervm -XX:+EnableValhalla Reflection
30 */
31
32 import java.lang.reflect.Array;
33 import java.lang.reflect.Constructor;
34 import java.lang.reflect.Field;
35 import java.lang.reflect.InaccessibleObjectException;
36 import java.lang.reflect.Method;
37 import java.lang.reflect.Modifier;
38 import java.util.Arrays;
39 import java.util.List;
40 import java.util.stream.Collectors;
41
42 public class Reflection {
43 public static void main(String... args) throws Exception {
44 testPointClass();
45 testLineClass();
46 testNonFlattenValue();
47 testMirrors();
48 testClassName();
49 }
50
51 static void testPointClass() throws Exception {
52 Point o = Point.makePoint(10, 20);
53 Reflection test = new Reflection(Point.class, "Point", o);
54 test.newInstance();
55 test.constructor();
56 test.constructors("public Point(int,int)", "Point()");
57 test.accessFieldX(o.x);
58 test.setAccessible();
59 test.trySetAccessible();
60 test.staticField();
61 test.initFactoryNotMethods();
62 }
63
64 static void testLineClass() throws Exception {
65 Line l = Line.makeLine(10, 20, 30, 40);
66 Reflection test = new Reflection(Line.class, "Line", l);
67 test.checkField("public final Point Line.p1", "p1", Point.class);
68 test.checkField("public final Point Line.p2", "p2", Point.class);
69 test.checkMethod("public Point Line.p1()", "p1", Point.class);
70 test.checkMethod("public Point Line.p2()", "p2", Point.class);
71 test.initFactoryNotMethods();
72 test.constructors("Line()");
73 }
74
75 static void testNonFlattenValue() throws Exception {
76 NonFlattenValue nfv = NonFlattenValue.make(10, 20);
77 Reflection test = new Reflection(NonFlattenValue.class, "NonFlattenValue", nfv);
78 test.checkField("final Point? NonFlattenValue.nfp", "nfp", Point.class.asNullableType());
79 test.checkMethod("public Point NonFlattenValue.pointValue()", "pointValue", Point.class);
80 test.checkMethod("public Point? NonFlattenValue.point()", "point", Point.class.asNullableType());
81 test.checkMethod("public boolean NonFlattenValue.has(Point,Point?)", "has", boolean.class, Point.class, Point.class.asNullableType());
82 test.initFactoryNotMethods();
83 test.constructors("NonFlattenValue()");
84
85 }
86
87 /*
88 * Tests reflection APIs with the primary and nullable mirror
89 */
90 static void testMirrors() throws Exception {
91 Class<?> primary = Point.class;
92 Class<?> nullable = Point.class.asNullableType();
93
94 assertEquals(primary, Point.class);
95 assertTrue(primary.isInlineClass());
96 assertTrue(nullable.isInlineClass());
97
98 Point o = Point.makePoint(10, 20);
99 assertTrue(primary.isInstance(o));
100 assertTrue(nullable.isInstance(o));
101
102 // V <: V? and V <: Object
103 assertTrue(nullable.isAssignableFrom(primary));
104 assertTrue(Object.class.isAssignableFrom(primary));
169 assertEquals(arrayType.asNullableType(), arrayType);
170 if (array[0] == null) {
171 System.out.println("array[0] = null");
172 } else {
173 System.out.println("array[0] = " + array[0]);
174 }
175 }
176
177 void accessFieldX(int x) throws Exception {
178 Field field = c.getField("x");
179 if (field.getInt(o) != x) {
180 throw new RuntimeException("Unexpected Point.x value: " + field.getInt(o));
181 }
182
183 try {
184 field.setInt(o, 100);
185 throw new RuntimeException("IllegalAccessException not thrown");
186 } catch (IllegalAccessException e) {}
187 }
188
189 @SuppressWarnings("deprecation")
190 void newInstance() throws Exception {
191 Object o = c.newInstance();
192 assertEquals(o.getClass(), c);
193 }
194
195 void constructor() throws Exception {
196 Object o = ctor.newInstance();
197 assertEquals(o.getClass(), c);
198 }
199
200 // Check that the class has the expected Constructors
201 void constructors(String... expected) throws Exception {
202 Constructor<? extends Object>[] cons = c.getDeclaredConstructors();
203 List<String> declaredSig = Arrays.stream(cons).map( Constructor::toString).collect(Collectors.toList());
204 List<String> expectedSig = List.of(expected);
205 boolean ok = expectedSig.equals(declaredSig);
206 if (!ok) {
207 System.out.printf("expected: %s%n", expectedSig);
208 System.out.printf("declared: %s%n", declaredSig);
209 assertTrue(ok);
210 }
211 }
212
213 void setAccessible() throws Exception {
214 ctor.setAccessible(true);
215 Field field = c.getField("x");
216 try {
217 field.setAccessible(true);
218 throw new RuntimeException("InaccessibleObjectException not thrown");
219 } catch (InaccessibleObjectException e) {
220 System.out.println("as expected: " + e.toString());
221 }
222 }
223
224 void trySetAccessible() throws Exception {
225 ctor.trySetAccessible();
226 Field field = c.getField("x");
227 if (field.trySetAccessible()) {
228 throw new RuntimeException("trySetAccessible should not succeed");
229 }
230 }
231
232 void staticField() throws Exception {
233 Field f = c.getDeclaredField("STATIC_FIELD");
234 if (f.trySetAccessible()) {
235 throw new RuntimeException("trySetAccessible should not succeed");
236 }
237 try {
238 f.setAccessible(true);
239 throw new RuntimeException("IllegalAccessException not thrown");
240 } catch (InaccessibleObjectException e) { }
241 }
242
243 void checkField(String source, String name, Class<?> type) throws Exception {
244 Field f = c.getDeclaredField(name);
245 assertEquals(f.getType(), type);
246 assertEquals(f.toString(), source);
247 }
248
249 void checkMethod(String source, String name, Class<?> returnType, Class<?>... params) throws Exception {
250 Method m = c.getDeclaredMethod(name, params);
251 assertEquals(m.toString(), source);
252 }
253
254 // Check that the class does not have a static method with the name <init>
255 void initFactoryNotMethods() throws Exception {
256 Method[] methods = c.getDeclaredMethods();
257 for (Method m : methods) {
258 if (Modifier.isStatic(m.getModifiers())) {
259 assertFalse(m.getName().equals("<init>"));
260 }
261 }
262 }
263
264 static void assertEquals(Object o1, Object o2) {
265 if (o1 == o2 || o1.equals(o2))
266 return;
267
268 throw new AssertionError(o1 + " != " + o2);
269 }
270
271 static void assertTrue(boolean value) {
272 if (!value)
273 throw new AssertionError("expected true");
274 }
275
276 static void assertFalse(boolean value) {
277 if (value)
278 throw new AssertionError("expected false");
279 }
280 }
|