--- /dev/null	2013-01-22 15:27:51.271811652 -0500
+++ new/test/java/lang/reflect/Parameter/WithoutParameters.java	2013-01-23 11:10:28.455496529 -0500
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2012, 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.
+ */
+
+/*
+ * @test
+ * @summary javac should generate method parameters correctly.
+ */
+
+import java.lang.*;
+import java.lang.reflect.*;
+import java.util.List;
+
+public class WithoutParameters {
+
+    private static final Class<?>[] qux_types = {
+	int.class,
+	Foo.class,
+	List.class,
+	List.class,
+	List.class,
+        String[].class
+    };
+
+    public static void main(String argv[]) throws Exception {
+	int error = 0;
+	Method[] methods = Foo.class.getMethods();
+	for(Method m : methods) {
+	    System.err.println("Inspecting method " + m);
+	    Parameter[] parameters = m.getParameters();
+	    if(parameters == null)
+		throw new Exception("getParameters should never be null");
+	    for(int i = 0; i < parameters.length; i++) {
+		    Parameter p = parameters[i];
+		    if(!p.getDeclaringExecutable().equals(m)) {
+			System.err.println(p + ".getDeclaringExecutable != " + m);
+			error++;
+		    }
+		    if(null == p.getType()) {
+			System.err.println(p + ".getType() == null");
+			error++;
+		    }
+		    if(null == p.getParameterizedType()) {
+			System.err.println(p + ".getParameterizedType == null");
+			error++;
+		    }
+	    }
+	    if(m.getName().equals("qux")) {
+		if(6 != parameters.length) {
+		    System.err.println("Wrong number of parameters for qux");
+		    error++;
+		}
+		for(int i = 0; i < parameters.length; i++) {
+		    Parameter p = parameters[i];
+		    // The getType family work with or without
+		    // parameter attributes compiled in.
+		    if(!parameters[i].getType().equals(qux_types[i])) {
+			System.err.println("Wrong parameter type for " + parameters[0] + ": expected " + qux_types[i] + ", but got " + parameters[i].getType());
+			error++;
+		    }
+		}
+		if(!parameters[0].getParameterizedType().equals(int.class)) {
+		    System.err.println("getParameterizedType for quux is wrong");
+		    error++;
+		}
+		if(!parameters[1].getParameterizedType().equals(Foo.class)) {
+		    System.err.println("getParameterizedType for quux is wrong");
+		    error++;
+		}
+		if(!(parameters[2].getParameterizedType() instanceof
+		     ParameterizedType)) {
+		    System.err.println("getParameterizedType for l is wrong");
+		    error++;
+		} else {
+		    ParameterizedType pt =
+			(ParameterizedType) parameters[2].getParameterizedType();
+		    if(!pt.getRawType().equals(List.class)) {
+			System.err.println("Raw type for l is wrong");
+			error++;
+		    }
+		    if(1 != pt.getActualTypeArguments().length) {
+			System.err.println("Number of type parameters for l is wrong");
+			error++;
+		    }
+		    if(!(pt.getActualTypeArguments()[0] instanceof WildcardType)) {
+			System.err.println("Type parameter for l is wrong");
+			error++;
+		    }
+		}
+		if(!(parameters[3].getParameterizedType() instanceof
+		     ParameterizedType)) {
+		    System.err.println("getParameterizedType for l2 is wrong");
+		    error++;
+		} else {
+		    ParameterizedType pt =
+			(ParameterizedType) parameters[3].getParameterizedType();
+		    if(!pt.getRawType().equals(List.class)) {
+			System.err.println("Raw type for l2 is wrong");
+			error++;
+		    }
+		    if(1 != pt.getActualTypeArguments().length) {
+			System.err.println("Number of type parameters for l2 is wrong");
+			error++;
+		    }
+		    if(!(pt.getActualTypeArguments()[0].equals(Foo.class))) {
+			System.err.println("Type parameter for l2 is wrong");
+			error++;
+		    }
+		}
+		if(!(parameters[4].getParameterizedType() instanceof
+		     ParameterizedType)) {
+		    System.err.println("getParameterizedType for l3 is wrong");
+		    error++;
+		} else {
+		    ParameterizedType pt =
+			(ParameterizedType) parameters[4].getParameterizedType();
+		    if(!pt.getRawType().equals(List.class)) {
+			System.err.println("Raw type for l3 is wrong");
+			error++;
+		    }
+		    if(1 != pt.getActualTypeArguments().length) {
+			System.err.println("Number of type parameters for l3 is wrong");
+			error++;
+		    }
+		    if(!(pt.getActualTypeArguments()[0] instanceof WildcardType)) {
+			System.err.println("Type parameter for l3 is wrong");
+			error++;
+		    } else {
+			WildcardType wt = (WildcardType)
+			    pt.getActualTypeArguments()[0];
+			if(!wt.getUpperBounds()[0].equals(Foo.class)) {
+			    System.err.println("Upper bounds on type parameter fol l3 is wrong");
+			    error++;
+			}
+		    }
+		}
+		if(!parameters[5].isVarArgs()) {
+		    System.err.println("isVarArg for rest is wrong");
+		    error++;
+		}
+		if(!(parameters[5].getParameterizedType().equals(String[].class))) {
+		    System.err.println("getParameterizedType for rest is wrong");
+		    error++;
+		}
+
+	    }
+	}
+	if(0 != error)
+	    throw new Exception("Failed " + error + " tests");
+    }
+
+    public class Foo {
+        int thing;
+	public void qux(int quux, Foo quuux,
+			List<?> l, List<Foo> l2,
+			List<? extends Foo> l3,
+                        String... rest) {}
+        public class Inner {
+            int thang;
+            public Inner(int theng) {
+                thang = theng + thing;
+            }
+        }
+    }
+
+}