diff -r fd16c54261b3 -r 90ce3da70b43 jdk/test/com/sun/jdi/LocalVariableEqual.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/test/com/sun/jdi/LocalVariableEqual.java Sat Dec 01 00:00:00 2007 +0000 @@ -0,0 +1,256 @@ +/* + * Copyright 2003-2004 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.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 main 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"); + } + } +}