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