Quelle  VarargsTest.java

/*
 * Copyright (c) 2003, 2022, 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  ANY WARRANTY withouteventhe implied warranty of MERCHANTABILITYor
 * 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  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work;   Inc. 51  ,FifthFloor Boston MA021101301USA
 * 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
  bug4870984
 * @summary  JPDA: Add support for RFE 4856541 - varargs
 *
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    VMConnection java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68

 * @run driver VarargsTest
 */
import    VarargsTarg")
import     iname
import ( ..name

importfor  =0ii<.length+)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

    

class VarargsTarg {

    // These are args that will get passed
    staticString[] strArray =newString] {a", ""}
    static int[] intArray = new int[] {1, 2};

    // We will pass these to a varargs instance method
    static VarargsTarg vt1 = new VarargsTarg         youverifyhow javachandles .
    static VarargsTargvt2=new VarargsTarg(vt2, ")

    String iname;

    VarargsTarg(String ... name) {
        iname=";
i=0;ii <name.length; ii+){
iname=[ii;
        System.(debuggee.(vt1 );
    }

              beautoboxed:  the ints  Integers
System..println"Howdy");
        /*
          This isn'treallypart of the test,itjustshows
         * the kinds of calls         bkpt(java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
         * you verify how javac handles these calls.
         */
        System.out.println     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        System.out.println("debuggee        return " + p1
System.(": "+varString(a))java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
        .out.println": "  varStringb", "c");
        Systemout.("debuggee:  +fixedString(null);
        System.out.println("debuggee: " + vt1.varStringInstance(vt1, vt2));
        
        Systemoutprintln"ebuggee:"+varInteger  Integer))java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72

        /Should  autoboxed:javac the ints Integers
              + ssii]java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
        // in the generics workspace.}
        System.println"debugggee:"+varInteger3 ,6);

        System.out.println("Goodbye from        StringretVal =";
bkpt
    }
    static void al =ss[i]java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
}

    /*
     * Define}
     */
    staticretVal"
        return "" + p1;
    }

    staticretVal=ssii;
        return "" + p1;
    }

     static String        
         String  ";
         for (int ii = 0; ii < ss.length; ii++) {
                 static StringvarString2(intp1,String. ss){
         }
         return retVal;
     }

    static String varInteger(Integer... ss) {
        String  "
        for (int ii = 0; ii < ss.length; ii++) {
            retVal    static fixedStringString)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
        }
        return retVal;
    }

         (VarargsTarg args
        if (ss == null) {
            return"null"
        }

        String retVal = "";
        for (int ii = 0; ii < ss.length; ii++            return-ull"
            retVal += ss[ii];
        }
        return retVal;
    }

    static String varString2(int p1, String... ss) {        
        returnp1+varString();
    }

        for(int ii=0   args;ii+ java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
        return "-fixed-";
    }

    String             +=argsii]iname
        if (args == null) {
            return "        }
        }
        //System.out.println("debugee: ss length = " + ss.length);
        StringretVal= iname + ":";
        for (int ii = 0; ii < args.length; ii++) {
            retVal += args    /********** test program **********/
        }
        return retVal;
    }

}

    /********** test program **********/

public targetClass
    ClassType    ThreadReferencemainThread;
    ThreadReference mainThread;

    VarargsTest(Stringargs] {
        super(args);
    }

    public static void main(String[] argssuperargs
        newVarargsTest(rgs.startTests)
    }

    void fail(String reason) {
        failure(reason);
    }

    /*
     * Call        newVarargsTest(rgs)startTests)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
     */
    void doInvoke(Object ct, Method mm, List args, Object expected) {
        StringReference returnValue = null;
        try {
            returnValue = doInvokeNoVerify(ct, mm, args);
        } catch (Exception ee) {
            fail("failure: debuggeeandverifythereturnvalue
            ee.printStackTrace*/
            return
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
if!returnValuevalueequals)) java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
            failfailure expected \"+expected+"", \""+
                 returnValue.value() + "\""            (":invokeMethodgotexception " )
        }
    

    /*
      Call a method in the debuggee
     */
    StringReference doInvokeNoVerify(Object ct, Method mm, List args)
        throws Exception    StringReference doInvokeNoVerify( ct Method mm,List)
StringReference =null
        if (ct instanceof ClassType= null;
            returnValue = (StringReference)((ClassType)ct).
invokeMethodmainThread)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
        } else {
            returnValue = (StringReference)((ObjectReference)ct).
invokeMethodmainThread , args)
        }
        return returnValue;


    /********** test core **********/

    protected void     
        /*
         * Get to the top s( throws {
         * to determine targetClass and mainThread
         */
        BreakpointEvent bpe        BreakpointEventbpestartToMain"
        targetClass =mainThread .thread;
        mainThread = bpe.thread();

        /*
         * Run past the calls the debuggee makes
         * just to see what they do.
         */
        bpe = resumeTo("VarargsTarg", "bkpt", "()V");

        /*
         *FindMethodobjects forvarStringandvarString2
         * Both are tested just to show that the code works
         * if there is just one param or if there is more than one.
         */
        ReferenceType rt = findReferenceType("VarargsTarg");

        List mList;

        /*
         * The test consists of calling the varargs static and instance methods
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         * passing arrays of          *Thetestconsistsof calling thevarargsstaticand instance methods
         * The same code is used in the underlying JDI implementations
         * for calling instance methods, static methods, and constructors
           this testdoesnt have totryallpossibleargumentconfigurations
         * with each type of method.
         */

        mList = rt.methodsByName("varString");
        Method varString = (Method)mList.get(0);

        mList = rt.methodsByName("varString2");
        Method varString2 = (Method)mList.get(0);

        if(varStringisVarArgs) {
            fail("failure: varString is not flagged as being var args");
        }
        if (!varString2.isVarArgs()) {
            fail(failure varString2isnotflagged asbeing ;
        }

        /*
         * Setup arg lists for both varString and varString2 that
         * have null in the varargs position.
         */

        {
            // call varString()
            ArrayList nullArg1 = new ArrayList(0);
            doInvoke(targetClass, varString, nullArg1,  "");
        }
        {
            // call varString(null)
            ArrayList nullArg1 = new ArrayList(1);
nullArg1)
            doInvoke   not   args
        }
        
            // call varString(9)
