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