X-VarHandleTestByteArrayView.java.template revision 15541:e2d28c613133 
1/*
2 * Copyright (c) 2015, 2016, 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 * @bug 8154556
27 * @run testng/othervm -Diters=20000 -XX:TieredStopAtLevel=1 VarHandleTestByteArrayAs$Type$
28 * @run testng/othervm -Diters=20000                         VarHandleTestByteArrayAs$Type$
29 * @run testng/othervm -Diters=20000 -XX:-TieredCompilation  VarHandleTestByteArrayAs$Type$
30 */
31
32import org.testng.annotations.DataProvider;
33import org.testng.annotations.Test;
34
35import java.lang.invoke.MethodHandles;
36import java.lang.invoke.VarHandle;
37import java.nio.ByteBuffer;
38import java.nio.ByteOrder;
39import java.util.ArrayList;
40import java.util.Arrays;
41import java.util.EnumSet;
42import java.util.List;
43
44import static org.testng.Assert.*;
45
46public class VarHandleTestByteArrayAs$Type$ extends VarHandleBaseByteArrayTest {
47    static final int SIZE = $BoxType$.BYTES;
48
49    static final $type$ VALUE_1 = $value1$;
50
51    static final $type$ VALUE_2 = $value2$;
52
53    static final $type$ VALUE_3 = $value3$;
54
55
56    @Override
57    public void setupVarHandleSources() {
58        // Combinations of VarHandle byte[] or ByteBuffer
59        vhss = new ArrayList<>();
60        for (MemoryMode endianess : Arrays.asList(MemoryMode.BIG_ENDIAN, MemoryMode.LITTLE_ENDIAN)) {
61
62            ByteOrder bo = endianess == MemoryMode.BIG_ENDIAN
63                    ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN;
64            VarHandleSource aeh = new VarHandleSource(
65                    MethodHandles.byteArrayViewVarHandle($type$[].class, bo),
66                    endianess, MemoryMode.READ_WRITE);
67            vhss.add(aeh);
68
69            VarHandleSource bbh = new VarHandleSource(
70                    MethodHandles.byteBufferViewVarHandle($type$[].class, bo),
71                    endianess, MemoryMode.READ_WRITE);
72            vhss.add(bbh);
73        }
74    }
75
76
77    @Test(dataProvider = "varHandlesProvider")
78    public void testIsAccessModeSupported(VarHandleSource vhs) {
79        VarHandle vh = vhs.s;
80
81        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET));
82        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET));
83
84        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_VOLATILE));
85        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_VOLATILE));
86        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_ACQUIRE));
87        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_RELEASE));
88        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_OPAQUE));
89        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.SET_OPAQUE));
90
91#if[CAS]
92        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_SET));
93        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE));
94        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_ACQUIRE));
95        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_RELEASE));
96        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_PLAIN));
97        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
98        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
99        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
100        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
101        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_ACQUIRE));
102        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_RELEASE));
103#else[CAS]
104        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_SET));
105        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE));
106        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_ACQUIRE));
107        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_RELEASE));
108        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_PLAIN));
109        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET));
110        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE));
111        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE));
112        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET));
113        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_ACQUIRE));
114        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_SET_RELEASE));
115#end[CAS]
116
117#if[AtomicAdd]
118        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
119        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_ACQUIRE));
120        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_RELEASE));
121#else[AtomicAdd]
122        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD));
123        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_ACQUIRE));
124        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_ADD_RELEASE));
125#end[AtomicAdd]
126
127#if[Bitwise]
128        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR));
129        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_ACQUIRE));
130        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_RELEASE));
131        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND));
132        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_ACQUIRE));
133        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_RELEASE));
134        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR));
135        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_ACQUIRE));
136        assertTrue(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE));
137#else[Bitwise]
138        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR));
139        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_ACQUIRE));
140        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_OR_RELEASE));
141        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND));
142        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_ACQUIRE));
143        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_AND_RELEASE));
144        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR));
145        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_ACQUIRE));
146        assertFalse(vh.isAccessModeSupported(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE));
147#end[Bitwise]
148    }
149
150    @Test(dataProvider = "typesProvider")
151    public void testTypes(VarHandle vh, List<java.lang.Class<?>> pts) {
152        assertEquals(vh.varType(), $type$.class);
153
154        assertEquals(vh.coordinateTypes(), pts);
155
156        testTypes(vh);
157    }
158
159
160    @DataProvider
161    public Object[][] accessTestCaseProvider() throws Exception {
162        List<AccessTestCase<?>> cases = new ArrayList<>();
163
164        for (ByteArrayViewSource<?> bav : bavss) {
165            for (VarHandleSource vh : vhss) {
166                if (vh.matches(bav)) {
167                    if (bav instanceof ByteArraySource) {
168                        ByteArraySource bas = (ByteArraySource) bav;
169
170                        cases.add(new VarHandleSourceAccessTestCase(
171                                "read write", bav, vh, h -> testArrayReadWrite(bas, h),
172                                true));
173                        cases.add(new VarHandleSourceAccessTestCase(
174                                "unsupported", bav, vh, h -> testArrayUnsupported(bas, h),
175                                false));
176                        cases.add(new VarHandleSourceAccessTestCase(
177                                "index out of bounds", bav, vh, h -> testArrayIndexOutOfBounds(bas, h),
178                                false));
179                        cases.add(new VarHandleSourceAccessTestCase(
180                                "misaligned access", bav, vh, h -> testArrayMisalignedAccess(bas, h),
181                                false));
182                    }
183                    else {
184                        ByteBufferSource bbs = (ByteBufferSource) bav;
185
186                        if (MemoryMode.READ_WRITE.isSet(bav.memoryModes)) {
187                            cases.add(new VarHandleSourceAccessTestCase(
188                                    "read write", bav, vh, h -> testArrayReadWrite(bbs, h),
189                                    true));
190                        }
191                        else {
192                            cases.add(new VarHandleSourceAccessTestCase(
193                                    "read only", bav, vh, h -> testArrayReadOnly(bbs, h),
194                                    true));
195                        }
196
197                        cases.add(new VarHandleSourceAccessTestCase(
198                                "unsupported", bav, vh, h -> testArrayUnsupported(bbs, h),
199                                false));
200                        cases.add(new VarHandleSourceAccessTestCase(
201                                "index out of bounds", bav, vh, h -> testArrayIndexOutOfBounds(bbs, h),
202                                false));
203                        cases.add(new VarHandleSourceAccessTestCase(
204                                "misaligned access", bav, vh, h -> testArrayMisalignedAccess(bbs, h),
205                                false));
206                    }
207                }
208            }
209        }
210
211        // Work around issue with jtreg summary reporting which truncates
212        // the String result of Object.toString to 30 characters, hence
213        // the first dummy argument
214        return cases.stream().map(tc -> new Object[]{tc.toString(), tc}).toArray(Object[][]::new);
215    }
216
217    @Test(dataProvider = "accessTestCaseProvider")
218    public <T> void testAccess(String desc, AccessTestCase<T> atc) throws Throwable {
219        T t = atc.get();
220        int iters = atc.requiresLoop() ? ITERS : 1;
221        for (int c = 0; c < iters; c++) {
222            atc.testAccess(t);
223        }
224    }
225
226
227    static void testArrayUnsupported(ByteArraySource bs, VarHandleSource vhs) {
228        VarHandle vh = vhs.s;
229        byte[] array = bs.s;
230        int ci = 1;
231
232#if[!CAS]
233        checkUOE(() -> {
234            boolean r = vh.compareAndSet(array, ci, VALUE_1, VALUE_2);
235        });
236
237        checkUOE(() -> {
238            $type$ r = ($type$) vh.compareAndExchange(array, ci, VALUE_2, VALUE_1);
239        });
240
241        checkUOE(() -> {
242            $type$ r = ($type$) vh.compareAndExchangeAcquire(array, ci, VALUE_2, VALUE_1);
243        });
244
245        checkUOE(() -> {
246            $type$ r = ($type$) vh.compareAndExchangeRelease(array, ci, VALUE_2, VALUE_1);
247        });
248
249        checkUOE(() -> {
250            boolean r = vh.weakCompareAndSetPlain(array, ci, VALUE_1, VALUE_2);
251        });
252
253        checkUOE(() -> {
254            boolean r = vh.weakCompareAndSet(array, ci, VALUE_1, VALUE_2);
255        });
256
257        checkUOE(() -> {
258            boolean r = vh.weakCompareAndSetAcquire(array, ci, VALUE_1, VALUE_2);
259        });
260
261        checkUOE(() -> {
262            boolean r = vh.weakCompareAndSetRelease(array, ci, VALUE_1, VALUE_2);
263        });
264
265        checkUOE(() -> {
266            $type$ o = ($type$) vh.getAndSet(array, ci, VALUE_1);
267        });
268
269        checkUOE(() -> {
270            $type$ o = ($type$) vh.getAndSetAcquire(array, ci, VALUE_1);
271        });
272
273        checkUOE(() -> {
274            $type$ o = ($type$) vh.getAndSetRelease(array, ci, VALUE_1);
275        });
276#end[CAS]
277
278#if[!AtomicAdd]
279        checkUOE(() -> {
280            $type$ o = ($type$) vh.getAndAdd(array, ci, VALUE_1);
281        });
282
283        checkUOE(() -> {
284            $type$ o = ($type$) vh.getAndAddAcquire(array, ci, VALUE_1);
285        });
286
287        checkUOE(() -> {
288            $type$ o = ($type$) vh.getAndAddRelease(array, ci, VALUE_1);
289        });
290#end[AtomicAdd]
291
292#if[!Bitwise]
293        checkUOE(() -> {
294            $type$ o = ($type$) vh.getAndBitwiseOr(array, ci, VALUE_1);
295        });
296
297        checkUOE(() -> {
298            $type$ o = ($type$) vh.getAndBitwiseOrAcquire(array, ci, VALUE_1);
299        });
300
301        checkUOE(() -> {
302            $type$ o = ($type$) vh.getAndBitwiseOrRelease(array, ci, VALUE_1);
303        });
304
305        checkUOE(() -> {
306            $type$ o = ($type$) vh.getAndBitwiseAnd(array, ci, VALUE_1);
307        });
308
309        checkUOE(() -> {
310            $type$ o = ($type$) vh.getAndBitwiseAndAcquire(array, ci, VALUE_1);
311        });
312
313        checkUOE(() -> {
314            $type$ o = ($type$) vh.getAndBitwiseAndRelease(array, ci, VALUE_1);
315        });
316
317        checkUOE(() -> {
318            $type$ o = ($type$) vh.getAndBitwiseXor(array, ci, VALUE_1);
319        });
320
321        checkUOE(() -> {
322            $type$ o = ($type$) vh.getAndBitwiseXorAcquire(array, ci, VALUE_1);
323        });
324
325        checkUOE(() -> {
326            $type$ o = ($type$) vh.getAndBitwiseXorRelease(array, ci, VALUE_1);
327        });
328#end[Bitwise]
329    }
330
331    static void testArrayUnsupported(ByteBufferSource bs, VarHandleSource vhs) {
332        VarHandle vh = vhs.s;
333        ByteBuffer array = bs.s;
334        int ci = 0;
335        boolean readOnly = MemoryMode.READ_ONLY.isSet(bs.memoryModes);
336
337        if (readOnly) {
338            checkROBE(() -> {
339                vh.set(array, ci, VALUE_1);
340            });
341        }
342
343        if (readOnly) {
344            checkROBE(() -> {
345                vh.setVolatile(array, ci, VALUE_1);
346            });
347
348            checkROBE(() -> {
349                vh.setRelease(array, ci, VALUE_1);
350            });
351
352            checkROBE(() -> {
353                vh.setOpaque(array, ci, VALUE_1);
354            });
355#if[CAS]
356
357            checkROBE(() -> {
358                boolean r = vh.compareAndSet(array, ci, VALUE_1, VALUE_2);
359            });
360
361            checkROBE(() -> {
362                $type$ r = ($type$) vh.compareAndExchange(array, ci, VALUE_2, VALUE_1);
363            });
364
365            checkROBE(() -> {
366                $type$ r = ($type$) vh.compareAndExchangeAcquire(array, ci, VALUE_2, VALUE_1);
367            });
368
369            checkROBE(() -> {
370                $type$ r = ($type$) vh.compareAndExchangeRelease(array, ci, VALUE_2, VALUE_1);
371            });
372
373            checkROBE(() -> {
374                boolean r = vh.weakCompareAndSetPlain(array, ci, VALUE_1, VALUE_2);
375            });
376
377            checkROBE(() -> {
378                boolean r = vh.weakCompareAndSet(array, ci, VALUE_1, VALUE_2);
379            });
380
381            checkROBE(() -> {
382                boolean r = vh.weakCompareAndSetAcquire(array, ci, VALUE_1, VALUE_2);
383            });
384
385            checkROBE(() -> {
386                boolean r = vh.weakCompareAndSetRelease(array, ci, VALUE_1, VALUE_2);
387            });
388
389            checkROBE(() -> {
390                $type$ o = ($type$) vh.getAndSet(array, ci, VALUE_1);
391            });
392
393            checkROBE(() -> {
394                $type$ o = ($type$) vh.getAndSetAcquire(array, ci, VALUE_1);
395            });
396
397            checkROBE(() -> {
398                $type$ o = ($type$) vh.getAndSetRelease(array, ci, VALUE_1);
399            });
400
401#else[CAS]
402            checkUOE(() -> {
403                boolean r = vh.compareAndSet(array, ci, VALUE_1, VALUE_2);
404            });
405
406            checkUOE(() -> {
407                $type$ r = ($type$) vh.compareAndExchange(array, ci, VALUE_2, VALUE_1);
408            });
409
410            checkUOE(() -> {
411                $type$ r = ($type$) vh.compareAndExchangeAcquire(array, ci, VALUE_2, VALUE_1);
412            });
413
414            checkUOE(() -> {
415                $type$ r = ($type$) vh.compareAndExchangeRelease(array, ci, VALUE_2, VALUE_1);
416            });
417
418            checkUOE(() -> {
419                boolean r = vh.weakCompareAndSetPlain(array, ci, VALUE_1, VALUE_2);
420            });
421
422            checkUOE(() -> {
423                boolean r = vh.weakCompareAndSet(array, ci, VALUE_1, VALUE_2);
424            });
425
426            checkUOE(() -> {
427                boolean r = vh.weakCompareAndSetAcquire(array, ci, VALUE_1, VALUE_2);
428            });
429
430            checkUOE(() -> {
431                boolean r = vh.weakCompareAndSetRelease(array, ci, VALUE_1, VALUE_2);
432            });
433
434            checkUOE(() -> {
435                $type$ o = ($type$) vh.getAndSet(array, ci, VALUE_1);
436            });
437
438            checkUOE(() -> {
439                $type$ o = ($type$) vh.getAndSetAcquire(array, ci, VALUE_1);
440            });
441
442            checkUOE(() -> {
443                $type$ o = ($type$) vh.getAndSetRelease(array, ci, VALUE_1);
444            });
445#end[CAS]
446
447#if[AtomicAdd]
448            checkROBE(() -> {
449                $type$ o = ($type$) vh.getAndAdd(array, ci, VALUE_1);
450            });
451
452            checkROBE(() -> {
453                $type$ o = ($type$) vh.getAndAddAcquire(array, ci, VALUE_1);
454            });
455
456            checkROBE(() -> {
457                $type$ o = ($type$) vh.getAndAddRelease(array, ci, VALUE_1);
458            });
459#else[AtomicAdd]
460            checkUOE(() -> {
461                $type$ o = ($type$) vh.getAndAdd(array, ci, VALUE_1);
462            });
463
464            checkUOE(() -> {
465                $type$ o = ($type$) vh.getAndAddAcquire(array, ci, VALUE_1);
466            });
467
468            checkUOE(() -> {
469                $type$ o = ($type$) vh.getAndAddRelease(array, ci, VALUE_1);
470            });
471#end[AtomicAdd]
472
473#if[Bitwise]
474            checkROBE(() -> {
475                $type$ o = ($type$) vh.getAndBitwiseOr(array, ci, VALUE_1);
476            });
477
478            checkROBE(() -> {
479                $type$ o = ($type$) vh.getAndBitwiseOrAcquire(array, ci, VALUE_1);
480            });
481
482            checkROBE(() -> {
483                $type$ o = ($type$) vh.getAndBitwiseOrRelease(array, ci, VALUE_1);
484            });
485
486            checkROBE(() -> {
487                $type$ o = ($type$) vh.getAndBitwiseAnd(array, ci, VALUE_1);
488            });
489
490            checkROBE(() -> {
491                $type$ o = ($type$) vh.getAndBitwiseAndAcquire(array, ci, VALUE_1);
492            });
493
494            checkROBE(() -> {
495                $type$ o = ($type$) vh.getAndBitwiseAndRelease(array, ci, VALUE_1);
496            });
497
498            checkROBE(() -> {
499                $type$ o = ($type$) vh.getAndBitwiseXor(array, ci, VALUE_1);
500            });
501
502            checkROBE(() -> {
503                $type$ o = ($type$) vh.getAndBitwiseXorAcquire(array, ci, VALUE_1);
504            });
505
506            checkROBE(() -> {
507                $type$ o = ($type$) vh.getAndBitwiseXorRelease(array, ci, VALUE_1);
508            });
509#else[Bitwise]
510            checkUOE(() -> {
511                $type$ o = ($type$) vh.getAndBitwiseOr(array, ci, VALUE_1);
512            });
513
514            checkUOE(() -> {
515                $type$ o = ($type$) vh.getAndBitwiseOrAcquire(array, ci, VALUE_1);
516            });
517
518            checkUOE(() -> {
519                $type$ o = ($type$) vh.getAndBitwiseOrRelease(array, ci, VALUE_1);
520            });
521
522            checkUOE(() -> {
523                $type$ o = ($type$) vh.getAndBitwiseAnd(array, ci, VALUE_1);
524            });
525
526            checkUOE(() -> {
527                $type$ o = ($type$) vh.getAndBitwiseAndAcquire(array, ci, VALUE_1);
528            });
529
530            checkUOE(() -> {
531                $type$ o = ($type$) vh.getAndBitwiseAndRelease(array, ci, VALUE_1);
532            });
533
534            checkUOE(() -> {
535                $type$ o = ($type$) vh.getAndBitwiseXor(array, ci, VALUE_1);
536            });
537
538            checkUOE(() -> {
539                $type$ o = ($type$) vh.getAndBitwiseXorAcquire(array, ci, VALUE_1);
540            });
541
542            checkUOE(() -> {
543                $type$ o = ($type$) vh.getAndBitwiseXorRelease(array, ci, VALUE_1);
544            });
545#end[Bitwise]
546        }
547        else {
548#if[!CAS]
549            checkUOE(() -> {
550                boolean r = vh.compareAndSet(array, ci, VALUE_1, VALUE_2);
551            });
552
553            checkUOE(() -> {
554                $type$ r = ($type$) vh.compareAndExchange(array, ci, VALUE_2, VALUE_1);
555            });
556
557            checkUOE(() -> {
558                $type$ r = ($type$) vh.compareAndExchangeAcquire(array, ci, VALUE_2, VALUE_1);
559            });
560
561            checkUOE(() -> {
562                $type$ r = ($type$) vh.compareAndExchangeRelease(array, ci, VALUE_2, VALUE_1);
563            });
564
565            checkUOE(() -> {
566                boolean r = vh.weakCompareAndSetPlain(array, ci, VALUE_1, VALUE_2);
567            });
568
569            checkUOE(() -> {
570                boolean r = vh.weakCompareAndSet(array, ci, VALUE_1, VALUE_2);
571            });
572
573            checkUOE(() -> {
574                boolean r = vh.weakCompareAndSetAcquire(array, ci, VALUE_1, VALUE_2);
575            });
576
577            checkUOE(() -> {
578                boolean r = vh.weakCompareAndSetRelease(array, ci, VALUE_1, VALUE_2);
579            });
580
581            checkUOE(() -> {
582                $type$ o = ($type$) vh.getAndSet(array, ci, VALUE_1);
583            });
584
585            checkUOE(() -> {
586                $type$ o = ($type$) vh.getAndSetAcquire(array, ci, VALUE_1);
587            });
588
589            checkUOE(() -> {
590                $type$ o = ($type$) vh.getAndSetRelease(array, ci, VALUE_1);
591            });
592#end[CAS]
593#if[!AtomicAdd]
594            checkUOE(() -> {
595                $type$ o = ($type$) vh.getAndAdd(array, ci, VALUE_1);
596            });
597
598            checkUOE(() -> {
599                $type$ o = ($type$) vh.getAndAddAcquire(array, ci, VALUE_1);
600            });
601
602            checkUOE(() -> {
603                $type$ o = ($type$) vh.getAndAddRelease(array, ci, VALUE_1);
604            });
605#end[AtomicAdd]
606#if[!Bitwise]
607            checkUOE(() -> {
608                $type$ o = ($type$) vh.getAndBitwiseOr(array, ci, VALUE_1);
609            });
610
611            checkUOE(() -> {
612                $type$ o = ($type$) vh.getAndBitwiseOrAcquire(array, ci, VALUE_1);
613            });
614
615            checkUOE(() -> {
616                $type$ o = ($type$) vh.getAndBitwiseOrRelease(array, ci, VALUE_1);
617            });
618
619            checkUOE(() -> {
620                $type$ o = ($type$) vh.getAndBitwiseAnd(array, ci, VALUE_1);
621            });
622
623            checkUOE(() -> {
624                $type$ o = ($type$) vh.getAndBitwiseAndAcquire(array, ci, VALUE_1);
625            });
626
627            checkUOE(() -> {
628                $type$ o = ($type$) vh.getAndBitwiseAndRelease(array, ci, VALUE_1);
629            });
630
631            checkUOE(() -> {
632                $type$ o = ($type$) vh.getAndBitwiseXor(array, ci, VALUE_1);
633            });
634
635            checkUOE(() -> {
636                $type$ o = ($type$) vh.getAndBitwiseXorAcquire(array, ci, VALUE_1);
637            });
638
639            checkUOE(() -> {
640                $type$ o = ($type$) vh.getAndBitwiseXorRelease(array, ci, VALUE_1);
641            });
642#end[Bitwise]
643        }
644    }
645
646
647    static void testArrayIndexOutOfBounds(ByteArraySource bs, VarHandleSource vhs) throws Throwable {
648        VarHandle vh = vhs.s;
649        byte[] array = bs.s;
650
651        int length = array.length - SIZE + 1;
652        for (int i : new int[]{-1, Integer.MIN_VALUE, length, length + 1, Integer.MAX_VALUE}) {
653            final int ci = i;
654
655            checkIOOBE(() -> {
656                $type$ x = ($type$) vh.get(array, ci);
657            });
658
659            checkIOOBE(() -> {
660                vh.set(array, ci, VALUE_1);
661            });
662
663            checkIOOBE(() -> {
664                $type$ x = ($type$) vh.getVolatile(array, ci);
665            });
666
667            checkIOOBE(() -> {
668                $type$ x = ($type$) vh.getAcquire(array, ci);
669            });
670
671            checkIOOBE(() -> {
672                $type$ x = ($type$) vh.getOpaque(array, ci);
673            });
674
675            checkIOOBE(() -> {
676                vh.setVolatile(array, ci, VALUE_1);
677            });
678
679            checkIOOBE(() -> {
680                vh.setRelease(array, ci, VALUE_1);
681            });
682
683            checkIOOBE(() -> {
684                vh.setOpaque(array, ci, VALUE_1);
685            });
686#if[CAS]
687
688            checkIOOBE(() -> {
689                boolean r = vh.compareAndSet(array, ci, VALUE_1, VALUE_2);
690            });
691
692            checkIOOBE(() -> {
693                $type$ r = ($type$) vh.compareAndExchange(array, ci, VALUE_2, VALUE_1);
694            });
695
696            checkIOOBE(() -> {
697                $type$ r = ($type$) vh.compareAndExchangeAcquire(array, ci, VALUE_2, VALUE_1);
698            });
699
700            checkIOOBE(() -> {
701                $type$ r = ($type$) vh.compareAndExchangeRelease(array, ci, VALUE_2, VALUE_1);
702            });
703
704            checkIOOBE(() -> {
705                boolean r = vh.weakCompareAndSetPlain(array, ci, VALUE_1, VALUE_2);
706            });
707
708            checkIOOBE(() -> {
709                boolean r = vh.weakCompareAndSet(array, ci, VALUE_1, VALUE_2);
710            });
711
712            checkIOOBE(() -> {
713                boolean r = vh.weakCompareAndSetAcquire(array, ci, VALUE_1, VALUE_2);
714            });
715
716            checkIOOBE(() -> {
717                boolean r = vh.weakCompareAndSetRelease(array, ci, VALUE_1, VALUE_2);
718            });
719
720            checkIOOBE(() -> {
721                $type$ o = ($type$) vh.getAndSet(array, ci, VALUE_1);
722            });
723
724            checkIOOBE(() -> {
725                $type$ o = ($type$) vh.getAndSetAcquire(array, ci, VALUE_1);
726            });
727
728            checkIOOBE(() -> {
729                $type$ o = ($type$) vh.getAndSetRelease(array, ci, VALUE_1);
730            });
731#end[CAS]
732
733#if[AtomicAdd]
734            checkIOOBE(() -> {
735                $type$ o = ($type$) vh.getAndAdd(array, ci, VALUE_1);
736            });
737
738            checkIOOBE(() -> {
739                $type$ o = ($type$) vh.getAndAddAcquire(array, ci, VALUE_1);
740            });
741
742            checkIOOBE(() -> {
743                $type$ o = ($type$) vh.getAndAddRelease(array, ci, VALUE_1);
744            });
745#end[AtomicAdd]
746
747#if[Bitwise]
748            checkIOOBE(() -> {
749                $type$ o = ($type$) vh.getAndBitwiseOr(array, ci, VALUE_1);
750            });
751
752            checkIOOBE(() -> {
753                $type$ o = ($type$) vh.getAndBitwiseOrAcquire(array, ci, VALUE_1);
754            });
755
756            checkIOOBE(() -> {
757                $type$ o = ($type$) vh.getAndBitwiseOrRelease(array, ci, VALUE_1);
758            });
759
760            checkIOOBE(() -> {
761                $type$ o = ($type$) vh.getAndBitwiseAnd(array, ci, VALUE_1);
762            });
763
764            checkIOOBE(() -> {
765                $type$ o = ($type$) vh.getAndBitwiseAndAcquire(array, ci, VALUE_1);
766            });
767
768            checkIOOBE(() -> {
769                $type$ o = ($type$) vh.getAndBitwiseAndRelease(array, ci, VALUE_1);
770            });
771
772            checkIOOBE(() -> {
773                $type$ o = ($type$) vh.getAndBitwiseXor(array, ci, VALUE_1);
774            });
775
776            checkIOOBE(() -> {
777                $type$ o = ($type$) vh.getAndBitwiseXorAcquire(array, ci, VALUE_1);
778            });
779
780            checkIOOBE(() -> {
781                $type$ o = ($type$) vh.getAndBitwiseXorRelease(array, ci, VALUE_1);
782            });
783#end[Bitwise]
784
785        }
786    }
787
788    static void testArrayIndexOutOfBounds(ByteBufferSource bs, VarHandleSource vhs) throws Throwable {
789        VarHandle vh = vhs.s;
790        ByteBuffer array = bs.s;
791
792        boolean readOnly = MemoryMode.READ_ONLY.isSet(bs.memoryModes);
793
794        int length = array.limit() - SIZE + 1;
795        for (int i : new int[]{-1, Integer.MIN_VALUE, length, length + 1, Integer.MAX_VALUE}) {
796            final int ci = i;
797
798            checkIOOBE(() -> {
799                $type$ x = ($type$) vh.get(array, ci);
800            });
801
802            if (!readOnly) {
803                checkIOOBE(() -> {
804                    vh.set(array, ci, VALUE_1);
805                });
806            }
807
808            checkIOOBE(() -> {
809                $type$ x = ($type$) vh.getVolatile(array, ci);
810            });
811
812            checkIOOBE(() -> {
813                $type$ x = ($type$) vh.getAcquire(array, ci);
814            });
815
816            checkIOOBE(() -> {
817                $type$ x = ($type$) vh.getOpaque(array, ci);
818            });
819
820            if (!readOnly) {
821                checkIOOBE(() -> {
822                    vh.setVolatile(array, ci, VALUE_1);
823                });
824
825                checkIOOBE(() -> {
826                    vh.setRelease(array, ci, VALUE_1);
827                });
828
829                checkIOOBE(() -> {
830                    vh.setOpaque(array, ci, VALUE_1);
831                });
832
833#if[CAS]
834                checkIOOBE(() -> {
835                    boolean r = vh.compareAndSet(array, ci, VALUE_1, VALUE_2);
836                });
837
838                checkIOOBE(() -> {
839                    $type$ r = ($type$) vh.compareAndExchange(array, ci, VALUE_2, VALUE_1);
840                });
841
842                checkIOOBE(() -> {
843                    $type$ r = ($type$) vh.compareAndExchangeAcquire(array, ci, VALUE_2, VALUE_1);
844                });
845
846                checkIOOBE(() -> {
847                    $type$ r = ($type$) vh.compareAndExchangeRelease(array, ci, VALUE_2, VALUE_1);
848                });
849
850                checkIOOBE(() -> {
851                    boolean r = vh.weakCompareAndSetPlain(array, ci, VALUE_1, VALUE_2);
852                });
853
854                checkIOOBE(() -> {
855                    boolean r = vh.weakCompareAndSet(array, ci, VALUE_1, VALUE_2);
856                });
857
858                checkIOOBE(() -> {
859                    boolean r = vh.weakCompareAndSetAcquire(array, ci, VALUE_1, VALUE_2);
860                });
861
862                checkIOOBE(() -> {
863                    boolean r = vh.weakCompareAndSetRelease(array, ci, VALUE_1, VALUE_2);
864                });
865
866                checkIOOBE(() -> {
867                    $type$ o = ($type$) vh.getAndSet(array, ci, VALUE_1);
868                });
869
870                checkIOOBE(() -> {
871                    $type$ o = ($type$) vh.getAndSetAcquire(array, ci, VALUE_1);
872                });
873
874                checkIOOBE(() -> {
875                    $type$ o = ($type$) vh.getAndSetRelease(array, ci, VALUE_1);
876                });
877#end[CAS]
878
879#if[AtomicAdd]
880                checkIOOBE(() -> {
881                    $type$ o = ($type$) vh.getAndAdd(array, ci, VALUE_1);
882                });
883
884                checkIOOBE(() -> {
885                    $type$ o = ($type$) vh.getAndAddAcquire(array, ci, VALUE_1);
886                });
887
888                checkIOOBE(() -> {
889                    $type$ o = ($type$) vh.getAndAddRelease(array, ci, VALUE_1);
890                });
891#end[AtomicAdd]
892
893#if[Bitwise]
894                checkIOOBE(() -> {
895                    $type$ o = ($type$) vh.getAndBitwiseOr(array, ci, VALUE_1);
896                });
897
898                checkIOOBE(() -> {
899                    $type$ o = ($type$) vh.getAndBitwiseOrAcquire(array, ci, VALUE_1);
900                });
901
902                checkIOOBE(() -> {
903                    $type$ o = ($type$) vh.getAndBitwiseOrRelease(array, ci, VALUE_1);
904                });
905
906                checkIOOBE(() -> {
907                    $type$ o = ($type$) vh.getAndBitwiseAnd(array, ci, VALUE_1);
908                });
909
910                checkIOOBE(() -> {
911                    $type$ o = ($type$) vh.getAndBitwiseAndAcquire(array, ci, VALUE_1);
912                });
913
914                checkIOOBE(() -> {
915                    $type$ o = ($type$) vh.getAndBitwiseAndRelease(array, ci, VALUE_1);
916                });
917
918                checkIOOBE(() -> {
919                    $type$ o = ($type$) vh.getAndBitwiseXor(array, ci, VALUE_1);
920                });
921
922                checkIOOBE(() -> {
923                    $type$ o = ($type$) vh.getAndBitwiseXorAcquire(array, ci, VALUE_1);
924                });
925
926                checkIOOBE(() -> {
927                    $type$ o = ($type$) vh.getAndBitwiseXorRelease(array, ci, VALUE_1);
928                });
929#end[Bitwise]
930            }
931        }
932    }
933
934    static void testArrayMisalignedAccess(ByteArraySource bs, VarHandleSource vhs) throws Throwable {
935        VarHandle vh = vhs.s;
936        byte[] array = bs.s;
937
938        int misalignmentAtZero = ByteBuffer.wrap(array).alignmentOffset(0, SIZE);
939
940        int length = array.length - SIZE + 1;
941        for (int i = 0; i < length; i++) {
942            boolean iAligned = ((i + misalignmentAtZero) & (SIZE - 1)) == 0;
943            final int ci = i;
944
945            if (!iAligned) {
946                checkISE(() -> {
947                    $type$ x = ($type$) vh.getVolatile(array, ci);
948                });
949
950                checkISE(() -> {
951                    $type$ x = ($type$) vh.getAcquire(array, ci);
952                });
953
954                checkISE(() -> {
955                    $type$ x = ($type$) vh.getOpaque(array, ci);
956                });
957
958                checkISE(() -> {
959                    vh.setVolatile(array, ci, VALUE_1);
960                });
961
962                checkISE(() -> {
963                    vh.setRelease(array, ci, VALUE_1);
964                });
965
966                checkISE(() -> {
967                    vh.setOpaque(array, ci, VALUE_1);
968                });
969#if[CAS]
970
971                checkISE(() -> {
972                    boolean r = vh.compareAndSet(array, ci, VALUE_1, VALUE_2);
973                });
974
975                checkISE(() -> {
976                    $type$ r = ($type$) vh.compareAndExchange(array, ci, VALUE_2, VALUE_1);
977                });
978
979                checkISE(() -> {
980                    $type$ r = ($type$) vh.compareAndExchangeAcquire(array, ci, VALUE_2, VALUE_1);
981                });
982
983                checkISE(() -> {
984                    $type$ r = ($type$) vh.compareAndExchangeRelease(array, ci, VALUE_2, VALUE_1);
985                });
986
987                checkISE(() -> {
988                    boolean r = vh.weakCompareAndSetPlain(array, ci, VALUE_1, VALUE_2);
989                });
990
991                checkISE(() -> {
992                    boolean r = vh.weakCompareAndSet(array, ci, VALUE_1, VALUE_2);
993                });
994
995                checkISE(() -> {
996                    boolean r = vh.weakCompareAndSetAcquire(array, ci, VALUE_1, VALUE_2);
997                });
998
999                checkISE(() -> {
1000                    boolean r = vh.weakCompareAndSetRelease(array, ci, VALUE_1, VALUE_2);
1001                });
1002
1003                checkISE(() -> {
1004                    $type$ o = ($type$) vh.getAndSet(array, ci, VALUE_1);
1005                });
1006
1007                checkISE(() -> {
1008                    $type$ o = ($type$) vh.getAndSetAcquire(array, ci, VALUE_1);
1009                });
1010
1011                checkISE(() -> {
1012                    $type$ o = ($type$) vh.getAndSetRelease(array, ci, VALUE_1);
1013                });
1014#end[CAS]
1015
1016#if[AtomicAdd]
1017                checkISE(() -> {
1018                    $type$ o = ($type$) vh.getAndAdd(array, ci, VALUE_1);
1019                });
1020
1021                checkISE(() -> {
1022                    $type$ o = ($type$) vh.getAndAddAcquire(array, ci, VALUE_1);
1023                });
1024
1025                checkISE(() -> {
1026                    $type$ o = ($type$) vh.getAndAddRelease(array, ci, VALUE_1);
1027                });
1028#end[AtomicAdd]
1029
1030#if[Bitwise]
1031                checkISE(() -> {
1032                    $type$ o = ($type$) vh.getAndBitwiseOr(array, ci, VALUE_1);
1033                });
1034
1035                checkISE(() -> {
1036                    $type$ o = ($type$) vh.getAndBitwiseOrAcquire(array, ci, VALUE_1);
1037                });
1038
1039                checkISE(() -> {
1040                    $type$ o = ($type$) vh.getAndBitwiseOrRelease(array, ci, VALUE_1);
1041                });
1042
1043                checkISE(() -> {
1044                    $type$ o = ($type$) vh.getAndBitwiseAnd(array, ci, VALUE_1);
1045                });
1046
1047                checkISE(() -> {
1048                    $type$ o = ($type$) vh.getAndBitwiseAndAcquire(array, ci, VALUE_1);
1049                });
1050
1051                checkISE(() -> {
1052                    $type$ o = ($type$) vh.getAndBitwiseAndRelease(array, ci, VALUE_1);
1053                });
1054
1055                checkISE(() -> {
1056                    $type$ o = ($type$) vh.getAndBitwiseXor(array, ci, VALUE_1);
1057                });
1058
1059                checkISE(() -> {
1060                    $type$ o = ($type$) vh.getAndBitwiseXorAcquire(array, ci, VALUE_1);
1061                });
1062
1063                checkISE(() -> {
1064                    $type$ o = ($type$) vh.getAndBitwiseXorRelease(array, ci, VALUE_1);
1065                });
1066#end[Bitwise]
1067            }
1068        }
1069    }
1070
1071    static void testArrayMisalignedAccess(ByteBufferSource bs, VarHandleSource vhs) throws Throwable {
1072        VarHandle vh = vhs.s;
1073        ByteBuffer array = bs.s;
1074
1075        boolean readOnly = MemoryMode.READ_ONLY.isSet(bs.memoryModes);
1076        int misalignmentAtZero = array.alignmentOffset(0, SIZE);
1077
1078        int length = array.limit() - SIZE + 1;
1079        for (int i = 0; i < length; i++) {
1080            boolean iAligned = ((i + misalignmentAtZero) & (SIZE - 1)) == 0;
1081            final int ci = i;
1082
1083            if (!iAligned) {
1084                checkISE(() -> {
1085                    $type$ x = ($type$) vh.getVolatile(array, ci);
1086                });
1087
1088                checkISE(() -> {
1089                    $type$ x = ($type$) vh.getAcquire(array, ci);
1090                });
1091
1092                checkISE(() -> {
1093                    $type$ x = ($type$) vh.getOpaque(array, ci);
1094                });
1095
1096                if (!readOnly) {
1097                    checkISE(() -> {
1098                        vh.setVolatile(array, ci, VALUE_1);
1099                    });
1100
1101                    checkISE(() -> {
1102                        vh.setRelease(array, ci, VALUE_1);
1103                    });
1104
1105                    checkISE(() -> {
1106                        vh.setOpaque(array, ci, VALUE_1);
1107                    });
1108
1109#if[CAS]
1110                    checkISE(() -> {
1111                        boolean r = vh.compareAndSet(array, ci, VALUE_1, VALUE_2);
1112                    });
1113
1114                    checkISE(() -> {
1115                        $type$ r = ($type$) vh.compareAndExchange(array, ci, VALUE_2, VALUE_1);
1116                    });
1117
1118                    checkISE(() -> {
1119                        $type$ r = ($type$) vh.compareAndExchangeAcquire(array, ci, VALUE_2, VALUE_1);
1120                    });
1121
1122                    checkISE(() -> {
1123                        $type$ r = ($type$) vh.compareAndExchangeRelease(array, ci, VALUE_2, VALUE_1);
1124                    });
1125
1126                    checkISE(() -> {
1127                        boolean r = vh.weakCompareAndSetPlain(array, ci, VALUE_1, VALUE_2);
1128                    });
1129
1130                    checkISE(() -> {
1131                        boolean r = vh.weakCompareAndSet(array, ci, VALUE_1, VALUE_2);
1132                    });
1133
1134                    checkISE(() -> {
1135                        boolean r = vh.weakCompareAndSetAcquire(array, ci, VALUE_1, VALUE_2);
1136                    });
1137
1138                    checkISE(() -> {
1139                        boolean r = vh.weakCompareAndSetRelease(array, ci, VALUE_1, VALUE_2);
1140                    });
1141
1142                    checkISE(() -> {
1143                        $type$ o = ($type$) vh.getAndSet(array, ci, VALUE_1);
1144                    });
1145
1146                    checkISE(() -> {
1147                        $type$ o = ($type$) vh.getAndSetAcquire(array, ci, VALUE_1);
1148                    });
1149
1150                    checkISE(() -> {
1151                        $type$ o = ($type$) vh.getAndSetRelease(array, ci, VALUE_1);
1152                    });
1153#end[CAS]
1154
1155#if[AtomicAdd]
1156                    checkISE(() -> {
1157                        $type$ o = ($type$) vh.getAndAdd(array, ci, VALUE_1);
1158                    });
1159
1160                    checkISE(() -> {
1161                        $type$ o = ($type$) vh.getAndAddAcquire(array, ci, VALUE_1);
1162                    });
1163
1164                    checkISE(() -> {
1165                        $type$ o = ($type$) vh.getAndAddRelease(array, ci, VALUE_1);
1166                    });
1167#end[AtomicAdd]
1168
1169#if[Bitwise]
1170                    checkISE(() -> {
1171                        $type$ o = ($type$) vh.getAndBitwiseOr(array, ci, VALUE_1);
1172                    });
1173
1174                    checkISE(() -> {
1175                        $type$ o = ($type$) vh.getAndBitwiseOrAcquire(array, ci, VALUE_1);
1176                    });
1177
1178                    checkISE(() -> {
1179                        $type$ o = ($type$) vh.getAndBitwiseOrRelease(array, ci, VALUE_1);
1180                    });
1181
1182                    checkISE(() -> {
1183                        $type$ o = ($type$) vh.getAndBitwiseAnd(array, ci, VALUE_1);
1184                    });
1185
1186                    checkISE(() -> {
1187                        $type$ o = ($type$) vh.getAndBitwiseAndAcquire(array, ci, VALUE_1);
1188                    });
1189
1190                    checkISE(() -> {
1191                        $type$ o = ($type$) vh.getAndBitwiseAndRelease(array, ci, VALUE_1);
1192                    });
1193
1194                    checkISE(() -> {
1195                        $type$ o = ($type$) vh.getAndBitwiseXor(array, ci, VALUE_1);
1196                    });
1197
1198                    checkISE(() -> {
1199                        $type$ o = ($type$) vh.getAndBitwiseXorAcquire(array, ci, VALUE_1);
1200                    });
1201
1202                    checkISE(() -> {
1203                        $type$ o = ($type$) vh.getAndBitwiseXorRelease(array, ci, VALUE_1);
1204                    });
1205#end[Bitwise]
1206                }
1207            }
1208        }
1209    }
1210
1211    static void testArrayReadWrite(ByteArraySource bs, VarHandleSource vhs) {
1212        VarHandle vh = vhs.s;
1213        byte[] array = bs.s;
1214
1215        int misalignmentAtZero = ByteBuffer.wrap(array).alignmentOffset(0, SIZE);
1216
1217        bs.fill((byte) 0xff);
1218        int length = array.length - SIZE + 1;
1219        for (int i = 0; i < length; i++) {
1220            boolean iAligned = ((i + misalignmentAtZero) & (SIZE - 1)) == 0;
1221
1222            // Plain
1223            {
1224                vh.set(array, i, VALUE_1);
1225                $type$ x = ($type$) vh.get(array, i);
1226                assertEquals(x, VALUE_1, "get $type$ value");
1227            }
1228
1229
1230            if (iAligned) {
1231                // Volatile
1232                {
1233                    vh.setVolatile(array, i, VALUE_2);
1234                    $type$ x = ($type$) vh.getVolatile(array, i);
1235                    assertEquals(x, VALUE_2, "setVolatile $type$ value");
1236                }
1237
1238                // Lazy
1239                {
1240                    vh.setRelease(array, i, VALUE_1);
1241                    $type$ x = ($type$) vh.getAcquire(array, i);
1242                    assertEquals(x, VALUE_1, "setRelease $type$ value");
1243                }
1244
1245                // Opaque
1246                {
1247                    vh.setOpaque(array, i, VALUE_2);
1248                    $type$ x = ($type$) vh.getOpaque(array, i);
1249                    assertEquals(x, VALUE_2, "setOpaque $type$ value");
1250                }
1251#if[CAS]
1252
1253                vh.set(array, i, VALUE_1);
1254
1255                // Compare
1256                {
1257                    boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_2);
1258                    assertEquals(r, true, "success compareAndSet $type$");
1259                    $type$ x = ($type$) vh.get(array, i);
1260                    assertEquals(x, VALUE_2, "success compareAndSet $type$ value");
1261                }
1262
1263                {
1264                    boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_3);
1265                    assertEquals(r, false, "failing compareAndSet $type$");
1266                    $type$ x = ($type$) vh.get(array, i);
1267                    assertEquals(x, VALUE_2, "failing compareAndSet $type$ value");
1268                }
1269
1270                {
1271                    $type$ r = ($type$) vh.compareAndExchange(array, i, VALUE_2, VALUE_1);
1272                    assertEquals(r, VALUE_2, "success compareAndExchange $type$");
1273                    $type$ x = ($type$) vh.get(array, i);
1274                    assertEquals(x, VALUE_1, "success compareAndExchange $type$ value");
1275                }
1276
1277                {
1278                    $type$ r = ($type$) vh.compareAndExchange(array, i, VALUE_2, VALUE_3);
1279                    assertEquals(r, VALUE_1, "failing compareAndExchange $type$");
1280                    $type$ x = ($type$) vh.get(array, i);
1281                    assertEquals(x, VALUE_1, "failing compareAndExchange $type$ value");
1282                }
1283
1284                {
1285                    $type$ r = ($type$) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_2);
1286                    assertEquals(r, VALUE_1, "success compareAndExchangeAcquire $type$");
1287                    $type$ x = ($type$) vh.get(array, i);
1288                    assertEquals(x, VALUE_2, "success compareAndExchangeAcquire $type$ value");
1289                }
1290
1291                {
1292                    $type$ r = ($type$) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_3);
1293                    assertEquals(r, VALUE_2, "failing compareAndExchangeAcquire $type$");
1294                    $type$ x = ($type$) vh.get(array, i);
1295                    assertEquals(x, VALUE_2, "failing compareAndExchangeAcquire $type$ value");
1296                }
1297
1298                {
1299                    $type$ r = ($type$) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_1);
1300                    assertEquals(r, VALUE_2, "success compareAndExchangeRelease $type$");
1301                    $type$ x = ($type$) vh.get(array, i);
1302                    assertEquals(x, VALUE_1, "success compareAndExchangeRelease $type$ value");
1303                }
1304
1305                {
1306                    $type$ r = ($type$) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_3);
1307                    assertEquals(r, VALUE_1, "failing compareAndExchangeRelease $type$");
1308                    $type$ x = ($type$) vh.get(array, i);
1309                    assertEquals(x, VALUE_1, "failing compareAndExchangeRelease $type$ value");
1310                }
1311
1312                {
1313                    boolean success = false;
1314                    for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1315                        success = vh.weakCompareAndSetPlain(array, i, VALUE_1, VALUE_2);
1316                    }
1317                    assertEquals(success, true, "weakCompareAndSetPlain $type$");
1318                    $type$ x = ($type$) vh.get(array, i);
1319                    assertEquals(x, VALUE_2, "weakCompareAndSetPlain $type$ value");
1320                }
1321
1322                {
1323                    boolean success = false;
1324                    for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1325                        success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
1326                    }
1327                    assertEquals(success, true, "weakCompareAndSetAcquire $type$");
1328                    $type$ x = ($type$) vh.get(array, i);
1329                    assertEquals(x, VALUE_1, "weakCompareAndSetAcquire $type$");
1330                }
1331
1332                {
1333                    boolean success = false;
1334                    for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1335                        success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
1336                    }
1337                    assertEquals(success, true, "weakCompareAndSetRelease $type$");
1338                    $type$ x = ($type$) vh.get(array, i);
1339                    assertEquals(x, VALUE_2, "weakCompareAndSetRelease $type$");
1340                }
1341
1342                {
1343                    boolean success = false;
1344                    for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1345                        success = vh.weakCompareAndSet(array, i, VALUE_2, VALUE_1);
1346                    }
1347                    assertEquals(success, true, "weakCompareAndSet $type$");
1348                    $type$ x = ($type$) vh.get(array, i);
1349                    assertEquals(x, VALUE_1, "weakCompareAndSet $type$");
1350                }
1351
1352                // Compare set and get
1353                {
1354                    vh.set(array, i, VALUE_1);
1355
1356                    $type$ o = ($type$) vh.getAndSet(array, i, VALUE_2);
1357                    assertEquals(o, VALUE_1, "getAndSet $type$");
1358                    $type$ x = ($type$) vh.get(array, i);
1359                    assertEquals(x, VALUE_2, "getAndSet $type$ value");
1360                }
1361
1362                {
1363                    vh.set(array, i, VALUE_1);
1364
1365                    $type$ o = ($type$) vh.getAndSetAcquire(array, i, VALUE_2);
1366                    assertEquals(o, VALUE_1, "getAndSetAcquire $type$");
1367                    $type$ x = ($type$) vh.get(array, i);
1368                    assertEquals(x, VALUE_2, "getAndSetAcquire $type$ value");
1369                }
1370
1371                {
1372                    vh.set(array, i, VALUE_1);
1373
1374                    $type$ o = ($type$) vh.getAndSetRelease(array, i, VALUE_2);
1375                    assertEquals(o, VALUE_1, "getAndSetRelease $type$");
1376                    $type$ x = ($type$) vh.get(array, i);
1377                    assertEquals(x, VALUE_2, "getAndSetRelease $type$ value");
1378                }
1379#end[CAS]
1380
1381#if[AtomicAdd]
1382                // get and add, add and get
1383                {
1384                    vh.set(array, i, VALUE_1);
1385
1386                    $type$ o = ($type$) vh.getAndAdd(array, i, VALUE_2);
1387                    assertEquals(o, VALUE_1, "getAndAdd $type$");
1388                    $type$ x = ($type$) vh.get(array, i);
1389                    assertEquals(x, VALUE_1 + VALUE_2, "getAndAdd $type$ value");
1390                }
1391
1392                {
1393                    vh.set(array, i, VALUE_1);
1394
1395                    $type$ o = ($type$) vh.getAndAddAcquire(array, i, VALUE_2);
1396                    assertEquals(o, VALUE_1, "getAndAddAcquire $type$");
1397                    $type$ x = ($type$) vh.get(array, i);
1398                    assertEquals(x, VALUE_1 + VALUE_2, "getAndAddAcquire $type$ value");
1399                }
1400
1401                {
1402                    vh.set(array, i, VALUE_1);
1403
1404                    $type$ o = ($type$) vh.getAndAddRelease(array, i, VALUE_2);
1405                    assertEquals(o, VALUE_1, "getAndAddRelease $type$");
1406                    $type$ x = ($type$) vh.get(array, i);
1407                    assertEquals(x, VALUE_1 + VALUE_2, "getAndAddRelease $type$ value");
1408                }
1409#end[AtomicAdd]
1410
1411#if[Bitwise]
1412                // get and bitwise or
1413                {
1414                    vh.set(array, i, VALUE_1);
1415
1416                    $type$ o = ($type$) vh.getAndBitwiseOr(array, i, VALUE_2);
1417                    assertEquals(o, VALUE_1, "getAndBitwiseOr $type$");
1418                    $type$ x = ($type$) vh.get(array, i);
1419                    assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOr $type$ value");
1420                }
1421
1422                {
1423                    vh.set(array, i, VALUE_1);
1424
1425                    $type$ o = ($type$) vh.getAndBitwiseOrAcquire(array, i, VALUE_2);
1426                    assertEquals(o, VALUE_1, "getAndBitwiseOrAcquire $type$");
1427                    $type$ x = ($type$) vh.get(array, i);
1428                    assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOrAcquire $type$ value");
1429                }
1430
1431                {
1432                    vh.set(array, i, VALUE_1);
1433
1434                    $type$ o = ($type$) vh.getAndBitwiseOrRelease(array, i, VALUE_2);
1435                    assertEquals(o, VALUE_1, "getAndBitwiseOrRelease $type$");
1436                    $type$ x = ($type$) vh.get(array, i);
1437                    assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOrRelease $type$ value");
1438                }
1439
1440                // get and bitwise and
1441                {
1442                    vh.set(array, i, VALUE_1);
1443
1444                    $type$ o = ($type$) vh.getAndBitwiseAnd(array, i, VALUE_2);
1445                    assertEquals(o, VALUE_1, "getAndBitwiseAnd $type$");
1446                    $type$ x = ($type$) vh.get(array, i);
1447                    assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAnd $type$ value");
1448                }
1449
1450                {
1451                    vh.set(array, i, VALUE_1);
1452
1453                    $type$ o = ($type$) vh.getAndBitwiseAndAcquire(array, i, VALUE_2);
1454                    assertEquals(o, VALUE_1, "getAndBitwiseAndAcquire $type$");
1455                    $type$ x = ($type$) vh.get(array, i);
1456                    assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAndAcquire $type$ value");
1457                }
1458
1459                {
1460                    vh.set(array, i, VALUE_1);
1461
1462                    $type$ o = ($type$) vh.getAndBitwiseAndRelease(array, i, VALUE_2);
1463                    assertEquals(o, VALUE_1, "getAndBitwiseAndRelease $type$");
1464                    $type$ x = ($type$) vh.get(array, i);
1465                    assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAndRelease $type$ value");
1466                }
1467
1468                // get and bitwise xor
1469                {
1470                    vh.set(array, i, VALUE_1);
1471
1472                    $type$ o = ($type$) vh.getAndBitwiseXor(array, i, VALUE_2);
1473                    assertEquals(o, VALUE_1, "getAndBitwiseXor $type$");
1474                    $type$ x = ($type$) vh.get(array, i);
1475                    assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXor $type$ value");
1476                }
1477
1478                {
1479                    vh.set(array, i, VALUE_1);
1480
1481                    $type$ o = ($type$) vh.getAndBitwiseXorAcquire(array, i, VALUE_2);
1482                    assertEquals(o, VALUE_1, "getAndBitwiseXorAcquire $type$");
1483                    $type$ x = ($type$) vh.get(array, i);
1484                    assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXorAcquire $type$ value");
1485                }
1486
1487                {
1488                    vh.set(array, i, VALUE_1);
1489
1490                    $type$ o = ($type$) vh.getAndBitwiseXorRelease(array, i, VALUE_2);
1491                    assertEquals(o, VALUE_1, "getAndBitwiseXorRelease $type$");
1492                    $type$ x = ($type$) vh.get(array, i);
1493                    assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXorRelease $type$ value");
1494                }
1495#end[Bitwise]
1496            }
1497        }
1498    }
1499
1500
1501    static void testArrayReadWrite(ByteBufferSource bs, VarHandleSource vhs) {
1502        VarHandle vh = vhs.s;
1503        ByteBuffer array = bs.s;
1504
1505        int misalignmentAtZero = array.alignmentOffset(0, SIZE);
1506
1507        bs.fill((byte) 0xff);
1508        int length = array.limit() - SIZE + 1;
1509        for (int i = 0; i < length; i++) {
1510            boolean iAligned = ((i + misalignmentAtZero) & (SIZE - 1)) == 0;
1511
1512            // Plain
1513            {
1514                vh.set(array, i, VALUE_1);
1515                $type$ x = ($type$) vh.get(array, i);
1516                assertEquals(x, VALUE_1, "get $type$ value");
1517            }
1518
1519            if (iAligned) {
1520                // Volatile
1521                {
1522                    vh.setVolatile(array, i, VALUE_2);
1523                    $type$ x = ($type$) vh.getVolatile(array, i);
1524                    assertEquals(x, VALUE_2, "setVolatile $type$ value");
1525                }
1526
1527                // Lazy
1528                {
1529                    vh.setRelease(array, i, VALUE_1);
1530                    $type$ x = ($type$) vh.getAcquire(array, i);
1531                    assertEquals(x, VALUE_1, "setRelease $type$ value");
1532                }
1533
1534                // Opaque
1535                {
1536                    vh.setOpaque(array, i, VALUE_2);
1537                    $type$ x = ($type$) vh.getOpaque(array, i);
1538                    assertEquals(x, VALUE_2, "setOpaque $type$ value");
1539                }
1540#if[CAS]
1541
1542                vh.set(array, i, VALUE_1);
1543
1544                // Compare
1545                {
1546                    boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_2);
1547                    assertEquals(r, true, "success compareAndSet $type$");
1548                    $type$ x = ($type$) vh.get(array, i);
1549                    assertEquals(x, VALUE_2, "success compareAndSet $type$ value");
1550                }
1551
1552                {
1553                    boolean r = vh.compareAndSet(array, i, VALUE_1, VALUE_3);
1554                    assertEquals(r, false, "failing compareAndSet $type$");
1555                    $type$ x = ($type$) vh.get(array, i);
1556                    assertEquals(x, VALUE_2, "failing compareAndSet $type$ value");
1557                }
1558
1559                {
1560                    $type$ r = ($type$) vh.compareAndExchange(array, i, VALUE_2, VALUE_1);
1561                    assertEquals(r, VALUE_2, "success compareAndExchange $type$");
1562                    $type$ x = ($type$) vh.get(array, i);
1563                    assertEquals(x, VALUE_1, "success compareAndExchange $type$ value");
1564                }
1565
1566                {
1567                    $type$ r = ($type$) vh.compareAndExchange(array, i, VALUE_2, VALUE_3);
1568                    assertEquals(r, VALUE_1, "failing compareAndExchange $type$");
1569                    $type$ x = ($type$) vh.get(array, i);
1570                    assertEquals(x, VALUE_1, "failing compareAndExchange $type$ value");
1571                }
1572
1573                {
1574                    $type$ r = ($type$) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_2);
1575                    assertEquals(r, VALUE_1, "success compareAndExchangeAcquire $type$");
1576                    $type$ x = ($type$) vh.get(array, i);
1577                    assertEquals(x, VALUE_2, "success compareAndExchangeAcquire $type$ value");
1578                }
1579
1580                {
1581                    $type$ r = ($type$) vh.compareAndExchangeAcquire(array, i, VALUE_1, VALUE_3);
1582                    assertEquals(r, VALUE_2, "failing compareAndExchangeAcquire $type$");
1583                    $type$ x = ($type$) vh.get(array, i);
1584                    assertEquals(x, VALUE_2, "failing compareAndExchangeAcquire $type$ value");
1585                }
1586
1587                {
1588                    $type$ r = ($type$) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_1);
1589                    assertEquals(r, VALUE_2, "success compareAndExchangeRelease $type$");
1590                    $type$ x = ($type$) vh.get(array, i);
1591                    assertEquals(x, VALUE_1, "success compareAndExchangeRelease $type$ value");
1592                }
1593
1594                {
1595                    $type$ r = ($type$) vh.compareAndExchangeRelease(array, i, VALUE_2, VALUE_3);
1596                    assertEquals(r, VALUE_1, "failing compareAndExchangeRelease $type$");
1597                    $type$ x = ($type$) vh.get(array, i);
1598                    assertEquals(x, VALUE_1, "failing compareAndExchangeRelease $type$ value");
1599                }
1600
1601                {
1602                    boolean success = false;
1603                    for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1604                        success = vh.weakCompareAndSetPlain(array, i, VALUE_1, VALUE_2);
1605                    }
1606                    assertEquals(success, true, "weakCompareAndSetPlain $type$");
1607                    $type$ x = ($type$) vh.get(array, i);
1608                    assertEquals(x, VALUE_2, "weakCompareAndSetPlain $type$ value");
1609                }
1610
1611                {
1612                    boolean success = false;
1613                    for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1614                        success = vh.weakCompareAndSetAcquire(array, i, VALUE_2, VALUE_1);
1615                    }
1616                    assertEquals(success, true, "weakCompareAndSetAcquire $type$");
1617                    $type$ x = ($type$) vh.get(array, i);
1618                    assertEquals(x, VALUE_1, "weakCompareAndSetAcquire $type$");
1619                }
1620
1621                {
1622                    boolean success = false;
1623                    for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1624                        success = vh.weakCompareAndSetRelease(array, i, VALUE_1, VALUE_2);
1625                    }
1626                    assertEquals(success, true, "weakCompareAndSetRelease $type$");
1627                    $type$ x = ($type$) vh.get(array, i);
1628                    assertEquals(x, VALUE_2, "weakCompareAndSetRelease $type$");
1629                }
1630
1631                {
1632                    boolean success = false;
1633                    for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
1634                        success = vh.weakCompareAndSet(array, i, VALUE_2, VALUE_1);
1635                    }
1636                    assertEquals(success, true, "weakCompareAndSet $type$");
1637                    $type$ x = ($type$) vh.get(array, i);
1638                    assertEquals(x, VALUE_1, "weakCompareAndSet $type$");
1639                }
1640
1641                // Compare set and get
1642                {
1643                    vh.set(array, i, VALUE_1);
1644
1645                    $type$ o = ($type$) vh.getAndSet(array, i, VALUE_2);
1646                    assertEquals(o, VALUE_1, "getAndSet $type$");
1647                    $type$ x = ($type$) vh.get(array, i);
1648                    assertEquals(x, VALUE_2, "getAndSet $type$ value");
1649                }
1650
1651                {
1652                    vh.set(array, i, VALUE_1);
1653
1654                    $type$ o = ($type$) vh.getAndSetAcquire(array, i, VALUE_2);
1655                    assertEquals(o, VALUE_1, "getAndSetAcquire $type$");
1656                    $type$ x = ($type$) vh.get(array, i);
1657                    assertEquals(x, VALUE_2, "getAndSetAcquire $type$ value");
1658                }
1659
1660                {
1661                    vh.set(array, i, VALUE_1);
1662
1663                    $type$ o = ($type$) vh.getAndSetRelease(array, i, VALUE_2);
1664                    assertEquals(o, VALUE_1, "getAndSetRelease $type$");
1665                    $type$ x = ($type$) vh.get(array, i);
1666                    assertEquals(x, VALUE_2, "getAndSetRelease $type$ value");
1667                }
1668#end[CAS]
1669
1670#if[AtomicAdd]
1671                // get and add, add and get
1672                {
1673                    vh.set(array, i, VALUE_1);
1674
1675                    $type$ o = ($type$) vh.getAndAdd(array, i, VALUE_2);
1676                    assertEquals(o, VALUE_1, "getAndAdd $type$");
1677                    $type$ x = ($type$) vh.get(array, i);
1678                    assertEquals(x, VALUE_1 + VALUE_2, "getAndAdd $type$ value");
1679                }
1680
1681                {
1682                    vh.set(array, i, VALUE_1);
1683
1684                    $type$ o = ($type$) vh.getAndAddAcquire(array, i, VALUE_2);
1685                    assertEquals(o, VALUE_1, "getAndAddAcquire $type$");
1686                    $type$ x = ($type$) vh.get(array, i);
1687                    assertEquals(x, VALUE_1 + VALUE_2, "getAndAddAcquire $type$ value");
1688                }
1689
1690                {
1691                    vh.set(array, i, VALUE_1);
1692
1693                    $type$ o = ($type$) vh.getAndAddRelease(array, i, VALUE_2);
1694                    assertEquals(o, VALUE_1, "getAndAddRelease $type$");
1695                    $type$ x = ($type$) vh.get(array, i);
1696                    assertEquals(x, VALUE_1 + VALUE_2, "getAndAddRelease $type$ value");
1697                }
1698#end[AtomicAdd]
1699
1700#if[Bitwise]
1701                // get and bitwise or
1702                {
1703                    vh.set(array, i, VALUE_1);
1704
1705                    $type$ o = ($type$) vh.getAndBitwiseOr(array, i, VALUE_2);
1706                    assertEquals(o, VALUE_1, "getAndBitwiseOr $type$");
1707                    $type$ x = ($type$) vh.get(array, i);
1708                    assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOr $type$ value");
1709                }
1710
1711                {
1712                    vh.set(array, i, VALUE_1);
1713
1714                    $type$ o = ($type$) vh.getAndBitwiseOrAcquire(array, i, VALUE_2);
1715                    assertEquals(o, VALUE_1, "getAndBitwiseOrAcquire $type$");
1716                    $type$ x = ($type$) vh.get(array, i);
1717                    assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOrAcquire $type$ value");
1718                }
1719
1720                {
1721                    vh.set(array, i, VALUE_1);
1722
1723                    $type$ o = ($type$) vh.getAndBitwiseOrRelease(array, i, VALUE_2);
1724                    assertEquals(o, VALUE_1, "getAndBitwiseOrRelease $type$");
1725                    $type$ x = ($type$) vh.get(array, i);
1726                    assertEquals(x, VALUE_1 | VALUE_2, "getAndBitwiseOrRelease $type$ value");
1727                }
1728
1729                // get and bitwise and
1730                {
1731                    vh.set(array, i, VALUE_1);
1732
1733                    $type$ o = ($type$) vh.getAndBitwiseAnd(array, i, VALUE_2);
1734                    assertEquals(o, VALUE_1, "getAndBitwiseAnd $type$");
1735                    $type$ x = ($type$) vh.get(array, i);
1736                    assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAnd $type$ value");
1737                }
1738
1739                {
1740                    vh.set(array, i, VALUE_1);
1741
1742                    $type$ o = ($type$) vh.getAndBitwiseAndAcquire(array, i, VALUE_2);
1743                    assertEquals(o, VALUE_1, "getAndBitwiseAndAcquire $type$");
1744                    $type$ x = ($type$) vh.get(array, i);
1745                    assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAndAcquire $type$ value");
1746                }
1747
1748                {
1749                    vh.set(array, i, VALUE_1);
1750
1751                    $type$ o = ($type$) vh.getAndBitwiseAndRelease(array, i, VALUE_2);
1752                    assertEquals(o, VALUE_1, "getAndBitwiseAndRelease $type$");
1753                    $type$ x = ($type$) vh.get(array, i);
1754                    assertEquals(x, VALUE_1 & VALUE_2, "getAndBitwiseAndRelease $type$ value");
1755                }
1756
1757                // get and bitwise xor
1758                {
1759                    vh.set(array, i, VALUE_1);
1760
1761                    $type$ o = ($type$) vh.getAndBitwiseXor(array, i, VALUE_2);
1762                    assertEquals(o, VALUE_1, "getAndBitwiseXor $type$");
1763                    $type$ x = ($type$) vh.get(array, i);
1764                    assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXor $type$ value");
1765                }
1766
1767                {
1768                    vh.set(array, i, VALUE_1);
1769
1770                    $type$ o = ($type$) vh.getAndBitwiseXorAcquire(array, i, VALUE_2);
1771                    assertEquals(o, VALUE_1, "getAndBitwiseXorAcquire $type$");
1772                    $type$ x = ($type$) vh.get(array, i);
1773                    assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXorAcquire $type$ value");
1774                }
1775
1776                {
1777                    vh.set(array, i, VALUE_1);
1778
1779                    $type$ o = ($type$) vh.getAndBitwiseXorRelease(array, i, VALUE_2);
1780                    assertEquals(o, VALUE_1, "getAndBitwiseXorRelease $type$");
1781                    $type$ x = ($type$) vh.get(array, i);
1782                    assertEquals(x, VALUE_1 ^ VALUE_2, "getAndBitwiseXorRelease $type$ value");
1783                }
1784#end[Bitwise]
1785            }
1786        }
1787    }
1788
1789    static void testArrayReadOnly(ByteBufferSource bs, VarHandleSource vhs) {
1790        VarHandle vh = vhs.s;
1791        ByteBuffer array = bs.s;
1792
1793        int misalignmentAtZero = array.alignmentOffset(0, SIZE);
1794
1795        ByteBuffer bb = ByteBuffer.allocate(SIZE);
1796        bb.order(MemoryMode.BIG_ENDIAN.isSet(vhs.memoryModes) ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN);
1797        bs.fill(bb.put$Type$(0, VALUE_2).array());
1798
1799        int length = array.limit() - SIZE + 1;
1800        for (int i = 0; i < length; i++) {
1801            boolean iAligned = ((i + misalignmentAtZero) & (SIZE - 1)) == 0;
1802
1803            $type$ v = MemoryMode.BIG_ENDIAN.isSet(vhs.memoryModes)
1804                    ? rotateLeft(VALUE_2, (i % SIZE) << 3)
1805                    : rotateRight(VALUE_2, (i % SIZE) << 3);
1806            // Plain
1807            {
1808                $type$ x = ($type$) vh.get(array, i);
1809                assertEquals(x, v, "get $type$ value");
1810            }
1811
1812            if (iAligned) {
1813                // Volatile
1814                {
1815                    $type$ x = ($type$) vh.getVolatile(array, i);
1816                    assertEquals(x, v, "getVolatile $type$ value");
1817                }
1818
1819                // Lazy
1820                {
1821                    $type$ x = ($type$) vh.getAcquire(array, i);
1822                    assertEquals(x, v, "getRelease $type$ value");
1823                }
1824
1825                // Opaque
1826                {
1827                    $type$ x = ($type$) vh.getOpaque(array, i);
1828                    assertEquals(x, v, "getOpaque $type$ value");
1829                }
1830            }
1831        }
1832    }
1833
1834}
1835
1836