/*

 * 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.

 *

 */

/**

 *  @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 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");

        }

    }

}