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 VarHandleTestAccessByte
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 VarHandleTestAccessByte
32 * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestAccessByte
33 * @run testng/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 -XX:-TieredCompilation VarHandleTestAccessByte
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 VarHandleTestAccessByte extends VarHandleBaseTest {
49 static final byte static_final_v = (byte)0x01;
50
51 static byte static_v;
52
53 final byte final_v = (byte)0x01;
54
55 byte v;
56
57 static final byte static_final_v2 = (byte)0x01;
58
59 static byte static_v2;
60
61 final byte final_v2 = (byte)0x01;
62
63 byte 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 VarHandleTestAccessByte.class, "final_v" + postfix, byte.class);
84 vhs.add(vh);
85
86 vh = MethodHandles.lookup().findVarHandle(
87 VarHandleTestAccessByte.class, "v" + postfix, byte.class);
88 vhs.add(vh);
89
90 vh = MethodHandles.lookup().findStaticVarHandle(
91 VarHandleTestAccessByte.class, "static_final_v" + postfix, byte.class);
92 vhs.add(vh);
93
94 vh = MethodHandles.lookup().findStaticVarHandle(
95 VarHandleTestAccessByte.class, "static_v" + postfix, byte.class);
96 vhs.add(vh);
97
98 if (same) {
99 vh = MethodHandles.arrayElementVarHandle(byte[].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 VarHandleTestAccessByte.class, "final_v", byte.class);
115
116 vhField = MethodHandles.lookup().findVarHandle(
117 VarHandleTestAccessByte.class, "v", byte.class);
118
119 vhStaticFinalField = MethodHandles.lookup().findStaticVarHandle(
120 VarHandleTestAccessByte.class, "static_final_v", byte.class);
121
122 vhStaticField = MethodHandles.lookup().findStaticVarHandle(
123 VarHandleTestAccessByte.class, "static_v", byte.class);
124
125 vhArray = MethodHandles.arrayElementVarHandle(byte[].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(VarHandleTestAccessByte.class)});
202 types.add(new Object[] {vhStaticField, Arrays.asList()});
203 types.add(new Object[] {vhArray, Arrays.asList(byte[].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(), byte.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 VarHandleTestAccessByte.class, "final_v", byte.class);
223 });
224
225 checkIAE("Lookup of static field to instance field", () -> {
226 MethodHandles.lookup().findStaticVarHandle(
227 VarHandleTestAccessByte.class, "v", byte.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 VarHandleTestAccessByte.class, "static_final_v", byte.class);
236 });
237
238 checkIAE("Lookup of instance field to static field", () -> {
239 vhStaticField = MethodHandles.lookup().findVarHandle(
240 VarHandleTestAccessByte.class, "static_v", byte.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, VarHandleTestAccessByte::testStaticFinalField));
257 cases.add(new VarHandleAccessTestCase("Static final field unsupported",
258 vhStaticFinalField, VarHandleTestAccessByte::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, VarHandleTestAccessByte::testStaticField));
269 cases.add(new VarHandleAccessTestCase("Static field unsupported",
270 vhStaticField, VarHandleTestAccessByte::testStaticFieldUnsupported,
271 false));
272
273 cases.add(new VarHandleAccessTestCase("Array",
274 vhArray, VarHandleTestAccessByte::testArray));
275 cases.add(new VarHandleAccessTestCase("Array unsupported",
276 vhArray, VarHandleTestAccessByte::testArrayUnsupported,
277 false));
278 cases.add(new VarHandleAccessTestCase("Array index out of bounds",
279 vhArray, VarHandleTestAccessByte::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(VarHandleTestAccessByte recv, VarHandle vh) {
297 // Plain
298 {
299 byte x = (byte) vh.get(recv);
300 assertEquals(x, (byte)0x01, "get byte value");
301 }
302
303
304 // Volatile
305 {
306 byte x = (byte) vh.getVolatile(recv);
307 assertEquals(x, (byte)0x01, "getVolatile byte value");
308 }
309
310 // Lazy
311 {
312 byte x = (byte) vh.getAcquire(recv);
313 assertEquals(x, (byte)0x01, "getRelease byte value");
314 }
315
316 // Opaque
317 {
318 byte x = (byte) vh.getOpaque(recv);
319 assertEquals(x, (byte)0x01, "getOpaque byte value");
320 }
321 }
322
323 static void testInstanceFinalFieldUnsupported(VarHandleTestAccessByte recv, VarHandle vh) {
324 checkUOE(() -> {
325 vh.set(recv, (byte)0x23);
326 });
327
328 checkUOE(() -> {
329 vh.setVolatile(recv, (byte)0x23);
330 });
331
332 checkUOE(() -> {
333 vh.setRelease(recv, (byte)0x23);
334 });
335
336 checkUOE(() -> {
337 vh.setOpaque(recv, (byte)0x23);
338 });
339
340
341
342 }
343
344
345 static void testStaticFinalField(VarHandle vh) {
346 // Plain
347 {
348 byte x = (byte) vh.get();
349 assertEquals(x, (byte)0x01, "get byte value");
350 }
351
352
353 // Volatile
354 {
355 byte x = (byte) vh.getVolatile();
356 assertEquals(x, (byte)0x01, "getVolatile byte value");
357 }
358
359 // Lazy
360 {
361 byte x = (byte) vh.getAcquire();
362 assertEquals(x, (byte)0x01, "getRelease byte value");
363 }
364
365 // Opaque
366 {
367 byte x = (byte) vh.getOpaque();
368 assertEquals(x, (byte)0x01, "getOpaque byte value");
369 }
370 }
371
372 static void testStaticFinalFieldUnsupported(VarHandle vh) {
373 checkUOE(() -> {
374 vh.set((byte)0x23);
375 });
376
377 checkUOE(() -> {
378 vh.setVolatile((byte)0x23);
379 });
380
381 checkUOE(() -> {
382 vh.setRelease((byte)0x23);
383 });
384
385 checkUOE(() -> {
386 vh.setOpaque((byte)0x23);
387 });
388
389
390
391 }
392
393
394 static void testInstanceField(VarHandleTestAccessByte recv, VarHandle vh) {
395 // Plain
396 {
397 vh.set(recv, (byte)0x01);
398 byte x = (byte) vh.get(recv);
399 assertEquals(x, (byte)0x01, "set byte value");
400 }
401
402
403 // Volatile
404 {
405 vh.setVolatile(recv, (byte)0x23);
406 byte x = (byte) vh.getVolatile(recv);
407 assertEquals(x, (byte)0x23, "setVolatile byte value");
408 }
409
410 // Lazy
411 {
412 vh.setRelease(recv, (byte)0x01);
413 byte x = (byte) vh.getAcquire(recv);
414 assertEquals(x, (byte)0x01, "setRelease byte value");
415 }
416
417 // Opaque
418 {
419 vh.setOpaque(recv, (byte)0x23);
420 byte x = (byte) vh.getOpaque(recv);
421 assertEquals(x, (byte)0x23, "setOpaque byte value");
422 }
423
424 vh.set(recv, (byte)0x01);
425
426 // Compare
427 {
428 boolean r = vh.compareAndSet(recv, (byte)0x01, (byte)0x23);
429 assertEquals(r, true, "success compareAndSet byte");
430 byte x = (byte) vh.get(recv);
431 assertEquals(x, (byte)0x23, "success compareAndSet byte value");
432 }
433
434 {
435 boolean r = vh.compareAndSet(recv, (byte)0x01, (byte)0x45);
436 assertEquals(r, false, "failing compareAndSet byte");
437 byte x = (byte) vh.get(recv);
438 assertEquals(x, (byte)0x23, "failing compareAndSet byte value");
439 }
440
441 {
442 byte r = (byte) vh.compareAndExchange(recv, (byte)0x23, (byte)0x01);
443 assertEquals(r, (byte)0x23, "success compareAndExchange byte");
444 byte x = (byte) vh.get(recv);
445 assertEquals(x, (byte)0x01, "success compareAndExchange byte value");
446 }
447
448 {
449 byte r = (byte) vh.compareAndExchange(recv, (byte)0x23, (byte)0x45);
450 assertEquals(r, (byte)0x01, "failing compareAndExchange byte");
451 byte x = (byte) vh.get(recv);
452 assertEquals(x, (byte)0x01, "failing compareAndExchange byte value");
453 }
454
455 {
456 byte r = (byte) vh.compareAndExchangeAcquire(recv, (byte)0x01, (byte)0x23);
457 assertEquals(r, (byte)0x01, "success compareAndExchangeAcquire byte");
458 byte x = (byte) vh.get(recv);
459 assertEquals(x, (byte)0x23, "success compareAndExchangeAcquire byte value");
460 }
461
462 {
463 byte r = (byte) vh.compareAndExchangeAcquire(recv, (byte)0x01, (byte)0x45);
464 assertEquals(r, (byte)0x23, "failing compareAndExchangeAcquire byte");
465 byte x = (byte) vh.get(recv);
466 assertEquals(x, (byte)0x23, "failing compareAndExchangeAcquire byte value");
467 }
468
469 {
470 byte r = (byte) vh.compareAndExchangeRelease(recv, (byte)0x23, (byte)0x01);
471 assertEquals(r, (byte)0x23, "success compareAndExchangeRelease byte");
472 byte x = (byte) vh.get(recv);
473 assertEquals(x, (byte)0x01, "success compareAndExchangeRelease byte value");
474 }
475
476 {
477 byte r = (byte) vh.compareAndExchangeRelease(recv, (byte)0x23, (byte)0x45);
478 assertEquals(r, (byte)0x01, "failing compareAndExchangeRelease byte");
479 byte x = (byte) vh.get(recv);
480 assertEquals(x, (byte)0x01, "failing compareAndExchangeRelease byte value");
481 }
482
483 {
484 boolean success = false;
485 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
486 success = vh.weakCompareAndSetPlain(recv, (byte)0x01, (byte)0x23);
487 if (!success) weakDelay();
488 }
489 assertEquals(success, true, "success weakCompareAndSetPlain byte");
490 byte x = (byte) vh.get(recv);
491 assertEquals(x, (byte)0x23, "success weakCompareAndSetPlain byte value");
492 }
493
494 {
495 boolean success = vh.weakCompareAndSetPlain(recv, (byte)0x01, (byte)0x45);
496 assertEquals(success, false, "failing weakCompareAndSetPlain byte");
497 byte x = (byte) vh.get(recv);
498 assertEquals(x, (byte)0x23, "failing weakCompareAndSetPlain byte value");
499 }
500
501 {
502 boolean success = false;
503 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
504 success = vh.weakCompareAndSetAcquire(recv, (byte)0x23, (byte)0x01);
505 if (!success) weakDelay();
506 }
507 assertEquals(success, true, "success weakCompareAndSetAcquire byte");
508 byte x = (byte) vh.get(recv);
509 assertEquals(x, (byte)0x01, "success weakCompareAndSetAcquire byte");
510 }
511
512 {
513 boolean success = vh.weakCompareAndSetAcquire(recv, (byte)0x23, (byte)0x45);
514 assertEquals(success, false, "failing weakCompareAndSetAcquire byte");
515 byte x = (byte) vh.get(recv);
516 assertEquals(x, (byte)0x01, "failing weakCompareAndSetAcquire byte value");
517 }
518
519 {
520 boolean success = false;
521 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
522 success = vh.weakCompareAndSetRelease(recv, (byte)0x01, (byte)0x23);
523 if (!success) weakDelay();
524 }
525 assertEquals(success, true, "success weakCompareAndSetRelease byte");
526 byte x = (byte) vh.get(recv);
527 assertEquals(x, (byte)0x23, "success weakCompareAndSetRelease byte");
528 }
529
530 {
531 boolean success = vh.weakCompareAndSetRelease(recv, (byte)0x01, (byte)0x45);
532 assertEquals(success, false, "failing weakCompareAndSetRelease byte");
533 byte x = (byte) vh.get(recv);
534 assertEquals(x, (byte)0x23, "failing weakCompareAndSetRelease byte value");
535 }
536
537 {
538 boolean success = false;
539 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
540 success = vh.weakCompareAndSet(recv, (byte)0x23, (byte)0x01);
541 if (!success) weakDelay();
542 }
543 assertEquals(success, true, "success weakCompareAndSet byte");
544 byte x = (byte) vh.get(recv);
545 assertEquals(x, (byte)0x01, "success weakCompareAndSet byte value");
546 }
547
548 {
549 boolean success = vh.weakCompareAndSet(recv, (byte)0x23, (byte)0x45);
550 assertEquals(success, false, "failing weakCompareAndSet byte");
551 byte x = (byte) vh.get(recv);
552 assertEquals(x, (byte)0x01, "failing weakCompareAndSet byte value");
553 }
554
555 // Compare set and get
556 {
557 vh.set(recv, (byte)0x01);
558
559 byte o = (byte) vh.getAndSet(recv, (byte)0x23);
560 assertEquals(o, (byte)0x01, "getAndSet byte");
561 byte x = (byte) vh.get(recv);
562 assertEquals(x, (byte)0x23, "getAndSet byte value");
563 }
564
565 {
566 vh.set(recv, (byte)0x01);
567
568 byte o = (byte) vh.getAndSetAcquire(recv, (byte)0x23);
569 assertEquals(o, (byte)0x01, "getAndSetAcquire byte");
570 byte x = (byte) vh.get(recv);
571 assertEquals(x, (byte)0x23, "getAndSetAcquire byte value");
572 }
573
574 {
575 vh.set(recv, (byte)0x01);
576
577 byte o = (byte) vh.getAndSetRelease(recv, (byte)0x23);
578 assertEquals(o, (byte)0x01, "getAndSetRelease byte");
579 byte x = (byte) vh.get(recv);
580 assertEquals(x, (byte)0x23, "getAndSetRelease byte value");
581 }
582
583 // get and add, add and get
584 {
585 vh.set(recv, (byte)0x01);
586
587 byte o = (byte) vh.getAndAdd(recv, (byte)0x23);
588 assertEquals(o, (byte)0x01, "getAndAdd byte");
589 byte x = (byte) vh.get(recv);
590 assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAdd byte value");
591 }
592
593 {
594 vh.set(recv, (byte)0x01);
595
596 byte o = (byte) vh.getAndAddAcquire(recv, (byte)0x23);
597 assertEquals(o, (byte)0x01, "getAndAddAcquire byte");
598 byte x = (byte) vh.get(recv);
599 assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddAcquire byte value");
600 }
601
602 {
603 vh.set(recv, (byte)0x01);
604
605 byte o = (byte) vh.getAndAddRelease(recv, (byte)0x23);
606 assertEquals(o, (byte)0x01, "getAndAddReleasebyte");
607 byte x = (byte) vh.get(recv);
608 assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddRelease byte value");
609 }
610
611 // get and bitwise or
612 {
613 vh.set(recv, (byte)0x01);
614
615 byte o = (byte) vh.getAndBitwiseOr(recv, (byte)0x23);
616 assertEquals(o, (byte)0x01, "getAndBitwiseOr byte");
617 byte x = (byte) vh.get(recv);
618 assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOr byte value");
619 }
620
621 {
622 vh.set(recv, (byte)0x01);
623
624 byte o = (byte) vh.getAndBitwiseOrAcquire(recv, (byte)0x23);
625 assertEquals(o, (byte)0x01, "getAndBitwiseOrAcquire byte");
626 byte x = (byte) vh.get(recv);
627 assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrAcquire byte value");
628 }
629
630 {
631 vh.set(recv, (byte)0x01);
632
633 byte o = (byte) vh.getAndBitwiseOrRelease(recv, (byte)0x23);
634 assertEquals(o, (byte)0x01, "getAndBitwiseOrRelease byte");
635 byte x = (byte) vh.get(recv);
636 assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrRelease byte value");
637 }
638
639 // get and bitwise and
640 {
641 vh.set(recv, (byte)0x01);
642
643 byte o = (byte) vh.getAndBitwiseAnd(recv, (byte)0x23);
644 assertEquals(o, (byte)0x01, "getAndBitwiseAnd byte");
645 byte x = (byte) vh.get(recv);
646 assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAnd byte value");
647 }
648
649 {
650 vh.set(recv, (byte)0x01);
651
652 byte o = (byte) vh.getAndBitwiseAndAcquire(recv, (byte)0x23);
653 assertEquals(o, (byte)0x01, "getAndBitwiseAndAcquire byte");
654 byte x = (byte) vh.get(recv);
655 assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndAcquire byte value");
656 }
657
658 {
659 vh.set(recv, (byte)0x01);
660
661 byte o = (byte) vh.getAndBitwiseAndRelease(recv, (byte)0x23);
662 assertEquals(o, (byte)0x01, "getAndBitwiseAndRelease byte");
663 byte x = (byte) vh.get(recv);
664 assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndRelease byte value");
665 }
666
667 // get and bitwise xor
668 {
669 vh.set(recv, (byte)0x01);
670
671 byte o = (byte) vh.getAndBitwiseXor(recv, (byte)0x23);
672 assertEquals(o, (byte)0x01, "getAndBitwiseXor byte");
673 byte x = (byte) vh.get(recv);
674 assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXor byte value");
675 }
676
677 {
678 vh.set(recv, (byte)0x01);
679
680 byte o = (byte) vh.getAndBitwiseXorAcquire(recv, (byte)0x23);
681 assertEquals(o, (byte)0x01, "getAndBitwiseXorAcquire byte");
682 byte x = (byte) vh.get(recv);
683 assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorAcquire byte value");
684 }
685
686 {
687 vh.set(recv, (byte)0x01);
688
689 byte o = (byte) vh.getAndBitwiseXorRelease(recv, (byte)0x23);
690 assertEquals(o, (byte)0x01, "getAndBitwiseXorRelease byte");
691 byte x = (byte) vh.get(recv);
692 assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorRelease byte value");
693 }
694 }
695
696 static void testInstanceFieldUnsupported(VarHandleTestAccessByte recv, VarHandle vh) {
697
698
699 }
700
701
702 static void testStaticField(VarHandle vh) {
703 // Plain
704 {
705 vh.set((byte)0x01);
706 byte x = (byte) vh.get();
707 assertEquals(x, (byte)0x01, "set byte value");
708 }
709
710
711 // Volatile
712 {
713 vh.setVolatile((byte)0x23);
714 byte x = (byte) vh.getVolatile();
715 assertEquals(x, (byte)0x23, "setVolatile byte value");
716 }
717
718 // Lazy
719 {
720 vh.setRelease((byte)0x01);
721 byte x = (byte) vh.getAcquire();
722 assertEquals(x, (byte)0x01, "setRelease byte value");
723 }
724
725 // Opaque
726 {
727 vh.setOpaque((byte)0x23);
728 byte x = (byte) vh.getOpaque();
729 assertEquals(x, (byte)0x23, "setOpaque byte value");
730 }
731
732 vh.set((byte)0x01);
733
734 // Compare
735 {
736 boolean r = vh.compareAndSet((byte)0x01, (byte)0x23);
737 assertEquals(r, true, "success compareAndSet byte");
738 byte x = (byte) vh.get();
739 assertEquals(x, (byte)0x23, "success compareAndSet byte value");
740 }
741
742 {
743 boolean r = vh.compareAndSet((byte)0x01, (byte)0x45);
744 assertEquals(r, false, "failing compareAndSet byte");
745 byte x = (byte) vh.get();
746 assertEquals(x, (byte)0x23, "failing compareAndSet byte value");
747 }
748
749 {
750 byte r = (byte) vh.compareAndExchange((byte)0x23, (byte)0x01);
751 assertEquals(r, (byte)0x23, "success compareAndExchange byte");
752 byte x = (byte) vh.get();
753 assertEquals(x, (byte)0x01, "success compareAndExchange byte value");
754 }
755
756 {
757 byte r = (byte) vh.compareAndExchange((byte)0x23, (byte)0x45);
758 assertEquals(r, (byte)0x01, "failing compareAndExchange byte");
759 byte x = (byte) vh.get();
760 assertEquals(x, (byte)0x01, "failing compareAndExchange byte value");
761 }
762
763 {
764 byte r = (byte) vh.compareAndExchangeAcquire((byte)0x01, (byte)0x23);
765 assertEquals(r, (byte)0x01, "success compareAndExchangeAcquire byte");
766 byte x = (byte) vh.get();
767 assertEquals(x, (byte)0x23, "success compareAndExchangeAcquire byte value");
768 }
769
770 {
771 byte r = (byte) vh.compareAndExchangeAcquire((byte)0x01, (byte)0x45);
772 assertEquals(r, (byte)0x23, "failing compareAndExchangeAcquire byte");
773 byte x = (byte) vh.get();
774 assertEquals(x, (byte)0x23, "failing compareAndExchangeAcquire byte value");
775 }
776
777 {
778 byte r = (byte) vh.compareAndExchangeRelease((byte)0x23, (byte)0x01);
779 assertEquals(r, (byte)0x23, "success compareAndExchangeRelease byte");
780 byte x = (byte) vh.get();
781 assertEquals(x, (byte)0x01, "success compareAndExchangeRelease byte value");
782 }
783
784 {
785 byte r = (byte) vh.compareAndExchangeRelease((byte)0x23, (byte)0x45);
786 assertEquals(r, (byte)0x01, "failing compareAndExchangeRelease byte");
787 byte x = (byte) vh.get();
788 assertEquals(x, (byte)0x01, "failing compareAndExchangeRelease byte value");
789 }
790
791 {
792 boolean success = false;
793 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
794 success = vh.weakCompareAndSetPlain((byte)0x01, (byte)0x23);
795 if (!success) weakDelay();
796 }
797 assertEquals(success, true, "success weakCompareAndSetPlain byte");
798 byte x = (byte) vh.get();
799 assertEquals(x, (byte)0x23, "success weakCompareAndSetPlain byte value");
800 }
801
802 {
803 boolean success = vh.weakCompareAndSetPlain((byte)0x01, (byte)0x45);
804 assertEquals(success, false, "failing weakCompareAndSetPlain byte");
805 byte x = (byte) vh.get();
806 assertEquals(x, (byte)0x23, "failing weakCompareAndSetPlain byte value");
807 }
808
809 {
810 boolean success = false;
811 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
812 success = vh.weakCompareAndSetAcquire((byte)0x23, (byte)0x01);
813 if (!success) weakDelay();
814 }
815 assertEquals(success, true, "success weakCompareAndSetAcquire byte");
816 byte x = (byte) vh.get();
817 assertEquals(x, (byte)0x01, "success weakCompareAndSetAcquire byte");
818 }
819
820 {
821 boolean success = vh.weakCompareAndSetAcquire((byte)0x23, (byte)0x45);
822 assertEquals(success, false, "failing weakCompareAndSetAcquire byte");
823 byte x = (byte) vh.get();
824 assertEquals(x, (byte)0x01, "failing weakCompareAndSetAcquire byte value");
825 }
826
827 {
828 boolean success = false;
829 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
830 success = vh.weakCompareAndSetRelease((byte)0x01, (byte)0x23);
831 if (!success) weakDelay();
832 }
833 assertEquals(success, true, "success weakCompareAndSetRelease byte");
834 byte x = (byte) vh.get();
835 assertEquals(x, (byte)0x23, "success weakCompareAndSetRelease byte");
836 }
837
838 {
839 boolean success = vh.weakCompareAndSetRelease((byte)0x01, (byte)0x45);
840 assertEquals(success, false, "failing weakCompareAndSetRelease byte");
841 byte x = (byte) vh.get();
842 assertEquals(x, (byte)0x23, "failing weakCompareAndSetRelease byte value");
843 }
844
845 {
846 boolean success = false;
847 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
848 success = vh.weakCompareAndSet((byte)0x23, (byte)0x01);
849 if (!success) weakDelay();
850 }
851 assertEquals(success, true, "success weakCompareAndSet byte");
852 byte x = (byte) vh.get();
853 assertEquals(x, (byte)0x01, "success weakCompareAndSet byte");
854 }
855
856 {
857 boolean success = vh.weakCompareAndSet((byte)0x23, (byte)0x45);
858 assertEquals(success, false, "failing weakCompareAndSet byte");
859 byte x = (byte) vh.get();
860 assertEquals(x, (byte)0x01, "failing weakCompareAndSet byte value");
861 }
862
863 // Compare set and get
864 {
865 vh.set((byte)0x01);
866
867 byte o = (byte) vh.getAndSet((byte)0x23);
868 assertEquals(o, (byte)0x01, "getAndSet byte");
869 byte x = (byte) vh.get();
870 assertEquals(x, (byte)0x23, "getAndSet byte value");
871 }
872
873 {
874 vh.set((byte)0x01);
875
876 byte o = (byte) vh.getAndSetAcquire((byte)0x23);
877 assertEquals(o, (byte)0x01, "getAndSetAcquire byte");
878 byte x = (byte) vh.get();
879 assertEquals(x, (byte)0x23, "getAndSetAcquire byte value");
880 }
881
882 {
883 vh.set((byte)0x01);
884
885 byte o = (byte) vh.getAndSetRelease((byte)0x23);
886 assertEquals(o, (byte)0x01, "getAndSetRelease byte");
887 byte x = (byte) vh.get();
888 assertEquals(x, (byte)0x23, "getAndSetRelease byte value");
889 }
890
891 // get and add, add and get
892 {
893 vh.set((byte)0x01);
894
895 byte o = (byte) vh.getAndAdd((byte)0x23);
896 assertEquals(o, (byte)0x01, "getAndAdd byte");
897 byte x = (byte) vh.get();
898 assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAdd byte value");
899 }
900
901 {
902 vh.set((byte)0x01);
903
904 byte o = (byte) vh.getAndAddAcquire((byte)0x23);
905 assertEquals(o, (byte)0x01, "getAndAddAcquire byte");
906 byte x = (byte) vh.get();
907 assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddAcquire byte value");
908 }
909
910 {
911 vh.set((byte)0x01);
912
913 byte o = (byte) vh.getAndAddRelease((byte)0x23);
914 assertEquals(o, (byte)0x01, "getAndAddReleasebyte");
915 byte x = (byte) vh.get();
916 assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddRelease byte value");
917 }
918
919 // get and bitwise or
920 {
921 vh.set((byte)0x01);
922
923 byte o = (byte) vh.getAndBitwiseOr((byte)0x23);
924 assertEquals(o, (byte)0x01, "getAndBitwiseOr byte");
925 byte x = (byte) vh.get();
926 assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOr byte value");
927 }
928
929 {
930 vh.set((byte)0x01);
931
932 byte o = (byte) vh.getAndBitwiseOrAcquire((byte)0x23);
933 assertEquals(o, (byte)0x01, "getAndBitwiseOrAcquire byte");
934 byte x = (byte) vh.get();
935 assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrAcquire byte value");
936 }
937
938 {
939 vh.set((byte)0x01);
940
941 byte o = (byte) vh.getAndBitwiseOrRelease((byte)0x23);
942 assertEquals(o, (byte)0x01, "getAndBitwiseOrRelease byte");
943 byte x = (byte) vh.get();
944 assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrRelease byte value");
945 }
946
947 // get and bitwise and
948 {
949 vh.set((byte)0x01);
950
951 byte o = (byte) vh.getAndBitwiseAnd((byte)0x23);
952 assertEquals(o, (byte)0x01, "getAndBitwiseAnd byte");
953 byte x = (byte) vh.get();
954 assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAnd byte value");
955 }
956
957 {
958 vh.set((byte)0x01);
959
960 byte o = (byte) vh.getAndBitwiseAndAcquire((byte)0x23);
961 assertEquals(o, (byte)0x01, "getAndBitwiseAndAcquire byte");
962 byte x = (byte) vh.get();
963 assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndAcquire byte value");
964 }
965
966 {
967 vh.set((byte)0x01);
968
969 byte o = (byte) vh.getAndBitwiseAndRelease((byte)0x23);
970 assertEquals(o, (byte)0x01, "getAndBitwiseAndRelease byte");
971 byte x = (byte) vh.get();
972 assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndRelease byte value");
973 }
974
975 // get and bitwise xor
976 {
977 vh.set((byte)0x01);
978
979 byte o = (byte) vh.getAndBitwiseXor((byte)0x23);
980 assertEquals(o, (byte)0x01, "getAndBitwiseXor byte");
981 byte x = (byte) vh.get();
982 assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXor byte value");
983 }
984
985 {
986 vh.set((byte)0x01);
987
988 byte o = (byte) vh.getAndBitwiseXorAcquire((byte)0x23);
989 assertEquals(o, (byte)0x01, "getAndBitwiseXorAcquire byte");
990 byte x = (byte) vh.get();
991 assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorAcquire byte value");
992 }
993
994 {
995 vh.set((byte)0x01);
996
997 byte o = (byte) vh.getAndBitwiseXorRelease((byte)0x23);
998 assertEquals(o, (byte)0x01, "getAndBitwiseXorRelease byte");
999 byte x = (byte) vh.get();
1000 assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorRelease byte value");
1001 }
1002 }
1003
1004 static void testStaticFieldUnsupported(VarHandle vh) {
1005
1006
1007 }
1008
1009
1010 static void testArray(VarHandle vh) {
1011 byte[] array = new byte[10];
1012
1013 for (int i = 0; i < array.length; i++) {
1014 // Plain
1015 {
1016 vh.set(array, i, (byte)0x01);
1017 byte x = (byte) vh.get(array, i);
1018 assertEquals(x, (byte)0x01, "get byte value");
1019 }
1020
1021
1022 // Volatile
1023 {
1024 vh.setVolatile(array, i, (byte)0x23);
1025 byte x = (byte) vh.getVolatile(array, i);
1026 assertEquals(x, (byte)0x23, "setVolatile byte value");
1027 }
1028
1029 // Lazy
1030 {
1031 vh.setRelease(array, i, (byte)0x01);
1032 byte x = (byte) vh.getAcquire(array, i);
1033 assertEquals(x, (byte)0x01, "setRelease byte value");
1034 }
1035
1036 // Opaque
1037 {
1038 vh.setOpaque(array, i, (byte)0x23);
1039 byte x = (byte) vh.getOpaque(array, i);
1040 assertEquals(x, (byte)0x23, "setOpaque byte value");
1041 }
1042
1043 vh.set(array, i, (byte)0x01);
1044
1045 // Compare
1046 {
1047 boolean r = vh.compareAndSet(array, i, (byte)0x01, (byte)0x23);
1048 assertEquals(r, true, "success compareAndSet byte");
1049 byte x = (byte) vh.get(array, i);
1050 assertEquals(x, (byte)0x23, "success compareAndSet byte value");
1051 }
1052
1053 {
1054 boolean r = vh.compareAndSet(array, i, (byte)0x01, (byte)0x45);
1055 assertEquals(r, false, "failing compareAndSet byte");
1056 byte x = (byte) vh.get(array, i);
1057 assertEquals(x, (byte)0x23, "failing compareAndSet byte value");
1058 }
1059
1060 {
1061 byte r = (byte) vh.compareAndExchange(array, i, (byte)0x23, (byte)0x01);
1062 assertEquals(r, (byte)0x23, "success compareAndExchange byte");
1063 byte x = (byte) vh.get(array, i);
1064 assertEquals(x, (byte)0x01, "success compareAndExchange byte value");
1065 }
1066
1067 {
1068 byte r = (byte) vh.compareAndExchange(array, i, (byte)0x23, (byte)0x45);
1069 assertEquals(r, (byte)0x01, "failing compareAndExchange byte");
1070 byte x = (byte) vh.get(array, i);
1071 assertEquals(x, (byte)0x01, "failing compareAndExchange byte value");
1072 }
1073
1074 {
1075 byte r = (byte) vh.compareAndExchangeAcquire(array, i, (byte)0x01, (byte)0x23);
1076 assertEquals(r, (byte)0x01, "success compareAndExchangeAcquire byte");
1077 byte x = (byte) vh.get(array, i);
1078 assertEquals(x, (byte)0x23, "success compareAndExchangeAcquire byte value");
1079 }
1080
1081 {
1082 byte r = (byte) vh.compareAndExchangeAcquire(array, i, (byte)0x01, (byte)0x45);
1083 assertEquals(r, (byte)0x23, "failing compareAndExchangeAcquire byte");
1084 byte x = (byte) vh.get(array, i);
1085 assertEquals(x, (byte)0x23, "failing compareAndExchangeAcquire byte value");
1086 }
1087
1088 {
1089 byte r = (byte) vh.compareAndExchangeRelease(array, i, (byte)0x23, (byte)0x01);
1090 assertEquals(r, (byte)0x23, "success compareAndExchangeRelease byte");
1091 byte x = (byte) vh.get(array, i);
1092 assertEquals(x, (byte)0x01, "success compareAndExchangeRelease byte value");
1093 }
1094
1095 {
1096 byte r = (byte) vh.compareAndExchangeRelease(array, i, (byte)0x23, (byte)0x45);
1097 assertEquals(r, (byte)0x01, "failing compareAndExchangeRelease byte");
1098 byte x = (byte) vh.get(array, i);
1099 assertEquals(x, (byte)0x01, "failing compareAndExchangeRelease byte value");
1100 }
1101
1102 {
1103 boolean success = false;
1104 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1105 success = vh.weakCompareAndSetPlain(array, i, (byte)0x01, (byte)0x23);
1106 if (!success) weakDelay();
1107 }
1108 assertEquals(success, true, "success weakCompareAndSetPlain byte");
1109 byte x = (byte) vh.get(array, i);
1110 assertEquals(x, (byte)0x23, "success weakCompareAndSetPlain byte value");
1111 }
1112
1113 {
1114 boolean success = vh.weakCompareAndSetPlain(array, i, (byte)0x01, (byte)0x45);
1115 assertEquals(success, false, "failing weakCompareAndSetPlain byte");
1116 byte x = (byte) vh.get(array, i);
1117 assertEquals(x, (byte)0x23, "failing weakCompareAndSetPlain byte value");
1118 }
1119
1120 {
1121 boolean success = false;
1122 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1123 success = vh.weakCompareAndSetAcquire(array, i, (byte)0x23, (byte)0x01);
1124 if (!success) weakDelay();
1125 }
1126 assertEquals(success, true, "success weakCompareAndSetAcquire byte");
1127 byte x = (byte) vh.get(array, i);
1128 assertEquals(x, (byte)0x01, "success weakCompareAndSetAcquire byte");
1129 }
1130
1131 {
1132 boolean success = vh.weakCompareAndSetAcquire(array, i, (byte)0x23, (byte)0x45);
1133 assertEquals(success, false, "failing weakCompareAndSetAcquire byte");
1134 byte x = (byte) vh.get(array, i);
1135 assertEquals(x, (byte)0x01, "failing weakCompareAndSetAcquire byte value");
1136 }
1137
1138 {
1139 boolean success = false;
1140 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1141 success = vh.weakCompareAndSetRelease(array, i, (byte)0x01, (byte)0x23);
1142 if (!success) weakDelay();
1143 }
1144 assertEquals(success, true, "success weakCompareAndSetRelease byte");
1145 byte x = (byte) vh.get(array, i);
1146 assertEquals(x, (byte)0x23, "success weakCompareAndSetRelease byte");
1147 }
1148
1149 {
1150 boolean success = vh.weakCompareAndSetRelease(array, i, (byte)0x01, (byte)0x45);
1151 assertEquals(success, false, "failing weakCompareAndSetRelease byte");
1152 byte x = (byte) vh.get(array, i);
1153 assertEquals(x, (byte)0x23, "failing weakCompareAndSetRelease byte value");
1154 }
1155
1156 {
1157 boolean success = false;
1158 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1159 success = vh.weakCompareAndSet(array, i, (byte)0x23, (byte)0x01);
1160 if (!success) weakDelay();
1161 }
1162 assertEquals(success, true, "success weakCompareAndSet byte");
1163 byte x = (byte) vh.get(array, i);
1164 assertEquals(x, (byte)0x01, "success weakCompareAndSet byte");
1165 }
1166
1167 {
1168 boolean success = vh.weakCompareAndSet(array, i, (byte)0x23, (byte)0x45);
1169 assertEquals(success, false, "failing weakCompareAndSet byte");
1170 byte x = (byte) vh.get(array, i);
1171 assertEquals(x, (byte)0x01, "failing weakCompareAndSet byte value");
1172 }
1173
1174 // Compare set and get
1175 {
1176 vh.set(array, i, (byte)0x01);
1177
1178 byte o = (byte) vh.getAndSet(array, i, (byte)0x23);
1179 assertEquals(o, (byte)0x01, "getAndSet byte");
1180 byte x = (byte) vh.get(array, i);
1181 assertEquals(x, (byte)0x23, "getAndSet byte value");
1182 }
1183
1184 {
1185 vh.set(array, i, (byte)0x01);
1186
1187 byte o = (byte) vh.getAndSetAcquire(array, i, (byte)0x23);
1188 assertEquals(o, (byte)0x01, "getAndSetAcquire byte");
1189 byte x = (byte) vh.get(array, i);
1190 assertEquals(x, (byte)0x23, "getAndSetAcquire byte value");
1191 }
1192
1193 {
1194 vh.set(array, i, (byte)0x01);
1195
1196 byte o = (byte) vh.getAndSetRelease(array, i, (byte)0x23);
1197 assertEquals(o, (byte)0x01, "getAndSetRelease byte");
1198 byte x = (byte) vh.get(array, i);
1199 assertEquals(x, (byte)0x23, "getAndSetRelease byte value");
1200 }
1201
1202 // get and add, add and get
1203 {
1204 vh.set(array, i, (byte)0x01);
1205
1206 byte o = (byte) vh.getAndAdd(array, i, (byte)0x23);
1207 assertEquals(o, (byte)0x01, "getAndAdd byte");
1208 byte x = (byte) vh.get(array, i);
1209 assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAdd byte value");
1210 }
1211
1212 {
1213 vh.set(array, i, (byte)0x01);
1214
1215 byte o = (byte) vh.getAndAddAcquire(array, i, (byte)0x23);
1216 assertEquals(o, (byte)0x01, "getAndAddAcquire byte");
1217 byte x = (byte) vh.get(array, i);
1218 assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddAcquire byte value");
1219 }
1220
1221 {
1222 vh.set(array, i, (byte)0x01);
1223
1224 byte o = (byte) vh.getAndAddRelease(array, i, (byte)0x23);
1225 assertEquals(o, (byte)0x01, "getAndAddReleasebyte");
1226 byte x = (byte) vh.get(array, i);
1227 assertEquals(x, (byte)((byte)0x01 + (byte)0x23), "getAndAddRelease byte value");
1228 }
1229
1230 // get and bitwise or
1231 {
1232 vh.set(array, i, (byte)0x01);
1233
1234 byte o = (byte) vh.getAndBitwiseOr(array, i, (byte)0x23);
1235 assertEquals(o, (byte)0x01, "getAndBitwiseOr byte");
1236 byte x = (byte) vh.get(array, i);
1237 assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOr byte value");
1238 }
1239
1240 {
1241 vh.set(array, i, (byte)0x01);
1242
1243 byte o = (byte) vh.getAndBitwiseOrAcquire(array, i, (byte)0x23);
1244 assertEquals(o, (byte)0x01, "getAndBitwiseOrAcquire byte");
1245 byte x = (byte) vh.get(array, i);
1246 assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrAcquire byte value");
1247 }
1248
1249 {
1250 vh.set(array, i, (byte)0x01);
1251
1252 byte o = (byte) vh.getAndBitwiseOrRelease(array, i, (byte)0x23);
1253 assertEquals(o, (byte)0x01, "getAndBitwiseOrRelease byte");
1254 byte x = (byte) vh.get(array, i);
1255 assertEquals(x, (byte)((byte)0x01 | (byte)0x23), "getAndBitwiseOrRelease byte value");
1256 }
1257
1258 // get and bitwise and
1259 {
1260 vh.set(array, i, (byte)0x01);
1261
1262 byte o = (byte) vh.getAndBitwiseAnd(array, i, (byte)0x23);
1263 assertEquals(o, (byte)0x01, "getAndBitwiseAnd byte");
1264 byte x = (byte) vh.get(array, i);
1265 assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAnd byte value");
1266 }
1267
1268 {
1269 vh.set(array, i, (byte)0x01);
1270
1271 byte o = (byte) vh.getAndBitwiseAndAcquire(array, i, (byte)0x23);
1272 assertEquals(o, (byte)0x01, "getAndBitwiseAndAcquire byte");
1273 byte x = (byte) vh.get(array, i);
1274 assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndAcquire byte value");
1275 }
1276
1277 {
1278 vh.set(array, i, (byte)0x01);
1279
1280 byte o = (byte) vh.getAndBitwiseAndRelease(array, i, (byte)0x23);
1281 assertEquals(o, (byte)0x01, "getAndBitwiseAndRelease byte");
1282 byte x = (byte) vh.get(array, i);
1283 assertEquals(x, (byte)((byte)0x01 & (byte)0x23), "getAndBitwiseAndRelease byte value");
1284 }
1285
1286 // get and bitwise xor
1287 {
1288 vh.set(array, i, (byte)0x01);
1289
1290 byte o = (byte) vh.getAndBitwiseXor(array, i, (byte)0x23);
1291 assertEquals(o, (byte)0x01, "getAndBitwiseXor byte");
1292 byte x = (byte) vh.get(array, i);
1293 assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXor byte value");
1294 }
1295
1296 {
1297 vh.set(array, i, (byte)0x01);
1298
1299 byte o = (byte) vh.getAndBitwiseXorAcquire(array, i, (byte)0x23);
1300 assertEquals(o, (byte)0x01, "getAndBitwiseXorAcquire byte");
1301 byte x = (byte) vh.get(array, i);
1302 assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorAcquire byte value");
1303 }
1304
1305 {
1306 vh.set(array, i, (byte)0x01);
1307
1308 byte o = (byte) vh.getAndBitwiseXorRelease(array, i, (byte)0x23);
1309 assertEquals(o, (byte)0x01, "getAndBitwiseXorRelease byte");
1310 byte x = (byte) vh.get(array, i);
1311 assertEquals(x, (byte)((byte)0x01 ^ (byte)0x23), "getAndBitwiseXorRelease byte value");
1312 }
1313 }
1314 }
1315
1316 static void testArrayUnsupported(VarHandle vh) {
1317 byte[] array = new byte[10];
1318
1319 int i = 0;
1320
1321
1322 }
1323
1324 static void testArrayIndexOutOfBounds(VarHandle vh) throws Throwable {
1325 byte[] array = new byte[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 byte x = (byte) vh.get(array, ci);
1332 });
1333
1334 checkAIOOBE(() -> {
1335 vh.set(array, ci, (byte)0x01);
1336 });
1337
1338 checkAIOOBE(() -> {
1339 byte x = (byte) vh.getVolatile(array, ci);
1340 });
1341
1342 checkAIOOBE(() -> {
1343 vh.setVolatile(array, ci, (byte)0x01);
1344 });
1345
1346 checkAIOOBE(() -> {
1347 byte x = (byte) vh.getAcquire(array, ci);
1348 });
1349
1350 checkAIOOBE(() -> {
1351 vh.setRelease(array, ci, (byte)0x01);
1352 });
1353
1354 checkAIOOBE(() -> {
1355 byte x = (byte) vh.getOpaque(array, ci);
1356 });
1357
1358 checkAIOOBE(() -> {
1359 vh.setOpaque(array, ci, (byte)0x01);
1360 });
1361
1362 checkAIOOBE(() -> {
1363 boolean r = vh.compareAndSet(array, ci, (byte)0x01, (byte)0x23);
1364 });
1365
1366 checkAIOOBE(() -> {
1367 byte r = (byte) vh.compareAndExchange(array, ci, (byte)0x23, (byte)0x01);
1368 });
1369
1370 checkAIOOBE(() -> {
1371 byte r = (byte) vh.compareAndExchangeAcquire(array, ci, (byte)0x23, (byte)0x01);
1372 });
1373
1374 checkAIOOBE(() -> {
1375 byte r = (byte) vh.compareAndExchangeRelease(array, ci, (byte)0x23, (byte)0x01);
1376 });
1377
1378 checkAIOOBE(() -> {
1379 boolean r = vh.weakCompareAndSetPlain(array, ci, (byte)0x01, (byte)0x23);
1380 });
1381
1382 checkAIOOBE(() -> {
1383 boolean r = vh.weakCompareAndSet(array, ci, (byte)0x01, (byte)0x23);
1384 });
1385
1386 checkAIOOBE(() -> {
1387 boolean r = vh.weakCompareAndSetAcquire(array, ci, (byte)0x01, (byte)0x23);
1388 });
1389
1390 checkAIOOBE(() -> {
1391 boolean r = vh.weakCompareAndSetRelease(array, ci, (byte)0x01, (byte)0x23);
1392 });
1393
1394 checkAIOOBE(() -> {
1395 byte o = (byte) vh.getAndSet(array, ci, (byte)0x01);
1396 });
1397
1398 checkAIOOBE(() -> {
1399 byte o = (byte) vh.getAndSetAcquire(array, ci, (byte)0x01);
1400 });
1401
1402 checkAIOOBE(() -> {
1403 byte o = (byte) vh.getAndSetRelease(array, ci, (byte)0x01);
1404 });
1405
1406 checkAIOOBE(() -> {
1407 byte o = (byte) vh.getAndAdd(array, ci, (byte)0x01);
1408 });
1409
1410 checkAIOOBE(() -> {
1411 byte o = (byte) vh.getAndAddAcquire(array, ci, (byte)0x01);
1412 });
1413
1414 checkAIOOBE(() -> {
1415 byte o = (byte) vh.getAndAddRelease(array, ci, (byte)0x01);
1416 });
1417
1418 checkAIOOBE(() -> {
1419 byte o = (byte) vh.getAndBitwiseOr(array, ci, (byte)0x01);
1420 });
1421
1422 checkAIOOBE(() -> {
1423 byte o = (byte) vh.getAndBitwiseOrAcquire(array, ci, (byte)0x01);
1424 });
1425
1426 checkAIOOBE(() -> {
1427 byte o = (byte) vh.getAndBitwiseOrRelease(array, ci, (byte)0x01);
1428 });
1429
1430 checkAIOOBE(() -> {
1431 byte o = (byte) vh.getAndBitwiseAnd(array, ci, (byte)0x01);
1432 });
1433
1434 checkAIOOBE(() -> {
1435 byte o = (byte) vh.getAndBitwiseAndAcquire(array, ci, (byte)0x01);
1436 });
1437
1438 checkAIOOBE(() -> {
1439 byte o = (byte) vh.getAndBitwiseAndRelease(array, ci, (byte)0x01);
1440 });
1441
1442 checkAIOOBE(() -> {
1443 byte o = (byte) vh.getAndBitwiseXor(array, ci, (byte)0x01);
1444 });
1445
1446 checkAIOOBE(() -> {
1447 byte o = (byte) vh.getAndBitwiseXorAcquire(array, ci, (byte)0x01);
1448 });
1449
1450 checkAIOOBE(() -> {
1451 byte o = (byte) vh.getAndBitwiseXorRelease(array, ci, (byte)0x01);
1452 });
1453 }
1454 }
1455
1456 }
1457