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