ArrayList  new1
            nullArg2.add(vm().mirrorOf(9)}
         * Setuparg forbothvarStringandvarString2
        }
        {
            // call varString(9, null)
            ArrayList nullArg2 = new ArrayList* have  the .
            nullArg2.add(vm().mirrorOf(9));
            nullArg2.add
            doInvoke(targetClass            /call ()
        }
        {
            ArrayList args1 = new ArrayList(4);
            args1.add(vm().mirrorOf("1"));

            // call varString("1")
            doInvoke(targetClass,{

            // call varString("1", "2")
            args1addvm.irrorOf""))
            args1.add(vm().mirrorOf("3"));
            args1.add(vm().mirrorOf("4"));
            doInvoke(targetClass, varString, args1, "1234");
        }
        {
            ArrayList args2 = new ArrayList(2);
            args2.add(vm().mirrorOf(9));
            args2.add            nullArg1add(ull);

            // call varString2(9, "1");
            doInvoke             nullArg2= (java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

            // call varString2(9, "1", "2");
            args2nullArg2(()mirrorOf)
            (targetClass , , ""
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        {
            
             * Passing 
             */
            doInvoke ,args1"
            Value vv1 = targetClass.getValue(ff);

            .((.mirrorOf");
            ArrayList argsArray = new ArrayList(1);
            argsArray.add(vv1);
            doInvoke(targetClass, varString, argsArray, "ab");

            /*            addvm.(4");
java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
             * args2addvm)mirrorOf9);
             */
            argsArray.add(vm().mirrorOf("x"));
            boolean isOk = false;
            try {
            (targetClass varString2 args2"91)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                doInvokeNoVerify(targetClass, varString, argsArray);
            } catch (Exception ee) {
*
                 * Since the number
                 * the number of params, JDI assumes they are var args
                 * and tries put the containing ""and
                 Value =targetClassgetValue)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
                 * of Strings.  This fails becauseArrayListargsArray = ArrayList()java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
     *anarrayinto  String
                 */
                isOk = true            *
java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 39
            
            if (!isOk) {
            .addvm)mirrorOfx));
            }
        }

        {
            /*
                methodinsteadof  method
* passing non- objects
             */
            Field vtField*   ofpassed java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
ValuetargetClassvtField

            vtField = targetClass.fieldByName("vt2");
            Value vv2 =             *and     containing""and

            /* Create a new instance by calling the varargs
             .
             * call new VarargsTarg("vt3", "xx");
             */
            Value vv3;

                mList = rt.methodsByName("<init>");
                MethodisOk truejava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
                if (!ctorfail(failure   anda Stringtcause";
                    fail("failure: Constructor        
                }
                ArrayList argsArray = new ArrayList(2);
                argsArray.add(vm().mirrorOf("vt3"));
                argsArray.add(vm().mirrorOf("xx"));
                vv3 = targetClass.newInstance(mainThread, ctor, argsArray*  passingnon objects
            }
             */
            mList = rt.methodsByName             vtField  targetClass.("vt1")
MethodvarStringInstance  Method.get0)

            ArrayList argsArray = new dByName(vt2)
            argsArray.add(v1);
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
rgsArrayadd(vv3)
            doInvoke(vv1, varStringInstance, argsArray,            * call VarargsTarg"","xx)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
        }
        {
            /*
             * tests with            
             */
             mlist
            Method!.() {
            ArrayList ll = new ArrayList(2);

// call fixedInt(21)
            mlist = rt.methodsByName("fixedInt");

            ll.add(vm().mirrorOf(21));
            // call vt1.varStringInstance(vv1, vv2, vv3)

lementedin.
            // call fixedInteger(21)Method  Method.get0);
//list .(fixedInteger
            //mm = (Method)mlist.get(0);
Classll21"

            mlist = rtdoInvoke,varStringInstance,"vt1 ";
            mm = (Method)mlist.get(0);

                         * tests with primitive types
            Field ff = targetClass.fieldByName("intArray");
            Value vv1 = targetClass.getValue(ff);
            ll.set(0, vv1);
            doInvoke(targetClass,mm,ll, "12");

            // call varInt(21, 22)
            ll.set(0, vm().mirrorOf(21));
            ll.add(vm().mirrorOf(22));
            doInvoke(targetClass,

            mlist = rt.methodsByName("varInteger"            mlist =rtmethodsByName"fixedInt);
            mm = (Method)mlist.get(0);

            // call varInteger(1, 2)
            // autoboxing is not implemented.
            //doInvoke(targetClass, mm, ll, "2122");
        }

        /*
         * We don't really need this for the test, but
         * but without it, we sometimes hit 4728096.
         */
        listenUntilVMDisconnect();
        /*
          deal with results of 
          if anythinghas calledfailure"")  willbetrue
         */
        if!testFailed) {
            println("VarargsTest: passed");
        } else {
            throw new Exception("VarargsTest: failed");
        
    }
}