256 lines
8.1 KiB
Java
256 lines
8.1 KiB
Java
/*
|
|
* Copyright (c) 2003, 2015, 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.
|
|
*/
|
|
|
|
/**
|
|
* @test
|
|
* @bug 4916263
|
|
* @summary Test
|
|
* @author Serguei Spitsyn
|
|
*
|
|
* @run build TestScaffold VMConnection TargetListener TargetAdapter
|
|
* @run compile -g LocalVariableEqual.java
|
|
* @run driver LocalVariableEqual
|
|
*/
|
|
import com.sun.jdi.*;
|
|
import com.sun.jdi.event.*;
|
|
import com.sun.jdi.request.*;
|
|
import java.util.*;
|
|
|
|
/********** target program **********/
|
|
|
|
class LocalVariableEqualTarg {
|
|
public static void main(String[] args){
|
|
int intVar = 10;
|
|
System.out.println("LocalVariableEqualTarg: Started");
|
|
intVar = staticMeth(intVar);
|
|
System.out.println("LocalVariableEqualTarg: Finished");
|
|
}
|
|
|
|
public static int staticMeth(int intArg) {
|
|
System.out.println("staticMeth: Started");
|
|
int result;
|
|
{
|
|
{ boolean bool_1 = false;
|
|
intArg++;
|
|
{
|
|
{ byte byte_2 = 2;
|
|
intArg++;
|
|
}
|
|
byte byte_1 = 1;
|
|
intArg++;
|
|
}
|
|
}
|
|
boolean bool_2 = true;
|
|
intArg++;
|
|
}
|
|
{
|
|
{
|
|
{
|
|
{ char char_1 = '1';
|
|
intArg++;
|
|
}
|
|
short short_1 = 1;
|
|
intArg++;
|
|
}
|
|
}
|
|
{ short short_2 = 2;
|
|
intArg++;
|
|
}
|
|
char char_2 = '2';
|
|
intArg++;
|
|
}
|
|
{
|
|
{ int int_1 = 1;
|
|
intArg++;
|
|
}
|
|
long long_1 = 1;
|
|
intArg++;
|
|
}
|
|
{
|
|
{ float float_1 = 1;
|
|
intArg++;
|
|
}
|
|
double double_2 = 2;
|
|
intArg++;
|
|
}
|
|
{
|
|
{ String string_1 = "1";
|
|
intArg++;
|
|
}
|
|
Object obj_2 = new Object();
|
|
intArg++;
|
|
}
|
|
result = 10;
|
|
System.out.println("staticMeth: Finished");
|
|
return result;
|
|
}
|
|
}
|
|
|
|
|
|
/********** test program **********/
|
|
|
|
public class LocalVariableEqual extends TestScaffold {
|
|
ReferenceType targetClass;
|
|
ThreadReference mainThread;
|
|
|
|
LocalVariableEqual (String args[]) {
|
|
super(args);
|
|
}
|
|
|
|
public static void main(String[] args) throws Exception {
|
|
new LocalVariableEqual(args).startTests();
|
|
}
|
|
|
|
/********** test assist **********/
|
|
|
|
Method getMethod(String className, String methodName) {
|
|
List refs = vm().classesByName(className);
|
|
if (refs.size() != 1) {
|
|
failure("Test failure: " + refs.size() +
|
|
" ReferenceTypes named: " + className);
|
|
return null;
|
|
}
|
|
ReferenceType refType = (ReferenceType)refs.get(0);
|
|
List meths = refType.methodsByName(methodName);
|
|
if (meths.size() != 1) {
|
|
failure("Test failure: " + meths.size() +
|
|
" methods named: " + methodName);
|
|
return null;
|
|
}
|
|
return (Method)meths.get(0);
|
|
}
|
|
|
|
void printVariable(LocalVariable lv, int index) throws Exception {
|
|
if (lv == null) {
|
|
println(" Var name: null");
|
|
return;
|
|
}
|
|
String tyname = lv.typeName();
|
|
println(" Var: " + lv.name() + ", index: " + index + ", type: " + tyname +
|
|
", Signature: " + lv.type().signature());
|
|
// Sorry, there is no way to take local variable slot numbers using JDI!
|
|
// It is because method LocalVariableImpl.slot() is private.
|
|
}
|
|
|
|
void compareTwoEqualVars(LocalVariable lv1, LocalVariable lv2) {
|
|
if (lv1.equals(lv2)) {
|
|
println(" Success: equality of local vars detected");
|
|
} else {
|
|
failure(" Failure: equality of local vars is NOT detected");
|
|
}
|
|
if (lv1.hashCode() == lv2.hashCode()) {
|
|
println(" Success: hashCode's of equal local vars are equal");
|
|
} else {
|
|
failure(" Failure: hashCode's of equal local vars differ");
|
|
}
|
|
if (lv1.compareTo(lv2) == 0) {
|
|
println(" Success: compareTo() is correct for equal local vars");
|
|
} else {
|
|
failure(" Failure: compareTo() is NOT correct for equal local vars");
|
|
}
|
|
}
|
|
|
|
void compareTwoDifferentVars(LocalVariable lv1, LocalVariable lv2) {
|
|
if (!lv1.equals(lv2)) {
|
|
println(" Success: difference of local vars detected");
|
|
} else {
|
|
failure(" Failure: difference of local vars is NOT detected");
|
|
}
|
|
if (lv1.hashCode() != lv2.hashCode()) {
|
|
println(" Success: hashCode's of different local vars differ");
|
|
} else {
|
|
failure(" Failure: hashCode's of different local vars are equal");
|
|
}
|
|
if (lv1.compareTo(lv2) != 0) {
|
|
println(" Success: compareTo() is correct for different local vars");
|
|
} else {
|
|
failure(" Failure: compareTo() is NOT correct for different local vars");
|
|
}
|
|
}
|
|
|
|
void compareAllVariables(String className, String methodName) throws Exception {
|
|
println("compareAllVariables for method: " + className + "." + methodName);
|
|
Method method = getMethod(className, methodName);
|
|
List localVars;
|
|
try {
|
|
localVars = method.variables();
|
|
println("\n Success: got a list of all method variables: " + methodName);
|
|
}
|
|
catch (com.sun.jdi.AbsentInformationException ex) {
|
|
failure("\n AbsentInformationException has been thrown");
|
|
return;
|
|
}
|
|
|
|
// We consider N*N combinations for set of N variables
|
|
int index1 = 0;
|
|
for (Iterator it1 = localVars.iterator(); it1.hasNext(); index1++) {
|
|
LocalVariable lv1 = (LocalVariable) it1.next();
|
|
|
|
int index2 = 0;
|
|
for (Iterator it2 = localVars.iterator(); it2.hasNext(); index2++) {
|
|
LocalVariable lv2 = (LocalVariable) it2.next();
|
|
|
|
println("\n Two variables:");
|
|
printVariable(lv1, index1);
|
|
printVariable(lv2, index2);
|
|
println("");
|
|
if (index1 == index2) {
|
|
compareTwoEqualVars(lv1, lv2);
|
|
} else {
|
|
compareTwoDifferentVars(lv1, lv2);
|
|
}
|
|
}
|
|
}
|
|
println("");
|
|
return;
|
|
}
|
|
|
|
/********** test core **********/
|
|
|
|
protected void runTests() throws Exception {
|
|
|
|
/*
|
|
* Get to the top of main() to determine targetClass and mainThread
|
|
*/
|
|
BreakpointEvent bpe = startToMain("LocalVariableEqualTarg");
|
|
println("startToMain(LocalVariableEqualTarg)");
|
|
|
|
compareAllVariables("LocalVariableEqualTarg", "staticMeth");
|
|
|
|
/*
|
|
* resume until the end
|
|
*/
|
|
listenUntilVMDisconnect();
|
|
|
|
/*
|
|
* deal with results of test
|
|
* if anything has called failure("foo") testFailed will be true
|
|
*/
|
|
if (!testFailed) {
|
|
println("\nLocalVariableEqual: passed");
|
|
} else {
|
|
throw new Exception("\nLocalVariableEqual: FAILED");
|
|
}
|
|
}
|
|
}
|