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