EvalArgs.java

/*
 * Copyright (c) 2002, 2018, 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 4663146
 * @summary Arguments match no method error
 * @comment converted from test/jdk/com/sun/jdi/EvalArgs.sh
 *
 * @library /test/lib
 * @build EvalArgs
 * @run main/othervm EvalArgs
 */

import lib.jdb.JdbCommand;
import lib.jdb.JdbTest;

/*
 * The bug is that, for example, if a String is passed
 * as an arg to a func where an Object is expected,
 * "Arguments match no method" error occurs. jdb doesn't notice that this is
 * legal because String is an instance of Object.
 */

class EvalArgsTarg {

    static jj1 myjj1;
    static jj2 myjj2;
    static oranges myoranges;
    static boolean jjboolean = true;
    static byte    jjbyte = 1;
    static char    jjchar = 'a';
    static double  jjdouble = 2.2;
    static float   jjfloat = 3.1f;
    static int     jjint = 4;
    static long    jjlong = 5;
    static short   jjshort = 6;
    static int[]   jjintArray = {7, 8};
    static float[] jjfloatArray = {9.1f, 10.2f};


    public static void main(String args[]) {
        myjj1 = new jj1();
        myjj2 = new jj2();
        myoranges = new oranges();

        // prove that these work
        System.out.println( ffjj1(myjj1));
        System.out.println( ffjj1(myjj2));

        System.out.println("EvalArgsTarg.ffoverload(EvalArgsTarg.jjboolean) = " +
                            EvalArgsTarg.ffoverload(EvalArgsTarg.jjboolean));
        System.out.println("EvalArgsTarg.ffoverload(EvalArgsTarg.jjbyte) = " +
                            EvalArgsTarg.ffoverload(EvalArgsTarg.jjbyte));
        System.out.println("EvalArgsTarg.ffoverload(EvalArgsTarg.jjchar) = " +
                            EvalArgsTarg.ffoverload(EvalArgsTarg.jjchar));
        System.out.println("EvalArgsTarg.ffoverload(EvalArgsTarg.jjdouble) = " +
                            EvalArgsTarg.ffoverload(EvalArgsTarg.jjdouble));

        //This doesn't even compile
        //System.out.println( "ffintArray(jjfloatArray) = " + ffintArray(jjfloatArray));
        gus();
    }

    static void gus() {
        int x = 0;             // @1 breakpoint
    }

    public static String ffjj1(jj1 arg) {
        return arg.me;
    }

    public static String ffjj2(jj2 arg) {
        return arg.me;
    }

    static String ffboolean(boolean p1) {
        return "ffbool: p1 = " + p1;
    }

    static String ffbyte(byte p1) {
        return "ffbyte: p1 = " + p1;
    }

    static String ffchar(char p1) {
        return "ffchar: p1 = " + p1;
    }

    static String ffdouble(double p1) {
        return "ffdouble: p1 = " + p1;
    }

    static String fffloat(float p1) {
        return "fffloat: p1 = " + p1;
    }

    static String ffint(int p1) {
        return "ffint: p1 = " + p1;
    }

    static String fflong(long p1) {
        return "fflong: p1 = " + p1;
    }

    static String ffshort(short p1) {
        return "ffshort: p1 = " + p1;
    }

    static String ffintArray(int[] p1) {
        return "ffintArray: p1 = " + p1;
    }

    // Overloaded funcs
    public static String ffoverload(jj1 arg) {
        return arg.me;
    }

    static String ffoverload(boolean p1) {
        return "ffoverload: boolean p1 = " + p1;
    }
/***
    static String ffoverload(byte p1) {
        return "ffoverload: byte p1 = " + p1;
    }
***/
    static String ffoverload(char p1) {
        return "ffoverload: char p1 = " + p1;
    }

    static String ffoverload(double p1) {
        return "ffoverload: double p1 = " + p1;
    }

    static String ffoverload(float p1) {
        return "ffoverload: float p1 = " + p1;
    }
/***
    static String ffoverload(int p1) {
        return "ffoverload: int p1 = " + p1;
    }
***/
    static String ffoverload(long p1) {
        return "ffoverload: long p1 = " + p1;
    }

    static String ffoverload(short p1) {
        return "ffoverload: short p1 = " + p1;
    }

    static String ffoverload(int[] p1) {
        return "ffoverload: int array p1 = " + p1;
    }

    static class jj1 {
        String me;
        jj1() {
            me = "jj1name";
        }
        public String toString() {
            return me;
        }

    }

    static class jj2 extends jj1 {
        jj2() {
            super();
            me = "jj2name";
        }
    }

