test/jdk/valhalla/valuetypes/Reflection.java

*** 23,42 ****
  
  
  /*
   * @test
   * @summary test reflection on value types
!  * @compile -XDallowWithFieldOperator Point.java Line.java
   * @run main/othervm -XX:+EnableValhalla Reflection
   */
  
  import java.lang.reflect.*;
  
  public class Reflection {
      public static void main(String... args) throws Exception {
          testPointClass();
          testLineClass();
      }
  
      static void testPointClass() throws Exception  {
          Point o = Point.makePoint(10, 20);
          Reflection test = new Reflection("Point", o);
--- 23,46 ----
  
  
  /*
   * @test
   * @summary test reflection on value types
!  * @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,59 ****
      }
  
      static void testLineClass() throws Exception {
          Line l = Line.makeLine(10, 20, 30, 40);
          Reflection test = new Reflection("Line", l);
!         test.getDeclaredFields();
      }
  
      private final Class<?> c;
      private final Constructor<?> ctor;
      private final Object o;
--- 53,75 ----
      }
  
      static void testLineClass() throws Exception {
          Line l = Line.makeLine(10, 20, 30, 40);
          Reflection test = new Reflection("Line", l);
!         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,72 ****
--- 79,120 ----
              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,134 ****
              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));
          }
      }
  }
--- 172,207 ----
              f.setAccessible(true);
              throw new RuntimeException("IllegalAccessException not thrown");
          } catch (InaccessibleObjectException e) { }
      }
  
!     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");
+ 
      }
  }