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