--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/com/sun/jdi/GenericsTest.java Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,344 @@
+/*
+ * 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 4421040
+ * @summary JPDA: Add support for JSR-014 Generics
+ *
+ * @author jjh
+ *
+ * @run build TestScaffold VMConnection TargetListener TargetAdapter
+ * @run compile -source 1.5 -target 1.5 -g GenericsTest.java
+ * @run main GenericsTest
+ */
+import com.sun.jdi.*;
+import com.sun.jdi.event.*;
+import com.sun.jdi.request.*;
+
+import java.util.*;
+
+ /********** target program **********/
+
+class GenericsTarg {
+ static Gen1<String> genField = new Gen1<String>();;
+ static Sub1 sub1Field = new Sub1();
+
+ String[] strArray = null;
+ int intField = 0;
+ Object objField;
+ public static void main(String[] args){
+ //genField.print();
+ System.out.println("Goodbye from GenericsTarg!");
+ }
+}
+class Gen1<tt> {
+ tt field1;
+ Gen1() {
+ System.out.println("Gen1<tt> ctor called");
+ }
+ tt method1(tt p1) {
+ Gen1<String> xxx = null;
+ System.out.println("method1: param is " + p1);
+ return p1;
+ }
+ String method2() {
+ String str = "This local variable is not generic";
+ return str;
+ }
+}
+
+class Sub1 extends Gen1<String> {
+ String method1(String p1) {
+ System.out.println("method1 has been overridden: param is " + p1);
+ return "hi";
+ }
+}
+
+ /********** test program **********/
+
+public class GenericsTest extends TestScaffold {
+ ReferenceType targetClass;
+ ThreadReference mainThread;
+ static boolean useOld;
+
+ GenericsTest (String args[]) {
+ super(args);
+ }
+
+ public static void main(String[] args) throws Exception {
+ /*
+ * The 1.5 FE must be able to talk to a 1.4 BE, ie, JDWP version <= 1.4.
+ * This is hard to test since this test file must be compiled with
+ * -source 1.5 which will cause its class file to be version 49 which
+ * won't run on a pre 1.5 JDK. We can simulate this though
+ * by passing
+ * -xjdk <pathname>
+ * to this test which causes the debuggee to be run on that JDK.
+ * This should be a version of 1.5 that accepts classfile version 49,
+ * but which still contains the 1.4 version of JDWP.
+ * This trick verifies that the calls to genericSignature() methods
+ * in the test do not cause the generic JDWP commands to be issued.
+ * The value to use for this is currently:
+ * /java/re/jdk/1.5/promoted/all/b17/binaries/solaris-sparc
+ */
+ if (args.length > 1 && args[0].equals("-xjdk")) {
+ System.setProperty("java.home", args[1]);
+ useOld = true;
+
+ // Delete this arg
+ String[] args1 = new String[args.length - 2];
+ for (int ii = 0; ii < args.length -2; ii++) {
+ args1[ii] = args[ii + 2];
+ }
+ args = args1;
+ }
+
+ new GenericsTest(args).startTests();
+ }
+
+ /********** test core **********/
+
+ protected void runTests() throws Exception {
+ /*
+ * Get to the top of main()
+ * to determine targetClass and mainThread
+ */
+ BreakpointEvent bpe = startToMain("GenericsTarg");
+ targetClass = bpe.location().declaringType();
+ {
+ /*
+ * Prove that arrays aren't broken and that
+ * null is returned if there is no generic signature
+ */
+ Field strArray = targetClass.fieldByName("strArray");
+ ReferenceType fieldType = (ReferenceType)(strArray.type());
+ String genSig = fieldType.genericSignature();
+ System.out.println("strArray name = " + strArray);
+ System.out.println(" type = " + fieldType);
+ System.out.println(" sig = " + fieldType.signature());
+ System.out.println(" genSig = " + genSig);
+ if (!useOld && genSig != null) {
+ failure("FAILED: Expected generic signature = null for "
+ + fieldType.name() + ", received: " + genSig);
+ }
+ }
+ {
+ // prove that primitives aren't broken.
+ Field intField = targetClass.fieldByName("intField");
+ Type fieldType = (Type)(intField.type());
+ System.out.println("intField name = " + intField);
+ System.out.println(" type = " + fieldType);
+ System.out.println(" sig = " + fieldType.signature());
+ }
+
+ Field genField = targetClass.fieldByName("genField");
+ ReferenceType gen1Class = (ReferenceType)(genField.type());
+ String genSig;
+ String expected;
+ {
+ // Verify genericSignature for a class
+ expected = "<tt:Ljava/lang/Object;>Ljava/lang/Object;";
+ genSig = gen1Class.genericSignature();
+ System.out.println("genField name = " + genField);
+ System.out.println(" type = " + gen1Class);
+ System.out.println(" sig = " + gen1Class.signature());
+ System.out.println(" genSig = " + genSig);
+ if (!useOld && !expected.equals(genSig)) {
+ failure("FAILED: Expected generic signature for gen1: " +
+ expected + ", received: " + genSig);
+ }
+ }
+ {
+ // Verify genericSignature() for a field
+ List genFields = gen1Class.fields();
+ Field field1 = (Field)genFields.get(0);
+ // there is only one field
+ expected = "Ttt;";
+ genSig = field1.genericSignature();
+ System.out.println("field1 name = " + field1);
+ System.out.println(" type = " + gen1Class.signature());
+ System.out.println(" sig = " + field1.signature());
+ System.out.println(" gen sig = " + genSig);
+ if (!useOld && !expected.equals(genSig)) {
+ failure("FAILED: Expected generic signature for field1: " +
+ expected + ", received: " + genSig);
+ }
+ }
+ {
+ // Verify genericSignature() for a method
+ List genMethods = gen1Class.methodsByName("method1");
+ // There is only uno
+ Method method1 = (Method)genMethods.get(0);
+ expected = "(Ttt;)Ttt;";
+ genSig = method1.genericSignature();
+ System.out.println("method1 name = " + method1);
+ System.out.println(" type = " + gen1Class.signature());
+ System.out.println(" sig = " + method1.signature());
+ System.out.println(" gen sig = " + genSig);
+ System.out.println(" bridge = " + method1.isBridge());
+ if (!useOld && !expected.equals(genSig)) {
+ failure("FAILED: Expected generic signature for method1: " +
+ expected + ", received: " + genSig);
+ }
+
+ // Verify this is not a bridge method
+ if (method1.isBridge()) {
+ failure("FAILED: Expected gen1.method1 to not be a bridge"
+ + " method but it is");
+ }
+
+ // Verify genericSignature for a local var
+ List localVars = method1.variables();
+ String[] expectedGenSigs = { "Ttt", "Gen1<String>" };
+ for ( int ii = 0 ; ii < localVars.size(); ii++) {
+ expected = expectedGenSigs[ii];
+ LocalVariable pp = (LocalVariable)localVars.get(ii);
+ genSig = pp.genericSignature();
+ System.out.println(" local var " + ii + " = " + pp.name());
+ System.out.println(" sig = " + pp.signature());
+ System.out.println(" gen sig = " + genSig);
+ //jjh Uncomment when generics for local vars are available from
+ //jjh javac and hotspot. See:
+ //jjh 4914602 LVT entries for classfile version > 49 must be converted
+ //jjh if (!useOld && !expected.equals(genSig)) {
+ //jjh failure("FAILED: Expected generic signature for local var: " +
+ //jjh expected + ", received: " + genSig);
+ //jjh }
+ }
+ }
+ {
+ // Verify genericSignature() for a method2
+ List genMethods = gen1Class.methodsByName("method2");
+ // There is only uno
+ Method method2 = (Method)genMethods.get(0);
+ expected = "null";
+ genSig = method2.genericSignature();
+ genSig = (genSig == null) ? "null" : genSig;
+ System.out.println("method2 name = " + method2);
+ System.out.println(" type = " + gen1Class.signature());
+ System.out.println(" sig = " + method2.signature());
+ System.out.println(" gen sig = " + genSig);
+ System.out.println(" bridge = " + method2.isBridge());
+ if (!useOld && !expected.equals(genSig)) {
+ failure("FAILED: Expected generic signature for method2: " +
+ expected + ", received: " + genSig);
+ }
+
+ // Verify this is not a bridge method
+ if (method2.isBridge()) {
+ failure("FAILED: Expected gen1.method2 to not be a bridge"
+ + " method but it is");
+ }
+
+ // Verify genericSignature for a local var
+ List localVars = method2.variables();
+ expected = "null";
+ for ( int ii = 0 ; ii < localVars.size(); ii++) {
+ LocalVariable pp = (LocalVariable)localVars.get(ii);
+ genSig = pp.genericSignature();
+ genSig = (genSig == null) ? "null" : genSig;
+
+ System.out.println(" local var " + ii + " = " + pp.name());
+ System.out.println(" sig = " + pp.signature());
+ System.out.println(" gen sig = " + genSig);
+ if (!useOld && !expected.equals(genSig)) {
+ failure("FAILED: Expected generic signature for local var: " +
+ expected + ", received: " + genSig);
+ }
+ }
+ }
+ {
+ Field sub1Field = targetClass.fieldByName("sub1Field");
+ ReferenceType sub1Class = (ReferenceType)(sub1Field.type());
+ List<Method> sub1Methods = sub1Class.methodsByName("method1");
+ for (Method mm: sub1Methods) {
+ System.out.println("method is: " + mm);
+ }
+ /*
+ * There should be two methods - the first is the
+ * method1 defined in Sub1, and the 2nd is a javac generated
+ * bridge method.
+ */
+ Method method1 = (Method)sub1Methods.get(1);
+ System.out.println("\nmethod1 name = " + method1);
+ System.out.println(" sig = " + method1.signature());
+ System.out.println(" bridge = " + method1.isBridge());
+ if (!useOld && !method1.isBridge()) {
+ failure("FAILED: Expected Sub1.method1 to be a bridge method"
+ + " but it isn't");
+ }
+
+ }
+ {
+ // Verify genericSignature for a non generic class
+ genSig = targetClass.genericSignature();
+ if (genSig != null) {
+ failure("FAILED: Expected generic signature = null for "
+ + targetClass.name() + ", received: " + genSig);
+ }
+ }
+ {
+ // Verify genericSignature for a non generic field
+ Field objField = targetClass.fieldByName("objField");
+ genSig = objField.genericSignature();
+ if (genSig != null) {
+ failure("FAILED: Expected generic signature = null for "
+ + objField.name() + ", received: " + genSig);
+ }
+ }
+ {
+ // Verify genericSignature for a non generic method
+ List methods = targetClass.methodsByName("main");
+ Method main = (Method)methods.get(0);
+ genSig = main.genericSignature();
+ if (genSig != null) {
+ failure("FAILED: Expected generic signature = null for "
+ + main.name() + ", received: " + genSig);
+ }
+ }
+ if (0 == 1) {
+ mainThread = bpe.thread();
+ EventRequestManager erm = vm().eventRequestManager();
+ StepRequest request = erm.createStepRequest(mainThread,
+ StepRequest.STEP_LINE,
+ StepRequest.STEP_INTO);
+ request.enable();
+ }
+
+ /*
+ * 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("GenericsTest: passed");
+ } else {
+ throw new Exception("GenericsTest: failed");
+ }
+ }
+}