438 lines
14 KiB
Java
438 lines
14 KiB
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 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 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
|
|
* "b" elements into 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");
|
|
}
|
|
}
|
|
}
|