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