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 
  64     @BeforeClass
  65     public void setup() throws Exception {
  66         vhFinalField = MethodHandles.lookup().findVarHandle(
  67                 VarHandleTestAccessInt.class, "final_v", int.class);
  68 
  69         vhField = MethodHandles.lookup().findVarHandle(
  70                 VarHandleTestAccessInt.class, "v", int.class);
  71 
  72         vhStaticFinalField = MethodHandles.lookup().findStaticVarHandle(
  73             VarHandleTestAccessInt.class, "static_final_v", int.class);
  74 
  75         vhStaticField = MethodHandles.lookup().findStaticVarHandle(
  76             VarHandleTestAccessInt.class, "static_v", int.class);
  77 
  78         vhArray = MethodHandles.arrayElementVarHandle(int[].class);
  79     }
  80 
  81 
  82     @DataProvider
  83     public Object[][] varHandlesProvider() throws Exception {
  84         List<VarHandle> vhs = new ArrayList<>();
  85         vhs.add(vhField);
  86         vhs.add(vhStaticField);
  87         vhs.add(vhArray);
  88 
  89         return vhs.stream().map(tc -> new Object[]{tc}).toArray(Object[][]::new);
  90     }
  91 
  92     @Test(dataProvider = "varHandlesProvider")
  93     public void testIsAccessModeSupported(VarHandle vh) {
  94         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET));
  95         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET));
  96         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_VOLATILE));
  97         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_VOLATILE));
  98         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_ACQUIRE));
  99         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_RELEASE));
 100         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_OPAQUE));
 101         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_OPAQUE));
 102 
 103         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_SET));
 104         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE));
 105         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_ACQUIRE));
 106         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_RELEASE));
 107         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_PLAIN));
 108         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
 109         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
 110         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
 111         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
 112         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_ACQUIRE));
 113         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_RELEASE));
 114 
 115         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
 116         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_ACQUIRE));
 117         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_RELEASE));
 118 
 119         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR));
 120         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_ACQUIRE));
 121         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_RELEASE));
 122         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND));
 123         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_ACQUIRE));
 124         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_RELEASE));
 125         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR));
 126         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_ACQUIRE));
 127         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE));
 128     }
 129 
 130 
 131     @DataProvider
 132     public Object[][] typesProvider() throws Exception {
 133         List<Object[]> types = new ArrayList<>();
 134         types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessInt.class)});
 135         types.add(new Object[] {vhStaticField, Arrays.asList()});
 136         types.add(new Object[] {vhArray, Arrays.asList(int[].class, int.class)});
 137 
 138         return types.stream().toArray(Object[][]::new);
 139     }
 140 
 141     @Test(dataProvider = "typesProvider")
 142     public void testTypes(VarHandle vh, List<Class<?>> pts) {
 143         assertEquals(vh.varType(), int.class);
 144 
 145         assertEquals(vh.coordinateTypes(), pts);
 146 
 147         testTypes(vh);
 148     }
 149 
 150 
 151     @Test
 152     public void testLookupInstanceToStatic() {
 153         checkIAE("Lookup of static final field to instance final field", () -> {
 154             MethodHandles.lookup().findStaticVarHandle(
 155                     VarHandleTestAccessInt.class, "final_v", int.class);
 156         });
 157 
 158         checkIAE("Lookup of static field to instance field", () -> {
 159             MethodHandles.lookup().findStaticVarHandle(
 160                     VarHandleTestAccessInt.class, "v", int.class);
 161         });
 162     }
 163 
 164     @Test
 165     public void testLookupStaticToInstance() {
 166         checkIAE("Lookup of instance final field to static final field", () -> {
 167             MethodHandles.lookup().findVarHandle(
 168                 VarHandleTestAccessInt.class, "static_final_v", int.class);
 169         });
 170 
 171         checkIAE("Lookup of instance field to static field", () -> {
 172             vhStaticField = MethodHandles.lookup().findVarHandle(
 173                 VarHandleTestAccessInt.class, "static_v", int.class);
 174         });
 175     }
 176 
 177 
 178     @DataProvider
 179     public Object[][] accessTestCaseProvider() throws Exception {
 180         List<AccessTestCase<?>> cases = new ArrayList<>();
 181 
 182         cases.add(new VarHandleAccessTestCase("Instance final field",
 183                                               vhFinalField, vh -> testInstanceFinalField(this, vh)));
 184         cases.add(new VarHandleAccessTestCase("Instance final field unsupported",
 185                                               vhFinalField, vh -> testInstanceFinalFieldUnsupported(this, vh),
 186                                               false));
 187 
 188         cases.add(new VarHandleAccessTestCase("Static final field",
 189                                               vhStaticFinalField, VarHandleTestAccessInt::testStaticFinalField));
 190         cases.add(new VarHandleAccessTestCase("Static final field unsupported",
 191                                               vhStaticFinalField, VarHandleTestAccessInt::testStaticFinalFieldUnsupported,
 192                                               false));
 193 
 194         cases.add(new VarHandleAccessTestCase("Instance field",
 195                                               vhField, vh -> testInstanceField(this, vh)));
 196         cases.add(new VarHandleAccessTestCase("Instance field unsupported",
 197                                               vhField, vh -> testInstanceFieldUnsupported(this, vh),
 198                                               false));
 199 
 200         cases.add(new VarHandleAccessTestCase("Static field",
 201                                               vhStaticField, VarHandleTestAccessInt::testStaticField));
 202         cases.add(new VarHandleAccessTestCase("Static field unsupported",
 203                                               vhStaticField, VarHandleTestAccessInt::testStaticFieldUnsupported,
 204                                               false));
 205 
 206         cases.add(new VarHandleAccessTestCase("Array",
 207                                               vhArray, VarHandleTestAccessInt::testArray));
 208         cases.add(new VarHandleAccessTestCase("Array unsupported",
 209                                               vhArray, VarHandleTestAccessInt::testArrayUnsupported,
 210                                               false));
 211         cases.add(new VarHandleAccessTestCase("Array index out of bounds",
 212                                               vhArray, VarHandleTestAccessInt::testArrayIndexOutOfBounds,
 213                                               false));
 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) {
 233         // Plain
 234         {
 235             int x = (int) vh.get(recv);
 236             assertEquals(x, 0x01234567, "get int value");
 237         }
 238 
 239 
 240         // Volatile
 241         {
 242             int x = (int) vh.getVolatile(recv);
 243             assertEquals(x, 0x01234567, "getVolatile int value");
 244         }
 245 
 246         // Lazy
 247         {
 248             int x = (int) vh.getAcquire(recv);
 249             assertEquals(x, 0x01234567, "getRelease int value");
 250         }
 251 
 252         // Opaque
 253         {
 254             int x = (int) vh.getOpaque(recv);
 255             assertEquals(x, 0x01234567, "getOpaque int value");
 256         }
 257     }
 258 
 259     static void testInstanceFinalFieldUnsupported(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         }
 300 
 301         // Opaque
 302         {
 303             int x = (int) vh.getOpaque();
 304             assertEquals(x, 0x01234567, "getOpaque int value");
 305         }
 306     }
 307 
 308     static void testStaticFinalFieldUnsupported(VarHandle vh) {
 309         checkUOE(() -> {
 310             vh.set(0x89ABCDEF);
 311         });
 312 
 313         checkUOE(() -> {
 314             vh.setVolatile(0x89ABCDEF);
 315         });
 316 
 317         checkUOE(() -> {
 318             vh.setRelease(0x89ABCDEF);
 319         });
 320 
 321         checkUOE(() -> {
 322             vh.setOpaque(0x89ABCDEF);
 323         });
 324 
 325 
 326 
 327     }
 328 
 329 
 330     static void testInstanceField(VarHandleTestAccessInt recv, VarHandle vh) {
 331         // Plain
 332         {
 333             vh.set(recv, 0x01234567);
 334             int x = (int) vh.get(recv);
 335             assertEquals(x, 0x01234567, "set int value");
 336         }
 337 
 338 
 339         // Volatile
 340         {
 341             vh.setVolatile(recv, 0x89ABCDEF);
 342             int x = (int) vh.getVolatile(recv);
 343             assertEquals(x, 0x89ABCDEF, "setVolatile int value");
 344         }
 345 
 346         // Lazy
 347         {
 348             vh.setRelease(recv, 0x01234567);
 349             int x = (int) vh.getAcquire(recv);
 350             assertEquals(x, 0x01234567, "setRelease int value");
 351         }
 352 
 353         // Opaque
 354         {
 355             vh.setOpaque(recv, 0x89ABCDEF);
 356             int x = (int) vh.getOpaque(recv);
 357             assertEquals(x, 0x89ABCDEF, "setOpaque int value");
 358         }
 359 
 360         vh.set(recv, 0x01234567);
 361 
 362         // Compare
 363         {
 364             boolean r = vh.compareAndSet(recv, 0x01234567, 0x89ABCDEF);
 365             assertEquals(r, true, "success compareAndSet int");
 366             int x = (int) vh.get(recv);
 367             assertEquals(x, 0x89ABCDEF, "success compareAndSet int value");
 368         }
 369 
 370         {
 371             boolean r = vh.compareAndSet(recv, 0x01234567, 0xCAFEBABE);
 372             assertEquals(r, false, "failing compareAndSet int");
 373             int x = (int) vh.get(recv);
 374             assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value");
 375         }
 376 
 377         {
 378             int r = (int) vh.compareAndExchange(recv, 0x89ABCDEF, 0x01234567);
 379             assertEquals(r, 0x89ABCDEF, "success compareAndExchange int");
 380             int x = (int) vh.get(recv);
 381             assertEquals(x, 0x01234567, "success compareAndExchange int value");
 382         }
 383 
 384         {
 385             int r = (int) vh.compareAndExchange(recv, 0x89ABCDEF, 0xCAFEBABE);
 386             assertEquals(r, 0x01234567, "failing compareAndExchange int");
 387             int x = (int) vh.get(recv);
 388             assertEquals(x, 0x01234567, "failing compareAndExchange int value");
 389         }
 390 
 391         {
 392             int r = (int) vh.compareAndExchangeAcquire(recv, 0x01234567, 0x89ABCDEF);
 393             assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int");
 394             int x = (int) vh.get(recv);
 395             assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value");
 396         }
 397 
 398         {
 399             int r = (int) vh.compareAndExchangeAcquire(recv, 0x01234567, 0xCAFEBABE);
 400             assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int");
 401             int x = (int) vh.get(recv);
 402             assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value");
 403         }
 404 
 405         {
 406             int r = (int) vh.compareAndExchangeRelease(recv, 0x89ABCDEF, 0x01234567);
 407             assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int");
 408             int x = (int) vh.get(recv);
 409             assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value");
 410         }
 411 
 412         {
 413             int r = (int) vh.compareAndExchangeRelease(recv, 0x89ABCDEF, 0xCAFEBABE);
 414             assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int");
 415             int x = (int) vh.get(recv);
 416             assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value");
 417         }
 418 
 419         {
 420             boolean success = false;
 421             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 422                 success = vh.weakCompareAndSetPlain(recv, 0x01234567, 0x89ABCDEF);
 423             }
 424             assertEquals(success, true, "weakCompareAndSetPlain int");
 425             int x = (int) vh.get(recv);
 426             assertEquals(x, 0x89ABCDEF, "weakCompareAndSetPlain int value");
 427         }
 428 
 429         {
 430             boolean success = false;
 431             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 432                 success = vh.weakCompareAndSetAcquire(recv, 0x89ABCDEF, 0x01234567);
 433             }
 434             assertEquals(success, true, "weakCompareAndSetAcquire int");
 435             int x = (int) vh.get(recv);
 436             assertEquals(x, 0x01234567, "weakCompareAndSetAcquire int");
 437         }
 438 
 439         {
 440             boolean success = false;
 441             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 442                 success = vh.weakCompareAndSetRelease(recv, 0x01234567, 0x89ABCDEF);
 443             }
 444             assertEquals(success, true, "weakCompareAndSetRelease int");
 445             int x = (int) vh.get(recv);
 446             assertEquals(x, 0x89ABCDEF, "weakCompareAndSetRelease int");
 447         }
 448 
 449         {
 450             boolean success = false;
 451             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 452                 success = vh.weakCompareAndSet(recv, 0x89ABCDEF, 0x01234567);
 453             }
 454             assertEquals(success, true, "weakCompareAndSet int");
 455             int x = (int) vh.get(recv);
 456             assertEquals(x, 0x01234567, "weakCompareAndSet int value");
 457         }
 458 
 459         // Compare set and get
 460         {
 461             vh.set(recv, 0x01234567);
 462 
 463             int o = (int) vh.getAndSet(recv, 0x89ABCDEF);
 464             assertEquals(o, 0x01234567, "getAndSet int");
 465             int x = (int) vh.get(recv);
 466             assertEquals(x, 0x89ABCDEF, "getAndSet int value");
 467         }
 468 
 469         {
 470             vh.set(recv, 0x01234567);
 471 
 472             int o = (int) vh.getAndSetAcquire(recv, 0x89ABCDEF);
 473             assertEquals(o, 0x01234567, "getAndSetAcquire int");
 474             int x = (int) vh.get(recv);
 475             assertEquals(x, 0x89ABCDEF, "getAndSetAcquire int value");
 476         }
 477 
 478         {
 479             vh.set(recv, 0x01234567);
 480 
 481             int o = (int) vh.getAndSetRelease(recv, 0x89ABCDEF);
 482             assertEquals(o, 0x01234567, "getAndSetRelease int");
 483             int x = (int) vh.get(recv);
 484             assertEquals(x, 0x89ABCDEF, "getAndSetRelease int value");
 485         }
 486 
 487         // get and add, add and get
 488         {
 489             vh.set(recv, 0x01234567);
 490 
 491             int o = (int) vh.getAndAdd(recv, 0x89ABCDEF);
 492             assertEquals(o, 0x01234567, "getAndAdd int");
 493             int x = (int) vh.get(recv);
 494             assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value");
 495         }
 496 
 497         {
 498             vh.set(recv, 0x01234567);
 499 
 500             int o = (int) vh.getAndAddAcquire(recv, 0x89ABCDEF);
 501             assertEquals(o, 0x01234567, "getAndAddAcquire int");
 502             int x = (int) vh.get(recv);
 503             assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value");
 504         }
 505 
 506         {
 507             vh.set(recv, 0x01234567);
 508 
 509             int o = (int) vh.getAndAddRelease(recv, 0x89ABCDEF);
 510             assertEquals(o, 0x01234567, "getAndAddReleaseint");
 511             int x = (int) vh.get(recv);
 512             assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value");
 513         }
 514 
 515         // get and bitwise or
 516         {
 517             vh.set(recv, 0x01234567);
 518 
 519             int o = (int) vh.getAndBitwiseOr(recv, 0x89ABCDEF);
 520             assertEquals(o, 0x01234567, "getAndBitwiseOr int");
 521             int x = (int) vh.get(recv);
 522             assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value");
 523         }
 524 
 525         {
 526             vh.set(recv, 0x01234567);
 527 
 528             int o = (int) vh.getAndBitwiseOrAcquire(recv, 0x89ABCDEF);
 529             assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int");
 530             int x = (int) vh.get(recv);
 531             assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value");
 532         }
 533 
 534         {
 535             vh.set(recv, 0x01234567);
 536 
 537             int o = (int) vh.getAndBitwiseOrRelease(recv, 0x89ABCDEF);
 538             assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int");
 539             int x = (int) vh.get(recv);
 540             assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value");
 541         }
 542 
 543         // get and bitwise and
 544         {
 545             vh.set(recv, 0x01234567);
 546 
 547             int o = (int) vh.getAndBitwiseAnd(recv, 0x89ABCDEF);
 548             assertEquals(o, 0x01234567, "getAndBitwiseAnd int");
 549             int x = (int) vh.get(recv);
 550             assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value");
 551         }
 552 
 553         {
 554             vh.set(recv, 0x01234567);
 555 
 556             int o = (int) vh.getAndBitwiseAndAcquire(recv, 0x89ABCDEF);
 557             assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int");
 558             int x = (int) vh.get(recv);
 559             assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value");
 560         }
 561 
 562         {
 563             vh.set(recv, 0x01234567);
 564 
 565             int o = (int) vh.getAndBitwiseAndRelease(recv, 0x89ABCDEF);
 566             assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int");
 567             int x = (int) vh.get(recv);
 568             assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value");
 569         }
 570 
 571         // get and bitwise xor
 572         {
 573             vh.set(recv, 0x01234567);
 574 
 575             int o = (int) vh.getAndBitwiseXor(recv, 0x89ABCDEF);
 576             assertEquals(o, 0x01234567, "getAndBitwiseXor int");
 577             int x = (int) vh.get(recv);
 578             assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value");
 579         }
 580 
 581         {
 582             vh.set(recv, 0x01234567);
 583 
 584             int o = (int) vh.getAndBitwiseXorAcquire(recv, 0x89ABCDEF);
 585             assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int");
 586             int x = (int) vh.get(recv);
 587             assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value");
 588         }
 589 
 590         {
 591             vh.set(recv, 0x01234567);
 592 
 593             int o = (int) vh.getAndBitwiseXorRelease(recv, 0x89ABCDEF);
 594             assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int");
 595             int x = (int) vh.get(recv);
 596             assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value");
 597         }
 598     }
 599 
 600     static void testInstanceFieldUnsupported(VarHandleTestAccessInt recv, VarHandle vh) {
 601 
 602 
 603     }
 604 
 605 
 606     static void testStaticField(VarHandle vh) {
 607         // Plain
 608         {
 609             vh.set(0x01234567);
 610             int x = (int) vh.get();
 611             assertEquals(x, 0x01234567, "set int value");
 612         }
 613 
 614 
 615         // Volatile
 616         {
 617             vh.setVolatile(0x89ABCDEF);
 618             int x = (int) vh.getVolatile();
 619             assertEquals(x, 0x89ABCDEF, "setVolatile int value");
 620         }
 621 
 622         // Lazy
 623         {
 624             vh.setRelease(0x01234567);
 625             int x = (int) vh.getAcquire();
 626             assertEquals(x, 0x01234567, "setRelease int value");
 627         }
 628 
 629         // Opaque
 630         {
 631             vh.setOpaque(0x89ABCDEF);
 632             int x = (int) vh.getOpaque();
 633             assertEquals(x, 0x89ABCDEF, "setOpaque int value");
 634         }
 635 
 636         vh.set(0x01234567);
 637 
 638         // Compare
 639         {
 640             boolean r = vh.compareAndSet(0x01234567, 0x89ABCDEF);
 641             assertEquals(r, true, "success compareAndSet int");
 642             int x = (int) vh.get();
 643             assertEquals(x, 0x89ABCDEF, "success compareAndSet int value");
 644         }
 645 
 646         {
 647             boolean r = vh.compareAndSet(0x01234567, 0xCAFEBABE);
 648             assertEquals(r, false, "failing compareAndSet int");
 649             int x = (int) vh.get();
 650             assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value");
 651         }
 652 
 653         {
 654             int r = (int) vh.compareAndExchange(0x89ABCDEF, 0x01234567);
 655             assertEquals(r, 0x89ABCDEF, "success compareAndExchange int");
 656             int x = (int) vh.get();
 657             assertEquals(x, 0x01234567, "success compareAndExchange int value");
 658         }
 659 
 660         {
 661             int r = (int) vh.compareAndExchange(0x89ABCDEF, 0xCAFEBABE);
 662             assertEquals(r, 0x01234567, "failing compareAndExchange int");
 663             int x = (int) vh.get();
 664             assertEquals(x, 0x01234567, "failing compareAndExchange int value");
 665         }
 666 
 667         {
 668             int r = (int) vh.compareAndExchangeAcquire(0x01234567, 0x89ABCDEF);
 669             assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int");
 670             int x = (int) vh.get();
 671             assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value");
 672         }
 673 
 674         {
 675             int r = (int) vh.compareAndExchangeAcquire(0x01234567, 0xCAFEBABE);
 676             assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int");
 677             int x = (int) vh.get();
 678             assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value");
 679         }
 680 
 681         {
 682             int r = (int) vh.compareAndExchangeRelease(0x89ABCDEF, 0x01234567);
 683             assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int");
 684             int x = (int) vh.get();
 685             assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value");
 686         }
 687 
 688         {
 689             int r = (int) vh.compareAndExchangeRelease(0x89ABCDEF, 0xCAFEBABE);
 690             assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int");
 691             int x = (int) vh.get();
 692             assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value");
 693         }
 694 
 695         {
 696             boolean success = false;
 697             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 698                 success = vh.weakCompareAndSetPlain(0x01234567, 0x89ABCDEF);
 699             }
 700             assertEquals(success, true, "weakCompareAndSetPlain int");
 701             int x = (int) vh.get();
 702             assertEquals(x, 0x89ABCDEF, "weakCompareAndSetPlain int value");
 703         }
 704 
 705         {
 706             boolean success = false;
 707             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 708                 success = vh.weakCompareAndSetAcquire(0x89ABCDEF, 0x01234567);
 709             }
 710             assertEquals(success, true, "weakCompareAndSetAcquire int");
 711             int x = (int) vh.get();
 712             assertEquals(x, 0x01234567, "weakCompareAndSetAcquire int");
 713         }
 714 
 715         {
 716             boolean success = false;
 717             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 718                 success = vh.weakCompareAndSetRelease(0x01234567, 0x89ABCDEF);
 719             }
 720             assertEquals(success, true, "weakCompareAndSetRelease int");
 721             int x = (int) vh.get();
 722             assertEquals(x, 0x89ABCDEF, "weakCompareAndSetRelease int");
 723         }
 724 
 725         {
 726             boolean success = false;
 727             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 728                 success = vh.weakCompareAndSet(0x89ABCDEF, 0x01234567);
 729             }
 730             assertEquals(success, true, "weakCompareAndSet int");
 731             int x = (int) vh.get();
 732             assertEquals(x, 0x01234567, "weakCompareAndSet int");
 733         }
 734 
 735         // Compare set and get
 736         {
 737             vh.set(0x01234567);
 738 
 739             int o = (int) vh.getAndSet(0x89ABCDEF);
 740             assertEquals(o, 0x01234567, "getAndSet int");
 741             int x = (int) vh.get();
 742             assertEquals(x, 0x89ABCDEF, "getAndSet int value");
 743         }
 744 
 745         {
 746             vh.set(0x01234567);
 747 
 748             int o = (int) vh.getAndSetAcquire(0x89ABCDEF);
 749             assertEquals(o, 0x01234567, "getAndSetAcquire int");
 750             int x = (int) vh.get();
 751             assertEquals(x, 0x89ABCDEF, "getAndSetAcquire int value");
 752         }
 753 
 754         {
 755             vh.set(0x01234567);
 756 
 757             int o = (int) vh.getAndSetRelease(0x89ABCDEF);
 758             assertEquals(o, 0x01234567, "getAndSetRelease int");
 759             int x = (int) vh.get();
 760             assertEquals(x, 0x89ABCDEF, "getAndSetRelease int value");
 761         }
 762 
 763         // get and add, add and get
 764         {
 765             vh.set(0x01234567);
 766 
 767             int o = (int) vh.getAndAdd(0x89ABCDEF);
 768             assertEquals(o, 0x01234567, "getAndAdd int");
 769             int x = (int) vh.get();
 770             assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value");
 771         }
 772 
 773         {
 774             vh.set(0x01234567);
 775 
 776             int o = (int) vh.getAndAddAcquire(0x89ABCDEF);
 777             assertEquals(o, 0x01234567, "getAndAddAcquire int");
 778             int x = (int) vh.get();
 779             assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value");
 780         }
 781 
 782         {
 783             vh.set(0x01234567);
 784 
 785             int o = (int) vh.getAndAddRelease(0x89ABCDEF);
 786             assertEquals(o, 0x01234567, "getAndAddReleaseint");
 787             int x = (int) vh.get();
 788             assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value");
 789         }
 790 
 791         // get and bitwise or
 792         {
 793             vh.set(0x01234567);
 794 
 795             int o = (int) vh.getAndBitwiseOr(0x89ABCDEF);
 796             assertEquals(o, 0x01234567, "getAndBitwiseOr int");
 797             int x = (int) vh.get();
 798             assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value");
 799         }
 800 
 801         {
 802             vh.set(0x01234567);
 803 
 804             int o = (int) vh.getAndBitwiseOrAcquire(0x89ABCDEF);
 805             assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int");
 806             int x = (int) vh.get();
 807             assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value");
 808         }
 809 
 810         {
 811             vh.set(0x01234567);
 812 
 813             int o = (int) vh.getAndBitwiseOrRelease(0x89ABCDEF);
 814             assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int");
 815             int x = (int) vh.get();
 816             assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value");
 817         }
 818 
 819         // get and bitwise and
 820         {
 821             vh.set(0x01234567);
 822 
 823             int o = (int) vh.getAndBitwiseAnd(0x89ABCDEF);
 824             assertEquals(o, 0x01234567, "getAndBitwiseAnd int");
 825             int x = (int) vh.get();
 826             assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value");
 827         }
 828 
 829         {
 830             vh.set(0x01234567);
 831 
 832             int o = (int) vh.getAndBitwiseAndAcquire(0x89ABCDEF);
 833             assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int");
 834             int x = (int) vh.get();
 835             assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value");
 836         }
 837 
 838         {
 839             vh.set(0x01234567);
 840 
 841             int o = (int) vh.getAndBitwiseAndRelease(0x89ABCDEF);
 842             assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int");
 843             int x = (int) vh.get();
 844             assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value");
 845         }
 846 
 847         // get and bitwise xor
 848         {
 849             vh.set(0x01234567);
 850 
 851             int o = (int) vh.getAndBitwiseXor(0x89ABCDEF);
 852             assertEquals(o, 0x01234567, "getAndBitwiseXor int");
 853             int x = (int) vh.get();
 854             assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value");
 855         }
 856 
 857         {
 858             vh.set(0x01234567);
 859 
 860             int o = (int) vh.getAndBitwiseXorAcquire(0x89ABCDEF);
 861             assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int");
 862             int x = (int) vh.get();
 863             assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value");
 864         }
 865 
 866         {
 867             vh.set(0x01234567);
 868 
 869             int o = (int) vh.getAndBitwiseXorRelease(0x89ABCDEF);
 870             assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int");
 871             int x = (int) vh.get();
 872             assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value");
 873         }
 874     }
 875 
 876     static void testStaticFieldUnsupported(VarHandle vh) {
 877 
 878 
 879     }
 880 
 881 
 882     static void testArray(VarHandle vh) {
 883         int[] array = new int[10];
 884 
 885         for (int i = 0; i < array.length; i++) {
 886             // Plain
 887             {
 888                 vh.set(array, i, 0x01234567);
 889                 int x = (int) vh.get(array, i);
 890                 assertEquals(x, 0x01234567, "get int value");
 891             }
 892 
 893 
 894             // Volatile
 895             {
 896                 vh.setVolatile(array, i, 0x89ABCDEF);
 897                 int x = (int) vh.getVolatile(array, i);
 898                 assertEquals(x, 0x89ABCDEF, "setVolatile int value");
 899             }
 900 
 901             // Lazy
 902             {
 903                 vh.setRelease(array, i, 0x01234567);
 904                 int x = (int) vh.getAcquire(array, i);
 905                 assertEquals(x, 0x01234567, "setRelease int value");
 906             }
 907 
 908             // Opaque
 909             {
 910                 vh.setOpaque(array, i, 0x89ABCDEF);
 911                 int x = (int) vh.getOpaque(array, i);
 912                 assertEquals(x, 0x89ABCDEF, "setOpaque int value");
 913             }
 914 
 915             vh.set(array, i, 0x01234567);
 916 
 917             // Compare
 918             {
 919                 boolean r = vh.compareAndSet(array, i, 0x01234567, 0x89ABCDEF);
 920                 assertEquals(r, true, "success compareAndSet int");
 921                 int x = (int) vh.get(array, i);
 922                 assertEquals(x, 0x89ABCDEF, "success compareAndSet int value");
 923             }
 924 
 925             {
 926                 boolean r = vh.compareAndSet(array, i, 0x01234567, 0xCAFEBABE);
 927                 assertEquals(r, false, "failing compareAndSet int");
 928                 int x = (int) vh.get(array, i);
 929                 assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value");
 930             }
 931 
 932             {
 933                 int r = (int) vh.compareAndExchange(array, i, 0x89ABCDEF, 0x01234567);
 934                 assertEquals(r, 0x89ABCDEF, "success compareAndExchange int");
 935                 int x = (int) vh.get(array, i);
 936                 assertEquals(x, 0x01234567, "success compareAndExchange int value");
 937             }
 938 
 939             {
 940                 int r = (int) vh.compareAndExchange(array, i, 0x89ABCDEF, 0xCAFEBABE);
 941                 assertEquals(r, 0x01234567, "failing compareAndExchange int");
 942                 int x = (int) vh.get(array, i);
 943                 assertEquals(x, 0x01234567, "failing compareAndExchange int value");
 944             }
 945 
 946             {
 947                 int r = (int) vh.compareAndExchangeAcquire(array, i, 0x01234567, 0x89ABCDEF);
 948                 assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int");
 949                 int x = (int) vh.get(array, i);
 950                 assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value");
 951             }
 952 
 953             {
 954                 int r = (int) vh.compareAndExchangeAcquire(array, i, 0x01234567, 0xCAFEBABE);
 955                 assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int");
 956                 int x = (int) vh.get(array, i);
 957                 assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value");
 958             }
 959 
 960             {
 961                 int r = (int) vh.compareAndExchangeRelease(array, i, 0x89ABCDEF, 0x01234567);
 962                 assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int");
 963                 int x = (int) vh.get(array, i);
 964                 assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value");
 965             }
 966 
 967             {
 968                 int r = (int) vh.compareAndExchangeRelease(array, i, 0x89ABCDEF, 0xCAFEBABE);
 969                 assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int");
 970                 int x = (int) vh.get(array, i);
 971                 assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value");
 972             }
 973 
 974             {
 975                 boolean success = false;
 976                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 977                     success = vh.weakCompareAndSetPlain(array, i, 0x01234567, 0x89ABCDEF);
 978                 }
 979                 assertEquals(success, true, "weakCompareAndSetPlain int");
 980                 int x = (int) vh.get(array, i);
 981                 assertEquals(x, 0x89ABCDEF, "weakCompareAndSetPlain int value");
 982             }
 983 
 984             {
 985                 boolean success = false;
 986                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 987                     success = vh.weakCompareAndSetAcquire(array, i, 0x89ABCDEF, 0x01234567);
 988                 }
 989                 assertEquals(success, true, "weakCompareAndSetAcquire int");
 990                 int x = (int) vh.get(array, i);
 991                 assertEquals(x, 0x01234567, "weakCompareAndSetAcquire int");
 992             }
 993 
 994             {
 995                 boolean success = false;
 996                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 997                     success = vh.weakCompareAndSetRelease(array, i, 0x01234567, 0x89ABCDEF);
 998                 }
 999                 assertEquals(success, true, "weakCompareAndSetRelease int");
