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