1 /*
2 * Copyright (c) 2019, 2023, 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/othervm --enable-native-access=ALL-UNNAMED TestNative
28 */
29
30 import java.lang.foreign.*;
31 import java.lang.foreign.MemoryLayout.PathElement;
32
33 import org.testng.annotations.DataProvider;
34 import org.testng.annotations.Test;
35
36 import java.lang.invoke.VarHandle;
37 import java.nio.Buffer;
38 import java.nio.ByteBuffer;
39 import java.nio.ByteOrder;
40 import java.nio.CharBuffer;
41 import java.nio.DoubleBuffer;
42 import java.nio.FloatBuffer;
43 import java.nio.IntBuffer;
44 import java.nio.LongBuffer;
45 import java.nio.ShortBuffer;
46 import java.util.function.BiConsumer;
47 import java.util.function.BiFunction;
48 import java.util.function.Consumer;
49 import java.util.function.Function;
50
51 import static java.lang.foreign.ValueLayout.JAVA_INT;
52 import static org.testng.Assert.*;
53
54 public class TestNative extends NativeTestHelper {
55
56 static SequenceLayout bytes = MemoryLayout.sequenceLayout(100,
57 ValueLayout.JAVA_BYTE.withOrder(ByteOrder.nativeOrder())
58 );
59
60 static SequenceLayout chars = MemoryLayout.sequenceLayout(100,
61 ValueLayout.JAVA_CHAR.withOrder(ByteOrder.nativeOrder())
62 );
63
64 static SequenceLayout shorts = MemoryLayout.sequenceLayout(100,
65 ValueLayout.JAVA_SHORT.withOrder(ByteOrder.nativeOrder())
66 );
67
68 static SequenceLayout ints = MemoryLayout.sequenceLayout(100,
69 JAVA_INT.withOrder(ByteOrder.nativeOrder())
70 );
71
72 static SequenceLayout floats = MemoryLayout.sequenceLayout(100,
73 ValueLayout.JAVA_FLOAT.withOrder(ByteOrder.nativeOrder())
74 );
75
76 static SequenceLayout longs = MemoryLayout.sequenceLayout(100,
77 ValueLayout.JAVA_LONG.withOrder(ByteOrder.nativeOrder())
78 );
79
80 static SequenceLayout doubles = MemoryLayout.sequenceLayout(100,
81 ValueLayout.JAVA_DOUBLE.withOrder(ByteOrder.nativeOrder())
82 );
83
84 static VarHandle byteHandle = bytes.varHandle(PathElement.sequenceElement());
85 static VarHandle charHandle = chars.varHandle(PathElement.sequenceElement());
86 static VarHandle shortHandle = shorts.varHandle(PathElement.sequenceElement());
87 static VarHandle intHandle = ints.varHandle(PathElement.sequenceElement());
88 static VarHandle floatHandle = floats.varHandle(PathElement.sequenceElement());
89 static VarHandle longHandle = longs.varHandle(PathElement.sequenceElement());
90 static VarHandle doubleHandle = doubles.varHandle(PathElement.sequenceElement());
91
92 static void initBytes(MemorySegment base, SequenceLayout seq, BiConsumer<MemorySegment, Long> handleSetter) {
93 for (long i = 0; i < seq.elementCount() ; i++) {
94 handleSetter.accept(base, i);
95 }
96 }
97
98 static <Z extends Buffer> void checkBytes(MemorySegment base, SequenceLayout layout,
99 BiFunction<MemorySegment, Long, Object> handleExtractor,
100 Function<ByteBuffer, Z> bufferFactory,
101 BiFunction<Z, Integer, Object> nativeBufferExtractor,
102 BiFunction<Long, Integer, Object> nativeRawExtractor) {
103 long nelems = layout.elementCount();
104 ByteBuffer bb = base.asByteBuffer();
105 Z z = bufferFactory.apply(bb);
106 for (long i = 0 ; i < nelems ; i++) {
107 Object handleValue = handleExtractor.apply(base, i);
108 Object bufferValue = nativeBufferExtractor.apply(z, (int)i);
109 Object rawValue = nativeRawExtractor.apply(base.address(), (int)i);
110 if (handleValue instanceof Number) {
111 assertEquals(((Number)handleValue).longValue(), i);
112 assertEquals(((Number)bufferValue).longValue(), i);
113 assertEquals(((Number)rawValue).longValue(), i);
114 } else {
115 assertEquals((long)(char)handleValue, i);
116 assertEquals((long)(char)bufferValue, i);
117 assertEquals((long)(char)rawValue, i);
118 }
119 }
120 }
121
122 public static native byte getByteBuffer(ByteBuffer buf, int index);
123 public static native char getCharBuffer(CharBuffer buf, int index);
124 public static native short getShortBuffer(ShortBuffer buf, int index);
125 public static native int getIntBuffer(IntBuffer buf, int index);
126 public static native float getFloatBuffer(FloatBuffer buf, int index);
127 public static native long getLongBuffer(LongBuffer buf, int index);
128 public static native double getDoubleBuffer(DoubleBuffer buf, int index);
129
130 public static native byte getByteRaw(long addr, int index);
131 public static native char getCharRaw(long addr, int index);
132 public static native short getShortRaw(long addr, int index);
133 public static native int getIntRaw(long addr, int index);
134 public static native float getFloatRaw(long addr, int index);
135 public static native long getLongRaw(long addr, int index);
136 public static native double getDoubleRaw(long addr, int index);
137
138 public static native long getCapacity(Buffer buffer);
139
140 @Test(dataProvider="nativeAccessOps")
141 public void testNativeAccess(Consumer<MemorySegment> checker, Consumer<MemorySegment> initializer, SequenceLayout seq) {
142 try (Arena arena = Arena.ofConfined()) {
143 MemorySegment segment = arena.allocate(seq);;
144 initializer.accept(segment);
145 checker.accept(segment);
146 }
147 }
148
149 @Test(dataProvider="buffers")
150 public void testNativeCapacity(Function<ByteBuffer, Buffer> bufferFunction, int elemSize) {
151 int capacity = (int)doubles.byteSize();
152 try (Arena arena = Arena.ofConfined()) {
153 MemorySegment segment = arena.allocate(doubles);;
154 ByteBuffer bb = segment.asByteBuffer();
155 Buffer buf = bufferFunction.apply(bb);
156 int expected = capacity / elemSize;
157 assertEquals(buf.capacity(), expected);
158 assertEquals(getCapacity(buf), expected);
159 }
160 }
161
162 @Test
163 public void testDefaultAccessModes() {
164 MemorySegment addr = allocateMemory(12);
165 try (Arena arena = Arena.ofConfined()) {
166 MemorySegment mallocSegment = addr.asSlice(0, 12)
167 .reinterpret(arena, TestNative::freeMemory);
168 assertFalse(mallocSegment.isReadOnly());
169 }
170 }
171
172 @Test
173 public void testMallocSegment() {
174 MemorySegment addr = allocateMemory(12);
175 MemorySegment mallocSegment = null;
176 try (Arena arena = Arena.ofConfined()) {
177 mallocSegment = addr.asSlice(0, 12)
178 .reinterpret(arena, TestNative::freeMemory);
179 assertEquals(mallocSegment.byteSize(), 12);
180 //free here
181 }
182 assertTrue(!mallocSegment.scope().isAlive());
183 }
184
185 @Test
186 public void testAddressAccess() {
187 MemorySegment addr = allocateMemory(4);
188 addr.set(JAVA_INT, 0, 42);
189 assertEquals(addr.get(JAVA_INT, 0), 42);
190 freeMemory(addr);
191 }
192
193 @Test
194 public void testBadResize() {
195 try (Arena arena = Arena.ofConfined()) {
196 MemorySegment segment = arena.allocate(4, 1);
197 assertThrows(IllegalArgumentException.class, () -> segment.reinterpret(-1));
198 assertThrows(IllegalArgumentException.class, () -> segment.reinterpret(-1, Arena.ofAuto(), null));
199 }
200 }
201
202 static {
203 System.loadLibrary("NativeAccess");
204 }
205
206 @DataProvider(name = "nativeAccessOps")
207 public Object[][] nativeAccessOps() {
208 Consumer<MemorySegment> byteInitializer =
209 (base) -> initBytes(base, bytes, (addr, pos) -> byteHandle.set(addr, 0L, pos, (byte)(long)pos));
210 Consumer<MemorySegment> charInitializer =
211 (base) -> initBytes(base, chars, (addr, pos) -> charHandle.set(addr, 0L, pos, (char)(long)pos));
212 Consumer<MemorySegment> shortInitializer =
213 (base) -> initBytes(base, shorts, (addr, pos) -> shortHandle.set(addr, 0L, pos, (short)(long)pos));
214 Consumer<MemorySegment> intInitializer =
215 (base) -> initBytes(base, ints, (addr, pos) -> intHandle.set(addr, 0L, pos, (int)(long)pos));
216 Consumer<MemorySegment> floatInitializer =
217 (base) -> initBytes(base, floats, (addr, pos) -> floatHandle.set(addr, 0L, pos, (float)(long)pos));
218 Consumer<MemorySegment> longInitializer =
219 (base) -> initBytes(base, longs, (addr, pos) -> longHandle.set(addr, 0L, pos, (long)pos));
220 Consumer<MemorySegment> doubleInitializer =
221 (base) -> initBytes(base, doubles, (addr, pos) -> doubleHandle.set(addr, 0L, pos, (double)(long)pos));
222
223 Consumer<MemorySegment> byteChecker =
224 (base) -> checkBytes(base, bytes, (addr, pos) -> byteHandle.get(addr, 0L, pos), bb -> bb, TestNative::getByteBuffer, TestNative::getByteRaw);
225 Consumer<MemorySegment> charChecker =
226 (base) -> checkBytes(base, chars, (addr, pos) -> charHandle.get(addr, 0L, pos), ByteBuffer::asCharBuffer, TestNative::getCharBuffer, TestNative::getCharRaw);
227 Consumer<MemorySegment> shortChecker =
228 (base) -> checkBytes(base, shorts, (addr, pos) -> shortHandle.get(addr, 0L, pos), ByteBuffer::asShortBuffer, TestNative::getShortBuffer, TestNative::getShortRaw);
229 Consumer<MemorySegment> intChecker =
230 (base) -> checkBytes(base, ints, (addr, pos) -> intHandle.get(addr, 0L, pos), ByteBuffer::asIntBuffer, TestNative::getIntBuffer, TestNative::getIntRaw);
231 Consumer<MemorySegment> floatChecker =
232 (base) -> checkBytes(base, floats, (addr, pos) -> floatHandle.get(addr, 0L, pos), ByteBuffer::asFloatBuffer, TestNative::getFloatBuffer, TestNative::getFloatRaw);
233 Consumer<MemorySegment> longChecker =
234 (base) -> checkBytes(base, longs, (addr, pos) -> longHandle.get(addr, 0L, pos), ByteBuffer::asLongBuffer, TestNative::getLongBuffer, TestNative::getLongRaw);
235 Consumer<MemorySegment> doubleChecker =
236 (base) -> checkBytes(base, doubles, (addr, pos) -> doubleHandle.get(addr, 0L, pos), ByteBuffer::asDoubleBuffer, TestNative::getDoubleBuffer, TestNative::getDoubleRaw);
237
238 return new Object[][]{
239 {byteChecker, byteInitializer, bytes},
240 {charChecker, charInitializer, chars},
241 {shortChecker, shortInitializer, shorts},
242 {intChecker, intInitializer, ints},
243 {floatChecker, floatInitializer, floats},
244 {longChecker, longInitializer, longs},
245 {doubleChecker, doubleInitializer, doubles}
246 };
247 }
248
249 @DataProvider(name = "buffers")
250 public Object[][] buffers() {
251 return new Object[][] {
252 { (Function<ByteBuffer, Buffer>)bb -> bb, 1 },
253 { (Function<ByteBuffer, Buffer>)ByteBuffer::asCharBuffer, 2 },
254 { (Function<ByteBuffer, Buffer>)ByteBuffer::asShortBuffer, 2 },
255 { (Function<ByteBuffer, Buffer>)ByteBuffer::asIntBuffer, 4 },
256 { (Function<ByteBuffer, Buffer>)ByteBuffer::asFloatBuffer, 4 },
257 { (Function<ByteBuffer, Buffer>)ByteBuffer::asLongBuffer, 8 },
258 { (Function<ByteBuffer, Buffer>)ByteBuffer::asDoubleBuffer, 8 },
259 };
260 }
261 }