Skip to content

Commit e0faea2

Browse files
leerholeerho
committed
Better test coverage AND actual checking for the @pawel-weijacha bug for
all the primitives.
1 parent 7f40e8b commit e0faea2

File tree

4 files changed

+354
-497
lines changed

4 files changed

+354
-497
lines changed

‎src/test/java/org/apache/datasketches/memory/internal/NativeWritableBufferImplTest.java‎

Lines changed: 128 additions & 187 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,14 @@
2020
package org.apache.datasketches.memory.internal;
2121

2222
import java.lang.foreign.Arena;
23-
import static org.apache.datasketches.memory.internal.ResourceImpl.NON_NATIVE_BYTE_ORDER;
23+
import static org.apache.datasketches.memory.internal.UtilForTest.CB;
24+
import static org.apache.datasketches.memory.internal.UtilForTest.DB;
25+
import static org.apache.datasketches.memory.internal.UtilForTest.FB;
26+
import static org.apache.datasketches.memory.internal.UtilForTest.IB;
27+
import static org.apache.datasketches.memory.internal.UtilForTest.LB;
28+
import static org.apache.datasketches.memory.internal.UtilForTest.NBO;
29+
import static org.apache.datasketches.memory.internal.UtilForTest.NNBO;
30+
import static org.apache.datasketches.memory.internal.UtilForTest.SB;
2431
import static org.testng.Assert.assertEquals;
2532
import static org.testng.Assert.assertFalse;
2633
import static org.testng.Assert.assertNotNull;
@@ -38,6 +45,9 @@
3845
import org.testng.Assert;
3946
import org.testng.annotations.Test;
4047

