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