/*
* Copyright (c) 2013, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
import java.io.*;
import java.lang.reflect.*;
/**
* Test MethodParameter attributs by reflection API
*/
public class ReflectionVisitor extends MethodParametersTester.Visitor {
public ReflectionVisitor(MethodParametersTester tester) {
super(tester);
}
public void error(String msg) {
super.error("reflection: " + msg);
}
public void warn(String msg) {
super.warn("reflection: " + msg);
}
boolean isEnum;
boolean isInterface;
boolean isAnon;
boolean isLocal;
boolean isMember;
boolean isStatic;
boolean isPublic;
boolean isFinal;
Class clazz;
StringBuilder sb;
/**
* Read class using {@code ClassFile}, and generate a list of methods
* with parameter names as available in the MethodParameters attribute.
*/
void visitClass(final String cl, final File cfile, final StringBuilder sb)
throws Exception {
this.sb = sb;
clazz = Class.forName(cl);
isEnum = clazz.isEnum();
isInterface = clazz.isInterface();
isAnon = clazz.isAnonymousClass();
isLocal = clazz.isLocalClass();
isMember = clazz.isMemberClass();
isStatic = ((clazz.getModifiers() & Modifier.STATIC) != 0);
isPublic = ((clazz.getModifiers() & Modifier.PUBLIC) != 0);
sb.append(isStatic ? "static " : "")
.append(isPublic ? "public " : "")
.append(isEnum ? "enum " : isInterface ? "interface " : "class ")
.append(cl).append(" -- ")
.append(isMember? "inner" : "" )
.append(isLocal? "inner" : "" )
.append(isAnon ? "anon" : "")
.append("\n");
for (Constructor c : clazz.getDeclaredConstructors()) {
testConstructor(c);
}
for (Method m :clazz.getDeclaredMethods()) {
testMethod(m);
}
}
void testConstructor(Constructor c) {
String prefix = clazz.getName() + "." + c.getName() + "() - ";
// Parameters must match parameter types
Parameter params[] = c.getParameters();
int paramTypes = c.getParameterTypes().length;
if (paramTypes != params.length) {
error(prefix + "number of parameter types (" + paramTypes
+ ") != number of parameters (" + params.length + ")");
return;
}
sb.append(clazz.getName()).append(".").append("<init>").append("(");
String sep = "";
// Some paramters are expected
if (params.length < 2 && isEnum) {
error(prefix + "enum constuctor, two arguments expected");
} else if (params.length < 1 && (isAnon || isLocal ||
(isMember && !isStatic ))) {
error(prefix + "class constuctor,expected implicit argument");
}
int i = -1;
String param = null;
for (Parameter p : c.getParameters()) {
i++;
String pname = p.getName();
int pmodifier = p.getModifiers();
isFinal = false;
if (Modifier.isFinal(pmodifier)) {
isFinal = true;
pname = "final " + pname;
}
sb.append(sep).append(pname);
if (p.isImplicit()) sb.append("/*implicit*/");
if (p.isSynthetic()) sb.append("/*synthetic*/");
sep = ", ";
// Set expectations
String expect = null;
boolean allowImplicit = false;
boolean allowSynthetic = false;
if (isEnum) {
if (i == 0) {
expect = "\\$enum\\$name";
allowSynthetic = true;
} else if(i == 1) {
expect = "\\$enum\\$ordinal";
allowSynthetic = true;
}
} else if (i == 0) {
if (isAnon) {
expect = "this\\$[0-9]+";
allowImplicit = true;
if (isFinal)
expect = "final this\\$[0-9]+";
} else if (isLocal) {
expect = "this\\$[0-9]+";
allowImplicit = true;
if (isFinal)
expect = "final this\\$[0-9]+";
} else if ((isMember && !isStatic)) {
expect = "this\\$[0-9]+";
allowImplicit = true;
if (!isPublic) {
// some but not all non-public inner classes
// have synthetic argument. For now we give
// the test a bit of slack and allow either.
allowSynthetic = true;
}
if (isFinal)
expect = "final this\\$[0-9]+";
}
}
if (p.isSynthetic() && !p.isImplicit() && !allowSynthetic) {
//patch treatment for local captures
if (isAnon || ((isLocal || isAnon) & !isStatic)) {
expect = "val\\$.*";
allowSynthetic = true;
if (isFinal) {
expect = "final val\\$.*";
}
}
}
// Check expected flags
if (p.isSynthetic() && p.isImplicit()) {
error(prefix + "param[" + i + "]='" + pname +
"' both isImplicit() and isSynthetic()");
break;
}
if (allowImplicit && allowSynthetic &&
!(p.isSynthetic() || p.isImplicit())) {
error(prefix + "param[" + i + "]='" + pname +
"' isImplicit() or isSynthetic() expected");
break;
}
if (allowImplicit && !allowSynthetic && !p.isImplicit()) {
error(prefix + "param[" + i + "]='" + pname +
"' isImplicit() expected");
break;
}
if (!allowImplicit && allowSynthetic && !p.isSynthetic()) {
error(prefix + "param[" + i + "]='" + pname +
"' isSynthetic() expected");
break;
}
if (!allowImplicit && p.isImplicit()) {
error(prefix + "param[" + i + "]='" + pname +
"' isImplicit() unexpected");
break;
}
if (!allowSynthetic && p.isSynthetic()) {
error(prefix + "param[" + i + "]='" + pname +
"' isSynthetic() unexpected");
break;
}
// Check expected names
if (expect != null) {
if (pname.matches(expect)) continue;
error(prefix + "param[" + i + "]='" + pname +
"' expected '" + expect + "'");
break;
}
// Test naming convention for explicit parameters.
boolean fidelity = !isAnon;
if (param != null && fidelity) {
char ch = param.charAt(0);
expect = (++ch) + param;
}
if (isFinal && expect != null) {
expect = "final " + expect;
}
if (pname != null && fidelity) {
if (isFinal) {
param = pname.substring(6);
} else {
param = pname;
}
}
if (expect != null && !expect.equals(pname)) {
error(prefix + "param[" + i + "]='" + pname +
"' expected '" + expect + "'");
break;
}
}
if (c.isSynthetic()) {
sb.append(")/*synthetic*/\n");
} else {
sb.append(")\n");
}
}
void testMethod(Method m) {
String prefix = clazz.getName() + "." + m.getName() + "() - ";
// Parameters must match parameter types
int paramTypes = m.getParameterTypes().length;
int params = m.getParameters().length;
if (paramTypes != params) {
error(prefix + "number of parameter types (" + paramTypes
+ ") != number of parameters (" + params + ")");
return;
}
sb.append(clazz.getName()).append(".").append(m.getName()).append("(");
String sep = "";
String param = null;
int i = -1;
// For methods we expect all parameters to follow
// the test-case design pattern, except synthetic methods.
for (Parameter p : m.getParameters()) {
i++;
isFinal = false;
int pmodifier = p.getModifiers();
if (param == null) {
param = p.getName();
if (Modifier.isFinal(pmodifier)) {
isFinal = true;
param = "final " + param;
}
sb.append(sep).append(param);
} else {
char c = param.charAt(0);
String expect = m.isSynthetic() ? ("arg" + i) : ((++c) + param);
param = p.getName();
if (Modifier.isFinal(pmodifier)) {
isFinal = true;
expect = "final " + expect;
param = "final " + param;
}
sb.append(sep).append(param);
if (!m.isBridge() && !expect.equals(param)) {
error(prefix + "param[" + i + "]='"
+ param + "' expected '" + expect + "'");
break;
}
}
if(isFinal)
param = param.substring(6);
if (p.isImplicit()) {
sb.append("/*implicit*/");
}
if (p.isSynthetic()) {
sb.append("/*synthetic*/");
}
sep = ", ";
}
if (m.isSynthetic()) {
sb.append(")/*synthetic*/\n");
} else {
sb.append(")\n");
}
}
}