/*

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

 */

import com.sun.jdi.*;

import com.sun.jdi.request.*;

import com.sun.jdi.event.*;

import java.util.*;

import java.io.*;

/**

 * Framework used by all JDI regression tests

 */

abstract public class TestScaffold extends TargetAdapter {

    private boolean shouldTrace = false;

    private VMConnection connection;

    private VirtualMachine vm;

    private EventRequestManager requestManager;

    private List listeners = Collections.synchronizedList(new LinkedList());

    private boolean redefineAtStart = false;

    private boolean redefineAtEvents = false;

    private boolean redefineAsynchronously = false;

    private ReferenceType mainStartClass = null;

    ThreadReference mainThread;

    /**

     * We create a VMDeathRequest, SUSPEND_ALL, to sync the BE and FE.

     */

    private VMDeathRequest ourVMDeathRequest = null;

    /**

     * We create an ExceptionRequest, SUSPEND_NONE so that we can

     * catch it and output a msg if an exception occurs in the

     * debuggee.

     */

    private ExceptionRequest ourExceptionRequest = null;

    /**

     * If we do catch an uncaught exception, we set this true

     * so the testcase can find out if it wants to.

     */

    private boolean exceptionCaught = false;

    ThreadReference vmStartThread = null;

    boolean vmDied = false;

    boolean vmDisconnected = false;

    final String[] args;

    protected boolean testFailed = false;

    static private class ArgInfo {

        String targetVMArgs = "";

        String targetAppCommandLine = "";

        String connectorSpec = "com.sun.jdi.CommandLineLaunch:";

        int traceFlags = 0;

    }

    /**

     * An easy way to sleep for awhile

     */

    public void mySleep(int millis) {

        try {

            Thread.sleep(millis);

        } catch (InterruptedException ee) {

        }

    }

    boolean getExceptionCaught() {

        return exceptionCaught;

    }

    void setExceptionCaught(boolean value) {

        exceptionCaught = value;

    }

    /**

     * Return true if eventSet contains the VMDeathEvent for the request in

     * the ourVMDeathRequest ivar.

     */

    private boolean containsOurVMDeathRequest(EventSet eventSet) {

        if (ourVMDeathRequest != null) {

            Iterator myIter = eventSet.iterator();

            while (myIter.hasNext()) {

                Event myEvent = (Event)myIter.next();

                if (!(myEvent instanceof VMDeathEvent)) {

                    // We assume that an EventSet contains only VMDeathEvents

                    // or no VMDeathEvents.

                    break;

                }

                if (ourVMDeathRequest.equals(myEvent.request())) {

                    return true;

                }

            }

        }

        return false;

    }

    /************************************************************************

     * The following methods override those in our base class, TargetAdapter.

     *************************************************************************/

    /**

     * Events handled directly by scaffold always resume (well, almost always)

     */

    public void eventSetComplete(EventSet set) {

        // The listener in connect(..) resumes after receiving our

        // special VMDeathEvent.  We can't also do the resume

        // here or we will probably get a VMDisconnectedException

        if (!containsOurVMDeathRequest(set)) {

            traceln("TS: set.resume() called");

            set.resume();

        }

    }

    /**

     * This method sets up default requests.

     * Testcases can override this to change default behavior.

     */

    protected void createDefaultEventRequests() {

        createDefaultVMDeathRequest();

        createDefaultExceptionRequest();

    }

    /**

     * We want the BE to stop when it issues a VMDeathEvent in order to

     * give the FE time to complete handling events that occured before

     * the VMDeath.  When we get the VMDeathEvent for this request in

     * the listener in connect(), we will do a resume.

     * If a testcase wants to do something special with VMDeathEvent's,

     * then it should override this method with an empty method or

     * whatever in order to suppress the automatic resume.  The testcase

     * will then be responsible for the handling of VMDeathEvents.  It

     * has to be sure that it does a resume if it gets a VMDeathEvent

     * with SUSPEND_ALL, and it has to be sure that it doesn't do a

     * resume after getting a VMDeath with SUSPEND_NONE (the automatically

     * generated VMDeathEvent.)

     */

