1 /* 2 * Copyright (c) 2015, 2016 Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 /* 25 * @test 26 * @bug 8156486 27 * @run testng/othervm VarHandleTestMethodTypeBoolean 28 * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false VarHandleTestMethodTypeBoolean 29 */ 30 31 import org.testng.annotations.BeforeClass; 32 import org.testng.annotations.DataProvider; 33 import org.testng.annotations.Test; 34 35 import java.lang.invoke.MethodHandles; 36 import java.lang.invoke.VarHandle; 37 import java.util.ArrayList; 38 import java.util.Arrays; 39 import java.util.List; 40 41 import static org.testng.Assert.*; 42 43 import static java.lang.invoke.MethodType.*; 44 45 public class VarHandleTestMethodTypeBoolean extends VarHandleBaseTest { 46 static final boolean static_final_v = true; 47 48 static boolean static_v = true; 49 50 final boolean final_v = true; 51 52 boolean v = true; 53 54 VarHandle vhFinalField; 55 56 VarHandle vhField; 57 58 VarHandle vhStaticField; 59 60 VarHandle vhStaticFinalField; 61 62 VarHandle vhArray; 63 64 @BeforeClass 65 public void setup() throws Exception { 66 vhFinalField = MethodHandles.lookup().findVarHandle( 67 VarHandleTestMethodTypeBoolean.class, "final_v", boolean.class); 68 69 vhField = MethodHandles.lookup().findVarHandle( 70 VarHandleTestMethodTypeBoolean.class, "v", boolean.class); 71 72 vhStaticFinalField = MethodHandles.lookup().findStaticVarHandle( 73 VarHandleTestMethodTypeBoolean.class, "static_final_v", boolean.class); 74 75 vhStaticField = MethodHandles.lookup().findStaticVarHandle( 76 VarHandleTestMethodTypeBoolean.class, "static_v", boolean.class); 77 78 vhArray = MethodHandles.arrayElementVarHandle(boolean[].class); 79 } 80 81 @DataProvider 82 public Object[][] accessTestCaseProvider() throws Exception { 83 List<AccessTestCase<?>> cases = new ArrayList<>(); 84 85 cases.add(new VarHandleAccessTestCase("Instance field", 86 vhField, vh -> testInstanceFieldWrongMethodType(this, vh), 87 false)); 88 89 cases.add(new VarHandleAccessTestCase("Static field", 90 vhStaticField, VarHandleTestMethodTypeBoolean::testStaticFieldWrongMethodType, 91 false)); 92 93 cases.add(new VarHandleAccessTestCase("Array", 94 vhArray, VarHandleTestMethodTypeBoolean::testArrayWrongMethodType, 95 false)); 96 97 for (VarHandleToMethodHandle f : VarHandleToMethodHandle.values()) { 98 cases.add(new MethodHandleAccessTestCase("Instance field", 99 vhField, f, hs -> testInstanceFieldWrongMethodType(this, hs), 100 false)); 101 102 cases.add(new MethodHandleAccessTestCase("Static field", 103 vhStaticField, f, VarHandleTestMethodTypeBoolean::testStaticFieldWrongMethodType, 104 false)); 105 106 cases.add(new MethodHandleAccessTestCase("Array", 107 vhArray, f, VarHandleTestMethodTypeBoolean::testArrayWrongMethodType, 108 false)); 109 } 110 // Work around issue with jtreg summary reporting which truncates 111 // the String result of Object.toString to 30 characters, hence 112 // the first dummy argument 113 return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new); 114 } 115 116 @Test(dataProvider = "accessTestCaseProvider") 117 public <T> void testAccess(String desc, AccessTestCase<T> atc) throws Throwable { 118 T t = atc.get(); 119 int iters = atc.requiresLoop() ? ITERS : 1; 120 for (int c = 0; c < iters; c++) { 121 atc.testAccess(t); 122 } 123 } 124 125 126 static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeBoolean recv, VarHandle vh) throws Throwable { 127 // Get 128 // Incorrect argument types 129 checkNPE(() -> { // null receiver 130 boolean x = (boolean) vh.get(null); 131 }); 132 checkCCE(() -> { // receiver reference class 133 boolean x = (boolean) vh.get(Void.class); 134 }); 135 checkWMTE(() -> { // receiver primitive class 136 boolean x = (boolean) vh.get(0); 137 }); 138 // Incorrect return type 139 checkWMTE(() -> { // reference class 140 Void x = (Void) vh.get(recv); 141 }); 142 checkWMTE(() -> { // primitive class 143 int x = (int) vh.get(recv); 144 }); 145 // Incorrect arity 146 checkWMTE(() -> { // 0 147 boolean x = (boolean) vh.get(); 148 }); 149 checkWMTE(() -> { // > 150 boolean x = (boolean) vh.get(recv, Void.class); 151 }); 152 153 154 // Set 155 // Incorrect argument types 156 checkNPE(() -> { // null receiver 157 vh.set(null, true); 158 }); 159 checkCCE(() -> { // receiver reference class 160 vh.set(Void.class, true); 161 }); 162 checkWMTE(() -> { // value reference class 163 vh.set(recv, Void.class); 164 }); 165 checkWMTE(() -> { // receiver primitive class 166 vh.set(0, true); 167 }); 168 // Incorrect arity 169 checkWMTE(() -> { // 0 170 vh.set(); 171 }); 172 checkWMTE(() -> { // > 173 vh.set(recv, true, Void.class); 174 }); 175 176 177 // GetVolatile 178 // Incorrect argument types 179 checkNPE(() -> { // null receiver 180 boolean x = (boolean) vh.getVolatile(null); 181 }); 182 checkCCE(() -> { // receiver reference class 183 boolean x = (boolean) vh.getVolatile(Void.class); 184 }); 185 checkWMTE(() -> { // receiver primitive class 186 boolean x = (boolean) vh.getVolatile(0); 187 }); 188 // Incorrect return type 189 checkWMTE(() -> { // reference class 190 Void x = (Void) vh.getVolatile(recv); 191 }); 192 checkWMTE(() -> { // primitive class 193 int x = (int) vh.getVolatile(recv); 194 }); 195 // Incorrect arity 196 checkWMTE(() -> { // 0 197 boolean x = (boolean) vh.getVolatile(); 198 }); 199 checkWMTE(() -> { // > 200 boolean x = (boolean) vh.getVolatile(recv, Void.class); 201 }); 202 203 204 // SetVolatile 205 // Incorrect argument types 206 checkNPE(() -> { // null receiver 207 vh.setVolatile(null, true); 208 }); 209 checkCCE(() -> { // receiver reference class 210 vh.setVolatile(Void.class, true); 211 }); 212 checkWMTE(() -> { // value reference class 213 vh.setVolatile(recv, Void.class); 214 }); 215 checkWMTE(() -> { // receiver primitive class 216 vh.setVolatile(0, true); 217 }); 218 // Incorrect arity 219 checkWMTE(() -> { // 0 220 vh.setVolatile(); 221 }); 222 checkWMTE(() -> { // > 223 vh.setVolatile(recv, true, Void.class); 224 }); 225 226 227 // GetOpaque 228 // Incorrect argument types 229 checkNPE(() -> { // null receiver 230 boolean x = (boolean) vh.getOpaque(null); 231 }); 232 checkCCE(() -> { // receiver reference class 233 boolean x = (boolean) vh.getOpaque(Void.class); 234 }); 235 checkWMTE(() -> { // receiver primitive class 236 boolean x = (boolean) vh.getOpaque(0); 237 }); 238 // Incorrect return type 239 checkWMTE(() -> { // reference class 240 Void x = (Void) vh.getOpaque(recv); 241 }); 242 checkWMTE(() -> { // primitive class 243 int x = (int) vh.getOpaque(recv); 244 }); 245 // Incorrect arity 246 checkWMTE(() -> { // 0 247 boolean x = (boolean) vh.getOpaque(); 248 }); 249 checkWMTE(() -> { // > 250 boolean x = (boolean) vh.getOpaque(recv, Void.class); 251 }); 252 253 254 // SetOpaque 255 // Incorrect argument types 256 checkNPE(() -> { // null receiver 257 vh.setOpaque(null, true); 258 }); 259 checkCCE(() -> { // receiver reference class 260 vh.setOpaque(Void.class, true); 261 }); 262 checkWMTE(() -> { // value reference class 263 vh.setOpaque(recv, Void.class); 264 }); 265 checkWMTE(() -> { // receiver primitive class 266 vh.setOpaque(0, true); 267 }); 268 // Incorrect arity 269 checkWMTE(() -> { // 0 270 vh.setOpaque(); 271 }); 272 checkWMTE(() -> { // > 273 vh.setOpaque(recv, true, Void.class); 274 }); 275 276 277 // GetAcquire 278 // Incorrect argument types 279 checkNPE(() -> { // null receiver 280 boolean x = (boolean) vh.getAcquire(null); 281 }); 282 checkCCE(() -> { // receiver reference class 283 boolean x = (boolean) vh.getAcquire(Void.class); 284 }); 285 checkWMTE(() -> { // receiver primitive class 286 boolean x = (boolean) vh.getAcquire(0); 287 }); 288 // Incorrect return type 289 checkWMTE(() -> { // reference class 290 Void x = (Void) vh.getAcquire(recv); 291 }); 292 checkWMTE(() -> { // primitive class 293 int x = (int) vh.getAcquire(recv); 294 }); 295 // Incorrect arity 296 checkWMTE(() -> { // 0 297 boolean x = (boolean) vh.getAcquire(); 298 }); 299 checkWMTE(() -> { // > 300 boolean x = (boolean) vh.getAcquire(recv, Void.class); 301 }); 302 303 304 // SetRelease 305 // Incorrect argument types 306 checkNPE(() -> { // null receiver 307 vh.setRelease(null, true); 308 }); 309 checkCCE(() -> { // receiver reference class 310 vh.setRelease(Void.class, true); 311 }); 312 checkWMTE(() -> { // value reference class 313 vh.setRelease(recv, Void.class); 314 }); 315 checkWMTE(() -> { // receiver primitive class 316 vh.setRelease(0, true); 317 }); 318 // Incorrect arity 319 checkWMTE(() -> { // 0 320 vh.setRelease(); 321 }); 322 checkWMTE(() -> { // > 323 vh.setRelease(recv, true, Void.class); 324 }); 325 326 327 // CompareAndSet 328 // Incorrect argument types 329 checkNPE(() -> { // null receiver 330 boolean r = vh.compareAndSet(null, true, true); 331 }); 332 checkCCE(() -> { // receiver reference class 333 boolean r = vh.compareAndSet(Void.class, true, true); 334 }); 335 checkWMTE(() -> { // expected reference class 336 boolean r = vh.compareAndSet(recv, Void.class, true); 337 }); 338 checkWMTE(() -> { // actual reference class 339 boolean r = vh.compareAndSet(recv, true, Void.class); 340 }); 341 checkWMTE(() -> { // receiver primitive class 342 boolean r = vh.compareAndSet(0, true, true); 343 }); 344 // Incorrect arity 345 checkWMTE(() -> { // 0 346 boolean r = vh.compareAndSet(); 347 }); 348 checkWMTE(() -> { // > 349 boolean r = vh.compareAndSet(recv, true, true, Void.class); 350 }); 351 352 353 // WeakCompareAndSet 354 // Incorrect argument types 355 checkNPE(() -> { // null receiver 356 boolean r = vh.weakCompareAndSet(null, true, true); 357 }); 358 checkCCE(() -> { // receiver reference class 359 boolean r = vh.weakCompareAndSet(Void.class, true, true); 360 }); 361 checkWMTE(() -> { // expected reference class 362 boolean r = vh.weakCompareAndSet(recv, Void.class, true); 363 }); 364 checkWMTE(() -> { // actual reference class 365 boolean r = vh.weakCompareAndSet(recv, true, Void.class); 366 }); 367 checkWMTE(() -> { // receiver primitive class 368 boolean r = vh.weakCompareAndSet(0, true, true); 369 }); 370 // Incorrect arity 371 checkWMTE(() -> { // 0 372 boolean r = vh.weakCompareAndSet(); 373 }); 374 checkWMTE(() -> { // > 375 boolean r = vh.weakCompareAndSet(recv, true, true, Void.class); 376 }); 377 378 379 // WeakCompareAndSetVolatile 380 // Incorrect argument types 381 checkNPE(() -> { // null receiver 382 boolean r = vh.weakCompareAndSetVolatile(null, true, true); 383 }); 384 checkCCE(() -> { // receiver reference class 385 boolean r = vh.weakCompareAndSetVolatile(Void.class, true, true); 386 }); 387 checkWMTE(() -> { // expected reference class 388 boolean r = vh.weakCompareAndSetVolatile(recv, Void.class, true); 389 }); 390 checkWMTE(() -> { // actual reference class 391 boolean r = vh.weakCompareAndSetVolatile(recv, true, Void.class); 392 }); 393 checkWMTE(() -> { // receiver primitive class 394 boolean r = vh.weakCompareAndSetVolatile(0, true, true); 395 }); 396 // Incorrect arity 397 checkWMTE(() -> { // 0 398 boolean r = vh.weakCompareAndSetVolatile(); 399 }); 400 checkWMTE(() -> { // > 401 boolean r = vh.weakCompareAndSetVolatile(recv, true, true, Void.class); 402 }); 403 404 405 // WeakCompareAndSetAcquire 406 // Incorrect argument types 407 checkNPE(() -> { // null receiver 408 boolean r = vh.weakCompareAndSetAcquire(null, true, true); 409 }); 410 checkCCE(() -> { // receiver reference class 411 boolean r = vh.weakCompareAndSetAcquire(Void.class, true, true); 412 }); 413 checkWMTE(() -> { // expected reference class 414 boolean r = vh.weakCompareAndSetAcquire(recv, Void.class, true); 415 }); 416 checkWMTE(() -> { // actual reference class 417 boolean r = vh.weakCompareAndSetAcquire(recv, true, Void.class); 418 }); 419 checkWMTE(() -> { // receiver primitive class 420 boolean r = vh.weakCompareAndSetAcquire(0, true, true); 421 }); 422 // Incorrect arity 423 checkWMTE(() -> { // 0 424 boolean r = vh.weakCompareAndSetAcquire(); 425 }); 426 checkWMTE(() -> { // > 427 boolean r = vh.weakCompareAndSetAcquire(recv, true, true, Void.class); 428 }); 429 430 431 // WeakCompareAndSetRelease 432 // Incorrect argument types 433 checkNPE(() -> { // null receiver 434 boolean r = vh.weakCompareAndSetRelease(null, true, true); 435 }); 436 checkCCE(() -> { // receiver reference class 437 boolean r = vh.weakCompareAndSetRelease(Void.class, true, true); 438 }); 439 checkWMTE(() -> { // expected reference class 440 boolean r = vh.weakCompareAndSetRelease(recv, Void.class, true); 441 }); 442 checkWMTE(() -> { // actual reference class 443 boolean r = vh.weakCompareAndSetRelease(recv, true, Void.class); 444 }); 445 checkWMTE(() -> { // receiver primitive class 446 boolean r = vh.weakCompareAndSetRelease(0, true, true); 447 }); 448 // Incorrect arity 449 checkWMTE(() -> { // 0 450 boolean r = vh.weakCompareAndSetRelease(); 451 }); 452 checkWMTE(() -> { // > 453 boolean r = vh.weakCompareAndSetRelease(recv, true, true, Void.class); 454 }); 455 456 457 // CompareAndExchange 458 // Incorrect argument types 459 checkNPE(() -> { // null receiver 460 boolean x = (boolean) vh.compareAndExchange(null, true, true); 461 }); 462 checkCCE(() -> { // receiver reference class 463 boolean x = (boolean) vh.compareAndExchange(Void.class, true, true); 464 }); 465 checkWMTE(() -> { // expected reference class 466 boolean x = (boolean) vh.compareAndExchange(recv, Void.class, true); 467 }); 468 checkWMTE(() -> { // actual reference class 469 boolean x = (boolean) vh.compareAndExchange(recv, true, Void.class); 470 }); 471 checkWMTE(() -> { // reciever primitive class 472 boolean x = (boolean) vh.compareAndExchange(0, true, true); 473 }); 474 // Incorrect return type 475 checkWMTE(() -> { // reference class 476 Void r = (Void) vh.compareAndExchange(recv, true, true); 477 }); 478 checkWMTE(() -> { // primitive class 479 int x = (int) vh.compareAndExchange(recv, true, true); 480 }); 481 // Incorrect arity 482 checkWMTE(() -> { // 0 483 boolean x = (boolean) vh.compareAndExchange(); 484 }); 485 checkWMTE(() -> { // > 486 boolean x = (boolean) vh.compareAndExchange(recv, true, true, Void.class); 487 }); 488 489 490 // CompareAndExchangeAcquire 491 // Incorrect argument types 492 checkNPE(() -> { // null receiver 493 boolean x = (boolean) vh.compareAndExchangeAcquire(null, true, true); 494 }); 495 checkCCE(() -> { // receiver reference class 496 boolean x = (boolean) vh.compareAndExchangeAcquire(Void.class, true, true); 497 }); 498 checkWMTE(() -> { // expected reference class 499 boolean x = (boolean) vh.compareAndExchangeAcquire(recv, Void.class, true); 500 }); 501 checkWMTE(() -> { // actual reference class 502 boolean x = (boolean) vh.compareAndExchangeAcquire(recv, true, Void.class); 503 }); 504 checkWMTE(() -> { // reciever primitive class 505 boolean x = (boolean) vh.compareAndExchangeAcquire(0, true, true); 506 }); 507 // Incorrect return type 508 checkWMTE(() -> { // reference class 509 Void r = (Void) vh.compareAndExchangeAcquire(recv, true, true); 510 }); 511 checkWMTE(() -> { // primitive class 512 int x = (int) vh.compareAndExchangeAcquire(recv, true, true); 513 }); 514 // Incorrect arity 515 checkWMTE(() -> { // 0 516 boolean x = (boolean) vh.compareAndExchangeAcquire(); 517 }); 518 checkWMTE(() -> { // > 519 boolean x = (boolean) vh.compareAndExchangeAcquire(recv, true, true, Void.class); 520 }); 521 522 523 // CompareAndExchangeRelease 524 // Incorrect argument types 525 checkNPE(() -> { // null receiver 526 boolean x = (boolean) vh.compareAndExchangeRelease(null, true, true); 527 }); 528 checkCCE(() -> { // receiver reference class 529 boolean x = (boolean) vh.compareAndExchangeRelease(Void.class, true, true); 530 }); 531 checkWMTE(() -> { // expected reference class 532 boolean x = (boolean) vh.compareAndExchangeRelease(recv, Void.class, true); 533 }); 534 checkWMTE(() -> { // actual reference class 535 boolean x = (boolean) vh.compareAndExchangeRelease(recv, true, Void.class); 536 }); 537 checkWMTE(() -> { // reciever primitive class 538 boolean x = (boolean) vh.compareAndExchangeRelease(0, true, true); 539 }); 540 // Incorrect return type 541 checkWMTE(() -> { // reference class 542 Void r = (Void) vh.compareAndExchangeRelease(recv, true, true); 543 }); 544 checkWMTE(() -> { // primitive class 545 int x = (int) vh.compareAndExchangeRelease(recv, true, true); 546 }); 547 // Incorrect arity 548 checkWMTE(() -> { // 0 549 boolean x = (boolean) vh.compareAndExchangeRelease(); 550 }); 551 checkWMTE(() -> { // > 552 boolean x = (boolean) vh.compareAndExchangeRelease(recv, true, true, Void.class); 553 }); 554 555 556 // GetAndSet 557 // Incorrect argument types 558 checkNPE(() -> { // null receiver 559 boolean x = (boolean) vh.getAndSet(null, true); 560 }); 561 checkCCE(() -> { // receiver reference class 562 boolean x = (boolean) vh.getAndSet(Void.class, true); 563 }); 564 checkWMTE(() -> { // value reference class 565 boolean x = (boolean) vh.getAndSet(recv, Void.class); 566 }); 567 checkWMTE(() -> { // reciever primitive class 568 boolean x = (boolean) vh.getAndSet(0, true); 569 }); 570 // Incorrect return type 571 checkWMTE(() -> { // reference class 572 Void r = (Void) vh.getAndSet(recv, true); 573 }); 574 checkWMTE(() -> { // primitive class 575 int x = (int) vh.getAndSet(recv, true); 576 }); 577 // Incorrect arity 578 checkWMTE(() -> { // 0 579 boolean x = (boolean) vh.getAndSet(); 580 }); 581 checkWMTE(() -> { // > 582 boolean x = (boolean) vh.getAndSet(recv, true, Void.class); 583 }); 584 585 } 586 587 static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeBoolean recv, Handles hs) throws Throwable { 588 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) { 589 // Incorrect argument types 590 checkNPE(() -> { // null receiver 591 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class)). 592 invokeExact((VarHandleTestMethodTypeBoolean) null); 593 }); 594 hs.checkWMTEOrCCE(() -> { // receiver reference class 595 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class)). 596 invokeExact(Void.class); 597 }); 598 checkWMTE(() -> { // receiver primitive class 599 boolean x = (boolean) hs.get(am, methodType(boolean.class, int.class)). 600 invokeExact(0); 601 }); 602 // Incorrect return type 603 checkWMTE(() -> { // reference class 604 Void x = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodTypeBoolean.class)). 605 invokeExact(recv); 606 }); 607 checkWMTE(() -> { // primitive class 608 int x = (int) hs.get(am, methodType(int.class, VarHandleTestMethodTypeBoolean.class)). 609 invokeExact(recv); 610 }); 611 // Incorrect arity 612 checkWMTE(() -> { // 0 613 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 614 invokeExact(); 615 }); 616 checkWMTE(() -> { // > 617 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, Class.class)). 618 invokeExact(recv, Void.class); 619 }); 620 } 621 622 for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) { 623 // Incorrect argument types 624 checkNPE(() -> { // null receiver 625 hs.get(am, methodType(void.class, VarHandleTestMethodTypeBoolean.class, boolean.class)). 626 invokeExact((VarHandleTestMethodTypeBoolean) null, true); 627 }); 628 hs.checkWMTEOrCCE(() -> { // receiver reference class 629 hs.get(am, methodType(void.class, Class.class, boolean.class)). 630 invokeExact(Void.class, true); 631 }); 632 checkWMTE(() -> { // value reference class 633 hs.get(am, methodType(void.class, VarHandleTestMethodTypeBoolean.class, Class.class)). 634 invokeExact(recv, Void.class); 635 }); 636 checkWMTE(() -> { // receiver primitive class 637 hs.get(am, methodType(void.class, int.class, boolean.class)). 638 invokeExact(0, true); 639 }); 640 // Incorrect arity 641 checkWMTE(() -> { // 0 642 hs.get(am, methodType(void.class)). 643 invokeExact(); 644 }); 645 checkWMTE(() -> { // > 646 hs.get(am, methodType(void.class, VarHandleTestMethodTypeBoolean.class, boolean.class, Class.class)). 647 invokeExact(recv, true, Void.class); 648 }); 649 } 650 651 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) { 652 // Incorrect argument types 653 checkNPE(() -> { // null receiver 654 boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class, boolean.class)). 655 invokeExact((VarHandleTestMethodTypeBoolean) null, true, true); 656 }); 657 hs.checkWMTEOrCCE(() -> { // receiver reference class 658 boolean r = (boolean) hs.get(am, methodType(boolean.class, Class.class, boolean.class, boolean.class)). 659 invokeExact(Void.class, true, true); 660 }); 661 checkWMTE(() -> { // expected reference class 662 boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, Class.class, boolean.class)). 663 invokeExact(recv, Void.class, true); 664 }); 665 checkWMTE(() -> { // actual reference class 666 boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class, Class.class)). 667 invokeExact(recv, true, Void.class); 668 }); 669 checkWMTE(() -> { // receiver primitive class 670 boolean r = (boolean) hs.get(am, methodType(boolean.class, int.class , boolean.class, boolean.class)). 671 invokeExact(0, true, true); 672 }); 673 // Incorrect arity 674 checkWMTE(() -> { // 0 675 boolean r = (boolean) hs.get(am, methodType(boolean.class)). 676 invokeExact(); 677 }); 678 checkWMTE(() -> { // > 679 boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class, boolean.class, Class.class)). 680 invokeExact(recv, true, true, Void.class); 681 }); 682 } 683 684 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) { 685 checkNPE(() -> { // null receiver 686 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class, boolean.class)). 687 invokeExact((VarHandleTestMethodTypeBoolean) null, true, true); 688 }); 689 hs.checkWMTEOrCCE(() -> { // receiver reference class 690 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class, boolean.class, boolean.class)). 691 invokeExact(Void.class, true, true); 692 }); 693 checkWMTE(() -> { // expected reference class 694 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, Class.class, boolean.class)). 695 invokeExact(recv, Void.class, true); 696 }); 697 checkWMTE(() -> { // actual reference class 698 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class, Class.class)). 699 invokeExact(recv, true, Void.class); 700 }); 701 checkWMTE(() -> { // reciever primitive class 702 boolean x = (boolean) hs.get(am, methodType(boolean.class, int.class , boolean.class, boolean.class)). 703 invokeExact(0, true, true); 704 }); 705 // Incorrect return type 706 checkWMTE(() -> { // reference class 707 Void r = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodTypeBoolean.class , boolean.class, boolean.class)). 708 invokeExact(recv, true, true); 709 }); 710 checkWMTE(() -> { // primitive class 711 int x = (int) hs.get(am, methodType(int.class, VarHandleTestMethodTypeBoolean.class , boolean.class, boolean.class)). 712 invokeExact(recv, true, true); 713 }); 714 // Incorrect arity 715 checkWMTE(() -> { // 0 716 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 717 invokeExact(); 718 }); 719 checkWMTE(() -> { // > 720 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class, boolean.class, Class.class)). 721 invokeExact(recv, true, true, Void.class); 722 }); 723 } 724 725 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) { 726 checkNPE(() -> { // null receiver 727 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class)). 728 invokeExact((VarHandleTestMethodTypeBoolean) null, true); 729 }); 730 hs.checkWMTEOrCCE(() -> { // receiver reference class 731 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class, boolean.class)). 732 invokeExact(Void.class, true); 733 }); 734 checkWMTE(() -> { // value reference class 735 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, Class.class)). 736 invokeExact(recv, Void.class); 737 }); 738 checkWMTE(() -> { // reciever primitive class 739 boolean x = (boolean) hs.get(am, methodType(boolean.class, int.class, boolean.class)). 740 invokeExact(0, true); 741 }); 742 // Incorrect return type 743 checkWMTE(() -> { // reference class 744 Void r = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodTypeBoolean.class, boolean.class)). 745 invokeExact(recv, true); 746 }); 747 checkWMTE(() -> { // primitive class 748 int x = (int) hs.get(am, methodType(int.class, VarHandleTestMethodTypeBoolean.class, boolean.class)). 749 invokeExact(recv, true); 750 }); 751 // Incorrect arity 752 checkWMTE(() -> { // 0 753 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 754 invokeExact(); 755 }); 756 checkWMTE(() -> { // > 757 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeBoolean.class, boolean.class)). 758 invokeExact(recv, true, Void.class); 759 }); 760 } 761 762 } 763 764 765 static void testStaticFieldWrongMethodType(VarHandle vh) throws Throwable { 766 // Get 767 // Incorrect return type 768 checkWMTE(() -> { // reference class 769 Void x = (Void) vh.get(); 770 }); 771 checkWMTE(() -> { // primitive class 772 int x = (int) vh.get(); 773 }); 774 // Incorrect arity 775 checkWMTE(() -> { // > 776 boolean x = (boolean) vh.get(Void.class); 777 }); 778 779 780 // Set 781 // Incorrect argument types 782 checkWMTE(() -> { // value reference class 783 vh.set(Void.class); 784 }); 785 // Incorrect arity 786 checkWMTE(() -> { // 0 787 vh.set(); 788 }); 789 checkWMTE(() -> { // > 790 vh.set(true, Void.class); 791 }); 792 793 794 // GetVolatile 795 // Incorrect return type 796 checkWMTE(() -> { // reference class 797 Void x = (Void) vh.getVolatile(); 798 }); 799 checkWMTE(() -> { // primitive class 800 int x = (int) vh.getVolatile(); 801 }); 802 checkWMTE(() -> { // > 803 boolean x = (boolean) vh.getVolatile(Void.class); 804 }); 805 806 807 // SetVolatile 808 // Incorrect argument types 809 checkWMTE(() -> { // value reference class 810 vh.setVolatile(Void.class); 811 }); 812 // Incorrect arity 813 checkWMTE(() -> { // 0 814 vh.setVolatile(); 815 }); 816 checkWMTE(() -> { // > 817 vh.setVolatile(true, Void.class); 818 }); 819 820 821 // GetOpaque 822 // Incorrect return type 823 checkWMTE(() -> { // reference class 824 Void x = (Void) vh.getOpaque(); 825 }); 826 checkWMTE(() -> { // primitive class 827 int x = (int) vh.getOpaque(); 828 }); 829 checkWMTE(() -> { // > 830 boolean x = (boolean) vh.getOpaque(Void.class); 831 }); 832 833 834 // SetOpaque 835 // Incorrect argument types 836 checkWMTE(() -> { // value reference class 837 vh.setOpaque(Void.class); 838 }); 839 // Incorrect arity 840 checkWMTE(() -> { // 0 841 vh.setOpaque(); 842 }); 843 checkWMTE(() -> { // > 844 vh.setOpaque(true, Void.class); 845 }); 846 847 848 // GetAcquire 849 // Incorrect return type 850 checkWMTE(() -> { // reference class 851 Void x = (Void) vh.getAcquire(); 852 }); 853 checkWMTE(() -> { // primitive class 854 int x = (int) vh.getAcquire(); 855 }); 856 checkWMTE(() -> { // > 857 boolean x = (boolean) vh.getAcquire(Void.class); 858 }); 859 860 861 // SetRelease 862 // Incorrect argument types 863 checkWMTE(() -> { // value reference class 864 vh.setRelease(Void.class); 865 }); 866 // Incorrect arity 867 checkWMTE(() -> { // 0 868 vh.setRelease(); 869 }); 870 checkWMTE(() -> { // > 871 vh.setRelease(true, Void.class); 872 }); 873 874 875 // CompareAndSet 876 // Incorrect argument types 877 checkWMTE(() -> { // expected reference class 878 boolean r = vh.compareAndSet(Void.class, true); 879 }); 880 checkWMTE(() -> { // actual reference class 881 boolean r = vh.compareAndSet(true, Void.class); 882 }); 883 // Incorrect arity 884 checkWMTE(() -> { // 0 885 boolean r = vh.compareAndSet(); 886 }); 887 checkWMTE(() -> { // > 888 boolean r = vh.compareAndSet(true, true, Void.class); 889 }); 890 891 892 // WeakCompareAndSet 893 // Incorrect argument types 894 checkWMTE(() -> { // expected reference class 895 boolean r = vh.weakCompareAndSet(Void.class, true); 896 }); 897 checkWMTE(() -> { // actual reference class 898 boolean r = vh.weakCompareAndSet(true, Void.class); 899 }); 900 // Incorrect arity 901 checkWMTE(() -> { // 0 902 boolean r = vh.weakCompareAndSet(); 903 }); 904 checkWMTE(() -> { // > 905 boolean r = vh.weakCompareAndSet(true, true, Void.class); 906 }); 907 908 909 // WeakCompareAndSetVolatile 910 // Incorrect argument types 911 checkWMTE(() -> { // expected reference class 912 boolean r = vh.weakCompareAndSetVolatile(Void.class, true); 913 }); 914 checkWMTE(() -> { // actual reference class 915 boolean r = vh.weakCompareAndSetVolatile(true, Void.class); 916 }); 917 // Incorrect arity 918 checkWMTE(() -> { // 0 919 boolean r = vh.weakCompareAndSetVolatile(); 920 }); 921 checkWMTE(() -> { // > 922 boolean r = vh.weakCompareAndSetVolatile(true, true, Void.class); 923 }); 924 925 926 // WeakCompareAndSetAcquire 927 // Incorrect argument types 928 checkWMTE(() -> { // expected reference class 929 boolean r = vh.weakCompareAndSetAcquire(Void.class, true); 930 }); 931 checkWMTE(() -> { // actual reference class 932 boolean r = vh.weakCompareAndSetAcquire(true, Void.class); 933 }); 934 // Incorrect arity 935 checkWMTE(() -> { // 0 936 boolean r = vh.weakCompareAndSetAcquire(); 937 }); 938 checkWMTE(() -> { // > 939 boolean r = vh.weakCompareAndSetAcquire(true, true, Void.class); 940 }); 941 942 943 // WeakCompareAndSetRelease 944 // Incorrect argument types 945 checkWMTE(() -> { // expected reference class 946 boolean r = vh.weakCompareAndSetRelease(Void.class, true); 947 }); 948 checkWMTE(() -> { // actual reference class 949 boolean r = vh.weakCompareAndSetRelease(true, Void.class); 950 }); 951 // Incorrect arity 952 checkWMTE(() -> { // 0 953 boolean r = vh.weakCompareAndSetRelease(); 954 }); 955 checkWMTE(() -> { // > 956 boolean r = vh.weakCompareAndSetRelease(true, true, Void.class); 957 }); 958 959 960 // CompareAndExchange 961 // Incorrect argument types 962 checkWMTE(() -> { // expected reference class 963 boolean x = (boolean) vh.compareAndExchange(Void.class, true); 964 }); 965 checkWMTE(() -> { // actual reference class 966 boolean x = (boolean) vh.compareAndExchange(true, Void.class); 967 }); 968 // Incorrect return type 969 checkWMTE(() -> { // reference class 970 Void r = (Void) vh.compareAndExchange(true, true); 971 }); 972 checkWMTE(() -> { // primitive class 973 int x = (int) vh.compareAndExchange(true, true); 974 }); 975 // Incorrect arity 976 checkWMTE(() -> { // 0 977 boolean x = (boolean) vh.compareAndExchange(); 978 }); 979 checkWMTE(() -> { // > 980 boolean x = (boolean) vh.compareAndExchange(true, true, Void.class); 981 }); 982 983 984 // CompareAndExchangeAcquire 985 // Incorrect argument types 986 checkWMTE(() -> { // expected reference class 987 boolean x = (boolean) vh.compareAndExchangeAcquire(Void.class, true); 988 }); 989 checkWMTE(() -> { // actual reference class 990 boolean x = (boolean) vh.compareAndExchangeAcquire(true, Void.class); 991 }); 992 // Incorrect return type 993 checkWMTE(() -> { // reference class 994 Void r = (Void) vh.compareAndExchangeAcquire(true, true); 995 }); 996 checkWMTE(() -> { // primitive class 997 int x = (int) vh.compareAndExchangeAcquire(true, true); 998 }); 999 // Incorrect arity 1000 checkWMTE(() -> { // 0 1001 boolean x = (boolean) vh.compareAndExchangeAcquire(); 1002 }); 1003 checkWMTE(() -> { // > 1004 boolean x = (boolean) vh.compareAndExchangeAcquire(true, true, Void.class); 1005 }); 1006 1007 1008 // CompareAndExchangeRelease 1009 // Incorrect argument types 1010 checkWMTE(() -> { // expected reference class 1011 boolean x = (boolean) vh.compareAndExchangeRelease(Void.class, true); 1012 }); 1013 checkWMTE(() -> { // actual reference class 1014 boolean x = (boolean) vh.compareAndExchangeRelease(true, Void.class); 1015 }); 1016 // Incorrect return type 1017 checkWMTE(() -> { // reference class 1018 Void r = (Void) vh.compareAndExchangeRelease(true, true); 1019 }); 1020 checkWMTE(() -> { // primitive class 1021 int x = (int) vh.compareAndExchangeRelease(true, true); 1022 }); 1023 // Incorrect arity 1024 checkWMTE(() -> { // 0 1025 boolean x = (boolean) vh.compareAndExchangeRelease(); 1026 }); 1027 checkWMTE(() -> { // > 1028 boolean x = (boolean) vh.compareAndExchangeRelease(true, true, Void.class); 1029 }); 1030 1031 1032 // GetAndSet 1033 // Incorrect argument types 1034 checkWMTE(() -> { // value reference class 1035 boolean x = (boolean) vh.getAndSet(Void.class); 1036 }); 1037 // Incorrect return type 1038 checkWMTE(() -> { // reference class 1039 Void r = (Void) vh.getAndSet(true); 1040 }); 1041 checkWMTE(() -> { // primitive class 1042 int x = (int) vh.getAndSet(true); 1043 }); 1044 // Incorrect arity 1045 checkWMTE(() -> { // 0 1046 boolean x = (boolean) vh.getAndSet(); 1047 }); 1048 checkWMTE(() -> { // > 1049 boolean x = (boolean) vh.getAndSet(true, Void.class); 1050 }); 1051 1052 } 1053 1054 static void testStaticFieldWrongMethodType(Handles hs) throws Throwable { 1055 int i = 0; 1056 1057 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) { 1058 // Incorrect return type 1059 checkWMTE(() -> { // reference class 1060 Void x = (Void) hs.get(am, methodType(Void.class)). 1061 invokeExact(); 1062 }); 1063 checkWMTE(() -> { // primitive class 1064 int x = (int) hs.get(am, methodType(int.class)). 1065 invokeExact(); 1066 }); 1067 // Incorrect arity 1068 checkWMTE(() -> { // > 1069 boolean x = (boolean) hs.get(am, methodType(Class.class)). 1070 invokeExact(Void.class); 1071 }); 1072 } 1073 1074 for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) { 1075 checkWMTE(() -> { // value reference class 1076 hs.get(am, methodType(void.class, Class.class)). 1077 invokeExact(Void.class); 1078 }); 1079 // Incorrect arity 1080 checkWMTE(() -> { // 0 1081 hs.get(am, methodType(void.class)). 1082 invokeExact(); 1083 }); 1084 checkWMTE(() -> { // > 1085 hs.get(am, methodType(void.class, boolean.class, Class.class)). 1086 invokeExact(true, Void.class); 1087 }); 1088 } 1089 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) { 1090 // Incorrect argument types 1091 checkWMTE(() -> { // expected reference class 1092 boolean r = (boolean) hs.get(am, methodType(boolean.class, Class.class, boolean.class)). 1093 invokeExact(Void.class, true); 1094 }); 1095 checkWMTE(() -> { // actual reference class 1096 boolean r = (boolean) hs.get(am, methodType(boolean.class, boolean.class, Class.class)). 1097 invokeExact(true, Void.class); 1098 }); 1099 // Incorrect arity 1100 checkWMTE(() -> { // 0 1101 boolean r = (boolean) hs.get(am, methodType(boolean.class)). 1102 invokeExact(); 1103 }); 1104 checkWMTE(() -> { // > 1105 boolean r = (boolean) hs.get(am, methodType(boolean.class, boolean.class, boolean.class, Class.class)). 1106 invokeExact(true, true, Void.class); 1107 }); 1108 } 1109 1110 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) { 1111 // Incorrect argument types 1112 checkWMTE(() -> { // expected reference class 1113 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class, boolean.class)). 1114 invokeExact(Void.class, true); 1115 }); 1116 checkWMTE(() -> { // actual reference class 1117 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean.class, Class.class)). 1118 invokeExact(true, Void.class); 1119 }); 1120 // Incorrect return type 1121 checkWMTE(() -> { // reference class 1122 Void r = (Void) hs.get(am, methodType(Void.class, boolean.class, boolean.class)). 1123 invokeExact(true, true); 1124 }); 1125 checkWMTE(() -> { // primitive class 1126 int x = (int) hs.get(am, methodType(int.class, boolean.class, boolean.class)). 1127 invokeExact(true, true); 1128 }); 1129 // Incorrect arity 1130 checkWMTE(() -> { // 0 1131 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 1132 invokeExact(); 1133 }); 1134 checkWMTE(() -> { // > 1135 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean.class, boolean.class, Class.class)). 1136 invokeExact(true, true, Void.class); 1137 }); 1138 } 1139 1140 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) { 1141 // Incorrect argument types 1142 checkWMTE(() -> { // value reference class 1143 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class)). 1144 invokeExact(Void.class); 1145 }); 1146 // Incorrect return type 1147 checkWMTE(() -> { // reference class 1148 Void r = (Void) hs.get(am, methodType(Void.class, boolean.class)). 1149 invokeExact(true); 1150 }); 1151 checkWMTE(() -> { // primitive class 1152 int x = (int) hs.get(am, methodType(int.class, boolean.class)). 1153 invokeExact(true); 1154 }); 1155 // Incorrect arity 1156 checkWMTE(() -> { // 0 1157 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 1158 invokeExact(); 1159 }); 1160 checkWMTE(() -> { // > 1161 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean.class, Class.class)). 1162 invokeExact(true, Void.class); 1163 }); 1164 } 1165 1166 } 1167 1168 1169 static void testArrayWrongMethodType(VarHandle vh) throws Throwable { 1170 boolean[] array = new boolean[10]; 1171 Arrays.fill(array, true); 1172 1173 // Get 1174 // Incorrect argument types 1175 checkNPE(() -> { // null array 1176 boolean x = (boolean) vh.get(null, 0); 1177 }); 1178 checkCCE(() -> { // array reference class 1179 boolean x = (boolean) vh.get(Void.class, 0); 1180 }); 1181 checkWMTE(() -> { // array primitive class 1182 boolean x = (boolean) vh.get(0, 0); 1183 }); 1184 checkWMTE(() -> { // index reference class 1185 boolean x = (boolean) vh.get(array, Void.class); 1186 }); 1187 // Incorrect return type 1188 checkWMTE(() -> { // reference class 1189 Void x = (Void) vh.get(array, 0); 1190 }); 1191 checkWMTE(() -> { // primitive class 1192 int x = (int) vh.get(array, 0); 1193 }); 1194 // Incorrect arity 1195 checkWMTE(() -> { // 0 1196 boolean x = (boolean) vh.get(); 1197 }); 1198 checkWMTE(() -> { // > 1199 boolean x = (boolean) vh.get(array, 0, Void.class); 1200 }); 1201 1202 1203 // Set 1204 // Incorrect argument types 1205 checkNPE(() -> { // null array 1206 vh.set(null, 0, true); 1207 }); 1208 checkCCE(() -> { // array reference class 1209 vh.set(Void.class, 0, true); 1210 }); 1211 checkWMTE(() -> { // value reference class 1212 vh.set(array, 0, Void.class); 1213 }); 1214 checkWMTE(() -> { // receiver primitive class 1215 vh.set(0, 0, true); 1216 }); 1217 checkWMTE(() -> { // index reference class 1218 vh.set(array, Void.class, true); 1219 }); 1220 // Incorrect arity 1221 checkWMTE(() -> { // 0 1222 vh.set(); 1223 }); 1224 checkWMTE(() -> { // > 1225 vh.set(array, 0, true, Void.class); 1226 }); 1227 1228 1229 // GetVolatile 1230 // Incorrect argument types 1231 checkNPE(() -> { // null array 1232 boolean x = (boolean) vh.getVolatile(null, 0); 1233 }); 1234 checkCCE(() -> { // array reference class 1235 boolean x = (boolean) vh.getVolatile(Void.class, 0); 1236 }); 1237 checkWMTE(() -> { // array primitive class 1238 boolean x = (boolean) vh.getVolatile(0, 0); 1239 }); 1240 checkWMTE(() -> { // index reference class 1241 boolean x = (boolean) vh.getVolatile(array, Void.class); 1242 }); 1243 // Incorrect return type 1244 checkWMTE(() -> { // reference class 1245 Void x = (Void) vh.getVolatile(array, 0); 1246 }); 1247 checkWMTE(() -> { // primitive class 1248 int x = (int) vh.getVolatile(array, 0); 1249 }); 1250 // Incorrect arity 1251 checkWMTE(() -> { // 0 1252 boolean x = (boolean) vh.getVolatile(); 1253 }); 1254 checkWMTE(() -> { // > 1255 boolean x = (boolean) vh.getVolatile(array, 0, Void.class); 1256 }); 1257 1258 1259 // SetVolatile 1260 // Incorrect argument types 1261 checkNPE(() -> { // null array 1262 vh.setVolatile(null, 0, true); 1263 }); 1264 checkCCE(() -> { // array reference class 1265 vh.setVolatile(Void.class, 0, true); 1266 }); 1267 checkWMTE(() -> { // value reference class 1268 vh.setVolatile(array, 0, Void.class); 1269 }); 1270 checkWMTE(() -> { // receiver primitive class 1271 vh.setVolatile(0, 0, true); 1272 }); 1273 checkWMTE(() -> { // index reference class 1274 vh.setVolatile(array, Void.class, true); 1275 }); 1276 // Incorrect arity 1277 checkWMTE(() -> { // 0 1278 vh.setVolatile(); 1279 }); 1280 checkWMTE(() -> { // > 1281 vh.setVolatile(array, 0, true, Void.class); 1282 }); 1283 1284 1285 // GetOpaque 1286 // Incorrect argument types 1287 checkNPE(() -> { // null array 1288 boolean x = (boolean) vh.getOpaque(null, 0); 1289 }); 1290 checkCCE(() -> { // array reference class 1291 boolean x = (boolean) vh.getOpaque(Void.class, 0); 1292 }); 1293 checkWMTE(() -> { // array primitive class 1294 boolean x = (boolean) vh.getOpaque(0, 0); 1295 }); 1296 checkWMTE(() -> { // index reference class 1297 boolean x = (boolean) vh.getOpaque(array, Void.class); 1298 }); 1299 // Incorrect return type 1300 checkWMTE(() -> { // reference class 1301 Void x = (Void) vh.getOpaque(array, 0); 1302 }); 1303 checkWMTE(() -> { // primitive class 1304 int x = (int) vh.getOpaque(array, 0); 1305 }); 1306 // Incorrect arity 1307 checkWMTE(() -> { // 0 1308 boolean x = (boolean) vh.getOpaque(); 1309 }); 1310 checkWMTE(() -> { // > 1311 boolean x = (boolean) vh.getOpaque(array, 0, Void.class); 1312 }); 1313 1314 1315 // SetOpaque 1316 // Incorrect argument types 1317 checkNPE(() -> { // null array 1318 vh.setOpaque(null, 0, true); 1319 }); 1320 checkCCE(() -> { // array reference class 1321 vh.setOpaque(Void.class, 0, true); 1322 }); 1323 checkWMTE(() -> { // value reference class 1324 vh.setOpaque(array, 0, Void.class); 1325 }); 1326 checkWMTE(() -> { // receiver primitive class 1327 vh.setOpaque(0, 0, true); 1328 }); 1329 checkWMTE(() -> { // index reference class 1330 vh.setOpaque(array, Void.class, true); 1331 }); 1332 // Incorrect arity 1333 checkWMTE(() -> { // 0 1334 vh.setOpaque(); 1335 }); 1336 checkWMTE(() -> { // > 1337 vh.setOpaque(array, 0, true, Void.class); 1338 }); 1339 1340 1341 // GetAcquire 1342 // Incorrect argument types 1343 checkNPE(() -> { // null array 1344 boolean x = (boolean) vh.getAcquire(null, 0); 1345 }); 1346 checkCCE(() -> { // array reference class 1347 boolean x = (boolean) vh.getAcquire(Void.class, 0); 1348 }); 1349 checkWMTE(() -> { // array primitive class 1350 boolean x = (boolean) vh.getAcquire(0, 0); 1351 }); 1352 checkWMTE(() -> { // index reference class 1353 boolean x = (boolean) vh.getAcquire(array, Void.class); 1354 }); 1355 // Incorrect return type 1356 checkWMTE(() -> { // reference class 1357 Void x = (Void) vh.getAcquire(array, 0); 1358 }); 1359 checkWMTE(() -> { // primitive class 1360 int x = (int) vh.getAcquire(array, 0); 1361 }); 1362 // Incorrect arity 1363 checkWMTE(() -> { // 0 1364 boolean x = (boolean) vh.getAcquire(); 1365 }); 1366 checkWMTE(() -> { // > 1367 boolean x = (boolean) vh.getAcquire(array, 0, Void.class); 1368 }); 1369 1370 1371 // SetRelease 1372 // Incorrect argument types 1373 checkNPE(() -> { // null array 1374 vh.setRelease(null, 0, true); 1375 }); 1376 checkCCE(() -> { // array reference class 1377 vh.setRelease(Void.class, 0, true); 1378 }); 1379 checkWMTE(() -> { // value reference class 1380 vh.setRelease(array, 0, Void.class); 1381 }); 1382 checkWMTE(() -> { // receiver primitive class 1383 vh.setRelease(0, 0, true); 1384 }); 1385 checkWMTE(() -> { // index reference class 1386 vh.setRelease(array, Void.class, true); 1387 }); 1388 // Incorrect arity 1389 checkWMTE(() -> { // 0 1390 vh.setRelease(); 1391 }); 1392 checkWMTE(() -> { // > 1393 vh.setRelease(array, 0, true, Void.class); 1394 }); 1395 1396 1397 // CompareAndSet 1398 // Incorrect argument types 1399 checkNPE(() -> { // null receiver 1400 boolean r = vh.compareAndSet(null, 0, true, true); 1401 }); 1402 checkCCE(() -> { // receiver reference class 1403 boolean r = vh.compareAndSet(Void.class, 0, true, true); 1404 }); 1405 checkWMTE(() -> { // expected reference class 1406 boolean r = vh.compareAndSet(array, 0, Void.class, true); 1407 }); 1408 checkWMTE(() -> { // actual reference class 1409 boolean r = vh.compareAndSet(array, 0, true, Void.class); 1410 }); 1411 checkWMTE(() -> { // receiver primitive class 1412 boolean r = vh.compareAndSet(0, 0, true, true); 1413 }); 1414 checkWMTE(() -> { // index reference class 1415 boolean r = vh.compareAndSet(array, Void.class, true, true); 1416 }); 1417 // Incorrect arity 1418 checkWMTE(() -> { // 0 1419 boolean r = vh.compareAndSet(); 1420 }); 1421 checkWMTE(() -> { // > 1422 boolean r = vh.compareAndSet(array, 0, true, true, Void.class); 1423 }); 1424 1425 1426 // WeakCompareAndSet 1427 // Incorrect argument types 1428 checkNPE(() -> { // null receiver 1429 boolean r = vh.weakCompareAndSet(null, 0, true, true); 1430 }); 1431 checkCCE(() -> { // receiver reference class 1432 boolean r = vh.weakCompareAndSet(Void.class, 0, true, true); 1433 }); 1434 checkWMTE(() -> { // expected reference class 1435 boolean r = vh.weakCompareAndSet(array, 0, Void.class, true); 1436 }); 1437 checkWMTE(() -> { // actual reference class 1438 boolean r = vh.weakCompareAndSet(array, 0, true, Void.class); 1439 }); 1440 checkWMTE(() -> { // receiver primitive class 1441 boolean r = vh.weakCompareAndSet(0, 0, true, true); 1442 }); 1443 checkWMTE(() -> { // index reference class 1444 boolean r = vh.weakCompareAndSet(array, Void.class, true, true); 1445 }); 1446 // Incorrect arity 1447 checkWMTE(() -> { // 0 1448 boolean r = vh.weakCompareAndSet(); 1449 }); 1450 checkWMTE(() -> { // > 1451 boolean r = vh.weakCompareAndSet(array, 0, true, true, Void.class); 1452 }); 1453 1454 1455 // WeakCompareAndSetVolatile 1456 // Incorrect argument types 1457 checkNPE(() -> { // null receiver 1458 boolean r = vh.weakCompareAndSetVolatile(null, 0, true, true); 1459 }); 1460 checkCCE(() -> { // receiver reference class 1461 boolean r = vh.weakCompareAndSetVolatile(Void.class, 0, true, true); 1462 }); 1463 checkWMTE(() -> { // expected reference class 1464 boolean r = vh.weakCompareAndSetVolatile(array, 0, Void.class, true); 1465 }); 1466 checkWMTE(() -> { // actual reference class 1467 boolean r = vh.weakCompareAndSetVolatile(array, 0, true, Void.class); 1468 }); 1469 checkWMTE(() -> { // receiver primitive class 1470 boolean r = vh.weakCompareAndSetVolatile(0, 0, true, true); 1471 }); 1472 checkWMTE(() -> { // index reference class 1473 boolean r = vh.weakCompareAndSetVolatile(array, Void.class, true, true); 1474 }); 1475 // Incorrect arity 1476 checkWMTE(() -> { // 0 1477 boolean r = vh.weakCompareAndSetVolatile(); 1478 }); 1479 checkWMTE(() -> { // > 1480 boolean r = vh.weakCompareAndSetVolatile(array, 0, true, true, Void.class); 1481 }); 1482 1483 1484 // WeakCompareAndSetAcquire 1485 // Incorrect argument types 1486 checkNPE(() -> { // null receiver 1487 boolean r = vh.weakCompareAndSetAcquire(null, 0, true, true); 1488 }); 1489 checkCCE(() -> { // receiver reference class 1490 boolean r = vh.weakCompareAndSetAcquire(Void.class, 0, true, true); 1491 }); 1492 checkWMTE(() -> { // expected reference class 1493 boolean r = vh.weakCompareAndSetAcquire(array, 0, Void.class, true); 1494 }); 1495 checkWMTE(() -> { // actual reference class 1496 boolean r = vh.weakCompareAndSetAcquire(array, 0, true, Void.class); 1497 }); 1498 checkWMTE(() -> { // receiver primitive class 1499 boolean r = vh.weakCompareAndSetAcquire(0, 0, true, true); 1500 }); 1501 checkWMTE(() -> { // index reference class 1502 boolean r = vh.weakCompareAndSetAcquire(array, Void.class, true, true); 1503 }); 1504 // Incorrect arity 1505 checkWMTE(() -> { // 0 1506 boolean r = vh.weakCompareAndSetAcquire(); 1507 }); 1508 checkWMTE(() -> { // > 1509 boolean r = vh.weakCompareAndSetAcquire(array, 0, true, true, Void.class); 1510 }); 1511 1512 1513 // WeakCompareAndSetRelease 1514 // Incorrect argument types 1515 checkNPE(() -> { // null receiver 1516 boolean r = vh.weakCompareAndSetRelease(null, 0, true, true); 1517 }); 1518 checkCCE(() -> { // receiver reference class 1519 boolean r = vh.weakCompareAndSetRelease(Void.class, 0, true, true); 1520 }); 1521 checkWMTE(() -> { // expected reference class 1522 boolean r = vh.weakCompareAndSetRelease(array, 0, Void.class, true); 1523 }); 1524 checkWMTE(() -> { // actual reference class 1525 boolean r = vh.weakCompareAndSetRelease(array, 0, true, Void.class); 1526 }); 1527 checkWMTE(() -> { // receiver primitive class 1528 boolean r = vh.weakCompareAndSetRelease(0, 0, true, true); 1529 }); 1530 checkWMTE(() -> { // index reference class 1531 boolean r = vh.weakCompareAndSetRelease(array, Void.class, true, true); 1532 }); 1533 // Incorrect arity 1534 checkWMTE(() -> { // 0 1535 boolean r = vh.weakCompareAndSetRelease(); 1536 }); 1537 checkWMTE(() -> { // > 1538 boolean r = vh.weakCompareAndSetRelease(array, 0, true, true, Void.class); 1539 }); 1540 1541 1542 // CompareAndExchange 1543 // Incorrect argument types 1544 checkNPE(() -> { // null receiver 1545 boolean x = (boolean) vh.compareAndExchange(null, 0, true, true); 1546 }); 1547 checkCCE(() -> { // array reference class 1548 boolean x = (boolean) vh.compareAndExchange(Void.class, 0, true, true); 1549 }); 1550 checkWMTE(() -> { // expected reference class 1551 boolean x = (boolean) vh.compareAndExchange(array, 0, Void.class, true); 1552 }); 1553 checkWMTE(() -> { // actual reference class 1554 boolean x = (boolean) vh.compareAndExchange(array, 0, true, Void.class); 1555 }); 1556 checkWMTE(() -> { // array primitive class 1557 boolean x = (boolean) vh.compareAndExchange(0, 0, true, true); 1558 }); 1559 checkWMTE(() -> { // index reference class 1560 boolean x = (boolean) vh.compareAndExchange(array, Void.class, true, true); 1561 }); 1562 // Incorrect return type 1563 checkWMTE(() -> { // reference class 1564 Void r = (Void) vh.compareAndExchange(array, 0, true, true); 1565 }); 1566 checkWMTE(() -> { // primitive class 1567 int x = (int) vh.compareAndExchange(array, 0, true, true); 1568 }); 1569 // Incorrect arity 1570 checkWMTE(() -> { // 0 1571 boolean x = (boolean) vh.compareAndExchange(); 1572 }); 1573 checkWMTE(() -> { // > 1574 boolean x = (boolean) vh.compareAndExchange(array, 0, true, true, Void.class); 1575 }); 1576 1577 1578 // CompareAndExchangeAcquire 1579 // Incorrect argument types 1580 checkNPE(() -> { // null receiver 1581 boolean x = (boolean) vh.compareAndExchangeAcquire(null, 0, true, true); 1582 }); 1583 checkCCE(() -> { // array reference class 1584 boolean x = (boolean) vh.compareAndExchangeAcquire(Void.class, 0, true, true); 1585 }); 1586 checkWMTE(() -> { // expected reference class 1587 boolean x = (boolean) vh.compareAndExchangeAcquire(array, 0, Void.class, true); 1588 }); 1589 checkWMTE(() -> { // actual reference class 1590 boolean x = (boolean) vh.compareAndExchangeAcquire(array, 0, true, Void.class); 1591 }); 1592 checkWMTE(() -> { // array primitive class 1593 boolean x = (boolean) vh.compareAndExchangeAcquire(0, 0, true, true); 1594 }); 1595 checkWMTE(() -> { // index reference class 1596 boolean x = (boolean) vh.compareAndExchangeAcquire(array, Void.class, true, true); 1597 }); 1598 // Incorrect return type 1599 checkWMTE(() -> { // reference class 1600 Void r = (Void) vh.compareAndExchangeAcquire(array, 0, true, true); 1601 }); 1602 checkWMTE(() -> { // primitive class 1603 int x = (int) vh.compareAndExchangeAcquire(array, 0, true, true); 1604 }); 1605 // Incorrect arity 1606 checkWMTE(() -> { // 0 1607 boolean x = (boolean) vh.compareAndExchangeAcquire(); 1608 }); 1609 checkWMTE(() -> { // > 1610 boolean x = (boolean) vh.compareAndExchangeAcquire(array, 0, true, true, Void.class); 1611 }); 1612 1613 1614 // CompareAndExchangeRelease 1615 // Incorrect argument types 1616 checkNPE(() -> { // null receiver 1617 boolean x = (boolean) vh.compareAndExchangeRelease(null, 0, true, true); 1618 }); 1619 checkCCE(() -> { // array reference class 1620 boolean x = (boolean) vh.compareAndExchangeRelease(Void.class, 0, true, true); 1621 }); 1622 checkWMTE(() -> { // expected reference class 1623 boolean x = (boolean) vh.compareAndExchangeRelease(array, 0, Void.class, true); 1624 }); 1625 checkWMTE(() -> { // actual reference class 1626 boolean x = (boolean) vh.compareAndExchangeRelease(array, 0, true, Void.class); 1627 }); 1628 checkWMTE(() -> { // array primitive class 1629 boolean x = (boolean) vh.compareAndExchangeRelease(0, 0, true, true); 1630 }); 1631 checkWMTE(() -> { // index reference class 1632 boolean x = (boolean) vh.compareAndExchangeRelease(array, Void.class, true, true); 1633 }); 1634 // Incorrect return type 1635 checkWMTE(() -> { // reference class 1636 Void r = (Void) vh.compareAndExchangeRelease(array, 0, true, true); 1637 }); 1638 checkWMTE(() -> { // primitive class 1639 int x = (int) vh.compareAndExchangeRelease(array, 0, true, true); 1640 }); 1641 // Incorrect arity 1642 checkWMTE(() -> { // 0 1643 boolean x = (boolean) vh.compareAndExchangeRelease(); 1644 }); 1645 checkWMTE(() -> { // > 1646 boolean x = (boolean) vh.compareAndExchangeRelease(array, 0, true, true, Void.class); 1647 }); 1648 1649 1650 // GetAndSet 1651 // Incorrect argument types 1652 checkNPE(() -> { // null array 1653 boolean x = (boolean) vh.getAndSet(null, 0, true); 1654 }); 1655 checkCCE(() -> { // array reference class 1656 boolean x = (boolean) vh.getAndSet(Void.class, 0, true); 1657 }); 1658 checkWMTE(() -> { // value reference class 1659 boolean x = (boolean) vh.getAndSet(array, 0, Void.class); 1660 }); 1661 checkWMTE(() -> { // reciarrayever primitive class 1662 boolean x = (boolean) vh.getAndSet(0, 0, true); 1663 }); 1664 checkWMTE(() -> { // index reference class 1665 boolean x = (boolean) vh.getAndSet(array, Void.class, true); 1666 }); 1667 // Incorrect return type 1668 checkWMTE(() -> { // reference class 1669 Void r = (Void) vh.getAndSet(array, 0, true); 1670 }); 1671 checkWMTE(() -> { // primitive class 1672 int x = (int) vh.getAndSet(array, 0, true); 1673 }); 1674 // Incorrect arity 1675 checkWMTE(() -> { // 0 1676 boolean x = (boolean) vh.getAndSet(); 1677 }); 1678 checkWMTE(() -> { // > 1679 boolean x = (boolean) vh.getAndSet(array, 0, true, Void.class); 1680 }); 1681 1682 } 1683 1684 static void testArrayWrongMethodType(Handles hs) throws Throwable { 1685 boolean[] array = new boolean[10]; 1686 Arrays.fill(array, true); 1687 1688 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) { 1689 // Incorrect argument types 1690 checkNPE(() -> { // null array 1691 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class)). 1692 invokeExact((boolean[]) null, 0); 1693 }); 1694 hs.checkWMTEOrCCE(() -> { // array reference class 1695 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class, int.class)). 1696 invokeExact(Void.class, 0); 1697 }); 1698 checkWMTE(() -> { // array primitive class 1699 boolean x = (boolean) hs.get(am, methodType(boolean.class, int.class, int.class)). 1700 invokeExact(0, 0); 1701 }); 1702 checkWMTE(() -> { // index reference class 1703 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, Class.class)). 1704 invokeExact(array, Void.class); 1705 }); 1706 // Incorrect return type 1707 checkWMTE(() -> { // reference class 1708 Void x = (Void) hs.get(am, methodType(Void.class, boolean[].class, int.class)). 1709 invokeExact(array, 0); 1710 }); 1711 checkWMTE(() -> { // primitive class 1712 int x = (int) hs.get(am, methodType(int.class, boolean[].class, int.class)). 1713 invokeExact(array, 0); 1714 }); 1715 // Incorrect arity 1716 checkWMTE(() -> { // 0 1717 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 1718 invokeExact(); 1719 }); 1720 checkWMTE(() -> { // > 1721 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, Class.class)). 1722 invokeExact(array, 0, Void.class); 1723 }); 1724 } 1725 1726 for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) { 1727 // Incorrect argument types 1728 checkNPE(() -> { // null array 1729 hs.get(am, methodType(void.class, boolean[].class, int.class, boolean.class)). 1730 invokeExact((boolean[]) null, 0, true); 1731 }); 1732 hs.checkWMTEOrCCE(() -> { // array reference class 1733 hs.get(am, methodType(void.class, Class.class, int.class, boolean.class)). 1734 invokeExact(Void.class, 0, true); 1735 }); 1736 checkWMTE(() -> { // value reference class 1737 hs.get(am, methodType(void.class, boolean[].class, int.class, Class.class)). 1738 invokeExact(array, 0, Void.class); 1739 }); 1740 checkWMTE(() -> { // receiver primitive class 1741 hs.get(am, methodType(void.class, int.class, int.class, boolean.class)). 1742 invokeExact(0, 0, true); 1743 }); 1744 checkWMTE(() -> { // index reference class 1745 hs.get(am, methodType(void.class, boolean[].class, Class.class, boolean.class)). 1746 invokeExact(array, Void.class, true); 1747 }); 1748 // Incorrect arity 1749 checkWMTE(() -> { // 0 1750 hs.get(am, methodType(void.class)). 1751 invokeExact(); 1752 }); 1753 checkWMTE(() -> { // > 1754 hs.get(am, methodType(void.class, boolean[].class, int.class, Class.class)). 1755 invokeExact(array, 0, true, Void.class); 1756 }); 1757 } 1758 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) { 1759 // Incorrect argument types 1760 checkNPE(() -> { // null receiver 1761 boolean r = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class, boolean.class)). 1762 invokeExact((boolean[]) null, 0, true, true); 1763 }); 1764 hs.checkWMTEOrCCE(() -> { // receiver reference class 1765 boolean r = (boolean) hs.get(am, methodType(boolean.class, Class.class, int.class, boolean.class, boolean.class)). 1766 invokeExact(Void.class, 0, true, true); 1767 }); 1768 checkWMTE(() -> { // expected reference class 1769 boolean r = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, Class.class, boolean.class)). 1770 invokeExact(array, 0, Void.class, true); 1771 }); 1772 checkWMTE(() -> { // actual reference class 1773 boolean r = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class, Class.class)). 1774 invokeExact(array, 0, true, Void.class); 1775 }); 1776 checkWMTE(() -> { // receiver primitive class 1777 boolean r = (boolean) hs.get(am, methodType(boolean.class, int.class, int.class, boolean.class, boolean.class)). 1778 invokeExact(0, 0, true, true); 1779 }); 1780 checkWMTE(() -> { // index reference class 1781 boolean r = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, Class.class, boolean.class, boolean.class)). 1782 invokeExact(array, Void.class, true, true); 1783 }); 1784 // Incorrect arity 1785 checkWMTE(() -> { // 0 1786 boolean r = (boolean) hs.get(am, methodType(boolean.class)). 1787 invokeExact(); 1788 }); 1789 checkWMTE(() -> { // > 1790 boolean r = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class, boolean.class, Class.class)). 1791 invokeExact(array, 0, true, true, Void.class); 1792 }); 1793 } 1794 1795 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) { 1796 // Incorrect argument types 1797 checkNPE(() -> { // null receiver 1798 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class, boolean.class)). 1799 invokeExact((boolean[]) null, 0, true, true); 1800 }); 1801 hs.checkWMTEOrCCE(() -> { // array reference class 1802 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class, int.class, boolean.class, boolean.class)). 1803 invokeExact(Void.class, 0, true, true); 1804 }); 1805 checkWMTE(() -> { // expected reference class 1806 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, Class.class, boolean.class)). 1807 invokeExact(array, 0, Void.class, true); 1808 }); 1809 checkWMTE(() -> { // actual reference class 1810 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class, Class.class)). 1811 invokeExact(array, 0, true, Void.class); 1812 }); 1813 checkWMTE(() -> { // array primitive class 1814 boolean x = (boolean) hs.get(am, methodType(boolean.class, int.class, int.class, boolean.class, boolean.class)). 1815 invokeExact(0, 0, true, true); 1816 }); 1817 checkWMTE(() -> { // index reference class 1818 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, Class.class, boolean.class, boolean.class)). 1819 invokeExact(array, Void.class, true, true); 1820 }); 1821 // Incorrect return type 1822 checkWMTE(() -> { // reference class 1823 Void r = (Void) hs.get(am, methodType(Void.class, boolean[].class, int.class, boolean.class, boolean.class)). 1824 invokeExact(array, 0, true, true); 1825 }); 1826 checkWMTE(() -> { // primitive class 1827 int x = (int) hs.get(am, methodType(int.class, boolean[].class, int.class, boolean.class, boolean.class)). 1828 invokeExact(array, 0, true, true); 1829 }); 1830 // Incorrect arity 1831 checkWMTE(() -> { // 0 1832 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 1833 invokeExact(); 1834 }); 1835 checkWMTE(() -> { // > 1836 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class, boolean.class, Class.class)). 1837 invokeExact(array, 0, true, true, Void.class); 1838 }); 1839 } 1840 1841 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) { 1842 // Incorrect argument types 1843 checkNPE(() -> { // null array 1844 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class)). 1845 invokeExact((boolean[]) null, 0, true); 1846 }); 1847 hs.checkWMTEOrCCE(() -> { // array reference class 1848 boolean x = (boolean) hs.get(am, methodType(boolean.class, Class.class, int.class, boolean.class)). 1849 invokeExact(Void.class, 0, true); 1850 }); 1851 checkWMTE(() -> { // value reference class 1852 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, Class.class)). 1853 invokeExact(array, 0, Void.class); 1854 }); 1855 checkWMTE(() -> { // array primitive class 1856 boolean x = (boolean) hs.get(am, methodType(boolean.class, int.class, int.class, boolean.class)). 1857 invokeExact(0, 0, true); 1858 }); 1859 checkWMTE(() -> { // index reference class 1860 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, Class.class, boolean.class)). 1861 invokeExact(array, Void.class, true); 1862 }); 1863 // Incorrect return type 1864 checkWMTE(() -> { // reference class 1865 Void r = (Void) hs.get(am, methodType(Void.class, boolean[].class, int.class, boolean.class)). 1866 invokeExact(array, 0, true); 1867 }); 1868 checkWMTE(() -> { // primitive class 1869 int x = (int) hs.get(am, methodType(int.class, boolean[].class, int.class, boolean.class)). 1870 invokeExact(array, 0, true); 1871 }); 1872 // Incorrect arity 1873 checkWMTE(() -> { // 0 1874 boolean x = (boolean) hs.get(am, methodType(boolean.class)). 1875 invokeExact(); 1876 }); 1877 checkWMTE(() -> { // > 1878 boolean x = (boolean) hs.get(am, methodType(boolean.class, boolean[].class, int.class, boolean.class, Class.class)). 1879 invokeExact(array, 0, true, Void.class); 1880 }); 1881 } 1882 1883 } 1884 } 1885