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