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