1 /*
2 * Copyright (c) 2024, 2024, 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 id=32bits
26 * @requires vm.bits == 32 & vm.flagless
27 * @library /test/lib
28 * @modules java.base/jdk.internal.vm.annotation
29 * @enablePreview
30 * @compile FieldLayoutAnalyzer.java ValueFieldInheritanceTest.java
31 * @run main/othervm -Xint ValueFieldInheritanceTest 0
32 */
33
34 /*
35 * @test id=64bitsCompressedOops
36 * @requires vm.bits == 64 & vm.flagless
37 * @library /test/lib
38 * @modules java.base/jdk.internal.vm.annotation
39 * @enablePreview
40 * @compile FieldLayoutAnalyzer.java ValueFieldInheritanceTest.java
41 * @run main/othervm -Xint ValueFieldInheritanceTest 1
42 */
43
44 /*
45 * @test id=64bitsNoCompressedOops
46 * @requires vm.bits == 64 & vm.flagless
47 * @library /test/lib
48 * @modules java.base/jdk.internal.vm.annotation
49 * @enablePreview
50 * @compile FieldLayoutAnalyzer.java ValueFieldInheritanceTest.java
51 * @run main/othervm -Xint ValueFieldInheritanceTest 2
52 */
53
54 /*
55 * @test id=64bitsNoCompressedOopsNoCompressKlassPointers
56 * @requires vm.bits == 64 & vm.flagless
57 * @library /test/lib
58 * @modules java.base/jdk.internal.vm.annotation
59 * @enablePreview
60 * @compile FieldLayoutAnalyzer.java ValueFieldInheritanceTest.java
61 * @run main/othervm -Xint ValueFieldInheritanceTest 3
62 */
63
64 import java.util.ArrayList;
65 import java.util.Collections;
66 import java.util.List;
67
68 import org.w3c.dom.views.AbstractView;
69
70 import jdk.internal.vm.annotation.ImplicitlyConstructible;
71 import jdk.internal.vm.annotation.LooselyConsistentValue;
72 import jdk.internal.vm.annotation.NullRestricted;
73
74 import java.lang.reflect.Method;
75 import java.lang.reflect.Modifier;
76 import jdk.test.lib.Asserts;
77 import jdk.test.lib.process.OutputAnalyzer;
78 import jdk.test.lib.process.ProcessTools;
79
80
81 public class ValueFieldInheritanceTest {
82
83 static abstract value class AbstractNoField { };
84
85 static abstract value class AbstractOneField { byte b = 0; }
86
87 static abstract value class SubAbstractOne extends AbstractNoField { }
88
89 static abstract value class SubAbstractTwo extends AbstractOneField { }
90
91 static abstract value class SubAbstractThree extends AbstractNoField { int i = 0; }
92
93 static abstract value class SubAbstractFour extends AbstractOneField { int i = 0; }
94
95 static class Identity0 extends AbstractNoField { }
96
97 static class Identity1 extends AbstractNoField { short s; }
98
99 static class Identity2 extends SubAbstractOne { }
100
101 static class Identity3 extends SubAbstractOne { char c; }
102
103 static class Identity4 extends SubAbstractTwo { }
104
105 static class Identity5 extends SubAbstractTwo { int i; }
106
107 static class Identity6 extends SubAbstractThree { }
108
109 static class Identity7 extends SubAbstractThree { int i; }
110
111 static class Identity8 extends SubAbstractFour { }
112
113 static class Identity9 extends SubAbstractFour { int i; }
114
115 static class ConcreteValue0 extends AbstractNoField { }
116
117 static class ConcreteValue1 extends AbstractNoField { short s; }
118
119 static class ConcreteValue2 extends SubAbstractOne { }
120
121 static class ConcreteValue3 extends SubAbstractOne { char c; }
122
123 static class ConcreteValue4 extends SubAbstractTwo { }
124
125 static class ConcreteValue5 extends SubAbstractTwo { int i; }
126
127 static class ConcreteValue6 extends SubAbstractThree { }
128
129 static class ConcreteValue7 extends SubAbstractThree { int i; }
130
131 static class ConcreteValue8 extends SubAbstractFour { }
132
133 static class ConcreteValue9 extends SubAbstractFour { int i; }
134
135 static public void test_0() {
136 var i0 = new Identity0();
137 var i1 = new Identity1();
138 var i2 = new Identity2();
139 var i3 = new Identity3();
140 var i4 = new Identity4();
141 var i5 = new Identity5();
142 var i6 = new Identity6();
143 var i7 = new Identity7();
144 var i8 = new Identity8();
145 var i9 = new Identity9();
146 var c0 = new ConcreteValue0();
147 var c1 = new ConcreteValue1();
148 var c2 = new ConcreteValue2();
149 var c3 = new ConcreteValue3();
150 var c4 = new ConcreteValue4();
151 var c5 = new ConcreteValue5();
152 var c6 = new ConcreteValue6();
153 var c7 = new ConcreteValue7();
154 var c8 = new ConcreteValue8();
155 var c9 = new ConcreteValue9();
156 }
157
158 static class TestRunner {
159 public static void main(String[] args) throws Exception {
160 Class testClass = Class.forName("ValueFieldInheritanceTest");
161 Asserts.assertNotNull(testClass);
162 Method[] testMethods = testClass.getMethods();
163 for (Method test : testMethods) {
164 if (test.getName().startsWith("test_")) {
165 Asserts.assertTrue(Modifier.isStatic(test.getModifiers()));
166 Asserts.assertTrue(test.getReturnType().equals(Void.TYPE));
167 System.out.println("Running " + test.getName());
168 test.invoke(null);
169 }
170 }
171 }
172 }
173
174 static ProcessBuilder exec(String compressedOopsArg, String compressedKlassPointersArg, String... args) throws Exception {
175 List<String> argsList = new ArrayList<>();
176 Collections.addAll(argsList, "--enable-preview");
177 Collections.addAll(argsList, "-XX:+UnlockDiagnosticVMOptions");
178 Collections.addAll(argsList, "-XX:+PrintFieldLayout");
179 Collections.addAll(argsList, "-Xshare:off");
180 if (compressedOopsArg != null) {
181 Collections.addAll(argsList, compressedOopsArg);
182 }
183 if (compressedKlassPointersArg != null) {
184 Collections.addAll(argsList, compressedKlassPointersArg);
185 }
186 Collections.addAll(argsList, "-Xmx256m");
187 Collections.addAll(argsList, "-cp", System.getProperty("java.class.path") + ":.");
188 Collections.addAll(argsList, args);
189 return ProcessTools.createTestJavaProcessBuilder(argsList);
190 }
191
192 public static void main(String[] args) throws Exception {
193 String compressedOopsArg;
194 String compressedKlassPointersArg;
195
196 switch(args[0]) {
197 case "0": compressedOopsArg = null;
198 compressedKlassPointersArg = null;
199 break;
200 case "1": compressedOopsArg = "-XX:+UseCompressedOops";
201 compressedKlassPointersArg = "-XX:+UseCompressedClassPointers";
202 break;
203 case "2": compressedOopsArg = "-XX:-UseCompressedOops";
204 compressedKlassPointersArg = "-XX:+UseCompressedClassPointers";
205 break;
206 case "3": compressedOopsArg = "-XX:-UseCompressedOops";
207 compressedKlassPointersArg = "-XX:-UseCompressedClassPointers";
208 break;
209 default: throw new RuntimeException("Unrecognized configuration");
210 }
211
212 // Generate test classes
213 // NullMarkersTest fat = new NullMarkersTest();
214
215 // Execute the test runner in charge of loading all test classes
216 ProcessBuilder pb = exec(compressedOopsArg, compressedKlassPointersArg, "ValueFieldInheritanceTest$TestRunner");
217 OutputAnalyzer out = new OutputAnalyzer(pb.start());
218
219 if (out.getExitValue() != 0) {
220 out.outputTo(System.out);
221 }
222 Asserts.assertEquals(out.getExitValue(), 0, "Something went wrong while running the tests");
223
224 // Get and parse the test output
225 System.out.print(out.getOutput());
226 FieldLayoutAnalyzer.LogOutput lo = new FieldLayoutAnalyzer.LogOutput(out.asLines());
227 FieldLayoutAnalyzer fla = FieldLayoutAnalyzer.createFieldLayoutAnalyzer(lo);
228
229 // Running tests verification method (check that tests produced the right configuration)
230 Class testClass = ValueFieldInheritanceTest.class;
231 Method[] testMethods = testClass.getMethods();
232 for (Method test : testMethods) {
233 if (test.getName().startsWith("check_")) {
234 Asserts.assertTrue(Modifier.isStatic(test.getModifiers()));
235 Asserts.assertTrue(test.getReturnType().equals(Void.TYPE));
236 test.invoke(null, fla);
237 }
238 }
239
240 // Verify that all layouts are correct
241 fla.check();
242 }
243
244 }