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 }