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