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