/*
 * 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.
 */

/*
 * @ignore
 * @test
 * @compile -parameters WithParameters.java
 * @run main WithParameters
 * @summary javac should generate method parameters correctly.
 */

import java.lang.*;
import java.lang.annotation.*;
import java.lang.reflect.*;
import java.util.List;

public class WithParameters {

    private static final Class<?>[] qux_types = {
        int.class, Foo.class, List.class, List.class, List.class, String[].class
    };

    private static final String[] qux_names = {
	"quux", "quuux", "l", "l2", "l3", "rest"
    };

    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.getName());
	    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];
		    if(!parameters[i].getName().equals(qux_names[i])) {
			System.err.println("Wrong parameter name for " + parameters[i]);
			error++;
		    }
		    // 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].toString().equals("int quux")) {
		    System.err.println("toString for quux is wrong");
		    error++;
		}
		if(parameters[0].getModifiers() != Modifier.FINAL) {
		    System.err.println("quux is not final");
		    error++;
		}
		if(parameters[0].isVarArgs()) {
		    System.err.println("isVarArg for quux is wrong");
		    error++;
		}
		if(!parameters[0].getParameterizedType().equals(int.class)) {
		    System.err.println("getParameterizedType for quux is wrong");
		    error++;
		}
		if(parameters[1].toString().equals("WithParameters$Foo quuux")) {
		    System.err.println("toString for quuux is wrong");
		    error++;
		}
		if(parameters[1].isVarArgs()) {
		    System.err.println("isVarArg for quuux is wrong");
		    error++;
		}
		if(!parameters[1].getParameterizedType().equals(Foo.class)) {
		    System.err.println("getParameterizedType for quuux is wrong");
		    error++;
		}
                Annotation[] anns = parameters[1].getAnnotations();
                if(1 != anns.length) {
                    System.err.println("getAnnotations missed an annotation");
                    error++;
                } else if(!anns[0].annotationType().equals(Thing.class)) {
                    System.err.println("getAnnotations has the wrong annotation");
                    error++;
                }
		if(parameters[2].toString().equals("java.util.List<?> quuux")) {
		    System.err.println("toString for l is wrong");
		    error++;
		}
		if(parameters[2].isVarArgs()) {
		    System.err.println("isVarArg for l 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].toString().equals("java.util.List<WithParameters$Foo> l")) {
		    System.err.println("toString for l2 is wrong");
		    error++;
		}
		if(parameters[3].isVarArgs()) {
		    System.err.println("isVarArg for l2 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].toString().equals("java.util.List<? extends WithParameters$Foo> l")) {
		    System.err.println("toString for l3 is wrong");
		    error++;
		}
		if(parameters[4].isVarArgs()) {
		    System.err.println("isVarArg for l3 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].toString().equals("java.lang.String... rest")) {
		    System.err.println("toString for l 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");
    }

    void test(int test) {}

    public class Foo {
        int thing;
        public void qux(final int quux, @Thing Foo quuux,
                        List<?> l, List<Foo> l2,
                        List<? extends Foo> l3,
                        String... rest) {}
    }

    @Retention(RetentionPolicy.RUNTIME)
    public @interface Thing {}

}