jdk8-mips64-public/langtools: test/tools/javac/MethodParameters/ReflectionVisitor.java@f5e5ca7505e2 (annotated)

test/tools/javac/MethodParameters/ReflectionVisitor.java@f5e5ca7505e2 (annotated)

test/tools/javac/MethodParameters/ReflectionVisitor.java

Wed, 08 Oct 2014 14:16:40 -0700

author: asaha
date: Wed, 08 Oct 2014 14:16:40 -0700
changeset 2586: f5e5ca7505e2
parent 2137: a48d3b981083
child 2525: 2eb010b6cb22
child 2733: 7974f6da2d76
permissions: -rw-r--r--

Merge

 /*
  * Copyright (c) 2013, 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 Tester.Visitor {
     public ReflectionVisitor(Tester 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]+";
                 }
             }
             // 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");
         }
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

test/tools/javac/MethodParameters/ReflectionVisitor.java@f5e5ca7505e2 (annotated)

test/tools/javac/MethodParameters/ReflectionVisitor.java