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