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