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