jdk/test/com/sun/jdi/VarargsTest.java - platform/libcore - Git at Google

 /*
  * 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 4870984
  *  @summary  JPDA: Add support for RFE 4856541 - varargs
  *
  *  @author jjh
  *
  *  @modules jdk.jdi
  *  @run build TestScaffold VMConnection TargetListener TargetAdapter
  *  @run compile -g VarargsTest.java
  *  @run driver 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");
         }
     }
 }
	/*
	* 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 4870984
	* @summary JPDA: Add support for RFE 4856541 - varargs
	*
	* @author jjh
	*
	* @modules jdk.jdi
	* @run build TestScaffold VMConnection TargetListener TargetAdapter
	* @run compile -g VarargsTest.java
	* @run driver 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");
	}
	}
	}