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