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 // -- This file was mechanically generated: Do not edit! -- // 25 26 /* 27 * @test 28 * @bug 8156486 8207257 29 * @run testng/othervm -XX:+EnableValhalla VarHandleTestMethodTypeBoolean 30 * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false 31 * -XX:+EnableValhalla VarHandleTestMethodTypeBoolean 32 */ 33 34 import org.testng.annotations.BeforeClass; 35 import org.testng.annotations.DataProvider; 36 import org.testng.annotations.Test; 37 38 import java.lang.invoke.MethodHandles; 39 import java.lang.invoke.VarHandle; 40 import java.util.ArrayList; 41 import java.util.Arrays; 42 import java.util.List; 43 44 import static org.testng.Assert.*; 45 46 import static java.lang.invoke.MethodType.*; 47 48 public class VarHandleTestMethodTypeBoolean extends VarHandleBaseTest { 49 static final boolean static_final_v = true; 50 51 static boolean static_v = true; 52 53 final boolean final_v = true; 54 55 boolean v = true; 56 57 VarHandle vhFinalField; 58 59 VarHandle vhField; 60 61 VarHandle vhStaticField; 62 63 VarHandle vhStaticFinalField; 64 65 VarHandle vhArray; 66 67 @BeforeClass 68 public void setup() throws Exception { 69 vhFinalField = MethodHandles.lookup().findVarHandle( 70 VarHandleTestMethodTypeBoolean.class, "final_v", boolean.class); 71 72 vhField = MethodHandles.lookup().findVarHandle( 73 VarHandleTestMethodTypeBoolean.class, "v", boolean.class); 74 75 vhStaticFinalField = MethodHandles.lookup().findStaticVarHandle( 76 VarHandleTestMethodTypeBoolean.class, "static_final_v", boolean.class); 77 78 vhStaticField = MethodHandles.lookup().findStaticVarHandle( 79 VarHandleTestMethodTypeBoolean.class, "static_v", boolean.class); 80 81 vhArray = MethodHandles.arrayElementVarHandle(boolean[].class); 82 } 83 84 @DataProvider 85 public Object[][] accessTestCaseProvider() throws Exception { 86 List<AccessTestCase<?>> cases = new ArrayList<>(); 87 88 cases.add(new VarHandleAccessTestCase("Instance field", 89 vhField, vh -> testInstanceFieldWrongMethodType(this, vh), 90 false)); 91 92 cases.add(new VarHandleAccessTestCase("Static field", 93 vhStaticField, VarHandleTestMethodTypeBoolean::testStaticFieldWrongMethodType, 94 false)); 95 96 cases.add(new VarHandleAccessTestCase("Array", 97 vhArray, VarHandleTestMethodTypeBoolean::testArrayWrongMethodType, 98 false)); 99 100 for (VarHandleToMethodHandle f : VarHandleToMethodHandle.values()) { 101 cases.add(new MethodHandleAccessTestCase("Instance field", 102 vhField, f, hs -> testInstanceFieldWrongMethodType(this, hs), 103 false)); 104 105 cases.add(new MethodHandleAccessTestCase("Static field", 106 vhStaticField, f, VarHandleTestMethodTypeBoolean::testStaticFieldWrongMethodType, 107 false)); 108 109 cases.add(new MethodHandleAccessTestCase("Array", 110 vhArray, f, VarHandleTestMethodTypeBoolean::testArrayWrongMethodType, 111 false)); 112 } 113 // Work around issue with jtreg summary reporting which truncates 114 // the String result of Object.toString to 30 characters, hence 115 // the first dummy argument 116 return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); 117 } 118 119 @Test(dataProvider = "accessTestCaseProvider") 120 public <T> void testAccess(String desc, AccessTestCase<T> atc) throws Throwable { 121 T t = atc.get(); 122 int iters = atc.requiresLoop() ? ITERS : 1; 123 for (int c = 0; c < iters; c++) { 124 atc.testAccess(t); 125 } 126 } 127 128 129 static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeBoolean recv, VarHandle vh) throws Throwable { 130 // Get 131 // Incorrect argument types 132 checkNPE(() -> { // null receiver 133 boolean x = (boolean) vh.get(null); 134 }); 135 checkCCE(() -> { // receiver reference class 136 boolean x = (boolean) vh.get(Void.class); 137 }); 138 checkWMTE(() -> { // receiver primitive class 139 boolean x = (boolean) vh.get(0); 140 }); 141 // Incorrect return type 142 checkWMTE(() -> { // reference class 143 Void x = (Void) vh.get(recv); 144 }); 145 checkWMTE(() -> { // primitive class 146 int x = (int) vh.get(recv); 147 }); 148 // Incorrect arity 149 checkWMTE(() -> { // 0 150 boolean x = (boolean) vh.get(); 151 }); 152 checkWMTE(() -> { // > 153 boolean x = (boolean) vh.get(recv, Void.class); 154 }); 155 156 157 // Set 158 // Incorrect argument types 159 checkNPE(() -> { // null receiver 160 vh.set(null, true); 161 }); 162 checkCCE(() -> { // receiver reference class 163 vh.set(Void.class, true); 164 }); 165 checkWMTE(() -> { // value reference class 166 vh.set(recv, Void.class); 167 }); 168 checkWMTE(() -> { // receiver primitive class 169 vh.set(0, true); 170 }); 171 // Incorrect arity 172 checkWMTE(() -> { // 0 173 vh.set(); 174 }); 175 checkWMTE(() -> { // > 176 vh.set(recv, true, Void.class); 177 }); 178 179 180 // GetVolatile 181 // Incorrect argument types 182 checkNPE(() -> { // null receiver 183 boolean x = (boolean) vh.getVolatile(null); 184 }); 185 checkCCE(() -> { // receiver reference class 186 boolean x = (boolean) vh.getVolatile(Void.class); 187 }); 188 checkWMTE(() -> { // receiver primitive class 189 boolean x = (boolean) vh.getVolatile(0); 190 }); 191 // Incorrect return type 192 checkWMTE(() -> { // reference class 193 Void x = (Void) vh.getVolatile(recv); 194 }); 195 checkWMTE(() -> { // primitive class 196 int x = (int) vh.getVolatile(recv); 197 }); 198 // Incorrect arity 199 checkWMTE(() -> { // 0 200 boolean x = (boolean) vh.getVolatile(); 201 }); 202 checkWMTE(() -> { // > 203 boolean x = (boolean) vh.getVolatile(recv, Void.class); 204 }); 205 206 207 // SetVolatile 208 // Incorrect argument types 209 checkNPE(() -> { // null receiver 210 vh.setVolatile(null, true); 211 }); 212 checkCCE(() -> { // receiver reference class 213 vh.setVolatile(Void.class, true); 214 }); 215 checkWMTE(() -> { // value reference class 216 vh.setVolatile(recv, Void.class); 217 }); 218 checkWMTE(() -> { // receiver primitive class 219 vh.setVolatile(0, true); 220 }); 221 // Incorrect arity 222 checkWMTE(() -> { // 0 223 vh.setVolatile(); 224 }); 225 checkWMTE(() -> { // > 226 vh.setVolatile(recv, true, Void.class); 227 }); 228 229 230 // GetOpaque 231 // Incorrect argument types 232 checkNPE(() -> { // null receiver 233 boolean x = (boolean) vh.getOpaque(null); 234 }); 235 checkCCE(() -> { // receiver reference class 236 boolean x = (boolean) vh.getOpaque(Void.class); 237 }); 238 checkWMTE(() -> { // receiver primitive class 239 boolean x = (boolean) vh.getOpaque(0); 240 }); 241 // Incorrect return type 242 checkWMTE(() -> { // reference class 243 Void x = (Void) vh.getOpaque(recv); 244 }); 245 checkWMTE(() -> { // primitive class 246 int x = (int) vh.getOpaque(recv); 247 }); 248 // Incorrect arity 249 checkWMTE(() -> { // 0 250 boolean x = (boolean) vh.getOpaque(); 251 }); 252 checkWMTE(() -> { // > 253 boolean x = (boolean) vh.getOpaque(recv, Void.class); 254 }); 255 256 257 // SetOpaque 258 // Incorrect argument types 259 checkNPE(() -> { // null receiver 260 vh.setOpaque(null, true); 261 }); 262 checkCCE(() -> { // receiver reference class 263 vh.setOpaque(Void.class, true); 264 }); 265 checkWMTE(() -> { // value reference class 266 vh.setOpaque(recv, Void.class); 267 }); 268 checkWMTE(() -> { // receiver primitive class 269 vh.setOpaque(0, true); 270 }); 271 // Incorrect arity 272 checkWMTE(() -> { // 0 273 vh.setOpaque(); 274 }); 275 checkWMTE(() -> { // > 276 vh.setOpaque(recv, true, Void.class); 277 }); 278 279 280 // GetAcquire 281 // Incorrect argument types 282 checkNPE(() -> { // null receiver 283 boolean x = (boolean) vh.getAcquire(null); 284 }); 285 checkCCE(() -> { // receiver reference class 286 boolean x = (boolean) vh.getAcquire(Void.class); 287 }); 288 checkWMTE(() -> { // receiver primitive class 289 boolean x = (boolean) vh.getAcquire(0); 290 }); 291 // Incorrect return type 292 checkWMTE(() -> { // reference class 293 Void x = (Void) vh.getAcquire(recv); 294 }); 295 checkWMTE(() -> { // primitive class 296 int x = (int) vh.getAcquire(recv); 297 }); 298 // Incorrect arity 299 checkWMTE(() -> { // 0 300 boolean x = (boolean) vh.getAcquire(); 301 }); 302 checkWMTE(() -> { // > 303 boolean x = (boolean) vh.getAcquire(recv, Void.class); 304 }); 305 306 307 // SetRelease 308 // Incorrect argument types 309 checkNPE(() -> { // null receiver 310 vh.setRelease(null, true); 311 }); 312 checkCCE(() -> { // receiver reference class 313 vh.setRelease(Void.class, true); 314 }); 315 checkWMTE(() -> { // value reference class 316 vh.setRelease(recv, Void.class); 317 }); 318 checkWMTE(() -> { // receiver primitive class 319 vh.setRelease(0, true); 320 }); 321 // Incorrect arity 322 checkWMTE(() -> { // 0 323 vh.setRelease(); 324 }); 325 checkWMTE(() -> { // > 326 vh.setRelease(recv, true, Void.class); 327 }); 328 329 330 // CompareAndSet 331 // Incorrect argument types 332 checkNPE(() -> { // null receiver 333 boolean r = vh.compareAndSet(null, true, true); 334 }); 335 checkCCE(() -> { // receiver reference class 336 boolean r = vh.compareAndSet(Void.class, true, true); 337 }); 338 checkWMTE(() -> { // expected reference class 339 boolean r = vh.compareAndSet(recv, Void.class, true); 340 }); 341 checkWMTE(() -> { // actual reference class 342 boolean r = vh.compareAndSet(recv, true, Void.class); 343 }); 344 checkWMTE(() -> { // receiver primitive class 345 boolean r = vh.compareAndSet(0, true, true); 346 }); 347 // Incorrect arity 348 checkWMTE(() -> { // 0 349 boolean r = vh.compareAndSet(); 350 }); 351 checkWMTE(() -> { // > 352 boolean r = vh.compareAndSet(recv, true, true, Void.class); 353 }); 354 355 356 // WeakCompareAndSet 357 // Incorrect argument types 358 checkNPE(() -> { // null receiver 359 boolean r = vh.weakCompareAndSetPlain(null, true, true); 360 }); 361 checkCCE(() -> { // receiver reference class 362 boolean r = vh.weakCompareAndSetPlain(Void.class, true, true); 363 }); 364 checkWMTE(() -> { // expected reference class 365 boolean r = vh.weakCompareAndSetPlain(recv, Void.class, true); 366 }); 367 checkWMTE(() -> { // actual reference class 368 boolean r = vh.weakCompareAndSetPlain(recv, true, Void.class); 369 }); 370 checkWMTE(() -> { // receiver primitive class 371 boolean r = vh.weakCompareAndSetPlain(0, true, true); 372 }); 373 // Incorrect arity 374 checkWMTE(() -> { // 0 375 boolean r = vh.weakCompareAndSetPlain(); 376 }); 377 checkWMTE(() -> { // > 378 boolean r = vh.weakCompareAndSetPlain(recv, true, true, Void.class); 379 }); 380 381 382 // WeakCompareAndSetVolatile 383 // Incorrect argument types 384 checkNPE(() -> { // null receiver 385 boolean r = vh.weakCompareAndSet(null, true, true); 386 }); 387 checkCCE(() -> { // receiver reference class 388 boolean r = vh.weakCompareAndSet(Void.class, true, true); 389 }); 390 checkWMTE(() -> { // expected reference class 391 boolean r = vh.weakCompareAndSet(recv, Void.class, true); 392 }); 393 checkWMTE(() -> { // actual reference class 394 boolean r = vh.weakCompareAndSet(recv, true, Void.class); 395 }); 396 checkWMTE(() -> { // receiver primitive class 397 boolean r = vh.weakCompareAndSet(0, true, true); 398 }); 399 // Incorrect arity 400 checkWMTE(() -> { // 0 401 boolean r = vh.weakCompareAndSet(); 402 }); 403 checkWMTE(() -> { // > 404 boolean r = vh.weakCompareAndSet(recv, true, true, Void.class); 405 }); 406 407 408 // WeakCompareAndSetAcquire 409 // Incorrect argument types 410 checkNPE(() -> { // null receiver 411 boolean r = vh.weakCompareAndSetAcquire(null, true, true); 412 }); 413 checkCCE(() -> { // receiver reference class 414 boolean r = vh.weakCompareAndSetAcquire(Void.class, true, true); 415 }); 416 checkWMTE(() -> { // expected reference class 417 boolean r = vh.weakCompareAndSetAcquire(recv, Void.class, true); 418 }); 419 checkWMTE(() -> { // actual reference class 420 boolean r = vh.weakCompareAndSetAcquire(recv, true, Void.class); 421 }); 422 checkWMTE(() -> { // receiver primitive class 423 boolean r = vh.weakCompareAndSetAcquire(0, true, true); 424 }); 425 // Incorrect arity 426 checkWMTE(() -> { // 0 427 boolean r = vh.weakCompareAndSetAcquire(); 428 }); 429 checkWMTE(() -> { // > 430 boolean r = vh.weakCompareAndSetAcquire(recv, true, true, Void.class); 431 }); 432 433 434 // WeakCompareAndSetRelease 435 // Incorrect argument types 436 checkNPE(() -> { // null receiver 437 boolean r = vh.weakCompareAndSetRelease(null, true, true); 438 }); 439 checkCCE(() -> { // receiver reference class 440 boolean r = vh.weakCompareAndSetRelease(Void.class, true, true); 441 }); 442 checkWMTE(() -> { // expected reference class 443 boolean r = vh.weakCompareAndSetRelease(recv, Void.class, true); 444 }); 445 checkWMTE(() -> { // actual reference class 446 boolean r = vh.weakCompareAndSetRelease(recv, true, Void.class); 447 }); 448 checkWMTE(() -> { // receiver primitive class 449 boolean r = vh.weakCompareAndSetRelease(0, true, true); 450 }); 451 // Incorrect arity 452 checkWMTE(() -> { // 0 453 boolean r = vh.weakCompareAndSetRelease(); 454 }); 455 checkWMTE(() -> { // > 456 boolean r = vh.weakCompareAndSetRelease(recv, true, true, Void.class); 457 }); 458 459 460 // CompareAndExchange 461 // Incorrect argument types 462 checkNPE(() -> { // null receiver 463 boolean x = (boolean) vh.compareAndExchange(null, true, true); 464 }); 465 checkCCE(() -> { // receiver reference class 466 boolean x = (boolean) vh.compareAndExchange(Void.class, true, true); 467 }); 468 checkWMTE(() -> { // expected reference class 469 boolean x = (boolean) vh.compareAndExchange(recv, Void.class, true); 470 }); 471 checkWMTE(() -> { // actual reference class 472 boolean x = (boolean) vh.compareAndExchange(recv, true, Void.class); 473 }); 474 checkWMTE(() -> { // reciever primitive class 475 boolean x = (boolean) vh.compareAndExchange(0, true, true); 476 }); 477 // Incorrect return type 478 checkWMTE(() -> { // reference class 479 Void r = (Void) vh.compareAndExchange(recv, true, true); 480 }); 481 checkWMTE(() -> { // primitive class 482 int x = (int) vh.compareAndExchange(recv, true, true); 483 }); 484 // Incorrect arity 485 checkWMTE(() -> { // 0 486 boolean x = (boolean) vh.compareAndExchange(); 487 }); 488 checkWMTE(() -> { // > 489 boolean x = (boolean) vh.compareAndExchange(recv, true, true, Void.class); 490 }); 491 492 493 // CompareAndExchangeAcquire 494 // Incorrect argument types 495 checkNPE(() -> { // null receiver 496 boolean x = (boolean) vh.compareAndExchangeAcquire(null, true, true); 497 }); 498 checkCCE(() -> { // receiver reference class 499 boolean x = (boolean) vh.compareAndExchangeAcquire(Void.class, true, true); 500 }); 501 checkWMTE(() -> { // expected reference class 502 boolean x = (boolean) vh.compareAndExchangeAcquire(recv, Void.class, true); 503 }); 504 checkWMTE(() -> { // actual reference class 505 boolean x = (boolean) vh.compareAndExchangeAcquire(recv, true, Void.class); 506 }); 507 checkWMTE(() -> { // reciever primitive class 508 boolean x = (boolean) vh.compareAndExchangeAcquire(0, true, true); 509 }); 510 // Incorrect return type 511 checkWMTE(() -> { // reference class 512 Void r = (Void) vh.compareAndExchangeAcquire(recv, true, true); 513 }); 514 checkWMTE(() -> { // primitive class 515 int x = (int) vh.compareAndExchangeAcquire(recv, true, true); 516 }); 517 // Incorrect arity 518 checkWMTE(() -> { // 0 519 boolean x = (boolean) vh.compareAndExchangeAcquire(); 520 }); 521 checkWMTE(() -> { // > 522 boolean x = (boolean) vh.compareAndExchangeAcquire(recv, true, true, Void.class); 523 }); 524 525 526 // CompareAndExchangeRelease 527 // Incorrect argument types 528 checkNPE(() -> { // null receiver 529 boolean x = (boolean) vh.compareAndExchangeRelease(null, true, true); 530 }); 531 checkCCE(() -> { // receiver reference class 532 boolean x = (boolean) vh.compareAndExchangeRelease(Void.class, true, true); 533 }); 534 checkWMTE(() -> { // expected reference class 535 boolean x = (boolean) vh.compareAndExchangeRelease(recv, Void.class, true); 536 }); 537 checkWMTE(() -> { // actual reference class 538 boolean x = (boolean) vh.compareAndExchangeRelease(recv, true, Void.class); 539 }); 540 checkWMTE(() -> { // reciever primitive class 541 boolean x = (boolean) vh.compareAndExchangeRelease(0, true, true); 542 }); 543 // Incorrect return type 544 checkWMTE(() -> { // reference class 545 Void r = (Void) vh.compareAndExchangeRelease(recv, true, true); 546 }); 547 checkWMTE(() -> { // primitive class 548 int x = (int) vh.compareAndExchangeRelease(recv, true, true); 549 }); 550 // Incorrect arity 551 checkWMTE(() -> { // 0 552 boolean x = (boolean) vh.compareAndExchangeRelease(); 553 }); 554 checkWMTE(() -> { // > 555 boolean x = (boolean) vh.compareAndExchangeRelease(recv, true, true, Void.class); 556 }); 557 558 559 // GetAndSet 560 // Incorrect argument types 561 checkNPE(() -> { // null receiver 562 boolean x = (boolean) vh.getAndSet(null, true); 563 }); 564 checkCCE(() -> { // receiver reference class 565 boolean x = (boolean) vh.getAndSet(Void.class, true); 566 }); 567 checkWMTE(() -> { // value reference class 568 boolean x = (boolean) vh.getAndSet(recv, Void.class); 569 }); 570 checkWMTE(() -> { // reciever primitive class 571 boolean x = (boolean) vh.getAndSet(0, true); 572 }); 573 // Incorrect return type 574 checkWMTE(() -> { // reference class 575 Void r = (Void) vh.getAndSet(recv, true); 576 }); 577 checkWMTE(() -> { // primitive class 578 int x = (int) vh.getAndSet(recv, true); 579 }); 580 // Incorrect arity 581 checkWMTE(() -> { // 0 582 boolean x = (boolean) vh.getAndSet(); 583 }); 584 checkWMTE(() -> { // > 585 boolean x = (boolean) vh.getAndSet(recv, true, Void.class); 586 }); 587 588 // GetAndSetAcquire 589 // Incorrect argument types 590 checkNPE(() -> { // null receiver 591 boolean x = (boolean) vh.getAndSetAcquire(null, true); 592 }); 593 checkCCE(() -> { // receiver reference class 594 boolean x = (boolean) vh.getAndSetAcquire(Void.class, true); 595 }); 596 checkWMTE(() -> { // value reference class 597 boolean x = (boolean) vh.getAndSetAcquire(recv, Void.class); 598 }); 599 checkWMTE(() -> { // reciever primitive class 600 boolean x = (boolean) vh.getAndSetAcquire(0, true); 601 }); 602 // Incorrect return type 603 checkWMTE(() -> { // reference class 604 Void r = (Void) vh.getAndSetAcquire(recv, true); 605 }); 606 checkWMTE(() -> { // primitive class 607 int x = (int) vh.getAndSetAcquire(recv, true); 608 }); 609 // Incorrect arity 610 checkWMTE(() -> { // 0 611 boolean x = (boolean) vh.getAndSetAcquire(); 612 }); 613 checkWMTE(() -> { // > 614 boolean x = (boolean) vh.getAndSetAcquire(recv, true, Void.class); 615 }); 616 617 // GetAndSetRelease 618 // Incorrect argument types 619 checkNPE(() -> { // null receiver 620 boolean x = (boolean) vh.getAndSetRelease(null, true); 621 }); 622 checkCCE(() -> { // receiver reference class 623 boolean x = (boolean) vh.getAndSetRelease(Void.class, true); 624 }); 625 checkWMTE(() -> { // value reference class 626 boolean x = (boolean) vh.getAndSetRelease(recv, Void.class); 627 }); 628 checkWMTE(() -> { // reciever primitive class 629 boolean x = (boolean) vh.getAndSetRelease(0, true); 630 }); 631 // Incorrect return type 632 checkWMTE(() -> { // reference class 633 Void r = (Void) vh.getAndSetRelease(recv, true); 634 }); 635 checkWMTE(() -> { // primitive class 636 int x = (int) vh.getAndSetRelease(recv, true); 637 }); 638 // Incorrect arity 639 checkWMTE(() -> { // 0 640 boolean x = (boolean) vh.getAndSetRelease(); 641 }); 642 checkWMTE(() -> { // > 643 boolean x = (boolean) vh.getAndSetRelease(recv, true, Void.class); 644 }); 645 646 647 // GetAndBitwiseOr 648 // Incorrect argument types 649 checkNPE(() -> { // null receiver 650 boolean x = (boolean) vh.getAndBitwiseOr(null, true); 651 }); 652 checkCCE(() -> { // receiver reference class 653 boolean x = (boolean) vh.getAndBitwiseOr(Void.class, true); 654 }); 655 checkWMTE(() -> { // value reference class 656 boolean x = (boolean) vh.getAndBitwiseOr(recv, Void.class); 657 }); 658 checkWMTE(() -> { // reciever primitive class 659 boolean x = (boolean) vh.getAndBitwiseOr(0, true); 660 }); 661 // Incorrect return type 662 checkWMTE(() -> { // reference class 663 Void r = (Void) vh.getAndBitwiseOr(recv, true); 664 }); 665 checkWMTE(() -> { // primitive class 666 int x = (int) vh.getAndBitwiseOr(recv, true); 667 }); 668 // Incorrect arity 669 checkWMTE(() -> { // 0 670 boolean x = (boolean) vh.getAndBitwiseOr(); 671 }); 672 checkWMTE(() -> { // > 673 boolean x = (boolean) vh.getAndBitwiseOr(recv, true, Void.class); 674 }); 675 676 677 // GetAndBitwiseOrAcquire 678 // Incorrect argument types 679 checkNPE(() -> { // null receiver 680 boolean x = (boolean) vh.getAndBitwiseOrAcquire(null, true); 681 }); 682 checkCCE(() -> { // receiver reference class 683 boolean x = (boolean) vh.getAndBitwiseOrAcquire(Void.class, true); 684 }); 685 checkWMTE(() -> { // value reference class 686 boolean x = (boolean) vh.getAndBitwiseOrAcquire(recv, Void.class); 687 }); 688 checkWMTE(() -> { // reciever primitive class 689 boolean x = (boolean) vh.getAndBitwiseOrAcquire(0, true); 690 }); 691 // Incorrect return type 692 checkWMTE(() -> { // reference class 693 Void r = (Void) vh.getAndBitwiseOrAcquire(recv, true); 694 }); 695 checkWMTE(() -> { // primitive class 696 int x = (int) vh.getAndBitwiseOrAcquire(recv, true); 697 }); 698 // Incorrect arity 699 checkWMTE(() -> { // 0 700 boolean x = (boolean) vh.getAndBitwiseOrAcquire(); 701 }); 702 checkWMTE(() -> { // > 703 boolean x = (boolean) vh.getAndBitwiseOrAcquire(recv, true, Void.class); 704 }); 705 706 707 // GetAndBitwiseOrRelease 708 // Incorrect argument types 709 checkNPE(() -> { // null receiver 710 boolean x = (boolean) vh.getAndBitwiseOrRelease(null, true); 711 }); 712 checkCCE(() -> { // receiver reference class 713 boolean x = (boolean) vh.getAndBitwiseOr(Void.class, true); 714 }); 715 checkWMTE(() -> { // value reference class 716 boolean x = (boolean) vh.getAndBitwiseOr(recv, Void.class); 717 }); 718 checkWMTE(() -> { // reciever primitive class 719 boolean x = (boolean) vh.getAndBitwiseOr(0, true); 720 }); 721 // Incorrect return type 722 checkWMTE(() -> { // reference class 723 Void r = (Void) vh.getAndBitwiseOr(recv, true); 724 }); 725 checkWMTE(() -> { // primitive class 726 int x = (int) vh.getAndBitwiseOr(recv, true); 727 }); 728 // Incorrect arity 729 checkWMTE(() -> { // 0 730 boolean x = (boolean) vh.getAndBitwiseOr(); 731 }); 732 checkWMTE(() -> { // > 733 boolean x = (boolean) vh.getAndBitwiseOr(recv, true, Void.class); 734 }); 735 736 737 // GetAndBitwiseAnd 738 // Incorrect argument types 739 checkNPE(() -> { // null receiver 740 boolean x = (boolean) vh.getAndBitwiseAnd(null, true); 741 }); 742 checkCCE(() -> { // receiver reference class 743 boolean x = (boolean) vh.getAndBitwiseAnd(Void.class, true); 744 }); 745 checkWMTE(() -> { // value reference class 746 boolean x = (boolean) vh.getAndBitwiseAnd(recv, Void.class); 747 }); 748 checkWMTE(() -> { // reciever primitive class 749 boolean x = (boolean) vh.getAndBitwiseAnd(0, true); 750 }); 751 // Incorrect return type 752 checkWMTE(() -> { // reference class 753 Void r = (Void) vh.getAndBitwiseAnd(recv, true); 754 }); 755 checkWMTE(() -> { // primitive class 756 int x = (int) vh.getAndBitwiseAnd(recv, true); 757 }); 758 // Incorrect arity 759 checkWMTE(() -> { // 0 760 boolean x = (boolean) vh.getAndBitwiseAnd(); 761 }); 762 checkWMTE(() -> { // > 763 boolean x = (boolean) vh.getAndBitwiseAnd(recv, true, Void.class); 764 }); 765 766 767 // GetAndBitwiseAndAcquire 768 // Incorrect argument types 769 checkNPE(() -> { // null receiver 770 boolean x = (boolean) vh.getAndBitwiseAndAcquire(null, true); 771 }); 772 checkCCE(() -> { // receiver reference class 773 boolean x = (boolean) vh.getAndBitwiseAndAcquire(Void.class, true); 774 }); 775 checkWMTE(() -> { // value reference class 776 boolean x = (boolean) vh.getAndBitwiseAndAcquire(recv, Void.class); 777 }); 778 checkWMTE(() -> { // reciever primitive class 779 boolean x = (boolean) vh.getAndBitwiseAndAcquire(0, true); 780 }); 781 // Incorrect return type 782 checkWMTE(() -> { // reference class 783 Void r = (Void) vh.getAndBitwiseAndAcquire(recv, true); 784 }); 785 checkWMTE(() -> { // primitive class 786 int x = (int) vh.getAndBitwiseAndAcquire(recv, true); 787 }); 788 // Incorrect arity 789 checkWMTE(() -> { // 0 790 boolean x = (boolean) vh.getAndBitwiseAndAcquire(); 791 }); 792 checkWMTE(() -> { // > 793 boolean x = (boolean) vh.getAndBitwiseAndAcquire(recv, true, Void.class); 794 }); 795 796 797 // GetAndBitwiseAndRelease 798 // Incorrect argument types 799 checkNPE(() -> { // null receiver 800 boolean x = (boolean) vh.getAndBitwiseAndRelease(null, true); 801 }); 802 checkCCE(() -> { // receiver reference class 803 boolean x = (boolean) vh.getAndBitwiseAnd(Void.class, true); 804 }); 805 checkWMTE(() -> { // value reference class 806 boolean x = (boolean) vh.getAndBitwiseAnd(recv, Void.class); 807 }); 808 checkWMTE(() -> { // reciever primitive class 809 boolean x = (boolean) vh.getAndBitwiseAnd(0, true); 810 }); 811 // Incorrect return type 812 checkWMTE(() -> { // reference class 813 Void r = (Void) vh.getAndBitwiseAnd(recv, true); 814 }); 815 checkWMTE(() -> { // primitive class 816 int x = (int) vh.getAndBitwiseAnd(recv, true); 817 }); 818 // Incorrect arity 819 checkWMTE(() -> { // 0 820 boolean x = (boolean) vh.getAndBitwiseAnd(); 821 }); 822 checkWMTE(() -> { // > 823 boolean x = (boolean) vh.getAndBitwiseAnd(recv, true, Void.class); 824 }); 825 826 827 // GetAndBitwiseXor 828 // Incorrect argument types 829 checkNPE(() -> { // null receiver 830 boolean x = (boolean) vh.getAndBitwiseXor(null, true); 831 }); 832 checkCCE(() -> { // receiver reference class 833 boolean x = (boolean) vh.getAndBitwiseXor(Void.class, true); 834 }); 835 checkWMTE(() -> { // value reference class 836 boolean x = (boolean) vh.getAndBitwiseXor(recv, Void.class); 837 }); 838 checkWMTE(() -> { // reciever primitive class 839 boolean x = (boolean) vh.getAndBitwiseXor(0, true); 840 }); 841 // Incorrect return type 842 checkWMTE(() -> { // reference class 843 Void r = (Void) vh.getAndBitwiseXor(recv, true); 844 }); 845 checkWMTE(() -> { // primitive class 846 int x = (int) vh.getAndBitwiseXor(recv, true); 847 }); 848 // Incorrect arity 849 checkWMTE(() -> { // 0 850 boolean x = (boolean) vh.getAndBitwiseXor(); 851 }); 852 checkWMTE(() -> { // > 853 boolean x = (boolean) vh.getAndBitwiseXor(recv, true, Void.class); 854 }); 855 856 857 // GetAndBitwiseXorAcquire 858 // Incorrect argument types 859 checkNPE(() -> { // null receiver 860 boolean x = (boolean) vh.getAndBitwiseXorAcquire(null, true); 861 }); 862 checkCCE(() -> { // receiver reference class 863 boolean x = (boolean) vh.getAndBitwiseXorAcquire(Void.class, true); 864 }); 865 checkWMTE(() -> { // value reference class 866 boolean x = (boolean) vh.getAndBitwiseXorAcquire(recv, Void.class); 867 }); 868 checkWMTE(() -> { // reciever primitive class 869 boolean x = (boolean) vh.getAndBitwiseXorAcquire(0, true); 870 }); 871 // Incorrect return type 872 checkWMTE(() -> { // reference class 873 Void r = (Void) vh.getAndBitwiseXorAcquire(recv, true); 874 }); 875 checkWMTE(() -> { // primitive class 876 int x = (int) vh.getAndBitwiseXorAcquire(recv, true); 877 }); 878 // Incorrect arity 879 checkWMTE(() -> { // 0 880 boolean x = (boolean) vh.getAndBitwiseXorAcquire(); 881 }); 882 checkWMTE(() -> { // > 883 boolean x = (boolean) vh.getAndBitwiseXorAcquire(recv, true, Void.class); 884 }); 885 886 887 // GetAndBitwiseXorRelease 888 // Incorrect argument types 889 checkNPE(() -> { // null receiver 890 boolean x = (boolean) vh.getAndBitwiseXorRelease(null, true); 891 }); 892 checkCCE(() -> { // receiver reference class 893 boolean x = (boolean) vh.getAndBitwiseXor(Void.class, true); 894 }); 895 checkWMTE(() -> { // value reference class 896 boolean x = (boolean) vh.getAndBitwiseXor(recv, Void.class); 897 }); 898 checkWMTE(() -> { // reciever primitive class 899 boolean x = (boolean) vh.getAndBitwiseXor(0, true); 900 }); 901 // Incorrect return type 902 checkWMTE(() -> { // reference class 903 Void r = (Void) vh.getAndBitwiseXor(recv, true); 904 }); 905 checkWMTE(() -> { // primitive class 906 int x = (int) vh.getAndBitwiseXor(recv, true); 907 }); 908 // Incorrect arity 909 checkWMTE(() -> { // 0 910 boolean x = (boolean) vh.getAndBitwiseXor(); 911 }); 912 checkWMTE(() -> { // > 913 boolean x = (boolean) vh.getAndBitwiseXor(recv, true, Void.class); 914 }); 915 } 916 917 static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeBoolean recv, Handles hs) throws Throwable { 918 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) { 919 // Incorrect argument types 920 checkNPE(() -> { // null receiver 921 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class)). 922 invokeExact((VarHandleTestMethodTypeBoolean) null); 923 }); 924 hs.checkWMTEOrCCE(() -> { // receiver reference class 925 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class)). 926 invokeExact(Void.class); 927 }); 928 checkWMTE(() -> { // receiver primitive class 929 boolean x = (boolean) hs.get(am, methodType(boolean.class, int.class)). 930 invokeExact(0); 931 }); 932 // Incorrect return type 933 checkWMTE(() -> { // reference class 934 Void x = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodTypeBoolean.class)). 935 invokeExact(recv); 936 }); 937 checkWMTE(() -> { // primitive class 938 int x = (int) hs.get(am, methodType(int.class, VarHandleTestMethodTypeBoolean.class)). 939 invokeExact(recv); 940 }); 941 // Incorrect arity 942 checkWMTE(() -> { // 0 943 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 944 invokeExact(); 945 }); 946 checkWMTE(() -> { // > 947 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, Class.class)). 948 invokeExact(recv, Void.class); 949 }); 950 } 951 952 for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) { 953 // Incorrect argument types 954 checkNPE(() -> { // null receiver 955 hs.get(am, methodType(void.class, VarHandleTestMethodTypeBoolean.class, boolean.class)). 956 invokeExact((VarHandleTestMethodTypeBoolean) null, true); 957 }); 958 hs.checkWMTEOrCCE(() -> { // receiver reference class 959 hs.get(am, methodType(void.class, Class.class, boolean.class)). 960 invokeExact(Void.class, true); 961 }); 962 checkWMTE(() -> { // value reference class 963 hs.get(am, methodType(void.class, VarHandleTestMethodTypeBoolean.class, Class.class)). 964 invokeExact(recv, Void.class); 965 }); 966 checkWMTE(() -> { // receiver primitive class 967 hs.get(am, methodType(void.class, int.class, boolean.class)). 968 invokeExact(0, true); 969 }); 970 // Incorrect arity 971 checkWMTE(() -> { // 0 972 hs.get(am, methodType(void.class)). 973 invokeExact(); 974 }); 975 checkWMTE(() -> { // > 976 hs.get(am, methodType(void.class, VarHandleTestMethodTypeBoolean.class, boolean.class, Class.class)). 977 invokeExact(recv, true, Void.class); 978 }); 979 } 980 981 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) { 982 // Incorrect argument types 983 checkNPE(() -> { // null receiver 984 boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class, boolean.class)). 985 invokeExact((VarHandleTestMethodTypeBoolean) null, true, true); 986 }); 987 hs.checkWMTEOrCCE(() -> { // receiver reference class 988 boolean r = (boolean) hs.get(am, methodType(boolean.class, Class.class, boolean.class, boolean.class)). 989 invokeExact(Void.class, true, true); 990 }); 991 checkWMTE(() -> { // expected reference class 992 boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, Class.class, boolean.class)). 993 invokeExact(recv, Void.class, true); 994 }); 995 checkWMTE(() -> { // actual reference class 996 boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class, Class.class)). 997 invokeExact(recv, true, Void.class); 998 }); 999 checkWMTE(() -> { // receiver primitive class 1000 boolean r = (boolean) hs.get(am, methodType(boolean.class, int.class , boolean.class, boolean.class)). 1001 invokeExact(0, true, true); 1002 }); 1003 // Incorrect arity 1004 checkWMTE(() -> { // 0 1005 boolean r = (boolean) hs.get(am, methodType(boolean.class)). 1006 invokeExact(); 1007 }); 1008 checkWMTE(() -> { // > 1009 boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class, boolean.class, Class.class)). 1010 invokeExact(recv, true, true, Void.class); 1011 }); 1012 } 1013 1014 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) { 1015 checkNPE(() -> { // null receiver 1016 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class, boolean.class)). 1017 invokeExact((VarHandleTestMethodTypeBoolean) null, true, true); 1018 }); 1019 hs.checkWMTEOrCCE(() -> { // receiver reference class 1020 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class, boolean.class, boolean.class)). 1021 invokeExact(Void.class, true, true); 1022 }); 1023 checkWMTE(() -> { // expected reference class 1024 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, Class.class, boolean.class)). 1025 invokeExact(recv, Void.class, true); 1026 }); 1027 checkWMTE(() -> { // actual reference class 1028 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class, Class.class)). 1029 invokeExact(recv, true, Void.class); 1030 }); 1031 checkWMTE(() -> { // reciever primitive class 1032 boolean x = (boolean) hs.get(am, methodType(boolean.class, int.class , boolean.class, boolean.class)). 1033 invokeExact(0, true, true); 1034 }); 1035 // Incorrect return type 1036 checkWMTE(() -> { // reference class 1037 Void r = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodTypeBoolean.class , boolean.class, boolean.class)). 1038 invokeExact(recv, true, true); 1039 }); 1040 checkWMTE(() -> { // primitive class 1041 int x = (int) hs.get(am, methodType(int.class, VarHandleTestMethodTypeBoolean.class , boolean.class, boolean.class)). 1042 invokeExact(recv, true, true); 1043 }); 1044 // Incorrect arity 1045 checkWMTE(() -> { // 0 1046 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 1047 invokeExact(); 1048 }); 1049 checkWMTE(() -> { // > 1050 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class, boolean.class, Class.class)). 1051 invokeExact(recv, true, true, Void.class); 1052 }); 1053 } 1054 1055 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) { 1056 checkNPE(() -> { // null receiver 1057 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class)). 1058 invokeExact((VarHandleTestMethodTypeBoolean) null, true); 1059 }); 1060 hs.checkWMTEOrCCE(() -> { // receiver reference class 1061 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class, boolean.class)). 1062 invokeExact(Void.class, true); 1063 }); 1064 checkWMTE(() -> { // value reference class 1065 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, Class.class)). 1066 invokeExact(recv, Void.class); 1067 }); 1068 checkWMTE(() -> { // reciever primitive class 1069 boolean x = (boolean) hs.get(am, methodType(boolean.class, int.class, boolean.class)). 1070 invokeExact(0, true); 1071 }); 1072 // Incorrect return type 1073 checkWMTE(() -> { // reference class 1074 Void r = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodTypeBoolean.class, boolean.class)). 1075 invokeExact(recv, true); 1076 }); 1077 checkWMTE(() -> { // primitive class 1078 int x = (int) hs.get(am, methodType(int.class, VarHandleTestMethodTypeBoolean.class, boolean.class)). 1079 invokeExact(recv, true); 1080 }); 1081 // Incorrect arity 1082 checkWMTE(() -> { // 0 1083 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 1084 invokeExact(); 1085 }); 1086 checkWMTE(() -> { // > 1087 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class)). 1088 invokeExact(recv, true, Void.class); 1089 }); 1090 } 1091 1092 1093 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) { 1094 checkNPE(() -> { // null receiver 1095 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class)). 1096 invokeExact((VarHandleTestMethodTypeBoolean) null, true); 1097 }); 1098 hs.checkWMTEOrCCE(() -> { // receiver reference class 1099 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class, boolean.class)). 1100 invokeExact(Void.class, true); 1101 }); 1102 checkWMTE(() -> { // value reference class 1103 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, Class.class)). 1104 invokeExact(recv, Void.class); 1105 }); 1106 checkWMTE(() -> { // reciever primitive class 1107 boolean x = (boolean) hs.get(am, methodType(boolean.class, int.class, boolean.class)). 1108 invokeExact(0, true); 1109 }); 1110 // Incorrect return type 1111 checkWMTE(() -> { // reference class 1112 Void r = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodTypeBoolean.class, boolean.class)). 1113 invokeExact(recv, true); 1114 }); 1115 checkWMTE(() -> { // primitive class 1116 int x = (int) hs.get(am, methodType(int.class, VarHandleTestMethodTypeBoolean.class, boolean.class)). 1117 invokeExact(recv, true); 1118 }); 1119 // Incorrect arity 1120 checkWMTE(() -> { // 0 1121 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 1122 invokeExact(); 1123 }); 1124 checkWMTE(() -> { // > 1125 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class)). 1126 invokeExact(recv, true, Void.class); 1127 }); 1128 } 1129 } 1130 1131 1132 static void testStaticFieldWrongMethodType(VarHandle vh) throws Throwable { 1133 // Get 1134 // Incorrect return type 1135 checkWMTE(() -> { // reference class 1136 Void x = (Void) vh.get(); 1137 }); 1138 checkWMTE(() -> { // primitive class 1139 int x = (int) vh.get(); 1140 }); 1141 // Incorrect arity 1142 checkWMTE(() -> { // > 1143 boolean x = (boolean) vh.get(Void.class); 1144 }); 1145 1146 1147 // Set 1148 // Incorrect argument types 1149 checkWMTE(() -> { // value reference class 1150 vh.set(Void.class); 1151 }); 1152 // Incorrect arity 1153 checkWMTE(() -> { // 0 1154 vh.set(); 1155 }); 1156 checkWMTE(() -> { // > 1157 vh.set(true, Void.class); 1158 }); 1159 1160 1161 // GetVolatile 1162 // Incorrect return type 1163 checkWMTE(() -> { // reference class 1164 Void x = (Void) vh.getVolatile(); 1165 }); 1166 checkWMTE(() -> { // primitive class 1167 int x = (int) vh.getVolatile(); 1168 }); 1169 checkWMTE(() -> { // > 1170 boolean x = (boolean) vh.getVolatile(Void.class); 1171 }); 1172 1173 1174 // SetVolatile 1175 // Incorrect argument types 1176 checkWMTE(() -> { // value reference class 1177 vh.setVolatile(Void.class); 1178 }); 1179 // Incorrect arity 1180 checkWMTE(() -> { // 0 1181 vh.setVolatile(); 1182 }); 1183 checkWMTE(() -> { // > 1184 vh.setVolatile(true, Void.class); 1185 }); 1186 1187 1188 // GetOpaque 1189 // Incorrect return type 1190 checkWMTE(() -> { // reference class 1191 Void x = (Void) vh.getOpaque(); 1192 }); 1193 checkWMTE(() -> { // primitive class 1194 int x = (int) vh.getOpaque(); 1195 }); 1196 checkWMTE(() -> { // > 1197 boolean x = (boolean) vh.getOpaque(Void.class); 1198 }); 1199 1200 1201 // SetOpaque 1202 // Incorrect argument types 1203 checkWMTE(() -> { // value reference class 1204 vh.setOpaque(Void.class); 1205 }); 1206 // Incorrect arity 1207 checkWMTE(() -> { // 0 1208 vh.setOpaque(); 1209 }); 1210 checkWMTE(() -> { // > 1211 vh.setOpaque(true, Void.class); 1212 }); 1213 1214 1215 // GetAcquire 1216 // Incorrect return type 1217 checkWMTE(() -> { // reference class 1218 Void x = (Void) vh.getAcquire(); 1219 }); 1220 checkWMTE(() -> { // primitive class 1221 int x = (int) vh.getAcquire(); 1222 }); 1223 checkWMTE(() -> { // > 1224 boolean x = (boolean) vh.getAcquire(Void.class); 1225 }); 1226 1227 1228 // SetRelease 1229 // Incorrect argument types 1230 checkWMTE(() -> { // value reference class 1231 vh.setRelease(Void.class); 1232 }); 1233 // Incorrect arity 1234 checkWMTE(() -> { // 0 1235 vh.setRelease(); 1236 }); 1237 checkWMTE(() -> { // > 1238 vh.setRelease(true, Void.class); 1239 }); 1240 1241 1242 // CompareAndSet 1243 // Incorrect argument types 1244 checkWMTE(() -> { // expected reference class 1245 boolean r = vh.compareAndSet(Void.class, true); 1246 }); 1247 checkWMTE(() -> { // actual reference class 1248 boolean r = vh.compareAndSet(true, Void.class); 1249 }); 1250 // Incorrect arity 1251 checkWMTE(() -> { // 0 1252 boolean r = vh.compareAndSet(); 1253 }); 1254 checkWMTE(() -> { // > 1255 boolean r = vh.compareAndSet(true, true, Void.class); 1256 }); 1257 1258 1259 // WeakCompareAndSet 1260 // Incorrect argument types 1261 checkWMTE(() -> { // expected reference class 1262 boolean r = vh.weakCompareAndSetPlain(Void.class, true); 1263 }); 1264 checkWMTE(() -> { // actual reference class 1265 boolean r = vh.weakCompareAndSetPlain(true, Void.class); 1266 }); 1267 // Incorrect arity 1268 checkWMTE(() -> { // 0 1269 boolean r = vh.weakCompareAndSetPlain(); 1270 }); 1271 checkWMTE(() -> { // > 1272 boolean r = vh.weakCompareAndSetPlain(true, true, Void.class); 1273 }); 1274 1275 1276 // WeakCompareAndSetVolatile 1277 // Incorrect argument types 1278 checkWMTE(() -> { // expected reference class 1279 boolean r = vh.weakCompareAndSet(Void.class, true); 1280 }); 1281 checkWMTE(() -> { // actual reference class 1282 boolean r = vh.weakCompareAndSet(true, Void.class); 1283 }); 1284 // Incorrect arity 1285 checkWMTE(() -> { // 0 1286 boolean r = vh.weakCompareAndSet(); 1287 }); 1288 checkWMTE(() -> { // > 1289 boolean r = vh.weakCompareAndSet(true, true, Void.class); 1290 }); 1291 1292 1293 // WeakCompareAndSetAcquire 1294 // Incorrect argument types 1295 checkWMTE(() -> { // expected reference class 1296 boolean r = vh.weakCompareAndSetAcquire(Void.class, true); 1297 }); 1298 checkWMTE(() -> { // actual reference class 1299 boolean r = vh.weakCompareAndSetAcquire(true, Void.class); 1300 }); 1301 // Incorrect arity 1302 checkWMTE(() -> { // 0 1303 boolean r = vh.weakCompareAndSetAcquire(); 1304 }); 1305 checkWMTE(() -> { // > 1306 boolean r = vh.weakCompareAndSetAcquire(true, true, Void.class); 1307 }); 1308 1309 1310 // WeakCompareAndSetRelease 1311 // Incorrect argument types 1312 checkWMTE(() -> { // expected reference class 1313 boolean r = vh.weakCompareAndSetRelease(Void.class, true); 1314 }); 1315 checkWMTE(() -> { // actual reference class 1316 boolean r = vh.weakCompareAndSetRelease(true, Void.class); 1317 }); 1318 // Incorrect arity 1319 checkWMTE(() -> { // 0 1320 boolean r = vh.weakCompareAndSetRelease(); 1321 }); 1322 checkWMTE(() -> { // > 1323 boolean r = vh.weakCompareAndSetRelease(true, true, Void.class); 1324 }); 1325 1326 1327 // CompareAndExchange 1328 // Incorrect argument types 1329 checkWMTE(() -> { // expected reference class 1330 boolean x = (boolean) vh.compareAndExchange(Void.class, true); 1331 }); 1332 checkWMTE(() -> { // actual reference class 1333 boolean x = (boolean) vh.compareAndExchange(true, Void.class); 1334 }); 1335 // Incorrect return type 1336 checkWMTE(() -> { // reference class 1337 Void r = (Void) vh.compareAndExchange(true, true); 1338 }); 1339 checkWMTE(() -> { // primitive class 1340 int x = (int) vh.compareAndExchange(true, true); 1341 }); 1342 // Incorrect arity 1343 checkWMTE(() -> { // 0 1344 boolean x = (boolean) vh.compareAndExchange(); 1345 }); 1346 checkWMTE(() -> { // > 1347 boolean x = (boolean) vh.compareAndExchange(true, true, Void.class); 1348 }); 1349 1350 1351 // CompareAndExchangeAcquire 1352 // Incorrect argument types 1353 checkWMTE(() -> { // expected reference class 1354 boolean x = (boolean) vh.compareAndExchangeAcquire(Void.class, true); 1355 }); 1356 checkWMTE(() -> { // actual reference class 1357 boolean x = (boolean) vh.compareAndExchangeAcquire(true, Void.class); 1358 }); 1359 // Incorrect return type 1360 checkWMTE(() -> { // reference class 1361 Void r = (Void) vh.compareAndExchangeAcquire(true, true); 1362 }); 1363 checkWMTE(() -> { // primitive class 1364 int x = (int) vh.compareAndExchangeAcquire(true, true); 1365 }); 1366 // Incorrect arity 1367 checkWMTE(() -> { // 0 1368 boolean x = (boolean) vh.compareAndExchangeAcquire(); 1369 }); 1370 checkWMTE(() -> { // > 1371 boolean x = (boolean) vh.compareAndExchangeAcquire(true, true, Void.class); 1372 }); 1373 1374 1375 // CompareAndExchangeRelease 1376 // Incorrect argument types 1377 checkWMTE(() -> { // expected reference class 1378 boolean x = (boolean) vh.compareAndExchangeRelease(Void.class, true); 1379 }); 1380 checkWMTE(() -> { // actual reference class 1381 boolean x = (boolean) vh.compareAndExchangeRelease(true, Void.class); 1382 }); 1383 // Incorrect return type 1384 checkWMTE(() -> { // reference class 1385 Void r = (Void) vh.compareAndExchangeRelease(true, true); 1386 }); 1387 checkWMTE(() -> { // primitive class 1388 int x = (int) vh.compareAndExchangeRelease(true, true); 1389 }); 1390 // Incorrect arity 1391 checkWMTE(() -> { // 0 1392 boolean x = (boolean) vh.compareAndExchangeRelease(); 1393 }); 1394 checkWMTE(() -> { // > 1395 boolean x = (boolean) vh.compareAndExchangeRelease(true, true, Void.class); 1396 }); 1397 1398 1399 // GetAndSet 1400 // Incorrect argument types 1401 checkWMTE(() -> { // value reference class 1402 boolean x = (boolean) vh.getAndSet(Void.class); 1403 }); 1404 // Incorrect return type 1405 checkWMTE(() -> { // reference class 1406 Void r = (Void) vh.getAndSet(true); 1407 }); 1408 checkWMTE(() -> { // primitive class 1409 int x = (int) vh.getAndSet(true); 1410 }); 1411 // Incorrect arity 1412 checkWMTE(() -> { // 0 1413 boolean x = (boolean) vh.getAndSet(); 1414 }); 1415 checkWMTE(() -> { // > 1416 boolean x = (boolean) vh.getAndSet(true, Void.class); 1417 }); 1418 1419 1420 // GetAndSetAcquire 1421 // Incorrect argument types 1422 checkWMTE(() -> { // value reference class 1423 boolean x = (boolean) vh.getAndSetAcquire(Void.class); 1424 }); 1425 // Incorrect return type 1426 checkWMTE(() -> { // reference class 1427 Void r = (Void) vh.getAndSetAcquire(true); 1428 }); 1429 checkWMTE(() -> { // primitive class 1430 int x = (int) vh.getAndSetAcquire(true); 1431 }); 1432 // Incorrect arity 1433 checkWMTE(() -> { // 0 1434 boolean x = (boolean) vh.getAndSetAcquire(); 1435 }); 1436 checkWMTE(() -> { // > 1437 boolean x = (boolean) vh.getAndSetAcquire(true, Void.class); 1438 }); 1439 1440 1441 // GetAndSetRelease 1442 // Incorrect argument types 1443 checkWMTE(() -> { // value reference class 1444 boolean x = (boolean) vh.getAndSetRelease(Void.class); 1445 }); 1446 // Incorrect return type 1447 checkWMTE(() -> { // reference class 1448 Void r = (Void) vh.getAndSetRelease(true); 1449 }); 1450 checkWMTE(() -> { // primitive class 1451 int x = (int) vh.getAndSetRelease(true); 1452 }); 1453 // Incorrect arity 1454 checkWMTE(() -> { // 0 1455 boolean x = (boolean) vh.getAndSetRelease(); 1456 }); 1457 checkWMTE(() -> { // > 1458 boolean x = (boolean) vh.getAndSetRelease(true, Void.class); 1459 }); 1460 1461 1462 // GetAndBitwiseOr 1463 // Incorrect argument types 1464 checkWMTE(() -> { // value reference class 1465 boolean x = (boolean) vh.getAndBitwiseOr(Void.class); 1466 }); 1467 // Incorrect return type 1468 checkWMTE(() -> { // reference class 1469 Void r = (Void) vh.getAndBitwiseOr(true); 1470 }); 1471 checkWMTE(() -> { // primitive class 1472 int x = (int) vh.getAndBitwiseOr(true); 1473 }); 1474 // Incorrect arity 1475 checkWMTE(() -> { // 0 1476 boolean x = (boolean) vh.getAndBitwiseOr(); 1477 }); 1478 checkWMTE(() -> { // > 1479 boolean x = (boolean) vh.getAndBitwiseOr(true, Void.class); 1480 }); 1481 1482 1483 // GetAndBitwiseOrAcquire 1484 // Incorrect argument types 1485 checkWMTE(() -> { // value reference class 1486 boolean x = (boolean) vh.getAndBitwiseOrAcquire(Void.class); 1487 }); 1488 // Incorrect return type 1489 checkWMTE(() -> { // reference class 1490 Void r = (Void) vh.getAndBitwiseOrAcquire(true); 1491 }); 1492 checkWMTE(() -> { // primitive class 1493 int x = (int) vh.getAndBitwiseOrAcquire(true); 1494 }); 1495 // Incorrect arity 1496 checkWMTE(() -> { // 0 1497 boolean x = (boolean) vh.getAndBitwiseOrAcquire(); 1498 }); 1499 checkWMTE(() -> { // > 1500 boolean x = (boolean) vh.getAndBitwiseOrAcquire(true, Void.class); 1501 }); 1502 1503 1504 // GetAndBitwiseOrReleaseRelease 1505 // Incorrect argument types 1506 checkWMTE(() -> { // value reference class 1507 boolean x = (boolean) vh.getAndBitwiseOrRelease(Void.class); 1508 }); 1509 // Incorrect return type 1510 checkWMTE(() -> { // reference class 1511 Void r = (Void) vh.getAndBitwiseOrRelease(true); 1512 }); 1513 checkWMTE(() -> { // primitive class 1514 int x = (int) vh.getAndBitwiseOrRelease(true); 1515 }); 1516 // Incorrect arity 1517 checkWMTE(() -> { // 0 1518 boolean x = (boolean) vh.getAndBitwiseOrRelease(); 1519 }); 1520 checkWMTE(() -> { // > 1521 boolean x = (boolean) vh.getAndBitwiseOrRelease(true, Void.class); 1522 }); 1523 1524 1525 // GetAndBitwiseAnd 1526 // Incorrect argument types 1527 checkWMTE(() -> { // value reference class 1528 boolean x = (boolean) vh.getAndBitwiseAnd(Void.class); 1529 }); 1530 // Incorrect return type 1531 checkWMTE(() -> { // reference class 1532 Void r = (Void) vh.getAndBitwiseAnd(true); 1533 }); 1534 checkWMTE(() -> { // primitive class 1535 int x = (int) vh.getAndBitwiseAnd(true); 1536 }); 1537 // Incorrect arity 1538 checkWMTE(() -> { // 0 1539 boolean x = (boolean) vh.getAndBitwiseAnd(); 1540 }); 1541 checkWMTE(() -> { // > 1542 boolean x = (boolean) vh.getAndBitwiseAnd(true, Void.class); 1543 }); 1544 1545 1546 // GetAndBitwiseAndAcquire 1547 // Incorrect argument types 1548 checkWMTE(() -> { // value reference class 1549 boolean x = (boolean) vh.getAndBitwiseAndAcquire(Void.class); 1550 }); 1551 // Incorrect return type 1552 checkWMTE(() -> { // reference class 1553 Void r = (Void) vh.getAndBitwiseAndAcquire(true); 1554 }); 1555 checkWMTE(() -> { // primitive class 1556 int x = (int) vh.getAndBitwiseAndAcquire(true); 1557 }); 1558 // Incorrect arity 1559 checkWMTE(() -> { // 0 1560 boolean x = (boolean) vh.getAndBitwiseAndAcquire(); 1561 }); 1562 checkWMTE(() -> { // > 1563 boolean x = (boolean) vh.getAndBitwiseAndAcquire(true, Void.class); 1564 }); 1565 1566 1567 // GetAndBitwiseAndReleaseRelease 1568 // Incorrect argument types 1569 checkWMTE(() -> { // value reference class 1570 boolean x = (boolean) vh.getAndBitwiseAndRelease(Void.class); 1571 }); 1572 // Incorrect return type 1573 checkWMTE(() -> { // reference class 1574 Void r = (Void) vh.getAndBitwiseAndRelease(true); 1575 }); 1576 checkWMTE(() -> { // primitive class 1577 int x = (int) vh.getAndBitwiseAndRelease(true); 1578 }); 1579 // Incorrect arity 1580 checkWMTE(() -> { // 0 1581 boolean x = (boolean) vh.getAndBitwiseAndRelease(); 1582 }); 1583 checkWMTE(() -> { // > 1584 boolean x = (boolean) vh.getAndBitwiseAndRelease(true, Void.class); 1585 }); 1586 1587 1588 // GetAndBitwiseXor 1589 // Incorrect argument types 1590 checkWMTE(() -> { // value reference class 1591 boolean x = (boolean) vh.getAndBitwiseXor(Void.class); 1592 }); 1593 // Incorrect return type 1594 checkWMTE(() -> { // reference class 1595 Void r = (Void) vh.getAndBitwiseXor(true); 1596 }); 1597 checkWMTE(() -> { // primitive class 1598 int x = (int) vh.getAndBitwiseXor(true); 1599 }); 1600 // Incorrect arity 1601 checkWMTE(() -> { // 0 1602 boolean x = (boolean) vh.getAndBitwiseXor(); 1603 }); 1604 checkWMTE(() -> { // > 1605 boolean x = (boolean) vh.getAndBitwiseXor(true, Void.class); 1606 }); 1607 1608 1609 // GetAndBitwiseXorAcquire 1610 // Incorrect argument types 1611 checkWMTE(() -> { // value reference class 1612 boolean x = (boolean) vh.getAndBitwiseXorAcquire(Void.class); 1613 }); 1614 // Incorrect return type 1615 checkWMTE(() -> { // reference class 1616 Void r = (Void) vh.getAndBitwiseXorAcquire(true); 1617 }); 1618 checkWMTE(() -> { // primitive class 1619 int x = (int) vh.getAndBitwiseXorAcquire(true); 1620 }); 1621 // Incorrect arity 1622 checkWMTE(() -> { // 0 1623 boolean x = (boolean) vh.getAndBitwiseXorAcquire(); 1624 }); 1625 checkWMTE(() -> { // > 1626 boolean x = (boolean) vh.getAndBitwiseXorAcquire(true, Void.class); 1627 }); 1628 1629 1630 // GetAndBitwiseXorReleaseRelease 1631 // Incorrect argument types 1632 checkWMTE(() -> { // value reference class 1633 boolean x = (boolean) vh.getAndBitwiseXorRelease(Void.class); 1634 }); 1635 // Incorrect return type 1636 checkWMTE(() -> { // reference class 1637 Void r = (Void) vh.getAndBitwiseXorRelease(true); 1638 }); 1639 checkWMTE(() -> { // primitive class 1640 int x = (int) vh.getAndBitwiseXorRelease(true); 1641 }); 1642 // Incorrect arity 1643 checkWMTE(() -> { // 0 1644 boolean x = (boolean) vh.getAndBitwiseXorRelease(); 1645 }); 1646 checkWMTE(() -> { // > 1647 boolean x = (boolean) vh.getAndBitwiseXorRelease(true, Void.class); 1648 }); 1649 } 1650 1651 static void testStaticFieldWrongMethodType(Handles hs) throws Throwable { 1652 int i = 0; 1653 1654 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) { 1655 // Incorrect return type 1656 checkWMTE(() -> { // reference class 1657 Void x = (Void) hs.get(am, methodType(Void.class)). 1658 invokeExact(); 1659 }); 1660 checkWMTE(() -> { // primitive class 1661 int x = (int) hs.get(am, methodType(int.class)). 1662 invokeExact(); 1663 }); 1664 // Incorrect arity 1665 checkWMTE(() -> { // > 1666 boolean x = (boolean) hs.get(am, methodType(Class.class)). 1667 invokeExact(Void.class); 1668 }); 1669 } 1670 1671 for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) { 1672 checkWMTE(() -> { // value reference class 1673 hs.get(am, methodType(void.class, Class.class)). 1674 invokeExact(Void.class); 1675 }); 1676 // Incorrect arity 1677 checkWMTE(() -> { // 0 1678 hs.get(am, methodType(void.class)). 1679 invokeExact(); 1680 }); 1681 checkWMTE(() -> { // > 1682 hs.get(am, methodType(void.class, boolean.class, Class.class)). 1683 invokeExact(true, Void.class); 1684 }); 1685 } 1686 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) { 1687 // Incorrect argument types 1688 checkWMTE(() -> { // expected reference class 1689 boolean r = (boolean) hs.get(am, methodType(boolean.class, Class.class, boolean.class)). 1690 invokeExact(Void.class, true); 1691 }); 1692 checkWMTE(() -> { // actual reference class 1693 boolean r = (boolean) hs.get(am, methodType(boolean.class, boolean.class, Class.class)). 1694 invokeExact(true, Void.class); 1695 }); 1696 // Incorrect arity 1697 checkWMTE(() -> { // 0 1698 boolean r = (boolean) hs.get(am, methodType(boolean.class)). 1699 invokeExact(); 1700 }); 1701 checkWMTE(() -> { // > 1702 boolean r = (boolean) hs.get(am, methodType(boolean.class, boolean.class, boolean.class, Class.class)). 1703 invokeExact(true, true, Void.class); 1704 }); 1705 } 1706 1707 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) { 1708 // Incorrect argument types 1709 checkWMTE(() -> { // expected reference class 1710 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class, boolean.class)). 1711 invokeExact(Void.class, true); 1712 }); 1713 checkWMTE(() -> { // actual reference class 1714 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean.class, Class.class)). 1715 invokeExact(true, Void.class); 1716 }); 1717 // Incorrect return type 1718 checkWMTE(() -> { // reference class 1719 Void r = (Void) hs.get(am, methodType(Void.class, boolean.class, boolean.class)). 1720 invokeExact(true, true); 1721 }); 1722 checkWMTE(() -> { // primitive class 1723 int x = (int) hs.get(am, methodType(int.class, boolean.class, boolean.class)). 1724 invokeExact(true, true); 1725 }); 1726 // Incorrect arity 1727 checkWMTE(() -> { // 0 1728 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 1729 invokeExact(); 1730 }); 1731 checkWMTE(() -> { // > 1732 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean.class, boolean.class, Class.class)). 1733 invokeExact(true, true, Void.class); 1734 }); 1735 } 1736 1737 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) { 1738 // Incorrect argument types 1739 checkWMTE(() -> { // value reference class 1740 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class)). 1741 invokeExact(Void.class); 1742 }); 1743 // Incorrect return type 1744 checkWMTE(() -> { // reference class 1745 Void r = (Void) hs.get(am, methodType(Void.class, boolean.class)). 1746 invokeExact(true); 1747 }); 1748 checkWMTE(() -> { // primitive class 1749 int x = (int) hs.get(am, methodType(int.class, boolean.class)). 1750 invokeExact(true); 1751 }); 1752 // Incorrect arity 1753 checkWMTE(() -> { // 0 1754 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 1755 invokeExact(); 1756 }); 1757 checkWMTE(() -> { // > 1758 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean.class, Class.class)). 1759 invokeExact(true, Void.class); 1760 }); 1761 } 1762 1763 1764 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) { 1765 // Incorrect argument types 1766 checkWMTE(() -> { // value reference class 1767 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class)). 1768 invokeExact(Void.class); 1769 }); 1770 // Incorrect return type 1771 checkWMTE(() -> { // reference class 1772 Void r = (Void) hs.get(am, methodType(Void.class, boolean.class)). 1773 invokeExact(true); 1774 }); 1775 checkWMTE(() -> { // primitive class 1776 int x = (int) hs.get(am, methodType(int.class, boolean.class)). 1777 invokeExact(true); 1778 }); 1779 // Incorrect arity 1780 checkWMTE(() -> { // 0 1781 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 1782 invokeExact(); 1783 }); 1784 checkWMTE(() -> { // > 1785 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean.class, Class.class)). 1786 invokeExact(true, Void.class); 1787 }); 1788 } 1789 } 1790 1791 1792 static void testArrayWrongMethodType(VarHandle vh) throws Throwable { 1793 boolean[] array = new boolean[10]; 1794 Arrays.fill(array, true); 1795 1796 // Get 1797 // Incorrect argument types 1798 checkNPE(() -> { // null array 1799 boolean x = (boolean) vh.get(null, 0); 1800 }); 1801 checkCCE(() -> { // array reference class 1802 boolean x = (boolean) vh.get(Void.class, 0); 1803 }); 1804 checkWMTE(() -> { // array primitive class 1805 boolean x = (boolean) vh.get(0, 0); 1806 }); 1807 checkWMTE(() -> { // index reference class 1808 boolean x = (boolean) vh.get(array, Void.class); 1809 }); 1810 // Incorrect return type 1811 checkWMTE(() -> { // reference class 1812 Void x = (Void) vh.get(array, 0); 1813 }); 1814 checkWMTE(() -> { // primitive class 1815 int x = (int) vh.get(array, 0); 1816 }); 1817 // Incorrect arity 1818 checkWMTE(() -> { // 0 1819 boolean x = (boolean) vh.get(); 1820 }); 1821 checkWMTE(() -> { // > 1822 boolean x = (boolean) vh.get(array, 0, Void.class); 1823 }); 1824 1825 1826 // Set 1827 // Incorrect argument types 1828 checkNPE(() -> { // null array 1829 vh.set(null, 0, true); 1830 }); 1831 checkCCE(() -> { // array reference class 1832 vh.set(Void.class, 0, true); 1833 }); 1834 checkWMTE(() -> { // value reference class 1835 vh.set(array, 0, Void.class); 1836 }); 1837 checkWMTE(() -> { // receiver primitive class 1838 vh.set(0, 0, true); 1839 }); 1840 checkWMTE(() -> { // index reference class 1841 vh.set(array, Void.class, true); 1842 }); 1843 // Incorrect arity 1844 checkWMTE(() -> { // 0 1845 vh.set(); 1846 }); 1847 checkWMTE(() -> { // > 1848 vh.set(array, 0, true, Void.class); 1849 }); 1850 1851 1852 // GetVolatile 1853 // Incorrect argument types 1854 checkNPE(() -> { // null array 1855 boolean x = (boolean) vh.getVolatile(null, 0); 1856 }); 1857 checkCCE(() -> { // array reference class 1858 boolean x = (boolean) vh.getVolatile(Void.class, 0); 1859 }); 1860 checkWMTE(() -> { // array primitive class 1861 boolean x = (boolean) vh.getVolatile(0, 0); 1862 }); 1863 checkWMTE(() -> { // index reference class 1864 boolean x = (boolean) vh.getVolatile(array, Void.class); 1865 }); 1866 // Incorrect return type 1867 checkWMTE(() -> { // reference class 1868 Void x = (Void) vh.getVolatile(array, 0); 1869 }); 1870 checkWMTE(() -> { // primitive class 1871 int x = (int) vh.getVolatile(array, 0); 1872 }); 1873 // Incorrect arity 1874 checkWMTE(() -> { // 0 1875 boolean x = (boolean) vh.getVolatile(); 1876 }); 1877 checkWMTE(() -> { // > 1878 boolean x = (boolean) vh.getVolatile(array, 0, Void.class); 1879 }); 1880 1881 1882 // SetVolatile 1883 // Incorrect argument types 1884 checkNPE(() -> { // null array 1885 vh.setVolatile(null, 0, true); 1886 }); 1887 checkCCE(() -> { // array reference class 1888 vh.setVolatile(Void.class, 0, true); 1889 }); 1890 checkWMTE(() -> { // value reference class 1891 vh.setVolatile(array, 0, Void.class); 1892 }); 1893 checkWMTE(() -> { // receiver primitive class 1894 vh.setVolatile(0, 0, true); 1895 }); 1896 checkWMTE(() -> { // index reference class 1897 vh.setVolatile(array, Void.class, true); 1898 }); 1899 // Incorrect arity 1900 checkWMTE(() -> { // 0 1901 vh.setVolatile(); 1902 }); 1903 checkWMTE(() -> { // > 1904 vh.setVolatile(array, 0, true, Void.class); 1905 }); 1906 1907 1908 // GetOpaque 1909 // Incorrect argument types 1910 checkNPE(() -> { // null array 1911 boolean x = (boolean) vh.getOpaque(null, 0); 1912 }); 1913 checkCCE(() -> { // array reference class 1914 boolean x = (boolean) vh.getOpaque(Void.class, 0); 1915 }); 1916 checkWMTE(() -> { // array primitive class 1917 boolean x = (boolean) vh.getOpaque(0, 0); 1918 }); 1919 checkWMTE(() -> { // index reference class 1920 boolean x = (boolean) vh.getOpaque(array, Void.class); 1921 }); 1922 // Incorrect return type 1923 checkWMTE(() -> { // reference class 1924 Void x = (Void) vh.getOpaque(array, 0); 1925 }); 1926 checkWMTE(() -> { // primitive class 1927 int x = (int) vh.getOpaque(array, 0); 1928 }); 1929 // Incorrect arity 1930 checkWMTE(() -> { // 0 1931 boolean x = (boolean) vh.getOpaque(); 1932 }); 1933 checkWMTE(() -> { // > 1934 boolean x = (boolean) vh.getOpaque(array, 0, Void.class); 1935 }); 1936 1937 1938 // SetOpaque 1939 // Incorrect argument types 1940 checkNPE(() -> { // null array 1941 vh.setOpaque(null, 0, true); 1942 }); 1943 checkCCE(() -> { // array reference class 1944 vh.setOpaque(Void.class, 0, true); 1945 }); 1946 checkWMTE(() -> { // value reference class 1947 vh.setOpaque(array, 0, Void.class); 1948 }); 1949 checkWMTE(() -> { // receiver primitive class 1950 vh.setOpaque(0, 0, true); 1951 }); 1952 checkWMTE(() -> { // index reference class 1953 vh.setOpaque(array, Void.class, true); 1954 }); 1955 // Incorrect arity 1956 checkWMTE(() -> { // 0 1957 vh.setOpaque(); 1958 }); 1959 checkWMTE(() -> { // > 1960 vh.setOpaque(array, 0, true, Void.class); 1961 }); 1962 1963 1964 // GetAcquire 1965 // Incorrect argument types 1966 checkNPE(() -> { // null array 1967 boolean x = (boolean) vh.getAcquire(null, 0); 1968 }); 1969 checkCCE(() -> { // array reference class 1970 boolean x = (boolean) vh.getAcquire(Void.class, 0); 1971 }); 1972 checkWMTE(() -> { // array primitive class 1973 boolean x = (boolean) vh.getAcquire(0, 0); 1974 }); 1975 checkWMTE(() -> { // index reference class 1976 boolean x = (boolean) vh.getAcquire(array, Void.class); 1977 }); 1978 // Incorrect return type 1979 checkWMTE(() -> { // reference class 1980 Void x = (Void) vh.getAcquire(array, 0); 1981 }); 1982 checkWMTE(() -> { // primitive class 1983 int x = (int) vh.getAcquire(array, 0); 1984 }); 1985 // Incorrect arity 1986 checkWMTE(() -> { // 0 1987 boolean x = (boolean) vh.getAcquire(); 1988 }); 1989 checkWMTE(() -> { // > 1990 boolean x = (boolean) vh.getAcquire(array, 0, Void.class); 1991 }); 1992 1993 1994 // SetRelease 1995 // Incorrect argument types 1996 checkNPE(() -> { // null array 1997 vh.setRelease(null, 0, true); 1998 }); 1999 checkCCE(() -> { // array reference class 2000 vh.setRelease(Void.class, 0, true); 2001 }); 2002 checkWMTE(() -> { // value reference class 2003 vh.setRelease(array, 0, Void.class); 2004 }); 2005 checkWMTE(() -> { // receiver primitive class 2006 vh.setRelease(0, 0, true); 2007 }); 2008 checkWMTE(() -> { // index reference class 2009 vh.setRelease(array, Void.class, true); 2010 }); 2011 // Incorrect arity 2012 checkWMTE(() -> { // 0 2013 vh.setRelease(); 2014 }); 2015 checkWMTE(() -> { // > 2016 vh.setRelease(array, 0, true, Void.class); 2017 }); 2018 2019 2020 // CompareAndSet 2021 // Incorrect argument types 2022 checkNPE(() -> { // null receiver 2023 boolean r = vh.compareAndSet(null, 0, true, true); 2024 }); 2025 checkCCE(() -> { // receiver reference class 2026 boolean r = vh.compareAndSet(Void.class, 0, true, true); 2027 }); 2028 checkWMTE(() -> { // expected reference class 2029 boolean r = vh.compareAndSet(array, 0, Void.class, true); 2030 }); 2031 checkWMTE(() -> { // actual reference class 2032 boolean r = vh.compareAndSet(array, 0, true, Void.class); 2033 }); 2034 checkWMTE(() -> { // receiver primitive class 2035 boolean r = vh.compareAndSet(0, 0, true, true); 2036 }); 2037 checkWMTE(() -> { // index reference class 2038 boolean r = vh.compareAndSet(array, Void.class, true, true); 2039 }); 2040 // Incorrect arity 2041 checkWMTE(() -> { // 0 2042 boolean r = vh.compareAndSet(); 2043 }); 2044 checkWMTE(() -> { // > 2045 boolean r = vh.compareAndSet(array, 0, true, true, Void.class); 2046 }); 2047 2048 2049 // WeakCompareAndSet 2050 // Incorrect argument types 2051 checkNPE(() -> { // null receiver 2052 boolean r = vh.weakCompareAndSetPlain(null, 0, true, true); 2053 }); 2054 checkCCE(() -> { // receiver reference class 2055 boolean r = vh.weakCompareAndSetPlain(Void.class, 0, true, true); 2056 }); 2057 checkWMTE(() -> { // expected reference class 2058 boolean r = vh.weakCompareAndSetPlain(array, 0, Void.class, true); 2059 }); 2060 checkWMTE(() -> { // actual reference class 2061 boolean r = vh.weakCompareAndSetPlain(array, 0, true, Void.class); 2062 }); 2063 checkWMTE(() -> { // receiver primitive class 2064 boolean r = vh.weakCompareAndSetPlain(0, 0, true, true); 2065 }); 2066 checkWMTE(() -> { // index reference class 2067 boolean r = vh.weakCompareAndSetPlain(array, Void.class, true, true); 2068 }); 2069 // Incorrect arity 2070 checkWMTE(() -> { // 0 2071 boolean r = vh.weakCompareAndSetPlain(); 2072 }); 2073 checkWMTE(() -> { // > 2074 boolean r = vh.weakCompareAndSetPlain(array, 0, true, true, Void.class); 2075 }); 2076 2077 2078 // WeakCompareAndSetVolatile 2079 // Incorrect argument types 2080 checkNPE(() -> { // null receiver 2081 boolean r = vh.weakCompareAndSet(null, 0, true, true); 2082 }); 2083 checkCCE(() -> { // receiver reference class 2084 boolean r = vh.weakCompareAndSet(Void.class, 0, true, true); 2085 }); 2086 checkWMTE(() -> { // expected reference class 2087 boolean r = vh.weakCompareAndSet(array, 0, Void.class, true); 2088 }); 2089 checkWMTE(() -> { // actual reference class 2090 boolean r = vh.weakCompareAndSet(array, 0, true, Void.class); 2091 }); 2092 checkWMTE(() -> { // receiver primitive class 2093 boolean r = vh.weakCompareAndSet(0, 0, true, true); 2094 }); 2095 checkWMTE(() -> { // index reference class 2096 boolean r = vh.weakCompareAndSet(array, Void.class, true, true); 2097 }); 2098 // Incorrect arity 2099 checkWMTE(() -> { // 0 2100 boolean r = vh.weakCompareAndSet(); 2101 }); 2102 checkWMTE(() -> { // > 2103 boolean r = vh.weakCompareAndSet(array, 0, true, true, Void.class); 2104 }); 2105 2106 2107 // WeakCompareAndSetAcquire 2108 // Incorrect argument types 2109 checkNPE(() -> { // null receiver 2110 boolean r = vh.weakCompareAndSetAcquire(null, 0, true, true); 2111 }); 2112 checkCCE(() -> { // receiver reference class 2113 boolean r = vh.weakCompareAndSetAcquire(Void.class, 0, true, true); 2114 }); 2115 checkWMTE(() -> { // expected reference class 2116 boolean r = vh.weakCompareAndSetAcquire(array, 0, Void.class, true); 2117 }); 2118 checkWMTE(() -> { // actual reference class 2119 boolean r = vh.weakCompareAndSetAcquire(array, 0, true, Void.class); 2120 }); 2121 checkWMTE(() -> { // receiver primitive class 2122 boolean r = vh.weakCompareAndSetAcquire(0, 0, true, true); 2123 }); 2124 checkWMTE(() -> { // index reference class 2125 boolean r = vh.weakCompareAndSetAcquire(array, Void.class, true, true); 2126 }); 2127 // Incorrect arity 2128 checkWMTE(() -> { // 0 2129 boolean r = vh.weakCompareAndSetAcquire(); 2130 }); 2131 checkWMTE(() -> { // > 2132 boolean r = vh.weakCompareAndSetAcquire(array, 0, true, true, Void.class); 2133 }); 2134 2135 2136 // WeakCompareAndSetRelease 2137 // Incorrect argument types 2138 checkNPE(() -> { // null receiver 2139 boolean r = vh.weakCompareAndSetRelease(null, 0, true, true); 2140 }); 2141 checkCCE(() -> { // receiver reference class 2142 boolean r = vh.weakCompareAndSetRelease(Void.class, 0, true, true); 2143 }); 2144 checkWMTE(() -> { // expected reference class 2145 boolean r = vh.weakCompareAndSetRelease(array, 0, Void.class, true); 2146 }); 2147 checkWMTE(() -> { // actual reference class 2148 boolean r = vh.weakCompareAndSetRelease(array, 0, true, Void.class); 2149 }); 2150 checkWMTE(() -> { // receiver primitive class 2151 boolean r = vh.weakCompareAndSetRelease(0, 0, true, true); 2152 }); 2153 checkWMTE(() -> { // index reference class 2154 boolean r = vh.weakCompareAndSetRelease(array, Void.class, true, true); 2155 }); 2156 // Incorrect arity 2157 checkWMTE(() -> { // 0 2158 boolean r = vh.weakCompareAndSetRelease(); 2159 }); 2160 checkWMTE(() -> { // > 2161 boolean r = vh.weakCompareAndSetRelease(array, 0, true, true, Void.class); 2162 }); 2163 2164 2165 // CompareAndExchange 2166 // Incorrect argument types 2167 checkNPE(() -> { // null receiver 2168 boolean x = (boolean) vh.compareAndExchange(null, 0, true, true); 2169 }); 2170 checkCCE(() -> { // array reference class 2171 boolean x = (boolean) vh.compareAndExchange(Void.class, 0, true, true); 2172 }); 2173 checkWMTE(() -> { // expected reference class 2174 boolean x = (boolean) vh.compareAndExchange(array, 0, Void.class, true); 2175 }); 2176 checkWMTE(() -> { // actual reference class 2177 boolean x = (boolean) vh.compareAndExchange(array, 0, true, Void.class); 2178 }); 2179 checkWMTE(() -> { // array primitive class 2180 boolean x = (boolean) vh.compareAndExchange(0, 0, true, true); 2181 }); 2182 checkWMTE(() -> { // index reference class 2183 boolean x = (boolean) vh.compareAndExchange(array, Void.class, true, true); 2184 }); 2185 // Incorrect return type 2186 checkWMTE(() -> { // reference class 2187 Void r = (Void) vh.compareAndExchange(array, 0, true, true); 2188 }); 2189 checkWMTE(() -> { // primitive class 2190 int x = (int) vh.compareAndExchange(array, 0, true, true); 2191 }); 2192 // Incorrect arity 2193 checkWMTE(() -> { // 0 2194 boolean x = (boolean) vh.compareAndExchange(); 2195 }); 2196 checkWMTE(() -> { // > 2197 boolean x = (boolean) vh.compareAndExchange(array, 0, true, true, Void.class); 2198 }); 2199 2200 2201 // CompareAndExchangeAcquire 2202 // Incorrect argument types 2203 checkNPE(() -> { // null receiver 2204 boolean x = (boolean) vh.compareAndExchangeAcquire(null, 0, true, true); 2205 }); 2206 checkCCE(() -> { // array reference class 2207 boolean x = (boolean) vh.compareAndExchangeAcquire(Void.class, 0, true, true); 2208 }); 2209 checkWMTE(() -> { // expected reference class 2210 boolean x = (boolean) vh.compareAndExchangeAcquire(array, 0, Void.class, true); 2211 }); 2212 checkWMTE(() -> { // actual reference class 2213 boolean x = (boolean) vh.compareAndExchangeAcquire(array, 0, true, Void.class); 2214 }); 2215 checkWMTE(() -> { // array primitive class 2216 boolean x = (boolean) vh.compareAndExchangeAcquire(0, 0, true, true); 2217 }); 2218 checkWMTE(() -> { // index reference class 2219 boolean x = (boolean) vh.compareAndExchangeAcquire(array, Void.class, true, true); 2220 }); 2221 // Incorrect return type 2222 checkWMTE(() -> { // reference class 2223 Void r = (Void) vh.compareAndExchangeAcquire(array, 0, true, true); 2224 }); 2225 checkWMTE(() -> { // primitive class 2226 int x = (int) vh.compareAndExchangeAcquire(array, 0, true, true); 2227 }); 2228 // Incorrect arity 2229 checkWMTE(() -> { // 0 2230 boolean x = (boolean) vh.compareAndExchangeAcquire(); 2231 }); 2232 checkWMTE(() -> { // > 2233 boolean x = (boolean) vh.compareAndExchangeAcquire(array, 0, true, true, Void.class); 2234 }); 2235 2236 2237 // CompareAndExchangeRelease 2238 // Incorrect argument types 2239 checkNPE(() -> { // null receiver 2240 boolean x = (boolean) vh.compareAndExchangeRelease(null, 0, true, true); 2241 }); 2242 checkCCE(() -> { // array reference class 2243 boolean x = (boolean) vh.compareAndExchangeRelease(Void.class, 0, true, true); 2244 }); 2245 checkWMTE(() -> { // expected reference class 2246 boolean x = (boolean) vh.compareAndExchangeRelease(array, 0, Void.class, true); 2247 }); 2248 checkWMTE(() -> { // actual reference class 2249 boolean x = (boolean) vh.compareAndExchangeRelease(array, 0, true, Void.class); 2250 }); 2251 checkWMTE(() -> { // array primitive class 2252 boolean x = (boolean) vh.compareAndExchangeRelease(0, 0, true, true); 2253 }); 2254 checkWMTE(() -> { // index reference class 2255 boolean x = (boolean) vh.compareAndExchangeRelease(array, Void.class, true, true); 2256 }); 2257 // Incorrect return type 2258 checkWMTE(() -> { // reference class 2259 Void r = (Void) vh.compareAndExchangeRelease(array, 0, true, true); 2260 }); 2261 checkWMTE(() -> { // primitive class 2262 int x = (int) vh.compareAndExchangeRelease(array, 0, true, true); 2263 }); 2264 // Incorrect arity 2265 checkWMTE(() -> { // 0 2266 boolean x = (boolean) vh.compareAndExchangeRelease(); 2267 }); 2268 checkWMTE(() -> { // > 2269 boolean x = (boolean) vh.compareAndExchangeRelease(array, 0, true, true, Void.class); 2270 }); 2271 2272 2273 // GetAndSet 2274 // Incorrect argument types 2275 checkNPE(() -> { // null array 2276 boolean x = (boolean) vh.getAndSet(null, 0, true); 2277 }); 2278 checkCCE(() -> { // array reference class 2279 boolean x = (boolean) vh.getAndSet(Void.class, 0, true); 2280 }); 2281 checkWMTE(() -> { // value reference class 2282 boolean x = (boolean) vh.getAndSet(array, 0, Void.class); 2283 }); 2284 checkWMTE(() -> { // reciarrayever primitive class 2285 boolean x = (boolean) vh.getAndSet(0, 0, true); 2286 }); 2287 checkWMTE(() -> { // index reference class 2288 boolean x = (boolean) vh.getAndSet(array, Void.class, true); 2289 }); 2290 // Incorrect return type 2291 checkWMTE(() -> { // reference class 2292 Void r = (Void) vh.getAndSet(array, 0, true); 2293 }); 2294 checkWMTE(() -> { // primitive class 2295 int x = (int) vh.getAndSet(array, 0, true); 2296 }); 2297 // Incorrect arity 2298 checkWMTE(() -> { // 0 2299 boolean x = (boolean) vh.getAndSet(); 2300 }); 2301 checkWMTE(() -> { // > 2302 boolean x = (boolean) vh.getAndSet(array, 0, true, Void.class); 2303 }); 2304 2305 2306 // GetAndSetAcquire 2307 // Incorrect argument types 2308 checkNPE(() -> { // null array 2309 boolean x = (boolean) vh.getAndSetAcquire(null, 0, true); 2310 }); 2311 checkCCE(() -> { // array reference class 2312 boolean x = (boolean) vh.getAndSetAcquire(Void.class, 0, true); 2313 }); 2314 checkWMTE(() -> { // value reference class 2315 boolean x = (boolean) vh.getAndSetAcquire(array, 0, Void.class); 2316 }); 2317 checkWMTE(() -> { // reciarrayever primitive class 2318 boolean x = (boolean) vh.getAndSetAcquire(0, 0, true); 2319 }); 2320 checkWMTE(() -> { // index reference class 2321 boolean x = (boolean) vh.getAndSetAcquire(array, Void.class, true); 2322 }); 2323 // Incorrect return type 2324 checkWMTE(() -> { // reference class 2325 Void r = (Void) vh.getAndSetAcquire(array, 0, true); 2326 }); 2327 checkWMTE(() -> { // primitive class 2328 int x = (int) vh.getAndSetAcquire(array, 0, true); 2329 }); 2330 // Incorrect arity 2331 checkWMTE(() -> { // 0 2332 boolean x = (boolean) vh.getAndSetAcquire(); 2333 }); 2334 checkWMTE(() -> { // > 2335 boolean x = (boolean) vh.getAndSetAcquire(array, 0, true, Void.class); 2336 }); 2337 2338 2339 // GetAndSetRelease 2340 // Incorrect argument types 2341 checkNPE(() -> { // null array 2342 boolean x = (boolean) vh.getAndSetRelease(null, 0, true); 2343 }); 2344 checkCCE(() -> { // array reference class 2345 boolean x = (boolean) vh.getAndSetRelease(Void.class, 0, true); 2346 }); 2347 checkWMTE(() -> { // value reference class 2348 boolean x = (boolean) vh.getAndSetRelease(array, 0, Void.class); 2349 }); 2350 checkWMTE(() -> { // reciarrayever primitive class 2351 boolean x = (boolean) vh.getAndSetRelease(0, 0, true); 2352 }); 2353 checkWMTE(() -> { // index reference class 2354 boolean x = (boolean) vh.getAndSetRelease(array, Void.class, true); 2355 }); 2356 // Incorrect return type 2357 checkWMTE(() -> { // reference class 2358 Void r = (Void) vh.getAndSetRelease(array, 0, true); 2359 }); 2360 checkWMTE(() -> { // primitive class 2361 int x = (int) vh.getAndSetRelease(array, 0, true); 2362 }); 2363 // Incorrect arity 2364 checkWMTE(() -> { // 0 2365 boolean x = (boolean) vh.getAndSetRelease(); 2366 }); 2367 checkWMTE(() -> { // > 2368 boolean x = (boolean) vh.getAndSetRelease(array, 0, true, Void.class); 2369 }); 2370 2371 2372 // GetAndBitwiseOr 2373 // Incorrect argument types 2374 checkNPE(() -> { // null array 2375 boolean x = (boolean) vh.getAndBitwiseOr(null, 0, true); 2376 }); 2377 checkCCE(() -> { // array reference class 2378 boolean x = (boolean) vh.getAndBitwiseOr(Void.class, 0, true); 2379 }); 2380 checkWMTE(() -> { // value reference class 2381 boolean x = (boolean) vh.getAndBitwiseOr(array, 0, Void.class); 2382 }); 2383 checkWMTE(() -> { // array primitive class 2384 boolean x = (boolean) vh.getAndBitwiseOr(0, 0, true); 2385 }); 2386 checkWMTE(() -> { // index reference class 2387 boolean x = (boolean) vh.getAndBitwiseOr(array, Void.class, true); 2388 }); 2389 // Incorrect return type 2390 checkWMTE(() -> { // reference class 2391 Void r = (Void) vh.getAndBitwiseOr(array, 0, true); 2392 }); 2393 checkWMTE(() -> { // primitive class 2394 int x = (int) vh.getAndBitwiseOr(array, 0, true); 2395 }); 2396 // Incorrect arity 2397 checkWMTE(() -> { // 0 2398 boolean x = (boolean) vh.getAndBitwiseOr(); 2399 }); 2400 checkWMTE(() -> { // > 2401 boolean x = (boolean) vh.getAndBitwiseOr(array, 0, true, Void.class); 2402 }); 2403 2404 2405 // GetAndBitwiseOrAcquire 2406 // Incorrect argument types 2407 checkNPE(() -> { // null array 2408 boolean x = (boolean) vh.getAndBitwiseOrAcquire(null, 0, true); 2409 }); 2410 checkCCE(() -> { // array reference class 2411 boolean x = (boolean) vh.getAndBitwiseOrAcquire(Void.class, 0, true); 2412 }); 2413 checkWMTE(() -> { // value reference class 2414 boolean x = (boolean) vh.getAndBitwiseOrAcquire(array, 0, Void.class); 2415 }); 2416 checkWMTE(() -> { // array primitive class 2417 boolean x = (boolean) vh.getAndBitwiseOrAcquire(0, 0, true); 2418 }); 2419 checkWMTE(() -> { // index reference class 2420 boolean x = (boolean) vh.getAndBitwiseOrAcquire(array, Void.class, true); 2421 }); 2422 // Incorrect return type 2423 checkWMTE(() -> { // reference class 2424 Void r = (Void) vh.getAndBitwiseOrAcquire(array, 0, true); 2425 }); 2426 checkWMTE(() -> { // primitive class 2427 int x = (int) vh.getAndBitwiseOrAcquire(array, 0, true); 2428 }); 2429 // Incorrect arity 2430 checkWMTE(() -> { // 0 2431 boolean x = (boolean) vh.getAndBitwiseOrAcquire(); 2432 }); 2433 checkWMTE(() -> { // > 2434 boolean x = (boolean) vh.getAndBitwiseOrAcquire(array, 0, true, Void.class); 2435 }); 2436 2437 2438 // GetAndBitwiseOrRelease 2439 // Incorrect argument types 2440 checkNPE(() -> { // null array 2441 boolean x = (boolean) vh.getAndBitwiseOrRelease(null, 0, true); 2442 }); 2443 checkCCE(() -> { // array reference class 2444 boolean x = (boolean) vh.getAndBitwiseOrRelease(Void.class, 0, true); 2445 }); 2446 checkWMTE(() -> { // value reference class 2447 boolean x = (boolean) vh.getAndBitwiseOrRelease(array, 0, Void.class); 2448 }); 2449 checkWMTE(() -> { // array primitive class 2450 boolean x = (boolean) vh.getAndBitwiseOrRelease(0, 0, true); 2451 }); 2452 checkWMTE(() -> { // index reference class 2453 boolean x = (boolean) vh.getAndBitwiseOrRelease(array, Void.class, true); 2454 }); 2455 // Incorrect return type 2456 checkWMTE(() -> { // reference class 2457 Void r = (Void) vh.getAndBitwiseOrRelease(array, 0, true); 2458 }); 2459 checkWMTE(() -> { // primitive class 2460 int x = (int) vh.getAndBitwiseOrRelease(array, 0, true); 2461 }); 2462 // Incorrect arity 2463 checkWMTE(() -> { // 0 2464 boolean x = (boolean) vh.getAndBitwiseOrRelease(); 2465 }); 2466 checkWMTE(() -> { // > 2467 boolean x = (boolean) vh.getAndBitwiseOrRelease(array, 0, true, Void.class); 2468 }); 2469 2470 2471 // GetAndBitwiseAnd 2472 // Incorrect argument types 2473 checkNPE(() -> { // null array 2474 boolean x = (boolean) vh.getAndBitwiseAnd(null, 0, true); 2475 }); 2476 checkCCE(() -> { // array reference class 2477 boolean x = (boolean) vh.getAndBitwiseAnd(Void.class, 0, true); 2478 }); 2479 checkWMTE(() -> { // value reference class 2480 boolean x = (boolean) vh.getAndBitwiseAnd(array, 0, Void.class); 2481 }); 2482 checkWMTE(() -> { // array primitive class 2483 boolean x = (boolean) vh.getAndBitwiseAnd(0, 0, true); 2484 }); 2485 checkWMTE(() -> { // index reference class 2486 boolean x = (boolean) vh.getAndBitwiseAnd(array, Void.class, true); 2487 }); 2488 // Incorrect return type 2489 checkWMTE(() -> { // reference class 2490 Void r = (Void) vh.getAndBitwiseAnd(array, 0, true); 2491 }); 2492 checkWMTE(() -> { // primitive class 2493 int x = (int) vh.getAndBitwiseAnd(array, 0, true); 2494 }); 2495 // Incorrect arity 2496 checkWMTE(() -> { // 0 2497 boolean x = (boolean) vh.getAndBitwiseAnd(); 2498 }); 2499 checkWMTE(() -> { // > 2500 boolean x = (boolean) vh.getAndBitwiseAnd(array, 0, true, Void.class); 2501 }); 2502 2503 2504 // GetAndBitwiseAndAcquire 2505 // Incorrect argument types 2506 checkNPE(() -> { // null array 2507 boolean x = (boolean) vh.getAndBitwiseAndAcquire(null, 0, true); 2508 }); 2509 checkCCE(() -> { // array reference class 2510 boolean x = (boolean) vh.getAndBitwiseAndAcquire(Void.class, 0, true); 2511 }); 2512 checkWMTE(() -> { // value reference class 2513 boolean x = (boolean) vh.getAndBitwiseAndAcquire(array, 0, Void.class); 2514 }); 2515 checkWMTE(() -> { // array primitive class 2516 boolean x = (boolean) vh.getAndBitwiseAndAcquire(0, 0, true); 2517 }); 2518 checkWMTE(() -> { // index reference class 2519 boolean x = (boolean) vh.getAndBitwiseAndAcquire(array, Void.class, true); 2520 }); 2521 // Incorrect return type 2522 checkWMTE(() -> { // reference class 2523 Void r = (Void) vh.getAndBitwiseAndAcquire(array, 0, true); 2524 }); 2525 checkWMTE(() -> { // primitive class 2526 int x = (int) vh.getAndBitwiseAndAcquire(array, 0, true); 2527 }); 2528 // Incorrect arity 2529 checkWMTE(() -> { // 0 2530 boolean x = (boolean) vh.getAndBitwiseAndAcquire(); 2531 }); 2532 checkWMTE(() -> { // > 2533 boolean x = (boolean) vh.getAndBitwiseAndAcquire(array, 0, true, Void.class); 2534 }); 2535 2536 2537 // GetAndBitwiseAndRelease 2538 // Incorrect argument types 2539 checkNPE(() -> { // null array 2540 boolean x = (boolean) vh.getAndBitwiseAndRelease(null, 0, true); 2541 }); 2542 checkCCE(() -> { // array reference class 2543 boolean x = (boolean) vh.getAndBitwiseAndRelease(Void.class, 0, true); 2544 }); 2545 checkWMTE(() -> { // value reference class 2546 boolean x = (boolean) vh.getAndBitwiseAndRelease(array, 0, Void.class); 2547 }); 2548 checkWMTE(() -> { // array primitive class 2549 boolean x = (boolean) vh.getAndBitwiseAndRelease(0, 0, true); 2550 }); 2551 checkWMTE(() -> { // index reference class 2552 boolean x = (boolean) vh.getAndBitwiseAndRelease(array, Void.class, true); 2553 }); 2554 // Incorrect return type 2555 checkWMTE(() -> { // reference class 2556 Void r = (Void) vh.getAndBitwiseAndRelease(array, 0, true); 2557 }); 2558 checkWMTE(() -> { // primitive class 2559 int x = (int) vh.getAndBitwiseAndRelease(array, 0, true); 2560 }); 2561 // Incorrect arity 2562 checkWMTE(() -> { // 0 2563 boolean x = (boolean) vh.getAndBitwiseAndRelease(); 2564 }); 2565 checkWMTE(() -> { // > 2566 boolean x = (boolean) vh.getAndBitwiseAndRelease(array, 0, true, Void.class); 2567 }); 2568 2569 2570 // GetAndBitwiseXor 2571 // Incorrect argument types 2572 checkNPE(() -> { // null array 2573 boolean x = (boolean) vh.getAndBitwiseXor(null, 0, true); 2574 }); 2575 checkCCE(() -> { // array reference class 2576 boolean x = (boolean) vh.getAndBitwiseXor(Void.class, 0, true); 2577 }); 2578 checkWMTE(() -> { // value reference class 2579 boolean x = (boolean) vh.getAndBitwiseXor(array, 0, Void.class); 2580 }); 2581 checkWMTE(() -> { // array primitive class 2582 boolean x = (boolean) vh.getAndBitwiseXor(0, 0, true); 2583 }); 2584 checkWMTE(() -> { // index reference class 2585 boolean x = (boolean) vh.getAndBitwiseXor(array, Void.class, true); 2586 }); 2587 // Incorrect return type 2588 checkWMTE(() -> { // reference class 2589 Void r = (Void) vh.getAndBitwiseXor(array, 0, true); 2590 }); 2591 checkWMTE(() -> { // primitive class 2592 int x = (int) vh.getAndBitwiseXor(array, 0, true); 2593 }); 2594 // Incorrect arity 2595 checkWMTE(() -> { // 0 2596 boolean x = (boolean) vh.getAndBitwiseXor(); 2597 }); 2598 checkWMTE(() -> { // > 2599 boolean x = (boolean) vh.getAndBitwiseXor(array, 0, true, Void.class); 2600 }); 2601 2602 2603 // GetAndBitwiseXorAcquire 2604 // Incorrect argument types 2605 checkNPE(() -> { // null array 2606 boolean x = (boolean) vh.getAndBitwiseXorAcquire(null, 0, true); 2607 }); 2608 checkCCE(() -> { // array reference class 2609 boolean x = (boolean) vh.getAndBitwiseXorAcquire(Void.class, 0, true); 2610 }); 2611 checkWMTE(() -> { // value reference class 2612 boolean x = (boolean) vh.getAndBitwiseXorAcquire(array, 0, Void.class); 2613 }); 2614 checkWMTE(() -> { // array primitive class 2615 boolean x = (boolean) vh.getAndBitwiseXorAcquire(0, 0, true); 2616 }); 2617 checkWMTE(() -> { // index reference class 2618 boolean x = (boolean) vh.getAndBitwiseXorAcquire(array, Void.class, true); 2619 }); 2620 // Incorrect return type 2621 checkWMTE(() -> { // reference class 2622 Void r = (Void) vh.getAndBitwiseXorAcquire(array, 0, true); 2623 }); 2624 checkWMTE(() -> { // primitive class 2625 int x = (int) vh.getAndBitwiseXorAcquire(array, 0, true); 2626 }); 2627 // Incorrect arity 2628 checkWMTE(() -> { // 0 2629 boolean x = (boolean) vh.getAndBitwiseXorAcquire(); 2630 }); 2631 checkWMTE(() -> { // > 2632 boolean x = (boolean) vh.getAndBitwiseXorAcquire(array, 0, true, Void.class); 2633 }); 2634 2635 2636 // GetAndBitwiseXorRelease 2637 // Incorrect argument types 2638 checkNPE(() -> { // null array 2639 boolean x = (boolean) vh.getAndBitwiseXorRelease(null, 0, true); 2640 }); 2641 checkCCE(() -> { // array reference class 2642 boolean x = (boolean) vh.getAndBitwiseXorRelease(Void.class, 0, true); 2643 }); 2644 checkWMTE(() -> { // value reference class 2645 boolean x = (boolean) vh.getAndBitwiseXorRelease(array, 0, Void.class); 2646 }); 2647 checkWMTE(() -> { // array primitive class 2648 boolean x = (boolean) vh.getAndBitwiseXorRelease(0, 0, true); 2649 }); 2650 checkWMTE(() -> { // index reference class 2651 boolean x = (boolean) vh.getAndBitwiseXorRelease(array, Void.class, true); 2652 }); 2653 // Incorrect return type 2654 checkWMTE(() -> { // reference class 2655 Void r = (Void) vh.getAndBitwiseXorRelease(array, 0, true); 2656 }); 2657 checkWMTE(() -> { // primitive class 2658 int x = (int) vh.getAndBitwiseXorRelease(array, 0, true); 2659 }); 2660 // Incorrect arity 2661 checkWMTE(() -> { // 0 2662 boolean x = (boolean) vh.getAndBitwiseXorRelease(); 2663 }); 2664 checkWMTE(() -> { // > 2665 boolean x = (boolean) vh.getAndBitwiseXorRelease(array, 0, true, Void.class); 2666 }); 2667 } 2668 2669 static void testArrayWrongMethodType(Handles hs) throws Throwable { 2670 boolean[] array = new boolean[10]; 2671 Arrays.fill(array, true); 2672 2673 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) { 2674 // Incorrect argument types 2675 checkNPE(() -> { // null array 2676 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class)). 2677 invokeExact((boolean[]) null, 0); 2678 }); 2679 hs.checkWMTEOrCCE(() -> { // array reference class 2680 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class, int.class)). 2681 invokeExact(Void.class, 0); 2682 }); 2683 checkWMTE(() -> { // array primitive class 2684 boolean x = (boolean) hs.get(am, methodType(boolean.class, int.class, int.class)). 2685 invokeExact(0, 0); 2686 }); 2687 checkWMTE(() -> { // index reference class 2688 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, Class.class)). 2689 invokeExact(array, Void.class); 2690 }); 2691 // Incorrect return type 2692 checkWMTE(() -> { // reference class 2693 Void x = (Void) hs.get(am, methodType(Void.class, boolean[].class, int.class)). 2694 invokeExact(array, 0); 2695 }); 2696 checkWMTE(() -> { // primitive class 2697 int x = (int) hs.get(am, methodType(int.class, boolean[].class, int.class)). 2698 invokeExact(array, 0); 2699 }); 2700 // Incorrect arity 2701 checkWMTE(() -> { // 0 2702 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 2703 invokeExact(); 2704 }); 2705 checkWMTE(() -> { // > 2706 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, Class.class)). 2707 invokeExact(array, 0, Void.class); 2708 }); 2709 } 2710 2711 for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) { 2712 // Incorrect argument types 2713 checkNPE(() -> { // null array 2714 hs.get(am, methodType(void.class, boolean[].class, int.class, boolean.class)). 2715 invokeExact((boolean[]) null, 0, true); 2716 }); 2717 hs.checkWMTEOrCCE(() -> { // array reference class 2718 hs.get(am, methodType(void.class, Class.class, int.class, boolean.class)). 2719 invokeExact(Void.class, 0, true); 2720 }); 2721 checkWMTE(() -> { // value reference class 2722 hs.get(am, methodType(void.class, boolean[].class, int.class, Class.class)). 2723 invokeExact(array, 0, Void.class); 2724 }); 2725 checkWMTE(() -> { // receiver primitive class 2726 hs.get(am, methodType(void.class, int.class, int.class, boolean.class)). 2727 invokeExact(0, 0, true); 2728 }); 2729 checkWMTE(() -> { // index reference class 2730 hs.get(am, methodType(void.class, boolean[].class, Class.class, boolean.class)). 2731 invokeExact(array, Void.class, true); 2732 }); 2733 // Incorrect arity 2734 checkWMTE(() -> { // 0 2735 hs.get(am, methodType(void.class)). 2736 invokeExact(); 2737 }); 2738 checkWMTE(() -> { // > 2739 hs.get(am, methodType(void.class, boolean[].class, int.class, Class.class)). 2740 invokeExact(array, 0, true, Void.class); 2741 }); 2742 } 2743 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) { 2744 // Incorrect argument types 2745 checkNPE(() -> { // null receiver 2746 boolean r = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class, boolean.class)). 2747 invokeExact((boolean[]) null, 0, true, true); 2748 }); 2749 hs.checkWMTEOrCCE(() -> { // receiver reference class 2750 boolean r = (boolean) hs.get(am, methodType(boolean.class, Class.class, int.class, boolean.class, boolean.class)). 2751 invokeExact(Void.class, 0, true, true); 2752 }); 2753 checkWMTE(() -> { // expected reference class 2754 boolean r = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, Class.class, boolean.class)). 2755 invokeExact(array, 0, Void.class, true); 2756 }); 2757 checkWMTE(() -> { // actual reference class 2758 boolean r = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class, Class.class)). 2759 invokeExact(array, 0, true, Void.class); 2760 }); 2761 checkWMTE(() -> { // receiver primitive class 2762 boolean r = (boolean) hs.get(am, methodType(boolean.class, int.class, int.class, boolean.class, boolean.class)). 2763 invokeExact(0, 0, true, true); 2764 }); 2765 checkWMTE(() -> { // index reference class 2766 boolean r = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, Class.class, boolean.class, boolean.class)). 2767 invokeExact(array, Void.class, true, true); 2768 }); 2769 // Incorrect arity 2770 checkWMTE(() -> { // 0 2771 boolean r = (boolean) hs.get(am, methodType(boolean.class)). 2772 invokeExact(); 2773 }); 2774 checkWMTE(() -> { // > 2775 boolean r = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class, boolean.class, Class.class)). 2776 invokeExact(array, 0, true, true, Void.class); 2777 }); 2778 } 2779 2780 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) { 2781 // Incorrect argument types 2782 checkNPE(() -> { // null receiver 2783 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class, boolean.class)). 2784 invokeExact((boolean[]) null, 0, true, true); 2785 }); 2786 hs.checkWMTEOrCCE(() -> { // array reference class 2787 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class, int.class, boolean.class, boolean.class)). 2788 invokeExact(Void.class, 0, true, true); 2789 }); 2790 checkWMTE(() -> { // expected reference class 2791 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, Class.class, boolean.class)). 2792 invokeExact(array, 0, Void.class, true); 2793 }); 2794 checkWMTE(() -> { // actual reference class 2795 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class, Class.class)). 2796 invokeExact(array, 0, true, Void.class); 2797 }); 2798 checkWMTE(() -> { // array primitive class 2799 boolean x = (boolean) hs.get(am, methodType(boolean.class, int.class, int.class, boolean.class, boolean.class)). 2800 invokeExact(0, 0, true, true); 2801 }); 2802 checkWMTE(() -> { // index reference class 2803 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, Class.class, boolean.class, boolean.class)). 2804 invokeExact(array, Void.class, true, true); 2805 }); 2806 // Incorrect return type 2807 checkWMTE(() -> { // reference class 2808 Void r = (Void) hs.get(am, methodType(Void.class, boolean[].class, int.class, boolean.class, boolean.class)). 2809 invokeExact(array, 0, true, true); 2810 }); 2811 checkWMTE(() -> { // primitive class 2812 int x = (int) hs.get(am, methodType(int.class, boolean[].class, int.class, boolean.class, boolean.class)). 2813 invokeExact(array, 0, true, true); 2814 }); 2815 // Incorrect arity 2816 checkWMTE(() -> { // 0 2817 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 2818 invokeExact(); 2819 }); 2820 checkWMTE(() -> { // > 2821 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class, boolean.class, Class.class)). 2822 invokeExact(array, 0, true, true, Void.class); 2823 }); 2824 } 2825 2826 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) { 2827 // Incorrect argument types 2828 checkNPE(() -> { // null array 2829 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class)). 2830 invokeExact((boolean[]) null, 0, true); 2831 }); 2832 hs.checkWMTEOrCCE(() -> { // array reference class 2833 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class, int.class, boolean.class)). 2834 invokeExact(Void.class, 0, true); 2835 }); 2836 checkWMTE(() -> { // value reference class 2837 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, Class.class)). 2838 invokeExact(array, 0, Void.class); 2839 }); 2840 checkWMTE(() -> { // array primitive class 2841 boolean x = (boolean) hs.get(am, methodType(boolean.class, int.class, int.class, boolean.class)). 2842 invokeExact(0, 0, true); 2843 }); 2844 checkWMTE(() -> { // index reference class 2845 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, Class.class, boolean.class)). 2846 invokeExact(array, Void.class, true); 2847 }); 2848 // Incorrect return type 2849 checkWMTE(() -> { // reference class 2850 Void r = (Void) hs.get(am, methodType(Void.class, boolean[].class, int.class, boolean.class)). 2851 invokeExact(array, 0, true); 2852 }); 2853 checkWMTE(() -> { // primitive class 2854 int x = (int) hs.get(am, methodType(int.class, boolean[].class, int.class, boolean.class)). 2855 invokeExact(array, 0, true); 2856 }); 2857 // Incorrect arity 2858 checkWMTE(() -> { // 0 2859 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 2860 invokeExact(); 2861 }); 2862 checkWMTE(() -> { // > 2863 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class, Class.class)). 2864 invokeExact(array, 0, true, Void.class); 2865 }); 2866 } 2867 2868 2869 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) { 2870 // Incorrect argument types 2871 checkNPE(() -> { // null array 2872 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class)). 2873 invokeExact((boolean[]) null, 0, true); 2874 }); 2875 hs.checkWMTEOrCCE(() -> { // array reference class 2876 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class, int.class, boolean.class)). 2877 invokeExact(Void.class, 0, true); 2878 }); 2879 checkWMTE(() -> { // value reference class 2880 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, Class.class)). 2881 invokeExact(array, 0, Void.class); 2882 }); 2883 checkWMTE(() -> { // array primitive class 2884 boolean x = (boolean) hs.get(am, methodType(boolean.class, int.class, int.class, boolean.class)). 2885 invokeExact(0, 0, true); 2886 }); 2887 checkWMTE(() -> { // index reference class 2888 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, Class.class, boolean.class)). 2889 invokeExact(array, Void.class, true); 2890 }); 2891 // Incorrect return type 2892 checkWMTE(() -> { // reference class 2893 Void r = (Void) hs.get(am, methodType(Void.class, boolean[].class, int.class, boolean.class)). 2894 invokeExact(array, 0, true); 2895 }); 2896 checkWMTE(() -> { // primitive class 2897 int x = (int) hs.get(am, methodType(int.class, boolean[].class, int.class, boolean.class)). 2898 invokeExact(array, 0, true); 2899 }); 2900 // Incorrect arity 2901 checkWMTE(() -> { // 0 2902 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 2903 invokeExact(); 2904 }); 2905 checkWMTE(() -> { // > 2906 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class, Class.class)). 2907 invokeExact(array, 0, true, Void.class); 2908 }); 2909 } 2910 } 2911 }