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         try {
  67             Class<?> arrayCls = Class.forName(arrayClsName);
  68             assertTrue(arrayCls.isArray(), "Expected an array class");
  69             // array-of-L-type not supported yet
  70             // the component type of a flattened value array is of the value type
  71             // the component type of a non-flattened array is of the box type
  72             assertTrue(arrayCls.getComponentType().asBoxType() == Point.class,
  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         catch (ClassNotFoundException cnfe) {
  81             fail("Class.forName(" + arrayClsName + ") failed", cnfe);
  82         }
  83     }
  84 
  85     void testSimplePointArray() {
  86         Point[] defaultPoint = new Point[1];
  87         Point p = defaultPoint[0];
  88         assertEquals(p.x, 0, "invalid default loaded from array");
  89         assertEquals(p.y, 0, "invalid default loaded from array");
  90         boolean gotNpe = false;
  91         try {
  92             defaultPoint[0] = (Point) getNull();
  93         } catch (NullPointerException npe) {
  94             gotNpe = true;
  95         }
  96         assertTrue(gotNpe, "Expected NullPointerException");
  97 
  98         Point[] points = createSimplePointArray();
  99         checkSimplePointArray(points);
 100         System.gc(); // check that VTs survive GC
 101 
 102         assertTrue(points instanceof Point[], "Instance of");
 103 
 104         Point[] pointsCopy = new Point[points.length];
 105         System.arraycopy(points, 0, pointsCopy, 0, points.length);
 106         checkSimplePointArray(pointsCopy);
 107     }
 108 
 109     static Point[] createSimplePointArray() {
 110         Point[] ps = new Point[2];
 111         assertEquals(ps.length, 2, "Length");
 112         ps.toString();
 113         ps[0] = Point.createPoint(1, 2);
 114         ps[1] = Point.createPoint(3, 4);
 115         boolean sawOob = false;
 116         try {
 117             ps[2] = Point.createPoint(0, 0);
 118         } catch (ArrayIndexOutOfBoundsException aioobe) { sawOob = true; }
 119         assertTrue(sawOob, "Didn't see AIOOBE");
 120         System.gc(); // check that VTs survive GC
 121         return ps;
 122     }
 123 
 124     static void checkSimplePointArray(Point[] points) {
 125         assertEquals(points[0].x, 1, "invalid 0 point x value");
 126         assertEquals(points[0].y, 2, "invalid 0 point y value");
 127         assertEquals(points[1].x, 3, "invalid 1 point x value");
 128         assertEquals(points[1].y, 4, "invalid 1 point y value");
 129     }
 130 
 131     void testLong8Array() {
 132         Long8Value[] values = new Long8Value[3];
 133         assertEquals(values.length, 3, "length");
 134         values.toString();
 135         Long8Value value = values[1];
 136         long zl = 0;
 137         Long8Value.check(value, zl, zl, zl, zl, zl, zl, zl, zl);
 138         values[1] = Long8Value.create(1, 2, 3, 4, 5, 6, 7, 8);
 139         value = values[1];
 140         Long8Value.check(value, 1, 2, 3, 4, 5, 6, 7, 8);
 141 
 142         Long8Value[] copy = new Long8Value[values.length];
 143         System.arraycopy(values, 0, copy, 0, values.length);
 144         value = copy[1];
 145         Long8Value.check(value, 1, 2, 3, 4, 5, 6, 7, 8);
 146     }
 147 
 148     void testMixedPersonArray() {
 149         Person[] people = new Person[3];
 150 
 151         people[0] = Person.create(1, "First", "Last");
 152         assertEquals(people[0].getId(), 1, "Invalid Id person");
 153         assertEquals(people[0].getFirstName(), "First", "Invalid First Name");
 154         assertEquals(people[0].getLastName(), "Last", "Invalid Last Name");
 155 
 156         people[1] = Person.create(2, "Jane", "Wayne");
 157         people[2] = Person.create(3, "Bob", "Dobalina");
 158 
 159         Person[] peopleCopy = new Person[people.length];
 160         System.arraycopy(people, 0, peopleCopy, 0, people.length);
 161         assertEquals(peopleCopy[2].getId(), 3, "Invalid Id");
 162         assertEquals(peopleCopy[2].getFirstName(), "Bob", "Invalid First Name");
 163         assertEquals(peopleCopy[2].getLastName(), "Dobalina", "Invalid Last Name");
 164     }
 165 
 166     void testMultiDimPointArray() {
 167         Point[][][] multiPoints = new Point[2][3][4];
 168         assertEquals(multiPoints.length, 2, "1st dim length");
 169         assertEquals(multiPoints[0].length, 3, "2st dim length");
 170         assertEquals(multiPoints[0][0].length, 4, "3rd dim length");
 171 
 172         Point defaultPoint = multiPoints[1][2][3];
 173         assertEquals(defaultPoint.x, 0, "invalid point x value");
 174         assertEquals(defaultPoint.y, 0, "invalid point x value");
 175     }
 176 
 177     void testReflectArray() {
 178         // Check the java.lang.reflect.Array.newInstance methods...
 179         Class<?> cls = (Class<?>) Point[].class;
 180         Point[][] array = (Point[][]) Array.newInstance(cls, 1);
 181         assertEquals(array.length, 1, "Incorrect length");
 182         assertTrue(array[0] == null, "Expected NULL");
 183 
 184         Point[][][] array3 = (Point[][][]) Array.newInstance(cls, 1, 2);
 185         assertEquals(array3.length, 1, "Incorrect length");
 186         assertEquals(array3[0].length, 2, "Incorrect length");
 187         assertTrue(array3[0][0] == null, "Expected NULL");
 188 
 189         // Now create ObjArrays of ValueArray...
 190         cls = (Class<?>) Point.class;
 191         array = (Point[][]) Array.newInstance(cls, 1, 2);
 192         assertEquals(array.length, 1, "Incorrect length");
 193         assertEquals(array[0].length, 2, "Incorrect length");
 194         Point p = array[0][1];
 195         int x = p.x;
 196         assertEquals(x, 0, "Bad Point Value");
 197     }
 198 
 199     static final value class MyInt implements Comparable<MyInt> {
 200         final int value;
 201 
 202         private MyInt() { value = 0; }
 203         public int getValue() { return value; }
 204         public String toString() { return "MyInt: " + getValue(); }
 205         public int compareTo(MyInt that) { return Integer.compare(this.getValue(), that.getValue()); }
 206         public boolean equals(Object o) {
 207             if (o instanceof MyInt) {
 208                 return this.getValue() == ((MyInt) o).getValue();
 209             }
 210             return false;
 211         }
 212 
 213         public static MyInt create(int v) {
 214             MyInt mi = MyInt.default;
 215             mi = __WithField(mi.value, v);
 216             return mi;
 217         }
 218 
 219         public static final MyInt.box MIN = MyInt.create(Integer.MIN_VALUE);
 220         public static final MyInt.box ZERO = MyInt.create(0);
 221         public static final MyInt.box MAX = MyInt.create(Integer.MAX_VALUE);
 222     }
 223 
 224     static interface SomeSecondaryType {
 225         default String hi() { return "Hi"; }
 226     }
 227 
 228     static final value class MyOtherInt implements SomeSecondaryType {
 229         final int value;
 230         private MyOtherInt() { value = 0; }
 231     }
 232 
 233     void testSanityCheckcasts() {
 234 // TODO Re-enable if value type arrays become covariant with object arrays
 235 /*
 236 
 237         MyInt[] myInts = new MyInt[1];
 238         assertTrue(myInts instanceof Object[]);
 239         assertTrue(myInts instanceof Comparable[]);
 240 
 241         Object arrObj = Array.newInstance(MyInt.class, 1);
 242         assertTrue(arrObj instanceof Object[], "Not Object array");
 243         assertTrue(arrObj instanceof Comparable[], "Not Comparable array");
 244         assertTrue(arrObj instanceof MyInt[], "Not MyInt array");
 245 
 246         Object[] arr = (Object[]) arrObj;
 247         assertTrue(arr instanceof Comparable[], "Not Comparable array");
 248         assertTrue(arr instanceof MyInt[], "Not MyInt array");
 249         Comparable[] comparables = (Comparable[])arr;
 250         MyInt[] myIntArr = (MyInt[]) arr;
 251 
 252         // multi-dim, check secondary array types are setup...
 253         MyOtherInt[][] matrix = new MyOtherInt[1][1];
 254         assertTrue(matrix[0] instanceof MyOtherInt[]);
 255         assertTrue(matrix[0] instanceof SomeSecondaryType[]);
 256 */
 257     }
 258 
 259 /*
 260  * Comment out this test because value type arrays are not assignable to the array
 261  * parameter types used by the methods in class java.util.Arrays.
 262  *
 263     void testUtilArrays() {
 264         // Sanity check j.u.Arrays
 265         MyInt[] myInts = new MyInt[] { MyInt.MAX, MyInt.MIN };
 266         // Sanity sort another copy
 267         MyInt[] copyMyInts = Arrays.copyOf(myInts, myInts.length + 1);
 268         checkArrayElementsEqual(copyMyInts, new MyInt[] { myInts[0], myInts[1], MyInt.ZERO});
 269 
 270         Arrays.sort(copyMyInts);
 271         checkArrayElementsEqual(copyMyInts, new MyInt[] { MyInt.MIN, MyInt.ZERO, MyInt.MAX });
 272 
 273         List myIntList = Arrays.asList(copyMyInts);
 274         checkArrayElementsEqual(copyMyInts, myIntList.toArray(new MyInt[copyMyInts.length]));
 275         // This next line needs testMixedLayoutArrays to work
 276         checkArrayElementsEqual(copyMyInts, myIntList.toArray());
 277 
 278         // Sanity check j.u.ArrayList
 279         ArrayList<MyInt> aList = new ArrayList<MyInt>(Arrays.asList(copyMyInts));
 280         assertTrue(aList.indexOf(MyInt.MIN) == 0, "Bad Index");
 281         assertTrue(aList.indexOf(MyInt.ZERO) == 1, "Bad Index");
 282         assertTrue(aList.indexOf(MyInt.MAX) == 2, "Bad Index");
 283 
 284         aList.remove(2);
 285         aList.add(MyInt.create(5));
 286 
 287         // Interesting:
 288         //aList.add((MyInt)getNull());
 289 
 290         // javac currently generating "java/util/Objects.requireNonNull
 291         // should checkcast treat null against Value class as CCE ?
 292         // Then in the end, ArrayList.elementData is Object[], (that's why remove works)
 293         // why can't I write add(null) then ?
 294     }
 295 */
 296 
 297     void testObjectArrayOfValues() {
 298         testSanityObjectArrays();
 299         testMixedLayoutArrays();
 300     }
 301 
 302     void testSanityObjectArrays() {
 303         Object[] objects = new Object[2];
 304         assertTrue(objects[0] == null && objects[1] == null, "Not null ?");
 305 
 306         objects[0] = MyInt.create(1);
 307         objects[1] = Integer.valueOf(2);
 308         assertTrue(objects[0].equals(MyInt.create(1)), "Bad Value");
 309         assertTrue(objects[1].equals(Integer.valueOf(2)), "Bad Object");
 310 
 311         Comparable[] copyComparables = new Comparable[objects.length];
 312         System.arraycopy(objects, 0, copyComparables, 0, objects.length);
 313         checkArrayElementsEqual(objects, copyComparables);
 314 
 315         objects[0] = null;
 316         objects[1] = null;
 317         assertTrue(objects[0] == null && objects[1] == null, "Not null ?");
 318 
 319         Comparable[] comparables = new Comparable[2];
 320         assertTrue(comparables[0] == null && comparables[1] == null, "Not null ?");
 321         comparables[0] = MyInt.create(3);
 322         comparables[1] = Integer.valueOf(4);
 323         assertTrue(comparables[0].equals(MyInt.create(3)), "Bad Value");
 324         assertTrue(comparables[1].equals(Integer.valueOf(4)), "Bad Object");
 325 
 326         Object[] copyObjects = new Object[2];
 327         System.arraycopy(comparables, 0, copyObjects, 0, comparables.length);
 328         checkArrayElementsEqual(comparables, copyObjects);
 329 
 330         comparables[0] = null;
 331         comparables[1] = null;
 332         assertTrue(comparables[0] == null && comparables[1] == null, "Not null ?");
 333     }
 334 
 335     void testMixedLayoutArrays() {
 336         Object[] objArray = new Object[3];
 337         Comparable[] compArray = new Comparable[3];
 338         MyInt[] valArray = new MyInt[] { MyInt.MIN, MyInt.ZERO, MyInt.MAX };
 339 
 340         arrayCopy(valArray, 0, objArray, 0, 3);
 341         checkArrayElementsEqual(valArray, objArray);
 342         arrayCopy(valArray, 0, objArray, 0, 3);
 343 
 344         objArray = new Object[3];
 345         System.arraycopy(valArray, 0, objArray, 0, 3);
 346         checkArrayElementsEqual(valArray, objArray);
 347 
 348         System.arraycopy(valArray, 0, compArray, 0, 3);
 349         checkArrayElementsEqual(valArray, compArray);
 350 
 351         valArray = new MyInt[] { MyInt.ZERO, MyInt.ZERO, MyInt.ZERO };
 352         System.arraycopy(compArray, 0, valArray, 0, 3);
 353         checkArrayElementsEqual(valArray, compArray);
 354 
 355         valArray = new MyInt[] { MyInt.ZERO, MyInt.ZERO, MyInt.ZERO };
 356         System.arraycopy(objArray, 0, valArray, 0, 3);
 357         checkArrayElementsEqual(valArray, objArray);
 358 
 359         // Sanity check dst == src
 360         System.arraycopy(valArray, 0, valArray, 0, 3);
 361         checkArrayElementsEqual(valArray, objArray);
 362 
 363         objArray[0] = "Not a value object";
 364         try {
 365             System.arraycopy(objArray, 0, valArray, 0, 3);
 366             throw new RuntimeException("Expected ArrayStoreException");
 367         } catch (ArrayStoreException ase) {}
 368     }
 369 
 370     static final value class MyPoint {
 371         final               MyInt.val x;
 372         final               MyInt y;
 373 
 374         private MyPoint() {
 375             x = MyInt.ZERO;
 376             y = x;
 377         }
 378         public boolean equals(Object that) {
 379             if (that instanceof MyPoint) {
 380                 MyPoint thatPoint = (MyPoint) that;
 381                 return x.equals(thatPoint.x) && java.util.Objects.equals(y, thatPoint.y);
 382             }
 383             return false;
 384         }
 385         static MyPoint create(int x) {
 386             MyPoint mp = MyPoint.default;
 387             mp = __WithField(mp.x, MyInt.create(x));
 388             return mp;
 389         }
 390         static MyPoint create(int x, int y) {
 391             MyPoint mp = MyPoint.default;
 392             mp = __WithField(mp.x, MyInt.create(x));
 393             mp = __WithField(mp.y, MyInt.create(y));
 394             return mp;
 395         }
 396         static final MyPoint.box ORIGIN = create(0);
 397     }
 398 
 399     void testComposition() {
 400         // Test array operations with compostion of values, check element payload is correct...
 401         MyPoint a = MyPoint.create(1, 2);
 402         MyPoint b = MyPoint.create(7, 21);
 403         MyPoint c = MyPoint.create(Integer.MAX_VALUE, Integer.MIN_VALUE);
 404 
 405         MyPoint[] pts = new MyPoint[3];
 406         if (!pts[0].equals(MyPoint.ORIGIN)) {
 407             throw new RuntimeException("Equals failed: " + pts[0] + " vs " + MyPoint.ORIGIN);
 408         }
 409         pts = new MyPoint[] { a, b, c };
 410         checkArrayElementsEqual(pts, new Object[] { a, b, c});
 411         Object[] oarr = new Object[3];
 412 
 413         arrayCopy(pts, 0, oarr, 0, 3);
 414         checkArrayElementsEqual(pts, oarr);
 415 
 416         oarr = new Object[3];
 417         System.arraycopy(pts, 0, oarr, 0, 3);
 418         checkArrayElementsEqual(pts, oarr);
 419 
 420         System.arraycopy(oarr, 0, pts, 0, 3);
 421         checkArrayElementsEqual(pts, oarr);
 422 
 423         oarr = new Object[3];
 424         try {
 425             System.arraycopy(oarr, 0, pts, 0, 3);
 426             throw new RuntimeException("Expected NPE");
 427         }
 428         catch (NullPointerException npe) {}
 429 
 430         oarr = new Object[3];
 431         oarr[0] = new Object();
 432         try {
 433             System.arraycopy(oarr, 0, pts, 0, 3);
 434             throw new RuntimeException("Expected ASE");
 435         }
 436         catch (ArrayStoreException ase) {}
 437     }
 438 
 439     void checkArrayElementsEqual(MyInt[] arr1, Object[] arr2) {
 440         assertTrue(arr1.length == arr2.length, "Bad length");
 441         for (int i = 0; i < arr1.length; i++) {
 442             assertTrue(java.util.Objects.equals(arr1[i], arr2[i]), "Element " + i + " not equal");
 443         }
 444     }
 445 
 446     void checkArrayElementsEqual(MyPoint[] arr1, Object[] arr2) {
 447         assertTrue(arr1.length == arr2.length, "Bad length");
 448         for (int i = 0; i < arr1.length; i++) {
 449             assertTrue(java.util.Objects.equals(arr1[i], arr2[i]), "Element " + i + " not equal");
 450         }
 451     }
 452 
 453     void checkArrayElementsEqual(Object[] arr1, Object[] arr2) {
 454         assertTrue(arr1.length == arr2.length, "Bad length");
 455         for (int i = 0; i < arr1.length; i++) {
 456             assertTrue(java.util.Objects.equals(arr1[i], arr2[i]), "Element " + i + " not equal");
 457         }
 458     }
 459 
 460     void arrayCopy(MyInt[] src, int srcPos, Object[] dst, int dstPos, int length) {
 461         for (int i = 0; i < length ; i++) {
 462             dst[dstPos++] = src[srcPos++];
 463         }
 464     }
 465     void arrayCopy(MyPoint[] src, int srcPos, Object[] dst, int dstPos, int length) {
 466         for (int i = 0; i < length ; i++) {
 467             dst[dstPos++] = src[srcPos++];
 468         }
 469     }
 470 
 471     Object getNull() { return null; }
 472 
 473 }