    protected void createDefaultVMDeathRequest() {

        ourVMDeathRequest = requestManager.createVMDeathRequest();

        ourVMDeathRequest.setSuspendPolicy(EventRequest.SUSPEND_ALL);

        ourVMDeathRequest.enable();

    }

    /**

     * This will allow us to print a warning if a debuggee gets an

     * unexpected exception.  The unexpected exception will be handled in

     * the exceptionThrown method in the listener created in the connect()

     * method.

     * If a testcase does not want an uncaught exception to cause a

     * msg, it must override this method.

     */

    protected void createDefaultExceptionRequest() {

        ourExceptionRequest = requestManager.createExceptionRequest(null,

                                                                false, true);

        // We can't afford to make this be other than SUSPEND_NONE.  Otherwise,

        // it would have to be resumed.  If our connect() listener resumes it,

        // what about the case where the EventSet contains other events with

        // SUSPEND_ALL and there are other listeners who expect the BE to still

        // be suspended when their handlers get called?

        ourExceptionRequest.setSuspendPolicy(EventRequest.SUSPEND_NONE);

        ourExceptionRequest.enable();

    }

    private class EventHandler implements Runnable {

        EventHandler() {

            Thread thread = new Thread(this);

            thread.setDaemon(true);

            thread.start();

        }

        private void notifyEvent(TargetListener listener, Event event) {

            if (event instanceof BreakpointEvent) {

                listener.breakpointReached((BreakpointEvent)event);

            } else if (event instanceof ExceptionEvent) {

                listener.exceptionThrown((ExceptionEvent)event);

            } else if (event instanceof StepEvent) {

                listener.stepCompleted((StepEvent)event);

            } else if (event instanceof ClassPrepareEvent) {

                listener.classPrepared((ClassPrepareEvent)event);

            } else if (event instanceof ClassUnloadEvent) {

                listener.classUnloaded((ClassUnloadEvent)event);

            } else if (event instanceof MethodEntryEvent) {

                listener.methodEntered((MethodEntryEvent)event);

            } else if (event instanceof MethodExitEvent) {

                listener.methodExited((MethodExitEvent)event);

            } else if (event instanceof MonitorContendedEnterEvent) {

                listener.monitorContendedEnter((MonitorContendedEnterEvent)event);

            } else if (event instanceof MonitorContendedEnteredEvent) {

                listener.monitorContendedEntered((MonitorContendedEnteredEvent)event);

            } else if (event instanceof MonitorWaitEvent) {

                listener.monitorWait((MonitorWaitEvent)event);

            } else if (event instanceof MonitorWaitedEvent) {

                listener.monitorWaited((MonitorWaitedEvent)event);

            } else if (event instanceof AccessWatchpointEvent) {

                listener.fieldAccessed((AccessWatchpointEvent)event);

            } else if (event instanceof ModificationWatchpointEvent) {

                listener.fieldModified((ModificationWatchpointEvent)event);

            } else if (event instanceof ThreadStartEvent) {

                listener.threadStarted((ThreadStartEvent)event);

            } else if (event instanceof ThreadDeathEvent) {

                listener.threadDied((ThreadDeathEvent)event);

            } else if (event instanceof VMStartEvent) {

                listener.vmStarted((VMStartEvent)event);

            } else if (event instanceof VMDeathEvent) {

                listener.vmDied((VMDeathEvent)event);

            } else if (event instanceof VMDisconnectEvent) {

                listener.vmDisconnected((VMDisconnectEvent)event);

            } else {

                throw new InternalError("Unknown event type: " + event.getClass());

            }

        }

        private void traceSuspendPolicy(int policy) {

            if (shouldTrace) {

                switch (policy) {

                case EventRequest.SUSPEND_NONE:

                    traceln("TS: eventHandler: suspend = SUSPEND_NONE");

                    break;

                case EventRequest.SUSPEND_ALL:

                    traceln("TS: eventHandler: suspend = SUSPEND_ALL");

                    break;

                case EventRequest.SUSPEND_EVENT_THREAD:

                    traceln("TS: eventHandler: suspend = SUSPEND_EVENT_THREAD");

                    break;

                }

            }

        }

