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