test/jdk/java/lang/reflect/Parameter/WithoutParameters.java

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

/*
 * @test
 * @bug 8004729
 * @summary javac should generate method parameters correctly.
 */

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

import static java.lang.annotation.ElementType.*;

public class WithoutParameters {
    int errors = 0;

    private WithoutParameters() {}

    public static void main(String argv[]) throws Exception {
        WithoutParameters wp = new WithoutParameters();
        wp.runTests(Foo.class.getMethods());
        wp.runTests(Foo.Inner.class.getConstructors());
        wp.checkForErrors();
    }

    void runTests(Method[] methods) throws Exception {
        for(Method m : methods) {runTest(m);}
    }

    void runTests(Constructor[] constructors) throws Exception {
        for(Constructor c : constructors) {runTest(c);}
    }

    void runTest(Executable e) throws Exception {
        System.err.println("Inspecting executable " + e);
        Parameter[] parameters = e.getParameters();
        Objects.requireNonNull(parameters, "getParameters should never be null");

        ExpectedParameterInfo epi = e.getAnnotation(ExpectedParameterInfo.class);
        if (epi != null) {
            abortIfTrue(epi.parameterCount() != e.getParameterCount(), "Bad parameter count for "+ e);
            abortIfTrue(epi.isVarArgs() != e.isVarArgs(),"Bad varargs value for "+ e);
        }
        abortIfTrue(e.getParameterCount() != parameters.length, "Mismatched of parameter counts.");

        for(int i = 0; i < parameters.length; i++) {
            Parameter p = parameters[i];
            errorIfTrue(p.isNamePresent(), p + ".isNamePresent == true");
            errorIfTrue(!p.getDeclaringExecutable().equals(e), p + ".getDeclaringExecutable != " + e);
            Objects.requireNonNull(p.getType(), "getType() should not be null");
            Objects.requireNonNull(p.getParameterizedType(), "getParameterizedType() should not be null");

            if (epi != null) {
                Class<?> expectedParameterType = epi.parameterTypes()[i];
                errorIfTrue(!p.getType().equals(expectedParameterType),
                            "Wrong parameter type for " + p + ": expected " + expectedParameterType  +
                            ", but got " + p.getType());

                ParameterizedInfo[] expectedParameterizedTypes = epi.parameterizedTypes();
                if (expectedParameterizedTypes.length > 0) {
                    Type parameterizedType = p.getParameterizedType();
                    Class<? extends Type> expectedParameterziedTypeType = expectedParameterizedTypes[i].value();
                    errorIfTrue(!expectedParameterziedTypeType.isAssignableFrom(parameterizedType.getClass()),
                                "Wrong class of parameteried type of " + p + ": expected " + expectedParameterziedTypeType  +
                                ", but got " + parameterizedType.getClass());

                    if (expectedParameterziedTypeType.equals(Class.class)) {
                        errorIfTrue(!parameterizedType.equals(expectedParameterType),
                                    "Wrong parameteried type for " + p + ": expected " + expectedParameterType  +
                                    ", but got " + parameterizedType);
                    } else {
                        if (expectedParameterziedTypeType.equals(ParameterizedType.class)) {
                            ParameterizedType ptype = (ParameterizedType)parameterizedType;
                            errorIfTrue(!ptype.getRawType().equals(expectedParameterType),
                                        "Wrong raw type for " + p + ": expected " + expectedParameterType  +
                                        ", but got " + ptype.getRawType());
                        }

                        // Check string representation
                        String expectedStringOfType = epi.parameterizedTypes()[i].string();
                        errorIfTrue(!expectedStringOfType.equals(parameterizedType.toString()),
                                    "Bad type string" + p + ": expected " + expectedStringOfType  +
                                    ", but got " + parameterizedType.toString());
                    }
                }
            }
        }
    }

    private void checkForErrors() {
        if (errors > 0)
            throw new RuntimeException("Failed " + errors + " tests");
    }

    private void errorIfTrue(boolean predicate, String errMessage) {
        if (predicate) {
            errors++;
            System.err.println(errMessage);
        }
    }

    private void abortIfTrue(boolean predicate, String errMessage) {
        if (predicate) {
            throw new RuntimeException(errMessage);
        }
    }

    @Retention(RetentionPolicy.RUNTIME)
    @Target({METHOD, CONSTRUCTOR})
    @interface ExpectedParameterInfo {
        int parameterCount() default 0;
        Class<?>[] parameterTypes() default {};
        ParameterizedInfo[] parameterizedTypes() default {};
        boolean isVarArgs() default false;
    }

    @Target({})
    @interface ParameterizedInfo {
        Class<? extends Type> value() default Class.class;
        String string() default "";
    }

    public class Foo {
        int thing;
        @ExpectedParameterInfo(parameterCount = 6,
                               parameterTypes =
                               {int.class, Foo.class,
                                List.class, List.class,
                                List.class, String[].class},
                               parameterizedTypes =
                                {@ParameterizedInfo(Class.class),
                                 @ParameterizedInfo(Class.class),
                                 @ParameterizedInfo(value=ParameterizedType.class, string="java.util.List<?>"),
                                 @ParameterizedInfo(value=ParameterizedType.class, string="java.util.List<WithoutParameters$Foo>"),
                                 @ParameterizedInfo(value=ParameterizedType.class, string="java.util.List<? extends WithoutParameters$Foo>"),
                                 @ParameterizedInfo(Class.class)},
                               isVarArgs = true)
        public void qux(int quux, Foo quuux,
                        List<?> l, List<Foo> l2,
                        List<? extends Foo> l3,
                        String... rest) {}
        public class Inner {
            int thang;
            @ExpectedParameterInfo(parameterCount = 2,
                                   parameterTypes = {Foo.class, int.class})
            public Inner(int theng) {
                thang = theng + thing;
            }
        }
    }
}