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