|
/*
* 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");
}
}
}
¤ Dauer der Verarbeitung: 0.26 Sekunden
(vorverarbeitet)
¤
|
Haftungshinweis
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
|
