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