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();
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));
|
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();
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));
|