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