    static class oranges {
        oranges() {
        }
    }
}

public class EvalArgs extends JdbTest {
    public static void main(String argv[]) {
        new EvalArgs().run();
    }

    private EvalArgs() {
        super(DEBUGGEE_CLASS);
    }

    private static final String DEBUGGEE_CLASS = EvalArgsTarg.class.getName();

    @Override
    protected void runCases() {
        setBreakpointsFromTestSource("EvalArgs.java", 1);
        // Run to breakpoint #1
        jdb.command(JdbCommand.run());

        final String argsMatchNoMethod = "Arguments match no method";
        // verify that it works ok when arg types are the same as
        // the param types
        evalShouldNotContain("EvalArgsTarg.ffboolean(EvalArgsTarg.jjboolean)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffbyte(EvalArgsTarg.jjbyte)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffchar(EvalArgsTarg.jjchar)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffdouble(EvalArgsTarg.jjdouble)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.fffloat(EvalArgsTarg.jjfloat)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffint(EvalArgsTarg.jjint)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.fflong(EvalArgsTarg.jjlong)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffshort(EvalArgsTarg.jjshort)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffintArray(EvalArgsTarg.jjintArray)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffjj1(EvalArgsTarg.myjj1)", argsMatchNoMethod);

        // Provide a visual break in the output
        jdb.command(JdbCommand.print("1"));

        // Verify mixing primitive types works ok
        // These should work even though the arg types are
        // not the same because there is only one
        // method with each name.
        evalShouldNotContain("EvalArgsTarg.ffbyte(EvalArgsTarg.jjint)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffchar(EvalArgsTarg.jjdouble)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffdouble(EvalArgsTarg.jjfloat)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.fffloat(EvalArgsTarg.jjshort)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffint(EvalArgsTarg.jjlong)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.fflong(EvalArgsTarg.jjchar)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffshort(EvalArgsTarg.jjbyte)", argsMatchNoMethod);

        jdb.command(JdbCommand.print("1"));

        //  Verify that passing a subclass object works
        evalShouldNotContain("EvalArgsTarg.ffjj1(EvalArgsTarg.myjj2)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.myjj1.toString().equals(\"jj1name\")", argsMatchNoMethod);

        jdb.command(JdbCommand.print("1"));

        // Overloaded methods.  These should pass
        // because there is an exact  match.
        evalShouldNotContain("EvalArgsTarg.ffoverload(EvalArgsTarg.jjboolean)", argsMatchNoMethod);

        evalShouldNotContain("EvalArgsTarg.ffoverload(EvalArgsTarg.jjchar)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffoverload(EvalArgsTarg.jjdouble)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffoverload(EvalArgsTarg.jjfloat)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffoverload(EvalArgsTarg.jjlong)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffoverload(EvalArgsTarg.jjshort)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffoverload(EvalArgsTarg.jjintArray)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffoverload(EvalArgsTarg.myjj1)", argsMatchNoMethod);
        evalShouldNotContain("EvalArgsTarg.ffoverload(EvalArgsTarg.myjj2)", argsMatchNoMethod);

        jdb.command(JdbCommand.print("1"));
        jdb.command(JdbCommand.print("\"These should fail with msg Arguments match multiple methods\""));

        // These overload calls should fail because there
        // isn't an exact match and jdb isn't smart  enough
        // to figure out which of several possibilities
        // should be called
        final String argsMatchMultipleMethods = "Arguments match multiple methods";
        evalShouldContain("EvalArgsTarg.ffoverload(EvalArgsTarg.jjbyte)", argsMatchMultipleMethods);

        evalShouldContain("EvalArgsTarg.ffoverload(EvalArgsTarg.jjint)", argsMatchMultipleMethods);

        jdb.command(JdbCommand.print("1"));
        jdb.command(JdbCommand.print("\"These should fail with InvalidTypeExceptions\""));

        final String invalidTypeException = "InvalidTypeException";
        evalShouldContain("EvalArgsTarg.ffboolean(EvalArgsTarg.jjbyte)", invalidTypeException);
        evalShouldContain("EvalArgsTarg.ffintArray(EvalArgsTarg.jjint)", invalidTypeException);
        evalShouldContain("EvalArgsTarg.ffintArray(EvalArgsTarg.jjfloatArray)", invalidTypeException);
        evalShouldContain("EvalArgsTarg.ffjj2(EvalArgsTarg.myjj1)", invalidTypeException);
        evalShouldContain("EvalArgsTarg.ffjj2(EvalArgsTarg.myoranges)", invalidTypeException);

        jdb.contToExit(1);
    }

}