        public void run() {

            boolean connected = true;

            do {

                try {

                    EventSet set = vm.eventQueue().remove();

                    traceSuspendPolicy(set.suspendPolicy());

                    synchronized (listeners) {

                        ListIterator iter = listeners.listIterator();

                        while (iter.hasNext()) {

                            TargetListener listener = (TargetListener)iter.next();

                            traceln("TS: eventHandler: listener = " + listener);

                            listener.eventSetReceived(set);

                            if (listener.shouldRemoveListener()) {

                                iter.remove();

                            } else {

                                Iterator jter = set.iterator();

                                while (jter.hasNext()) {

                                    Event event = (Event)jter.next();

                                    traceln("TS: eventHandler:    event = " + event.getClass());

                                    if (event instanceof VMDisconnectEvent) {

                                        connected = false;

                                    }

                                    listener.eventReceived(event);

                                    if (listener.shouldRemoveListener()) {

                                        iter.remove();

                                        break;

                                    }

                                    notifyEvent(listener, event);

                                    if (listener.shouldRemoveListener()) {

                                        iter.remove();

                                        break;

                                    }

                                }

                                traceln("TS: eventHandler:   end of events loop");

                                if (!listener.shouldRemoveListener()) {

                                    traceln("TS: eventHandler:   calling ESC");

                                    listener.eventSetComplete(set);

                                    if (listener.shouldRemoveListener()) {

                                        iter.remove();

                                    }

                                }

                            }

                            traceln("TS: eventHandler: end of listeners loop");

                        }

                    }

                } catch (InterruptedException e) {

                    traceln("TS: eventHandler: InterruptedException");

                } catch (Exception e) {

                    failure("FAILED: Exception occured in eventHandler: " + e);

                    e.printStackTrace();

                    connected = false;

                    synchronized(TestScaffold.this) {

                        // This will make the waiters such as waitForVMDisconnect

                        // exit their wait loops.

                        vmDisconnected = true;

                        TestScaffold.this.notifyAll();

                    }

                }

                traceln("TS: eventHandler: End of outerloop");

            } while (connected);

            traceln("TS: eventHandler: finished");

        }

    }

    /**

     * Constructor

     */

    public TestScaffold(String[] args) {

        this.args = args;

    }

    public void enableScaffoldTrace() {

        this.shouldTrace = true;

    }

    public void disableScaffoldTrace() {

        this.shouldTrace = false;

    }

    /**

     * Helper for the redefine method.  Build the map

     * needed for a redefine.

     */

    protected Map makeRedefineMap(ReferenceType rt) throws Exception {

        String className = rt.name();

        File path = new File(System.getProperty("test.classes", "."));

        className = className.replace('.', File.separatorChar);

        File phyl = new File(path, className + ".class");

        byte[] bytes = new byte[(int)phyl.length()];

        InputStream in = new FileInputStream(phyl);

        in.read(bytes);

        in.close();

        Map map = new HashMap();

        map.put(rt, bytes);

        return map;

    }

    /**

     * Redefine a class - HotSwap it

     */

    protected void redefine(ReferenceType rt) {

        try {

            println("Redefining " + rt);

            vm().redefineClasses(makeRedefineMap(rt));

        } catch (Exception exc) {

            failure("FAIL: redefine - unexpected exception: " + exc);

        }

    }

    protected void startUp(String targetName) {

        List argList = new ArrayList(Arrays.asList(args));

        argList.add(targetName);

        println("run args: " + argList);

        connect((String[]) argList.toArray(args));

        waitForVMStart();

    }

    protected BreakpointEvent startToMain(String targetName) {

        return startTo(targetName, "main", "([Ljava/lang/String;)V");

    }

