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