/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.harmony.jpda.tests.jdwp.DebuggerOnDemand;
import org.apache.harmony.jpda.tests.framework.LogWriter;
import org.apache.harmony.jpda.tests.framework.TestErrorException;
import org.apache.harmony.jpda.tests.framework.jdwp.CommandPacket;
import org.apache.harmony.jpda.tests.framework.jdwp.JDWPCommands;
import org.apache.harmony.jpda.tests.framework.jdwp.JDWPConstants;
import org.apache.harmony.jpda.tests.framework.jdwp.Location;
import org.apache.harmony.jpda.tests.framework.jdwp.ReplyPacket;
import org.apache.harmony.jpda.tests.jdwp.share.JDWPTestCase;
import org.apache.harmony.jpda.tests.jdwp.share.JDWPUnitDebuggeeWrapper;
import org.apache.harmony.jpda.tests.share.JPDADebuggeeSynchronizer;
import org.apache.harmony.jpda.tests.share.JPDATestOptions;
/**
* Base class for debuggers that are used in tests for DebuggerOnDemand functionality.
*/
public abstract class LaunchedDebugger extends JDWPTestCase {
// synchronization channel between debugger and debuggee
protected JPDADebuggeeSynchronizer synchronizer;
// synchronization channel between debugger and test
protected JPDADebuggeeSynchronizer testSynchronizer;
// name of tested debuggee class
public static final String DEBUGGEE_CLASS_NAME =
"org/apache/harmony/jpda/tests/jdwp/DebuggerOnDemand/OnthowDebuggerLaunchDebuggee";
// signature of the tested debuggee class
public static final String DEBUGGEE_CLASS_SIGNATURE = "L" + DEBUGGEE_CLASS_NAME + ";";
/**
* This method is invoked right before attaching to debuggee VM.
* It forces to use attaching connector and fixed transport address.
*/
/*
protected void beforeDebuggeeStart(JDWPOnDemandDebuggeeWrapper debugeeWrapper) {
settings.setAttachConnectorKind();
if (settings.getTransportAddress() == null) {
settings.setTransportAddress(JPDADebuggerOnDemandOptions.DEFAULT_ATTACHING_ADDRESS);
}
logWriter.println("DEBUGGER: Use ATTACH connector kind");
super.beforeDebuggeeStart(debuggeeWrapper);
}
*/
/**
* Overrides inherited method to resume debuggee VM and then to establish
* sync connection with debuggee and server.
*/
protected void internalSetUp() throws Exception {
// estabslish synch connection with test
logWriter.println("Establish synch connection between debugger and test");
JPDADebuggerOnDemandOptions debuggerSettings = new JPDADebuggerOnDemandOptions();
testSynchronizer = new JPDADebuggerOnDemandSynchronizer(logWriter, debuggerSettings);
testSynchronizer.startClient();
logWriter.println("Established synch connection between debugger and test");
// handle JDWP connection with debuggee
super.internalSetUp();
// establish synch connection with debuggee
logWriter.println("Establish synch connection between debugger and debuggee");
synchronizer = new JPDADebuggeeSynchronizer(logWriter, settings);;
synchronizer.startClient();
logWriter.println("Established synch connection between debugger and debuggee");
}
/**
* Creates wrapper for debuggee process.
*/
protected JDWPUnitDebuggeeWrapper createDebuggeeWrapper() {
return new JPDADebuggerOnDemandDebuggeeWrapper(settings, logWriter);
}
/**
* Receives initial EXCEPTION event if debuggee is suspended on event.
*/
protected void receiveInitialEvent() {
if (settings.isDebuggeeSuspend()) {
initialEvent =
debuggeeWrapper.vmMirror.receiveCertainEvent(JDWPConstants.EventKind.EXCEPTION);
logWriter.println("Received inital EXCEPTION event");
debuggeeWrapper.resume();
logWriter.println("Resumed debuggee VM");
}
}
/**
* Overrides inherited method to close sync connection upon exit.
*/
protected void internalTearDown() {
// close synch connection with debuggee
if (synchronizer != null) {
synchronizer.stop();
logWriter.println("Closed synch connection between debugger and debuggee");
}
// close synch connection with test
if (testSynchronizer != null) {
testSynchronizer.stop();
logWriter.println("Closed synch connection between debugger and test");
}
// close connections with debuggee
super.internalTearDown();
}
protected String getDebuggeeClassName() {
return null;
}
///////////////////////////////////////////////////////////////////
/**
* This class contains information about frame of a java thread.
*/
public class FrameInfo {
long frameID;
Location location;
public FrameInfo(long frameID, Location location) {
super();
this.frameID = frameID;
this.location = location;
}
/**
* @return Returns the frameID.
*/
public long getFrameID() {
return frameID;
}
/**
* @return Returns the location.
*/
public Location getLocation() {
return location;
}
}
protected FrameInfo[] jdwpGetFrames(long threadID, int startFrame, int length) {
CommandPacket packet = new CommandPacket(
JDWPCommands.ThreadReferenceCommandSet.CommandSetID,
JDWPCommands.ThreadReferenceCommandSet.FramesCommand);
packet.setNextValueAsThreadID(threadID);
packet.setNextValueAsInt(startFrame);
packet.setNextValueAsInt(length);
ReplyPacket reply = debuggeeWrapper.vmMirror.performCommand(packet);
if (!checkReplyPacketWithoutFail(reply, "ThreadReference::FramesCommand command")) {
throw new TestErrorException("Error during performing ThreadReference::Frames command");
}
int frames = reply.getNextValueAsInt();
FrameInfo[] frameInfos = new FrameInfo[frames];
for (int i = 0; i < frames; i++) {
long frameID = reply.getNextValueAsLong();
Location location = reply.getNextValueAsLocation();
frameInfos[i] = new FrameInfo(frameID, location);
}
return frameInfos;
}
protected long getClassIDBySignature(String signature) {
logWriter.println("=> Getting reference type ID for class: " + signature);
CommandPacket packet = new CommandPacket(
JDWPCommands.VirtualMachineCommandSet.CommandSetID,
JDWPCommands.VirtualMachineCommandSet.ClassesBySignatureCommand);
packet.setNextValueAsString(signature);
ReplyPacket reply = debuggeeWrapper.vmMirror.performCommand(packet);
if (!checkReplyPacketWithoutFail(reply, "VirtualMachine::ClassesBySignature command")) {
throw new TestErrorException("Error during performing VirtualMachine::ClassesBySignature command");
}
int classes = reply.getNextValueAsInt();
logWriter.println("=> Returned number of classes: " + classes);
long classID = 0;
for (int i = 0; i < classes; i++) {
reply.getNextValueAsByte();
classID = reply.getNextValueAsReferenceTypeID();
reply.getNextValueAsInt();
// we need the only class, even if there were multiply ones
break;
}
assertTrue("VirtualMachine::ClassesBySignature command returned invalid classID:<" +
classID + "> for signature " + signature, classID > 0);
return classID;
}
protected void printStackFrame(int NumberOfFrames, FrameInfo[] frameInfos) {
for (int i = 0; i < NumberOfFrames; i++) {
logWriter.println(" ");
logWriter
.println("=> #" + i + " frameID=" + frameInfos[i].frameID);
String methodName = "";
try {
methodName = getMethodName(frameInfos[i].location.classID,
frameInfos[i].location.methodID);
} catch (TestErrorException e) {
throw new TestErrorException(e);
}
logWriter.println("=> method name=" + methodName);
}
logWriter.println(" ");
}
protected String getMethodName(long classID, long methodID) {
CommandPacket packet = new CommandPacket(
JDWPCommands.ReferenceTypeCommandSet.CommandSetID,
JDWPCommands.ReferenceTypeCommandSet.MethodsCommand);
packet.setNextValueAsClassID(classID);
ReplyPacket reply = debuggeeWrapper.vmMirror.performCommand(packet);
if (!checkReplyPacketWithoutFail(reply, "ReferenceType::Methods command")) {
throw new TestErrorException("Error during performing ReferenceType::Method command");
}
int methods = reply.getNextValueAsInt();
for (int i = 0; i < methods; i++) {
long mid = reply.getNextValueAsMethodID();
String name = reply.getNextValueAsString();
reply.getNextValueAsString();
reply.getNextValueAsInt();
if (mid == methodID) {
return name;
}
}
return "unknown";
}
//////////////////////////////////////////////////////////////////////////////////////
/**
* This class provides functionality to establish synch connection between debugger and test.
*/
protected static class JPDADebuggerOnDemandSynchronizer extends JPDADebuggeeSynchronizer {
public JPDADebuggerOnDemandSynchronizer(LogWriter logWriter, JPDADebuggerOnDemandOptions settings) {
super(logWriter, settings);
this.settings = settings;
}
public int getSyncPortNumber() {
return ((JPDADebuggerOnDemandOptions)settings).getSyncDebuggerPortNumber();
}
}
/**
* This class provides customization of DebuggeeWrapper that attaches to already launched debuggee.
*/
protected static class JPDADebuggerOnDemandDebuggeeWrapper extends JDWPUnitDebuggeeWrapper {
public JPDADebuggerOnDemandDebuggeeWrapper(JPDATestOptions settings, LogWriter logWriter) {
super(settings, logWriter);
}
/**
* Attaches to already launched debuggee process and
* establishes JDWP connection.
*/
public void start() {
try {
transport = createTransportWrapper();
openConnection();
logWriter.println("Established connection");
} catch (Exception e) {
throw new TestErrorException(e);
}
}
/**
* Closes all connections but does not wait for debuggee process to exit.
*/
public void stop() {
disposeConnection();
closeConnection();
}
}
/**
* This class provides additional options to debuggers, that are used in DebuggerOnDemand tests.
* Currently the following additional options are supported:
* <ul>
* <li><i>jpda.settings.syncDebuggerPort</i>
* - port number for sync connection between debugger and test
* </ul>
*
*/
protected static class JPDADebuggerOnDemandOptions extends JPDATestOptions {
public static final String DEFAULT_SYNC_DEBUGGER_PORT = "9899";
/**
* Returns port number string for sync connection between debugger and test.
*/
public String getSyncDebuggerPortString() {
return getProperty("jpda.settings.syncDebuggerPort", null);
}
/**
* Returns port number for sync connection between debugger and test.
*/
public int getSyncDebuggerPortNumber() {
String buf = getSyncDebuggerPortString();
if (buf == null) {
buf = DEFAULT_SYNC_DEBUGGER_PORT;
}
try {
return Integer.parseInt(buf);
} catch (NumberFormatException e) {
throw new TestErrorException(e);
}
}
}
}