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