1 /*
2 * Copyright (c) 2012, 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 * @requires vm.jvmci
27 * @library ../../../../../
28 * @modules jdk.internal.vm.ci/jdk.vm.ci.meta
29 * jdk.internal.vm.ci/jdk.vm.ci.runtime
30 * java.base/jdk.internal.misc
31 * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI jdk.vm.ci.runtime.test.TestConstantReflectionProvider
32 */
33
34 package jdk.vm.ci.runtime.test;
35
36 import jdk.vm.ci.meta.ConstantReflectionProvider;
37 import jdk.vm.ci.meta.JavaConstant;
38 import jdk.vm.ci.meta.JavaKind;
39 import org.junit.Test;
40
41 import java.lang.reflect.Array;
42 import java.util.List;
43
44 import static org.junit.Assert.assertEquals;
45 import static org.junit.Assert.assertFalse;
46 import static org.junit.Assert.assertNotNull;
47 import static org.junit.Assert.assertNull;
48 import static org.junit.Assert.assertTrue;
49
50 /**
51 * Tests for {@link ConstantReflectionProvider}. It assumes an implementation of the interface that
52 * actually returns non-null results for access operations that are possible, i.e., the tests will
53 * fail for an implementation that spuriously returns null (which is allowed by the specification).
54 */
55 public class TestConstantReflectionProvider extends TypeUniverse {
56
57 @Test
58 public void constantEqualsTest() {
59 for (ConstantValue c1 : constants()) {
60 for (ConstantValue c2 : constants()) {
61 // test symmetry
62 assertEquals(constantReflection.constantEquals(c1.value, c2.value), constantReflection.constantEquals(c2.value, c1.value));
63 if (c1.value.getJavaKind() != JavaKind.Object && c2.value.getJavaKind() != JavaKind.Object) {
64 assertEquals(c1.value.equals(c2.value), constantReflection.constantEquals(c2.value, c1.value));
65 }
66 }
67 }
68 }
69
70 @Test
71 public void readArrayLengthTest() {
72 for (ConstantValue cv : constants()) {
73 JavaConstant c = cv.value;
74 Integer actual = constantReflection.readArrayLength(c);
75 if (c.getJavaKind() != JavaKind.Object || c.isNull() || !cv.boxed.getClass().isArray()) {
76 assertNull(actual);
77 } else {
78 assertNotNull(actual);
79 int actualInt = actual;
80 assertEquals(Array.getLength(cv.boxed), actualInt);
81 }
82 }
83 }
84
85 static class PrimitiveConstants {
86 static final long LONG_CONST = 42;
87 static final int INT_CONST = 66;
88 static final byte BYTE_CONST = 123;
89 static final boolean BOOL_CONST = true;
90 }
91
92 static class BoxedConstants {
93 static final Long LONG_CONST = 42L;
94 static final Integer INT_CONST = 66;
95 static final Byte BYTE_CONST = 123;
96 static final Boolean BOOL_CONST = true;
97 }
98
99 @Test
100 public void boxTest() {
101 for (ConstantValue cv : constants()) {
102 JavaConstant c = cv.value;
103 JavaConstant boxed = constantReflection.boxPrimitive(c);
104 if (boxed != null && c.getJavaKind().isPrimitive()) {
105 assertTrue(boxed.getJavaKind().isObject());
106 assertFalse(boxed.isNull());
107 }
108 }
109
110 List<ConstantValue> primitiveConstants = readConstants(PrimitiveConstants.class);
111 List<ConstantValue> boxedConstants = readConstants(BoxedConstants.class);
112 for (int i = 0; i < primitiveConstants.size(); i++) {
113 ConstantValue prim = primitiveConstants.get(i);
114 ConstantValue box = boxedConstants.get(i);
115 assertEquals(box.value, constantReflection.boxPrimitive(prim.value));
116 }
117
118 assertNull(constantReflection.boxPrimitive(JavaConstant.NULL_POINTER));
119 }
120
121 @Test
122 public void unboxTest() {
123 for (ConstantValue cv : constants()) {
124 JavaConstant c = cv.value;
125 JavaConstant unboxed = c.isNull() ? null : constantReflection.unboxPrimitive(c);
126 if (unboxed != null) {
127 assertFalse(unboxed.getJavaKind().isObject());
128 }
129 }
130 List<ConstantValue> primitiveConstants = readConstants(PrimitiveConstants.class);
131 List<ConstantValue> boxedConstants = readConstants(BoxedConstants.class);
132 for (int i = 0; i < primitiveConstants.size(); i++) {
133 ConstantValue prim = primitiveConstants.get(i);
134 ConstantValue box = boxedConstants.get(i);
135 assert prim.getSimpleName().equals(box.getSimpleName());
136 assertEquals(prim.value, constantReflection.unboxPrimitive(box.value));
137 }
138
139 assertNull(constantReflection.unboxPrimitive(JavaConstant.NULL_POINTER));
140 }
141 }