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