protected void runTests() throws Exception { /* * Get to the top of main() * to determine targetClass and mainThread */ BreakpointEvent bpe = startToMain("GetLocalVariables2Targ"); targetClass = bpe.location().declaringType(); mainThread = bpe.thread(); EventRequestManager erm = vm().eventRequestManager(); bpe = resumeTo("GetLocalVariables2Targ", "bar", "(I)Z"); /* * Inspect the stack frame for main(), not bar()... */ StackFrame frame = bpe.thread().frame(1); List localVars = frame.visibleVariables(); System.out.println(" Visible variables at this point are: "); for (Iterator it = localVars.iterator(); it.hasNext(); ) { LocalVariable lv = (LocalVariable) it.next(); System.out.print(lv.name()); System.out.print(" typeName: "); System.out.print(lv.typeName()); System.out.print(" signature: "); System.out.print(lv.type().signature()); System.out.print(" primitive type: "); System.out.println(lv.type().name()); if ("command".equals(lv.name())) { failure("Failure: LocalVariable \"command\" should not be visible at this point."); if (lv.isVisible(frame)) { System.out.println("Failure: \"command.isvisible(frame)\" returned true."); } } } /* * resume the target listening for events */ listenUntilVMDisconnect(); /* * deal with results of test * if anything has called failure("foo") testFailed will be true */ if (!testFailed) { println("GetLocalVariables2Test: passed"); } else { throw new Exception("GetLocalVariables2Test: failed"); } }
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); } }