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