void ckThreadGroupValue(Value retValue) {
Field theValueField = targetClass.fieldByName("ethreadGroupValue");
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);
earlyReturns++;
}
}
void ckClassLoaderValue(Value retValue) {
Field theValueField = targetClass.fieldByName("eclassLoaderValue");
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);
earlyReturns++;
}
}
void ckObjectValue(Value retValue) {
ObjectReference theRetValue = (ObjectReference) retValue;
Field theIVarField = targetClass.fieldByName("eobjectValue");
ObjectReference theRetValField = (ObjectReference) targetClass.getValue(theIVarField);
if (!theRetValue.equals(theRetValField)) {
failure("failure: Object: expected " + theIVarField + ", got " + theRetValField);
} else {
System.out.println("Passed: Object: " + theRetValField);
earlyReturns++;
}
}
void ckStringValue(Value retValue) {
Field theValueField = targetClass.fieldByName("estringValue");
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);
earlyReturns++;
}
}
void ckShortValue(Value retValue) {
Field theValueField = targetClass.fieldByName("eshortValue");
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);
earlyReturns++;
}
}
void ckBooleanValue(Value retValue) {
Field theValueField = targetClass.fieldByName("ebooleanValue");
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);
earlyReturns++;
}
}
void ckLongValue(Value retValue) {
Field theValueField = targetClass.fieldByName("elongValue");
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);
earlyReturns++;
}
}
void ckIntValue(Value retValue) {
Field theValueField = targetClass.fieldByName("eintValue");
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);
earlyReturns++;
}
}
void ckFloatValue(Value retValue) {
Field theValueField = targetClass.fieldByName("efloatValue");
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);
earlyReturns++;
}
}
void ckDoubleValue(Value retValue) {
Field theValueField = targetClass.fieldByName("edoubleValue");
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);
earlyReturns++;
}
}
void ckCharValue(Value retValue) {
Field theValueField = targetClass.fieldByName("echarValue");
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);
earlyReturns++;
}
}
void ckArrayValue(Value retValue) {
Field theValueField = targetClass.fieldByName("eintArrayValue");
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);
earlyReturns++;
}
}
protected void runTests() throws Exception {
/*
* Get to the top of main()
* to determine targetClass and mainThread
*/
BreakpointEvent bpe = startToMain("EarlyReturnTarg");
targetClass = (ClassType) bpe.location().declaringType();
mainThread = bpe.thread();
/*
* Ask for method exit events
*/
MethodExitRequest exitRequest = eventRequestManager().createMethodExitRequest();
for (int i = 0; i < excludes.length; ++i) {
exitRequest.addClassExclusionFilter(excludes[i]);
}
int sessionSuspendPolicy = EventRequest.SUSPEND_ALL;
// sessionSuspendPolicy = EventRequest.SUSPEND_EVENT_THREAD;
// sessionSuspendPolicy = EventRequest.SUSPEND_NONE;
exitRequest.setSuspendPolicy(sessionSuspendPolicy);
exitRequest.enable();
/*
* Turn on the flag so debugee knows to check for early
* return values instead of regular return values.
*/
Field flagField = targetClass.fieldByName("debuggerWatching");
targetClass.setValue(flagField, vm().mirrorOf(true));
/*
* We set and enable breakpoints on all of the interesting
* methods called by doit(). In the breakpointReached()
* handler we force an early return with a different return
* value.
*
* The MethodExitEvent handler will keep score.
*/
setBreakpoint("EarlyReturnTarg", "s_bytef", "(I)B");
setBreakpoint("EarlyReturnTarg", "s_charf", "()C");
setBreakpoint("EarlyReturnTarg", "s_doublef", "()D");
setBreakpoint("EarlyReturnTarg", "s_floatf", "()F");
setBreakpoint("EarlyReturnTarg", "s_intf", "()I");
setBreakpoint("EarlyReturnTarg", "s_longf", "()J");
setBreakpoint("EarlyReturnTarg", "s_shortf", "()S");
setBreakpoint("EarlyReturnTarg", "s_booleanf", "()Z");
setBreakpoint("EarlyReturnTarg", "s_stringf", "()Ljava/lang/String;");
setBreakpoint("EarlyReturnTarg", "s_classf", "()Ljava/lang/Class;");
setBreakpoint("EarlyReturnTarg", "s_classLoaderf", "()Ljava/lang/ClassLoader;");
setBreakpoint("EarlyReturnTarg", "s_threadf", "()Ljava/lang/Thread;");
setBreakpoint("EarlyReturnTarg", "s_threadGroupf", "()Ljava/lang/ThreadGroup;");
setBreakpoint("EarlyReturnTarg", "s_intArrayf", "()[I");
setBreakpoint("EarlyReturnTarg", "s_nullObjectf", "()Ljava/lang/Object;");
setBreakpoint("EarlyReturnTarg", "s_objectf", "()Ljava/lang/Object;");
setBreakpoint("EarlyReturnTarg", "s_voidf", "()V");
setBreakpoint("EarlyReturnTarg", "i_bytef", "(I)B");
setBreakpoint("EarlyReturnTarg", "i_charf", "()C");
setBreakpoint("EarlyReturnTarg", "i_doublef", "()D");
setBreakpoint("EarlyReturnTarg", "i_floatf", "()F");
setBreakpoint("EarlyReturnTarg", "i_intf", "()I");
setBreakpoint("EarlyReturnTarg", "i_longf", "()J");
setBreakpoint("EarlyReturnTarg", "i_shortf", "()S");
setBreakpoint("EarlyReturnTarg", "i_booleanf", "()Z");
setBreakpoint("EarlyReturnTarg", "i_stringf", "()Ljava/lang/String;");
setBreakpoint("EarlyReturnTarg", "i_intArrayf", "()[I");
setBreakpoint("EarlyReturnTarg", "i_classf", "()Ljava/lang/Class;");
setBreakpoint("EarlyReturnTarg", "i_classLoaderf", "()Ljava/lang/ClassLoader;");
setBreakpoint("EarlyReturnTarg", "i_threadf", "()Ljava/lang/Thread;");
setBreakpoint("EarlyReturnTarg", "i_threadGroupf", "()Ljava/lang/ThreadGroup;");
setBreakpoint("EarlyReturnTarg", "i_nullObjectf", "()Ljava/lang/Object;");
setBreakpoint("EarlyReturnTarg", "i_objectf", "()Ljava/lang/Object;");
setBreakpoint("EarlyReturnTarg", "i_voidf", "()V");
/* Here we go. This adds 'this' as a listener so
* that our handlers above will be called.
*/
listenUntilVMDisconnect();
if (earlyReturns != expectedEarlyReturns) {
failure("failure: Expected " + expectedEarlyReturns + ", but got " + earlyReturns);
}
System.out.println("All done, " + earlyReturns + " passed");
if (!testFailed) {
System.out.println();
System.out.println("EarlyReturnTest: passed");
} else {
System.out.println();
System.out.println("EarlyReturnTest: failed");
throw new Exception("EarlyReturnTest: failed");
}
}
public void breakpointReached(BreakpointEvent event) {
String origMethodName = event.location().method().name();
String methodName = origMethodName.substring(2);
ThreadReference tr = event.thread();
if (vm().canForceEarlyReturn()) {
try {
if ("bytef".equals(methodName)) {
Field theValueField = targetClass.fieldByName("ebyteValue");
ByteValue theValue = (ByteValue) targetClass.getValue(theValueField);
tr.forceEarlyReturn(theValue);
/*
* See what happens if we access the stack after the force
* and before the resume. Disabling this since spec says
* the stack is undefined. This type of code can be used to
* pursue just what that means.
*
* StackFrame sf = tr.frame(0);
* List<Value> ll = sf.getArgumentValues();
* for (Value vv: ll) {
* System.out.println("vv = " + vv);
* }
*/
} else if ("charf".equals(methodName)) {
Field theValueField = targetClass.fieldByName("echarValue");
CharValue theValue = (CharValue) targetClass.getValue(theValueField);
tr.forceEarlyReturn(theValue);
} else if ("doublef".equals(methodName)) {
Field theValueField = targetClass.fieldByName("edoubleValue");
DoubleValue theValue = (DoubleValue) targetClass.getValue(theValueField);
tr.forceEarlyReturn(theValue);
} else if ("floatf".equals(methodName)) {
Field theValueField = targetClass.fieldByName("efloatValue");
FloatValue theValue = (FloatValue) targetClass.getValue(theValueField);
tr.forceEarlyReturn(theValue);
} else if ("intf".equals(methodName)) {
Field theValueField = targetClass.fieldByName("eintValue");
IntegerValue theValue = (IntegerValue) targetClass.getValue(theValueField);
tr.forceEarlyReturn(theValue);
} else if ("longf".equals(methodName)) {
Field theValueField = targetClass.fieldByName("elongValue");
LongValue theValue = (LongValue) targetClass.getValue(theValueField);
tr.forceEarlyReturn(theValue);
} else if ("shortf".equals(methodName)) {
Field theValueField = targetClass.fieldByName("eshortValue");
ShortValue theValue = (ShortValue) targetClass.getValue(theValueField);
tr.forceEarlyReturn(theValue);
} else if ("booleanf".equals(methodName)) {
Field theValueField = targetClass.fieldByName("ebooleanValue");
BooleanValue theValue = (BooleanValue) targetClass.getValue(theValueField);
tr.forceEarlyReturn(theValue);
} else if ("stringf".equals(methodName)) {
Field theValueField = targetClass.fieldByName("estringValue");
StringReference theValue = (StringReference) targetClass.getValue(theValueField);
tr.forceEarlyReturn(theValue);
} else if ("classf".equals(methodName)) {
Field theValueField = targetClass.fieldByName("eclassValue");
ClassObjectReference theValue =
(ClassObjectReference) targetClass.getValue(theValueField);
tr.forceEarlyReturn(theValue);
} else if ("classLoaderf".equals(methodName)) {
Field theValueField = targetClass.fieldByName("eclassLoaderValue");
ClassLoaderReference theValue =
(ClassLoaderReference) targetClass.getValue(theValueField);
tr.forceEarlyReturn(theValue);
} else if ("threadf".equals(methodName)) {
Field theValueField = targetClass.fieldByName("ethreadValue");
ThreadReference theValue = (ThreadReference) targetClass.getValue(theValueField);
tr.forceEarlyReturn(theValue);
} else if ("threadGroupf".equals(methodName)) {
Field theValueField = targetClass.fieldByName("ethreadGroupValue");
ThreadGroupReference theValue =
(ThreadGroupReference) targetClass.getValue(theValueField);
tr.forceEarlyReturn(theValue);
} else if ("intArrayf".equals(methodName)) {
Field theValueField = targetClass.fieldByName("eintArrayValue");
ArrayReference theValue = (ArrayReference) targetClass.getValue(theValueField);
tr.forceEarlyReturn(theValue);
} else if ("nullObjectf".equals(methodName)) {
tr.forceEarlyReturn(null);
} else if ("objectf".equals(methodName)) {
Field theValueField = targetClass.fieldByName("eobjectValue");
ObjectReference theValue = (ObjectReference) targetClass.getValue(theValueField);
tr.forceEarlyReturn(theValue);
} else if ("voidf".equals(methodName)) {
VoidValue theValue = vm().mirrorOfVoid();
tr.forceEarlyReturn(theValue);
} else {
failure("failure: Unknown methodName: " + origMethodName);
}
} catch (Exception ex) {
failure("failure: " + ex.toString());
ex.printStackTrace();
}
} else {
System.out.println("Cannot force early return for method: " + origMethodName);
}
}