test/jdk/java/util/Arrays/ArraysEqCmpTest.java

@@ -23,14 +23,14 @@
  
  /*
   * @test
   * @bug 8033148 8141409
   * @summary tests for array equals and compare
+  * @library /test/lib
   * @run junit ArraysEqCmpTest
  */
  
- 
  import java.lang.invoke.MethodHandle;
  import java.lang.invoke.MethodHandles;
  import java.lang.invoke.MethodType;
  import java.lang.reflect.Array;
  import java.util.Arrays;

@@ -41,10 +41,12 @@
  import java.util.Objects;
  import java.util.function.BiFunction;
  import java.util.function.LongFunction;
  import java.util.stream.IntStream;
  
+ import jdk.test.lib.valueclass.AsValueClass;
+ 
  import org.junit.jupiter.api.Assertions;
  import org.junit.jupiter.api.Test;
  import org.junit.jupiter.api.TestInstance;
  import org.junit.jupiter.params.ParameterizedTest;
  import org.junit.jupiter.params.provider.MethodSource;

@@ -55,10 +57,19 @@
      // Maximum width in bits
      static final int MAX_WIDTH = 512;
  
      static final Map<Class, Integer> typeToWidth;
  
+     @AsValueClass
+     record Point(int x, int y) implements Comparable<Point> {
+         @Override
+         public int compareTo(Point o) {
+             int r = Integer.compare(this.x, o.x);
+             return (r != 0) ? r : Integer.compare(this.y, o.y);
+         }
+     }
+ 
      static {
          typeToWidth = new HashMap<>();
          typeToWidth.put(boolean.class, Byte.SIZE);
          typeToWidth.put(byte.class, Byte.SIZE);
          typeToWidth.put(short.class, Short.SIZE);

@@ -586,10 +597,28 @@
                  else throw new IllegalStateException();
  
                  ((double[]) a)[i] = pv;
              }
          }
+ 
+         static class ValuePoints extends ArrayType<Point[]> {
+             public ValuePoints() {
+                 super(Point[].class);
+             }
+ 
+             @Override
+             void set(Object a, int i, Object v) {
+                 if (v == null) {
+                     ((Point[]) a)[i] = null;
+                 } else if (v instanceof Point) {
+                     ((Point[]) a)[i] = (Point) v;
+                 } else if (v instanceof Integer) {
+                     int val = (Integer) v;
+                     ((Point[]) a)[i] = new Point(val, val);
+                 } else throw new IllegalStateException();
+             }
+         }
      }
  
      static Object[][] arrayTypes;
  
      public static Object[][] arrayTypesProvider() {

@@ -607,10 +636,11 @@
                      new Object[]{new ArrayType.Integers(true)},
                      new Object[]{new ArrayType.Longs(false)},
                      new Object[]{new ArrayType.Longs(true)},
                      new Object[]{new ArrayType.Floats()},
                      new Object[]{new ArrayType.Doubles()},
+                     new Object[]{new ArrayType.ValuePoints()}
              };
          }
          return arrayTypes;
      }
  

@@ -637,10 +667,11 @@
              LongFunction<Object> bToD = Double::longBitsToDouble;
  
              objectArrayTypes = new Object[][]{
                      new Object[]{new ArrayType.BoxedIntegers()},
                      new Object[]{new ArrayType.BoxedIntegersWithReverseComparator()},
+                     new Object[]{new ArrayType.ValuePoints()},
              };
          }
          return objectArrayTypes;
      }
  

@@ -765,41 +796,41 @@
          BiFunction<ArrayType<?>, Object, Object> cloner = ArrayType::copyOf;
  
          // One ref
          Integer one = 1;
          testArrayType(arrayType,
-                       (at, s) -> {
-                           Integer[] a = (Integer[]) at.construct(s);
-                           for (int x = 0; x < s; x++) {
-                               a[x] = one;
-                           }
-                           return a;
-                       },
-                       cloner);
+                     (at, s) -> {
+                         Object a = at.construct(s);
+                             for (int x = 0; x < s; x++) {
+                                 at.set(a, x, one);
+                             }
+                         return a;
+                     },
+                     cloner);
  
          // All ref
          testArrayType(arrayType,
-                       (at, s) -> {
-                           Integer[] a = (Integer[]) at.construct(s);
-                           for (int x = 0; x < s; x++) {
-                               a[x] = Integer.valueOf(s);
-                           }
-                           return a;
-                       },
-                       cloner);
+                     (at, s) -> {
+                         Object a = at.construct(s);
+                         for (int x = 0; x < s; x++) {
+                             at.set(a, x, s);
+                         }
+                         return a;
+                     },
+                     cloner);
  
          // Some same ref
          testArrayType(arrayType,
-                       (at, s) -> {
-                           Integer[] a = (Integer[]) at.construct(s);
-                           for (int x = 0; x < s; x++) {
-                               int v = x % 8;
-                               a[x] = v == 1 ? one : new Integer(v);
-                           }
-                           return a;
-                       },
-                       cloner);
+                     (at, s) -> {
+                         Object a = at.construct(s);
+                         for (int x = 0; x < s; x++) {
+                             int v = x % 8;
+                             at.set(a, x, v == 1 ? one : v);
+                         }
+                         return a;
+                     },
+                     cloner);
      }
  
      @ParameterizedTest
      @MethodSource("signedUnsignedArrayTypes")
      public void testSignedUnsignedArray(ArrayType<?> sat, ArrayType<?> uat) {