< prev index next >

test/valhalla/mvt/ConstructorTest.java

Print this page
rev 17247 : [mq]: find-constructor


   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 import jdk.experimental.value.MethodHandleBuilder;
  25 import jdk.experimental.value.ValueType;
  26 import org.testng.annotations.Test;
  27 
  28 import java.lang.invoke.MethodHandle;
  29 import java.lang.invoke.MethodHandles;
  30 import java.lang.invoke.MethodType;
  31 
  32 import static org.testng.Assert.*;


  33 
  34 /*
  35  * @test
  36  * @run testng/othervm -Xverify:none -XX:+EnableMVT -Dvalhalla.enablePoolPatches=true WithFieldTest
  37  */
  38 
  39 @Test
  40 public class WithFieldTest {
  41 
  42     static final ValueType<?> VT_Point = ValueType.forClass(Point.class);
  43 
  44     static final ValueType<?> VT_PrivatePoint = ValueType.forClass(PrivatePoint.class);
  45 
  46     static final MethodHandle MH_Point_get_x;
  47 
  48     static final MethodHandle MH_PrivatePoint_get_x;
  49 

  50     static {
  51         try {
  52             MH_Point_get_x = MethodHandles.lookup().findGetter(
  53                     Point.class, "x", int.class);
  54             MH_PrivatePoint_get_x = MethodHandles.lookup().findVirtual(
  55                     PrivatePoint.class, "getX", MethodType.methodType(int.class));
  56         } catch (Exception e) {
  57             throw new InternalError(e);
  58         }
  59     }
  60 
  61 
  62     public void testPrivateLookupPrivateFieldUsingVCC() throws Throwable {
  63         testPrivateAccess(VT_PrivatePoint, VT_PrivatePoint.boxClass(), MethodHandles.lookup(), MH_PrivatePoint_get_x);
  64     }
  65 
  66     public void testPrivateLookupPublicFieldUsingVCC() throws Throwable {
  67         testPrivateAccess(VT_Point, VT_Point.boxClass(), MethodHandles.lookup(), MH_Point_get_x);
  68     }
  69 
  70     public void testPrivateLookupPrivateFieldUsingDVT() throws Throwable {
  71         testPrivateAccess(VT_PrivatePoint, VT_PrivatePoint.valueClass(), MethodHandles.lookup(), MH_PrivatePoint_get_x);
  72     }
  73 
  74     public void testPrivateLookupPublicFieldUsingDVT() throws Throwable {
  75         testPrivateAccess(VT_Point, VT_Point.valueClass(), MethodHandles.lookup(), MH_Point_get_x);
  76     }
  77 
  78 
  79     @Test(expectedExceptions = IllegalAccessError.class)
  80     public void testLookupPrivateFieldUsingVCC() throws Throwable {
  81         testAccess(VT_PrivatePoint, MethodHandles.lookup(), MH_PrivatePoint_get_x);
  82     }
  83 
  84     @Test(expectedExceptions = IllegalAccessError.class)
  85     public void testLookupPublicFieldUsingVCC() throws Throwable {
  86         testAccess(VT_Point, MethodHandles.lookup(), MH_Point_get_x);
  87     }
  88 
  89     @Test(expectedExceptions = IllegalAccessError.class)
  90     public void testLookupPrivateFieldUsingDVT() throws Throwable {
  91         testAccess(VT_PrivatePoint, MethodHandles.lookup(), MH_PrivatePoint_get_x);
  92     }
  93 
  94     @Test(expectedExceptions = IllegalAccessError.class)
  95     public void testLookupPublicFieldUsingDVT() throws Throwable {
  96         testAccess(VT_Point, MethodHandles.lookup(), MH_Point_get_x);
  97     }
  98 
  99 
 100     static void testPrivateAccess(ValueType<?> vt, Class<?> lc, MethodHandles.Lookup l, MethodHandle getter) throws Throwable {
 101         testAccess(vt, MethodHandles.privateLookupIn(lc, l), getter);
 102     }
 103 
 104     static void testAccess(ValueType<?> vt, MethodHandles.Lookup l, MethodHandle getter) throws Throwable {
 105         MethodHandle mh = MethodHandles.collectArguments(vwithfield(l, vt, "x", int.class), 0, vt.defaultValueConstant());
 106 
 107         mh = MethodHandles.filterReturnValue(mh, vt.box());
 108 
 109         mh = MethodHandles.filterReturnValue(mh, getter);
 110 
 111         int actual = (int) mh.invoke(42);
 112         assertEquals(actual, 42);
 113     }
 114 
 115     static MethodHandle vwithfield(MethodHandles.Lookup lookup, ValueType<?> vt, String name, Class<?> type) {
 116         Class<?> dvt = vt.valueClass();
 117         return MethodHandleBuilder.loadCode(
 118                 lookup,
 119                 lookup.lookupClass().toString() + "_wither$" + name,
 120                 MethodType.methodType(dvt, dvt, type),
 121                 C -> C.vload(0).load(1).vwithfield(dvt, name, fieldDescriptor(type)).vreturn());
 122     }
 123 
 124     static String fieldDescriptor(Class<?> type) {
 125         String s = MethodType.methodType(type).toMethodDescriptorString();
 126         return s.substring(2);
 127     }
 128 
 129 }


   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 

  24 import jdk.experimental.value.ValueType;
  25 import org.testng.annotations.Test;
  26 
  27 import java.lang.invoke.MethodHandle;
  28 import java.lang.invoke.MethodHandles;
  29 import java.lang.invoke.MethodType;
  30 
  31 import static org.testng.Assert.assertEquals;
  32 import static org.testng.Assert.fail;
  33 import static org.testng.AssertJUnit.assertTrue;
  34 
  35 /*
  36  * @test
  37  * @run testng/othervm -Xverify:none -XX:+EnableMVT -Dvalhalla.enablePoolPatches=true ConstructorTest
  38  */
  39 
  40 @Test
  41 public class ConstructorTest {
  42 
  43     static final ValueType<?> VT_Interval = ValueType.forClass(Interval.class);






  44 
  45     static final MethodHandle VT_constructor;
  46     static {
  47         try {
  48             MethodHandle mh = VT_Interval.findConstructor(MethodHandles.lookup(),
  49                                                           MethodType.methodType(void.class, int.class, int.class));
  50             VT_constructor = MethodHandles.filterReturnValue(mh, VT_Interval.box());

  51         } catch (Exception e) {
  52             throw new InternalError(e);
  53         }
  54     }
  55 
  56     public void testConstructorWithValidArguments() throws Throwable {
  57         Interval i = (Interval) VT_constructor.invoke(1, 2);
  58         assertEquals(i.l, 1);
  59         assertEquals(i.u, 2);





































  60     }
  61 
  62     public void testConstructorWithIllegalArguments() throws Throwable {
  63         try {
  64             Interval i = (Interval) VT_constructor.invoke(3, 1);
  65             fail();
  66         } catch (Throwable t) {
  67             assertTrue(IllegalArgumentException.class.isInstance(t));












  68         }




  69     }

  70 }
< prev index next >