/*
 * Copyright (c) 2004, 2016, 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 4195445 6204179
 * @summary JDWP, JDI: Add return value to Method Exit Event
 * @author Jim Holmlund
 *
 * @run build TestScaffold VMConnection TargetListener TargetAdapter
 * @run compile -g MethodExitReturnValuesTest.java
 * @run driver MethodExitReturnValuesTest
 */
import com.sun.jdi.*;
import com.sun.jdi.event.*;
import com.sun.jdi.request.*;
import java.util.*;
import java.net.URLClassLoader;
import java.net.URL;
import java.lang.reflect.Array;

/*
 * This test has a debuggee which calls a static method
 * for each kind of JDI Value, and then an instance method
 * for each.
 * The debugger turns on MethodExitEvents and checks
 * that the right return values are included in the MethodExitEvents.
 * Each value is stored in a static var in the debuggee.  The debugger
 * gets the values from these static vars to check for correct
 * return values in the MethodExitEvents.
 */

class MethodExitReturnValuesTarg {
    // These are the values that will be returned by the methods
    static URL[] urls = new URL[1];
    public static byte      byteValue = 89;
    public static char      charValue = 'x';
    public static double    doubleValue = 2.2;
    public static float     floatValue = 3.3f;
    public static int       intValue = 1;
    public static long      longValue = Long.MAX_VALUE;
    public static short     shortValue = 8;
    public static boolean   booleanValue = false;

    public static Class       classValue = Object.class;
    public static ClassLoader classLoaderValue;
    {
        try {
            urls[0] = new URL("file:/foo");
        } catch (java.net.MalformedURLException ex) {
            throw new AssertionError(ex);
        }
        classLoaderValue = new URLClassLoader(urls);
    }

    public static Thread      threadValue;
    public static ThreadGroup threadGroupValue;
    public static String      stringValue = "abc";
    public static int[]       intArrayValue = new int[] {1, 2, 3};

    public static MethodExitReturnValuesTarg  objectValue =
        new MethodExitReturnValuesTarg();
    public String ivar = stringValue;

    // arrays to be used in calls to native methods Array.get...(....)
    public static byte[]    arrByte      = new byte[]    {byteValue};
    public static char[]    arrChar      = new char[]    {charValue};
    public static double[]  arrDouble    = new double[]  {doubleValue};
    public static float[]   arrFloat     = new float[]   {floatValue};
    public static int[]     arrInt       = new int[]     {intValue};
    public static long[]    arrLong      = new long[]    {longValue};
    public static short[]   arrShort     = new short[]   {shortValue};
    public static boolean[] arrBoolean   = new boolean[] {booleanValue};
    public static Object[]  arrObject    = new Object[]  {objectValue};

    // Used to show which set of tests follows
    public static String s_show(String p1) { return p1;}

    // These are the static methods
    public static byte s_bytef()      { return byteValue; }
    public static char s_charf()      { return charValue; }
    public static double s_doublef()  { return doubleValue; }
    public static float s_floatf()    { return floatValue; }
    public static int s_intf()        { return intValue; }
    public static long s_longf()      { return longValue; }
    public static short s_shortf()    { return shortValue; }
    public static boolean s_booleanf(){ return booleanValue; }
    public static String s_stringf()  { return stringValue; }
    public static Class s_classf()    { return classValue; }
    public static ClassLoader s_classLoaderf()
                                      { return classLoaderValue; }
    public static Thread s_threadf()  { threadValue = Thread.currentThread();
                                        return threadValue; }
    public static ThreadGroup s_threadGroupf()
                                      { threadGroupValue = threadValue.getThreadGroup();
                                        return threadGroupValue; }
    public static int[] s_intArrayf() { return intArrayValue; }
    public static Object s_nullObjectf() { return null; }
    public static Object s_objectf()  { return objectValue; }
    public static void s_voidf()      {}