    protected BreakpointEvent startTo(String targetName,

                                      String methodName, String signature) {

        startUp(targetName);

        traceln("TS: back from startUp");

        BreakpointEvent bpr = resumeTo(targetName, methodName,

                                       signature);

        Location loc = bpr.location();

        mainStartClass = loc.declaringType();

        if (redefineAtStart) {

            redefine(mainStartClass);

        }

        if (redefineAsynchronously) {

            Thread asyncDaemon = new Thread("Async Redefine") {

                public void run() {

                    try {

                        Map redefMap = makeRedefineMap(mainStartClass);

                        while (true) {

                            println("Redefining " + mainStartClass);

                            vm().redefineClasses(redefMap);

                            Thread.sleep(100);

                        }

                    } catch (VMDisconnectedException vmde) {

                        println("async redefine - VM disconnected");

                    } catch (Exception exc) {

                        failure("FAIL: async redefine - unexpected exception: " + exc);

                    }

                }

            };

            asyncDaemon.setDaemon(true);

            asyncDaemon.start();

        }

        if (System.getProperty("jpda.wait") != null) {

            waitForInput();

        }

        return bpr;

    }

    protected void waitForInput() {

        try {

            System.err.println("Press <enter> to continue");

            System.in.read();

            System.err.println("running...");

        } catch(Exception e) {

        }

    }

    /*

     * Test cases should implement tests in runTests and should

     * initiate testing by calling run().

     */

    abstract protected void runTests() throws Exception;

    final public void startTests() throws Exception {

        try {

            runTests();

        } finally {

            shutdown();

        }

    }

    protected void println(String str) {

        System.err.println(str);

    }

    protected void print(String str) {

        System.err.print(str);

    }

    protected void traceln(String str) {

        if (shouldTrace) {

            println(str);

        }

    }

    protected void failure(String str) {

        println(str);

        testFailed = true;

    }

    private ArgInfo parseArgs(String args[]) {

        ArgInfo argInfo = new ArgInfo();

        for (int i = 0; i < args.length; i++) {

            if (args[i].equals("-connect")) {

                i++;

                argInfo.connectorSpec = args[i];

            } else if (args[i].equals("-trace")) {

                i++;

                argInfo.traceFlags = Integer.decode(args[i]).intValue();

            } else if (args[i].equals("-redefstart")) {

                redefineAtStart = true;

            } else if (args[i].equals("-redefevent")) {

                redefineAtEvents = true;

            } else if (args[i].equals("-redefasync")) {

                redefineAsynchronously = true;

            } else if (args[i].startsWith("-J")) {

                argInfo.targetVMArgs += (args[i].substring(2) + ' ');

                /*

                 * classpath can span two arguments so we need to handle

                 * it specially.

                 */

                if (args[i].equals("-J-classpath")) {

                    i++;

                    argInfo.targetVMArgs += (args[i] + ' ');

                }

            } else {

                argInfo.targetAppCommandLine += (args[i] + ' ');

            }

        }

        return argInfo;

    }

    /**

     * This is called to connect to a debuggee VM.  It starts the VM and

     * installs a listener to catch VMStartEvent, our default events, and

     * VMDisconnectedEvent.  When these events appear, that is remembered

     * and waiters are notified.

     * This is normally called in the main thread of the test case.

     * It starts up an EventHandler thread that gets events coming in

     * from the debuggee and distributes them to listeners.  That thread

     * keeps running until a VMDisconnectedEvent occurs or some exception

     * occurs during its processing.

     *

     * The 'listenUntilVMDisconnect' method adds 'this' as a listener.

     * This means that 'this's vmDied method will get called.  This has a

     * default impl in TargetAdapter.java which can be overridden in the

     * testcase.

     *

     * waitForRequestedEvent also adds an adaptor listener that listens

     * for the particular event it is supposed to wait for (and it also

     * catches VMDisconnectEvents.)  This listener is removed once

     * its eventReceived method is called.

     * waitForRequestedEvent is called by most of the methods to do bkpts,

     * etc.

     */

    public void connect(String args[]) {

        ArgInfo argInfo = parseArgs(args);

        argInfo.targetVMArgs += VMConnection.getDebuggeeVMOptions();

        connection = new VMConnection(argInfo.connectorSpec,

                                      argInfo.traceFlags);

        addListener(new TargetAdapter() {

                public void eventSetComplete(EventSet set) {

                    if (TestScaffold.this.containsOurVMDeathRequest(set)) {

                        traceln("TS: connect: set.resume() called");

                        set.resume();

                        // Note that we want to do the above resume before

                        // waking up any sleepers.

                        synchronized(TestScaffold.this) {

                            TestScaffold.this.notifyAll();

                        }

                    }