This fixes API changes in the new Memory configuration that will appear
in Memory 2.0.
diff --git a/src/main/java/org/apache/datasketches/ArrayOfBooleansSerDe.java b/src/main/java/org/apache/datasketches/ArrayOfBooleansSerDe.java
index b36cd9a..6cf8e62 100644
--- a/src/main/java/org/apache/datasketches/ArrayOfBooleansSerDe.java
+++ b/src/main/java/org/apache/datasketches/ArrayOfBooleansSerDe.java
@@ -44,7 +44,7 @@
public byte[] serializeToByteArray(final Boolean[] items) {
final int bytesNeeded = computeBytesNeeded(items.length);
final byte[] bytes = new byte[bytesNeeded];
- final WritableMemory mem = WritableMemory.wrap(bytes);
+ final WritableMemory mem = WritableMemory.writableWrap(bytes);
byte val = 0;
for (int i = 0; i < items.length; ++i) {
diff --git a/src/main/java/org/apache/datasketches/ArrayOfDoublesSerDe.java b/src/main/java/org/apache/datasketches/ArrayOfDoublesSerDe.java
index ac754e4..b458577 100644
--- a/src/main/java/org/apache/datasketches/ArrayOfDoublesSerDe.java
+++ b/src/main/java/org/apache/datasketches/ArrayOfDoublesSerDe.java
@@ -33,7 +33,7 @@
@Override
public byte[] serializeToByteArray(final Double[] items) {
final byte[] bytes = new byte[Double.BYTES * items.length];
- final WritableMemory mem = WritableMemory.wrap(bytes);
+ final WritableMemory mem = WritableMemory.writableWrap(bytes);
long offsetBytes = 0;
for (int i = 0; i < items.length; i++) {
mem.putDouble(offsetBytes, items[i]);
diff --git a/src/main/java/org/apache/datasketches/ArrayOfLongsSerDe.java b/src/main/java/org/apache/datasketches/ArrayOfLongsSerDe.java
index e7fee6a..34bfe86 100644
--- a/src/main/java/org/apache/datasketches/ArrayOfLongsSerDe.java
+++ b/src/main/java/org/apache/datasketches/ArrayOfLongsSerDe.java
@@ -33,7 +33,7 @@
@Override
public byte[] serializeToByteArray(final Long[] items) {
final byte[] bytes = new byte[Long.BYTES * items.length];
- final WritableMemory mem = WritableMemory.wrap(bytes);
+ final WritableMemory mem = WritableMemory.writableWrap(bytes);
long offsetBytes = 0;
for (int i = 0; i < items.length; i++) {
mem.putLong(offsetBytes, items[i]);
diff --git a/src/main/java/org/apache/datasketches/ArrayOfNumbersSerDe.java b/src/main/java/org/apache/datasketches/ArrayOfNumbersSerDe.java
index 3256a8b..419a182 100644
--- a/src/main/java/org/apache/datasketches/ArrayOfNumbersSerDe.java
+++ b/src/main/java/org/apache/datasketches/ArrayOfNumbersSerDe.java
@@ -68,7 +68,7 @@
}
}
final byte[] bytes = new byte[length];
- final WritableMemory mem = WritableMemory.wrap(bytes);
+ final WritableMemory mem = WritableMemory.writableWrap(bytes);
long offsetBytes = 0;
for (final Number item: items) {
if (item instanceof Long) {
diff --git a/src/main/java/org/apache/datasketches/ArrayOfStringsSerDe.java b/src/main/java/org/apache/datasketches/ArrayOfStringsSerDe.java
index 1252950..ab9305b 100644
--- a/src/main/java/org/apache/datasketches/ArrayOfStringsSerDe.java
+++ b/src/main/java/org/apache/datasketches/ArrayOfStringsSerDe.java
@@ -45,7 +45,7 @@
length += itemsBytes[i].length + Integer.BYTES;
}
final byte[] bytes = new byte[length];
- final WritableMemory mem = WritableMemory.wrap(bytes);
+ final WritableMemory mem = WritableMemory.writableWrap(bytes);
long offsetBytes = 0;
for (int i = 0; i < items.length; i++) {
mem.putInt(offsetBytes, itemsBytes[i].length);
diff --git a/src/main/java/org/apache/datasketches/ArrayOfUtf16StringsSerDe.java b/src/main/java/org/apache/datasketches/ArrayOfUtf16StringsSerDe.java
index 4c7477b..f202317 100644
--- a/src/main/java/org/apache/datasketches/ArrayOfUtf16StringsSerDe.java
+++ b/src/main/java/org/apache/datasketches/ArrayOfUtf16StringsSerDe.java
@@ -41,7 +41,7 @@
length += (items[i].length() * Character.BYTES) + Integer.BYTES;
}
final byte[] bytes = new byte[length];
- final WritableMemory mem = WritableMemory.wrap(bytes);
+ final WritableMemory mem = WritableMemory.writableWrap(bytes);
long offsetBytes = 0;
for (int i = 0; i < items.length; i++) {
mem.putInt(offsetBytes, items[i].length());
diff --git a/src/main/java/org/apache/datasketches/frequencies/ItemsSketch.java b/src/main/java/org/apache/datasketches/frequencies/ItemsSketch.java
index a4fd947..76a6a0b 100644
--- a/src/main/java/org/apache/datasketches/frequencies/ItemsSketch.java
+++ b/src/main/java/org/apache/datasketches/frequencies/ItemsSketch.java
@@ -498,7 +498,7 @@
outBytes = ((preLongs + activeItems) << 3) + bytes.length;
}
final byte[] outArr = new byte[outBytes];
- final WritableMemory mem = WritableMemory.wrap(outArr);
+ final WritableMemory mem = WritableMemory.writableWrap(outArr);
// build first preLong empty or not
long pre0 = 0L;
diff --git a/src/main/java/org/apache/datasketches/frequencies/LongsSketch.java b/src/main/java/org/apache/datasketches/frequencies/LongsSketch.java
index aab538f..a95f0ba 100644
--- a/src/main/java/org/apache/datasketches/frequencies/LongsSketch.java
+++ b/src/main/java/org/apache/datasketches/frequencies/LongsSketch.java
@@ -566,7 +566,7 @@
outBytes = (preLongs + (2 * activeItems)) << 3; //2 because both keys and values are longs
}
final byte[] outArr = new byte[outBytes];
- final WritableMemory mem = WritableMemory.wrap(outArr);
+ final WritableMemory mem = WritableMemory.writableWrap(outArr);
// build first preLong empty or not
long pre0 = 0L;
diff --git a/src/main/java/org/apache/datasketches/hll/DirectHll4Array.java b/src/main/java/org/apache/datasketches/hll/DirectHll4Array.java
index a56f135..970a0f9 100644
--- a/src/main/java/org/apache/datasketches/hll/DirectHll4Array.java
+++ b/src/main/java/org/apache/datasketches/hll/DirectHll4Array.java
@@ -152,7 +152,7 @@
final boolean srcMemIsCompact = extractCompactFlag(mem);
final int totBytes = getCompactSerializationBytes();
final byte[] byteArr = new byte[totBytes];
- final WritableMemory memOut = WritableMemory.wrap(byteArr);
+ final WritableMemory memOut = WritableMemory.writableWrap(byteArr);
if (srcMemIsCompact) { //mem is already consistent with result
mem.copyTo(0, memOut, 0, totBytes);
return byteArr;
@@ -179,7 +179,7 @@
final boolean memIsCompact = extractCompactFlag(mem);
final int totBytes = getUpdatableSerializationBytes();
final byte[] byteArr = new byte[totBytes];
- final WritableMemory memOut = WritableMemory.wrap(byteArr);
+ final WritableMemory memOut = WritableMemory.writableWrap(byteArr);
if (!memIsCompact) { //both mem and target are updatable
mem.copyTo(0, memOut, 0, totBytes);
diff --git a/src/main/java/org/apache/datasketches/hll/DirectHllArray.java b/src/main/java/org/apache/datasketches/hll/DirectHllArray.java
index f4b2446..d623b8c 100644
--- a/src/main/java/org/apache/datasketches/hll/DirectHllArray.java
+++ b/src/main/java/org/apache/datasketches/hll/DirectHllArray.java
@@ -269,7 +269,7 @@
byte[] toUpdatableByteArray() {
final int totBytes = getCompactSerializationBytes();
final byte[] byteArr = new byte[totBytes];
- final WritableMemory memOut = WritableMemory.wrap(byteArr);
+ final WritableMemory memOut = WritableMemory.writableWrap(byteArr);
mem.copyTo(0, memOut, 0, totBytes);
insertCompactFlag(memOut, false);
return byteArr;
diff --git a/src/main/java/org/apache/datasketches/hll/ToByteArrayImpl.java b/src/main/java/org/apache/datasketches/hll/ToByteArrayImpl.java
index 131a53c..3e08144 100644
--- a/src/main/java/org/apache/datasketches/hll/ToByteArrayImpl.java
+++ b/src/main/java/org/apache/datasketches/hll/ToByteArrayImpl.java
@@ -68,7 +68,7 @@
}
final int totBytes = HLL_BYTE_ARR_START + impl.getHllByteArrBytes() + auxBytes;
final byte[] byteArr = new byte[totBytes];
- final WritableMemory wmem = WritableMemory.wrap(byteArr);
+ final WritableMemory wmem = WritableMemory.writableWrap(byteArr);
insertHll(impl, wmem, compact);
return byteArr;
}
@@ -146,7 +146,7 @@
final int dataStart = impl.getMemDataStart();
final int bytesOut = dataStart + (srcCouponArrInts << 2);
byteArrOut = new byte[bytesOut];
- final WritableMemory memOut = WritableMemory.wrap(byteArrOut);
+ final WritableMemory memOut = WritableMemory.writableWrap(byteArrOut);
copyCommonListAndSet(impl, memOut);
insertCompactFlag(memOut, dstCompact);
@@ -174,7 +174,7 @@
final int dataStart = impl.getMemDataStart();
final int bytesOut = dataStart + (srcCouponCount << 2);
byteArrOut = new byte[bytesOut];
- final WritableMemory memOut = WritableMemory.wrap(byteArrOut);
+ final WritableMemory memOut = WritableMemory.writableWrap(byteArrOut);
copyCommonListAndSet(impl, memOut);
insertCompactFlag(memOut, dstCompact);
@@ -201,7 +201,7 @@
final int dataStart = impl.getMemDataStart();
final int bytesOut = dataStart + (srcCouponCount << 2);
byteArrOut = new byte[bytesOut];
- final WritableMemory memOut = WritableMemory.wrap(byteArrOut);
+ final WritableMemory memOut = WritableMemory.writableWrap(byteArrOut);
copyCommonListAndSet(impl, memOut);
insertCompactFlag(memOut, dstCompact);
@@ -221,7 +221,7 @@
final int dataStart = impl.getMemDataStart();
final int bytesOut = dataStart + (srcCouponArrInts << 2);
byteArrOut = new byte[bytesOut];
- final WritableMemory memOut = WritableMemory.wrap(byteArrOut);
+ final WritableMemory memOut = WritableMemory.writableWrap(byteArrOut);
copyCommonListAndSet(impl, memOut);
memOut.putIntArray(dataStart, impl.getCouponIntArr(), 0, srcCouponArrInts);
diff --git a/src/main/java/org/apache/datasketches/quantiles/DoublesByteArrayImpl.java b/src/main/java/org/apache/datasketches/quantiles/DoublesByteArrayImpl.java
index 540fbe4..e59273d 100644
--- a/src/main/java/org/apache/datasketches/quantiles/DoublesByteArrayImpl.java
+++ b/src/main/java/org/apache/datasketches/quantiles/DoublesByteArrayImpl.java
@@ -58,7 +58,7 @@
if (empty && !sketch.isDirect()) { //empty & on-heap
final byte[] outByteArr = new byte[Long.BYTES];
- final WritableMemory memOut = WritableMemory.wrap(outByteArr);
+ final WritableMemory memOut = WritableMemory.writableWrap(outByteArr);
final int preLongs = 1;
insertPre0(memOut, preLongs, flags, sketch.getK());
return outByteArr;
@@ -90,7 +90,7 @@
final int outBytes = (compact ? sketch.getCompactStorageBytes() : sketch.getUpdatableStorageBytes());
final byte[] outByteArr = new byte[outBytes];
- final WritableMemory memOut = WritableMemory.wrap(outByteArr);
+ final WritableMemory memOut = WritableMemory.writableWrap(outByteArr);
//insert preamble-0, N, min, max
insertPre0(memOut, preLongs, flags, k);
diff --git a/src/main/java/org/apache/datasketches/quantiles/ItemsByteArrayImpl.java b/src/main/java/org/apache/datasketches/quantiles/ItemsByteArrayImpl.java
index 0036ba4..919020f 100644
--- a/src/main/java/org/apache/datasketches/quantiles/ItemsByteArrayImpl.java
+++ b/src/main/java/org/apache/datasketches/quantiles/ItemsByteArrayImpl.java
@@ -56,7 +56,7 @@
if (empty) {
final byte[] outByteArr = new byte[Long.BYTES];
- final WritableMemory memOut = WritableMemory.wrap(outByteArr);
+ final WritableMemory memOut = WritableMemory.writableWrap(outByteArr);
final int preLongs = 1;
insertPre0(memOut, preLongs, flags, sketch.getK());
return outByteArr;
@@ -69,7 +69,7 @@
final byte[] itemsByteArr = serDe.serializeToByteArray(dataArr);
final int numOutBytes = (preLongs << 3) + itemsByteArr.length;
final byte[] outByteArr = new byte[numOutBytes];
- final WritableMemory memOut = WritableMemory.wrap(outByteArr);
+ final WritableMemory memOut = WritableMemory.writableWrap(outByteArr);
//insert preamble
insertPre0(memOut, preLongs, flags, sketch.getK());
diff --git a/src/main/java/org/apache/datasketches/req/FloatBuffer.java b/src/main/java/org/apache/datasketches/req/FloatBuffer.java
index 72c48b9..6d86316 100755
--- a/src/main/java/org/apache/datasketches/req/FloatBuffer.java
+++ b/src/main/java/org/apache/datasketches/req/FloatBuffer.java
@@ -398,7 +398,7 @@
byte[] floatsToBytes() {
final int bytes = Float.BYTES * count_;
final byte[] arr = new byte[bytes];
- final WritableBuffer wbuf = WritableMemory.wrap(arr).asWritableBuffer();
+ final WritableBuffer wbuf = WritableMemory.writableWrap(arr).asWritableBuffer();
if (spaceAtBottom_) {
wbuf.putFloatArray(arr_, capacity_ - count_, count_);
} else {
diff --git a/src/main/java/org/apache/datasketches/req/ReqCompactor.java b/src/main/java/org/apache/datasketches/req/ReqCompactor.java
index d1eede8..968eea7 100644
--- a/src/main/java/org/apache/datasketches/req/ReqCompactor.java
+++ b/src/main/java/org/apache/datasketches/req/ReqCompactor.java
@@ -297,7 +297,7 @@
byte[] toByteArray() {
final int bytes = getSerializationBytes();
final byte[] arr = new byte[bytes];
- final WritableBuffer wbuf = WritableMemory.wrap(arr).asWritableBuffer();
+ final WritableBuffer wbuf = WritableMemory.writableWrap(arr).asWritableBuffer();
wbuf.putLong(state);
wbuf.putFloat(sectionSizeFlt);
wbuf.putByte(lgWeight);
diff --git a/src/main/java/org/apache/datasketches/req/ReqSerDe.java b/src/main/java/org/apache/datasketches/req/ReqSerDe.java
index d5f7712..5164852 100644
--- a/src/main/java/org/apache/datasketches/req/ReqSerDe.java
+++ b/src/main/java/org/apache/datasketches/req/ReqSerDe.java
@@ -266,7 +266,7 @@
final SerDeFormat serDeFormat = getSerFormat(sk);
final int bytes = getSerBytes(sk, serDeFormat);
final byte[] arr = new byte[bytes];
- final WritableBuffer wbuf = WritableMemory.wrap(arr).asWritableBuffer();
+ final WritableBuffer wbuf = WritableMemory.writableWrap(arr).asWritableBuffer();
final byte preInts = (byte)(serDeFormat == SerDeFormat.ESTIMATION ? 4 : 2);
final byte flags = getFlags(sk);
final byte numCompactors = sk.isEmpty() ? 0 : (byte) sk.getNumLevels();
diff --git a/src/main/java/org/apache/datasketches/sampling/ReservoirItemsSketch.java b/src/main/java/org/apache/datasketches/sampling/ReservoirItemsSketch.java
index 3c4741c..d4344dd 100644
--- a/src/main/java/org/apache/datasketches/sampling/ReservoirItemsSketch.java
+++ b/src/main/java/org/apache/datasketches/sampling/ReservoirItemsSketch.java
@@ -475,7 +475,7 @@
outBytes = (preLongs << 3) + bytes.length;
}
final byte[] outArr = new byte[outBytes];
- final WritableMemory mem = WritableMemory.wrap(outArr);
+ final WritableMemory mem = WritableMemory.writableWrap(outArr);
// Common header elements
PreambleUtil.insertPreLongs(mem, preLongs); // Byte 0
diff --git a/src/main/java/org/apache/datasketches/sampling/ReservoirItemsUnion.java b/src/main/java/org/apache/datasketches/sampling/ReservoirItemsUnion.java
index 28e0e4d..6d56a57 100644
--- a/src/main/java/org/apache/datasketches/sampling/ReservoirItemsUnion.java
+++ b/src/main/java/org/apache/datasketches/sampling/ReservoirItemsUnion.java
@@ -300,7 +300,7 @@
outBytes = (preLongs << 3) + gadgetBytes.length; // for longs, we know the size
}
final byte[] outArr = new byte[outBytes];
- final WritableMemory mem = WritableMemory.wrap(outArr);
+ final WritableMemory mem = WritableMemory.writableWrap(outArr);
// build preLong
PreambleUtil.insertPreLongs(mem, preLongs); // Byte 0
diff --git a/src/main/java/org/apache/datasketches/sampling/ReservoirLongsSketch.java b/src/main/java/org/apache/datasketches/sampling/ReservoirLongsSketch.java
index ee2ec59..62b430c 100644
--- a/src/main/java/org/apache/datasketches/sampling/ReservoirLongsSketch.java
+++ b/src/main/java/org/apache/datasketches/sampling/ReservoirLongsSketch.java
@@ -402,7 +402,7 @@
outBytes = (preLongs + numItems) << 3; // for longs, we know the size
}
final byte[] outArr = new byte[outBytes];
- final WritableMemory mem = WritableMemory.wrap(outArr);
+ final WritableMemory mem = WritableMemory.writableWrap(outArr);
// build first preLong
PreambleUtil.insertPreLongs(mem, preLongs); // Byte 0
diff --git a/src/main/java/org/apache/datasketches/sampling/ReservoirLongsUnion.java b/src/main/java/org/apache/datasketches/sampling/ReservoirLongsUnion.java
index 891e9d2..50c891f 100644
--- a/src/main/java/org/apache/datasketches/sampling/ReservoirLongsUnion.java
+++ b/src/main/java/org/apache/datasketches/sampling/ReservoirLongsUnion.java
@@ -253,7 +253,7 @@
outBytes = (preLongs << 3) + gadgetBytes.length; // longs, so we know the size
}
final byte[] outArr = new byte[outBytes];
- final WritableMemory mem = WritableMemory.wrap(outArr);
+ final WritableMemory mem = WritableMemory.writableWrap(outArr);
// construct header
PreambleUtil.insertPreLongs(mem, preLongs); // Byte 0
diff --git a/src/main/java/org/apache/datasketches/sampling/VarOptItemsSketch.java b/src/main/java/org/apache/datasketches/sampling/VarOptItemsSketch.java
index 055ebbb..0d1f832 100644
--- a/src/main/java/org/apache/datasketches/sampling/VarOptItemsSketch.java
+++ b/src/main/java/org/apache/datasketches/sampling/VarOptItemsSketch.java
@@ -584,7 +584,7 @@
outBytes = (preLongs << 3) + (h_ * Double.BYTES) + numMarkBytes + itemBytes.length;
}
final byte[] outArr = new byte[outBytes];
- final WritableMemory mem = WritableMemory.wrap(outArr);
+ final WritableMemory mem = WritableMemory.writableWrap(outArr);
// build first preLong
PreambleUtil.insertPreLongs(mem, preLongs); // Byte 0
diff --git a/src/main/java/org/apache/datasketches/sampling/VarOptItemsUnion.java b/src/main/java/org/apache/datasketches/sampling/VarOptItemsUnion.java
index 4c13abc..975ff17 100644
--- a/src/main/java/org/apache/datasketches/sampling/VarOptItemsUnion.java
+++ b/src/main/java/org/apache/datasketches/sampling/VarOptItemsUnion.java
@@ -328,7 +328,7 @@
outBytes = (preLongs << 3) + gadgetBytes.length; // for longs, we know the size
}
final byte[] outArr = new byte[outBytes];
- final WritableMemory mem = WritableMemory.wrap(outArr);
+ final WritableMemory mem = WritableMemory.writableWrap(outArr);
// build preLong
PreambleUtil.insertPreLongs(mem, preLongs); // Byte 0
diff --git a/src/main/java/org/apache/datasketches/theta/DirectQuickSelectSketchR.java b/src/main/java/org/apache/datasketches/theta/DirectQuickSelectSketchR.java
index d79b71b..1958b90 100644
--- a/src/main/java/org/apache/datasketches/theta/DirectQuickSelectSketchR.java
+++ b/src/main/java/org/apache/datasketches/theta/DirectQuickSelectSketchR.java
@@ -172,7 +172,7 @@
checkIllegalCurCountAndEmpty(isEmpty(), extractCurCount(wmem_));
final int lengthBytes = getCurrentBytes();
final byte[] byteArray = new byte[lengthBytes];
- final WritableMemory mem = WritableMemory.wrap(byteArray);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArray);
wmem_.copyTo(0, mem, 0, lengthBytes);
final long thetaLong =
correctThetaOnCompact(isEmpty(), extractCurCount(wmem_), extractThetaLong(wmem_));
@@ -219,7 +219,7 @@
final long lgArrLongs = wmem_.getByte(LG_ARR_LONGS_BYTE) & 0XFF;
final int preambleLongs = wmem_.getByte(PREAMBLE_LONGS_BYTE) & 0X3F;
final long[] cacheArr = new long[1 << lgArrLongs];
- final WritableMemory mem = WritableMemory.wrap(cacheArr);
+ final WritableMemory mem = WritableMemory.writableWrap(cacheArr);
wmem_.copyTo(preambleLongs << 3, mem, 0, 8 << lgArrLongs);
return cacheArr;
}
diff --git a/src/main/java/org/apache/datasketches/theta/HeapCompactSketch.java b/src/main/java/org/apache/datasketches/theta/HeapCompactSketch.java
index 432b4aa..e1f1ebb 100644
--- a/src/main/java/org/apache/datasketches/theta/HeapCompactSketch.java
+++ b/src/main/java/org/apache/datasketches/theta/HeapCompactSketch.java
@@ -158,7 +158,7 @@
public byte[] toByteArray() {
final int bytes = getCurrentBytes();
final byte[] byteArray = new byte[bytes];
- final WritableMemory dstMem = WritableMemory.wrap(byteArray);
+ final WritableMemory dstMem = WritableMemory.writableWrap(byteArray);
final int emptyBit = isEmpty() ? EMPTY_FLAG_MASK : 0;
final int orderedBit = ordered_ ? ORDERED_FLAG_MASK : 0;
final int singleItemBit = singleItem_ ? SINGLEITEM_FLAG_MASK : 0;
diff --git a/src/main/java/org/apache/datasketches/theta/HeapUpdateSketch.java b/src/main/java/org/apache/datasketches/theta/HeapUpdateSketch.java
index 2bc2915..f0e67a2 100644
--- a/src/main/java/org/apache/datasketches/theta/HeapUpdateSketch.java
+++ b/src/main/java/org/apache/datasketches/theta/HeapUpdateSketch.java
@@ -113,7 +113,7 @@
final int preBytes = (preLongs << 3) & 0X3F;
final int dataBytes = getCurrentDataLongs() << 3;
final byte[] byteArrOut = new byte[preBytes + dataBytes];
- final WritableMemory memOut = WritableMemory.wrap(byteArrOut);
+ final WritableMemory memOut = WritableMemory.writableWrap(byteArrOut);
//preamble first 8 bytes. Note: only compact can be reduced to 8 bytes.
final int lgRf = getResizeFactor().lg() & 0x3;
diff --git a/src/main/java/org/apache/datasketches/theta/IntersectionImpl.java b/src/main/java/org/apache/datasketches/theta/IntersectionImpl.java
index 4a8811c..901ec42 100644
--- a/src/main/java/org/apache/datasketches/theta/IntersectionImpl.java
+++ b/src/main/java/org/apache/datasketches/theta/IntersectionImpl.java
@@ -363,7 +363,7 @@
wmem_.getByteArray(0, byteArrOut, 0, preBytes + dataBytes);
}
else {
- final WritableMemory memOut = WritableMemory.wrap(byteArrOut);
+ final WritableMemory memOut = WritableMemory.writableWrap(byteArrOut);
//preamble
memOut.putByte(PREAMBLE_LONGS_BYTE, (byte) CONST_PREAMBLE_LONGS); //RF not used = 0
diff --git a/src/main/java/org/apache/datasketches/theta/UnionImpl.java b/src/main/java/org/apache/datasketches/theta/UnionImpl.java
index 591d1ca..83888f6 100644
--- a/src/main/java/org/apache/datasketches/theta/UnionImpl.java
+++ b/src/main/java/org/apache/datasketches/theta/UnionImpl.java
@@ -260,7 +260,7 @@
@Override
public byte[] toByteArray() {
final byte[] gadgetByteArr = gadget_.toByteArray();
- final WritableMemory mem = WritableMemory.wrap(gadgetByteArr);
+ final WritableMemory mem = WritableMemory.writableWrap(gadgetByteArr);
insertUnionThetaLong(mem, unionThetaLong_);
if (gadget_.isEmpty() != unionEmpty_) {
clearEmpty(mem);
diff --git a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnion.java b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnion.java
index 7835c82..ec781f9 100644
--- a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnion.java
+++ b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnion.java
@@ -199,7 +199,7 @@
public byte[] toByteArray() {
final int sizeBytes = PREAMBLE_SIZE_BYTES + sketch_.getSerializedSizeBytes();
final byte[] byteArray = new byte[sizeBytes];
- final WritableMemory mem = WritableMemory.wrap(byteArray);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArray);
mem.putByte(PREAMBLE_LONGS_BYTE, (byte) 1); // unused, always 1
mem.putByte(SERIAL_VERSION_BYTE, serialVersionUID);
mem.putByte(FAMILY_ID_BYTE, (byte) Family.TUPLE.getID());
diff --git a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesCompactSketch.java b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesCompactSketch.java
index 3939e1b..8da948d 100644
--- a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesCompactSketch.java
+++ b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesCompactSketch.java
@@ -198,7 +198,7 @@
+ (SIZE_OF_VALUE_BYTES * count * numValues_);
}
final byte[] byteArray = new byte[sizeBytes];
- final WritableMemory mem = WritableMemory.wrap(byteArray);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArray);
mem_.copyTo(0, mem, 0, sizeBytes);
return byteArray;
}
diff --git a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesQuickSelectSketch.java b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesQuickSelectSketch.java
index 5c4e4b4..5341297 100644
--- a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesQuickSelectSketch.java
+++ b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesQuickSelectSketch.java
@@ -171,7 +171,7 @@
public byte[] toByteArray() {
final int sizeBytes = getSerializedSizeBytes();
final byte[] byteArray = new byte[sizeBytes];
- final WritableMemory mem = WritableMemory.wrap(byteArray);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArray);
serializeInto(mem);
return byteArray;
}
diff --git a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesCompactSketch.java b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesCompactSketch.java
index 3ad23d4..1f34022 100644
--- a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesCompactSketch.java
+++ b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesCompactSketch.java
@@ -157,7 +157,7 @@
ENTRIES_START + (SIZE_OF_KEY_BYTES * count) + (SIZE_OF_VALUE_BYTES * numValues_ * count);
}
final byte[] bytes = new byte[sizeBytes];
- final WritableMemory mem = WritableMemory.wrap(bytes);
+ final WritableMemory mem = WritableMemory.writableWrap(bytes);
mem.putByte(PREAMBLE_LONGS_BYTE, (byte) 1);
mem.putByte(SERIAL_VERSION_BYTE, serialVersionUID);
mem.putByte(FAMILY_ID_BYTE, (byte) Family.TUPLE.getID());
diff --git a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketch.java b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketch.java
index 5b10192..c4ce58c 100644
--- a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketch.java
+++ b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketch.java
@@ -153,7 +153,7 @@
@Override
public byte[] toByteArray() {
final byte[] byteArray = new byte[getSerializedSizeBytes()];
- final WritableMemory mem = WritableMemory.wrap(byteArray); // wrap the byte array to use the putX methods
+ final WritableMemory mem = WritableMemory.writableWrap(byteArray); // wrap the byte array to use the putX methods
serializeInto(mem);
return byteArray;
}
diff --git a/src/main/java/org/apache/datasketches/tuple/strings/ArrayOfStringsSummary.java b/src/main/java/org/apache/datasketches/tuple/strings/ArrayOfStringsSummary.java
index 75ab751..08b1f51 100644
--- a/src/main/java/org/apache/datasketches/tuple/strings/ArrayOfStringsSummary.java
+++ b/src/main/java/org/apache/datasketches/tuple/strings/ArrayOfStringsSummary.java
@@ -75,7 +75,7 @@
final ComputeBytes cb = new ComputeBytes(nodesArr);
final int totBytes = cb.totBytes_;
final byte[] out = new byte[totBytes];
- final WritableMemory wmem = WritableMemory.wrap(out);
+ final WritableMemory wmem = WritableMemory.writableWrap(out);
final WritableBuffer wbuf = wmem.asWritableBuffer();
wbuf.putInt(totBytes);
wbuf.putByte(cb.numNodes_);
diff --git a/src/test/java/org/apache/datasketches/HashOperationsTest.java b/src/test/java/org/apache/datasketches/HashOperationsTest.java
index f7495aa..1c2e529 100644
--- a/src/test/java/org/apache/datasketches/HashOperationsTest.java
+++ b/src/test/java/org/apache/datasketches/HashOperationsTest.java
@@ -106,7 +106,7 @@
@Test
public void testHashInsertOnlyMemoryNoStride() {
final long[] table = new long[32];
- final WritableMemory mem = WritableMemory.wrap(table);
+ final WritableMemory mem = WritableMemory.writableWrap(table);
final int index = hashInsertOnlyMemory(mem, 5, 1, 0);
assertEquals(index, 1);
assertEquals(table[1], 1L);
@@ -116,7 +116,7 @@
public void testHashInsertOnlyMemoryWithStride() {
final long[] table = new long[32];
table[1] = 1;
- final WritableMemory mem = WritableMemory.wrap(table);
+ final WritableMemory mem = WritableMemory.writableWrap(table);
final int index = hashInsertOnlyMemory(mem, 5, 1, 0);
assertEquals(index, 2);
assertEquals(table[2], 1L);
@@ -151,7 +151,7 @@
@Test
public void checkFullDirectTableCatchesInfiniteLoop() {
final long[] table = new long[32];
- final WritableMemory mem = WritableMemory.wrap(table);
+ final WritableMemory mem = WritableMemory.writableWrap(table);
for (int i = 1; i <= 32; ++i) {
hashInsertOnlyMemory(mem, 5, i, 0);
}
@@ -178,7 +178,7 @@
@Test
public void checkFullFastDirectTableCatchesInfiniteLoop() {
final long[] table = new long[32];
- final WritableMemory wmem = WritableMemory.wrap(table);
+ final WritableMemory wmem = WritableMemory.writableWrap(table);
for (int i = 1; i <= 32; ++i) {
hashInsertOnlyMemory(wmem, 5, i, 0);
diff --git a/src/test/java/org/apache/datasketches/cpc/CpcCBinariesTest.java b/src/test/java/org/apache/datasketches/cpc/CpcCBinariesTest.java
index 3df8816..4600674 100644
--- a/src/test/java/org/apache/datasketches/cpc/CpcCBinariesTest.java
+++ b/src/test/java/org/apache/datasketches/cpc/CpcCBinariesTest.java
@@ -23,7 +23,6 @@
import static org.testng.Assert.assertEquals;
import java.io.File;
-import java.io.IOException;
import java.io.PrintStream;
import org.apache.datasketches.memory.MapHandle;
@@ -48,7 +47,7 @@
println(PreambleUtil.toString(wmem, true));
final CpcSketch sk = CpcSketch.heapify(wmem);
assertEquals(sk.getFlavor(), Flavor.EMPTY);
- } catch (final IOException e) {
+ } catch (final Exception e) {
e.printStackTrace();
}
}
@@ -74,7 +73,7 @@
for (int i = 0; i < 100; i++) { sk.update(i); }
final double est2 = sk.getEstimate();
assertEquals(est2, est1, 0); //assert no change
- } catch (final IOException e) {
+ } catch (final Exception e) {
e.printStackTrace();
}
}
@@ -100,7 +99,7 @@
for (long i = 0; i < 200; i++) { sk.update(i); }
final double est2 = sk.getEstimate();
assertEquals(est2, est1, 0); //assert no change
- } catch (final IOException e) {
+ } catch (final Exception e) {
e.printStackTrace();
}
}
@@ -126,7 +125,7 @@
for (long i = 0; i < 2000; i++) { sk.update(i); }
final double est2 = sk.getEstimate();
assertEquals(est2, est1, 0); //assert no change
- } catch (final IOException e) {
+ } catch (final Exception e) {
e.printStackTrace();
}
}
@@ -152,7 +151,7 @@
for (long i = 0; i < 20000; i++) { sk.update(i); }
final double est2 = sk.getEstimate();
assertEquals(est2, est1, 0);
- } catch (final IOException e) {
+ } catch (final Exception e) {
e.printStackTrace();
}
}
@@ -174,7 +173,7 @@
final Memory mem2 = Memory.wrap(mem2ByteArr);
assertEquals(mem.getCapacity(), mem2.getCapacity());
assertEquals(memByteArr, mem2ByteArr);
- } catch (final IOException e) {
+ } catch (final Exception e) {
e.printStackTrace();
}
}
@@ -195,7 +194,7 @@
final Memory mem2 = Memory.wrap(mem2ByteArr);
assertEquals(mem.getCapacity(), mem2.getCapacity());
assertEquals(memByteArr, mem2ByteArr);
- } catch (final IOException e) {
+ } catch (final Exception e) {
e.printStackTrace();
}
}
@@ -216,7 +215,7 @@
final Memory mem2 = Memory.wrap(mem2ByteArr);
assertEquals(mem.getCapacity(), mem2.getCapacity());
assertEquals(memByteArr, mem2ByteArr);
- } catch (final IOException e) {
+ } catch (final Exception e) {
e.printStackTrace();
}
}
@@ -237,7 +236,7 @@
final Memory mem2 = Memory.wrap(javaMemByteArr);
assertEquals(mem.getCapacity(), mem2.getCapacity());
assertEquals(cppMemByteArr, javaMemByteArr);
- } catch (final IOException e) {
+ } catch (final Exception e) {
e.printStackTrace();
}
}
@@ -258,7 +257,7 @@
final Memory mem2 = Memory.wrap(mem2ByteArr);
assertEquals(mem.getCapacity(), mem2.getCapacity());
assertEquals(memByteArr, mem2ByteArr);
- } catch (final IOException e) {
+ } catch (final Exception e) {
e.printStackTrace();
}
}
diff --git a/src/test/java/org/apache/datasketches/cpc/SpecialCBinariesTest.java b/src/test/java/org/apache/datasketches/cpc/SpecialCBinariesTest.java
index e0f7234..17e3582 100644
--- a/src/test/java/org/apache/datasketches/cpc/SpecialCBinariesTest.java
+++ b/src/test/java/org/apache/datasketches/cpc/SpecialCBinariesTest.java
@@ -53,7 +53,7 @@
try {
CpcSketch sk = CpcSketch.heapify(mem);
} catch (SketchesArgumentException e) {} // Image was truncated by 4 bytes
- } catch (IOException e) {
+ } catch (Exception e) {
e.printStackTrace();
}
}
@@ -90,8 +90,8 @@
assertTrue(file.isFile());
try (WritableMapHandle wmh
- = WritableMemory.map(file, 0, byteArr.length, ByteOrder.nativeOrder())) {
- WritableMemory wmem = wmh.get();
+ = WritableMemory.writableMap(file, 0, byteArr.length, ByteOrder.nativeOrder())) {
+ WritableMemory wmem = wmh.getWritable();
wmem.putByteArray(0, byteArr, 0, byteArr.length);
wmh.force();
} catch (IOException e) {
diff --git a/src/test/java/org/apache/datasketches/frequencies/ItemsSketchTest.java b/src/test/java/org/apache/datasketches/frequencies/ItemsSketchTest.java
index 211aa8e..e0c515c 100644
--- a/src/test/java/org/apache/datasketches/frequencies/ItemsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/frequencies/ItemsSketchTest.java
@@ -346,7 +346,7 @@
sk1.update(Long.valueOf(1), 1);
ArrayOfLongsSerDe serDe = new ArrayOfLongsSerDe();
byte[] byteArr = sk1.toByteArray(serDe);
- WritableMemory mem = WritableMemory.wrap(byteArr);
+ WritableMemory mem = WritableMemory.writableWrap(byteArr);
//FrequentItemsSketch<Long> sk2 = FrequentItemsSketch.getInstance(mem, serDe);
//println(sk2.toString());
long pre0 = mem.getLong(0); //The correct first 8 bytes.
diff --git a/src/test/java/org/apache/datasketches/frequencies/LongsSketchTest.java b/src/test/java/org/apache/datasketches/frequencies/LongsSketchTest.java
index 4f53204..e52dfcf 100644
--- a/src/test/java/org/apache/datasketches/frequencies/LongsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/frequencies/LongsSketchTest.java
@@ -121,7 +121,7 @@
//Empty Sketch
LongsSketch sketch = new LongsSketch(16);
byte[] bytearray0 = sketch.toByteArray();
- WritableMemory mem0 = WritableMemory.wrap(bytearray0);
+ WritableMemory mem0 = WritableMemory.writableWrap(bytearray0);
LongsSketch new_sketch0 = LongsSketch.getInstance(mem0);
String str0 = LongsSketch.toString(mem0);
println(str0);
@@ -284,7 +284,7 @@
sk1.update(1L);
byte[] bytearray0 = sk1.toByteArray();
- WritableMemory mem = WritableMemory.wrap(bytearray0);
+ WritableMemory mem = WritableMemory.writableWrap(bytearray0);
long pre0 = mem.getLong(0);
tryBadMem(mem, PREAMBLE_LONGS_BYTE, 2); //Corrupt
@@ -386,7 +386,7 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkGetInstanceMemory() {
- WritableMemory mem = WritableMemory.wrap(new byte[4]);
+ WritableMemory mem = WritableMemory.writableWrap(new byte[4]);
LongsSketch.getInstance(mem);
}
diff --git a/src/test/java/org/apache/datasketches/frequencies/SerDeCompatibilityTest.java b/src/test/java/org/apache/datasketches/frequencies/SerDeCompatibilityTest.java
index 2417cf7..3414598 100644
--- a/src/test/java/org/apache/datasketches/frequencies/SerDeCompatibilityTest.java
+++ b/src/test/java/org/apache/datasketches/frequencies/SerDeCompatibilityTest.java
@@ -40,7 +40,7 @@
sketch1.update(4L);
byte[] bytes = sketch1.toByteArray(serDe);
- LongsSketch sketch2 = LongsSketch.getInstance(WritableMemory.wrap(bytes));
+ LongsSketch sketch2 = LongsSketch.getInstance(WritableMemory.writableWrap(bytes));
sketch2.update(2L);
sketch2.update(3L);
sketch2.update(2L);
@@ -63,7 +63,7 @@
sketch1.update(4L);
byte[] bytes = sketch1.toByteArray();
- ItemsSketch<Long> sketch2 = ItemsSketch.getInstance(WritableMemory.wrap(bytes), serDe);
+ ItemsSketch<Long> sketch2 = ItemsSketch.getInstance(WritableMemory.writableWrap(bytes), serDe);
sketch2.update(2L);
sketch2.update(3L);
sketch2.update(2L);
diff --git a/src/test/java/org/apache/datasketches/hash/MurmurHash3v2Test.java b/src/test/java/org/apache/datasketches/hash/MurmurHash3v2Test.java
index 2e074bd..c56c6c4 100644
--- a/src/test/java/org/apache/datasketches/hash/MurmurHash3v2Test.java
+++ b/src/test/java/org/apache/datasketches/hash/MurmurHash3v2Test.java
@@ -66,7 +66,7 @@
for (int j = 1; j < bytes; j++) {
byte[] in = new byte[bytes];
- WritableMemory wmem = WritableMemory.wrap(in);
+ WritableMemory wmem = WritableMemory.writableWrap(in);
for (int i = 0; i < j; i++) { wmem.putByte(i, (byte) (-128 + i)); }
long[] hash1 = MurmurHash3.hash(in, 0);
@@ -90,7 +90,7 @@
for (int j = 1; j < chars; j++) {
char[] in = new char[chars];
- WritableMemory wmem = WritableMemory.wrap(in);
+ WritableMemory wmem = WritableMemory.writableWrap(in);
for (int i = 0; i < j; i++) { wmem.putInt(i, i); }
long[] hash1 = MurmurHash3.hash(in, 0);
@@ -114,7 +114,7 @@
for (int j = 1; j < ints; j++) {
int[] in = new int[ints];
- WritableMemory wmem = WritableMemory.wrap(in);
+ WritableMemory wmem = WritableMemory.writableWrap(in);
for (int i = 0; i < j; i++) { wmem.putInt(i, i); }
long[] hash1 = MurmurHash3.hash(in, 0);
@@ -138,7 +138,7 @@
for (int j = 1; j < longs; j++) {
long[] in = new long[longs];
- WritableMemory wmem = WritableMemory.wrap(in);
+ WritableMemory wmem = WritableMemory.writableWrap(in);
for (int i = 0; i < j; i++) { wmem.putLong(i, i); }
long[] hash1 = MurmurHash3.hash(in, 0);
@@ -158,7 +158,7 @@
long[] hash2 = new long[2];
long[] in = { 1 };
- WritableMemory wmem = WritableMemory.wrap(in);
+ WritableMemory wmem = WritableMemory.writableWrap(in);
long[] hash1 = MurmurHash3.hash(in, 0);
hash2 = MurmurHash3v2.hash(wmem, offset, bytes, seed, hash2);
@@ -231,7 +231,7 @@
final long data = Double.doubleToLongBits(d);// canonicalize all NaN forms
final long[] dataArr = { data };
- WritableMemory wmem = WritableMemory.wrap(dataArr);
+ WritableMemory wmem = WritableMemory.writableWrap(dataArr);
long[] hash1 = MurmurHash3.hash(dataArr, 0);
hash2 = MurmurHash3v2.hash(wmem, offset, bytes, seed, hash2);
long[] hash3 = MurmurHash3v2.hash(dbl, seed, hash2);
diff --git a/src/test/java/org/apache/datasketches/hll/BaseHllSketchTest.java b/src/test/java/org/apache/datasketches/hll/BaseHllSketchTest.java
index e78e807..c3ee04b 100644
--- a/src/test/java/org/apache/datasketches/hll/BaseHllSketchTest.java
+++ b/src/test/java/org/apache/datasketches/hll/BaseHllSketchTest.java
@@ -94,7 +94,7 @@
assertTrue(sk.isEstimationMode());
sk.reset();
assertEquals(BaseHllSketch.getSerializationVersion(), PreambleUtil.SER_VER);
- WritableMemory wmem = WritableMemory.wrap(sk.toCompactByteArray());
+ WritableMemory wmem = WritableMemory.writableWrap(sk.toCompactByteArray());
assertEquals(BaseHllSketch.getSerializationVersion(wmem), PreambleUtil.SER_VER);
}
diff --git a/src/test/java/org/apache/datasketches/hll/DirectAuxHashMapTest.java b/src/test/java/org/apache/datasketches/hll/DirectAuxHashMapTest.java
index d25efc6..0a83ec0 100644
--- a/src/test/java/org/apache/datasketches/hll/DirectAuxHashMapTest.java
+++ b/src/test/java/org/apache/datasketches/hll/DirectAuxHashMapTest.java
@@ -50,7 +50,7 @@
int bytes = HllSketch.getMaxUpdatableSerializationBytes(lgConfigK, tgtHllType);
HllSketch hllSketch;
try (WritableDirectHandle handle = WritableMemory.allocateDirect(bytes)) {
- WritableMemory wmem = handle.get();
+ WritableMemory wmem = handle.getWritable();
hllSketch = new HllSketch(lgConfigK, tgtHllType, wmem);
for (int i = 0; i < n; i++) {
hllSketch.update(i);
@@ -74,7 +74,7 @@
//Check wrap
byteArray = hllSketch.toUpdatableByteArray();
- WritableMemory wmem2 = WritableMemory.wrap(byteArray);
+ WritableMemory wmem2 = WritableMemory.writableWrap(byteArray);
hllSketch2 = HllSketch.writableWrap(wmem2);
//println(hllSketch2.toString(true, true, true, true));
DirectHllArray dha2 = (DirectHllArray) hllSketch2.hllSketchImpl;
@@ -90,6 +90,8 @@
assertTrue(hllSketch.isMemory());
assertFalse(hllSketch.isOffHeap());
assertFalse(hllSketch.isSameResource(wmem));
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -100,7 +102,7 @@
TgtHllType type = TgtHllType.HLL_4;
int bytes = HllSketch.getMaxUpdatableSerializationBytes(lgK, type);
byte[] memByteArr = new byte[bytes];
- WritableMemory wmem = WritableMemory.wrap(memByteArr);
+ WritableMemory wmem = WritableMemory.writableWrap(memByteArr);
HllSketch heapSk = new HllSketch(lgK, type);
HllSketch dirSk = new HllSketch(lgK, type, wmem);
for (int i = 0; i < (1 << lgU); i++) {
diff --git a/src/test/java/org/apache/datasketches/hll/DirectCouponListTest.java b/src/test/java/org/apache/datasketches/hll/DirectCouponListTest.java
index c045272..d0927e3 100644
--- a/src/test/java/org/apache/datasketches/hll/DirectCouponListTest.java
+++ b/src/test/java/org/apache/datasketches/hll/DirectCouponListTest.java
@@ -72,7 +72,7 @@
byte[] barr1;
WritableMemory wmem = null;
try (WritableDirectHandle hand = WritableMemory.allocateDirect(bytes)) {
- wmem = hand.get();
+ wmem = hand.getWritable();
//byte[] byteArr = new byte[bytes];
//WritableMemory wmem = WritableMemory.wrap(byteArr);
hllSketch = new HllSketch(lgConfigK, tgtHllType, wmem);
@@ -93,6 +93,8 @@
//println(PreambleUtil.toString(barr1));
hllSketch.reset();
assertTrue(hllSketch.isEmpty());
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
//println("HEAP");
diff --git a/src/test/java/org/apache/datasketches/hll/DirectUnionTest.java b/src/test/java/org/apache/datasketches/hll/DirectUnionTest.java
index d967747..b8015e1 100644
--- a/src/test/java/org/apache/datasketches/hll/DirectUnionTest.java
+++ b/src/test/java/org/apache/datasketches/hll/DirectUnionTest.java
@@ -412,7 +412,7 @@
Union union = newUnion(lgConfigK);
for (int i = 0; i < n; i++) { union.update(i); }
double est = union.getEstimate();
- Union union2 = Union.writableWrap(WritableMemory.wrap(union.toUpdatableByteArray()));
+ Union union2 = Union.writableWrap(WritableMemory.writableWrap(union.toUpdatableByteArray()));
double est2 = union2.getEstimate();
assertEquals(est2, est, 0.0);
}
@@ -423,7 +423,7 @@
int n = 128;
HllSketch sk = new HllSketch(lgConfigK, HLL_6);
for (int i = 0; i < n; i++) {sk.update(i); }
- Union.writableWrap(WritableMemory.wrap(sk.toUpdatableByteArray()));
+ Union.writableWrap(WritableMemory.writableWrap(sk.toUpdatableByteArray()));
}
private static Union newUnion(int lgK) {
diff --git a/src/test/java/org/apache/datasketches/hll/HllSketchTest.java b/src/test/java/org/apache/datasketches/hll/HllSketchTest.java
index a237c24..3b346d8 100644
--- a/src/test/java/org/apache/datasketches/hll/HllSketchTest.java
+++ b/src/test/java/org/apache/datasketches/hll/HllSketchTest.java
@@ -400,7 +400,7 @@
boolean resourceCompact = sk2.isCompact();
if (resourceCompact) {
try {
- HllSketch.writableWrap(WritableMemory.wrap(byteArr));
+ HllSketch.writableWrap(WritableMemory.writableWrap(byteArr));
fail();
} catch (SketchesArgumentException e) {
//OK
@@ -415,7 +415,7 @@
public void checkWritableWrapOfCompact() {
HllSketch sk = new HllSketch();
byte[] byteArr = sk.toCompactByteArray();
- WritableMemory wmem = WritableMemory.wrap(byteArr);
+ WritableMemory wmem = WritableMemory.writableWrap(byteArr);
HllSketch sk2 = HllSketch.writableWrap(wmem);
}
diff --git a/src/test/java/org/apache/datasketches/hll/PreambleUtilTest.java b/src/test/java/org/apache/datasketches/hll/PreambleUtilTest.java
index 9137276..93007f5 100644
--- a/src/test/java/org/apache/datasketches/hll/PreambleUtilTest.java
+++ b/src/test/java/org/apache/datasketches/hll/PreambleUtilTest.java
@@ -47,10 +47,10 @@
public void preambleToString() { //TODO Check Visually
int bytes = HllSketch.getMaxUpdatableSerializationBytes(8, TgtHllType.HLL_4);
byte[] byteArr1 = new byte[bytes];
- WritableMemory wmem1 = WritableMemory.wrap(byteArr1);
+ WritableMemory wmem1 = WritableMemory.writableWrap(byteArr1);
HllSketch sk = new HllSketch(8, TgtHllType.HLL_4, wmem1);
byte[] byteArr2 = sk.toCompactByteArray();
- WritableMemory wmem2 = WritableMemory.wrap(byteArr2);
+ WritableMemory wmem2 = WritableMemory.writableWrap(byteArr2);
assertEquals(sk.getCurMode(), CurMode.LIST);
assertTrue(sk.isEmpty());
@@ -62,7 +62,7 @@
for (int i = 0; i < 7; i++) { sk.update(i); }
byteArr2 = sk.toCompactByteArray();
- wmem2 = WritableMemory.wrap(byteArr2);
+ wmem2 = WritableMemory.writableWrap(byteArr2);
assertEquals(sk.getCurMode(), CurMode.LIST);
assertFalse(sk.isEmpty());
s = HllSketch.toString(byteArr2);
@@ -73,7 +73,7 @@
for (int i = 7; i < 24; i++) { sk.update(i); }
byteArr2 = sk.toCompactByteArray();
- wmem2 = WritableMemory.wrap(byteArr2);
+ wmem2 = WritableMemory.writableWrap(byteArr2);
assertEquals(sk.getCurMode(), CurMode.SET);
s = HllSketch.toString(byteArr2);
println(s);
@@ -83,7 +83,7 @@
sk.update(24);
byteArr2 = sk.toCompactByteArray();
- wmem2 = WritableMemory.wrap(byteArr2);
+ wmem2 = WritableMemory.writableWrap(byteArr2);
assertEquals(sk.getCurMode(), CurMode.HLL);
s = HllSketch.toString(Memory.wrap(byteArr2));
println(s);
@@ -96,7 +96,7 @@
public void checkCompactFlag() {
HllSketch sk = new HllSketch(7);
byte[] memObj = sk.toCompactByteArray();
- WritableMemory wmem = WritableMemory.wrap(memObj);
+ WritableMemory wmem = WritableMemory.writableWrap(memObj);
boolean compact = PreambleUtil.extractCompactFlag(wmem);
assertTrue(compact);
@@ -110,7 +110,7 @@
public void checkCorruptMemoryInput() {
HllSketch sk = new HllSketch(12);
byte[] memObj = sk.toCompactByteArray();
- WritableMemory wmem = WritableMemory.wrap(memObj);
+ WritableMemory wmem = WritableMemory.writableWrap(memObj);
long memAdd = wmem.getCumulativeOffset(0);
HllSketch bad;
@@ -149,7 +149,7 @@
//move to Set mode
for (int i = 1; i <= 15; i++) { sk.update(i); }
memObj = sk.toCompactByteArray();
- wmem = WritableMemory.wrap(memObj);
+ wmem = WritableMemory.writableWrap(memObj);
memAdd = wmem.getCumulativeOffset(0);
//check wrong PreInts and SET
@@ -163,7 +163,7 @@
//move to HLL mode
for (int i = 15; i <= 1000; i++) { sk.update(i); }
memObj = sk.toCompactByteArray();
- wmem = WritableMemory.wrap(memObj);
+ wmem = WritableMemory.writableWrap(memObj);
memAdd = wmem.getCumulativeOffset(0);
//check wrong PreInts and HLL
diff --git a/src/test/java/org/apache/datasketches/hll/ToFromByteArrayTest.java b/src/test/java/org/apache/datasketches/hll/ToFromByteArrayTest.java
index 1df65fe..b626310 100644
--- a/src/test/java/org/apache/datasketches/hll/ToFromByteArrayTest.java
+++ b/src/test/java/org/apache/datasketches/hll/ToFromByteArrayTest.java
@@ -68,7 +68,7 @@
//printSketch(dst, "DST");
assertEquals(dst2.getEstimate(), src.getEstimate(), 0.0);
- WritableMemory mem3 = WritableMemory.wrap(byteArr2);
+ WritableMemory mem3 = WritableMemory.writableWrap(byteArr2);
HllSketch dst3 = HllSketch.heapify(mem3); //using WritableMemory interface
//printSketch(dst, "DST");
assertEquals(dst3.getEstimate(), src.getEstimate(), 0.0);
@@ -91,7 +91,7 @@
private static void toFrom2(int lgConfigK, TgtHllType tgtHllType, int n) {
int bytes = HllSketch.getMaxUpdatableSerializationBytes(lgConfigK, tgtHllType);
byte[] byteArray = new byte[bytes];
- WritableMemory wmem = WritableMemory.wrap(byteArray);
+ WritableMemory wmem = WritableMemory.writableWrap(byteArray);
HllSketch src = new HllSketch(lgConfigK, tgtHllType, wmem);
for (int i = 0; i < n; i++) {
src.update(i);
@@ -107,7 +107,7 @@
//Heapify updatable
byte[] updatableByteArr = src.toUpdatableByteArray();
- WritableMemory wmem2 = WritableMemory.wrap(updatableByteArr);
+ WritableMemory wmem2 = WritableMemory.writableWrap(updatableByteArr);
HllSketch dst2 = HllSketch.heapify(wmem2); //using Memory interface
//printSketch(dst2, "Heapify From Updatable");
assertEquals(dst2.getEstimate(), src.getEstimate(), 0.0);
diff --git a/src/test/java/org/apache/datasketches/quantiles/DebugUnionTest.java b/src/test/java/org/apache/datasketches/quantiles/DebugUnionTest.java
index e56f907..cb6096c 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DebugUnionTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DebugUnionTest.java
@@ -63,10 +63,12 @@
DoublesUnion dUnion;
DoublesSketch dSketch;
try ( WritableDirectHandle wdh = WritableMemory.allocateDirect(10_000_000) ) {
- WritableMemory wmem = wdh.get();
+ WritableMemory wmem = wdh.getWritable();
dUnion = DoublesUnion.builder().setMaxK(8).build(wmem);
for (int s = 0; s < numSketches; s++) { dUnion.update(sketchArr[s]); }
dSketch = dUnion.getResult(); //result is on heap
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
//iterates and counts errors
diff --git a/src/test/java/org/apache/datasketches/quantiles/DeprecatedAndMiscTest.java b/src/test/java/org/apache/datasketches/quantiles/DeprecatedAndMiscTest.java
index a92abb7..9eb84e5 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DeprecatedAndMiscTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DeprecatedAndMiscTest.java
@@ -46,7 +46,7 @@
final DoublesUnion du3 = DoublesUnionBuilder.wrap(mem); //v2.0.0.
- final WritableMemory wmem = WritableMemory.wrap(ds.toByteArray());
+ final WritableMemory wmem = WritableMemory.writableWrap(ds.toByteArray());
final DoublesUnion du4 = DoublesUnionBuilder.wrap(wmem); //v2.0.0.
final ItemsSketch<String> is = ItemsSketch.getInstance(64, Comparator.naturalOrder());
diff --git a/src/test/java/org/apache/datasketches/quantiles/DirectCompactDoublesSketchTest.java b/src/test/java/org/apache/datasketches/quantiles/DirectCompactDoublesSketchTest.java
index 90f70bf..3121c8b 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DirectCompactDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DirectCompactDoublesSketchTest.java
@@ -65,7 +65,7 @@
for (int i = n; i > 0; --i) {
qs.update(i);
}
- final WritableMemory dstMem = WritableMemory.wrap(new byte[qs.getCompactStorageBytes()]);
+ final WritableMemory dstMem = WritableMemory.writableWrap(new byte[qs.getCompactStorageBytes()]);
final DirectCompactDoublesSketch compactQs
= DirectCompactDoublesSketch.createFromUpdateSketch(qs, dstMem);
@@ -153,7 +153,7 @@
qs.update(startV + i);
}
final byte[] byteArr = new byte[qs.getCompactStorageBytes()];
- final WritableMemory mem = WritableMemory.wrap(byteArr);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArr);
return (DirectCompactDoublesSketch) qs.compact(mem);
}
diff --git a/src/test/java/org/apache/datasketches/quantiles/DirectQuantilesMemoryRequestTest.java b/src/test/java/org/apache/datasketches/quantiles/DirectQuantilesMemoryRequestTest.java
index 42091e4..93ac0fd 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DirectQuantilesMemoryRequestTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DirectQuantilesMemoryRequestTest.java
@@ -47,7 +47,7 @@
//########## Owning Implementation
// This part would actually be part of the Memory owning implemention so it is faked here
try (WritableDirectHandle wdh = WritableMemory.allocateDirect(initBytes)) {
- final WritableMemory wmem = wdh.get();
+ final WritableMemory wmem = wdh.getWritable();
println("Initial mem size: " + wmem.getCapacity());
//########## Receiving Application
@@ -70,6 +70,8 @@
//The actual Memory has been re-allocated several times,
// so the above wmem reference is invalid.
println("\nFinal mem size: " + wmem.getCapacity());
+ } catch (Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -82,7 +84,7 @@
try (WritableDirectHandle memHandler = WritableMemory.allocateDirect(initBytes)) {
//final MemoryManager memMgr = new MemoryManager();
//final WritableMemory mem1 = memMgr.request(initBytes);
- final WritableMemory mem1 = memHandler.get();
+ final WritableMemory mem1 = memHandler.getWritable();
println("Initial mem size: " + mem1.getCapacity());
final UpdateDoublesSketch usk1 = DoublesSketch.builder().setK(k).build(mem1);
for (int i = 1; i <= u; i++) {
@@ -91,6 +93,8 @@
final int currentSpace = usk1.getCombinedBufferItemCapacity();
println("curCombBufItemCap: " + currentSpace);
assertEquals(currentSpace, 2 * k);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -103,7 +107,7 @@
try (WritableDirectHandle memHandler = WritableMemory.allocateDirect(initBytes)) {
//final MemoryManager memMgr = new MemoryManager();
//final WritableMemory mem1 = memMgr.request(initBytes);
- final WritableMemory mem1 = memHandler.get();
+ final WritableMemory mem1 = memHandler.getWritable();
println("Initial mem size: " + mem1.getCapacity());
final UpdateDoublesSketch usk1 = DoublesSketch.builder().setK(k).build(mem1);
for (int i = 1; i <= u; i++) {
@@ -116,6 +120,8 @@
println("newCombBurItemCap: " + newSpace);
assertEquals(newCB.length, 3 * k);
//memMgr.free(mem1);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -128,7 +134,7 @@
final Memory origSketchMem = Memory.wrap(usk1.toByteArray());
try (WritableDirectHandle memHandle = WritableMemory.allocateDirect(initBytes)) {
- WritableMemory mem = memHandle.get();
+ WritableMemory mem = memHandle.getWritable();
origSketchMem.copyTo(0, mem, 0, initBytes);
UpdateDoublesSketch usk2 = DirectUpdateDoublesSketch.wrapInstance(mem);
assertTrue(mem.isSameResource(usk2.getMemory()));
@@ -145,6 +151,8 @@
final int expectedSize = COMBINED_BUFFER + ((2 * k) << 3);
assertEquals(mem2.getCapacity(), expectedSize);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
diff --git a/src/test/java/org/apache/datasketches/quantiles/DirectUpdateDoublesSketchTest.java b/src/test/java/org/apache/datasketches/quantiles/DirectUpdateDoublesSketchTest.java
index 5bf3e10..33a8e50 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DirectUpdateDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DirectUpdateDoublesSketchTest.java
@@ -150,7 +150,7 @@
public void wrapEmptyUpdateSketch() {
final UpdateDoublesSketch s1 = DoublesSketch.builder().build();
final WritableMemory mem
- = WritableMemory.wrap(ByteBuffer.wrap(s1.toByteArray()).order(ByteOrder.nativeOrder()));
+ = WritableMemory.writableWrap(ByteBuffer.wrap(s1.toByteArray()).order(ByteOrder.nativeOrder()));
final UpdateDoublesSketch s2 = DirectUpdateDoublesSketch.wrapInstance(mem);
assertTrue(s2.isEmpty());
@@ -166,7 +166,7 @@
public void checkPutCombinedBuffer() {
final int k = PreambleUtil.DEFAULT_K;
final int cap = 32 + ((2 * k) << 3);
- WritableMemory mem = WritableMemory.wrap(new byte[cap]);
+ WritableMemory mem = WritableMemory.writableWrap(new byte[cap]);
final UpdateDoublesSketch qs = DoublesSketch.builder().setK(k).build(mem);
mem = qs.getMemory();
assertEquals(mem.getCapacity(), cap);
@@ -194,7 +194,7 @@
int k = PreambleUtil.DEFAULT_K;
int n = 48;
int cap = 32 + ((2 * k) << 3);
- WritableMemory mem = WritableMemory.wrap(new byte[cap]);
+ WritableMemory mem = WritableMemory.writableWrap(new byte[cap]);
UpdateDoublesSketch qs = DoublesSketch.builder().setK(k).build(mem);
mem = qs.getMemory();
assertEquals(mem.getCapacity(), cap);
@@ -215,7 +215,7 @@
@SuppressWarnings("unused")
@Test
public void variousExceptions() {
- WritableMemory mem = WritableMemory.wrap(new byte[8]);
+ WritableMemory mem = WritableMemory.writableWrap(new byte[8]);
try {
int flags = PreambleUtil.COMPACT_FLAG_MASK;
DirectUpdateDoublesSketchR.checkCompact(2, 0);
@@ -262,7 +262,7 @@
@Test
public void serializeDeserialize() {
int sizeBytes = DoublesSketch.getUpdatableStorageBytes(128, 2000);
- WritableMemory mem = WritableMemory.wrap(new byte[sizeBytes]);
+ WritableMemory mem = WritableMemory.writableWrap(new byte[sizeBytes]);
UpdateDoublesSketch sketch1 = DoublesSketch.builder().build(mem);
for (int i = 0; i < 1000; i++) {
sketch1.update(i);
@@ -278,7 +278,7 @@
byte[] arr2 = sketch2.toByteArray(false);
assertEquals(arr2.length, sketch2.getStorageBytes());
- DoublesSketch sketch3 = DoublesSketch.wrap(WritableMemory.wrap(arr2));
+ DoublesSketch sketch3 = DoublesSketch.wrap(WritableMemory.writableWrap(arr2));
assertEquals(sketch3.getMinValue(), 0.0);
assertEquals(sketch3.getMaxValue(), 1999.0);
assertEquals(sketch3.getQuantile(0.5), 1000.0, 10.0);
@@ -303,7 +303,7 @@
final int n = k * 2;
final int memBytes = DoublesSketch.getUpdatableStorageBytes(k, n);
- final WritableMemory mem = WritableMemory.wrap(new byte[memBytes]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[memBytes]);
final DoublesSketchBuilder bldr = DoublesSketch.builder();
final UpdateDoublesSketch ds = bldr.setK(k).build(mem);
for (int i = 1; i <= n; i++) { // 1 ... n
@@ -324,7 +324,7 @@
final int k = 128;
final int n = 1_000_000;
final int memBytes = DoublesSketch.getUpdatableStorageBytes(k, n);
- final WritableMemory mem = WritableMemory.wrap(new byte[memBytes]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[memBytes]);
final UpdateDoublesSketch sketch = DoublesSketch.builder().build(mem);
final double[] values = new double[n];
for (int i = 0; i < n; i++) {
@@ -354,7 +354,7 @@
if (cap < (2 * k)) { cap = 2 * k; }
DoublesSketchBuilder bldr = new DoublesSketchBuilder();
bldr.setK(k);
- UpdateDoublesSketch dqs = bldr.build(WritableMemory.wrap(new byte[cap]));
+ UpdateDoublesSketch dqs = bldr.build(WritableMemory.writableWrap(new byte[cap]));
return dqs;
}
diff --git a/src/test/java/org/apache/datasketches/quantiles/DoublesSketchBuilderTest.java b/src/test/java/org/apache/datasketches/quantiles/DoublesSketchBuilderTest.java
index 618e954..5fe6b6e 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DoublesSketchBuilderTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DoublesSketchBuilderTest.java
@@ -38,7 +38,7 @@
println(bldr.toString());
int bytes = DoublesSketch.getUpdatableStorageBytes(k, 0);
byte[] byteArr = new byte[bytes];
- WritableMemory mem = WritableMemory.wrap(byteArr);
+ WritableMemory mem = WritableMemory.writableWrap(byteArr);
DoublesSketch ds = bldr.build(mem);
assertTrue(ds.isDirect());
println(bldr.toString());
diff --git a/src/test/java/org/apache/datasketches/quantiles/DoublesSketchTest.java b/src/test/java/org/apache/datasketches/quantiles/DoublesSketchTest.java
index 3ae8e47..11498e6 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DoublesSketchTest.java
@@ -39,7 +39,7 @@
for (int i = 0; i < 1000; i++) {
heapSketch.update(i);
}
- DoublesSketch directSketch = DoublesSketch.wrap(WritableMemory.wrap(heapSketch.toByteArray(false)));
+ DoublesSketch directSketch = DoublesSketch.wrap(WritableMemory.writableWrap(heapSketch.toByteArray(false)));
assertEquals(directSketch.getMinValue(), 0.0);
assertEquals(directSketch.getMaxValue(), 999.0);
@@ -49,12 +49,12 @@
@Test
public void directToHeap() {
int sizeBytes = 10000;
- UpdateDoublesSketch directSketch = DoublesSketch.builder().build(WritableMemory.wrap(new byte[sizeBytes]));
+ UpdateDoublesSketch directSketch = DoublesSketch.builder().build(WritableMemory.writableWrap(new byte[sizeBytes]));
for (int i = 0; i < 1000; i++) {
directSketch.update(i);
}
UpdateDoublesSketch heapSketch;
- heapSketch = (UpdateDoublesSketch) DoublesSketch.heapify(WritableMemory.wrap(directSketch.toByteArray()));
+ heapSketch = (UpdateDoublesSketch) DoublesSketch.heapify(WritableMemory.writableWrap(directSketch.toByteArray()));
for (int i = 0; i < 1000; i++) {
heapSketch.update(i + 1000);
}
@@ -111,8 +111,8 @@
@Test
public void checkIsSameResource() {
int k = 16;
- WritableMemory mem = WritableMemory.wrap(new byte[(k*16) +24]);
- WritableMemory cmem = WritableMemory.wrap(new byte[8]);
+ WritableMemory mem = WritableMemory.writableWrap(new byte[(k*16) +24]);
+ WritableMemory cmem = WritableMemory.writableWrap(new byte[8]);
DirectUpdateDoublesSketch duds =
(DirectUpdateDoublesSketch) DoublesSketch.builder().setK(k).build(mem);
assertTrue(duds.isSameResource(mem));
@@ -135,22 +135,26 @@
@Test
public void directSketchShouldMoveOntoHeapEventually() {
try (WritableDirectHandle wdh = WritableMemory.allocateDirect(1000)) {
- WritableMemory mem = wdh.get();
+ WritableMemory mem = wdh.getWritable();
UpdateDoublesSketch sketch = DoublesSketch.builder().build(mem);
Assert.assertTrue(sketch.isSameResource(mem));
for (int i = 0; i < 1000; i++) {
sketch.update(i);
}
Assert.assertFalse(sketch.isSameResource(mem));
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@Test
public void checkEmptyDirect() {
try (WritableDirectHandle wdh = WritableMemory.allocateDirect(1000)) {
- WritableMemory mem = wdh.get();
+ WritableMemory mem = wdh.getWritable();
UpdateDoublesSketch sketch = DoublesSketch.builder().build(mem);
sketch.toByteArray(); //exercises a specific path
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
diff --git a/src/test/java/org/apache/datasketches/quantiles/DoublesUnionBuilderTest.java b/src/test/java/org/apache/datasketches/quantiles/DoublesUnionBuilderTest.java
index 0c9f82d..7b5802e 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DoublesUnionBuilderTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DoublesUnionBuilderTest.java
@@ -36,7 +36,7 @@
for (int i=0; i<1000; i++) { qs1.update(i); }
int bytes = qs1.getCompactStorageBytes();
- WritableMemory dstMem = WritableMemory.wrap(new byte[bytes]);
+ WritableMemory dstMem = WritableMemory.writableWrap(new byte[bytes]);
qs1.putMemory(dstMem);
Memory srcMem = dstMem;
@@ -63,7 +63,7 @@
}
int bytes = qs1.getCompactStorageBytes();
- WritableMemory dstMem = WritableMemory.wrap(new byte[bytes]);
+ WritableMemory dstMem = WritableMemory.writableWrap(new byte[bytes]);
qs1.putMemory(dstMem);
Memory srcMem = dstMem;
diff --git a/src/test/java/org/apache/datasketches/quantiles/DoublesUnionImplTest.java b/src/test/java/org/apache/datasketches/quantiles/DoublesUnionImplTest.java
index 5972a78..e79d3d4 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DoublesUnionImplTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DoublesUnionImplTest.java
@@ -145,7 +145,7 @@
final int n2 = 2000;
final DoublesSketch sketchIn1 = buildAndLoadQS(k1, n1);
final int bytes = DoublesSketch.getUpdatableStorageBytes(k2, n2);//just for size
- final WritableMemory mem = WritableMemory.wrap(new byte[bytes]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[bytes]);
final DoublesUnion union = DoublesUnion.builder().setMaxK(k2).build(mem); //virgin 256
union.update(sketchIn1);
assertEquals(union.getMaxK(), k2);
@@ -164,7 +164,7 @@
final int n2 = 2000;
final DoublesSketch sketchIn1 = buildAndLoadDQS(k1, n1);
final int bytes = DoublesSketch.getUpdatableStorageBytes(k2, n2);//just for size
- final WritableMemory mem = WritableMemory.wrap(new byte[bytes]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[bytes]);
final DoublesUnion union = DoublesUnion.builder().setMaxK(k2).build(mem); //virgin 256
union.update(sketchIn1);
assertEquals(union.getMaxK(), k2);
@@ -182,11 +182,11 @@
final int k2 = 4;
final int n2 = 2 * k2; //8
final int bytes = DoublesSketch.getUpdatableStorageBytes(256, 50);//just for size
- final WritableMemory skMem = WritableMemory.wrap(new byte[bytes]);
+ final WritableMemory skMem = WritableMemory.writableWrap(new byte[bytes]);
final UpdateDoublesSketch sketchIn1 = DoublesSketch.builder().setK(k1).build(skMem);
for (int i = 0; i < n1; i++) { sketchIn1.update(i + 1); }
- final WritableMemory uMem = WritableMemory.wrap(new byte[bytes]);
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[bytes]);
final DoublesUnion union = DoublesUnion.builder().setMaxK(256).build(uMem); //virgin 256
//DoublesUnion union = DoublesUnion.builder().setMaxK(256).build(); //virgin 256
union.update(sketchIn1);
@@ -215,11 +215,11 @@
final int k2 = 4;
final int n2 = 2 * k2; //8
final int bytes = DoublesSketch.getUpdatableStorageBytes(256, 50);//just for size
- final WritableMemory skMem = WritableMemory.wrap(new byte[bytes]);
+ final WritableMemory skMem = WritableMemory.writableWrap(new byte[bytes]);
final UpdateDoublesSketch sketchIn1 = DoublesSketch.builder().setK(k1).build(skMem);
for (int i = 0; i < n1; i++) { sketchIn1.update(i + 1); }
- final WritableMemory uMem = WritableMemory.wrap(new byte[bytes]);
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[bytes]);
final DoublesUnion union = DoublesUnion.builder().setMaxK(256).build(uMem); //virgin 256
union.update(sketchIn1);
assertEquals(union.getResult().getN(), n1);
@@ -247,12 +247,12 @@
final int k2 = 4;
final int n2 = 5 * k2; //8
final int bytes = DoublesSketch.getUpdatableStorageBytes(256, 50);//just for size
- final WritableMemory skMem = WritableMemory.wrap(new byte[bytes]);
+ final WritableMemory skMem = WritableMemory.writableWrap(new byte[bytes]);
final UpdateDoublesSketch sketchIn0 = DoublesSketch.builder().setK(k1).build(skMem);
for (int i = 0; i < n1; i++) { sketchIn0.update(i + 1); }
final CompactDoublesSketch sketchIn1 = sketchIn0.compact();
- final WritableMemory uMem = WritableMemory.wrap(new byte[bytes]);
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[bytes]);
final DoublesUnion union = DoublesUnion.builder().setMaxK(256).build(uMem); //virgin 256
union.update(sketchIn1);
assertEquals(union.getResult().getN(), n1);
@@ -278,7 +278,7 @@
final int k2 = 4;
final int n2 = 2 * k2; //8
final int bytes = DoublesSketch.getUpdatableStorageBytes(256, 50);//big enough
- final WritableMemory skMem = WritableMemory.wrap(new byte[bytes]);
+ final WritableMemory skMem = WritableMemory.writableWrap(new byte[bytes]);
DoublesSketch.builder().setK(256).build(skMem);
final DoublesUnion union = DoublesUnionImpl.heapifyInstance(skMem);
@@ -299,7 +299,7 @@
final int k2 = 4;
final int n2 = 2 * k2; //8
final int bytes = DoublesSketch.getUpdatableStorageBytes(256, 50);//big enough
- final WritableMemory skMem = WritableMemory.wrap(new byte[bytes]);
+ final WritableMemory skMem = WritableMemory.writableWrap(new byte[bytes]);
DoublesSketch.builder().setK(256).build(skMem);
final DoublesUnion union = DoublesUnionImpl.heapifyInstance(skMem);
@@ -397,7 +397,7 @@
public void checkUpdateMemory() {
final DoublesSketch qs1 = buildAndLoadQS(256, 1000);
final int bytes = qs1.getCompactStorageBytes();
- final WritableMemory dstMem = WritableMemory.wrap(new byte[bytes]);
+ final WritableMemory dstMem = WritableMemory.writableWrap(new byte[bytes]);
qs1.putMemory(dstMem);
final Memory srcMem = dstMem;
@@ -415,7 +415,7 @@
public void checkUpdateMemoryDirect() {
final DoublesSketch qs1 = buildAndLoadDQS(256, 1000);
final int bytes = qs1.getCompactStorageBytes();
- final WritableMemory dstMem = WritableMemory.wrap(new byte[bytes]);
+ final WritableMemory dstMem = WritableMemory.writableWrap(new byte[bytes]);
qs1.putMemory(dstMem);
final Memory srcMem = dstMem;
@@ -653,7 +653,7 @@
Assert.assertEquals(bldr.getMaxK(), k);
final int bytes = DoublesSketch.getUpdatableStorageBytes(k, n);
final byte[] byteArr = new byte[bytes];
- final WritableMemory mem = WritableMemory.wrap(byteArr);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArr);
final DoublesUnion union = bldr.build(mem);
assertTrue(union.isEmpty());
assertTrue(union.isDirect());
@@ -679,7 +679,7 @@
Assert.assertEquals(skMedian, 500, 10);
final byte[] byteArr = sketch.toByteArray(false);
- final WritableMemory mem = WritableMemory.wrap(byteArr);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArr);
final DoublesUnion union = DoublesUnion.wrap(mem);
Assert.assertFalse(union.isEmpty());
assertTrue(union.isDirect());
@@ -701,10 +701,10 @@
@Test
public void isSameResourceDirect() {
- WritableMemory mem1 = WritableMemory.wrap(new byte[1000000]);
+ WritableMemory mem1 = WritableMemory.writableWrap(new byte[1000000]);
DoublesUnion union = DoublesUnion.builder().build(mem1);
Assert.assertTrue(union.isSameResource(mem1));
- WritableMemory mem2 = WritableMemory.wrap(new byte[1000000]);
+ WritableMemory mem2 = WritableMemory.writableWrap(new byte[1000000]);
Assert.assertFalse(union.isSameResource(mem2));
}
diff --git a/src/test/java/org/apache/datasketches/quantiles/DoublesUtilTest.java b/src/test/java/org/apache/datasketches/quantiles/DoublesUtilTest.java
index 15670d9..0d00441 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DoublesUtilTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DoublesUtilTest.java
@@ -67,7 +67,7 @@
DoublesSketchTest.testSketchEquality(huds, target1);
// DirectUpdateDoublesSketch
- final WritableMemory mem1 = WritableMemory.wrap(huds.toByteArray());
+ final WritableMemory mem1 = WritableMemory.writableWrap(huds.toByteArray());
final DirectUpdateDoublesSketch duds = (DirectUpdateDoublesSketch) UpdateDoublesSketch.wrap(mem1);
final HeapUpdateDoublesSketch target2 = DoublesUtil.copyToHeap(duds);
DoublesSketchTest.testSketchEquality(huds, duds);
diff --git a/src/test/java/org/apache/datasketches/quantiles/HeapCompactDoublesSketchTest.java b/src/test/java/org/apache/datasketches/quantiles/HeapCompactDoublesSketchTest.java
index c07376c..5bc6ba6 100644
--- a/src/test/java/org/apache/datasketches/quantiles/HeapCompactDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/HeapCompactDoublesSketchTest.java
@@ -90,7 +90,7 @@
}
assertEquals(qs.getBaseBufferCount(), k);
final byte[] sketchBytes = qs.toByteArray(true);
- final WritableMemory mem = WritableMemory.wrap(sketchBytes);
+ final WritableMemory mem = WritableMemory.writableWrap(sketchBytes);
// modify to make v2, clear compact flag, and insert a -1 in the middle of the base buffer
PreambleUtil.insertSerVer(mem, 2);
diff --git a/src/test/java/org/apache/datasketches/quantiles/HeapUpdateDoublesSketchTest.java b/src/test/java/org/apache/datasketches/quantiles/HeapUpdateDoublesSketchTest.java
index 8d7b903..7c017ed 100644
--- a/src/test/java/org/apache/datasketches/quantiles/HeapUpdateDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/HeapUpdateDoublesSketchTest.java
@@ -352,7 +352,7 @@
println(s);
println("");
- Memory srcMem = WritableMemory.wrap(qs.toByteArray());
+ Memory srcMem = WritableMemory.writableWrap(qs.toByteArray());
HeapUpdateDoublesSketch qs2 = HeapUpdateDoublesSketch.heapifyInstance(srcMem);
s = qs2.toString();
@@ -685,7 +685,7 @@
UpdateDoublesSketch sketch2 = DoublesSketch.builder().setK(k2).build();
DoublesSketch downSketch;
int bytes = DoublesSketch.getUpdatableStorageBytes(k2, n);
- WritableMemory mem = WritableMemory.wrap(new byte[bytes]);
+ WritableMemory mem = WritableMemory.writableWrap(new byte[bytes]);
for (int i = 0; i < n; i++) {
sketch1.update (i);
sketch2.update (i);
@@ -835,7 +835,7 @@
qs1.update(i);
}
int bytes = qs1.getUpdatableStorageBytes();
- WritableMemory dstMem = WritableMemory.wrap(new byte[bytes]);
+ WritableMemory dstMem = WritableMemory.writableWrap(new byte[bytes]);
qs1.putMemory(dstMem, false);
Memory srcMem = dstMem;
DoublesSketch qs2 = DoublesSketch.heapify(srcMem);
@@ -850,7 +850,7 @@
qs1.update(i);
}
int bytes = qs1.getCompactStorageBytes();
- WritableMemory dstMem = WritableMemory.wrap(new byte[bytes-1]); //too small
+ WritableMemory dstMem = WritableMemory.writableWrap(new byte[bytes-1]); //too small
qs1.putMemory(dstMem);
}
@@ -866,7 +866,7 @@
@Test
public void testIt() {
java.nio.ByteBuffer bb = java.nio.ByteBuffer.allocate(1<<20).order(ByteOrder.nativeOrder());
- WritableMemory mem = WritableMemory.wrap(bb);
+ WritableMemory mem = WritableMemory.writableWrap(bb);
int k = 1024;
DoublesSketch qsk = new DoublesSketchBuilder().setK(k).build();
diff --git a/src/test/java/org/apache/datasketches/quantiles/ItemsSketchTest.java b/src/test/java/org/apache/datasketches/quantiles/ItemsSketchTest.java
index 97c5c13..4c6a431 100644
--- a/src/test/java/org/apache/datasketches/quantiles/ItemsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/ItemsSketchTest.java
@@ -376,7 +376,7 @@
final ArrayOfDoublesSerDe serDe = new ArrayOfDoublesSerDe();
final ItemsSketch<Double> sketch = ItemsSketch.getInstance(Comparator.naturalOrder());
final byte[] byteArr = sketch.toByteArray(serDe);
- final WritableMemory mem = WritableMemory.wrap(byteArr);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArr);
mem.clearBits(PreambleUtil.FLAGS_BYTE, (byte) PreambleUtil.COMPACT_FLAG_MASK);
println(PreambleUtil.toString(mem, false));
ItemsSketch.getInstance(mem, Comparator.naturalOrder(), serDe);
@@ -389,7 +389,7 @@
sketch.update(Integer.toString(i));
}
final byte[] byteArr = new byte[200];
- final WritableMemory mem = WritableMemory.wrap(byteArr);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArr);
sketch.putMemory(mem, new ArrayOfStringsSerDe());
}
@@ -400,7 +400,7 @@
sketch.update(Integer.toString(i));
}
final byte[] byteArr = new byte[100];
- final WritableMemory mem = WritableMemory.wrap(byteArr);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArr);
sketch.putMemory(mem, new ArrayOfStringsSerDe());
}
diff --git a/src/test/java/org/apache/datasketches/quantiles/PreambleUtilTest.java b/src/test/java/org/apache/datasketches/quantiles/PreambleUtilTest.java
index 265b047..7cee84f 100644
--- a/src/test/java/org/apache/datasketches/quantiles/PreambleUtilTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/PreambleUtilTest.java
@@ -50,8 +50,8 @@
public void checkInsertsAndExtracts() {
final int bytes = 32;
try (WritableDirectHandle offHeapMemHandler = WritableMemory.allocateDirect(bytes)) {
- final WritableMemory offHeapMem = offHeapMemHandler.get();
- final WritableMemory onHeapMem = WritableMemory.wrap(new byte[bytes]);
+ final WritableMemory offHeapMem = offHeapMemHandler.getWritable();
+ final WritableMemory onHeapMem = WritableMemory.writableWrap(new byte[bytes]);
onHeapMem.clear();
offHeapMem.clear();
@@ -157,6 +157,8 @@
assertEquals(offHD, vD);
onHeapMem.clear();
offHeapMem.clear();
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
diff --git a/src/test/java/org/apache/datasketches/req/FloatBufferTest.java b/src/test/java/org/apache/datasketches/req/FloatBufferTest.java
index efe1aad..1b0e308 100644
--- a/src/test/java/org/apache/datasketches/req/FloatBufferTest.java
+++ b/src/test/java/org/apache/datasketches/req/FloatBufferTest.java
@@ -267,7 +267,7 @@
assertEquals(buf.getItemFromIndex(hra ? 199 : 1), 1.0f);
assertEquals(buf.isSpaceAtBottom(), hra);
//uses the serialization method
- final WritableMemory wmem = WritableMemory.wrap(buf.floatsToBytes());
+ final WritableMemory wmem = WritableMemory.writableWrap(buf.floatsToBytes());
final float[] farr2 = new float[101];
wmem.getFloatArray(0, farr2, 0, 101);
//uses the deserialization method
diff --git a/src/test/java/org/apache/datasketches/sampling/ReservoirItemsSketchTest.java b/src/test/java/org/apache/datasketches/sampling/ReservoirItemsSketchTest.java
index 21dd451..723a3fe 100644
--- a/src/test/java/org/apache/datasketches/sampling/ReservoirItemsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/sampling/ReservoirItemsSketchTest.java
@@ -425,7 +425,7 @@
// get a new byte[], manually revert to v1, then reconstruct
final byte[] sketchBytes = ris.toByteArray(serDe);
- final WritableMemory sketchMem = WritableMemory.wrap(sketchBytes);
+ final WritableMemory sketchMem = WritableMemory.writableWrap(sketchBytes);
sketchMem.putByte(SER_VER_BYTE, (byte) 1);
sketchMem.putInt(RESERVOIR_SIZE_INT, 0); // zero out all 4 bytes
@@ -602,7 +602,7 @@
assertEquals(ris.getK(), k);
final byte[] sketchBytes = ris.toByteArray(new ArrayOfLongsSerDe());
- return WritableMemory.wrap(sketchBytes);
+ return WritableMemory.writableWrap(sketchBytes);
}
private static void validateSerializeAndDeserialize(final ReservoirItemsSketch<Long> ris) {
diff --git a/src/test/java/org/apache/datasketches/sampling/ReservoirItemsUnionTest.java b/src/test/java/org/apache/datasketches/sampling/ReservoirItemsUnionTest.java
index 88647c1..acb70ad 100644
--- a/src/test/java/org/apache/datasketches/sampling/ReservoirItemsUnionTest.java
+++ b/src/test/java/org/apache/datasketches/sampling/ReservoirItemsUnionTest.java
@@ -164,7 +164,7 @@
// get a new byte[], manually revert to v1, then reconstruct
final byte[] unionBytes = riu.toByteArray(serDe);
- final WritableMemory unionMem = WritableMemory.wrap(unionBytes);
+ final WritableMemory unionMem = WritableMemory.writableWrap(unionBytes);
unionMem.putByte(SER_VER_BYTE, (byte) 1);
unionMem.putInt(RESERVOIR_SIZE_INT, 0); // zero out all 4 bytes
@@ -195,7 +195,7 @@
// get a new byte[], manually revert to v1, then reconstruct
final byte[] unionBytes = rlu.toByteArray(serDe);
- final WritableMemory unionMem = WritableMemory.wrap(unionBytes);
+ final WritableMemory unionMem = WritableMemory.writableWrap(unionBytes);
unionMem.putByte(SER_VER_BYTE, (byte) 1);
unionMem.putInt(RESERVOIR_SIZE_INT, 0); // zero out all 4 bytes
@@ -448,7 +448,7 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkBadPreLongs() {
final ReservoirItemsUnion<Number> riu = ReservoirItemsUnion.newInstance(1024);
- final WritableMemory mem = WritableMemory.wrap(riu.toByteArray(new ArrayOfNumbersSerDe()));
+ final WritableMemory mem = WritableMemory.writableWrap(riu.toByteArray(new ArrayOfNumbersSerDe()));
mem.putByte(PREAMBLE_LONGS_BYTE, (byte) 0); // corrupt the preLongs count
ReservoirItemsUnion.heapify(mem, new ArrayOfNumbersSerDe());
@@ -458,7 +458,7 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkBadSerVer() {
final ReservoirItemsUnion<String> riu = ReservoirItemsUnion.newInstance(1024);
- final WritableMemory mem = WritableMemory.wrap(riu.toByteArray(new ArrayOfStringsSerDe()));
+ final WritableMemory mem = WritableMemory.writableWrap(riu.toByteArray(new ArrayOfStringsSerDe()));
mem.putByte(SER_VER_BYTE, (byte) 0); // corrupt the serialization version
ReservoirItemsUnion.heapify(mem, new ArrayOfStringsSerDe());
@@ -468,7 +468,7 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkBadFamily() {
final ReservoirItemsUnion<Double> rlu = ReservoirItemsUnion.newInstance(1024);
- final WritableMemory mem = WritableMemory.wrap(rlu.toByteArray(new ArrayOfDoublesSerDe()));
+ final WritableMemory mem = WritableMemory.writableWrap(rlu.toByteArray(new ArrayOfDoublesSerDe()));
mem.putByte(FAMILY_BYTE, (byte) 0); // corrupt the family ID
ReservoirItemsUnion.heapify(mem, new ArrayOfDoublesSerDe());
diff --git a/src/test/java/org/apache/datasketches/sampling/ReservoirLongsSketchTest.java b/src/test/java/org/apache/datasketches/sampling/ReservoirLongsSketchTest.java
index 1295c68..c448d2c 100644
--- a/src/test/java/org/apache/datasketches/sampling/ReservoirLongsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/sampling/ReservoirLongsSketchTest.java
@@ -305,7 +305,7 @@
// get a new byte[], manually revert to v1, then reconstruct
final byte[] sketchBytes = rls.toByteArray();
- final WritableMemory sketchMem = WritableMemory.wrap(sketchBytes);
+ final WritableMemory sketchMem = WritableMemory.writableWrap(sketchBytes);
sketchMem.putByte(SER_VER_BYTE, (byte) 1);
sketchMem.putInt(RESERVOIR_SIZE_INT, 0); // zero out all 4 bytes
@@ -477,7 +477,7 @@
assertEquals(rls.getK(), k);
final byte[] sketchBytes = rls.toByteArray();
- return WritableMemory.wrap(sketchBytes);
+ return WritableMemory.writableWrap(sketchBytes);
}
private static void validateSerializeAndDeserialize(final ReservoirLongsSketch rls) {
diff --git a/src/test/java/org/apache/datasketches/sampling/ReservoirLongsUnionTest.java b/src/test/java/org/apache/datasketches/sampling/ReservoirLongsUnionTest.java
index c9530dc..184db27 100644
--- a/src/test/java/org/apache/datasketches/sampling/ReservoirLongsUnionTest.java
+++ b/src/test/java/org/apache/datasketches/sampling/ReservoirLongsUnionTest.java
@@ -147,7 +147,7 @@
// get a new byte[], manually revert to v1, then reconstruct
final byte[] unionBytes = rlu.toByteArray();
- final WritableMemory unionMem = WritableMemory.wrap(unionBytes);
+ final WritableMemory unionMem = WritableMemory.writableWrap(unionBytes);
unionMem.putByte(SER_VER_BYTE, (byte) 1);
unionMem.putInt(RESERVOIR_SIZE_INT, 0); // zero out all 4 bytes
@@ -177,7 +177,7 @@
// get a new byte[], manually revert to v1, then reconstruct
final byte[] unionBytes = rlu.toByteArray();
- final WritableMemory unionMem = WritableMemory.wrap(unionBytes);
+ final WritableMemory unionMem = WritableMemory.writableWrap(unionBytes);
unionMem.putByte(SER_VER_BYTE, (byte) 1);
unionMem.putInt(RESERVOIR_SIZE_INT, 0); // zero out all 4 bytes
@@ -370,7 +370,7 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkBadPreLongs() {
final ReservoirLongsUnion rlu = ReservoirLongsUnion.newInstance(1024);
- final WritableMemory mem = WritableMemory.wrap(rlu.toByteArray());
+ final WritableMemory mem = WritableMemory.writableWrap(rlu.toByteArray());
mem.putByte(PREAMBLE_LONGS_BYTE, (byte) 0); // corrupt the preLongs count
ReservoirLongsUnion.heapify(mem);
@@ -380,7 +380,7 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkBadSerVer() {
final ReservoirLongsUnion rlu = ReservoirLongsUnion.newInstance(1024);
- final WritableMemory mem = WritableMemory.wrap(rlu.toByteArray());
+ final WritableMemory mem = WritableMemory.writableWrap(rlu.toByteArray());
mem.putByte(SER_VER_BYTE, (byte) 0); // corrupt the serialization version
ReservoirLongsUnion.heapify(mem);
@@ -390,7 +390,7 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkBadFamily() {
final ReservoirLongsUnion rlu = ReservoirLongsUnion.newInstance(1024);
- final WritableMemory mem = WritableMemory.wrap(rlu.toByteArray());
+ final WritableMemory mem = WritableMemory.writableWrap(rlu.toByteArray());
mem.putByte(FAMILY_BYTE, (byte) 0); // corrupt the family ID
ReservoirLongsUnion.heapify(mem);
diff --git a/src/test/java/org/apache/datasketches/sampling/VarOptItemsSketchTest.java b/src/test/java/org/apache/datasketches/sampling/VarOptItemsSketchTest.java
index 4454308..d701ce3 100644
--- a/src/test/java/org/apache/datasketches/sampling/VarOptItemsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/sampling/VarOptItemsSketchTest.java
@@ -51,7 +51,7 @@
public void checkBadSerVer() {
final VarOptItemsSketch<Long> sketch = getUnweightedLongsVIS(16, 16);
final byte[] bytes = sketch.toByteArray(new ArrayOfLongsSerDe());
- final WritableMemory mem = WritableMemory.wrap(bytes);
+ final WritableMemory mem = WritableMemory.writableWrap(bytes);
mem.putByte(SER_VER_BYTE, (byte) 0); // corrupt the serialization version
@@ -63,7 +63,7 @@
public void checkBadFamily() {
final VarOptItemsSketch<Long> sketch = getUnweightedLongsVIS(32, 16);
final byte[] bytes = sketch.toByteArray(new ArrayOfLongsSerDe());
- final WritableMemory mem = WritableMemory.wrap(bytes);
+ final WritableMemory mem = WritableMemory.writableWrap(bytes);
mem.putByte(FAMILY_BYTE, (byte) 0); // corrupt the family ID
@@ -75,7 +75,7 @@
public void checkBadPreLongs() {
final VarOptItemsSketch<Long> sketch = getUnweightedLongsVIS(32, 33);
final byte[] bytes = sketch.toByteArray(new ArrayOfLongsSerDe());
- final WritableMemory mem = WritableMemory.wrap(bytes);
+ final WritableMemory mem = WritableMemory.writableWrap(bytes);
// corrupt the preLongs count to 0
mem.putByte(PREAMBLE_LONGS_BYTE, (byte) (Family.VAROPT.getMinPreLongs() - 1));
@@ -132,7 +132,7 @@
// we'll use the same initial sketch a few times, so grab a copy of it
final byte[] copyBytes = new byte[sketchBytes.length];
- final WritableMemory mem = WritableMemory.wrap(copyBytes);
+ final WritableMemory mem = WritableMemory.writableWrap(copyBytes);
// copy the bytes
srcMem.copyTo(0, mem, 0, sketchBytes.length);
@@ -235,7 +235,7 @@
final VarOptItemsSketch<String> vis = VarOptItemsSketch.newInstance(12, ResizeFactor.X2);
final byte[] sketchBytes = vis.toByteArray(new ArrayOfStringsSerDe());
final byte[] dstByteArr = new byte[PreambleUtil.VO_PRELONGS_WARMUP << 3];
- final WritableMemory mem = WritableMemory.wrap(dstByteArr);
+ final WritableMemory mem = WritableMemory.writableWrap(dstByteArr);
mem.putByteArray(0, sketchBytes, 0, sketchBytes.length);
// ensure non-empty but with H and R region sizes set to 0
@@ -266,7 +266,7 @@
}
final byte[] sketchBytes = vis.toByteArray(new ArrayOfStringsSerDe(), String.class);
- final WritableMemory mem = WritableMemory.wrap(sketchBytes);
+ final WritableMemory mem = WritableMemory.writableWrap(sketchBytes);
// weights will be stored in the first double after the preamble
final int numPreLongs = PreambleUtil.extractPreLongs(mem);
diff --git a/src/test/java/org/apache/datasketches/sampling/VarOptItemsUnionTest.java b/src/test/java/org/apache/datasketches/sampling/VarOptItemsUnionTest.java
index 18bdd3d..2189771 100644
--- a/src/test/java/org/apache/datasketches/sampling/VarOptItemsUnionTest.java
+++ b/src/test/java/org/apache/datasketches/sampling/VarOptItemsUnionTest.java
@@ -48,7 +48,7 @@
final VarOptItemsUnion<Long> union = VarOptItemsUnion.newInstance(k);
union.update(getUnweightedLongsVIS(k, n));
final byte[] bytes = union.toByteArray(new ArrayOfLongsSerDe());
- final WritableMemory mem = WritableMemory.wrap(bytes);
+ final WritableMemory mem = WritableMemory.writableWrap(bytes);
mem.putByte(SER_VER_BYTE, (byte) 0); // corrupt the serialization version
@@ -63,7 +63,7 @@
final VarOptItemsUnion<Long> union = VarOptItemsUnion.newInstance(k);
union.update(getUnweightedLongsVIS(k, n));
final byte[] bytes = union.toByteArray(new ArrayOfLongsSerDe());
- final WritableMemory mem = WritableMemory.wrap(bytes);
+ final WritableMemory mem = WritableMemory.writableWrap(bytes);
// corrupt the preLongs count to 0
mem.putByte(PREAMBLE_LONGS_BYTE, (byte) (Family.VAROPT.getMinPreLongs() - 1));
diff --git a/src/test/java/org/apache/datasketches/theta/CompactSketchTest.java b/src/test/java/org/apache/datasketches/theta/CompactSketchTest.java
index 3c4b49f..d8237ad 100644
--- a/src/test/java/org/apache/datasketches/theta/CompactSketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/CompactSketchTest.java
@@ -79,7 +79,7 @@
int bytes = usk.getCompactBytes(); //for Compact
try (WritableDirectHandle wdh = WritableMemory.allocateDirect(bytes)) {
- WritableMemory directMem = wdh.get();
+ WritableMemory directMem = wdh.getWritable();
/**Via CompactSketch.compact**/
refSk = usk.compact(ordered, directMem);
@@ -90,6 +90,8 @@
/**Via CompactSketch.compact**/
testSk = (CompactSketch)Sketch.wrap(directMem);
checkByRange(refSk, testSk, u, ordered);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -193,7 +195,7 @@
int bytes = usk.getCompactBytes();
byte[] byteArray = new byte[bytes -8]; //too small
- WritableMemory mem = WritableMemory.wrap(byteArray);
+ WritableMemory mem = WritableMemory.writableWrap(byteArray);
usk.compact(ordered, mem);
}
@@ -209,7 +211,7 @@
int bytes = usk.getCompactBytes();
byte[] byteArray = new byte[bytes -8]; //too small
- WritableMemory mem = WritableMemory.wrap(byteArray);
+ WritableMemory mem = WritableMemory.writableWrap(byteArray);
usk.compact(ordered, mem);
}
diff --git a/src/test/java/org/apache/datasketches/theta/ConcurrentDirectQuickSelectSketchTest.java b/src/test/java/org/apache/datasketches/theta/ConcurrentDirectQuickSelectSketchTest.java
index 023a326..b5c7760 100644
--- a/src/test/java/org/apache/datasketches/theta/ConcurrentDirectQuickSelectSketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/ConcurrentDirectQuickSelectSketchTest.java
@@ -236,7 +236,7 @@
int bytes = shared.getCompactBytes();
assertEquals(bytes, (k*8) + (Family.COMPACT.getMaxPreLongs() << 3));
byte[] memArr2 = new byte[bytes];
- WritableMemory mem2 = WritableMemory.wrap(memArr2);
+ WritableMemory mem2 = WritableMemory.writableWrap(memArr2);
csk = shared.compact(false, mem2);
assertEquals(csk.getEstimate(), localEst);
@@ -276,7 +276,7 @@
int bytes = local.getCompactBytes(); //compact form
assertEquals(bytes, 8);
byte[] memArr2 = new byte[bytes];
- WritableMemory mem2 = WritableMemory.wrap(memArr2);
+ WritableMemory mem2 = WritableMemory.writableWrap(memArr2);
CompactSketch csk2 = shared.compact(false, mem2);
assertEquals(csk2.getEstimate(), localEst);
@@ -500,7 +500,7 @@
double est2;
serArr = shared.toByteArray();
- WritableMemory mem = WritableMemory.wrap(serArr);
+ WritableMemory mem = WritableMemory.writableWrap(serArr);
UpdateSketch recoveredShared = Sketches.wrapUpdateSketch(mem);
//reconstruct to Native/Direct
diff --git a/src/test/java/org/apache/datasketches/theta/ConcurrentHeapQuickSelectSketchTest.java b/src/test/java/org/apache/datasketches/theta/ConcurrentHeapQuickSelectSketchTest.java
index 8e03aa3..e28cc74 100644
--- a/src/test/java/org/apache/datasketches/theta/ConcurrentHeapQuickSelectSketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/ConcurrentHeapQuickSelectSketchTest.java
@@ -64,7 +64,7 @@
assertEquals(shared.getRetainedEntries(false), u);
byte[] serArr = shared.toByteArray();
- WritableMemory mem = WritableMemory.wrap(serArr);
+ WritableMemory mem = WritableMemory.writableWrap(serArr);
Sketch sk = Sketch.heapify(mem, sl.seed);
assertTrue(sk instanceof HeapQuickSelectSketch); //Intentional promotion to Parent
@@ -112,7 +112,7 @@
assertEquals(local.getEstimate(), u, 0.0);
assertEquals(shared.getRetainedEntries(false), u);
byte[] byteArray = shared.toByteArray();
- WritableMemory mem = WritableMemory.wrap(byteArray);
+ WritableMemory mem = WritableMemory.writableWrap(byteArray);
mem.putByte(FAMILY_BYTE, (byte) 0); //corrupt the Sketch ID byte
//try to heapify the corruped mem
@@ -135,7 +135,7 @@
int lgK = 4;
SharedLocal sl = new SharedLocal(lgK);
byte[] serArr = sl.shared.toByteArray();
- WritableMemory srcMem = WritableMemory.wrap(serArr);
+ WritableMemory srcMem = WritableMemory.writableWrap(serArr);
srcMem.putByte(LG_NOM_LONGS_BYTE, (byte)2); //corrupt
Sketch.heapify(srcMem, DEFAULT_UPDATE_SEED);
}
@@ -312,7 +312,7 @@
assertEquals(comp2.getClass().getSimpleName(), "HeapCompactSketch");
byte[] memArr2 = new byte[sharedCompBytes];
- WritableMemory mem2 = WritableMemory.wrap(memArr2); //allocate mem for compact form
+ WritableMemory mem2 = WritableMemory.writableWrap(memArr2); //allocate mem for compact form
comp3 = shared.compact(false, mem2); //load the mem2
@@ -359,7 +359,7 @@
assertEquals(local.isEstimationMode(), estimating);
byte[] arr2 = new byte[compBytes];
- WritableMemory mem2 = WritableMemory.wrap(arr2);
+ WritableMemory mem2 = WritableMemory.writableWrap(arr2);
CompactSketch csk2 = shared.compact(false, mem2);
assertEquals(csk2.getEstimate(), localEst);
@@ -550,7 +550,7 @@
int bytes = local.getCompactBytes();
assertEquals(bytes, 8);
byte[] memArr2 = new byte[bytes];
- WritableMemory mem2 = WritableMemory.wrap(memArr2);
+ WritableMemory mem2 = WritableMemory.writableWrap(memArr2);
CompactSketch csk2 = shared.compact(false, mem2);
assertEquals(csk2.getEstimate(), localEst);
@@ -592,7 +592,7 @@
for (int i = 0; i < k; i++) { sl.local.update(i); }
waitForBgPropagationToComplete(sl.shared);
byte[] badArray = sl.shared.toByteArray();
- WritableMemory mem = WritableMemory.wrap(badArray);
+ WritableMemory mem = WritableMemory.writableWrap(badArray);
PreambleUtil.insertLgArrLongs(mem, 4); //corrupt
PreambleUtil.insertThetaLong(mem, Long.MAX_VALUE / 2); //corrupt
Sketch.heapify(mem);
diff --git a/src/test/java/org/apache/datasketches/theta/DirectIntersectionTest.java b/src/test/java/org/apache/datasketches/theta/DirectIntersectionTest.java
index 5bbd384..5063957 100644
--- a/src/test/java/org/apache/datasketches/theta/DirectIntersectionTest.java
+++ b/src/test/java/org/apache/datasketches/theta/DirectIntersectionTest.java
@@ -62,7 +62,7 @@
final int memBytes = getMaxIntersectionBytes(k);
final byte[] memArr = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
inter = SetOperation.builder().buildIntersection(iMem);
@@ -84,7 +84,7 @@
final int bytes = rsk1.getCompactBytes();
final byte[] byteArray = new byte[bytes];
- final WritableMemory mem = WritableMemory.wrap(byteArray);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArray);
rsk1 = inter.getResult(!ordered, mem);
assertEquals(rsk1.getEstimate(), 0.0);
@@ -111,7 +111,7 @@
final int memBytes = getMaxIntersectionBytes(k);
final byte[] memArr = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
inter = SetOperation.builder().buildIntersection(iMem);
inter.intersect(usk1);
@@ -128,7 +128,7 @@
final int bytes = rsk1.getCompactBytes();
final byte[] byteArray = new byte[bytes];
- final WritableMemory mem = WritableMemory.wrap(byteArray);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArray);
rsk1 = inter.getResult(!ordered, mem); //executed twice to fully exercise the internal state machine
assertEquals(rsk1.getEstimate(), k);
@@ -155,7 +155,7 @@
final int memBytes = getMaxIntersectionBytes(k);
final byte[] memArr = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
final CompactSketch csk1 = usk1.compact(true, null);
final CompactSketch csk2 = usk2.compact(true, null);
@@ -178,7 +178,7 @@
final int memBytes = getMaxIntersectionBytes(k);
final byte[] memArr = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
inter = SetOperation.builder().buildIntersection(iMem);
assertFalse(inter.hasResult());
@@ -191,7 +191,7 @@
final int k = 1<<lgK;
final int memBytes = getMaxIntersectionBytes(k);
final byte[] memArr = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
final Intersection inter = SetOperation.builder().buildIntersection(iMem);
final UpdateSketch sk = null;
try { inter.intersect(sk); fail(); }
@@ -213,7 +213,7 @@
final int memBytes = getMaxIntersectionBytes(k);
final byte[] memArr = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
//1st call = empty
sk = UpdateSketch.builder().setNominalEntries(k).build(); //empty
@@ -246,7 +246,7 @@
final int memBytes = getMaxIntersectionBytes(k);
final byte[] memArr = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
//1st call = empty
sk1 = UpdateSketch.builder().build(); //empty
@@ -285,7 +285,7 @@
final int memBytes = getMaxIntersectionBytes(k);
final byte[] memArr = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
//1st call = valid
sk1 = UpdateSketch.builder().build();
@@ -340,7 +340,7 @@
final int memBytes = getMaxIntersectionBytes(k);
final byte[] memArr = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
//1st call = valid
sk1 = UpdateSketch.builder().setNominalEntries(k).build();
@@ -381,7 +381,7 @@
final int reqBytes = getMaxIntersectionBytes(k);
final byte[] memArr = new byte[reqBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
//1st call = valid
sk1 = UpdateSketch.builder().setNominalEntries(2 * k).build(); // bigger sketch
@@ -407,7 +407,7 @@
final int memBytes = getMaxIntersectionBytes(k);
final byte[] memArr = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
//1st call = valid
sk1 = UpdateSketch.builder().setNominalEntries(k).build();
@@ -460,7 +460,7 @@
UpdateSketch sk1;
final int memBytes = getMaxIntersectionBytes(k);
- WritableMemory iMem = WritableMemory.wrap(new byte[memBytes]);
+ WritableMemory iMem = WritableMemory.writableWrap(new byte[memBytes]);
inter1 = SetOperation.builder().buildIntersection(iMem); //virgin off-heap
inter2 = Sketches.wrapIntersection(iMem); //virgin off-heap, identical to inter1
@@ -484,7 +484,7 @@
assertTrue(inter2.hasResult());
//test the path via toByteArray, wrap, now in a different state
- iMem = WritableMemory.wrap(inter1.toByteArray());
+ iMem = WritableMemory.writableWrap(inter1.toByteArray());
inter2 = Sketches.wrapIntersection((Memory)iMem);
assertTrue(inter2.hasResult()); //still true
@@ -503,7 +503,7 @@
final int memBytes = getMaxIntersectionBytes(k);
final byte[] memArr = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
inter1 = SetOperation.builder().buildIntersection(iMem); //virgin
inter2 = Sketches.wrapIntersection(iMem);
@@ -531,7 +531,7 @@
final int memBytes = getMaxIntersectionBytes(k);
final byte[] memArr = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
SetOperation.builder().buildIntersection(iMem);
}
@@ -544,7 +544,7 @@
final int memBytes = getMaxIntersectionBytes(k/2);
final byte[] memArr = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
final UpdateSketch usk1 = UpdateSketch.builder().setNominalEntries(k).build();
@@ -564,11 +564,11 @@
final int memBytes = getMaxIntersectionBytes(k);
final byte[] memArr = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
final Intersection inter1 = SetOperation.builder().buildIntersection(iMem); //virgin
final byte[] byteArray = inter1.toByteArray();
- final WritableMemory mem = WritableMemory.wrap(byteArray);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArray);
//corrupt:
mem.putByte(PREAMBLE_LONGS_BYTE, (byte) 2);//RF not used = 0
Sketches.wrapIntersection(mem);
@@ -581,11 +581,11 @@
final int memBytes = getMaxIntersectionBytes(k);
final byte[] memArr = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
inter1 = SetOperation.builder().buildIntersection(iMem); //virgin
final byte[] byteArray = inter1.toByteArray();
- final WritableMemory mem = WritableMemory.wrap(byteArray);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArray);
//corrupt:
mem.putByte(SER_VER_BYTE, (byte) 2);
Sketches.wrapIntersection(mem); //throws in SetOperations
@@ -598,7 +598,7 @@
union = SetOperation.builder().setNominalEntries(k).buildUnion();
final byte[] byteArray = union.toByteArray();
- final WritableMemory mem = WritableMemory.wrap(byteArray);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArray);
Sketches.wrapIntersection(mem);
}
@@ -613,7 +613,7 @@
final int memBytes = getMaxIntersectionBytes(k);
final byte[] memArr1 = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr1);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr1);
//1st call = valid
sk1 = UpdateSketch.builder().setNominalEntries(k).build();
@@ -628,7 +628,7 @@
inter.intersect(compSkIn1);
final byte[] memArr2 = inter.toByteArray();
- final WritableMemory srcMem = WritableMemory.wrap(memArr2);
+ final WritableMemory srcMem = WritableMemory.writableWrap(memArr2);
inter2 = Sketches.wrapIntersection(srcMem);
//2nd call = valid intersecting
@@ -647,7 +647,7 @@
println("Est: "+est);
final byte[] memArr3 = inter2.toByteArray();
- final WritableMemory srcMem2 = WritableMemory.wrap(memArr3);
+ final WritableMemory srcMem2 = WritableMemory.writableWrap(memArr3);
inter3 = Sketches.wrapIntersection(srcMem2);
resultComp2 = inter3.getResult(false, null);
est2 = resultComp2.getEstimate();
@@ -661,14 +661,14 @@
@Test
public void checkDefaultMinSize() {
final int k = 32;
- final WritableMemory mem = WritableMemory.wrap(new byte[k*8 + PREBYTES]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[k*8 + PREBYTES]);
IntersectionImpl.initNewDirectInstance(DEFAULT_UPDATE_SEED, mem);
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkExceptionMinSize() {
final int k = 16;
- final WritableMemory mem = WritableMemory.wrap(new byte[k*8 + PREBYTES]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[k*8 + PREBYTES]);
IntersectionImpl.initNewDirectInstance(DEFAULT_UPDATE_SEED, mem);
}
@@ -679,7 +679,7 @@
final int memBytes = getMaxIntersectionBytes(k);
final byte[] memArr = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
final Intersection inter = Sketches.setOperationBuilder().buildIntersection(iMem);
inter.intersect(sk);
@@ -691,7 +691,7 @@
public void checkFamily() {
//cheap trick
final int k = 16;
- final WritableMemory mem = WritableMemory.wrap(new byte[k*16 + PREBYTES]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[k*16 + PREBYTES]);
final IntersectionImpl impl = IntersectionImpl.initNewDirectInstance(DEFAULT_UPDATE_SEED, mem);
assertEquals(impl.getFamily(), Family.INTERSECTION);
}
@@ -699,7 +699,7 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkExceptions1() {
final int k = 16;
- final WritableMemory mem = WritableMemory.wrap(new byte[k*16 + PREBYTES]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[k*16 + PREBYTES]);
IntersectionImpl.initNewDirectInstance(DEFAULT_UPDATE_SEED, mem);
//corrupt SerVer
mem.putByte(PreambleUtil.SER_VER_BYTE, (byte) 2);
@@ -709,7 +709,7 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkExceptions2() {
final int k = 16;
- final WritableMemory mem = WritableMemory.wrap(new byte[k*16 + PREBYTES]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[k*16 + PREBYTES]);
IntersectionImpl.initNewDirectInstance(DEFAULT_UPDATE_SEED, mem);
//mem now has non-empty intersection
//corrupt empty and CurCount
@@ -730,10 +730,10 @@
sk1.update(i);
sk2.update(k-2 +i); //overlap by 2
}
- final WritableMemory memIn1 = WritableMemory.wrap(new byte[memBytes]);
- final WritableMemory memIn2 = WritableMemory.wrap(new byte[memBytes]);
- final WritableMemory memInter = WritableMemory.wrap(new byte[memBytes]);
- final WritableMemory memComp = WritableMemory.wrap(new byte[memBytes]);
+ final WritableMemory memIn1 = WritableMemory.writableWrap(new byte[memBytes]);
+ final WritableMemory memIn2 = WritableMemory.writableWrap(new byte[memBytes]);
+ final WritableMemory memInter = WritableMemory.writableWrap(new byte[memBytes]);
+ final WritableMemory memComp = WritableMemory.writableWrap(new byte[memBytes]);
final CompactSketch csk1 = sk1.compact(true, memIn1);
final CompactSketch csk2 = sk2.compact(true, memIn2);
final Intersection inter = Sketches.setOperationBuilder().buildIntersection(memInter);
diff --git a/src/test/java/org/apache/datasketches/theta/DirectQuickSelectSketchTest.java b/src/test/java/org/apache/datasketches/theta/DirectQuickSelectSketchTest.java
index 26e7b4c..876a9b4 100644
--- a/src/test/java/org/apache/datasketches/theta/DirectQuickSelectSketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/DirectQuickSelectSketchTest.java
@@ -57,11 +57,11 @@
@SuppressWarnings("javadoc")
public class DirectQuickSelectSketchTest {
- @Test(expectedExceptions = SketchesArgumentException.class)
+ @Test//(expectedExceptions = SketchesArgumentException.class)
public void checkBadSerVer() {
int k = 512;
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -77,24 +77,33 @@
mem.putByte(SER_VER_BYTE, (byte) 0); //corrupt the SerVer byte
Sketch.wrap(mem);
+ } catch (final Exception e) {
+ if (e instanceof SketchesArgumentException) {}
+ else { throw new RuntimeException(e); }
}
}
- @Test(expectedExceptions = SketchesArgumentException.class)
+ @Test//(expectedExceptions = SketchesArgumentException.class)
public void checkConstructorKtooSmall() {
int k = 8;
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch.builder().setNominalEntries(k).build(mem);
+ } catch (final Exception e) {
+ if (e instanceof SketchesArgumentException) {}
+ else { throw new RuntimeException(e); }
}
}
- @Test(expectedExceptions = SketchesArgumentException.class)
+ @Test//(expectedExceptions = SketchesArgumentException.class)
public void checkConstructorMemTooSmall() {
int k = 16;
try (WritableDirectHandle h = makeNativeMemory(k/2)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch.builder().setNominalEntries(k).build(mem);
+ } catch (final Exception e) {
+ if (e instanceof SketchesArgumentException) {}
+ else { throw new RuntimeException(e); }
}
}
@@ -102,7 +111,7 @@
public void checkHeapifyIllegalFamilyID_heapify() {
int k = 512;
int bytes = (k << 4) + (Family.QUICKSELECT.getMinPreLongs() << 3);
- WritableMemory mem = WritableMemory.wrap(new byte[bytes]);
+ WritableMemory mem = WritableMemory.writableWrap(new byte[bytes]);
UpdateSketch.builder().setNominalEntries(k).build(mem);
mem.putByte(FAMILY_BYTE, (byte) 0); //corrupt the Family ID byte
@@ -118,7 +127,7 @@
boolean estimating = (u > k);
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch sk1 = UpdateSketch.builder().setNominalEntries(k).build(mem);
for (int i=0; i<u; i++) { sk1.update(i); }
@@ -151,6 +160,8 @@
assertFalse(sk2.isDirect());
assertFalse(sk2.hasMemory());
assertFalse(sk2.isDirty());
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -158,7 +169,7 @@
public void checkWrapIllegalFamilyID_wrap() {
int k = 512;
int maxBytes = (k << 4) + (Family.QUICKSELECT.getMinPreLongs() << 3);
- WritableMemory mem = WritableMemory.wrap(new byte[maxBytes]);
+ WritableMemory mem = WritableMemory.writableWrap(new byte[maxBytes]);
UpdateSketch.builder().setNominalEntries(k).build(mem);
@@ -172,7 +183,7 @@
public void checkWrapIllegalFamilyID_direct() {
int k = 512;
int maxBytes = (k << 4) + (Family.QUICKSELECT.getMinPreLongs() << 3);
- WritableMemory mem = WritableMemory.wrap(new byte[maxBytes]);
+ WritableMemory mem = WritableMemory.writableWrap(new byte[maxBytes]);
UpdateSketch.builder().setNominalEntries(k).build(mem);
@@ -182,29 +193,35 @@
DirectQuickSelectSketch.writableWrap(mem, DEFAULT_UPDATE_SEED);
}
- @Test(expectedExceptions = SketchesArgumentException.class)
+ @Test //(expectedExceptions = SketchesArgumentException.class)
public void checkHeapifySeedConflict() {
int k = 512;
long seed1 = 1021;
long seed2 = DEFAULT_UPDATE_SEED;
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch usk = UpdateSketch.builder().setSeed(seed1).setNominalEntries(k).build(mem);
byte[] byteArray = usk.toByteArray();
Memory srcMem = Memory.wrap(byteArray);
Sketch.heapify(srcMem, seed2);
+ } catch (final Exception e) {
+ if (e instanceof SketchesArgumentException) {}
+ else { throw new RuntimeException(e); }
}
}
- @Test(expectedExceptions = SketchesArgumentException.class)
+ @Test//(expectedExceptions = SketchesArgumentException.class)
public void checkCorruptLgNomLongs() {
int k = 16;
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch.builder().setNominalEntries(k).build(mem);
mem.putByte(LG_NOM_LONGS_BYTE, (byte)2); //corrupt
Sketch.heapify(mem, DEFAULT_UPDATE_SEED);
+ } catch (final Exception e) {
+ if (e instanceof SketchesArgumentException) {}
+ else { throw new RuntimeException(e); }
}
}
@@ -212,7 +229,7 @@
public void checkHeapifyByteArrayExact() {
int k = 512;
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
@@ -235,6 +252,8 @@
// That is, this is being run for its side-effect of accessing things.
// If something is wonky, it will generate an exception and fail the test.
usk2.toString(true, true, 8, true);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -243,7 +262,7 @@
int k = 4096;
int u = 2*k;
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
for (int i=0; i<u; i++) { usk.update(i); }
@@ -262,6 +281,8 @@
assertEquals(usk2.isEmpty(), false);
assertEquals(usk2.isEstimationMode(), true);
assertEquals(usk2.getClass().getSimpleName(), "HeapQuickSelectSketch");
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -272,7 +293,7 @@
boolean estimating = (u > k);
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch sk1 = UpdateSketch.builder().setNominalEntries(k).build(mem);
for (int i=0; i<u; i++) { sk1.update(i); }
@@ -288,6 +309,8 @@
assertEquals(sk2.getUpperBound(2), sk1ub);
assertEquals(sk2.isEmpty(), false);
assertEquals(sk2.isEstimationMode(), estimating);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -297,7 +320,7 @@
int u = 4*k;
boolean estimating = (u > k);
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -339,7 +362,7 @@
int bytes = usk.getCompactBytes();
assertEquals(bytes, (k*8) + (Family.COMPACT.getMaxPreLongs() << 3));
byte[] memArr2 = new byte[bytes];
- WritableMemory mem2 = WritableMemory.wrap(memArr2);
+ WritableMemory mem2 = WritableMemory.writableWrap(memArr2);
csk = usk.compact(false, mem2);
assertEquals(csk.getEstimate(), uskEst);
@@ -358,6 +381,8 @@
assertEquals(csk.isEstimationMode(), estimating);
assertEquals(csk.getClass().getSimpleName(), "DirectCompactSketch");
csk.toString(false, true, 0, false);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -365,7 +390,7 @@
public void checkDQStoCompactEmptyForms() {
int k = 512;
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
@@ -380,7 +405,7 @@
int bytes = usk.getCompactBytes(); //compact form
assertEquals(bytes, 8);
byte[] memArr2 = new byte[bytes];
- WritableMemory mem2 = WritableMemory.wrap(memArr2);
+ WritableMemory mem2 = WritableMemory.writableWrap(memArr2);
CompactSketch csk2 = usk.compact(false, mem2);
assertEquals(csk2.getEstimate(), uskEst);
@@ -399,6 +424,9 @@
assertEquals(csk3.isEmpty(), true);
assertEquals(csk3.isEstimationMode(), false);
assertEquals(csk3.getClass().getSimpleName(), "DirectCompactSketch");
+ } catch (final Exception e) {
+ //if (e instanceof SketchesArgumentException) {}
+ throw new RuntimeException(e);
}
}
@@ -408,7 +436,7 @@
int u = 2*k;
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -418,6 +446,8 @@
for (int i = 0; i< u; i++) { usk.update(i); }
assertTrue(sk1.getRetainedEntries(false) > k);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -427,7 +457,7 @@
float p = (float)0.5;
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch usk = UpdateSketch.builder().setP(p).setNominalEntries(k).build(mem);
DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -444,6 +474,8 @@
assertTrue(ub > est);
double lb = usk.getLowerBound(1);
assertTrue(lb < est);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -451,7 +483,7 @@
public void checkErrorBounds() {
int k = 512;
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
@@ -475,6 +507,8 @@
ub = usk.getUpperBound(2);
assertTrue(est <= ub);
assertTrue(est >= lb);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -485,7 +519,7 @@
int k = 1024;
float p = (float)1.0;
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch usk = UpdateSketch.builder().setP(p).setNominalEntries(k).build(mem);
DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -498,7 +532,7 @@
//virgin, p = .001
p = (float)0.001;
byte[] memArr2 = new byte[(int) mem.getCapacity()];
- WritableMemory mem2 = WritableMemory.wrap(memArr2);
+ WritableMemory mem2 = WritableMemory.writableWrap(memArr2);
UpdateSketch usk2 = UpdateSketch.builder().setP(p).setNominalEntries(k).build(mem2);
sk1 = (DirectQuickSelectSketch)usk2;
@@ -515,6 +549,8 @@
double lb = usk2.getLowerBound(2);
assertTrue(lb <= est);
//println("LB: "+lb);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -523,7 +559,7 @@
int k = 512;
int u = 2*k;
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
@@ -534,6 +570,8 @@
double lb = usk.getLowerBound(1);
assertTrue(ub > est);
assertTrue(lb < est);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -542,7 +580,7 @@
int k = 512;
int u = 4*k;
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -561,6 +599,8 @@
sk1.rebuild();
assertEquals(sk1.getRetainedEntries(false), k);
assertEquals(sk1.getRetainedEntries(true), k);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -569,7 +609,7 @@
int k = 512;
int u = 4*k;
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -590,6 +630,8 @@
assertNotNull(sk1.getMemory());
assertFalse(sk1.isOrdered());
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -598,7 +640,7 @@
int k = 4096;
int u = 4096;
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -608,6 +650,8 @@
assertEquals(usk.getEstimate(), u, 0.0);
assertEquals(sk1.getRetainedEntries(false), u);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -617,7 +661,7 @@
int u = 2*k;
try (WritableDirectHandle h = makeNativeMemory(k)) {
- WritableMemory mem = h.get();
+ WritableMemory mem = h.getWritable();
UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -627,6 +671,8 @@
assertEquals(usk.getEstimate(), u, u*.05);
assertTrue(sk1.getRetainedEntries(false) > k);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -638,7 +684,7 @@
try(WritableDirectHandle memHandler = WritableMemory.allocateDirect(memCapacity)) {
- UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(memHandler.get());
+ UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(memHandler.getWritable());
DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
assertTrue(usk.isEmpty());
@@ -647,6 +693,8 @@
println(""+est);
assertEquals(usk.getEstimate(), u, u*.05);
assertTrue(sk1.getRetainedEntries(false) > k);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -656,7 +704,7 @@
int u = 2*k;
try (WritableDirectHandle h = makeNativeMemory(k)) {
- UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(h.get());
+ UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(h.getWritable());
assertTrue(usk.isEmpty());
for (int i = 0; i< u; i++) { usk.update(i); } //force estimation
@@ -672,7 +720,7 @@
serArr = usk.toByteArray();
- WritableMemory mem2 = WritableMemory.wrap(serArr);
+ WritableMemory mem2 = WritableMemory.writableWrap(serArr);
//reconstruct to Native/Direct
UpdateSketch usk2 = Sketches.wrapUpdateSketch(mem2);
@@ -682,6 +730,8 @@
assertEquals(count2, count1);
assertEquals(est2, est1, 0.0);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -694,7 +744,7 @@
public void updateAfterWritableWrap() {
UpdateSketch usk1 = UpdateSketch.builder().build();
- UpdateSketch usk2 = UpdateSketch.wrap(WritableMemory.wrap(usk1.toByteArray()));
+ UpdateSketch usk2 = UpdateSketch.wrap(WritableMemory.writableWrap(usk1.toByteArray()));
usk2.update(0);
}
@@ -712,7 +762,7 @@
int bytes = Sketches.getMaxUpdateSketchBytes(k);
byte[] arr1 = new byte[bytes];
- WritableMemory mem1 = WritableMemory.wrap(arr1);
+ WritableMemory mem1 = WritableMemory.writableWrap(arr1);
ResizeFactor rf = ResizeFactor.X1; //0
UpdateSketch usk1 = UpdateSketch.builder().setNominalEntries(k).setResizeFactor(rf).build(mem1);
for (int i=0; i<u; i++) { usk1.update(i); }
@@ -764,7 +814,7 @@
}
byte[] arr2 = Arrays.copyOfRange(arr1, 0, bytes-1); //corrupt length
- WritableMemory mem2 = WritableMemory.wrap(arr2);
+ WritableMemory mem2 = WritableMemory.writableWrap(arr2);
try {
usk2 = DirectQuickSelectSketch.writableWrap(mem2, DEFAULT_UPDATE_SEED);
fail("Expected SketchesArgumentException");
@@ -779,7 +829,7 @@
int bytes = Sketches.getMaxUpdateSketchBytes(k);
byte[] arr = new byte[bytes];
- WritableMemory mem = WritableMemory.wrap(arr);
+ WritableMemory mem = WritableMemory.writableWrap(arr);
ResizeFactor rf = ResizeFactor.X8; // 3
UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).setResizeFactor(rf).build(mem);
usk.update(0);
@@ -792,7 +842,7 @@
@Test
public void checkFamilyAndRF() {
int k = 16;
- WritableMemory mem = WritableMemory.wrap(new byte[(k*16) +24]);
+ WritableMemory mem = WritableMemory.writableWrap(new byte[(k*16) +24]);
UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build(mem);
assertEquals(sketch.getFamily(), Family.QUICKSELECT);
assertEquals(sketch.getResizeFactor(), ResizeFactor.X8);
@@ -803,7 +853,7 @@
public void checkResizeInBigMem() {
int k = 1 << 14;
int u = 1 << 20;
- WritableMemory mem = WritableMemory.wrap(new byte[(8*k*16) +24]);
+ WritableMemory mem = WritableMemory.writableWrap(new byte[(8*k*16) +24]);
UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build(mem);
for (int i=0; i<u; i++) { sketch.update(i); }
}
@@ -811,7 +861,7 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkBadLgNomLongs() {
int k = 16;
- WritableMemory mem = WritableMemory.wrap(new byte[(k*16) +24]);
+ WritableMemory mem = WritableMemory.writableWrap(new byte[(k*16) +24]);
Sketches.updateSketchBuilder().setNominalEntries(k).build(mem);
mem.putByte(LG_NOM_LONGS_BYTE, (byte) 3); //Corrupt LgNomLongs byte
DirectQuickSelectSketch.writableWrap(mem, DEFAULT_UPDATE_SEED);
@@ -823,11 +873,13 @@
int u = 2 * k;
int bytes = Sketches.getMaxUpdateSketchBytes(k);
try (WritableDirectHandle wdh = WritableMemory.allocateDirect(bytes/2)) { //will request
- WritableMemory wmem = wdh.get();
+ WritableMemory wmem = wdh.getWritable();
UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build(wmem);
assertTrue(sketch.isSameResource(wmem));
for (int i = 0; i < u; i++) { sketch.update(i); }
assertFalse(sketch.isSameResource(wmem));
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -837,7 +889,7 @@
int u = 2 * k;
int bytes = Sketches.getMaxUpdateSketchBytes(k);
try (WritableDirectHandle wdh = WritableMemory.allocateDirect(bytes/2)) { //will request
- WritableMemory wmem = wdh.get();
+ WritableMemory wmem = wdh.getWritable();
UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build(wmem);
for (int i = 0; i < u; i++) { sketch.update(i); }
double est1 = sketch.getEstimate();
@@ -858,6 +910,8 @@
} catch (SketchesReadOnlyException e) {
//expected
}
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
diff --git a/src/test/java/org/apache/datasketches/theta/DirectUnionTest.java b/src/test/java/org/apache/datasketches/theta/DirectUnionTest.java
index d92e672..3c21096 100644
--- a/src/test/java/org/apache/datasketches/theta/DirectUnionTest.java
+++ b/src/test/java/org/apache/datasketches/theta/DirectUnionTest.java
@@ -62,7 +62,7 @@
assertEquals(u, usk1.getEstimate() + usk2.getEstimate(), 0.0); //exact, no overlap
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(usk1); //update with heap UpdateSketch
@@ -87,7 +87,7 @@
usk2.update(i); //2*k no overlap
}
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(usk1); //update with heap UpdateSketch
@@ -114,7 +114,7 @@
assertEquals(u, usk1.getEstimate() + usk2.getEstimate()/2, 0.0); //exact, overlapped
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(usk1); //update with heap UpdateSketch
@@ -141,7 +141,7 @@
assertEquals(u, usk1.getEstimate() + usk2.getEstimate(), 0.0); //exact, no overlap
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(usk1); //update with heap UpdateSketch
@@ -149,7 +149,7 @@
testAllCompactForms(union, u, 0.0);
- final Union union2 = (Union)SetOperation.heapify(WritableMemory.wrap(union.toByteArray()));
+ final Union union2 = (Union)SetOperation.heapify(WritableMemory.writableWrap(union.toByteArray()));
testAllCompactForms(union2, u, 0.0);
}
@@ -173,7 +173,7 @@
assertEquals(u, usk1.getEstimate() + usk2.getEstimate(), 0.0); //exact, no overlap
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(usk1); //update with heap UpdateSketch
@@ -181,7 +181,7 @@
testAllCompactForms(union, u, 0.0);
- final Union union2 = Sketches.wrapUnion(WritableMemory.wrap(union.toByteArray()));
+ final Union union2 = Sketches.wrapUnion(WritableMemory.writableWrap(union.toByteArray()));
testAllCompactForms(union2, u, 0.0);
}
@@ -202,7 +202,7 @@
usk2.update(i); //2k no overlap, exact
}
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(usk1); //update with heap UpdateSketch
@@ -210,7 +210,7 @@
testAllCompactForms(union, u, 0.05);
- final Union union2 = Sketches.wrapUnion(WritableMemory.wrap(union.toByteArray()));
+ final Union union2 = Sketches.wrapUnion(WritableMemory.writableWrap(union.toByteArray()));
testAllCompactForms(union2, u, 0.05);
}
@@ -233,7 +233,7 @@
final CompactSketch cosk2 = usk2.compact(true, null);
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(usk1); //update with heap UpdateSketch
@@ -246,7 +246,7 @@
testAllCompactForms(union, u, 0.05);
- final Union union2 = Sketches.wrapUnion(WritableMemory.wrap(union.toByteArray()));
+ final Union union2 = Sketches.wrapUnion(WritableMemory.writableWrap(union.toByteArray()));
testAllCompactForms(union2, u, 0.05);
@@ -270,10 +270,10 @@
usk2.update(i); //2k no overlap, exact, will force early stop
}
- final WritableMemory cskMem2 = WritableMemory.wrap(new byte[usk2.getCompactBytes()]);
+ final WritableMemory cskMem2 = WritableMemory.writableWrap(new byte[usk2.getCompactBytes()]);
final CompactSketch cosk2 = usk2.compact(true, cskMem2); //ordered, loads the cskMem2 as ordered
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(usk1); //updates with heap UpdateSketch
@@ -286,7 +286,7 @@
testAllCompactForms(union, u, 0.05);
- final Union union2 = Sketches.wrapUnion(WritableMemory.wrap(union.toByteArray()));
+ final Union union2 = Sketches.wrapUnion(WritableMemory.writableWrap(union.toByteArray()));
testAllCompactForms(union2, u, 0.05);
@@ -310,10 +310,10 @@
usk2.update(i); //2k no overlap, exact, will force early stop
}
- final WritableMemory cskMem2 = WritableMemory.wrap(new byte[usk2.getCompactBytes()]);
+ final WritableMemory cskMem2 = WritableMemory.writableWrap(new byte[usk2.getCompactBytes()]);
usk2.compact(true, cskMem2); //ordered, loads the cskMem2 as ordered
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(usk1); //updates with heap UpdateSketch
@@ -326,7 +326,7 @@
testAllCompactForms(union, u, 0.05);
- final Union union2 = Sketches.wrapUnion(WritableMemory.wrap(union.toByteArray()));
+ final Union union2 = Sketches.wrapUnion(WritableMemory.writableWrap(union.toByteArray()));
testAllCompactForms(union2, u, 0.05);
@@ -350,10 +350,10 @@
usk2.update(i); //2k no overlap, exact, will force early stop
}
- final WritableMemory cskMem2 = WritableMemory.wrap(new byte[usk2.getCompactBytes()]);
+ final WritableMemory cskMem2 = WritableMemory.writableWrap(new byte[usk2.getCompactBytes()]);
usk2.compact(false, cskMem2); //unordered, loads the cskMem2 as unordered
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(usk1); //updates with heap UpdateSketch
@@ -366,7 +366,7 @@
testAllCompactForms(union, u, 0.05);
- final Union union2 = Sketches.wrapUnion(WritableMemory.wrap(union.toByteArray()));
+ final Union union2 = Sketches.wrapUnion(WritableMemory.writableWrap(union.toByteArray()));
testAllCompactForms(union2, u, 0.05);
@@ -404,7 +404,7 @@
}
v += u;
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(usk1); //updates with heap UpdateSketch
@@ -441,7 +441,7 @@
final CompactSketch csk1 = (CompactSketch)Sketch.wrap(skMem1);
final CompactSketch csk2 = (CompactSketch)Sketch.wrap(skMem2);
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(csk1);
@@ -472,7 +472,7 @@
final Memory v1mem1 = convertSerVer3toSerVer1(usk1.compact(true, null));
final Memory v1mem2 = convertSerVer3toSerVer1(usk2.compact(true, null));
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(v1mem1);
@@ -503,7 +503,7 @@
final Memory v2mem1 = convertSerVer3toSerVer2(usk1.compact(true, null), Util.DEFAULT_UPDATE_SEED);
final Memory v2mem2 = convertSerVer3toSerVer2(usk2.compact(true, null), Util.DEFAULT_UPDATE_SEED);
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(v2mem1);
@@ -520,11 +520,11 @@
final UpdateSketch usk1 = UpdateSketch.builder().setNominalEntries(k).build();
final CompactSketch usk1c = usk1.compact(true, null);
- WritableMemory v3mem1 = WritableMemory.wrap(usk1c.toByteArray());
+ WritableMemory v3mem1 = WritableMemory.writableWrap(usk1c.toByteArray());
final Memory v1mem1 = convertSerVer3toSerVer1(usk1c);
- WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(v1mem1);
CompactSketch cOut = union.getResult(true, null);
@@ -532,19 +532,19 @@
final Memory v2mem1 = convertSerVer3toSerVer2(usk1c, Util.DEFAULT_UPDATE_SEED);
- uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(v2mem1);
cOut = union.getResult(true, null);
assertEquals(cOut.getEstimate(), 0.0, 0.0);
- uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(v3mem1);
cOut = union.getResult(true, null);
assertEquals(cOut.getEstimate(), 0.0, 0.0);
- uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
v3mem1 = null;
union.union(v3mem1);
@@ -564,9 +564,9 @@
usk1.update(i); //force prelongs to 3
}
final CompactSketch usk1c = usk1.compact(true, null);
- final WritableMemory v3mem1 = WritableMemory.wrap(usk1c.toByteArray());
+ final WritableMemory v3mem1 = WritableMemory.writableWrap(usk1c.toByteArray());
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(v3mem1);
}
@@ -580,11 +580,11 @@
usk1.update(1);
usk1.update(2);
final CompactSketch usk1c = usk1.compact(true, null);
- final WritableMemory v3mem1 = WritableMemory.wrap(usk1c.toByteArray());
+ final WritableMemory v3mem1 = WritableMemory.writableWrap(usk1c.toByteArray());
//corrupt SerVer
v3mem1.putByte(SER_VER_BYTE, (byte)0);
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(v3mem1);
@@ -598,17 +598,17 @@
final CompactSketch usk1c = usk1.compact(true, null);
final byte[] skArr = usk1c.toByteArray();
final byte[] skArr2 = Arrays.copyOf(skArr, skArr.length * 2);
- final WritableMemory v3mem1 = WritableMemory.wrap(skArr2);
+ final WritableMemory v3mem1 = WritableMemory.writableWrap(skArr2);
- WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(v3mem1);
final Memory v2mem1 = convertSerVer3toSerVer2(usk1c, Util.DEFAULT_UPDATE_SEED);
- final WritableMemory v2mem2 = WritableMemory.wrap(new byte[16]);
+ final WritableMemory v2mem2 = WritableMemory.writableWrap(new byte[16]);
v2mem1.copyTo(0, v2mem2, 0, 8);
- uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(v2mem2);
}
@@ -617,7 +617,7 @@
@Test //Himanshu's issue
public void checkDirectWrap() {
final int nomEntries = 16;
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(nomEntries)]);
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(nomEntries)]);
SetOperation.builder().setNominalEntries(nomEntries).buildUnion(uMem);
final UpdateSketch sk1 = UpdateSketch.builder().setNominalEntries(nomEntries).build();
@@ -642,10 +642,10 @@
public void checkEmptyUnionCompactResult() {
final int k = 64;
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
- final WritableMemory mem = WritableMemory.wrap(new byte[Sketch.getMaxCompactSketchBytes(0)]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[Sketch.getMaxCompactSketchBytes(0)]);
final CompactSketch csk = union.getResult(false, mem); //DirectCompactSketch
assertTrue(csk.isEmpty());
}
@@ -654,10 +654,10 @@
public void checkEmptyUnionCompactOrderedResult() {
final int k = 64;
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
- final WritableMemory mem = WritableMemory.wrap(new byte[Sketch.getMaxCompactSketchBytes(0)]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[Sketch.getMaxCompactSketchBytes(0)]);
final CompactSketch csk = union.getResult(true, mem); //DirectCompactSketch
assertTrue(csk.isEmpty());
}
@@ -666,7 +666,7 @@
public void checkUnionMemToString() {
final int k = 64;
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
}
@@ -677,7 +677,7 @@
final int memBytes = getMaxUnionBytes(k);
final byte[] memArr = new byte[memBytes];
- final WritableMemory iMem = WritableMemory.wrap(memArr);
+ final WritableMemory iMem = WritableMemory.writableWrap(memArr);
final Union union = Sketches.setOperationBuilder().setNominalEntries(k).buildUnion(iMem);
union.union(sk);
@@ -688,7 +688,7 @@
@Test
public void checkPrimitiveUpdates() {
final int k = 32;
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.update(1L);
@@ -729,7 +729,7 @@
@Test
public void checkGetFamily() {
final int k = 16;
- final WritableMemory mem = WritableMemory.wrap(new byte[k*16 +32]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[k*16 +32]);
final SetOperation setOp = new SetOperationBuilder().setNominalEntries(k).build(Family.UNION, mem);
assertEquals(setOp.getFamily(), Family.UNION);
}
@@ -737,7 +737,7 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkPreambleLongsCorruption() {
final int k = 16;
- final WritableMemory mem = WritableMemory.wrap(new byte[k*16 +32]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[k*16 +32]);
final SetOperation setOp = new SetOperationBuilder().setNominalEntries(k).build(Family.UNION, mem);
println(setOp.toString());
@@ -752,10 +752,10 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkSizeTooSmall() {
final int k = 16;
- final WritableMemory mem = WritableMemory.wrap(new byte[k*16 +32]); //initialized
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[k*16 +32]); //initialized
final SetOperation setOp = new SetOperationBuilder().setNominalEntries(k).build(Family.UNION, mem);
println(setOp.toString());
- final WritableMemory mem2 = WritableMemory.wrap(new byte[32]); //for just preamble
+ final WritableMemory mem2 = WritableMemory.writableWrap(new byte[32]); //for just preamble
mem.copyTo(0, mem2, 0, 32); //too small
DirectQuickSelectSketch.writableWrap(mem2, Util.DEFAULT_UPDATE_SEED);
}
@@ -772,7 +772,7 @@
final Sketch s = usk.compact();
//create empty target union in off-heap mem
- final WritableMemory mem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
final Union union1 = SetOperation.builder().setNominalEntries(k).buildUnion(mem);
union1.union(s);
@@ -798,7 +798,7 @@
usk.compact(true, memIn); //side effect of loading the memIn
//create empty target union in off-heap mem
- final WritableMemory mem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
final Union union1 = SetOperation.builder().setNominalEntries(k).buildUnion(mem);
union1.union(memIn);
diff --git a/src/test/java/org/apache/datasketches/theta/HeapAlphaSketchTest.java b/src/test/java/org/apache/datasketches/theta/HeapAlphaSketchTest.java
index 68133fd..157731a 100644
--- a/src/test/java/org/apache/datasketches/theta/HeapAlphaSketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/HeapAlphaSketchTest.java
@@ -73,7 +73,7 @@
assertEquals(sk1.getRetainedEntries(false), u);
byte[] byteArray = usk.toByteArray();
- WritableMemory mem = WritableMemory.wrap(byteArray);
+ WritableMemory mem = WritableMemory.writableWrap(byteArray);
mem.putByte(SER_VER_BYTE, (byte) 0); //corrupt the SerVer byte
Sketch.heapify(mem, seed);
@@ -87,7 +87,7 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkAlphaIncompatibleWithMem() {
- WritableMemory mem = WritableMemory.wrap(new byte[(512*16)+24]);
+ WritableMemory mem = WritableMemory.writableWrap(new byte[(512*16)+24]);
UpdateSketch.builder().setFamily(Family.ALPHA).setNominalEntries(512).build(mem);
}
@@ -109,7 +109,7 @@
assertEquals(usk.getEstimate(), u, 0.0);
assertEquals(sk1.getRetainedEntries(false), u);
byte[] byteArray = usk.toByteArray();
- WritableMemory mem = WritableMemory.wrap(byteArray);
+ WritableMemory mem = WritableMemory.writableWrap(byteArray);
mem.putByte(FAMILY_BYTE, (byte) 0); //corrupt the Sketch ID byte
//try to heapify the corruped mem
@@ -269,7 +269,7 @@
int alphaBytes = sk1.getRetainedEntries(true) * 8;
assertEquals(bytes, alphaBytes + (Family.COMPACT.getMaxPreLongs() << 3));
byte[] memArr2 = new byte[bytes];
- WritableMemory mem2 = WritableMemory.wrap(memArr2);
+ WritableMemory mem2 = WritableMemory.writableWrap(memArr2);
comp3 = usk.compact(false, mem2);
@@ -313,7 +313,7 @@
int bytes = usk.getCompactBytes();
assertEquals(bytes, 8); //compact, empty and theta = 1.0
byte[] memArr2 = new byte[bytes];
- WritableMemory mem2 = WritableMemory.wrap(memArr2);
+ WritableMemory mem2 = WritableMemory.writableWrap(memArr2);
CompactSketch csk2 = usk.compact(false, mem2);
assertEquals(csk2.getEstimate(), uskEst);
@@ -575,7 +575,7 @@
int k = 512;
Sketch alpha = UpdateSketch.builder().setFamily(ALPHA).setNominalEntries(k).build();
byte[] byteArray = alpha.toByteArray();
- WritableMemory mem = WritableMemory.wrap(byteArray);
+ WritableMemory mem = WritableMemory.writableWrap(byteArray);
//corrupt:
mem.putByte(PREAMBLE_LONGS_BYTE, (byte) 4);
Sketch.heapify(mem);
@@ -594,7 +594,7 @@
UpdateSketch sk1 = UpdateSketch.builder().setFamily(ALPHA).setNominalEntries(k).build();
sk1.update(1L); //forces preLongs to 3
byte[] bytearray1 = sk1.toByteArray();
- WritableMemory mem = WritableMemory.wrap(bytearray1);
+ WritableMemory mem = WritableMemory.writableWrap(bytearray1);
long pre0 = mem.getLong(0);
tryBadMem(mem, PREAMBLE_LONGS_BYTE, 2); //Corrupt PreLongs
@@ -619,7 +619,7 @@
}
mem.putLong(THETA_LONG, origThetaLong); //restore theta
byte[] byteArray2 = new byte[bytearray1.length -1];
- WritableMemory mem2 = WritableMemory.wrap(byteArray2);
+ WritableMemory mem2 = WritableMemory.writableWrap(byteArray2);
mem.copyTo(0, mem2, 0, mem2.getCapacity());
try {
HeapAlphaSketch.heapifyInstance(mem2, DEFAULT_UPDATE_SEED);
@@ -678,7 +678,7 @@
.setFamily(ALPHA).build();
for (int i = 0; i < k; i++) { sketch.update(i); }
byte[] byteArr = sketch.toByteArray();
- WritableMemory wmem = WritableMemory.wrap(byteArr);
+ WritableMemory wmem = WritableMemory.writableWrap(byteArr);
wmem.putByte(LG_NOM_LONGS_BYTE, (byte) 8); //corrupt LgNomLongs
UpdateSketch sk = Sketches.heapifyUpdateSketch(wmem);
}
diff --git a/src/test/java/org/apache/datasketches/theta/HeapIntersectionTest.java b/src/test/java/org/apache/datasketches/theta/HeapIntersectionTest.java
index 736b1e5..894864f 100644
--- a/src/test/java/org/apache/datasketches/theta/HeapIntersectionTest.java
+++ b/src/test/java/org/apache/datasketches/theta/HeapIntersectionTest.java
@@ -74,7 +74,7 @@
final int bytes = rsk1.getCompactBytes();
final byte[] byteArray = new byte[bytes];
- final WritableMemory mem = WritableMemory.wrap(byteArray);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArray);
rsk1 = inter.getResult(!ordered, mem);
assertEquals(rsk1.getEstimate(), 0.0);
@@ -116,7 +116,7 @@
final int bytes = rsk1.getCompactBytes();
final byte[] byteArray = new byte[bytes];
- final WritableMemory mem = WritableMemory.wrap(byteArray);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArray);
rsk1 = inter.getResult(!ordered, mem); //executed twice to fully exercise the internal state machine
assertEquals(rsk1.getEstimate(), k);
@@ -356,7 +356,7 @@
//Put the intersection into memory
final byte[] byteArray = inter.toByteArray();
- final WritableMemory mem = WritableMemory.wrap(byteArray);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArray);
//Heapify
final Intersection inter2 = (Intersection) SetOperation.heapify(mem);
final CompactSketch heapifiedSk = inter2.getResult(false, null);
@@ -428,7 +428,7 @@
public void checkBadPreambleLongs() {
final Intersection inter1 = SetOperation.builder().buildIntersection(); //virgin
final byte[] byteArray = inter1.toByteArray();
- final WritableMemory mem = WritableMemory.wrap(byteArray);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArray);
//corrupt:
mem.putByte(PREAMBLE_LONGS_BYTE, (byte) 2); //RF not used = 0
SetOperation.heapify(mem);
@@ -438,7 +438,7 @@
public void checkBadSerVer() {
final Intersection inter1 = SetOperation.builder().buildIntersection(); //virgin
final byte[] byteArray = inter1.toByteArray();
- final WritableMemory mem = WritableMemory.wrap(byteArray);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArray);
//corrupt:
mem.putByte(SER_VER_BYTE, (byte) 2);
SetOperation.heapify(mem);
@@ -462,7 +462,7 @@
final UpdateSketch sk = Sketches.updateSketchBuilder().build();
inter1.intersect(sk); //initializes to a true empty intersection.
final byte[] byteArray = inter1.toByteArray();
- final WritableMemory mem = WritableMemory.wrap(byteArray);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArray);
//corrupt:
mem.putInt(RETAINED_ENTRIES_INT, 1);
SetOperation.heapify(mem);
diff --git a/src/test/java/org/apache/datasketches/theta/HeapQuickSelectSketchTest.java b/src/test/java/org/apache/datasketches/theta/HeapQuickSelectSketchTest.java
index 7001649..155cb12 100644
--- a/src/test/java/org/apache/datasketches/theta/HeapQuickSelectSketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/HeapQuickSelectSketchTest.java
@@ -73,7 +73,7 @@
assertEquals(sk1.getRetainedEntries(false), u);
byte[] byteArray = usk.toByteArray();
- WritableMemory mem = WritableMemory.wrap(byteArray);
+ WritableMemory mem = WritableMemory.writableWrap(byteArray);
mem.putByte(SER_VER_BYTE, (byte) 0); //corrupt the SerVer byte
Sketch.heapify(mem, seed);
@@ -96,7 +96,7 @@
assertEquals(usk.getEstimate(), u, 0.0);
assertEquals(sk1.getRetainedEntries(false), u);
byte[] byteArray = usk.toByteArray();
- WritableMemory mem = WritableMemory.wrap(byteArray);
+ WritableMemory mem = WritableMemory.writableWrap(byteArray);
mem.putByte(FAMILY_BYTE, (byte) 0); //corrupt the Sketch ID byte
//try to heapify the corruped mem
@@ -117,7 +117,7 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkHeapifyCorruptLgNomLongs() {
UpdateSketch usk = UpdateSketch.builder().setNominalEntries(16).build();
- WritableMemory srcMem = WritableMemory.wrap(usk.toByteArray());
+ WritableMemory srcMem = WritableMemory.writableWrap(usk.toByteArray());
srcMem.putByte(LG_NOM_LONGS_BYTE, (byte)2); //corrupt
Sketch.heapify(srcMem, DEFAULT_UPDATE_SEED);
}
@@ -264,7 +264,7 @@
assertEquals(comp2.getClass().getSimpleName(), "HeapCompactSketch");
byte[] memArr2 = new byte[uskCompBytes];
- WritableMemory mem2 = WritableMemory.wrap(memArr2); //allocate mem for compact form
+ WritableMemory mem2 = WritableMemory.writableWrap(memArr2); //allocate mem for compact form
comp3 = usk.compact(false, mem2); //load the mem2
@@ -310,7 +310,7 @@
assertEquals(usk.isEstimationMode(), estimating);
byte[] arr2 = new byte[compBytes];
- WritableMemory mem2 = WritableMemory.wrap(arr2);
+ WritableMemory mem2 = WritableMemory.writableWrap(arr2);
CompactSketch csk2 = usk.compact(false, mem2);
assertEquals(csk2.getEstimate(), uskEst);
@@ -558,7 +558,7 @@
UpdateSketch s1 = Sketches.updateSketchBuilder().setNominalEntries(k).build();
for (int i = 0; i < k; i++) { s1.update(i); }
byte[] badArray = s1.toByteArray();
- WritableMemory mem = WritableMemory.wrap(badArray);
+ WritableMemory mem = WritableMemory.writableWrap(badArray);
PreambleUtil.insertLgArrLongs(mem, 4);
PreambleUtil.insertThetaLong(mem, Long.MAX_VALUE / 2);
Sketch.heapify(mem);
@@ -576,7 +576,7 @@
UpdateSketch sk1 = UpdateSketch.builder().setFamily(QUICKSELECT).setNominalEntries(k).build();
sk1.update(1L); //forces preLongs to 3
byte[] bytearray1 = sk1.toByteArray();
- WritableMemory mem = WritableMemory.wrap(bytearray1);
+ WritableMemory mem = WritableMemory.writableWrap(bytearray1);
long pre0 = mem.getLong(0);
tryBadMem(mem, PREAMBLE_LONGS_BYTE, 2); //Corrupt PreLongs
@@ -604,7 +604,7 @@
}
mem.putLong(THETA_LONG, origThetaLong); //restore theta
byte[] byteArray2 = new byte[bytearray1.length -1];
- WritableMemory mem2 = WritableMemory.wrap(byteArray2);
+ WritableMemory mem2 = WritableMemory.writableWrap(byteArray2);
mem.copyTo(0, mem2, 0, mem2.getCapacity());
try {
HeapQuickSelectSketch.heapifyInstance(mem2, DEFAULT_UPDATE_SEED);
diff --git a/src/test/java/org/apache/datasketches/theta/HeapUnionTest.java b/src/test/java/org/apache/datasketches/theta/HeapUnionTest.java
index 6c1240a..7aead0e 100644
--- a/src/test/java/org/apache/datasketches/theta/HeapUnionTest.java
+++ b/src/test/java/org/apache/datasketches/theta/HeapUnionTest.java
@@ -229,7 +229,7 @@
usk2.update(i); //2k no overlap, exact, will force early stop
}
- final WritableMemory cskMem2 = WritableMemory.wrap(new byte[usk2.getCompactBytes()]);
+ final WritableMemory cskMem2 = WritableMemory.writableWrap(new byte[usk2.getCompactBytes()]);
final CompactSketch cosk2 = usk2.compact(true, cskMem2); //ordered, loads the cskMem2 as ordered
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion();
@@ -268,7 +268,7 @@
usk2.update(i); //2k no overlap, exact, will force early stop
}
- final WritableMemory cskMem2 = WritableMemory.wrap(new byte[usk2.getCompactBytes()]);
+ final WritableMemory cskMem2 = WritableMemory.writableWrap(new byte[usk2.getCompactBytes()]);
usk2.compact(true, cskMem2); //ordered, loads the cskMem2 as ordered
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion();
@@ -307,7 +307,7 @@
usk2.update(i); //2k no overlap, exact, will force early stop
}
- final WritableMemory cskMem2 = WritableMemory.wrap(new byte[usk2.getCompactBytes()]);
+ final WritableMemory cskMem2 = WritableMemory.writableWrap(new byte[usk2.getCompactBytes()]);
usk2.compact(false, cskMem2); //unordered, loads the cskMem2 as unordered
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion();
@@ -390,8 +390,8 @@
usk2.update(i); //2*k + 1024 no overlap
}
- final WritableMemory skMem1 = WritableMemory.wrap(usk1.compact(false, null).toByteArray());
- final WritableMemory skMem2 = WritableMemory.wrap(usk2.compact(true, null).toByteArray());
+ final WritableMemory skMem1 = WritableMemory.writableWrap(usk1.compact(false, null).toByteArray());
+ final WritableMemory skMem2 = WritableMemory.writableWrap(usk2.compact(true, null).toByteArray());
final CompactSketch csk1 = (CompactSketch)Sketch.wrap(skMem1);
final CompactSketch csk2 = (CompactSketch)Sketch.wrap(skMem2);
@@ -472,7 +472,7 @@
final UpdateSketch usk1 = UpdateSketch.builder().setNominalEntries(k).build();
final CompactSketch usk1c = usk1.compact(true, null);
- WritableMemory v3mem1 = WritableMemory.wrap(usk1c.toByteArray());
+ WritableMemory v3mem1 = WritableMemory.writableWrap(usk1c.toByteArray());
final Memory v1mem1 = convertSerVer3toSerVer1(usk1.compact(true, null));
@@ -512,7 +512,7 @@
usk1.update(i); //force prelongs to 3
}
final CompactSketch usk1c = usk1.compact(true, null);
- final WritableMemory v3mem1 = WritableMemory.wrap(usk1c.toByteArray());
+ final WritableMemory v3mem1 = WritableMemory.writableWrap(usk1c.toByteArray());
//println(PreambleUtil.toString(v3mem1));
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion();
union.union(v3mem1);
@@ -526,7 +526,7 @@
usk1.update(1);
usk1.update(2);
final CompactSketch usk1c = usk1.compact(true, null);
- final WritableMemory v3mem1 = WritableMemory.wrap(usk1c.toByteArray());
+ final WritableMemory v3mem1 = WritableMemory.writableWrap(usk1c.toByteArray());
//corrupt SerVer
v3mem1.putByte(SER_VER_BYTE, (byte)0);
@@ -540,13 +540,13 @@
final CompactSketch usk1c = usk1.compact(true, null);
final byte[] skArr = usk1c.toByteArray();
final byte[] skArr2 = Arrays.copyOf(skArr, skArr.length * 2);
- final WritableMemory v3mem1 = WritableMemory.wrap(skArr2);
+ final WritableMemory v3mem1 = WritableMemory.writableWrap(skArr2);
Union union = SetOperation.builder().buildUnion();
union.union(v3mem1);
final Memory v2mem1 = convertSerVer3toSerVer2(usk1c, Util.DEFAULT_UPDATE_SEED);
- final WritableMemory v2mem2 = WritableMemory.wrap(new byte[16]);
+ final WritableMemory v2mem2 = WritableMemory.writableWrap(new byte[16]);
v2mem1.copyTo(0, v2mem2, 0, 8);
union = SetOperation.builder().buildUnion();
@@ -625,7 +625,7 @@
compEst2 = comp2.getEstimate();
assertEquals(compEst2, compEst1, 0.0);
- final WritableMemory mem = WritableMemory.wrap(new byte[comp2.getCurrentBytes()]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[comp2.getCurrentBytes()]);
compEst2 = union.getResult(false, mem).getEstimate(); //not ordered, mem
assertEquals(compEst2, compEst1, 0.0);
diff --git a/src/test/java/org/apache/datasketches/theta/PreambleUtilTest.java b/src/test/java/org/apache/datasketches/theta/PreambleUtilTest.java
index 5088510..38bcc16 100644
--- a/src/test/java/org/apache/datasketches/theta/PreambleUtilTest.java
+++ b/src/test/java/org/apache/datasketches/theta/PreambleUtilTest.java
@@ -74,7 +74,7 @@
final int u = 2*k;
final int bytes = (k << 4) + (Family.QUICKSELECT.getMinPreLongs() << 3);
final byte[] byteArray = new byte[bytes];
- final WritableMemory mem = WritableMemory.wrap(byteArray);
+ final WritableMemory mem = WritableMemory.writableWrap(byteArray);
final UpdateSketch quick1 = UpdateSketch.builder().setNominalEntries(k).build(mem);
println(Sketch.toString(byteArray));
@@ -91,7 +91,7 @@
println(quick1.toString());
println(PreambleUtil.preambleToString(mem));
- final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+ final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
union.union(quick1);
println(PreambleUtil.preambleToString(uMem));
@@ -157,7 +157,7 @@
@Test
public void checkInsertsAndExtracts() {
final byte[] arr = new byte[32];
- final WritableMemory wmem = WritableMemory.wrap(arr);
+ final WritableMemory wmem = WritableMemory.writableWrap(arr);
int v = 0;
insertPreLongs(wmem, ++v);
diff --git a/src/test/java/org/apache/datasketches/theta/SetOperationTest.java b/src/test/java/org/apache/datasketches/theta/SetOperationTest.java
index 179a0c2..af5fcfb 100644
--- a/src/test/java/org/apache/datasketches/theta/SetOperationTest.java
+++ b/src/test/java/org/apache/datasketches/theta/SetOperationTest.java
@@ -133,7 +133,7 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkBuilderAnotB_noMem() {
- final WritableMemory mem = WritableMemory.wrap(new byte[64]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[64]);
SetOperation.builder().build(Family.A_NOT_B, mem);
}
@@ -198,7 +198,7 @@
for (int i=0; i<k; i++) {
usk1.update(i); //64
}
- final WritableMemory wmem = WritableMemory.wrap(usk1.toByteArray());
+ final WritableMemory wmem = WritableMemory.writableWrap(usk1.toByteArray());
PreambleUtil.insertSerVer(wmem, 2); //corrupt
final Memory mem = wmem;
SetOperation.wrap(mem);
@@ -211,7 +211,7 @@
for (int i=0; i<k; i++) {
usk1.update(i); //64
}
- final WritableMemory wmem = WritableMemory.wrap(usk1.toByteArray());
+ final WritableMemory wmem = WritableMemory.writableWrap(usk1.toByteArray());
SetOperation.wrap(wmem);
}
@@ -260,7 +260,7 @@
// However, if you had created this WM object directly in raw, off-heap "native" memory
// you would have the responsibility to close it when you are done.
// But, since it was allocated via BB, it closes it for you.
- final WritableMemory heapMem = WritableMemory.wrap(heapBuf);
+ final WritableMemory heapMem = WritableMemory.writableWrap(heapBuf);
double result = directUnionTrial1(heapMem, heapLayout, sketchNomEntries, unionNomEntries);
println("1st est: "+result);
@@ -318,7 +318,7 @@
@Test
public void checkIsSameResource() {
final int k = 16;
- final WritableMemory wmem = WritableMemory.wrap(new byte[k*16 + 32]);
+ final WritableMemory wmem = WritableMemory.writableWrap(new byte[k*16 + 32]);
final Memory roCompactMem = Memory.wrap(new byte[8]);
final Union union = Sketches.setOperationBuilder().setNominalEntries(k).buildUnion(wmem);
assertTrue(union.isSameResource(wmem));
diff --git a/src/test/java/org/apache/datasketches/theta/SetOpsCornerCasesTest.java b/src/test/java/org/apache/datasketches/theta/SetOpsCornerCasesTest.java
index 51a60d7..1365160 100644
--- a/src/test/java/org/apache/datasketches/theta/SetOpsCornerCasesTest.java
+++ b/src/test/java/org/apache/datasketches/theta/SetOpsCornerCasesTest.java
@@ -482,7 +482,7 @@
}
int bytes = Sketch.getMaxCompactSketchBytes(sk.getRetainedEntries(true));
byte[] byteArr = new byte[bytes];
- WritableMemory mem = WritableMemory.wrap(byteArr);
+ WritableMemory mem = WritableMemory.writableWrap(byteArr);
csk = sk.compact(false, mem);
break;
}
diff --git a/src/test/java/org/apache/datasketches/theta/SingleItemSketchTest.java b/src/test/java/org/apache/datasketches/theta/SingleItemSketchTest.java
index ba3c298..bb50617 100644
--- a/src/test/java/org/apache/datasketches/theta/SingleItemSketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/SingleItemSketchTest.java
@@ -194,7 +194,7 @@
//Off-heap
bytes = Sketches.getMaxUpdateSketchBytes(32);
- WritableMemory wmem = WritableMemory.wrap(new byte[bytes]);
+ WritableMemory wmem = WritableMemory.writableWrap(new byte[bytes]);
sk1= Sketches.updateSketchBuilder().setNominalEntries(32).build(wmem);
sk1.update(1);
csk = sk1.compact(true, null);
@@ -203,7 +203,7 @@
assertTrue(csk instanceof SingleItemSketch);
bytes = Sketches.getMaxCompactSketchBytes(1);
- wmem = WritableMemory.wrap(new byte[bytes]);
+ wmem = WritableMemory.writableWrap(new byte[bytes]);
csk = sk1.compact(true, wmem);
assertTrue(csk.isOrdered());
csk = sk1.compact(false, wmem);
@@ -229,7 +229,7 @@
//Intersection off-heap
bytes = Sketches.getMaxIntersectionBytes(32);
- WritableMemory wmem = WritableMemory.wrap(new byte[bytes]);
+ WritableMemory wmem = WritableMemory.writableWrap(new byte[bytes]);
inter = Sketches.setOperationBuilder().buildIntersection(wmem);
inter.intersect(sk1);
inter.intersect(sk2);
@@ -257,7 +257,7 @@
//Union off-heap
bytes = Sketches.getMaxUnionBytes(32);
- WritableMemory wmem = WritableMemory.wrap(new byte[bytes]);
+ WritableMemory wmem = WritableMemory.writableWrap(new byte[bytes]);
union = Sketches.setOperationBuilder().buildUnion(wmem);
union.update(sk1);
union.update(sk2);
@@ -292,7 +292,7 @@
Intersection inter = Sketches.setOperationBuilder().buildIntersection();
inter.intersect(sk1);
inter.intersect(sk2);
- WritableMemory wmem = WritableMemory.wrap(new byte[16]);
+ WritableMemory wmem = WritableMemory.writableWrap(new byte[16]);
CompactSketch csk = inter.getResult(false, wmem);
assertTrue(csk.isOrdered());
Sketch csk2 = Sketches.heapifySketch(wmem);
diff --git a/src/test/java/org/apache/datasketches/theta/SketchTest.java b/src/test/java/org/apache/datasketches/theta/SketchTest.java
index 18c7ed7..9317767 100644
--- a/src/test/java/org/apache/datasketches/theta/SketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/SketchTest.java
@@ -200,7 +200,7 @@
Memory mem = Memory.wrap(sketchArray);
int serVer = Sketch.getSerializationVersion(mem);
assertEquals(serVer, 3);
- WritableMemory wmem = WritableMemory.wrap(sketchArray);
+ WritableMemory wmem = WritableMemory.writableWrap(sketchArray);
UpdateSketch sk2 = UpdateSketch.wrap(wmem);
serVer = sk2.getSerializationVersion(wmem);
assertEquals(serVer, 3);
@@ -211,7 +211,7 @@
int k = 512;
Sketch sketch1 = UpdateSketch.builder().setFamily(ALPHA).setNominalEntries(k).build();
byte[] byteArray = sketch1.toByteArray();
- WritableMemory mem = WritableMemory.wrap(byteArray);
+ WritableMemory mem = WritableMemory.writableWrap(byteArray);
//corrupt:
mem.setBits(FLAGS_BYTE, (byte) COMPACT_FLAG_MASK);
Sketch.heapify(mem);
@@ -222,7 +222,7 @@
int k = 512;
Sketch sketch1 = UpdateSketch.builder().setFamily(QUICKSELECT).setNominalEntries(k).build();
byte[] byteArray = sketch1.toByteArray();
- WritableMemory mem = WritableMemory.wrap(byteArray);
+ WritableMemory mem = WritableMemory.writableWrap(byteArray);
//corrupt:
mem.setBits(FLAGS_BYTE, (byte) COMPACT_FLAG_MASK);
Sketch.heapify(mem);
@@ -234,7 +234,7 @@
UpdateSketch sketch1 = UpdateSketch.builder().setFamily(QUICKSELECT).setNominalEntries(k).build();
int bytes = Sketch.getMaxCompactSketchBytes(0);
byte[] byteArray = new byte[bytes];
- WritableMemory mem = WritableMemory.wrap(byteArray);
+ WritableMemory mem = WritableMemory.writableWrap(byteArray);
sketch1.compact(false, mem);
//corrupt:
mem.clearBits(FLAGS_BYTE, (byte) COMPACT_FLAG_MASK);
@@ -256,7 +256,7 @@
int k = 512;
Sketch sketch1 = UpdateSketch.builder().setFamily(ALPHA).setNominalEntries(k).build();
byte[] byteArray = sketch1.toByteArray();
- WritableMemory mem = WritableMemory.wrap(byteArray);
+ WritableMemory mem = WritableMemory.writableWrap(byteArray);
//corrupt:
mem.setBits(FLAGS_BYTE, (byte) COMPACT_FLAG_MASK);
Sketch.wrap(mem);
@@ -268,7 +268,7 @@
int k = 512;
Sketch sketch1 = UpdateSketch.builder().setFamily(QUICKSELECT).setNominalEntries(k).build();
byte[] byteArray = sketch1.toByteArray();
- WritableMemory mem = WritableMemory.wrap(byteArray);
+ WritableMemory mem = WritableMemory.writableWrap(byteArray);
//corrupt:
mem.setBits(FLAGS_BYTE, (byte) COMPACT_FLAG_MASK);
Sketch.wrap(mem);
@@ -280,7 +280,7 @@
UpdateSketch sketch1 = UpdateSketch.builder().setFamily(QUICKSELECT).setNominalEntries(k).build();
int bytes = Sketch.getMaxCompactSketchBytes(0);
byte[] byteArray = new byte[bytes];
- WritableMemory mem = WritableMemory.wrap(byteArray);
+ WritableMemory mem = WritableMemory.writableWrap(byteArray);
sketch1.compact(false, mem);
//corrupt:
mem.clearBits(FLAGS_BYTE, (byte) COMPACT_FLAG_MASK);
@@ -322,8 +322,8 @@
@Test
public void checkIsSameResource() {
int k = 16;
- WritableMemory mem = WritableMemory.wrap(new byte[(k*16) + 24]);
- WritableMemory cmem = WritableMemory.wrap(new byte[32]);
+ WritableMemory mem = WritableMemory.writableWrap(new byte[(k*16) + 24]);
+ WritableMemory cmem = WritableMemory.writableWrap(new byte[32]);
UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build(mem);
sketch.update(1);
sketch.update(2);
diff --git a/src/test/java/org/apache/datasketches/theta/SketchesTest.java b/src/test/java/org/apache/datasketches/theta/SketchesTest.java
index 6a92ec0..a498459 100644
--- a/src/test/java/org/apache/datasketches/theta/SketchesTest.java
+++ b/src/test/java/org/apache/datasketches/theta/SketchesTest.java
@@ -107,7 +107,7 @@
assertEquals((int)cSk.getEstimate(), 3*k/2);
final byte[] ubytes = union.toByteArray();
- final WritableMemory uMem = WritableMemory.wrap(ubytes);
+ final WritableMemory uMem = WritableMemory.writableWrap(ubytes);
Union union2 = (Union)heapifySetOperation(uMem);
cSk = union2.getResult(true, null);
diff --git a/src/test/java/org/apache/datasketches/theta/UnionImplTest.java b/src/test/java/org/apache/datasketches/theta/UnionImplTest.java
index 8c87d8e..b9db91f 100644
--- a/src/test/java/org/apache/datasketches/theta/UnionImplTest.java
+++ b/src/test/java/org/apache/datasketches/theta/UnionImplTest.java
@@ -39,8 +39,8 @@
@Test
public void checkUpdateWithSketch() {
final int k = 16;
- final WritableMemory mem = WritableMemory.wrap(new byte[k*8 + 24]);
- final WritableMemory mem2 = WritableMemory.wrap(new byte[k*8 + 24]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[k*8 + 24]);
+ final WritableMemory mem2 = WritableMemory.writableWrap(new byte[k*8 + 24]);
final UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build();
for (int i=0; i<k; i++) { sketch.update(i); }
final CompactSketch sketchInDirectOrd = sketch.compact(true, mem);
@@ -57,7 +57,7 @@
@Test
public void checkUnorderedAndOrderedMemory() {
final int k = 16;
- final WritableMemory mem = WritableMemory.wrap(new byte[k*8 + 24]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[k*8 + 24]);
final UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build();
for (int i = 0; i < k; i++) { sketch.update(i); }
final CompactSketch sketchInDirectOrd = sketch.compact(false, mem);
@@ -76,9 +76,9 @@
@Test
public void checkUpdateWithMem() {
final int k = 16;
- final WritableMemory skMem = WritableMemory.wrap(new byte[2*k*8 + 24]);
- final WritableMemory dirOrdCskMem = WritableMemory.wrap(new byte[k*8 + 24]);
- final WritableMemory dirUnordCskMem = WritableMemory.wrap(new byte[k*8 + 24]);
+ final WritableMemory skMem = WritableMemory.writableWrap(new byte[2*k*8 + 24]);
+ final WritableMemory dirOrdCskMem = WritableMemory.writableWrap(new byte[k*8 + 24]);
+ final WritableMemory dirUnordCskMem = WritableMemory.writableWrap(new byte[k*8 + 24]);
final UpdateSketch udSketch = UpdateSketch.builder().setNominalEntries(k).build(skMem);
for (int i = 0; i < k; i++) { udSketch.update(i); } //exact
udSketch.compact(true, dirOrdCskMem);
@@ -96,7 +96,7 @@
final int k = 16;
final long seed = DEFAULT_UPDATE_SEED;
final int unionSize = Sketches.getMaxUnionBytes(k);
- final WritableMemory srcMem = WritableMemory.wrap(new byte[unionSize]);
+ final WritableMemory srcMem = WritableMemory.writableWrap(new byte[unionSize]);
final Union union = Sketches.setOperationBuilder().setNominalEntries(k).buildUnion(srcMem);
for (int i = 0; i < k; i++) { union.update(i); } //exact
assertEquals(union.getResult().getEstimate(), k, 0.0);
@@ -110,7 +110,7 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void checkCorruptFamilyException() {
final int k = 16;
- final WritableMemory mem = WritableMemory.wrap(new byte[k*8 + 24]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[k*8 + 24]);
final UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build();
for (int i=0; i<k; i++) {
sketch.update(i);
@@ -171,11 +171,11 @@
final int bytes = Sketches.getMaxUpdateSketchBytes(k);
try (WritableDirectHandle wdh = WritableMemory.allocateDirect(bytes/2);
WritableDirectHandle wdh2 = WritableMemory.allocateDirect(bytes/2) ) {
- final WritableMemory wmem = wdh.get();
+ final WritableMemory wmem = wdh.getWritable();
final UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build(wmem);
assertTrue(sketch.isSameResource(wmem));
- final WritableMemory wmem2 = wdh2.get();
+ final WritableMemory wmem2 = wdh2.getWritable();
final Union union = SetOperation.builder().buildUnion(wmem2);
assertTrue(union.isSameResource(wmem2));
@@ -184,6 +184,8 @@
final Union union2 = SetOperation.builder().buildUnion(); //on-heap union
assertFalse(union2.isSameResource(wmem2)); //obviously not
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
@@ -206,12 +208,14 @@
final int bytes = Sketches.getMaxCompactSketchBytes(sk.getRetainedEntries(true));
try (WritableDirectHandle h = WritableMemory.allocateDirect(bytes)) {
- final WritableMemory wmem = h.get();
+ final WritableMemory wmem = h.getWritable();
final CompactSketch csk = sk.compact(true, wmem); //ordered, direct
final Union union = Sketches.setOperationBuilder().buildUnion();
union.union(csk);
final double est2 = union.getResult().getEstimate();
assertEquals(est2, est1);
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
}
}
diff --git a/src/test/java/org/apache/datasketches/theta/UpdateSketchTest.java b/src/test/java/org/apache/datasketches/theta/UpdateSketchTest.java
index 8ee0f2a..115b9ee 100644
--- a/src/test/java/org/apache/datasketches/theta/UpdateSketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/UpdateSketchTest.java
@@ -158,7 +158,7 @@
public void checkIncompatibleFamily() {
UpdateSketch sk = Sketches.updateSketchBuilder().build();
sk.update(1);
- WritableMemory wmem = WritableMemory.wrap(sk.compact().toByteArray());
+ WritableMemory wmem = WritableMemory.writableWrap(sk.compact().toByteArray());
UpdateSketch.wrap(wmem, DEFAULT_UPDATE_SEED);
}
@@ -166,7 +166,7 @@
public void checkCorruption() {
UpdateSketch sk = Sketches.updateSketchBuilder().build();
sk.update(1);
- WritableMemory wmem = WritableMemory.wrap(sk.toByteArray());
+ WritableMemory wmem = WritableMemory.writableWrap(sk.toByteArray());
try {
wmem.putByte(SER_VER_BYTE, (byte) 2);
UpdateSketch.wrap(wmem, DEFAULT_UPDATE_SEED);
@@ -212,7 +212,7 @@
for (int i = 2; i < n; i++) { sk.update(i); }
int cbytes = sk.getCompactBytes();
byte[] byteArr = sk.toByteArray();
- skwmem = WritableMemory.wrap(byteArr);
+ skwmem = WritableMemory.writableWrap(byteArr);
cskwmem1 = WritableMemory.allocate(cbytes);
cskwmem2 = WritableMemory.allocate(cbytes);
cskwmem3 = WritableMemory.allocate(cbytes);
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesAnotBTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesAnotBTest.java
index a0d2a4f..6d993ad 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesAnotBTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesAnotBTest.java
@@ -243,7 +243,7 @@
// same operation, but compact sketches and off-heap result
aNotB.update(sketchA.compact(), sketchB.compact());
- result = aNotB.getResult(WritableMemory.wrap(new byte[1000000]));
+ result = aNotB.getResult(WritableMemory.writableWrap(new byte[1000000]));
Assert.assertFalse(result.isEmpty());
Assert.assertEquals(result.getEstimate(), 4096.0, 4096 * 0.03); // crude estimate of RSE(95%) = 2 / sqrt(result.getRetainedEntries())
Assert.assertTrue(result.getLowerBound(1) <= result.getEstimate());
@@ -283,7 +283,7 @@
// same operation, but compact sketches and off-heap result
aNotB.update(sketchA.compact(), sketchB.compact());
- result = aNotB.getResult(WritableMemory.wrap(new byte[1000000]));
+ result = aNotB.getResult(WritableMemory.writableWrap(new byte[1000000]));
Assert.assertFalse(result.isEmpty());
Assert.assertEquals(result.getEstimate(), expected, expected * 0.1); // crude estimate of RSE(95%) = 2 / sqrt(result.getRetainedEntries())
Assert.assertTrue(result.getLowerBound(1) <= result.getEstimate());
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesCompactSketchTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesCompactSketchTest.java
index b7287e0..a2e1c56 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesCompactSketchTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesCompactSketchTest.java
@@ -56,7 +56,8 @@
@Test
public void directToHeapExactTwoDoubles() {
- ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().setNumberOfValues(2).build(WritableMemory.wrap(new byte[1000000]));
+ ArrayOfDoublesUpdatableSketch sketch1 =
+ new ArrayOfDoublesUpdatableSketchBuilder().setNumberOfValues(2).build(WritableMemory.writableWrap(new byte[1000000]));
sketch1.update("a", new double[] {1, 2});
sketch1.update("b", new double[] {1, 2});
sketch1.update("c", new double[] {1, 2});
@@ -65,7 +66,8 @@
sketch1.update("b", new double[] {1, 2});
sketch1.update("c", new double[] {1, 2});
sketch1.update("d", new double[] {1, 2});
- ArrayOfDoublesSketch sketch2 = new HeapArrayOfDoublesCompactSketch(Memory.wrap(sketch1.compact(WritableMemory.wrap(new byte[1000000])).toByteArray()));
+ ArrayOfDoublesSketch sketch2 =
+ new HeapArrayOfDoublesCompactSketch(Memory.wrap(sketch1.compact(WritableMemory.writableWrap(new byte[1000000])).toByteArray()));
Assert.assertFalse(sketch2.isEmpty());
Assert.assertFalse(sketch2.isEstimationMode());
Assert.assertEquals(sketch2.getEstimate(), 4.0);
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesIntersectionTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesIntersectionTest.java
index 802ee7d..be48409 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesIntersectionTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesIntersectionTest.java
@@ -103,19 +103,19 @@
@Test
public void directExactWithEmpty() {
final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder()
- .build(WritableMemory.wrap(new byte[1000000]));
+ .build(WritableMemory.writableWrap(new byte[1000000]));
sketch1.update(1, new double[] {1});
sketch1.update(2, new double[] {1});
sketch1.update(3, new double[] {1});
final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder()
- .build(WritableMemory.wrap(new byte[1000000]));
+ .build(WritableMemory.writableWrap(new byte[1000000]));
final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().
- buildIntersection(WritableMemory.wrap(new byte[1000000]));
+ buildIntersection(WritableMemory.writableWrap(new byte[1000000]));
intersection.intersect(sketch1, null);
intersection.intersect(sketch2, null);
- final ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.writableWrap(new byte[1000000]));
Assert.assertTrue(result.isEmpty());
Assert.assertEquals(result.getRetainedEntries(), 0);
Assert.assertEquals(result.getEstimate(), 0.0);
@@ -190,22 +190,22 @@
public void directDisjointEstimationMode() {
int key = 0;
final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().
- build(WritableMemory.wrap(new byte[1000000]));
+ build(WritableMemory.writableWrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, new double[] {1.0});
}
final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().
- build(WritableMemory.wrap(new byte[1000000]));
+ build(WritableMemory.writableWrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, new double[] {1.0});
}
final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().
- buildIntersection(WritableMemory.wrap(new byte[1000000]));
+ buildIntersection(WritableMemory.writableWrap(new byte[1000000]));
intersection.intersect(sketch1, combiner);
intersection.intersect(sketch2, combiner);
- final ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.writableWrap(new byte[1000000]));
Assert.assertTrue(result.isEmpty());
Assert.assertEquals(result.getRetainedEntries(), 0);
Assert.assertEquals(result.getEstimate(), 0.0);
@@ -245,21 +245,21 @@
@Test
public void directEstimationMode() {
int key = 0;
- final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, new double[] {1.0});
}
key -= 4096; // overlap half of the entries
- final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, new double[] {1.0});
}
- final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection(WritableMemory.writableWrap(new byte[1000000]));
intersection.intersect(sketch1, combiner);
intersection.intersect(sketch2, combiner);
- final ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.writableWrap(new byte[1000000]));
Assert.assertFalse(result.isEmpty());
Assert.assertEquals(result.getEstimate(), 4096.0, 4096 * 0.03); // crude estimate of RSE(95%) = 2 / sqrt(result.getRetainedEntries())
Assert.assertTrue(result.getLowerBound(1) <= result.getEstimate());
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesQuickSelectSketchTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesQuickSelectSketchTest.java
index 84c4d33..d02687b 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesQuickSelectSketchTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesQuickSelectSketchTest.java
@@ -44,7 +44,7 @@
sketch1.update("d", valuesArr);
sketch1.update("a", valuesArr);
noopUpdates(sketch1, valuesArr);
- ArrayOfDoublesUpdatableSketch sketch2 = ArrayOfDoublesUpdatableSketch.wrap(WritableMemory.wrap(sketch1.toByteArray()));
+ ArrayOfDoublesUpdatableSketch sketch2 = ArrayOfDoublesUpdatableSketch.wrap(WritableMemory.writableWrap(sketch1.toByteArray()));
sketch2.update("b", valuesArr);
sketch2.update("c", valuesArr);
sketch2.update("d", valuesArr);
@@ -75,7 +75,7 @@
sketch1.update("b", values);
sketch1.update("c", values);
- ArrayOfDoublesUpdatableSketch sketch2 = ArrayOfDoublesUpdatableSketch.wrap(WritableMemory.wrap(sketch1.toByteArray()), seed);
+ ArrayOfDoublesUpdatableSketch sketch2 = ArrayOfDoublesUpdatableSketch.wrap(WritableMemory.writableWrap(sketch1.toByteArray()), seed);
sketch2.update("b", values);
sketch2.update("c", values);
sketch2.update("d", values);
@@ -95,7 +95,7 @@
double[] valuesArr = {1.0, 2.0};
ArrayOfDoublesUpdatableSketch sketch1 =
new ArrayOfDoublesUpdatableSketchBuilder().
- setNumberOfValues(2).build(WritableMemory.wrap(new byte[1000000]));
+ setNumberOfValues(2).build(WritableMemory.writableWrap(new byte[1000000]));
sketch1.update("a", valuesArr);
sketch1.update("b", valuesArr);
sketch1.update("c", valuesArr);
@@ -129,7 +129,7 @@
ArrayOfDoublesUpdatableSketch sketch1 =
new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed).build(
- WritableMemory.wrap(new byte[1000000]));
+ WritableMemory.writableWrap(new byte[1000000]));
sketch1.update("a", values);
sketch1.update("b", values);
sketch1.update("c", values);
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnionTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnionTest.java
index 29a2096..0da4c0f 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnionTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnionTest.java
@@ -61,7 +61,7 @@
Assert.assertEquals(values[1][0], 3.0);
Assert.assertEquals(values[2][0], 3.0);
- final WritableMemory wmem = WritableMemory.wrap(union.toByteArray());
+ final WritableMemory wmem = WritableMemory.writableWrap(union.toByteArray());
final ArrayOfDoublesUnion wrappedUnion = ArrayOfDoublesSketches.wrapUnion(wmem);
result = wrappedUnion.getResult();
Assert.assertEquals(result.getEstimate(), 3.0);
@@ -211,7 +211,7 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void noSupportWrapV0_9_1() throws Exception {
final byte[] bytes = getResourceBytes("ArrayOfDoublesUnion_v0.9.1.sk");
- ArrayOfDoublesUnion.wrap(WritableMemory.wrap(bytes));
+ ArrayOfDoublesUnion.wrap(WritableMemory.writableWrap(bytes));
}
@Test
@@ -242,25 +242,25 @@
public void directSerializeDeserialize() {
int key = 0;
final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(
- WritableMemory.wrap(new byte[1000000]));
+ WritableMemory.writableWrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, new double[] {1.0});
}
key -= 4096; // overlap half of the entries
final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(
- WritableMemory.wrap(new byte[1000000]));
+ WritableMemory.writableWrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, new double[] {1.0});
}
final ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().buildUnion(
- WritableMemory.wrap(new byte[1000000]));
+ WritableMemory.writableWrap(new byte[1000000]));
union1.union(sketch1);
union1.union(sketch2);
- final ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.wrap(WritableMemory.wrap(union1.toByteArray()));
- ArrayOfDoublesCompactSketch result = union2.getResult(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.wrap(WritableMemory.writableWrap(union1.toByteArray()));
+ ArrayOfDoublesCompactSketch result = union2.getResult(WritableMemory.writableWrap(new byte[1000000]));
Assert.assertEquals(result.getEstimate(), 12288.0, 12288 * 0.01);
union2.reset();
@@ -282,47 +282,47 @@
final long seed = 1;
int key = 0;
final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed)
- .build(WritableMemory.wrap(new byte[1000000]));
+ .build(WritableMemory.writableWrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, new double[] {1.0});
}
key -= 4096; // overlap half of the entries
final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed)
- .build(WritableMemory.wrap(new byte[1000000]));
+ .build(WritableMemory.writableWrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, new double[] {1.0});
}
final ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().setSeed(seed)
- .buildUnion(WritableMemory.wrap(new byte[1000000]));
+ .buildUnion(WritableMemory.writableWrap(new byte[1000000]));
union1.union(sketch1);
union1.union(sketch2);
- final ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.wrap(WritableMemory.wrap(union1.toByteArray()), seed);
- final ArrayOfDoublesCompactSketch result = union2.getResult(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.wrap(WritableMemory.writableWrap(union1.toByteArray()), seed);
+ final ArrayOfDoublesCompactSketch result = union2.getResult(WritableMemory.writableWrap(new byte[1000000]));
Assert.assertEquals(result.getEstimate(), 12288.0, 12288 * 0.01);
}
@Test
public void directExactMode() {
- final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
sketch1.update(1, new double[] {1.0});
sketch1.update(1, new double[] {1.0});
sketch1.update(1, new double[] {1.0});
sketch1.update(2, new double[] {1.0});
- final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
sketch2.update(2, new double[] {1.0});
sketch2.update(2, new double[] {1.0});
sketch2.update(3, new double[] {1.0});
sketch2.update(3, new double[] {1.0});
sketch2.update(3, new double[] {1.0});
- final ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.writableWrap(new byte[1000000]));
union.union(sketch1);
union.union(sketch2);
- ArrayOfDoublesCompactSketch result = union.getResult(WritableMemory.wrap(new byte[1000000]));
+ ArrayOfDoublesCompactSketch result = union.getResult(WritableMemory.writableWrap(new byte[1000000]));
Assert.assertEquals(result.getEstimate(), 3.0);
final double[][] values = result.getValues();
Assert.assertEquals(values[0][0], 3.0);
@@ -342,21 +342,21 @@
@Test
public void directEstimationMode() {
int key = 0;
- final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch1.update(key++, new double[] {1.0});
}
key -= 4096; // overlap half of the entries
- final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
sketch2.update(key++, new double[] {1.0});
}
- final ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.writableWrap(new byte[1000000]));
union.union(sketch1);
union.union(sketch2);
- ArrayOfDoublesCompactSketch result = union.getResult(WritableMemory.wrap(new byte[1000000]));
+ ArrayOfDoublesCompactSketch result = union.getResult(WritableMemory.writableWrap(new byte[1000000]));
Assert.assertEquals(result.getEstimate(), 12288.0, 12288 * 0.01);
union.reset();
@@ -387,10 +387,10 @@
final ArrayOfDoublesUnion heapUnion = new ArrayOfDoublesSetOperationBuilder().buildUnion();
heapUnion.union(sketch1);
- final ArrayOfDoublesUnion directUnion = ArrayOfDoublesUnion.wrap(WritableMemory.wrap(heapUnion.toByteArray()));
+ final ArrayOfDoublesUnion directUnion = ArrayOfDoublesUnion.wrap(WritableMemory.writableWrap(heapUnion.toByteArray()));
directUnion.union(sketch2);
- final ArrayOfDoublesCompactSketch result = directUnion.getResult(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesCompactSketch result = directUnion.getResult(WritableMemory.writableWrap(new byte[1000000]));
Assert.assertFalse(result.isEmpty());
Assert.assertEquals(result.getEstimate(), 3.0);
final double[][] values = result.getValues();
@@ -415,7 +415,7 @@
sketch2.update(3, new double[] {1.0});
sketch2.update(3, new double[] {1.0});
- final ArrayOfDoublesUnion directUnion = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.wrap(new byte[1000000]));
+ final ArrayOfDoublesUnion directUnion = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.writableWrap(new byte[1000000]));
directUnion.union(sketch1);
final ArrayOfDoublesUnion heapUnion = ArrayOfDoublesUnion.heapify(Memory.wrap(directUnion.toByteArray()));
@@ -454,7 +454,7 @@
@Test
public void directDruidUsageOneSketch() {
- final WritableMemory mem = WritableMemory.wrap(new byte[1000000]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[1000000]);
new ArrayOfDoublesSetOperationBuilder().buildUnion(mem); // just set up memory to wrap later
final int n = 100000; // estimation mode
@@ -465,7 +465,7 @@
sketch.trim(); // pretend this is a result from a union
// as Druid wraps memory
- ArrayOfDoublesSketches.wrapUnion(mem).union(sketch.compact(WritableMemory.wrap(new byte[1000000])));
+ ArrayOfDoublesSketches.wrapUnion(mem).union(sketch.compact(WritableMemory.writableWrap(new byte[1000000])));
final ArrayOfDoublesSketch result = ArrayOfDoublesUnion.wrap(mem).getResult();
Assert.assertEquals(result.getEstimate(), sketch.getEstimate());
@@ -474,7 +474,7 @@
@Test
public void directDruidUsageTwoSketches() {
- final WritableMemory mem = WritableMemory.wrap(new byte[1000000]);
+ final WritableMemory mem = WritableMemory.writableWrap(new byte[1000000]);
new ArrayOfDoublesSetOperationBuilder().buildUnion(mem); // just set up memory to wrap later
int key = 0;
@@ -485,7 +485,7 @@
sketch1.update(key++, new double[] {1.0});
}
// as Druid wraps memory
- ArrayOfDoublesSketches.wrapUnion(mem).union(sketch1.compact(WritableMemory.wrap(new byte[1000000])));
+ ArrayOfDoublesSketches.wrapUnion(mem).union(sketch1.compact(WritableMemory.writableWrap(new byte[1000000])));
final int n2 = 1000000; // estimation mode
final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
@@ -493,7 +493,7 @@
sketch2.update(key++, new double[] {1.0});
}
// as Druid wraps memory
- ArrayOfDoublesSketches.wrapUnion(mem).union(sketch2.compact(WritableMemory.wrap(new byte[1000000])));
+ ArrayOfDoublesSketches.wrapUnion(mem).union(sketch2.compact(WritableMemory.writableWrap(new byte[1000000])));
// build one sketch that must be the same as union
key = 0; // reset to have the same keys
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesCompactSketchTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesCompactSketchTest.java
index dfedb38..5c7a8ab 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesCompactSketchTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesCompactSketchTest.java
@@ -33,8 +33,8 @@
@Test
public void emptyFromQuickSelectSketch() {
ArrayOfDoublesUpdatableSketch us =
- new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
- ArrayOfDoublesCompactSketch sketch = us.compact(WritableMemory.wrap(new byte[1000000]));
+ new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
+ ArrayOfDoublesCompactSketch sketch = us.compact(WritableMemory.writableWrap(new byte[1000000]));
Assert.assertTrue(sketch.isEmpty());
Assert.assertFalse(sketch.isEstimationMode());
Assert.assertEquals(sketch.getEstimate(), 0.0);
@@ -54,14 +54,14 @@
@Test
public void exactModeFromQuickSelectSketch() {
ArrayOfDoublesUpdatableSketch us =
- new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+ new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
us.update(1, new double[] {1.0});
us.update(2, new double[] {1.0});
us.update(3, new double[] {1.0});
us.update(1, new double[] {1.0});
us.update(2, new double[] {1.0});
us.update(3, new double[] {1.0});
- ArrayOfDoublesCompactSketch sketch = us.compact(WritableMemory.wrap(new byte[1000000]));
+ ArrayOfDoublesCompactSketch sketch = us.compact(WritableMemory.writableWrap(new byte[1000000]));
Assert.assertFalse(sketch.isEmpty());
Assert.assertFalse(sketch.isEstimationMode());
Assert.assertEquals(sketch.getEstimate(), 3.0);
@@ -80,12 +80,12 @@
@Test
public void serializeDeserializeSmallExact() {
- ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+ ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
us.update("a", new double[] {1.0});
us.update("b", new double[] {1.0});
us.update("c", new double[] {1.0});
- ArrayOfDoublesCompactSketch sketch1 = us.compact(WritableMemory.wrap(new byte[1000000]));
- ArrayOfDoublesSketch sketch2 = ArrayOfDoublesSketches.wrapSketch(WritableMemory.wrap(sketch1.toByteArray()));
+ ArrayOfDoublesCompactSketch sketch1 = us.compact(WritableMemory.writableWrap(new byte[1000000]));
+ ArrayOfDoublesSketch sketch2 = ArrayOfDoublesSketches.wrapSketch(WritableMemory.writableWrap(sketch1.toByteArray()));
Assert.assertFalse(sketch2.isEmpty());
Assert.assertFalse(sketch2.isEstimationMode());
Assert.assertEquals(sketch2.getEstimate(), 3.0);
@@ -103,12 +103,12 @@
@Test
public void serializeDeserializeEstimation() {
- ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+ ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
us.update(i, new double[] {1.0});
}
- ArrayOfDoublesCompactSketch sketch1 = us.compact(WritableMemory.wrap(new byte[1000000]));
- ArrayOfDoublesSketch sketch2 = ArrayOfDoublesSketches.wrapSketch(WritableMemory.wrap(sketch1.toByteArray()));
+ ArrayOfDoublesCompactSketch sketch1 = us.compact(WritableMemory.writableWrap(new byte[1000000]));
+ ArrayOfDoublesSketch sketch2 = ArrayOfDoublesSketches.wrapSketch(WritableMemory.writableWrap(sketch1.toByteArray()));
Assert.assertFalse(sketch2.isEmpty());
Assert.assertTrue(sketch2.isEstimationMode());
Assert.assertEquals(sketch2.getEstimate(), sketch1.getEstimate());
@@ -117,19 +117,19 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void deserializeWithWrongSeed() {
- ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+ ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
for (int i = 0; i < 8192; i++) {
us.update(i, new double[] {1.0});
}
- ArrayOfDoublesCompactSketch sketch1 = us.compact(WritableMemory.wrap(new byte[1000000]));
- ArrayOfDoublesSketches.wrapSketch(WritableMemory.wrap(sketch1.toByteArray()), 123);
+ ArrayOfDoublesCompactSketch sketch1 = us.compact(WritableMemory.writableWrap(new byte[1000000]));
+ ArrayOfDoublesSketches.wrapSketch(WritableMemory.writableWrap(sketch1.toByteArray()), 123);
}
@Test(expectedExceptions = SketchesArgumentException.class)
public void fromQuickSelectSketchNotEnoughMemory() {
- ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+ ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
us.update(1, new double[] {1.0});
- us.compact(WritableMemory.wrap(new byte[39]));
+ us.compact(WritableMemory.writableWrap(new byte[39]));
}
}
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesQuickSelectSketchTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesQuickSelectSketchTest.java
index 1846cc7..c77664c 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesQuickSelectSketchTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesQuickSelectSketchTest.java
@@ -31,7 +31,7 @@
public void isEmpty() {
final ArrayOfDoublesUpdatableSketch sketch =
new ArrayOfDoublesUpdatableSketchBuilder().
- build(WritableMemory.wrap(new byte[1000000]));
+ build(WritableMemory.writableWrap(new byte[1000000]));
Assert.assertTrue(sketch.isEmpty());
Assert.assertFalse(sketch.isEstimationMode());
Assert.assertEquals(sketch.getEstimate(), 0.0);
@@ -51,7 +51,7 @@
final ArrayOfDoublesUpdatableSketch sketch =
new ArrayOfDoublesUpdatableSketchBuilder().
setSamplingProbability(samplingProbability).
- build(WritableMemory.wrap(new byte[1000000]));
+ build(WritableMemory.writableWrap(new byte[1000000]));
Assert.assertTrue(sketch.isEmpty());
Assert.assertTrue(((DirectArrayOfDoublesQuickSelectSketch)sketch).isInSamplingMode());
Assert.assertFalse(sketch.isEstimationMode());
@@ -72,7 +72,7 @@
final ArrayOfDoublesUpdatableSketch sketch =
new ArrayOfDoublesUpdatableSketchBuilder().
setSamplingProbability(samplingProbability).
- build(WritableMemory.wrap(new byte[1000000]));
+ build(WritableMemory.writableWrap(new byte[1000000]));
sketch.update("a", new double[] {1.0});
Assert.assertFalse(sketch.isEmpty());
Assert.assertTrue(sketch.isEstimationMode());
@@ -88,7 +88,7 @@
public void exactMode() {
final ArrayOfDoublesUpdatableSketch sketch =
new ArrayOfDoublesUpdatableSketchBuilder().
- build(WritableMemory.wrap(new byte[1000000]));
+ build(WritableMemory.writableWrap(new byte[1000000]));
Assert.assertTrue(sketch.isEmpty());
Assert.assertEquals(sketch.getEstimate(), 0.0);
for (int i = 0; i < 4096; i++) {
@@ -136,7 +136,7 @@
public void estimationMode() {
final ArrayOfDoublesUpdatableSketch sketch =
new ArrayOfDoublesUpdatableSketchBuilder().
- build(WritableMemory.wrap(new byte[4096 * 2 * 16 + 32]));
+ build(WritableMemory.writableWrap(new byte[4096 * 2 * 16 + 32]));
Assert.assertEquals(sketch.getEstimate(), 0.0);
for (int i = 1; i <= 8192; i++) {
sketch.update(i, new double[] {1.0});
@@ -177,7 +177,7 @@
public void updatesOfAllKeyTypes() {
final ArrayOfDoublesUpdatableSketch sketch =
new ArrayOfDoublesUpdatableSketchBuilder().
- build(WritableMemory.wrap(new byte[1000000]));
+ build(WritableMemory.writableWrap(new byte[1000000]));
sketch.update(1L, new double[] {1.0});
sketch.update(2.0, new double[] {1.0});
sketch.update(new byte[] {3}, new double[] {1.0});
@@ -191,7 +191,7 @@
public void doubleSum() {
final ArrayOfDoublesUpdatableSketch sketch =
new ArrayOfDoublesUpdatableSketchBuilder().
- build(WritableMemory.wrap(new byte[1000000]));
+ build(WritableMemory.writableWrap(new byte[1000000]));
sketch.update(1, new double[] {1.0});
Assert.assertEquals(sketch.getRetainedEntries(), 1);
Assert.assertEquals(sketch.getValues()[0][0], 1.0);
@@ -207,10 +207,10 @@
public void serializeDeserializeExact() throws Exception {
final ArrayOfDoublesUpdatableSketch sketch1 =
new ArrayOfDoublesUpdatableSketchBuilder().
- build(WritableMemory.wrap(new byte[1000000]));
+ build(WritableMemory.writableWrap(new byte[1000000]));
sketch1.update(1, new double[] {1.0});
- final ArrayOfDoublesUpdatableSketch sketch2 = ArrayOfDoublesUpdatableSketch.wrap(WritableMemory.wrap(sketch1.toByteArray()));
+ final ArrayOfDoublesUpdatableSketch sketch2 = ArrayOfDoublesUpdatableSketch.wrap(WritableMemory.writableWrap(sketch1.toByteArray()));
Assert.assertEquals(sketch2.getEstimate(), 1.0);
final double[][] values = sketch2.getValues();
@@ -229,7 +229,7 @@
public void serializeDeserializeEstimationNoResize() throws Exception {
final ArrayOfDoublesUpdatableSketch sketch1 =
new ArrayOfDoublesUpdatableSketchBuilder().setResizeFactor(ResizeFactor.X1).
- build(WritableMemory.wrap(new byte[1000000]));
+ build(WritableMemory.writableWrap(new byte[1000000]));
for (int j = 0; j < 10; j++) {
for (int i = 0; i < 8192; i++) {
sketch1.update(i, new double[] {1.0});
@@ -240,7 +240,7 @@
//for visual testing
//TestUtil.writeBytesToFile(byteArray, "ArrayOfDoublesQuickSelectSketch4K.data");
- final ArrayOfDoublesSketch sketch2 = ArrayOfDoublesSketch.wrap(WritableMemory.wrap(byteArray));
+ final ArrayOfDoublesSketch sketch2 = ArrayOfDoublesSketch.wrap(WritableMemory.writableWrap(byteArray));
Assert.assertTrue(sketch2.isEstimationMode());
Assert.assertEquals(sketch2.getEstimate(), 8192, 8192 * 0.99);
Assert.assertEquals(sketch1.getTheta(), sketch2.getTheta());
@@ -258,12 +258,12 @@
final ArrayOfDoublesUpdatableSketch sketch1 =
new ArrayOfDoublesUpdatableSketchBuilder().
setNominalEntries(sketchSize).setSamplingProbability(0.5f).
- build(WritableMemory.wrap(new byte[1000000]));
+ build(WritableMemory.writableWrap(new byte[1000000]));
for (int i = 0; i < numberOfUniques; i++) {
sketch1.update(i, new double[] {1.0});
}
final ArrayOfDoublesSketch sketch2 =
- ArrayOfDoublesSketch.wrap(WritableMemory.wrap(sketch1.toByteArray()));
+ ArrayOfDoublesSketch.wrap(WritableMemory.writableWrap(sketch1.toByteArray()));
Assert.assertTrue(sketch2.isEstimationMode());
Assert.assertEquals(sketch2.getEstimate() / numberOfUniques, 1.0, 0.01);
Assert.assertEquals(sketch2.getRetainedEntries() / (double) numberOfUniques, 0.5, 0.01);
@@ -273,6 +273,6 @@
@Test(expectedExceptions = SketchesArgumentException.class)
public void notEnoughMemory() {
new ArrayOfDoublesUpdatableSketchBuilder().
- setNominalEntries(32).build(WritableMemory.wrap(new byte[1055]));
+ setNominalEntries(32).build(WritableMemory.writableWrap(new byte[1055]));
}
}
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesCompactSketchTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesCompactSketchTest.java
index d37d5a7..0da7101 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesCompactSketchTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesCompactSketchTest.java
@@ -102,7 +102,7 @@
for (int i = 0; i < 8192; i++) {
us.update(i, new double[] {1.0});
}
- WritableMemory wmem = WritableMemory.wrap(us.toByteArray());
+ WritableMemory wmem = WritableMemory.writableWrap(us.toByteArray());
ArrayOfDoublesUpdatableSketch wrappedUS = ArrayOfDoublesSketches.wrapUpdatableSketch(wmem);
Assert.assertFalse(wrappedUS.isEmpty());
Assert.assertTrue(wrappedUS.isEstimationMode());
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketchTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketchTest.java
index 0e691e3..e27cda2 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketchTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketchTest.java
@@ -187,7 +187,7 @@
final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
sketch1.update(1, new double[] {1.0});
- final ArrayOfDoublesUpdatableSketch sketch2 = ArrayOfDoublesUpdatableSketch.heapify(WritableMemory.wrap(sketch1.toByteArray()));
+ final ArrayOfDoublesUpdatableSketch sketch2 = ArrayOfDoublesUpdatableSketch.heapify(WritableMemory.writableWrap(sketch1.toByteArray()));
Assert.assertEquals(sketch2.getEstimate(), 1.0);
final double[][] values = sketch2.getValues();
diff --git a/src/test/java/org/apache/datasketches/tuple/strings/ArrayOfStringsSketchTest.java b/src/test/java/org/apache/datasketches/tuple/strings/ArrayOfStringsSketchTest.java
index 43b4034..00e2bd4 100644
--- a/src/test/java/org/apache/datasketches/tuple/strings/ArrayOfStringsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/strings/ArrayOfStringsSketchTest.java
@@ -49,7 +49,7 @@
sketch1.update(strArrArr[0], strArrArr[0]); //insert duplicate
//printSummaries(sketch1.iterator());
byte[] array = sketch1.toByteArray();
- WritableMemory wmem = WritableMemory.wrap(array);
+ WritableMemory wmem = WritableMemory.writableWrap(array);
ArrayOfStringsSketch sketch2 = new ArrayOfStringsSketch(wmem);
//printSummaries(sketch2.iterator());
checkSummaries(sketch2, sketch2);
