test/jdk/java/util/Arrays/CopyMethods.java

@@ -25,25 +25,32 @@
   * @test
   * @bug     4655503
   * @summary Test for array cloning and slicing methods.
   * @author  John Rose
   * @key randomness
+  * @library /test/lib
   */
  
+ import java.time.LocalDate;
  import java.util.*;
  import java.lang.reflect.*;
  
+ import jdk.test.lib.valueclass.AsValueClass;
+ 
  public class CopyMethods {
      static int muzzle;  // if !=0, suppresses ("muzzles") messages
  
      static int maxLen = 40;  // maximum length of test arrays
      static int shortStepsNear = 4;  // interesting span near critical values
      static int downShift = 3;
  
      static int testCasesRun = 0;
      static long consing = 0;
  
+     @AsValueClass
+     record Point(int x, int y) {}
+ 
      // very simple tests, mainly to test the framework itself
      static void simpleTests() {
          int[] a = (int[]) makeArray(3, int.class);
          if (muzzle == 0)
              System.out.println("int[] a = "+Arrays.toString(a));

@@ -351,10 +358,13 @@
      static long    coerceToLong(int x) { return x; }
      static char    coerceToChar(int x) { return (char)x; }
      static float   coerceToFloat(int x) { return x; }
      static double  coerceToDouble(int x) { return x; }
      static boolean coerceToBoolean(int x) { return (x&1) != 0; }
+     static Point coerceToPoint(int x) { return (x == 0) ? null : new Point(x, x); }
+     static LocalDate coerceToLocalDate(int x) { return (x == 0) ? null : LocalDate.ofEpochDay(x); }
+     static Optional coerceToOptional(int x) { return (x == 0) ? null : Optional.of(x); }
  
      static Integer[] copyOfIntegerArray(Object[] a, int len) {
          // This guy exercises the API based on a type-token.
          // Note the static typing.
          return Arrays.copyOf(a, len, Integer[].class);

@@ -368,11 +378,12 @@
      static final List<Class<?>> allTypes
          = Arrays.asList(new Class<?>[]
                          {   Object.class, String.class, Integer.class,
                              byte.class, short.class, int.class, long.class,
                              char.class, float.class, double.class,
-                             boolean.class
+                             boolean.class, LocalDate.class, Optional.class,
+                             Point.class,
                          });
      static final HashMap<Class<?>,Method> coercers;
      static final HashMap<Class<?>,Method> cloners;
      static final HashMap<Class<?>,Method> cloneRangers;
      static final HashMap<Class<?>,Method> toStrings;

@@ -415,10 +426,16 @@
          cloneRangers.put(String.class, cloneRangers.get(Object.class));
          assert(cia != null);
          cloners.put(Integer.class, cia);
          assert(ciar != null);
          cloneRangers.put(Integer.class, ciar);
+         cloners.put(Point.class, cloners.get(Object.class));
+         cloneRangers.put(Point.class, cloneRangers.get(Object.class));
+         cloners.put(LocalDate.class, cloners.get(Object.class));
+         cloneRangers.put(LocalDate.class, cloneRangers.get(Object.class));
+         cloners.put(Optional.class, cloners.get(Object.class));
+         cloneRangers.put(Optional.class, cloneRangers.get(Object.class));
          nullValues = new HashMap<Class<?>,Object>();
          for (Class<?> c : allTypes) {
              nullValues.put(c, invoke(coercers.get(c), 0));
          }
      }