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