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