test/valhalla/mvt/ConstructorTest.java

rev 17247 : [mq]: find-constructor

@@ -19,111 +19,52 @@
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 
-import jdk.experimental.value.MethodHandleBuilder;
 import jdk.experimental.value.ValueType;
 import org.testng.annotations.Test;
 
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
 
-import static org.testng.Assert.*;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.fail;
+import static org.testng.AssertJUnit.assertTrue;
 
 /*
  * @test
- * @run testng/othervm -Xverify:none -XX:+EnableMVT -Dvalhalla.enablePoolPatches=true WithFieldTest
+ * @run testng/othervm -Xverify:none -XX:+EnableMVT -Dvalhalla.enablePoolPatches=true ConstructorTest
  */
 
 @Test
-public class WithFieldTest {
+public class ConstructorTest {
 
-    static final ValueType<?> VT_Point = ValueType.forClass(Point.class);
-
-    static final ValueType<?> VT_PrivatePoint = ValueType.forClass(PrivatePoint.class);
-
-    static final MethodHandle MH_Point_get_x;
-
-    static final MethodHandle MH_PrivatePoint_get_x;
+    static final ValueType<?> VT_Interval = ValueType.forClass(Interval.class);
 
+    static final MethodHandle VT_constructor;
     static {
         try {
-            MH_Point_get_x = MethodHandles.lookup().findGetter(
-                    Point.class, "x", int.class);
-            MH_PrivatePoint_get_x = MethodHandles.lookup().findVirtual(
-                    PrivatePoint.class, "getX", MethodType.methodType(int.class));
+            MethodHandle mh = VT_Interval.findConstructor(MethodHandles.lookup(),
+                                                          MethodType.methodType(void.class, int.class, int.class));
+            VT_constructor = MethodHandles.filterReturnValue(mh, VT_Interval.box());
         } catch (Exception e) {
             throw new InternalError(e);
         }
     }
 
-
-    public void testPrivateLookupPrivateFieldUsingVCC() throws Throwable {
-        testPrivateAccess(VT_PrivatePoint, VT_PrivatePoint.boxClass(), MethodHandles.lookup(), MH_PrivatePoint_get_x);
-    }
-
-    public void testPrivateLookupPublicFieldUsingVCC() throws Throwable {
-        testPrivateAccess(VT_Point, VT_Point.boxClass(), MethodHandles.lookup(), MH_Point_get_x);
-    }
-
-    public void testPrivateLookupPrivateFieldUsingDVT() throws Throwable {
-        testPrivateAccess(VT_PrivatePoint, VT_PrivatePoint.valueClass(), MethodHandles.lookup(), MH_PrivatePoint_get_x);
-    }
-
-    public void testPrivateLookupPublicFieldUsingDVT() throws Throwable {
-        testPrivateAccess(VT_Point, VT_Point.valueClass(), MethodHandles.lookup(), MH_Point_get_x);
-    }
-
-
-    @Test(expectedExceptions = IllegalAccessError.class)
-    public void testLookupPrivateFieldUsingVCC() throws Throwable {
-        testAccess(VT_PrivatePoint, MethodHandles.lookup(), MH_PrivatePoint_get_x);
-    }
-
-    @Test(expectedExceptions = IllegalAccessError.class)
-    public void testLookupPublicFieldUsingVCC() throws Throwable {
-        testAccess(VT_Point, MethodHandles.lookup(), MH_Point_get_x);
-    }
-
-    @Test(expectedExceptions = IllegalAccessError.class)
-    public void testLookupPrivateFieldUsingDVT() throws Throwable {
-        testAccess(VT_PrivatePoint, MethodHandles.lookup(), MH_PrivatePoint_get_x);
-    }
-
-    @Test(expectedExceptions = IllegalAccessError.class)
-    public void testLookupPublicFieldUsingDVT() throws Throwable {
-        testAccess(VT_Point, MethodHandles.lookup(), MH_Point_get_x);
-    }
-
-
-    static void testPrivateAccess(ValueType<?> vt, Class<?> lc, MethodHandles.Lookup l, MethodHandle getter) throws Throwable {
-        testAccess(vt, MethodHandles.privateLookupIn(lc, l), getter);
+    public void testConstructorWithValidArguments() throws Throwable {
+        Interval i = (Interval) VT_constructor.invoke(1, 2);
+        assertEquals(i.l, 1);
+        assertEquals(i.u, 2);
     }
 
-    static void testAccess(ValueType<?> vt, MethodHandles.Lookup l, MethodHandle getter) throws Throwable {
-        MethodHandle mh = MethodHandles.collectArguments(vwithfield(l, vt, "x", int.class), 0, vt.defaultValueConstant());
-
-        mh = MethodHandles.filterReturnValue(mh, vt.box());
-
-        mh = MethodHandles.filterReturnValue(mh, getter);
-
-        int actual = (int) mh.invoke(42);
-        assertEquals(actual, 42);
-    }
-
-    static MethodHandle vwithfield(MethodHandles.Lookup lookup, ValueType<?> vt, String name, Class<?> type) {
-        Class<?> dvt = vt.valueClass();
-        return MethodHandleBuilder.loadCode(
-                lookup,
-                lookup.lookupClass().toString() + "_wither$" + name,
-                MethodType.methodType(dvt, dvt, type),
-                C -> C.vload(0).load(1).vwithfield(dvt, name, fieldDescriptor(type)).vreturn());
+    public void testConstructorWithIllegalArguments() throws Throwable {
+        try {
+            Interval i = (Interval) VT_constructor.invoke(3, 1);
+            fail();
+        } catch (Throwable t) {
+            assertTrue(IllegalArgumentException.class.isInstance(t));
     }
-
-    static String fieldDescriptor(Class<?> type) {
-        String s = MethodType.methodType(type).toMethodDescriptorString();
-        return s.substring(2);
     }
-
 }