690 lines
22 KiB
Java
690 lines
22 KiB
Java
/*
|
|
* Copyright (c) 2007, 2017, Oracle and/or its affiliates. All rights reserved.
|
|
* 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.
|
|
*/
|
|
|
|
// THIS TEST IS LINE NUMBER SENSITIVE
|
|
|
|
/**
|
|
* @test
|
|
* @bug 4300412
|
|
* @summary Test GetLocal* and SetLocal* functions
|
|
* @author Serguei Spitsyn
|
|
*
|
|
* @run build TestScaffold VMConnection TargetListener TargetAdapter
|
|
* @run compile -g GetSetLocalTest.java
|
|
* @run driver GetSetLocalTest
|
|
*/
|
|
import com.sun.jdi.*;
|
|
import com.sun.jdi.event.*;
|
|
import com.sun.jdi.request.*;
|
|
|
|
import java.util.*;
|
|
|
|
/********** target program **********/
|
|
|
|
class GetSetLocalTarg {
|
|
public static void main(String[] args){
|
|
int intVar = 10;
|
|
System.out.println("GetSetLocalTarg: Started");
|
|
intVar = staticMeth(intVar);
|
|
System.out.println("GetSetLocalTarg: Finished");
|
|
}
|
|
|
|
/*
|
|
* The line numbers of this method *MUST NOT* be changed
|
|
* because the testing algorithm counts on this layout!
|
|
* It's in calls to resumeTo("GetSetLocalTarg", line).
|
|
*/
|
|
public static int staticMeth(int intArg) {
|
|
System.out.println("staticMeth: Started");
|
|
int result;
|
|
{
|
|
{ boolean bool_1 = false;
|
|
intArg++; // START_LINE
|
|
}
|
|
|
|
boolean bool_2 = true;
|
|
intArg++;
|
|
}
|
|
{
|
|
{ byte byte_1 = 1;
|
|
intArg++;
|
|
}
|
|
|
|
byte byte_2 = 2;
|
|
intArg++;
|
|
}
|
|
{
|
|
{ char char_1 = '1';
|
|
intArg++;
|
|
}
|
|
|
|
char char_2 = '2';
|
|
intArg++;
|
|
}
|
|
{
|
|
{ short short_1 = 1;
|
|
intArg++;
|
|
}
|
|
|
|
short short_2 = 2;
|
|
intArg++;
|
|
}
|
|
{
|
|
{ int int_1 = 1;
|
|
intArg++;
|
|
}
|
|
|
|
int int_2 = 2;
|
|
intArg++;
|
|
}
|
|
{
|
|
{ long long_1 = 1;
|
|
intArg++;
|
|
}
|
|
|
|
long long_2 = 2;
|
|
intArg++;
|
|
}
|
|
{
|
|
{ float float_1 = 1;
|
|
intArg++;
|
|
}
|
|
|
|
float float_2 = 2;
|
|
intArg++;
|
|
}
|
|
{
|
|
{ double double_1 = 1;
|
|
intArg++;
|
|
}
|
|
|
|
double double_2 = 2;
|
|
intArg++;
|
|
}
|
|
{
|
|
{ String string_1 = "1";
|
|
intArg++;
|
|
}
|
|
|
|
String string_2 = "2";
|
|
intArg++;
|
|
}
|
|
{
|
|
{ Object obj_1 = new Object();
|
|
intArg++;
|
|
}
|
|
|
|
Object obj_2 = new Object();
|
|
intArg++; // STOP_LINE. Last stop is at this point.
|
|
// Only obj_2 and intArg are valid
|
|
// Note: even result is not valid here!
|
|
}
|
|
result = 10; // <- This is first init of result var
|
|
System.out.println("staticMeth: Finished");
|
|
return result;
|
|
}
|
|
}
|
|
|
|
|
|
/********** test program **********/
|
|
|
|
public class GetSetLocalTest extends TestScaffold {
|
|
static final int START_LINE = 62;
|
|
static final int STOP_LINE = 138;
|
|
ReferenceType targetClass;
|
|
ThreadReference mainThread;
|
|
|
|
GetSetLocalTest (String args[]) {
|
|
super(args);
|
|
}
|
|
|
|
public static void main(String[] args) throws Exception {
|
|
new GetSetLocalTest(args).startTests();
|
|
}
|
|
|
|
/********** test assist **********/
|
|
|
|
Method getMethod(String className, String methodName) {
|
|
List refs = vm().classesByName(className);
|
|
if (refs.size() != 1) {
|
|
failure(" Failure: " + refs.size() +
|
|
" ReferenceTypes named: " + className);
|
|
return null;
|
|
}
|
|
ReferenceType refType = (ReferenceType)refs.get(0);
|
|
List meths = refType.methodsByName(methodName);
|
|
if (meths.size() != 1) {
|
|
failure(" Failure: " + meths.size() +
|
|
" methods named: " + methodName);
|
|
return null;
|
|
}
|
|
return (Method)meths.get(0);
|
|
}
|
|
|
|
List printAllVariables(String className, String methodName) throws Exception {
|
|
println("printAllVariables for method: " + className + "." + methodName);
|
|
Method method = getMethod(className, methodName);
|
|
List localVars;
|
|
try {
|
|
localVars = method.variables();
|
|
println(" Success: got a list of all method variables: " + methodName);
|
|
}
|
|
catch (com.sun.jdi.AbsentInformationException ex) {
|
|
failure(" Failure: AbsentInformationException has been thrown");
|
|
return null;
|
|
}
|
|
|
|
int index = 0;
|
|
for (Iterator it = localVars.iterator(); it.hasNext();) {
|
|
LocalVariable lv = (LocalVariable) it.next();
|
|
printOneVariable(lv, index++);
|
|
}
|
|
println("");
|
|
return localVars;
|
|
}
|
|
|
|
void checkGetSetAllVariables(List localVars, StackFrame frame) throws Exception {
|
|
println("\n checkGetSetAllVariables for method at particular frame location: ");
|
|
int index = 0;
|
|
for (Iterator it = localVars.iterator(); it.hasNext();) {
|
|
LocalVariable lv = (LocalVariable) it.next();
|
|
String lv_name = lv.name();
|
|
print(" Variable " + lv_name);
|
|
try {
|
|
Value val = frame.getValue(lv);
|
|
frame.setValue(lv, val);
|
|
println(" has been get/set");
|
|
if (lv_name.compareTo("intArg") != 0 &&
|
|
lv_name.compareTo("obj_2") != 0) {
|
|
failure(" Failure: AbsentInformationException is expected");
|
|
}
|
|
} catch (java.lang.IllegalArgumentException ex) {
|
|
println(" is not valid");
|
|
if (lv_name.compareTo("intArg") == 0 &&
|
|
lv_name.compareTo("obj_2") == 0) {
|
|
failure(" Failure: AbsentInformationException was not expected");
|
|
}
|
|
}
|
|
}
|
|
println("");
|
|
}
|
|
|
|
void printOneVariable(LocalVariable lv, int index) throws Exception {
|
|
String tyname = lv.typeName();
|
|
println("");
|
|
println(" Var name: " + lv.name());
|
|
println(" Var type: " + tyname);
|
|
println(" Var index: " + index);
|
|
println(" Signature: " + lv.type().signature());
|
|
// Sorry, there is no way to get (and print)
|
|
// a local variable slot numbers using JDI!
|
|
}
|
|
|
|
void printFrameVariables(StackFrame frame) throws Exception {
|
|
int index = 0;
|
|
List localVars = frame.visibleVariables();
|
|
println("\n Visible variables at this point are: ");
|
|
|
|
for (Iterator it = localVars.iterator(); it.hasNext();) {
|
|
LocalVariable lv = (LocalVariable) it.next();
|
|
printOneVariable(lv, index++);
|
|
println(" Var value: " + frame.getValue(lv));
|
|
}
|
|
}
|
|
|
|
BooleanValue incrValue(BooleanValue val) {
|
|
boolean value = val.value();
|
|
return vm().mirrorOf(!value);
|
|
}
|
|
|
|
ByteValue incrValue(ByteValue val) {
|
|
byte value = val.value();
|
|
return vm().mirrorOf(++value);
|
|
}
|
|
|
|
CharValue incrValue(CharValue val) {
|
|
char value = val.value();
|
|
return vm().mirrorOf(++value);
|
|
}
|
|
|
|
ShortValue incrValue(ShortValue val) {
|
|
short value = val.value();
|
|
return vm().mirrorOf(++value);
|
|
}
|
|
|
|
IntegerValue incrValue(IntegerValue val) {
|
|
int value = val.value();
|
|
return vm().mirrorOf(++value);
|
|
}
|
|
|
|
LongValue incrValue(LongValue val) {
|
|
long value = val.value();
|
|
return vm().mirrorOf(++value);
|
|
}
|
|
|
|
FloatValue incrValue(FloatValue val) {
|
|
float value = val.value();
|
|
return vm().mirrorOf(++value);
|
|
}
|
|
|
|
DoubleValue incrValue(DoubleValue val) {
|
|
double value = val.value();
|
|
return vm().mirrorOf(++value);
|
|
}
|
|
|
|
StringReference incrValue(StringReference val) {
|
|
String newstr = new String("Set String ").concat(val.value());
|
|
return vm().mirrorOf(newstr);
|
|
}
|
|
|
|
void checkSetBooleanTypes(StackFrame frame, LocalVariable lv) throws Exception {
|
|
BooleanValue get = (BooleanValue) frame.getValue(lv);
|
|
BooleanValue set = incrValue(get);
|
|
frame.setValue(lv, set);
|
|
|
|
// To get the new value which has been set
|
|
get = (BooleanValue) frame.getValue(lv);
|
|
println(" Var Set: " + set);
|
|
println(" Var Get: " + get);
|
|
println("");
|
|
boolean v1 = get.value();
|
|
boolean v2 = set.value();
|
|
|
|
// Check if set was done properly
|
|
if (v1 == v2) {
|
|
println(" Success: Value was set correctly!");
|
|
} else {
|
|
failure(" Failure: Value was NOT set correctly!");
|
|
}
|
|
println("");
|
|
}
|
|
|
|
void checkSetByteTypes(StackFrame frame, LocalVariable lv) throws Exception {
|
|
ByteValue get = (ByteValue) frame.getValue(lv);
|
|
ByteValue set = incrValue(get);
|
|
frame.setValue(lv, set);
|
|
|
|
// To get the new value which has been set
|
|
get = (ByteValue) frame.getValue(lv);
|
|
println(" Var Set: " + set);
|
|
println(" Var Get: " + get);
|
|
println("");
|
|
byte v1 = get.value();
|
|
byte v2 = set.value();
|
|
|
|
// Check if set was done properly
|
|
if (v1 == v2) {
|
|
println(" Success: Value was set correctly!");
|
|
} else {
|
|
failure(" Failure: Value was NOT set correctly!");
|
|
}
|
|
println("");
|
|
}
|
|
|
|
void checkSetCharTypes(StackFrame frame, LocalVariable lv) throws Exception {
|
|
CharValue get = (CharValue) frame.getValue(lv);
|
|
CharValue set = incrValue(get);
|
|
frame.setValue(lv, set);
|
|
|
|
// To get the new value which has been set
|
|
get = (CharValue) frame.getValue(lv);
|
|
println(" Var Set: " + set);
|
|
println(" Var Get: " + get);
|
|
println("");
|
|
char v1 = get.value();
|
|
char v2 = set.value();
|
|
|
|
// Check if set was done properly
|
|
if (v1 == v2) {
|
|
println(" Success: Value was set correctly!");
|
|
} else {
|
|
failure(" Failure: Value was NOT set correctly!");
|
|
}
|
|
println("");
|
|
}
|
|
|
|
void checkSetShortTypes(StackFrame frame, LocalVariable lv) throws Exception {
|
|
ShortValue get = (ShortValue) frame.getValue(lv);
|
|
ShortValue set = incrValue(get);
|
|
frame.setValue(lv, set);
|
|
|
|
// To get the new value which has been set
|
|
get = (ShortValue) frame.getValue(lv);
|
|
println(" Var Set: " + set);
|
|
println(" Var Get: " + get);
|
|
println("");
|
|
short v1 = get.value();
|
|
short v2 = set.value();
|
|
|
|
// Check if set was done properly
|
|
if (v1 == v2) {
|
|
println(" Success: Value was set correctly!");
|
|
} else {
|
|
failure(" Failure: Value was NOT set correctly!");
|
|
}
|
|
println("");
|
|
}
|
|
|
|
void checkSetIntegerTypes(StackFrame frame, LocalVariable lv) throws Exception {
|
|
IntegerValue get = (IntegerValue) frame.getValue(lv);
|
|
IntegerValue set = incrValue(get);
|
|
frame.setValue(lv, set);
|
|
|
|
// To get the new value which has been set
|
|
get = (IntegerValue) frame.getValue(lv);
|
|
println(" Var Set: " + set);
|
|
println(" Var Get: " + get);
|
|
println("");
|
|
int v1 = get.value();
|
|
int v2 = set.value();
|
|
|
|
// Check if set was done properly
|
|
if (v1 == v2) {
|
|
println(" Success: Value was set correctly!");
|
|
} else {
|
|
failure(" Failure: Value was NOT set correctly!");
|
|
}
|
|
println("");
|
|
}
|
|
|
|
void checkSetLongTypes(StackFrame frame, LocalVariable lv) throws Exception {
|
|
LongValue get = (LongValue) frame.getValue(lv);
|
|
LongValue set = incrValue(get);
|
|
frame.setValue(lv, set);
|
|
|
|
// To get the new value which has been set
|
|
get = (LongValue) frame.getValue(lv);
|
|
println(" Var Set: " + set);
|
|
println(" Var Get: " + get);
|
|
println("");
|
|
long v1 = get.value();
|
|
long v2 = set.value();
|
|
|
|
// Check if set was done properly
|
|
if (v1 == v2) {
|
|
println(" Success: Value was set correctly!");
|
|
} else {
|
|
failure(" Failure: Value was NOT set correctly!");
|
|
}
|
|
println("");
|
|
}
|
|
|
|
void checkSetFloatTypes(StackFrame frame, LocalVariable lv) throws Exception {
|
|
FloatValue get = (FloatValue) frame.getValue(lv);
|
|
FloatValue set = incrValue(get);
|
|
frame.setValue(lv, set);
|
|
|
|
// To get the new value which has been set
|
|
get = (FloatValue) frame.getValue(lv);
|
|
println(" Var Set: " + set);
|
|
println(" Var Get: " + get);
|
|
println("");
|
|
float v1 = get.value();
|
|
float v2 = set.value();
|
|
|
|
// Check if set was done properly
|
|
if (v1 == v2) {
|
|
println(" Success: Value was set correctly!");
|
|
} else {
|
|
failure(" Failure: Value was NOT set correctly!");
|
|
}
|
|
println("");
|
|
}
|
|
|
|
void checkSetDoubleTypes(StackFrame frame, LocalVariable lv) throws Exception {
|
|
DoubleValue get = (DoubleValue) frame.getValue(lv);
|
|
DoubleValue set = incrValue(get);
|
|
frame.setValue(lv, set);
|
|
|
|
// To get the new value which has been set
|
|
get = (DoubleValue) frame.getValue(lv);
|
|
println(" Var Set: " + set);
|
|
println(" Var Get: " + get);
|
|
println("");
|
|
double v1 = get.value();
|
|
double v2 = set.value();
|
|
|
|
// Check if set was done properly
|
|
if (v1 == v2) {
|
|
println(" Success: Value was set correctly!");
|
|
} else {
|
|
failure(" Failure: Value was NOT set correctly!");
|
|
}
|
|
println("");
|
|
}
|
|
|
|
void checkSetStringTypes(StackFrame frame, LocalVariable lv) throws Exception {
|
|
StringReference get = (StringReference) frame.getValue(lv);
|
|
StringReference set = incrValue((StringReference) frame.getValue(lv));
|
|
frame.setValue(lv, set);
|
|
|
|
// To get the new value which has been set
|
|
get = (StringReference) frame.getValue(lv);
|
|
println(" Var Set: " + set);
|
|
println(" Var Get: " + get);
|
|
println("");
|
|
String str1 = get.value();
|
|
String str2 = set.value();
|
|
|
|
// Check if set was done properly
|
|
if (str1.compareTo(str2) == 0) {
|
|
println(" Success: String was set correctly!");
|
|
} else {
|
|
failure(" Failure: String was NOT set correctly!");
|
|
}
|
|
println("");
|
|
}
|
|
|
|
void checkSetObjectTypes(StackFrame frame, LocalVariable lv) throws Exception {
|
|
ObjectReference get = (ObjectReference) frame.getValue(lv);
|
|
ObjectReference set = get; // FIXME: Don't know how to create a mirror of Object
|
|
frame.setValue(lv, set);
|
|
|
|
// To get the new value which has been set
|
|
get = (ObjectReference) frame.getValue(lv);
|
|
println(" Var Set: " + set);
|
|
println(" Var Get: " + get);
|
|
println("");
|
|
|
|
if (set.uniqueID() == get.uniqueID()) {
|
|
println(" Success: Object was set correctly!");
|
|
} else {
|
|
failure(" Failure: Object was NOT set correctly!");
|
|
}
|
|
println("");
|
|
}
|
|
|
|
void negativeIntegerCheck(StackFrame frame, LocalVariable lv) throws Exception {
|
|
try {
|
|
IntegerValue get = (IntegerValue) frame.getValue(lv);
|
|
println(" Get: No ClassCastException error!");
|
|
} catch(java.lang.ClassCastException ex) {
|
|
println(" Success: Get: ClassCastException error has cought as expected!");
|
|
}
|
|
try {
|
|
IntegerValue set = vm().mirrorOf((int) 0x3F);
|
|
frame.setValue(lv, set);
|
|
println(" Set: No InvalidTypeException with Integer error!");
|
|
} catch(com.sun.jdi.InvalidTypeException ex) {
|
|
println(" Success: Set: InvalidTypeException with Integer error has cought as expected!");
|
|
}
|
|
}
|
|
|
|
void negativeFloatCheck(StackFrame frame, LocalVariable lv) throws Exception {
|
|
try {
|
|
FloatValue get = (FloatValue) frame.getValue(lv);
|
|
println(" Get: No ClassCastException error!");
|
|
} catch(java.lang.ClassCastException ex) {
|
|
println(" Success: Get: ClassCastException with Float error has cought as expected!");
|
|
}
|
|
try {
|
|
FloatValue set = vm().mirrorOf(1.2345f);
|
|
frame.setValue(lv, set);
|
|
println(" Set: No InvalidTypeException with Float error!");
|
|
} catch(com.sun.jdi.InvalidTypeException ex) {
|
|
println(" Success: Set: InvalidTypeException error has cought as expected!");
|
|
}
|
|
}
|
|
|
|
void negativeDoubleCheck(StackFrame frame, LocalVariable lv) throws Exception {
|
|
try {
|
|
DoubleValue get = (DoubleValue) frame.getValue(lv);
|
|
println(" Get: No ClassCastException error!");
|
|
} catch(java.lang.ClassCastException ex) {
|
|
println(" Success: Get: ClassCastException with Double error has cought as expected!");
|
|
}
|
|
try {
|
|
DoubleValue set = vm().mirrorOf(1.2345E02);
|
|
frame.setValue(lv, set);
|
|
println(" Set: No InvalidTypeException with Double error!");
|
|
} catch(com.sun.jdi.InvalidTypeException ex) {
|
|
println(" Success: Set: InvalidTypeException error has cought as expected!");
|
|
}
|
|
}
|
|
|
|
void checkSetFrameVariables(StackFrame frame) throws Exception {
|
|
List localVars = frame.visibleVariables();
|
|
int index = 0;
|
|
println("\n Set variable values:");
|
|
|
|
for (Iterator it = localVars.iterator(); it.hasNext();index++) {
|
|
LocalVariable lv = (LocalVariable) it.next();
|
|
String signature = lv.type().signature();
|
|
|
|
switch (signature.charAt(0)) {
|
|
case 'Z': // Boolean Type
|
|
checkSetBooleanTypes(frame, lv);
|
|
negativeIntegerCheck(frame, lv);
|
|
negativeFloatCheck(frame, lv);
|
|
negativeDoubleCheck(frame, lv);
|
|
break;
|
|
case 'B': // Byte Type
|
|
checkSetByteTypes(frame, lv);
|
|
negativeIntegerCheck(frame, lv);
|
|
negativeFloatCheck(frame, lv);
|
|
negativeDoubleCheck(frame, lv);
|
|
break;
|
|
case 'C': // Char Type
|
|
checkSetCharTypes(frame, lv);
|
|
negativeIntegerCheck(frame, lv);
|
|
negativeFloatCheck(frame, lv);
|
|
negativeDoubleCheck(frame, lv);
|
|
break;
|
|
case 'S': // Short Type
|
|
checkSetShortTypes(frame, lv);
|
|
negativeIntegerCheck(frame, lv);
|
|
negativeFloatCheck(frame, lv);
|
|
negativeDoubleCheck(frame, lv);
|
|
break;
|
|
case 'I': // Integer Type
|
|
checkSetIntegerTypes(frame, lv);
|
|
if (index > 0) { // To skip integer method parameter
|
|
negativeFloatCheck(frame, lv);
|
|
negativeDoubleCheck(frame, lv);
|
|
}
|
|
break;
|
|
case 'J': // Long Type
|
|
checkSetLongTypes(frame, lv);
|
|
negativeIntegerCheck(frame, lv);
|
|
negativeFloatCheck(frame, lv);
|
|
negativeDoubleCheck(frame, lv);
|
|
break;
|
|
case 'F': // Float Type
|
|
checkSetFloatTypes(frame, lv);
|
|
negativeIntegerCheck(frame, lv);
|
|
negativeDoubleCheck(frame, lv);
|
|
break;
|
|
case 'D': // Double Type
|
|
checkSetDoubleTypes(frame, lv);
|
|
negativeIntegerCheck(frame, lv);
|
|
negativeFloatCheck(frame, lv);
|
|
break;
|
|
case 'L':
|
|
if (signature.compareTo("Ljava/lang/String;") == 0) {
|
|
checkSetStringTypes(frame, lv);
|
|
negativeIntegerCheck(frame, lv);
|
|
negativeFloatCheck(frame, lv);
|
|
}
|
|
if (signature.compareTo("Ljava/lang/Object;") == 0) {
|
|
checkSetObjectTypes(frame, lv);
|
|
negativeIntegerCheck(frame, lv);
|
|
negativeFloatCheck(frame, lv);
|
|
}
|
|
break;
|
|
default:
|
|
printOneVariable(lv, index);
|
|
failure(" Failure: List of local variables has a wrong entry!");
|
|
};
|
|
}
|
|
}
|
|
|
|
|
|
/********** test core **********/
|
|
|
|
protected void runTests() throws Exception {
|
|
|
|
/*
|
|
* Get to the top of main() to determine targetClass and mainThread
|
|
*/
|
|
BreakpointEvent bpe = startToMain("GetSetLocalTarg");
|
|
println("startToMain(GetSetLocalTarg)");
|
|
|
|
List localVars = printAllVariables("GetSetLocalTarg", "staticMeth");
|
|
|
|
targetClass = bpe.location().declaringType();
|
|
println("targetClass");
|
|
|
|
mainThread = bpe.thread();
|
|
println("mainThread");
|
|
|
|
EventRequestManager erm = vm().eventRequestManager();
|
|
println("EventRequestManager");
|
|
StackFrame frame = null;
|
|
|
|
for (int line = START_LINE; line <= STOP_LINE; line += 4) {
|
|
println("\n resumeTo(GetSetLocalTarg, " + line + ")");
|
|
bpe = resumeTo("GetSetLocalTarg", line);
|
|
frame = bpe.thread().frame(0);
|
|
printFrameVariables(frame);
|
|
checkSetFrameVariables(frame);
|
|
}
|
|
// Check if we can Get/Set all local vars using last frame state
|
|
checkGetSetAllVariables(localVars, frame);
|
|
|
|
/*
|
|
* resume until the end
|
|
*/
|
|
listenUntilVMDisconnect();
|
|
|
|
/*
|
|
* deal with results of test
|
|
* if anything has called failure("foo") testFailed will be true
|
|
*/
|
|
if (!testFailed) {
|
|
println("GetSetLocalTest: passed");
|
|
} else {
|
|
throw new Exception("GetSetLocalTest: failed");
|
|
}
|
|
}
|
|
}
|