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