test/jdk/valhalla/valuetypes/Reflection.java

@@ -23,20 +23,24 @@
 
 
 /*
  * @test
  * @summary test reflection on value types
- * @compile -XDallowWithFieldOperator Point.java Line.java
+ * @compile -XDallowWithFieldOperator Point.java Line.java NonFlattenValue.java
  * @run main/othervm -XX:+EnableValhalla Reflection
  */
 
 import java.lang.reflect.*;
+import java.util.Arrays;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
 
 public class Reflection {
     public static void main(String... args) throws Exception {
         testPointClass();
         testLineClass();
+        testNonFlattenValue();
     }
 
     static void testPointClass() throws Exception  {
         Point o = Point.makePoint(10, 20);
         Reflection test = new Reflection("Point", o);

@@ -49,11 +53,23 @@
     }
 
     static void testLineClass() throws Exception {
         Line l = Line.makeLine(10, 20, 30, 40);
         Reflection test = new Reflection("Line", l);
-        test.getDeclaredFields();
+        test.checkField("p1", Point.class.asValueType());
+        test.checkField("p2", Point.class.asValueType());
+        test.checkMethod("p1", Point.class.asValueType());
+        test.checkMethod("p2", Point.class.asValueType());
+    }
+
+    static void testNonFlattenValue() throws Exception {
+        NonFlattenValue nfv = NonFlattenValue.make(10, 20);
+        Reflection test = new Reflection("NonFlattenValue", nfv);
+        test.checkField("nfp", Point.class.asBoxType());
+        test.checkMethod("point", Point.class.asBoxType());
+        test.checkMethod("pointValue", Point.class.asValueType());
+        test.checkMethod("has", void.class, Point.class.asValueType(), Point.class.asBoxType());
     }
 
     private final Class<?> c;
     private final Constructor<?> ctor;
     private final Object o;

@@ -63,10 +79,42 @@
             throw new RuntimeException(cn + " is not a value class");
         }
 
         this.ctor = c.getDeclaredConstructor();
         this.o = o;
+
+        // TODO: what should Object::getClass return?
+        // assertEquals(o.getClass(), c.asValueType());
+
+        // test the box type and value type
+        testBoxAndValueType(this.c);
+        // test array of Q-type
+        // TODO: array of L-type support
+        testArrayOfQType();
+    }
+
+    private static void testBoxAndValueType(Class<?> c) {
+        Class<?> box = c.asBoxType();
+        Class<?> val = c.asValueType();
+        assertTrue(val != null);
+        assertEquals(box.getTypeName(), c.getTypeName());
+        assertEquals(val.getTypeName(), c.getTypeName() + "/val");
+        assertEquals(box, c);
+        assertEquals(val.asBoxType(), box);
+        assertEquals(box.asValueType(), val);
+    }
+
+    void testArrayOfQType() {
+        Class<?> elementType = c.asValueType();
+        Object array = Array.newInstance(elementType, 1);
+        Class<?> arrayType = array.getClass();
+        assertTrue(arrayType.isArray());
+        Class<?> componentType = arrayType.getComponentType();
+        assertTrue(componentType.isValue());
+        assertEquals(componentType, elementType);
+        // Array is a reference type
+        assertEquals(arrayType.asBoxType(), arrayType);
     }
 
     void accessFieldX(int x) throws Exception {
         Field field = c.getField("x");
         if (field.getInt(o) != x) {

@@ -124,11 +172,36 @@
             f.setAccessible(true);
             throw new RuntimeException("IllegalAccessException not thrown");
         } catch (InaccessibleObjectException e) { }
     }
 
-    void getDeclaredFields() throws Exception {
-        for (Field f : c.getDeclaredFields()) {
-            System.out.println(f.getName() + " = " + f.get(o));
+    void checkField(String name, Class<?> type) throws Exception {
+        Field f = c.getDeclaredField(name);
+        System.out.format("Field %s::%s of type %s = %s%n",
+                          f.getDeclaringClass().getTypeName(), f.getName(),
+                          f.getType().getTypeName(), f.get(o));
+        assertEquals(f.getType(), type);
+    }
+
+    void checkMethod(String name, Class<?> returnType, Class<?>... params) throws Exception {
+        Method m = c.getDeclaredMethod(name, params);
+
+        String paramDesc = (params == null || params.length == 0) ? "" :
+            Arrays.stream(params).map(Class::getTypeName).collect(Collectors.joining(", "));
+        System.out.format("Method %s::%s(%s)%s%n",
+                          m.getDeclaringClass().getTypeName(), m.getName(),
+                          paramDesc, returnType.getTypeName());
+    }
+    
+    static void assertEquals(Object o1, Object o2) {
+        if (o1 == o2 || o1.equals(o2))
+            return;
+
+        throw new AssertionError(o1 + " != " + o2);
         }
+
+    static void assertTrue(boolean value) {
+        if (!value)
+            throw new AssertionError("expected true");
+
     }
 }