1000                 int x = (int) vh.get(array, i);
1001                 assertEquals(x, 0x89ABCDEF, "weakCompareAndSetRelease int");
1002             }
1003 
1004             {
1005                 boolean success = false;
1006                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1007                     success = vh.weakCompareAndSet(array, i, 0x89ABCDEF, 0x01234567);
1008                 }
1009                 assertEquals(success, true, "weakCompareAndSet int");
1010                 int x = (int) vh.get(array, i);
1011                 assertEquals(x, 0x01234567, "weakCompareAndSet int");
1012             }
1013 
1014             // Compare set and get
1015             {
1016                 vh.set(array, i, 0x01234567);
1017 
1018                 int o = (int) vh.getAndSet(array, i, 0x89ABCDEF);
1019                 assertEquals(o, 0x01234567, "getAndSet int");
1020                 int x = (int) vh.get(array, i);
1021                 assertEquals(x, 0x89ABCDEF, "getAndSet int value");
1022             }
1023 
1024             {
1025                 vh.set(array, i, 0x01234567);
1026 
1027                 int o = (int) vh.getAndSetAcquire(array, i, 0x89ABCDEF);
1028                 assertEquals(o, 0x01234567, "getAndSetAcquire int");
1029                 int x = (int) vh.get(array, i);
1030                 assertEquals(x, 0x89ABCDEF, "getAndSetAcquire int value");
1031             }
1032 
1033             {
1034                 vh.set(array, i, 0x01234567);
1035 
1036                 int o = (int) vh.getAndSetRelease(array, i, 0x89ABCDEF);
1037                 assertEquals(o, 0x01234567, "getAndSetRelease int");
1038                 int x = (int) vh.get(array, i);
1039                 assertEquals(x, 0x89ABCDEF, "getAndSetRelease int value");
1040             }
1041 
1042             // get and add, add and get
1043             {
1044                 vh.set(array, i, 0x01234567);
1045 
1046                 int o = (int) vh.getAndAdd(array, i, 0x89ABCDEF);
1047                 assertEquals(o, 0x01234567, "getAndAdd int");
1048                 int x = (int) vh.get(array, i);
1049                 assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value");
1050             }
1051 
1052             {
1053                 vh.set(array, i, 0x01234567);
1054 
1055                 int o = (int) vh.getAndAddAcquire(array, i, 0x89ABCDEF);
1056                 assertEquals(o, 0x01234567, "getAndAddAcquire int");
1057                 int x = (int) vh.get(array, i);
1058                 assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value");
1059             }
1060 
1061             {
1062                 vh.set(array, i, 0x01234567);
1063 
1064                 int o = (int) vh.getAndAddRelease(array, i, 0x89ABCDEF);
1065                 assertEquals(o, 0x01234567, "getAndAddReleaseint");
1066                 int x = (int) vh.get(array, i);
1067                 assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value");
1068             }
1069 
1070             // get and bitwise or
1071             {
1072                 vh.set(array, i, 0x01234567);
1073 
1074                 int o = (int) vh.getAndBitwiseOr(array, i, 0x89ABCDEF);
1075                 assertEquals(o, 0x01234567, "getAndBitwiseOr int");
1076                 int x = (int) vh.get(array, i);
1077                 assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value");
1078             }
1079 
1080             {
1081                 vh.set(array, i, 0x01234567);
1082 
1083                 int o = (int) vh.getAndBitwiseOrAcquire(array, i, 0x89ABCDEF);
1084                 assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int");
1085                 int x = (int) vh.get(array, i);
1086                 assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value");
1087             }
1088 
1089             {
1090                 vh.set(array, i, 0x01234567);
1091 
1092                 int o = (int) vh.getAndBitwiseOrRelease(array, i, 0x89ABCDEF);
1093                 assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int");
1094                 int x = (int) vh.get(array, i);
1095                 assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value");
1096             }
1097 
1098             // get and bitwise and
1099             {
1100                 vh.set(array, i, 0x01234567);
1101 
1102                 int o = (int) vh.getAndBitwiseAnd(array, i, 0x89ABCDEF);
1103                 assertEquals(o, 0x01234567, "getAndBitwiseAnd int");
1104                 int x = (int) vh.get(array, i);
1105                 assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value");
1106             }
1107 
1108             {
1109                 vh.set(array, i, 0x01234567);
1110 
1111                 int o = (int) vh.getAndBitwiseAndAcquire(array, i, 0x89ABCDEF);
1112                 assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int");
1113                 int x = (int) vh.get(array, i);
1114                 assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value");
1115             }
1116 
1117             {
1118                 vh.set(array, i, 0x01234567);
1119 
1120                 int o = (int) vh.getAndBitwiseAndRelease(array, i, 0x89ABCDEF);
1121                 assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int");
1122                 int x = (int) vh.get(array, i);
1123                 assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value");
1124             }
1125 
1126             // get and bitwise xor
1127             {
1128                 vh.set(array, i, 0x01234567);
1129 
1130                 int o = (int) vh.getAndBitwiseXor(array, i, 0x89ABCDEF);
1131                 assertEquals(o, 0x01234567, "getAndBitwiseXor int");
1132                 int x = (int) vh.get(array, i);
1133                 assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value");
1134             }
1135 
1136             {
1137                 vh.set(array, i, 0x01234567);
1138 
1139                 int o = (int) vh.getAndBitwiseXorAcquire(array, i, 0x89ABCDEF);
1140                 assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int");
1141                 int x = (int) vh.get(array, i);
1142                 assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value");
1143             }
1144 
1145             {
1146                 vh.set(array, i, 0x01234567);
1147 
1148                 int o = (int) vh.getAndBitwiseXorRelease(array, i, 0x89ABCDEF);
1149                 assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int");
1150                 int x = (int) vh.get(array, i);
1151                 assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value");
1152             }
1153         }
1154     }
1155 
1156     static void testArrayUnsupported(VarHandle vh) {
1157         int[] array = new int[10];
1158 
1159         int i = 0;
1160 
1161 
1162     }
1163 
1164     static void testArrayIndexOutOfBounds(VarHandle vh) throws Throwable {
1165         int[] array = new int[10];
1166 
1167         for (int i : new int[]{-1, Integer.MIN_VALUE, 10, 11, Integer.MAX_VALUE}) {
1168             final int ci = i;
1169 
1170             checkIOOBE(() -> {
1171                 int x = (int) vh.get(array, ci);
1172             });
1173 
1174             checkIOOBE(() -> {
1175                 vh.set(array, ci, 0x01234567);
1176             });
1177 
1178             checkIOOBE(() -> {
1179                 int x = (int) vh.getVolatile(array, ci);
1180             });
1181 
1182             checkIOOBE(() -> {
1183                 vh.setVolatile(array, ci, 0x01234567);
1184             });
1185 
1186             checkIOOBE(() -> {
1187                 int x = (int) vh.getAcquire(array, ci);
1188             });
1189 
1190             checkIOOBE(() -> {
1191                 vh.setRelease(array, ci, 0x01234567);
1192             });
1193 
1194             checkIOOBE(() -> {
1195                 int x = (int) vh.getOpaque(array, ci);
1196             });
1197 
1198             checkIOOBE(() -> {
1199                 vh.setOpaque(array, ci, 0x01234567);
1200             });
1201 
1202             checkIOOBE(() -> {
1203                 boolean r = vh.compareAndSet(array, ci, 0x01234567, 0x89ABCDEF);
1204             });
1205 
1206             checkIOOBE(() -> {
1207                 int r = (int) vh.compareAndExchange(array, ci, 0x89ABCDEF, 0x01234567);
1208             });
1209 
1210             checkIOOBE(() -> {
1211                 int r = (int) vh.compareAndExchangeAcquire(array, ci, 0x89ABCDEF, 0x01234567);
1212             });
1213 
1214             checkIOOBE(() -> {
1215                 int r = (int) vh.compareAndExchangeRelease(array, ci, 0x89ABCDEF, 0x01234567);
1216             });
1217 
1218             checkIOOBE(() -> {
1219                 boolean r = vh.weakCompareAndSetPlain(array, ci, 0x01234567, 0x89ABCDEF);
1220             });
1221 
1222             checkIOOBE(() -> {
1223                 boolean r = vh.weakCompareAndSet(array, ci, 0x01234567, 0x89ABCDEF);
1224             });
1225 
1226             checkIOOBE(() -> {
1227                 boolean r = vh.weakCompareAndSetAcquire(array, ci, 0x01234567, 0x89ABCDEF);
1228             });
1229 
1230             checkIOOBE(() -> {
1231                 boolean r = vh.weakCompareAndSetRelease(array, ci, 0x01234567, 0x89ABCDEF);
1232             });
1233 
1234             checkIOOBE(() -> {
1235                 int o = (int) vh.getAndSet(array, ci, 0x01234567);
1236             });
1237 
1238             checkIOOBE(() -> {
1239                 int o = (int) vh.getAndSetAcquire(array, ci, 0x01234567);
1240             });
1241 
1242             checkIOOBE(() -> {
1243                 int o = (int) vh.getAndSetRelease(array, ci, 0x01234567);
1244             });
1245 
1246             checkIOOBE(() -> {
1247                 int o = (int) vh.getAndAdd(array, ci, 0x01234567);
1248             });
1249 
1250             checkIOOBE(() -> {
1251                 int o = (int) vh.getAndAddAcquire(array, ci, 0x01234567);
1252             });
1253 
1254             checkIOOBE(() -> {
1255                 int o = (int) vh.getAndAddRelease(array, ci, 0x01234567);
1256             });
1257 
1258             checkIOOBE(() -> {
1259                 int o = (int) vh.getAndBitwiseOr(array, ci, 0x01234567);
1260             });
1261 
1262             checkIOOBE(() -> {
1263                 int o = (int) vh.getAndBitwiseOrAcquire(array, ci, 0x01234567);
1264             });
1265 
1266             checkIOOBE(() -> {
1267                 int o = (int) vh.getAndBitwiseOrRelease(array, ci, 0x01234567);
1268             });
1269 
1270             checkIOOBE(() -> {
1271                 int o = (int) vh.getAndBitwiseAnd(array, ci, 0x01234567);
1272             });
1273 
1274             checkIOOBE(() -> {
1275                 int o = (int) vh.getAndBitwiseAndAcquire(array, ci, 0x01234567);
1276             });
1277 
1278             checkIOOBE(() -> {
1279                 int o = (int) vh.getAndBitwiseAndRelease(array, ci, 0x01234567);
1280             });
1281 
1282             checkIOOBE(() -> {
1283                 int o = (int) vh.getAndBitwiseXor(array, ci, 0x01234567);
1284             });
1285 
1286             checkIOOBE(() -> {
1287                 int o = (int) vh.getAndBitwiseXorAcquire(array, ci, 0x01234567);
1288             });
1289 
1290             checkIOOBE(() -> {
1291                 int o = (int) vh.getAndBitwiseXorRelease(array, ci, 0x01234567);
1292             });
1293         }
1294     }
1295 
1296 }
1297