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 VarHandleTestAccessShort 27 * @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 VarHandleTestAccessShort 28 * @run testng/othervm -Diters=20000 VarHandleTestAccessShort 29 * @run testng/othervm -Diters=20000 -XX:-TieredCompilation VarHandleTestAccessShort 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 VarHandleTestAccessShort extends VarHandleBaseTest { 45 static final short static_final_v = (short)0x0123; 46 47 static short static_v; 48 49 final short final_v = (short)0x0123; 50 51 short 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 VarHandleTestAccessShort.class, "final_v", short.class); 67 68 vhField = MethodHandles.lookup().findVarHandle( 69 VarHandleTestAccessShort.class, "v", short.class); 70 71 vhStaticFinalField = MethodHandles.lookup().findStaticVarHandle( 72 VarHandleTestAccessShort.class, "static_final_v", short.class); 73 74 vhStaticField = MethodHandles.lookup().findStaticVarHandle( 75 VarHandleTestAccessShort.class, "static_v", short.class); 76 77 vhArray = MethodHandles.arrayElementVarHandle(short[].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, VarHandleTestAccessShort::testStaticField)); 201 cases.add(new VarHandleAccessTestCase("Static field unsupported", 202 vhStaticField, VarHandleTestAccessShort::testStaticFieldUnsupported, 203 false)); 204 205 cases.add(new VarHandleAccessTestCase("Array", 206 vhArray, VarHandleTestAccessShort::testArray)); 207 cases.add(new VarHandleAccessTestCase("Array unsupported", 208 vhArray, VarHandleTestAccessShort::testArrayUnsupported, 209 false)); 210 cases.add(new VarHandleAccessTestCase("Array index out of bounds", 211 vhArray, VarHandleTestAccessShort::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(VarHandleTestAccessShort recv, VarHandle vh) { 260 checkUOE(() -> { 261 vh.set(recv, (short)0x4567); 262 }); 263 264 checkUOE(() -> { 265 vh.setVolatile(recv, (short)0x4567); 266 }); 267 268 checkUOE(() -> { 269 vh.setRelease(recv, (short)0x4567); 270 }); 271 272 checkUOE(() -> { 273 vh.setOpaque(recv, (short)0x4567); 274 }); 275 276 277 278 } 279 280 281 static void testStaticFinalField(VarHandle vh) { 282 // Plain 283 { 284 short x = (short) vh.get(); 285 assertEquals(x, (short)0x0123, "get short value"); 286 } 287 288 289 // Volatile 290 { 291 short x = (short) vh.getVolatile(); 292 assertEquals(x, (short)0x0123, "getVolatile short value"); 293 } 294 295 // Lazy 296 { 297 short x = (short) vh.getAcquire(); 298 assertEquals(x, (short)0x0123, "getRelease short 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 VarHandleTestAccessShort 28 */ 29 /* Disabled temporarily for lworld 30 * @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 VarHandleTestAccessShort 31 * @run testng/othervm -Diters=20000 VarHandleTestAccessShort 32 * @run testng/othervm -Diters=20000 -XX:-TieredCompilation VarHandleTestAccessShort 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 VarHandleTestAccessShort extends VarHandleBaseTest { 48 static final short static_final_v = (short)0x0123; 49 50 static short static_v; 51 52 final short final_v = (short)0x0123; 53 54 short 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 VarHandleTestAccessShort.class, "final_v", short.class); 72 73 vhField = MethodHandles.lookup().findVarHandle( 74 VarHandleTestAccessShort.class, "v", short.class); 75 76 vhStaticFinalField = MethodHandles.lookup().findStaticVarHandle( 77 VarHandleTestAccessShort.class, "static_final_v", short.class); 78 79 vhStaticField = MethodHandles.lookup().findStaticVarHandle( 80 VarHandleTestAccessShort.class, "static_v", short.class); 81 82 vhArray = MethodHandles.arrayElementVarHandle(short[].class); 83 84 vhValueTypeField = MethodHandles.lookup().findVarHandle( 85 Value.class, "short_v", short.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, VarHandleTestAccessShort::testStaticField)); 209 cases.add(new VarHandleAccessTestCase("Static field unsupported", 210 vhStaticField, VarHandleTestAccessShort::testStaticFieldUnsupported, 211 false)); 212 213 cases.add(new VarHandleAccessTestCase("Array", 214 vhArray, VarHandleTestAccessShort::testArray)); 215 cases.add(new VarHandleAccessTestCase("Array unsupported", 216 vhArray, VarHandleTestAccessShort::testArrayUnsupported, 217 false)); 218 cases.add(new VarHandleAccessTestCase("Array index out of bounds", 219 vhArray, VarHandleTestAccessShort::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(VarHandleTestAccessShort recv, VarHandle vh) { 273 checkUOE(() -> { 274 vh.set(recv, (short)0x4567); 275 }); 276 277 checkUOE(() -> { 278 vh.setVolatile(recv, (short)0x4567); 279 }); 280 281 checkUOE(() -> { 282 vh.setRelease(recv, (short)0x4567); 283 }); 284 285 checkUOE(() -> { 286 vh.setOpaque(recv, (short)0x4567); 287 }); 288 289 290 291 } 292 293 static void testValueTypeField(Value recv, VarHandle vh) { 294 // Plain 295 { 296 short x = (short) vh.get(recv); 297 assertEquals(x, (short)0x0123, "get short value"); 298 } 299 } 300 301 static void testValueTypeFieldUnsupported(Value recv, VarHandle vh) { 302 checkUOE(() -> { 303 vh.set(recv, (short)0x4567); 304 }); 305 } 306 307 static void testStaticFinalField(VarHandle vh) { 308 // Plain 309 { 310 short x = (short) vh.get(); 311 assertEquals(x, (short)0x0123, "get short value"); 312 } 313 314 315 // Volatile 316 { 317 short x = (short) vh.getVolatile(); 318 assertEquals(x, (short)0x0123, "getVolatile short value"); 319 } 320 321 // Lazy 322 { 323 short x = (short) vh.getAcquire(); 324 assertEquals(x, (short)0x0123, "getRelease short value"); 325 } |