1 /*
2  * Copyright (c) 2019, 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 /*
26  * @test
27  * @run testng TestVarHandleCombinators
28  */
29 
30 import jdk.incubator.foreign.MemoryHandles;
31 import jdk.incubator.foreign.ResourceScope;
32 import org.testng.annotations.DataProvider;
33 import org.testng.annotations.Test;
34 
35 import jdk.incubator.foreign.MemorySegment;
36 
37 import java.lang.invoke.VarHandle;
38 import java.nio.ByteOrder;
39 
40 import static org.testng.Assert.assertEquals;
41 
42 public class TestVarHandleCombinators {
43 
44     @Test
testElementAccess()45     public void testElementAccess() {
46         VarHandle vh = MemoryHandles.varHandle(byte.class, ByteOrder.nativeOrder());
47 
48         byte[] arr = { 0, 0, -1, 0 };
49         MemorySegment segment = MemorySegment.ofArray(arr);
50         assertEquals((byte) vh.get(segment, 2), (byte) -1);
51     }
52 
53     @Test(expectedExceptions = IllegalStateException.class)
testUnalignedElement()54     public void testUnalignedElement() {
55         VarHandle vh = MemoryHandles.varHandle(byte.class, 4, ByteOrder.nativeOrder());
56         MemorySegment segment = MemorySegment.ofArray(new byte[4]);
57         vh.get(segment, 2L); //should throw
58         //FIXME: the VH only checks the alignment of the segment, which is fine if the VH is derived from layouts,
59         //FIXME: but not if the VH is just created from scratch - we need a VH variable to govern this property,
60         //FIXME: at least until the VM is fixed
61     }
62 
63     @Test(expectedExceptions = IllegalArgumentException.class)
testAlignNotPowerOf2()64     public void testAlignNotPowerOf2() {
65         VarHandle vh = MemoryHandles.varHandle(byte.class, 3, ByteOrder.nativeOrder());
66     }
67 
68     @Test(expectedExceptions = IllegalArgumentException.class)
testAlignNegative()69     public void testAlignNegative() {
70         VarHandle vh = MemoryHandles.varHandle(byte.class, -1, ByteOrder.nativeOrder());
71     }
72 
73     @Test
testAlign()74     public void testAlign() {
75         VarHandle vh = MemoryHandles.varHandle(byte.class, 2, ByteOrder.nativeOrder());
76 
77         MemorySegment segment = MemorySegment.allocateNative(1, 2, ResourceScope.newImplicitScope());
78         vh.set(segment, 0L, (byte) 10); // fine, memory region is aligned
79         assertEquals((byte) vh.get(segment, 0L), (byte) 10);
80     }
81 
82     @Test
testByteOrderLE()83     public void testByteOrderLE() {
84         VarHandle vh = MemoryHandles.varHandle(short.class, 2, ByteOrder.LITTLE_ENDIAN);
85         byte[] arr = new byte[2];
86         MemorySegment segment = MemorySegment.ofArray(arr);
87         vh.set(segment, 0L, (short) 0xFF);
88         assertEquals(arr[0], (byte) 0xFF);
89         assertEquals(arr[1], (byte) 0);
90     }
91 
92     @Test
testByteOrderBE()93     public void testByteOrderBE() {
94         VarHandle vh = MemoryHandles.varHandle(short.class, 2, ByteOrder.BIG_ENDIAN);
95         byte[] arr = new byte[2];
96         MemorySegment segment = MemorySegment.ofArray(arr);
97         vh.set(segment, 0L, (short) 0xFF);
98         assertEquals(arr[0], (byte) 0);
99         assertEquals(arr[1], (byte) 0xFF);
100     }
101 
102     @Test
testNestedSequenceAccess()103     public void testNestedSequenceAccess() {
104         int outer_size = 10;
105         int inner_size = 5;
106 
107         //[10 : [5 : [x32 i32]]]
108 
109         VarHandle vh = MemoryHandles.varHandle(int.class, ByteOrder.nativeOrder());
110         int count = 0;
111         try (ResourceScope scope = ResourceScope.newConfinedScope()) {
112             MemorySegment segment = MemorySegment.allocateNative(inner_size * outer_size * 8, 4, scope);
113             for (long i = 0; i < outer_size; i++) {
114                 for (long j = 0; j < inner_size; j++) {
115                     vh.set(segment, i * 40 + j * 8, count);
116                     assertEquals(
117                             (int)vh.get(segment.asSlice(i * inner_size * 8), j * 8),
118                             count);
119                     count++;
120                 }
121             }
122         }
123     }
124 
125     @Test(dataProvider = "badCarriers", expectedExceptions = IllegalArgumentException.class)
testBadCarrier(Class<?> carrier)126     public void testBadCarrier(Class<?> carrier) {
127         MemoryHandles.varHandle(carrier, ByteOrder.nativeOrder());
128     }
129 
130     @DataProvider(name = "badCarriers")
createBadCarriers()131     public Object[][] createBadCarriers() {
132         return new Object[][] {
133                 { void.class },
134                 { boolean.class },
135                 { Object.class },
136                 { int[].class },
137                 { MemorySegment.class }
138         };
139     }
140 
141 }
142