Sat, 07 Nov 2020 10:30:02 +0800
Added tag mips-jdk8u275-b01 for changeset eb6ee6a5f2fe
1 /*
2 * Copyright (c) 2013, 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 */
24 import java.io.*;
25 import java.lang.reflect.*;
27 /**
28 * Test MethodParameter attributs by reflection API
29 */
30 public class ReflectionVisitor extends Tester.Visitor {
32 public ReflectionVisitor(Tester tester) {
33 super(tester);
34 }
36 public void error(String msg) {
37 super.error("reflection: " + msg);
38 }
40 public void warn(String msg) {
41 super.warn("reflection: " + msg);
42 }
44 boolean isEnum;
45 boolean isInterface;
46 boolean isAnon;
47 boolean isLocal;
48 boolean isMember;
49 boolean isStatic;
50 boolean isPublic;
51 boolean isFinal;
52 Class clazz;
53 StringBuilder sb;
55 /**
56 * Read class using {@code ClassFile}, and generate a list of methods
57 * with parameter names as available in the MethodParameters attribute.
58 */
59 void visitClass(final String cl, final File cfile, final StringBuilder sb)
60 throws Exception {
62 this.sb = sb;
63 clazz = Class.forName(cl);
64 isEnum = clazz.isEnum();
65 isInterface = clazz.isInterface();
66 isAnon = clazz.isAnonymousClass();
67 isLocal = clazz.isLocalClass();
68 isMember = clazz.isMemberClass();
69 isStatic = ((clazz.getModifiers() & Modifier.STATIC) != 0);
70 isPublic = ((clazz.getModifiers() & Modifier.PUBLIC) != 0);
72 sb.append(isStatic ? "static " : "")
73 .append(isPublic ? "public " : "")
74 .append(isEnum ? "enum " : isInterface ? "interface " : "class ")
75 .append(cl).append(" -- ")
76 .append(isMember? "inner" : "" )
77 .append(isLocal? "inner" : "" )
78 .append(isAnon ? "anon" : "")
79 .append("\n");
81 for (Constructor c : clazz.getDeclaredConstructors()) {
82 testConstructor(c);
83 }
85 for (Method m :clazz.getDeclaredMethods()) {
86 testMethod(m);
87 }
88 }
90 void testConstructor(Constructor c) {
92 String prefix = clazz.getName() + "." + c.getName() + "() - ";
94 // Parameters must match parameter types
95 Parameter params[] = c.getParameters();
96 int paramTypes = c.getParameterTypes().length;
97 if (paramTypes != params.length) {
98 error(prefix + "number of parameter types (" + paramTypes
99 + ") != number of parameters (" + params.length + ")");
100 return;
101 }
103 sb.append(clazz.getName()).append(".").append("<init>").append("(");
104 String sep = "";
106 // Some paramters are expected
107 if (params.length < 2 && isEnum) {
108 error(prefix + "enum constuctor, two arguments expected");
109 } else if (params.length < 1 && (isAnon || isLocal ||
110 (isMember && !isStatic ))) {
111 error(prefix + "class constuctor,expected implicit argument");
112 }
114 int i = -1;
115 String param = null;
116 for (Parameter p : c.getParameters()) {
117 i++;
118 String pname = p.getName();
119 int pmodifier = p.getModifiers();
120 isFinal = false;
121 if (Modifier.isFinal(pmodifier)) {
122 isFinal = true;
123 pname = "final " + pname;
124 }
125 sb.append(sep).append(pname);
126 if (p.isImplicit()) sb.append("/*implicit*/");
127 if (p.isSynthetic()) sb.append("/*synthetic*/");
128 sep = ", ";
130 // Set expectations
131 String expect = null;
132 boolean allowImplicit = false;
133 boolean allowSynthetic = false;
134 if (isEnum) {
135 if (i == 0) {
136 expect = "\\$enum\\$name";
137 allowSynthetic = true;
138 } else if(i == 1) {
139 expect = "\\$enum\\$ordinal";
140 allowSynthetic = true;
141 }
142 } else if (i == 0) {
143 if (isAnon) {
144 expect = "this\\$[0-9]+";
145 allowImplicit = true;
146 if (isFinal)
147 expect = "final this\\$[0-9]+";
148 } else if (isLocal) {
149 expect = "this\\$[0-9]+";
150 allowImplicit = true;
151 if (isFinal)
152 expect = "final this\\$[0-9]+";
153 } else if ((isMember && !isStatic)) {
154 expect = "this\\$[0-9]+";
155 allowImplicit = true;
156 if (!isPublic) {
157 // some but not all non-public inner classes
158 // have synthetic argument. For now we give
159 // the test a bit of slack and allow either.
160 allowSynthetic = true;
161 }
162 if (isFinal)
163 expect = "final this\\$[0-9]+";
164 }
165 }
167 // Check expected flags
168 if (p.isSynthetic() && p.isImplicit()) {
169 error(prefix + "param[" + i + "]='" + pname +
170 "' both isImplicit() and isSynthetic()");
171 break;
172 }
173 if (allowImplicit && allowSynthetic &&
174 !(p.isSynthetic() || p.isImplicit())) {
175 error(prefix + "param[" + i + "]='" + pname +
176 "' isImplicit() or isSynthetic() expected");
177 break;
178 }
180 if (allowImplicit && !allowSynthetic && !p.isImplicit()) {
181 error(prefix + "param[" + i + "]='" + pname +
182 "' isImplicit() expected");
183 break;
184 }
185 if (!allowImplicit && allowSynthetic && !p.isSynthetic()) {
186 error(prefix + "param[" + i + "]='" + pname +
187 "' isSynthetic() expected");
188 break;
189 }
191 if (!allowImplicit && p.isImplicit()) {
192 error(prefix + "param[" + i + "]='" + pname +
193 "' isImplicit() unexpected");
194 break;
195 }
197 if (!allowSynthetic && p.isSynthetic()) {
198 error(prefix + "param[" + i + "]='" + pname +
199 "' isSynthetic() unexpected");
200 break;
201 }
203 // Check expected names
204 if (expect != null) {
205 if (pname.matches(expect)) continue;
206 error(prefix + "param[" + i + "]='" + pname +
207 "' expected '" + expect + "'");
208 break;
209 }
211 // Test naming convention for explicit parameters.
212 boolean fidelity = !isAnon;
213 if (param != null && fidelity) {
214 char ch = param.charAt(0);
215 expect = (++ch) + param;
216 }
217 if (isFinal && expect != null) {
218 expect = "final " + expect;
219 }
220 if (pname != null && fidelity) {
221 if (isFinal) {
222 param = pname.substring(6);
223 } else {
224 param = pname;
225 }
226 }
227 if (expect != null && !expect.equals(pname)) {
228 error(prefix + "param[" + i + "]='" + pname +
229 "' expected '" + expect + "'");
230 break;
231 }
232 }
233 if (c.isSynthetic()) {
234 sb.append(")/*synthetic*/\n");
235 } else {
236 sb.append(")\n");
237 }
238 }
240 void testMethod(Method m) {
242 String prefix = clazz.getName() + "." + m.getName() + "() - ";
244 // Parameters must match parameter types
245 int paramTypes = m.getParameterTypes().length;
246 int params = m.getParameters().length;
247 if (paramTypes != params) {
248 error(prefix + "number of parameter types (" + paramTypes
249 + ") != number of parameters (" + params + ")");
250 return;
251 }
253 sb.append(clazz.getName()).append(".").append(m.getName()).append("(");
254 String sep = "";
255 String param = null;
256 int i = -1;
257 // For methods we expect all parameters to follow
258 // the test-case design pattern, except synthetic methods.
259 for (Parameter p : m.getParameters()) {
260 i++;
261 isFinal = false;
262 int pmodifier = p.getModifiers();
263 if (param == null) {
264 param = p.getName();
265 if (Modifier.isFinal(pmodifier)) {
266 isFinal = true;
267 param = "final " + param;
268 }
269 sb.append(sep).append(param);
270 } else {
271 char c = param.charAt(0);
272 String expect = m.isSynthetic() ? ("arg" + i) : ((++c) + param);
273 param = p.getName();
274 if (Modifier.isFinal(pmodifier)) {
275 isFinal = true;
276 expect = "final " + expect;
277 param = "final " + param;
278 }
279 sb.append(sep).append(param);
280 if (!m.isBridge() && !m.getName().startsWith("lambda$") && !expect.equals(param)) {
281 error(prefix + "param[" + i + "]='"
282 + param + "' expected '" + expect + "'");
283 break;
284 }
285 }
286 if(isFinal)
287 param = param.substring(6);
288 if (p.isImplicit()) {
289 sb.append("/*implicit*/");
290 }
291 if (p.isSynthetic()) {
292 sb.append("/*synthetic*/");
293 }
294 sep = ", ";
295 }
296 if (m.isSynthetic()) {
297 sb.append(")/*synthetic*/\n");
298 } else {
299 sb.append(")\n");
300 }
301 }
302 }