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