48+
/**
49+
* @author Lee Rhodes
50+
*/
4151
public class NativeWritableBufferImplTest {
4252
private static final MemoryRequestServer memReqSvr = Resource.defaultMemReqSvr;
4353

@@ -55,239 +65,170 @@ public void checkNativeCapacityAndClose() throws Exception {
5565
try { wmem.getArena().close(); } catch (IllegalStateException e) { }
5666
}
5767

58-
//Simple Heap arrays
68+
//Check primitives
5969

6070
@Test
61-
public void checkGetByteArray() {
62-
byte[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
71+
public void checkPutGetBooleans() {
72+
boolean[] srcArray = {true, false, true, false, false, true, false, true};
6373
final int len = srcArray.length;
6474
final int half = len / 2;
65-
byte[] dstArray = new byte[len];
66-
67-
Buffer buf = Memory.wrap(srcArray).asBuffer();
68-
buf.getByteArray(dstArray, 0, half);
69-
buf.getByteArray(dstArray, half, half);
70-
assertEquals(dstArray, srcArray);
71-
72-
WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
73-
wbuf.getByteArray(dstArray, 0, half);
74-
wbuf.getByteArray(dstArray, half, half);
75-
assertEquals(dstArray, srcArray);
75+
WritableBuffer wbuf = WritableMemory.allocate(len, NBO).asWritableBuffer();
76+
//put
77+
for (int i = 0; i < half; i++) { wbuf.putBoolean(srcArray[i]); } //put*(value)
78+
for (int i = half; i < len; i++) { wbuf.putBoolean(i, srcArray[i]); } //put*(add, value)
79+
wbuf.resetPosition();
80+
//get
81+
boolean[] dstArray = new boolean[len];
82+
for (int i = 0; i < half; i++) { dstArray[i] = wbuf.getBoolean(); } //get*()
83+
for (int i = half; i < len; i++) { dstArray[i] = wbuf.getBoolean(i); } //get*(add)
84+
assertEquals(srcArray, dstArray);
7685
}
7786

7887
@Test
79-
public void checkPutByteArray() {
88+
public void checkPutGetBytes() {
8089
byte[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
8190
final int len = srcArray.length;
8291
final int half = len / 2;
83-
byte[] dstArray = new byte[len];
84-
85-
WritableBuffer wbuf = WritableMemory.allocate(len * Byte.BYTES).asWritableBuffer();
86-
wbuf.putByteArray(srcArray, 0, half);
87-
wbuf.putByteArray(srcArray, half, half);
92+
WritableBuffer wbuf = WritableMemory.allocate(len, NBO).asWritableBuffer();
93+
//put
94+
wbuf.putByte(srcArray[0]); //put*(value)
95+
wbuf.putByteArray(srcArray, 1, 2); //put*Array(src[], srcOff, len)
96+
wbuf.putByte(srcArray[3]); //put*(value)
97+
for (int i = half; i < len; i++) { wbuf.putByte(i, srcArray[i]); } //put*(add, value)
8898
wbuf.resetPosition();
89-
wbuf.getByteArray(dstArray, 0, len);
90-
assertEquals(dstArray, srcArray);
99+
//get
100+
byte[] dstArray = new byte[len];
101+
dstArray[0] = wbuf.getByte(); //get*()
102+
wbuf.getByteArray(dstArray, 1, 2); //get*Array(dst[], dstOff, len)
103+
dstArray[3] = wbuf.getByte(); //get*()
104+
for (int i = half; i < len; i++) { dstArray[i] = wbuf.getByte(i); } //get*(add)
105+
assertEquals(srcArray, dstArray);
91106
}
92107

93108
@Test
94-
public void checkGetCharArray() {
95-
char[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
109+
public void checkPutGetNativeCharacters() {
110+
char[] srcArray = { 'a','b','c','d','e','f','g','h' };
96111
final int len = srcArray.length;
97112
final int half = len / 2;
113+
WritableBuffer wbuf = WritableMemory.allocate(len * CB, NBO).asWritableBuffer();
114+
//put
115+
wbuf.putChar(srcArray[0]); //put*(value)
116+
wbuf.putCharArray(srcArray, 1, 2); //put*Array(src[], srcOff, len)
117+
wbuf.putChar(srcArray[3]); //put*(value)
118+
for (int i = half; i < len; i++) { wbuf.putChar(i * CB, srcArray[i]); } //put*(add, value)
119+
wbuf.resetPosition();
120+
//get
98121
char[] dstArray = new char[len];
99-
100-
Buffer buf = Memory.wrap(srcArray).asBuffer();
101-
buf.getCharArray(dstArray, 0, half);
102-
buf.getCharArray(dstArray, half, half);
103-
assertEquals(dstArray, srcArray);
104-
105-
WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
106-
wbuf.getCharArray(dstArray, 0, half);
107-
wbuf.getCharArray(dstArray, half, half);
108-
assertEquals(dstArray, srcArray);
122+
dstArray[0] = wbuf.getChar(); //get*()
123+
wbuf.getCharArray(dstArray, 1, 2); //get*Array(dst[], dstOff, len)
124+
dstArray[3] = wbuf.getChar(); //get*()
125+
for (int i = half; i < len; i++) { dstArray[i] = wbuf.getChar(i * CB); } //get*(add)
126+
assertEquals(srcArray, dstArray);
109127
}
110128

111129
@Test
112-
public void checkPutCharArray() {
113-
char[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
130+
public void checkPutGetNativeDoubles() {
131+
double[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
114132
final int len = srcArray.length;
115133
final int half = len / 2;
116-
char[] dstArray = new char[len];
117-
118-
WritableBuffer wbuf = WritableMemory.allocate(len * Character.BYTES).asWritableBuffer();
119-
wbuf.putCharArray(srcArray, 0, half);
120-
wbuf.putCharArray(srcArray, half, half);
134+
WritableBuffer wbuf = WritableMemory.allocate(len * DB, NBO).asWritableBuffer();
135+
//put
136+
wbuf.putDouble(srcArray[0]); //put*(value)
137+
wbuf.putDoubleArray(srcArray, 1, 2); //put*Array(src[], srcOff, len)
138+
wbuf.putDouble(srcArray[3]); //put*(value)
139+
for (int i = half; i < len; i++) { wbuf.putDouble(i * DB, srcArray[i]); } //put*(add, value)
121140
wbuf.resetPosition();
122-
wbuf.getCharArray(dstArray, 0, len);
123-
assertEquals(dstArray, srcArray);
124-
}
125-
126-
@Test
127-
public void checkGetShortArray() {
128-
short[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
129-
final int len = srcArray.length;
130-
final int half = len / 2;
131-
short[] dstArray = new short[len];
132-
133-
Buffer buf = Memory.wrap(srcArray).asBuffer();
134-
buf.getShortArray(dstArray, 0, half);
135-
buf.getShortArray(dstArray, half, half);
136-
assertEquals(dstArray, srcArray);
137-
138-
WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
139-
wbuf.getShortArray(dstArray, 0, half);
140-
wbuf.getShortArray(dstArray, half, half);
141-
assertEquals(dstArray, srcArray);
141+
//get
142+
double[] dstArray = new double[len];
143+
dstArray[0] = wbuf.getDouble(); //get*()
144+
wbuf.getDoubleArray(dstArray, 1, 2); //get*Array(dst[], dstOff, len)
145+
dstArray[3] = wbuf.getDouble(); //get*()
146+
for (int i = half; i < len; i++) { dstArray[i] = wbuf.getDouble(i * DB); } //get*(add)
147+
assertEquals(srcArray, dstArray);
142148
}
143149

144150
@Test
145-
public void checkPutShortArray() {
146-
short[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
151+
public void checkPutGetNativeFloats() {
152+
float[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
147153
final int len = srcArray.length;
148154
final int half = len / 2;
149-
short[] dstArray = new short[len];
150-
151-
WritableBuffer wbuf = WritableMemory.allocate(len * Short.BYTES).asWritableBuffer();
152-
wbuf.putShortArray(srcArray, 0, half);
153-
wbuf.putShortArray(srcArray, half, half);
155+
WritableBuffer wbuf = WritableMemory.allocate(len * FB, NBO).asWritableBuffer();
156+
//put
157+
wbuf.putFloat(srcArray[0]); //put*(value)
158+
wbuf.putFloatArray(srcArray, 1, 2); //put*Array(src[], srcOff, len)
159+
wbuf.putFloat(srcArray[3]); //put*(value)
160+
for (int i = half; i < len; i++) { wbuf.putFloat(i * FB, srcArray[i]); } //put*(add, value)
154161
wbuf.resetPosition();
155-
wbuf.getShortArray(dstArray, 0, len);
156-
assertEquals(dstArray, srcArray);
162+
//get
163+
float[] dstArray = new float[len];
164+
dstArray[0] = wbuf.getFloat(); //get*()
165+
wbuf.getFloatArray(dstArray, 1, 2); //get*Array(dst[], dstOff, len)
166+
dstArray[3] = wbuf.getFloat(); //get*()
167+
for (int i = half; i < len; i++) { dstArray[i] = wbuf.getFloat(i * FB); } //get*(add)
168+
assertEquals(srcArray, dstArray);
157169
}
158170

159171
@Test
160-
public void checkGetIntArray() {
161-
int[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
172+
public void checkPutGetNativeInts() {
173+
int[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
162174
final int len = srcArray.length;
163175
final int half = len / 2;
176+
WritableBuffer wbuf = WritableMemory.allocate(len * IB, NBO).asWritableBuffer();
177+
//put
178+
wbuf.putInt(srcArray[0]); //put*(value)
179+
wbuf.putIntArray(srcArray, 1, 2); //put*Array(src[], srcOff, len)
180+
wbuf.putInt(srcArray[3]); //put*(value)
181+
for (int i = half; i < len; i++) { wbuf.putInt(i * IB, srcArray[i]); } //put*(add, value)
182+
wbuf.resetPosition();
183+
//get
164184
int[] dstArray = new int[len];
165-
166-
Buffer buf = Memory.wrap(srcArray).asBuffer();
167-
buf.getIntArray(dstArray, 0, half);
168-
buf.getIntArray(dstArray, half, half);
169-
assertEquals(dstArray, srcArray);
170-
171-
WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
172-
wbuf.getIntArray(dstArray, 0, half);
173-
wbuf.getIntArray(dstArray, half, half);
174-
assertEquals(dstArray, srcArray);
185+
dstArray[0] = wbuf.getInt(); //get*()
186+
wbuf.getIntArray(dstArray, 1, 2); //get*Array(dst[], dstOff, len)
187+
dstArray[3] = wbuf.getInt(); //get*()
188+
for (int i = half; i < len; i++) { dstArray[i] = wbuf.getInt(i * IB); } //get*(add)
189+
assertEquals(srcArray, dstArray);
175190
}
176191

177192
@Test
178-
public void checkPutIntArray() {
179-
int[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
193+
public void checkPutGetNativeLongs() {
194+
long[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
180195
final int len = srcArray.length;
181196
final int half = len / 2;
182-
int[] dstArray = new int[len];
183-
184-
WritableBuffer wbuf = WritableMemory.allocate(len * Integer.BYTES).asWritableBuffer();
185-
wbuf.putIntArray(srcArray, 0, half);
186-
wbuf.putIntArray(srcArray, half, half);
197+
WritableBuffer wbuf = WritableMemory.allocate(len * LB, NNBO).asWritableBuffer();
198+
//put
199+
wbuf.putLong(srcArray[0]); //put*(value)
200+
wbuf.putLongArray(srcArray, 1, 2); //put*Array(src[], srcOff, len)
201+
wbuf.putLong(srcArray[3]); //put*(value)
202+
for (int i = half; i < len; i++) { wbuf.putLong(i * LB, srcArray[i]); } //put*(add, value)
187203
wbuf.resetPosition();
188-
wbuf.getIntArray(dstArray, 0, len);
189-
assertEquals(dstArray, srcArray);
190-
}
191-
192-
@Test
193-
public void checkGetLongArray() {
194-
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
195-
final int len = srcArray.length;
196-
final int half = len / 2;
197-
long[] dstArray = new long[len];
198-
199-
Buffer buf = Memory.wrap(srcArray).asBuffer();
200-
buf.getLongArray(dstArray, 0, half);
201-
buf.getLongArray(dstArray, half, half);
202-
assertEquals(dstArray, srcArray);
203-
204-
WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
205-
wbuf.getLongArray(dstArray, 0, half);
206-
wbuf.getLongArray(dstArray, half, half);
207-
assertEquals(dstArray, srcArray);
208-
}
209-
210-
@Test
211-
public void checkPutLongArray() {
212-
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
213-
final int len = srcArray.length;
214-
final int half = len / 2;
204+
//get
215205
long[] dstArray = new long[len];
216-
217-
WritableBuffer wbuf = WritableMemory.allocate(len * Long.BYTES).asWritableBuffer();
218-
wbuf.putLongArray(srcArray, 0, half);
219-
wbuf.putLongArray(srcArray, half, half);
220-
wbuf.resetPosition();
221-
wbuf.getLongArray(dstArray, 0, len);
222-
assertEquals(dstArray, srcArray);
223-
}
224-
225-
@Test
226-
public void checkGetFloatArray() {
227-
float[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
228-
final int len = srcArray.length;
229-
final int half = len / 2;
230-
float[] dstArray = new float[len];
231-
232-
Buffer buf = Memory.wrap(srcArray).asBuffer();
233-
buf.getFloatArray(dstArray, 0, half);
234-
buf.getFloatArray(dstArray, half, half);
235-
assertEquals(dstArray, srcArray);
236-
237-
238-
WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
239-
wbuf.getFloatArray(dstArray, 0, half);
240-
wbuf.getFloatArray(dstArray, half, half);
241-
assertEquals(dstArray, srcArray);
206+
dstArray[0] = wbuf.getLong(); //get*()
207+
wbuf.getLongArray(dstArray, 1, 2); //get*Array(dst[], dstOff, len)
208+
dstArray[3] = wbuf.getLong(); //get*()
209+
for (int i = half; i < len; i++) { dstArray[i] = wbuf.getLong(i * LB); } //get*(add)
210+
assertEquals(srcArray, dstArray);
242211
}
243212

244213
@Test
245-
public void checkPutFloatArray() {
246-
float[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
214+
public void checkPutGetNativeShorts() {
215+
short[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
247216
final int len = srcArray.length;
248217
final int half = len / 2;
249-
float[] dstArray = new float[len];
250-
251-
WritableBuffer wbuf = WritableMemory.allocate(len * Float.BYTES).asWritableBuffer();
252-
wbuf.putFloatArray(srcArray, 0, half);
253-
wbuf.putFloatArray(srcArray, half, half);
218+
WritableBuffer wbuf = WritableMemory.allocate(len * SB, NBO).asWritableBuffer();
219+
//put
220+
wbuf.putShort(srcArray[0]); //put*(value)
221+
wbuf.putShortArray(srcArray, 1, 2); //put*Array(src[], srcOff, len)
222+
wbuf.putShort(srcArray[3]); //put*(value)
223+
for (int i = half; i < len; i++) { wbuf.putShort(i * SB, srcArray[i]); } //put*(add, value)
254224
wbuf.resetPosition();
255-
wbuf.getFloatArray(dstArray, 0, len);
256-
assertEquals(dstArray, srcArray);
257-
}
258-
259-
@Test
260-
public void checkGetDoubleArray() {
261-
double[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
262-
final int len = srcArray.length;
263-
final int half = len / 2;
264-
double[] dstArray = new double[len];
265-
266-
Buffer buf = Memory.wrap(srcArray).asBuffer();
267-
buf.getDoubleArray(dstArray, 0, half);
268-
buf.getDoubleArray(dstArray, half, half);
269-
assertEquals(dstArray, srcArray);
270-
271-
272-
WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
273-
wbuf.getDoubleArray(dstArray, 0, half);
274-
wbuf.getDoubleArray(dstArray, half, half);
275-
assertEquals(dstArray, srcArray);
276-
}
277-
278-
@Test
279-
public void checkPutDoubleArray() {
280-
double[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
281-
final int len = srcArray.length;
282-
final int half = len / 2;
283-
double[] dstArray = new double[len];
284-
285-
WritableBuffer wbuf = WritableMemory.allocate(len * Double.BYTES).asWritableBuffer();
286-
wbuf.putDoubleArray(srcArray, 0, half);
287-
wbuf.putDoubleArray(srcArray, half, half);
288-
wbuf.resetPosition();
289-
wbuf.getDoubleArray(dstArray, 0, len);
290-
assertEquals(dstArray, srcArray);
225+
//get
226+
short[] dstArray = new short[len];
227+
dstArray[0] = wbuf.getShort(); //get*()
228+
wbuf.getShortArray(dstArray, 1, 2); //get*Array(dst[], dstOff, len)
229+
dstArray[3] = wbuf.getShort(); //get*()
230+
for (int i = half; i < len; i++) { dstArray[i] = wbuf.getShort(i * SB); } //get*(add)
231+
assertEquals(srcArray, dstArray);
291232
}
292233

293234
@Test
@@ -571,7 +512,7 @@ public void checkZeroBuffer() {
571512
public void checkDuplicateNonNative() {
572513
WritableMemory wmem = WritableMemory.allocate(64);
573514
wmem.putShort(0, (short) 1);
574-
Buffer buf = wmem.asWritableBuffer().duplicate(NON_NATIVE_BYTE_ORDER);
515+
Buffer buf = wmem.asWritableBuffer().duplicate(NNBO);
575516
assertEquals(buf.getShort(0), 256);
576517
}
577518

0 commit comments

Comments
 (0)