1 /*
2 * Copyright (c) 2015, 2018, 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=20000 VarHandleTestMethodHandleAccessString
29 */
30
31 import org.testng.annotations.BeforeClass;
32 import org.testng.annotations.DataProvider;
33 import org.testng.annotations.Test;
34
35 import java.lang.invoke.MethodHandles;
36 import java.lang.invoke.VarHandle;
37 import java.util.ArrayList;
38 import java.util.Arrays;
39 import java.util.List;
40
41 import static org.testng.Assert.*;
42
43 public class VarHandleTestMethodHandleAccessString extends VarHandleBaseTest {
44 static final String static_final_v = "foo";
45
46 static String static_v;
47
48 final String final_v = "foo";
49
50 String v;
51
52 VarHandle vhFinalField;
53
54 VarHandle vhField;
55
56 VarHandle vhStaticField;
57
58 VarHandle vhStaticFinalField;
59
60 VarHandle vhArray;
61
62
63 @BeforeClass
64 public void setup() throws Exception {
65 vhFinalField = MethodHandles.lookup().findVarHandle(
66 VarHandleTestMethodHandleAccessString.class, "final_v", String.class);
67
68 vhField = MethodHandles.lookup().findVarHandle(
69 VarHandleTestMethodHandleAccessString.class, "v", String.class);
70
71 vhStaticFinalField = MethodHandles.lookup().findStaticVarHandle(
72 VarHandleTestMethodHandleAccessString.class, "static_final_v", String.class);
73
74 vhStaticField = MethodHandles.lookup().findStaticVarHandle(
75 VarHandleTestMethodHandleAccessString.class, "static_v", String.class);
76
77 vhArray = MethodHandles.arrayElementVarHandle(String[].class);
78
79 }
80
81
82 @DataProvider
83 public Object[][] accessTestCaseProvider() throws Exception {
84 List<AccessTestCase<?>> cases = new ArrayList<>();
85
86 for (VarHandleToMethodHandle f : VarHandleToMethodHandle.values()) {
87 cases.add(new MethodHandleAccessTestCase("Instance field",
88 vhField, f, hs -> testInstanceField(this, hs)));
89 cases.add(new MethodHandleAccessTestCase("Instance field unsupported",
90 vhField, f, hs -> testInstanceFieldUnsupported(this, hs),
91 false));
92
93 cases.add(new MethodHandleAccessTestCase("Static field",
94 vhStaticField, f, VarHandleTestMethodHandleAccessString::testStaticField));
95 cases.add(new MethodHandleAccessTestCase("Static field unsupported",
96 vhStaticField, f, VarHandleTestMethodHandleAccessString::testStaticFieldUnsupported,
97 false));
98
99 cases.add(new MethodHandleAccessTestCase("Array",
100 vhArray, f, VarHandleTestMethodHandleAccessString::testArray));
101 cases.add(new MethodHandleAccessTestCase("Array unsupported",
102 vhArray, f, VarHandleTestMethodHandleAccessString::testArrayUnsupported,
103 false));
104 cases.add(new MethodHandleAccessTestCase("Array index out of bounds",
105 vhArray, f, VarHandleTestMethodHandleAccessString::testArrayIndexOutOfBounds,
106 false));
107 }
108
109 // Work around issue with jtreg summary reporting which truncates
110 // the String result of Object.toString to 30 characters, hence
111 // the first dummy argument
112 return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new);
113 }
114
115 @Test(dataProvider = "accessTestCaseProvider")
116 public <T> void testAccess(String desc, AccessTestCase<T> atc) throws Throwable {
117 T t = atc.get();
118 int iters = atc.requiresLoop() ? ITERS : 1;
119 for (int c = 0; c < iters; c++) {
120 atc.testAccess(t);
121 }
122 }
123
124
125 static void testInstanceField(VarHandleTestMethodHandleAccessString recv, Handles hs) throws Throwable {
126 // Plain
127 {
128 hs.get(TestAccessMode.SET).invokeExact(recv, "foo");
129 String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
130 assertEquals(x, "foo", "set String value");
131 }
132
133
134 // Volatile
135 {
136 hs.get(TestAccessMode.SET_VOLATILE).invokeExact(recv, "bar");
137 String x = (String) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(recv);
138 assertEquals(x, "bar", "setVolatile String value");
139 }
140
141 // Lazy
142 {
143 hs.get(TestAccessMode.SET_RELEASE).invokeExact(recv, "foo");
144 String x = (String) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(recv);
145 assertEquals(x, "foo", "setRelease String value");
146 }
147
148 // Opaque
149 {
150 hs.get(TestAccessMode.SET_OPAQUE).invokeExact(recv, "bar");
151 String x = (String) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(recv);
152 assertEquals(x, "bar", "setOpaque String value");
153 }
154
155 hs.get(TestAccessMode.SET).invokeExact(recv, "foo");
156
157 // Compare
158 {
159 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, "foo", "bar");
160 assertEquals(r, true, "success compareAndSet String");
161 String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
162 assertEquals(x, "bar", "success compareAndSet String value");
163 }
164
165 {
166 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(recv, "foo", "baz");
167 assertEquals(r, false, "failing compareAndSet String");
168 String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
169 assertEquals(x, "bar", "failing compareAndSet String value");
170 }
171
172 {
173 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, "bar", "foo");
174 assertEquals(r, "bar", "success compareAndExchange String");
175 String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
176 assertEquals(x, "foo", "success compareAndExchange String value");
177 }
178
179 {
180 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(recv, "bar", "baz");
181 assertEquals(r, "foo", "failing compareAndExchange String");
182 String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
183 assertEquals(x, "foo", "failing compareAndExchange String value");
184 }
185
186 {
187 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, "foo", "bar");
188 assertEquals(r, "foo", "success compareAndExchangeAcquire String");
189 String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
190 assertEquals(x, "bar", "success compareAndExchangeAcquire String value");
191 }
192
193 {
194 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(recv, "foo", "baz");
195 assertEquals(r, "bar", "failing compareAndExchangeAcquire String");
196 String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
197 assertEquals(x, "bar", "failing compareAndExchangeAcquire String value");
198 }
199
200 {
201 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, "bar", "foo");
202 assertEquals(r, "bar", "success compareAndExchangeRelease String");
203 String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
204 assertEquals(x, "foo", "success compareAndExchangeRelease String value");
205 }
206
207 {
208 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(recv, "bar", "baz");
209 assertEquals(r, "foo", "failing compareAndExchangeRelease String");
210 String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
211 assertEquals(x, "foo", "failing compareAndExchangeRelease String value");
212 }
213
214 {
215 boolean success = false;
216 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
217 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(recv, "foo", "bar");
218 }
219 assertEquals(success, true, "weakCompareAndSetPlain String");
220 String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
221 assertEquals(x, "bar", "weakCompareAndSetPlain String value");
222 }
223
224 {
225 boolean success = false;
226 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
227 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(recv, "bar", "foo");
228 }
229 assertEquals(success, true, "weakCompareAndSetAcquire String");
230 String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
231 assertEquals(x, "foo", "weakCompareAndSetAcquire String");
232 }
233
234 {
235 boolean success = false;
236 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
237 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(recv, "foo", "bar");
238 }
239 assertEquals(success, true, "weakCompareAndSetRelease String");
240 String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
241 assertEquals(x, "bar", "weakCompareAndSetRelease String");
242 }
243
244 {
245 boolean success = false;
246 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
247 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(recv, "bar", "foo");
248 }
249 assertEquals(success, true, "weakCompareAndSet String");
250 String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
251 assertEquals(x, "foo", "weakCompareAndSet String");
252 }
253
254 // Compare set and get
255 {
256 String o = (String) hs.get(TestAccessMode.GET_AND_SET).invokeExact(recv, "bar");
257 assertEquals(o, "foo", "getAndSet String");
258 String x = (String) hs.get(TestAccessMode.GET).invokeExact(recv);
259 assertEquals(x, "bar", "getAndSet String value");
260 }
261
262
263 }
264
265 static void testInstanceFieldUnsupported(VarHandleTestMethodHandleAccessString recv, Handles hs) throws Throwable {
266
267 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
268 checkUOE(am, () -> {
269 String r = (String) hs.get(am).invokeExact(recv, "foo");
270 });
271 }
272
273 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) {
274 checkUOE(am, () -> {
275 String r = (String) hs.get(am).invokeExact(recv, "foo");
276 });
277 }
278 }
279
280
281 static void testStaticField(Handles hs) throws Throwable {
282 // Plain
283 {
284 hs.get(TestAccessMode.SET).invokeExact("foo");
285 String x = (String) hs.get(TestAccessMode.GET).invokeExact();
286 assertEquals(x, "foo", "set String value");
287 }
288
289
290 // Volatile
291 {
292 hs.get(TestAccessMode.SET_VOLATILE).invokeExact("bar");
293 String x = (String) hs.get(TestAccessMode.GET_VOLATILE).invokeExact();
294 assertEquals(x, "bar", "setVolatile String value");
295 }
296
297 // Lazy
298 {
299 hs.get(TestAccessMode.SET_RELEASE).invokeExact("foo");
300 String x = (String) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact();
301 assertEquals(x, "foo", "setRelease String value");
302 }
303
304 // Opaque
305 {
306 hs.get(TestAccessMode.SET_OPAQUE).invokeExact("bar");
307 String x = (String) hs.get(TestAccessMode.GET_OPAQUE).invokeExact();
308 assertEquals(x, "bar", "setOpaque String value");
309 }
310
311 hs.get(TestAccessMode.SET).invokeExact("foo");
312
313 // Compare
314 {
315 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact("foo", "bar");
316 assertEquals(r, true, "success compareAndSet String");
317 String x = (String) hs.get(TestAccessMode.GET).invokeExact();
318 assertEquals(x, "bar", "success compareAndSet String value");
319 }
320
321 {
322 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact("foo", "baz");
323 assertEquals(r, false, "failing compareAndSet String");
324 String x = (String) hs.get(TestAccessMode.GET).invokeExact();
325 assertEquals(x, "bar", "failing compareAndSet String value");
326 }
327
328 {
329 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact("bar", "foo");
330 assertEquals(r, "bar", "success compareAndExchange String");
331 String x = (String) hs.get(TestAccessMode.GET).invokeExact();
332 assertEquals(x, "foo", "success compareAndExchange String value");
333 }
334
335 {
336 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact("bar", "baz");
337 assertEquals(r, "foo", "failing compareAndExchange String");
338 String x = (String) hs.get(TestAccessMode.GET).invokeExact();
339 assertEquals(x, "foo", "failing compareAndExchange String value");
340 }
341
342 {
343 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact("foo", "bar");
344 assertEquals(r, "foo", "success compareAndExchangeAcquire String");
345 String x = (String) hs.get(TestAccessMode.GET).invokeExact();
346 assertEquals(x, "bar", "success compareAndExchangeAcquire String value");
347 }
348
349 {
350 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact("foo", "baz");
351 assertEquals(r, "bar", "failing compareAndExchangeAcquire String");
352 String x = (String) hs.get(TestAccessMode.GET).invokeExact();
353 assertEquals(x, "bar", "failing compareAndExchangeAcquire String value");
354 }
355
356 {
357 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact("bar", "foo");
358 assertEquals(r, "bar", "success compareAndExchangeRelease String");
359 String x = (String) hs.get(TestAccessMode.GET).invokeExact();
360 assertEquals(x, "foo", "success compareAndExchangeRelease String value");
361 }
362
363 {
364 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact("bar", "baz");
365 assertEquals(r, "foo", "failing compareAndExchangeRelease String");
366 String x = (String) hs.get(TestAccessMode.GET).invokeExact();
367 assertEquals(x, "foo", "failing compareAndExchangeRelease String value");
368 }
369
370 {
371 boolean success = false;
372 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
373 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact("foo", "bar");
374 }
375 assertEquals(success, true, "weakCompareAndSetPlain String");
376 String x = (String) hs.get(TestAccessMode.GET).invokeExact();
377 assertEquals(x, "bar", "weakCompareAndSetPlain String value");
378 }
379
380 {
381 boolean success = false;
382 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
383 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact("bar", "foo");
384 }
385 assertEquals(success, true, "weakCompareAndSetAcquire String");
386 String x = (String) hs.get(TestAccessMode.GET).invokeExact();
387 assertEquals(x, "foo", "weakCompareAndSetAcquire String");
388 }
389
390 {
391 boolean success = false;
392 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
393 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact("foo", "bar");
394 }
395 assertEquals(success, true, "weakCompareAndSetRelease String");
396 String x = (String) hs.get(TestAccessMode.GET).invokeExact();
397 assertEquals(x, "bar", "weakCompareAndSetRelease String");
398 }
399
400 {
401 boolean success = false;
402 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
403 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact("bar", "foo");
404 }
405 assertEquals(success, true, "weakCompareAndSet String");
406 String x = (String) hs.get(TestAccessMode.GET).invokeExact();
407 assertEquals(x, "foo", "weakCompareAndSet String");
408 }
409
410 // Compare set and get
411 {
412 hs.get(TestAccessMode.SET).invokeExact("foo");
413
414 String o = (String) hs.get(TestAccessMode.GET_AND_SET).invokeExact("bar");
415 assertEquals(o, "foo", "getAndSet String");
416 String x = (String) hs.get(TestAccessMode.GET).invokeExact();
417 assertEquals(x, "bar", "getAndSet String value");
418 }
419
420 // Compare set and get
421 {
422 hs.get(TestAccessMode.SET).invokeExact("foo");
423
424 String o = (String) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact("bar");
425 assertEquals(o, "foo", "getAndSetAcquire String");
426 String x = (String) hs.get(TestAccessMode.GET).invokeExact();
427 assertEquals(x, "bar", "getAndSetAcquire String value");
428 }
429
430 // Compare set and get
431 {
432 hs.get(TestAccessMode.SET).invokeExact("foo");
433
434 String o = (String) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact("bar");
435 assertEquals(o, "foo", "getAndSetRelease String");
436 String x = (String) hs.get(TestAccessMode.GET).invokeExact();
437 assertEquals(x, "bar", "getAndSetRelease String value");
438 }
439
440
441 }
442
443 static void testStaticFieldUnsupported(Handles hs) throws Throwable {
444
445 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
446 checkUOE(am, () -> {
447 String r = (String) hs.get(am).invokeExact("foo");
448 });
449 }
450
451 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) {
452 checkUOE(am, () -> {
453 String r = (String) hs.get(am).invokeExact("foo");
454 });
455 }
456 }
457
458
459 static void testArray(Handles hs) throws Throwable {
460 String[] array = new String[10];
461
462 for (int i = 0; i < array.length; i++) {
463 // Plain
464 {
465 hs.get(TestAccessMode.SET).invokeExact(array, i, "foo");
466 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
467 assertEquals(x, "foo", "get String value");
468 }
469
470
471 // Volatile
472 {
473 hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, "bar");
474 String x = (String) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i);
475 assertEquals(x, "bar", "setVolatile String value");
476 }
477
478 // Lazy
479 {
480 hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, "foo");
481 String x = (String) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i);
482 assertEquals(x, "foo", "setRelease String value");
483 }
484
485 // Opaque
486 {
487 hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, "bar");
488 String x = (String) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i);
489 assertEquals(x, "bar", "setOpaque String value");
490 }
491
492 hs.get(TestAccessMode.SET).invokeExact(array, i, "foo");
493
494 // Compare
495 {
496 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, "foo", "bar");
497 assertEquals(r, true, "success compareAndSet String");
498 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
499 assertEquals(x, "bar", "success compareAndSet String value");
500 }
501
502 {
503 boolean r = (boolean) hs.get(TestAccessMode.COMPARE_AND_SET).invokeExact(array, i, "foo", "baz");
504 assertEquals(r, false, "failing compareAndSet String");
505 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
506 assertEquals(x, "bar", "failing compareAndSet String value");
507 }
508
509 {
510 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, "bar", "foo");
511 assertEquals(r, "bar", "success compareAndExchange String");
512 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
513 assertEquals(x, "foo", "success compareAndExchange String value");
514 }
515
516 {
517 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE).invokeExact(array, i, "bar", "baz");
518 assertEquals(r, "foo", "failing compareAndExchange String");
519 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
520 assertEquals(x, "foo", "failing compareAndExchange String value");
521 }
522
523 {
524 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, "foo", "bar");
525 assertEquals(r, "foo", "success compareAndExchangeAcquire String");
526 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
527 assertEquals(x, "bar", "success compareAndExchangeAcquire String value");
528 }
529
530 {
531 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE).invokeExact(array, i, "foo", "baz");
532 assertEquals(r, "bar", "failing compareAndExchangeAcquire String");
533 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
534 assertEquals(x, "bar", "failing compareAndExchangeAcquire String value");
535 }
536
537 {
538 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, "bar", "foo");
539 assertEquals(r, "bar", "success compareAndExchangeRelease String");
540 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
541 assertEquals(x, "foo", "success compareAndExchangeRelease String value");
542 }
543
544 {
545 String r = (String) hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE).invokeExact(array, i, "bar", "baz");
546 assertEquals(r, "foo", "failing compareAndExchangeRelease String");
547 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
548 assertEquals(x, "foo", "failing compareAndExchangeRelease String value");
549 }
550
551 {
552 boolean success = false;
553 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
554 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN).invokeExact(array, i, "foo", "bar");
555 }
556 assertEquals(success, true, "weakCompareAndSetPlain String");
557 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
558 assertEquals(x, "bar", "weakCompareAndSetPlain String value");
559 }
560
561 {
562 boolean success = false;
563 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
564 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE).invokeExact(array, i, "bar", "foo");
565 }
566 assertEquals(success, true, "weakCompareAndSetAcquire String");
567 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
568 assertEquals(x, "foo", "weakCompareAndSetAcquire String");
569 }
570
571 {
572 boolean success = false;
573 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
574 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE).invokeExact(array, i, "foo", "bar");
575 }
576 assertEquals(success, true, "weakCompareAndSetRelease String");
577 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
578 assertEquals(x, "bar", "weakCompareAndSetRelease String");
579 }
580
581 {
582 boolean success = false;
583 for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
584 success = (boolean) hs.get(TestAccessMode.WEAK_COMPARE_AND_SET).invokeExact(array, i, "bar", "foo");
585 }
586 assertEquals(success, true, "weakCompareAndSet String");
587 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
588 assertEquals(x, "foo", "weakCompareAndSet String");
589 }
590
591 // Compare set and get
592 {
593 hs.get(TestAccessMode.SET).invokeExact(array, i, "foo");
594
595 String o = (String) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, "bar");
596 assertEquals(o, "foo", "getAndSet String");
597 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
598 assertEquals(x, "bar", "getAndSet String value");
599 }
600
601 {
602 hs.get(TestAccessMode.SET).invokeExact(array, i, "foo");
603
604 String o = (String) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, "bar");
605 assertEquals(o, "foo", "getAndSetAcquire String");
606 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
607 assertEquals(x, "bar", "getAndSetAcquire String value");
608 }
609
610 {
611 hs.get(TestAccessMode.SET).invokeExact(array, i, "foo");
612
613 String o = (String) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, "bar");
614 assertEquals(o, "foo", "getAndSetRelease String");
615 String x = (String) hs.get(TestAccessMode.GET).invokeExact(array, i);
616 assertEquals(x, "bar", "getAndSetRelease String value");
617 }
618
619
620 }
621 }
622
623 static void testArrayUnsupported(Handles hs) throws Throwable {
624 String[] array = new String[10];
625
626 final int i = 0;
627
628 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
629 checkUOE(am, () -> {
630 String o = (String) hs.get(am).invokeExact(array, i, "foo");
631 });
632 }
633
634 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) {
635 checkUOE(am, () -> {
636 String o = (String) hs.get(am).invokeExact(array, i, "foo");
637 });
638 }
639 }
640
641 static void testArrayIndexOutOfBounds(Handles hs) throws Throwable {
642 String[] array = new String[10];
643
644 for (int i : new int[]{-1, Integer.MIN_VALUE, 10, 11, Integer.MAX_VALUE}) {
645 final int ci = i;
646
647 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) {
648 checkIOOBE(am, () -> {
649 String x = (String) hs.get(am).invokeExact(array, ci);
650 });
651 }
652
653 for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) {
654 checkIOOBE(am, () -> {
655 hs.get(am).invokeExact(array, ci, "foo");
656 });
657 }
658
659 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) {
660 checkIOOBE(am, () -> {
661 boolean r = (boolean) hs.get(am).invokeExact(array, ci, "foo", "bar");
662 });
663 }
664
665 for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) {
666 checkIOOBE(am, () -> {
667 String r = (String) hs.get(am).invokeExact(array, ci, "bar", "foo");
668 });
669 }
670
671 for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) {
672 checkIOOBE(am, () -> {
673 String o = (String) hs.get(am).invokeExact(array, ci, "foo");
674 });
675 }
676
677
678 }
679 }
680 }
681