< prev index next >

test/jdk/java/lang/invoke/VarHandles/VarHandleTestAccessInt.java

Print this page


   1 /*
   2  * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   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 /*
  25  * @test
  26  * @run testng/othervm -Diters=10    -Xint                   VarHandleTestAccessInt



  27  * @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 VarHandleTestAccessInt
  28  * @run testng/othervm -Diters=20000                         VarHandleTestAccessInt
  29  * @run testng/othervm -Diters=20000 -XX:-TieredCompilation  VarHandleTestAccessInt
  30  */
  31 
  32 import org.testng.annotations.BeforeClass;
  33 import org.testng.annotations.DataProvider;
  34 import org.testng.annotations.Test;
  35 
  36 import java.lang.invoke.MethodHandles;
  37 import java.lang.invoke.VarHandle;
  38 import java.util.ArrayList;
  39 import java.util.Arrays;
  40 import java.util.List;
  41 
  42 import static org.testng.Assert.*;
  43 
  44 public class VarHandleTestAccessInt extends VarHandleBaseTest {
  45     static final int static_final_v = 0x01234567;
  46 
  47     static int static_v;
  48 
  49     final int final_v = 0x01234567;
  50 
  51     int v;
  52 
  53     VarHandle vhFinalField;
  54 
  55     VarHandle vhField;
  56 
  57     VarHandle vhStaticField;
  58 
  59     VarHandle vhStaticFinalField;
  60 
  61     VarHandle vhArray;
  62 


  63     @BeforeClass
  64     public void setup() throws Exception {
  65         vhFinalField = MethodHandles.lookup().findVarHandle(
  66                 VarHandleTestAccessInt.class, "final_v", int.class);
  67 
  68         vhField = MethodHandles.lookup().findVarHandle(
  69                 VarHandleTestAccessInt.class, "v", int.class);
  70 
  71         vhStaticFinalField = MethodHandles.lookup().findStaticVarHandle(
  72             VarHandleTestAccessInt.class, "static_final_v", int.class);
  73 
  74         vhStaticField = MethodHandles.lookup().findStaticVarHandle(
  75             VarHandleTestAccessInt.class, "static_v", int.class);
  76 
  77         vhArray = MethodHandles.arrayElementVarHandle(int[].class);



  78     }
  79 
  80 
  81     @DataProvider
  82     public Object[][] varHandlesProvider() throws Exception {
  83         List<VarHandle> vhs = new ArrayList<>();
  84         vhs.add(vhField);
  85         vhs.add(vhStaticField);
  86         vhs.add(vhArray);
  87 
  88         return vhs.stream().map(tc -> new Object[]{tc}).toArray(Object[][]::new);
  89     }
  90 
  91     @Test(dataProvider = "varHandlesProvider")
  92     public void testIsAccessModeSupported(VarHandle vh) {
  93         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET));
  94         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET));
  95         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_VOLATILE));
  96         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_VOLATILE));
  97         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_ACQUIRE));


 193         cases.add(new VarHandleAccessTestCase("Instance field",
 194                                               vhField, vh -> testInstanceField(this, vh)));
 195         cases.add(new VarHandleAccessTestCase("Instance field unsupported",
 196                                               vhField, vh -> testInstanceFieldUnsupported(this, vh),
 197                                               false));
 198 
 199         cases.add(new VarHandleAccessTestCase("Static field",
 200                                               vhStaticField, VarHandleTestAccessInt::testStaticField));
 201         cases.add(new VarHandleAccessTestCase("Static field unsupported",
 202                                               vhStaticField, VarHandleTestAccessInt::testStaticFieldUnsupported,
 203                                               false));
 204 
 205         cases.add(new VarHandleAccessTestCase("Array",
 206                                               vhArray, VarHandleTestAccessInt::testArray));
 207         cases.add(new VarHandleAccessTestCase("Array unsupported",
 208                                               vhArray, VarHandleTestAccessInt::testArrayUnsupported,
 209                                               false));
 210         cases.add(new VarHandleAccessTestCase("Array index out of bounds",
 211                                               vhArray, VarHandleTestAccessInt::testArrayIndexOutOfBounds,
 212                                               false));





 213 
 214         // Work around issue with jtreg summary reporting which truncates
 215         // the String result of Object.toString to 30 characters, hence
 216         // the first dummy argument
 217         return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new);
 218     }
 219 
 220     @Test(dataProvider = "accessTestCaseProvider")
 221     public <T> void testAccess(String desc, AccessTestCase<T> atc) throws Throwable {
 222         T t = atc.get();
 223         int iters = atc.requiresLoop() ? ITERS : 1;
 224         for (int c = 0; c < iters; c++) {
 225             atc.testAccess(t);
 226         }
 227     }
 228 
 229 
 230 
 231 
 232     static void testInstanceFinalField(VarHandleTestAccessInt recv, VarHandle vh) {


 260         checkUOE(() -> {
 261             vh.set(recv, 0x89ABCDEF);
 262         });
 263 
 264         checkUOE(() -> {
 265             vh.setVolatile(recv, 0x89ABCDEF);
 266         });
 267 
 268         checkUOE(() -> {
 269             vh.setRelease(recv, 0x89ABCDEF);
 270         });
 271 
 272         checkUOE(() -> {
 273             vh.setOpaque(recv, 0x89ABCDEF);
 274         });
 275 
 276 
 277 
 278     }
 279 













 280 
 281     static void testStaticFinalField(VarHandle vh) {
 282         // Plain
 283         {
 284             int x = (int) vh.get();
 285             assertEquals(x, 0x01234567, "get int value");
 286         }
 287 
 288 
 289         // Volatile
 290         {
 291             int x = (int) vh.getVolatile();
 292             assertEquals(x, 0x01234567, "getVolatile int value");
 293         }
 294 
 295         // Lazy
 296         {
 297             int x = (int) vh.getAcquire();
 298             assertEquals(x, 0x01234567, "getRelease int value");
 299         }


   1 /*
   2  * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   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 /*
  25  * @test
  26  * @compile -XDenableValueTypes Value.java
  27  * @run testng/othervm -Xverify:none -Diters=10    -Xint                   VarHandleTestAccessInt
  28  */
  29 /* Disabled temporarily for lworld
  30  * @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 VarHandleTestAccessInt
  31  * @run testng/othervm -Diters=20000                         VarHandleTestAccessInt
  32  * @run testng/othervm -Diters=20000 -XX:-TieredCompilation  VarHandleTestAccessInt
  33  */
  34 
  35 import org.testng.annotations.BeforeClass;
  36 import org.testng.annotations.DataProvider;
  37 import org.testng.annotations.Test;
  38 
  39 import java.lang.invoke.MethodHandles;
  40 import java.lang.invoke.VarHandle;
  41 import java.util.ArrayList;
  42 import java.util.Arrays;
  43 import java.util.List;
  44 
  45 import static org.testng.Assert.*;
  46 
  47 public class VarHandleTestAccessInt extends VarHandleBaseTest {
  48     static final int static_final_v = 0x01234567;
  49 
  50     static int static_v;
  51 
  52     final int final_v = 0x01234567;
  53 
  54     int v;
  55 
  56     VarHandle vhFinalField;
  57 
  58     VarHandle vhField;
  59 
  60     VarHandle vhStaticField;
  61 
  62     VarHandle vhStaticFinalField;
  63 
  64     VarHandle vhArray;
  65 
  66     VarHandle vhValueTypeField;
  67 
  68     @BeforeClass
  69     public void setup() throws Exception {
  70         vhFinalField = MethodHandles.lookup().findVarHandle(
  71                 VarHandleTestAccessInt.class, "final_v", int.class);
  72 
  73         vhField = MethodHandles.lookup().findVarHandle(
  74                 VarHandleTestAccessInt.class, "v", int.class);
  75 
  76         vhStaticFinalField = MethodHandles.lookup().findStaticVarHandle(
  77             VarHandleTestAccessInt.class, "static_final_v", int.class);
  78 
  79         vhStaticField = MethodHandles.lookup().findStaticVarHandle(
  80             VarHandleTestAccessInt.class, "static_v", int.class);
  81 
  82         vhArray = MethodHandles.arrayElementVarHandle(int[].class);
  83 
  84         vhValueTypeField = MethodHandles.lookup().findVarHandle(
  85                     Value.class, "int_v", int.class);
  86     }
  87 
  88 
  89     @DataProvider
  90     public Object[][] varHandlesProvider() throws Exception {
  91         List<VarHandle> vhs = new ArrayList<>();
  92         vhs.add(vhField);
  93         vhs.add(vhStaticField);
  94         vhs.add(vhArray);
  95 
  96         return vhs.stream().map(tc -> new Object[]{tc}).toArray(Object[][]::new);
  97     }
  98 
  99     @Test(dataProvider = "varHandlesProvider")
 100     public void testIsAccessModeSupported(VarHandle vh) {
 101         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET));
 102         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET));
 103         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_VOLATILE));
 104         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_VOLATILE));
 105         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_ACQUIRE));


 201         cases.add(new VarHandleAccessTestCase("Instance field",
 202                                               vhField, vh -> testInstanceField(this, vh)));
 203         cases.add(new VarHandleAccessTestCase("Instance field unsupported",
 204                                               vhField, vh -> testInstanceFieldUnsupported(this, vh),
 205                                               false));
 206 
 207         cases.add(new VarHandleAccessTestCase("Static field",
 208                                               vhStaticField, VarHandleTestAccessInt::testStaticField));
 209         cases.add(new VarHandleAccessTestCase("Static field unsupported",
 210                                               vhStaticField, VarHandleTestAccessInt::testStaticFieldUnsupported,
 211                                               false));
 212 
 213         cases.add(new VarHandleAccessTestCase("Array",
 214                                               vhArray, VarHandleTestAccessInt::testArray));
 215         cases.add(new VarHandleAccessTestCase("Array unsupported",
 216                                               vhArray, VarHandleTestAccessInt::testArrayUnsupported,
 217                                               false));
 218         cases.add(new VarHandleAccessTestCase("Array index out of bounds",
 219                                               vhArray, VarHandleTestAccessInt::testArrayIndexOutOfBounds,
 220                                               false));
 221         cases.add(new VarHandleAccessTestCase("Value type field",
 222                                               vhValueTypeField, vh -> testValueTypeField(Value.VT, vh)));
 223         cases.add(new VarHandleAccessTestCase("Value type field unsupported",
 224                                               vhValueTypeField, vh -> testValueTypeFieldUnsupported(Value.VT, vh),
 225                                               false));
 226 
 227         // Work around issue with jtreg summary reporting which truncates
 228         // the String result of Object.toString to 30 characters, hence
 229         // the first dummy argument
 230         return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new);
 231     }
 232 
 233     @Test(dataProvider = "accessTestCaseProvider")
 234     public <T> void testAccess(String desc, AccessTestCase<T> atc) throws Throwable {
 235         T t = atc.get();
 236         int iters = atc.requiresLoop() ? ITERS : 1;
 237         for (int c = 0; c < iters; c++) {
 238             atc.testAccess(t);
 239         }
 240     }
 241 
 242 
 243 
 244 
 245     static void testInstanceFinalField(VarHandleTestAccessInt recv, VarHandle vh) {


 273         checkUOE(() -> {
 274             vh.set(recv, 0x89ABCDEF);
 275         });
 276 
 277         checkUOE(() -> {
 278             vh.setVolatile(recv, 0x89ABCDEF);
 279         });
 280 
 281         checkUOE(() -> {
 282             vh.setRelease(recv, 0x89ABCDEF);
 283         });
 284 
 285         checkUOE(() -> {
 286             vh.setOpaque(recv, 0x89ABCDEF);
 287         });
 288 
 289 
 290 
 291     }
 292 
 293     static void testValueTypeField(Value recv, VarHandle vh) {
 294         // Plain
 295         {
 296             int x = (int) vh.get(recv);
 297             assertEquals(x, 0x01234567, "get int value");
 298         }
 299     }
 300 
 301     static void testValueTypeFieldUnsupported(Value recv, VarHandle vh) {
 302         checkUOE(() -> {
 303             vh.set(recv, 0x89ABCDEF);
 304         });
 305     }
 306 
 307     static void testStaticFinalField(VarHandle vh) {
 308         // Plain
 309         {
 310             int x = (int) vh.get();
 311             assertEquals(x, 0x01234567, "get int value");
 312         }
 313 
 314 
 315         // Volatile
 316         {
 317             int x = (int) vh.getVolatile();
 318             assertEquals(x, 0x01234567, "getVolatile int value");
 319         }
 320 
 321         // Lazy
 322         {
 323             int x = (int) vh.getAcquire();
 324             assertEquals(x, 0x01234567, "getRelease int value");
 325         }


< prev index next >