1 /*

     2  * Copyright 2001 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  */

    23 

    24 /**

    25  *  @test

    26  *  @bug 4439631

    27  *  @bug 4448721

    28  *  @bug 4448603

    29  *  @summary Test access to ranges within ArrayReferences

    30  *

    31  *  @author Robert Field

    32  *

    33  *  @run build TestScaffold VMConnection TargetListener TargetAdapter

    34  *  @run compile -g ArrayRangeTest.java

    35  *  @run main ArrayRangeTest

    36  */

    37 import com.sun.jdi.*;

    38 import com.sun.jdi.event.*;

    39 import com.sun.jdi.request.*;

    40 

    41 import java.util.*;

    42 

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

    44 

    45 class ArrayRangeTarg {

    46     static int[] emptyArray = {};

    47     static int[] fullArray = {0, 100, 200, 300, 400};

    48 

    49     public static void main(String[] args) {

    50         System.out.println("Goodbye from ArrayRangeTarg!");

    51     }

    52 }

    53 

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

    55 

    56 public class ArrayRangeTest extends TestScaffold {

    57     ReferenceType targetClass;

    58 

    59     class Sample {

    60         Sample(String name, ArrayReference arrRef, int[] expected) {

    61             this.name = name;

    62             this.arrRef = arrRef;

    63             this.expected = expected;

    64         }

    65         String name;

    66         ArrayReference arrRef;

    67         int[] expected;

    68     }

    69 

    70     ArrayRangeTest (String args[]) {

    71         super(args);

    72     }

    73 

    74     public static void main(String[] args)      throws Exception {

    75         new ArrayRangeTest(args).startTests();

    76     }

    77 

    78     /********** test assist **********/

    79 

    80     String arr(int a[]) {

    81         StringBuffer buf = new StringBuffer();

    82         buf.append('[');

    83         if (a.length > 0) {

    84             buf.append(a[0]);

    85             for (int i = 1; i < a.length; ++i) {

    86                 buf.append(',');

    87                 buf.append(a[i]);

    88             }

    89         }

    90         buf.append(']');

    91         return buf.toString();

    92     }

    93 

    94     void getValueGood(Sample samp, int index) {

    95         try {

    96             Value val = samp.arrRef.getValue(index);

    97             int ival = ((IntegerValue)val).value();

    98             if (ival != samp.expected[index]) {

    99                 failure("FAIL - " + samp.name +

   100                         ".getValue(" + index + ") - wrong value=" + ival);

   101             } else {

   102                 println("pass - " + samp.name +

   103                         ".getValue(" + index + ") - value=" + ival);

   104             }

   105         } catch (Throwable exc) {

   106             failure("FAIL - " + samp.name +

   107                     ".getValue(" + index + ") - unexpected: " + exc);

   108         }

   109     }

   110 

   111     void getValueBad(Sample samp, int index) {

   112         try {

   113             Value val = samp.arrRef.getValue(index);

   114             failure("FAIL - " + samp.name +

   115                     ".getValue(" + index + ") - no expected exception");

   116         } catch (IndexOutOfBoundsException exc) {

   117             println("pass - " + samp.name +

   118                     ".getValue(" + index + ") - got expected: " + exc);

   119         } catch (Throwable exc) {

   120             failure("FAIL - " + samp.name +

   121                     ".getValue(" + index + ") - unexpected: " + exc);

   122         }

   123     }

   124 

   125     void getValuesGood(Sample samp) {

   126         String desc = samp.name + ".getValues()";

   127         try {

   128             List vals = samp.arrRef.getValues();

   129             if (vals.size() != samp.expected.length) {

   130                 failure("FAIL - " + desc +

   131                         " - wrong size=" + vals.size() +

   132                         " , expected: " + samp.expected.length);

   133             }

   134             for (int index = 0; index < vals.size(); ++index) {

   135                 int ival = ((IntegerValue)vals.get(index)).value();

   136                 if (ival != samp.expected[index]) {

   137                     failure("FAIL - " + desc +

   138                             " - wrong value=" + ival);

   139                     return;

   140                 }

   141             }

   142             println("pass - " + samp.name + ".getValues())");

   143         } catch (Throwable exc) {

   144             failure("FAIL - " + desc  +

   145                     " - unexpected: " + exc);

   146         }

   147     }

   148 

   149     void getValuesGood(Sample samp, int index, int length) {

   150         try {

   151             List vals = samp.arrRef.getValues(index, length);

   152             if (vals.size() !=

   153                  ((length==-1)? (samp.expected.length - index) : length)) {

   154                 failure("FAIL - " + samp.name + ".getValues(" +

   155                         index + ", " + length + ") - wrong size=" +

   156                         vals.size());

   157             }

   158             for (int i = 0; i < vals.size(); ++i) {

   159                 int ival = ((IntegerValue)vals.get(i)).value();

   160                 if (ival != samp.expected[index + i]) {

   161                     failure("FAIL - " + samp.name + ".getValues(" +

   162                             index + ", " + length + ") - wrong value=" +

   163                             ival);

   164                     return;

   165                 }

   166             }

   167             println("pass - " + samp.name + ".getValues(" +

   168                     index + ", " + length + "))");

   169         } catch (Throwable exc) {

   170             failure("FAIL - " + samp.name + ".getValues(" +

   171                     index + ", " + length + ") - unexpected: " + exc);

   172         }

   173     }

   174 

   175     void getValuesBad(Sample samp, int index, int length) {

   176         try {

   177             List vals = samp.arrRef.getValues(index, length);

   178             failure("FAIL - " + samp.name + ".getValues(" +

   179                         index + ", " + length + ") - no expected exception");

   180         } catch (IndexOutOfBoundsException exc) {

   181             println("pass - " + samp.name + ".getValue(" +

   182                     index + ", " + length + ") - got expected: " + exc);

   183         } catch (Throwable exc) {

   184             failure("FAIL - " + samp.name + ".getValues(" +

   185                     index + ", " + length + ") - unexpected: " + exc);

   186         }

   187     }

   188 

   189     void setValueGood(Sample samp, int index, int ival) {

   190         try {

   191             Value val = vm().mirrorOf(ival);

   192             samp.arrRef.setValue(index, val);

   193             println("pass - " + samp.name +

   194                     ".setValue(" + index + ", ..)");

   195         } catch (Throwable exc) {

   196             failure("FAIL - " + samp.name +

   197                     ".setValue(" + index + ",...) - unexpected: " + exc);

   198         }

   199     }

   200 

   201     void setValueBad(Sample samp, int index, int ival) {

   202         try {

   203             Value val = vm().mirrorOf(ival);

   204             samp.arrRef.setValue(index, val);

   205             failure("FAIL - " + samp.name +

   206                     ".setValue(" + index + ", ..) - no expected exception");

   207         } catch (IndexOutOfBoundsException exc) {

   208             println("pass - " + samp.name +

   209                     ".setValue(" + index + ",...) - got expected: " + exc);

   210         } catch (Throwable exc) {

   211             failure("FAIL - " + samp.name +

   212                     ".setValue(" + index + ",...) - unexpected: " + exc);

   213         }

   214     }

   215 

   216     void setValuesGood(Sample samp, int[] valArray) {

   217         String desc = samp.name + ".setValues(" + arr(valArray) + ")";

   218         try {

   219             List values = new ArrayList();

   220             for (int i = 0; i < valArray.length; ++i) {

   221                 Value val = vm().mirrorOf(valArray[i]);

   222                 values.add(val);

   223             }

   224             samp.arrRef.setValues(values);

   225             println("pass - " + desc);

   226         } catch (Throwable exc) {

   227             failure("FAIL - " + desc + " - unexpected: " + exc);

   228         }

   229     }

   230 

   231     void setValuesGood(Sample samp, int index, int[] valArray,

   232                        int srcInx, int length) {

   233         String desc = samp.name + ".setValues(" + index + ", " +

   234             arr(valArray) + ", " + srcInx + ", " + length + ")";

   235         try {

   236             List values = new ArrayList();

   237             for (int i = 0; i < valArray.length; ++i) {

   238                 Value val = vm().mirrorOf(valArray[i]);

   239                 values.add(val);

   240             }

   241             samp.arrRef.setValues(index, values, srcInx, length);

   242             println("pass - " + desc);

   243         } catch (Throwable exc) {

   244             failure("FAIL - " + desc + " - unexpected: " + exc);

   245         }

   246     }

   247 

   248     void setValuesBad(Sample samp, int index, int[] valArray,

   249                        int srcInx, int length) {

   250         String desc = samp.name + ".setValues(" + index + ", " +

   251             arr(valArray) + ", " + srcInx + ", " + length + ")";

   252         try {

   253             List values = new ArrayList();

   254             for (int i = 0; i < valArray.length; ++i) {

   255                 Value val = vm().mirrorOf(valArray[i]);

   256                 values.add(val);

   257             }

   258             samp.arrRef.setValues(index, values, srcInx, length);

   259             failure("FAIL - " + desc + " - no expected exception");

   260         } catch (IndexOutOfBoundsException exc) {

   261             println("pass - " + desc + " - got expected: " + exc);

   262         } catch (Throwable exc) {

   263             failure("FAIL - " + desc + " - unexpected: " + exc);

   264         }

   265     }

   266 

   267     void check(Sample samp, int[] expectArray) {

   268         String desc = samp.name + " - check - " + arr(expectArray);

   269 

   270         try {

   271             List vals = samp.arrRef.getValues();

   272             if (vals.size() != expectArray.length) {

   273                 failure("FAIL - " + desc +

   274                         " - wrong size=" + vals.size() +

   275                         " , expected: " + expectArray.length);

   276             }

   277             for (int index = 0; index < vals.size(); ++index) {

   278                 int ival = ((IntegerValue)vals.get(index)).value();

   279                 if (ival != expectArray[index]) {

   280                     failure("FAIL - " + desc +

   281                             " - wrong value=" + ival);

   282                     return;

   283                 }

   284             }

   285             println("pass - " + desc);

   286         } catch (Throwable exc) {

   287             failure("FAIL - " + desc  +

   288                     " - unexpected: " + exc);

   289         }

   290     }

   291 

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

   293 

   294     protected void runTests() throws Exception {

   295         /*

   296          * Get to the top of main() to determine targetClass

   297          */

   298         BreakpointEvent bpe = startToMain("ArrayRangeTarg");

   299         targetClass = bpe.location().declaringType();

   300         Field fullField = targetClass.fieldByName("fullArray");

   301         Field emptyField = targetClass.fieldByName("emptyArray");

   302         ArrayReference emptyAR = (ArrayReference)targetClass.getValue(emptyField);

   303         ArrayReference fullAR = (ArrayReference)targetClass.getValue(fullField);

   304         Sample full = new Sample("full", fullAR, ArrayRangeTarg.fullArray);

   305         Sample empty = new Sample("empty", emptyAR, ArrayRangeTarg.emptyArray);

   306 

   307         getValueGood(full, 0);

   308         getValueGood(full, 4);

   309 

   310         // index < 0

   311         getValueBad(full, -1);

   312         getValueBad(full, -2);

   313         getValueBad(empty, -1);

   314         getValueBad(empty, -2);

   315 

   316         // index >= length

   317         getValueBad(full, 5);

   318         getValueBad(empty, 0);

   319         getValueBad(empty, 5);

   320 

   321         getValuesGood(full);

   322         getValuesGood(empty);

   323 

   324         getValuesGood(full, 0, 5);

   325         getValuesGood(full, 0, 4);

   326         getValuesGood(full, 1, 4);

   327         getValuesGood(full, 5, 0);

   328         getValuesGood(full, 0, 0);

   329         getValuesGood(full, 0, -1);

   330         getValuesGood(full, 1, -1);

   331         getValuesGood(full, 5, -1);

   332 

   333         getValuesGood(empty, 0, 0);

   334         getValuesGood(empty, 0, -1);

   335 

   336         // index < 0

   337         getValuesBad(full, -1, 0);

   338         getValuesBad(full, -1, 3);

   339         getValuesBad(full, -1, -1);

   340         getValuesBad(empty, -1, 0);

   341         getValuesBad(full, -2, 0);

   342         getValuesBad(full, -2, 3);

   343         getValuesBad(full, -2, -1);

   344         getValuesBad(empty, -2, 0);

   345 

   346         // index > length()

   347         getValuesBad(full, 6, 0);

   348         getValuesBad(full, 6, -1);

   349         getValuesBad(empty, 1, 0);

   350         getValuesBad(empty, 1, -1);

   351 

   352         // length < 0

   353         getValuesBad(full, 0, -2);

   354         getValuesBad(empty, 0, -2);

   355 

   356         // index + length > length()

   357         getValuesBad(full, 0, 6);

   358         getValuesBad(full, 1, 5);

   359         getValuesBad(full, 2, 4);

   360         getValuesBad(full, 5, 1);

   361         getValuesBad(empty, 0, 1);

   362 

   363         setValueGood(full, 0, 55);

   364         setValueGood(full, 4, 66);

   365 

   366         // index < 0

   367         setValueBad(full, -1, 77);

   368         setValueBad(full, -2, 77);

   369 

   370         // index > length()

   371         setValueBad(full, 5, 77);

   372         setValueBad(full, 6, 77);

   373 

   374         check(full, new int[] {55, 100, 200, 300, 66});

   375 

   376         // index < 0

   377         setValueBad(empty, -1, 77);

   378         setValueBad(empty, -2, 77);

   379 

   380         // index > length()

   381         setValueBad(empty, 0, 77);

   382         setValueBad(empty, 1, 77);

   383 

   384         setValuesGood(full, new int[] {40, 41, 42});

   385         setValuesGood(full, new int[] {});

   386 

   387         check(full, new int[] {40, 41, 42, 300, 66});

   388 

   389         setValuesGood(full, new int[] {99, 51, 52, 53, 54, 55});

   390         setValuesGood(full, new int[] {50});

   391 

   392         check(full, new int[] {50, 51, 52, 53, 54});

   393 

   394         setValuesGood(empty, new int[] {});

   395         setValuesGood(empty, new int[] {88});

   396 

   397         setValuesGood(full, 2, new int[] {30, 31, 32, 33, 34, 35}, 0, 3);

   398         setValuesGood(full, 0, new int[] {80}, 0, 1);

   399 

   400         check(full, new int[] {80, 51, 30, 31, 32});

   401 

   402         setValuesGood(full, 0, new int[] {90, 91, 92, 93, 94, 95}, 3, 3);

   403         setValuesGood(full, 4, new int[] {81}, 0, 1);

   404 

   405         check(full, new int[] {93, 94, 95, 31, 81});

   406 

   407         setValuesGood(full, 3, new int[] {60, 61, 62, 63}, 0, -1);

   408         setValuesGood(full, 0, new int[] {82}, 0, -1);

   409 

   410         check(full, new int[] {82, 94, 95, 60, 61});

   411 

   412         setValuesGood(full, 3, new int[] {20, 21, 22, 23}, 1, -1);

   413         setValuesGood(full, 1, new int[] {83, 84}, 1, -1);

   414         setValuesGood(full, 1, new int[] {}, 0, -1);

   415         setValuesGood(full, 2, new int[] {}, 0, 0);

   416         setValuesGood(full, 3, new int[] {99}, 0, 0);

   417         setValuesGood(full, 4, new int[] {99, 98}, 1, 0);

   418 

   419         check(full, new int[] {82, 84, 95, 21, 22});

   420 

   421         setValuesGood(empty, 0, new int[] {}, 0, -1);

   422         setValuesGood(empty, 0, new int[] {}, 0, 0);

   423         setValuesGood(empty, 0, new int[] {99}, 0, 0);

   424         setValuesGood(empty, 0, new int[] {99, 98}, 1, 0);

   425 

   426         // index < 0

   427         setValuesBad(full, -1, new int[] {30, 31, 32, 33, 34, 35}, 0, 0);

   428         setValuesBad(full, -1, new int[] {30, 31, 32, 33, 34, 35}, 0, -1);

   429         setValuesBad(full, -2, new int[] {30, 31, 32, 33, 34, 35}, 0, -1);

   430         setValuesBad(empty, -1, new int[] {}, 0, 0);

   431         setValuesBad(empty, -2, new int[] {}, 0, 0);

   432 

   433         // index > length()

   434         setValuesBad(full, 6, new int[] {30, 31, 32, 33, 34, 35}, 0, 1);

   435         setValuesBad(full, 6, new int[] {30, 31, 32, 33, 34, 35}, 0, -1);

   436         setValuesBad(empty, 1, new int[] {4}, 0, 0);

   437         setValuesBad(empty, 1, new int[] {}, 0, 0);

   438         setValuesBad(empty, 1, new int[] {}, 0, -1);

   439 

   440         // srcIndex < 0

   441         setValuesBad(full, 0, new int[] {90, 91, 92, 93, 94, 95}, -1, 3);

   442         setValuesBad(full, 0, new int[] {90, 91, 92, 93, 94, 95}, -1, 0);

   443         setValuesBad(full, 0, new int[] {90, 91, 92, 93, 94, 95}, -1, -1);

   444         setValuesBad(full, 0, new int[] {90, 91, 92, 93, 94, 95}, -2, -1);

   445         setValuesBad(full, 1, new int[] {}, -1, -1);

   446         setValuesBad(full, 2, new int[] {}, -1, 0);

   447         setValuesBad(empty, 0, new int[] {}, -1, 0);

   448 

   449         // srcIndex > values.size()

   450         setValuesBad(full, 0, new int[] {81}, 2, 0);

   451         setValuesBad(full, 0, new int[] {81}, 2, 1);

   452         setValuesBad(full, 0, new int[] {81}, 2, -1);

   453         setValuesBad(full, 4, new int[] {}, 1, 0);

   454         setValuesBad(full, 1, new int[] {}, 1, -1);

   455         setValuesBad(full, 2, new int[] {}, 1, 0);

   456         setValuesBad(empty, 0, new int[] {}, 1, 0);

   457         setValuesBad(empty, 0, new int[] {5}, 2, 0);

   458 

   459         // length < 0 (length != -1)

   460         setValuesBad(full, 3, new int[] {60, 61, 62, 63}, 0, -2);

   461         setValuesBad(full, 3, new int[] {}, 0, -2);

   462 

   463         // index + length > length()

   464         setValuesBad(full, 0, new int[] {20, 21, 22, 23, 24, 25, 26}, 0, 6);

   465         setValuesBad(full, 1, new int[] {20, 21, 22, 23, 24, 25, 26}, 0, 5);

   466         setValuesBad(full, 2, new int[] {20, 21, 22, 23, 24, 25, 26}, 0, 4);

   467         setValuesBad(full, 3, new int[] {20, 21, 22, 23, 24, 25, 26}, 0, 3);

   468         setValuesBad(full, 4, new int[] {20, 21, 22, 23, 24, 25, 26}, 0, 2);

   469         setValuesBad(full, 5, new int[] {20, 21, 22, 23, 24, 25, 26}, 0, 1);

   470         setValuesBad(full, 6, new int[] {20, 21, 22, 23, 24, 25, 26}, 0, 0);

   471         setValuesBad(full, 2, new int[] {20, 21, 22, 23, 24, 25, 26}, 1, 4);

   472         setValuesBad(full, 3, new int[] {20, 21, 22, 23, 24, 25, 26}, 1, 3);

   473         setValuesBad(full, 4, new int[] {20, 21, 22, 23, 24, 25, 26}, 2, 2);

   474         setValuesBad(full, 5, new int[] {20, 21, 22, 23, 24, 25, 26}, 3, 1);

   475         setValuesBad(full, 6, new int[] {20, 21, 22, 23, 24, 25, 26}, 4, 0);

   476         setValuesBad(empty, 0, new int[] {6}, 0, 1);

   477 

   478         // srcIndex + length > values.size()

   479         setValuesBad(full, 0, new int[] {82}, 0, 2);

   480         setValuesBad(full, 0, new int[] {82}, 1, 1);

   481         setValuesBad(full, 0, new int[] {82}, 2, 0);

   482         setValuesBad(full, 0, new int[] {20, 21, 22}, 0, 4);

   483         setValuesBad(full, 0, new int[] {20, 21, 22}, 1, 3);

   484         setValuesBad(full, 0, new int[] {20, 21, 22}, 2, 2);

   485         setValuesBad(full, 0, new int[] {20, 21, 22}, 3, 1);

   486         setValuesBad(full, 0, new int[] {20, 21, 22}, 4, 0);

   487 

   488         check(full, new int[] {82, 84, 95, 21, 22});

   489 

   490         /*

   491          * resume the target until end

   492          */

   493         listenUntilVMDisconnect();

   494 

   495         /*

   496          * deal with results of test

   497          * if anything has called failure("foo") testFailed will be true

   498          */

   499         if (!testFailed) {

   500             println("ArrayRangeTest: passed");

   501         } else {

   502             throw new Exception("ArrayRangeTest: failed");

   503         }

   504     }

   505 }