X-VarHandleTestMethodType.java.template revision 15539:74cfa7836890 
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
31import org.testng.annotations.BeforeClass;
32import org.testng.annotations.DataProvider;
33import org.testng.annotations.Test;
34
35import java.lang.invoke.MethodHandles;
36import java.lang.invoke.VarHandle;
37import java.util.ArrayList;
38import java.util.Arrays;
39import java.util.List;
40
41import static org.testng.Assert.*;
42
43import static java.lang.invoke.MethodType.*;
44
45public 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.weakCompareAndSet(null, $value1$, $value1$);
358        });
359        checkCCE(() -> { // receiver reference class
360            boolean r = vh.weakCompareAndSet(Void.class, $value1$, $value1$);
361        });
362        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
363            boolean r = vh.weakCompareAndSet(recv, Void.class, $value1$);
364        });
365        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
366            boolean r = vh.weakCompareAndSet(recv, $value1$, Void.class);
367        });
368        checkWMTE(() -> { // receiver primitive class
369            boolean r = vh.weakCompareAndSet(0, $value1$, $value1$);
370        });
371        // Incorrect arity
372        checkWMTE(() -> { // 0
373            boolean r = vh.weakCompareAndSet();
374        });
375        checkWMTE(() -> { // >
376            boolean r = vh.weakCompareAndSet(recv, $value1$, $value1$, Void.class);
377        });
378
379
380        // WeakCompareAndSetVolatile
381        // Incorrect argument types
382        checkNPE(() -> { // null receiver
383            boolean r = vh.weakCompareAndSetVolatile(null, $value1$, $value1$);
384        });
385        checkCCE(() -> { // receiver reference class
386            boolean r = vh.weakCompareAndSetVolatile(Void.class, $value1$, $value1$);
387        });
388        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
389            boolean r = vh.weakCompareAndSetVolatile(recv, Void.class, $value1$);
390        });
391        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
392            boolean r = vh.weakCompareAndSetVolatile(recv, $value1$, Void.class);
393        });
394        checkWMTE(() -> { // receiver primitive class
395            boolean r = vh.weakCompareAndSetVolatile(0, $value1$, $value1$);
396        });
397        // Incorrect arity
398        checkWMTE(() -> { // 0
399            boolean r = vh.weakCompareAndSetVolatile();
400        });
401        checkWMTE(() -> { // >
402            boolean r = vh.weakCompareAndSetVolatile(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
733        // AddAndGet
734        // Incorrect argument types
735        checkNPE(() -> { // null receiver
736            $type$ x = ($type$) vh.addAndGet(null, $value1$);
737        });
738        checkCCE(() -> { // receiver reference class
739            $type$ x = ($type$) vh.addAndGet(Void.class, $value1$);
740        });
741        check{#if[String]?CCE:WMTE}(() -> { // value reference class
742            $type$ x = ($type$) vh.addAndGet(recv, Void.class);
743        });
744        checkWMTE(() -> { // reciever primitive class
745            $type$ x = ($type$) vh.addAndGet(0, $value1$);
746        });
747        // Incorrect return type
748        check{#if[String]?CCE:WMTE}(() -> { // reference class
749            Void r = (Void) vh.addAndGet(recv, $value1$);
750        });
751        checkWMTE(() -> { // primitive class
752            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.addAndGet(recv, $value1$);
753        });
754        // Incorrect arity
755        checkWMTE(() -> { // 0
756            $type$ x = ($type$) vh.addAndGet();
757        });
758        checkWMTE(() -> { // >
759            $type$ x = ($type$) vh.addAndGet(recv, $value1$, Void.class);
760        });
761#end[AtomicAdd]
762
763#if[Bitwise]
764        // GetAndBitwiseOr
765        // Incorrect argument types
766        checkNPE(() -> { // null receiver
767            $type$ x = ($type$) vh.getAndBitwiseOr(null, $value1$);
768        });
769        checkCCE(() -> { // receiver reference class
770            $type$ x = ($type$) vh.getAndBitwiseOr(Void.class, $value1$);
771        });
772        check{#if[String]?CCE:WMTE}(() -> { // value reference class
773            $type$ x = ($type$) vh.getAndBitwiseOr(recv, Void.class);
774        });
775        checkWMTE(() -> { // reciever primitive class
776            $type$ x = ($type$) vh.getAndBitwiseOr(0, $value1$);
777        });
778        // Incorrect return type
779        check{#if[String]?CCE:WMTE}(() -> { // reference class
780            Void r = (Void) vh.getAndBitwiseOr(recv, $value1$);
781        });
782        checkWMTE(() -> { // primitive class
783            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOr(recv, $value1$);
784        });
785        // Incorrect arity
786        checkWMTE(() -> { // 0
787            $type$ x = ($type$) vh.getAndBitwiseOr();
788        });
789        checkWMTE(() -> { // >
790            $type$ x = ($type$) vh.getAndBitwiseOr(recv, $value1$, Void.class);
791        });
792
793
794        // GetAndBitwiseOrAcquire
795        // Incorrect argument types
796        checkNPE(() -> { // null receiver
797            $type$ x = ($type$) vh.getAndBitwiseOrAcquire(null, $value1$);
798        });
799        checkCCE(() -> { // receiver reference class
800            $type$ x = ($type$) vh.getAndBitwiseOrAcquire(Void.class, $value1$);
801        });
802        check{#if[String]?CCE:WMTE}(() -> { // value reference class
803            $type$ x = ($type$) vh.getAndBitwiseOrAcquire(recv, Void.class);
804        });
805        checkWMTE(() -> { // reciever primitive class
806            $type$ x = ($type$) vh.getAndBitwiseOrAcquire(0, $value1$);
807        });
808        // Incorrect return type
809        check{#if[String]?CCE:WMTE}(() -> { // reference class
810            Void r = (Void) vh.getAndBitwiseOrAcquire(recv, $value1$);
811        });
812        checkWMTE(() -> { // primitive class
813            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOrAcquire(recv, $value1$);
814        });
815        // Incorrect arity
816        checkWMTE(() -> { // 0
817            $type$ x = ($type$) vh.getAndBitwiseOrAcquire();
818        });
819        checkWMTE(() -> { // >
820            $type$ x = ($type$) vh.getAndBitwiseOrAcquire(recv, $value1$, Void.class);
821        });
822
823
824        // GetAndBitwiseOrRelease
825        // Incorrect argument types
826        checkNPE(() -> { // null receiver
827            $type$ x = ($type$) vh.getAndBitwiseOrRelease(null, $value1$);
828        });
829        checkCCE(() -> { // receiver reference class
830            $type$ x = ($type$) vh.getAndBitwiseOr(Void.class, $value1$);
831        });
832        check{#if[String]?CCE:WMTE}(() -> { // value reference class
833            $type$ x = ($type$) vh.getAndBitwiseOr(recv, Void.class);
834        });
835        checkWMTE(() -> { // reciever primitive class
836            $type$ x = ($type$) vh.getAndBitwiseOr(0, $value1$);
837        });
838        // Incorrect return type
839        check{#if[String]?CCE:WMTE}(() -> { // reference class
840            Void r = (Void) vh.getAndBitwiseOr(recv, $value1$);
841        });
842        checkWMTE(() -> { // primitive class
843            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOr(recv, $value1$);
844        });
845        // Incorrect arity
846        checkWMTE(() -> { // 0
847            $type$ x = ($type$) vh.getAndBitwiseOr();
848        });
849        checkWMTE(() -> { // >
850            $type$ x = ($type$) vh.getAndBitwiseOr(recv, $value1$, Void.class);
851        });
852
853
854        // GetAndBitwiseAnd
855        // Incorrect argument types
856        checkNPE(() -> { // null receiver
857            $type$ x = ($type$) vh.getAndBitwiseAnd(null, $value1$);
858        });
859        checkCCE(() -> { // receiver reference class
860            $type$ x = ($type$) vh.getAndBitwiseAnd(Void.class, $value1$);
861        });
862        check{#if[String]?CCE:WMTE}(() -> { // value reference class
863            $type$ x = ($type$) vh.getAndBitwiseAnd(recv, Void.class);
864        });
865        checkWMTE(() -> { // reciever primitive class
866            $type$ x = ($type$) vh.getAndBitwiseAnd(0, $value1$);
867        });
868        // Incorrect return type
869        check{#if[String]?CCE:WMTE}(() -> { // reference class
870            Void r = (Void) vh.getAndBitwiseAnd(recv, $value1$);
871        });
872        checkWMTE(() -> { // primitive class
873            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAnd(recv, $value1$);
874        });
875        // Incorrect arity
876        checkWMTE(() -> { // 0
877            $type$ x = ($type$) vh.getAndBitwiseAnd();
878        });
879        checkWMTE(() -> { // >
880            $type$ x = ($type$) vh.getAndBitwiseAnd(recv, $value1$, Void.class);
881        });
882
883
884        // GetAndBitwiseAndAcquire
885        // Incorrect argument types
886        checkNPE(() -> { // null receiver
887            $type$ x = ($type$) vh.getAndBitwiseAndAcquire(null, $value1$);
888        });
889        checkCCE(() -> { // receiver reference class
890            $type$ x = ($type$) vh.getAndBitwiseAndAcquire(Void.class, $value1$);
891        });
892        check{#if[String]?CCE:WMTE}(() -> { // value reference class
893            $type$ x = ($type$) vh.getAndBitwiseAndAcquire(recv, Void.class);
894        });
895        checkWMTE(() -> { // reciever primitive class
896            $type$ x = ($type$) vh.getAndBitwiseAndAcquire(0, $value1$);
897        });
898        // Incorrect return type
899        check{#if[String]?CCE:WMTE}(() -> { // reference class
900            Void r = (Void) vh.getAndBitwiseAndAcquire(recv, $value1$);
901        });
902        checkWMTE(() -> { // primitive class
903            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAndAcquire(recv, $value1$);
904        });
905        // Incorrect arity
906        checkWMTE(() -> { // 0
907            $type$ x = ($type$) vh.getAndBitwiseAndAcquire();
908        });
909        checkWMTE(() -> { // >
910            $type$ x = ($type$) vh.getAndBitwiseAndAcquire(recv, $value1$, Void.class);
911        });
912
913
914        // GetAndBitwiseAndRelease
915        // Incorrect argument types
916        checkNPE(() -> { // null receiver
917            $type$ x = ($type$) vh.getAndBitwiseAndRelease(null, $value1$);
918        });
919        checkCCE(() -> { // receiver reference class
920            $type$ x = ($type$) vh.getAndBitwiseAnd(Void.class, $value1$);
921        });
922        check{#if[String]?CCE:WMTE}(() -> { // value reference class
923            $type$ x = ($type$) vh.getAndBitwiseAnd(recv, Void.class);
924        });
925        checkWMTE(() -> { // reciever primitive class
926            $type$ x = ($type$) vh.getAndBitwiseAnd(0, $value1$);
927        });
928        // Incorrect return type
929        check{#if[String]?CCE:WMTE}(() -> { // reference class
930            Void r = (Void) vh.getAndBitwiseAnd(recv, $value1$);
931        });
932        checkWMTE(() -> { // primitive class
933            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAnd(recv, $value1$);
934        });
935        // Incorrect arity
936        checkWMTE(() -> { // 0
937            $type$ x = ($type$) vh.getAndBitwiseAnd();
938        });
939        checkWMTE(() -> { // >
940            $type$ x = ($type$) vh.getAndBitwiseAnd(recv, $value1$, Void.class);
941        });
942
943
944        // GetAndBitwiseXor
945        // Incorrect argument types
946        checkNPE(() -> { // null receiver
947            $type$ x = ($type$) vh.getAndBitwiseXor(null, $value1$);
948        });
949        checkCCE(() -> { // receiver reference class
950            $type$ x = ($type$) vh.getAndBitwiseXor(Void.class, $value1$);
951        });
952        check{#if[String]?CCE:WMTE}(() -> { // value reference class
953            $type$ x = ($type$) vh.getAndBitwiseXor(recv, Void.class);
954        });
955        checkWMTE(() -> { // reciever primitive class
956            $type$ x = ($type$) vh.getAndBitwiseXor(0, $value1$);
957        });
958        // Incorrect return type
959        check{#if[String]?CCE:WMTE}(() -> { // reference class
960            Void r = (Void) vh.getAndBitwiseXor(recv, $value1$);
961        });
962        checkWMTE(() -> { // primitive class
963            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXor(recv, $value1$);
964        });
965        // Incorrect arity
966        checkWMTE(() -> { // 0
967            $type$ x = ($type$) vh.getAndBitwiseXor();
968        });
969        checkWMTE(() -> { // >
970            $type$ x = ($type$) vh.getAndBitwiseXor(recv, $value1$, Void.class);
971        });
972
973
974        // GetAndBitwiseXorAcquire
975        // Incorrect argument types
976        checkNPE(() -> { // null receiver
977            $type$ x = ($type$) vh.getAndBitwiseXorAcquire(null, $value1$);
978        });
979        checkCCE(() -> { // receiver reference class
980            $type$ x = ($type$) vh.getAndBitwiseXorAcquire(Void.class, $value1$);
981        });
982        check{#if[String]?CCE:WMTE}(() -> { // value reference class
983            $type$ x = ($type$) vh.getAndBitwiseXorAcquire(recv, Void.class);
984        });
985        checkWMTE(() -> { // reciever primitive class
986            $type$ x = ($type$) vh.getAndBitwiseXorAcquire(0, $value1$);
987        });
988        // Incorrect return type
989        check{#if[String]?CCE:WMTE}(() -> { // reference class
990            Void r = (Void) vh.getAndBitwiseXorAcquire(recv, $value1$);
991        });
992        checkWMTE(() -> { // primitive class
993            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXorAcquire(recv, $value1$);
994        });
995        // Incorrect arity
996        checkWMTE(() -> { // 0
997            $type$ x = ($type$) vh.getAndBitwiseXorAcquire();
998        });
999        checkWMTE(() -> { // >
1000            $type$ x = ($type$) vh.getAndBitwiseXorAcquire(recv, $value1$, Void.class);
1001        });
1002
1003
1004        // GetAndBitwiseXorRelease
1005        // Incorrect argument types
1006        checkNPE(() -> { // null receiver
1007            $type$ x = ($type$) vh.getAndBitwiseXorRelease(null, $value1$);
1008        });
1009        checkCCE(() -> { // receiver reference class
1010            $type$ x = ($type$) vh.getAndBitwiseXor(Void.class, $value1$);
1011        });
1012        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1013            $type$ x = ($type$) vh.getAndBitwiseXor(recv, Void.class);
1014        });
1015        checkWMTE(() -> { // reciever primitive class
1016            $type$ x = ($type$) vh.getAndBitwiseXor(0, $value1$);
1017        });
1018        // Incorrect return type
1019        check{#if[String]?CCE:WMTE}(() -> { // reference class
1020            Void r = (Void) vh.getAndBitwiseXor(recv, $value1$);
1021        });
1022        checkWMTE(() -> { // primitive class
1023            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXor(recv, $value1$);
1024        });
1025        // Incorrect arity
1026        checkWMTE(() -> { // 0
1027            $type$ x = ($type$) vh.getAndBitwiseXor();
1028        });
1029        checkWMTE(() -> { // >
1030            $type$ x = ($type$) vh.getAndBitwiseXor(recv, $value1$, Void.class);
1031        });
1032#end[Bitwise]
1033    }
1034
1035    static void testInstanceFieldWrongMethodType(VarHandleTestMethodType$Type$ recv, Handles hs) throws Throwable {
1036        for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) {
1037            // Incorrect argument types
1038            checkNPE(() -> { // null receiver
1039                $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class)).
1040                    invokeExact((VarHandleTestMethodType$Type$) null);
1041            });
1042            hs.checkWMTEOrCCE(() -> { // receiver reference class
1043                $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class)).
1044                    invokeExact(Void.class);
1045            });
1046            checkWMTE(() -> { // receiver primitive class
1047                $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class)).
1048                    invokeExact(0);
1049            });
1050            // Incorrect return type
1051            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
1052                Void x = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodType$Type$.class)).
1053                    invokeExact(recv);
1054            });
1055            checkWMTE(() -> { // primitive class
1056                $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, VarHandleTestMethodType$Type$.class)).
1057                    invokeExact(recv);
1058            });
1059            // Incorrect arity
1060            checkWMTE(() -> { // 0
1061                $type$ x = ($type$) hs.get(am, methodType($type$.class)).
1062                    invokeExact();
1063            });
1064            checkWMTE(() -> { // >
1065                $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, Class.class)).
1066                    invokeExact(recv, Void.class);
1067            });
1068        }
1069
1070        for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) {
1071            // Incorrect argument types
1072            checkNPE(() -> { // null receiver
1073                hs.get(am, methodType(void.class, VarHandleTestMethodType$Type$.class, $type$.class)).
1074                    invokeExact((VarHandleTestMethodType$Type$) null, $value1$);
1075            });
1076            hs.checkWMTEOrCCE(() -> { // receiver reference class
1077                hs.get(am, methodType(void.class, Class.class, $type$.class)).
1078                    invokeExact(Void.class, $value1$);
1079            });
1080            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
1081                hs.get(am, methodType(void.class, VarHandleTestMethodType$Type$.class, Class.class)).
1082                    invokeExact(recv, Void.class);
1083            });
1084            checkWMTE(() -> { // receiver primitive class
1085                hs.get(am, methodType(void.class, int.class, $type$.class)).
1086                    invokeExact(0, $value1$);
1087            });
1088            // Incorrect arity
1089            checkWMTE(() -> { // 0
1090                hs.get(am, methodType(void.class)).
1091                    invokeExact();
1092            });
1093            checkWMTE(() -> { // >
1094                hs.get(am, methodType(void.class, VarHandleTestMethodType$Type$.class, $type$.class, Class.class)).
1095                    invokeExact(recv, $value1$, Void.class);
1096            });
1097        }
1098
1099#if[CAS]
1100        for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) {
1101            // Incorrect argument types
1102            checkNPE(() -> { // null receiver
1103                boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodType$Type$.class, $type$.class, $type$.class)).
1104                    invokeExact((VarHandleTestMethodType$Type$) null, $value1$, $value1$);
1105            });
1106            hs.checkWMTEOrCCE(() -> { // receiver reference class
1107                boolean r = (boolean) hs.get(am, methodType(boolean.class, Class.class, $type$.class, $type$.class)).
1108                    invokeExact(Void.class, $value1$, $value1$);
1109            });
1110            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
1111                boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodType$Type$.class, Class.class, $type$.class)).
1112                    invokeExact(recv, Void.class, $value1$);
1113            });
1114            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
1115                boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodType$Type$.class, $type$.class, Class.class)).
1116                    invokeExact(recv, $value1$, Void.class);
1117            });
1118            checkWMTE(() -> { // receiver primitive class
1119                boolean r = (boolean) hs.get(am, methodType(boolean.class, int.class , $type$.class, $type$.class)).
1120                    invokeExact(0, $value1$, $value1$);
1121            });
1122            // Incorrect arity
1123            checkWMTE(() -> { // 0
1124                boolean r = (boolean) hs.get(am, methodType(boolean.class)).
1125                    invokeExact();
1126            });
1127            checkWMTE(() -> { // >
1128                boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodType$Type$.class, $type$.class, $type$.class, Class.class)).
1129                    invokeExact(recv, $value1$, $value1$, Void.class);
1130            });
1131        }
1132
1133        for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) {
1134            checkNPE(() -> { // null receiver
1135                $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, $type$.class, $type$.class)).
1136                    invokeExact((VarHandleTestMethodType$Type$) null, $value1$, $value1$);
1137            });
1138            hs.checkWMTEOrCCE(() -> { // receiver reference class
1139                $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, $type$.class, $type$.class)).
1140                    invokeExact(Void.class, $value1$, $value1$);
1141            });
1142            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
1143                $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, Class.class, $type$.class)).
1144                    invokeExact(recv, Void.class, $value1$);
1145            });
1146            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
1147                $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, $type$.class, Class.class)).
1148                    invokeExact(recv, $value1$, Void.class);
1149            });
1150            checkWMTE(() -> { // reciever primitive class
1151                $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class , $type$.class, $type$.class)).
1152                    invokeExact(0, $value1$, $value1$);
1153            });
1154            // Incorrect return type
1155            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
1156                Void r = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodType$Type$.class , $type$.class, $type$.class)).
1157                    invokeExact(recv, $value1$, $value1$);
1158            });
1159            checkWMTE(() -> { // primitive class
1160                $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, VarHandleTestMethodType$Type$.class , $type$.class, $type$.class)).
1161                    invokeExact(recv, $value1$, $value1$);
1162            });
1163            // Incorrect arity
1164            checkWMTE(() -> { // 0
1165                $type$ x = ($type$) hs.get(am, methodType($type$.class)).
1166                    invokeExact();
1167            });
1168            checkWMTE(() -> { // >
1169                $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, $type$.class, $type$.class, Class.class)).
1170                    invokeExact(recv, $value1$, $value1$, Void.class);
1171            });
1172        }
1173
1174        for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) {
1175            checkNPE(() -> { // null receiver
1176                $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, $type$.class)).
1177                    invokeExact((VarHandleTestMethodType$Type$) null, $value1$);
1178            });
1179            hs.checkWMTEOrCCE(() -> { // receiver reference class
1180                $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, $type$.class)).
1181                    invokeExact(Void.class, $value1$);
1182            });
1183            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
1184                $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, Class.class)).
1185                    invokeExact(recv, Void.class);
1186            });
1187            checkWMTE(() -> { // reciever primitive class
1188                $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class, $type$.class)).
1189                    invokeExact(0, $value1$);
1190            });
1191            // Incorrect return type
1192            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
1193                Void r = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodType$Type$.class, $type$.class)).
1194                    invokeExact(recv, $value1$);
1195            });
1196            checkWMTE(() -> { // primitive class
1197                $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, VarHandleTestMethodType$Type$.class, $type$.class)).
1198                    invokeExact(recv, $value1$);
1199            });
1200            // Incorrect arity
1201            checkWMTE(() -> { // 0
1202                $type$ x = ($type$) hs.get(am, methodType($type$.class)).
1203                    invokeExact();
1204            });
1205            checkWMTE(() -> { // >
1206                $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, $type$.class)).
1207                    invokeExact(recv, $value1$, Void.class);
1208            });
1209        }
1210#end[CAS]
1211
1212#if[AtomicAdd]
1213        for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
1214            checkNPE(() -> { // null receiver
1215                $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, $type$.class)).
1216                    invokeExact((VarHandleTestMethodType$Type$) null, $value1$);
1217            });
1218            hs.checkWMTEOrCCE(() -> { // receiver reference class
1219                $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, $type$.class)).
1220                    invokeExact(Void.class, $value1$);
1221            });
1222            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
1223                $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, Class.class)).
1224                    invokeExact(recv, Void.class);
1225            });
1226            checkWMTE(() -> { // reciever primitive class
1227                $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class, $type$.class)).
1228                    invokeExact(0, $value1$);
1229            });
1230            // Incorrect return type
1231            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
1232                Void r = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodType$Type$.class, $type$.class)).
1233                    invokeExact(recv, $value1$);
1234            });
1235            checkWMTE(() -> { // primitive class
1236                $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, VarHandleTestMethodType$Type$.class, $type$.class)).
1237                    invokeExact(recv, $value1$);
1238            });
1239            // Incorrect arity
1240            checkWMTE(() -> { // 0
1241                $type$ x = ($type$) hs.get(am, methodType($type$.class)).
1242                    invokeExact();
1243            });
1244            checkWMTE(() -> { // >
1245                $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, $type$.class)).
1246                    invokeExact(recv, $value1$, Void.class);
1247            });
1248        }
1249#end[AtomicAdd]
1250
1251#if[Bitwise]
1252        for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) {
1253            checkNPE(() -> { // null receiver
1254                $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, $type$.class)).
1255                    invokeExact((VarHandleTestMethodType$Type$) null, $value1$);
1256            });
1257            hs.checkWMTEOrCCE(() -> { // receiver reference class
1258                $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, $type$.class)).
1259                    invokeExact(Void.class, $value1$);
1260            });
1261            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
1262                $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, Class.class)).
1263                    invokeExact(recv, Void.class);
1264            });
1265            checkWMTE(() -> { // reciever primitive class
1266                $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class, $type$.class)).
1267                    invokeExact(0, $value1$);
1268            });
1269            // Incorrect return type
1270            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
1271                Void r = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodType$Type$.class, $type$.class)).
1272                    invokeExact(recv, $value1$);
1273            });
1274            checkWMTE(() -> { // primitive class
1275                $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, VarHandleTestMethodType$Type$.class, $type$.class)).
1276                    invokeExact(recv, $value1$);
1277            });
1278            // Incorrect arity
1279            checkWMTE(() -> { // 0
1280                $type$ x = ($type$) hs.get(am, methodType($type$.class)).
1281                    invokeExact();
1282            });
1283            checkWMTE(() -> { // >
1284                $type$ x = ($type$) hs.get(am, methodType($type$.class, VarHandleTestMethodType$Type$.class, $type$.class)).
1285                    invokeExact(recv, $value1$, Void.class);
1286            });
1287        }
1288#end[Bitwise]
1289    }
1290
1291
1292    static void testStaticFieldWrongMethodType(VarHandle vh) throws Throwable {
1293        // Get
1294        // Incorrect return type
1295        check{#if[String]?CCE:WMTE}(() -> { // reference class
1296            Void x = (Void) vh.get();
1297        });
1298        checkWMTE(() -> { // primitive class
1299            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.get();
1300        });
1301        // Incorrect arity
1302        checkWMTE(() -> { // >
1303            $type$ x = ($type$) vh.get(Void.class);
1304        });
1305
1306
1307        // Set
1308        // Incorrect argument types
1309        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1310            vh.set(Void.class);
1311        });
1312        // Incorrect arity
1313        checkWMTE(() -> { // 0
1314            vh.set();
1315        });
1316        checkWMTE(() -> { // >
1317            vh.set($value1$, Void.class);
1318        });
1319
1320
1321        // GetVolatile
1322        // Incorrect return type
1323        check{#if[String]?CCE:WMTE}(() -> { // reference class
1324            Void x = (Void) vh.getVolatile();
1325        });
1326        checkWMTE(() -> { // primitive class
1327            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getVolatile();
1328        });
1329        checkWMTE(() -> { // >
1330            $type$ x = ($type$) vh.getVolatile(Void.class);
1331        });
1332
1333
1334        // SetVolatile
1335        // Incorrect argument types
1336        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1337            vh.setVolatile(Void.class);
1338        });
1339        // Incorrect arity
1340        checkWMTE(() -> { // 0
1341            vh.setVolatile();
1342        });
1343        checkWMTE(() -> { // >
1344            vh.setVolatile($value1$, Void.class);
1345        });
1346
1347
1348        // GetOpaque
1349        // Incorrect return type
1350        check{#if[String]?CCE:WMTE}(() -> { // reference class
1351            Void x = (Void) vh.getOpaque();
1352        });
1353        checkWMTE(() -> { // primitive class
1354            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getOpaque();
1355        });
1356        checkWMTE(() -> { // >
1357            $type$ x = ($type$) vh.getOpaque(Void.class);
1358        });
1359
1360
1361        // SetOpaque
1362        // Incorrect argument types
1363        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1364            vh.setOpaque(Void.class);
1365        });
1366        // Incorrect arity
1367        checkWMTE(() -> { // 0
1368            vh.setOpaque();
1369        });
1370        checkWMTE(() -> { // >
1371            vh.setOpaque($value1$, Void.class);
1372        });
1373
1374
1375        // GetAcquire
1376        // Incorrect return type
1377        check{#if[String]?CCE:WMTE}(() -> { // reference class
1378            Void x = (Void) vh.getAcquire();
1379        });
1380        checkWMTE(() -> { // primitive class
1381            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAcquire();
1382        });
1383        checkWMTE(() -> { // >
1384            $type$ x = ($type$) vh.getAcquire(Void.class);
1385        });
1386
1387
1388        // SetRelease
1389        // Incorrect argument types
1390        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1391            vh.setRelease(Void.class);
1392        });
1393        // Incorrect arity
1394        checkWMTE(() -> { // 0
1395            vh.setRelease();
1396        });
1397        checkWMTE(() -> { // >
1398            vh.setRelease($value1$, Void.class);
1399        });
1400
1401
1402#if[CAS]
1403        // CompareAndSet
1404        // Incorrect argument types
1405        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
1406            boolean r = vh.compareAndSet(Void.class, $value1$);
1407        });
1408        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
1409            boolean r = vh.compareAndSet($value1$, Void.class);
1410        });
1411        // Incorrect arity
1412        checkWMTE(() -> { // 0
1413            boolean r = vh.compareAndSet();
1414        });
1415        checkWMTE(() -> { // >
1416            boolean r = vh.compareAndSet($value1$, $value1$, Void.class);
1417        });
1418
1419
1420        // WeakCompareAndSet
1421        // Incorrect argument types
1422        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
1423            boolean r = vh.weakCompareAndSet(Void.class, $value1$);
1424        });
1425        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
1426            boolean r = vh.weakCompareAndSet($value1$, Void.class);
1427        });
1428        // Incorrect arity
1429        checkWMTE(() -> { // 0
1430            boolean r = vh.weakCompareAndSet();
1431        });
1432        checkWMTE(() -> { // >
1433            boolean r = vh.weakCompareAndSet($value1$, $value1$, Void.class);
1434        });
1435
1436
1437        // WeakCompareAndSetVolatile
1438        // Incorrect argument types
1439        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
1440            boolean r = vh.weakCompareAndSetVolatile(Void.class, $value1$);
1441        });
1442        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
1443            boolean r = vh.weakCompareAndSetVolatile($value1$, Void.class);
1444        });
1445        // Incorrect arity
1446        checkWMTE(() -> { // 0
1447            boolean r = vh.weakCompareAndSetVolatile();
1448        });
1449        checkWMTE(() -> { // >
1450            boolean r = vh.weakCompareAndSetVolatile($value1$, $value1$, Void.class);
1451        });
1452
1453
1454        // WeakCompareAndSetAcquire
1455        // Incorrect argument types
1456        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
1457            boolean r = vh.weakCompareAndSetAcquire(Void.class, $value1$);
1458        });
1459        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
1460            boolean r = vh.weakCompareAndSetAcquire($value1$, Void.class);
1461        });
1462        // Incorrect arity
1463        checkWMTE(() -> { // 0
1464            boolean r = vh.weakCompareAndSetAcquire();
1465        });
1466        checkWMTE(() -> { // >
1467            boolean r = vh.weakCompareAndSetAcquire($value1$, $value1$, Void.class);
1468        });
1469
1470
1471        // WeakCompareAndSetRelease
1472        // Incorrect argument types
1473        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
1474            boolean r = vh.weakCompareAndSetRelease(Void.class, $value1$);
1475        });
1476        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
1477            boolean r = vh.weakCompareAndSetRelease($value1$, Void.class);
1478        });
1479        // Incorrect arity
1480        checkWMTE(() -> { // 0
1481            boolean r = vh.weakCompareAndSetRelease();
1482        });
1483        checkWMTE(() -> { // >
1484            boolean r = vh.weakCompareAndSetRelease($value1$, $value1$, Void.class);
1485        });
1486
1487
1488        // CompareAndExchange
1489        // Incorrect argument types
1490        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
1491            $type$ x = ($type$) vh.compareAndExchange(Void.class, $value1$);
1492        });
1493        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
1494            $type$ x = ($type$) vh.compareAndExchange($value1$, Void.class);
1495        });
1496        // Incorrect return type
1497        check{#if[String]?CCE:WMTE}(() -> { // reference class
1498            Void r = (Void) vh.compareAndExchange($value1$, $value1$);
1499        });
1500        checkWMTE(() -> { // primitive class
1501            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.compareAndExchange($value1$, $value1$);
1502        });
1503        // Incorrect arity
1504        checkWMTE(() -> { // 0
1505            $type$ x = ($type$) vh.compareAndExchange();
1506        });
1507        checkWMTE(() -> { // >
1508            $type$ x = ($type$) vh.compareAndExchange($value1$, $value1$, Void.class);
1509        });
1510
1511
1512        // CompareAndExchangeAcquire
1513        // Incorrect argument types
1514        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
1515            $type$ x = ($type$) vh.compareAndExchangeAcquire(Void.class, $value1$);
1516        });
1517        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
1518            $type$ x = ($type$) vh.compareAndExchangeAcquire($value1$, Void.class);
1519        });
1520        // Incorrect return type
1521        check{#if[String]?CCE:WMTE}(() -> { // reference class
1522            Void r = (Void) vh.compareAndExchangeAcquire($value1$, $value1$);
1523        });
1524        checkWMTE(() -> { // primitive class
1525            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.compareAndExchangeAcquire($value1$, $value1$);
1526        });
1527        // Incorrect arity
1528        checkWMTE(() -> { // 0
1529            $type$ x = ($type$) vh.compareAndExchangeAcquire();
1530        });
1531        checkWMTE(() -> { // >
1532            $type$ x = ($type$) vh.compareAndExchangeAcquire($value1$, $value1$, Void.class);
1533        });
1534
1535
1536        // CompareAndExchangeRelease
1537        // Incorrect argument types
1538        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
1539            $type$ x = ($type$) vh.compareAndExchangeRelease(Void.class, $value1$);
1540        });
1541        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
1542            $type$ x = ($type$) vh.compareAndExchangeRelease($value1$, Void.class);
1543        });
1544        // Incorrect return type
1545        check{#if[String]?CCE:WMTE}(() -> { // reference class
1546            Void r = (Void) vh.compareAndExchangeRelease($value1$, $value1$);
1547        });
1548        checkWMTE(() -> { // primitive class
1549            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.compareAndExchangeRelease($value1$, $value1$);
1550        });
1551        // Incorrect arity
1552        checkWMTE(() -> { // 0
1553            $type$ x = ($type$) vh.compareAndExchangeRelease();
1554        });
1555        checkWMTE(() -> { // >
1556            $type$ x = ($type$) vh.compareAndExchangeRelease($value1$, $value1$, Void.class);
1557        });
1558
1559
1560        // GetAndSet
1561        // Incorrect argument types
1562        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1563            $type$ x = ($type$) vh.getAndSet(Void.class);
1564        });
1565        // Incorrect return type
1566        check{#if[String]?CCE:WMTE}(() -> { // reference class
1567            Void r = (Void) vh.getAndSet($value1$);
1568        });
1569        checkWMTE(() -> { // primitive class
1570            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndSet($value1$);
1571        });
1572        // Incorrect arity
1573        checkWMTE(() -> { // 0
1574            $type$ x = ($type$) vh.getAndSet();
1575        });
1576        checkWMTE(() -> { // >
1577            $type$ x = ($type$) vh.getAndSet($value1$, Void.class);
1578        });
1579
1580
1581        // GetAndSetAcquire
1582        // Incorrect argument types
1583        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1584            $type$ x = ($type$) vh.getAndSetAcquire(Void.class);
1585        });
1586        // Incorrect return type
1587        check{#if[String]?CCE:WMTE}(() -> { // reference class
1588            Void r = (Void) vh.getAndSetAcquire($value1$);
1589        });
1590        checkWMTE(() -> { // primitive class
1591            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndSetAcquire($value1$);
1592        });
1593        // Incorrect arity
1594        checkWMTE(() -> { // 0
1595            $type$ x = ($type$) vh.getAndSetAcquire();
1596        });
1597        checkWMTE(() -> { // >
1598            $type$ x = ($type$) vh.getAndSetAcquire($value1$, Void.class);
1599        });
1600
1601
1602        // GetAndSetRelease
1603        // Incorrect argument types
1604        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1605            $type$ x = ($type$) vh.getAndSetRelease(Void.class);
1606        });
1607        // Incorrect return type
1608        check{#if[String]?CCE:WMTE}(() -> { // reference class
1609            Void r = (Void) vh.getAndSetRelease($value1$);
1610        });
1611        checkWMTE(() -> { // primitive class
1612            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndSetRelease($value1$);
1613        });
1614        // Incorrect arity
1615        checkWMTE(() -> { // 0
1616            $type$ x = ($type$) vh.getAndSetRelease();
1617        });
1618        checkWMTE(() -> { // >
1619            $type$ x = ($type$) vh.getAndSetRelease($value1$, Void.class);
1620        });
1621#end[CAS]
1622
1623#if[AtomicAdd]
1624        // GetAndAdd
1625        // Incorrect argument types
1626        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1627            $type$ x = ($type$) vh.getAndAdd(Void.class);
1628        });
1629        // Incorrect return type
1630        check{#if[String]?CCE:WMTE}(() -> { // reference class
1631            Void r = (Void) vh.getAndAdd($value1$);
1632        });
1633        checkWMTE(() -> { // primitive class
1634            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndAdd($value1$);
1635        });
1636        // Incorrect arity
1637        checkWMTE(() -> { // 0
1638            $type$ x = ($type$) vh.getAndAdd();
1639        });
1640        checkWMTE(() -> { // >
1641            $type$ x = ($type$) vh.getAndAdd($value1$, Void.class);
1642        });
1643
1644
1645        // GetAndAddAcquire
1646        // Incorrect argument types
1647        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1648            $type$ x = ($type$) vh.getAndAddAcquire(Void.class);
1649        });
1650        // Incorrect return type
1651        check{#if[String]?CCE:WMTE}(() -> { // reference class
1652            Void r = (Void) vh.getAndAddAcquire($value1$);
1653        });
1654        checkWMTE(() -> { // primitive class
1655            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndAddAcquire($value1$);
1656        });
1657        // Incorrect arity
1658        checkWMTE(() -> { // 0
1659            $type$ x = ($type$) vh.getAndAddAcquire();
1660        });
1661        checkWMTE(() -> { // >
1662            $type$ x = ($type$) vh.getAndAddAcquire($value1$, Void.class);
1663        });
1664
1665
1666        // GetAndAddRelease
1667        // Incorrect argument types
1668        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1669            $type$ x = ($type$) vh.getAndAddRelease(Void.class);
1670        });
1671        // Incorrect return type
1672        check{#if[String]?CCE:WMTE}(() -> { // reference class
1673            Void r = (Void) vh.getAndAddRelease($value1$);
1674        });
1675        checkWMTE(() -> { // primitive class
1676            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndAddRelease($value1$);
1677        });
1678        // Incorrect arity
1679        checkWMTE(() -> { // 0
1680            $type$ x = ($type$) vh.getAndAddRelease();
1681        });
1682        checkWMTE(() -> { // >
1683            $type$ x = ($type$) vh.getAndAddRelease($value1$, Void.class);
1684        });
1685
1686
1687        // AddAndGet
1688        // Incorrect argument types
1689        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1690            $type$ x = ($type$) vh.addAndGet(Void.class);
1691        });
1692        // Incorrect return type
1693        check{#if[String]?CCE:WMTE}(() -> { // reference class
1694            Void r = (Void) vh.addAndGet($value1$);
1695        });
1696        checkWMTE(() -> { // primitive class
1697            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.addAndGet($value1$);
1698        });
1699        // Incorrect arity
1700        checkWMTE(() -> { // 0
1701            $type$ x = ($type$) vh.addAndGet();
1702        });
1703        checkWMTE(() -> { // >
1704            $type$ x = ($type$) vh.addAndGet($value1$, Void.class);
1705        });
1706#end[AtomicAdd]
1707
1708#if[Bitwise]
1709        // GetAndBitwiseOr
1710        // Incorrect argument types
1711        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1712            $type$ x = ($type$) vh.getAndBitwiseOr(Void.class);
1713        });
1714        // Incorrect return type
1715        check{#if[String]?CCE:WMTE}(() -> { // reference class
1716            Void r = (Void) vh.getAndBitwiseOr($value1$);
1717        });
1718        checkWMTE(() -> { // primitive class
1719            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOr($value1$);
1720        });
1721        // Incorrect arity
1722        checkWMTE(() -> { // 0
1723            $type$ x = ($type$) vh.getAndBitwiseOr();
1724        });
1725        checkWMTE(() -> { // >
1726            $type$ x = ($type$) vh.getAndBitwiseOr($value1$, Void.class);
1727        });
1728
1729
1730        // GetAndBitwiseOrAcquire
1731        // Incorrect argument types
1732        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1733            $type$ x = ($type$) vh.getAndBitwiseOrAcquire(Void.class);
1734        });
1735        // Incorrect return type
1736        check{#if[String]?CCE:WMTE}(() -> { // reference class
1737            Void r = (Void) vh.getAndBitwiseOrAcquire($value1$);
1738        });
1739        checkWMTE(() -> { // primitive class
1740            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOrAcquire($value1$);
1741        });
1742        // Incorrect arity
1743        checkWMTE(() -> { // 0
1744            $type$ x = ($type$) vh.getAndBitwiseOrAcquire();
1745        });
1746        checkWMTE(() -> { // >
1747            $type$ x = ($type$) vh.getAndBitwiseOrAcquire($value1$, Void.class);
1748        });
1749
1750
1751        // GetAndBitwiseOrReleaseRelease
1752        // Incorrect argument types
1753        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1754            $type$ x = ($type$) vh.getAndBitwiseOrRelease(Void.class);
1755        });
1756        // Incorrect return type
1757        check{#if[String]?CCE:WMTE}(() -> { // reference class
1758            Void r = (Void) vh.getAndBitwiseOrRelease($value1$);
1759        });
1760        checkWMTE(() -> { // primitive class
1761            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOrRelease($value1$);
1762        });
1763        // Incorrect arity
1764        checkWMTE(() -> { // 0
1765            $type$ x = ($type$) vh.getAndBitwiseOrRelease();
1766        });
1767        checkWMTE(() -> { // >
1768            $type$ x = ($type$) vh.getAndBitwiseOrRelease($value1$, Void.class);
1769        });
1770
1771
1772        // GetAndBitwiseAnd
1773        // Incorrect argument types
1774        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1775            $type$ x = ($type$) vh.getAndBitwiseAnd(Void.class);
1776        });
1777        // Incorrect return type
1778        check{#if[String]?CCE:WMTE}(() -> { // reference class
1779            Void r = (Void) vh.getAndBitwiseAnd($value1$);
1780        });
1781        checkWMTE(() -> { // primitive class
1782            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAnd($value1$);
1783        });
1784        // Incorrect arity
1785        checkWMTE(() -> { // 0
1786            $type$ x = ($type$) vh.getAndBitwiseAnd();
1787        });
1788        checkWMTE(() -> { // >
1789            $type$ x = ($type$) vh.getAndBitwiseAnd($value1$, Void.class);
1790        });
1791
1792
1793        // GetAndBitwiseAndAcquire
1794        // Incorrect argument types
1795        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1796            $type$ x = ($type$) vh.getAndBitwiseAndAcquire(Void.class);
1797        });
1798        // Incorrect return type
1799        check{#if[String]?CCE:WMTE}(() -> { // reference class
1800            Void r = (Void) vh.getAndBitwiseAndAcquire($value1$);
1801        });
1802        checkWMTE(() -> { // primitive class
1803            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAndAcquire($value1$);
1804        });
1805        // Incorrect arity
1806        checkWMTE(() -> { // 0
1807            $type$ x = ($type$) vh.getAndBitwiseAndAcquire();
1808        });
1809        checkWMTE(() -> { // >
1810            $type$ x = ($type$) vh.getAndBitwiseAndAcquire($value1$, Void.class);
1811        });
1812
1813
1814        // GetAndBitwiseAndReleaseRelease
1815        // Incorrect argument types
1816        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1817            $type$ x = ($type$) vh.getAndBitwiseAndRelease(Void.class);
1818        });
1819        // Incorrect return type
1820        check{#if[String]?CCE:WMTE}(() -> { // reference class
1821            Void r = (Void) vh.getAndBitwiseAndRelease($value1$);
1822        });
1823        checkWMTE(() -> { // primitive class
1824            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAndRelease($value1$);
1825        });
1826        // Incorrect arity
1827        checkWMTE(() -> { // 0
1828            $type$ x = ($type$) vh.getAndBitwiseAndRelease();
1829        });
1830        checkWMTE(() -> { // >
1831            $type$ x = ($type$) vh.getAndBitwiseAndRelease($value1$, Void.class);
1832        });
1833
1834
1835        // GetAndBitwiseXor
1836        // Incorrect argument types
1837        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1838            $type$ x = ($type$) vh.getAndBitwiseXor(Void.class);
1839        });
1840        // Incorrect return type
1841        check{#if[String]?CCE:WMTE}(() -> { // reference class
1842            Void r = (Void) vh.getAndBitwiseXor($value1$);
1843        });
1844        checkWMTE(() -> { // primitive class
1845            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXor($value1$);
1846        });
1847        // Incorrect arity
1848        checkWMTE(() -> { // 0
1849            $type$ x = ($type$) vh.getAndBitwiseXor();
1850        });
1851        checkWMTE(() -> { // >
1852            $type$ x = ($type$) vh.getAndBitwiseXor($value1$, Void.class);
1853        });
1854
1855
1856        // GetAndBitwiseXorAcquire
1857        // Incorrect argument types
1858        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1859            $type$ x = ($type$) vh.getAndBitwiseXorAcquire(Void.class);
1860        });
1861        // Incorrect return type
1862        check{#if[String]?CCE:WMTE}(() -> { // reference class
1863            Void r = (Void) vh.getAndBitwiseXorAcquire($value1$);
1864        });
1865        checkWMTE(() -> { // primitive class
1866            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXorAcquire($value1$);
1867        });
1868        // Incorrect arity
1869        checkWMTE(() -> { // 0
1870            $type$ x = ($type$) vh.getAndBitwiseXorAcquire();
1871        });
1872        checkWMTE(() -> { // >
1873            $type$ x = ($type$) vh.getAndBitwiseXorAcquire($value1$, Void.class);
1874        });
1875
1876
1877        // GetAndBitwiseXorReleaseRelease
1878        // Incorrect argument types
1879        check{#if[String]?CCE:WMTE}(() -> { // value reference class
1880            $type$ x = ($type$) vh.getAndBitwiseXorRelease(Void.class);
1881        });
1882        // Incorrect return type
1883        check{#if[String]?CCE:WMTE}(() -> { // reference class
1884            Void r = (Void) vh.getAndBitwiseXorRelease($value1$);
1885        });
1886        checkWMTE(() -> { // primitive class
1887            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXorRelease($value1$);
1888        });
1889        // Incorrect arity
1890        checkWMTE(() -> { // 0
1891            $type$ x = ($type$) vh.getAndBitwiseXorRelease();
1892        });
1893        checkWMTE(() -> { // >
1894            $type$ x = ($type$) vh.getAndBitwiseXorRelease($value1$, Void.class);
1895        });
1896#end[Bitwise]
1897    }
1898
1899    static void testStaticFieldWrongMethodType(Handles hs) throws Throwable {
1900        int i = 0;
1901
1902        for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) {
1903            // Incorrect return type
1904            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
1905                Void x = (Void) hs.get(am, methodType(Void.class)).
1906                    invokeExact();
1907            });
1908            checkWMTE(() -> { // primitive class
1909                $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class)).
1910                    invokeExact();
1911            });
1912            // Incorrect arity
1913            checkWMTE(() -> { // >
1914                $type$ x = ($type$) hs.get(am, methodType(Class.class)).
1915                    invokeExact(Void.class);
1916            });
1917        }
1918
1919        for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) {
1920            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
1921                hs.get(am, methodType(void.class, Class.class)).
1922                    invokeExact(Void.class);
1923            });
1924            // Incorrect arity
1925            checkWMTE(() -> { // 0
1926                hs.get(am, methodType(void.class)).
1927                    invokeExact();
1928            });
1929            checkWMTE(() -> { // >
1930                hs.get(am, methodType(void.class, $type$.class, Class.class)).
1931                    invokeExact($value1$, Void.class);
1932            });
1933        }
1934#if[CAS]
1935        for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) {
1936            // Incorrect argument types
1937            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
1938                boolean r = (boolean) hs.get(am, methodType(boolean.class, Class.class, $type$.class)).
1939                    invokeExact(Void.class, $value1$);
1940            });
1941            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
1942                boolean r = (boolean) hs.get(am, methodType(boolean.class, $type$.class, Class.class)).
1943                    invokeExact($value1$, Void.class);
1944            });
1945            // Incorrect arity
1946            checkWMTE(() -> { // 0
1947                boolean r = (boolean) hs.get(am, methodType(boolean.class)).
1948                    invokeExact();
1949            });
1950            checkWMTE(() -> { // >
1951                boolean r = (boolean) hs.get(am, methodType(boolean.class, $type$.class, $type$.class, Class.class)).
1952                    invokeExact($value1$, $value1$, Void.class);
1953            });
1954        }
1955
1956        for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) {
1957            // Incorrect argument types
1958            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
1959                $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, $type$.class)).
1960                    invokeExact(Void.class, $value1$);
1961            });
1962            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
1963                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$.class, Class.class)).
1964                    invokeExact($value1$, Void.class);
1965            });
1966            // Incorrect return type
1967            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
1968                Void r = (Void) hs.get(am, methodType(Void.class, $type$.class, $type$.class)).
1969                    invokeExact($value1$, $value1$);
1970            });
1971            checkWMTE(() -> { // primitive class
1972                $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$.class, $type$.class)).
1973                    invokeExact($value1$, $value1$);
1974            });
1975            // Incorrect arity
1976            checkWMTE(() -> { // 0
1977                $type$ x = ($type$) hs.get(am, methodType($type$.class)).
1978                    invokeExact();
1979            });
1980            checkWMTE(() -> { // >
1981                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$.class, $type$.class, Class.class)).
1982                    invokeExact($value1$, $value1$, Void.class);
1983            });
1984        }
1985
1986        for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) {
1987            // Incorrect argument types
1988            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
1989                $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class)).
1990                    invokeExact(Void.class);
1991            });
1992            // Incorrect return type
1993            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
1994                Void r = (Void) hs.get(am, methodType(Void.class, $type$.class)).
1995                    invokeExact($value1$);
1996            });
1997            checkWMTE(() -> { // primitive class
1998                $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$.class)).
1999                    invokeExact($value1$);
2000            });
2001            // Incorrect arity
2002            checkWMTE(() -> { // 0
2003                $type$ x = ($type$) hs.get(am, methodType($type$.class)).
2004                    invokeExact();
2005            });
2006            checkWMTE(() -> { // >
2007                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$.class, Class.class)).
2008                    invokeExact($value1$, Void.class);
2009            });
2010        }
2011#end[CAS]
2012
2013#if[AtomicAdd]
2014        for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
2015            // Incorrect argument types
2016            check{#if[String]?CCE:WMTE}(() -> { // value reference class
2017                $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class)).
2018                    invokeExact(Void.class);
2019            });
2020            // Incorrect return type
2021            check{#if[String]?CCE:WMTE}(() -> { // reference class
2022                Void r = (Void) hs.get(am, methodType(Void.class, $type$.class)).
2023                    invokeExact($value1$);
2024            });
2025            checkWMTE(() -> { // primitive class
2026                $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$.class)).
2027                    invokeExact($value1$);
2028            });
2029            // Incorrect arity
2030            checkWMTE(() -> { // 0
2031                $type$ x = ($type$) hs.get(am, methodType($type$.class)).
2032                    invokeExact();
2033            });
2034            checkWMTE(() -> { // >
2035                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$.class, Class.class)).
2036                    invokeExact($value1$, Void.class);
2037            });
2038        }
2039#end[AtomicAdd]
2040
2041#if[Bitwise]
2042        for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) {
2043            // Incorrect argument types
2044            check{#if[String]?CCE:WMTE}(() -> { // value reference class
2045                $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class)).
2046                    invokeExact(Void.class);
2047            });
2048            // Incorrect return type
2049            check{#if[String]?CCE:WMTE}(() -> { // reference class
2050                Void r = (Void) hs.get(am, methodType(Void.class, $type$.class)).
2051                    invokeExact($value1$);
2052            });
2053            checkWMTE(() -> { // primitive class
2054                $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$.class)).
2055                    invokeExact($value1$);
2056            });
2057            // Incorrect arity
2058            checkWMTE(() -> { // 0
2059                $type$ x = ($type$) hs.get(am, methodType($type$.class)).
2060                    invokeExact();
2061            });
2062            checkWMTE(() -> { // >
2063                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$.class, Class.class)).
2064                    invokeExact($value1$, Void.class);
2065            });
2066        }
2067#end[Bitwise]
2068    }
2069
2070
2071    static void testArrayWrongMethodType(VarHandle vh) throws Throwable {
2072        $type$[] array = new $type$[10];
2073        Arrays.fill(array, $value1$);
2074
2075        // Get
2076        // Incorrect argument types
2077        checkNPE(() -> { // null array
2078            $type$ x = ($type$) vh.get(null, 0);
2079        });
2080        checkCCE(() -> { // array reference class
2081            $type$ x = ($type$) vh.get(Void.class, 0);
2082        });
2083        checkWMTE(() -> { // array primitive class
2084            $type$ x = ($type$) vh.get(0, 0);
2085        });
2086        checkWMTE(() -> { // index reference class
2087            $type$ x = ($type$) vh.get(array, Void.class);
2088        });
2089        // Incorrect return type
2090        check{#if[String]?CCE:WMTE}(() -> { // reference class
2091            Void x = (Void) vh.get(array, 0);
2092        });
2093        checkWMTE(() -> { // primitive class
2094            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.get(array, 0);
2095        });
2096        // Incorrect arity
2097        checkWMTE(() -> { // 0
2098            $type$ x = ($type$) vh.get();
2099        });
2100        checkWMTE(() -> { // >
2101            $type$ x = ($type$) vh.get(array, 0, Void.class);
2102        });
2103
2104
2105        // Set
2106        // Incorrect argument types
2107        checkNPE(() -> { // null array
2108            vh.set(null, 0, $value1$);
2109        });
2110        checkCCE(() -> { // array reference class
2111            vh.set(Void.class, 0, $value1$);
2112        });
2113        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2114            vh.set(array, 0, Void.class);
2115        });
2116        checkWMTE(() -> { // receiver primitive class
2117            vh.set(0, 0, $value1$);
2118        });
2119        checkWMTE(() -> { // index reference class
2120            vh.set(array, Void.class, $value1$);
2121        });
2122        // Incorrect arity
2123        checkWMTE(() -> { // 0
2124            vh.set();
2125        });
2126        checkWMTE(() -> { // >
2127            vh.set(array, 0, $value1$, Void.class);
2128        });
2129
2130
2131        // GetVolatile
2132        // Incorrect argument types
2133        checkNPE(() -> { // null array
2134            $type$ x = ($type$) vh.getVolatile(null, 0);
2135        });
2136        checkCCE(() -> { // array reference class
2137            $type$ x = ($type$) vh.getVolatile(Void.class, 0);
2138        });
2139        checkWMTE(() -> { // array primitive class
2140            $type$ x = ($type$) vh.getVolatile(0, 0);
2141        });
2142        checkWMTE(() -> { // index reference class
2143            $type$ x = ($type$) vh.getVolatile(array, Void.class);
2144        });
2145        // Incorrect return type
2146        check{#if[String]?CCE:WMTE}(() -> { // reference class
2147            Void x = (Void) vh.getVolatile(array, 0);
2148        });
2149        checkWMTE(() -> { // primitive class
2150            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getVolatile(array, 0);
2151        });
2152        // Incorrect arity
2153        checkWMTE(() -> { // 0
2154            $type$ x = ($type$) vh.getVolatile();
2155        });
2156        checkWMTE(() -> { // >
2157            $type$ x = ($type$) vh.getVolatile(array, 0, Void.class);
2158        });
2159
2160
2161        // SetVolatile
2162        // Incorrect argument types
2163        checkNPE(() -> { // null array
2164            vh.setVolatile(null, 0, $value1$);
2165        });
2166        checkCCE(() -> { // array reference class
2167            vh.setVolatile(Void.class, 0, $value1$);
2168        });
2169        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2170            vh.setVolatile(array, 0, Void.class);
2171        });
2172        checkWMTE(() -> { // receiver primitive class
2173            vh.setVolatile(0, 0, $value1$);
2174        });
2175        checkWMTE(() -> { // index reference class
2176            vh.setVolatile(array, Void.class, $value1$);
2177        });
2178        // Incorrect arity
2179        checkWMTE(() -> { // 0
2180            vh.setVolatile();
2181        });
2182        checkWMTE(() -> { // >
2183            vh.setVolatile(array, 0, $value1$, Void.class);
2184        });
2185
2186
2187        // GetOpaque
2188        // Incorrect argument types
2189        checkNPE(() -> { // null array
2190            $type$ x = ($type$) vh.getOpaque(null, 0);
2191        });
2192        checkCCE(() -> { // array reference class
2193            $type$ x = ($type$) vh.getOpaque(Void.class, 0);
2194        });
2195        checkWMTE(() -> { // array primitive class
2196            $type$ x = ($type$) vh.getOpaque(0, 0);
2197        });
2198        checkWMTE(() -> { // index reference class
2199            $type$ x = ($type$) vh.getOpaque(array, Void.class);
2200        });
2201        // Incorrect return type
2202        check{#if[String]?CCE:WMTE}(() -> { // reference class
2203            Void x = (Void) vh.getOpaque(array, 0);
2204        });
2205        checkWMTE(() -> { // primitive class
2206            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getOpaque(array, 0);
2207        });
2208        // Incorrect arity
2209        checkWMTE(() -> { // 0
2210            $type$ x = ($type$) vh.getOpaque();
2211        });
2212        checkWMTE(() -> { // >
2213            $type$ x = ($type$) vh.getOpaque(array, 0, Void.class);
2214        });
2215
2216
2217        // SetOpaque
2218        // Incorrect argument types
2219        checkNPE(() -> { // null array
2220            vh.setOpaque(null, 0, $value1$);
2221        });
2222        checkCCE(() -> { // array reference class
2223            vh.setOpaque(Void.class, 0, $value1$);
2224        });
2225        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2226            vh.setOpaque(array, 0, Void.class);
2227        });
2228        checkWMTE(() -> { // receiver primitive class
2229            vh.setOpaque(0, 0, $value1$);
2230        });
2231        checkWMTE(() -> { // index reference class
2232            vh.setOpaque(array, Void.class, $value1$);
2233        });
2234        // Incorrect arity
2235        checkWMTE(() -> { // 0
2236            vh.setOpaque();
2237        });
2238        checkWMTE(() -> { // >
2239            vh.setOpaque(array, 0, $value1$, Void.class);
2240        });
2241
2242
2243        // GetAcquire
2244        // Incorrect argument types
2245        checkNPE(() -> { // null array
2246            $type$ x = ($type$) vh.getAcquire(null, 0);
2247        });
2248        checkCCE(() -> { // array reference class
2249            $type$ x = ($type$) vh.getAcquire(Void.class, 0);
2250        });
2251        checkWMTE(() -> { // array primitive class
2252            $type$ x = ($type$) vh.getAcquire(0, 0);
2253        });
2254        checkWMTE(() -> { // index reference class
2255            $type$ x = ($type$) vh.getAcquire(array, Void.class);
2256        });
2257        // Incorrect return type
2258        check{#if[String]?CCE:WMTE}(() -> { // reference class
2259            Void x = (Void) vh.getAcquire(array, 0);
2260        });
2261        checkWMTE(() -> { // primitive class
2262            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAcquire(array, 0);
2263        });
2264        // Incorrect arity
2265        checkWMTE(() -> { // 0
2266            $type$ x = ($type$) vh.getAcquire();
2267        });
2268        checkWMTE(() -> { // >
2269            $type$ x = ($type$) vh.getAcquire(array, 0, Void.class);
2270        });
2271
2272
2273        // SetRelease
2274        // Incorrect argument types
2275        checkNPE(() -> { // null array
2276            vh.setRelease(null, 0, $value1$);
2277        });
2278        checkCCE(() -> { // array reference class
2279            vh.setRelease(Void.class, 0, $value1$);
2280        });
2281        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2282            vh.setRelease(array, 0, Void.class);
2283        });
2284        checkWMTE(() -> { // receiver primitive class
2285            vh.setRelease(0, 0, $value1$);
2286        });
2287        checkWMTE(() -> { // index reference class
2288            vh.setRelease(array, Void.class, $value1$);
2289        });
2290        // Incorrect arity
2291        checkWMTE(() -> { // 0
2292            vh.setRelease();
2293        });
2294        checkWMTE(() -> { // >
2295            vh.setRelease(array, 0, $value1$, Void.class);
2296        });
2297
2298
2299#if[CAS]
2300        // CompareAndSet
2301        // Incorrect argument types
2302        checkNPE(() -> { // null receiver
2303            boolean r = vh.compareAndSet(null, 0, $value1$, $value1$);
2304        });
2305        checkCCE(() -> { // receiver reference class
2306            boolean r = vh.compareAndSet(Void.class, 0, $value1$, $value1$);
2307        });
2308        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
2309            boolean r = vh.compareAndSet(array, 0, Void.class, $value1$);
2310        });
2311        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
2312            boolean r = vh.compareAndSet(array, 0, $value1$, Void.class);
2313        });
2314        checkWMTE(() -> { // receiver primitive class
2315            boolean r = vh.compareAndSet(0, 0, $value1$, $value1$);
2316        });
2317        checkWMTE(() -> { // index reference class
2318            boolean r = vh.compareAndSet(array, Void.class, $value1$, $value1$);
2319        });
2320        // Incorrect arity
2321        checkWMTE(() -> { // 0
2322            boolean r = vh.compareAndSet();
2323        });
2324        checkWMTE(() -> { // >
2325            boolean r = vh.compareAndSet(array, 0, $value1$, $value1$, Void.class);
2326        });
2327
2328
2329        // WeakCompareAndSet
2330        // Incorrect argument types
2331        checkNPE(() -> { // null receiver
2332            boolean r = vh.weakCompareAndSet(null, 0, $value1$, $value1$);
2333        });
2334        checkCCE(() -> { // receiver reference class
2335            boolean r = vh.weakCompareAndSet(Void.class, 0, $value1$, $value1$);
2336        });
2337        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
2338            boolean r = vh.weakCompareAndSet(array, 0, Void.class, $value1$);
2339        });
2340        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
2341            boolean r = vh.weakCompareAndSet(array, 0, $value1$, Void.class);
2342        });
2343        checkWMTE(() -> { // receiver primitive class
2344            boolean r = vh.weakCompareAndSet(0, 0, $value1$, $value1$);
2345        });
2346        checkWMTE(() -> { // index reference class
2347            boolean r = vh.weakCompareAndSet(array, Void.class, $value1$, $value1$);
2348        });
2349        // Incorrect arity
2350        checkWMTE(() -> { // 0
2351            boolean r = vh.weakCompareAndSet();
2352        });
2353        checkWMTE(() -> { // >
2354            boolean r = vh.weakCompareAndSet(array, 0, $value1$, $value1$, Void.class);
2355        });
2356
2357
2358        // WeakCompareAndSetVolatile
2359        // Incorrect argument types
2360        checkNPE(() -> { // null receiver
2361            boolean r = vh.weakCompareAndSetVolatile(null, 0, $value1$, $value1$);
2362        });
2363        checkCCE(() -> { // receiver reference class
2364            boolean r = vh.weakCompareAndSetVolatile(Void.class, 0, $value1$, $value1$);
2365        });
2366        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
2367            boolean r = vh.weakCompareAndSetVolatile(array, 0, Void.class, $value1$);
2368        });
2369        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
2370            boolean r = vh.weakCompareAndSetVolatile(array, 0, $value1$, Void.class);
2371        });
2372        checkWMTE(() -> { // receiver primitive class
2373            boolean r = vh.weakCompareAndSetVolatile(0, 0, $value1$, $value1$);
2374        });
2375        checkWMTE(() -> { // index reference class
2376            boolean r = vh.weakCompareAndSetVolatile(array, Void.class, $value1$, $value1$);
2377        });
2378        // Incorrect arity
2379        checkWMTE(() -> { // 0
2380            boolean r = vh.weakCompareAndSetVolatile();
2381        });
2382        checkWMTE(() -> { // >
2383            boolean r = vh.weakCompareAndSetVolatile(array, 0, $value1$, $value1$, Void.class);
2384        });
2385
2386
2387        // WeakCompareAndSetAcquire
2388        // Incorrect argument types
2389        checkNPE(() -> { // null receiver
2390            boolean r = vh.weakCompareAndSetAcquire(null, 0, $value1$, $value1$);
2391        });
2392        checkCCE(() -> { // receiver reference class
2393            boolean r = vh.weakCompareAndSetAcquire(Void.class, 0, $value1$, $value1$);
2394        });
2395        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
2396            boolean r = vh.weakCompareAndSetAcquire(array, 0, Void.class, $value1$);
2397        });
2398        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
2399            boolean r = vh.weakCompareAndSetAcquire(array, 0, $value1$, Void.class);
2400        });
2401        checkWMTE(() -> { // receiver primitive class
2402            boolean r = vh.weakCompareAndSetAcquire(0, 0, $value1$, $value1$);
2403        });
2404        checkWMTE(() -> { // index reference class
2405            boolean r = vh.weakCompareAndSetAcquire(array, Void.class, $value1$, $value1$);
2406        });
2407        // Incorrect arity
2408        checkWMTE(() -> { // 0
2409            boolean r = vh.weakCompareAndSetAcquire();
2410        });
2411        checkWMTE(() -> { // >
2412            boolean r = vh.weakCompareAndSetAcquire(array, 0, $value1$, $value1$, Void.class);
2413        });
2414
2415
2416        // WeakCompareAndSetRelease
2417        // Incorrect argument types
2418        checkNPE(() -> { // null receiver
2419            boolean r = vh.weakCompareAndSetRelease(null, 0, $value1$, $value1$);
2420        });
2421        checkCCE(() -> { // receiver reference class
2422            boolean r = vh.weakCompareAndSetRelease(Void.class, 0, $value1$, $value1$);
2423        });
2424        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
2425            boolean r = vh.weakCompareAndSetRelease(array, 0, Void.class, $value1$);
2426        });
2427        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
2428            boolean r = vh.weakCompareAndSetRelease(array, 0, $value1$, Void.class);
2429        });
2430        checkWMTE(() -> { // receiver primitive class
2431            boolean r = vh.weakCompareAndSetRelease(0, 0, $value1$, $value1$);
2432        });
2433        checkWMTE(() -> { // index reference class
2434            boolean r = vh.weakCompareAndSetRelease(array, Void.class, $value1$, $value1$);
2435        });
2436        // Incorrect arity
2437        checkWMTE(() -> { // 0
2438            boolean r = vh.weakCompareAndSetRelease();
2439        });
2440        checkWMTE(() -> { // >
2441            boolean r = vh.weakCompareAndSetRelease(array, 0, $value1$, $value1$, Void.class);
2442        });
2443
2444
2445        // CompareAndExchange
2446        // Incorrect argument types
2447        checkNPE(() -> { // null receiver
2448            $type$ x = ($type$) vh.compareAndExchange(null, 0, $value1$, $value1$);
2449        });
2450        checkCCE(() -> { // array reference class
2451            $type$ x = ($type$) vh.compareAndExchange(Void.class, 0, $value1$, $value1$);
2452        });
2453        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
2454            $type$ x = ($type$) vh.compareAndExchange(array, 0, Void.class, $value1$);
2455        });
2456        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
2457            $type$ x = ($type$) vh.compareAndExchange(array, 0, $value1$, Void.class);
2458        });
2459        checkWMTE(() -> { // array primitive class
2460            $type$ x = ($type$) vh.compareAndExchange(0, 0, $value1$, $value1$);
2461        });
2462        checkWMTE(() -> { // index reference class
2463            $type$ x = ($type$) vh.compareAndExchange(array, Void.class, $value1$, $value1$);
2464        });
2465        // Incorrect return type
2466        check{#if[String]?CCE:WMTE}(() -> { // reference class
2467            Void r = (Void) vh.compareAndExchange(array, 0, $value1$, $value1$);
2468        });
2469        checkWMTE(() -> { // primitive class
2470            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.compareAndExchange(array, 0, $value1$, $value1$);
2471        });
2472        // Incorrect arity
2473        checkWMTE(() -> { // 0
2474            $type$ x = ($type$) vh.compareAndExchange();
2475        });
2476        checkWMTE(() -> { // >
2477            $type$ x = ($type$) vh.compareAndExchange(array, 0, $value1$, $value1$, Void.class);
2478        });
2479
2480
2481        // CompareAndExchangeAcquire
2482        // Incorrect argument types
2483        checkNPE(() -> { // null receiver
2484            $type$ x = ($type$) vh.compareAndExchangeAcquire(null, 0, $value1$, $value1$);
2485        });
2486        checkCCE(() -> { // array reference class
2487            $type$ x = ($type$) vh.compareAndExchangeAcquire(Void.class, 0, $value1$, $value1$);
2488        });
2489        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
2490            $type$ x = ($type$) vh.compareAndExchangeAcquire(array, 0, Void.class, $value1$);
2491        });
2492        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
2493            $type$ x = ($type$) vh.compareAndExchangeAcquire(array, 0, $value1$, Void.class);
2494        });
2495        checkWMTE(() -> { // array primitive class
2496            $type$ x = ($type$) vh.compareAndExchangeAcquire(0, 0, $value1$, $value1$);
2497        });
2498        checkWMTE(() -> { // index reference class
2499            $type$ x = ($type$) vh.compareAndExchangeAcquire(array, Void.class, $value1$, $value1$);
2500        });
2501        // Incorrect return type
2502        check{#if[String]?CCE:WMTE}(() -> { // reference class
2503            Void r = (Void) vh.compareAndExchangeAcquire(array, 0, $value1$, $value1$);
2504        });
2505        checkWMTE(() -> { // primitive class
2506            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.compareAndExchangeAcquire(array, 0, $value1$, $value1$);
2507        });
2508        // Incorrect arity
2509        checkWMTE(() -> { // 0
2510            $type$ x = ($type$) vh.compareAndExchangeAcquire();
2511        });
2512        checkWMTE(() -> { // >
2513            $type$ x = ($type$) vh.compareAndExchangeAcquire(array, 0, $value1$, $value1$, Void.class);
2514        });
2515
2516
2517        // CompareAndExchangeRelease
2518        // Incorrect argument types
2519        checkNPE(() -> { // null receiver
2520            $type$ x = ($type$) vh.compareAndExchangeRelease(null, 0, $value1$, $value1$);
2521        });
2522        checkCCE(() -> { // array reference class
2523            $type$ x = ($type$) vh.compareAndExchangeRelease(Void.class, 0, $value1$, $value1$);
2524        });
2525        check{#if[String]?CCE:WMTE}(() -> { // expected reference class
2526            $type$ x = ($type$) vh.compareAndExchangeRelease(array, 0, Void.class, $value1$);
2527        });
2528        check{#if[String]?CCE:WMTE}(() -> { // actual reference class
2529            $type$ x = ($type$) vh.compareAndExchangeRelease(array, 0, $value1$, Void.class);
2530        });
2531        checkWMTE(() -> { // array primitive class
2532            $type$ x = ($type$) vh.compareAndExchangeRelease(0, 0, $value1$, $value1$);
2533        });
2534        checkWMTE(() -> { // index reference class
2535            $type$ x = ($type$) vh.compareAndExchangeRelease(array, Void.class, $value1$, $value1$);
2536        });
2537        // Incorrect return type
2538        check{#if[String]?CCE:WMTE}(() -> { // reference class
2539            Void r = (Void) vh.compareAndExchangeRelease(array, 0, $value1$, $value1$);
2540        });
2541        checkWMTE(() -> { // primitive class
2542            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.compareAndExchangeRelease(array, 0, $value1$, $value1$);
2543        });
2544        // Incorrect arity
2545        checkWMTE(() -> { // 0
2546            $type$ x = ($type$) vh.compareAndExchangeRelease();
2547        });
2548        checkWMTE(() -> { // >
2549            $type$ x = ($type$) vh.compareAndExchangeRelease(array, 0, $value1$, $value1$, Void.class);
2550        });
2551
2552
2553        // GetAndSet
2554        // Incorrect argument types
2555        checkNPE(() -> { // null array
2556            $type$ x = ($type$) vh.getAndSet(null, 0, $value1$);
2557        });
2558        checkCCE(() -> { // array reference class
2559            $type$ x = ($type$) vh.getAndSet(Void.class, 0, $value1$);
2560        });
2561        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2562            $type$ x = ($type$) vh.getAndSet(array, 0, Void.class);
2563        });
2564        checkWMTE(() -> { // reciarrayever primitive class
2565            $type$ x = ($type$) vh.getAndSet(0, 0, $value1$);
2566        });
2567        checkWMTE(() -> { // index reference class
2568            $type$ x = ($type$) vh.getAndSet(array, Void.class, $value1$);
2569        });
2570        // Incorrect return type
2571        check{#if[String]?CCE:WMTE}(() -> { // reference class
2572            Void r = (Void) vh.getAndSet(array, 0, $value1$);
2573        });
2574        checkWMTE(() -> { // primitive class
2575            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndSet(array, 0, $value1$);
2576        });
2577        // Incorrect arity
2578        checkWMTE(() -> { // 0
2579            $type$ x = ($type$) vh.getAndSet();
2580        });
2581        checkWMTE(() -> { // >
2582            $type$ x = ($type$) vh.getAndSet(array, 0, $value1$, Void.class);
2583        });
2584
2585
2586        // GetAndSetAcquire
2587        // Incorrect argument types
2588        checkNPE(() -> { // null array
2589            $type$ x = ($type$) vh.getAndSetAcquire(null, 0, $value1$);
2590        });
2591        checkCCE(() -> { // array reference class
2592            $type$ x = ($type$) vh.getAndSetAcquire(Void.class, 0, $value1$);
2593        });
2594        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2595            $type$ x = ($type$) vh.getAndSetAcquire(array, 0, Void.class);
2596        });
2597        checkWMTE(() -> { // reciarrayever primitive class
2598            $type$ x = ($type$) vh.getAndSetAcquire(0, 0, $value1$);
2599        });
2600        checkWMTE(() -> { // index reference class
2601            $type$ x = ($type$) vh.getAndSetAcquire(array, Void.class, $value1$);
2602        });
2603        // Incorrect return type
2604        check{#if[String]?CCE:WMTE}(() -> { // reference class
2605            Void r = (Void) vh.getAndSetAcquire(array, 0, $value1$);
2606        });
2607        checkWMTE(() -> { // primitive class
2608            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndSetAcquire(array, 0, $value1$);
2609        });
2610        // Incorrect arity
2611        checkWMTE(() -> { // 0
2612            $type$ x = ($type$) vh.getAndSetAcquire();
2613        });
2614        checkWMTE(() -> { // >
2615            $type$ x = ($type$) vh.getAndSetAcquire(array, 0, $value1$, Void.class);
2616        });
2617
2618
2619        // GetAndSetRelease
2620        // Incorrect argument types
2621        checkNPE(() -> { // null array
2622            $type$ x = ($type$) vh.getAndSetRelease(null, 0, $value1$);
2623        });
2624        checkCCE(() -> { // array reference class
2625            $type$ x = ($type$) vh.getAndSetRelease(Void.class, 0, $value1$);
2626        });
2627        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2628            $type$ x = ($type$) vh.getAndSetRelease(array, 0, Void.class);
2629        });
2630        checkWMTE(() -> { // reciarrayever primitive class
2631            $type$ x = ($type$) vh.getAndSetRelease(0, 0, $value1$);
2632        });
2633        checkWMTE(() -> { // index reference class
2634            $type$ x = ($type$) vh.getAndSetRelease(array, Void.class, $value1$);
2635        });
2636        // Incorrect return type
2637        check{#if[String]?CCE:WMTE}(() -> { // reference class
2638            Void r = (Void) vh.getAndSetRelease(array, 0, $value1$);
2639        });
2640        checkWMTE(() -> { // primitive class
2641            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndSetRelease(array, 0, $value1$);
2642        });
2643        // Incorrect arity
2644        checkWMTE(() -> { // 0
2645            $type$ x = ($type$) vh.getAndSetRelease();
2646        });
2647        checkWMTE(() -> { // >
2648            $type$ x = ($type$) vh.getAndSetRelease(array, 0, $value1$, Void.class);
2649        });
2650#end[CAS]
2651
2652#if[AtomicAdd]
2653        // GetAndAdd
2654        // Incorrect argument types
2655        checkNPE(() -> { // null array
2656            $type$ x = ($type$) vh.getAndAdd(null, 0, $value1$);
2657        });
2658        checkCCE(() -> { // array reference class
2659            $type$ x = ($type$) vh.getAndAdd(Void.class, 0, $value1$);
2660        });
2661        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2662            $type$ x = ($type$) vh.getAndAdd(array, 0, Void.class);
2663        });
2664        checkWMTE(() -> { // array primitive class
2665            $type$ x = ($type$) vh.getAndAdd(0, 0, $value1$);
2666        });
2667        checkWMTE(() -> { // index reference class
2668            $type$ x = ($type$) vh.getAndAdd(array, Void.class, $value1$);
2669        });
2670        // Incorrect return type
2671        check{#if[String]?CCE:WMTE}(() -> { // reference class
2672            Void r = (Void) vh.getAndAdd(array, 0, $value1$);
2673        });
2674        checkWMTE(() -> { // primitive class
2675            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndAdd(array, 0, $value1$);
2676        });
2677        // Incorrect arity
2678        checkWMTE(() -> { // 0
2679            $type$ x = ($type$) vh.getAndAdd();
2680        });
2681        checkWMTE(() -> { // >
2682            $type$ x = ($type$) vh.getAndAdd(array, 0, $value1$, Void.class);
2683        });
2684
2685
2686        // GetAndAddAcquire
2687        // Incorrect argument types
2688        checkNPE(() -> { // null array
2689            $type$ x = ($type$) vh.getAndAddAcquire(null, 0, $value1$);
2690        });
2691        checkCCE(() -> { // array reference class
2692            $type$ x = ($type$) vh.getAndAddAcquire(Void.class, 0, $value1$);
2693        });
2694        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2695            $type$ x = ($type$) vh.getAndAddAcquire(array, 0, Void.class);
2696        });
2697        checkWMTE(() -> { // array primitive class
2698            $type$ x = ($type$) vh.getAndAddAcquire(0, 0, $value1$);
2699        });
2700        checkWMTE(() -> { // index reference class
2701            $type$ x = ($type$) vh.getAndAddAcquire(array, Void.class, $value1$);
2702        });
2703        // Incorrect return type
2704        check{#if[String]?CCE:WMTE}(() -> { // reference class
2705            Void r = (Void) vh.getAndAddAcquire(array, 0, $value1$);
2706        });
2707        checkWMTE(() -> { // primitive class
2708            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndAddAcquire(array, 0, $value1$);
2709        });
2710        // Incorrect arity
2711        checkWMTE(() -> { // 0
2712            $type$ x = ($type$) vh.getAndAddAcquire();
2713        });
2714        checkWMTE(() -> { // >
2715            $type$ x = ($type$) vh.getAndAddAcquire(array, 0, $value1$, Void.class);
2716        });
2717
2718
2719        // GetAndAddRelease
2720        // Incorrect argument types
2721        checkNPE(() -> { // null array
2722            $type$ x = ($type$) vh.getAndAddRelease(null, 0, $value1$);
2723        });
2724        checkCCE(() -> { // array reference class
2725            $type$ x = ($type$) vh.getAndAddRelease(Void.class, 0, $value1$);
2726        });
2727        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2728            $type$ x = ($type$) vh.getAndAddRelease(array, 0, Void.class);
2729        });
2730        checkWMTE(() -> { // array primitive class
2731            $type$ x = ($type$) vh.getAndAddRelease(0, 0, $value1$);
2732        });
2733        checkWMTE(() -> { // index reference class
2734            $type$ x = ($type$) vh.getAndAddRelease(array, Void.class, $value1$);
2735        });
2736        // Incorrect return type
2737        check{#if[String]?CCE:WMTE}(() -> { // reference class
2738            Void r = (Void) vh.getAndAddRelease(array, 0, $value1$);
2739        });
2740        checkWMTE(() -> { // primitive class
2741            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndAddRelease(array, 0, $value1$);
2742        });
2743        // Incorrect arity
2744        checkWMTE(() -> { // 0
2745            $type$ x = ($type$) vh.getAndAddRelease();
2746        });
2747        checkWMTE(() -> { // >
2748            $type$ x = ($type$) vh.getAndAddRelease(array, 0, $value1$, Void.class);
2749        });
2750
2751
2752        // AddAndGet
2753        // Incorrect argument types
2754        checkNPE(() -> { // null array
2755            $type$ x = ($type$) vh.addAndGet(null, 0, $value1$);
2756        });
2757        checkCCE(() -> { // array reference class
2758            $type$ x = ($type$) vh.addAndGet(Void.class, 0, $value1$);
2759        });
2760        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2761            $type$ x = ($type$) vh.addAndGet(array, 0, Void.class);
2762        });
2763        checkWMTE(() -> { // array primitive class
2764            $type$ x = ($type$) vh.addAndGet(0, 0, $value1$);
2765        });
2766        checkWMTE(() -> { // index reference class
2767            $type$ x = ($type$) vh.addAndGet(array, Void.class, $value1$);
2768        });
2769        // Incorrect return type
2770        check{#if[String]?CCE:WMTE}(() -> { // reference class
2771            Void r = (Void) vh.addAndGet(array, 0, $value1$);
2772        });
2773        checkWMTE(() -> { // primitive class
2774            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.addAndGet(array, 0, $value1$);
2775        });
2776        // Incorrect arity
2777        checkWMTE(() -> { // 0
2778            $type$ x = ($type$) vh.addAndGet();
2779        });
2780        checkWMTE(() -> { // >
2781            $type$ x = ($type$) vh.addAndGet(array, 0, $value1$, Void.class);
2782        });
2783#end[AtomicAdd]
2784
2785#if[Bitwise]
2786        // GetAndBitwiseOr
2787        // Incorrect argument types
2788        checkNPE(() -> { // null array
2789            $type$ x = ($type$) vh.getAndBitwiseOr(null, 0, $value1$);
2790        });
2791        checkCCE(() -> { // array reference class
2792            $type$ x = ($type$) vh.getAndBitwiseOr(Void.class, 0, $value1$);
2793        });
2794        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2795            $type$ x = ($type$) vh.getAndBitwiseOr(array, 0, Void.class);
2796        });
2797        checkWMTE(() -> { // array primitive class
2798            $type$ x = ($type$) vh.getAndBitwiseOr(0, 0, $value1$);
2799        });
2800        checkWMTE(() -> { // index reference class
2801            $type$ x = ($type$) vh.getAndBitwiseOr(array, Void.class, $value1$);
2802        });
2803        // Incorrect return type
2804        check{#if[String]?CCE:WMTE}(() -> { // reference class
2805            Void r = (Void) vh.getAndBitwiseOr(array, 0, $value1$);
2806        });
2807        checkWMTE(() -> { // primitive class
2808            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOr(array, 0, $value1$);
2809        });
2810        // Incorrect arity
2811        checkWMTE(() -> { // 0
2812            $type$ x = ($type$) vh.getAndBitwiseOr();
2813        });
2814        checkWMTE(() -> { // >
2815            $type$ x = ($type$) vh.getAndBitwiseOr(array, 0, $value1$, Void.class);
2816        });
2817
2818
2819        // GetAndBitwiseOrAcquire
2820        // Incorrect argument types
2821        checkNPE(() -> { // null array
2822            $type$ x = ($type$) vh.getAndBitwiseOrAcquire(null, 0, $value1$);
2823        });
2824        checkCCE(() -> { // array reference class
2825            $type$ x = ($type$) vh.getAndBitwiseOrAcquire(Void.class, 0, $value1$);
2826        });
2827        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2828            $type$ x = ($type$) vh.getAndBitwiseOrAcquire(array, 0, Void.class);
2829        });
2830        checkWMTE(() -> { // array primitive class
2831            $type$ x = ($type$) vh.getAndBitwiseOrAcquire(0, 0, $value1$);
2832        });
2833        checkWMTE(() -> { // index reference class
2834            $type$ x = ($type$) vh.getAndBitwiseOrAcquire(array, Void.class, $value1$);
2835        });
2836        // Incorrect return type
2837        check{#if[String]?CCE:WMTE}(() -> { // reference class
2838            Void r = (Void) vh.getAndBitwiseOrAcquire(array, 0, $value1$);
2839        });
2840        checkWMTE(() -> { // primitive class
2841            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOrAcquire(array, 0, $value1$);
2842        });
2843        // Incorrect arity
2844        checkWMTE(() -> { // 0
2845            $type$ x = ($type$) vh.getAndBitwiseOrAcquire();
2846        });
2847        checkWMTE(() -> { // >
2848            $type$ x = ($type$) vh.getAndBitwiseOrAcquire(array, 0, $value1$, Void.class);
2849        });
2850
2851
2852        // GetAndBitwiseOrRelease
2853        // Incorrect argument types
2854        checkNPE(() -> { // null array
2855            $type$ x = ($type$) vh.getAndBitwiseOrRelease(null, 0, $value1$);
2856        });
2857        checkCCE(() -> { // array reference class
2858            $type$ x = ($type$) vh.getAndBitwiseOrRelease(Void.class, 0, $value1$);
2859        });
2860        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2861            $type$ x = ($type$) vh.getAndBitwiseOrRelease(array, 0, Void.class);
2862        });
2863        checkWMTE(() -> { // array primitive class
2864            $type$ x = ($type$) vh.getAndBitwiseOrRelease(0, 0, $value1$);
2865        });
2866        checkWMTE(() -> { // index reference class
2867            $type$ x = ($type$) vh.getAndBitwiseOrRelease(array, Void.class, $value1$);
2868        });
2869        // Incorrect return type
2870        check{#if[String]?CCE:WMTE}(() -> { // reference class
2871            Void r = (Void) vh.getAndBitwiseOrRelease(array, 0, $value1$);
2872        });
2873        checkWMTE(() -> { // primitive class
2874            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseOrRelease(array, 0, $value1$);
2875        });
2876        // Incorrect arity
2877        checkWMTE(() -> { // 0
2878            $type$ x = ($type$) vh.getAndBitwiseOrRelease();
2879        });
2880        checkWMTE(() -> { // >
2881            $type$ x = ($type$) vh.getAndBitwiseOrRelease(array, 0, $value1$, Void.class);
2882        });
2883
2884
2885        // GetAndBitwiseAnd
2886        // Incorrect argument types
2887        checkNPE(() -> { // null array
2888            $type$ x = ($type$) vh.getAndBitwiseAnd(null, 0, $value1$);
2889        });
2890        checkCCE(() -> { // array reference class
2891            $type$ x = ($type$) vh.getAndBitwiseAnd(Void.class, 0, $value1$);
2892        });
2893        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2894            $type$ x = ($type$) vh.getAndBitwiseAnd(array, 0, Void.class);
2895        });
2896        checkWMTE(() -> { // array primitive class
2897            $type$ x = ($type$) vh.getAndBitwiseAnd(0, 0, $value1$);
2898        });
2899        checkWMTE(() -> { // index reference class
2900            $type$ x = ($type$) vh.getAndBitwiseAnd(array, Void.class, $value1$);
2901        });
2902        // Incorrect return type
2903        check{#if[String]?CCE:WMTE}(() -> { // reference class
2904            Void r = (Void) vh.getAndBitwiseAnd(array, 0, $value1$);
2905        });
2906        checkWMTE(() -> { // primitive class
2907            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAnd(array, 0, $value1$);
2908        });
2909        // Incorrect arity
2910        checkWMTE(() -> { // 0
2911            $type$ x = ($type$) vh.getAndBitwiseAnd();
2912        });
2913        checkWMTE(() -> { // >
2914            $type$ x = ($type$) vh.getAndBitwiseAnd(array, 0, $value1$, Void.class);
2915        });
2916
2917
2918        // GetAndBitwiseAndAcquire
2919        // Incorrect argument types
2920        checkNPE(() -> { // null array
2921            $type$ x = ($type$) vh.getAndBitwiseAndAcquire(null, 0, $value1$);
2922        });
2923        checkCCE(() -> { // array reference class
2924            $type$ x = ($type$) vh.getAndBitwiseAndAcquire(Void.class, 0, $value1$);
2925        });
2926        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2927            $type$ x = ($type$) vh.getAndBitwiseAndAcquire(array, 0, Void.class);
2928        });
2929        checkWMTE(() -> { // array primitive class
2930            $type$ x = ($type$) vh.getAndBitwiseAndAcquire(0, 0, $value1$);
2931        });
2932        checkWMTE(() -> { // index reference class
2933            $type$ x = ($type$) vh.getAndBitwiseAndAcquire(array, Void.class, $value1$);
2934        });
2935        // Incorrect return type
2936        check{#if[String]?CCE:WMTE}(() -> { // reference class
2937            Void r = (Void) vh.getAndBitwiseAndAcquire(array, 0, $value1$);
2938        });
2939        checkWMTE(() -> { // primitive class
2940            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAndAcquire(array, 0, $value1$);
2941        });
2942        // Incorrect arity
2943        checkWMTE(() -> { // 0
2944            $type$ x = ($type$) vh.getAndBitwiseAndAcquire();
2945        });
2946        checkWMTE(() -> { // >
2947            $type$ x = ($type$) vh.getAndBitwiseAndAcquire(array, 0, $value1$, Void.class);
2948        });
2949
2950
2951        // GetAndBitwiseAndRelease
2952        // Incorrect argument types
2953        checkNPE(() -> { // null array
2954            $type$ x = ($type$) vh.getAndBitwiseAndRelease(null, 0, $value1$);
2955        });
2956        checkCCE(() -> { // array reference class
2957            $type$ x = ($type$) vh.getAndBitwiseAndRelease(Void.class, 0, $value1$);
2958        });
2959        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2960            $type$ x = ($type$) vh.getAndBitwiseAndRelease(array, 0, Void.class);
2961        });
2962        checkWMTE(() -> { // array primitive class
2963            $type$ x = ($type$) vh.getAndBitwiseAndRelease(0, 0, $value1$);
2964        });
2965        checkWMTE(() -> { // index reference class
2966            $type$ x = ($type$) vh.getAndBitwiseAndRelease(array, Void.class, $value1$);
2967        });
2968        // Incorrect return type
2969        check{#if[String]?CCE:WMTE}(() -> { // reference class
2970            Void r = (Void) vh.getAndBitwiseAndRelease(array, 0, $value1$);
2971        });
2972        checkWMTE(() -> { // primitive class
2973            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseAndRelease(array, 0, $value1$);
2974        });
2975        // Incorrect arity
2976        checkWMTE(() -> { // 0
2977            $type$ x = ($type$) vh.getAndBitwiseAndRelease();
2978        });
2979        checkWMTE(() -> { // >
2980            $type$ x = ($type$) vh.getAndBitwiseAndRelease(array, 0, $value1$, Void.class);
2981        });
2982
2983
2984        // GetAndBitwiseXor
2985        // Incorrect argument types
2986        checkNPE(() -> { // null array
2987            $type$ x = ($type$) vh.getAndBitwiseXor(null, 0, $value1$);
2988        });
2989        checkCCE(() -> { // array reference class
2990            $type$ x = ($type$) vh.getAndBitwiseXor(Void.class, 0, $value1$);
2991        });
2992        check{#if[String]?CCE:WMTE}(() -> { // value reference class
2993            $type$ x = ($type$) vh.getAndBitwiseXor(array, 0, Void.class);
2994        });
2995        checkWMTE(() -> { // array primitive class
2996            $type$ x = ($type$) vh.getAndBitwiseXor(0, 0, $value1$);
2997        });
2998        checkWMTE(() -> { // index reference class
2999            $type$ x = ($type$) vh.getAndBitwiseXor(array, Void.class, $value1$);
3000        });
3001        // Incorrect return type
3002        check{#if[String]?CCE:WMTE}(() -> { // reference class
3003            Void r = (Void) vh.getAndBitwiseXor(array, 0, $value1$);
3004        });
3005        checkWMTE(() -> { // primitive class
3006            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXor(array, 0, $value1$);
3007        });
3008        // Incorrect arity
3009        checkWMTE(() -> { // 0
3010            $type$ x = ($type$) vh.getAndBitwiseXor();
3011        });
3012        checkWMTE(() -> { // >
3013            $type$ x = ($type$) vh.getAndBitwiseXor(array, 0, $value1$, Void.class);
3014        });
3015
3016
3017        // GetAndBitwiseXorAcquire
3018        // Incorrect argument types
3019        checkNPE(() -> { // null array
3020            $type$ x = ($type$) vh.getAndBitwiseXorAcquire(null, 0, $value1$);
3021        });
3022        checkCCE(() -> { // array reference class
3023            $type$ x = ($type$) vh.getAndBitwiseXorAcquire(Void.class, 0, $value1$);
3024        });
3025        check{#if[String]?CCE:WMTE}(() -> { // value reference class
3026            $type$ x = ($type$) vh.getAndBitwiseXorAcquire(array, 0, Void.class);
3027        });
3028        checkWMTE(() -> { // array primitive class
3029            $type$ x = ($type$) vh.getAndBitwiseXorAcquire(0, 0, $value1$);
3030        });
3031        checkWMTE(() -> { // index reference class
3032            $type$ x = ($type$) vh.getAndBitwiseXorAcquire(array, Void.class, $value1$);
3033        });
3034        // Incorrect return type
3035        check{#if[String]?CCE:WMTE}(() -> { // reference class
3036            Void r = (Void) vh.getAndBitwiseXorAcquire(array, 0, $value1$);
3037        });
3038        checkWMTE(() -> { // primitive class
3039            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXorAcquire(array, 0, $value1$);
3040        });
3041        // Incorrect arity
3042        checkWMTE(() -> { // 0
3043            $type$ x = ($type$) vh.getAndBitwiseXorAcquire();
3044        });
3045        checkWMTE(() -> { // >
3046            $type$ x = ($type$) vh.getAndBitwiseXorAcquire(array, 0, $value1$, Void.class);
3047        });
3048
3049
3050        // GetAndBitwiseXorRelease
3051        // Incorrect argument types
3052        checkNPE(() -> { // null array
3053            $type$ x = ($type$) vh.getAndBitwiseXorRelease(null, 0, $value1$);
3054        });
3055        checkCCE(() -> { // array reference class
3056            $type$ x = ($type$) vh.getAndBitwiseXorRelease(Void.class, 0, $value1$);
3057        });
3058        check{#if[String]?CCE:WMTE}(() -> { // value reference class
3059            $type$ x = ($type$) vh.getAndBitwiseXorRelease(array, 0, Void.class);
3060        });
3061        checkWMTE(() -> { // array primitive class
3062            $type$ x = ($type$) vh.getAndBitwiseXorRelease(0, 0, $value1$);
3063        });
3064        checkWMTE(() -> { // index reference class
3065            $type$ x = ($type$) vh.getAndBitwiseXorRelease(array, Void.class, $value1$);
3066        });
3067        // Incorrect return type
3068        check{#if[String]?CCE:WMTE}(() -> { // reference class
3069            Void r = (Void) vh.getAndBitwiseXorRelease(array, 0, $value1$);
3070        });
3071        checkWMTE(() -> { // primitive class
3072            $wrong_primitive_type$ x = ($wrong_primitive_type$) vh.getAndBitwiseXorRelease(array, 0, $value1$);
3073        });
3074        // Incorrect arity
3075        checkWMTE(() -> { // 0
3076            $type$ x = ($type$) vh.getAndBitwiseXorRelease();
3077        });
3078        checkWMTE(() -> { // >
3079            $type$ x = ($type$) vh.getAndBitwiseXorRelease(array, 0, $value1$, Void.class);
3080        });
3081#end[Bitwise]
3082    }
3083
3084    static void testArrayWrongMethodType(Handles hs) throws Throwable {
3085        $type$[] array = new $type$[10];
3086        Arrays.fill(array, $value1$);
3087
3088        for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) {
3089            // Incorrect argument types
3090            checkNPE(() -> { // null array
3091                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class)).
3092                    invokeExact(($type$[]) null, 0);
3093            });
3094            hs.checkWMTEOrCCE(() -> { // array reference class
3095                $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, int.class)).
3096                    invokeExact(Void.class, 0);
3097            });
3098            checkWMTE(() -> { // array primitive class
3099                $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class, int.class)).
3100                    invokeExact(0, 0);
3101            });
3102            checkWMTE(() -> { // index reference class
3103                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, Class.class)).
3104                    invokeExact(array, Void.class);
3105            });
3106            // Incorrect return type
3107            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
3108                Void x = (Void) hs.get(am, methodType(Void.class, $type$[].class, int.class)).
3109                    invokeExact(array, 0);
3110            });
3111            checkWMTE(() -> { // primitive class
3112                $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$[].class, int.class)).
3113                    invokeExact(array, 0);
3114            });
3115            // Incorrect arity
3116            checkWMTE(() -> { // 0
3117                $type$ x = ($type$) hs.get(am, methodType($type$.class)).
3118                    invokeExact();
3119            });
3120            checkWMTE(() -> { // >
3121                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, Class.class)).
3122                    invokeExact(array, 0, Void.class);
3123            });
3124        }
3125
3126        for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) {
3127            // Incorrect argument types
3128            checkNPE(() -> { // null array
3129                hs.get(am, methodType(void.class, $type$[].class, int.class, $type$.class)).
3130                    invokeExact(($type$[]) null, 0, $value1$);
3131            });
3132            hs.checkWMTEOrCCE(() -> { // array reference class
3133                hs.get(am, methodType(void.class, Class.class, int.class, $type$.class)).
3134                    invokeExact(Void.class, 0, $value1$);
3135            });
3136            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
3137                hs.get(am, methodType(void.class, $type$[].class, int.class, Class.class)).
3138                    invokeExact(array, 0, Void.class);
3139            });
3140            checkWMTE(() -> { // receiver primitive class
3141                hs.get(am, methodType(void.class, int.class, int.class, $type$.class)).
3142                    invokeExact(0, 0, $value1$);
3143            });
3144            checkWMTE(() -> { // index reference class
3145                hs.get(am, methodType(void.class, $type$[].class, Class.class, $type$.class)).
3146                    invokeExact(array, Void.class, $value1$);
3147            });
3148            // Incorrect arity
3149            checkWMTE(() -> { // 0
3150                hs.get(am, methodType(void.class)).
3151                    invokeExact();
3152            });
3153            checkWMTE(() -> { // >
3154                hs.get(am, methodType(void.class, $type$[].class, int.class, Class.class)).
3155                    invokeExact(array, 0, $value1$, Void.class);
3156            });
3157        }
3158#if[CAS]
3159        for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) {
3160            // Incorrect argument types
3161            checkNPE(() -> { // null receiver
3162                boolean r = (boolean) hs.get(am, methodType(boolean.class, $type$[].class, int.class, $type$.class, $type$.class)).
3163                    invokeExact(($type$[]) null, 0, $value1$, $value1$);
3164            });
3165            hs.checkWMTEOrCCE(() -> { // receiver reference class
3166                boolean r = (boolean) hs.get(am, methodType(boolean.class, Class.class, int.class, $type$.class, $type$.class)).
3167                    invokeExact(Void.class, 0, $value1$, $value1$);
3168            });
3169            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
3170                boolean r = (boolean) hs.get(am, methodType(boolean.class, $type$[].class, int.class, Class.class, $type$.class)).
3171                    invokeExact(array, 0, Void.class, $value1$);
3172            });
3173            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
3174                boolean r = (boolean) hs.get(am, methodType(boolean.class, $type$[].class, int.class, $type$.class, Class.class)).
3175                    invokeExact(array, 0, $value1$, Void.class);
3176            });
3177            checkWMTE(() -> { // receiver primitive class
3178                boolean r = (boolean) hs.get(am, methodType(boolean.class, int.class, int.class, $type$.class, $type$.class)).
3179                    invokeExact(0, 0, $value1$, $value1$);
3180            });
3181            checkWMTE(() -> { // index reference class
3182                boolean r = (boolean) hs.get(am, methodType(boolean.class, $type$[].class, Class.class, $type$.class, $type$.class)).
3183                    invokeExact(array, Void.class, $value1$, $value1$);
3184            });
3185            // Incorrect arity
3186            checkWMTE(() -> { // 0
3187                boolean r = (boolean) hs.get(am, methodType(boolean.class)).
3188                    invokeExact();
3189            });
3190            checkWMTE(() -> { // >
3191                boolean r = (boolean) hs.get(am, methodType(boolean.class, $type$[].class, int.class, $type$.class, $type$.class, Class.class)).
3192                    invokeExact(array, 0, $value1$, $value1$, Void.class);
3193            });
3194        }
3195
3196        for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) {
3197            // Incorrect argument types
3198            checkNPE(() -> { // null receiver
3199                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, $type$.class, $type$.class)).
3200                    invokeExact(($type$[]) null, 0, $value1$, $value1$);
3201            });
3202            hs.checkWMTEOrCCE(() -> { // array reference class
3203                $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, int.class, $type$.class, $type$.class)).
3204                    invokeExact(Void.class, 0, $value1$, $value1$);
3205            });
3206            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // expected reference class
3207                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, Class.class, $type$.class)).
3208                    invokeExact(array, 0, Void.class, $value1$);
3209            });
3210            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // actual reference class
3211                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, $type$.class, Class.class)).
3212                    invokeExact(array, 0, $value1$, Void.class);
3213            });
3214            checkWMTE(() -> { // array primitive class
3215                $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class, int.class, $type$.class, $type$.class)).
3216                    invokeExact(0, 0, $value1$, $value1$);
3217            });
3218            checkWMTE(() -> { // index reference class
3219                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, Class.class, $type$.class, $type$.class)).
3220                    invokeExact(array, Void.class, $value1$, $value1$);
3221            });
3222            // Incorrect return type
3223            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
3224                Void r = (Void) hs.get(am, methodType(Void.class, $type$[].class, int.class, $type$.class, $type$.class)).
3225                    invokeExact(array, 0, $value1$, $value1$);
3226            });
3227            checkWMTE(() -> { // primitive class
3228                $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$[].class, int.class, $type$.class, $type$.class)).
3229                    invokeExact(array, 0, $value1$, $value1$);
3230            });
3231            // Incorrect arity
3232            checkWMTE(() -> { // 0
3233                $type$ x = ($type$) hs.get(am, methodType($type$.class)).
3234                    invokeExact();
3235            });
3236            checkWMTE(() -> { // >
3237                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, $type$.class, $type$.class, Class.class)).
3238                    invokeExact(array, 0, $value1$, $value1$, Void.class);
3239            });
3240        }
3241
3242        for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) {
3243            // Incorrect argument types
3244            checkNPE(() -> { // null array
3245                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, $type$.class)).
3246                    invokeExact(($type$[]) null, 0, $value1$);
3247            });
3248            hs.checkWMTEOrCCE(() -> { // array reference class
3249                $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, int.class, $type$.class)).
3250                    invokeExact(Void.class, 0, $value1$);
3251            });
3252            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
3253                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, Class.class)).
3254                    invokeExact(array, 0, Void.class);
3255            });
3256            checkWMTE(() -> { // array primitive class
3257                $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class, int.class, $type$.class)).
3258                    invokeExact(0, 0, $value1$);
3259            });
3260            checkWMTE(() -> { // index reference class
3261                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, Class.class, $type$.class)).
3262                    invokeExact(array, Void.class, $value1$);
3263            });
3264            // Incorrect return type
3265            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
3266                Void r = (Void) hs.get(am, methodType(Void.class, $type$[].class, int.class, $type$.class)).
3267                    invokeExact(array, 0, $value1$);
3268            });
3269            checkWMTE(() -> { // primitive class
3270                $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$[].class, int.class, $type$.class)).
3271                    invokeExact(array, 0, $value1$);
3272            });
3273            // Incorrect arity
3274            checkWMTE(() -> { // 0
3275                $type$ x = ($type$) hs.get(am, methodType($type$.class)).
3276                    invokeExact();
3277            });
3278            checkWMTE(() -> { // >
3279                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, $type$.class, Class.class)).
3280                    invokeExact(array, 0, $value1$, Void.class);
3281            });
3282        }
3283#end[CAS]
3284
3285#if[AtomicAdd]
3286        for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
3287            // Incorrect argument types
3288            checkNPE(() -> { // null array
3289                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, $type$.class)).
3290                    invokeExact(($type$[]) null, 0, $value1$);
3291            });
3292            hs.checkWMTEOrCCE(() -> { // array reference class
3293                $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, int.class, $type$.class)).
3294                    invokeExact(Void.class, 0, $value1$);
3295            });
3296            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
3297                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, Class.class)).
3298                    invokeExact(array, 0, Void.class);
3299            });
3300            checkWMTE(() -> { // array primitive class
3301                $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class, int.class, $type$.class)).
3302                    invokeExact(0, 0, $value1$);
3303            });
3304            checkWMTE(() -> { // index reference class
3305                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, Class.class, $type$.class)).
3306                    invokeExact(array, Void.class, $value1$);
3307            });
3308            // Incorrect return type
3309            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
3310                Void r = (Void) hs.get(am, methodType(Void.class, $type$[].class, int.class, $type$.class)).
3311                    invokeExact(array, 0, $value1$);
3312            });
3313            checkWMTE(() -> { // primitive class
3314                $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$[].class, int.class, $type$.class)).
3315                    invokeExact(array, 0, $value1$);
3316            });
3317            // Incorrect arity
3318            checkWMTE(() -> { // 0
3319                $type$ x = ($type$) hs.get(am, methodType($type$.class)).
3320                    invokeExact();
3321            });
3322            checkWMTE(() -> { // >
3323                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, $type$.class, Class.class)).
3324                    invokeExact(array, 0, $value1$, Void.class);
3325            });
3326        }
3327#end[AtomicAdd]
3328
3329#if[Bitwise]
3330        for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) {
3331            // Incorrect argument types
3332            checkNPE(() -> { // null array
3333                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, $type$.class)).
3334                    invokeExact(($type$[]) null, 0, $value1$);
3335            });
3336            hs.checkWMTEOrCCE(() -> { // array reference class
3337                $type$ x = ($type$) hs.get(am, methodType($type$.class, Class.class, int.class, $type$.class)).
3338                    invokeExact(Void.class, 0, $value1$);
3339            });
3340            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // value reference class
3341                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, Class.class)).
3342                    invokeExact(array, 0, Void.class);
3343            });
3344            checkWMTE(() -> { // array primitive class
3345                $type$ x = ($type$) hs.get(am, methodType($type$.class, int.class, int.class, $type$.class)).
3346                    invokeExact(0, 0, $value1$);
3347            });
3348            checkWMTE(() -> { // index reference class
3349                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, Class.class, $type$.class)).
3350                    invokeExact(array, Void.class, $value1$);
3351            });
3352            // Incorrect return type
3353            {#if[String]?hs.checkWMTEOrCCE:checkWMTE}(() -> { // reference class
3354                Void r = (Void) hs.get(am, methodType(Void.class, $type$[].class, int.class, $type$.class)).
3355                    invokeExact(array, 0, $value1$);
3356            });
3357            checkWMTE(() -> { // primitive class
3358                $wrong_primitive_type$ x = ($wrong_primitive_type$) hs.get(am, methodType($wrong_primitive_type$.class, $type$[].class, int.class, $type$.class)).
3359                    invokeExact(array, 0, $value1$);
3360            });
3361            // Incorrect arity
3362            checkWMTE(() -> { // 0
3363                $type$ x = ($type$) hs.get(am, methodType($type$.class)).
3364                    invokeExact();
3365            });
3366            checkWMTE(() -> { // >
3367                $type$ x = ($type$) hs.get(am, methodType($type$.class, $type$[].class, int.class, $type$.class, Class.class)).
3368                    invokeExact(array, 0, $value1$, Void.class);
3369            });
3370        }
3371#end[Bitwise]
3372    }
3373}
3374
3375