diff a/test/jdk/java/util/Arrays/CopyMethods.java b/test/jdk/java/util/Arrays/CopyMethods.java
--- a/test/jdk/java/util/Arrays/CopyMethods.java
+++ b/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));
         }
     }