    // These are the instance methods
    public byte i_bytef()            { return byteValue; }
    public char i_charf()            { return charValue; }
    public double i_doublef()        { return doubleValue; }
    public float i_floatf()          { return floatValue; }
    public int i_intf()              { return intValue; }
    public long i_longf()            { return longValue; }
    public short i_shortf()          { return shortValue; }
    public boolean i_booleanf()      { return booleanValue; }
    public String i_stringf()        { return stringValue; }
    public Class i_classf()          { return classValue; }
    public ClassLoader i_classLoaderf()
                                     { return classLoaderValue; }
    public Thread i_threadf()        { return threadValue; }
    public ThreadGroup i_threadGroupf()
                                     { return threadGroupValue; }
    public int[] i_intArrayf()       { return intArrayValue; }
    public Object i_nullObjectf()    { return null; }
    public Object i_objectf()        { return objectValue; }
    public void i_voidf()            {}

    static void doit(MethodExitReturnValuesTarg xx) {
        s_show("==========  Testing static methods ================");
        s_bytef();
        s_charf();
        s_doublef();
        s_floatf();
        s_intf();
        s_longf();
        s_shortf();
        s_booleanf();

        s_stringf();
        s_classf();
        s_classLoaderf();
        s_threadf();
        s_threadGroupf();
        s_intArrayf();
        s_nullObjectf();
        s_objectf();
        s_voidf();

        s_show("==========  Testing instance methods ================");
        xx.i_bytef();
        xx.i_charf();
        xx.i_doublef();
        xx.i_floatf();
        xx.i_intf();
        xx.i_longf();
        xx.i_shortf();
        xx.i_booleanf();
        xx.i_stringf();
        xx.i_intArrayf();
        xx.i_classf();
        xx.i_classLoaderf();
        xx.i_threadf();
        xx.i_threadGroupf();
        xx.i_nullObjectf();
        xx.i_objectf();
        xx.i_voidf();

        // Prove it works for native methods too
        s_show("==========  Testing native methods ================");
        StrictMath.sin(doubleValue);
        Array.getByte(arrByte, 0);
        Array.getChar(arrChar, 0);
        Array.getDouble(arrDouble, 0);
        Array.getFloat(arrFloat, 0);
        Array.getInt(arrInt, 0);
        Array.getLong(arrLong, 0);
        Array.getShort(arrShort, 0);
        Array.getBoolean(arrBoolean, 0);
        Array.get(arrObject, 0);
        stringValue.intern();
    }

    public static void main(String[] args) {
        // The debugger will stop at the start of main,
        // enable method exit events, and then do
        // a resume.

        MethodExitReturnValuesTarg xx =
            new MethodExitReturnValuesTarg();

        doit(xx);
    }
}



public class MethodExitReturnValuesTest extends TestScaffold {
    // Classes which we are interested in
    private List includes = Arrays.asList(new String[] {
        "MethodExitReturnValuesTarg",
        "java.lang.reflect.Array",
        "java.lang.StrictMath",
        "java.lang.String"
    });

    static VirtualMachineManager vmm ;
    ClassType targetClass;
    Field theValueField;
    static int successes = 0;
    static final int expectedSuccesses = 44;  // determined by inspection :-)

    MethodExitReturnValuesTest(String args[]) {
        super(args);
    }

    public static void main(String[] args)      throws Exception {
        MethodExitReturnValuesTest meee = new MethodExitReturnValuesTest(args);
        vmm = Bootstrap.virtualMachineManager();
        meee.startTests();
    }

    // These are the methods that check for correct return values.

    void ckByteValue(Value retValue) {
        Field theValueField = targetClass.fieldByName("byteValue");
        ByteValue theValue = (ByteValue)targetClass.getValue(theValueField);

        byte vv = theValue.value();
        byte rv = ((ByteValue)retValue).value();
        if (vv != rv) {
            failure("failure: byte: expected " + vv + ", got " + rv);
        } else {
            System.out.println("Passed: byte " + rv);
            successes++;
        }
    }

