1 /*
2 * Copyright (c) 2015, 2021, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 // -- This file was mechanically generated: Do not edit! -- //
25
26 /*
27 * @test
28 * @run testng/othervm -Diters=10 -Xint VarHandleTestAccessFloat
29 * @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 VarHandleTestAccessFloat
30 * @run testng/othervm -Diters=20000 VarHandleTestAccessFloat
31 * @run testng/othervm -Diters=20000 -XX:-TieredCompilation VarHandleTestAccessFloat
32 */
33
34 import org.testng.annotations.BeforeClass;
35 import org.testng.annotations.DataProvider;
36 import org.testng.annotations.Test;
37
38 import java.lang.invoke.MethodHandles;
39 import java.lang.invoke.VarHandle;
40 import java.util.ArrayList;
41 import java.util.Arrays;
42 import java.util.List;
43
44 import static org.testng.Assert.*;
45
46 public class VarHandleTestAccessFloat extends VarHandleBaseTest {
47 static final Class<?> type = float.class;
48
49 static final float static_final_v = 1.0f;
50
51 static float static_v;
52
53 final float final_v = 1.0f;
54
55 float v;
56
57 static final float static_final_v2 = 1.0f;
58
59 static float static_v2;
60
61 final float final_v2 = 1.0f;
62
63 float v2;
64
65 VarHandle vhFinalField;
66
67 VarHandle vhField;
68
69 VarHandle vhStaticField;
70
71 VarHandle vhStaticFinalField;
72
73 VarHandle vhArray;
74
75 VarHandle vhValueTypeField;
76
77 VarHandle[] allocate(boolean same) {
78 List<VarHandle> vhs = new ArrayList<>();
79
80 String postfix = same ? "" : "2";
81 VarHandle vh;
82 try {
83 vh = MethodHandles.lookup().findVarHandle(
84 VarHandleTestAccessFloat.class, "final_v" + postfix, type);
85 vhs.add(vh);
86
87 vh = MethodHandles.lookup().findVarHandle(
88 VarHandleTestAccessFloat.class, "v" + postfix, type);
89 vhs.add(vh);
90
91 vh = MethodHandles.lookup().findStaticVarHandle(
92 VarHandleTestAccessFloat.class, "static_final_v" + postfix, type);
93 vhs.add(vh);
94
95 vh = MethodHandles.lookup().findStaticVarHandle(
96 VarHandleTestAccessFloat.class, "static_v" + postfix, type);
97 vhs.add(vh);
98
99 if (same) {
100 vh = MethodHandles.arrayElementVarHandle(float[].class);
101 }
102 else {
103 vh = MethodHandles.arrayElementVarHandle(String[].class);
104 }
105 vhs.add(vh);
106 } catch (Exception e) {
107 throw new InternalError(e);
108 }
109 return vhs.toArray(new VarHandle[0]);
110 }
111
112 @BeforeClass
113 public void setup() throws Exception {
114 vhFinalField = MethodHandles.lookup().findVarHandle(
115 VarHandleTestAccessFloat.class, "final_v", type);
116
117 vhField = MethodHandles.lookup().findVarHandle(
118 VarHandleTestAccessFloat.class, "v", type);
119
120 vhStaticFinalField = MethodHandles.lookup().findStaticVarHandle(
121 VarHandleTestAccessFloat.class, "static_final_v", type);
122
123 vhStaticField = MethodHandles.lookup().findStaticVarHandle(
124 VarHandleTestAccessFloat.class, "static_v", type);
125
126 vhArray = MethodHandles.arrayElementVarHandle(float[].class);
127
128 vhValueTypeField = MethodHandles.lookup().findVarHandle(
129 Value.class, "float_v", type);
130 }
131
132
133 @DataProvider
134 public Object[][] varHandlesProvider() throws Exception {
135 List<VarHandle> vhs = new ArrayList<>();
136 vhs.add(vhField);
137 vhs.add(vhStaticField);
138 vhs.add(vhArray);
139
140 return vhs.stream().map(tc -> new Object[]{tc}).toArray(Object[][]::new);
141 }
142
143 @Test
144 public void testEquals() {
145 VarHandle[] vhs1 = allocate(true);
146 VarHandle[] vhs2 = allocate(true);
147
148 for (int i = 0; i < vhs1.length; i++) {
149 for (int j = 0; j < vhs1.length; j++) {
150 if (i != j) {
151 assertNotEquals(vhs1[i], vhs1[j]);
152 assertNotEquals(vhs1[i], vhs2[j]);
153 }
154 }
155 }
156
157 VarHandle[] vhs3 = allocate(false);
158 for (int i = 0; i < vhs1.length; i++) {
159 assertNotEquals(vhs1[i], vhs3[i]);
160 }
161 }
162
163 @Test(dataProvider = "varHandlesProvider")
164 public void testIsAccessModeSupported(VarHandle vh) {
165 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET));
166 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET));
167 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_VOLATILE));
168 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_VOLATILE));
169 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_ACQUIRE));
170 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_RELEASE));
171 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_OPAQUE));
172 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_OPAQUE));
173
174 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_SET));
175 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE));
176 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_ACQUIRE));
177 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_RELEASE));
178 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_PLAIN));
179 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
180 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
181 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
182 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
183 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_ACQUIRE));
184 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_RELEASE));
185
186 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
187 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_ACQUIRE));
188 assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_RELEASE));
189
190 assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR));
191 assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_ACQUIRE));
192 assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_RELEASE));
193 assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND));
194 assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_ACQUIRE));
195 assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_RELEASE));
196 assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR));
197 assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_ACQUIRE));
198 assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE));
199 }
200
201
202 @DataProvider
203 public Object[][] typesProvider() throws Exception {
204 List<Object[]> types = new ArrayList<>();
205 types.add(new Object[] {vhField, Arrays.asList(VarHandleTestAccessFloat.class)});
206 types.add(new Object[] {vhStaticField, Arrays.asList()});
207 types.add(new Object[] {vhArray, Arrays.asList(float[].class, int.class)});
208
209 return types.stream().toArray(Object[][]::new);
210 }
211
212 @Test(dataProvider = "typesProvider")
213 public void testTypes(VarHandle vh, List<Class<?>> pts) {
214 assertEquals(vh.varType(), type);
215
216 assertEquals(vh.coordinateTypes(), pts);
217
218 testTypes(vh);
219 }
220
221
222 @Test
223 public void testLookupInstanceToStatic() {
224 checkIAE("Lookup of static final field to instance final field", () -> {
225 MethodHandles.lookup().findStaticVarHandle(
226 VarHandleTestAccessFloat.class, "final_v", type);
227 });
228
229 checkIAE("Lookup of static field to instance field", () -> {
230 MethodHandles.lookup().findStaticVarHandle(
231 VarHandleTestAccessFloat.class, "v", type);
232 });
233 }
234
235 @Test
236 public void testLookupStaticToInstance() {
237 checkIAE("Lookup of instance final field to static final field", () -> {
238 MethodHandles.lookup().findVarHandle(
239 VarHandleTestAccessFloat.class, "static_final_v", type);
240 });
241
242 checkIAE("Lookup of instance field to static field", () -> {
243 vhStaticField = MethodHandles.lookup().findVarHandle(
244 VarHandleTestAccessFloat.class, "static_v", type);
245 });
246 }
247
248
249 @DataProvider
250 public Object[][] accessTestCaseProvider() throws Exception {
251 List<AccessTestCase<?>> cases = new ArrayList<>();
252
253 cases.add(new VarHandleAccessTestCase("Instance final field",
254 vhFinalField, vh -> testInstanceFinalField(this, vh)));
255 cases.add(new VarHandleAccessTestCase("Instance final field unsupported",
256 vhFinalField, vh -> testInstanceFinalFieldUnsupported(this, vh),
257 false));
258
259 cases.add(new VarHandleAccessTestCase("Static final field",
260 vhStaticFinalField, VarHandleTestAccessFloat::testStaticFinalField));
261 cases.add(new VarHandleAccessTestCase("Static final field unsupported",
262 vhStaticFinalField, VarHandleTestAccessFloat::testStaticFinalFieldUnsupported,
263 false));
264
265 cases.add(new VarHandleAccessTestCase("Instance field",
266 vhField, vh -> testInstanceField(this, vh)));
267 cases.add(new VarHandleAccessTestCase("Instance field unsupported",
268 vhField, vh -> testInstanceFieldUnsupported(this, vh),
269 false));
270
271 cases.add(new VarHandleAccessTestCase("Static field",
272 vhStaticField, VarHandleTestAccessFloat::testStaticField));
273 cases.add(new VarHandleAccessTestCase("Static field unsupported",
274 vhStaticField, VarHandleTestAccessFloat::testStaticFieldUnsupported,
275 false));
276
277 cases.add(new VarHandleAccessTestCase("Array",
278 vhArray, VarHandleTestAccessFloat::testArray));
279 cases.add(new VarHandleAccessTestCase("Array unsupported",
280 vhArray, VarHandleTestAccessFloat::testArrayUnsupported,
281 false));
282 cases.add(new VarHandleAccessTestCase("Array index out of bounds",
283 vhArray, VarHandleTestAccessFloat::testArrayIndexOutOfBounds,
284 false));
285 cases.add(new VarHandleAccessTestCase("Value type field",
286 vhValueTypeField, vh -> testValueTypeField(Value.getInstance(), vh)));
287 cases.add(new VarHandleAccessTestCase("Value type field unsupported",
288 vhValueTypeField, vh -> testValueTypeFieldUnsupported(Value.getInstance(), vh),
289 false));
290 // Work around issue with jtreg summary reporting which truncates
291 // the String result of Object.toString to 30 characters, hence
292 // the first dummy argument
293 return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new);
294 }
295
296 @Test(dataProvider = "accessTestCaseProvider")
297 public <T> void testAccess(String desc, AccessTestCase<T> atc) throws Throwable {
298 T t = atc.get();
299 int iters = atc.requiresLoop() ? ITERS : 1;
300 for (int c = 0; c < iters; c++) {
301 atc.testAccess(t);
302 }
303 }
304
305
306
307
308 static void testInstanceFinalField(VarHandleTestAccessFloat recv, VarHandle vh) {
309 // Plain
310 {
311 float x = (float) vh.get(recv);
312 assertEquals(x, 1.0f, "get float value");
313 }
314
315
316 // Volatile
317 {
318 float x = (float) vh.getVolatile(recv);
319 assertEquals(x, 1.0f, "getVolatile float value");
320 }
321
322 // Lazy
323 {
324 float x = (float) vh.getAcquire(recv);
325 assertEquals(x, 1.0f, "getRelease float value");
326 }
327
328 // Opaque
329 {
330 float x = (float) vh.getOpaque(recv);
331 assertEquals(x, 1.0f, "getOpaque float value");
332 }
333 }
334
335 static void testInstanceFinalFieldUnsupported(VarHandleTestAccessFloat recv, VarHandle vh) {
336 checkUOE(() -> {
337 vh.set(recv, 2.0f);
338 });
339
340 checkUOE(() -> {
341 vh.setVolatile(recv, 2.0f);
342 });
343
344 checkUOE(() -> {
345 vh.setRelease(recv, 2.0f);
346 });
347
348 checkUOE(() -> {
349 vh.setOpaque(recv, 2.0f);
350 });
351
352
353
354 checkUOE(() -> {
355 float o = (float) vh.getAndBitwiseOr(recv, 1.0f);
356 });
357
358 checkUOE(() -> {
359 float o = (float) vh.getAndBitwiseOrAcquire(recv, 1.0f);
360 });
361
362 checkUOE(() -> {
363 float o = (float) vh.getAndBitwiseOrRelease(recv, 1.0f);
364 });
365
366 checkUOE(() -> {
367 float o = (float) vh.getAndBitwiseAnd(recv, 1.0f);
368 });
369
370 checkUOE(() -> {
371 float o = (float) vh.getAndBitwiseAndAcquire(recv, 1.0f);
372 });
373
374 checkUOE(() -> {
375 float o = (float) vh.getAndBitwiseAndRelease(recv, 1.0f);
376 });
377
378 checkUOE(() -> {
379 float o = (float) vh.getAndBitwiseXor(recv, 1.0f);
380 });
381
382 checkUOE(() -> {
383 float o = (float) vh.getAndBitwiseXorAcquire(recv, 1.0f);
384 });
385
386 checkUOE(() -> {
387 float o = (float) vh.getAndBitwiseXorRelease(recv, 1.0f);
388 });
389 }
390
391 static void testValueTypeField(Value recv, VarHandle vh) {
392 // Plain
393 {
394 float x = (float) vh.get(recv);
395 assertEquals(x, 1.0f, "get float value");
396 }
397 }
398
399 static void testValueTypeFieldUnsupported(Value recv, VarHandle vh) {
400 checkUOE(() -> {
401 vh.set(recv, 2.0f);
402 });
403 }
404
405 static void testStaticFinalField(VarHandle vh) {
406 // Plain
407 {
408 float x = (float) vh.get();
409 assertEquals(x, 1.0f, "get float value");
410 }
411
412
413 // Volatile
414 {
415 float x = (float) vh.getVolatile();
416 assertEquals(x, 1.0f, "getVolatile float value");
417 }
418
419 // Lazy
420 {
421 float x = (float) vh.getAcquire();
422 assertEquals(x, 1.0f, "getRelease float value");
423 }
424
425 // Opaque
426 {
427 float x = (float) vh.getOpaque();
428 assertEquals(x, 1.0f, "getOpaque float value");
429 }
430 }
431
432 static void testStaticFinalFieldUnsupported(VarHandle vh) {
433 checkUOE(() -> {
434 vh.set(2.0f);
435 });
436
437 checkUOE(() -> {
438 vh.setVolatile(2.0f);
439 });
440
441 checkUOE(() -> {
442 vh.setRelease(2.0f);
443 });
444
445 checkUOE(() -> {
446 vh.setOpaque(2.0f);
447 });
448
449
450
451 checkUOE(() -> {
452 float o = (float) vh.getAndBitwiseOr(1.0f);
453 });
454
455 checkUOE(() -> {
456 float o = (float) vh.getAndBitwiseOrAcquire(1.0f);
457 });
458
459 checkUOE(() -> {
460 float o = (float) vh.getAndBitwiseOrRelease(1.0f);
461 });
462
463 checkUOE(() -> {
464 float o = (float) vh.getAndBitwiseAnd(1.0f);
465 });
466
467 checkUOE(() -> {
468 float o = (float) vh.getAndBitwiseAndAcquire(1.0f);
469 });
470
471 checkUOE(() -> {
472 float o = (float) vh.getAndBitwiseAndRelease(1.0f);
473 });
474
475 checkUOE(() -> {
476 float o = (float) vh.getAndBitwiseXor(1.0f);
477 });
478
479 checkUOE(() -> {
480 float o = (float) vh.getAndBitwiseXorAcquire(1.0f);
481 });
482
483 checkUOE(() -> {
484 float o = (float) vh.getAndBitwiseXorRelease(1.0f);
485 });
486 }
487
488
489 static void testInstanceField(VarHandleTestAccessFloat recv, VarHandle vh) {
490 // Plain
491 {
492 vh.set(recv, 1.0f);
493 float x = (float) vh.get(recv);
494 assertEquals(x, 1.0f, "set float value");
495 }
496
497
498 // Volatile
499 {
500 vh.setVolatile(recv, 2.0f);
501 float x = (float) vh.getVolatile(recv);
502 assertEquals(x, 2.0f, "setVolatile float value");
503 }
504
505 // Lazy
506 {
507 vh.setRelease(recv, 1.0f);
508 float x = (float) vh.getAcquire(recv);
509 assertEquals(x, 1.0f, "setRelease float value");
510 }
511
512 // Opaque
513 {
514 vh.setOpaque(recv, 2.0f);
515 float x = (float) vh.getOpaque(recv);
516 assertEquals(x, 2.0f, "setOpaque float value");
517 }
518
519 vh.set(recv, 1.0f);
520
521 // Compare
522 {
523 boolean r = vh.compareAndSet(recv, 1.0f, 2.0f);
524 assertEquals(r, true, "success compareAndSet float");
525 float x = (float) vh.get(recv);
526 assertEquals(x, 2.0f, "success compareAndSet float value");
527 }
528
529 {
530 boolean r = vh.compareAndSet(recv, 1.0f, 3.0f);
531 assertEquals(r, false, "failing compareAndSet float");
532 float x = (float) vh.get(recv);
533 assertEquals(x, 2.0f, "failing compareAndSet float value");
534 }
535
536 {
537 float r = (float) vh.compareAndExchange(recv, 2.0f, 1.0f);
538 assertEquals(r, 2.0f, "success compareAndExchange float");
539 float x = (float) vh.get(recv);
540 assertEquals(x, 1.0f, "success compareAndExchange float value");
541 }
542
543 {
544 float r = (float) vh.compareAndExchange(recv, 2.0f, 3.0f);
545 assertEquals(r, 1.0f, "failing compareAndExchange float");
546 float x = (float) vh.get(recv);
547 assertEquals(x, 1.0f, "failing compareAndExchange float value");
548 }
549
550 {
551 float r = (float) vh.compareAndExchangeAcquire(recv, 1.0f, 2.0f);
552 assertEquals(r, 1.0f, "success compareAndExchangeAcquire float");
553 float x = (float) vh.get(recv);
554 assertEquals(x, 2.0f, "success compareAndExchangeAcquire float value");
555 }
556
557 {
558 float r = (float) vh.compareAndExchangeAcquire(recv, 1.0f, 3.0f);
559 assertEquals(r, 2.0f, "failing compareAndExchangeAcquire float");
560 float x = (float) vh.get(recv);
561 assertEquals(x, 2.0f, "failing compareAndExchangeAcquire float value");
562 }
563
564 {
565 float r = (float) vh.compareAndExchangeRelease(recv, 2.0f, 1.0f);
566 assertEquals(r, 2.0f, "success compareAndExchangeRelease float");
567 float x = (float) vh.get(recv);
568 assertEquals(x, 1.0f, "success compareAndExchangeRelease float value");
569 }
570
571 {
572 float r = (float) vh.compareAndExchangeRelease(recv, 2.0f, 3.0f);
573 assertEquals(r, 1.0f, "failing compareAndExchangeRelease float");
574 float x = (float) vh.get(recv);
575 assertEquals(x, 1.0f, "failing compareAndExchangeRelease float value");
576 }
577
578 {
579 boolean success = false;
580 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
581 success = vh.weakCompareAndSetPlain(recv, 1.0f, 2.0f);
582 }
583 assertEquals(success, true, "weakCompareAndSetPlain float");
584 float x = (float) vh.get(recv);
585 assertEquals(x, 2.0f, "weakCompareAndSetPlain float value");
586 }
587
588 {
589 boolean success = false;
590 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
591 success = vh.weakCompareAndSetAcquire(recv, 2.0f, 1.0f);
592 }
593 assertEquals(success, true, "weakCompareAndSetAcquire float");
594 float x = (float) vh.get(recv);
595 assertEquals(x, 1.0f, "weakCompareAndSetAcquire float");
596 }
597
598 {
599 boolean success = false;
600 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
601 success = vh.weakCompareAndSetRelease(recv, 1.0f, 2.0f);
602 }
603 assertEquals(success, true, "weakCompareAndSetRelease float");
604 float x = (float) vh.get(recv);
605 assertEquals(x, 2.0f, "weakCompareAndSetRelease float");
606 }
607
608 {
609 boolean success = false;
610 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
611 success = vh.weakCompareAndSet(recv, 2.0f, 1.0f);
612 }
613 assertEquals(success, true, "weakCompareAndSet float");
614 float x = (float) vh.get(recv);
615 assertEquals(x, 1.0f, "weakCompareAndSet float value");
616 }
617
618 // Compare set and get
619 {
620 vh.set(recv, 1.0f);
621
622 float o = (float) vh.getAndSet(recv, 2.0f);
623 assertEquals(o, 1.0f, "getAndSet float");
624 float x = (float) vh.get(recv);
625 assertEquals(x, 2.0f, "getAndSet float value");
626 }
627
628 {
629 vh.set(recv, 1.0f);
630
631 float o = (float) vh.getAndSetAcquire(recv, 2.0f);
632 assertEquals(o, 1.0f, "getAndSetAcquire float");
633 float x = (float) vh.get(recv);
634 assertEquals(x, 2.0f, "getAndSetAcquire float value");
635 }
636
637 {
638 vh.set(recv, 1.0f);
639
640 float o = (float) vh.getAndSetRelease(recv, 2.0f);
641 assertEquals(o, 1.0f, "getAndSetRelease float");
642 float x = (float) vh.get(recv);
643 assertEquals(x, 2.0f, "getAndSetRelease float value");
644 }
645
646 // get and add, add and get
647 {
648 vh.set(recv, 1.0f);
649
650 float o = (float) vh.getAndAdd(recv, 2.0f);
651 assertEquals(o, 1.0f, "getAndAdd float");
652 float x = (float) vh.get(recv);
653 assertEquals(x, (float)(1.0f + 2.0f), "getAndAdd float value");
654 }
655
656 {
657 vh.set(recv, 1.0f);
658
659 float o = (float) vh.getAndAddAcquire(recv, 2.0f);
660 assertEquals(o, 1.0f, "getAndAddAcquire float");
661 float x = (float) vh.get(recv);
662 assertEquals(x, (float)(1.0f + 2.0f), "getAndAddAcquire float value");
663 }
664
665 {
666 vh.set(recv, 1.0f);
667
668 float o = (float) vh.getAndAddRelease(recv, 2.0f);
669 assertEquals(o, 1.0f, "getAndAddReleasefloat");
670 float x = (float) vh.get(recv);
671 assertEquals(x, (float)(1.0f + 2.0f), "getAndAddRelease float value");
672 }
673
674 }
675
676 static void testInstanceFieldUnsupported(VarHandleTestAccessFloat recv, VarHandle vh) {
677
678
679 checkUOE(() -> {
680 float o = (float) vh.getAndBitwiseOr(recv, 1.0f);
681 });
682
683 checkUOE(() -> {
684 float o = (float) vh.getAndBitwiseOrAcquire(recv, 1.0f);
685 });
686
687 checkUOE(() -> {
688 float o = (float) vh.getAndBitwiseOrRelease(recv, 1.0f);
689 });
690
691 checkUOE(() -> {
692 float o = (float) vh.getAndBitwiseAnd(recv, 1.0f);
693 });
694
695 checkUOE(() -> {
696 float o = (float) vh.getAndBitwiseAndAcquire(recv, 1.0f);
697 });
698
699 checkUOE(() -> {
700 float o = (float) vh.getAndBitwiseAndRelease(recv, 1.0f);
701 });
702
703 checkUOE(() -> {
704 float o = (float) vh.getAndBitwiseXor(recv, 1.0f);
705 });
706
707 checkUOE(() -> {
708 float o = (float) vh.getAndBitwiseXorAcquire(recv, 1.0f);
709 });
710
711 checkUOE(() -> {
712 float o = (float) vh.getAndBitwiseXorRelease(recv, 1.0f);
713 });
714 }
715
716
717 static void testStaticField(VarHandle vh) {
718 // Plain
719 {
720 vh.set(1.0f);
721 float x = (float) vh.get();
722 assertEquals(x, 1.0f, "set float value");
723 }
724
725
726 // Volatile
727 {
728 vh.setVolatile(2.0f);
729 float x = (float) vh.getVolatile();
730 assertEquals(x, 2.0f, "setVolatile float value");
731 }
732
733 // Lazy
734 {
735 vh.setRelease(1.0f);
736 float x = (float) vh.getAcquire();
737 assertEquals(x, 1.0f, "setRelease float value");
738 }
739
740 // Opaque
741 {
742 vh.setOpaque(2.0f);
743 float x = (float) vh.getOpaque();
744 assertEquals(x, 2.0f, "setOpaque float value");
745 }
746
747 vh.set(1.0f);
748
749 // Compare
750 {
751 boolean r = vh.compareAndSet(1.0f, 2.0f);
752 assertEquals(r, true, "success compareAndSet float");
753 float x = (float) vh.get();
754 assertEquals(x, 2.0f, "success compareAndSet float value");
755 }
756
757 {
758 boolean r = vh.compareAndSet(1.0f, 3.0f);
759 assertEquals(r, false, "failing compareAndSet float");
760 float x = (float) vh.get();
761 assertEquals(x, 2.0f, "failing compareAndSet float value");
762 }
763
764 {
765 float r = (float) vh.compareAndExchange(2.0f, 1.0f);
766 assertEquals(r, 2.0f, "success compareAndExchange float");
767 float x = (float) vh.get();
768 assertEquals(x, 1.0f, "success compareAndExchange float value");
769 }
770
771 {
772 float r = (float) vh.compareAndExchange(2.0f, 3.0f);
773 assertEquals(r, 1.0f, "failing compareAndExchange float");
774 float x = (float) vh.get();
775 assertEquals(x, 1.0f, "failing compareAndExchange float value");
776 }
777
778 {
779 float r = (float) vh.compareAndExchangeAcquire(1.0f, 2.0f);
780 assertEquals(r, 1.0f, "success compareAndExchangeAcquire float");
781 float x = (float) vh.get();
782 assertEquals(x, 2.0f, "success compareAndExchangeAcquire float value");
783 }
784
785 {
786 float r = (float) vh.compareAndExchangeAcquire(1.0f, 3.0f);
787 assertEquals(r, 2.0f, "failing compareAndExchangeAcquire float");
788 float x = (float) vh.get();
789 assertEquals(x, 2.0f, "failing compareAndExchangeAcquire float value");
790 }
791
792 {
793 float r = (float) vh.compareAndExchangeRelease(2.0f, 1.0f);
794 assertEquals(r, 2.0f, "success compareAndExchangeRelease float");
795 float x = (float) vh.get();
796 assertEquals(x, 1.0f, "success compareAndExchangeRelease float value");
797 }
798
799 {
800 float r = (float) vh.compareAndExchangeRelease(2.0f, 3.0f);
801 assertEquals(r, 1.0f, "failing compareAndExchangeRelease float");
802 float x = (float) vh.get();
803 assertEquals(x, 1.0f, "failing compareAndExchangeRelease float value");
804 }
805
806 {
807 boolean success = false;
808 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
809 success = vh.weakCompareAndSetPlain(1.0f, 2.0f);
810 }
811 assertEquals(success, true, "weakCompareAndSetPlain float");
812 float x = (float) vh.get();
813 assertEquals(x, 2.0f, "weakCompareAndSetPlain float value");
814 }
815
816 {
817 boolean success = false;
818 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
819 success = vh.weakCompareAndSetAcquire(2.0f, 1.0f);
820 }
821 assertEquals(success, true, "weakCompareAndSetAcquire float");
822 float x = (float) vh.get();
823 assertEquals(x, 1.0f, "weakCompareAndSetAcquire float");
824 }
825
826 {
827 boolean success = false;
828 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
829 success = vh.weakCompareAndSetRelease(1.0f, 2.0f);
830 }
831 assertEquals(success, true, "weakCompareAndSetRelease float");
832 float x = (float) vh.get();
833 assertEquals(x, 2.0f, "weakCompareAndSetRelease float");
834 }
835
836 {
837 boolean success = false;
838 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
839 success = vh.weakCompareAndSet(2.0f, 1.0f);
840 }
841 assertEquals(success, true, "weakCompareAndSet float");
842 float x = (float) vh.get();
843 assertEquals(x, 1.0f, "weakCompareAndSet float");
844 }
845
846 // Compare set and get
847 {
848 vh.set(1.0f);
849
850 float o = (float) vh.getAndSet(2.0f);
851 assertEquals(o, 1.0f, "getAndSet float");
852 float x = (float) vh.get();
853 assertEquals(x, 2.0f, "getAndSet float value");
854 }
855
856 {
857 vh.set(1.0f);
858
859 float o = (float) vh.getAndSetAcquire(2.0f);
860 assertEquals(o, 1.0f, "getAndSetAcquire float");
861 float x = (float) vh.get();
862 assertEquals(x, 2.0f, "getAndSetAcquire float value");
863 }
864
865 {
866 vh.set(1.0f);
867
868 float o = (float) vh.getAndSetRelease(2.0f);
869 assertEquals(o, 1.0f, "getAndSetRelease float");
870 float x = (float) vh.get();
871 assertEquals(x, 2.0f, "getAndSetRelease float value");
872 }
873
874 // get and add, add and get
875 {
876 vh.set(1.0f);
877
878 float o = (float) vh.getAndAdd(2.0f);
879 assertEquals(o, 1.0f, "getAndAdd float");
880 float x = (float) vh.get();
881 assertEquals(x, (float)(1.0f + 2.0f), "getAndAdd float value");
882 }
883
884 {
885 vh.set(1.0f);
886
887 float o = (float) vh.getAndAddAcquire(2.0f);
888 assertEquals(o, 1.0f, "getAndAddAcquire float");
889 float x = (float) vh.get();
890 assertEquals(x, (float)(1.0f + 2.0f), "getAndAddAcquire float value");
891 }
892
893 {
894 vh.set(1.0f);
895
896 float o = (float) vh.getAndAddRelease(2.0f);
897 assertEquals(o, 1.0f, "getAndAddReleasefloat");
898 float x = (float) vh.get();
899 assertEquals(x, (float)(1.0f + 2.0f), "getAndAddRelease float value");
900 }
901
902 }
903
904 static void testStaticFieldUnsupported(VarHandle vh) {
905
906
907 checkUOE(() -> {
908 float o = (float) vh.getAndBitwiseOr(1.0f);
909 });
910
911 checkUOE(() -> {
912 float o = (float) vh.getAndBitwiseOrAcquire(1.0f);
913 });
914
915 checkUOE(() -> {
916 float o = (float) vh.getAndBitwiseOrRelease(1.0f);
917 });
918
919 checkUOE(() -> {
920 float o = (float) vh.getAndBitwiseAnd(1.0f);
921 });
922
923 checkUOE(() -> {
924 float o = (float) vh.getAndBitwiseAndAcquire(1.0f);
925 });
926
927 checkUOE(() -> {
928 float o = (float) vh.getAndBitwiseAndRelease(1.0f);
929 });
930
931 checkUOE(() -> {
932 float o = (float) vh.getAndBitwiseXor(1.0f);
933 });
934
935 checkUOE(() -> {
936 float o = (float) vh.getAndBitwiseXorAcquire(1.0f);
937 });
938
939 checkUOE(() -> {
940 float o = (float) vh.getAndBitwiseXorRelease(1.0f);
941 });
942 }
943
944
945 static void testArray(VarHandle vh) {
946 float[] array = new float[10];
947
948 for (int i = 0; i < array.length; i++) {
949 // Plain
950 {
951 vh.set(array, i, 1.0f);
952 float x = (float) vh.get(array, i);
953 assertEquals(x, 1.0f, "get float value");
954 }
955
956
957 // Volatile
958 {
959 vh.setVolatile(array, i, 2.0f);
960 float x = (float) vh.getVolatile(array, i);
961 assertEquals(x, 2.0f, "setVolatile float value");
962 }
963
964 // Lazy
965 {
966 vh.setRelease(array, i, 1.0f);
967 float x = (float) vh.getAcquire(array, i);
968 assertEquals(x, 1.0f, "setRelease float value");
969 }
970
971 // Opaque
972 {
973 vh.setOpaque(array, i, 2.0f);
974 float x = (float) vh.getOpaque(array, i);
975 assertEquals(x, 2.0f, "setOpaque float value");
976 }
977
978 vh.set(array, i, 1.0f);
979
980 // Compare
981 {
982 boolean r = vh.compareAndSet(array, i, 1.0f, 2.0f);
983 assertEquals(r, true, "success compareAndSet float");
984 float x = (float) vh.get(array, i);
985 assertEquals(x, 2.0f, "success compareAndSet float value");
986 }
987
988 {
989 boolean r = vh.compareAndSet(array, i, 1.0f, 3.0f);
990 assertEquals(r, false, "failing compareAndSet float");
991 float x = (float) vh.get(array, i);
992 assertEquals(x, 2.0f, "failing compareAndSet float value");
993 }
994
995 {
996 float r = (float) vh.compareAndExchange(array, i, 2.0f, 1.0f);
997 assertEquals(r, 2.0f, "success compareAndExchange float");
998 float x = (float) vh.get(array, i);
999 assertEquals(x, 1.0f, "success compareAndExchange float value");
1000 }
1001
1002 {
1003 float r = (float) vh.compareAndExchange(array, i, 2.0f, 3.0f);
1004 assertEquals(r, 1.0f, "failing compareAndExchange float");
1005 float x = (float) vh.get(array, i);
1006 assertEquals(x, 1.0f, "failing compareAndExchange float value");
1007 }
1008
1009 {
1010 float r = (float) vh.compareAndExchangeAcquire(array, i, 1.0f, 2.0f);
1011 assertEquals(r, 1.0f, "success compareAndExchangeAcquire float");
1012 float x = (float) vh.get(array, i);
1013 assertEquals(x, 2.0f, "success compareAndExchangeAcquire float value");
1014 }
1015
1016 {
1017 float r = (float) vh.compareAndExchangeAcquire(array, i, 1.0f, 3.0f);
1018 assertEquals(r, 2.0f, "failing compareAndExchangeAcquire float");
1019 float x = (float) vh.get(array, i);
1020 assertEquals(x, 2.0f, "failing compareAndExchangeAcquire float value");
1021 }
1022
1023 {
1024 float r = (float) vh.compareAndExchangeRelease(array, i, 2.0f, 1.0f);
1025 assertEquals(r, 2.0f, "success compareAndExchangeRelease float");
1026 float x = (float) vh.get(array, i);
1027 assertEquals(x, 1.0f, "success compareAndExchangeRelease float value");
1028 }
1029
1030 {
1031 float r = (float) vh.compareAndExchangeRelease(array, i, 2.0f, 3.0f);
1032 assertEquals(r, 1.0f, "failing compareAndExchangeRelease float");
1033 float x = (float) vh.get(array, i);
1034 assertEquals(x, 1.0f, "failing compareAndExchangeRelease float value");
1035 }
1036
1037 {
1038 boolean success = false;
1039 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1040 success = vh.weakCompareAndSetPlain(array, i, 1.0f, 2.0f);
1041 }
1042 assertEquals(success, true, "weakCompareAndSetPlain float");
1043 float x = (float) vh.get(array, i);
1044 assertEquals(x, 2.0f, "weakCompareAndSetPlain float value");
1045 }
1046
1047 {
1048 boolean success = false;
1049 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1050 success = vh.weakCompareAndSetAcquire(array, i, 2.0f, 1.0f);
1051 }
1052 assertEquals(success, true, "weakCompareAndSetAcquire float");
1053 float x = (float) vh.get(array, i);
1054 assertEquals(x, 1.0f, "weakCompareAndSetAcquire float");
1055 }
1056
1057 {
1058 boolean success = false;
1059 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1060 success = vh.weakCompareAndSetRelease(array, i, 1.0f, 2.0f);
1061 }
1062 assertEquals(success, true, "weakCompareAndSetRelease float");
1063 float x = (float) vh.get(array, i);
1064 assertEquals(x, 2.0f, "weakCompareAndSetRelease float");
1065 }
1066
1067 {
1068 boolean success = false;
1069 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1070 success = vh.weakCompareAndSet(array, i, 2.0f, 1.0f);
1071 }
1072 assertEquals(success, true, "weakCompareAndSet float");
1073 float x = (float) vh.get(array, i);
1074 assertEquals(x, 1.0f, "weakCompareAndSet float");
1075 }
1076
1077 // Compare set and get
1078 {
1079 vh.set(array, i, 1.0f);
1080
1081 float o = (float) vh.getAndSet(array, i, 2.0f);
1082 assertEquals(o, 1.0f, "getAndSet float");
1083 float x = (float) vh.get(array, i);
1084 assertEquals(x, 2.0f, "getAndSet float value");
1085 }
1086
1087 {
1088 vh.set(array, i, 1.0f);
1089
1090 float o = (float) vh.getAndSetAcquire(array, i, 2.0f);
1091 assertEquals(o, 1.0f, "getAndSetAcquire float");
1092 float x = (float) vh.get(array, i);
1093 assertEquals(x, 2.0f, "getAndSetAcquire float value");
1094 }
1095
1096 {
1097 vh.set(array, i, 1.0f);
1098
1099 float o = (float) vh.getAndSetRelease(array, i, 2.0f);
1100 assertEquals(o, 1.0f, "getAndSetRelease float");
1101 float x = (float) vh.get(array, i);
1102 assertEquals(x, 2.0f, "getAndSetRelease float value");
1103 }
1104
1105 // get and add, add and get
1106 {
1107 vh.set(array, i, 1.0f);
1108
1109 float o = (float) vh.getAndAdd(array, i, 2.0f);
1110 assertEquals(o, 1.0f, "getAndAdd float");
1111 float x = (float) vh.get(array, i);
1112 assertEquals(x, (float)(1.0f + 2.0f), "getAndAdd float value");
1113 }
1114
1115 {
1116 vh.set(array, i, 1.0f);
1117
1118 float o = (float) vh.getAndAddAcquire(array, i, 2.0f);
1119 assertEquals(o, 1.0f, "getAndAddAcquire float");
1120 float x = (float) vh.get(array, i);
1121 assertEquals(x, (float)(1.0f + 2.0f), "getAndAddAcquire float value");
1122 }
1123
1124 {
1125 vh.set(array, i, 1.0f);
1126
1127 float o = (float) vh.getAndAddRelease(array, i, 2.0f);
1128 assertEquals(o, 1.0f, "getAndAddReleasefloat");
1129 float x = (float) vh.get(array, i);
1130 assertEquals(x, (float)(1.0f + 2.0f), "getAndAddRelease float value");
1131 }
1132
1133 }
1134 }
1135
1136 static void testArrayUnsupported(VarHandle vh) {
1137 float[] array = new float[10];
1138
1139 int i = 0;
1140
1141
1142 checkUOE(() -> {
1143 float o = (float) vh.getAndBitwiseOr(array, i, 1.0f);
1144 });
1145
1146 checkUOE(() -> {
1147 float o = (float) vh.getAndBitwiseOrAcquire(array, i, 1.0f);
1148 });
1149
1150 checkUOE(() -> {
1151 float o = (float) vh.getAndBitwiseOrRelease(array, i, 1.0f);
1152 });
1153
1154 checkUOE(() -> {
1155 float o = (float) vh.getAndBitwiseAnd(array, i, 1.0f);
1156 });
1157
1158 checkUOE(() -> {
1159 float o = (float) vh.getAndBitwiseAndAcquire(array, i, 1.0f);
1160 });
1161
1162 checkUOE(() -> {
1163 float o = (float) vh.getAndBitwiseAndRelease(array, i, 1.0f);
1164 });
1165
1166 checkUOE(() -> {
1167 float o = (float) vh.getAndBitwiseXor(array, i, 1.0f);
1168 });
1169
1170 checkUOE(() -> {
1171 float o = (float) vh.getAndBitwiseXorAcquire(array, i, 1.0f);
1172 });
1173
1174 checkUOE(() -> {
1175 float o = (float) vh.getAndBitwiseXorRelease(array, i, 1.0f);
1176 });
1177 }
1178
1179 static void testArrayIndexOutOfBounds(VarHandle vh) throws Throwable {
1180 float[] array = new float[10];
1181
1182 for (int i : new int[]{-1, Integer.MIN_VALUE, 10, 11, Integer.MAX_VALUE}) {
1183 final int ci = i;
1184
1185 checkAIOOBE(() -> {
1186 float x = (float) vh.get(array, ci);
1187 });
1188
1189 checkAIOOBE(() -> {
1190 vh.set(array, ci, 1.0f);
1191 });
1192
1193 checkAIOOBE(() -> {
1194 float x = (float) vh.getVolatile(array, ci);
1195 });
1196
1197 checkAIOOBE(() -> {
1198 vh.setVolatile(array, ci, 1.0f);
1199 });
1200
1201 checkAIOOBE(() -> {
1202 float x = (float) vh.getAcquire(array, ci);
1203 });
1204
1205 checkAIOOBE(() -> {
1206 vh.setRelease(array, ci, 1.0f);
1207 });
1208
1209 checkAIOOBE(() -> {
1210 float x = (float) vh.getOpaque(array, ci);
1211 });
1212
1213 checkAIOOBE(() -> {
1214 vh.setOpaque(array, ci, 1.0f);
1215 });
1216
1217 checkAIOOBE(() -> {
1218 boolean r = vh.compareAndSet(array, ci, 1.0f, 2.0f);
1219 });
1220
1221 checkAIOOBE(() -> {
1222 float r = (float) vh.compareAndExchange(array, ci, 2.0f, 1.0f);
1223 });
1224
1225 checkAIOOBE(() -> {
1226 float r = (float) vh.compareAndExchangeAcquire(array, ci, 2.0f, 1.0f);
1227 });
1228
1229 checkAIOOBE(() -> {
1230 float r = (float) vh.compareAndExchangeRelease(array, ci, 2.0f, 1.0f);
1231 });
1232
1233 checkAIOOBE(() -> {
1234 boolean r = vh.weakCompareAndSetPlain(array, ci, 1.0f, 2.0f);
1235 });
1236
1237 checkAIOOBE(() -> {
1238 boolean r = vh.weakCompareAndSet(array, ci, 1.0f, 2.0f);
1239 });
1240
1241 checkAIOOBE(() -> {
1242 boolean r = vh.weakCompareAndSetAcquire(array, ci, 1.0f, 2.0f);
1243 });
1244
1245 checkAIOOBE(() -> {
1246 boolean r = vh.weakCompareAndSetRelease(array, ci, 1.0f, 2.0f);
1247 });
1248
1249 checkAIOOBE(() -> {
1250 float o = (float) vh.getAndSet(array, ci, 1.0f);
1251 });
1252
1253 checkAIOOBE(() -> {
1254 float o = (float) vh.getAndSetAcquire(array, ci, 1.0f);
1255 });
1256
1257 checkAIOOBE(() -> {
1258 float o = (float) vh.getAndSetRelease(array, ci, 1.0f);
1259 });
1260
1261 checkAIOOBE(() -> {
1262 float o = (float) vh.getAndAdd(array, ci, 1.0f);
1263 });
1264
1265 checkAIOOBE(() -> {
1266 float o = (float) vh.getAndAddAcquire(array, ci, 1.0f);
1267 });
1268
1269 checkAIOOBE(() -> {
1270 float o = (float) vh.getAndAddRelease(array, ci, 1.0f);
1271 });
1272
1273 }
1274 }
1275
1276 }
1277