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 VarHandleTestMethodTypeDouble
30 * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeDouble
31 * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false VarHandleTestMethodTypeDouble
32 * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true VarHandleTestMethodTypeDouble
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 VarHandleTestMethodTypeDouble extends VarHandleBaseTest {
50 static final double static_final_v = 1.0d;
51
52 static double static_v = 1.0d;
53
54 final double final_v = 1.0d;
55
56 double v = 1.0d;
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 VarHandleTestMethodTypeDouble.class, "final_v", double.class);
72
73 vhField = MethodHandles.lookup().findVarHandle(
74 VarHandleTestMethodTypeDouble.class, "v", double.class);
75
76 vhStaticFinalField = MethodHandles.lookup().findStaticVarHandle(
77 VarHandleTestMethodTypeDouble.class, "static_final_v", double.class);
78
79 vhStaticField = MethodHandles.lookup().findStaticVarHandle(
80 VarHandleTestMethodTypeDouble.class, "static_v", double.class);
81
82 vhArray = MethodHandles.arrayElementVarHandle(double[].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, VarHandleTestMethodTypeDouble::testStaticFieldWrongMethodType,
95 false));
96
97 cases.add(new VarHandleAccessTestCase("Array",
98 vhArray, VarHandleTestMethodTypeDouble::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, VarHandleTestMethodTypeDouble::testStaticFieldWrongMethodType,
108 false));
109
110 cases.add(new MethodHandleAccessTestCase("Array",
111 vhArray, f, VarHandleTestMethodTypeDouble::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(VarHandleTestMethodTypeDouble recv, VarHandle vh) throws Throwable {
131 // Get
132 // Incorrect argument types
133 checkNPE(() -> { // null receiver
134 double x = (double) vh.get(null);
135 });
136 checkCCE(() -> { // receiver reference class
137 double x = (double) vh.get(Void.class);
138 });
139 checkWMTE(() -> { // receiver primitive class
140 double x = (double) 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 double x = (double) vh.get();
152 });
153 checkWMTE(() -> { // >
154 double x = (double) vh.get(recv, Void.class);
155 });
156
157
158 // Set
159 // Incorrect argument types
160 checkNPE(() -> { // null receiver
161 vh.set(null, 1.0d);
162 });
163 checkCCE(() -> { // receiver reference class
164 vh.set(Void.class, 1.0d);
165 });
166 checkWMTE(() -> { // value reference class
167 vh.set(recv, Void.class);
168 });
169 checkWMTE(() -> { // receiver primitive class
170 vh.set(0, 1.0d);
171 });
172 // Incorrect arity
173 checkWMTE(() -> { // 0
174 vh.set();
175 });
176 checkWMTE(() -> { // >
177 vh.set(recv, 1.0d, Void.class);
178 });
179
180
181 // GetVolatile
182 // Incorrect argument types
183 checkNPE(() -> { // null receiver
184 double x = (double) vh.getVolatile(null);
185 });
186 checkCCE(() -> { // receiver reference class
187 double x = (double) vh.getVolatile(Void.class);
188 });
189 checkWMTE(() -> { // receiver primitive class
190 double x = (double) 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 double x = (double) vh.getVolatile();
202 });
203 checkWMTE(() -> { // >
204 double x = (double) vh.getVolatile(recv, Void.class);
205 });
206
207
208 // SetVolatile
209 // Incorrect argument types
210 checkNPE(() -> { // null receiver
211 vh.setVolatile(null, 1.0d);
212 });
213 checkCCE(() -> { // receiver reference class
214 vh.setVolatile(Void.class, 1.0d);
215 });
216 checkWMTE(() -> { // value reference class
217 vh.setVolatile(recv, Void.class);
218 });
219 checkWMTE(() -> { // receiver primitive class
220 vh.setVolatile(0, 1.0d);
221 });
222 // Incorrect arity
223 checkWMTE(() -> { // 0
224 vh.setVolatile();
225 });
226 checkWMTE(() -> { // >
227 vh.setVolatile(recv, 1.0d, Void.class);
228 });
229
230
231 // GetOpaque
232 // Incorrect argument types
233 checkNPE(() -> { // null receiver
234 double x = (double) vh.getOpaque(null);
235 });
236 checkCCE(() -> { // receiver reference class
237 double x = (double) vh.getOpaque(Void.class);
238 });
239 checkWMTE(() -> { // receiver primitive class
240 double x = (double) 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 double x = (double) vh.getOpaque();
252 });
253 checkWMTE(() -> { // >
254 double x = (double) vh.getOpaque(recv, Void.class);
255 });
256
257
258 // SetOpaque
259 // Incorrect argument types
260 checkNPE(() -> { // null receiver
261 vh.setOpaque(null, 1.0d);
262 });
263 checkCCE(() -> { // receiver reference class
264 vh.setOpaque(Void.class, 1.0d);
265 });
266 checkWMTE(() -> { // value reference class
267 vh.setOpaque(recv, Void.class);
268 });
269 checkWMTE(() -> { // receiver primitive class
270 vh.setOpaque(0, 1.0d);
271 });
272 // Incorrect arity
273 checkWMTE(() -> { // 0
274 vh.setOpaque();
275 });
276 checkWMTE(() -> { // >
277 vh.setOpaque(recv, 1.0d, Void.class);
278 });
279
280
281 // GetAcquire
282 // Incorrect argument types
283 checkNPE(() -> { // null receiver
284 double x = (double) vh.getAcquire(null);
285 });
286 checkCCE(() -> { // receiver reference class
287 double x = (double) vh.getAcquire(Void.class);
288 });
289 checkWMTE(() -> { // receiver primitive class
290 double x = (double) 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 double x = (double) vh.getAcquire();
302 });
303 checkWMTE(() -> { // >
304 double x = (double) vh.getAcquire(recv, Void.class);
305 });
306
307
308 // SetRelease
309 // Incorrect argument types
310 checkNPE(() -> { // null receiver
311 vh.setRelease(null, 1.0d);
312 });
313 checkCCE(() -> { // receiver reference class
314 vh.setRelease(Void.class, 1.0d);
315 });
316 checkWMTE(() -> { // value reference class
317 vh.setRelease(recv, Void.class);
318 });
319 checkWMTE(() -> { // receiver primitive class
320 vh.setRelease(0, 1.0d);
321 });
322 // Incorrect arity
323 checkWMTE(() -> { // 0
324 vh.setRelease();
325 });
326 checkWMTE(() -> { // >
327 vh.setRelease(recv, 1.0d, Void.class);
328 });
329
330
331 // CompareAndSet
332 // Incorrect argument types
333 checkNPE(() -> { // null receiver
334 boolean r = vh.compareAndSet(null, 1.0d, 1.0d);
335 });
336 checkCCE(() -> { // receiver reference class
337 boolean r = vh.compareAndSet(Void.class, 1.0d, 1.0d);
338 });
339 checkWMTE(() -> { // expected reference class
340 boolean r = vh.compareAndSet(recv, Void.class, 1.0d);
341 });
342 checkWMTE(() -> { // actual reference class
343 boolean r = vh.compareAndSet(recv, 1.0d, Void.class);
344 });
345 checkWMTE(() -> { // receiver primitive class
346 boolean r = vh.compareAndSet(0, 1.0d, 1.0d);
347 });
348 // Incorrect arity
349 checkWMTE(() -> { // 0
350 boolean r = vh.compareAndSet();
351 });
352 checkWMTE(() -> { // >
353 boolean r = vh.compareAndSet(recv, 1.0d, 1.0d, Void.class);
354 });
355
356
357 // WeakCompareAndSet
358 // Incorrect argument types
359 checkNPE(() -> { // null receiver
360 boolean r = vh.weakCompareAndSetPlain(null, 1.0d, 1.0d);
361 });
362 checkCCE(() -> { // receiver reference class
363 boolean r = vh.weakCompareAndSetPlain(Void.class, 1.0d, 1.0d);
364 });
365 checkWMTE(() -> { // expected reference class
366 boolean r = vh.weakCompareAndSetPlain(recv, Void.class, 1.0d);
367 });
368 checkWMTE(() -> { // actual reference class
369 boolean r = vh.weakCompareAndSetPlain(recv, 1.0d, Void.class);
370 });
371 checkWMTE(() -> { // receiver primitive class
372 boolean r = vh.weakCompareAndSetPlain(0, 1.0d, 1.0d);
373 });
374 // Incorrect arity
375 checkWMTE(() -> { // 0
376 boolean r = vh.weakCompareAndSetPlain();
377 });
378 checkWMTE(() -> { // >
379 boolean r = vh.weakCompareAndSetPlain(recv, 1.0d, 1.0d, Void.class);
380 });
381
382
383 // WeakCompareAndSetVolatile
384 // Incorrect argument types
385 checkNPE(() -> { // null receiver
386 boolean r = vh.weakCompareAndSet(null, 1.0d, 1.0d);
387 });
388 checkCCE(() -> { // receiver reference class
389 boolean r = vh.weakCompareAndSet(Void.class, 1.0d, 1.0d);
390 });
391 checkWMTE(() -> { // expected reference class
392 boolean r = vh.weakCompareAndSet(recv, Void.class, 1.0d);
393 });
394 checkWMTE(() -> { // actual reference class
395 boolean r = vh.weakCompareAndSet(recv, 1.0d, Void.class);
396 });
397 checkWMTE(() -> { // receiver primitive class
398 boolean r = vh.weakCompareAndSet(0, 1.0d, 1.0d);
399 });
400 // Incorrect arity
401 checkWMTE(() -> { // 0
402 boolean r = vh.weakCompareAndSet();
403 });
404 checkWMTE(() -> { // >
405 boolean r = vh.weakCompareAndSet(recv, 1.0d, 1.0d, Void.class);
406 });
407
408
409 // WeakCompareAndSetAcquire
410 // Incorrect argument types
411 checkNPE(() -> { // null receiver
412 boolean r = vh.weakCompareAndSetAcquire(null, 1.0d, 1.0d);
413 });
414 checkCCE(() -> { // receiver reference class
415 boolean r = vh.weakCompareAndSetAcquire(Void.class, 1.0d, 1.0d);
416 });
417 checkWMTE(() -> { // expected reference class
418 boolean r = vh.weakCompareAndSetAcquire(recv, Void.class, 1.0d);
419 });
420 checkWMTE(() -> { // actual reference class
421 boolean r = vh.weakCompareAndSetAcquire(recv, 1.0d, Void.class);
422 });
423 checkWMTE(() -> { // receiver primitive class
424 boolean r = vh.weakCompareAndSetAcquire(0, 1.0d, 1.0d);
425 });
426 // Incorrect arity
427 checkWMTE(() -> { // 0
428 boolean r = vh.weakCompareAndSetAcquire();
429 });
430 checkWMTE(() -> { // >
431 boolean r = vh.weakCompareAndSetAcquire(recv, 1.0d, 1.0d, Void.class);
432 });
433
434
435 // WeakCompareAndSetRelease
436 // Incorrect argument types
437 checkNPE(() -> { // null receiver
438 boolean r = vh.weakCompareAndSetRelease(null, 1.0d, 1.0d);
439 });
440 checkCCE(() -> { // receiver reference class
441 boolean r = vh.weakCompareAndSetRelease(Void.class, 1.0d, 1.0d);
442 });
443 checkWMTE(() -> { // expected reference class
444 boolean r = vh.weakCompareAndSetRelease(recv, Void.class, 1.0d);
445 });
446 checkWMTE(() -> { // actual reference class
447 boolean r = vh.weakCompareAndSetRelease(recv, 1.0d, Void.class);
448 });
449 checkWMTE(() -> { // receiver primitive class
450 boolean r = vh.weakCompareAndSetRelease(0, 1.0d, 1.0d);
451 });
452 // Incorrect arity
453 checkWMTE(() -> { // 0
454 boolean r = vh.weakCompareAndSetRelease();
455 });
456 checkWMTE(() -> { // >
457 boolean r = vh.weakCompareAndSetRelease(recv, 1.0d, 1.0d, Void.class);
458 });
459
460
461 // CompareAndExchange
462 // Incorrect argument types
463 checkNPE(() -> { // null receiver
464 double x = (double) vh.compareAndExchange(null, 1.0d, 1.0d);
465 });
466 checkCCE(() -> { // receiver reference class
467 double x = (double) vh.compareAndExchange(Void.class, 1.0d, 1.0d);
468 });
469 checkWMTE(() -> { // expected reference class
470 double x = (double) vh.compareAndExchange(recv, Void.class, 1.0d);
471 });
472 checkWMTE(() -> { // actual reference class
473 double x = (double) vh.compareAndExchange(recv, 1.0d, Void.class);
474 });
475 checkWMTE(() -> { // reciever primitive class
476 double x = (double) vh.compareAndExchange(0, 1.0d, 1.0d);
477 });
478 // Incorrect return type
479 checkWMTE(() -> { // reference class
480 Void r = (Void) vh.compareAndExchange(recv, 1.0d, 1.0d);
481 });
482 checkWMTE(() -> { // primitive class
483 boolean x = (boolean) vh.compareAndExchange(recv, 1.0d, 1.0d);
484 });
485 // Incorrect arity
486 checkWMTE(() -> { // 0
487 double x = (double) vh.compareAndExchange();
488 });
489 checkWMTE(() -> { // >
490 double x = (double) vh.compareAndExchange(recv, 1.0d, 1.0d, Void.class);
491 });
492
493
494 // CompareAndExchangeAcquire
495 // Incorrect argument types
496 checkNPE(() -> { // null receiver
497 double x = (double) vh.compareAndExchangeAcquire(null, 1.0d, 1.0d);
498 });
499 checkCCE(() -> { // receiver reference class
500 double x = (double) vh.compareAndExchangeAcquire(Void.class, 1.0d, 1.0d);
501 });
502 checkWMTE(() -> { // expected reference class
503 double x = (double) vh.compareAndExchangeAcquire(recv, Void.class, 1.0d);
504 });
505 checkWMTE(() -> { // actual reference class
506 double x = (double) vh.compareAndExchangeAcquire(recv, 1.0d, Void.class);
507 });
508 checkWMTE(() -> { // reciever primitive class
509 double x = (double) vh.compareAndExchangeAcquire(0, 1.0d, 1.0d);
510 });
511 // Incorrect return type
512 checkWMTE(() -> { // reference class
513 Void r = (Void) vh.compareAndExchangeAcquire(recv, 1.0d, 1.0d);
514 });
515 checkWMTE(() -> { // primitive class
516 boolean x = (boolean) vh.compareAndExchangeAcquire(recv, 1.0d, 1.0d);
517 });
518 // Incorrect arity
519 checkWMTE(() -> { // 0
520 double x = (double) vh.compareAndExchangeAcquire();
521 });
522 checkWMTE(() -> { // >
523 double x = (double) vh.compareAndExchangeAcquire(recv, 1.0d, 1.0d, Void.class);
524 });
525
526
527 // CompareAndExchangeRelease
528 // Incorrect argument types
529 checkNPE(() -> { // null receiver
530 double x = (double) vh.compareAndExchangeRelease(null, 1.0d, 1.0d);
531 });
532 checkCCE(() -> { // receiver reference class
533 double x = (double) vh.compareAndExchangeRelease(Void.class, 1.0d, 1.0d);
534 });
535 checkWMTE(() -> { // expected reference class
536 double x = (double) vh.compareAndExchangeRelease(recv, Void.class, 1.0d);
537 });
538 checkWMTE(() -> { // actual reference class
539 double x = (double) vh.compareAndExchangeRelease(recv, 1.0d, Void.class);
540 });
541 checkWMTE(() -> { // reciever primitive class
542 double x = (double) vh.compareAndExchangeRelease(0, 1.0d, 1.0d);
543 });
544 // Incorrect return type
545 checkWMTE(() -> { // reference class
546 Void r = (Void) vh.compareAndExchangeRelease(recv, 1.0d, 1.0d);
547 });
548 checkWMTE(() -> { // primitive class
549 boolean x = (boolean) vh.compareAndExchangeRelease(recv, 1.0d, 1.0d);
550 });
551 // Incorrect arity
552 checkWMTE(() -> { // 0
553 double x = (double) vh.compareAndExchangeRelease();
554 });
555 checkWMTE(() -> { // >
556 double x = (double) vh.compareAndExchangeRelease(recv, 1.0d, 1.0d, Void.class);
557 });
558
559
560 // GetAndSet
561 // Incorrect argument types
562 checkNPE(() -> { // null receiver
563 double x = (double) vh.getAndSet(null, 1.0d);
564 });
565 checkCCE(() -> { // receiver reference class
566 double x = (double) vh.getAndSet(Void.class, 1.0d);
567 });
568 checkWMTE(() -> { // value reference class
569 double x = (double) vh.getAndSet(recv, Void.class);
570 });
571 checkWMTE(() -> { // reciever primitive class
572 double x = (double) vh.getAndSet(0, 1.0d);
573 });
574 // Incorrect return type
575 checkWMTE(() -> { // reference class
576 Void r = (Void) vh.getAndSet(recv, 1.0d);
577 });
578 checkWMTE(() -> { // primitive class
579 boolean x = (boolean) vh.getAndSet(recv, 1.0d);
580 });
581 // Incorrect arity
582 checkWMTE(() -> { // 0
583 double x = (double) vh.getAndSet();
584 });
585 checkWMTE(() -> { // >
586 double x = (double) vh.getAndSet(recv, 1.0d, Void.class);
587 });
588
589 // GetAndSetAcquire
590 // Incorrect argument types
591 checkNPE(() -> { // null receiver
592 double x = (double) vh.getAndSetAcquire(null, 1.0d);
593 });
594 checkCCE(() -> { // receiver reference class
595 double x = (double) vh.getAndSetAcquire(Void.class, 1.0d);
596 });
597 checkWMTE(() -> { // value reference class
598 double x = (double) vh.getAndSetAcquire(recv, Void.class);
599 });
600 checkWMTE(() -> { // reciever primitive class
601 double x = (double) vh.getAndSetAcquire(0, 1.0d);
602 });
603 // Incorrect return type
604 checkWMTE(() -> { // reference class
605 Void r = (Void) vh.getAndSetAcquire(recv, 1.0d);
606 });
607 checkWMTE(() -> { // primitive class
608 boolean x = (boolean) vh.getAndSetAcquire(recv, 1.0d);
609 });
610 // Incorrect arity
611 checkWMTE(() -> { // 0
612 double x = (double) vh.getAndSetAcquire();
613 });
614 checkWMTE(() -> { // >
615 double x = (double) vh.getAndSetAcquire(recv, 1.0d, Void.class);
616 });
617
618 // GetAndSetRelease
619 // Incorrect argument types
620 checkNPE(() -> { // null receiver
621 double x = (double) vh.getAndSetRelease(null, 1.0d);
622 });
623 checkCCE(() -> { // receiver reference class
624 double x = (double) vh.getAndSetRelease(Void.class, 1.0d);
625 });
626 checkWMTE(() -> { // value reference class
627 double x = (double) vh.getAndSetRelease(recv, Void.class);
628 });
629 checkWMTE(() -> { // reciever primitive class
630 double x = (double) vh.getAndSetRelease(0, 1.0d);
631 });
632 // Incorrect return type
633 checkWMTE(() -> { // reference class
634 Void r = (Void) vh.getAndSetRelease(recv, 1.0d);
635 });
636 checkWMTE(() -> { // primitive class
637 boolean x = (boolean) vh.getAndSetRelease(recv, 1.0d);
638 });
639 // Incorrect arity
640 checkWMTE(() -> { // 0
641 double x = (double) vh.getAndSetRelease();
642 });
643 checkWMTE(() -> { // >
644 double x = (double) vh.getAndSetRelease(recv, 1.0d, Void.class);
645 });
646
647 // GetAndAdd
648 // Incorrect argument types
649 checkNPE(() -> { // null receiver
650 double x = (double) vh.getAndAdd(null, 1.0d);
651 });
652 checkCCE(() -> { // receiver reference class
653 double x = (double) vh.getAndAdd(Void.class, 1.0d);
654 });
655 checkWMTE(() -> { // value reference class
656 double x = (double) vh.getAndAdd(recv, Void.class);
657 });
658 checkWMTE(() -> { // reciever primitive class
659 double x = (double) vh.getAndAdd(0, 1.0d);
660 });
661 // Incorrect return type
662 checkWMTE(() -> { // reference class
663 Void r = (Void) vh.getAndAdd(recv, 1.0d);
664 });
665 checkWMTE(() -> { // primitive class
666 boolean x = (boolean) vh.getAndAdd(recv, 1.0d);
667 });
668 // Incorrect arity
669 checkWMTE(() -> { // 0
670 double x = (double) vh.getAndAdd();
671 });
672 checkWMTE(() -> { // >
673 double x = (double) vh.getAndAdd(recv, 1.0d, Void.class);
674 });
675
676 // GetAndAddAcquire
677 // Incorrect argument types
678 checkNPE(() -> { // null receiver
679 double x = (double) vh.getAndAddAcquire(null, 1.0d);
680 });
681 checkCCE(() -> { // receiver reference class
682 double x = (double) vh.getAndAddAcquire(Void.class, 1.0d);
683 });
684 checkWMTE(() -> { // value reference class
685 double x = (double) vh.getAndAddAcquire(recv, Void.class);
686 });
687 checkWMTE(() -> { // reciever primitive class
688 double x = (double) vh.getAndAddAcquire(0, 1.0d);
689 });
690 // Incorrect return type
691 checkWMTE(() -> { // reference class
692 Void r = (Void) vh.getAndAddAcquire(recv, 1.0d);
693 });
694 checkWMTE(() -> { // primitive class
695 boolean x = (boolean) vh.getAndAddAcquire(recv, 1.0d);
696 });
697 // Incorrect arity
698 checkWMTE(() -> { // 0
699 double x = (double) vh.getAndAddAcquire();
700 });
701 checkWMTE(() -> { // >
702 double x = (double) vh.getAndAddAcquire(recv, 1.0d, Void.class);
703 });
704
705 // GetAndAddRelease
706 // Incorrect argument types
707 checkNPE(() -> { // null receiver
708 double x = (double) vh.getAndAddRelease(null, 1.0d);
709 });
710 checkCCE(() -> { // receiver reference class
711 double x = (double) vh.getAndAddRelease(Void.class, 1.0d);
712 });
713 checkWMTE(() -> { // value reference class
714 double x = (double) vh.getAndAddRelease(recv, Void.class);
715 });
716 checkWMTE(() -> { // reciever primitive class
717 double x = (double) vh.getAndAddRelease(0, 1.0d);
718 });
719 // Incorrect return type
720 checkWMTE(() -> { // reference class
721 Void r = (Void) vh.getAndAddRelease(recv, 1.0d);
722 });
723 checkWMTE(() -> { // primitive class
724 boolean x = (boolean) vh.getAndAddRelease(recv, 1.0d);
725 });
726 // Incorrect arity
727 checkWMTE(() -> { // 0
728 double x = (double) vh.getAndAddRelease();
729 });
730 checkWMTE(() -> { // >
731 double x = (double) vh.getAndAddRelease(recv, 1.0d, Void.class);
732 });
733
734 }
735
736 static void testInstanceFieldWrongMethodType(VarHandleTestMethodTypeDouble recv, Handles hs) throws Throwable {
737 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) {
738 // Incorrect argument types
739 checkNPE(() -> { // null receiver
740 double x = (double) hs.get(am, methodType(double.class, VarHandleTestMethodTypeDouble.class)).
741 invokeExact((VarHandleTestMethodTypeDouble) null);
742 });
743 hs.checkWMTEOrCCE(() -> { // receiver reference class
744 double x = (double) hs.get(am, methodType(double.class, Class.class)).
745 invokeExact(Void.class);
746 });
747 checkWMTE(() -> { // receiver primitive class
748 double x = (double) hs.get(am, methodType(double.class, int.class)).
749 invokeExact(0);
750 });
751 // Incorrect return type
752 checkWMTE(() -> { // reference class
753 Void x = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodTypeDouble.class)).
754 invokeExact(recv);
755 });
756 checkWMTE(() -> { // primitive class
757 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeDouble.class)).
758 invokeExact(recv);
759 });
760 // Incorrect arity
761 checkWMTE(() -> { // 0
762 double x = (double) hs.get(am, methodType(double.class)).
763 invokeExact();
764 });
765 checkWMTE(() -> { // >
766 double x = (double) hs.get(am, methodType(double.class, VarHandleTestMethodTypeDouble.class, Class.class)).
767 invokeExact(recv, Void.class);
768 });
769 }
770
771 for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) {
772 // Incorrect argument types
773 checkNPE(() -> { // null receiver
774 hs.get(am, methodType(void.class, VarHandleTestMethodTypeDouble.class, double.class)).
775 invokeExact((VarHandleTestMethodTypeDouble) null, 1.0d);
776 });
777 hs.checkWMTEOrCCE(() -> { // receiver reference class
778 hs.get(am, methodType(void.class, Class.class, double.class)).
779 invokeExact(Void.class, 1.0d);
780 });
781 checkWMTE(() -> { // value reference class
782 hs.get(am, methodType(void.class, VarHandleTestMethodTypeDouble.class, Class.class)).
783 invokeExact(recv, Void.class);
784 });
785 checkWMTE(() -> { // receiver primitive class
786 hs.get(am, methodType(void.class, int.class, double.class)).
787 invokeExact(0, 1.0d);
788 });
789 // Incorrect arity
790 checkWMTE(() -> { // 0
791 hs.get(am, methodType(void.class)).
792 invokeExact();
793 });
794 checkWMTE(() -> { // >
795 hs.get(am, methodType(void.class, VarHandleTestMethodTypeDouble.class, double.class, Class.class)).
796 invokeExact(recv, 1.0d, Void.class);
797 });
798 }
799
800 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) {
801 // Incorrect argument types
802 checkNPE(() -> { // null receiver
803 boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeDouble.class, double.class, double.class)).
804 invokeExact((VarHandleTestMethodTypeDouble) null, 1.0d, 1.0d);
805 });
806 hs.checkWMTEOrCCE(() -> { // receiver reference class
807 boolean r = (boolean) hs.get(am, methodType(boolean.class, Class.class, double.class, double.class)).
808 invokeExact(Void.class, 1.0d, 1.0d);
809 });
810 checkWMTE(() -> { // expected reference class
811 boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeDouble.class, Class.class, double.class)).
812 invokeExact(recv, Void.class, 1.0d);
813 });
814 checkWMTE(() -> { // actual reference class
815 boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeDouble.class, double.class, Class.class)).
816 invokeExact(recv, 1.0d, Void.class);
817 });
818 checkWMTE(() -> { // receiver primitive class
819 boolean r = (boolean) hs.get(am, methodType(boolean.class, int.class , double.class, double.class)).
820 invokeExact(0, 1.0d, 1.0d);
821 });
822 // Incorrect arity
823 checkWMTE(() -> { // 0
824 boolean r = (boolean) hs.get(am, methodType(boolean.class)).
825 invokeExact();
826 });
827 checkWMTE(() -> { // >
828 boolean r = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeDouble.class, double.class, double.class, Class.class)).
829 invokeExact(recv, 1.0d, 1.0d, Void.class);
830 });
831 }
832
833 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) {
834 checkNPE(() -> { // null receiver
835 double x = (double) hs.get(am, methodType(double.class, VarHandleTestMethodTypeDouble.class, double.class, double.class)).
836 invokeExact((VarHandleTestMethodTypeDouble) null, 1.0d, 1.0d);
837 });
838 hs.checkWMTEOrCCE(() -> { // receiver reference class
839 double x = (double) hs.get(am, methodType(double.class, Class.class, double.class, double.class)).
840 invokeExact(Void.class, 1.0d, 1.0d);
841 });
842 checkWMTE(() -> { // expected reference class
843 double x = (double) hs.get(am, methodType(double.class, VarHandleTestMethodTypeDouble.class, Class.class, double.class)).
844 invokeExact(recv, Void.class, 1.0d);
845 });
846 checkWMTE(() -> { // actual reference class
847 double x = (double) hs.get(am, methodType(double.class, VarHandleTestMethodTypeDouble.class, double.class, Class.class)).
848 invokeExact(recv, 1.0d, Void.class);
849 });
850 checkWMTE(() -> { // reciever primitive class
851 double x = (double) hs.get(am, methodType(double.class, int.class , double.class, double.class)).
852 invokeExact(0, 1.0d, 1.0d);
853 });
854 // Incorrect return type
855 checkWMTE(() -> { // reference class
856 Void r = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodTypeDouble.class , double.class, double.class)).
857 invokeExact(recv, 1.0d, 1.0d);
858 });
859 checkWMTE(() -> { // primitive class
860 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeDouble.class , double.class, double.class)).
861 invokeExact(recv, 1.0d, 1.0d);
862 });
863 // Incorrect arity
864 checkWMTE(() -> { // 0
865 double x = (double) hs.get(am, methodType(double.class)).
866 invokeExact();
867 });
868 checkWMTE(() -> { // >
869 double x = (double) hs.get(am, methodType(double.class, VarHandleTestMethodTypeDouble.class, double.class, double.class, Class.class)).
870 invokeExact(recv, 1.0d, 1.0d, Void.class);
871 });
872 }
873
874 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) {
875 checkNPE(() -> { // null receiver
876 double x = (double) hs.get(am, methodType(double.class, VarHandleTestMethodTypeDouble.class, double.class)).
877 invokeExact((VarHandleTestMethodTypeDouble) null, 1.0d);
878 });
879 hs.checkWMTEOrCCE(() -> { // receiver reference class
880 double x = (double) hs.get(am, methodType(double.class, Class.class, double.class)).
881 invokeExact(Void.class, 1.0d);
882 });
883 checkWMTE(() -> { // value reference class
884 double x = (double) hs.get(am, methodType(double.class, VarHandleTestMethodTypeDouble.class, Class.class)).
885 invokeExact(recv, Void.class);
886 });
887 checkWMTE(() -> { // reciever primitive class
888 double x = (double) hs.get(am, methodType(double.class, int.class, double.class)).
889 invokeExact(0, 1.0d);
890 });
891 // Incorrect return type
892 checkWMTE(() -> { // reference class
893 Void r = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodTypeDouble.class, double.class)).
894 invokeExact(recv, 1.0d);
895 });
896 checkWMTE(() -> { // primitive class
897 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeDouble.class, double.class)).
898 invokeExact(recv, 1.0d);
899 });
900 // Incorrect arity
901 checkWMTE(() -> { // 0
902 double x = (double) hs.get(am, methodType(double.class)).
903 invokeExact();
904 });
905 checkWMTE(() -> { // >
906 double x = (double) hs.get(am, methodType(double.class, VarHandleTestMethodTypeDouble.class, double.class)).
907 invokeExact(recv, 1.0d, Void.class);
908 });
909 }
910
911 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
912 checkNPE(() -> { // null receiver
913 double x = (double) hs.get(am, methodType(double.class, VarHandleTestMethodTypeDouble.class, double.class)).
914 invokeExact((VarHandleTestMethodTypeDouble) null, 1.0d);
915 });
916 hs.checkWMTEOrCCE(() -> { // receiver reference class
917 double x = (double) hs.get(am, methodType(double.class, Class.class, double.class)).
918 invokeExact(Void.class, 1.0d);
919 });
920 checkWMTE(() -> { // value reference class
921 double x = (double) hs.get(am, methodType(double.class, VarHandleTestMethodTypeDouble.class, Class.class)).
922 invokeExact(recv, Void.class);
923 });
924 checkWMTE(() -> { // reciever primitive class
925 double x = (double) hs.get(am, methodType(double.class, int.class, double.class)).
926 invokeExact(0, 1.0d);
927 });
928 // Incorrect return type
929 checkWMTE(() -> { // reference class
930 Void r = (Void) hs.get(am, methodType(Void.class, VarHandleTestMethodTypeDouble.class, double.class)).
931 invokeExact(recv, 1.0d);
932 });
933 checkWMTE(() -> { // primitive class
934 boolean x = (boolean) hs.get(am, methodType(boolean.class, VarHandleTestMethodTypeDouble.class, double.class)).
935 invokeExact(recv, 1.0d);
936 });
937 // Incorrect arity
938 checkWMTE(() -> { // 0
939 double x = (double) hs.get(am, methodType(double.class)).
940 invokeExact();
941 });
942 checkWMTE(() -> { // >
943 double x = (double) hs.get(am, methodType(double.class, VarHandleTestMethodTypeDouble.class, double.class)).
944 invokeExact(recv, 1.0d, Void.class);
945 });
946 }
947
948 }
949
950
951 static void testStaticFieldWrongMethodType(VarHandle vh) throws Throwable {
952 // Get
953 // Incorrect return type
954 checkWMTE(() -> { // reference class
955 Void x = (Void) vh.get();
956 });
957 checkWMTE(() -> { // primitive class
958 boolean x = (boolean) vh.get();
959 });
960 // Incorrect arity
961 checkWMTE(() -> { // >
962 double x = (double) vh.get(Void.class);
963 });
964
965
966 // Set
967 // Incorrect argument types
968 checkWMTE(() -> { // value reference class
969 vh.set(Void.class);
970 });
971 // Incorrect arity
972 checkWMTE(() -> { // 0
973 vh.set();
974 });
975 checkWMTE(() -> { // >
976 vh.set(1.0d, Void.class);
977 });
978
979
980 // GetVolatile
981 // Incorrect return type
982 checkWMTE(() -> { // reference class
983 Void x = (Void) vh.getVolatile();
984 });
985 checkWMTE(() -> { // primitive class
986 boolean x = (boolean) vh.getVolatile();
987 });
988 checkWMTE(() -> { // >
989 double x = (double) vh.getVolatile(Void.class);
990 });
991
992
993 // SetVolatile
994 // Incorrect argument types
995 checkWMTE(() -> { // value reference class
996 vh.setVolatile(Void.class);
997 });
998 // Incorrect arity
999 checkWMTE(() -> { // 0
1000 vh.setVolatile();
1001 });
1002 checkWMTE(() -> { // >
1003 vh.setVolatile(1.0d, Void.class);
1004 });
1005
1006
1007 // GetOpaque
1008 // Incorrect return type
1009 checkWMTE(() -> { // reference class
1010 Void x = (Void) vh.getOpaque();
1011 });
1012 checkWMTE(() -> { // primitive class
1013 boolean x = (boolean) vh.getOpaque();
1014 });
1015 checkWMTE(() -> { // >
1016 double x = (double) vh.getOpaque(Void.class);
1017 });
1018
1019
1020 // SetOpaque
1021 // Incorrect argument types
1022 checkWMTE(() -> { // value reference class
1023 vh.setOpaque(Void.class);
1024 });
1025 // Incorrect arity
1026 checkWMTE(() -> { // 0
1027 vh.setOpaque();
1028 });
1029 checkWMTE(() -> { // >
1030 vh.setOpaque(1.0d, Void.class);
1031 });
1032
1033
1034 // GetAcquire
1035 // Incorrect return type
1036 checkWMTE(() -> { // reference class
1037 Void x = (Void) vh.getAcquire();
1038 });
1039 checkWMTE(() -> { // primitive class
1040 boolean x = (boolean) vh.getAcquire();
1041 });
1042 checkWMTE(() -> { // >
1043 double x = (double) vh.getAcquire(Void.class);
1044 });
1045
1046
1047 // SetRelease
1048 // Incorrect argument types
1049 checkWMTE(() -> { // value reference class
1050 vh.setRelease(Void.class);
1051 });
1052 // Incorrect arity
1053 checkWMTE(() -> { // 0
1054 vh.setRelease();
1055 });
1056 checkWMTE(() -> { // >
1057 vh.setRelease(1.0d, Void.class);
1058 });
1059
1060
1061 // CompareAndSet
1062 // Incorrect argument types
1063 checkWMTE(() -> { // expected reference class
1064 boolean r = vh.compareAndSet(Void.class, 1.0d);
1065 });
1066 checkWMTE(() -> { // actual reference class
1067 boolean r = vh.compareAndSet(1.0d, Void.class);
1068 });
1069 // Incorrect arity
1070 checkWMTE(() -> { // 0
1071 boolean r = vh.compareAndSet();
1072 });
1073 checkWMTE(() -> { // >
1074 boolean r = vh.compareAndSet(1.0d, 1.0d, Void.class);
1075 });
1076
1077
1078 // WeakCompareAndSet
1079 // Incorrect argument types
1080 checkWMTE(() -> { // expected reference class
1081 boolean r = vh.weakCompareAndSetPlain(Void.class, 1.0d);
1082 });
1083 checkWMTE(() -> { // actual reference class
1084 boolean r = vh.weakCompareAndSetPlain(1.0d, Void.class);
1085 });
1086 // Incorrect arity
1087 checkWMTE(() -> { // 0
1088 boolean r = vh.weakCompareAndSetPlain();
1089 });
1090 checkWMTE(() -> { // >
1091 boolean r = vh.weakCompareAndSetPlain(1.0d, 1.0d, Void.class);
1092 });
1093
1094
1095 // WeakCompareAndSetVolatile
1096 // Incorrect argument types
1097 checkWMTE(() -> { // expected reference class
1098 boolean r = vh.weakCompareAndSet(Void.class, 1.0d);
1099 });
1100 checkWMTE(() -> { // actual reference class
1101 boolean r = vh.weakCompareAndSet(1.0d, Void.class);
1102 });
1103 // Incorrect arity
1104 checkWMTE(() -> { // 0
1105 boolean r = vh.weakCompareAndSet();
1106 });
1107 checkWMTE(() -> { // >
1108 boolean r = vh.weakCompareAndSet(1.0d, 1.0d, Void.class);
1109 });
1110
1111
1112 // WeakCompareAndSetAcquire
1113 // Incorrect argument types
1114 checkWMTE(() -> { // expected reference class
1115 boolean r = vh.weakCompareAndSetAcquire(Void.class, 1.0d);
1116 });
1117 checkWMTE(() -> { // actual reference class
1118 boolean r = vh.weakCompareAndSetAcquire(1.0d, Void.class);
1119 });
1120 // Incorrect arity
1121 checkWMTE(() -> { // 0
1122 boolean r = vh.weakCompareAndSetAcquire();
1123 });
1124 checkWMTE(() -> { // >
1125 boolean r = vh.weakCompareAndSetAcquire(1.0d, 1.0d, Void.class);
1126 });
1127
1128
1129 // WeakCompareAndSetRelease
1130 // Incorrect argument types
1131 checkWMTE(() -> { // expected reference class
1132 boolean r = vh.weakCompareAndSetRelease(Void.class, 1.0d);
1133 });
1134 checkWMTE(() -> { // actual reference class
1135 boolean r = vh.weakCompareAndSetRelease(1.0d, Void.class);
1136 });
1137 // Incorrect arity
1138 checkWMTE(() -> { // 0
1139 boolean r = vh.weakCompareAndSetRelease();
1140 });
1141 checkWMTE(() -> { // >
1142 boolean r = vh.weakCompareAndSetRelease(1.0d, 1.0d, Void.class);
1143 });
1144
1145
1146 // CompareAndExchange
1147 // Incorrect argument types
1148 checkWMTE(() -> { // expected reference class
1149 double x = (double) vh.compareAndExchange(Void.class, 1.0d);
1150 });
1151 checkWMTE(() -> { // actual reference class
1152 double x = (double) vh.compareAndExchange(1.0d, Void.class);
1153 });
1154 // Incorrect return type
1155 checkWMTE(() -> { // reference class
1156 Void r = (Void) vh.compareAndExchange(1.0d, 1.0d);
1157 });
1158 checkWMTE(() -> { // primitive class
1159 boolean x = (boolean) vh.compareAndExchange(1.0d, 1.0d);
1160 });
1161 // Incorrect arity
1162 checkWMTE(() -> { // 0
1163 double x = (double) vh.compareAndExchange();
1164 });
1165 checkWMTE(() -> { // >
1166 double x = (double) vh.compareAndExchange(1.0d, 1.0d, Void.class);
1167 });
1168
1169
1170 // CompareAndExchangeAcquire
1171 // Incorrect argument types
1172 checkWMTE(() -> { // expected reference class
1173 double x = (double) vh.compareAndExchangeAcquire(Void.class, 1.0d);
1174 });
1175 checkWMTE(() -> { // actual reference class
1176 double x = (double) vh.compareAndExchangeAcquire(1.0d, Void.class);
1177 });
1178 // Incorrect return type
1179 checkWMTE(() -> { // reference class
1180 Void r = (Void) vh.compareAndExchangeAcquire(1.0d, 1.0d);
1181 });
1182 checkWMTE(() -> { // primitive class
1183 boolean x = (boolean) vh.compareAndExchangeAcquire(1.0d, 1.0d);
1184 });
1185 // Incorrect arity
1186 checkWMTE(() -> { // 0
1187 double x = (double) vh.compareAndExchangeAcquire();
1188 });
1189 checkWMTE(() -> { // >
1190 double x = (double) vh.compareAndExchangeAcquire(1.0d, 1.0d, Void.class);
1191 });
1192
1193
1194 // CompareAndExchangeRelease
1195 // Incorrect argument types
1196 checkWMTE(() -> { // expected reference class
1197 double x = (double) vh.compareAndExchangeRelease(Void.class, 1.0d);
1198 });
1199 checkWMTE(() -> { // actual reference class
1200 double x = (double) vh.compareAndExchangeRelease(1.0d, Void.class);
1201 });
1202 // Incorrect return type
1203 checkWMTE(() -> { // reference class
1204 Void r = (Void) vh.compareAndExchangeRelease(1.0d, 1.0d);
1205 });
1206 checkWMTE(() -> { // primitive class
1207 boolean x = (boolean) vh.compareAndExchangeRelease(1.0d, 1.0d);
1208 });
1209 // Incorrect arity
1210 checkWMTE(() -> { // 0
1211 double x = (double) vh.compareAndExchangeRelease();
1212 });
1213 checkWMTE(() -> { // >
1214 double x = (double) vh.compareAndExchangeRelease(1.0d, 1.0d, Void.class);
1215 });
1216
1217
1218 // GetAndSet
1219 // Incorrect argument types
1220 checkWMTE(() -> { // value reference class
1221 double x = (double) vh.getAndSet(Void.class);
1222 });
1223 // Incorrect return type
1224 checkWMTE(() -> { // reference class
1225 Void r = (Void) vh.getAndSet(1.0d);
1226 });
1227 checkWMTE(() -> { // primitive class
1228 boolean x = (boolean) vh.getAndSet(1.0d);
1229 });
1230 // Incorrect arity
1231 checkWMTE(() -> { // 0
1232 double x = (double) vh.getAndSet();
1233 });
1234 checkWMTE(() -> { // >
1235 double x = (double) vh.getAndSet(1.0d, Void.class);
1236 });
1237
1238
1239 // GetAndSetAcquire
1240 // Incorrect argument types
1241 checkWMTE(() -> { // value reference class
1242 double x = (double) vh.getAndSetAcquire(Void.class);
1243 });
1244 // Incorrect return type
1245 checkWMTE(() -> { // reference class
1246 Void r = (Void) vh.getAndSetAcquire(1.0d);
1247 });
1248 checkWMTE(() -> { // primitive class
1249 boolean x = (boolean) vh.getAndSetAcquire(1.0d);
1250 });
1251 // Incorrect arity
1252 checkWMTE(() -> { // 0
1253 double x = (double) vh.getAndSetAcquire();
1254 });
1255 checkWMTE(() -> { // >
1256 double x = (double) vh.getAndSetAcquire(1.0d, Void.class);
1257 });
1258
1259
1260 // GetAndSetRelease
1261 // Incorrect argument types
1262 checkWMTE(() -> { // value reference class
1263 double x = (double) vh.getAndSetRelease(Void.class);
1264 });
1265 // Incorrect return type
1266 checkWMTE(() -> { // reference class
1267 Void r = (Void) vh.getAndSetRelease(1.0d);
1268 });
1269 checkWMTE(() -> { // primitive class
1270 boolean x = (boolean) vh.getAndSetRelease(1.0d);
1271 });
1272 // Incorrect arity
1273 checkWMTE(() -> { // 0
1274 double x = (double) vh.getAndSetRelease();
1275 });
1276 checkWMTE(() -> { // >
1277 double x = (double) vh.getAndSetRelease(1.0d, Void.class);
1278 });
1279
1280 // GetAndAdd
1281 // Incorrect argument types
1282 checkWMTE(() -> { // value reference class
1283 double x = (double) vh.getAndAdd(Void.class);
1284 });
1285 // Incorrect return type
1286 checkWMTE(() -> { // reference class
1287 Void r = (Void) vh.getAndAdd(1.0d);
1288 });
1289 checkWMTE(() -> { // primitive class
1290 boolean x = (boolean) vh.getAndAdd(1.0d);
1291 });
1292 // Incorrect arity
1293 checkWMTE(() -> { // 0
1294 double x = (double) vh.getAndAdd();
1295 });
1296 checkWMTE(() -> { // >
1297 double x = (double) vh.getAndAdd(1.0d, Void.class);
1298 });
1299
1300
1301 // GetAndAddAcquire
1302 // Incorrect argument types
1303 checkWMTE(() -> { // value reference class
1304 double x = (double) vh.getAndAddAcquire(Void.class);
1305 });
1306 // Incorrect return type
1307 checkWMTE(() -> { // reference class
1308 Void r = (Void) vh.getAndAddAcquire(1.0d);
1309 });
1310 checkWMTE(() -> { // primitive class
1311 boolean x = (boolean) vh.getAndAddAcquire(1.0d);
1312 });
1313 // Incorrect arity
1314 checkWMTE(() -> { // 0
1315 double x = (double) vh.getAndAddAcquire();
1316 });
1317 checkWMTE(() -> { // >
1318 double x = (double) vh.getAndAddAcquire(1.0d, Void.class);
1319 });
1320
1321
1322 // GetAndAddRelease
1323 // Incorrect argument types
1324 checkWMTE(() -> { // value reference class
1325 double x = (double) vh.getAndAddRelease(Void.class);
1326 });
1327 // Incorrect return type
1328 checkWMTE(() -> { // reference class
1329 Void r = (Void) vh.getAndAddRelease(1.0d);
1330 });
1331 checkWMTE(() -> { // primitive class
1332 boolean x = (boolean) vh.getAndAddRelease(1.0d);
1333 });
1334 // Incorrect arity
1335 checkWMTE(() -> { // 0
1336 double x = (double) vh.getAndAddRelease();
1337 });
1338 checkWMTE(() -> { // >
1339 double x = (double) vh.getAndAddRelease(1.0d, Void.class);
1340 });
1341
1342 }
1343
1344 static void testStaticFieldWrongMethodType(Handles hs) throws Throwable {
1345 int i = 0;
1346
1347 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) {
1348 // Incorrect return type
1349 checkWMTE(() -> { // reference class
1350 Void x = (Void) hs.get(am, methodType(Void.class)).
1351 invokeExact();
1352 });
1353 checkWMTE(() -> { // primitive class
1354 boolean x = (boolean) hs.get(am, methodType(boolean.class)).
1355 invokeExact();
1356 });
1357 // Incorrect arity
1358 checkWMTE(() -> { // >
1359 double x = (double) hs.get(am, methodType(Class.class)).
1360 invokeExact(Void.class);
1361 });
1362 }
1363
1364 for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) {
1365 checkWMTE(() -> { // value reference class
1366 hs.get(am, methodType(void.class, Class.class)).
1367 invokeExact(Void.class);
1368 });
1369 // Incorrect arity
1370 checkWMTE(() -> { // 0
1371 hs.get(am, methodType(void.class)).
1372 invokeExact();
1373 });
1374 checkWMTE(() -> { // >
1375 hs.get(am, methodType(void.class, double.class, Class.class)).
1376 invokeExact(1.0d, Void.class);
1377 });
1378 }
1379 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) {
1380 // Incorrect argument types
1381 checkWMTE(() -> { // expected reference class
1382 boolean r = (boolean) hs.get(am, methodType(boolean.class, Class.class, double.class)).
1383 invokeExact(Void.class, 1.0d);
1384 });
1385 checkWMTE(() -> { // actual reference class
1386 boolean r = (boolean) hs.get(am, methodType(boolean.class, double.class, Class.class)).
1387 invokeExact(1.0d, Void.class);
1388 });
1389 // Incorrect arity
1390 checkWMTE(() -> { // 0
1391 boolean r = (boolean) hs.get(am, methodType(boolean.class)).
1392 invokeExact();
1393 });
1394 checkWMTE(() -> { // >
1395 boolean r = (boolean) hs.get(am, methodType(boolean.class, double.class, double.class, Class.class)).
1396 invokeExact(1.0d, 1.0d, Void.class);
1397 });
1398 }
1399
1400 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) {
1401 // Incorrect argument types
1402 checkWMTE(() -> { // expected reference class
1403 double x = (double) hs.get(am, methodType(double.class, Class.class, double.class)).
1404 invokeExact(Void.class, 1.0d);
1405 });
1406 checkWMTE(() -> { // actual reference class
1407 double x = (double) hs.get(am, methodType(double.class, double.class, Class.class)).
1408 invokeExact(1.0d, Void.class);
1409 });
1410 // Incorrect return type
1411 checkWMTE(() -> { // reference class
1412 Void r = (Void) hs.get(am, methodType(Void.class, double.class, double.class)).
1413 invokeExact(1.0d, 1.0d);
1414 });
1415 checkWMTE(() -> { // primitive class
1416 boolean x = (boolean) hs.get(am, methodType(boolean.class, double.class, double.class)).
1417 invokeExact(1.0d, 1.0d);
1418 });
1419 // Incorrect arity
1420 checkWMTE(() -> { // 0
1421 double x = (double) hs.get(am, methodType(double.class)).
1422 invokeExact();
1423 });
1424 checkWMTE(() -> { // >
1425 double x = (double) hs.get(am, methodType(double.class, double.class, double.class, Class.class)).
1426 invokeExact(1.0d, 1.0d, Void.class);
1427 });
1428 }
1429
1430 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) {
1431 // Incorrect argument types
1432 checkWMTE(() -> { // value reference class
1433 double x = (double) hs.get(am, methodType(double.class, Class.class)).
1434 invokeExact(Void.class);
1435 });
1436 // Incorrect return type
1437 checkWMTE(() -> { // reference class
1438 Void r = (Void) hs.get(am, methodType(Void.class, double.class)).
1439 invokeExact(1.0d);
1440 });
1441 checkWMTE(() -> { // primitive class
1442 boolean x = (boolean) hs.get(am, methodType(boolean.class, double.class)).
1443 invokeExact(1.0d);
1444 });
1445 // Incorrect arity
1446 checkWMTE(() -> { // 0
1447 double x = (double) hs.get(am, methodType(double.class)).
1448 invokeExact();
1449 });
1450 checkWMTE(() -> { // >
1451 double x = (double) hs.get(am, methodType(double.class, double.class, Class.class)).
1452 invokeExact(1.0d, Void.class);
1453 });
1454 }
1455
1456 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
1457 // Incorrect argument types
1458 checkWMTE(() -> { // value reference class
1459 double x = (double) hs.get(am, methodType(double.class, Class.class)).
1460 invokeExact(Void.class);
1461 });
1462 // Incorrect return type
1463 checkWMTE(() -> { // reference class
1464 Void r = (Void) hs.get(am, methodType(Void.class, double.class)).
1465 invokeExact(1.0d);
1466 });
1467 checkWMTE(() -> { // primitive class
1468 boolean x = (boolean) hs.get(am, methodType(boolean.class, double.class)).
1469 invokeExact(1.0d);
1470 });
1471 // Incorrect arity
1472 checkWMTE(() -> { // 0
1473 double x = (double) hs.get(am, methodType(double.class)).
1474 invokeExact();
1475 });
1476 checkWMTE(() -> { // >
1477 double x = (double) hs.get(am, methodType(double.class, double.class, Class.class)).
1478 invokeExact(1.0d, Void.class);
1479 });
1480 }
1481
1482 }
1483
1484
1485 static void testArrayWrongMethodType(VarHandle vh) throws Throwable {
1486 double[] array = new double[10];
1487 Arrays.fill(array, 1.0d);
1488
1489 // Get
1490 // Incorrect argument types
1491 checkNPE(() -> { // null array
1492 double x = (double) vh.get(null, 0);
1493 });
1494 checkCCE(() -> { // array reference class
1495 double x = (double) vh.get(Void.class, 0);
1496 });
1497 checkWMTE(() -> { // array primitive class
1498 double x = (double) vh.get(0, 0);
1499 });
1500 checkWMTE(() -> { // index reference class
1501 double x = (double) vh.get(array, Void.class);
1502 });
1503 // Incorrect return type
1504 checkWMTE(() -> { // reference class
1505 Void x = (Void) vh.get(array, 0);
1506 });
1507 checkWMTE(() -> { // primitive class
1508 boolean x = (boolean) vh.get(array, 0);
1509 });
1510 // Incorrect arity
1511 checkWMTE(() -> { // 0
1512 double x = (double) vh.get();
1513 });
1514 checkWMTE(() -> { // >
1515 double x = (double) vh.get(array, 0, Void.class);
1516 });
1517
1518
1519 // Set
1520 // Incorrect argument types
1521 checkNPE(() -> { // null array
1522 vh.set(null, 0, 1.0d);
1523 });
1524 checkCCE(() -> { // array reference class
1525 vh.set(Void.class, 0, 1.0d);
1526 });
1527 checkWMTE(() -> { // value reference class
1528 vh.set(array, 0, Void.class);
1529 });
1530 checkWMTE(() -> { // receiver primitive class
1531 vh.set(0, 0, 1.0d);
1532 });
1533 checkWMTE(() -> { // index reference class
1534 vh.set(array, Void.class, 1.0d);
1535 });
1536 // Incorrect arity
1537 checkWMTE(() -> { // 0
1538 vh.set();
1539 });
1540 checkWMTE(() -> { // >
1541 vh.set(array, 0, 1.0d, Void.class);
1542 });
1543
1544
1545 // GetVolatile
1546 // Incorrect argument types
1547 checkNPE(() -> { // null array
1548 double x = (double) vh.getVolatile(null, 0);
1549 });
1550 checkCCE(() -> { // array reference class
1551 double x = (double) vh.getVolatile(Void.class, 0);
1552 });
1553 checkWMTE(() -> { // array primitive class
1554 double x = (double) vh.getVolatile(0, 0);
1555 });
1556 checkWMTE(() -> { // index reference class
1557 double x = (double) vh.getVolatile(array, Void.class);
1558 });
1559 // Incorrect return type
1560 checkWMTE(() -> { // reference class
1561 Void x = (Void) vh.getVolatile(array, 0);
1562 });
1563 checkWMTE(() -> { // primitive class
1564 boolean x = (boolean) vh.getVolatile(array, 0);
1565 });
1566 // Incorrect arity
1567 checkWMTE(() -> { // 0
1568 double x = (double) vh.getVolatile();
1569 });
1570 checkWMTE(() -> { // >
1571 double x = (double) vh.getVolatile(array, 0, Void.class);
1572 });
1573
1574
1575 // SetVolatile
1576 // Incorrect argument types
1577 checkNPE(() -> { // null array
1578 vh.setVolatile(null, 0, 1.0d);
1579 });
1580 checkCCE(() -> { // array reference class
1581 vh.setVolatile(Void.class, 0, 1.0d);
1582 });
1583 checkWMTE(() -> { // value reference class
1584 vh.setVolatile(array, 0, Void.class);
1585 });
1586 checkWMTE(() -> { // receiver primitive class
1587 vh.setVolatile(0, 0, 1.0d);
1588 });
1589 checkWMTE(() -> { // index reference class
1590 vh.setVolatile(array, Void.class, 1.0d);
1591 });
1592 // Incorrect arity
1593 checkWMTE(() -> { // 0
1594 vh.setVolatile();
1595 });
1596 checkWMTE(() -> { // >
1597 vh.setVolatile(array, 0, 1.0d, Void.class);
1598 });
1599
1600
1601 // GetOpaque
1602 // Incorrect argument types
1603 checkNPE(() -> { // null array
1604 double x = (double) vh.getOpaque(null, 0);
1605 });
1606 checkCCE(() -> { // array reference class
1607 double x = (double) vh.getOpaque(Void.class, 0);
1608 });
1609 checkWMTE(() -> { // array primitive class
1610 double x = (double) vh.getOpaque(0, 0);
1611 });
1612 checkWMTE(() -> { // index reference class
1613 double x = (double) vh.getOpaque(array, Void.class);
1614 });
1615 // Incorrect return type
1616 checkWMTE(() -> { // reference class
1617 Void x = (Void) vh.getOpaque(array, 0);
1618 });
1619 checkWMTE(() -> { // primitive class
1620 boolean x = (boolean) vh.getOpaque(array, 0);
1621 });
1622 // Incorrect arity
1623 checkWMTE(() -> { // 0
1624 double x = (double) vh.getOpaque();
1625 });
1626 checkWMTE(() -> { // >
1627 double x = (double) vh.getOpaque(array, 0, Void.class);
1628 });
1629
1630
1631 // SetOpaque
1632 // Incorrect argument types
1633 checkNPE(() -> { // null array
1634 vh.setOpaque(null, 0, 1.0d);
1635 });
1636 checkCCE(() -> { // array reference class
1637 vh.setOpaque(Void.class, 0, 1.0d);
1638 });
1639 checkWMTE(() -> { // value reference class
1640 vh.setOpaque(array, 0, Void.class);
1641 });
1642 checkWMTE(() -> { // receiver primitive class
1643 vh.setOpaque(0, 0, 1.0d);
1644 });
1645 checkWMTE(() -> { // index reference class
1646 vh.setOpaque(array, Void.class, 1.0d);
1647 });
1648 // Incorrect arity
1649 checkWMTE(() -> { // 0
1650 vh.setOpaque();
1651 });
1652 checkWMTE(() -> { // >
1653 vh.setOpaque(array, 0, 1.0d, Void.class);
1654 });
1655
1656
1657 // GetAcquire
1658 // Incorrect argument types
1659 checkNPE(() -> { // null array
1660 double x = (double) vh.getAcquire(null, 0);
1661 });
1662 checkCCE(() -> { // array reference class
1663 double x = (double) vh.getAcquire(Void.class, 0);
1664 });
1665 checkWMTE(() -> { // array primitive class
1666 double x = (double) vh.getAcquire(0, 0);
1667 });
1668 checkWMTE(() -> { // index reference class
1669 double x = (double) vh.getAcquire(array, Void.class);
1670 });
1671 // Incorrect return type
1672 checkWMTE(() -> { // reference class
1673 Void x = (Void) vh.getAcquire(array, 0);
1674 });
1675 checkWMTE(() -> { // primitive class
1676 boolean x = (boolean) vh.getAcquire(array, 0);
1677 });
1678 // Incorrect arity
1679 checkWMTE(() -> { // 0
1680 double x = (double) vh.getAcquire();
1681 });
1682 checkWMTE(() -> { // >
1683 double x = (double) vh.getAcquire(array, 0, Void.class);
1684 });
1685
1686
1687 // SetRelease
1688 // Incorrect argument types
1689 checkNPE(() -> { // null array
1690 vh.setRelease(null, 0, 1.0d);
1691 });
1692 checkCCE(() -> { // array reference class
1693 vh.setRelease(Void.class, 0, 1.0d);
1694 });
1695 checkWMTE(() -> { // value reference class
1696 vh.setRelease(array, 0, Void.class);
1697 });
1698 checkWMTE(() -> { // receiver primitive class
1699 vh.setRelease(0, 0, 1.0d);
1700 });
1701 checkWMTE(() -> { // index reference class
1702 vh.setRelease(array, Void.class, 1.0d);
1703 });
1704 // Incorrect arity
1705 checkWMTE(() -> { // 0
1706 vh.setRelease();
1707 });
1708 checkWMTE(() -> { // >
1709 vh.setRelease(array, 0, 1.0d, Void.class);
1710 });
1711
1712
1713 // CompareAndSet
1714 // Incorrect argument types
1715 checkNPE(() -> { // null receiver
1716 boolean r = vh.compareAndSet(null, 0, 1.0d, 1.0d);
1717 });
1718 checkCCE(() -> { // receiver reference class
1719 boolean r = vh.compareAndSet(Void.class, 0, 1.0d, 1.0d);
1720 });
1721 checkWMTE(() -> { // expected reference class
1722 boolean r = vh.compareAndSet(array, 0, Void.class, 1.0d);
1723 });
1724 checkWMTE(() -> { // actual reference class
1725 boolean r = vh.compareAndSet(array, 0, 1.0d, Void.class);
1726 });
1727 checkWMTE(() -> { // receiver primitive class
1728 boolean r = vh.compareAndSet(0, 0, 1.0d, 1.0d);
1729 });
1730 checkWMTE(() -> { // index reference class
1731 boolean r = vh.compareAndSet(array, Void.class, 1.0d, 1.0d);
1732 });
1733 // Incorrect arity
1734 checkWMTE(() -> { // 0
1735 boolean r = vh.compareAndSet();
1736 });
1737 checkWMTE(() -> { // >
1738 boolean r = vh.compareAndSet(array, 0, 1.0d, 1.0d, Void.class);
1739 });
1740
1741
1742 // WeakCompareAndSet
1743 // Incorrect argument types
1744 checkNPE(() -> { // null receiver
1745 boolean r = vh.weakCompareAndSetPlain(null, 0, 1.0d, 1.0d);
1746 });
1747 checkCCE(() -> { // receiver reference class
1748 boolean r = vh.weakCompareAndSetPlain(Void.class, 0, 1.0d, 1.0d);
1749 });
1750 checkWMTE(() -> { // expected reference class
1751 boolean r = vh.weakCompareAndSetPlain(array, 0, Void.class, 1.0d);
1752 });
1753 checkWMTE(() -> { // actual reference class
1754 boolean r = vh.weakCompareAndSetPlain(array, 0, 1.0d, Void.class);
1755 });
1756 checkWMTE(() -> { // receiver primitive class
1757 boolean r = vh.weakCompareAndSetPlain(0, 0, 1.0d, 1.0d);
1758 });
1759 checkWMTE(() -> { // index reference class
1760 boolean r = vh.weakCompareAndSetPlain(array, Void.class, 1.0d, 1.0d);
1761 });
1762 // Incorrect arity
1763 checkWMTE(() -> { // 0
1764 boolean r = vh.weakCompareAndSetPlain();
1765 });
1766 checkWMTE(() -> { // >
1767 boolean r = vh.weakCompareAndSetPlain(array, 0, 1.0d, 1.0d, Void.class);
1768 });
1769
1770
1771 // WeakCompareAndSetVolatile
1772 // Incorrect argument types
1773 checkNPE(() -> { // null receiver
1774 boolean r = vh.weakCompareAndSet(null, 0, 1.0d, 1.0d);
1775 });
1776 checkCCE(() -> { // receiver reference class
1777 boolean r = vh.weakCompareAndSet(Void.class, 0, 1.0d, 1.0d);
1778 });
1779 checkWMTE(() -> { // expected reference class
1780 boolean r = vh.weakCompareAndSet(array, 0, Void.class, 1.0d);
1781 });
1782 checkWMTE(() -> { // actual reference class
1783 boolean r = vh.weakCompareAndSet(array, 0, 1.0d, Void.class);
1784 });
1785 checkWMTE(() -> { // receiver primitive class
1786 boolean r = vh.weakCompareAndSet(0, 0, 1.0d, 1.0d);
1787 });
1788 checkWMTE(() -> { // index reference class
1789 boolean r = vh.weakCompareAndSet(array, Void.class, 1.0d, 1.0d);
1790 });
1791 // Incorrect arity
1792 checkWMTE(() -> { // 0
1793 boolean r = vh.weakCompareAndSet();
1794 });
1795 checkWMTE(() -> { // >
1796 boolean r = vh.weakCompareAndSet(array, 0, 1.0d, 1.0d, Void.class);
1797 });
1798
1799
1800 // WeakCompareAndSetAcquire
1801 // Incorrect argument types
1802 checkNPE(() -> { // null receiver
1803 boolean r = vh.weakCompareAndSetAcquire(null, 0, 1.0d, 1.0d);
1804 });
1805 checkCCE(() -> { // receiver reference class
1806 boolean r = vh.weakCompareAndSetAcquire(Void.class, 0, 1.0d, 1.0d);
1807 });
1808 checkWMTE(() -> { // expected reference class
1809 boolean r = vh.weakCompareAndSetAcquire(array, 0, Void.class, 1.0d);
1810 });
1811 checkWMTE(() -> { // actual reference class
1812 boolean r = vh.weakCompareAndSetAcquire(array, 0, 1.0d, Void.class);
1813 });
1814 checkWMTE(() -> { // receiver primitive class
1815 boolean r = vh.weakCompareAndSetAcquire(0, 0, 1.0d, 1.0d);
1816 });
1817 checkWMTE(() -> { // index reference class
1818 boolean r = vh.weakCompareAndSetAcquire(array, Void.class, 1.0d, 1.0d);
1819 });
1820 // Incorrect arity
1821 checkWMTE(() -> { // 0
1822 boolean r = vh.weakCompareAndSetAcquire();
1823 });
1824 checkWMTE(() -> { // >
1825 boolean r = vh.weakCompareAndSetAcquire(array, 0, 1.0d, 1.0d, Void.class);
1826 });
1827
1828
1829 // WeakCompareAndSetRelease
1830 // Incorrect argument types
1831 checkNPE(() -> { // null receiver
1832 boolean r = vh.weakCompareAndSetRelease(null, 0, 1.0d, 1.0d);
1833 });
1834 checkCCE(() -> { // receiver reference class
1835 boolean r = vh.weakCompareAndSetRelease(Void.class, 0, 1.0d, 1.0d);
1836 });
1837 checkWMTE(() -> { // expected reference class
1838 boolean r = vh.weakCompareAndSetRelease(array, 0, Void.class, 1.0d);
1839 });
1840 checkWMTE(() -> { // actual reference class
1841 boolean r = vh.weakCompareAndSetRelease(array, 0, 1.0d, Void.class);
1842 });
1843 checkWMTE(() -> { // receiver primitive class
1844 boolean r = vh.weakCompareAndSetRelease(0, 0, 1.0d, 1.0d);
1845 });
1846 checkWMTE(() -> { // index reference class
1847 boolean r = vh.weakCompareAndSetRelease(array, Void.class, 1.0d, 1.0d);
1848 });
1849 // Incorrect arity
1850 checkWMTE(() -> { // 0
1851 boolean r = vh.weakCompareAndSetRelease();
1852 });
1853 checkWMTE(() -> { // >
1854 boolean r = vh.weakCompareAndSetRelease(array, 0, 1.0d, 1.0d, Void.class);
1855 });
1856
1857
1858 // CompareAndExchange
1859 // Incorrect argument types
1860 checkNPE(() -> { // null receiver
1861 double x = (double) vh.compareAndExchange(null, 0, 1.0d, 1.0d);
1862 });
1863 checkCCE(() -> { // array reference class
1864 double x = (double) vh.compareAndExchange(Void.class, 0, 1.0d, 1.0d);
1865 });
1866 checkWMTE(() -> { // expected reference class
1867 double x = (double) vh.compareAndExchange(array, 0, Void.class, 1.0d);
1868 });
1869 checkWMTE(() -> { // actual reference class
1870 double x = (double) vh.compareAndExchange(array, 0, 1.0d, Void.class);
1871 });
1872 checkWMTE(() -> { // array primitive class
1873 double x = (double) vh.compareAndExchange(0, 0, 1.0d, 1.0d);
1874 });
1875 checkWMTE(() -> { // index reference class
1876 double x = (double) vh.compareAndExchange(array, Void.class, 1.0d, 1.0d);
1877 });
1878 // Incorrect return type
1879 checkWMTE(() -> { // reference class
1880 Void r = (Void) vh.compareAndExchange(array, 0, 1.0d, 1.0d);
1881 });
1882 checkWMTE(() -> { // primitive class
1883 boolean x = (boolean) vh.compareAndExchange(array, 0, 1.0d, 1.0d);
1884 });
1885 // Incorrect arity
1886 checkWMTE(() -> { // 0
1887 double x = (double) vh.compareAndExchange();
1888 });
1889 checkWMTE(() -> { // >
1890 double x = (double) vh.compareAndExchange(array, 0, 1.0d, 1.0d, Void.class);
1891 });
1892
1893
1894 // CompareAndExchangeAcquire
1895 // Incorrect argument types
1896 checkNPE(() -> { // null receiver
1897 double x = (double) vh.compareAndExchangeAcquire(null, 0, 1.0d, 1.0d);
1898 });
1899 checkCCE(() -> { // array reference class
1900 double x = (double) vh.compareAndExchangeAcquire(Void.class, 0, 1.0d, 1.0d);
1901 });
1902 checkWMTE(() -> { // expected reference class
1903 double x = (double) vh.compareAndExchangeAcquire(array, 0, Void.class, 1.0d);
1904 });
1905 checkWMTE(() -> { // actual reference class
1906 double x = (double) vh.compareAndExchangeAcquire(array, 0, 1.0d, Void.class);
1907 });
1908 checkWMTE(() -> { // array primitive class
1909 double x = (double) vh.compareAndExchangeAcquire(0, 0, 1.0d, 1.0d);
1910 });
1911 checkWMTE(() -> { // index reference class
1912 double x = (double) vh.compareAndExchangeAcquire(array, Void.class, 1.0d, 1.0d);
1913 });
1914 // Incorrect return type
1915 checkWMTE(() -> { // reference class
1916 Void r = (Void) vh.compareAndExchangeAcquire(array, 0, 1.0d, 1.0d);
1917 });
1918 checkWMTE(() -> { // primitive class
1919 boolean x = (boolean) vh.compareAndExchangeAcquire(array, 0, 1.0d, 1.0d);
1920 });
1921 // Incorrect arity
1922 checkWMTE(() -> { // 0
1923 double x = (double) vh.compareAndExchangeAcquire();
1924 });
1925 checkWMTE(() -> { // >
1926 double x = (double) vh.compareAndExchangeAcquire(array, 0, 1.0d, 1.0d, Void.class);
1927 });
1928
1929
1930 // CompareAndExchangeRelease
1931 // Incorrect argument types
1932 checkNPE(() -> { // null receiver
1933 double x = (double) vh.compareAndExchangeRelease(null, 0, 1.0d, 1.0d);
1934 });
1935 checkCCE(() -> { // array reference class
1936 double x = (double) vh.compareAndExchangeRelease(Void.class, 0, 1.0d, 1.0d);
1937 });
1938 checkWMTE(() -> { // expected reference class
1939 double x = (double) vh.compareAndExchangeRelease(array, 0, Void.class, 1.0d);
1940 });
1941 checkWMTE(() -> { // actual reference class
1942 double x = (double) vh.compareAndExchangeRelease(array, 0, 1.0d, Void.class);
1943 });
1944 checkWMTE(() -> { // array primitive class
1945 double x = (double) vh.compareAndExchangeRelease(0, 0, 1.0d, 1.0d);
1946 });
1947 checkWMTE(() -> { // index reference class
1948 double x = (double) vh.compareAndExchangeRelease(array, Void.class, 1.0d, 1.0d);
1949 });
1950 // Incorrect return type
1951 checkWMTE(() -> { // reference class
1952 Void r = (Void) vh.compareAndExchangeRelease(array, 0, 1.0d, 1.0d);
1953 });
1954 checkWMTE(() -> { // primitive class
1955 boolean x = (boolean) vh.compareAndExchangeRelease(array, 0, 1.0d, 1.0d);
1956 });
1957 // Incorrect arity
1958 checkWMTE(() -> { // 0
1959 double x = (double) vh.compareAndExchangeRelease();
1960 });
1961 checkWMTE(() -> { // >
1962 double x = (double) vh.compareAndExchangeRelease(array, 0, 1.0d, 1.0d, Void.class);
1963 });
1964
1965
1966 // GetAndSet
1967 // Incorrect argument types
1968 checkNPE(() -> { // null array
1969 double x = (double) vh.getAndSet(null, 0, 1.0d);
1970 });
1971 checkCCE(() -> { // array reference class
1972 double x = (double) vh.getAndSet(Void.class, 0, 1.0d);
1973 });
1974 checkWMTE(() -> { // value reference class
1975 double x = (double) vh.getAndSet(array, 0, Void.class);
1976 });
1977 checkWMTE(() -> { // reciarrayever primitive class
1978 double x = (double) vh.getAndSet(0, 0, 1.0d);
1979 });
1980 checkWMTE(() -> { // index reference class
1981 double x = (double) vh.getAndSet(array, Void.class, 1.0d);
1982 });
1983 // Incorrect return type
1984 checkWMTE(() -> { // reference class
1985 Void r = (Void) vh.getAndSet(array, 0, 1.0d);
1986 });
1987 checkWMTE(() -> { // primitive class
1988 boolean x = (boolean) vh.getAndSet(array, 0, 1.0d);
1989 });
1990 // Incorrect arity
1991 checkWMTE(() -> { // 0
1992 double x = (double) vh.getAndSet();
1993 });
1994 checkWMTE(() -> { // >
1995 double x = (double) vh.getAndSet(array, 0, 1.0d, Void.class);
1996 });
1997
1998
1999 // GetAndSetAcquire
2000 // Incorrect argument types
2001 checkNPE(() -> { // null array
2002 double x = (double) vh.getAndSetAcquire(null, 0, 1.0d);
2003 });
2004 checkCCE(() -> { // array reference class
2005 double x = (double) vh.getAndSetAcquire(Void.class, 0, 1.0d);
2006 });
2007 checkWMTE(() -> { // value reference class
2008 double x = (double) vh.getAndSetAcquire(array, 0, Void.class);
2009 });
2010 checkWMTE(() -> { // reciarrayever primitive class
2011 double x = (double) vh.getAndSetAcquire(0, 0, 1.0d);
2012 });
2013 checkWMTE(() -> { // index reference class
2014 double x = (double) vh.getAndSetAcquire(array, Void.class, 1.0d);
2015 });
2016 // Incorrect return type
2017 checkWMTE(() -> { // reference class
2018 Void r = (Void) vh.getAndSetAcquire(array, 0, 1.0d);
2019 });
2020 checkWMTE(() -> { // primitive class
2021 boolean x = (boolean) vh.getAndSetAcquire(array, 0, 1.0d);
2022 });
2023 // Incorrect arity
2024 checkWMTE(() -> { // 0
2025 double x = (double) vh.getAndSetAcquire();
2026 });
2027 checkWMTE(() -> { // >
2028 double x = (double) vh.getAndSetAcquire(array, 0, 1.0d, Void.class);
2029 });
2030
2031
2032 // GetAndSetRelease
2033 // Incorrect argument types
2034 checkNPE(() -> { // null array
2035 double x = (double) vh.getAndSetRelease(null, 0, 1.0d);
2036 });
2037 checkCCE(() -> { // array reference class
2038 double x = (double) vh.getAndSetRelease(Void.class, 0, 1.0d);
2039 });
2040 checkWMTE(() -> { // value reference class
2041 double x = (double) vh.getAndSetRelease(array, 0, Void.class);
2042 });
2043 checkWMTE(() -> { // reciarrayever primitive class
2044 double x = (double) vh.getAndSetRelease(0, 0, 1.0d);
2045 });
2046 checkWMTE(() -> { // index reference class
2047 double x = (double) vh.getAndSetRelease(array, Void.class, 1.0d);
2048 });
2049 // Incorrect return type
2050 checkWMTE(() -> { // reference class
2051 Void r = (Void) vh.getAndSetRelease(array, 0, 1.0d);
2052 });
2053 checkWMTE(() -> { // primitive class
2054 boolean x = (boolean) vh.getAndSetRelease(array, 0, 1.0d);
2055 });
2056 // Incorrect arity
2057 checkWMTE(() -> { // 0
2058 double x = (double) vh.getAndSetRelease();
2059 });
2060 checkWMTE(() -> { // >
2061 double x = (double) vh.getAndSetRelease(array, 0, 1.0d, Void.class);
2062 });
2063
2064 // GetAndAdd
2065 // Incorrect argument types
2066 checkNPE(() -> { // null array
2067 double x = (double) vh.getAndAdd(null, 0, 1.0d);
2068 });
2069 checkCCE(() -> { // array reference class
2070 double x = (double) vh.getAndAdd(Void.class, 0, 1.0d);
2071 });
2072 checkWMTE(() -> { // value reference class
2073 double x = (double) vh.getAndAdd(array, 0, Void.class);
2074 });
2075 checkWMTE(() -> { // array primitive class
2076 double x = (double) vh.getAndAdd(0, 0, 1.0d);
2077 });
2078 checkWMTE(() -> { // index reference class
2079 double x = (double) vh.getAndAdd(array, Void.class, 1.0d);
2080 });
2081 // Incorrect return type
2082 checkWMTE(() -> { // reference class
2083 Void r = (Void) vh.getAndAdd(array, 0, 1.0d);
2084 });
2085 checkWMTE(() -> { // primitive class
2086 boolean x = (boolean) vh.getAndAdd(array, 0, 1.0d);
2087 });
2088 // Incorrect arity
2089 checkWMTE(() -> { // 0
2090 double x = (double) vh.getAndAdd();
2091 });
2092 checkWMTE(() -> { // >
2093 double x = (double) vh.getAndAdd(array, 0, 1.0d, Void.class);
2094 });
2095
2096
2097 // GetAndAddAcquire
2098 // Incorrect argument types
2099 checkNPE(() -> { // null array
2100 double x = (double) vh.getAndAddAcquire(null, 0, 1.0d);
2101 });
2102 checkCCE(() -> { // array reference class
2103 double x = (double) vh.getAndAddAcquire(Void.class, 0, 1.0d);
2104 });
2105 checkWMTE(() -> { // value reference class
2106 double x = (double) vh.getAndAddAcquire(array, 0, Void.class);
2107 });
2108 checkWMTE(() -> { // array primitive class
2109 double x = (double) vh.getAndAddAcquire(0, 0, 1.0d);
2110 });
2111 checkWMTE(() -> { // index reference class
2112 double x = (double) vh.getAndAddAcquire(array, Void.class, 1.0d);
2113 });
2114 // Incorrect return type
2115 checkWMTE(() -> { // reference class
2116 Void r = (Void) vh.getAndAddAcquire(array, 0, 1.0d);
2117 });
2118 checkWMTE(() -> { // primitive class
2119 boolean x = (boolean) vh.getAndAddAcquire(array, 0, 1.0d);
2120 });
2121 // Incorrect arity
2122 checkWMTE(() -> { // 0
2123 double x = (double) vh.getAndAddAcquire();
2124 });
2125 checkWMTE(() -> { // >
2126 double x = (double) vh.getAndAddAcquire(array, 0, 1.0d, Void.class);
2127 });
2128
2129
2130 // GetAndAddRelease
2131 // Incorrect argument types
2132 checkNPE(() -> { // null array
2133 double x = (double) vh.getAndAddRelease(null, 0, 1.0d);
2134 });
2135 checkCCE(() -> { // array reference class
2136 double x = (double) vh.getAndAddRelease(Void.class, 0, 1.0d);
2137 });
2138 checkWMTE(() -> { // value reference class
2139 double x = (double) vh.getAndAddRelease(array, 0, Void.class);
2140 });
2141 checkWMTE(() -> { // array primitive class
2142 double x = (double) vh.getAndAddRelease(0, 0, 1.0d);
2143 });
2144 checkWMTE(() -> { // index reference class
2145 double x = (double) vh.getAndAddRelease(array, Void.class, 1.0d);
2146 });
2147 // Incorrect return type
2148 checkWMTE(() -> { // reference class
2149 Void r = (Void) vh.getAndAddRelease(array, 0, 1.0d);
2150 });
2151 checkWMTE(() -> { // primitive class
2152 boolean x = (boolean) vh.getAndAddRelease(array, 0, 1.0d);
2153 });
2154 // Incorrect arity
2155 checkWMTE(() -> { // 0
2156 double x = (double) vh.getAndAddRelease();
2157 });
2158 checkWMTE(() -> { // >
2159 double x = (double) vh.getAndAddRelease(array, 0, 1.0d, Void.class);
2160 });
2161
2162 }
2163
2164 static void testArrayWrongMethodType(Handles hs) throws Throwable {
2165 double[] array = new double[10];
2166 Arrays.fill(array, 1.0d);
2167
2168 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) {
2169 // Incorrect argument types
2170 checkNPE(() -> { // null array
2171 double x = (double) hs.get(am, methodType(double.class, double[].class, int.class)).
2172 invokeExact((double[]) null, 0);
2173 });
2174 hs.checkWMTEOrCCE(() -> { // array reference class
2175 double x = (double) hs.get(am, methodType(double.class, Class.class, int.class)).
2176 invokeExact(Void.class, 0);
2177 });
2178 checkWMTE(() -> { // array primitive class
2179 double x = (double) hs.get(am, methodType(double.class, int.class, int.class)).
2180 invokeExact(0, 0);
2181 });
2182 checkWMTE(() -> { // index reference class
2183 double x = (double) hs.get(am, methodType(double.class, double[].class, Class.class)).
2184 invokeExact(array, Void.class);
2185 });
2186 // Incorrect return type
2187 checkWMTE(() -> { // reference class
2188 Void x = (Void) hs.get(am, methodType(Void.class, double[].class, int.class)).
2189 invokeExact(array, 0);
2190 });
2191 checkWMTE(() -> { // primitive class
2192 boolean x = (boolean) hs.get(am, methodType(boolean.class, double[].class, int.class)).
2193 invokeExact(array, 0);
2194 });
2195 // Incorrect arity
2196 checkWMTE(() -> { // 0
2197 double x = (double) hs.get(am, methodType(double.class)).
2198 invokeExact();
2199 });
2200 checkWMTE(() -> { // >
2201 double x = (double) hs.get(am, methodType(double.class, double[].class, int.class, Class.class)).
2202 invokeExact(array, 0, Void.class);
2203 });
2204 }
2205
2206 for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) {
2207 // Incorrect argument types
2208 checkNPE(() -> { // null array
2209 hs.get(am, methodType(void.class, double[].class, int.class, double.class)).
2210 invokeExact((double[]) null, 0, 1.0d);
2211 });
2212 hs.checkWMTEOrCCE(() -> { // array reference class
2213 hs.get(am, methodType(void.class, Class.class, int.class, double.class)).
2214 invokeExact(Void.class, 0, 1.0d);
2215 });
2216 checkWMTE(() -> { // value reference class
2217 hs.get(am, methodType(void.class, double[].class, int.class, Class.class)).
2218 invokeExact(array, 0, Void.class);
2219 });
2220 checkWMTE(() -> { // receiver primitive class
2221 hs.get(am, methodType(void.class, int.class, int.class, double.class)).
2222 invokeExact(0, 0, 1.0d);
2223 });
2224 checkWMTE(() -> { // index reference class
2225 hs.get(am, methodType(void.class, double[].class, Class.class, double.class)).
2226 invokeExact(array, Void.class, 1.0d);
2227 });
2228 // Incorrect arity
2229 checkWMTE(() -> { // 0
2230 hs.get(am, methodType(void.class)).
2231 invokeExact();
2232 });
2233 checkWMTE(() -> { // >
2234 hs.get(am, methodType(void.class, double[].class, int.class, Class.class)).
2235 invokeExact(array, 0, 1.0d, Void.class);
2236 });
2237 }
2238 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) {
2239 // Incorrect argument types
2240 checkNPE(() -> { // null receiver
2241 boolean r = (boolean) hs.get(am, methodType(boolean.class, double[].class, int.class, double.class, double.class)).
2242 invokeExact((double[]) null, 0, 1.0d, 1.0d);
2243 });
2244 hs.checkWMTEOrCCE(() -> { // receiver reference class
2245 boolean r = (boolean) hs.get(am, methodType(boolean.class, Class.class, int.class, double.class, double.class)).
2246 invokeExact(Void.class, 0, 1.0d, 1.0d);
2247 });
2248 checkWMTE(() -> { // expected reference class
2249 boolean r = (boolean) hs.get(am, methodType(boolean.class, double[].class, int.class, Class.class, double.class)).
2250 invokeExact(array, 0, Void.class, 1.0d);
2251 });
2252 checkWMTE(() -> { // actual reference class
2253 boolean r = (boolean) hs.get(am, methodType(boolean.class, double[].class, int.class, double.class, Class.class)).
2254 invokeExact(array, 0, 1.0d, Void.class);
2255 });
2256 checkWMTE(() -> { // receiver primitive class
2257 boolean r = (boolean) hs.get(am, methodType(boolean.class, int.class, int.class, double.class, double.class)).
2258 invokeExact(0, 0, 1.0d, 1.0d);
2259 });
2260 checkWMTE(() -> { // index reference class
2261 boolean r = (boolean) hs.get(am, methodType(boolean.class, double[].class, Class.class, double.class, double.class)).
2262 invokeExact(array, Void.class, 1.0d, 1.0d);
2263 });
2264 // Incorrect arity
2265 checkWMTE(() -> { // 0
2266 boolean r = (boolean) hs.get(am, methodType(boolean.class)).
2267 invokeExact();
2268 });
2269 checkWMTE(() -> { // >
2270 boolean r = (boolean) hs.get(am, methodType(boolean.class, double[].class, int.class, double.class, double.class, Class.class)).
2271 invokeExact(array, 0, 1.0d, 1.0d, Void.class);
2272 });
2273 }
2274
2275 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) {
2276 // Incorrect argument types
2277 checkNPE(() -> { // null receiver
2278 double x = (double) hs.get(am, methodType(double.class, double[].class, int.class, double.class, double.class)).
2279 invokeExact((double[]) null, 0, 1.0d, 1.0d);
2280 });
2281 hs.checkWMTEOrCCE(() -> { // array reference class
2282 double x = (double) hs.get(am, methodType(double.class, Class.class, int.class, double.class, double.class)).
2283 invokeExact(Void.class, 0, 1.0d, 1.0d);
2284 });
2285 checkWMTE(() -> { // expected reference class
2286 double x = (double) hs.get(am, methodType(double.class, double[].class, int.class, Class.class, double.class)).
2287 invokeExact(array, 0, Void.class, 1.0d);
2288 });
2289 checkWMTE(() -> { // actual reference class
2290 double x = (double) hs.get(am, methodType(double.class, double[].class, int.class, double.class, Class.class)).
2291 invokeExact(array, 0, 1.0d, Void.class);
2292 });
2293 checkWMTE(() -> { // array primitive class
2294 double x = (double) hs.get(am, methodType(double.class, int.class, int.class, double.class, double.class)).
2295 invokeExact(0, 0, 1.0d, 1.0d);
2296 });
2297 checkWMTE(() -> { // index reference class
2298 double x = (double) hs.get(am, methodType(double.class, double[].class, Class.class, double.class, double.class)).
2299 invokeExact(array, Void.class, 1.0d, 1.0d);
2300 });
2301 // Incorrect return type
2302 checkWMTE(() -> { // reference class
2303 Void r = (Void) hs.get(am, methodType(Void.class, double[].class, int.class, double.class, double.class)).
2304 invokeExact(array, 0, 1.0d, 1.0d);
2305 });
2306 checkWMTE(() -> { // primitive class
2307 boolean x = (boolean) hs.get(am, methodType(boolean.class, double[].class, int.class, double.class, double.class)).
2308 invokeExact(array, 0, 1.0d, 1.0d);
2309 });
2310 // Incorrect arity
2311 checkWMTE(() -> { // 0
2312 double x = (double) hs.get(am, methodType(double.class)).
2313 invokeExact();
2314 });
2315 checkWMTE(() -> { // >
2316 double x = (double) hs.get(am, methodType(double.class, double[].class, int.class, double.class, double.class, Class.class)).
2317 invokeExact(array, 0, 1.0d, 1.0d, Void.class);
2318 });
2319 }
2320
2321 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) {
2322 // Incorrect argument types
2323 checkNPE(() -> { // null array
2324 double x = (double) hs.get(am, methodType(double.class, double[].class, int.class, double.class)).
2325 invokeExact((double[]) null, 0, 1.0d);
2326 });
2327 hs.checkWMTEOrCCE(() -> { // array reference class
2328 double x = (double) hs.get(am, methodType(double.class, Class.class, int.class, double.class)).
2329 invokeExact(Void.class, 0, 1.0d);
2330 });
2331 checkWMTE(() -> { // value reference class
2332 double x = (double) hs.get(am, methodType(double.class, double[].class, int.class, Class.class)).
2333 invokeExact(array, 0, Void.class);
2334 });
2335 checkWMTE(() -> { // array primitive class
2336 double x = (double) hs.get(am, methodType(double.class, int.class, int.class, double.class)).
2337 invokeExact(0, 0, 1.0d);
2338 });
2339 checkWMTE(() -> { // index reference class
2340 double x = (double) hs.get(am, methodType(double.class, double[].class, Class.class, double.class)).
2341 invokeExact(array, Void.class, 1.0d);
2342 });
2343 // Incorrect return type
2344 checkWMTE(() -> { // reference class
2345 Void r = (Void) hs.get(am, methodType(Void.class, double[].class, int.class, double.class)).
2346 invokeExact(array, 0, 1.0d);
2347 });
2348 checkWMTE(() -> { // primitive class
2349 boolean x = (boolean) hs.get(am, methodType(boolean.class, double[].class, int.class, double.class)).
2350 invokeExact(array, 0, 1.0d);
2351 });
2352 // Incorrect arity
2353 checkWMTE(() -> { // 0
2354 double x = (double) hs.get(am, methodType(double.class)).
2355 invokeExact();
2356 });
2357 checkWMTE(() -> { // >
2358 double x = (double) hs.get(am, methodType(double.class, double[].class, int.class, double.class, Class.class)).
2359 invokeExact(array, 0, 1.0d, Void.class);
2360 });
2361 }
2362
2363 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
2364 // Incorrect argument types
2365 checkNPE(() -> { // null array
2366 double x = (double) hs.get(am, methodType(double.class, double[].class, int.class, double.class)).
2367 invokeExact((double[]) null, 0, 1.0d);
2368 });
2369 hs.checkWMTEOrCCE(() -> { // array reference class
2370 double x = (double) hs.get(am, methodType(double.class, Class.class, int.class, double.class)).
2371 invokeExact(Void.class, 0, 1.0d);
2372 });
2373 checkWMTE(() -> { // value reference class
2374 double x = (double) hs.get(am, methodType(double.class, double[].class, int.class, Class.class)).
2375 invokeExact(array, 0, Void.class);
2376 });
2377 checkWMTE(() -> { // array primitive class
2378 double x = (double) hs.get(am, methodType(double.class, int.class, int.class, double.class)).
2379 invokeExact(0, 0, 1.0d);
2380 });
2381 checkWMTE(() -> { // index reference class
2382 double x = (double) hs.get(am, methodType(double.class, double[].class, Class.class, double.class)).
2383 invokeExact(array, Void.class, 1.0d);
2384 });
2385 // Incorrect return type
2386 checkWMTE(() -> { // reference class
2387 Void r = (Void) hs.get(am, methodType(Void.class, double[].class, int.class, double.class)).
2388 invokeExact(array, 0, 1.0d);
2389 });
2390 checkWMTE(() -> { // primitive class
2391 boolean x = (boolean) hs.get(am, methodType(boolean.class, double[].class, int.class, double.class)).
2392 invokeExact(array, 0, 1.0d);
2393 });
2394 // Incorrect arity
2395 checkWMTE(() -> { // 0
2396 double x = (double) hs.get(am, methodType(double.class)).
2397 invokeExact();
2398 });
2399 checkWMTE(() -> { // >
2400 double x = (double) hs.get(am, methodType(double.class, double[].class, int.class, double.class, Class.class)).
2401 invokeExact(array, 0, 1.0d, Void.class);
2402 });
2403 }
2404
2405 }
2406 }