test/jdk/com/sun/jdi/GenericsTest.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 4421040
 * @summary  JPDA: Add support for JSR-014 Generics
 * @author jjh
 *
 * @run build TestScaffold VMConnection TargetListener TargetAdapter
 * @run compile -g GenericsTest.java
 * @run driver 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");
        }
    }
}