1 /*
2 * Copyright (c) 2016, 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
26 * @bug 8161013
27 * @summary Verify that anonymous class binaries have the correct flags set
28 * @run main AnonymousClassFlags
29 */
30
31 import java.util.*;
32 import java.nio.file.Path;
33 import java.nio.file.Paths;
34
35 import java.lang.classfile.*;
36 import java.lang.classfile.attribute.InnerClassInfo;
37 import java.lang.classfile.attribute.InnerClassesAttribute;
38
39 public class AnonymousClassFlags {
40 public static void main(String[] args) throws Exception {
41 new AnonymousClassFlags().test(System.getProperty("test.classes", "."));
42 }
43
44 /** Maps names of anonymous classes to their expected inner_class_access_flags */
45 private static Map<String, Integer> anonClasses = new LinkedHashMap<>();
46
47 // ******* TEST CASES ********
48
49 static Object o1 = new Object() {
50 { anonClasses.put(getClass().getName(), 0); }
51 };
52
53 static void staticMethod() {
54 Object o2 = new Object() {
55 { anonClasses.put(getClass().getName(), 0); }
56 };
57 }
58
59 static {
60 staticMethod();
61
62 Object o3 = new Object() {
63 { anonClasses.put(getClass().getName(), 0); }
64 };
65 }
66
67 Object o4 = new Object() {
68 { anonClasses.put(getClass().getName(), 0); }
69 };
70
71 void instanceMethod() {
72 Object o5 = new Object() {
73 { anonClasses.put(getClass().getName(), 0); }
74 };
75 }
76
77 {
78 instanceMethod();
79
80 Object o6 = new Object() {
81 { anonClasses.put(getClass().getName(), 0); }
82 };
83 }
84
85 // ******* TEST IMPLEMENTATION ********
86
87 void test(String classesDir) throws Exception {
88 staticMethod();
89 instanceMethod();
90
91 Path outerFile = Paths.get(classesDir, getClass().getName() + ".class");
92 ClassModel outerClass = ClassFile.of().parse(outerFile);
93 for (Map.Entry<String,Integer> entry : anonClasses.entrySet()) {
94 Path innerFile = Paths.get(classesDir, entry.getKey() + ".class");
95 ClassModel innerClass = ClassFile.of().parse(innerFile);
96 String name = entry.getKey();
97 int expected = entry.getValue();
98 assertInnerFlags(outerClass, name, expected);
99 assertClassFlags(innerClass, name, expected);
100 assertInnerFlags(innerClass, name, expected);
101 }
102 }
103
104 static void assertClassFlags(ClassModel classFile, String name, int expected) {
105 int mask = ClassFile.ACC_PUBLIC | ClassFile.ACC_FINAL | ClassFile.ACC_INTERFACE | ClassFile.ACC_ABSTRACT |
106 ClassFile.ACC_SYNTHETIC | ClassFile.ACC_ANNOTATION | ClassFile.ACC_ENUM;
107 int classExpected = (expected & mask) | ClassFile.ACC_SUPER;
108 int classActual = classFile.flags().flagsMask();
109 if (classActual != classExpected) {
110 throw new AssertionError("Incorrect access_flags for class " + name +
111 ": expected=" + classExpected + ", actual=" + classActual);
112 }
113
114 }
115
116 static void assertInnerFlags(ClassModel classFile, String name, int expected) {
117 int innerActual = lookupInnerFlags(classFile, name);
118 if (innerActual != expected) {
119 throw new AssertionError("Incorrect inner_class_access_flags for class " + name +
120 " in class " + classFile.thisClass().asInternalName() +
121 ": expected=" + expected + ", actual=" + innerActual);
122 }
123 }
124
125 private static int lookupInnerFlags(ClassModel classFile, String innerName) {
126 InnerClassesAttribute inners = classFile.findAttribute(Attributes.innerClasses()).orElse(null);
|
1 /*
2 * Copyright (c) 2016, 2025, 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=NoPreview
26 * @bug 8161013
27 * @summary Verify that anonymous class binaries have the correct flags set
28 * @modules java.base/jdk.internal.misc
29 * @comment Ensure that that this test is skipped if the test is run on a preview enabled
30 VM as the compiled test class has not been forced into preview mode.
31 Valhalla affects the outcome.
32 * @requires !java.enablePreview
33 * @run main AnonymousClassFlags
34 */
35
36 /*
37 * @test id=Preview
38 * @bug 8161013
39 * @summary Verify that anonymous class binaries have the correct flags set
40 * @modules java.base/jdk.internal.misc
41 * @enablePreview
42 * @compile -XDforcePreview AnonymousClassFlags.java
43 * @run main AnonymousClassFlags
44 */
45
46 import java.util.*;
47 import java.nio.file.Path;
48 import java.nio.file.Paths;
49
50 import java.lang.classfile.*;
51 import java.lang.classfile.attribute.InnerClassInfo;
52 import java.lang.classfile.attribute.InnerClassesAttribute;
53
54 import jdk.internal.misc.PreviewFeatures;
55
56 public class AnonymousClassFlags {
57 public static void main(String[] args) throws Exception {
58 new AnonymousClassFlags().test(System.getProperty("test.classes", "."));
59 }
60
61 AnonymousClassFlags() {
62 System.currentTimeMillis();
63 super(); // Triggers force preview
64 }
65
66 // ACC_SUPER does not exist in InnerClasses before Value Objects
67 private static final int EXPECTED_ACCESS_FLAGS = PreviewFeatures.isEnabled() ? ClassFile.ACC_IDENTITY : 0;
68
69 /** Maps names of anonymous classes to their expected inner_class_access_flags */
70 private static Map<String, Integer> anonClasses = new LinkedHashMap<>();
71
72 // ******* TEST CASES ********
73
74 static Object o1 = new Object() {
75 { anonClasses.put(getClass().getName(), EXPECTED_ACCESS_FLAGS); }
76 };
77
78 static void staticMethod() {
79 Object o2 = new Object() {
80 { anonClasses.put(getClass().getName(), EXPECTED_ACCESS_FLAGS); }
81 };
82 }
83
84 static {
85 staticMethod();
86
87 Object o3 = new Object() {
88 { anonClasses.put(getClass().getName(), EXPECTED_ACCESS_FLAGS); }
89 };
90 }
91
92 Object o4 = new Object() {
93 { anonClasses.put(getClass().getName(), EXPECTED_ACCESS_FLAGS); }
94 };
95
96 void instanceMethod() {
97 Object o5 = new Object() {
98 { anonClasses.put(getClass().getName(), EXPECTED_ACCESS_FLAGS); }
99 };
100 }
101
102 {
103 instanceMethod();
104
105 Object o6 = new Object() {
106 { anonClasses.put(getClass().getName(), EXPECTED_ACCESS_FLAGS); }
107 };
108 }
109
110 // ******* TEST IMPLEMENTATION ********
111
112 void test(String classesDir) throws Exception {
113 staticMethod();
114 instanceMethod();
115
116 Path outerFile = Paths.get(classesDir, getClass().getName() + ".class");
117 ClassModel outerClass = ClassFile.of().parse(outerFile);
118 for (Map.Entry<String,Integer> entry : anonClasses.entrySet()) {
119 Path innerFile = Paths.get(classesDir, entry.getKey() + ".class");
120 ClassModel innerClass = ClassFile.of().parse(innerFile);
121 String name = entry.getKey();
122 int expected = entry.getValue();
123 assertInnerFlags(outerClass, name, expected);
124 assertClassFlags(innerClass, name, expected);
125 assertInnerFlags(innerClass, name, expected);
126 }
127 }
128
129 static void assertClassFlags(ClassModel classFile, String name, int expected) {
130 int mask = ClassFile.ACC_PUBLIC | ClassFile.ACC_FINAL | ClassFile.ACC_INTERFACE | ClassFile.ACC_ABSTRACT |
131 ClassFile.ACC_SYNTHETIC | ClassFile.ACC_ANNOTATION | ClassFile.ACC_ENUM | ClassFile.ACC_IDENTITY;
132 int classExpected = (expected & mask) | ClassFile.ACC_SUPER;
133 int classActual = classFile.flags().flagsMask();
134 if (classActual != classExpected) {
135 throw new AssertionError("Incorrect access_flags for class " + name +
136 ": expected=" + classExpected + ", actual=" + classActual);
137 }
138
139 }
140
141 static void assertInnerFlags(ClassModel classFile, String name, int expected) {
142 int innerActual = lookupInnerFlags(classFile, name);
143 if (innerActual != expected) {
144 throw new AssertionError("Incorrect inner_class_access_flags for class " + name +
145 " in class " + classFile.thisClass().asInternalName() +
146 ": expected=" + expected + ", actual=" + innerActual);
147 }
148 }
149
150 private static int lookupInnerFlags(ClassModel classFile, String innerName) {
151 InnerClassesAttribute inners = classFile.findAttribute(Attributes.innerClasses()).orElse(null);
|