    void ckCharValue(Value retValue) {
        Field theValueField = targetClass.fieldByName("charValue");
        CharValue theValue = (CharValue)targetClass.getValue(theValueField);

        char vv = theValue.value();
        char rv = ((CharValue)retValue).value();
        if (vv != rv) {
            failure("failure: char: expected " + vv + ", got " + rv);
        } else {
            System.out.println("Passed: char " + rv);
            successes++;
        }
    }

    void ckDoubleValue(Value retValue) {
        Field theValueField = targetClass.fieldByName("doubleValue");
        DoubleValue theValue = (DoubleValue)targetClass.getValue(theValueField);

        double vv = theValue.value();
        double rv = ((DoubleValue)retValue).value();
        if (vv != rv) {
            failure("failure: double: expected " + vv + ", got " + rv);
        } else {
            System.out.println("Passed: double " + rv);
            successes++;
        }
    }

    void ckFloatValue(Value retValue) {
        Field theValueField = targetClass.fieldByName("floatValue");
        FloatValue theValue = (FloatValue)targetClass.getValue(theValueField);

        float vv = theValue.value();
        float rv = ((FloatValue)retValue).value();
        if (vv != rv) {
            failure("failure: float: expected " + vv + ", got " + rv);
        } else {
            System.out.println("Passed: float " + rv);
            successes++;
        }
    }

    void ckIntValue(Value retValue) {
        Field theValueField = targetClass.fieldByName("intValue");
        IntegerValue theValue = (IntegerValue)targetClass.getValue(theValueField);

        int vv = theValue.value();
        int rv = ((IntegerValue)retValue).value();
        if (vv != rv) {
            failure("failure: int: expected " + vv + ", got " + rv);
        } else {
            System.out.println("Passed: int " + rv);
            successes++;
        }
    }

    void ckLongValue(Value retValue) {
        Field theValueField = targetClass.fieldByName("longValue");
        LongValue theValue = (LongValue)targetClass.getValue(theValueField);

        long vv = theValue.value();
        long rv = ((LongValue)retValue).value();
        if (vv != rv) {
            failure("failure: long: expected " + vv + ", got " + rv);
        } else {
            System.out.println("Passed: long " + rv);
            successes++;
        }
    }

    void ckShortValue(Value retValue) {
        Field theValueField = targetClass.fieldByName("shortValue");
        ShortValue theValue = (ShortValue)targetClass.getValue(theValueField);

        short vv = theValue.value();
        short rv = ((ShortValue)retValue).value();
        if (vv != rv) {
            failure("failure: short: expected " + vv + ", got " + rv);
        } else {
            System.out.println("Passed: short " + rv);
            successes++;
        }
    }

    void ckBooleanValue(Value retValue) {
        Field theValueField = targetClass.fieldByName("booleanValue");
        BooleanValue theValue = (BooleanValue)targetClass.getValue(theValueField);

        boolean vv = theValue.value();
        boolean rv = ((BooleanValue)retValue).value();
        if (vv != rv) {
            failure("failure: boolean: expected " + vv + ", got " + rv);
        } else {
            System.out.println("Passed: boolean " + rv);
            successes++;
        }
    }

    void ckStringValue(Value retValue) {
        Field theValueField = targetClass.fieldByName("stringValue");
        StringReference theValue = (StringReference)targetClass.getValue(theValueField);

        String vv = theValue.value();
        String rv = ((StringReference)retValue).value();
        if (vv != rv) {
            failure("failure: String: expected " + vv + ", got " + rv);
        } else {
            System.out.println("Passed: String: " + rv);
            successes++;
        }
    }

    void ckClassValue(Value retValue) {
        Field theValueField = targetClass.fieldByName("classValue");
        ClassObjectReference vv = (ClassObjectReference)targetClass.
            getValue(theValueField);

        ClassObjectReference rv = (ClassObjectReference)retValue;
        if (vv != rv) {
            failure("failure: Class: expected " + vv + ", got " + rv);
        } else {
            System.out.println("Passed: Class: " + rv);
            successes++;
        }
    }

