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  */
  23 
  24 /*
  25  * @test
  26  * @bug 8004729
  27  * @summary javac should generate method parameters correctly.
  28  */
  29 
  30 import java.lang.*;
  31 import java.lang.reflect.*;
  32 import java.lang.annotation.*;
  33 import java.util.List;
  34 import java.util.Objects;
  35 
  36 import static java.lang.annotation.ElementType.*;
  37 
  38 public class WithoutParameters {
  39     int errors = 0;
  40 
  41     private WithoutParameters() {}
  42 
  43     public static void main(String argv[]) throws Exception {
  44         WithoutParameters wp = new WithoutParameters();
  45         wp.runTests(Foo.class.getMethods());
  46         wp.runTests(Foo.Inner.class.getConstructors());
  47         wp.checkForErrors();
  48     }
  49 
  50     void runTests(Method[] methods) throws Exception {
  51         for(Method m : methods) {runTest(m);}
  52     }
  53 
  54     void runTests(Constructor[] constructors) throws Exception {
  55         for(Constructor c : constructors) {runTest(c);}
  56     }
  57 
  58     void runTest(Executable e) throws Exception {
  59         System.err.println("Inspecting executable " + e);
  60         Parameter[] parameters = e.getParameters();
  61         Objects.requireNonNull(parameters, "getParameters should never be null");
  62 
  63         ExpectedParameterInfo epi = e.getAnnotation(ExpectedParameterInfo.class);
  64         if (epi != null) {
  65             abortIfTrue(epi.parameterCount() != e.getParameterCount(), "Bad parameter count for "+ e);
  66             abortIfTrue(epi.isVarArgs() != e.isVarArgs(),"Bad varargs value for "+ e);
  67         }
  68         abortIfTrue(e.getParameterCount() != parameters.length, "Mismatched of parameter counts.");
  69 
  70         for(int i = 0; i < parameters.length; i++) {
  71             Parameter p = parameters[i];
  72             errorIfTrue(!p.getDeclaringExecutable().equals(e), p + ".getDeclaringExecutable != " + e);
  73             Objects.requireNonNull(p.getType(), "getType() should not be null");
  74             Objects.requireNonNull(p.getParameterizedType(), "getParameterizedType() should not be null");
  75 
  76             if (epi != null) {
  77                 Class<?> expectedParameterType = epi.parameterTypes()[i];
  78                 errorIfTrue(!p.getType().equals(expectedParameterType),
  79                             "Wrong parameter type for " + p + ": expected " + expectedParameterType  +
  80                             ", but got " + p.getType());
  81 
  82                 ParameterizedInfo[] expectedParameterizedTypes = epi.parameterizedTypes();
  83                 if (expectedParameterizedTypes.length > 0) {
  84                     Type parameterizedType = p.getParameterizedType();                    
  85                     Class<? extends Type> expectedParameterziedTypeType = expectedParameterizedTypes[i].value();
  86                     errorIfTrue(!expectedParameterziedTypeType.isAssignableFrom(parameterizedType.getClass()),
  87                                 "Wrong class of parameteried type of " + p + ": expected " + expectedParameterziedTypeType  +
  88                                 ", but got " + parameterizedType.getClass());
  89 
  90                     if (expectedParameterziedTypeType.equals(Class.class)) {
  91                         errorIfTrue(!parameterizedType.equals(expectedParameterType),
  92                                     "Wrong parameteried type for " + p + ": expected " + expectedParameterType  +
  93                                     ", but got " + parameterizedType);
  94                     } else {
  95                         if (expectedParameterziedTypeType.equals(ParameterizedType.class)) {
  96                             ParameterizedType ptype = (ParameterizedType)parameterizedType;
  97                             errorIfTrue(!ptype.getRawType().equals(expectedParameterType),
  98                                         "Wrong raw type for " + p + ": expected " + expectedParameterType  +
  99                                         ", but got " + ptype.getRawType());
 100                         }
 101 
 102                         // Check string representation
 103                         String expectedStringOfType = epi.parameterizedTypes()[i].string();
 104                         errorIfTrue(!expectedStringOfType.equals(parameterizedType.toString()),
 105                                     "Bad type string" + p + ": expected " + expectedStringOfType  +
 106                                     ", but got " + parameterizedType.toString());              
 107                     }   
 108                 }
 109             }
 110         }
 111     }
 112 
 113     private void checkForErrors() {
 114         if (errors > 0)
 115             throw new RuntimeException("Failed " + errors + " tests");
 116     }
 117 
 118     private void errorIfTrue(boolean predicate, String errMessage) {
 119         if (predicate) {
 120             errors++;
 121             System.err.println(errMessage);
 122         }
 123     }
 124 
 125     private void abortIfTrue(boolean predicate, String errMessage) {
 126         if (predicate) {
 127             throw new RuntimeException(errMessage);
 128         }
 129     }
 130 
 131     @Retention(RetentionPolicy.RUNTIME)
 132     @Target({METHOD, CONSTRUCTOR})
 133     @interface ExpectedParameterInfo {
 134         int parameterCount() default 0;
 135         Class<?>[] parameterTypes() default {};
 136         ParameterizedInfo[] parameterizedTypes() default {};
 137         boolean isVarArgs() default false;
 138     }
 139 
 140     @Target({})
 141     @interface ParameterizedInfo {
 142         Class<? extends Type> value() default Class.class;
 143         String string() default "";
 144     }
 145 
 146     public class Foo {
 147         int thing;
 148         @ExpectedParameterInfo(parameterCount = 6,
 149                                parameterTypes =
 150                                {int.class, Foo.class,
 151                                 List.class, List.class,
 152                                 List.class, String[].class},
 153                                parameterizedTypes =
 154                                 {@ParameterizedInfo(Class.class),
 155                                  @ParameterizedInfo(Class.class),
 156                                  @ParameterizedInfo(value=ParameterizedType.class, string="java.util.List<?>"),
 157                                  @ParameterizedInfo(value=ParameterizedType.class, string="java.util.List<WithoutParameters$Foo>"),
 158                                  @ParameterizedInfo(value=ParameterizedType.class, string="java.util.List<? extends WithoutParameters$Foo>"),
 159                                  @ParameterizedInfo(Class.class)},
 160                                isVarArgs = true)
 161         public void qux(int quux, Foo quuux,
 162                         List<?> l, List<Foo> l2,
 163                         List<? extends Foo> l3,
 164                         String... rest) {}
 165         public class Inner {
 166             int thang;
 167             @ExpectedParameterInfo(parameterCount = 2,
 168                                    parameterTypes = {Foo.class, int.class})
 169             public Inner(int theng) {
 170                 thang = theng + thing;
 171             }
 172         }
 173     }
 174 }