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 #if[Value]
  25 /*
  26  * @test
  27  * @compile -XDenableValueTypes Value.java
  28  * @run testng/othervm -Xverify:none -Diters=10    -Xint                   VarHandleTestAccess$Type$
  29  */
  30 /* Disabled temporarily for lworld
  31  * @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 VarHandleTestAccess$Type$
  32  * @run testng/othervm -Diters=20000                         VarHandleTestAccess$Type$
  33  * @run testng/othervm -Diters=20000 -XX:-TieredCompilation  VarHandleTestAccess$Type$
  34  */
  35 #else[Value]
  36 /*
  37  * @test
  38  * @run testng/othervm -Diters=10    -Xint                   VarHandleTestAccess$Type$
  39  * @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 VarHandleTestAccess$Type$
  40  * @run testng/othervm -Diters=20000                         VarHandleTestAccess$Type$
  41  * @run testng/othervm -Diters=20000 -XX:-TieredCompilation  VarHandleTestAccess$Type$
  42  */
  43 #end[Value]
  44 
  45 import org.testng.annotations.BeforeClass;
  46 import org.testng.annotations.DataProvider;
  47 import org.testng.annotations.Test;
  48 
  49 import java.lang.invoke.MethodHandles;
  50 import java.lang.invoke.VarHandle;
  51 import java.util.ArrayList;
  52 import java.util.Arrays;
  53 import java.util.List;
  54 
  55 import static org.testng.Assert.*;
  56 
  57 public class VarHandleTestAccess$Type$ extends VarHandleBaseTest {
  58     static final $type$ static_final_v = $value1$;
  59 
  60     static $type$ static_v;
  61 
  62     final $type$ final_v = $value1$;
  63 
  64     $type$ v;
  65 
  66     VarHandle vhFinalField;
  67 
  68     VarHandle vhField;
  69 
  70     VarHandle vhStaticField;
  71 
  72     VarHandle vhStaticFinalField;
  73 
  74     VarHandle vhArray;
  75 
  76 #if[Value]
  77     VarHandle vhValueTypeField;
  78 #end[Value]
  79 
  80     @BeforeClass
  81     public void setup() throws Exception {
  82         vhFinalField = MethodHandles.lookup().findVarHandle(
  83                 VarHandleTestAccess$Type$.class, "final_v", $type$.class);
  84 
  85         vhField = MethodHandles.lookup().findVarHandle(
  86                 VarHandleTestAccess$Type$.class, "v", $type$.class);
  87 
  88         vhStaticFinalField = MethodHandles.lookup().findStaticVarHandle(
  89             VarHandleTestAccess$Type$.class, "static_final_v", $type$.class);
  90 
  91         vhStaticField = MethodHandles.lookup().findStaticVarHandle(
  92             VarHandleTestAccess$Type$.class, "static_v", $type$.class);
  93 
  94         vhArray = MethodHandles.arrayElementVarHandle($type$[].class);
  95 
  96 #if[Value]
  97         vhValueTypeField = MethodHandles.lookup().findVarHandle(
  98                     Value.class, "$type$_v", $type$.class);
  99 #end[Value]
 100     }
 101 
 102 
 103     @DataProvider
 104     public Object[][] varHandlesProvider() throws Exception {
 105         List<VarHandle> vhs = new ArrayList<>();
 106         vhs.add(vhField);
 107         vhs.add(vhStaticField);
 108         vhs.add(vhArray);
 109 
 110         return vhs.stream().map(tc -> new Object[]{tc}).toArray(Object[][]::new);
 111     }
 112 
 113     @Test(dataProvider = "varHandlesProvider")
 114     public void testIsAccessModeSupported(VarHandle vh) {
 115         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET));
 116         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET));
 117         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_VOLATILE));
 118         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_VOLATILE));
 119         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_ACQUIRE));
 120         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_RELEASE));
 121         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_OPAQUE));
 122         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_OPAQUE));
 123 
 124 #if[CAS]
 125         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_SET));
 126         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE));
 127         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_ACQUIRE));
 128         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_RELEASE));
 129         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_PLAIN));
 130         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
 131         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
 132         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
 133         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
 134         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_ACQUIRE));
 135         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_RELEASE));
 136 #else[CAS]
 137         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_SET));
 138         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE));
 139         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_ACQUIRE));
 140         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_RELEASE));
 141         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_PLAIN));
 142         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
 143         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
 144         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
 145         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
 146         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_ACQUIRE));
 147         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_RELEASE));
 148 #end[CAS]
 149 
 150 #if[AtomicAdd]
 151         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
 152         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_ACQUIRE));
 153         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_RELEASE));
 154 #else[AtomicAdd]
 155         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
 156         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_ACQUIRE));
 157         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_RELEASE));
 158 #end[AtomicAdd]
 159 
 160 #if[Bitwise]
 161         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR));
 162         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_ACQUIRE));
 163         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_RELEASE));
 164         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND));
 165         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_ACQUIRE));
 166         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_RELEASE));
 167         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR));
 168         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_ACQUIRE));
 169         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE));
 170 #else[Bitwise]
 171         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR));
 172         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_ACQUIRE));
 173         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_RELEASE));
 174         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND));
 175         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_ACQUIRE));
 176         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_RELEASE));
 177         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR));
 178         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_ACQUIRE));
 179         assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE));
 180 #end[Bitwise]
 181     }
 182 
 183 
 184     @DataProvider
 185     public Object[][] typesProvider() throws Exception {
 186         List<Object[]> types = new ArrayList<>();
 187         types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccess$Type$.class)});
 188         types.add(new Object[] {vhStaticField, Arrays.asList()});
 189         types.add(new Object[] {vhArray, Arrays.asList($type$[].class, int.class)});
 190 
 191         return types.stream().toArray(Object[][]::new);
 192     }
 193 
 194     @Test(dataProvider = "typesProvider")
 195     public void testTypes(VarHandle vh, List<Class<?>> pts) {
 196         assertEquals(vh.varType(), $type$.class);
 197 
 198         assertEquals(vh.coordinateTypes(), pts);
 199 
 200         testTypes(vh);
 201     }
 202 
 203 
 204     @Test
 205     public void testLookupInstanceToStatic() {
 206         checkIAE("Lookup of static final field to instance final field", () -> {
 207             MethodHandles.lookup().findStaticVarHandle(
 208                     VarHandleTestAccess$Type$.class, "final_v", $type$.class);
 209         });
 210 
 211         checkIAE("Lookup of static field to instance field", () -> {
 212             MethodHandles.lookup().findStaticVarHandle(
 213                     VarHandleTestAccess$Type$.class, "v", $type$.class);
 214         });
 215     }
 216 
 217     @Test
 218     public void testLookupStaticToInstance() {
 219         checkIAE("Lookup of instance final field to static final field", () -> {
 220             MethodHandles.lookup().findVarHandle(
 221                 VarHandleTestAccess$Type$.class, "static_final_v", $type$.class);
 222         });
 223 
 224         checkIAE("Lookup of instance field to static field", () -> {
 225             vhStaticField = MethodHandles.lookup().findVarHandle(
 226                 VarHandleTestAccess$Type$.class, "static_v", $type$.class);
 227         });
 228     }
 229 
 230 
 231     @DataProvider
 232     public Object[][] accessTestCaseProvider() throws Exception {
 233         List<AccessTestCase<?>> cases = new ArrayList<>();
 234 
 235         cases.add(new VarHandleAccessTestCase("Instance final field",
 236                                               vhFinalField, vh -> testInstanceFinalField(this, vh)));
 237         cases.add(new VarHandleAccessTestCase("Instance final field unsupported",
 238                                               vhFinalField, vh -> testInstanceFinalFieldUnsupported(this, vh),
 239                                               false));
 240 
 241         cases.add(new VarHandleAccessTestCase("Static final field",
 242                                               vhStaticFinalField, VarHandleTestAccess$Type$::testStaticFinalField));
 243         cases.add(new VarHandleAccessTestCase("Static final field unsupported",
 244                                               vhStaticFinalField, VarHandleTestAccess$Type$::testStaticFinalFieldUnsupported,
 245                                               false));
 246 
 247         cases.add(new VarHandleAccessTestCase("Instance field",
 248                                               vhField, vh -> testInstanceField(this, vh)));
 249         cases.add(new VarHandleAccessTestCase("Instance field unsupported",
 250                                               vhField, vh -> testInstanceFieldUnsupported(this, vh),
 251                                               false));
 252 
 253         cases.add(new VarHandleAccessTestCase("Static field",
 254                                               vhStaticField, VarHandleTestAccess$Type$::testStaticField));
 255         cases.add(new VarHandleAccessTestCase("Static field unsupported",
 256                                               vhStaticField, VarHandleTestAccess$Type$::testStaticFieldUnsupported,
 257                                               false));
 258 
 259         cases.add(new VarHandleAccessTestCase("Array",
 260                                               vhArray, VarHandleTestAccess$Type$::testArray));
 261         cases.add(new VarHandleAccessTestCase("Array unsupported",
 262                                               vhArray, VarHandleTestAccess$Type$::testArrayUnsupported,
 263                                               false));
 264         cases.add(new VarHandleAccessTestCase("Array index out of bounds",
 265                                               vhArray, VarHandleTestAccess$Type$::testArrayIndexOutOfBounds,
 266                                               false));
 267 #if[Value]
 268         cases.add(new VarHandleAccessTestCase("Value type field",
 269                                               vhValueTypeField, vh -> testValueTypeField(Value.VT, vh)));
 270         cases.add(new VarHandleAccessTestCase("Value type field unsupported",
 271                                               vhValueTypeField, vh -> testValueTypeFieldUnsupported(Value.VT, vh),
 272                                               false));
 273 #end[Value]
 274 
 275         // Work around issue with jtreg summary reporting which truncates
 276         // the String result of Object.toString to 30 characters, hence
 277         // the first dummy argument
 278         return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new);
 279     }
 280 
 281     @Test(dataProvider = "accessTestCaseProvider")
 282     public <T> void testAccess(String desc, AccessTestCase<T> atc) throws Throwable {
 283         T t = atc.get();
 284         int iters = atc.requiresLoop() ? ITERS : 1;
 285         for (int c = 0; c < iters; c++) {
 286             atc.testAccess(t);
 287         }
 288     }
 289 
 290 
 291 
 292 
 293     static void testInstanceFinalField(VarHandleTestAccess$Type$ recv, VarHandle vh) {
 294         // Plain
 295         {
 296             $type$ x = ($type$) vh.get(recv);
 297             assertEquals(x, $value1$, "get $type$ value");
 298         }
 299 
 300 
 301         // Volatile
 302         {
 303             $type$ x = ($type$) vh.getVolatile(recv);
 304             assertEquals(x, $value1$, "getVolatile $type$ value");
 305         }
 306 
 307         // Lazy
 308         {
 309             $type$ x = ($type$) vh.getAcquire(recv);
 310             assertEquals(x, $value1$, "getRelease $type$ value");
 311         }
 312 
 313         // Opaque
 314         {
 315             $type$ x = ($type$) vh.getOpaque(recv);
 316             assertEquals(x, $value1$, "getOpaque $type$ value");
 317         }
 318     }
 319 
 320     static void testInstanceFinalFieldUnsupported(VarHandleTestAccess$Type$ recv, VarHandle vh) {
 321         checkUOE(() -> {
 322             vh.set(recv, $value2$);
 323         });
 324 
 325         checkUOE(() -> {
 326             vh.setVolatile(recv, $value2$);
 327         });
 328 
 329         checkUOE(() -> {
 330             vh.setRelease(recv, $value2$);
 331         });
 332 
 333         checkUOE(() -> {
 334             vh.setOpaque(recv, $value2$);
 335         });
 336 
 337 #if[!CAS]
 338         checkUOE(() -> {
 339             boolean r = vh.compareAndSet(recv, $value1$, $value2$);
 340         });
 341 
 342         checkUOE(() -> {
 343             $type$ r = ($type$) vh.compareAndExchange(recv, $value1$, $value2$);
 344         });
 345 
 346         checkUOE(() -> {
 347             $type$ r = ($type$) vh.compareAndExchangeAcquire(recv, $value1$, $value2$);
 348         });
 349 
 350         checkUOE(() -> {
 351             $type$ r = ($type$) vh.compareAndExchangeRelease(recv, $value1$, $value2$);
 352         });
 353 
 354         checkUOE(() -> {
 355             boolean r = vh.weakCompareAndSetPlain(recv, $value1$, $value2$);
 356         });
 357 
 358         checkUOE(() -> {
 359             boolean r = vh.weakCompareAndSet(recv, $value1$, $value2$);
 360         });
 361 
 362         checkUOE(() -> {
 363             boolean r = vh.weakCompareAndSetAcquire(recv, $value1$, $value2$);
 364         });
 365 
 366         checkUOE(() -> {
 367             boolean r = vh.weakCompareAndSetRelease(recv, $value1$, $value2$);
 368         });
 369 
 370         checkUOE(() -> {
 371             $type$ r = ($type$) vh.getAndSet(recv, $value1$);
 372         });
 373 
 374         checkUOE(() -> {
 375             $type$ r = ($type$) vh.getAndSetAcquire(recv, $value1$);
 376         });
 377 
 378         checkUOE(() -> {
 379             $type$ r = ($type$) vh.getAndSetRelease(recv, $value1$);
 380         });
 381 #end[CAS]
 382 
 383 #if[!AtomicAdd]
 384         checkUOE(() -> {
 385             $type$ o = ($type$) vh.getAndAdd(recv, $value1$);
 386         });
 387 
 388         checkUOE(() -> {
 389             $type$ o = ($type$) vh.getAndAddAcquire(recv, $value1$);
 390         });
 391 
 392         checkUOE(() -> {
 393             $type$ o = ($type$) vh.getAndAddRelease(recv, $value1$);
 394         });
 395 #end[AtomicAdd]
 396 
 397 #if[!Bitwise]
 398         checkUOE(() -> {
 399             $type$ o = ($type$) vh.getAndBitwiseOr(recv, $value1$);
 400         });
 401 
 402         checkUOE(() -> {
 403             $type$ o = ($type$) vh.getAndBitwiseOrAcquire(recv, $value1$);
 404         });
 405 
 406         checkUOE(() -> {
 407             $type$ o = ($type$) vh.getAndBitwiseOrRelease(recv, $value1$);
 408         });
 409 
 410         checkUOE(() -> {
 411             $type$ o = ($type$) vh.getAndBitwiseAnd(recv, $value1$);
 412         });
 413 
 414         checkUOE(() -> {
 415             $type$ o = ($type$) vh.getAndBitwiseAndAcquire(recv, $value1$);
 416         });
 417 
 418         checkUOE(() -> {
 419             $type$ o = ($type$) vh.getAndBitwiseAndRelease(recv, $value1$);
 420         });
 421 
 422         checkUOE(() -> {
 423             $type$ o = ($type$) vh.getAndBitwiseXor(recv, $value1$);
 424         });
 425 
 426         checkUOE(() -> {
 427             $type$ o = ($type$) vh.getAndBitwiseXorAcquire(recv, $value1$);
 428         });
 429 
 430         checkUOE(() -> {
 431             $type$ o = ($type$) vh.getAndBitwiseXorRelease(recv, $value1$);
 432         });
 433 #end[Bitwise]
 434     }
 435 
 436 #if[Value]
 437     static void testValueTypeField(Value recv, VarHandle vh) {
 438         // Plain
 439         {
 440             $type$ x = ($type$) vh.get(recv);
 441             assertEquals(x, $value1$, "get $type$ value");
 442         }
 443     }
 444 
 445     static void testValueTypeFieldUnsupported(Value recv, VarHandle vh) {
 446         checkUOE(() -> {
 447             vh.set(recv, $value2$);
 448         });
 449     }
 450 #end[Value]
 451 
 452     static void testStaticFinalField(VarHandle vh) {
 453         // Plain
 454         {
 455             $type$ x = ($type$) vh.get();
 456             assertEquals(x, $value1$, "get $type$ value");
 457         }
 458 
 459 
 460         // Volatile
 461         {
 462             $type$ x = ($type$) vh.getVolatile();
 463             assertEquals(x, $value1$, "getVolatile $type$ value");
 464         }
 465 
 466         // Lazy
 467         {
 468             $type$ x = ($type$) vh.getAcquire();
 469             assertEquals(x, $value1$, "getRelease $type$ value");
 470         }
 471 
 472         // Opaque
 473         {
 474             $type$ x = ($type$) vh.getOpaque();
 475             assertEquals(x, $value1$, "getOpaque $type$ value");
 476         }
 477     }
 478 
 479     static void testStaticFinalFieldUnsupported(VarHandle vh) {
 480         checkUOE(() -> {
 481             vh.set($value2$);
 482         });
 483 
 484         checkUOE(() -> {
 485             vh.setVolatile($value2$);
 486         });
 487 
 488         checkUOE(() -> {
 489             vh.setRelease($value2$);
 490         });
 491 
 492         checkUOE(() -> {
 493             vh.setOpaque($value2$);
 494         });
 495 
 496 #if[!CAS]
 497         checkUOE(() -> {
 498             boolean r = vh.compareAndSet($value1$, $value2$);
 499         });
 500 
 501         checkUOE(() -> {
 502             $type$ r = ($type$) vh.compareAndExchange($value1$, $value2$);
 503         });
 504 
 505         checkUOE(() -> {
 506             $type$ r = ($type$) vh.compareAndExchangeAcquire($value1$, $value2$);
 507         });
 508 
 509         checkUOE(() -> {
 510             $type$ r = ($type$) vh.compareAndExchangeRelease($value1$, $value2$);
 511         });
 512 
 513         checkUOE(() -> {
 514             boolean r = vh.weakCompareAndSetPlain($value1$, $value2$);
 515         });
 516 
 517         checkUOE(() -> {
 518             boolean r = vh.weakCompareAndSet($value1$, $value2$);
 519         });
 520 
 521         checkUOE(() -> {
 522             boolean r = vh.weakCompareAndSetAcquire($value1$, $value2$);
 523         });
 524 
 525         checkUOE(() -> {
 526             boolean r = vh.weakCompareAndSetRelease($value1$, $value2$);
 527         });
 528 
 529         checkUOE(() -> {
 530             $type$ r = ($type$) vh.getAndSet($value1$);
 531         });
 532 
 533         checkUOE(() -> {
 534             $type$ r = ($type$) vh.getAndSetAcquire($value1$);
 535         });
 536 
 537         checkUOE(() -> {
 538             $type$ r = ($type$) vh.getAndSetRelease($value1$);
 539         });
 540 #end[CAS]
 541 
 542 #if[!AtomicAdd]
 543         checkUOE(() -> {
 544             $type$ o = ($type$) vh.getAndAdd($value1$);
 545         });
 546 
 547         checkUOE(() -> {
 548             $type$ o = ($type$) vh.getAndAddAcquire($value1$);
 549         });
 550 
 551         checkUOE(() -> {
 552             $type$ o = ($type$) vh.getAndAddRelease($value1$);
 553         });
 554 #end[AtomicAdd]
 555 
 556 #if[!Bitwise]
 557         checkUOE(() -> {
 558             $type$ o = ($type$) vh.getAndBitwiseOr($value1$);
 559         });
 560 
 561         checkUOE(() -> {
 562             $type$ o = ($type$) vh.getAndBitwiseOrAcquire($value1$);
 563         });
 564 
 565         checkUOE(() -> {
 566             $type$ o = ($type$) vh.getAndBitwiseOrRelease($value1$);
 567         });
 568 
 569         checkUOE(() -> {
 570             $type$ o = ($type$) vh.getAndBitwiseAnd($value1$);
 571         });
 572 
 573         checkUOE(() -> {
 574             $type$ o = ($type$) vh.getAndBitwiseAndAcquire($value1$);
 575         });
 576 
 577         checkUOE(() -> {
 578             $type$ o = ($type$) vh.getAndBitwiseAndRelease($value1$);
 579         });
 580 
 581         checkUOE(() -> {
 582             $type$ o = ($type$) vh.getAndBitwiseXor($value1$);
 583         });
 584 
 585         checkUOE(() -> {
 586             $type$ o = ($type$) vh.getAndBitwiseXorAcquire($value1$);
 587         });
 588 
 589         checkUOE(() -> {
 590             $type$ o = ($type$) vh.getAndBitwiseXorRelease($value1$);
 591         });
 592 #end[Bitwise]
 593     }
 594 
 595 
 596     static void testInstanceField(VarHandleTestAccess$Type$ recv, VarHandle vh) {
 597         // Plain
 598         {
 599             vh.set(recv, $value1$);
 600             $type$ x = ($type$) vh.get(recv);
 601             assertEquals(x, $value1$, "set $type$ value");
 602         }
 603 
 604 
 605         // Volatile
 606         {
 607             vh.setVolatile(recv, $value2$);
 608             $type$ x = ($type$) vh.getVolatile(recv);
 609             assertEquals(x, $value2$, "setVolatile $type$ value");
 610         }
 611 
 612         // Lazy
 613         {
 614             vh.setRelease(recv, $value1$);
 615             $type$ x = ($type$) vh.getAcquire(recv);
 616             assertEquals(x, $value1$, "setRelease $type$ value");
 617         }
 618 
 619         // Opaque
 620         {
 621             vh.setOpaque(recv, $value2$);
 622             $type$ x = ($type$) vh.getOpaque(recv);
 623             assertEquals(x, $value2$, "setOpaque $type$ value");
 624         }
 625 
 626 #if[CAS]
 627         vh.set(recv, $value1$);
 628 
 629         // Compare
 630         {
 631             boolean r = vh.compareAndSet(recv, $value1$, $value2$);
 632             assertEquals(r, true, "success compareAndSet $type$");
 633             $type$ x = ($type$) vh.get(recv);
 634             assertEquals(x, $value2$, "success compareAndSet $type$ value");
 635         }
 636 
 637         {
 638             boolean r = vh.compareAndSet(recv, $value1$, $value3$);
 639             assertEquals(r, false, "failing compareAndSet $type$");
 640             $type$ x = ($type$) vh.get(recv);
 641             assertEquals(x, $value2$, "failing compareAndSet $type$ value");
 642         }
 643 
 644         {
 645             $type$ r = ($type$) vh.compareAndExchange(recv, $value2$, $value1$);
 646             assertEquals(r, $value2$, "success compareAndExchange $type$");
 647             $type$ x = ($type$) vh.get(recv);
 648             assertEquals(x, $value1$, "success compareAndExchange $type$ value");
 649         }
 650 
 651         {
 652             $type$ r = ($type$) vh.compareAndExchange(recv, $value2$, $value3$);
 653             assertEquals(r, $value1$, "failing compareAndExchange $type$");
 654             $type$ x = ($type$) vh.get(recv);
 655             assertEquals(x, $value1$, "failing compareAndExchange $type$ value");
 656         }
 657 
 658         {
 659             $type$ r = ($type$) vh.compareAndExchangeAcquire(recv, $value1$, $value2$);
 660             assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$");
 661             $type$ x = ($type$) vh.get(recv);
 662             assertEquals(x, $value2$, "success compareAndExchangeAcquire $type$ value");
 663         }
 664 
 665         {
 666             $type$ r = ($type$) vh.compareAndExchangeAcquire(recv, $value1$, $value3$);
 667             assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$");
 668             $type$ x = ($type$) vh.get(recv);
 669             assertEquals(x, $value2$, "failing compareAndExchangeAcquire $type$ value");
 670         }
 671 
 672         {
 673             $type$ r = ($type$) vh.compareAndExchangeRelease(recv, $value2$, $value1$);
 674             assertEquals(r, $value2$, "success compareAndExchangeRelease $type$");
 675             $type$ x = ($type$) vh.get(recv);
 676             assertEquals(x, $value1$, "success compareAndExchangeRelease $type$ value");
 677         }
 678 
 679         {
 680             $type$ r = ($type$) vh.compareAndExchangeRelease(recv, $value2$, $value3$);
 681             assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$");
 682             $type$ x = ($type$) vh.get(recv);
 683             assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value");
 684         }
 685 
 686         {
 687             boolean success = false;
 688             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 689                 success = vh.weakCompareAndSetPlain(recv, $value1$, $value2$);
 690             }
 691             assertEquals(success, true, "weakCompareAndSetPlain $type$");
 692             $type$ x = ($type$) vh.get(recv);
 693             assertEquals(x, $value2$, "weakCompareAndSetPlain $type$ value");
 694         }
 695 
 696         {
 697             boolean success = false;
 698             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 699                 success = vh.weakCompareAndSetAcquire(recv, $value2$, $value1$);
 700             }
 701             assertEquals(success, true, "weakCompareAndSetAcquire $type$");
 702             $type$ x = ($type$) vh.get(recv);
 703             assertEquals(x, $value1$, "weakCompareAndSetAcquire $type$");
 704         }
 705 
 706         {
 707             boolean success = false;
 708             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 709                 success = vh.weakCompareAndSetRelease(recv, $value1$, $value2$);
 710             }
 711             assertEquals(success, true, "weakCompareAndSetRelease $type$");
 712             $type$ x = ($type$) vh.get(recv);
 713             assertEquals(x, $value2$, "weakCompareAndSetRelease $type$");
 714         }
 715 
 716         {
 717             boolean success = false;
 718             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 719                 success = vh.weakCompareAndSet(recv, $value2$, $value1$);
 720             }
 721             assertEquals(success, true, "weakCompareAndSet $type$");
 722             $type$ x = ($type$) vh.get(recv);
 723             assertEquals(x, $value1$, "weakCompareAndSet $type$ value");
 724         }
 725 
 726         // Compare set and get
 727         {
 728             vh.set(recv, $value1$);
 729 
 730             $type$ o = ($type$) vh.getAndSet(recv, $value2$);
 731             assertEquals(o, $value1$, "getAndSet $type$");
 732             $type$ x = ($type$) vh.get(recv);
 733             assertEquals(x, $value2$, "getAndSet $type$ value");
 734         }
 735 
 736         {
 737             vh.set(recv, $value1$);
 738 
 739             $type$ o = ($type$) vh.getAndSetAcquire(recv, $value2$);
 740             assertEquals(o, $value1$, "getAndSetAcquire $type$");
 741             $type$ x = ($type$) vh.get(recv);
 742             assertEquals(x, $value2$, "getAndSetAcquire $type$ value");
 743         }
 744 
 745         {
 746             vh.set(recv, $value1$);
 747 
 748             $type$ o = ($type$) vh.getAndSetRelease(recv, $value2$);
 749             assertEquals(o, $value1$, "getAndSetRelease $type$");
 750             $type$ x = ($type$) vh.get(recv);
 751             assertEquals(x, $value2$, "getAndSetRelease $type$ value");
 752         }
 753 #end[CAS]
 754 
 755 #if[AtomicAdd]
 756         // get and add, add and get
 757         {
 758             vh.set(recv, $value1$);
 759 
 760             $type$ o = ($type$) vh.getAndAdd(recv, $value2$);
 761             assertEquals(o, $value1$, "getAndAdd $type$");
 762             $type$ x = ($type$) vh.get(recv);
 763             assertEquals(x, ($type$)($value1$ + $value2$), "getAndAdd $type$ value");
 764         }
 765 
 766         {
 767             vh.set(recv, $value1$);
 768 
 769             $type$ o = ($type$) vh.getAndAddAcquire(recv, $value2$);
 770             assertEquals(o, $value1$, "getAndAddAcquire $type$");
 771             $type$ x = ($type$) vh.get(recv);
 772             assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddAcquire $type$ value");
 773         }
 774 
 775         {
 776             vh.set(recv, $value1$);
 777 
 778             $type$ o = ($type$) vh.getAndAddRelease(recv, $value2$);
 779             assertEquals(o, $value1$, "getAndAddRelease$type$");
 780             $type$ x = ($type$) vh.get(recv);
 781             assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddRelease $type$ value");
 782         }
 783 #end[AtomicAdd]
 784 
 785 #if[Bitwise]
 786         // get and bitwise or
 787         {
 788             vh.set(recv, $value1$);
 789 
 790             $type$ o = ($type$) vh.getAndBitwiseOr(recv, $value2$);
 791             assertEquals(o, $value1$, "getAndBitwiseOr $type$");
 792             $type$ x = ($type$) vh.get(recv);
 793             assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOr $type$ value");
 794         }
 795 
 796         {
 797             vh.set(recv, $value1$);
 798 
 799             $type$ o = ($type$) vh.getAndBitwiseOrAcquire(recv, $value2$);
 800             assertEquals(o, $value1$, "getAndBitwiseOrAcquire $type$");
 801             $type$ x = ($type$) vh.get(recv);
 802             assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrAcquire $type$ value");
 803         }
 804 
 805         {
 806             vh.set(recv, $value1$);
 807 
 808             $type$ o = ($type$) vh.getAndBitwiseOrRelease(recv, $value2$);
 809             assertEquals(o, $value1$, "getAndBitwiseOrRelease $type$");
 810             $type$ x = ($type$) vh.get(recv);
 811             assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrRelease $type$ value");
 812         }
 813 
 814         // get and bitwise and
 815         {
 816             vh.set(recv, $value1$);
 817 
 818             $type$ o = ($type$) vh.getAndBitwiseAnd(recv, $value2$);
 819             assertEquals(o, $value1$, "getAndBitwiseAnd $type$");
 820             $type$ x = ($type$) vh.get(recv);
 821             assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAnd $type$ value");
 822         }
 823 
 824         {
 825             vh.set(recv, $value1$);
 826 
 827             $type$ o = ($type$) vh.getAndBitwiseAndAcquire(recv, $value2$);
 828             assertEquals(o, $value1$, "getAndBitwiseAndAcquire $type$");
 829             $type$ x = ($type$) vh.get(recv);
 830             assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndAcquire $type$ value");
 831         }
 832 
 833         {
 834             vh.set(recv, $value1$);
 835 
 836             $type$ o = ($type$) vh.getAndBitwiseAndRelease(recv, $value2$);
 837             assertEquals(o, $value1$, "getAndBitwiseAndRelease $type$");
 838             $type$ x = ($type$) vh.get(recv);
 839             assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndRelease $type$ value");
 840         }
 841 
 842         // get and bitwise xor
 843         {
 844             vh.set(recv, $value1$);
 845 
 846             $type$ o = ($type$) vh.getAndBitwiseXor(recv, $value2$);
 847             assertEquals(o, $value1$, "getAndBitwiseXor $type$");
 848             $type$ x = ($type$) vh.get(recv);
 849             assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXor $type$ value");
 850         }
 851 
 852         {
 853             vh.set(recv, $value1$);
 854 
 855             $type$ o = ($type$) vh.getAndBitwiseXorAcquire(recv, $value2$);
 856             assertEquals(o, $value1$, "getAndBitwiseXorAcquire $type$");
 857             $type$ x = ($type$) vh.get(recv);
 858             assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorAcquire $type$ value");
 859         }
 860 
 861         {
 862             vh.set(recv, $value1$);
 863 
 864             $type$ o = ($type$) vh.getAndBitwiseXorRelease(recv, $value2$);
 865             assertEquals(o, $value1$, "getAndBitwiseXorRelease $type$");
 866             $type$ x = ($type$) vh.get(recv);
 867             assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorRelease $type$ value");
 868         }
 869 #end[Bitwise]
 870     }
 871 
 872     static void testInstanceFieldUnsupported(VarHandleTestAccess$Type$ recv, VarHandle vh) {
 873 #if[!CAS]
 874         checkUOE(() -> {
 875             boolean r = vh.compareAndSet(recv, $value1$, $value2$);
 876         });
 877 
 878         checkUOE(() -> {
 879             $type$ r = ($type$) vh.compareAndExchange(recv, $value1$, $value2$);
 880         });
 881 
 882         checkUOE(() -> {
 883             $type$ r = ($type$) vh.compareAndExchangeAcquire(recv, $value1$, $value2$);
 884         });
 885 
 886         checkUOE(() -> {
 887             $type$ r = ($type$) vh.compareAndExchangeRelease(recv, $value1$, $value2$);
 888         });
 889 
 890         checkUOE(() -> {
 891             boolean r = vh.weakCompareAndSetPlain(recv, $value1$, $value2$);
 892         });
 893 
 894         checkUOE(() -> {
 895             boolean r = vh.weakCompareAndSet(recv, $value1$, $value2$);
 896         });
 897 
 898         checkUOE(() -> {
 899             boolean r = vh.weakCompareAndSetAcquire(recv, $value1$, $value2$);
 900         });
 901 
 902         checkUOE(() -> {
 903             boolean r = vh.weakCompareAndSetRelease(recv, $value1$, $value2$);
 904         });
 905 
 906         checkUOE(() -> {
 907             $type$ r = ($type$) vh.getAndSet(recv, $value1$);
 908         });
 909 
 910         checkUOE(() -> {
 911             $type$ r = ($type$) vh.getAndSetAcquire(recv, $value1$);
 912         });
 913 
 914         checkUOE(() -> {
 915             $type$ r = ($type$) vh.getAndSetRelease(recv, $value1$);
 916         });
 917 #end[CAS]
 918 
 919 #if[!AtomicAdd]
 920         checkUOE(() -> {
 921             $type$ o = ($type$) vh.getAndAdd(recv, $value1$);
 922         });
 923 
 924         checkUOE(() -> {
 925             $type$ o = ($type$) vh.getAndAddAcquire(recv, $value1$);
 926         });
 927 
 928         checkUOE(() -> {
 929             $type$ o = ($type$) vh.getAndAddRelease(recv, $value1$);
 930         });
 931 #end[AtomicAdd]
 932 
 933 #if[!Bitwise]
 934         checkUOE(() -> {
 935             $type$ o = ($type$) vh.getAndBitwiseOr(recv, $value1$);
 936         });
 937 
 938         checkUOE(() -> {
 939             $type$ o = ($type$) vh.getAndBitwiseOrAcquire(recv, $value1$);
 940         });
 941 
 942         checkUOE(() -> {
 943             $type$ o = ($type$) vh.getAndBitwiseOrRelease(recv, $value1$);
 944         });
 945 
 946         checkUOE(() -> {
 947             $type$ o = ($type$) vh.getAndBitwiseAnd(recv, $value1$);
 948         });
 949 
 950         checkUOE(() -> {
 951             $type$ o = ($type$) vh.getAndBitwiseAndAcquire(recv, $value1$);
 952         });
 953 
 954         checkUOE(() -> {
 955             $type$ o = ($type$) vh.getAndBitwiseAndRelease(recv, $value1$);
 956         });
 957 
 958         checkUOE(() -> {
 959             $type$ o = ($type$) vh.getAndBitwiseXor(recv, $value1$);
 960         });
 961 
 962         checkUOE(() -> {
 963             $type$ o = ($type$) vh.getAndBitwiseXorAcquire(recv, $value1$);
 964         });
 965 
 966         checkUOE(() -> {
 967             $type$ o = ($type$) vh.getAndBitwiseXorRelease(recv, $value1$);
 968         });
 969 #end[Bitwise]
 970     }
 971 
 972 
 973     static void testStaticField(VarHandle vh) {
 974         // Plain
 975         {
 976             vh.set($value1$);
 977             $type$ x = ($type$) vh.get();
 978             assertEquals(x, $value1$, "set $type$ value");
 979         }
 980 
 981 
 982         // Volatile
 983         {
 984             vh.setVolatile($value2$);
 985             $type$ x = ($type$) vh.getVolatile();
 986             assertEquals(x, $value2$, "setVolatile $type$ value");
 987         }
 988 
 989         // Lazy
 990         {
 991             vh.setRelease($value1$);
 992             $type$ x = ($type$) vh.getAcquire();
 993             assertEquals(x, $value1$, "setRelease $type$ value");
 994         }
 995 
 996         // Opaque
 997         {
 998             vh.setOpaque($value2$);
 999             $type$ x = ($type$) vh.getOpaque();
1000             assertEquals(x, $value2$, "setOpaque $type$ value");
1001         }
1002 
1003 #if[CAS]
1004         vh.set($value1$);
1005 
1006         // Compare
1007         {
1008             boolean r = vh.compareAndSet($value1$, $value2$);
1009             assertEquals(r, true, "success compareAndSet $type$");
1010             $type$ x = ($type$) vh.get();
1011             assertEquals(x, $value2$, "success compareAndSet $type$ value");
1012         }
1013 
1014         {
1015             boolean r = vh.compareAndSet($value1$, $value3$);
1016             assertEquals(r, false, "failing compareAndSet $type$");
1017             $type$ x = ($type$) vh.get();
1018             assertEquals(x, $value2$, "failing compareAndSet $type$ value");
1019         }
1020 
1021         {
1022             $type$ r = ($type$) vh.compareAndExchange($value2$, $value1$);
1023             assertEquals(r, $value2$, "success compareAndExchange $type$");
1024             $type$ x = ($type$) vh.get();
1025             assertEquals(x, $value1$, "success compareAndExchange $type$ value");
1026         }
1027 
1028         {
1029             $type$ r = ($type$) vh.compareAndExchange($value2$, $value3$);
1030             assertEquals(r, $value1$, "failing compareAndExchange $type$");
1031             $type$ x = ($type$) vh.get();
1032             assertEquals(x, $value1$, "failing compareAndExchange $type$ value");
1033         }
1034 
1035         {
1036             $type$ r = ($type$) vh.compareAndExchangeAcquire($value1$, $value2$);
1037             assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$");
1038             $type$ x = ($type$) vh.get();
1039             assertEquals(x, $value2$, "success compareAndExchangeAcquire $type$ value");
1040         }
1041 
1042         {
1043             $type$ r = ($type$) vh.compareAndExchangeAcquire($value1$, $value3$);
1044             assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$");
1045             $type$ x = ($type$) vh.get();
1046             assertEquals(x, $value2$, "failing compareAndExchangeAcquire $type$ value");
1047         }
1048 
1049         {
1050             $type$ r = ($type$) vh.compareAndExchangeRelease($value2$, $value1$);
1051             assertEquals(r, $value2$, "success compareAndExchangeRelease $type$");
1052             $type$ x = ($type$) vh.get();
1053             assertEquals(x, $value1$, "success compareAndExchangeRelease $type$ value");
1054         }
1055 
1056         {
1057             $type$ r = ($type$) vh.compareAndExchangeRelease($value2$, $value3$);
1058             assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$");
1059             $type$ x = ($type$) vh.get();
1060             assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value");
1061         }
1062 
1063         {
1064             boolean success = false;
1065             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1066                 success = vh.weakCompareAndSetPlain($value1$, $value2$);
1067             }
1068             assertEquals(success, true, "weakCompareAndSetPlain $type$");
1069             $type$ x = ($type$) vh.get();
1070             assertEquals(x, $value2$, "weakCompareAndSetPlain $type$ value");
1071         }
1072 
1073         {
1074             boolean success = false;
1075             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1076                 success = vh.weakCompareAndSetAcquire($value2$, $value1$);
1077             }
1078             assertEquals(success, true, "weakCompareAndSetAcquire $type$");
1079             $type$ x = ($type$) vh.get();
1080             assertEquals(x, $value1$, "weakCompareAndSetAcquire $type$");
1081         }
1082 
1083         {
1084             boolean success = false;
1085             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1086                 success = vh.weakCompareAndSetRelease($value1$, $value2$);
1087             }
1088             assertEquals(success, true, "weakCompareAndSetRelease $type$");
1089             $type$ x = ($type$) vh.get();
1090             assertEquals(x, $value2$, "weakCompareAndSetRelease $type$");
1091         }
1092 
1093         {
1094             boolean success = false;
1095             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1096                 success = vh.weakCompareAndSet($value2$, $value1$);
1097             }
1098             assertEquals(success, true, "weakCompareAndSet $type$");
1099             $type$ x = ($type$) vh.get();
1100             assertEquals(x, $value1$, "weakCompareAndSet $type$");
1101         }
1102 
1103         // Compare set and get
1104         {
1105             vh.set($value1$);
1106 
1107             $type$ o = ($type$) vh.getAndSet($value2$);
1108             assertEquals(o, $value1$, "getAndSet $type$");
1109             $type$ x = ($type$) vh.get();
1110             assertEquals(x, $value2$, "getAndSet $type$ value");
1111         }
1112 
1113         {
1114             vh.set($value1$);
1115 
1116             $type$ o = ($type$) vh.getAndSetAcquire($value2$);
1117             assertEquals(o, $value1$, "getAndSetAcquire $type$");
1118             $type$ x = ($type$) vh.get();
1119             assertEquals(x, $value2$, "getAndSetAcquire $type$ value");
1120         }
1121 
1122         {
1123             vh.set($value1$);
1124 
1125             $type$ o = ($type$) vh.getAndSetRelease($value2$);
1126             assertEquals(o, $value1$, "getAndSetRelease $type$");
1127             $type$ x = ($type$) vh.get();
1128             assertEquals(x, $value2$, "getAndSetRelease $type$ value");
1129         }
1130 #end[CAS]
1131 
1132 #if[AtomicAdd]
1133         // get and add, add and get
1134         {
1135             vh.set($value1$);
1136 
1137             $type$ o = ($type$) vh.getAndAdd($value2$);
1138             assertEquals(o, $value1$, "getAndAdd $type$");
1139             $type$ x = ($type$) vh.get();
1140             assertEquals(x, ($type$)($value1$ + $value2$), "getAndAdd $type$ value");
1141         }
1142 
1143         {
1144             vh.set($value1$);
1145 
1146             $type$ o = ($type$) vh.getAndAddAcquire($value2$);
1147             assertEquals(o, $value1$, "getAndAddAcquire $type$");
1148             $type$ x = ($type$) vh.get();
1149             assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddAcquire $type$ value");
1150         }
1151 
1152         {
1153             vh.set($value1$);
1154 
1155             $type$ o = ($type$) vh.getAndAddRelease($value2$);
1156             assertEquals(o, $value1$, "getAndAddRelease$type$");
1157             $type$ x = ($type$) vh.get();
1158             assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddRelease $type$ value");
1159         }
1160 #end[AtomicAdd]
1161 
1162 #if[Bitwise]
1163         // get and bitwise or
1164         {
1165             vh.set($value1$);
1166 
1167             $type$ o = ($type$) vh.getAndBitwiseOr($value2$);
1168             assertEquals(o, $value1$, "getAndBitwiseOr $type$");
1169             $type$ x = ($type$) vh.get();
1170             assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOr $type$ value");
1171         }
1172 
1173         {
1174             vh.set($value1$);
1175 
1176             $type$ o = ($type$) vh.getAndBitwiseOrAcquire($value2$);
1177             assertEquals(o, $value1$, "getAndBitwiseOrAcquire $type$");
1178             $type$ x = ($type$) vh.get();
1179             assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrAcquire $type$ value");
1180         }
1181 
1182         {
1183             vh.set($value1$);
1184 
1185             $type$ o = ($type$) vh.getAndBitwiseOrRelease($value2$);
1186             assertEquals(o, $value1$, "getAndBitwiseOrRelease $type$");
1187             $type$ x = ($type$) vh.get();
1188             assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrRelease $type$ value");
1189         }
1190 
1191         // get and bitwise and
1192         {
1193             vh.set($value1$);
1194 
1195             $type$ o = ($type$) vh.getAndBitwiseAnd($value2$);
1196             assertEquals(o, $value1$, "getAndBitwiseAnd $type$");
1197             $type$ x = ($type$) vh.get();
1198             assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAnd $type$ value");
1199         }
1200 
1201         {
1202             vh.set($value1$);
1203 
1204             $type$ o = ($type$) vh.getAndBitwiseAndAcquire($value2$);
1205             assertEquals(o, $value1$, "getAndBitwiseAndAcquire $type$");
1206             $type$ x = ($type$) vh.get();
1207             assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndAcquire $type$ value");
1208         }
1209 
1210         {
1211             vh.set($value1$);
1212 
1213             $type$ o = ($type$) vh.getAndBitwiseAndRelease($value2$);
1214             assertEquals(o, $value1$, "getAndBitwiseAndRelease $type$");
1215             $type$ x = ($type$) vh.get();
1216             assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndRelease $type$ value");
1217         }
1218 
1219         // get and bitwise xor
1220         {
1221             vh.set($value1$);
1222 
1223             $type$ o = ($type$) vh.getAndBitwiseXor($value2$);
1224             assertEquals(o, $value1$, "getAndBitwiseXor $type$");
1225             $type$ x = ($type$) vh.get();
1226             assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXor $type$ value");
1227         }
1228 
1229         {
1230             vh.set($value1$);
1231 
1232             $type$ o = ($type$) vh.getAndBitwiseXorAcquire($value2$);
1233             assertEquals(o, $value1$, "getAndBitwiseXorAcquire $type$");
1234             $type$ x = ($type$) vh.get();
1235             assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorAcquire $type$ value");
1236         }
1237 
1238         {
1239             vh.set($value1$);
1240 
1241             $type$ o = ($type$) vh.getAndBitwiseXorRelease($value2$);
1242             assertEquals(o, $value1$, "getAndBitwiseXorRelease $type$");
1243             $type$ x = ($type$) vh.get();
1244             assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorRelease $type$ value");
1245         }
1246 #end[Bitwise]
1247     }
1248 
1249     static void testStaticFieldUnsupported(VarHandle vh) {
1250 #if[!CAS]
1251         checkUOE(() -> {
1252             boolean r = vh.compareAndSet($value1$, $value2$);
1253         });
1254 
1255         checkUOE(() -> {
1256             $type$ r = ($type$) vh.compareAndExchange($value1$, $value2$);
1257         });
1258 
1259         checkUOE(() -> {
1260             $type$ r = ($type$) vh.compareAndExchangeAcquire($value1$, $value2$);
1261         });
1262 
1263         checkUOE(() -> {
1264             $type$ r = ($type$) vh.compareAndExchangeRelease($value1$, $value2$);
1265         });
1266 
1267         checkUOE(() -> {
1268             boolean r = vh.weakCompareAndSetPlain($value1$, $value2$);
1269         });
1270 
1271         checkUOE(() -> {
1272             boolean r = vh.weakCompareAndSet($value1$, $value2$);
1273         });
1274 
1275         checkUOE(() -> {
1276             boolean r = vh.weakCompareAndSetAcquire($value1$, $value2$);
1277         });
1278 
1279         checkUOE(() -> {
1280             boolean r = vh.weakCompareAndSetRelease($value1$, $value2$);
1281         });
1282 
1283         checkUOE(() -> {
1284             $type$ r = ($type$) vh.getAndSet($value1$);
1285         });
1286 
1287         checkUOE(() -> {
1288             $type$ r = ($type$) vh.getAndSetAcquire($value1$);
1289         });
1290 
1291         checkUOE(() -> {
1292             $type$ r = ($type$) vh.getAndSetRelease($value1$);
1293         });
1294 #end[CAS]
1295 
1296 #if[!AtomicAdd]
1297         checkUOE(() -> {
1298             $type$ o = ($type$) vh.getAndAdd($value1$);
1299         });
1300 
1301         checkUOE(() -> {
1302             $type$ o = ($type$) vh.getAndAddAcquire($value1$);
1303         });
1304 
1305         checkUOE(() -> {
1306             $type$ o = ($type$) vh.getAndAddRelease($value1$);
1307         });
1308 #end[AtomicAdd]
1309 
1310 #if[!Bitwise]
1311         checkUOE(() -> {
1312             $type$ o = ($type$) vh.getAndBitwiseOr($value1$);
1313         });
1314 
1315         checkUOE(() -> {
1316             $type$ o = ($type$) vh.getAndBitwiseOrAcquire($value1$);
1317         });
1318 
1319         checkUOE(() -> {
1320             $type$ o = ($type$) vh.getAndBitwiseOrRelease($value1$);
1321         });
1322 
1323         checkUOE(() -> {
1324             $type$ o = ($type$) vh.getAndBitwiseAnd($value1$);
1325         });
1326 
1327         checkUOE(() -> {
1328             $type$ o = ($type$) vh.getAndBitwiseAndAcquire($value1$);
1329         });
1330 
1331         checkUOE(() -> {
1332             $type$ o = ($type$) vh.getAndBitwiseAndRelease($value1$);
1333         });
1334 
1335         checkUOE(() -> {
1336             $type$ o = ($type$) vh.getAndBitwiseXor($value1$);
1337         });
1338 
1339         checkUOE(() -> {
1340             $type$ o = ($type$) vh.getAndBitwiseXorAcquire($value1$);
1341         });
1342 
1343         checkUOE(() -> {
1344             $type$ o = ($type$) vh.getAndBitwiseXorRelease($value1$);
1345         });
1346 #end[Bitwise]
1347     }
1348 
1349 
1350     static void testArray(VarHandle vh) {
1351         $type$[] array = new $type$[10];
1352 
1353         for (int i = 0; i < array.length; i++) {
1354             // Plain
1355             {
1356                 vh.set(array, i, $value1$);
1357                 $type$ x = ($type$) vh.get(array, i);
1358                 assertEquals(x, $value1$, "get $type$ value");
1359             }
1360 
1361 
1362             // Volatile
1363             {
1364                 vh.setVolatile(array, i, $value2$);
1365                 $type$ x = ($type$) vh.getVolatile(array, i);
1366                 assertEquals(x, $value2$, "setVolatile $type$ value");
1367             }
1368 
1369             // Lazy
1370             {
1371                 vh.setRelease(array, i, $value1$);
1372                 $type$ x = ($type$) vh.getAcquire(array, i);
1373                 assertEquals(x, $value1$, "setRelease $type$ value");
1374             }
1375 
1376             // Opaque
1377             {
1378                 vh.setOpaque(array, i, $value2$);
1379                 $type$ x = ($type$) vh.getOpaque(array, i);
1380                 assertEquals(x, $value2$, "setOpaque $type$ value");
1381             }
1382 
1383 #if[CAS]
1384             vh.set(array, i, $value1$);
1385 
1386             // Compare
1387             {
1388                 boolean r = vh.compareAndSet(array, i, $value1$, $value2$);
1389                 assertEquals(r, true, "success compareAndSet $type$");
1390                 $type$ x = ($type$) vh.get(array, i);
1391                 assertEquals(x, $value2$, "success compareAndSet $type$ value");
1392             }
1393 
1394             {
1395                 boolean r = vh.compareAndSet(array, i, $value1$, $value3$);
1396                 assertEquals(r, false, "failing compareAndSet $type$");
1397                 $type$ x = ($type$) vh.get(array, i);
1398                 assertEquals(x, $value2$, "failing compareAndSet $type$ value");
1399             }
1400 
1401             {
1402                 $type$ r = ($type$) vh.compareAndExchange(array, i, $value2$, $value1$);
1403                 assertEquals(r, $value2$, "success compareAndExchange $type$");
1404                 $type$ x = ($type$) vh.get(array, i);
1405                 assertEquals(x, $value1$, "success compareAndExchange $type$ value");
1406             }
1407 
1408             {
1409                 $type$ r = ($type$) vh.compareAndExchange(array, i, $value2$, $value3$);
1410                 assertEquals(r, $value1$, "failing compareAndExchange $type$");
1411                 $type$ x = ($type$) vh.get(array, i);
1412                 assertEquals(x, $value1$, "failing compareAndExchange $type$ value");
1413             }
1414 
1415             {
1416                 $type$ r = ($type$) vh.compareAndExchangeAcquire(array, i, $value1$, $value2$);
1417                 assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$");
1418                 $type$ x = ($type$) vh.get(array, i);
1419                 assertEquals(x, $value2$, "success compareAndExchangeAcquire $type$ value");
1420             }
1421 
1422             {
1423                 $type$ r = ($type$) vh.compareAndExchangeAcquire(array, i, $value1$, $value3$);
1424                 assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$");
1425                 $type$ x = ($type$) vh.get(array, i);
1426                 assertEquals(x, $value2$, "failing compareAndExchangeAcquire $type$ value");
1427             }
1428 
1429             {
1430                 $type$ r = ($type$) vh.compareAndExchangeRelease(array, i, $value2$, $value1$);
1431                 assertEquals(r, $value2$, "success compareAndExchangeRelease $type$");
1432                 $type$ x = ($type$) vh.get(array, i);
1433                 assertEquals(x, $value1$, "success compareAndExchangeRelease $type$ value");
1434             }
1435 
1436             {
1437                 $type$ r = ($type$) vh.compareAndExchangeRelease(array, i, $value2$, $value3$);
1438                 assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$");
1439                 $type$ x = ($type$) vh.get(array, i);
1440                 assertEquals(x, $value1$, "failing compareAndExchangeRelease $type$ value");
1441             }
1442 
1443             {
1444                 boolean success = false;
1445                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1446                     success = vh.weakCompareAndSetPlain(array, i, $value1$, $value2$);
1447                 }
1448                 assertEquals(success, true, "weakCompareAndSetPlain $type$");
1449                 $type$ x = ($type$) vh.get(array, i);
1450                 assertEquals(x, $value2$, "weakCompareAndSetPlain $type$ value");
1451             }
1452 
1453             {
1454                 boolean success = false;
1455                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1456                     success = vh.weakCompareAndSetAcquire(array, i, $value2$, $value1$);
1457                 }
1458                 assertEquals(success, true, "weakCompareAndSetAcquire $type$");
1459                 $type$ x = ($type$) vh.get(array, i);
1460                 assertEquals(x, $value1$, "weakCompareAndSetAcquire $type$");
1461             }
1462 
1463             {
1464                 boolean success = false;
1465                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1466                     success = vh.weakCompareAndSetRelease(array, i, $value1$, $value2$);
1467                 }
1468                 assertEquals(success, true, "weakCompareAndSetRelease $type$");
1469                 $type$ x = ($type$) vh.get(array, i);
1470                 assertEquals(x, $value2$, "weakCompareAndSetRelease $type$");
1471             }
1472 
1473             {
1474                 boolean success = false;
1475                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1476                     success = vh.weakCompareAndSet(array, i, $value2$, $value1$);
1477                 }
1478                 assertEquals(success, true, "weakCompareAndSet $type$");
1479                 $type$ x = ($type$) vh.get(array, i);
1480                 assertEquals(x, $value1$, "weakCompareAndSet $type$");
1481             }
1482 
1483             // Compare set and get
1484             {
1485                 vh.set(array, i, $value1$);
1486 
1487                 $type$ o = ($type$) vh.getAndSet(array, i, $value2$);
1488                 assertEquals(o, $value1$, "getAndSet $type$");
1489                 $type$ x = ($type$) vh.get(array, i);
1490                 assertEquals(x, $value2$, "getAndSet $type$ value");
1491             }
1492 
1493             {
1494                 vh.set(array, i, $value1$);
1495 
1496                 $type$ o = ($type$) vh.getAndSetAcquire(array, i, $value2$);
1497                 assertEquals(o, $value1$, "getAndSetAcquire $type$");
1498                 $type$ x = ($type$) vh.get(array, i);
1499                 assertEquals(x, $value2$, "getAndSetAcquire $type$ value");
1500             }
1501 
1502             {
1503                 vh.set(array, i, $value1$);
1504 
1505                 $type$ o = ($type$) vh.getAndSetRelease(array, i, $value2$);
1506                 assertEquals(o, $value1$, "getAndSetRelease $type$");
1507                 $type$ x = ($type$) vh.get(array, i);
1508                 assertEquals(x, $value2$, "getAndSetRelease $type$ value");
1509             }
1510 #end[CAS]
1511 
1512 #if[AtomicAdd]
1513             // get and add, add and get
1514             {
1515                 vh.set(array, i, $value1$);
1516 
1517                 $type$ o = ($type$) vh.getAndAdd(array, i, $value2$);
1518                 assertEquals(o, $value1$, "getAndAdd $type$");
1519                 $type$ x = ($type$) vh.get(array, i);
1520                 assertEquals(x, ($type$)($value1$ + $value2$), "getAndAdd $type$ value");
1521             }
1522 
1523             {
1524                 vh.set(array, i, $value1$);
1525 
1526                 $type$ o = ($type$) vh.getAndAddAcquire(array, i, $value2$);
1527                 assertEquals(o, $value1$, "getAndAddAcquire $type$");
1528                 $type$ x = ($type$) vh.get(array, i);
1529                 assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddAcquire $type$ value");
1530             }
1531 
1532             {
1533                 vh.set(array, i, $value1$);
1534 
1535                 $type$ o = ($type$) vh.getAndAddRelease(array, i, $value2$);
1536                 assertEquals(o, $value1$, "getAndAddRelease$type$");
1537                 $type$ x = ($type$) vh.get(array, i);
1538                 assertEquals(x, ($type$)($value1$ + $value2$), "getAndAddRelease $type$ value");
1539             }
1540 #end[AtomicAdd]
1541 
1542 #if[Bitwise]
1543             // get and bitwise or
1544             {
1545                 vh.set(array, i, $value1$);
1546 
1547                 $type$ o = ($type$) vh.getAndBitwiseOr(array, i, $value2$);
1548                 assertEquals(o, $value1$, "getAndBitwiseOr $type$");
1549                 $type$ x = ($type$) vh.get(array, i);
1550                 assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOr $type$ value");
1551             }
1552 
1553             {
1554                 vh.set(array, i, $value1$);
1555 
1556                 $type$ o = ($type$) vh.getAndBitwiseOrAcquire(array, i, $value2$);
1557                 assertEquals(o, $value1$, "getAndBitwiseOrAcquire $type$");
1558                 $type$ x = ($type$) vh.get(array, i);
1559                 assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrAcquire $type$ value");
1560             }
1561 
1562             {
1563                 vh.set(array, i, $value1$);
1564 
1565                 $type$ o = ($type$) vh.getAndBitwiseOrRelease(array, i, $value2$);
1566                 assertEquals(o, $value1$, "getAndBitwiseOrRelease $type$");
1567                 $type$ x = ($type$) vh.get(array, i);
1568                 assertEquals(x, ($type$)($value1$ | $value2$), "getAndBitwiseOrRelease $type$ value");
1569             }
1570 
1571             // get and bitwise and
1572             {
1573                 vh.set(array, i, $value1$);
1574 
1575                 $type$ o = ($type$) vh.getAndBitwiseAnd(array, i, $value2$);
1576                 assertEquals(o, $value1$, "getAndBitwiseAnd $type$");
1577                 $type$ x = ($type$) vh.get(array, i);
1578                 assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAnd $type$ value");
1579             }
1580 
1581             {
1582                 vh.set(array, i, $value1$);
1583 
1584                 $type$ o = ($type$) vh.getAndBitwiseAndAcquire(array, i, $value2$);
1585                 assertEquals(o, $value1$, "getAndBitwiseAndAcquire $type$");
1586                 $type$ x = ($type$) vh.get(array, i);
1587                 assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndAcquire $type$ value");
1588             }
1589 
1590             {
1591                 vh.set(array, i, $value1$);
1592 
1593                 $type$ o = ($type$) vh.getAndBitwiseAndRelease(array, i, $value2$);
1594                 assertEquals(o, $value1$, "getAndBitwiseAndRelease $type$");
1595                 $type$ x = ($type$) vh.get(array, i);
1596                 assertEquals(x, ($type$)($value1$ & $value2$), "getAndBitwiseAndRelease $type$ value");
1597             }
1598 
1599             // get and bitwise xor
1600             {
1601                 vh.set(array, i, $value1$);
1602 
1603                 $type$ o = ($type$) vh.getAndBitwiseXor(array, i, $value2$);
1604                 assertEquals(o, $value1$, "getAndBitwiseXor $type$");
1605                 $type$ x = ($type$) vh.get(array, i);
1606                 assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXor $type$ value");
1607             }
1608 
1609             {
1610                 vh.set(array, i, $value1$);
1611 
1612                 $type$ o = ($type$) vh.getAndBitwiseXorAcquire(array, i, $value2$);
1613                 assertEquals(o, $value1$, "getAndBitwiseXorAcquire $type$");
1614                 $type$ x = ($type$) vh.get(array, i);
1615                 assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorAcquire $type$ value");
1616             }
1617 
1618             {
1619                 vh.set(array, i, $value1$);
1620 
1621                 $type$ o = ($type$) vh.getAndBitwiseXorRelease(array, i, $value2$);
1622                 assertEquals(o, $value1$, "getAndBitwiseXorRelease $type$");
1623                 $type$ x = ($type$) vh.get(array, i);
1624                 assertEquals(x, ($type$)($value1$ ^ $value2$), "getAndBitwiseXorRelease $type$ value");
1625             }
1626 #end[Bitwise]
1627         }
1628     }
1629 
1630     static void testArrayUnsupported(VarHandle vh) {
1631         $type$[] array = new $type$[10];
1632 
1633         int i = 0;
1634 #if[!CAS]
1635         checkUOE(() -> {
1636             boolean r = vh.compareAndSet(array, i, $value1$, $value2$);
1637         });
1638 
1639         checkUOE(() -> {
1640             $type$ r = ($type$) vh.compareAndExchange(array, i, $value1$, $value2$);
1641         });
1642 
1643         checkUOE(() -> {
1644             $type$ r = ($type$) vh.compareAndExchangeAcquire(array, i, $value1$, $value2$);
1645         });
1646 
1647         checkUOE(() -> {
1648             $type$ r = ($type$) vh.compareAndExchangeRelease(array, i, $value1$, $value2$);
1649         });
1650 
1651         checkUOE(() -> {
1652             boolean r = vh.weakCompareAndSetPlain(array, i, $value1$, $value2$);
1653         });
1654 
1655         checkUOE(() -> {
1656             boolean r = vh.weakCompareAndSet(array, i, $value1$, $value2$);
1657         });
1658 
1659         checkUOE(() -> {
1660             boolean r = vh.weakCompareAndSetAcquire(array, i, $value1$, $value2$);
1661         });
1662 
1663         checkUOE(() -> {
1664             boolean r = vh.weakCompareAndSetRelease(array, i, $value1$, $value2$);
1665         });
1666 
1667         checkUOE(() -> {
1668             $type$ r = ($type$) vh.getAndSet(array, i, $value1$);
1669         });
1670 
1671         checkUOE(() -> {
1672             $type$ r = ($type$) vh.getAndSetAcquire(array, i, $value1$);
1673         });
1674 
1675         checkUOE(() -> {
1676             $type$ r = ($type$) vh.getAndSetRelease(array, i, $value1$);
1677         });
1678 #end[CAS]
1679 
1680 #if[!AtomicAdd]
1681         checkUOE(() -> {
1682             $type$ o = ($type$) vh.getAndAdd(array, i, $value1$);
1683         });
1684 
1685         checkUOE(() -> {
1686             $type$ o = ($type$) vh.getAndAddAcquire(array, i, $value1$);
1687         });
1688 
1689         checkUOE(() -> {
1690             $type$ o = ($type$) vh.getAndAddRelease(array, i, $value1$);
1691         });
1692 #end[AtomicAdd]
1693 
1694 #if[!Bitwise]
1695         checkUOE(() -> {
1696             $type$ o = ($type$) vh.getAndBitwiseOr(array, i, $value1$);
1697         });
1698 
1699         checkUOE(() -> {
1700             $type$ o = ($type$) vh.getAndBitwiseOrAcquire(array, i, $value1$);
1701         });
1702 
1703         checkUOE(() -> {
1704             $type$ o = ($type$) vh.getAndBitwiseOrRelease(array, i, $value1$);
1705         });
1706 
1707         checkUOE(() -> {
1708             $type$ o = ($type$) vh.getAndBitwiseAnd(array, i, $value1$);
1709         });
1710 
1711         checkUOE(() -> {
1712             $type$ o = ($type$) vh.getAndBitwiseAndAcquire(array, i, $value1$);
1713         });
1714 
1715         checkUOE(() -> {
1716             $type$ o = ($type$) vh.getAndBitwiseAndRelease(array, i, $value1$);
1717         });
1718 
1719         checkUOE(() -> {
1720             $type$ o = ($type$) vh.getAndBitwiseXor(array, i, $value1$);
1721         });
1722 
1723         checkUOE(() -> {
1724             $type$ o = ($type$) vh.getAndBitwiseXorAcquire(array, i, $value1$);
1725         });
1726 
1727         checkUOE(() -> {
1728             $type$ o = ($type$) vh.getAndBitwiseXorRelease(array, i, $value1$);
1729         });
1730 #end[Bitwise]
1731     }
1732 
1733     static void testArrayIndexOutOfBounds(VarHandle vh) throws Throwable {
1734         $type$[] array = new $type$[10];
1735 
1736         for (int i : new int[]{-1, Integer.MIN_VALUE, 10, 11, Integer.MAX_VALUE}) {
1737             final int ci = i;
1738 
1739             checkIOOBE(() -> {
1740                 $type$ x = ($type$) vh.get(array, ci);
1741             });
1742 
1743             checkIOOBE(() -> {
1744                 vh.set(array, ci, $value1$);
1745             });
1746 
1747             checkIOOBE(() -> {
1748                 $type$ x = ($type$) vh.getVolatile(array, ci);
1749             });
1750 
1751             checkIOOBE(() -> {
1752                 vh.setVolatile(array, ci, $value1$);
1753             });
1754 
1755             checkIOOBE(() -> {
1756                 $type$ x = ($type$) vh.getAcquire(array, ci);
1757             });
1758 
1759             checkIOOBE(() -> {
1760                 vh.setRelease(array, ci, $value1$);
1761             });
1762 
1763             checkIOOBE(() -> {
1764                 $type$ x = ($type$) vh.getOpaque(array, ci);
1765             });
1766 
1767             checkIOOBE(() -> {
1768                 vh.setOpaque(array, ci, $value1$);
1769             });
1770 
1771 #if[CAS]
1772             checkIOOBE(() -> {
1773                 boolean r = vh.compareAndSet(array, ci, $value1$, $value2$);
1774             });
1775 
1776             checkIOOBE(() -> {
1777                 $type$ r = ($type$) vh.compareAndExchange(array, ci, $value2$, $value1$);
1778             });
1779 
1780             checkIOOBE(() -> {
1781                 $type$ r = ($type$) vh.compareAndExchangeAcquire(array, ci, $value2$, $value1$);
1782             });
1783 
1784             checkIOOBE(() -> {
1785                 $type$ r = ($type$) vh.compareAndExchangeRelease(array, ci, $value2$, $value1$);
1786             });
1787 
1788             checkIOOBE(() -> {
1789                 boolean r = vh.weakCompareAndSetPlain(array, ci, $value1$, $value2$);
1790             });
1791 
1792             checkIOOBE(() -> {
1793                 boolean r = vh.weakCompareAndSet(array, ci, $value1$, $value2$);
1794             });
1795 
1796             checkIOOBE(() -> {
1797                 boolean r = vh.weakCompareAndSetAcquire(array, ci, $value1$, $value2$);
1798             });
1799 
1800             checkIOOBE(() -> {
1801                 boolean r = vh.weakCompareAndSetRelease(array, ci, $value1$, $value2$);
1802             });
1803 
1804             checkIOOBE(() -> {
1805                 $type$ o = ($type$) vh.getAndSet(array, ci, $value1$);
1806             });
1807 
1808             checkIOOBE(() -> {
1809                 $type$ o = ($type$) vh.getAndSetAcquire(array, ci, $value1$);
1810             });
1811 
1812             checkIOOBE(() -> {
1813                 $type$ o = ($type$) vh.getAndSetRelease(array, ci, $value1$);
1814             });
1815 #end[CAS]
1816 
1817 #if[AtomicAdd]
1818             checkIOOBE(() -> {
1819                 $type$ o = ($type$) vh.getAndAdd(array, ci, $value1$);
1820             });
1821 
1822             checkIOOBE(() -> {
1823                 $type$ o = ($type$) vh.getAndAddAcquire(array, ci, $value1$);
1824             });
1825 
1826             checkIOOBE(() -> {
1827                 $type$ o = ($type$) vh.getAndAddRelease(array, ci, $value1$);
1828             });
1829 #end[AtomicAdd]
1830 
1831 #if[Bitwise]
1832             checkIOOBE(() -> {
1833                 $type$ o = ($type$) vh.getAndBitwiseOr(array, ci, $value1$);
1834             });
1835 
1836             checkIOOBE(() -> {
1837                 $type$ o = ($type$) vh.getAndBitwiseOrAcquire(array, ci, $value1$);
1838             });
1839 
1840             checkIOOBE(() -> {
1841                 $type$ o = ($type$) vh.getAndBitwiseOrRelease(array, ci, $value1$);
1842             });
1843 
1844             checkIOOBE(() -> {
1845                 $type$ o = ($type$) vh.getAndBitwiseAnd(array, ci, $value1$);
1846             });
1847 
1848             checkIOOBE(() -> {
1849                 $type$ o = ($type$) vh.getAndBitwiseAndAcquire(array, ci, $value1$);
1850             });
1851 
1852             checkIOOBE(() -> {
1853                 $type$ o = ($type$) vh.getAndBitwiseAndRelease(array, ci, $value1$);
1854             });
1855 
1856             checkIOOBE(() -> {
1857                 $type$ o = ($type$) vh.getAndBitwiseXor(array, ci, $value1$);
1858             });
1859 
1860             checkIOOBE(() -> {
1861                 $type$ o = ($type$) vh.getAndBitwiseXorAcquire(array, ci, $value1$);
1862             });
1863 
1864             checkIOOBE(() -> {
1865                 $type$ o = ($type$) vh.getAndBitwiseXorRelease(array, ci, $value1$);
1866             });
1867 #end[Bitwise]
1868         }
1869     }
1870 }
1871 
--- EOF ---