1 /*
   2  * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /*
  25  * @test
  26  * @run testng/othervm -Diters=10   -Xint                                                   VarHandleTestAccessLong
  27  *
  28  * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations
  29  *          to hit compilation thresholds
  30  *
  31  * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:TieredStopAtLevel=1 VarHandleTestAccessLong
  32  * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1                         VarHandleTestAccessLong
  33  * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation  VarHandleTestAccessLong
  34  */
  35 
  36 import org.testng.annotations.BeforeClass;
  37 import org.testng.annotations.DataProvider;
  38 import org.testng.annotations.Test;
  39 
  40 import java.lang.invoke.MethodHandles;
  41 import java.lang.invoke.VarHandle;
  42 import java.util.ArrayList;
  43 import java.util.Arrays;
  44 import java.util.List;
  45 
  46 import static org.testng.Assert.*;
  47 
  48 public class VarHandleTestAccessLong extends VarHandleBaseTest {
  49     static final long static_final_v = 0x0123456789ABCDEFL;
  50 
  51     static long static_v;
  52 
  53     final long final_v = 0x0123456789ABCDEFL;
  54 
  55     long v;
  56 
  57     static final long static_final_v2 = 0x0123456789ABCDEFL;
  58 
  59     static long static_v2;
  60 
  61     final long final_v2 = 0x0123456789ABCDEFL;
  62 
  63     long v2;
  64 
  65     VarHandle vhFinalField;
  66 
  67     VarHandle vhField;
  68 
  69     VarHandle vhStaticField;
  70 
  71     VarHandle vhStaticFinalField;
  72 
  73     VarHandle vhArray;
  74 
  75 
  76     VarHandle[] allocate(boolean same) {
  77         List<VarHandle> vhs = new ArrayList<>();
  78 
  79         String postfix = same ? "" : "2";
  80         VarHandle vh;
  81         try {
  82             vh = MethodHandles.lookup().findVarHandle(
  83                     VarHandleTestAccessLong.class, "final_v" + postfix, long.class);
  84             vhs.add(vh);
  85 
  86             vh = MethodHandles.lookup().findVarHandle(
  87                     VarHandleTestAccessLong.class, "v" + postfix, long.class);
  88             vhs.add(vh);
  89 
  90             vh = MethodHandles.lookup().findStaticVarHandle(
  91                 VarHandleTestAccessLong.class, "static_final_v" + postfix, long.class);
  92             vhs.add(vh);
  93 
  94             vh = MethodHandles.lookup().findStaticVarHandle(
  95                 VarHandleTestAccessLong.class, "static_v" + postfix, long.class);
  96             vhs.add(vh);
  97 
  98             if (same) {
  99                 vh = MethodHandles.arrayElementVarHandle(long[].class);
 100             }
 101             else {
 102                 vh = MethodHandles.arrayElementVarHandle(String[].class);
 103             }
 104             vhs.add(vh);
 105         } catch (Exception e) {
 106             throw new InternalError(e);
 107         }
 108         return vhs.toArray(new VarHandle[0]);
 109     }
 110 
 111     @BeforeClass
 112     public void setup() throws Exception {
 113         vhFinalField = MethodHandles.lookup().findVarHandle(
 114                 VarHandleTestAccessLong.class, "final_v", long.class);
 115 
 116         vhField = MethodHandles.lookup().findVarHandle(
 117                 VarHandleTestAccessLong.class, "v", long.class);
 118 
 119         vhStaticFinalField = MethodHandles.lookup().findStaticVarHandle(
 120             VarHandleTestAccessLong.class, "static_final_v", long.class);
 121 
 122         vhStaticField = MethodHandles.lookup().findStaticVarHandle(
 123             VarHandleTestAccessLong.class, "static_v", long.class);
 124 
 125         vhArray = MethodHandles.arrayElementVarHandle(long[].class);
 126     }
 127 
 128 
 129     @DataProvider
 130     public Object[][] varHandlesProvider() throws Exception {
 131         List<VarHandle> vhs = new ArrayList<>();
 132         vhs.add(vhField);
 133         vhs.add(vhStaticField);
 134         vhs.add(vhArray);
 135 
 136         return vhs.stream().map(tc -> new Object[]{tc}).toArray(Object[][]::new);
 137     }
 138 
 139     @Test
 140     public void testEquals() {
 141         VarHandle[] vhs1 = allocate(true);
 142         VarHandle[] vhs2 = allocate(true);
 143 
 144         for (int i = 0; i < vhs1.length; i++) {
 145             for (int j = 0; j < vhs1.length; j++) {
 146                 if (i != j) {
 147                     assertNotEquals(vhs1[i], vhs1[j]);
 148                     assertNotEquals(vhs1[i], vhs2[j]);
 149                 }
 150             }
 151         }
 152 
 153         VarHandle[] vhs3 = allocate(false);
 154         for (int i = 0; i < vhs1.length; i++) {
 155             assertNotEquals(vhs1[i], vhs3[i]);
 156         }
 157     }
 158 
 159     @Test(dataProvider = "varHandlesProvider")
 160     public void testIsAccessModeSupported(VarHandle vh) {
 161         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET));
 162         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET));
 163         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_VOLATILE));
 164         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_VOLATILE));
 165         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_ACQUIRE));
 166         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_RELEASE));
 167         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_OPAQUE));
 168         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_OPAQUE));
 169 
 170         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_SET));
 171         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE));
 172         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_ACQUIRE));
 173         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_RELEASE));
 174         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_PLAIN));
 175         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
 176         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
 177         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
 178         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
 179         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_ACQUIRE));
 180         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_RELEASE));
 181 
 182         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
 183         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_ACQUIRE));
 184         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_RELEASE));
 185 
 186         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR));
 187         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_ACQUIRE));
 188         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_RELEASE));
 189         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND));
 190         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_ACQUIRE));
 191         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_RELEASE));
 192         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR));
 193         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_ACQUIRE));
 194         assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE));
 195     }
 196 
 197 
 198     @DataProvider
 199     public Object[][] typesProvider() throws Exception {
 200         List<Object[]> types = new ArrayList<>();
 201         types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessLong.class)});
 202         types.add(new Object[] {vhStaticField, Arrays.asList()});
 203         types.add(new Object[] {vhArray, Arrays.asList(long[].class, int.class)});
 204 
 205         return types.stream().toArray(Object[][]::new);
 206     }
 207 
 208     @Test(dataProvider = "typesProvider")
 209     public void testTypes(VarHandle vh, List<Class<?>> pts) {
 210         assertEquals(vh.varType(), long.class);
 211 
 212         assertEquals(vh.coordinateTypes(), pts);
 213 
 214         testTypes(vh);
 215     }
 216 
 217 
 218     @Test
 219     public void testLookupInstanceToStatic() {
 220         checkIAE("Lookup of static final field to instance final field", () -> {
 221             MethodHandles.lookup().findStaticVarHandle(
 222                     VarHandleTestAccessLong.class, "final_v", long.class);
 223         });
 224 
 225         checkIAE("Lookup of static field to instance field", () -> {
 226             MethodHandles.lookup().findStaticVarHandle(
 227                     VarHandleTestAccessLong.class, "v", long.class);
 228         });
 229     }
 230 
 231     @Test
 232     public void testLookupStaticToInstance() {
 233         checkIAE("Lookup of instance final field to static final field", () -> {
 234             MethodHandles.lookup().findVarHandle(
 235                 VarHandleTestAccessLong.class, "static_final_v", long.class);
 236         });
 237 
 238         checkIAE("Lookup of instance field to static field", () -> {
 239             vhStaticField = MethodHandles.lookup().findVarHandle(
 240                 VarHandleTestAccessLong.class, "static_v", long.class);
 241         });
 242     }
 243 
 244 
 245     @DataProvider
 246     public Object[][] accessTestCaseProvider() throws Exception {
 247         List<AccessTestCase<?>> cases = new ArrayList<>();
 248 
 249         cases.add(new VarHandleAccessTestCase("Instance final field",
 250                                               vhFinalField, vh -> testInstanceFinalField(this, vh)));
 251         cases.add(new VarHandleAccessTestCase("Instance final field unsupported",
 252                                               vhFinalField, vh -> testInstanceFinalFieldUnsupported(this, vh),
 253                                               false));
 254 
 255         cases.add(new VarHandleAccessTestCase("Static final field",
 256                                               vhStaticFinalField, VarHandleTestAccessLong::testStaticFinalField));
 257         cases.add(new VarHandleAccessTestCase("Static final field unsupported",
 258                                               vhStaticFinalField, VarHandleTestAccessLong::testStaticFinalFieldUnsupported,
 259                                               false));
 260 
 261         cases.add(new VarHandleAccessTestCase("Instance field",
 262                                               vhField, vh -> testInstanceField(this, vh)));
 263         cases.add(new VarHandleAccessTestCase("Instance field unsupported",
 264                                               vhField, vh -> testInstanceFieldUnsupported(this, vh),
 265                                               false));
 266 
 267         cases.add(new VarHandleAccessTestCase("Static field",
 268                                               vhStaticField, VarHandleTestAccessLong::testStaticField));
 269         cases.add(new VarHandleAccessTestCase("Static field unsupported",
 270                                               vhStaticField, VarHandleTestAccessLong::testStaticFieldUnsupported,
 271                                               false));
 272 
 273         cases.add(new VarHandleAccessTestCase("Array",
 274                                               vhArray, VarHandleTestAccessLong::testArray));
 275         cases.add(new VarHandleAccessTestCase("Array unsupported",
 276                                               vhArray, VarHandleTestAccessLong::testArrayUnsupported,
 277                                               false));
 278         cases.add(new VarHandleAccessTestCase("Array index out of bounds",
 279                                               vhArray, VarHandleTestAccessLong::testArrayIndexOutOfBounds,
 280                                               false));
 281         // Work around issue with jtreg summary reporting which truncates
 282         // the String result of Object.toString to 30 characters, hence
 283         // the first dummy argument
 284         return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new);
 285     }
 286 
 287     @Test(dataProvider = "accessTestCaseProvider")
 288     public <T> void testAccess(String desc, AccessTestCase<T> atc) throws Throwable {
 289         T t = atc.get();
 290         int iters = atc.requiresLoop() ? ITERS : 1;
 291         for (int c = 0; c < iters; c++) {
 292             atc.testAccess(t);
 293         }
 294     }
 295 
 296     static void testInstanceFinalField(VarHandleTestAccessLong recv, VarHandle vh) {
 297         // Plain
 298         {
 299             long x = (long) vh.get(recv);
 300             assertEquals(x, 0x0123456789ABCDEFL, "get long value");
 301         }
 302 
 303 
 304         // Volatile
 305         {
 306             long x = (long) vh.getVolatile(recv);
 307             assertEquals(x, 0x0123456789ABCDEFL, "getVolatile long value");
 308         }
 309 
 310         // Lazy
 311         {
 312             long x = (long) vh.getAcquire(recv);
 313             assertEquals(x, 0x0123456789ABCDEFL, "getRelease long value");
 314         }
 315 
 316         // Opaque
 317         {
 318             long x = (long) vh.getOpaque(recv);
 319             assertEquals(x, 0x0123456789ABCDEFL, "getOpaque long value");
 320         }
 321     }
 322 
 323     static void testInstanceFinalFieldUnsupported(VarHandleTestAccessLong recv, VarHandle vh) {
 324         checkUOE(() -> {
 325             vh.set(recv, 0xCAFEBABECAFEBABEL);
 326         });
 327 
 328         checkUOE(() -> {
 329             vh.setVolatile(recv, 0xCAFEBABECAFEBABEL);
 330         });
 331 
 332         checkUOE(() -> {
 333             vh.setRelease(recv, 0xCAFEBABECAFEBABEL);
 334         });
 335 
 336         checkUOE(() -> {
 337             vh.setOpaque(recv, 0xCAFEBABECAFEBABEL);
 338         });
 339 
 340 
 341 
 342     }
 343 
 344 
 345     static void testStaticFinalField(VarHandle vh) {
 346         // Plain
 347         {
 348             long x = (long) vh.get();
 349             assertEquals(x, 0x0123456789ABCDEFL, "get long value");
 350         }
 351 
 352 
 353         // Volatile
 354         {
 355             long x = (long) vh.getVolatile();
 356             assertEquals(x, 0x0123456789ABCDEFL, "getVolatile long value");
 357         }
 358 
 359         // Lazy
 360         {
 361             long x = (long) vh.getAcquire();
 362             assertEquals(x, 0x0123456789ABCDEFL, "getRelease long value");
 363         }
 364 
 365         // Opaque
 366         {
 367             long x = (long) vh.getOpaque();
 368             assertEquals(x, 0x0123456789ABCDEFL, "getOpaque long value");
 369         }
 370     }
 371 
 372     static void testStaticFinalFieldUnsupported(VarHandle vh) {
 373         checkUOE(() -> {
 374             vh.set(0xCAFEBABECAFEBABEL);
 375         });
 376 
 377         checkUOE(() -> {
 378             vh.setVolatile(0xCAFEBABECAFEBABEL);
 379         });
 380 
 381         checkUOE(() -> {
 382             vh.setRelease(0xCAFEBABECAFEBABEL);
 383         });
 384 
 385         checkUOE(() -> {
 386             vh.setOpaque(0xCAFEBABECAFEBABEL);
 387         });
 388 
 389 
 390 
 391     }
 392 
 393 
 394     static void testInstanceField(VarHandleTestAccessLong recv, VarHandle vh) {
 395         // Plain
 396         {
 397             vh.set(recv, 0x0123456789ABCDEFL);
 398             long x = (long) vh.get(recv);
 399             assertEquals(x, 0x0123456789ABCDEFL, "set long value");
 400         }
 401 
 402 
 403         // Volatile
 404         {
 405             vh.setVolatile(recv, 0xCAFEBABECAFEBABEL);
 406             long x = (long) vh.getVolatile(recv);
 407             assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value");
 408         }
 409 
 410         // Lazy
 411         {
 412             vh.setRelease(recv, 0x0123456789ABCDEFL);
 413             long x = (long) vh.getAcquire(recv);
 414             assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value");
 415         }
 416 
 417         // Opaque
 418         {
 419             vh.setOpaque(recv, 0xCAFEBABECAFEBABEL);
 420             long x = (long) vh.getOpaque(recv);
 421             assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value");
 422         }
 423 
 424         vh.set(recv, 0x0123456789ABCDEFL);
 425 
 426         // Compare
 427         {
 428             boolean r = vh.compareAndSet(recv, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 429             assertEquals(r, true, "success compareAndSet long");
 430             long x = (long) vh.get(recv);
 431             assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value");
 432         }
 433 
 434         {
 435             boolean r = vh.compareAndSet(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
 436             assertEquals(r, false, "failing compareAndSet long");
 437             long x = (long) vh.get(recv);
 438             assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value");
 439         }
 440 
 441         {
 442             long r = (long) vh.compareAndExchange(recv, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 443             assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchange long");
 444             long x = (long) vh.get(recv);
 445             assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchange long value");
 446         }
 447 
 448         {
 449             long r = (long) vh.compareAndExchange(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
 450             assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchange long");
 451             long x = (long) vh.get(recv);
 452             assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchange long value");
 453         }
 454 
 455         {
 456             long r = (long) vh.compareAndExchangeAcquire(recv, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 457             assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long");
 458             long x = (long) vh.get(recv);
 459             assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value");
 460         }
 461 
 462         {
 463             long r = (long) vh.compareAndExchangeAcquire(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
 464             assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long");
 465             long x = (long) vh.get(recv);
 466             assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value");
 467         }
 468 
 469         {
 470             long r = (long) vh.compareAndExchangeRelease(recv, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 471             assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long");
 472             long x = (long) vh.get(recv);
 473             assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value");
 474         }
 475 
 476         {
 477             long r = (long) vh.compareAndExchangeRelease(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
 478             assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long");
 479             long x = (long) vh.get(recv);
 480             assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value");
 481         }
 482 
 483         {
 484             boolean success = false;
 485             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 486                 success = vh.weakCompareAndSetPlain(recv, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 487                 if (!success) weakDelay();
 488             }
 489             assertEquals(success, true, "success weakCompareAndSetPlain long");
 490             long x = (long) vh.get(recv);
 491             assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetPlain long value");
 492         }
 493 
 494         {
 495             boolean success = vh.weakCompareAndSetPlain(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
 496             assertEquals(success, false, "failing weakCompareAndSetPlain long");
 497             long x = (long) vh.get(recv);
 498             assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetPlain long value");
 499         }
 500 
 501         {
 502             boolean success = false;
 503             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 504                 success = vh.weakCompareAndSetAcquire(recv, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 505                 if (!success) weakDelay();
 506             }
 507             assertEquals(success, true, "success weakCompareAndSetAcquire long");
 508             long x = (long) vh.get(recv);
 509             assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSetAcquire long");
 510         }
 511 
 512         {
 513             boolean success = vh.weakCompareAndSetAcquire(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
 514             assertEquals(success, false, "failing weakCompareAndSetAcquire long");
 515             long x = (long) vh.get(recv);
 516             assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSetAcquire long value");
 517         }
 518 
 519         {
 520             boolean success = false;
 521             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 522                 success = vh.weakCompareAndSetRelease(recv, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 523                 if (!success) weakDelay();
 524             }
 525             assertEquals(success, true, "success weakCompareAndSetRelease long");
 526             long x = (long) vh.get(recv);
 527             assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetRelease long");
 528         }
 529 
 530         {
 531             boolean success = vh.weakCompareAndSetRelease(recv, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
 532             assertEquals(success, false, "failing weakCompareAndSetRelease long");
 533             long x = (long) vh.get(recv);
 534             assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetRelease long value");
 535         }
 536 
 537         {
 538             boolean success = false;
 539             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 540                 success = vh.weakCompareAndSet(recv, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 541                 if (!success) weakDelay();
 542             }
 543             assertEquals(success, true, "success weakCompareAndSet long");
 544             long x = (long) vh.get(recv);
 545             assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSet long value");
 546         }
 547 
 548         {
 549             boolean success = vh.weakCompareAndSet(recv, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
 550             assertEquals(success, false, "failing weakCompareAndSet long");
 551             long x = (long) vh.get(recv);
 552             assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSet long value");
 553         }
 554 
 555         // Compare set and get
 556         {
 557             vh.set(recv, 0x0123456789ABCDEFL);
 558 
 559             long o = (long) vh.getAndSet(recv, 0xCAFEBABECAFEBABEL);
 560             assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long");
 561             long x = (long) vh.get(recv);
 562             assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value");
 563         }
 564 
 565         {
 566             vh.set(recv, 0x0123456789ABCDEFL);
 567 
 568             long o = (long) vh.getAndSetAcquire(recv, 0xCAFEBABECAFEBABEL);
 569             assertEquals(o, 0x0123456789ABCDEFL, "getAndSetAcquire long");
 570             long x = (long) vh.get(recv);
 571             assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetAcquire long value");
 572         }
 573 
 574         {
 575             vh.set(recv, 0x0123456789ABCDEFL);
 576 
 577             long o = (long) vh.getAndSetRelease(recv, 0xCAFEBABECAFEBABEL);
 578             assertEquals(o, 0x0123456789ABCDEFL, "getAndSetRelease long");
 579             long x = (long) vh.get(recv);
 580             assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetRelease long value");
 581         }
 582 
 583         // get and add, add and get
 584         {
 585             vh.set(recv, 0x0123456789ABCDEFL);
 586 
 587             long o = (long) vh.getAndAdd(recv, 0xCAFEBABECAFEBABEL);
 588             assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long");
 589             long x = (long) vh.get(recv);
 590             assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAdd long value");
 591         }
 592 
 593         {
 594             vh.set(recv, 0x0123456789ABCDEFL);
 595 
 596             long o = (long) vh.getAndAddAcquire(recv, 0xCAFEBABECAFEBABEL);
 597             assertEquals(o, 0x0123456789ABCDEFL, "getAndAddAcquire long");
 598             long x = (long) vh.get(recv);
 599             assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddAcquire long value");
 600         }
 601 
 602         {
 603             vh.set(recv, 0x0123456789ABCDEFL);
 604 
 605             long o = (long) vh.getAndAddRelease(recv, 0xCAFEBABECAFEBABEL);
 606             assertEquals(o, 0x0123456789ABCDEFL, "getAndAddReleaselong");
 607             long x = (long) vh.get(recv);
 608             assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddRelease long value");
 609         }
 610 
 611         // get and bitwise or
 612         {
 613             vh.set(recv, 0x0123456789ABCDEFL);
 614 
 615             long o = (long) vh.getAndBitwiseOr(recv, 0xCAFEBABECAFEBABEL);
 616             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOr long");
 617             long x = (long) vh.get(recv);
 618             assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOr long value");
 619         }
 620 
 621         {
 622             vh.set(recv, 0x0123456789ABCDEFL);
 623 
 624             long o = (long) vh.getAndBitwiseOrAcquire(recv, 0xCAFEBABECAFEBABEL);
 625             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrAcquire long");
 626             long x = (long) vh.get(recv);
 627             assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrAcquire long value");
 628         }
 629 
 630         {
 631             vh.set(recv, 0x0123456789ABCDEFL);
 632 
 633             long o = (long) vh.getAndBitwiseOrRelease(recv, 0xCAFEBABECAFEBABEL);
 634             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrRelease long");
 635             long x = (long) vh.get(recv);
 636             assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrRelease long value");
 637         }
 638 
 639         // get and bitwise and
 640         {
 641             vh.set(recv, 0x0123456789ABCDEFL);
 642 
 643             long o = (long) vh.getAndBitwiseAnd(recv, 0xCAFEBABECAFEBABEL);
 644             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAnd long");
 645             long x = (long) vh.get(recv);
 646             assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAnd long value");
 647         }
 648 
 649         {
 650             vh.set(recv, 0x0123456789ABCDEFL);
 651 
 652             long o = (long) vh.getAndBitwiseAndAcquire(recv, 0xCAFEBABECAFEBABEL);
 653             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndAcquire long");
 654             long x = (long) vh.get(recv);
 655             assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndAcquire long value");
 656         }
 657 
 658         {
 659             vh.set(recv, 0x0123456789ABCDEFL);
 660 
 661             long o = (long) vh.getAndBitwiseAndRelease(recv, 0xCAFEBABECAFEBABEL);
 662             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndRelease long");
 663             long x = (long) vh.get(recv);
 664             assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndRelease long value");
 665         }
 666 
 667         // get and bitwise xor
 668         {
 669             vh.set(recv, 0x0123456789ABCDEFL);
 670 
 671             long o = (long) vh.getAndBitwiseXor(recv, 0xCAFEBABECAFEBABEL);
 672             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXor long");
 673             long x = (long) vh.get(recv);
 674             assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXor long value");
 675         }
 676 
 677         {
 678             vh.set(recv, 0x0123456789ABCDEFL);
 679 
 680             long o = (long) vh.getAndBitwiseXorAcquire(recv, 0xCAFEBABECAFEBABEL);
 681             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorAcquire long");
 682             long x = (long) vh.get(recv);
 683             assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorAcquire long value");
 684         }
 685 
 686         {
 687             vh.set(recv, 0x0123456789ABCDEFL);
 688 
 689             long o = (long) vh.getAndBitwiseXorRelease(recv, 0xCAFEBABECAFEBABEL);
 690             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorRelease long");
 691             long x = (long) vh.get(recv);
 692             assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorRelease long value");
 693         }
 694     }
 695 
 696     static void testInstanceFieldUnsupported(VarHandleTestAccessLong recv, VarHandle vh) {
 697 
 698 
 699     }
 700 
 701 
 702     static void testStaticField(VarHandle vh) {
 703         // Plain
 704         {
 705             vh.set(0x0123456789ABCDEFL);
 706             long x = (long) vh.get();
 707             assertEquals(x, 0x0123456789ABCDEFL, "set long value");
 708         }
 709 
 710 
 711         // Volatile
 712         {
 713             vh.setVolatile(0xCAFEBABECAFEBABEL);
 714             long x = (long) vh.getVolatile();
 715             assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value");
 716         }
 717 
 718         // Lazy
 719         {
 720             vh.setRelease(0x0123456789ABCDEFL);
 721             long x = (long) vh.getAcquire();
 722             assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value");
 723         }
 724 
 725         // Opaque
 726         {
 727             vh.setOpaque(0xCAFEBABECAFEBABEL);
 728             long x = (long) vh.getOpaque();
 729             assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value");
 730         }
 731 
 732         vh.set(0x0123456789ABCDEFL);
 733 
 734         // Compare
 735         {
 736             boolean r = vh.compareAndSet(0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 737             assertEquals(r, true, "success compareAndSet long");
 738             long x = (long) vh.get();
 739             assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value");
 740         }
 741 
 742         {
 743             boolean r = vh.compareAndSet(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
 744             assertEquals(r, false, "failing compareAndSet long");
 745             long x = (long) vh.get();
 746             assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value");
 747         }
 748 
 749         {
 750             long r = (long) vh.compareAndExchange(0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 751             assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchange long");
 752             long x = (long) vh.get();
 753             assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchange long value");
 754         }
 755 
 756         {
 757             long r = (long) vh.compareAndExchange(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
 758             assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchange long");
 759             long x = (long) vh.get();
 760             assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchange long value");
 761         }
 762 
 763         {
 764             long r = (long) vh.compareAndExchangeAcquire(0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 765             assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long");
 766             long x = (long) vh.get();
 767             assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value");
 768         }
 769 
 770         {
 771             long r = (long) vh.compareAndExchangeAcquire(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
 772             assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long");
 773             long x = (long) vh.get();
 774             assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value");
 775         }
 776 
 777         {
 778             long r = (long) vh.compareAndExchangeRelease(0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 779             assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long");
 780             long x = (long) vh.get();
 781             assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value");
 782         }
 783 
 784         {
 785             long r = (long) vh.compareAndExchangeRelease(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
 786             assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long");
 787             long x = (long) vh.get();
 788             assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value");
 789         }
 790 
 791         {
 792             boolean success = false;
 793             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 794                 success = vh.weakCompareAndSetPlain(0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 795                 if (!success) weakDelay();
 796             }
 797             assertEquals(success, true, "success weakCompareAndSetPlain long");
 798             long x = (long) vh.get();
 799             assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetPlain long value");
 800         }
 801 
 802         {
 803             boolean success = vh.weakCompareAndSetPlain(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
 804             assertEquals(success, false, "failing weakCompareAndSetPlain long");
 805             long x = (long) vh.get();
 806             assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetPlain long value");
 807         }
 808 
 809         {
 810             boolean success = false;
 811             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 812                 success = vh.weakCompareAndSetAcquire(0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 813                 if (!success) weakDelay();
 814             }
 815             assertEquals(success, true, "success weakCompareAndSetAcquire long");
 816             long x = (long) vh.get();
 817             assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSetAcquire long");
 818         }
 819 
 820         {
 821             boolean success = vh.weakCompareAndSetAcquire(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
 822             assertEquals(success, false, "failing weakCompareAndSetAcquire long");
 823             long x = (long) vh.get();
 824             assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSetAcquire long value");
 825         }
 826 
 827         {
 828             boolean success = false;
 829             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 830                 success = vh.weakCompareAndSetRelease(0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
 831                 if (!success) weakDelay();
 832             }
 833             assertEquals(success, true, "success weakCompareAndSetRelease long");
 834             long x = (long) vh.get();
 835             assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetRelease long");
 836         }
 837 
 838         {
 839             boolean success = vh.weakCompareAndSetRelease(0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
 840             assertEquals(success, false, "failing weakCompareAndSetRelease long");
 841             long x = (long) vh.get();
 842             assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetRelease long value");
 843         }
 844 
 845         {
 846             boolean success = false;
 847             for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
 848                 success = vh.weakCompareAndSet(0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
 849                 if (!success) weakDelay();
 850             }
 851             assertEquals(success, true, "success weakCompareAndSet long");
 852             long x = (long) vh.get();
 853             assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSet long");
 854         }
 855 
 856         {
 857             boolean success = vh.weakCompareAndSet(0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
 858             assertEquals(success, false, "failing weakCompareAndSet long");
 859             long x = (long) vh.get();
 860             assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSet long value");
 861         }
 862 
 863         // Compare set and get
 864         {
 865             vh.set(0x0123456789ABCDEFL);
 866 
 867             long o = (long) vh.getAndSet(0xCAFEBABECAFEBABEL);
 868             assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long");
 869             long x = (long) vh.get();
 870             assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value");
 871         }
 872 
 873         {
 874             vh.set(0x0123456789ABCDEFL);
 875 
 876             long o = (long) vh.getAndSetAcquire(0xCAFEBABECAFEBABEL);
 877             assertEquals(o, 0x0123456789ABCDEFL, "getAndSetAcquire long");
 878             long x = (long) vh.get();
 879             assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetAcquire long value");
 880         }
 881 
 882         {
 883             vh.set(0x0123456789ABCDEFL);
 884 
 885             long o = (long) vh.getAndSetRelease(0xCAFEBABECAFEBABEL);
 886             assertEquals(o, 0x0123456789ABCDEFL, "getAndSetRelease long");
 887             long x = (long) vh.get();
 888             assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetRelease long value");
 889         }
 890 
 891         // get and add, add and get
 892         {
 893             vh.set(0x0123456789ABCDEFL);
 894 
 895             long o = (long) vh.getAndAdd(0xCAFEBABECAFEBABEL);
 896             assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long");
 897             long x = (long) vh.get();
 898             assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAdd long value");
 899         }
 900 
 901         {
 902             vh.set(0x0123456789ABCDEFL);
 903 
 904             long o = (long) vh.getAndAddAcquire(0xCAFEBABECAFEBABEL);
 905             assertEquals(o, 0x0123456789ABCDEFL, "getAndAddAcquire long");
 906             long x = (long) vh.get();
 907             assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddAcquire long value");
 908         }
 909 
 910         {
 911             vh.set(0x0123456789ABCDEFL);
 912 
 913             long o = (long) vh.getAndAddRelease(0xCAFEBABECAFEBABEL);
 914             assertEquals(o, 0x0123456789ABCDEFL, "getAndAddReleaselong");
 915             long x = (long) vh.get();
 916             assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddRelease long value");
 917         }
 918 
 919         // get and bitwise or
 920         {
 921             vh.set(0x0123456789ABCDEFL);
 922 
 923             long o = (long) vh.getAndBitwiseOr(0xCAFEBABECAFEBABEL);
 924             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOr long");
 925             long x = (long) vh.get();
 926             assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOr long value");
 927         }
 928 
 929         {
 930             vh.set(0x0123456789ABCDEFL);
 931 
 932             long o = (long) vh.getAndBitwiseOrAcquire(0xCAFEBABECAFEBABEL);
 933             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrAcquire long");
 934             long x = (long) vh.get();
 935             assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrAcquire long value");
 936         }
 937 
 938         {
 939             vh.set(0x0123456789ABCDEFL);
 940 
 941             long o = (long) vh.getAndBitwiseOrRelease(0xCAFEBABECAFEBABEL);
 942             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrRelease long");
 943             long x = (long) vh.get();
 944             assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrRelease long value");
 945         }
 946 
 947         // get and bitwise and
 948         {
 949             vh.set(0x0123456789ABCDEFL);
 950 
 951             long o = (long) vh.getAndBitwiseAnd(0xCAFEBABECAFEBABEL);
 952             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAnd long");
 953             long x = (long) vh.get();
 954             assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAnd long value");
 955         }
 956 
 957         {
 958             vh.set(0x0123456789ABCDEFL);
 959 
 960             long o = (long) vh.getAndBitwiseAndAcquire(0xCAFEBABECAFEBABEL);
 961             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndAcquire long");
 962             long x = (long) vh.get();
 963             assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndAcquire long value");
 964         }
 965 
 966         {
 967             vh.set(0x0123456789ABCDEFL);
 968 
 969             long o = (long) vh.getAndBitwiseAndRelease(0xCAFEBABECAFEBABEL);
 970             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndRelease long");
 971             long x = (long) vh.get();
 972             assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndRelease long value");
 973         }
 974 
 975         // get and bitwise xor
 976         {
 977             vh.set(0x0123456789ABCDEFL);
 978 
 979             long o = (long) vh.getAndBitwiseXor(0xCAFEBABECAFEBABEL);
 980             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXor long");
 981             long x = (long) vh.get();
 982             assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXor long value");
 983         }
 984 
 985         {
 986             vh.set(0x0123456789ABCDEFL);
 987 
 988             long o = (long) vh.getAndBitwiseXorAcquire(0xCAFEBABECAFEBABEL);
 989             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorAcquire long");
 990             long x = (long) vh.get();
 991             assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorAcquire long value");
 992         }
 993 
 994         {
 995             vh.set(0x0123456789ABCDEFL);
 996 
 997             long o = (long) vh.getAndBitwiseXorRelease(0xCAFEBABECAFEBABEL);
 998             assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorRelease long");
 999             long x = (long) vh.get();
1000             assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorRelease long value");
1001         }
1002     }
1003 
1004     static void testStaticFieldUnsupported(VarHandle vh) {
1005 
1006 
1007     }
1008 
1009 
1010     static void testArray(VarHandle vh) {
1011         long[] array = new long[10];
1012 
1013         for (int i = 0; i < array.length; i++) {
1014             // Plain
1015             {
1016                 vh.set(array, i, 0x0123456789ABCDEFL);
1017                 long x = (long) vh.get(array, i);
1018                 assertEquals(x, 0x0123456789ABCDEFL, "get long value");
1019             }
1020 
1021 
1022             // Volatile
1023             {
1024                 vh.setVolatile(array, i, 0xCAFEBABECAFEBABEL);
1025                 long x = (long) vh.getVolatile(array, i);
1026                 assertEquals(x, 0xCAFEBABECAFEBABEL, "setVolatile long value");
1027             }
1028 
1029             // Lazy
1030             {
1031                 vh.setRelease(array, i, 0x0123456789ABCDEFL);
1032                 long x = (long) vh.getAcquire(array, i);
1033                 assertEquals(x, 0x0123456789ABCDEFL, "setRelease long value");
1034             }
1035 
1036             // Opaque
1037             {
1038                 vh.setOpaque(array, i, 0xCAFEBABECAFEBABEL);
1039                 long x = (long) vh.getOpaque(array, i);
1040                 assertEquals(x, 0xCAFEBABECAFEBABEL, "setOpaque long value");
1041             }
1042 
1043             vh.set(array, i, 0x0123456789ABCDEFL);
1044 
1045             // Compare
1046             {
1047                 boolean r = vh.compareAndSet(array, i, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
1048                 assertEquals(r, true, "success compareAndSet long");
1049                 long x = (long) vh.get(array, i);
1050                 assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndSet long value");
1051             }
1052 
1053             {
1054                 boolean r = vh.compareAndSet(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
1055                 assertEquals(r, false, "failing compareAndSet long");
1056                 long x = (long) vh.get(array, i);
1057                 assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndSet long value");
1058             }
1059 
1060             {
1061                 long r = (long) vh.compareAndExchange(array, i, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
1062                 assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchange long");
1063                 long x = (long) vh.get(array, i);
1064                 assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchange long value");
1065             }
1066 
1067             {
1068                 long r = (long) vh.compareAndExchange(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
1069                 assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchange long");
1070                 long x = (long) vh.get(array, i);
1071                 assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchange long value");
1072             }
1073 
1074             {
1075                 long r = (long) vh.compareAndExchangeAcquire(array, i, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
1076                 assertEquals(r, 0x0123456789ABCDEFL, "success compareAndExchangeAcquire long");
1077                 long x = (long) vh.get(array, i);
1078                 assertEquals(x, 0xCAFEBABECAFEBABEL, "success compareAndExchangeAcquire long value");
1079             }
1080 
1081             {
1082                 long r = (long) vh.compareAndExchangeAcquire(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
1083                 assertEquals(r, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long");
1084                 long x = (long) vh.get(array, i);
1085                 assertEquals(x, 0xCAFEBABECAFEBABEL, "failing compareAndExchangeAcquire long value");
1086             }
1087 
1088             {
1089                 long r = (long) vh.compareAndExchangeRelease(array, i, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
1090                 assertEquals(r, 0xCAFEBABECAFEBABEL, "success compareAndExchangeRelease long");
1091                 long x = (long) vh.get(array, i);
1092                 assertEquals(x, 0x0123456789ABCDEFL, "success compareAndExchangeRelease long value");
1093             }
1094 
1095             {
1096                 long r = (long) vh.compareAndExchangeRelease(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
1097                 assertEquals(r, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long");
1098                 long x = (long) vh.get(array, i);
1099                 assertEquals(x, 0x0123456789ABCDEFL, "failing compareAndExchangeRelease long value");
1100             }
1101 
1102             {
1103                 boolean success = false;
1104                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1105                     success = vh.weakCompareAndSetPlain(array, i, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
1106                     if (!success) weakDelay();
1107                 }
1108                 assertEquals(success, true, "success weakCompareAndSetPlain long");
1109                 long x = (long) vh.get(array, i);
1110                 assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetPlain long value");
1111             }
1112 
1113             {
1114                 boolean success = vh.weakCompareAndSetPlain(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
1115                 assertEquals(success, false, "failing weakCompareAndSetPlain long");
1116                 long x = (long) vh.get(array, i);
1117                 assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetPlain long value");
1118             }
1119 
1120             {
1121                 boolean success = false;
1122                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1123                     success = vh.weakCompareAndSetAcquire(array, i, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
1124                     if (!success) weakDelay();
1125                 }
1126                 assertEquals(success, true, "success weakCompareAndSetAcquire long");
1127                 long x = (long) vh.get(array, i);
1128                 assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSetAcquire long");
1129             }
1130 
1131             {
1132                 boolean success = vh.weakCompareAndSetAcquire(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
1133                 assertEquals(success, false, "failing weakCompareAndSetAcquire long");
1134                 long x = (long) vh.get(array, i);
1135                 assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSetAcquire long value");
1136             }
1137 
1138             {
1139                 boolean success = false;
1140                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1141                     success = vh.weakCompareAndSetRelease(array, i, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
1142                     if (!success) weakDelay();
1143                 }
1144                 assertEquals(success, true, "success weakCompareAndSetRelease long");
1145                 long x = (long) vh.get(array, i);
1146                 assertEquals(x, 0xCAFEBABECAFEBABEL, "success weakCompareAndSetRelease long");
1147             }
1148 
1149             {
1150                 boolean success = vh.weakCompareAndSetRelease(array, i, 0x0123456789ABCDEFL, 0xDEADBEEFDEADBEEFL);
1151                 assertEquals(success, false, "failing weakCompareAndSetRelease long");
1152                 long x = (long) vh.get(array, i);
1153                 assertEquals(x, 0xCAFEBABECAFEBABEL, "failing weakCompareAndSetRelease long value");
1154             }
1155 
1156             {
1157                 boolean success = false;
1158                 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1159                     success = vh.weakCompareAndSet(array, i, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
1160                     if (!success) weakDelay();
1161                 }
1162                 assertEquals(success, true, "success weakCompareAndSet long");
1163                 long x = (long) vh.get(array, i);
1164                 assertEquals(x, 0x0123456789ABCDEFL, "success weakCompareAndSet long");
1165             }
1166 
1167             {
1168                 boolean success = vh.weakCompareAndSet(array, i, 0xCAFEBABECAFEBABEL, 0xDEADBEEFDEADBEEFL);
1169                 assertEquals(success, false, "failing weakCompareAndSet long");
1170                 long x = (long) vh.get(array, i);
1171                 assertEquals(x, 0x0123456789ABCDEFL, "failing weakCompareAndSet long value");
1172             }
1173 
1174             // Compare set and get
1175             {
1176                 vh.set(array, i, 0x0123456789ABCDEFL);
1177 
1178                 long o = (long) vh.getAndSet(array, i, 0xCAFEBABECAFEBABEL);
1179                 assertEquals(o, 0x0123456789ABCDEFL, "getAndSet long");
1180                 long x = (long) vh.get(array, i);
1181                 assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSet long value");
1182             }
1183 
1184             {
1185                 vh.set(array, i, 0x0123456789ABCDEFL);
1186 
1187                 long o = (long) vh.getAndSetAcquire(array, i, 0xCAFEBABECAFEBABEL);
1188                 assertEquals(o, 0x0123456789ABCDEFL, "getAndSetAcquire long");
1189                 long x = (long) vh.get(array, i);
1190                 assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetAcquire long value");
1191             }
1192 
1193             {
1194                 vh.set(array, i, 0x0123456789ABCDEFL);
1195 
1196                 long o = (long) vh.getAndSetRelease(array, i, 0xCAFEBABECAFEBABEL);
1197                 assertEquals(o, 0x0123456789ABCDEFL, "getAndSetRelease long");
1198                 long x = (long) vh.get(array, i);
1199                 assertEquals(x, 0xCAFEBABECAFEBABEL, "getAndSetRelease long value");
1200             }
1201 
1202             // get and add, add and get
1203             {
1204                 vh.set(array, i, 0x0123456789ABCDEFL);
1205 
1206                 long o = (long) vh.getAndAdd(array, i, 0xCAFEBABECAFEBABEL);
1207                 assertEquals(o, 0x0123456789ABCDEFL, "getAndAdd long");
1208                 long x = (long) vh.get(array, i);
1209                 assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAdd long value");
1210             }
1211 
1212             {
1213                 vh.set(array, i, 0x0123456789ABCDEFL);
1214 
1215                 long o = (long) vh.getAndAddAcquire(array, i, 0xCAFEBABECAFEBABEL);
1216                 assertEquals(o, 0x0123456789ABCDEFL, "getAndAddAcquire long");
1217                 long x = (long) vh.get(array, i);
1218                 assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddAcquire long value");
1219             }
1220 
1221             {
1222                 vh.set(array, i, 0x0123456789ABCDEFL);
1223 
1224                 long o = (long) vh.getAndAddRelease(array, i, 0xCAFEBABECAFEBABEL);
1225                 assertEquals(o, 0x0123456789ABCDEFL, "getAndAddReleaselong");
1226                 long x = (long) vh.get(array, i);
1227                 assertEquals(x, (long)(0x0123456789ABCDEFL + 0xCAFEBABECAFEBABEL), "getAndAddRelease long value");
1228             }
1229 
1230             // get and bitwise or
1231             {
1232                 vh.set(array, i, 0x0123456789ABCDEFL);
1233 
1234                 long o = (long) vh.getAndBitwiseOr(array, i, 0xCAFEBABECAFEBABEL);
1235                 assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOr long");
1236                 long x = (long) vh.get(array, i);
1237                 assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOr long value");
1238             }
1239 
1240             {
1241                 vh.set(array, i, 0x0123456789ABCDEFL);
1242 
1243                 long o = (long) vh.getAndBitwiseOrAcquire(array, i, 0xCAFEBABECAFEBABEL);
1244                 assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrAcquire long");
1245                 long x = (long) vh.get(array, i);
1246                 assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrAcquire long value");
1247             }
1248 
1249             {
1250                 vh.set(array, i, 0x0123456789ABCDEFL);
1251 
1252                 long o = (long) vh.getAndBitwiseOrRelease(array, i, 0xCAFEBABECAFEBABEL);
1253                 assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseOrRelease long");
1254                 long x = (long) vh.get(array, i);
1255                 assertEquals(x, (long)(0x0123456789ABCDEFL | 0xCAFEBABECAFEBABEL), "getAndBitwiseOrRelease long value");
1256             }
1257 
1258             // get and bitwise and
1259             {
1260                 vh.set(array, i, 0x0123456789ABCDEFL);
1261 
1262                 long o = (long) vh.getAndBitwiseAnd(array, i, 0xCAFEBABECAFEBABEL);
1263                 assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAnd long");
1264                 long x = (long) vh.get(array, i);
1265                 assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAnd long value");
1266             }
1267 
1268             {
1269                 vh.set(array, i, 0x0123456789ABCDEFL);
1270 
1271                 long o = (long) vh.getAndBitwiseAndAcquire(array, i, 0xCAFEBABECAFEBABEL);
1272                 assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndAcquire long");
1273                 long x = (long) vh.get(array, i);
1274                 assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndAcquire long value");
1275             }
1276 
1277             {
1278                 vh.set(array, i, 0x0123456789ABCDEFL);
1279 
1280                 long o = (long) vh.getAndBitwiseAndRelease(array, i, 0xCAFEBABECAFEBABEL);
1281                 assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseAndRelease long");
1282                 long x = (long) vh.get(array, i);
1283                 assertEquals(x, (long)(0x0123456789ABCDEFL & 0xCAFEBABECAFEBABEL), "getAndBitwiseAndRelease long value");
1284             }
1285 
1286             // get and bitwise xor
1287             {
1288                 vh.set(array, i, 0x0123456789ABCDEFL);
1289 
1290                 long o = (long) vh.getAndBitwiseXor(array, i, 0xCAFEBABECAFEBABEL);
1291                 assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXor long");
1292                 long x = (long) vh.get(array, i);
1293                 assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXor long value");
1294             }
1295 
1296             {
1297                 vh.set(array, i, 0x0123456789ABCDEFL);
1298 
1299                 long o = (long) vh.getAndBitwiseXorAcquire(array, i, 0xCAFEBABECAFEBABEL);
1300                 assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorAcquire long");
1301                 long x = (long) vh.get(array, i);
1302                 assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorAcquire long value");
1303             }
1304 
1305             {
1306                 vh.set(array, i, 0x0123456789ABCDEFL);
1307 
1308                 long o = (long) vh.getAndBitwiseXorRelease(array, i, 0xCAFEBABECAFEBABEL);
1309                 assertEquals(o, 0x0123456789ABCDEFL, "getAndBitwiseXorRelease long");
1310                 long x = (long) vh.get(array, i);
1311                 assertEquals(x, (long)(0x0123456789ABCDEFL ^ 0xCAFEBABECAFEBABEL), "getAndBitwiseXorRelease long value");
1312             }
1313         }
1314     }
1315 
1316     static void testArrayUnsupported(VarHandle vh) {
1317         long[] array = new long[10];
1318 
1319         int i = 0;
1320 
1321 
1322     }
1323 
1324     static void testArrayIndexOutOfBounds(VarHandle vh) throws Throwable {
1325         long[] array = new long[10];
1326 
1327         for (int i : new int[]{-1, Integer.MIN_VALUE, 10, 11, Integer.MAX_VALUE}) {
1328             final int ci = i;
1329 
1330             checkAIOOBE(() -> {
1331                 long x = (long) vh.get(array, ci);
1332             });
1333 
1334             checkAIOOBE(() -> {
1335                 vh.set(array, ci, 0x0123456789ABCDEFL);
1336             });
1337 
1338             checkAIOOBE(() -> {
1339                 long x = (long) vh.getVolatile(array, ci);
1340             });
1341 
1342             checkAIOOBE(() -> {
1343                 vh.setVolatile(array, ci, 0x0123456789ABCDEFL);
1344             });
1345 
1346             checkAIOOBE(() -> {
1347                 long x = (long) vh.getAcquire(array, ci);
1348             });
1349 
1350             checkAIOOBE(() -> {
1351                 vh.setRelease(array, ci, 0x0123456789ABCDEFL);
1352             });
1353 
1354             checkAIOOBE(() -> {
1355                 long x = (long) vh.getOpaque(array, ci);
1356             });
1357 
1358             checkAIOOBE(() -> {
1359                 vh.setOpaque(array, ci, 0x0123456789ABCDEFL);
1360             });
1361 
1362             checkAIOOBE(() -> {
1363                 boolean r = vh.compareAndSet(array, ci, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
1364             });
1365 
1366             checkAIOOBE(() -> {
1367                 long r = (long) vh.compareAndExchange(array, ci, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
1368             });
1369 
1370             checkAIOOBE(() -> {
1371                 long r = (long) vh.compareAndExchangeAcquire(array, ci, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
1372             });
1373 
1374             checkAIOOBE(() -> {
1375                 long r = (long) vh.compareAndExchangeRelease(array, ci, 0xCAFEBABECAFEBABEL, 0x0123456789ABCDEFL);
1376             });
1377 
1378             checkAIOOBE(() -> {
1379                 boolean r = vh.weakCompareAndSetPlain(array, ci, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
1380             });
1381 
1382             checkAIOOBE(() -> {
1383                 boolean r = vh.weakCompareAndSet(array, ci, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
1384             });
1385 
1386             checkAIOOBE(() -> {
1387                 boolean r = vh.weakCompareAndSetAcquire(array, ci, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
1388             });
1389 
1390             checkAIOOBE(() -> {
1391                 boolean r = vh.weakCompareAndSetRelease(array, ci, 0x0123456789ABCDEFL, 0xCAFEBABECAFEBABEL);
1392             });
1393 
1394             checkAIOOBE(() -> {
1395                 long o = (long) vh.getAndSet(array, ci, 0x0123456789ABCDEFL);
1396             });
1397 
1398             checkAIOOBE(() -> {
1399                 long o = (long) vh.getAndSetAcquire(array, ci, 0x0123456789ABCDEFL);
1400             });
1401 
1402             checkAIOOBE(() -> {
1403                 long o = (long) vh.getAndSetRelease(array, ci, 0x0123456789ABCDEFL);
1404             });
1405 
1406             checkAIOOBE(() -> {
1407                 long o = (long) vh.getAndAdd(array, ci, 0x0123456789ABCDEFL);
1408             });
1409 
1410             checkAIOOBE(() -> {
1411                 long o = (long) vh.getAndAddAcquire(array, ci, 0x0123456789ABCDEFL);
1412             });
1413 
1414             checkAIOOBE(() -> {
1415                 long o = (long) vh.getAndAddRelease(array, ci, 0x0123456789ABCDEFL);
1416             });
1417 
1418             checkAIOOBE(() -> {
1419                 long o = (long) vh.getAndBitwiseOr(array, ci, 0x0123456789ABCDEFL);
1420             });
1421 
1422             checkAIOOBE(() -> {
1423                 long o = (long) vh.getAndBitwiseOrAcquire(array, ci, 0x0123456789ABCDEFL);
1424             });
1425 
1426             checkAIOOBE(() -> {
1427                 long o = (long) vh.getAndBitwiseOrRelease(array, ci, 0x0123456789ABCDEFL);
1428             });
1429 
1430             checkAIOOBE(() -> {
1431                 long o = (long) vh.getAndBitwiseAnd(array, ci, 0x0123456789ABCDEFL);
1432             });
1433 
1434             checkAIOOBE(() -> {
1435                 long o = (long) vh.getAndBitwiseAndAcquire(array, ci, 0x0123456789ABCDEFL);
1436             });
1437 
1438             checkAIOOBE(() -> {
1439                 long o = (long) vh.getAndBitwiseAndRelease(array, ci, 0x0123456789ABCDEFL);
1440             });
1441 
1442             checkAIOOBE(() -> {
1443                 long o = (long) vh.getAndBitwiseXor(array, ci, 0x0123456789ABCDEFL);
1444             });
1445 
1446             checkAIOOBE(() -> {
1447                 long o = (long) vh.getAndBitwiseXorAcquire(array, ci, 0x0123456789ABCDEFL);
1448             });
1449 
1450             checkAIOOBE(() -> {
1451                 long o = (long) vh.getAndBitwiseXorRelease(array, ci, 0x0123456789ABCDEFL);
1452             });
1453         }
1454     }
1455 
1456 }
1457