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 VarHandleTestAccessInt 27 * @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 VarHandleTestAccessInt 28 * @run testng/othervm -Diters=20000 VarHandleTestAccessInt 29 * @run testng/othervm -Diters=20000 -XX:-TieredCompilation VarHandleTestAccessInt 30 */ 31 32 import org.testng.annotations.BeforeClass; 33 import org.testng.annotations.DataProvider; 34 import org.testng.annotations.Test; 35 36 import java.lang.invoke.MethodHandles; 37 import java.lang.invoke.VarHandle; 38 import java.util.ArrayList; 39 import java.util.Arrays; 40 import java.util.List; 41 42 import static org.testng.Assert.*; 43 44 public class VarHandleTestAccessInt extends VarHandleBaseTest { 45 static final int static_final_v = 0x01234567; 46 47 static int static_v; 48 49 final int final_v = 0x01234567; 50 51 int 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 VarHandleTestAccessInt.class, "final_v", int.class); 67 68 vhField = MethodHandles.lookup().findVarHandle( 69 VarHandleTestAccessInt.class, "v", int.class); 70 71 vhStaticFinalField = MethodHandles.lookup().findStaticVarHandle( 72 VarHandleTestAccessInt.class, "static_final_v", int.class); 73 74 vhStaticField = MethodHandles.lookup().findStaticVarHandle( 75 VarHandleTestAccessInt.class, "static_v", int.class); 76 77 vhArray = MethodHandles.arrayElementVarHandle(int[].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 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD)); 115 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_ACQUIRE)); 116 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_RELEASE)); 117 118 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR)); 119 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_ACQUIRE)); 120 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_RELEASE)); 121 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND)); 122 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_ACQUIRE)); 123 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_RELEASE)); 124 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR)); 125 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_ACQUIRE)); 126 assertTrue(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(VarHandleTestAccessInt.class)}); 134 types.add(new Object[] {vhStaticField, Arrays.asList()}); 135 types.add(new Object[] {vhArray, Arrays.asList(int[].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(), int.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 VarHandleTestAccessInt.class, "final_v", int.class); 155 }); 156 157 checkIAE("Lookup of static field to instance field", () -> { 158 MethodHandles.lookup().findStaticVarHandle( 159 VarHandleTestAccessInt.class, "v", int.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 VarHandleTestAccessInt.class, "static_final_v", int.class); 168 }); 169 170 checkIAE("Lookup of instance field to static field", () -> { 171 vhStaticField = MethodHandles.lookup().findVarHandle( 172 VarHandleTestAccessInt.class, "static_v", int.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, VarHandleTestAccessInt::testStaticFinalField)); 189 cases.add(new VarHandleAccessTestCase("Static final field unsupported", 190 vhStaticFinalField, VarHandleTestAccessInt::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, VarHandleTestAccessInt::testStaticField)); 201 cases.add(new VarHandleAccessTestCase("Static field unsupported", 202 vhStaticField, VarHandleTestAccessInt::testStaticFieldUnsupported, 203 false)); 204 205 cases.add(new VarHandleAccessTestCase("Array", 206 vhArray, VarHandleTestAccessInt::testArray)); 207 cases.add(new VarHandleAccessTestCase("Array unsupported", 208 vhArray, VarHandleTestAccessInt::testArrayUnsupported, 209 false)); 210 cases.add(new VarHandleAccessTestCase("Array index out of bounds", 211 vhArray, VarHandleTestAccessInt::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(VarHandleTestAccessInt recv, VarHandle vh) { 233 // Plain 234 { 235 int x = (int) vh.get(recv); 236 assertEquals(x, 0x01234567, "get int value"); 237 } 238 239 240 // Volatile 241 { 242 int x = (int) vh.getVolatile(recv); 243 assertEquals(x, 0x01234567, "getVolatile int value"); 244 } 245 246 // Lazy 247 { 248 int x = (int) vh.getAcquire(recv); 249 assertEquals(x, 0x01234567, "getRelease int value"); 250 } 251 252 // Opaque 253 { 254 int x = (int) vh.getOpaque(recv); 255 assertEquals(x, 0x01234567, "getOpaque int value"); 256 } 257 } 258 259 static void testInstanceFinalFieldUnsupported(VarHandleTestAccessInt recv, VarHandle vh) { 260 checkUOE(() -> { 261 vh.set(recv, 0x89ABCDEF); 262 }); 263 264 checkUOE(() -> { 265 vh.setVolatile(recv, 0x89ABCDEF); 266 }); 267 268 checkUOE(() -> { 269 vh.setRelease(recv, 0x89ABCDEF); 270 }); 271 272 checkUOE(() -> { 273 vh.setOpaque(recv, 0x89ABCDEF); 274 }); 275 276 277 278 } 279 280 281 static void testStaticFinalField(VarHandle vh) { 282 // Plain 283 { 284 int x = (int) vh.get(); 285 assertEquals(x, 0x01234567, "get int value"); 286 } 287 288 289 // Volatile 290 { 291 int x = (int) vh.getVolatile(); 292 assertEquals(x, 0x01234567, "getVolatile int value"); 293 } 294 295 // Lazy 296 { 297 int x = (int) vh.getAcquire(); 298 assertEquals(x, 0x01234567, "getRelease int value"); 299 } 300 301 // Opaque 302 { 303 int x = (int) vh.getOpaque(); 304 assertEquals(x, 0x01234567, "getOpaque int value"); 305 } 306 } 307 308 static void testStaticFinalFieldUnsupported(VarHandle vh) { 309 checkUOE(() -> { 310 vh.set(0x89ABCDEF); 311 }); 312 313 checkUOE(() -> { 314 vh.setVolatile(0x89ABCDEF); 315 }); 316 317 checkUOE(() -> { 318 vh.setRelease(0x89ABCDEF); 319 }); 320 321 checkUOE(() -> { 322 vh.setOpaque(0x89ABCDEF); 323 }); 324 325 326 327 } 328 329 330 static void testInstanceField(VarHandleTestAccessInt recv, VarHandle vh) { 331 // Plain 332 { 333 vh.set(recv, 0x01234567); 334 int x = (int) vh.get(recv); 335 assertEquals(x, 0x01234567, "set int value"); 336 } 337 338 339 // Volatile 340 { 341 vh.setVolatile(recv, 0x89ABCDEF); 342 int x = (int) vh.getVolatile(recv); 343 assertEquals(x, 0x89ABCDEF, "setVolatile int value"); 344 } 345 346 // Lazy 347 { 348 vh.setRelease(recv, 0x01234567); 349 int x = (int) vh.getAcquire(recv); 350 assertEquals(x, 0x01234567, "setRelease int value"); 351 } 352 353 // Opaque 354 { 355 vh.setOpaque(recv, 0x89ABCDEF); 356 int x = (int) vh.getOpaque(recv); 357 assertEquals(x, 0x89ABCDEF, "setOpaque int value"); 358 } 359 360 vh.set(recv, 0x01234567); 361 362 // Compare 363 { 364 boolean r = vh.compareAndSet(recv, 0x01234567, 0x89ABCDEF); 365 assertEquals(r, true, "success compareAndSet int"); 366 int x = (int) vh.get(recv); 367 assertEquals(x, 0x89ABCDEF, "success compareAndSet int value"); 368 } 369 370 { 371 boolean r = vh.compareAndSet(recv, 0x01234567, 0xCAFEBABE); 372 assertEquals(r, false, "failing compareAndSet int"); 373 int x = (int) vh.get(recv); 374 assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value"); 375 } 376 377 { 378 int r = (int) vh.compareAndExchange(recv, 0x89ABCDEF, 0x01234567); 379 assertEquals(r, 0x89ABCDEF, "success compareAndExchange int"); 380 int x = (int) vh.get(recv); 381 assertEquals(x, 0x01234567, "success compareAndExchange int value"); 382 } 383 384 { 385 int r = (int) vh.compareAndExchange(recv, 0x89ABCDEF, 0xCAFEBABE); 386 assertEquals(r, 0x01234567, "failing compareAndExchange int"); 387 int x = (int) vh.get(recv); 388 assertEquals(x, 0x01234567, "failing compareAndExchange int value"); 389 } 390 391 { 392 int r = (int) vh.compareAndExchangeAcquire(recv, 0x01234567, 0x89ABCDEF); 393 assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int"); 394 int x = (int) vh.get(recv); 395 assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value"); 396 } 397 398 { 399 int r = (int) vh.compareAndExchangeAcquire(recv, 0x01234567, 0xCAFEBABE); 400 assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int"); 401 int x = (int) vh.get(recv); 402 assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value"); 403 } 404 405 { 406 int r = (int) vh.compareAndExchangeRelease(recv, 0x89ABCDEF, 0x01234567); 407 assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int"); 408 int x = (int) vh.get(recv); 409 assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value"); 410 } 411 412 { 413 int r = (int) vh.compareAndExchangeRelease(recv, 0x89ABCDEF, 0xCAFEBABE); 414 assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int"); 415 int x = (int) vh.get(recv); 416 assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value"); 417 } 418 419 { 420 boolean success = false; 421 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { 422 success = vh.weakCompareAndSetPlain(recv, 0x01234567, 0x89ABCDEF); 423 } 424 assertEquals(success, true, "weakCompareAndSetPlain int"); 425 int x = (int) vh.get(recv); 426 assertEquals(x, 0x89ABCDEF, "weakCompareAndSetPlain int value"); 427 } 428 429 { 430 boolean success = false; 431 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { 432 success = vh.weakCompareAndSetAcquire(recv, 0x89ABCDEF, 0x01234567); 433 } 434 assertEquals(success, true, "weakCompareAndSetAcquire int"); 435 int x = (int) vh.get(recv); 436 assertEquals(x, 0x01234567, "weakCompareAndSetAcquire int"); 437 } 438 439 { 440 boolean success = false; 441 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { 442 success = vh.weakCompareAndSetRelease(recv, 0x01234567, 0x89ABCDEF); 443 } 444 assertEquals(success, true, "weakCompareAndSetRelease int"); 445 int x = (int) vh.get(recv); 446 assertEquals(x, 0x89ABCDEF, "weakCompareAndSetRelease int"); 447 } 448 449 { 450 boolean success = false; 451 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { 452 success = vh.weakCompareAndSet(recv, 0x89ABCDEF, 0x01234567); 453 } 454 assertEquals(success, true, "weakCompareAndSet int"); 455 int x = (int) vh.get(recv); 456 assertEquals(x, 0x01234567, "weakCompareAndSet int value"); 457 } 458 459 // Compare set and get 460 { 461 vh.set(recv, 0x01234567); 462 463 int o = (int) vh.getAndSet(recv, 0x89ABCDEF); 464 assertEquals(o, 0x01234567, "getAndSet int"); 465 int x = (int) vh.get(recv); 466 assertEquals(x, 0x89ABCDEF, "getAndSet int value"); 467 } 468 469 { 470 vh.set(recv, 0x01234567); 471 472 int o = (int) vh.getAndSetAcquire(recv, 0x89ABCDEF); 473 assertEquals(o, 0x01234567, "getAndSetAcquire int"); 474 int x = (int) vh.get(recv); 475 assertEquals(x, 0x89ABCDEF, "getAndSetAcquire int value"); 476 } 477 478 { 479 vh.set(recv, 0x01234567); 480 481 int o = (int) vh.getAndSetRelease(recv, 0x89ABCDEF); 482 assertEquals(o, 0x01234567, "getAndSetRelease int"); 483 int x = (int) vh.get(recv); 484 assertEquals(x, 0x89ABCDEF, "getAndSetRelease int value"); 485 } 486 487 // get and add, add and get 488 { 489 vh.set(recv, 0x01234567); 490 491 int o = (int) vh.getAndAdd(recv, 0x89ABCDEF); 492 assertEquals(o, 0x01234567, "getAndAdd int"); 493 int x = (int) vh.get(recv); 494 assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value"); 495 } 496 497 { 498 vh.set(recv, 0x01234567); 499 500 int o = (int) vh.getAndAddAcquire(recv, 0x89ABCDEF); 501 assertEquals(o, 0x01234567, "getAndAddAcquire int"); 502 int x = (int) vh.get(recv); 503 assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value"); 504 } 505 506 { 507 vh.set(recv, 0x01234567); 508 509 int o = (int) vh.getAndAddRelease(recv, 0x89ABCDEF); 510 assertEquals(o, 0x01234567, "getAndAddReleaseint"); 511 int x = (int) vh.get(recv); 512 assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value"); 513 } 514 515 // get and bitwise or 516 { 517 vh.set(recv, 0x01234567); 518 519 int o = (int) vh.getAndBitwiseOr(recv, 0x89ABCDEF); 520 assertEquals(o, 0x01234567, "getAndBitwiseOr int"); 521 int x = (int) vh.get(recv); 522 assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value"); 523 } 524 525 { 526 vh.set(recv, 0x01234567); 527 528 int o = (int) vh.getAndBitwiseOrAcquire(recv, 0x89ABCDEF); 529 assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int"); 530 int x = (int) vh.get(recv); 531 assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value"); 532 } 533 534 { 535 vh.set(recv, 0x01234567); 536 537 int o = (int) vh.getAndBitwiseOrRelease(recv, 0x89ABCDEF); 538 assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int"); 539 int x = (int) vh.get(recv); 540 assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value"); 541 } 542 543 // get and bitwise and 544 { 545 vh.set(recv, 0x01234567); 546 547 int o = (int) vh.getAndBitwiseAnd(recv, 0x89ABCDEF); 548 assertEquals(o, 0x01234567, "getAndBitwiseAnd int"); 549 int x = (int) vh.get(recv); 550 assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value"); 551 } 552 553 { 554 vh.set(recv, 0x01234567); 555 556 int o = (int) vh.getAndBitwiseAndAcquire(recv, 0x89ABCDEF); 557 assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int"); 558 int x = (int) vh.get(recv); 559 assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value"); 560 } 561 562 { 563 vh.set(recv, 0x01234567); 564 565 int o = (int) vh.getAndBitwiseAndRelease(recv, 0x89ABCDEF); 566 assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int"); 567 int x = (int) vh.get(recv); 568 assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value"); 569 } 570 571 // get and bitwise xor 572 { 573 vh.set(recv, 0x01234567); 574 575 int o = (int) vh.getAndBitwiseXor(recv, 0x89ABCDEF); 576 assertEquals(o, 0x01234567, "getAndBitwiseXor int"); 577 int x = (int) vh.get(recv); 578 assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value"); 579 } 580 581 { 582 vh.set(recv, 0x01234567); 583 584 int o = (int) vh.getAndBitwiseXorAcquire(recv, 0x89ABCDEF); 585 assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int"); 586 int x = (int) vh.get(recv); 587 assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value"); 588 } 589 590 { 591 vh.set(recv, 0x01234567); 592 593 int o = (int) vh.getAndBitwiseXorRelease(recv, 0x89ABCDEF); 594 assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int"); 595 int x = (int) vh.get(recv); 596 assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value"); 597 } 598 } 599 600 static void testInstanceFieldUnsupported(VarHandleTestAccessInt recv, VarHandle vh) { 601 602 603 } 604 605 606 static void testStaticField(VarHandle vh) { 607 // Plain 608 { 609 vh.set(0x01234567); 610 int x = (int) vh.get(); 611 assertEquals(x, 0x01234567, "set int value"); 612 } 613 614 615 // Volatile 616 { 617 vh.setVolatile(0x89ABCDEF); 618 int x = (int) vh.getVolatile(); 619 assertEquals(x, 0x89ABCDEF, "setVolatile int value"); 620 } 621 622 // Lazy 623 { 624 vh.setRelease(0x01234567); 625 int x = (int) vh.getAcquire(); 626 assertEquals(x, 0x01234567, "setRelease int value"); 627 } 628 629 // Opaque 630 { 631 vh.setOpaque(0x89ABCDEF); 632 int x = (int) vh.getOpaque(); 633 assertEquals(x, 0x89ABCDEF, "setOpaque int value"); 634 } 635 636 vh.set(0x01234567); 637 638 // Compare 639 { 640 boolean r = vh.compareAndSet(0x01234567, 0x89ABCDEF); 641 assertEquals(r, true, "success compareAndSet int"); 642 int x = (int) vh.get(); 643 assertEquals(x, 0x89ABCDEF, "success compareAndSet int value"); 644 } 645 646 { 647 boolean r = vh.compareAndSet(0x01234567, 0xCAFEBABE); 648 assertEquals(r, false, "failing compareAndSet int"); 649 int x = (int) vh.get(); 650 assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value"); 651 } 652 653 { 654 int r = (int) vh.compareAndExchange(0x89ABCDEF, 0x01234567); 655 assertEquals(r, 0x89ABCDEF, "success compareAndExchange int"); 656 int x = (int) vh.get(); 657 assertEquals(x, 0x01234567, "success compareAndExchange int value"); 658 } 659 660 { 661 int r = (int) vh.compareAndExchange(0x89ABCDEF, 0xCAFEBABE); 662 assertEquals(r, 0x01234567, "failing compareAndExchange int"); 663 int x = (int) vh.get(); 664 assertEquals(x, 0x01234567, "failing compareAndExchange int value"); 665 } 666 667 { 668 int r = (int) vh.compareAndExchangeAcquire(0x01234567, 0x89ABCDEF); 669 assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int"); 670 int x = (int) vh.get(); 671 assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value"); 672 } 673 674 { 675 int r = (int) vh.compareAndExchangeAcquire(0x01234567, 0xCAFEBABE); 676 assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int"); 677 int x = (int) vh.get(); 678 assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value"); 679 } 680 681 { 682 int r = (int) vh.compareAndExchangeRelease(0x89ABCDEF, 0x01234567); 683 assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int"); 684 int x = (int) vh.get(); 685 assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value"); 686 } 687 688 { 689 int r = (int) vh.compareAndExchangeRelease(0x89ABCDEF, 0xCAFEBABE); 690 assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int"); 691 int x = (int) vh.get(); 692 assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value"); 693 } 694 695 { 696 boolean success = false; 697 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { 698 success = vh.weakCompareAndSetPlain(0x01234567, 0x89ABCDEF); 699 } 700 assertEquals(success, true, "weakCompareAndSetPlain int"); 701 int x = (int) vh.get(); 702 assertEquals(x, 0x89ABCDEF, "weakCompareAndSetPlain int value"); 703 } 704 705 { 706 boolean success = false; 707 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { 708 success = vh.weakCompareAndSetAcquire(0x89ABCDEF, 0x01234567); 709 } 710 assertEquals(success, true, "weakCompareAndSetAcquire int"); 711 int x = (int) vh.get(); 712 assertEquals(x, 0x01234567, "weakCompareAndSetAcquire int"); 713 } 714 715 { 716 boolean success = false; 717 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { 718 success = vh.weakCompareAndSetRelease(0x01234567, 0x89ABCDEF); 719 } 720 assertEquals(success, true, "weakCompareAndSetRelease int"); 721 int x = (int) vh.get(); 722 assertEquals(x, 0x89ABCDEF, "weakCompareAndSetRelease int"); 723 } 724 725 { 726 boolean success = false; 727 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { 728 success = vh.weakCompareAndSet(0x89ABCDEF, 0x01234567); 729 } 730 assertEquals(success, true, "weakCompareAndSet int"); 731 int x = (int) vh.get(); 732 assertEquals(x, 0x01234567, "weakCompareAndSet int"); 733 } 734 735 // Compare set and get 736 { 737 vh.set(0x01234567); 738 739 int o = (int) vh.getAndSet(0x89ABCDEF); 740 assertEquals(o, 0x01234567, "getAndSet int"); 741 int x = (int) vh.get(); 742 assertEquals(x, 0x89ABCDEF, "getAndSet int value"); 743 } 744 745 { 746 vh.set(0x01234567); 747 748 int o = (int) vh.getAndSetAcquire(0x89ABCDEF); 749 assertEquals(o, 0x01234567, "getAndSetAcquire int"); 750 int x = (int) vh.get(); 751 assertEquals(x, 0x89ABCDEF, "getAndSetAcquire int value"); 752 } 753 754 { 755 vh.set(0x01234567); 756 757 int o = (int) vh.getAndSetRelease(0x89ABCDEF); 758 assertEquals(o, 0x01234567, "getAndSetRelease int"); 759 int x = (int) vh.get(); 760 assertEquals(x, 0x89ABCDEF, "getAndSetRelease int value"); 761 } 762 763 // get and add, add and get 764 { 765 vh.set(0x01234567); 766 767 int o = (int) vh.getAndAdd(0x89ABCDEF); 768 assertEquals(o, 0x01234567, "getAndAdd int"); 769 int x = (int) vh.get(); 770 assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value"); 771 } 772 773 { 774 vh.set(0x01234567); 775 776 int o = (int) vh.getAndAddAcquire(0x89ABCDEF); 777 assertEquals(o, 0x01234567, "getAndAddAcquire int"); 778 int x = (int) vh.get(); 779 assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value"); 780 } 781 782 { 783 vh.set(0x01234567); 784 785 int o = (int) vh.getAndAddRelease(0x89ABCDEF); 786 assertEquals(o, 0x01234567, "getAndAddReleaseint"); 787 int x = (int) vh.get(); 788 assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value"); 789 } 790 791 // get and bitwise or 792 { 793 vh.set(0x01234567); 794 795 int o = (int) vh.getAndBitwiseOr(0x89ABCDEF); 796 assertEquals(o, 0x01234567, "getAndBitwiseOr int"); 797 int x = (int) vh.get(); 798 assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value"); 799 } 800 801 { 802 vh.set(0x01234567); 803 804 int o = (int) vh.getAndBitwiseOrAcquire(0x89ABCDEF); 805 assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int"); 806 int x = (int) vh.get(); 807 assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value"); 808 } 809 810 { 811 vh.set(0x01234567); 812 813 int o = (int) vh.getAndBitwiseOrRelease(0x89ABCDEF); 814 assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int"); 815 int x = (int) vh.get(); 816 assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value"); 817 } 818 819 // get and bitwise and 820 { 821 vh.set(0x01234567); 822 823 int o = (int) vh.getAndBitwiseAnd(0x89ABCDEF); 824 assertEquals(o, 0x01234567, "getAndBitwiseAnd int"); 825 int x = (int) vh.get(); 826 assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value"); 827 } 828 829 { 830 vh.set(0x01234567); 831 832 int o = (int) vh.getAndBitwiseAndAcquire(0x89ABCDEF); 833 assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int"); 834 int x = (int) vh.get(); 835 assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value"); 836 } 837 838 { 839 vh.set(0x01234567); 840 841 int o = (int) vh.getAndBitwiseAndRelease(0x89ABCDEF); 842 assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int"); 843 int x = (int) vh.get(); 844 assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value"); 845 } 846 847 // get and bitwise xor 848 { 849 vh.set(0x01234567); 850 851 int o = (int) vh.getAndBitwiseXor(0x89ABCDEF); 852 assertEquals(o, 0x01234567, "getAndBitwiseXor int"); 853 int x = (int) vh.get(); 854 assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value"); 855 } 856 857 { 858 vh.set(0x01234567); 859 860 int o = (int) vh.getAndBitwiseXorAcquire(0x89ABCDEF); 861 assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int"); 862 int x = (int) vh.get(); 863 assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value"); 864 } 865 866 { 867 vh.set(0x01234567); 868 869 int o = (int) vh.getAndBitwiseXorRelease(0x89ABCDEF); 870 assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int"); 871 int x = (int) vh.get(); 872 assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value"); 873 } 874 } 875 876 static void testStaticFieldUnsupported(VarHandle vh) { 877 878 879 } 880 881 882 static void testArray(VarHandle vh) { 883 int[] array = new int[10]; 884 885 for (int i = 0; i < array.length; i++) { 886 // Plain 887 { 888 vh.set(array, i, 0x01234567); 889 int x = (int) vh.get(array, i); 890 assertEquals(x, 0x01234567, "get int value"); 891 } 892 893 894 // Volatile 895 { 896 vh.setVolatile(array, i, 0x89ABCDEF); 897 int x = (int) vh.getVolatile(array, i); 898 assertEquals(x, 0x89ABCDEF, "setVolatile int value"); 899 } 900 901 // Lazy 902 { 903 vh.setRelease(array, i, 0x01234567); 904 int x = (int) vh.getAcquire(array, i); 905 assertEquals(x, 0x01234567, "setRelease int value"); 906 } 907 908 // Opaque 909 { 910 vh.setOpaque(array, i, 0x89ABCDEF); 911 int x = (int) vh.getOpaque(array, i); 912 assertEquals(x, 0x89ABCDEF, "setOpaque int value"); 913 } 914 915 vh.set(array, i, 0x01234567); 916 917 // Compare 918 { 919 boolean r = vh.compareAndSet(array, i, 0x01234567, 0x89ABCDEF); 920 assertEquals(r, true, "success compareAndSet int"); 921 int x = (int) vh.get(array, i); 922 assertEquals(x, 0x89ABCDEF, "success compareAndSet int value"); 923 } 924 925 { 926 boolean r = vh.compareAndSet(array, i, 0x01234567, 0xCAFEBABE); 927 assertEquals(r, false, "failing compareAndSet int"); 928 int x = (int) vh.get(array, i); 929 assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value"); 930 } 931 932 { 933 int r = (int) vh.compareAndExchange(array, i, 0x89ABCDEF, 0x01234567); 934 assertEquals(r, 0x89ABCDEF, "success compareAndExchange int"); 935 int x = (int) vh.get(array, i); 936 assertEquals(x, 0x01234567, "success compareAndExchange int value"); 937 } 938 939 { 940 int r = (int) vh.compareAndExchange(array, i, 0x89ABCDEF, 0xCAFEBABE); 941 assertEquals(r, 0x01234567, "failing compareAndExchange int"); 942 int x = (int) vh.get(array, i); 943 assertEquals(x, 0x01234567, "failing compareAndExchange int value"); 944 } 945 946 { 947 int r = (int) vh.compareAndExchangeAcquire(array, i, 0x01234567, 0x89ABCDEF); 948 assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int"); 949 int x = (int) vh.get(array, i); 950 assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value"); 951 } 952 953 { 954 int r = (int) vh.compareAndExchangeAcquire(array, i, 0x01234567, 0xCAFEBABE); 955 assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int"); 956 int x = (int) vh.get(array, i); 957 assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value"); 958 } 959 960 { 961 int r = (int) vh.compareAndExchangeRelease(array, i, 0x89ABCDEF, 0x01234567); 962 assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int"); 963 int x = (int) vh.get(array, i); 964 assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value"); 965 } 966 967 { 968 int r = (int) vh.compareAndExchangeRelease(array, i, 0x89ABCDEF, 0xCAFEBABE); 969 assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int"); 970 int x = (int) vh.get(array, i); 971 assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value"); 972 } 973 974 { 975 boolean success = false; 976 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { 977 success = vh.weakCompareAndSetPlain(array, i, 0x01234567, 0x89ABCDEF); 978 } 979 assertEquals(success, true, "weakCompareAndSetPlain int"); 980 int x = (int) vh.get(array, i); 981 assertEquals(x, 0x89ABCDEF, "weakCompareAndSetPlain int value"); 982 } 983 984 { 985 boolean success = false; 986 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { 987 success = vh.weakCompareAndSetAcquire(array, i, 0x89ABCDEF, 0x01234567); 988 } 989 assertEquals(success, true, "weakCompareAndSetAcquire int"); 990 int x = (int) vh.get(array, i); 991 assertEquals(x, 0x01234567, "weakCompareAndSetAcquire int"); 992 } 993 994 { 995 boolean success = false; 996 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { 997 success = vh.weakCompareAndSetRelease(array, i, 0x01234567, 0x89ABCDEF); 998 } 999 assertEquals(success, true, "weakCompareAndSetRelease int"); 1000 int x = (int) vh.get(array, i); 1001 assertEquals(x, 0x89ABCDEF, "weakCompareAndSetRelease int"); 1002 } 1003 1004 { 1005 boolean success = false; 1006 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) { 1007 success = vh.weakCompareAndSet(array, i, 0x89ABCDEF, 0x01234567); 1008 } 1009 assertEquals(success, true, "weakCompareAndSet int"); 1010 int x = (int) vh.get(array, i); 1011 assertEquals(x, 0x01234567, "weakCompareAndSet int"); 1012 } 1013 1014 // Compare set and get 1015 { 1016 vh.set(array, i, 0x01234567); 1017 1018 int o = (int) vh.getAndSet(array, i, 0x89ABCDEF); 1019 assertEquals(o, 0x01234567, "getAndSet int"); 1020 int x = (int) vh.get(array, i); 1021 assertEquals(x, 0x89ABCDEF, "getAndSet int value"); 1022 } 1023 1024 { 1025 vh.set(array, i, 0x01234567); 1026 1027 int o = (int) vh.getAndSetAcquire(array, i, 0x89ABCDEF); 1028 assertEquals(o, 0x01234567, "getAndSetAcquire int"); 1029 int x = (int) vh.get(array, i); 1030 assertEquals(x, 0x89ABCDEF, "getAndSetAcquire int value"); 1031 } 1032 1033 { 1034 vh.set(array, i, 0x01234567); 1035 1036 int o = (int) vh.getAndSetRelease(array, i, 0x89ABCDEF); 1037 assertEquals(o, 0x01234567, "getAndSetRelease int"); 1038 int x = (int) vh.get(array, i); 1039 assertEquals(x, 0x89ABCDEF, "getAndSetRelease int value"); 1040 } 1041 1042 // get and add, add and get 1043 { 1044 vh.set(array, i, 0x01234567); 1045 1046 int o = (int) vh.getAndAdd(array, i, 0x89ABCDEF); 1047 assertEquals(o, 0x01234567, "getAndAdd int"); 1048 int x = (int) vh.get(array, i); 1049 assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAdd int value"); 1050 } 1051 1052 { 1053 vh.set(array, i, 0x01234567); 1054 1055 int o = (int) vh.getAndAddAcquire(array, i, 0x89ABCDEF); 1056 assertEquals(o, 0x01234567, "getAndAddAcquire int"); 1057 int x = (int) vh.get(array, i); 1058 assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value"); 1059 } 1060 1061 { 1062 vh.set(array, i, 0x01234567); 1063 1064 int o = (int) vh.getAndAddRelease(array, i, 0x89ABCDEF); 1065 assertEquals(o, 0x01234567, "getAndAddReleaseint"); 1066 int x = (int) vh.get(array, i); 1067 assertEquals(x, (int)(0x01234567 + 0x89ABCDEF), "getAndAddRelease int value"); 1068 } 1069 1070 // get and bitwise or 1071 { 1072 vh.set(array, i, 0x01234567); 1073 1074 int o = (int) vh.getAndBitwiseOr(array, i, 0x89ABCDEF); 1075 assertEquals(o, 0x01234567, "getAndBitwiseOr int"); 1076 int x = (int) vh.get(array, i); 1077 assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value"); 1078 } 1079 1080 { 1081 vh.set(array, i, 0x01234567); 1082 1083 int o = (int) vh.getAndBitwiseOrAcquire(array, i, 0x89ABCDEF); 1084 assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int"); 1085 int x = (int) vh.get(array, i); 1086 assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value"); 1087 } 1088 1089 { 1090 vh.set(array, i, 0x01234567); 1091 1092 int o = (int) vh.getAndBitwiseOrRelease(array, i, 0x89ABCDEF); 1093 assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int"); 1094 int x = (int) vh.get(array, i); 1095 assertEquals(x, (int)(0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value"); 1096 } 1097 1098 // get and bitwise and 1099 { 1100 vh.set(array, i, 0x01234567); 1101 1102 int o = (int) vh.getAndBitwiseAnd(array, i, 0x89ABCDEF); 1103 assertEquals(o, 0x01234567, "getAndBitwiseAnd int"); 1104 int x = (int) vh.get(array, i); 1105 assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value"); 1106 } 1107 1108 { 1109 vh.set(array, i, 0x01234567); 1110 1111 int o = (int) vh.getAndBitwiseAndAcquire(array, i, 0x89ABCDEF); 1112 assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int"); 1113 int x = (int) vh.get(array, i); 1114 assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value"); 1115 } 1116 1117 { 1118 vh.set(array, i, 0x01234567); 1119 1120 int o = (int) vh.getAndBitwiseAndRelease(array, i, 0x89ABCDEF); 1121 assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int"); 1122 int x = (int) vh.get(array, i); 1123 assertEquals(x, (int)(0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value"); 1124 } 1125 1126 // get and bitwise xor 1127 { 1128 vh.set(array, i, 0x01234567); 1129 1130 int o = (int) vh.getAndBitwiseXor(array, i, 0x89ABCDEF); 1131 assertEquals(o, 0x01234567, "getAndBitwiseXor int"); 1132 int x = (int) vh.get(array, i); 1133 assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value"); 1134 } 1135 1136 { 1137 vh.set(array, i, 0x01234567); 1138 1139 int o = (int) vh.getAndBitwiseXorAcquire(array, i, 0x89ABCDEF); 1140 assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int"); 1141 int x = (int) vh.get(array, i); 1142 assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value"); 1143 } 1144 1145 { 1146 vh.set(array, i, 0x01234567); 1147 1148 int o = (int) vh.getAndBitwiseXorRelease(array, i, 0x89ABCDEF); 1149 assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int"); 1150 int x = (int) vh.get(array, i); 1151 assertEquals(x, (int)(0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value"); 1152 } 1153 } 1154 } 1155 1156 static void testArrayUnsupported(VarHandle vh) { 1157 int[] array = new int[10]; 1158 1159 int i = 0; 1160 1161 1162 } 1163 1164 static void testArrayIndexOutOfBounds(VarHandle vh) throws Throwable { 1165 int[] array = new int[10]; 1166 1167 for (int i : new int[]{-1, Integer.MIN_VALUE, 10, 11, Integer.MAX_VALUE}) { 1168 final int ci = i; 1169 1170 checkIOOBE(() -> { 1171 int x = (int) vh.get(array, ci); 1172 }); 1173 1174 checkIOOBE(() -> { 1175 vh.set(array, ci, 0x01234567); 1176 }); 1177 1178 checkIOOBE(() -> { 1179 int x = (int) vh.getVolatile(array, ci); 1180 }); 1181 1182 checkIOOBE(() -> { 1183 vh.setVolatile(array, ci, 0x01234567); 1184 }); 1185 1186 checkIOOBE(() -> { 1187 int x = (int) vh.getAcquire(array, ci); 1188 }); 1189 1190 checkIOOBE(() -> { 1191 vh.setRelease(array, ci, 0x01234567); 1192 }); 1193 1194 checkIOOBE(() -> { 1195 int x = (int) vh.getOpaque(array, ci); 1196 }); 1197 1198 checkIOOBE(() -> { 1199 vh.setOpaque(array, ci, 0x01234567); 1200 }); 1201 1202 checkIOOBE(() -> { 1203 boolean r = vh.compareAndSet(array, ci, 0x01234567, 0x89ABCDEF); 1204 }); 1205 1206 checkIOOBE(() -> { 1207 int r = (int) vh.compareAndExchange(array, ci, 0x89ABCDEF, 0x01234567); 1208 }); 1209 1210 checkIOOBE(() -> { 1211 int r = (int) vh.compareAndExchangeAcquire(array, ci, 0x89ABCDEF, 0x01234567); 1212 }); 1213 1214 checkIOOBE(() -> { 1215 int r = (int) vh.compareAndExchangeRelease(array, ci, 0x89ABCDEF, 0x01234567); 1216 }); 1217 1218 checkIOOBE(() -> { 1219 boolean r = vh.weakCompareAndSetPlain(array, ci, 0x01234567, 0x89ABCDEF); 1220 }); 1221 1222 checkIOOBE(() -> { 1223 boolean r = vh.weakCompareAndSet(array, ci, 0x01234567, 0x89ABCDEF); 1224 }); 1225 1226 checkIOOBE(() -> { 1227 boolean r = vh.weakCompareAndSetAcquire(array, ci, 0x01234567, 0x89ABCDEF); 1228 }); 1229 1230 checkIOOBE(() -> { 1231 boolean r = vh.weakCompareAndSetRelease(array, ci, 0x01234567, 0x89ABCDEF); 1232 }); 1233 1234 checkIOOBE(() -> { 1235 int o = (int) vh.getAndSet(array, ci, 0x01234567); 1236 }); 1237 1238 checkIOOBE(() -> { 1239 int o = (int) vh.getAndSetAcquire(array, ci, 0x01234567); 1240 }); 1241 1242 checkIOOBE(() -> { 1243 int o = (int) vh.getAndSetRelease(array, ci, 0x01234567); 1244 }); 1245 1246 checkIOOBE(() -> { 1247 int o = (int) vh.getAndAdd(array, ci, 0x01234567); 1248 }); 1249 1250 checkIOOBE(() -> { 1251 int o = (int) vh.getAndAddAcquire(array, ci, 0x01234567); 1252 }); 1253 1254 checkIOOBE(() -> { 1255 int o = (int) vh.getAndAddRelease(array, ci, 0x01234567); 1256 }); 1257 1258 checkIOOBE(() -> { 1259 int o = (int) vh.getAndBitwiseOr(array, ci, 0x01234567); 1260 }); 1261 1262 checkIOOBE(() -> { 1263 int o = (int) vh.getAndBitwiseOrAcquire(array, ci, 0x01234567); 1264 }); 1265 1266 checkIOOBE(() -> { 1267 int o = (int) vh.getAndBitwiseOrRelease(array, ci, 0x01234567); 1268 }); 1269 1270 checkIOOBE(() -> { 1271 int o = (int) vh.getAndBitwiseAnd(array, ci, 0x01234567); 1272 }); 1273 1274 checkIOOBE(() -> { 1275 int o = (int) vh.getAndBitwiseAndAcquire(array, ci, 0x01234567); 1276 }); 1277 1278 checkIOOBE(() -> { 1279 int o = (int) vh.getAndBitwiseAndRelease(array, ci, 0x01234567); 1280 }); 1281 1282 checkIOOBE(() -> { 1283 int o = (int) vh.getAndBitwiseXor(array, ci, 0x01234567); 1284 }); 1285 1286 checkIOOBE(() -> { 1287 int o = (int) vh.getAndBitwiseXorAcquire(array, ci, 0x01234567); 1288 }); 1289 1290 checkIOOBE(() -> { 1291 int o = (int) vh.getAndBitwiseXorRelease(array, ci, 0x01234567); 1292 }); 1293 } 1294 } 1295 } 1296