More comprehensive tests.

Brought coverage from 90% to 95.7%

Author: leerho

src/main/java/org/apache/datasketches/memory/internal/NativeWritableBufferImpl.java

@@ -41,10 +41,10 @@ final class NativeWritableBufferImpl extends WritableBufferImpl {
 
   //Pass-through ctor
   NativeWritableBufferImpl(
-      final Arena arena,
       final MemorySegment seg,
       final int typeId,
-      final MemoryRequestServer memReqSvr) {
+      final MemoryRequestServer memReqSvr,
+      final Arena arena) {
     super(seg, typeId, memReqSvr, arena);
   }
 

src/main/java/org/apache/datasketches/memory/internal/ResourceImpl.java

@@ -220,7 +220,7 @@ static final WritableBuffer selectBuffer(
     final MemoryRequestServer memReqSvr2 = (byteBufferType || mapType) ? null : memReqSvr;
     final WritableBuffer wbuf;
     if (nativeBOType) {
-      wbuf = new NativeWritableBufferImpl(null, segment, type, memReqSvr2);
+      wbuf = new NativeWritableBufferImpl(segment, type, memReqSvr2, null);
     } else { //non-native BO
       wbuf = new NonNativeWritableBufferImpl(segment, type, memReqSvr2, null);
     }

src/main/java/org/apache/datasketches/memory/internal/WritableBufferImpl.java

@@ -90,7 +90,7 @@ public static WritableBuffer wrapByteBuffer(
       type |= NONNATIVE_BO;
       wbuf = new NonNativeWritableBufferImpl(seg, type, memReqSvr, null);
     } else {
-      wbuf = new NativeWritableBufferImpl(null, seg, type, memReqSvr);
+      wbuf = new NativeWritableBufferImpl(seg, type, memReqSvr, null);
     }
     wbuf.setStartPositionEnd(0, byteBuffer.position(), byteBuffer.limit());
     return wbuf;

src/test/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImplTest.java

@@ -19,15 +19,17 @@
 
 package org.apache.datasketches.memory.internal;
 
-import static org.apache.datasketches.memory.internal.NonNativeWritableMemoryImplTest.doubleReverseBytes;
-import static org.apache.datasketches.memory.internal.NonNativeWritableMemoryImplTest.floatReverseBytes;
-import static org.apache.datasketches.memory.internal.ResourceImpl.NATIVE_BYTE_ORDER;
-import static org.apache.datasketches.memory.internal.ResourceImpl.NON_NATIVE_BYTE_ORDER;
+import static org.apache.datasketches.memory.internal.UtilForTest.CB;
+import static org.apache.datasketches.memory.internal.UtilForTest.DB;
+import static org.apache.datasketches.memory.internal.UtilForTest.FB;
+import static org.apache.datasketches.memory.internal.UtilForTest.IB;
+import static org.apache.datasketches.memory.internal.UtilForTest.LB;
+import static org.apache.datasketches.memory.internal.UtilForTest.NBO;
+import static org.apache.datasketches.memory.internal.UtilForTest.NNBO;
+import static org.apache.datasketches.memory.internal.UtilForTest.SB;
 import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertTrue;
 
-import java.nio.ByteOrder;
-
 import org.apache.datasketches.memory.Buffer;
 import org.apache.datasketches.memory.Memory;
 import org.apache.datasketches.memory.WritableBuffer;
@@ -43,26 +45,34 @@ public class NonNativeWritableBufferImplTest {
 
   @Test
   public void checkPutGetNonNativeCharacters() {
-    char[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
+    char[] srcArray = { 'a','b','c','d','e','f','g','h' };
     final int len = srcArray.length;
     final int half = len / 2;
-    WritableBuffer wbuf = WritableMemory.allocate(len * Character.BYTES, NON_NATIVE_BYTE_ORDER).asWritableBuffer();
-    wbuf.putCharArray(srcArray, 0, half);
-    wbuf.putCharArray(srcArray, half, half);
+    final int qtr = len / 4;
+    WritableBuffer wbuf = WritableMemory.allocate(len * CB, NNBO).asWritableBuffer();
+    //put
+    wbuf.putCharArray(srcArray, 0, qtr);              //put*Array(src[], srcOff, len)
+    wbuf.putChar(qtr * CB, srcArray[qtr]);            //put*(add, value)
+    wbuf.putChar((qtr + 1) * CB, srcArray[qtr + 1]);  //put*(add, value)
+    wbuf.setPosition(half * CB);
+    for (int i = half; i < len; i++) { wbuf.putChar(srcArray[i]); } //put*(value)
     wbuf.resetPosition();
     //confirm
-    WritableBuffer wbuf2 = WritableMemory.allocate(len * Character.BYTES, NATIVE_BYTE_ORDER).asWritableBuffer();
-    for (int i = 0; i < len * Character.BYTES; i++) { wbuf2.putByte(wbuf.getByte()); }
+    WritableBuffer wbuf2 = WritableMemory.allocate(len * CB, NBO).asWritableBuffer();
+    for (int i = 0; i < len * CB; i++) { wbuf2.putByte(wbuf.getByte()); }
     wbuf.resetPosition();
     wbuf2.resetPosition();
     for (int i = 0; i < len; i++) {
       assertTrue(srcArray[i] == Character.reverseBytes(wbuf2.getChar()));
     }
-    wbuf2.resetPosition();
     //get
+    wbuf2.resetPosition();
     char[] dstArray = new char[len];
-    wbuf.getCharArray(dstArray, 0, half);
-    wbuf.getCharArray(dstArray, half, half);
+    wbuf.getCharArray(dstArray, 0, qtr);              //get*Array(dst[], dstOff, len)
+    dstArray[qtr] = wbuf.getChar(qtr * CB);           //get*(add)
+    dstArray[qtr + 1] = wbuf.getChar((qtr + 1) * CB); //get*(add)
+    wbuf.setPosition(half * CB);
+    for (int i = half; i < len; i++) { dstArray[i] = wbuf.getChar(); } //get*()
     assertEquals(srcArray, dstArray);
   }
 
@@ -71,23 +81,31 @@ public void checkPutGetNonNativeDoubles() {
     double[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
     final int len = srcArray.length;
     final int half = len / 2;
-    WritableBuffer wbuf = WritableMemory.allocate(len * Double.BYTES, NON_NATIVE_BYTE_ORDER).asWritableBuffer();
-    wbuf.putDoubleArray(srcArray, 0, half);
-    wbuf.putDoubleArray(srcArray, half, half);
+    final int qtr = len / 4;
+    WritableBuffer wbuf = WritableMemory.allocate(len * DB, NNBO).asWritableBuffer();
+    //put
+    wbuf.putDoubleArray(srcArray, 0, qtr);              //put*Array(src[], srcOff, len)
+    wbuf.putDouble(qtr * DB, srcArray[qtr]);            //put*(add, value)
+    wbuf.putDouble((qtr + 1) * DB, srcArray[qtr + 1]);  //put*(add, value)
+    wbuf.setPosition(half * DB);
+    for (int i = half; i < len; i++) { wbuf.putDouble(srcArray[i]); } //put*(value)
     wbuf.resetPosition();
     //confirm
-    WritableBuffer wbuf2 = WritableMemory.allocate(len * Double.BYTES, NATIVE_BYTE_ORDER).asWritableBuffer();
-    for (int i = 0; i < len * Double.BYTES; i++) { wbuf2.putByte(wbuf.getByte()); }
+    WritableBuffer wbuf2 = WritableMemory.allocate(len * DB, NBO).asWritableBuffer();
+    for (int i = 0; i < len * DB; i++) { wbuf2.putByte(wbuf.getByte()); }
     wbuf.resetPosition();
     wbuf2.resetPosition();
     for (int i = 0; i < len; i++) {
-      assertTrue(srcArray[i] == doubleReverseBytes(wbuf2.getDouble()));
+      assertTrue(srcArray[i] == UtilForTest.doubleReverseBytes(wbuf2.getDouble()));
     }
-    wbuf2.resetPosition();
     //get
+    wbuf2.resetPosition();
     double[] dstArray = new double[len];
-    wbuf.getDoubleArray(dstArray, 0, half);
-    wbuf.getDoubleArray(dstArray, half, half);
+    wbuf.getDoubleArray(dstArray, 0, qtr);              //get*Array(dst[], dstOff, len)
+    dstArray[qtr] = wbuf.getDouble(qtr * DB);           //get*(add)
+    dstArray[qtr + 1] = wbuf.getDouble((qtr + 1) * DB); //get*(add)
+    wbuf.setPosition(half * DB);
+    for (int i = half; i < len; i++) { dstArray[i] = wbuf.getDouble(); } //get*()
     assertEquals(srcArray, dstArray);
   }
 
@@ -96,23 +114,31 @@ public void checkPutGetNonNativeFloats() {
     float[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
     final int len = srcArray.length;
     final int half = len / 2;
-    WritableBuffer wbuf = WritableMemory.allocate(len * Float.BYTES, NON_NATIVE_BYTE_ORDER).asWritableBuffer();
-    wbuf.putFloatArray(srcArray, 0, half);
-    wbuf.putFloatArray(srcArray, half, half);
+    final int qtr = len / 4;
+    WritableBuffer wbuf = WritableMemory.allocate(len * FB, NNBO).asWritableBuffer();
+    //put
+    wbuf.putFloatArray(srcArray, 0, qtr);              //put*Array(src[], srcOff, len)
+    wbuf.putFloat(qtr * FB, srcArray[qtr]);            //put*(add, value)
+    wbuf.putFloat((qtr + 1) * FB, srcArray[qtr + 1]);  //put*(add, value)
+    wbuf.setPosition(half * FB);
+    for (int i = half; i < len; i++) { wbuf.putFloat(srcArray[i]); } //put*(value)
     wbuf.resetPosition();
     //confirm
-    WritableBuffer wbuf2 = WritableMemory.allocate(len * Float.BYTES, NATIVE_BYTE_ORDER).asWritableBuffer();
-    for (int i = 0; i < len * Float.BYTES; i++) { wbuf2.putByte(wbuf.getByte()); }
+    WritableBuffer wbuf2 = WritableMemory.allocate(len * FB, NBO).asWritableBuffer();
+    for (int i = 0; i < len * FB; i++) { wbuf2.putByte(wbuf.getByte()); }
     wbuf.resetPosition();
     wbuf2.resetPosition();
     for (int i = 0; i < len; i++) {
-      assertTrue(srcArray[i] == floatReverseBytes(wbuf2.getFloat()));
+      assertTrue(srcArray[i] == UtilForTest.floatReverseBytes(wbuf2.getFloat()));
     }
-    wbuf2.resetPosition();
     //get
+    wbuf2.resetPosition();
     float[] dstArray = new float[len];
-    wbuf.getFloatArray(dstArray, 0, half);
-    wbuf.getFloatArray(dstArray, half, half);
+    wbuf.getFloatArray(dstArray, 0, qtr);              //get*Array(dst[], dstOff, len)
+    dstArray[qtr] = wbuf.getFloat(qtr * FB);           //get*(add)
+    dstArray[qtr + 1] = wbuf.getFloat((qtr + 1) * FB); //get*(add)
+    wbuf.setPosition(half * FB);
+    for (int i = half; i < len; i++) { dstArray[i] = wbuf.getFloat(); } //get*()
     assertEquals(srcArray, dstArray);
   }
 
@@ -121,23 +147,31 @@ public void checkPutGetNonNativeInts() {
     int[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
     final int len = srcArray.length;
     final int half = len / 2;
-    WritableBuffer wbuf = WritableMemory.allocate(len * Integer.BYTES, NON_NATIVE_BYTE_ORDER).asWritableBuffer();
-    wbuf.putIntArray(srcArray, 0, half);
-    wbuf.putIntArray(srcArray, half, half);
+    final int qtr = len / 4;
+    WritableBuffer wbuf = WritableMemory.allocate(len * IB, NNBO).asWritableBuffer();
+    //put
+    wbuf.putIntArray(srcArray, 0, qtr);              //put*Array(src[], srcOff, len)
+    wbuf.putInt(qtr * IB, srcArray[qtr]);            //put*(add, value)
+    wbuf.putInt((qtr + 1) * IB, srcArray[qtr + 1]);  //put*(add, value)
+    wbuf.setPosition(half * IB);
+    for (int i = half; i < len; i++) { wbuf.putInt(srcArray[i]); } //put*(value)
     wbuf.resetPosition();
     //confirm
-    WritableBuffer wbuf2 = WritableMemory.allocate(len * Integer.BYTES, NATIVE_BYTE_ORDER).asWritableBuffer();
-    for (int i = 0; i < len * Integer.BYTES; i++) { wbuf2.putByte(wbuf.getByte()); }
+    WritableBuffer wbuf2 = WritableMemory.allocate(len * IB, NBO).asWritableBuffer();
+    for (int i = 0; i < len * IB; i++) { wbuf2.putByte(wbuf.getByte()); }
     wbuf.resetPosition();
     wbuf2.resetPosition();
     for (int i = 0; i < len; i++) {
       assertTrue(srcArray[i] == Integer.reverseBytes(wbuf2.getInt()));
     }
-    wbuf2.resetPosition();
     //get
+    wbuf2.resetPosition();
     int[] dstArray = new int[len];
-    wbuf.getIntArray(dstArray, 0, half);
-    wbuf.getIntArray(dstArray, half, half);
+    wbuf.getIntArray(dstArray, 0, qtr);              //get*Array(dst[], dstOff, len)
+    dstArray[qtr] = wbuf.getInt(qtr * IB);           //get*(add)
+    dstArray[qtr + 1] = wbuf.getInt((qtr + 1) * IB); //get*(add)
+    wbuf.setPosition(half * IB);
+    for (int i = half; i < len; i++) { dstArray[i] = wbuf.getInt(); } //get*()
     assertEquals(srcArray, dstArray);
   }
 
@@ -146,23 +180,31 @@ public void checkPutGetNonNativeLongs() {
     long[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
     final int len = srcArray.length;
     final int half = len / 2;
-    WritableBuffer wbuf = WritableMemory.allocate(len * Long.BYTES, NON_NATIVE_BYTE_ORDER).asWritableBuffer();
-    wbuf.putLongArray(srcArray, 0, half);
-    wbuf.putLongArray(srcArray, half, half);
+    final int qtr = len / 4;
+    WritableBuffer wbuf = WritableMemory.allocate(len * LB, NNBO).asWritableBuffer();
+    //put
+    wbuf.putLongArray(srcArray, 0, qtr);              //put*Array(src[], srcOff, len)
+    wbuf.putLong(qtr * LB, srcArray[qtr]);            //put*(add, value)
+    wbuf.putLong((qtr + 1) * LB, srcArray[qtr + 1]);  //put*(add, value)
+    wbuf.setPosition(half * LB);
+    for (int i = half; i < len; i++) { wbuf.putLong(srcArray[i]); } //put*(value)
     wbuf.resetPosition();
     //confirm
-    WritableBuffer wbuf2 = WritableMemory.allocate(len * Long.BYTES, NATIVE_BYTE_ORDER).asWritableBuffer();
-    for (int i = 0; i < len * Long.BYTES; i++) { wbuf2.putByte(wbuf.getByte()); }
+    WritableBuffer wbuf2 = WritableMemory.allocate(len * LB, NBO).asWritableBuffer();
+    for (int i = 0; i < len * LB; i++) { wbuf2.putByte(wbuf.getByte()); }
     wbuf.resetPosition();
     wbuf2.resetPosition();
     for (int i = 0; i < len; i++) {
       assertTrue(srcArray[i] == Long.reverseBytes(wbuf2.getLong()));
     }
-    wbuf2.resetPosition();
     //get
+    wbuf2.resetPosition();
     long[] dstArray = new long[len];
-    wbuf.getLongArray(dstArray, 0, half);
-    wbuf.getLongArray(dstArray, half, half);
+    wbuf.getLongArray(dstArray, 0, qtr);              //get*Array(dst[], dstOff, len)
+    dstArray[qtr] = wbuf.getLong(qtr * LB);           //get*(add)
+    dstArray[qtr + 1] = wbuf.getLong((qtr + 1) * LB); //get*(add)
+    wbuf.setPosition(half * LB);
+    for (int i = half; i < len; i++) { dstArray[i] = wbuf.getLong(); } //get*()
     assertEquals(srcArray, dstArray);
   }
 
@@ -171,72 +213,80 @@ public void checkPutGetNonNativeShorts() {
     short[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
     final int len = srcArray.length;
     final int half = len / 2;
-    WritableBuffer wbuf = WritableMemory.allocate(len * Short.BYTES, NON_NATIVE_BYTE_ORDER).asWritableBuffer();
-    wbuf.putShortArray(srcArray, 0, half);
-    wbuf.putShortArray(srcArray, half, half);
+    final int qtr = len / 4;
+    WritableBuffer wbuf = WritableMemory.allocate(len * SB, NNBO).asWritableBuffer();
+    //put
+    wbuf.putShortArray(srcArray, 0, qtr);              //put*Array(src[], srcOff, len)
+    wbuf.putShort(qtr * SB, srcArray[qtr]);            //put*(add, value)
+    wbuf.putShort((qtr + 1) * SB, srcArray[qtr + 1]);  //put*(add, value)
+    wbuf.setPosition(half * SB);
+    for (int i = half; i < len; i++) { wbuf.putShort(srcArray[i]); } //put*(value)
     wbuf.resetPosition();
     //confirm
-    WritableBuffer wbuf2 = WritableMemory.allocate(len * Short.BYTES, NATIVE_BYTE_ORDER).asWritableBuffer();
-    for (int i = 0; i < len * Short.BYTES; i++) { wbuf2.putByte(wbuf.getByte()); }
+    WritableBuffer wbuf2 = WritableMemory.allocate(len * SB, NBO).asWritableBuffer();
+    for (int i = 0; i < len * SB; i++) { wbuf2.putByte(wbuf.getByte()); }
     wbuf.resetPosition();
     wbuf2.resetPosition();
     for (int i = 0; i < len; i++) {
       assertTrue(srcArray[i] == Short.reverseBytes(wbuf2.getShort()));
     }
-    wbuf2.resetPosition();
     //get
+    wbuf2.resetPosition();
     short[] dstArray = new short[len];
-    wbuf.getShortArray(dstArray, 0, half);
-    wbuf.getShortArray(dstArray, half, half);
+    wbuf.getShortArray(dstArray, 0, qtr);              //get*Array(dst[], dstOff, len)
+    dstArray[qtr] = wbuf.getShort(qtr * SB);           //get*(add)
+    dstArray[qtr + 1] = wbuf.getShort((qtr + 1) * SB); //get*(add)
+    wbuf.setPosition(half * SB);
+    for (int i = half; i < len; i++) { dstArray[i] = wbuf.getShort(); } //get*()
     assertEquals(srcArray, dstArray);
   }
 
   //check Duplicate, Region
   @Test
   public void checkDuplicate() {
     byte[] bArr = new byte[8];
-    WritableMemory wmem = WritableMemory.writableWrap(bArr, NON_NATIVE_BYTE_ORDER);
+    WritableMemory wmem = WritableMemory.writableWrap(bArr, NNBO);
     WritableBuffer wbuf = wmem.asWritableBuffer();
     WritableBuffer wdup = wbuf.writableDuplicate();
-    assertEquals(wdup.getTypeByteOrder(), NON_NATIVE_BYTE_ORDER);
+    assertEquals(wdup.getTypeByteOrder(), NNBO);
 
     WritableBuffer wreg = wbuf.writableRegion();
-    assertEquals(wreg.getTypeByteOrder(), NON_NATIVE_BYTE_ORDER);
+    assertEquals(wreg.getTypeByteOrder(), NNBO);
   }
 
   @Test
   public void checkConversionByteOrder() {
     byte[] bArr = new byte[8];
     bArr[1] = 1;
-    WritableMemory wmem = WritableMemory.writableWrap(bArr, NON_NATIVE_BYTE_ORDER);
-    assertEquals(wmem.getTypeByteOrder(), NON_NATIVE_BYTE_ORDER);
+    WritableMemory wmem = WritableMemory.writableWrap(bArr, NNBO);
+    assertEquals(wmem.getTypeByteOrder(), NNBO);
     assertEquals(wmem.getChar(0), 1);
 
     Buffer buf = wmem.asBuffer();
-    assertEquals(buf.getTypeByteOrder(), NON_NATIVE_BYTE_ORDER); //
+    assertEquals(buf.getTypeByteOrder(), NNBO); //
     assertEquals(buf.getChar(0), 1);
 
     Buffer dup = buf.duplicate();
-    assertEquals(dup.getTypeByteOrder(), NON_NATIVE_BYTE_ORDER);
+    assertEquals(dup.getTypeByteOrder(), NNBO);
     assertEquals(dup.getChar(0), 1);
 
     Buffer reg = buf.region();
-    assertEquals(reg.getTypeByteOrder(), NON_NATIVE_BYTE_ORDER);
+    assertEquals(reg.getTypeByteOrder(), NNBO);
     assertEquals(reg.getChar(0), 1);
 
     Memory mem = reg.asMemory();
-    assertEquals(mem.getTypeByteOrder(), NON_NATIVE_BYTE_ORDER);
+    assertEquals(mem.getTypeByteOrder(), NNBO);
     assertEquals(mem.getChar(0), 1);
 
     Memory mreg = mem.region(0, 8);
-    assertEquals(mreg.getTypeByteOrder(), NON_NATIVE_BYTE_ORDER);
+    assertEquals(mreg.getTypeByteOrder(), NNBO);
     assertEquals(mreg.getChar(0), 1);
   }
 
   @Test
   public void checkPutIntArray() {
-    WritableMemory wmem = WritableMemory.allocate(12, NON_NATIVE_BYTE_ORDER);
-    WritableBuffer wbuf = wmem.asWritableBuffer(NON_NATIVE_BYTE_ORDER);
+    WritableMemory wmem = WritableMemory.allocate(12, NNBO);
+    WritableBuffer wbuf = wmem.asWritableBuffer(NNBO);
 
     wbuf.putInt(1);
     int[] array = new int[] { 2 };