    void ckClassLoaderValue(Value retValue) {
        Field theValueField = targetClass.fieldByName("classLoaderValue");
        ClassLoaderReference vv = (ClassLoaderReference)targetClass.
            getValue(theValueField);

        ClassLoaderReference rv = (ClassLoaderReference)retValue;
        if (vv != rv) {
            failure("failure: ClassLoader: expected " + vv + ", got " + rv);
        } else {
            System.out.println("Passed: ClassLoader: " + rv);
            successes++;
        }
    }

    void ckThreadValue(Value retValue) {
        Field theValueField = targetClass.fieldByName("threadValue");
        ThreadReference vv = (ThreadReference)targetClass.
            getValue(theValueField);

        ThreadReference rv = (ThreadReference)retValue;
        if (vv != rv) {
            failure("failure: Thread: expected " + vv + ", got " + rv);
        } else {
            System.out.println("Passed: Thread: " + rv);
            successes++;
        }
    }

    void ckThreadGroupValue(Value retValue) {
        Field theValueField = targetClass.fieldByName("threadGroupValue");
        ThreadGroupReference vv = (ThreadGroupReference)targetClass.
            getValue(theValueField);

        ThreadGroupReference rv = (ThreadGroupReference)retValue;
        if (vv != rv) {
            failure("failure: ThreadgGroup: expected " + vv + ", got " + rv);
        } else {
            System.out.println("Passed: ThreadGroup: " + rv);
            successes++;
        }
    }

    void ckArrayValue(Value retValue) {
        Field theValueField = targetClass.fieldByName("intArrayValue");
        ArrayReference theValue = (ArrayReference)targetClass.getValue(theValueField);
        IntegerValue theElem2 = (IntegerValue)theValue.getValue(2);

        ArrayReference theRetValue = (ArrayReference)retValue;
        IntegerValue retElem2 = (IntegerValue)theRetValue.getValue(2);
        int vv = theElem2.value();
        int rv = retElem2.value();
        if (vv != rv) {
            failure("failure: in[2]: expected " + vv + ", got " + rv);
        } else {
            System.out.println("Passed: int[2]: " + rv);
            successes++;
        }
    }

    void ckNullObjectValue(Value retValue) {
        if (retValue != null) {
            failure("failure: NullObject: expected " + null + ", got " + retValue);
        } else {
            System.out.println("Passed: NullObject: " + retValue);
            successes++;
        }
    }

    void ckObjectValue(Value retValue) {
        // We will check the ivar field which we know contains
        // the value of 'stringValue'
        Field theValueField = targetClass.fieldByName("stringValue");
        StringReference theValue = (StringReference)targetClass.getValue(theValueField);

        Field theIVarField = targetClass.fieldByName("ivar");
        ObjectReference theRetValue = (ObjectReference)retValue;
        StringReference theRetValField = (StringReference)theRetValue.getValue(theIVarField);

        String vv = theValue.value();
        String rv = theRetValField.value();
        if (vv != rv) {
            failure("failure: Object: expected " + vv + ", got " + rv);
       } else {
            System.out.println("Passed: Object: " + rv);
            successes++;
        }
    }

    void ckVoidValue(Value retValue) {
        System.out.println("Passed: Void");
        successes++;
    }

    void ckSinValue(Value retValue) {
        double rv = ((DoubleValue)retValue).value();
        double vv = StrictMath.sin(MethodExitReturnValuesTarg.doubleValue);
        if (rv != vv) {
            failure("failure: sin: expected " + vv + ", got " + rv);
        } else {
            System.out.println("Passed: sin " + rv);
            successes++;
        }
    }

