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