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