1 /*
2 * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 #warn
25
26 /*
27 * @test
28 #if[Value]
29 * @enablePreview
30 * @modules java.base/jdk.internal.vm.annotation
31 #end[Value]
32 * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations
33 * to hit compilation thresholds
34 * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccess$Type$
35 */
36
37 import java.lang.invoke.MethodHandle;
38 import java.lang.invoke.MethodHandles;
39 import java.lang.invoke.VarHandle;
40 import java.util.ArrayList;
41 import java.util.List;
42
43 import static org.junit.jupiter.api.Assertions.*;
44 import org.junit.jupiter.api.BeforeAll;
45 import org.junit.jupiter.api.TestInstance;
46 import org.junit.jupiter.params.ParameterizedTest;
47 import org.junit.jupiter.params.provider.MethodSource;
48
49 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
50 public class VarHandleTestMethodHandleAccess$Type$ extends VarHandleBaseTest {
51 static final $type$ static_final_v = $value1$;
52
53 static $type$ static_v;
54
55 final $type$ final_v = $value1$;
56
57 $type$ v;
58
59 VarHandle vhFinalField;
60
61 VarHandle vhField;
62
63 VarHandle vhStaticField;
64
65 VarHandle vhStaticFinalField;
66
67 VarHandle vhArray;
68
69 @BeforeAll
70 public void setup() throws Exception {
71 vhFinalField = MethodHandles.lookup().findVarHandle(
72 VarHandleTestMethodHandleAccess$Type$.class, "final_v", $type$.class);
73
74 vhField = MethodHandles.lookup().findVarHandle(
75 VarHandleTestMethodHandleAccess$Type$.class, "v", $type$.class);
76
77 vhStaticFinalField = MethodHandles.lookup().findStaticVarHandle(
78 VarHandleTestMethodHandleAccess$Type$.class, "static_final_v", $type$.class);
79
80 vhStaticField = MethodHandles.lookup().findStaticVarHandle(
81 VarHandleTestMethodHandleAccess$Type$.class, "static_v", $type$.class);
82
83 vhArray = MethodHandles.arrayElementVarHandle($type$[].class);
84 }
85
86 public Object[][] accessTestCaseProvider() throws Exception {
87 List<AccessTestCase<?>> cases = new ArrayList<>();
88
89 for (VarHandleToMethodHandle f : VarHandleToMethodHandle.values()) {
90 cases.add(new MethodHandleAccessTestCase("Instance field",
91 vhField, f, hs -> testInstanceField(this, hs)));
92 cases.add(new MethodHandleAccessTestCase("Instance field unsupported",
93 vhField, f, hs -> testInstanceFieldUnsupported(this, hs),
94 false));
95
96 cases.add(new MethodHandleAccessTestCase("Static field",
97 vhStaticField, f, VarHandleTestMethodHandleAccess$Type$::testStaticField));
98 cases.add(new MethodHandleAccessTestCase("Static field unsupported",
99 vhStaticField, f, VarHandleTestMethodHandleAccess$Type$::testStaticFieldUnsupported,
100 false));
101
102 cases.add(new MethodHandleAccessTestCase("Array",
103 vhArray, f, VarHandleTestMethodHandleAccess$Type$::testArray));
104 cases.add(new MethodHandleAccessTestCase("Array unsupported",
105 vhArray, f, VarHandleTestMethodHandleAccess$Type$::testArrayUnsupported,
106 false));
107 cases.add(new MethodHandleAccessTestCase("Array index out of bounds",
108 vhArray, f, VarHandleTestMethodHandleAccess$Type$::testArrayIndexOutOfBounds,
109 false));
110 }
111
112 // Work around issue with jtreg summary reporting which truncates
113 // the String result of Object.toString to 30 characters, hence
114 // the first dummy argument
115 return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new);
116 }
117
118 @ParameterizedTest
119 @MethodSource("accessTestCaseProvider")
120 public <T> void testAccess(String desc, AccessTestCase<T> atc) throws Throwable {
121 T t = atc.get();
122 int iters = atc.requiresLoop() ? ITERS : 1;
123 for (int c = 0; c < iters; c++) {
124 atc.testAccess(t);
125 }
126 }
127
128 static void testInstanceField(VarHandleTestMethodHandleAccess$Type$ recv, Handles hs) throws Throwable {
129 // Plain
130 {
131 hs.get(TestAccessMode.SET).invokeExact(recv, $value1$);
132 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
133 assertEquals($value1$, x, "set $type$ value");
134 }
135
136
137 // Volatile
138 {
139 hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, $value2$);
140 $type$ x = ($type$) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv);
141 assertEquals($value2$, x, "setVolatile $type$ value");
142 }
143
144 // Lazy
145 {
146 hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, $value1$);
147 $type$ x = ($type$) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv);
148 assertEquals($value1$, x, "setRelease $type$ value");
149 }
150
151 // Opaque
152 {
153 hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, $value2$);
154 $type$ x = ($type$) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv);
155 assertEquals($value2$, x, "setOpaque $type$ value");
156 }
157
158 #if[CAS]
159 hs.get(TestAccessMode.SET).invokeExact(recv, $value1$);
160
161 // Compare
162 {
163 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, $value1$, $value2$);
164 assertEquals(r, true, "success compareAndSet $type$");
165 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
166 assertEquals($value2$, x, "success compareAndSet $type$ value");
167 }
168
169 {
170 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, $value1$, $value3$);
171 assertEquals(r, false, "failing compareAndSet $type$");
172 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
173 assertEquals($value2$, x, "failing compareAndSet $type$ value");
174 }
175
176 {
177 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, $value2$, $value1$);
178 assertEquals(r, $value2$, "success compareAndExchange $type$");
179 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
180 assertEquals($value1$, x, "success compareAndExchange $type$ value");
181 }
182
183 {
184 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, $value2$, $value3$);
185 assertEquals(r, $value1$, "failing compareAndExchange $type$");
186 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
187 assertEquals($value1$, x, "failing compareAndExchange $type$ value");
188 }
189
190 {
191 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, $value1$, $value2$);
192 assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$");
193 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
194 assertEquals($value2$, x, "success compareAndExchangeAcquire $type$ value");
195 }
196
197 {
198 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, $value1$, $value3$);
199 assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$");
200 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
201 assertEquals($value2$, x, "failing compareAndExchangeAcquire $type$ value");
202 }
203
204 {
205 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, $value2$, $value1$);
206 assertEquals(r, $value2$, "success compareAndExchangeRelease $type$");
207 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
208 assertEquals($value1$, x, "success compareAndExchangeRelease $type$ value");
209 }
210
211 {
212 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, $value2$, $value3$);
213 assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$");
214 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
215 assertEquals($value1$, x, "failing compareAndExchangeRelease $type$ value");
216 }
217
218 {
219 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN);
220 boolean success = false;
221 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
222 success = (boolean) mh.invokeExact(recv, $value1$, $value2$);
223 if (!success) weakDelay();
224 }
225 assertEquals(success, true, "success weakCompareAndSetPlain $type$");
226 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
227 assertEquals($value2$, x, "success weakCompareAndSetPlain $type$ value");
228 }
229
230 {
231 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, $value1$, $value3$);
232 assertEquals(success, false, "failing weakCompareAndSetPlain $type$");
233 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
234 assertEquals($value2$, x, "failing weakCompareAndSetPlain $type$ value");
235 }
236
237 {
238 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE);
239 boolean success = false;
240 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
241 success = (boolean) mh.invokeExact(recv, $value2$, $value1$);
242 if (!success) weakDelay();
243 }
244 assertEquals(success, true, "success weakCompareAndSetAcquire $type$");
245 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
246 assertEquals($value1$, x, "success weakCompareAndSetAcquire $type$");
247 }
248
249 {
250 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, $value2$, $value3$);
251 assertEquals(success, false, "failing weakCompareAndSetAcquire $type$");
252 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
253 assertEquals($value1$, x, "failing weakCompareAndSetAcquire $type$ value");
254 }
255
256 {
257 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE);
258 boolean success = false;
259 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
260 success = (boolean) mh.invokeExact(recv, $value1$, $value2$);
261 if (!success) weakDelay();
262 }
263 assertEquals(success, true, "success weakCompareAndSetRelease $type$");
264 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
265 assertEquals($value2$, x, "success weakCompareAndSetRelease $type$");
266 }
267
268 {
269 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, $value1$, $value3$);
270 assertEquals(success, false, "failing weakCompareAndSetRelease $type$");
271 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
272 assertEquals($value2$, x, "failing weakCompareAndSetRelease $type$ value");
273 }
274
275 {
276 boolean success = false;
277 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET);
278 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
279 success = (boolean) mh.invokeExact(recv, $value2$, $value1$);
280 if (!success) weakDelay();
281 }
282 assertEquals(success, true, "success weakCompareAndSet $type$");
283 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
284 assertEquals($value1$, x, "success weakCompareAndSet $type$");
285 }
286
287 {
288 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, $value2$, $value3$);
289 assertEquals(success, false, "failing weakCompareAndSet $type$");
290 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
291 assertEquals($value1$, x, "failing weakCompareAndSet $type$ value");
292 }
293
294 // Compare set and get
295 {
296 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, $value2$);
297 assertEquals($value1$, o, "getAndSet $type$");
298 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
299 assertEquals($value2$, x, "getAndSet $type$ value");
300 }
301 #end[CAS]
302
303 #if[AtomicAdd]
304 // get and add, add and get
305 {
306 hs.get(TestAccessMode.SET).invokeExact(recv, $value1$);
307
308 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, $value2$);
309 assertEquals($value1$, o, "getAndAdd $type$");
310 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
311 assertEquals(($type$)($value1$ + $value2$), x, "getAndAdd $type$ value");
312 }
313
314 {
315 hs.get(TestAccessMode.SET).invokeExact(recv, $value1$);
316
317 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, $value2$);
318 assertEquals($value1$, o, "getAndAddAcquire $type$");
319 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
320 assertEquals(($type$)($value1$ + $value2$), x, "getAndAddAcquire $type$ value");
321 }
322
323 {
324 hs.get(TestAccessMode.SET).invokeExact(recv, $value1$);
325
326 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, $value2$);
327 assertEquals($value1$, o, "getAndAddRelease $type$");
328 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
329 assertEquals(($type$)($value1$ + $value2$), x, "getAndAddRelease $type$ value");
330 }
331 #end[AtomicAdd]
332
333 #if[Bitwise]
334 // get and bitwise or
335 {
336 hs.get(TestAccessMode.SET).invokeExact(recv, $value1$);
337
338 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(recv, $value2$);
339 assertEquals($value1$, o, "getAndBitwiseOr $type$");
340 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
341 assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOr $type$ value");
342 }
343
344 {
345 hs.get(TestAccessMode.SET).invokeExact(recv, $value1$);
346
347 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(recv, $value2$);
348 assertEquals($value1$, o, "getAndBitwiseOrAcquire $type$");
349 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
350 assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrAcquire $type$ value");
351 }
352
353 {
354 hs.get(TestAccessMode.SET).invokeExact(recv, $value1$);
355
356 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(recv, $value2$);
357 assertEquals($value1$, o, "getAndBitwiseOrRelease $type$");
358 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
359 assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrRelease $type$ value");
360 }
361
362 // get and bitwise and
363 {
364 hs.get(TestAccessMode.SET).invokeExact(recv, $value1$);
365
366 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(recv, $value2$);
367 assertEquals($value1$, o, "getAndBitwiseAnd $type$");
368 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
369 assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAnd $type$ value");
370 }
371
372 {
373 hs.get(TestAccessMode.SET).invokeExact(recv, $value1$);
374
375 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(recv, $value2$);
376 assertEquals($value1$, o, "getAndBitwiseAndAcquire $type$");
377 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
378 assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndAcquire $type$ value");
379 }
380
381 {
382 hs.get(TestAccessMode.SET).invokeExact(recv, $value1$);
383
384 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(recv, $value2$);
385 assertEquals($value1$, o, "getAndBitwiseAndRelease $type$");
386 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
387 assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndRelease $type$ value");
388 }
389
390 // get and bitwise xor
391 {
392 hs.get(TestAccessMode.SET).invokeExact(recv, $value1$);
393
394 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(recv, $value2$);
395 assertEquals($value1$, o, "getAndBitwiseXor $type$");
396 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
397 assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXor $type$ value");
398 }
399
400 {
401 hs.get(TestAccessMode.SET).invokeExact(recv, $value1$);
402
403 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(recv, $value2$);
404 assertEquals($value1$, o, "getAndBitwiseXorAcquire $type$");
405 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
406 assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorAcquire $type$ value");
407 }
408
409 {
410 hs.get(TestAccessMode.SET).invokeExact(recv, $value1$);
411
412 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(recv, $value2$);
413 assertEquals($value1$, o, "getAndBitwiseXorRelease $type$");
414 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(recv);
415 assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorRelease $type$ value");
416 }
417 #end[Bitwise]
418 }
419
420 static void testInstanceFieldUnsupported(VarHandleTestMethodHandleAccess$Type$ recv, Handles hs) throws Throwable {
421 #if[!CAS]
422 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) {
423 checkUOE(am, () -> {
424 boolean r = (boolean) hs.get(am).invokeExact(recv, $value1$, $value2$);
425 });
426 }
427
428 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) {
429 checkUOE(am, () -> {
430 $type$ r = ($type$) hs.get(am).invokeExact(recv, $value1$, $value2$);
431 });
432 }
433
434 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) {
435 checkUOE(am, () -> {
436 $type$ r = ($type$) hs.get(am).invokeExact(recv, $value1$);
437 });
438 }
439 #end[CAS]
440
441 #if[!AtomicAdd]
442 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
443 checkUOE(am, () -> {
444 $type$ r = ($type$) hs.get(am).invokeExact(recv, $value1$);
445 });
446 }
447 #end[AtomicAdd]
448
449 #if[!Bitwise]
450 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) {
451 checkUOE(am, () -> {
452 $type$ r = ($type$) hs.get(am).invokeExact(recv, $value1$);
453 });
454 }
455 #end[Bitwise]
456 }
457
458
459 static void testStaticField(Handles hs) throws Throwable {
460 // Plain
461 {
462 hs.get(TestAccessMode.SET).invokeExact($value1$);
463 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
464 assertEquals($value1$, x, "set $type$ value");
465 }
466
467
468 // Volatile
469 {
470 hs.get(TestAccessMode.SET_VOLATILE).invokeExact($value2$);
471 $type$ x = ($type$) hs.get(TestAccessMode.GET_VOLATILE).invokeExact();
472 assertEquals($value2$, x, "setVolatile $type$ value");
473 }
474
475 // Lazy
476 {
477 hs.get(TestAccessMode.SET_RELEASE).invokeExact($value1$);
478 $type$ x = ($type$) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact();
479 assertEquals($value1$, x, "setRelease $type$ value");
480 }
481
482 // Opaque
483 {
484 hs.get(TestAccessMode.SET_OPAQUE).invokeExact($value2$);
485 $type$ x = ($type$) hs.get(TestAccessMode.GET_OPAQUE).invokeExact();
486 assertEquals($value2$, x, "setOpaque $type$ value");
487 }
488
489 #if[CAS]
490 hs.get(TestAccessMode.SET).invokeExact($value1$);
491
492 // Compare
493 {
494 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact($value1$, $value2$);
495 assertEquals(r, true, "success compareAndSet $type$");
496 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
497 assertEquals($value2$, x, "success compareAndSet $type$ value");
498 }
499
500 {
501 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact($value1$, $value3$);
502 assertEquals(r, false, "failing compareAndSet $type$");
503 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
504 assertEquals($value2$, x, "failing compareAndSet $type$ value");
505 }
506
507 {
508 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact($value2$, $value1$);
509 assertEquals(r, $value2$, "success compareAndExchange $type$");
510 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
511 assertEquals($value1$, x, "success compareAndExchange $type$ value");
512 }
513
514 {
515 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact($value2$, $value3$);
516 assertEquals(r, $value1$, "failing compareAndExchange $type$");
517 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
518 assertEquals($value1$, x, "failing compareAndExchange $type$ value");
519 }
520
521 {
522 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact($value1$, $value2$);
523 assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$");
524 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
525 assertEquals($value2$, x, "success compareAndExchangeAcquire $type$ value");
526 }
527
528 {
529 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact($value1$, $value3$);
530 assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$");
531 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
532 assertEquals($value2$, x, "failing compareAndExchangeAcquire $type$ value");
533 }
534
535 {
536 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact($value2$, $value1$);
537 assertEquals(r, $value2$, "success compareAndExchangeRelease $type$");
538 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
539 assertEquals($value1$, x, "success compareAndExchangeRelease $type$ value");
540 }
541
542 {
543 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact($value2$, $value3$);
544 assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$");
545 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
546 assertEquals($value1$, x, "failing compareAndExchangeRelease $type$ value");
547 }
548
549 {
550 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN);
551 boolean success = false;
552 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
553 success = (boolean) mh.invokeExact($value1$, $value2$);
554 if (!success) weakDelay();
555 }
556 assertEquals(success, true, "success weakCompareAndSetPlain $type$");
557 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
558 assertEquals($value2$, x, "success weakCompareAndSetPlain $type$ value");
559 }
560
561 {
562 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact($value1$, $value3$);
563 assertEquals(success, false, "failing weakCompareAndSetPlain $type$");
564 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
565 assertEquals($value2$, x, "failing weakCompareAndSetPlain $type$ value");
566 }
567
568 {
569 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE);
570 boolean success = false;
571 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
572 success = (boolean) mh.invokeExact($value2$, $value1$);
573 if (!success) weakDelay();
574 }
575 assertEquals(success, true, "success weakCompareAndSetAcquire $type$");
576 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
577 assertEquals($value1$, x, "success weakCompareAndSetAcquire $type$");
578 }
579
580 {
581 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE);
582 boolean success = (boolean) mh.invokeExact($value2$, $value3$);
583 assertEquals(success, false, "failing weakCompareAndSetAcquire $type$");
584 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
585 assertEquals($value1$, x, "failing weakCompareAndSetAcquire $type$ value");
586 }
587
588 {
589 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE);
590 boolean success = false;
591 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
592 success = (boolean) mh.invokeExact($value1$, $value2$);
593 if (!success) weakDelay();
594 }
595 assertEquals(success, true, "success weakCompareAndSetRelease $type$");
596 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
597 assertEquals($value2$, x, "success weakCompareAndSetRelease $type$");
598 }
599
600 {
601 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact($value1$, $value3$);
602 assertEquals(success, false, "failing weakCompareAndSetRelease $type$");
603 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
604 assertEquals($value2$, x, "failing weakCompareAndSetRelease $type$ value");
605 }
606
607 {
608 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET);
609 boolean success = false;
610 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
611 success = (boolean) mh.invokeExact($value2$, $value1$);
612 if (!success) weakDelay();
613 }
614 assertEquals(success, true, "success weakCompareAndSet $type$");
615 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
616 assertEquals($value1$, x, "success weakCompareAndSet $type$");
617 }
618
619 {
620 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact($value2$, $value3$);
621 assertEquals(success, false, "failing weakCompareAndSet $type$");
622 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
623 assertEquals($value1$, x, "failing weakCompareAndSetRe $type$ value");
624 }
625
626 // Compare set and get
627 {
628 hs.get(TestAccessMode.SET).invokeExact($value1$);
629
630 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET).invokeExact($value2$);
631 assertEquals($value1$, o, "getAndSet $type$");
632 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
633 assertEquals($value2$, x, "getAndSet $type$ value");
634 }
635
636 // Compare set and get
637 {
638 hs.get(TestAccessMode.SET).invokeExact($value1$);
639
640 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact($value2$);
641 assertEquals($value1$, o, "getAndSetAcquire $type$");
642 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
643 assertEquals($value2$, x, "getAndSetAcquire $type$ value");
644 }
645
646 // Compare set and get
647 {
648 hs.get(TestAccessMode.SET).invokeExact($value1$);
649
650 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact($value2$);
651 assertEquals($value1$, o, "getAndSetRelease $type$");
652 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
653 assertEquals($value2$, x, "getAndSetRelease $type$ value");
654 }
655 #end[CAS]
656
657 #if[AtomicAdd]
658 // get and add, add and get
659 {
660 hs.get(TestAccessMode.SET).invokeExact($value1$);
661
662 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD).invokeExact($value2$);
663 assertEquals($value1$, o, "getAndAdd $type$");
664 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
665 assertEquals(($type$)($value1$ + $value2$), x, "getAndAdd $type$ value");
666 }
667
668 {
669 hs.get(TestAccessMode.SET).invokeExact($value1$);
670
671 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact($value2$);
672 assertEquals($value1$, o, "getAndAddAcquire $type$");
673 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
674 assertEquals(($type$)($value1$ + $value2$), x, "getAndAddAcquire $type$ value");
675 }
676
677 {
678 hs.get(TestAccessMode.SET).invokeExact($value1$);
679
680 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact($value2$);
681 assertEquals($value1$, o, "getAndAddRelease $type$");
682 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
683 assertEquals(($type$)($value1$ + $value2$), x, "getAndAddRelease $type$ value");
684 }
685 #end[AtomicAdd]
686
687 #if[Bitwise]
688 // get and bitwise or
689 {
690 hs.get(TestAccessMode.SET).invokeExact($value1$);
691
692 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact($value2$);
693 assertEquals($value1$, o, "getAndBitwiseOr $type$");
694 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
695 assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOr $type$ value");
696 }
697
698 {
699 hs.get(TestAccessMode.SET).invokeExact($value1$);
700
701 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact($value2$);
702 assertEquals($value1$, o, "getAndBitwiseOrAcquire $type$");
703 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
704 assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrAcquire $type$ value");
705 }
706
707 {
708 hs.get(TestAccessMode.SET).invokeExact($value1$);
709
710 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact($value2$);
711 assertEquals($value1$, o, "getAndBitwiseOrRelease $type$");
712 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
713 assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrRelease $type$ value");
714 }
715
716 // get and bitwise and
717 {
718 hs.get(TestAccessMode.SET).invokeExact($value1$);
719
720 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact($value2$);
721 assertEquals($value1$, o, "getAndBitwiseAnd $type$");
722 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
723 assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAnd $type$ value");
724 }
725
726 {
727 hs.get(TestAccessMode.SET).invokeExact($value1$);
728
729 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact($value2$);
730 assertEquals($value1$, o, "getAndBitwiseAndAcquire $type$");
731 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
732 assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndAcquire $type$ value");
733 }
734
735 {
736 hs.get(TestAccessMode.SET).invokeExact($value1$);
737
738 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact($value2$);
739 assertEquals($value1$, o, "getAndBitwiseAndRelease $type$");
740 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
741 assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndRelease $type$ value");
742 }
743
744 // get and bitwise xor
745 {
746 hs.get(TestAccessMode.SET).invokeExact($value1$);
747
748 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact($value2$);
749 assertEquals($value1$, o, "getAndBitwiseXor $type$");
750 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
751 assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXor $type$ value");
752 }
753
754 {
755 hs.get(TestAccessMode.SET).invokeExact($value1$);
756
757 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact($value2$);
758 assertEquals($value1$, o, "getAndBitwiseXorAcquire $type$");
759 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
760 assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorAcquire $type$ value");
761 }
762
763 {
764 hs.get(TestAccessMode.SET).invokeExact($value1$);
765
766 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact($value2$);
767 assertEquals($value1$, o, "getAndBitwiseXorRelease $type$");
768 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact();
769 assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorRelease $type$ value");
770 }
771 #end[Bitwise]
772 }
773
774 static void testStaticFieldUnsupported(Handles hs) throws Throwable {
775 #if[!CAS]
776 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) {
777 checkUOE(am, () -> {
778 boolean r = (boolean) hs.get(am).invokeExact($value1$, $value2$);
779 });
780 }
781
782 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) {
783 checkUOE(am, () -> {
784 $type$ r = ($type$) hs.get(am).invokeExact($value1$, $value2$);
785 });
786 }
787
788 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) {
789 checkUOE(am, () -> {
790 $type$ r = ($type$) hs.get(am).invokeExact($value1$);
791 });
792 }
793 #end[CAS]
794
795 #if[!AtomicAdd]
796 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
797 checkUOE(am, () -> {
798 $type$ r = ($type$) hs.get(am).invokeExact($value1$);
799 });
800 }
801 #end[AtomicAdd]
802
803 #if[!Bitwise]
804 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) {
805 checkUOE(am, () -> {
806 $type$ r = ($type$) hs.get(am).invokeExact($value1$);
807 });
808 }
809 #end[Bitwise]
810 }
811
812
813 static void testArray(Handles hs) throws Throwable {
814 $type$[] array = new $type$[10];
815
816 for (int i = 0; i < array.length; i++) {
817 // Plain
818 {
819 hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$);
820 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
821 assertEquals($value1$, x, "get $type$ value");
822 }
823
824
825 // Volatile
826 {
827 hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, $value2$);
828 $type$ x = ($type$) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i);
829 assertEquals($value2$, x, "setVolatile $type$ value");
830 }
831
832 // Lazy
833 {
834 hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, $value1$);
835 $type$ x = ($type$) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i);
836 assertEquals($value1$, x, "setRelease $type$ value");
837 }
838
839 // Opaque
840 {
841 hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, $value2$);
842 $type$ x = ($type$) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i);
843 assertEquals($value2$, x, "setOpaque $type$ value");
844 }
845
846 #if[CAS]
847 hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$);
848
849 // Compare
850 {
851 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, $value1$, $value2$);
852 assertEquals(r, true, "success compareAndSet $type$");
853 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
854 assertEquals($value2$, x, "success compareAndSet $type$ value");
855 }
856
857 {
858 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, $value1$, $value3$);
859 assertEquals(r, false, "failing compareAndSet $type$");
860 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
861 assertEquals($value2$, x, "failing compareAndSet $type$ value");
862 }
863
864 {
865 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, $value2$, $value1$);
866 assertEquals(r, $value2$, "success compareAndExchange $type$");
867 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
868 assertEquals($value1$, x, "success compareAndExchange $type$ value");
869 }
870
871 {
872 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, $value2$, $value3$);
873 assertEquals(r, $value1$, "failing compareAndExchange $type$");
874 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
875 assertEquals($value1$, x, "failing compareAndExchange $type$ value");
876 }
877
878 {
879 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, $value1$, $value2$);
880 assertEquals(r, $value1$, "success compareAndExchangeAcquire $type$");
881 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
882 assertEquals($value2$, x, "success compareAndExchangeAcquire $type$ value");
883 }
884
885 {
886 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, $value1$, $value3$);
887 assertEquals(r, $value2$, "failing compareAndExchangeAcquire $type$");
888 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
889 assertEquals($value2$, x, "failing compareAndExchangeAcquire $type$ value");
890 }
891
892 {
893 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, $value2$, $value1$);
894 assertEquals(r, $value2$, "success compareAndExchangeRelease $type$");
895 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
896 assertEquals($value1$, x, "success compareAndExchangeRelease $type$ value");
897 }
898
899 {
900 $type$ r = ($type$) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, $value2$, $value3$);
901 assertEquals(r, $value1$, "failing compareAndExchangeRelease $type$");
902 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
903 assertEquals($value1$, x, "failing compareAndExchangeRelease $type$ value");
904 }
905
906 {
907 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN);
908 boolean success = false;
909 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
910 success = (boolean) mh.invokeExact(array, i, $value1$, $value2$);
911 if (!success) weakDelay();
912 }
913 assertEquals(success, true, "success weakCompareAndSetPlain $type$");
914 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
915 assertEquals($value2$, x, "success weakCompareAndSetPlain $type$ value");
916 }
917
918 {
919 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, $value1$, $value3$);
920 assertEquals(success, false, "failing weakCompareAndSetPlain $type$");
921 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
922 assertEquals($value2$, x, "failing weakCompareAndSetPlain $type$ value");
923 }
924
925 {
926 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE);
927 boolean success = false;
928 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
929 success = (boolean) mh.invokeExact(array, i, $value2$, $value1$);
930 if (!success) weakDelay();
931 }
932 assertEquals(success, true, "success weakCompareAndSetAcquire $type$");
933 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
934 assertEquals($value1$, x, "success weakCompareAndSetAcquire $type$");
935 }
936
937 {
938 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, $value2$, $value3$);
939 assertEquals(success, false, "failing weakCompareAndSetAcquire $type$");
940 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
941 assertEquals($value1$, x, "failing weakCompareAndSetAcquire $type$ value");
942 }
943
944 {
945 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE);
946 boolean success = false;
947 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
948 success = (boolean) mh.invokeExact(array, i, $value1$, $value2$);
949 if (!success) weakDelay();
950 }
951 assertEquals(success, true, "success weakCompareAndSetRelease $type$");
952 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
953 assertEquals($value2$, x, "success weakCompareAndSetRelease $type$");
954 }
955
956 {
957 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, $value1$, $value3$);
958 assertEquals(success, false, "failing weakCompareAndSetAcquire $type$");
959 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
960 assertEquals($value2$, x, "failing weakCompareAndSetAcquire $type$ value");
961 }
962
963 {
964 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET);
965 boolean success = false;
966 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
967 success = (boolean) mh.invokeExact(array, i, $value2$, $value1$);
968 if (!success) weakDelay();
969 }
970 assertEquals(success, true, "success weakCompareAndSet $type$");
971 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
972 assertEquals($value1$, x, "success weakCompareAndSet $type$");
973 }
974
975 {
976 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, $value2$, $value3$);
977 assertEquals(success, false, "failing weakCompareAndSet $type$");
978 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
979 assertEquals($value1$, x, "failing weakCompareAndSet $type$ value");
980 }
981
982 // Compare set and get
983 {
984 hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$);
985
986 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, $value2$);
987 assertEquals($value1$, o, "getAndSet $type$");
988 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
989 assertEquals($value2$, x, "getAndSet $type$ value");
990 }
991
992 {
993 hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$);
994
995 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, $value2$);
996 assertEquals($value1$, o, "getAndSetAcquire $type$");
997 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
998 assertEquals($value2$, x, "getAndSetAcquire $type$ value");
999 }
1000
1001 {
1002 hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$);
1003
1004 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, $value2$);
1005 assertEquals($value1$, o, "getAndSetRelease $type$");
1006 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
1007 assertEquals($value2$, x, "getAndSetRelease $type$ value");
1008 }
1009 #end[CAS]
1010
1011 #if[AtomicAdd]
1012 // get and add, add and get
1013 {
1014 hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$);
1015
1016 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, $value2$);
1017 assertEquals($value1$, o, "getAndAdd $type$");
1018 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
1019 assertEquals(($type$)($value1$ + $value2$), x, "getAndAdd $type$ value");
1020 }
1021
1022 {
1023 hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$);
1024
1025 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, $value2$);
1026 assertEquals($value1$, o, "getAndAddAcquire $type$");
1027 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
1028 assertEquals(($type$)($value1$ + $value2$), x, "getAndAddAcquire $type$ value");
1029 }
1030
1031 {
1032 hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$);
1033
1034 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, $value2$);
1035 assertEquals($value1$, o, "getAndAddRelease $type$");
1036 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
1037 assertEquals(($type$)($value1$ + $value2$), x, "getAndAddRelease $type$ value");
1038 }
1039 #end[AtomicAdd]
1040
1041 #if[Bitwise]
1042 // get and bitwise or
1043 {
1044 hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$);
1045
1046 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(array, i, $value2$);
1047 assertEquals($value1$, o, "getAndBitwiseOr $type$");
1048 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
1049 assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOr $type$ value");
1050 }
1051
1052 {
1053 hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$);
1054
1055 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(array, i, $value2$);
1056 assertEquals($value1$, o, "getAndBitwiseOrAcquire $type$");
1057 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
1058 assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrAcquire $type$ value");
1059 }
1060
1061 {
1062 hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$);
1063
1064 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(array, i, $value2$);
1065 assertEquals($value1$, o, "getAndBitwiseOrRelease $type$");
1066 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
1067 assertEquals(($type$)($value1$ | $value2$), x, "getAndBitwiseOrRelease $type$ value");
1068 }
1069
1070 // get and bitwise and
1071 {
1072 hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$);
1073
1074 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(array, i, $value2$);
1075 assertEquals($value1$, o, "getAndBitwiseAnd $type$");
1076 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
1077 assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAnd $type$ value");
1078 }
1079
1080 {
1081 hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$);
1082
1083 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(array, i, $value2$);
1084 assertEquals($value1$, o, "getAndBitwiseAndAcquire $type$");
1085 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
1086 assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndAcquire $type$ value");
1087 }
1088
1089 {
1090 hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$);
1091
1092 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(array, i, $value2$);
1093 assertEquals($value1$, o, "getAndBitwiseAndRelease $type$");
1094 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
1095 assertEquals(($type$)($value1$ & $value2$), x, "getAndBitwiseAndRelease $type$ value");
1096 }
1097
1098 // get and bitwise xor
1099 {
1100 hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$);
1101
1102 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(array, i, $value2$);
1103 assertEquals($value1$, o, "getAndBitwiseXor $type$");
1104 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
1105 assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXor $type$ value");
1106 }
1107
1108 {
1109 hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$);
1110
1111 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(array, i, $value2$);
1112 assertEquals($value1$, o, "getAndBitwiseXorAcquire $type$");
1113 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
1114 assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorAcquire $type$ value");
1115 }
1116
1117 {
1118 hs.get(TestAccessMode.SET).invokeExact(array, i, $value1$);
1119
1120 $type$ o = ($type$) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(array, i, $value2$);
1121 assertEquals($value1$, o, "getAndBitwiseXorRelease $type$");
1122 $type$ x = ($type$) hs.get(TestAccessMode.GET).invokeExact(array, i);
1123 assertEquals(($type$)($value1$ ^ $value2$), x, "getAndBitwiseXorRelease $type$ value");
1124 }
1125 #end[Bitwise]
1126 }
1127 }
1128
1129 static void testArrayUnsupported(Handles hs) throws Throwable {
1130 $type$[] array = new $type$[10];
1131
1132 final int i = 0;
1133 #if[!CAS]
1134 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) {
1135 checkUOE(am, () -> {
1136 boolean r = (boolean) hs.get(am).invokeExact(array, i, $value1$, $value2$);
1137 });
1138 }
1139
1140 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) {
1141 checkUOE(am, () -> {
1142 $type$ r = ($type$) hs.get(am).invokeExact(array, i, $value1$, $value2$);
1143 });
1144 }
1145
1146 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) {
1147 checkUOE(am, () -> {
1148 $type$ r = ($type$) hs.get(am).invokeExact(array, i, $value1$);
1149 });
1150 }
1151 #end[CAS]
1152
1153 #if[!AtomicAdd]
1154 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
1155 checkUOE(am, () -> {
1156 $type$ o = ($type$) hs.get(am).invokeExact(array, i, $value1$);
1157 });
1158 }
1159 #end[AtomicAdd]
1160
1161 #if[!Bitwise]
1162 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) {
1163 checkUOE(am, () -> {
1164 $type$ o = ($type$) hs.get(am).invokeExact(array, i, $value1$);
1165 });
1166 }
1167 #end[Bitwise]
1168 }
1169
1170 static void testArrayIndexOutOfBounds(Handles hs) throws Throwable {
1171 $type$[] array = new $type$[10];
1172
1173 for (int i : new int[]{-1, Integer.MIN_VALUE, 10, 11, Integer.MAX_VALUE}) {
1174 final int ci = i;
1175
1176 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) {
1177 checkAIOOBE(am, () -> {
1178 $type$ x = ($type$) hs.get(am).invokeExact(array, ci);
1179 });
1180 }
1181
1182 for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) {
1183 checkAIOOBE(am, () -> {
1184 hs.get(am).invokeExact(array, ci, $value1$);
1185 });
1186 }
1187
1188 #if[CAS]
1189 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) {
1190 checkAIOOBE(am, () -> {
1191 boolean r = (boolean) hs.get(am).invokeExact(array, ci, $value1$, $value2$);
1192 });
1193 }
1194
1195 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) {
1196 checkAIOOBE(am, () -> {
1197 $type$ r = ($type$) hs.get(am).invokeExact(array, ci, $value2$, $value1$);
1198 });
1199 }
1200
1201 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) {
1202 checkAIOOBE(am, () -> {
1203 $type$ o = ($type$) hs.get(am).invokeExact(array, ci, $value1$);
1204 });
1205 }
1206 #end[CAS]
1207
1208 #if[AtomicAdd]
1209 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
1210 checkAIOOBE(am, () -> {
1211 $type$ o = ($type$) hs.get(am).invokeExact(array, ci, $value3$);
1212 });
1213 }
1214 #end[AtomicAdd]
1215
1216 #if[Bitwise]
1217 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) {
1218 checkAIOOBE(am, () -> {
1219 $type$ o = ($type$) hs.get(am).invokeExact(array, ci, $value3$);
1220 });
1221 }
1222 #end[Bitwise]
1223 }
1224 }
1225 }
1226