/*******************************************************************************
* Copyright (c) 2009, 2013 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.wst.jsdt.debug.rhino.tests;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import junit.framework.TestCase;
import org.eclipse.wst.jsdt.debug.core.jsdi.VirtualMachine;
import org.eclipse.wst.jsdt.debug.internal.rhino.debugger.RhinoDebuggerImpl;
import org.eclipse.wst.jsdt.debug.internal.rhino.transport.EventPacket;
import org.eclipse.wst.jsdt.debug.internal.rhino.transport.JSONConstants;
import org.eclipse.wst.jsdt.debug.internal.rhino.transport.PipedTransportService;
import org.eclipse.wst.jsdt.debug.internal.rhino.transport.RhinoRequest;
import org.eclipse.wst.jsdt.debug.rhino.tests.TestEventHandler.Subhandler;
import org.eclipse.wst.jsdt.debug.transport.DebugSession;
import org.eclipse.wst.jsdt.debug.transport.TransportService;
import org.eclipse.wst.jsdt.debug.transport.exception.DisconnectedException;
import org.eclipse.wst.jsdt.debug.transport.exception.TimeoutException;
import org.eclipse.wst.jsdt.debug.transport.packet.Response;
import org.mozilla.javascript.Context;
import org.mozilla.javascript.ContextFactory;
import org.mozilla.javascript.Scriptable;
/**
* Abstract test for making requests
*
* @since 1.0
*/
public abstract class RequestTest extends TestCase {
/**
* Default implementation of a {@link Subhandler}
*/
abstract class SubHandler implements Subhandler {
private String testname = null;
public SubHandler(String testname) {
assertNotNull("The test name cannot be null", testname); //$NON-NLS-1$
this.testname = testname;
}
/* (non-Javadoc)
* @see org.eclipse.wst.jsdt.debug.rhino.tests.TestEventHandler.Subhandler#testName()
*/
public String testName() {
return this.testname;
}
}
/**
* Handler to check that we can get frames from a suspended thread
* @since 1.1
*/
final class FrameCheckHandler extends SubHandler {
/**
* Constructor
* @param testname
*/
public FrameCheckHandler() {
super(getName());
}
/* (non-Javadoc)
* @see org.eclipse.wst.jsdt.debug.rhino.tests.TestEventHandler.Subhandler#handleEvent(org.eclipse.wst.jsdt.debug.transport.DebugSession, org.eclipse.wst.jsdt.debug.internal.rhino.transport.EventPacket)
*/
public boolean handleEvent(DebugSession debugSession, EventPacket event) {
if (event.getEvent().equals(JSONConstants.BREAK)) {
Number threadId = (Number) event.getBody().get(JSONConstants.THREAD_ID);
Number contextId = (Number) event.getBody().get(JSONConstants.CONTEXT_ID);
RhinoRequest request = new RhinoRequest(JSONConstants.FRAMES);
request.getArguments().put(JSONConstants.THREAD_ID, threadId);
try {
debugSession.send(request);
Response response = debugSession.receiveResponse(request.getSequence(), VirtualMachine.DEFAULT_TIMEOUT);
assertTrue(testName()+": the request for frames from thread ["+threadId.intValue()+"] was not successful", response.isSuccess()); //$NON-NLS-1$ //$NON-NLS-2$
Collection frames = (Collection) response.getBody().get(JSONConstants.FRAMES);
for (Iterator iterator = frames.iterator(); iterator.hasNext();) {
Number frameId = (Number) iterator.next();
request = new RhinoRequest(JSONConstants.FRAME);
request.getArguments().put(JSONConstants.THREAD_ID, threadId);
request.getArguments().put(JSONConstants.CONTEXT_ID, contextId);
request.getArguments().put(JSONConstants.FRAME_ID, frameId);
debugSession.send(request);
response = debugSession.receiveResponse(request.getSequence(), VirtualMachine.DEFAULT_TIMEOUT);
assertTrue(testName()+": the request for frame ["+frameId.intValue()+"] frmo thread ["+threadId.intValue()+"] was not successful", response.isSuccess()); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
} catch (DisconnectedException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
return true;
}
return false;
}
}
/**
* Handler to check that the thread returned when suspended is the same thread
* from the break event
* @since 1.1
*/
final class ThreadCheckHandler extends SubHandler {
/**
* Constructor
*/
public ThreadCheckHandler() {
super(getName());
}
/* (non-Javadoc)
* @see org.eclipse.wst.jsdt.debug.rhino.tests.TestEventHandler.Subhandler#handleEvent(org.eclipse.wst.jsdt.debug.transport.DebugSession, org.eclipse.wst.jsdt.debug.internal.rhino.transport.EventPacket)
*/
public boolean handleEvent(DebugSession debugSession, EventPacket event) {
if (event.getEvent().equals(JSONConstants.BREAK)) {
Number threadId = (Number) event.getBody().get(JSONConstants.THREAD_ID);
RhinoRequest request = new RhinoRequest(JSONConstants.THREADS);
try {
debugSession.send(request);
Response response = debugSession.receiveResponse(request.getSequence(), 10000);
assertTrue(response.isSuccess());
List threads = (List) response.getBody().get(JSONConstants.THREADS);
assertTrue(testName()+": the listing of threads must not be empty", threads.size() > 0); //$NON-NLS-1$
assertEquals(testName()+": the thread ids do not match", threadId.intValue(), Util.numberAsInt(threads.get(0))); //$NON-NLS-1$
} catch (DisconnectedException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
return true;
}
return false;
}
}
/**
* Handler for setting breakpoints on all executable lines in a loaded script
* @since 1.1
*/
final class SetBreakpointsHandler extends SubHandler {
/**
* Constructor
*/
public SetBreakpointsHandler() {
super(getName());
}
/* (non-Javadoc)
* @see org.eclipse.wst.jsdt.debug.rhino.tests.TestEventHandler.Subhandler#handleEvent(org.eclipse.wst.jsdt.debug.transport.DebugSession, org.eclipse.wst.jsdt.debug.internal.rhino.transport.EventPacket)
*/
public boolean handleEvent(DebugSession debugSession, EventPacket event) {
if (event.getEvent().equals(JSONConstants.SCRIPT)) {
Number scriptId = (Number) event.getBody().get(JSONConstants.SCRIPT_ID);
RhinoRequest request = new RhinoRequest(JSONConstants.SCRIPT);
request.getArguments().put(JSONConstants.SCRIPT_ID, scriptId);
try {
debugSession.send(request);
Response response = debugSession.receiveResponse(request.getSequence(), VirtualMachine.DEFAULT_TIMEOUT);
assertTrue(response.isSuccess());
Map result = (Map) response.getBody().get(JSONConstants.SCRIPT);
// line numbers
List lineNumbers = (List) result.get(JSONConstants.LINES);
for (Iterator iterator = lineNumbers.iterator(); iterator.hasNext();) {
Number lineNumber = (Number) iterator.next();
request = new RhinoRequest(JSONConstants.SETBREAKPOINT);
request.getArguments().put(JSONConstants.SCRIPT_ID, scriptId);
request.getArguments().put(JSONConstants.LINE, lineNumber);
request.getArguments().put(JSONConstants.CONDITION, "1===1"); //$NON-NLS-1$
debugSession.send(request);
response = debugSession.receiveResponse(request.getSequence(), VirtualMachine.DEFAULT_TIMEOUT);
assertTrue(testName()+": the request to set a breakpoint on line ["+lineNumber+"] was not successful", response.isSuccess()); //$NON-NLS-1$ //$NON-NLS-2$
Map breakpoint = (Map) response.getBody().get(JSONConstants.BREAKPOINT);
Number breakpointId = (Number) breakpoint.get(JSONConstants.BREAKPOINT_ID);
request = new RhinoRequest(JSONConstants.BREAKPOINT);
request.getArguments().put(JSONConstants.BREAKPOINT_ID, breakpointId);
debugSession.send(request);
response = debugSession.receiveResponse(request.getSequence(), VirtualMachine.DEFAULT_TIMEOUT);
assertTrue(response.isSuccess());
breakpoint = (Map) response.getBody().get(JSONConstants.BREAKPOINT);
assertEquals(breakpointId.intValue(), Util.numberAsInt(breakpoint.get(JSONConstants.BREAKPOINT_ID)));
assertEquals(scriptId.intValue(), Util.numberAsInt(breakpoint.get(JSONConstants.SCRIPT_ID)));
assertEquals(lineNumber.intValue(), Util.numberAsInt(breakpoint.get(JSONConstants.LINE)));
assertEquals("1===1", breakpoint.get(JSONConstants.CONDITION)); //$NON-NLS-1$
}
} catch (DisconnectedException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
return true;
}
return false;
}
}
/**
* Handler to set breakpoints on a given set of lines. The lines are not checked
* to see if they are valid.
*
* @since 1.1
*/
final class SetBreakpointHandler extends SubHandler {
int[] adds = null;
/**
* Constructor
* @param lines <code>null</code> is not accepted, not is an empty array
*/
public SetBreakpointHandler(int[] lines) {
super(getName());
assertNotNull(testName()+": no line numbers have been specified to set breakpoints on", lines); //$NON-NLS-1$
assertTrue(testName()+": no line numbers have been specified to set breakpoints on", lines.length > 0); //$NON-NLS-1$
this.adds = lines;
}
/* (non-Javadoc)
* @see org.eclipse.wst.jsdt.debug.rhino.tests.TestEventHandler.Subhandler#handleEvent(org.eclipse.wst.jsdt.debug.transport.DebugSession, org.eclipse.wst.jsdt.debug.internal.rhino.transport.EventPacket)
*/
public boolean handleEvent(DebugSession debugSession, EventPacket event) {
if (event.getEvent().equals(JSONConstants.SCRIPT)) {
Number scriptId = (Number) event.getBody().get(JSONConstants.SCRIPT_ID);
RhinoRequest request = new RhinoRequest(JSONConstants.SCRIPT);
request.getArguments().put(JSONConstants.SCRIPT_ID, scriptId);
try {
debugSession.send(request);
Response response = debugSession.receiveResponse(request.getSequence(), VirtualMachine.DEFAULT_TIMEOUT);
assertTrue(response.isSuccess());
Map script = (Map) response.getBody().get(JSONConstants.SCRIPT);
assertNotNull(testName()+": the response body cannot be null", script); //$NON-NLS-1$
for (int i = 0; i < adds.length; i++) {
request = new RhinoRequest(JSONConstants.SETBREAKPOINT);
request.getArguments().put(JSONConstants.SCRIPT_ID, scriptId);
request.getArguments().put(JSONConstants.LINE, new Integer(adds[i]));
debugSession.send(request);
response = debugSession.receiveResponse(request.getSequence(), VirtualMachine.DEFAULT_TIMEOUT);
assertTrue(testName()+": the request to set a breakpoint on line ["+adds[i]+"] was not successful", response.isSuccess()); //$NON-NLS-1$ //$NON-NLS-2$
}
} catch (DisconnectedException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
return true;
}
return false;
}
}
/**
* Clears all of the breakpoints that are hit
*
* @since 1.1
*/
final class ClearBreakpointsHandler extends SubHandler {
/**
* Constructor
*/
public ClearBreakpointsHandler() {
super(getName());
}
/* (non-Javadoc)
* @see org.eclipse.wst.jsdt.debug.rhino.tests.TestEventHandler.Subhandler#handleEvent(org.eclipse.wst.jsdt.debug.transport.DebugSession, org.eclipse.wst.jsdt.debug.internal.rhino.transport.EventPacket)
*/
public boolean handleEvent(DebugSession debugSession, EventPacket event) {
if (event.getEvent().equals(JSONConstants.BREAK)) {
Number bid = (Number)event.getBody().get(JSONConstants.BREAKPOINT);
if(bid == null && JSONConstants.STEP_OUT.equals(event.getBody().get(JSONConstants.STEP))) {
return false;
}
RhinoRequest request = new RhinoRequest(JSONConstants.CLEARBREAKPOINT);
request.getArguments().put(JSONConstants.BREAKPOINT_ID, bid);
try {
debugSession.send(request);
Response response = debugSession.receiveResponse(request.getSequence(), VirtualMachine.DEFAULT_TIMEOUT);
assertTrue(testName()+": the request to clear breakpoint ["+bid+"] should have succeeded", response.isSuccess()); //$NON-NLS-1$ //$NON-NLS-2$
return true;
} catch (DisconnectedException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
}
return false;
}
}
protected RhinoDebuggerImpl debugger;
protected DebugSession debugSession;
protected TestEventHandler eventHandler;
protected ContextFactory contextFactory;
private static boolean tracing = false;
/**
* Turns on tracing for the test. All testing event handlers use this.
*/
protected void useTracing() {
tracing = true;
}
/**
* Turns off tracing. This method is called on every {@link #tearDown()} invocation.
*/
protected void disableTracing() {
tracing = false;
}
/**
* Returns if tracing is enabled
*
* @return if tracing is enabled
*/
public static boolean isTracing() {
return tracing;
}
/**
* Evaluates the given script source
* @param script
* @since 1.1
*/
protected void evalScript(String script) {
Scriptable scope = null;
Context context = contextFactory.enterContext();
try {
scope = context.initStandardObjects();
context.evaluateString(scope, script, JSONConstants.SCRIPT, 0, null);
} finally {
Context.exit();
}
}
/**
* Evaluates the given script source and waits for the given number of events
* @param script
* @param eventcount
* @since 1.1
*/
protected void evalScript(String script, int eventcount) {
evalScript(script);
waitForEvents(eventcount);
}
/**
* Evaluates the given script and waits for the specific events to be received
* @param script
* @param events
* @since 1.1
*/
protected void evalScript(String script, EventPacket[] events) {
evalScript(script);
waitForEvents(events);
}
/* (non-Javadoc)
* @see junit.framework.TestCase#setUp()
*/
protected void setUp() throws Exception {
TransportService pipedTransport = new PipedTransportService();
ConnectionHelper helper = new ConnectionHelper(pipedTransport, null);
debugger = new RhinoDebuggerImpl(pipedTransport, null, false, false);
debugger.start();
debugSession = new DebugSession(helper.getClientConnection());
eventHandler = new TestEventHandler(debugSession, getName());
eventHandler.start();
assertTrue(suspendForRuntime(debugger, 100));
contextFactory = new ContextFactory();
contextFactory.addListener(debugger);
super.setUp();
}
/**
* Suspend waiting for the debugger to have a connected session
*
* @param debug the debugger to poll for a session connection
* @param timeout the amount of time to wait
* @return true when a {@link DebugSession} has connected
*/
public synchronized boolean suspendForRuntime(RhinoDebuggerImpl debug, long timeout) {
while (!debug.isConnected())
try {
wait(timeout);
} catch (InterruptedException e) {
e.printStackTrace();
}
return debug.isConnected();
}
/* (non-Javadoc)
* @see junit.framework.TestCase#tearDown()
*/
protected void tearDown() throws Exception {
disableTracing();
super.tearDown();
contextFactory.removeListener(debugger);
eventHandler.stop();
debugger.stop();
debugSession.dispose();
}
/**
* Forces the backing event handler to block until the given number of events have been
* received or a timeout occurs.
*
* @param count the event count to wait for
*/
synchronized void waitForEvents(int count) {
eventHandler.waitForEvents(count);
}
/**
* Sets the collection of specific events we are expecting to handle
*
* @param events the collection of events
*/
synchronized void setExpectedEvents(EventPacket[] events) {
eventHandler.setExpectedEvents(events);
}
/**
* Forces the backing event handler to block until the given number of events have been
* received or a timeout occurs.
*
* @param events the specific set of events expected
* @see #setExpectedEvents(EventPacket[])
*/
synchronized void waitForEvents(EventPacket[] events) {
eventHandler.waitForEvents(events);
}
/**
* @param props
* @param varname
* @return the variable map or <code>null</code>
*/
protected Map findVar(List props, String varname) {
if(props != null && varname != null) {
Map prop = null;
for (Iterator i = props.iterator(); i.hasNext();) {
prop = (Map) i.next();
if(varname.equals(prop.get(JSONConstants.NAME))) {
return prop;
}
}
}
return null;
}
/**
* @param session
* @param threadid
* @param contextid
* @param frameid
* @param refid
* @return the response, never <code>null</code>
*/
protected Response doLookup(DebugSession session, Number threadid, Number contextid, Number frameid, Number refid) throws Exception {
RhinoRequest request = new RhinoRequest(JSONConstants.LOOKUP);
request.getArguments().put(JSONConstants.THREAD_ID, threadid);
request.getArguments().put(JSONConstants.CONTEXT_ID, contextid);
request.getArguments().put(JSONConstants.FRAME_ID, frameid);
request.getArguments().put(JSONConstants.REF, refid);
debugSession.send(request);
return debugSession.receiveResponse(request.getSequence(), VirtualMachine.DEFAULT_TIMEOUT);
}
}