/*

 * Copyright (c) 2001, 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 8187143

 * @summary JDI crash in ~BufferBlob::MethodHandles adapters

 *

 * @run build TestScaffold VMConnection TargetListener TargetAdapter

 * @run compile -g NashornPopFrameTest.java

 * @run driver NashornPopFrameTest

 */

import com.sun.jdi.*;

import com.sun.jdi.event.*;

import com.sun.jdi.request.*;

import jdk.nashorn.api.scripting.NashornScriptEngineFactory;

import javax.script.*;

import java.io.PrintStream;

// The debuggee, creates and uses a Nashorn engine to evaluate a simple script.

// The debugger  tries to set a breakpoint in Nashorn internal DEBUGGER method.

// When the breakpoint is reached, it looks for stack frame whose method's

// declaring type name starts with jdk.nashorn.internal.scripts.Script$.

// (nashorn dynamically generated classes)

// It then pops stack frames using the ThreadReference.popFrames() call, up to

// and including the above stackframe.

// The execution of the debuggee application is resumed after the needed

// frames have been popped.

class ScriptDebuggee {

    public final static int BKPT_LINE = 74;

    static ScriptEngine engine = new NashornScriptEngineFactory().getScriptEngine();

    static public String failReason = null;

    static void doit() throws Exception {

        System.out.println("Debugee: started!");

        String script =

                "function f() {\r\n" +

                        " debugger;\r\n" +

                        " debugger;\r\n" +

                        "}\r\n" +

                        "f();";

        try {

            engine.eval(script);

        } catch (Exception ex) {

            failReason = "ScriptDebuggee failed: Exception in engine.eval(): "

                    + ex.toString();

            ex.printStackTrace();

        }

        System.out.println("Debugee: finished!"); // BKPT_LINE

    }

    public static void main(String[] args) throws Exception {

        doit();

    }

}

/********** test program **********/

public class NashornPopFrameTest extends TestScaffold {

    static PrintStream out = System.out;

    static boolean breakpointReached = false;

    String debuggeeFailReason = null;

    ClassType targetClass;

    ThreadReference mainThread;

    BreakpointRequest bkptRequest;

    NashornPopFrameTest(String args[]) {

        super(args);

    }

    public static void main(String[] args)      throws Exception {

        NashornPopFrameTest nashornPopFrameTest = new NashornPopFrameTest(args);

        nashornPopFrameTest.startTests();

    }

    /********** test core **********/

    protected void runTests() throws Exception {

        /*

         * Get to the top of main() to determine targetClass and mainThread

         */

        BreakpointEvent bpe = startToMain("ScriptDebuggee");

        targetClass = (ClassType)bpe.location().declaringType();

        out.println("Agent: runTests: after startToMain()");

        mainThread = bpe.thread();

        EventRequestManager erm = vm().eventRequestManager();

        Location loc = findLocation(targetClass, ScriptDebuggee.BKPT_LINE);

        try {

            addListener(this);

        } catch (Exception ex){

            ex.printStackTrace();

            failure("Failed: Could not add listener");

            throw new Exception("NashornPopFrameTest: failed with Exception in AddListener");

        }

        pauseAtDebugger(vm());

        bkptRequest = erm.createBreakpointRequest(loc);

        bkptRequest.enable();

        vm().resume();

        try {

            listen(vm());

        } catch (Exception exp) {

            exp.printStackTrace();

            failure("Failed: Caught Exception while Listening");

            throw new Exception("NashornPopFrameTest: failed with Exception in listen()");

        }

        // Debugger continues to run until it receives a VMdisconnect event either because

        // the Debuggee crashed / got exception / finished successfully.

        while (!vmDisconnected) {

            try {

                Thread.sleep(100);

            } catch (InterruptedException ee) {

            }

        }

        removeListener(this);

        if (breakpointReached) {

            if (debuggeeFailReason != null) {

                failure(debuggeeFailReason);

            }

        } else {

            failure("Expected breakpoint in ScriptDebuggee:" +

                    ScriptDebuggee.BKPT_LINE + " was not reached");

        }

        if (testFailed) {

            throw new Exception("NashornPopFrameTest: failed");

        }

        out.println("NashornPopFrameTest: passed");

    }

    private static void pauseAtDebugger(VirtualMachine vm) throws AbsentInformationException {

        for (ReferenceType t : vm.allClasses()) pauseAtDebugger(t);

    }

    // Set a breakpoint in Nashorn internal DEBUGGER method.

    private static void pauseAtDebugger(ReferenceType t) throws AbsentInformationException {

        if (!t.name().endsWith(".ScriptRuntime")) {

            return;

        }

        for (Location l : t.allLineLocations()) {

            if (!l.method().name().equals("DEBUGGER")) continue;

            BreakpointRequest bkptReq = t.virtualMachine().eventRequestManager().createBreakpointRequest(l);

            out.println("Setting breakpoint for " + l);

            bkptReq.enable();

            break;

        }

    }

    private static void listen(VirtualMachine vm) throws Exception {

        EventQueue eventQueue = vm.eventQueue();

        EventSet es = eventQueue.remove();

        if (es != null) {

            handle(es);

        }

    }

    // Handle event when breakpoint is reached

    private static void handle(EventSet eventSet) throws Exception {

        out.println("Agent handle(): started");

        for (Event event : eventSet) {

            if (event instanceof BreakpointEvent) {

                findFrameAndPop(event);

            }

        }

        eventSet.resume();

        out.println("Agent handle(): finished");

    }

    private static void findFrameAndPop(Event event) throws Exception {

        ThreadReference thread = ((BreakpointEvent) event).thread();

        out.println("Agent: handling Breakpoint " + " at " +

                ((BreakpointEvent) event).location() +

                " in thread: " + thread);

        StackFrame sf = findScriptFrame(thread);

        if (sf != null) {

            out.println("Thread Pop Frame on StackFrame = " + sf);

            thread.popFrames(sf);

        }

    }

    // Find stack frame whose method's declaring type name starts with

    // jdk.nashorn.internal.scripts.Script$ and return that frame

    private static StackFrame findScriptFrame(ThreadReference t) throws IncompatibleThreadStateException {

        for (int i = 0; i < t.frameCount(); i++) {

            StackFrame sf = t.frame(i);

            String typeName = sf.location().method().declaringType().name();

            if (typeName.startsWith("jdk.nashorn.internal.scripts.Script$")) {

                out.println("Agent: in findScriptFrame: TypeName = " + typeName);

                return sf;

            }

        }

        throw new RuntimeException("no script frame");

    }

    static int bkptCount = 0;

    /********** event handlers **********/

    public void breakpointReached(BreakpointEvent event) {

        ThreadReference thread = ((BreakpointEvent) event).thread();

        String locStr = "" + ((BreakpointEvent) event).location();

        out.println("Agent: BreakpointEvent #" + (bkptCount++) +

                " at " + locStr + " in thread: " + thread);

        if (locStr.equals("ScriptDebuggee:" + ScriptDebuggee.BKPT_LINE)) {

            breakpointReached = true;

            Field failReasonField = targetClass.fieldByName("failReason");

            Value failReasonVal = targetClass.getValue(failReasonField);

            if (failReasonVal != null) {

                debuggeeFailReason = ((StringReference)failReasonVal).value();

            }

            bkptRequest.disable();

        }

    }

    public void eventSetComplete(EventSet set) {

        set.resume();

    }

    public void vmDisconnected(VMDisconnectEvent event) {

        println("Agent: Got VMDisconnectEvent");

    }

}