1 /*
2 * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /*
25 * @test
26 * @comment Set CompileThresholdScaling to 0.1 so that the warmup loop sets to 2000 iterations
27 * to hit compilation thresholds
28 * @run junit/othervm -Diters=2000 -XX:CompileThresholdScaling=0.1 VarHandleTestMethodHandleAccessChar
29 */
30
31 import java.lang.invoke.MethodHandle;
32 import java.lang.invoke.MethodHandles;
33 import java.lang.invoke.VarHandle;
34 import java.util.ArrayList;
35 import java.util.List;
36
37 import static org.junit.jupiter.api.Assertions.*;
38 import org.junit.jupiter.api.BeforeAll;
39 import org.junit.jupiter.api.TestInstance;
40 import org.junit.jupiter.params.ParameterizedTest;
41 import org.junit.jupiter.params.provider.MethodSource;
42
43 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
44 public class VarHandleTestMethodHandleAccessChar extends VarHandleBaseTest {
45 static final char static_final_v = '\u0123';
46
47 static char static_v;
48
49 final char final_v = '\u0123';
50
51 char v;
52
53 VarHandle vhFinalField;
54
55 VarHandle vhField;
56
57 VarHandle vhStaticField;
58
59 VarHandle vhStaticFinalField;
60
61 VarHandle vhArray;
62
63 @BeforeAll
64 public void setup() throws Exception {
65 vhFinalField = MethodHandles.lookup().findVarHandle(
66 VarHandleTestMethodHandleAccessChar.class, "final_v", char.class);
67
68 vhField = MethodHandles.lookup().findVarHandle(
69 VarHandleTestMethodHandleAccessChar.class, "v", char.class);
70
71 vhStaticFinalField = MethodHandles.lookup().findStaticVarHandle(
72 VarHandleTestMethodHandleAccessChar.class, "static_final_v", char.class);
73
74 vhStaticField = MethodHandles.lookup().findStaticVarHandle(
75 VarHandleTestMethodHandleAccessChar.class, "static_v", char.class);
76
77 vhArray = MethodHandles.arrayElementVarHandle(char[].class);
78 }
79
80 public Object[][] accessTestCaseProvider() throws Exception {
81 List<AccessTestCase<?>> cases = new ArrayList<>();
82
83 for (VarHandleToMethodHandle f : VarHandleToMethodHandle.values()) {
84 cases.add(new MethodHandleAccessTestCase("Instance field",
85 vhField, f, hs -> testInstanceField(this, hs)));
86 cases.add(new MethodHandleAccessTestCase("Instance field unsupported",
87 vhField, f, hs -> testInstanceFieldUnsupported(this, hs),
88 false));
89
90 cases.add(new MethodHandleAccessTestCase("Static field",
91 vhStaticField, f, VarHandleTestMethodHandleAccessChar::testStaticField));
92 cases.add(new MethodHandleAccessTestCase("Static field unsupported",
93 vhStaticField, f, VarHandleTestMethodHandleAccessChar::testStaticFieldUnsupported,
94 false));
95
96 cases.add(new MethodHandleAccessTestCase("Array",
97 vhArray, f, VarHandleTestMethodHandleAccessChar::testArray));
98 cases.add(new MethodHandleAccessTestCase("Array unsupported",
99 vhArray, f, VarHandleTestMethodHandleAccessChar::testArrayUnsupported,
100 false));
101 cases.add(new MethodHandleAccessTestCase("Array index out of bounds",
102 vhArray, f, VarHandleTestMethodHandleAccessChar::testArrayIndexOutOfBounds,
103 false));
104 }
105
106 // Work around issue with jtreg summary reporting which truncates
107 // the String result of Object.toString to 30 characters, hence
108 // the first dummy argument
109 return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new);
110 }
111
112 @ParameterizedTest
113 @MethodSource("accessTestCaseProvider")
114 public <T> void testAccess(String desc, AccessTestCase<T> atc) throws Throwable {
115 T t = atc.get();
116 int iters = atc.requiresLoop() ? ITERS : 1;
117 for (int c = 0; c < iters; c++) {
118 atc.testAccess(t);
119 }
120 }
121
122 static void testInstanceField(VarHandleTestMethodHandleAccessChar recv, Handles hs) throws Throwable {
123 // Plain
124 {
125 hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123');
126 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
127 assertEquals('\u0123', x, "set char value");
128 }
129
130
131 // Volatile
132 {
133 hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, '\u4567');
134 char x = (char) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv);
135 assertEquals('\u4567', x, "setVolatile char value");
136 }
137
138 // Lazy
139 {
140 hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, '\u0123');
141 char x = (char) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv);
142 assertEquals('\u0123', x, "setRelease char value");
143 }
144
145 // Opaque
146 {
147 hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, '\u4567');
148 char x = (char) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv);
149 assertEquals('\u4567', x, "setOpaque char value");
150 }
151
152 hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123');
153
154 // Compare
155 {
156 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, '\u0123', '\u4567');
157 assertEquals(r, true, "success compareAndSet char");
158 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
159 assertEquals('\u4567', x, "success compareAndSet char value");
160 }
161
162 {
163 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, '\u0123', '\u89AB');
164 assertEquals(r, false, "failing compareAndSet char");
165 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
166 assertEquals('\u4567', x, "failing compareAndSet char value");
167 }
168
169 {
170 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, '\u4567', '\u0123');
171 assertEquals(r, '\u4567', "success compareAndExchange char");
172 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
173 assertEquals('\u0123', x, "success compareAndExchange char value");
174 }
175
176 {
177 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, '\u4567', '\u89AB');
178 assertEquals(r, '\u0123', "failing compareAndExchange char");
179 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
180 assertEquals('\u0123', x, "failing compareAndExchange char value");
181 }
182
183 {
184 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, '\u0123', '\u4567');
185 assertEquals(r, '\u0123', "success compareAndExchangeAcquire char");
186 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
187 assertEquals('\u4567', x, "success compareAndExchangeAcquire char value");
188 }
189
190 {
191 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, '\u0123', '\u89AB');
192 assertEquals(r, '\u4567', "failing compareAndExchangeAcquire char");
193 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
194 assertEquals('\u4567', x, "failing compareAndExchangeAcquire char value");
195 }
196
197 {
198 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, '\u4567', '\u0123');
199 assertEquals(r, '\u4567', "success compareAndExchangeRelease char");
200 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
201 assertEquals('\u0123', x, "success compareAndExchangeRelease char value");
202 }
203
204 {
205 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, '\u4567', '\u89AB');
206 assertEquals(r, '\u0123', "failing compareAndExchangeRelease char");
207 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
208 assertEquals('\u0123', x, "failing compareAndExchangeRelease char value");
209 }
210
211 {
212 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN);
213 boolean success = false;
214 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
215 success = (boolean) mh.invokeExact(recv, '\u0123', '\u4567');
216 if (!success) weakDelay();
217 }
218 assertEquals(success, true, "success weakCompareAndSetPlain char");
219 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
220 assertEquals('\u4567', x, "success weakCompareAndSetPlain char value");
221 }
222
223 {
224 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, '\u0123', '\u89AB');
225 assertEquals(success, false, "failing weakCompareAndSetPlain char");
226 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
227 assertEquals('\u4567', x, "failing weakCompareAndSetPlain char value");
228 }
229
230 {
231 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE);
232 boolean success = false;
233 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
234 success = (boolean) mh.invokeExact(recv, '\u4567', '\u0123');
235 if (!success) weakDelay();
236 }
237 assertEquals(success, true, "success weakCompareAndSetAcquire char");
238 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
239 assertEquals('\u0123', x, "success weakCompareAndSetAcquire char");
240 }
241
242 {
243 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, '\u4567', '\u89AB');
244 assertEquals(success, false, "failing weakCompareAndSetAcquire char");
245 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
246 assertEquals('\u0123', x, "failing weakCompareAndSetAcquire char value");
247 }
248
249 {
250 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE);
251 boolean success = false;
252 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
253 success = (boolean) mh.invokeExact(recv, '\u0123', '\u4567');
254 if (!success) weakDelay();
255 }
256 assertEquals(success, true, "success weakCompareAndSetRelease char");
257 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
258 assertEquals('\u4567', x, "success weakCompareAndSetRelease char");
259 }
260
261 {
262 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, '\u0123', '\u89AB');
263 assertEquals(success, false, "failing weakCompareAndSetRelease char");
264 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
265 assertEquals('\u4567', x, "failing weakCompareAndSetRelease char value");
266 }
267
268 {
269 boolean success = false;
270 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET);
271 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
272 success = (boolean) mh.invokeExact(recv, '\u4567', '\u0123');
273 if (!success) weakDelay();
274 }
275 assertEquals(success, true, "success weakCompareAndSet char");
276 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
277 assertEquals('\u0123', x, "success weakCompareAndSet char");
278 }
279
280 {
281 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, '\u4567', '\u89AB');
282 assertEquals(success, false, "failing weakCompareAndSet char");
283 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
284 assertEquals('\u0123', x, "failing weakCompareAndSet char value");
285 }
286
287 // Compare set and get
288 {
289 char o = (char) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, '\u4567');
290 assertEquals('\u0123', o, "getAndSet char");
291 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
292 assertEquals('\u4567', x, "getAndSet char value");
293 }
294
295 // get and add, add and get
296 {
297 hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123');
298
299 char o = (char) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(recv, '\u4567');
300 assertEquals('\u0123', o, "getAndAdd char");
301 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
302 assertEquals((char)('\u0123' + '\u4567'), x, "getAndAdd char value");
303 }
304
305 {
306 hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123');
307
308 char o = (char) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(recv, '\u4567');
309 assertEquals('\u0123', o, "getAndAddAcquire char");
310 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
311 assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddAcquire char value");
312 }
313
314 {
315 hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123');
316
317 char o = (char) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(recv, '\u4567');
318 assertEquals('\u0123', o, "getAndAddRelease char");
319 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
320 assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddRelease char value");
321 }
322
323 // get and bitwise or
324 {
325 hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123');
326
327 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(recv, '\u4567');
328 assertEquals('\u0123', o, "getAndBitwiseOr char");
329 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
330 assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOr char value");
331 }
332
333 {
334 hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123');
335
336 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(recv, '\u4567');
337 assertEquals('\u0123', o, "getAndBitwiseOrAcquire char");
338 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
339 assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrAcquire char value");
340 }
341
342 {
343 hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123');
344
345 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(recv, '\u4567');
346 assertEquals('\u0123', o, "getAndBitwiseOrRelease char");
347 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
348 assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrRelease char value");
349 }
350
351 // get and bitwise and
352 {
353 hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123');
354
355 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(recv, '\u4567');
356 assertEquals('\u0123', o, "getAndBitwiseAnd char");
357 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
358 assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAnd char value");
359 }
360
361 {
362 hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123');
363
364 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(recv, '\u4567');
365 assertEquals('\u0123', o, "getAndBitwiseAndAcquire char");
366 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
367 assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndAcquire char value");
368 }
369
370 {
371 hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123');
372
373 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(recv, '\u4567');
374 assertEquals('\u0123', o, "getAndBitwiseAndRelease char");
375 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
376 assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndRelease char value");
377 }
378
379 // get and bitwise xor
380 {
381 hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123');
382
383 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(recv, '\u4567');
384 assertEquals('\u0123', o, "getAndBitwiseXor char");
385 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
386 assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXor char value");
387 }
388
389 {
390 hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123');
391
392 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(recv, '\u4567');
393 assertEquals('\u0123', o, "getAndBitwiseXorAcquire char");
394 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
395 assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorAcquire char value");
396 }
397
398 {
399 hs.get(TestAccessMode.SET).invokeExact(recv, '\u0123');
400
401 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(recv, '\u4567');
402 assertEquals('\u0123', o, "getAndBitwiseXorRelease char");
403 char x = (char) hs.get(TestAccessMode.GET).invokeExact(recv);
404 assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorRelease char value");
405 }
406 }
407
408 static void testInstanceFieldUnsupported(VarHandleTestMethodHandleAccessChar recv, Handles hs) throws Throwable {
409
410
411 }
412
413
414 static void testStaticField(Handles hs) throws Throwable {
415 // Plain
416 {
417 hs.get(TestAccessMode.SET).invokeExact('\u0123');
418 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
419 assertEquals('\u0123', x, "set char value");
420 }
421
422
423 // Volatile
424 {
425 hs.get(TestAccessMode.SET_VOLATILE).invokeExact('\u4567');
426 char x = (char) hs.get(TestAccessMode.GET_VOLATILE).invokeExact();
427 assertEquals('\u4567', x, "setVolatile char value");
428 }
429
430 // Lazy
431 {
432 hs.get(TestAccessMode.SET_RELEASE).invokeExact('\u0123');
433 char x = (char) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact();
434 assertEquals('\u0123', x, "setRelease char value");
435 }
436
437 // Opaque
438 {
439 hs.get(TestAccessMode.SET_OPAQUE).invokeExact('\u4567');
440 char x = (char) hs.get(TestAccessMode.GET_OPAQUE).invokeExact();
441 assertEquals('\u4567', x, "setOpaque char value");
442 }
443
444 hs.get(TestAccessMode.SET).invokeExact('\u0123');
445
446 // Compare
447 {
448 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact('\u0123', '\u4567');
449 assertEquals(r, true, "success compareAndSet char");
450 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
451 assertEquals('\u4567', x, "success compareAndSet char value");
452 }
453
454 {
455 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact('\u0123', '\u89AB');
456 assertEquals(r, false, "failing compareAndSet char");
457 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
458 assertEquals('\u4567', x, "failing compareAndSet char value");
459 }
460
461 {
462 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact('\u4567', '\u0123');
463 assertEquals(r, '\u4567', "success compareAndExchange char");
464 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
465 assertEquals('\u0123', x, "success compareAndExchange char value");
466 }
467
468 {
469 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact('\u4567', '\u89AB');
470 assertEquals(r, '\u0123', "failing compareAndExchange char");
471 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
472 assertEquals('\u0123', x, "failing compareAndExchange char value");
473 }
474
475 {
476 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact('\u0123', '\u4567');
477 assertEquals(r, '\u0123', "success compareAndExchangeAcquire char");
478 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
479 assertEquals('\u4567', x, "success compareAndExchangeAcquire char value");
480 }
481
482 {
483 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact('\u0123', '\u89AB');
484 assertEquals(r, '\u4567', "failing compareAndExchangeAcquire char");
485 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
486 assertEquals('\u4567', x, "failing compareAndExchangeAcquire char value");
487 }
488
489 {
490 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact('\u4567', '\u0123');
491 assertEquals(r, '\u4567', "success compareAndExchangeRelease char");
492 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
493 assertEquals('\u0123', x, "success compareAndExchangeRelease char value");
494 }
495
496 {
497 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact('\u4567', '\u89AB');
498 assertEquals(r, '\u0123', "failing compareAndExchangeRelease char");
499 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
500 assertEquals('\u0123', x, "failing compareAndExchangeRelease char value");
501 }
502
503 {
504 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN);
505 boolean success = false;
506 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
507 success = (boolean) mh.invokeExact('\u0123', '\u4567');
508 if (!success) weakDelay();
509 }
510 assertEquals(success, true, "success weakCompareAndSetPlain char");
511 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
512 assertEquals('\u4567', x, "success weakCompareAndSetPlain char value");
513 }
514
515 {
516 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact('\u0123', '\u89AB');
517 assertEquals(success, false, "failing weakCompareAndSetPlain char");
518 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
519 assertEquals('\u4567', x, "failing weakCompareAndSetPlain char value");
520 }
521
522 {
523 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE);
524 boolean success = false;
525 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
526 success = (boolean) mh.invokeExact('\u4567', '\u0123');
527 if (!success) weakDelay();
528 }
529 assertEquals(success, true, "success weakCompareAndSetAcquire char");
530 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
531 assertEquals('\u0123', x, "success weakCompareAndSetAcquire char");
532 }
533
534 {
535 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE);
536 boolean success = (boolean) mh.invokeExact('\u4567', '\u89AB');
537 assertEquals(success, false, "failing weakCompareAndSetAcquire char");
538 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
539 assertEquals('\u0123', x, "failing weakCompareAndSetAcquire char value");
540 }
541
542 {
543 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE);
544 boolean success = false;
545 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
546 success = (boolean) mh.invokeExact('\u0123', '\u4567');
547 if (!success) weakDelay();
548 }
549 assertEquals(success, true, "success weakCompareAndSetRelease char");
550 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
551 assertEquals('\u4567', x, "success weakCompareAndSetRelease char");
552 }
553
554 {
555 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact('\u0123', '\u89AB');
556 assertEquals(success, false, "failing weakCompareAndSetRelease char");
557 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
558 assertEquals('\u4567', x, "failing weakCompareAndSetRelease char value");
559 }
560
561 {
562 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET);
563 boolean success = false;
564 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
565 success = (boolean) mh.invokeExact('\u4567', '\u0123');
566 if (!success) weakDelay();
567 }
568 assertEquals(success, true, "success weakCompareAndSet char");
569 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
570 assertEquals('\u0123', x, "success weakCompareAndSet char");
571 }
572
573 {
574 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact('\u4567', '\u89AB');
575 assertEquals(success, false, "failing weakCompareAndSet char");
576 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
577 assertEquals('\u0123', x, "failing weakCompareAndSetRe char value");
578 }
579
580 // Compare set and get
581 {
582 hs.get(TestAccessMode.SET).invokeExact('\u0123');
583
584 char o = (char) hs.get(TestAccessMode.GET_AND_SET).invokeExact('\u4567');
585 assertEquals('\u0123', o, "getAndSet char");
586 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
587 assertEquals('\u4567', x, "getAndSet char value");
588 }
589
590 // Compare set and get
591 {
592 hs.get(TestAccessMode.SET).invokeExact('\u0123');
593
594 char o = (char) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact('\u4567');
595 assertEquals('\u0123', o, "getAndSetAcquire char");
596 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
597 assertEquals('\u4567', x, "getAndSetAcquire char value");
598 }
599
600 // Compare set and get
601 {
602 hs.get(TestAccessMode.SET).invokeExact('\u0123');
603
604 char o = (char) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact('\u4567');
605 assertEquals('\u0123', o, "getAndSetRelease char");
606 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
607 assertEquals('\u4567', x, "getAndSetRelease char value");
608 }
609
610 // get and add, add and get
611 {
612 hs.get(TestAccessMode.SET).invokeExact('\u0123');
613
614 char o = (char) hs.get(TestAccessMode.GET_AND_ADD).invokeExact('\u4567');
615 assertEquals('\u0123', o, "getAndAdd char");
616 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
617 assertEquals((char)('\u0123' + '\u4567'), x, "getAndAdd char value");
618 }
619
620 {
621 hs.get(TestAccessMode.SET).invokeExact('\u0123');
622
623 char o = (char) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact('\u4567');
624 assertEquals('\u0123', o, "getAndAddAcquire char");
625 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
626 assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddAcquire char value");
627 }
628
629 {
630 hs.get(TestAccessMode.SET).invokeExact('\u0123');
631
632 char o = (char) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact('\u4567');
633 assertEquals('\u0123', o, "getAndAddRelease char");
634 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
635 assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddRelease char value");
636 }
637
638 // get and bitwise or
639 {
640 hs.get(TestAccessMode.SET).invokeExact('\u0123');
641
642 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact('\u4567');
643 assertEquals('\u0123', o, "getAndBitwiseOr char");
644 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
645 assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOr char value");
646 }
647
648 {
649 hs.get(TestAccessMode.SET).invokeExact('\u0123');
650
651 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact('\u4567');
652 assertEquals('\u0123', o, "getAndBitwiseOrAcquire char");
653 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
654 assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrAcquire char value");
655 }
656
657 {
658 hs.get(TestAccessMode.SET).invokeExact('\u0123');
659
660 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact('\u4567');
661 assertEquals('\u0123', o, "getAndBitwiseOrRelease char");
662 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
663 assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrRelease char value");
664 }
665
666 // get and bitwise and
667 {
668 hs.get(TestAccessMode.SET).invokeExact('\u0123');
669
670 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact('\u4567');
671 assertEquals('\u0123', o, "getAndBitwiseAnd char");
672 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
673 assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAnd char value");
674 }
675
676 {
677 hs.get(TestAccessMode.SET).invokeExact('\u0123');
678
679 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact('\u4567');
680 assertEquals('\u0123', o, "getAndBitwiseAndAcquire char");
681 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
682 assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndAcquire char value");
683 }
684
685 {
686 hs.get(TestAccessMode.SET).invokeExact('\u0123');
687
688 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact('\u4567');
689 assertEquals('\u0123', o, "getAndBitwiseAndRelease char");
690 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
691 assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndRelease char value");
692 }
693
694 // get and bitwise xor
695 {
696 hs.get(TestAccessMode.SET).invokeExact('\u0123');
697
698 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact('\u4567');
699 assertEquals('\u0123', o, "getAndBitwiseXor char");
700 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
701 assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXor char value");
702 }
703
704 {
705 hs.get(TestAccessMode.SET).invokeExact('\u0123');
706
707 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact('\u4567');
708 assertEquals('\u0123', o, "getAndBitwiseXorAcquire char");
709 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
710 assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorAcquire char value");
711 }
712
713 {
714 hs.get(TestAccessMode.SET).invokeExact('\u0123');
715
716 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact('\u4567');
717 assertEquals('\u0123', o, "getAndBitwiseXorRelease char");
718 char x = (char) hs.get(TestAccessMode.GET).invokeExact();
719 assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorRelease char value");
720 }
721 }
722
723 static void testStaticFieldUnsupported(Handles hs) throws Throwable {
724
725
726 }
727
728
729 static void testArray(Handles hs) throws Throwable {
730 char[] array = new char[10];
731
732 for (int i = 0; i < array.length; i++) {
733 // Plain
734 {
735 hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123');
736 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
737 assertEquals('\u0123', x, "get char value");
738 }
739
740
741 // Volatile
742 {
743 hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, '\u4567');
744 char x = (char) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i);
745 assertEquals('\u4567', x, "setVolatile char value");
746 }
747
748 // Lazy
749 {
750 hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, '\u0123');
751 char x = (char) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i);
752 assertEquals('\u0123', x, "setRelease char value");
753 }
754
755 // Opaque
756 {
757 hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, '\u4567');
758 char x = (char) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i);
759 assertEquals('\u4567', x, "setOpaque char value");
760 }
761
762 hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123');
763
764 // Compare
765 {
766 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, '\u0123', '\u4567');
767 assertEquals(r, true, "success compareAndSet char");
768 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
769 assertEquals('\u4567', x, "success compareAndSet char value");
770 }
771
772 {
773 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, '\u0123', '\u89AB');
774 assertEquals(r, false, "failing compareAndSet char");
775 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
776 assertEquals('\u4567', x, "failing compareAndSet char value");
777 }
778
779 {
780 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, '\u4567', '\u0123');
781 assertEquals(r, '\u4567', "success compareAndExchange char");
782 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
783 assertEquals('\u0123', x, "success compareAndExchange char value");
784 }
785
786 {
787 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, '\u4567', '\u89AB');
788 assertEquals(r, '\u0123', "failing compareAndExchange char");
789 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
790 assertEquals('\u0123', x, "failing compareAndExchange char value");
791 }
792
793 {
794 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, '\u0123', '\u4567');
795 assertEquals(r, '\u0123', "success compareAndExchangeAcquire char");
796 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
797 assertEquals('\u4567', x, "success compareAndExchangeAcquire char value");
798 }
799
800 {
801 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, '\u0123', '\u89AB');
802 assertEquals(r, '\u4567', "failing compareAndExchangeAcquire char");
803 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
804 assertEquals('\u4567', x, "failing compareAndExchangeAcquire char value");
805 }
806
807 {
808 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, '\u4567', '\u0123');
809 assertEquals(r, '\u4567', "success compareAndExchangeRelease char");
810 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
811 assertEquals('\u0123', x, "success compareAndExchangeRelease char value");
812 }
813
814 {
815 char r = (char) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, '\u4567', '\u89AB');
816 assertEquals(r, '\u0123', "failing compareAndExchangeRelease char");
817 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
818 assertEquals('\u0123', x, "failing compareAndExchangeRelease char value");
819 }
820
821 {
822 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN);
823 boolean success = false;
824 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
825 success = (boolean) mh.invokeExact(array, i, '\u0123', '\u4567');
826 if (!success) weakDelay();
827 }
828 assertEquals(success, true, "success weakCompareAndSetPlain char");
829 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
830 assertEquals('\u4567', x, "success weakCompareAndSetPlain char value");
831 }
832
833 {
834 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, '\u0123', '\u89AB');
835 assertEquals(success, false, "failing weakCompareAndSetPlain char");
836 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
837 assertEquals('\u4567', x, "failing weakCompareAndSetPlain char value");
838 }
839
840 {
841 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE);
842 boolean success = false;
843 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
844 success = (boolean) mh.invokeExact(array, i, '\u4567', '\u0123');
845 if (!success) weakDelay();
846 }
847 assertEquals(success, true, "success weakCompareAndSetAcquire char");
848 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
849 assertEquals('\u0123', x, "success weakCompareAndSetAcquire char");
850 }
851
852 {
853 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, '\u4567', '\u89AB');
854 assertEquals(success, false, "failing weakCompareAndSetAcquire char");
855 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
856 assertEquals('\u0123', x, "failing weakCompareAndSetAcquire char value");
857 }
858
859 {
860 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE);
861 boolean success = false;
862 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
863 success = (boolean) mh.invokeExact(array, i, '\u0123', '\u4567');
864 if (!success) weakDelay();
865 }
866 assertEquals(success, true, "success weakCompareAndSetRelease char");
867 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
868 assertEquals('\u4567', x, "success weakCompareAndSetRelease char");
869 }
870
871 {
872 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, '\u0123', '\u89AB');
873 assertEquals(success, false, "failing weakCompareAndSetAcquire char");
874 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
875 assertEquals('\u4567', x, "failing weakCompareAndSetAcquire char value");
876 }
877
878 {
879 MethodHandle mh = hs.get(TestAccessMode.WEAK_COMPARE_AND_SET);
880 boolean success = false;
881 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
882 success = (boolean) mh.invokeExact(array, i, '\u4567', '\u0123');
883 if (!success) weakDelay();
884 }
885 assertEquals(success, true, "success weakCompareAndSet char");
886 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
887 assertEquals('\u0123', x, "success weakCompareAndSet char");
888 }
889
890 {
891 boolean success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, '\u4567', '\u89AB');
892 assertEquals(success, false, "failing weakCompareAndSet char");
893 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
894 assertEquals('\u0123', x, "failing weakCompareAndSet char value");
895 }
896
897 // Compare set and get
898 {
899 hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123');
900
901 char o = (char) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, '\u4567');
902 assertEquals('\u0123', o, "getAndSet char");
903 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
904 assertEquals('\u4567', x, "getAndSet char value");
905 }
906
907 {
908 hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123');
909
910 char o = (char) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, '\u4567');
911 assertEquals('\u0123', o, "getAndSetAcquire char");
912 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
913 assertEquals('\u4567', x, "getAndSetAcquire char value");
914 }
915
916 {
917 hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123');
918
919 char o = (char) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, '\u4567');
920 assertEquals('\u0123', o, "getAndSetRelease char");
921 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
922 assertEquals('\u4567', x, "getAndSetRelease char value");
923 }
924
925 // get and add, add and get
926 {
927 hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123');
928
929 char o = (char) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, '\u4567');
930 assertEquals('\u0123', o, "getAndAdd char");
931 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
932 assertEquals((char)('\u0123' + '\u4567'), x, "getAndAdd char value");
933 }
934
935 {
936 hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123');
937
938 char o = (char) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, '\u4567');
939 assertEquals('\u0123', o, "getAndAddAcquire char");
940 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
941 assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddAcquire char value");
942 }
943
944 {
945 hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123');
946
947 char o = (char) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, '\u4567');
948 assertEquals('\u0123', o, "getAndAddRelease char");
949 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
950 assertEquals((char)('\u0123' + '\u4567'), x, "getAndAddRelease char value");
951 }
952
953 // get and bitwise or
954 {
955 hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123');
956
957 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(array, i, '\u4567');
958 assertEquals('\u0123', o, "getAndBitwiseOr char");
959 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
960 assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOr char value");
961 }
962
963 {
964 hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123');
965
966 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(array, i, '\u4567');
967 assertEquals('\u0123', o, "getAndBitwiseOrAcquire char");
968 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
969 assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrAcquire char value");
970 }
971
972 {
973 hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123');
974
975 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(array, i, '\u4567');
976 assertEquals('\u0123', o, "getAndBitwiseOrRelease char");
977 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
978 assertEquals((char)('\u0123' | '\u4567'), x, "getAndBitwiseOrRelease char value");
979 }
980
981 // get and bitwise and
982 {
983 hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123');
984
985 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(array, i, '\u4567');
986 assertEquals('\u0123', o, "getAndBitwiseAnd char");
987 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
988 assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAnd char value");
989 }
990
991 {
992 hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123');
993
994 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE).invokeExact(array, i, '\u4567');
995 assertEquals('\u0123', o, "getAndBitwiseAndAcquire char");
996 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
997 assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndAcquire char value");
998 }
999
1000 {
1001 hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123');
1002
1003 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE).invokeExact(array, i, '\u4567');
1004 assertEquals('\u0123', o, "getAndBitwiseAndRelease char");
1005 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
1006 assertEquals((char)('\u0123' & '\u4567'), x, "getAndBitwiseAndRelease char value");
1007 }
1008
1009 // get and bitwise xor
1010 {
1011 hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123');
1012
1013 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(array, i, '\u4567');
1014 assertEquals('\u0123', o, "getAndBitwiseXor char");
1015 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
1016 assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXor char value");
1017 }
1018
1019 {
1020 hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123');
1021
1022 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE).invokeExact(array, i, '\u4567');
1023 assertEquals('\u0123', o, "getAndBitwiseXorAcquire char");
1024 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
1025 assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorAcquire char value");
1026 }
1027
1028 {
1029 hs.get(TestAccessMode.SET).invokeExact(array, i, '\u0123');
1030
1031 char o = (char) hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE).invokeExact(array, i, '\u4567');
1032 assertEquals('\u0123', o, "getAndBitwiseXorRelease char");
1033 char x = (char) hs.get(TestAccessMode.GET).invokeExact(array, i);
1034 assertEquals((char)('\u0123' ^ '\u4567'), x, "getAndBitwiseXorRelease char value");
1035 }
1036 }
1037 }
1038
1039 static void testArrayUnsupported(Handles hs) throws Throwable {
1040 char[] array = new char[10];
1041
1042 final int i = 0;
1043
1044
1045 }
1046
1047 static void testArrayIndexOutOfBounds(Handles hs) throws Throwable {
1048 char[] array = new char[10];
1049
1050 for (int i : new int[]{-1, Integer.MIN_VALUE, 10, 11, Integer.MAX_VALUE}) {
1051 final int ci = i;
1052
1053 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) {
1054 checkAIOOBE(am, () -> {
1055 char x = (char) hs.get(am).invokeExact(array, ci);
1056 });
1057 }
1058
1059 for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) {
1060 checkAIOOBE(am, () -> {
1061 hs.get(am).invokeExact(array, ci, '\u0123');
1062 });
1063 }
1064
1065 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) {
1066 checkAIOOBE(am, () -> {
1067 boolean r = (boolean) hs.get(am).invokeExact(array, ci, '\u0123', '\u4567');
1068 });
1069 }
1070
1071 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) {
1072 checkAIOOBE(am, () -> {
1073 char r = (char) hs.get(am).invokeExact(array, ci, '\u4567', '\u0123');
1074 });
1075 }
1076
1077 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) {
1078 checkAIOOBE(am, () -> {
1079 char o = (char) hs.get(am).invokeExact(array, ci, '\u0123');
1080 });
1081 }
1082
1083 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
1084 checkAIOOBE(am, () -> {
1085 char o = (char) hs.get(am).invokeExact(array, ci, '\u89AB');
1086 });
1087 }
1088
1089 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) {
1090 checkAIOOBE(am, () -> {
1091 char o = (char) hs.get(am).invokeExact(array, ci, '\u89AB');
1092 });
1093 }
1094 }
1095 }
1096 }
1097