1 /*
   2  * Copyright (c) 2018, 2019, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 package runtime.valhalla.valuetypes;
  25 
  26 import java.lang.reflect.Array;
  27 import java.util.Arrays;
  28 import java.util.ArrayList;
  29 import java.util.List;
  30 
  31 import static jdk.test.lib.Asserts.*;
  32 
  33 /*
  34  * @test ValueTypeArray
  35  * @summary Plain array test for Value Types
  36  * @library /test/lib
  37  * @compile -XDemitQtypes -XDenableValueTypes -XDallowWithFieldOperator -XDallowFlattenabilityModifiers -XDallowGenericsOverValues ValueTypeArray.java Point.java Long8Value.java Person.java
  38  * @run main/othervm -Xint  -XX:ValueArrayElemMaxFlatSize=-1 -XX:+EnableValhalla runtime.valhalla.valuetypes.ValueTypeArray
  39  * @run main/othervm -Xint  -XX:ValueArrayElemMaxFlatSize=0  -XX:+EnableValhalla runtime.valhalla.valuetypes.ValueTypeArray
  40  * @run main/othervm -Xcomp -XX:ValueArrayElemMaxFlatSize=-1 -XX:+EnableValhalla runtime.valhalla.valuetypes.ValueTypeArray
  41  * @run main/othervm -Xcomp -XX:ValueArrayElemMaxFlatSize=0  -XX:+EnableValhalla runtime.valhalla.valuetypes.ValueTypeArray
  42  */
  43 public class ValueTypeArray {
  44     public static void main(String[] args) {
  45         ValueTypeArray valueTypeArray = new ValueTypeArray();
  46         valueTypeArray.run();
  47     }
  48 
  49     public void run() {
  50         testClassForName();
  51         testSimplePointArray();
  52         testLong8Array();
  53         testMixedPersonArray();
  54         testMultiDimPointArray();
  55         testComposition();
  56 
  57         testSanityCheckcasts();
  58         testObjectArrayOfValues();
  59 
  60         testReflectArray();
  61         testUtilArrays();
  62     }
  63 
  64     void testClassForName() {
  65         String arrayClsName = "[Lruntime.valhalla.valuetypes.Point;";
  66         String qarrayClsName = "[Qruntime.valhalla.valuetypes.Point;";
  67         try {
  68             // L-type..
  69             Class<?> arrayCls = Class.forName(arrayClsName);
  70             assertTrue(arrayCls.isArray(), "Expected an array class");
  71 
  72             assertTrue(arrayCls.getComponentType() == Point.class.asBoxType(),


  73                        "Expected component type of Point.class got: " + arrayCls.getComponentType());
  74 
  75             arrayClsName = "[" + arrayClsName;
  76             Class<?> mulArrayCls = Class.forName(arrayClsName);
  77             assertTrue(mulArrayCls.isArray());
  78             assertTrue(mulArrayCls.getComponentType() == arrayCls);
  79 
  80             // Q-type...
  81             arrayCls = Class.forName(qarrayClsName);
  82             assertTrue(arrayCls.isArray(), "Expected an array class");
  83 
  84             assertTrue(arrayCls.getComponentType() == Point.class.asValueType(),
  85                        arrayCls +
  86                        " Expected component type of Point.class got: " + arrayCls.getComponentType());
  87 
  88             qarrayClsName = "[" + qarrayClsName;
  89             mulArrayCls = Class.forName(qarrayClsName);
  90             assertTrue(mulArrayCls.isArray());
  91             assertTrue(mulArrayCls.getComponentType() == arrayCls);
  92         }
  93         catch (ClassNotFoundException cnfe) {
  94             fail("Class.forName(" + arrayClsName + ") failed", cnfe);
  95         }
  96     }
  97 
  98     void testSimplePointArray() {
  99         Point[] defaultPoint = new Point[1];
 100         Point p = defaultPoint[0];
 101         assertEquals(p.x, 0, "invalid default loaded from array");
 102         assertEquals(p.y, 0, "invalid default loaded from array");
 103         boolean gotNpe = false;
 104         try {
 105             defaultPoint[0] = (Point) getNull();
 106         } catch (NullPointerException npe) {
 107             gotNpe = true;
 108         }
 109         assertTrue(gotNpe, "Expected NullPointerException");
 110 
 111         Point[] points = createSimplePointArray();
 112         checkSimplePointArray(points);
 113         System.gc(); // check that VTs survive GC
 114 
 115         assertTrue(points instanceof Point[], "Instance of");
 116 
 117         Point[] pointsCopy = new Point[points.length];
 118         System.arraycopy(points, 0, pointsCopy, 0, points.length);
 119         checkSimplePointArray(pointsCopy);
 120     }
 121 
 122     static Point[] createSimplePointArray() {
 123         Point[] ps = new Point[2];
 124         assertEquals(ps.length, 2, "Length");
 125         ps.toString();
 126         ps[0] = Point.createPoint(1, 2);
 127         ps[1] = Point.createPoint(3, 4);
 128         boolean sawOob = false;
 129         try {
 130             ps[2] = Point.createPoint(0, 0);
 131         } catch (ArrayIndexOutOfBoundsException aioobe) { sawOob = true; }
 132         assertTrue(sawOob, "Didn't see AIOOBE");
 133         System.gc(); // check that VTs survive GC
 134         return ps;
 135     }
 136 
 137     static void checkSimplePointArray(Point[] points) {
 138         assertEquals(points[0].x, 1, "invalid 0 point x value");
 139         assertEquals(points[0].y, 2, "invalid 0 point y value");
 140         assertEquals(points[1].x, 3, "invalid 1 point x value");
 141         assertEquals(points[1].y, 4, "invalid 1 point y value");
 142     }
 143 
 144     void testLong8Array() {
 145         Long8Value[] values = new Long8Value[3];
 146         assertEquals(values.length, 3, "length");
 147         values.toString();
 148         Long8Value value = values[1];
 149         long zl = 0;
 150         Long8Value.check(value, zl, zl, zl, zl, zl, zl, zl, zl);
 151         values[1] = Long8Value.create(1, 2, 3, 4, 5, 6, 7, 8);
 152         value = values[1];
 153         Long8Value.check(value, 1, 2, 3, 4, 5, 6, 7, 8);
 154 
 155         Long8Value[] copy = new Long8Value[values.length];
 156         System.arraycopy(values, 0, copy, 0, values.length);
 157         value = copy[1];
 158         Long8Value.check(value, 1, 2, 3, 4, 5, 6, 7, 8);
 159     }
 160 
 161     void testMixedPersonArray() {
 162         Person[] people = new Person[3];
 163 
 164         people[0] = Person.create(1, "First", "Last");
 165         assertEquals(people[0].getId(), 1, "Invalid Id person");
 166         assertEquals(people[0].getFirstName(), "First", "Invalid First Name");
 167         assertEquals(people[0].getLastName(), "Last", "Invalid Last Name");
 168 
 169         people[1] = Person.create(2, "Jane", "Wayne");
 170         people[2] = Person.create(3, "Bob", "Dobalina");
 171 
 172         Person[] peopleCopy = new Person[people.length];
 173         System.arraycopy(people, 0, peopleCopy, 0, people.length);
 174         assertEquals(peopleCopy[2].getId(), 3, "Invalid Id");
 175         assertEquals(peopleCopy[2].getFirstName(), "Bob", "Invalid First Name");
 176         assertEquals(peopleCopy[2].getLastName(), "Dobalina", "Invalid Last Name");
 177     }
 178 
 179     void testMultiDimPointArray() {
 180         Point[][][] multiPoints = new Point[2][3][4];
 181         assertEquals(multiPoints.length, 2, "1st dim length");
 182         assertEquals(multiPoints[0].length, 3, "2st dim length");
 183         assertEquals(multiPoints[0][0].length, 4, "3rd dim length");
 184 
 185         Point defaultPoint = multiPoints[1][2][3];
 186         assertEquals(defaultPoint.x, 0, "invalid point x value");
 187         assertEquals(defaultPoint.y, 0, "invalid point x value");
 188     }
 189 
 190     void testReflectArray() {
 191         // Check the java.lang.reflect.Array.newInstance methods...
 192         Class<?> cls = (Class<?>) Point[].class;
 193         Point[][] array = (Point[][]) Array.newInstance(cls, 1);
 194         assertEquals(array.length, 1, "Incorrect length");
 195         assertTrue(array[0] == null, "Expected NULL");
 196 
 197         Point[][][] array3 = (Point[][][]) Array.newInstance(cls, 1, 2);
 198         assertEquals(array3.length, 1, "Incorrect length");
 199         assertEquals(array3[0].length, 2, "Incorrect length");
 200         assertTrue(array3[0][0] == null, "Expected NULL");
 201 
 202         // Now create ObjArrays of ValueArray...
 203         cls = (Class<?>) Point.class.asBoxType();
 204         Point.box[][] barray = (Point.box[][]) Array.newInstance(cls, 1, 2);
 205         assertEquals(barray.length, 1, "Incorrect length");
 206         assertEquals(barray[0].length, 2, "Incorrect length");
 207         barray[0][1] = Point.createPoint(1, 2);
 208         Point.box pb = barray[0][1];
 209         int x = pb.getX();
 210         assertEquals(x, 1, "Bad Point Value");
 211     }
 212 
 213     static final value class MyInt implements Comparable<MyInt> {
 214         final int value;
 215 
 216         private MyInt() { value = 0; }
 217         public int getValue() { return value; }
 218         public String toString() { return "MyInt: " + getValue(); }
 219         public int compareTo(MyInt that) { return Integer.compare(this.getValue(), that.getValue()); }
 220         public boolean equals(Object o) {
 221             if (o instanceof MyInt) {
 222                 return this.getValue() == ((MyInt) o).getValue();
 223             }
 224             return false;
 225         }
 226 
 227         public static MyInt create(int v) {
 228             MyInt mi = MyInt.default;
 229             mi = __WithField(mi.value, v);
 230             return mi;
 231         }
 232 
 233         public static final MyInt.box MIN = MyInt.create(Integer.MIN_VALUE);
 234         public static final MyInt.box ZERO = MyInt.create(0);
 235         public static final MyInt.box MAX = MyInt.create(Integer.MAX_VALUE);
 236     }
 237 
 238     static MyInt staticMyInt = MyInt.create(-1);
 239     static MyInt[] staticMyIntArray = new MyInt[] { staticMyInt };
 240     static MyInt[][] staticMyIntArrayArray = new MyInt[][] { staticMyIntArray, staticMyIntArray };
 241 
 242     static interface SomeSecondaryType {
 243         default String hi() { return "Hi"; }
 244     }
 245 
 246     static final value class MyOtherInt implements SomeSecondaryType {
 247         final int value;
 248         private MyOtherInt() { value = 0; }
 249     }
 250 
 251     void testSanityCheckcasts() {



 252         MyInt[] myInts = new MyInt[1];
 253         assertTrue(myInts instanceof Object[]);
 254         assertTrue(myInts instanceof Comparable[]);
 255 
 256         Class<?> cls = MyInt.class.asValueType();
 257         assertTrue(cls.isValue());
 258         Object arrObj = Array.newInstance(cls, 1);
 259         assertTrue(arrObj instanceof Object[], "Not Object array");
 260         assertTrue(arrObj instanceof Comparable[], "Not Comparable array");
 261         assertTrue(arrObj instanceof MyInt[], "Not MyInt array");
 262 
 263         Object[] arr = (Object[]) arrObj;
 264         assertTrue(arr instanceof Comparable[], "Not Comparable array");
 265         assertTrue(arr instanceof MyInt[], "Not MyInt array");
 266         Comparable[] comparables = (Comparable[])arr;
 267         MyInt[] myIntArr = (MyInt[]) arr;
 268 
 269         // multi-dim, check secondary array types are setup...
 270         MyOtherInt[][] matrix = new MyOtherInt[1][1];
 271         assertTrue(matrix[0] instanceof MyOtherInt[]);
 272         assertTrue(matrix[0] instanceof SomeSecondaryType[]);
 273 
 274         // Box types vs Value...
 275         MyInt.box[] myValueRefs = new MyInt.box[1];
 276         assertTrue(myValueRefs instanceof MyInt.box[]);
 277         assertTrue(myValueRefs instanceof Object[]);
 278         assertTrue(myValueRefs instanceof Comparable[]);
 279     }
 280 
 281 



 282     void testUtilArrays() {
 283         // Sanity check j.u.Arrays
 284         MyInt[] myInts = new MyInt[] { MyInt.MAX, MyInt.MIN };
 285         // Sanity sort another copy
 286         MyInt[] copyMyInts = Arrays.copyOf(myInts, myInts.length + 1);
 287         checkArrayElementsEqual(copyMyInts, new MyInt[] { myInts[0], myInts[1], MyInt.ZERO});
 288 
 289         Arrays.sort(copyMyInts);
 290         checkArrayElementsEqual(copyMyInts, new MyInt[] { MyInt.MIN, MyInt.ZERO, MyInt.MAX });
 291 
 292         List myIntList = Arrays.asList(copyMyInts);
 293         checkArrayElementsEqual(copyMyInts, myIntList.toArray(new MyInt[copyMyInts.length]));
 294         // This next line needs testMixedLayoutArrays to work
 295         checkArrayElementsEqual(copyMyInts, myIntList.toArray());
 296 
 297         // Sanity check j.u.ArrayList
 298         ArrayList<MyInt> aList = new ArrayList<MyInt>(Arrays.asList(copyMyInts));
 299         assertTrue(aList.indexOf(MyInt.MIN) == 0, "Bad Index");
 300         assertTrue(aList.indexOf(MyInt.ZERO) == 1, "Bad Index");
 301         assertTrue(aList.indexOf(MyInt.MAX) == 2, "Bad Index");
 302 
 303         aList.remove(2);
 304         aList.add(MyInt.create(5));








 305     }
 306 
 307 
 308     void testObjectArrayOfValues() {
 309         testSanityObjectArrays();
 310         testMixedLayoutArrays();
 311     }
 312 
 313     void testSanityObjectArrays() {
 314         Object[] objects = new Object[2];
 315         assertTrue(objects[0] == null && objects[1] == null, "Not null ?");
 316 
 317         objects[0] = MyInt.create(1);
 318         objects[1] = Integer.valueOf(2);
 319         assertTrue(objects[0].equals(MyInt.create(1)), "Bad Value");
 320         assertTrue(objects[1].equals(Integer.valueOf(2)), "Bad Object");
 321 
 322         Comparable[] copyComparables = new Comparable[objects.length];
 323         System.arraycopy(objects, 0, copyComparables, 0, objects.length);
 324         checkArrayElementsEqual(objects, copyComparables);
 325 
 326         objects[0] = null;
 327         objects[1] = null;
 328         assertTrue(objects[0] == null && objects[1] == null, "Not null ?");
 329 
 330         Comparable[] comparables = new Comparable[2];
 331         assertTrue(comparables[0] == null && comparables[1] == null, "Not null ?");
 332         comparables[0] = MyInt.create(3);
 333         comparables[1] = Integer.valueOf(4);
 334         assertTrue(comparables[0].equals(MyInt.create(3)), "Bad Value");
 335         assertTrue(comparables[1].equals(Integer.valueOf(4)), "Bad Object");
 336 
 337         Object[] copyObjects = new Object[2];
 338         System.arraycopy(comparables, 0, copyObjects, 0, comparables.length);
 339         checkArrayElementsEqual(comparables, copyObjects);
 340 
 341         comparables[0] = null;
 342         comparables[1] = null;
 343         assertTrue(comparables[0] == null && comparables[1] == null, "Not null ?");
 344 
 345         MyInt.box[] myIntRefArray = new MyInt.box[1];
 346         assertTrue(myIntRefArray[0] == null, "Got: " + myIntRefArray[0]);
 347         myIntRefArray[0] = null;
 348     }
 349 
 350     void testMixedLayoutArrays() {
 351         Object[] objArray = new Object[3];
 352         Comparable[] compArray = new Comparable[3];
 353         MyInt[] valArray = new MyInt[] { MyInt.MIN, MyInt.ZERO, MyInt.MAX };
 354 
 355         arrayCopy(valArray, 0, objArray, 0, 3);
 356         checkArrayElementsEqual(valArray, objArray);
 357         arrayCopy(valArray, 0, objArray, 0, 3);
 358 
 359         objArray = new Object[3];
 360         System.arraycopy(valArray, 0, objArray, 0, 3);
 361         checkArrayElementsEqual(valArray, objArray);
 362 
 363         System.arraycopy(valArray, 0, compArray, 0, 3);
 364         checkArrayElementsEqual(valArray, compArray);
 365 
 366         valArray = new MyInt[] { MyInt.ZERO, MyInt.ZERO, MyInt.ZERO };
 367         System.arraycopy(compArray, 0, valArray, 0, 3);
 368         checkArrayElementsEqual(valArray, compArray);
 369 
 370         valArray = new MyInt[] { MyInt.ZERO, MyInt.ZERO, MyInt.ZERO };
 371         System.arraycopy(objArray, 0, valArray, 0, 3);
 372         checkArrayElementsEqual(valArray, objArray);
 373 
 374         // Sanity check dst == src
 375         System.arraycopy(valArray, 0, valArray, 0, 3);
 376         checkArrayElementsEqual(valArray, objArray);
 377 
 378         objArray[0] = "Not a value object";
 379         try {
 380             System.arraycopy(objArray, 0, valArray, 0, 3);
 381             throw new RuntimeException("Expected ArrayStoreException");
 382         } catch (ArrayStoreException ase) {}
 383 
 384         MyInt.box[] myIntRefArray = new MyInt.box[3];
 385         System.arraycopy(valArray, 0, myIntRefArray, 0, 3);
 386         checkArrayElementsEqual(valArray, myIntRefArray);
 387 
 388         myIntRefArray[0] = null;
 389         try {
 390             System.arraycopy(myIntRefArray, 0, valArray, 0, 3);
 391             throw new RuntimeException("Expected NullPointerException");
 392         } catch (NullPointerException npe) {}
 393     }
 394 
 395     static final value class MyPoint {
 396         final               MyInt.val x;
 397         final               MyInt y;
 398 
 399         private MyPoint() {
 400             x = MyInt.ZERO;
 401             y = x;
 402         }
 403         public boolean equals(Object that) {
 404             if (that instanceof MyPoint) {
 405                 MyPoint thatPoint = (MyPoint) that;
 406                 return x.equals(thatPoint.x) && java.util.Objects.equals(y, thatPoint.y);
 407             }
 408             return false;
 409         }
 410         static MyPoint create(int x) {
 411             MyPoint mp = MyPoint.default;
 412             mp = __WithField(mp.x, MyInt.create(x));
 413             return mp;
 414         }
 415         static MyPoint create(int x, int y) {
 416             MyPoint mp = MyPoint.default;
 417             mp = __WithField(mp.x, MyInt.create(x));
 418             mp = __WithField(mp.y, MyInt.create(y));
 419             return mp;
 420         }
 421         static final MyPoint.box ORIGIN = create(0);
 422     }
 423 
 424     void testComposition() {
 425         // Test array operations with compostion of values, check element payload is correct...
 426         MyPoint a = MyPoint.create(1, 2);
 427         MyPoint b = MyPoint.create(7, 21);
 428         MyPoint c = MyPoint.create(Integer.MAX_VALUE, Integer.MIN_VALUE);
 429 
 430         MyPoint[] pts = new MyPoint[3];
 431         if (!pts[0].equals(MyPoint.ORIGIN)) {
 432             throw new RuntimeException("Equals failed: " + pts[0] + " vs " + MyPoint.ORIGIN);
 433         }
 434         pts = new MyPoint[] { a, b, c };
 435         checkArrayElementsEqual(pts, new Object[] { a, b, c});
 436         Object[] oarr = new Object[3];
 437 
 438         arrayCopy(pts, 0, oarr, 0, 3);
 439         checkArrayElementsEqual(pts, oarr);
 440 
 441         oarr = new Object[3];
 442         System.arraycopy(pts, 0, oarr, 0, 3);
 443         checkArrayElementsEqual(pts, oarr);
 444 
 445         System.arraycopy(oarr, 0, pts, 0, 3);
 446         checkArrayElementsEqual(pts, oarr);
 447 
 448         oarr = new Object[3];
 449         try {
 450             System.arraycopy(oarr, 0, pts, 0, 3);
 451             throw new RuntimeException("Expected NPE");
 452         }
 453         catch (NullPointerException npe) {}
 454 
 455         oarr = new Object[3];
 456         oarr[0] = new Object();
 457         try {
 458             System.arraycopy(oarr, 0, pts, 0, 3);
 459             throw new RuntimeException("Expected ASE");
 460         }
 461         catch (ArrayStoreException ase) {}
 462     }
 463 
 464     void checkArrayElementsEqual(MyInt[] arr1, Object[] arr2) {
 465         assertTrue(arr1.length == arr2.length, "Bad length");
 466         for (int i = 0; i < arr1.length; i++) {
 467             assertTrue(java.util.Objects.equals(arr1[i], arr2[i]), "Element " + i + " not equal");
 468         }
 469     }
 470 
 471     void checkArrayElementsEqual(MyPoint[] arr1, Object[] arr2) {
 472         assertTrue(arr1.length == arr2.length, "Bad length");
 473         for (int i = 0; i < arr1.length; i++) {
 474             assertTrue(java.util.Objects.equals(arr1[i], arr2[i]), "Element " + i + " not equal");
 475         }
 476     }
 477 
 478     void checkArrayElementsEqual(Object[] arr1, Object[] arr2) {
 479         assertTrue(arr1.length == arr2.length, "Bad length");
 480         for (int i = 0; i < arr1.length; i++) {
 481             assertTrue(java.util.Objects.equals(arr1[i], arr2[i]), "Element " + i + " not equal");
 482         }
 483     }
 484 
 485     void arrayCopy(MyInt[] src, int srcPos, Object[] dst, int dstPos, int length) {
 486         for (int i = 0; i < length ; i++) {
 487             dst[dstPos++] = src[srcPos++];
 488         }
 489     }
 490     void arrayCopy(MyPoint[] src, int srcPos, Object[] dst, int dstPos, int length) {
 491         for (int i = 0; i < length ; i++) {
 492             dst[dstPos++] = src[srcPos++];
 493         }
 494     }
 495 
 496     Object getNull() { return null; }
 497 
 498 }
--- EOF ---