    // This is the MethodExitEvent handler.
    public void methodExited(MethodExitEvent event) {
        String origMethodName = event.method().name();

        if (!includes.contains(event.method().declaringType().name())) {
            return;
        }

        if (vm().canGetMethodReturnValues()) {
            Value retValue = event.returnValue();

            if ("sin".equals(origMethodName)) {
                ckSinValue(retValue);
                return;
            }

            if (!origMethodName.startsWith("s_") &&
                !origMethodName.startsWith("i_")) {
                // Check native methods
                if ("getByte".equals(origMethodName))         ckByteValue(retValue);
                else if ("getChar".equals(origMethodName))    ckCharValue(retValue);
                else if ("getDouble".equals(origMethodName))  ckDoubleValue(retValue);
                else if ("getFloat".equals(origMethodName))   ckFloatValue(retValue);
                else if ("getInt".equals(origMethodName))     ckIntValue(retValue);
                else if ("getLong".equals(origMethodName))    ckLongValue(retValue);
                else if ("getShort".equals(origMethodName))   ckShortValue(retValue);
                else if ("getBoolean".equals(origMethodName)) ckBooleanValue(retValue);
                else if ("getObject".equals(origMethodName))  ckObjectValue(retValue);
                else if ("intern".equals(origMethodName))     ckStringValue(retValue);
                return;
            }

            String methodName = origMethodName.substring(2);
            if ("show".equals(methodName)) {
                System.out.println(retValue);
                return;
            }

            if ("bytef".equals(methodName))             ckByteValue(retValue);
            else if ("charf".equals(methodName))        ckCharValue(retValue);
            else if ("doublef".equals(methodName))      ckDoubleValue(retValue);
            else if ("floatf".equals(methodName))       ckFloatValue(retValue);
            else if ("intf".equals(methodName))         ckIntValue(retValue);
            else if ("longf".equals(methodName))        ckLongValue(retValue);
            else if ("shortf".equals(methodName))       ckShortValue(retValue);
            else if ("booleanf".equals(methodName))     ckBooleanValue(retValue);
            else if ("stringf".equals(methodName))      ckStringValue(retValue);
            else if ("classf".equals(methodName))       ckClassValue(retValue);
            else if ("classLoaderf".equals(methodName)) ckClassLoaderValue(retValue);
            else if ("threadf".equals(methodName))      ckThreadValue(retValue);
            else if ("threadGroupf".equals(methodName)) ckThreadGroupValue(retValue);
            else if ("intArrayf".equals(methodName))    ckArrayValue(retValue);
            else if ("nullObjectf".equals(methodName))  ckNullObjectValue(retValue);
            else if ("objectf".equals(methodName))      ckObjectValue(retValue);
            else if ("voidf".equals(methodName))        ckVoidValue(retValue);
            else {
                failure("failure: Unknown methodName: " + origMethodName);
            }
        } else {
            System.out.println("Return Value not available for method: " + origMethodName);
        }
    }

    protected void runTests() throws Exception {
        /*
         * Get to the top of main()
         * to determine targetClass and mainThread
         */
        BreakpointEvent bpe = startToMain("MethodExitReturnValuesTarg");
        targetClass = (ClassType)bpe.location().declaringType();
        mainThread = bpe.thread();

        theValueField = targetClass.fieldByName("theValue");

        /*
         * Ask for method exit events
         */
        MethodExitRequest exitRequest =
            eventRequestManager().createMethodExitRequest();
        exitRequest.addThreadFilter(mainThread);

        int sessionSuspendPolicy = EventRequest.SUSPEND_ALL;
        //sessionSuspendPolicy = EventRequest.SUSPEND_EVENT_THREAD;
        //sessionSuspendPolicy = EventRequest.SUSPEND_NONE;
        exitRequest.setSuspendPolicy(sessionSuspendPolicy);
        exitRequest.enable();

        /*
         * We are now set up to receive the notifications we want.
         * Here we go.  This adds 'this' as a listener so
         * that our handlers above will be called.
         */

        listenUntilVMDisconnect();

        if (successes != expectedSuccesses) {
            failure("failure: Expected " + expectedSuccesses + ", but got " + successes);
        }
        System.out.println("All done, " + successes + " passed");


        if (!testFailed) {
            System.out.println();
            System.out.println("MethodExitReturnValuesTest: passed");
        } else {
            System.out.println();
            System.out.println("MethodExitReturnValuesTest: failed");
            throw new Exception("MethodExitReturnValuesTest: failed");
        }
    }
}