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