Java example source code file (VarargsTest.java)

This example Java source code file (VarargsTest.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

arraylist, breakpointevent, classtype, constructor, exception, field, jdi, method, referencetype, string, stringreference, testscaffold, util, value, varargstarg, varargstest

The VarargsTest.java Java example source code

/*
 * Copyright (c) 2003, 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 4870984
 *  @summary  JPDA: Add support for RFE 4856541 - varargs
 *
 *  @author jjh
 *
 *  @run build TestScaffold VMConnection TargetListener TargetAdapter
 *  @run compile -g VarargsTest.java
 *  @run main VarargsTest
 */
import com.sun.jdi.*;
import com.sun.jdi.event.*;
import com.sun.jdi.request.*;

import java.util.*;

    /********** target program **********/

class VarargsTarg {

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

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

    String iname;

    VarargsTarg(String ... name) {
        iname = "";
        for (int ii = 0; ii < name.length; ii++) {
            iname += name[ii];
        }
    }

    public static void main(String[] args){
        System.out.println("Howdy!");
        /*
         * This isn't really part of the test, it just shows
         * the kinds of calls the debugger test will do and lets
         * you verify how javac handles these calls.
         */
        System.out.println("debuggee: " + varString());
        System.out.println("debuggee: " + varString(null));
        System.out.println("debuggee: " + varString("a"));
        System.out.println("debuggee: " + varString("b", "c"));
        System.out.println("debuggee: " + fixedString(null));
        System.out.println("debuggee: " + vt1.varStringInstance(vt1, vt2));
        System.out.println("debuggge: " + varInt(1, 2, 3));
        System.out.println("debuggee: " + varInteger( new Integer(89)));

        // Should be autoboxed: javac converts the ints to Integers
        // Needs a new method in java.lang.Integer which is only
        // in the generics workspace.
        System.out.println("debugggee: " + varInteger(3, 5, 6));

        System.out.println("Goodbye from VarargsTarg!");
        bkpt();
    }
    static void bkpt() {
    }

    /*
     * Define the methods to be called from the debugger
     */
    static String fixedInt(int p1) {
        return "" + p1;
    }

    static String fixedInteger(Integer p1) {
        return "" + p1;
    }

     static String varInt(int... ss) {
         String retVal = "";
         for (int ii = 0; ii < ss.length; ii++) {
             retVal += ss[ii];
         }
         return retVal;
     }

    static String varInteger(Integer... ss) {
        String retVal = "";
        for (int ii = 0; ii < ss.length; ii++) {
            retVal += ss[ii];
        }
        return retVal;
    }

    static String varString(String... ss) {
        if (ss == null) {
            return "-null-";
        }

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

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

    static String fixedString(String ss) {
        return "-fixed-";
    }

    String varStringInstance(VarargsTarg... args) {
        if (args == null) {
            return "-null-";
        }
        //System.out.println("debugee: ss length = " + ss.length);
        String retVal = iname + ": ";
        for (int ii = 0; ii < args.length; ii++) {
            retVal += args[ii].iname;
        }
        return retVal;
    }

}

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

public class VarargsTest extends TestScaffold {
    ClassType targetClass;
    ThreadReference mainThread;

    VarargsTest (String args[]) {
        super(args);
    }

    public static void main(String[] args)      throws Exception {
        new VarargsTest(args).startTests();
    }

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

    /*
     * Call a method in the debuggee and verify the return value.
     */
    void doInvoke(Object ct, Method mm, List args, Object expected) {
        StringReference returnValue = null;
        try {
            returnValue = doInvokeNoVerify(ct, mm, args);
        } catch (Exception ee) {
            fail("failure: invokeMethod got exception : " + ee);
            ee.printStackTrace();
            return;
        }
        if (!returnValue.value().equals(expected)) {
            fail("failure: expected \"" + expected + "\", got \"" +
                 returnValue.value() + "\"");
        }
    }

    /*
     * Call a method in the debuggee.
     */
    StringReference doInvokeNoVerify(Object ct, Method mm, List args)
        throws Exception {
        StringReference returnValue = null;
        if (ct instanceof ClassType) {
            returnValue = (StringReference)((ClassType)ct).
                invokeMethod(mainThread, mm, args, 0);
        } else {
            returnValue = (StringReference)((ObjectReference)ct).
                invokeMethod(mainThread, mm, args, 0);
        }
        return returnValue;
    }

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

    protected void runTests() throws Exception {
        /*
         * Get to the top of main()
         * to determine targetClass and mainThread
         */
        BreakpointEvent bpe = startToMain("VarargsTarg");
        targetClass = (ClassType)bpe.location().declaringType();
        mainThread = bpe.thread();

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

        /*
         * Find Method objects for varString and varString2
         * 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
         * (and constructor) passing primitives, Strings, and Objects, and also
         * passing arrays of the above instead of individual args.
         * The same code is used in the underlying JDI implementations
         * for calling instance methods, static methods, and constructors
         * so this test doesn't have to try all possible argument configurations
         * 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 (!varString.isVarArgs()) {
            fail("failure: varString is not flagged as being var args");
        }
        if (!varString2.isVarArgs()) {
            fail("failure: varString2 is not flagged as being var args");
        }

        /*
         * 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.add(null);
            doInvoke(targetClass, varString, nullArg1,  "-null-");
        }
        {
            // call varString(9)
            ArrayList nullArg2 = new ArrayList(1);
            nullArg2.add(vm().mirrorOf(9));
            doInvoke(targetClass, varString2, nullArg2,  "9");
        }
        {
            // call varString(9, null)
            ArrayList nullArg2 = new ArrayList(2);
            nullArg2.add(vm().mirrorOf(9));
            nullArg2.add(null);
            doInvoke(targetClass, varString2, nullArg2,  "9-null-");
        }
        {
            ArrayList args1 = new ArrayList(4);
            args1.add(vm().mirrorOf("1"));

            // call varString("1")
            doInvoke(targetClass, varString, args1, "1");

            // call varString("1", "2")
            args1.add(vm().mirrorOf("2"));
            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(vm().mirrorOf("1"));

            // call varString2(9, "1");
            doInvoke(targetClass, varString2, args2, "91");

            // call varString2(9, "1", "2");
            args2.add(vm().mirrorOf("2"));
            doInvoke(targetClass, varString2, args2, "912");
        }

        {
            /*
             * Passing an array of Strings should work too.
             */
            Field ff = targetClass.fieldByName("strArray");
            Value vv1 = targetClass.getValue(ff);

            // call varString(new String[] {"a", "b"})
            ArrayList argsArray = new ArrayList(1);
            argsArray.add(vv1);
            doInvoke(targetClass, varString, argsArray, "ab");

            /*
             * But passing an array of Strings and another String
             * should fail
             */
            argsArray.add(vm().mirrorOf("x"));
            boolean isOk = false;
            try {
                // call varString(new String[] {"a", "b"}, "x")
                doInvokeNoVerify(targetClass, varString, argsArray);
            } catch (Exception ee) {
                /*
                 * Since the number of args passed is > than
                 * the number of params, JDI assumes they are var args
                 * and tries to put the array containing the "a" and
                 * "be" elements into a the first element of an array
                 * of Strings.  This fails because you can't store
                 * an array into a String
                 */
                isOk = true;
                //ee.printStackTrace();
            }
            if (!isOk) {
                fail("failure: an array and a String didn't cause an exception");
            }
        }

        {
            /*
             * Test calling instance method instead of static method,
             * and passing non-String objects
             */
            Field vtField = targetClass.fieldByName("vt1");
            Value vv1 = targetClass.getValue(vtField);

            vtField = targetClass.fieldByName("vt2");
            Value vv2 = targetClass.getValue(vtField);

            /* Create a new instance by calling the varargs
             * ctor.
             * call new VarargsTarg("vt3", "xx");
             */
            Value vv3;
            {
                mList = rt.methodsByName("<init>");
                Method ctor = (Method)mList.get(0);
                if (!ctor.isVarArgs()) {
                    fail("failure: Constructor is not varargs");
                }
                ArrayList argsArray = new ArrayList(2);
                argsArray.add(vm().mirrorOf("vt3"));
                argsArray.add(vm().mirrorOf("xx"));
                vv3 = targetClass.newInstance(mainThread, ctor, argsArray, 0);
            }
            // call vt1.varStringInstance(vv1, vv2, vv3)
            mList = rt.methodsByName("varStringInstance");
            Method varStringInstance = (Method)mList.get(0);

            ArrayList argsArray = new ArrayList(3);
            argsArray.add(vv1);
            argsArray.add(vv2);
            argsArray.add(vv3);
            doInvoke(vv1, varStringInstance, argsArray, "vt1: vt1vt2vt3xx");
        }
        {
            /*
             * tests with primitive types
             */
            List mlist;
            Method mm;
            ArrayList ll = new ArrayList(2);

            // call fixedInt(21)
            mlist = rt.methodsByName("fixedInt");
            mm = (Method)mlist.get(0);
            ll.add(vm().mirrorOf(21));
            doInvoke(targetClass, mm, ll, "21");

            // autoboxing is not implemented in JDI.
            // call fixedInteger(21)
            //mlist = rt.methodsByName("fixedInteger");
            //mm = (Method)mlist.get(0);
            //doInvoke(targetClass, mm, ll, "21");

            mlist = rt.methodsByName("varInt");
            mm = (Method)mlist.get(0);

            // call varInt( new int[] {1, 2});
            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, mm, ll, "2122");

            mlist = rt.methodsByName("varInteger");
            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 test
         * if anything has called failure("foo") testFailed will be true
         */
        if (!testFailed) {
            println("VarargsTest: passed");
        } else {
            throw new Exception("VarargsTest: failed");
        }
    }
}