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