You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datasketches.apache.org by wl...@apache.org on 2022/10/20 19:51:58 UTC
[datasketches-memory] 11/12: step 11 - test updates
This is an automated email from the ASF dual-hosted git repository.
wlauer pushed a commit to branch refactorInterfaces
in repository https://gitbox.apache.org/repos/asf/datasketches-memory.git
commit de5a80cb23d83ceb0366ab545d49db5f6b818a1e
Author: Will Lauer <wl...@yahooinc.com>
AuthorDate: Thu Oct 20 13:52:24 2022 -0500
step 11 - test updates
---
.../memory/internal/BaseBufferTest.java | 7 +-
.../memory/internal/BaseStateTest.java | 23 +-
.../datasketches/memory/internal/Buffer2Test.java | 57 ++---
.../memory/internal/BufferBoundaryCheckTest.java | 3 +-
.../memory/internal/BufferInvariantsTest.java | 16 +-
.../memory/internal/BufferReadWriteSafetyTest.java | 29 ++-
.../datasketches/memory/internal/BufferTest.java | 62 +++---
.../memory/internal/CommonBufferTest.java | 11 +-
.../memory/internal/CommonMemoryTest.java | 23 +-
.../memory/internal/CopyMemoryOverlapTest.java | 5 +-
.../memory/internal/CopyMemoryTest.java | 13 +-
.../memory/internal/DruidIssue11544Test.java | 3 +-
.../internal/ExampleMemoryRequestServerTest.java | 15 +-
.../memory/internal/IgnoredArrayOverflowTest.java | 3 +-
.../datasketches/memory/internal/LeafImplTest.java | 67 +++---
.../memory/internal/MemoryBoundaryCheckTest.java | 4 +-
.../memory/internal/MemoryReadWriteSafetyTest.java | 53 +++--
.../datasketches/memory/internal/MemoryTest.java | 157 +++++++-------
.../memory/internal/MemoryWriteToTest.java | 9 +-
.../memory/internal/MurmurHash3v2Test.java | 11 +-
.../internal/NativeWritableBufferImplTest.java | 126 +++++------
.../internal/NativeWritableMemoryImplTest.java | 131 ++++++------
.../internal/NonNativeWritableBufferImplTest.java | 37 ++--
.../internal/NonNativeWritableMemoryImplTest.java | 33 +--
.../memory/internal/RandomCodePoints.java | 83 +++++++
.../memory/internal/SpecificLeafTest.java | 101 ++++-----
.../datasketches/memory/internal/TestUtils.java | 238 +++++++++++++++++++++
.../datasketches/memory/internal/Utf8Test.java | 39 ++--
.../datasketches/memory/internal/UtilTest.java | 60 ++----
.../memory/internal/WritableDirectCopyTest.java | 29 +--
.../memory/internal/WritableMemoryTest.java | 55 ++---
.../memory/internal/XxHash64LoopingTest.java | 3 +-
.../datasketches/memory/internal/XxHash64Test.java | 18 +-
.../memory/internal/ZeroCapacityTest.java | 11 +-
.../internal/direct/AllocateDirectMemoryTest.java | 29 ++-
.../AllocateDirectWritableMapMemoryTest.java | 56 ++---
.../internal/mmap/AllocateDirectMapMemoryTest.java | 30 +--
.../memory/internal/unsafe/NioBitsTest.java | 2 +-
.../memory/internal/unsafe/UnsafeUtilTest.java | 3 +-
39 files changed, 987 insertions(+), 668 deletions(-)
diff --git a/src/test/java/org/apache/datasketches/memory/internal/BaseBufferTest.java b/src/test/java/org/apache/datasketches/memory/internal/BaseBufferTest.java
index 4e8bfff..cc596fd 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/BaseBufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/BaseBufferTest.java
@@ -22,6 +22,7 @@ package org.apache.datasketches.memory.internal;
import static org.testng.Assert.fail;
import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.WritableMemory;
@@ -34,7 +35,7 @@ public class BaseBufferTest {
@Test
public void checkLimits() {
- Buffer buf = Memory.wrap(new byte[100]).asBuffer();
+ Buffer buf = DefaultMemoryFactory.DEFAULT.wrap(new byte[100]).asBuffer();
buf.setStartPositionEnd(40, 45, 50);
buf.setStartPositionEnd(0, 0, 100);
try {
@@ -47,7 +48,7 @@ public class BaseBufferTest {
@Test
public void checkLimitsAndCheck() {
- Buffer buf = Memory.wrap(new byte[100]).asBuffer();
+ Buffer buf = DefaultMemoryFactory.DEFAULT.wrap(new byte[100]).asBuffer();
buf.setAndCheckStartPositionEnd(40, 45, 50);
buf.setAndCheckStartPositionEnd(0, 0, 100);
try {
@@ -77,7 +78,7 @@ public class BaseBufferTest {
public void checkCheckValid() throws Exception {
WritableMemory wmem;
Buffer buf;
- try (WritableHandle hand = WritableMemory.allocateDirect(100)) {
+ try (WritableHandle hand = DefaultMemoryFactory.DEFAULT.allocateDirect(100)) {
wmem = hand.getWritable();
buf = wmem.asBuffer();
}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/BaseStateTest.java b/src/test/java/org/apache/datasketches/memory/internal/BaseStateTest.java
index 430dfa1..f684ae8 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/BaseStateTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/BaseStateTest.java
@@ -19,7 +19,7 @@
package org.apache.datasketches.memory.internal;
-import static org.apache.datasketches.memory.internal.UnsafeUtil.ARRAY_DOUBLE_INDEX_SCALE;
+import static org.apache.datasketches.memory.internal.unsafe.UnsafeUtil.ARRAY_DOUBLE_INDEX_SCALE;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
@@ -28,9 +28,12 @@ import static org.testng.Assert.fail;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableBuffer;
import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.unsafe.Prim;
+import org.apache.datasketches.memory.internal.unsafe.StepBoolean;
import org.testng.annotations.Test;
public class BaseStateTest {
@@ -43,7 +46,7 @@ public class BaseStateTest {
@Test
public void checkIsSameResource() {
- WritableMemory wmem = WritableMemory.allocate(16);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(16);
Memory mem = wmem;
assertFalse(wmem.isSameResource(null));
assertTrue(wmem.isSameResource(mem));
@@ -57,7 +60,7 @@ public class BaseStateTest {
@Test
public void checkNotEqualTo() {
byte[] arr = new byte[8];
- Memory mem = Memory.wrap(arr);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(arr);
assertFalse(mem.equalTo(0, arr, 0, 8));
}
@@ -86,14 +89,14 @@ public class BaseStateTest {
@Test
public void checkGetNativeBaseOffset_Heap() throws Exception {
- WritableMemory wmem = WritableMemory.allocate(8); //heap
- final long offset = ((BaseStateImpl)wmem).getNativeBaseOffset();
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(8); //heap
+ final long offset = ((ResourceImpl)wmem).getNativeBaseOffset();
assertEquals(offset, 0L);
}
@Test
public void checkIsByteOrderCompatible() {
- WritableMemory wmem = WritableMemory.allocate(8);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(8);
assertTrue(wmem.isByteOrderCompatible(ByteOrder.nativeOrder()));
}
@@ -105,16 +108,16 @@ public class BaseStateTest {
@Test
public void checkIsNativeByteOrder() {
- assertTrue(BaseStateImpl.isNativeByteOrder(ByteOrder.nativeOrder()));
+ assertTrue(ResourceImpl.isNativeByteOrder(ByteOrder.nativeOrder()));
try {
- BaseStateImpl.isNativeByteOrder(null);
+ ResourceImpl.isNativeByteOrder(null);
fail();
} catch (final IllegalArgumentException e) {}
}
@Test
public void checkXxHash64() {
- WritableMemory mem = WritableMemory.allocate(8);
+ WritableMemory mem = DefaultMemoryFactory.DEFAULT.allocate(8);
long out = mem.xxHash64(mem.getLong(0), 1L);
assertTrue(out != 0);
}
@@ -122,7 +125,7 @@ public class BaseStateTest {
@Test
public void checkTypeDecode() {
for (int i = 0; i < 128; i++) {
- BaseStateImpl.typeDecode(i);
+ ResourceImpl.typeDecode(i);
}
}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/Buffer2Test.java b/src/test/java/org/apache/datasketches/memory/internal/Buffer2Test.java
index e625cb4..a7ac0d5 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/Buffer2Test.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/Buffer2Test.java
@@ -28,9 +28,10 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.DefaultBufferFactory;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.DefaultMemoryRequestServer;
import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.ReadOnlyException;
import org.apache.datasketches.memory.WritableBuffer;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@@ -48,7 +49,7 @@ public class Buffer2Test {
}
bb.position(0);
- Buffer buffer = Buffer.wrap(bb.asReadOnlyBuffer().order(ByteOrder.nativeOrder()));
+ Buffer buffer = DefaultBufferFactory.DEFAULT.wrap(bb.asReadOnlyBuffer().order(ByteOrder.nativeOrder()));
while (buffer.hasRemaining()) {
assertEquals(bb.get(), buffer.getByte());
}
@@ -68,7 +69,7 @@ public class Buffer2Test {
}
bb.position(0);
- Buffer buffer = Buffer.wrap(bb);
+ Buffer buffer = DefaultBufferFactory.DEFAULT.wrap(bb);
while (buffer.hasRemaining()) {
assertEquals(bb.get(), buffer.getByte());
}
@@ -85,7 +86,7 @@ public class Buffer2Test {
byteArray[i] = i;
}
- Buffer buffer = Memory.wrap(byteArray).asBuffer();
+ Buffer buffer = DefaultMemoryFactory.DEFAULT.wrap(byteArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(byteArray[i++], buffer.getByte());
@@ -108,7 +109,7 @@ public class Buffer2Test {
charArray[i] = i;
}
- Buffer buffer = Memory.wrap(charArray).asBuffer();
+ Buffer buffer = DefaultMemoryFactory.DEFAULT.wrap(charArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(charArray[i++], buffer.getChar());
@@ -128,7 +129,7 @@ public class Buffer2Test {
shortArray[i] = i;
}
- Buffer buffer = Memory.wrap(shortArray).asBuffer();
+ Buffer buffer = DefaultMemoryFactory.DEFAULT.wrap(shortArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(shortArray[i++], buffer.getShort());
@@ -148,7 +149,7 @@ public class Buffer2Test {
intArray[i] = i;
}
- Buffer buffer = Memory.wrap(intArray).asBuffer();
+ Buffer buffer = DefaultMemoryFactory.DEFAULT.wrap(intArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(intArray[i++], buffer.getInt());
@@ -168,7 +169,7 @@ public class Buffer2Test {
longArray[i] = i;
}
- Buffer buffer = Memory.wrap(longArray).asBuffer();
+ Buffer buffer = DefaultMemoryFactory.DEFAULT.wrap(longArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(longArray[i++], buffer.getLong());
@@ -188,7 +189,7 @@ public class Buffer2Test {
floatArray[i] = i;
}
- Buffer buffer = Memory.wrap(floatArray).asBuffer();
+ Buffer buffer = DefaultMemoryFactory.DEFAULT.wrap(floatArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(floatArray[i++], buffer.getFloat());
@@ -208,7 +209,7 @@ public class Buffer2Test {
doubleArray[i] = i;
}
- Buffer buffer = Memory.wrap(doubleArray).asBuffer();
+ Buffer buffer = DefaultMemoryFactory.DEFAULT.wrap(doubleArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(doubleArray[i++], buffer.getDouble());
@@ -230,7 +231,7 @@ public class Buffer2Test {
}
}
- Buffer buffer = Memory.wrap(booleanArray).asBuffer();
+ Buffer buffer = DefaultMemoryFactory.DEFAULT.wrap(booleanArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(booleanArray[i++], buffer.getBoolean());
@@ -255,7 +256,7 @@ public class Buffer2Test {
}
bb.position(10);
- Buffer buffer = Buffer.wrap(bb);
+ Buffer buffer = DefaultBufferFactory.DEFAULT.wrap(bb);
while (buffer.hasRemaining()) {
assertEquals(bb.get(), buffer.getByte());
}
@@ -272,7 +273,7 @@ public class Buffer2Test {
}
bb.position(10);
- Buffer buffer = Buffer.wrap(bb);
+ Buffer buffer = DefaultBufferFactory.DEFAULT.wrap(bb);
assertEquals(bb.hasRemaining(), buffer.hasRemaining());
assertEquals(bb.remaining(), buffer.getRemaining());
}
@@ -288,7 +289,7 @@ public class Buffer2Test {
}
bb.position(10);
- Buffer buffer = Buffer.wrap(bb);
+ Buffer buffer = DefaultBufferFactory.DEFAULT.wrap(bb);
assertEquals(bb.position(), buffer.getPosition());
assertEquals(30, buffer.setPosition(30).getPosition());
assertEquals(40, buffer.incrementPosition(10).getPosition());
@@ -306,7 +307,7 @@ public class Buffer2Test {
}
bb.position(10);
- Buffer buffer = Buffer.wrap(bb.slice().order(ByteOrder.nativeOrder()));
+ Buffer buffer = DefaultBufferFactory.DEFAULT.wrap(bb.slice().order(ByteOrder.nativeOrder()));
while (buffer.hasRemaining()) {
assertEquals(bb.get(), buffer.getByte());
}
@@ -328,7 +329,7 @@ public class Buffer2Test {
}
bb.position(10);
- Buffer buffer = Buffer.wrap(bb.slice().order(ByteOrder.nativeOrder())); //slice = 54
+ Buffer buffer = DefaultBufferFactory.DEFAULT.wrap(bb.slice().order(ByteOrder.nativeOrder())); //slice = 54
buffer.setPosition(30);//remaining = 24
Buffer dupBuffer = buffer.duplicate(); //all 54
Buffer regionBuffer = buffer.region(); //24
@@ -349,9 +350,9 @@ public class Buffer2Test {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- Memory mem = Memory.wrap(arr);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(arr);
Buffer buf = mem.asBuffer();
- Buffer reg = buf.region(n2 * 8, n2 * 8, buf.getTypeByteOrder()); //top half
+ Buffer reg = buf.region(n2 * 8, n2 * 8, buf.getByteOrder()); //top half
for (int i = 0; i < n2; i++) {
long v = reg.getLong(i * 8);
long e = i + n2;
@@ -370,7 +371,7 @@ public class Buffer2Test {
}
bb.position(10);
- Buffer buffer = Buffer.wrap(bb);
+ Buffer buffer = DefaultBufferFactory.DEFAULT.wrap(bb);
Memory memory = buffer.asMemory();
assertEquals(buffer.getCapacity(), memory.getCapacity());
@@ -384,25 +385,25 @@ public class Buffer2Test {
public void testROByteBuffer() {
byte[] arr = new byte[64];
ByteBuffer roBB = ByteBuffer.wrap(arr).asReadOnlyBuffer();
- Buffer buf = Buffer.wrap(roBB);
+ Buffer buf = DefaultBufferFactory.DEFAULT.wrap(roBB);
WritableBuffer wbuf = (WritableBuffer) buf;
wbuf.putByte(0, (byte) 1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testROByteBuffer2() {
byte[] arr = new byte[64];
ByteBuffer roBB = ByteBuffer.wrap(arr).asReadOnlyBuffer();
- Buffer buf = Buffer.wrap(roBB);
+ Buffer buf = DefaultBufferFactory.DEFAULT.wrap(roBB);
WritableBuffer wbuf = (WritableBuffer) buf;
wbuf.putByteArray(arr, 0, 64);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testIllegalFill() {
byte[] arr = new byte[64];
ByteBuffer roBB = ByteBuffer.wrap(arr).asReadOnlyBuffer();
- Buffer buf = Buffer.wrap(roBB);
+ Buffer buf = DefaultBufferFactory.DEFAULT.wrap(roBB);
WritableBuffer wbuf = (WritableBuffer) buf;
wbuf.fill((byte)0);
}
@@ -410,15 +411,15 @@ public class Buffer2Test {
@Test
public void checkWritableWrap() {
ByteBuffer bb = ByteBuffer.allocate(16);
- WritableBuffer buf = WritableBuffer.writableWrap(bb, ByteOrder.nativeOrder(), null);
+ WritableBuffer buf = DefaultBufferFactory.DEFAULT.writableWrap(bb, ByteOrder.nativeOrder(), null);
assertNotNull(buf);
- buf = WritableBuffer.writableWrap(bb, ByteOrder.nativeOrder(), new DefaultMemoryRequestServer());
+ buf = DefaultBufferFactory.DEFAULT.writableWrap(bb, ByteOrder.nativeOrder(), new DefaultMemoryRequestServer());
assertNotNull(buf);
}
@Test
public void testWritableDuplicate() {
- WritableMemory wmem = WritableMemory.writableWrap(new byte[1]);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(new byte[1]);
WritableBuffer wbuf = wmem.asWritableBuffer();
WritableBuffer wbuf2 = wbuf.writableDuplicate();
assertEquals(wbuf2.getCapacity(), 1);
@@ -429,7 +430,7 @@ public class Buffer2Test {
@Test
public void checkIndependence() {
int cap = 64;
- WritableMemory wmem = WritableMemory.allocate(cap);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(cap);
WritableBuffer wbuf1 = wmem.asWritableBuffer();
WritableBuffer wbuf2 = wmem.asWritableBuffer();
assertFalse(wbuf1 == wbuf2);
diff --git a/src/test/java/org/apache/datasketches/memory/internal/BufferBoundaryCheckTest.java b/src/test/java/org/apache/datasketches/memory/internal/BufferBoundaryCheckTest.java
index 535b0ca..a0bcd95 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/BufferBoundaryCheckTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/BufferBoundaryCheckTest.java
@@ -19,12 +19,13 @@
package org.apache.datasketches.memory.internal;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
public class BufferBoundaryCheckTest {
- private final WritableMemory writableMemory = WritableMemory.allocate(8);
+ private final WritableMemory writableMemory = DefaultMemoryFactory.DEFAULT.allocate(8);
@Test
public void testGetBoolean() {
diff --git a/src/test/java/org/apache/datasketches/memory/internal/BufferInvariantsTest.java b/src/test/java/org/apache/datasketches/memory/internal/BufferInvariantsTest.java
index 735c6b0..b443dd4 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/BufferInvariantsTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/BufferInvariantsTest.java
@@ -25,6 +25,8 @@ import static org.testng.Assert.fail;
import java.nio.ByteBuffer;
import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.DefaultBufferFactory;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.WritableBuffer;
import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.WritableMemory;
@@ -39,7 +41,7 @@ public class BufferInvariantsTest {
public void testRegion() {
ByteBuffer byteBuffer = ByteBuffer.allocate(10);
byteBuffer.limit(7);
- Buffer buff = Buffer.wrap(byteBuffer); //assuming buff has cap of 8
+ Buffer buff = DefaultBufferFactory.DEFAULT.wrap(byteBuffer); //assuming buff has cap of 8
assertEquals(buff.getCapacity(), 10); //wrong should be 8
buff.getByte(); //pos moves to 1
Buffer copyBuff = buff.region(); //pos: 0, start: 0, end: 6: cap: 7
@@ -92,7 +94,7 @@ public class BufferInvariantsTest {
@Test
public void testBuf() {
int n = 25;
- WritableBuffer buf = WritableMemory.allocate(n).asWritableBuffer();
+ WritableBuffer buf = DefaultMemoryFactory.DEFAULT.allocate(n).asWritableBuffer();
for (byte i = 0; i < n; i++) { buf.putByte(i); }
buf.setPosition(0);
assertEquals(buf.getPosition(), 0);
@@ -138,7 +140,7 @@ public class BufferInvariantsTest {
bb.position(5);
bb.limit(20);
- Buffer buf = Buffer.wrap(bb);
+ Buffer buf = DefaultBufferFactory.DEFAULT.wrap(bb);
assertEquals(buf.getPosition(), 5);
assertEquals(buf.getEnd(), 20);
assertEquals(buf.getRemaining(), 15);
@@ -161,7 +163,7 @@ public class BufferInvariantsTest {
@Test
public void checkLimitsDirect() throws Exception {
- try (WritableHandle hand = WritableMemory.allocateDirect(100)) {
+ try (WritableHandle hand = DefaultMemoryFactory.DEFAULT.allocateDirect(100)) {
WritableMemory wmem = hand.getWritable();
Buffer buf = wmem.asBuffer();
buf.setStartPositionEnd(40, 45, 50);
@@ -179,7 +181,7 @@ public class BufferInvariantsTest {
public void testRegionDirect() {
ByteBuffer byteBuffer = ByteBuffer.allocate(10);
byteBuffer.limit(7);
- Buffer buff = Buffer.wrap(byteBuffer); //assuming buff has cap of 8
+ Buffer buff = DefaultBufferFactory.DEFAULT.wrap(byteBuffer); //assuming buff has cap of 8
assertEquals(buff.getCapacity(), 10); //wrong should be 8
buff.getByte(); //pos moves to 1
Buffer copyBuff = buff.region(); //pos: 0, start: 0, end: 6: cap: 7
@@ -232,7 +234,7 @@ public class BufferInvariantsTest {
@Test
public void testBufDirect() throws Exception {
int n = 25;
- try (WritableHandle whand = WritableMemory.allocateDirect(n)) {
+ try (WritableHandle whand = DefaultMemoryFactory.DEFAULT.allocateDirect(n)) {
WritableMemory wmem = whand.getWritable();
WritableBuffer buf = wmem.asWritableBuffer();
for (byte i = 0; i < n; i++) { buf.putByte(i); }
@@ -281,7 +283,7 @@ public class BufferInvariantsTest {
bb.position(5);
bb.limit(20);
- Buffer buf = Buffer.wrap(bb);
+ Buffer buf = DefaultBufferFactory.DEFAULT.wrap(bb);
assertEquals(buf.getPosition(), 5);
assertEquals(buf.getEnd(), 20);
assertEquals(buf.getRemaining(), 15);
diff --git a/src/test/java/org/apache/datasketches/memory/internal/BufferReadWriteSafetyTest.java b/src/test/java/org/apache/datasketches/memory/internal/BufferReadWriteSafetyTest.java
index 6f9f62a..465a808 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/BufferReadWriteSafetyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/BufferReadWriteSafetyTest.java
@@ -21,17 +21,16 @@ package org.apache.datasketches.memory.internal;
import java.nio.ByteBuffer;
-import org.apache.datasketches.memory.Buffer;
-import org.apache.datasketches.memory.ReadOnlyException;
+import org.apache.datasketches.memory.DefaultBufferFactory;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.WritableBuffer;
-import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
public class BufferReadWriteSafetyTest {
// Test various operations with read-only Buffer
- private final WritableBuffer buf = (WritableBuffer) Buffer.wrap(ByteBuffer.allocate(8));
+ private final WritableBuffer buf = (WritableBuffer) DefaultBufferFactory.DEFAULT.wrap(ByteBuffer.allocate(8));
@Test(expectedExceptions = AssertionError.class)
public void testPutByte() {
@@ -113,42 +112,42 @@ public class BufferReadWriteSafetyTest {
buf.putDouble(1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testPutByteArray() {
buf.putByteArray(new byte[] {1}, 0, 1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testPutBooleanArray() {
buf.putBooleanArray(new boolean[] {true}, 0, 1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testPutShortArray() {
buf.putShortArray(new short[] {1}, 0, 1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testPutCharArray() {
buf.putCharArray(new char[] {1}, 0, 1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testPutIntArray() {
buf.putIntArray(new int[] {1}, 0, 1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testPutLongArray() {
buf.putLongArray(new long[] {1}, 0, 1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testPutFloatArray() {
buf.putFloatArray(new float[] {1}, 0, 1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testDoubleByteArray() {
buf.putDoubleArray(new double[] {1}, 0, 1);
}
@@ -157,19 +156,19 @@ public class BufferReadWriteSafetyTest {
@Test(expectedExceptions = AssertionError.class)
public void testWritableMemoryAsBuffer() {
- WritableBuffer buf1 = (WritableBuffer) WritableMemory.allocate(8).asBuffer();
+ WritableBuffer buf1 = (WritableBuffer) DefaultMemoryFactory.DEFAULT.allocate(8).asBuffer();
buf1.putInt(1);
}
@Test(expectedExceptions = AssertionError.class)
public void testWritableBufferRegion() {
- WritableBuffer buf1 = (WritableBuffer) WritableMemory.allocate(8).asWritableBuffer().region();
+ WritableBuffer buf1 = (WritableBuffer) DefaultMemoryFactory.DEFAULT.allocate(8).asWritableBuffer().region();
buf1.putInt(1);
}
@Test(expectedExceptions = AssertionError.class)
public void testWritableBufferDuplicate() {
- WritableBuffer buf1 = (WritableBuffer) WritableMemory.allocate(8).asWritableBuffer().duplicate();
+ WritableBuffer buf1 = (WritableBuffer) DefaultMemoryFactory.DEFAULT.allocate(8).asWritableBuffer().duplicate();
buf1.putInt(1);
}
}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/BufferTest.java b/src/test/java/org/apache/datasketches/memory/internal/BufferTest.java
index 64b3c77..a4d34ab 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/BufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/BufferTest.java
@@ -27,6 +27,8 @@ import java.util.List;
import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.DefaultBufferFactory;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableBuffer;
import org.apache.datasketches.memory.WritableMemory;
@@ -38,7 +40,7 @@ public class BufferTest {
@Test
public void checkDirectRoundTrip() throws Exception {
int n = 1024; //longs
- try (WritableHandle wh = WritableMemory.allocateDirect(n * 8)) {
+ try (WritableHandle wh = DefaultMemoryFactory.DEFAULT.allocateDirect(n * 8)) {
WritableMemory wmem = wh.getWritable();
WritableBuffer wbuf = wmem.asWritableBuffer();
for (int i = 0; i < n; i++) {
@@ -55,7 +57,7 @@ public class BufferTest {
@Test
public void checkAutoHeapRoundTrip() {
int n = 1024; //longs
- WritableBuffer wbuf = WritableMemory.allocate(n * 8).asWritableBuffer();
+ WritableBuffer wbuf = DefaultMemoryFactory.DEFAULT.allocate(n * 8).asWritableBuffer();
for (int i = 0; i < n; i++) {
wbuf.putLong(i);
}
@@ -70,7 +72,7 @@ public class BufferTest {
public void checkArrayWrap() {
int n = 1024; //longs
byte[] arr = new byte[n * 8];
- WritableBuffer wbuf = WritableMemory.writableWrap(arr).asWritableBuffer();
+ WritableBuffer wbuf = DefaultMemoryFactory.DEFAULT.writableWrap(arr).asWritableBuffer();
for (int i = 0; i < n; i++) {
wbuf.putLong(i);
}
@@ -79,29 +81,29 @@ public class BufferTest {
long v = wbuf.getLong();
assertEquals(v, i);
}
- Buffer buf = Memory.wrap(arr).asBuffer();
+ Buffer buf = DefaultMemoryFactory.DEFAULT.wrap(arr).asBuffer();
buf.resetPosition();
for (int i = 0; i < n; i++) {
long v = buf.getLong();
assertEquals(v, i);
}
// Check Zero length array wraps
- Memory mem = Memory.wrap(new byte[0]);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(new byte[0]);
Buffer buffZeroLengthArrayWrap = mem.asBuffer();
assertEquals(buffZeroLengthArrayWrap.getCapacity(), 0);
// check 0 length array wraps
List<Buffer> buffersToCheck = Lists.newArrayList();
- buffersToCheck.add(WritableMemory.allocate(0).asBuffer());
- buffersToCheck.add(WritableBuffer.writableWrap(ByteBuffer.allocate(0)));
- buffersToCheck.add(Buffer.wrap(ByteBuffer.allocate(0)));
- buffersToCheck.add(Memory.wrap(new boolean[0]).asBuffer());
- buffersToCheck.add(Memory.wrap(new byte[0]).asBuffer());
- buffersToCheck.add(Memory.wrap(new char[0]).asBuffer());
- buffersToCheck.add(Memory.wrap(new short[0]).asBuffer());
- buffersToCheck.add(Memory.wrap(new int[0]).asBuffer());
- buffersToCheck.add(Memory.wrap(new long[0]).asBuffer());
- buffersToCheck.add(Memory.wrap(new float[0]).asBuffer());
- buffersToCheck.add(Memory.wrap(new double[0]).asBuffer());
+ buffersToCheck.add(DefaultMemoryFactory.DEFAULT.allocate(0).asBuffer());
+ buffersToCheck.add(DefaultBufferFactory.DEFAULT.writableWrap(ByteBuffer.allocate(0)));
+ buffersToCheck.add(DefaultBufferFactory.DEFAULT.wrap(ByteBuffer.allocate(0)));
+ buffersToCheck.add(DefaultMemoryFactory.DEFAULT.wrap(new boolean[0]).asBuffer());
+ buffersToCheck.add(DefaultMemoryFactory.DEFAULT.wrap(new byte[0]).asBuffer());
+ buffersToCheck.add(DefaultMemoryFactory.DEFAULT.wrap(new char[0]).asBuffer());
+ buffersToCheck.add(DefaultMemoryFactory.DEFAULT.wrap(new short[0]).asBuffer());
+ buffersToCheck.add(DefaultMemoryFactory.DEFAULT.wrap(new int[0]).asBuffer());
+ buffersToCheck.add(DefaultMemoryFactory.DEFAULT.wrap(new long[0]).asBuffer());
+ buffersToCheck.add(DefaultMemoryFactory.DEFAULT.wrap(new float[0]).asBuffer());
+ buffersToCheck.add(DefaultMemoryFactory.DEFAULT.wrap(new double[0]).asBuffer());
//Check the buffer lengths
for (Buffer buffer : buffersToCheck) {
assertEquals(buffer.getCapacity(), 0);
@@ -115,7 +117,7 @@ public class BufferTest {
ByteBuffer bb = ByteBuffer.wrap(arr);
bb.order(ByteOrder.nativeOrder());
- WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
+ WritableBuffer wbuf = DefaultBufferFactory.DEFAULT.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wbuf
wbuf.putLong(i);
}
@@ -137,7 +139,7 @@ public class BufferTest {
ByteBuffer bb = ByteBuffer.wrap(arr);
bb.order(ByteOrder.nativeOrder());
- WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
+ WritableBuffer wbuf = DefaultBufferFactory.DEFAULT.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wbuf
wbuf.putLong(i);
}
@@ -150,7 +152,7 @@ public class BufferTest {
long v = bb.getLong(i * 8);
assertEquals(v, i);
}
- Buffer buf1 = Memory.wrap(arr).asBuffer();
+ Buffer buf1 = DefaultMemoryFactory.DEFAULT.wrap(arr).asBuffer();
for (int i = 0; i < n; i++) { //read from wrapped arr
long v = buf1.getLong();
assertEquals(v, i);
@@ -170,7 +172,7 @@ public class BufferTest {
ByteBuffer bb = ByteBuffer.allocateDirect(n * 8);
bb.order(ByteOrder.nativeOrder());
- WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
+ WritableBuffer wbuf = DefaultBufferFactory.DEFAULT.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wmem
wbuf.putLong(i);
}
@@ -183,7 +185,7 @@ public class BufferTest {
long v = bb.getLong(i * 8);
assertEquals(v, i);
}
- Buffer buf1 = Buffer.wrap(bb);
+ Buffer buf1 = DefaultBufferFactory.DEFAULT.wrap(bb);
for (int i = 0; i < n; i++) { //read from wrapped bb RO
long v = buf1.getLong();
assertEquals(v, i);
@@ -202,8 +204,8 @@ public class BufferTest {
int n = 1024; //longs
ByteBuffer bb = ByteBuffer.allocate(n * 8);
bb.order(ByteOrder.BIG_ENDIAN);
- Buffer buf = Buffer.wrap(bb);
- assertEquals(buf.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
+ Buffer buf = DefaultBufferFactory.DEFAULT.wrap(bb);
+ assertEquals(buf.getByteOrder(), ByteOrder.BIG_ENDIAN);
}
@Test
@@ -216,7 +218,7 @@ public class BufferTest {
ByteBuffer slice = bb.slice().asReadOnlyBuffer();
slice.order(ByteOrder.nativeOrder());
- Buffer buf = Buffer.wrap(slice);
+ Buffer buf = DefaultBufferFactory.DEFAULT.wrap(slice);
for (int i = 0; i < 64; i++) {
assertEquals(buf.getByte(), 64 + i);
}
@@ -230,7 +232,7 @@ public class BufferTest {
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableBuffer wbuf = WritableMemory.allocate(n * 8).asWritableBuffer();
+ WritableBuffer wbuf = DefaultMemoryFactory.DEFAULT.allocate(n * 8).asWritableBuffer();
wbuf.putLongArray(arr, 0, n);
long[] arr2 = new long[n];
wbuf.resetPosition();
@@ -247,7 +249,7 @@ public class BufferTest {
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- Buffer buf = Memory.wrap(arr).asBuffer();
+ Buffer buf = DefaultMemoryFactory.DEFAULT.wrap(arr).asBuffer();
buf.setPosition(n2 * 8);
Buffer reg = buf.region();
for (int i = 0; i < n2; i++) {
@@ -263,7 +265,7 @@ public class BufferTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableBuffer wbuf = WritableMemory.writableWrap(arr).asWritableBuffer();
+ WritableBuffer wbuf = DefaultMemoryFactory.DEFAULT.writableWrap(arr).asWritableBuffer();
for (int i = 0; i < n; i++) {
assertEquals(wbuf.getLong(), i); //write all
//println("" + wmem.getLong(i * 8));
@@ -282,7 +284,7 @@ public class BufferTest {
@Test(expectedExceptions = AssertionError.class)
public void checkParentUseAfterFree() throws Exception {
int bytes = 64 * 8;
- WritableHandle wh = WritableMemory.allocateDirect(bytes);
+ WritableHandle wh = DefaultMemoryFactory.DEFAULT.allocateDirect(bytes);
WritableMemory wmem = wh.getWritable();
WritableBuffer wbuf = wmem.asWritableBuffer();
wh.close();
@@ -294,7 +296,7 @@ public class BufferTest {
@Test(expectedExceptions = AssertionError.class)
public void checkRegionUseAfterFree() throws Exception {
int bytes = 64;
- WritableHandle wh = WritableMemory.allocateDirect(bytes);
+ WritableHandle wh = DefaultMemoryFactory.DEFAULT.allocateDirect(bytes);
Memory wmem = wh.get();
Buffer reg = wmem.asBuffer().region();
@@ -306,7 +308,7 @@ public class BufferTest {
@Test(expectedExceptions = AssertionError.class)
public void checkBaseBufferInvariants() {
- WritableBuffer wbuf = WritableMemory.allocate(64).asWritableBuffer();
+ WritableBuffer wbuf = DefaultMemoryFactory.DEFAULT.allocate(64).asWritableBuffer();
wbuf.setStartPositionEnd(1, 0, 2); //out of order
}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/CommonBufferTest.java b/src/test/java/org/apache/datasketches/memory/internal/CommonBufferTest.java
index e5033a2..078f6d3 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/CommonBufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/CommonBufferTest.java
@@ -22,6 +22,7 @@ package org.apache.datasketches.memory.internal;
import static org.testng.Assert.assertEquals;
import org.apache.datasketches.memory.WritableHandle;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.WritableBuffer;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@@ -31,7 +32,7 @@ public class CommonBufferTest {
@Test
public void checkSetGet() throws Exception {
int memCapacity = 60; //must be at least 60
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
@@ -133,7 +134,7 @@ public class CommonBufferTest {
@Test
public void checkSetGetArrays() throws Exception {
int memCapacity = 32;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
@@ -230,7 +231,7 @@ public class CommonBufferTest {
@Test
public void checkSetGetPartialArraysWithOffset() throws Exception {
int memCapacity = 32;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
@@ -324,7 +325,7 @@ public class CommonBufferTest {
@Test
public void checkSetClearMemoryRegions() throws Exception {
int memCapacity = 64; //must be 64
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh1 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh1.getWritable();
WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
@@ -413,7 +414,7 @@ public class CommonBufferTest {
@Test
public void checkToHexStringAllMem() throws Exception {
int memCapacity = 48; //must be 48
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh1 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh1.getWritable();
WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
diff --git a/src/test/java/org/apache/datasketches/memory/internal/CommonMemoryTest.java b/src/test/java/org/apache/datasketches/memory/internal/CommonMemoryTest.java
index 322352f..9dc5ddf 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/CommonMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/CommonMemoryTest.java
@@ -19,14 +19,15 @@
package org.apache.datasketches.memory.internal;
-import static org.apache.datasketches.memory.internal.Util.isAllBitsClear;
-import static org.apache.datasketches.memory.internal.Util.isAllBitsSet;
-import static org.apache.datasketches.memory.internal.Util.isAnyBitsClear;
-import static org.apache.datasketches.memory.internal.Util.isAnyBitsSet;
+import static org.apache.datasketches.memory.internal.TestUtils.isAllBitsClear;
+import static org.apache.datasketches.memory.internal.TestUtils.isAllBitsSet;
+import static org.apache.datasketches.memory.internal.TestUtils.isAnyBitsClear;
+import static org.apache.datasketches.memory.internal.TestUtils.isAnyBitsSet;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@@ -36,7 +37,7 @@ public class CommonMemoryTest {
@Test
public void checkSetGet() throws Exception {
int memCapacity = 16; //must be at least 8
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
assertEquals(mem.getCapacity(), memCapacity);
setGetTests(mem);
@@ -88,7 +89,7 @@ public class CommonMemoryTest {
@Test
public void checkSetGetArrays() throws Exception {
int memCapacity = 32;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
assertEquals(memCapacity, mem.getCapacity());
setGetArraysTests(mem);
@@ -168,7 +169,7 @@ public class CommonMemoryTest {
@Test
public void checkSetGetPartialArraysWithOffset() throws Exception {
int memCapacity = 32;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
assertEquals(memCapacity, mem.getCapacity());
setGetPartialArraysWithOffsetTests(mem);
@@ -245,7 +246,7 @@ public class CommonMemoryTest {
@Test
public void checkSetClearIsBits() throws Exception {
int memCapacity = 8;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
assertEquals(memCapacity, mem.getCapacity());
mem.clear();
@@ -286,7 +287,7 @@ public class CommonMemoryTest {
@Test
public void checkAtomicMethods() throws Exception {
int memCapacity = 8;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
assertEquals(mem.getCapacity(), memCapacity);
atomicMethodTests(mem);
@@ -313,7 +314,7 @@ public class CommonMemoryTest {
@Test
public void checkSetClearMemoryRegions() throws Exception {
int memCapacity = 64; //must be 64
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh1 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh1.getWritable();
setClearMemoryRegionsTests(mem); //requires println enabled to visually check
@@ -384,7 +385,7 @@ public class CommonMemoryTest {
@Test
public void checkToHexStringAllMem() throws Exception {
int memCapacity = 48; //must be 48
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh1 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh1.getWritable();
toHexStringAllMemTests(mem); //requires println enabled to visually check
}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/CopyMemoryOverlapTest.java b/src/test/java/org/apache/datasketches/memory/internal/CopyMemoryOverlapTest.java
index 962b12f..a87a738 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/CopyMemoryOverlapTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/CopyMemoryOverlapTest.java
@@ -22,6 +22,7 @@ package org.apache.datasketches.memory.internal;
import static org.testng.Assert.assertEquals;
import org.apache.datasketches.memory.WritableHandle;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@@ -92,7 +93,7 @@ public class CopyMemoryOverlapTest {
println("CopyUp : " + copyUp);
println("Backing longs: " + backingLongs + "\t bytes: " + backingBytes);
- try (WritableHandle backHandle = WritableMemory.allocateDirect(backingBytes)) {
+ try (WritableHandle backHandle = DefaultMemoryFactory.DEFAULT.allocateDirect(backingBytes)) {
WritableMemory backingMem = backHandle.getWritable();
fill(backingMem); //fill mem with 0 thru copyLongs -1
//listMem(backingMem, "Original");
@@ -132,7 +133,7 @@ public class CopyMemoryOverlapTest {
println("CopyUp : " + copyUp);
println("Backing longs: " + backingLongs + "\t bytes: " + backingBytes);
- try (WritableHandle backHandle = WritableMemory.allocateDirect(backingBytes)) {
+ try (WritableHandle backHandle = DefaultMemoryFactory.DEFAULT.allocateDirect(backingBytes)) {
WritableMemory backingMem = backHandle.getWritable();
fill(backingMem); //fill mem with 0 thru copyLongs -1
//listMem(backingMem, "Original");
diff --git a/src/test/java/org/apache/datasketches/memory/internal/CopyMemoryTest.java b/src/test/java/org/apache/datasketches/memory/internal/CopyMemoryTest.java
index fe37aad..0da9e7d 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/CopyMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/CopyMemoryTest.java
@@ -25,6 +25,7 @@ import static org.testng.Assert.assertEquals;
import java.util.concurrent.ThreadLocalRandom;
import org.apache.datasketches.memory.WritableHandle;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.Assert;
@@ -122,8 +123,8 @@ public class CopyMemoryTest {
byte[] bytes = new byte[((UNSAFE_COPY_THRESHOLD_BYTES * 5) / 2) + 1];
ThreadLocalRandom.current().nextBytes(bytes);
byte[] referenceBytes = bytes.clone();
- Memory referenceMem = Memory.wrap(referenceBytes);
- WritableMemory mem = WritableMemory.writableWrap(bytes);
+ Memory referenceMem = DefaultMemoryFactory.DEFAULT.wrap(referenceBytes);
+ WritableMemory mem = DefaultMemoryFactory.DEFAULT.writableWrap(bytes);
long copyLen = UNSAFE_COPY_THRESHOLD_BYTES * 2;
mem.copyTo(0, mem, UNSAFE_COPY_THRESHOLD_BYTES / 2, copyLen);
Assert.assertEquals(0, mem.compareTo(UNSAFE_COPY_THRESHOLD_BYTES / 2, copyLen, referenceMem, 0,
@@ -135,8 +136,8 @@ public class CopyMemoryTest {
byte[] bytes = new byte[((UNSAFE_COPY_THRESHOLD_BYTES * 5) / 2) + 1];
ThreadLocalRandom.current().nextBytes(bytes);
byte[] referenceBytes = bytes.clone();
- Memory referenceMem = Memory.wrap(referenceBytes);
- WritableMemory mem = WritableMemory.writableWrap(bytes);
+ Memory referenceMem = DefaultMemoryFactory.DEFAULT.wrap(referenceBytes);
+ WritableMemory mem = DefaultMemoryFactory.DEFAULT.writableWrap(bytes);
long copyLen = UNSAFE_COPY_THRESHOLD_BYTES * 2;
mem.copyTo(UNSAFE_COPY_THRESHOLD_BYTES / 2, mem, 0, copyLen);
Assert.assertEquals(0, mem.compareTo(0, copyLen, referenceMem, UNSAFE_COPY_THRESHOLD_BYTES / 2,
@@ -151,7 +152,7 @@ public class CopyMemoryTest {
}
private static WritableHandle genWRH(int longs, boolean empty) {
- WritableHandle wrh = WritableMemory.allocateDirect(longs << 3);
+ WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(longs << 3);
WritableMemory mem = wrh.getWritable();
if (empty) {
mem.clear();
@@ -163,7 +164,7 @@ public class CopyMemoryTest {
private static WritableMemory genMem(int longs, boolean empty) {
- WritableMemory mem = WritableMemory.allocate(longs << 3);
+ WritableMemory mem = DefaultMemoryFactory.DEFAULT.allocate(longs << 3);
if (!empty) {
for (int i = 0; i < longs; i++) { mem.putLong(i << 3, i + 1); }
}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/DruidIssue11544Test.java b/src/test/java/org/apache/datasketches/memory/internal/DruidIssue11544Test.java
index 581bdda..479486a 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/DruidIssue11544Test.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/DruidIssue11544Test.java
@@ -27,6 +27,7 @@ import static org.testng.Assert.assertTrue;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.DefaultMemoryRequestServer;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableMemory;
@@ -60,7 +61,7 @@ public class DruidIssue11544Test {
bb.order(ByteOrder.nativeOrder());
//Wrap bb into WritableMemory
- WritableMemory mem1 = WritableMemory.writableWrap(bb);
+ WritableMemory mem1 = DefaultMemoryFactory.DEFAULT.writableWrap(bb);
assertTrue(mem1.isDirect()); //confirm mem1 is off-heap
//Acquire the DefaultMemoryRequestServer
diff --git a/src/test/java/org/apache/datasketches/memory/internal/ExampleMemoryRequestServerTest.java b/src/test/java/org/apache/datasketches/memory/internal/ExampleMemoryRequestServerTest.java
index 0cf345c..55d0562 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/ExampleMemoryRequestServerTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/ExampleMemoryRequestServerTest.java
@@ -24,6 +24,7 @@ import static org.testng.Assert.assertFalse;
import java.nio.ByteOrder;
import java.util.IdentityHashMap;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.WritableMemory;
@@ -38,13 +39,13 @@ public class ExampleMemoryRequestServerTest {
/**
* This version is without a TWR block.all of the memory allocations are done through the MemoryRequestServer
* and each is closed by the MemoryClient when it is done with each.
- * @throws Exception thrown by automatic close() invocation on WritableHandle.
+ * @throws Exception
*/
@Test
public void checkExampleMemoryRequestServer1() throws Exception {
int bytes = 8;
ExampleMemoryRequestServer svr = new ExampleMemoryRequestServer();
- try (WritableHandle wh = WritableMemory.allocateDirect(8)) {
+ try (WritableHandle wh = DefaultMemoryFactory.DEFAULT.allocateDirect(8)) {
WritableMemory memStart = wh.getWritable();
WritableMemory wMem = svr.request(memStart, bytes);
MemoryClient client = new MemoryClient(wMem);
@@ -59,13 +60,13 @@ public class ExampleMemoryRequestServerTest {
* by the MemoryClient when it is done with the new memory allocations.
* The initial allocation stays open until the end where it is closed at the end of the
* TWR scope.
- * @throws Exception thrown by automatic close() invocation on WritableHandle.
+ * @throws Exception
*/
@Test
public void checkExampleMemoryRequestServer2() throws Exception {
int bytes = 8;
ExampleMemoryRequestServer svr = new ExampleMemoryRequestServer();
- try (WritableHandle handle = WritableMemory.allocateDirect(bytes, ByteOrder.nativeOrder(), svr)) {
+ try (WritableHandle handle = DefaultMemoryFactory.DEFAULT.allocateDirect(bytes, ByteOrder.nativeOrder(), svr)) {
WritableMemory memStart = handle.getWritable();
MemoryClient client = new MemoryClient(memStart);
client.process();
@@ -76,7 +77,7 @@ public class ExampleMemoryRequestServerTest {
@Test(expectedExceptions = IllegalArgumentException.class)
public void checkZeroCapacity() throws Exception {
ExampleMemoryRequestServer svr = new ExampleMemoryRequestServer();
- try (WritableHandle wh = WritableMemory.allocateDirect(0, ByteOrder.nativeOrder(), svr)) {
+ try (WritableHandle wh = DefaultMemoryFactory.DEFAULT.allocateDirect(0, ByteOrder.nativeOrder(), svr)) {
}
}
@@ -131,8 +132,8 @@ public class ExampleMemoryRequestServerTest {
@Override
public WritableMemory request(WritableMemory currentWMem, long capacityBytes) {
- ByteOrder order = currentWMem.getTypeByteOrder();
- WritableHandle handle = WritableMemory.allocateDirect(capacityBytes, order, this);
+ ByteOrder order = currentWMem.getByteOrder();
+ WritableHandle handle = DefaultMemoryFactory.DEFAULT.allocateDirect(capacityBytes, order, this);
WritableMemory wmem = handle.getWritable();
map.put(wmem, handle); //We track the newly allocated memory and its handle.
return wmem;
diff --git a/src/test/java/org/apache/datasketches/memory/internal/IgnoredArrayOverflowTest.java b/src/test/java/org/apache/datasketches/memory/internal/IgnoredArrayOverflowTest.java
index d9e0773..b916422 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/IgnoredArrayOverflowTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/IgnoredArrayOverflowTest.java
@@ -19,6 +19,7 @@
package org.apache.datasketches.memory.internal;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.AfterClass;
@@ -33,7 +34,7 @@ public class IgnoredArrayOverflowTest {
@BeforeClass
public void allocate() {
- h = WritableMemory.allocateDirect(MAX_SIZE);
+ h = DefaultMemoryFactory.DEFAULT.allocateDirect(MAX_SIZE);
memory = h.getWritable();
}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/LeafImplTest.java b/src/test/java/org/apache/datasketches/memory/internal/LeafImplTest.java
index f1ef17e..6cc7277 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/LeafImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/LeafImplTest.java
@@ -32,10 +32,11 @@ import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableBuffer;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMapHandle;
+import org.apache.datasketches.memory.WritableMmapHandle;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@@ -59,18 +60,18 @@ public class LeafImplTest {
long off = 0;
long cap = 128;
// Off Heap, Native order, No ByteBuffer, has MemReqSvr
- try (WritableHandle wdh = WritableMemory.allocateDirect(cap, NBO, dummyMemReqSvr)) {
+ try (WritableHandle wdh = DefaultMemoryFactory.DEFAULT.allocateDirect(cap, NBO, dummyMemReqSvr)) {
WritableMemory memNO = wdh.getWritable();
memNO.putShort(0, (short) 1);
- assertNull(((BaseStateImpl)memNO).getUnsafeObject());
+ assertNull(((ResourceImpl)memNO).getUnsafeObject());
assertTrue(memNO.isDirect());
checkCombinations(memNO, off, cap, memNO.isDirect(), NBO, false, true);
}
// Off Heap, Non Native order, No ByteBuffer, has MemReqSvr
- try (WritableHandle wdh = WritableMemory.allocateDirect(cap, NNBO, dummyMemReqSvr)) {
+ try (WritableHandle wdh = DefaultMemoryFactory.DEFAULT.allocateDirect(cap, NNBO, dummyMemReqSvr)) {
WritableMemory memNNO = wdh.getWritable();
memNNO.putShort(0, (short) 1);
- assertNull(((BaseStateImpl)memNNO).getUnsafeObject());
+ assertNull(((ResourceImpl)memNNO).getUnsafeObject());
assertTrue(memNNO.isDirect());
checkCombinations(memNNO, off, cap, memNNO.isDirect(), NNBO, false, true);
}
@@ -84,37 +85,37 @@ public class LeafImplTest {
ByteBuffer bb = ByteBuffer.allocate((int)cap);
bb.order(NBO);
bb.putShort(0, (short) 1);
- WritableMemory mem = WritableMemory.writableWrap(bb, NBO, dummyMemReqSvr);
+ WritableMemory mem = DefaultMemoryFactory.DEFAULT.writableWrap(bb, NBO, dummyMemReqSvr);
assertEquals(bb.isDirect(), mem.isDirect());
- assertNotNull(((BaseStateImpl)mem).getUnsafeObject());
- checkCombinations(mem, off, cap, mem.isDirect(), mem.getTypeByteOrder(), true, true);
+ assertNotNull(((ResourceImpl)mem).getUnsafeObject());
+ checkCombinations(mem, off, cap, mem.isDirect(), mem.getByteOrder(), true, true);
//BB off heap, native order, has ByteBuffer, has MemReqSvr
ByteBuffer dbb = ByteBuffer.allocateDirect((int)cap);
dbb.order(NBO);
dbb.putShort(0, (short) 1);
- mem = WritableMemory.writableWrap(dbb, NBO, dummyMemReqSvr);
+ mem = DefaultMemoryFactory.DEFAULT.writableWrap(dbb, NBO, dummyMemReqSvr);
assertEquals(dbb.isDirect(), mem.isDirect());
- assertNull(((BaseStateImpl)mem).getUnsafeObject());
- checkCombinations(mem, off, cap, mem.isDirect(), mem.getTypeByteOrder(), true, true);
+ assertNull(((ResourceImpl)mem).getUnsafeObject());
+ checkCombinations(mem, off, cap, mem.isDirect(), mem.getByteOrder(), true, true);
//BB on heap, non native order, has ByteBuffer, has MemReqSvr
bb = ByteBuffer.allocate((int)cap);
bb.order(NNBO);
bb.putShort(0, (short) 1);
- mem = WritableMemory.writableWrap(bb, NNBO, dummyMemReqSvr);
+ mem = DefaultMemoryFactory.DEFAULT.writableWrap(bb, NNBO, dummyMemReqSvr);
assertEquals(bb.isDirect(), mem.isDirect());
- assertNotNull(((BaseStateImpl)mem).getUnsafeObject());
- checkCombinations(mem, off, cap, mem.isDirect(), mem.getTypeByteOrder(), true, true);
+ assertNotNull(((ResourceImpl)mem).getUnsafeObject());
+ checkCombinations(mem, off, cap, mem.isDirect(), mem.getByteOrder(), true, true);
//BB off heap, non native order, has ByteBuffer, has MemReqSvr
dbb = ByteBuffer.allocateDirect((int)cap);
dbb.order(NNBO);
dbb.putShort(0, (short) 1);
- mem = WritableMemory.writableWrap(dbb, NNBO, dummyMemReqSvr);
+ mem = DefaultMemoryFactory.DEFAULT.writableWrap(dbb, NNBO, dummyMemReqSvr);
assertEquals(dbb.isDirect(), mem.isDirect());
- assertNull(((BaseStateImpl)mem).getUnsafeObject());
- checkCombinations(mem, off, cap, mem.isDirect(), mem.getTypeByteOrder(), true, true);
+ assertNull(((ResourceImpl)mem).getUnsafeObject());
+ checkCombinations(mem, off, cap, mem.isDirect(), mem.getByteOrder(), true, true);
}
@Test
@@ -134,18 +135,18 @@ public class LeafImplTest {
assertTrue(file.isFile());
file.deleteOnExit(); //comment out if you want to examine the file.
// Off Heap, Native order, No ByteBuffer, No MemReqSvr
- try (WritableMapHandle wmh = WritableMemory.writableMap(file, off, cap, NBO)) {
+ try (WritableMmapHandle wmh = DefaultMemoryFactory.DEFAULT.writableMap(file, off, cap, NBO)) {
WritableMemory memNO = wmh.getWritable();
memNO.putShort(0, (short) 1);
- assertNull(((BaseStateImpl)memNO).getUnsafeObject());
+ assertNull(((ResourceImpl)memNO).getUnsafeObject());
assertTrue(memNO.isDirect());
checkCombinations(memNO, off, cap, memNO.isDirect(), NBO, false, false);
}
// Off heap, Non Native order, No ByteBuffer, no MemReqSvr
- try (WritableMapHandle wmh = WritableMemory.writableMap(file, off, cap, NNBO)) {
+ try (WritableMmapHandle wmh = DefaultMemoryFactory.DEFAULT.writableMap(file, off, cap, NNBO)) {
WritableMemory memNNO = wmh.getWritable();
memNNO.putShort(0, (short) 1);
- assertNull(((BaseStateImpl)memNNO).getUnsafeObject());
+ assertNull(((ResourceImpl)memNNO).getUnsafeObject());
assertTrue(memNNO.isDirect());
checkCombinations(memNNO, off, cap, memNNO.isDirect(), NNBO, false, false);
}
@@ -156,15 +157,15 @@ public class LeafImplTest {
long off = 0;
long cap = 128;
// On Heap, Native order, No ByteBuffer, No MemReqSvr
- WritableMemory memNO = WritableMemory.allocate((int)cap); //assumes NBO
+ WritableMemory memNO = DefaultMemoryFactory.DEFAULT.allocate((int)cap); //assumes NBO
memNO.putShort(0, (short) 1);
- assertNotNull(((BaseStateImpl)memNO).getUnsafeObject());
+ assertNotNull(((ResourceImpl)memNO).getUnsafeObject());
assertFalse(memNO.isDirect());
checkCombinations(memNO, off, cap, memNO.isDirect(), NBO, false, false);
// On Heap, Non-native order, No ByteBuffer, No MemReqSvr
- WritableMemory memNNO = WritableMemory.allocate((int)cap, NNBO);
+ WritableMemory memNNO = DefaultMemoryFactory.DEFAULT.allocate((int)cap, NNBO);
memNNO.putShort(0, (short) 1);
- assertNotNull(((BaseStateImpl)memNNO).getUnsafeObject());
+ assertNotNull(((ResourceImpl)memNNO).getUnsafeObject());
assertFalse(memNNO.isDirect());
checkCombinations(memNNO, off, cap, memNNO.isDirect(), NNBO, false, false);
}
@@ -182,11 +183,11 @@ public class LeafImplTest {
ByteBuffer bb = mem.getByteBuffer();
assertTrue( hasByteBuffer ? bb != null : bb == null);
- assertTrue(mem.getTypeByteOrder() == bo);
+ assertTrue(mem.getByteOrder() == bo);
if (hasMemReqSvr) { assertTrue(mem.getMemoryRequestServer() instanceof DummyMemoryRequestServer); }
- Object obj = ((BaseStateImpl)mem).getUnsafeObject();
+ Object obj = ((ResourceImpl)mem).getUnsafeObject();
if (direct) {
assertTrue(mem.isDirect());
assertNull(obj);
@@ -207,11 +208,11 @@ public class LeafImplTest {
bb = buf.getByteBuffer();
assertTrue(hasByteBuffer ? bb != null : bb == null);
- assertTrue(buf.getTypeByteOrder() == bo);
+ assertTrue(buf.getByteOrder() == bo);
if (hasMemReqSvr) { assertTrue(buf.getMemoryRequestServer() instanceof DummyMemoryRequestServer); }
- obj = ((BaseStateImpl)buf).getUnsafeObject();
+ obj = ((ResourceImpl)buf).getUnsafeObject();
if (direct) {
assertTrue(buf.isDirect());
assertNull(obj);
@@ -232,11 +233,11 @@ public class LeafImplTest {
bb = nnMem.getByteBuffer();
assertTrue( hasByteBuffer ? bb != null : bb == null);
- assertTrue(nnMem.getTypeByteOrder() == oo);
+ assertTrue(nnMem.getByteOrder() == oo);
if (hasMemReqSvr) { assertTrue(nnMem.getMemoryRequestServer() instanceof DummyMemoryRequestServer); }
- obj = ((BaseStateImpl)nnMem).getUnsafeObject();
+ obj = ((ResourceImpl)nnMem).getUnsafeObject();
if (direct) {
assertTrue(nnMem.isDirect());
assertNull(obj);
@@ -257,11 +258,11 @@ public class LeafImplTest {
bb = nnBuf.getByteBuffer();
assertTrue( hasByteBuffer ? bb != null : bb == null);
- assertTrue(nnBuf.getTypeByteOrder() == oo);
+ assertTrue(nnBuf.getByteOrder() == oo);
if (hasMemReqSvr) { assertTrue(nnBuf.getMemoryRequestServer() instanceof DummyMemoryRequestServer); }
- obj = ((BaseStateImpl)nnBuf).getUnsafeObject();
+ obj = ((ResourceImpl)nnBuf).getUnsafeObject();
if (direct) {
assertTrue(nnBuf.isDirect());
assertNull(obj);
diff --git a/src/test/java/org/apache/datasketches/memory/internal/MemoryBoundaryCheckTest.java b/src/test/java/org/apache/datasketches/memory/internal/MemoryBoundaryCheckTest.java
index 1362f44..f60c36d 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/MemoryBoundaryCheckTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/MemoryBoundaryCheckTest.java
@@ -19,13 +19,13 @@
package org.apache.datasketches.memory.internal;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.WritableBuffer;
-import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
public class MemoryBoundaryCheckTest {
- private final WritableBuffer writableBuffer = WritableMemory.allocate(8).asWritableBuffer();
+ private final WritableBuffer writableBuffer = DefaultMemoryFactory.DEFAULT.allocate(8).asWritableBuffer();
@Test
public void testGetBoolean() {
diff --git a/src/test/java/org/apache/datasketches/memory/internal/MemoryReadWriteSafetyTest.java b/src/test/java/org/apache/datasketches/memory/internal/MemoryReadWriteSafetyTest.java
index 553c432..2083b26 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/MemoryReadWriteSafetyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/MemoryReadWriteSafetyTest.java
@@ -24,9 +24,8 @@ import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.MapHandle;
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.ReadOnlyException;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
+import org.apache.datasketches.memory.MmapHandle;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@@ -34,7 +33,7 @@ public class MemoryReadWriteSafetyTest {
// Test various operations with read-only Memory
- final WritableMemory mem = (WritableMemory) Memory.wrap(new byte[8]);
+ final WritableMemory mem = (WritableMemory) DefaultMemoryFactory.DEFAULT.wrap(new byte[8]);
@Test(expectedExceptions = AssertionError.class)
public void testPutByte() {
@@ -76,42 +75,42 @@ public class MemoryReadWriteSafetyTest {
mem.putDouble(0, 1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testPutByteArray() {
mem.putByteArray(0, new byte[] {1}, 0, 1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testPutBooleanArray() {
mem.putBooleanArray(0, new boolean[] {true}, 0, 1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testPutShortArray() {
mem.putShortArray(0, new short[] {1}, 0, 1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testPutCharArray() {
mem.putCharArray(0, new char[] {1}, 0, 1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testPutIntArray() {
mem.putIntArray(0, new int[] {1}, 0, 1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testPutLongArray() {
mem.putLongArray(0, new long[] {1}, 0, 1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testPutFloatArray() {
mem.putFloatArray(0, new float[] {1}, 0, 1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void testDoubleByteArray() {
mem.putDoubleArray(0, new double[] {1}, 0, 1);
}
@@ -120,73 +119,73 @@ public class MemoryReadWriteSafetyTest {
@Test(expectedExceptions = AssertionError.class)
public void testWritableMemoryRegion() {
- WritableMemory mem1 = (WritableMemory) WritableMemory.allocate(8).region(0, 8);
+ WritableMemory mem1 = (WritableMemory) DefaultMemoryFactory.DEFAULT.allocate(8).region(0, 8);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testByteArrayWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new byte[8]);
+ WritableMemory mem1 = (WritableMemory) DefaultMemoryFactory.DEFAULT.wrap(new byte[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testByteArrayWrapWithBO() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new byte[8], ByteOrder.nativeOrder());
+ WritableMemory mem1 = (WritableMemory) DefaultMemoryFactory.DEFAULT.wrap(new byte[8], ByteOrder.nativeOrder());
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testByteArrayWrapWithOffsetsAndBO() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new byte[8], 0, 4, ByteOrder.nativeOrder());
+ WritableMemory mem1 = (WritableMemory) DefaultMemoryFactory.DEFAULT.wrap(new byte[8], 0, 4, ByteOrder.nativeOrder());
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testBooleanArrayWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new boolean[8]);
+ WritableMemory mem1 = (WritableMemory) DefaultMemoryFactory.DEFAULT.wrap(new boolean[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testShortArrayWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new short[8]);
+ WritableMemory mem1 = (WritableMemory) DefaultMemoryFactory.DEFAULT.wrap(new short[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testCharArrayWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new char[8]);
+ WritableMemory mem1 = (WritableMemory) DefaultMemoryFactory.DEFAULT.wrap(new char[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testIntArrayWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new int[8]);
+ WritableMemory mem1 = (WritableMemory) DefaultMemoryFactory.DEFAULT.wrap(new int[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testLongArrayWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new long[8]);
+ WritableMemory mem1 = (WritableMemory) DefaultMemoryFactory.DEFAULT.wrap(new long[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testFloatArrayWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new float[8]);
+ WritableMemory mem1 = (WritableMemory) DefaultMemoryFactory.DEFAULT.wrap(new float[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testDoubleArrayWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(new double[8]);
+ WritableMemory mem1 = (WritableMemory) DefaultMemoryFactory.DEFAULT.wrap(new double[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testByteBufferWrap() {
- WritableMemory mem1 = (WritableMemory) Memory.wrap(ByteBuffer.allocate(8));
+ WritableMemory mem1 = (WritableMemory) DefaultMemoryFactory.DEFAULT.wrap(ByteBuffer.allocate(8));
mem1.putInt(0, 1);
}
@@ -198,7 +197,7 @@ public class MemoryReadWriteSafetyTest {
try (RandomAccessFile raf = new RandomAccessFile(tempFile, "rw")) {
raf.setLength(8);
//System.out.println(UtilTest.getFileAttributes(tempFile));
- try (MapHandle h = Memory.map(tempFile)) {
+ try (MmapHandle h = DefaultMemoryFactory.DEFAULT.map(tempFile)) {
((WritableMemory) h.get()).putInt(0, 1);
}
}
@@ -210,7 +209,7 @@ public class MemoryReadWriteSafetyTest {
File tempFile = File.createTempFile("test", "test");
tempFile.deleteOnExit();
new RandomAccessFile(tempFile, "rw").setLength(8);
- try (MapHandle h = Memory.map(tempFile, 0, 4, ByteOrder.nativeOrder())) {
+ try (MmapHandle h = DefaultMemoryFactory.DEFAULT.map(tempFile, 0, 4, ByteOrder.nativeOrder())) {
((WritableMemory) h.get()).putInt(0, 1);
}
}
@@ -221,7 +220,7 @@ public class MemoryReadWriteSafetyTest {
File tempFile = File.createTempFile("test", "test");
tempFile.deleteOnExit();
new RandomAccessFile(tempFile, "rw").setLength(8);
- try (MapHandle unused = Memory.map(tempFile, 0, 16, ByteOrder.nativeOrder())) {
+ try (MmapHandle unused = DefaultMemoryFactory.DEFAULT.map(tempFile, 0, 16, ByteOrder.nativeOrder())) {
}
}
}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/MemoryTest.java b/src/test/java/org/apache/datasketches/memory/internal/MemoryTest.java
index 045c59f..6128e36 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/MemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/MemoryTest.java
@@ -23,7 +23,7 @@
package org.apache.datasketches.memory.internal;
-import static org.apache.datasketches.memory.internal.Util.getResourceFile;
+import static org.apache.datasketches.memory.internal.TestUtils.getResourceFile;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertNotNull;
@@ -35,8 +35,9 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.List;
-import org.apache.datasketches.memory.BaseState;
-import org.apache.datasketches.memory.MapHandle;
+import org.apache.datasketches.memory.MmapHandle;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableBuffer;
import org.apache.datasketches.memory.WritableHandle;
@@ -50,13 +51,13 @@ public class MemoryTest {
@BeforeClass
public void setReadOnly() {
- UtilTest.setGettysburgAddressFileToReadOnly();
+ TestUtils.setGettysburgAddressFileToReadOnly();
}
@Test
public void checkDirectRoundTrip() throws Exception {
int n = 1024; //longs
- try (WritableHandle wh = WritableMemory.allocateDirect(n * 8)) {
+ try (WritableHandle wh = DefaultMemoryFactory.DEFAULT.allocateDirect(n * 8)) {
WritableMemory mem = wh.getWritable();
for (int i = 0; i < n; i++) {
mem.putLong(i * 8, i);
@@ -71,7 +72,7 @@ public class MemoryTest {
@Test
public void checkAutoHeapRoundTrip() {
int n = 1024; //longs
- WritableMemory wmem = WritableMemory.allocate(n * 8);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(n * 8);
for (int i = 0; i < n; i++) {
wmem.putLong(i * 8, i);
}
@@ -85,7 +86,7 @@ public class MemoryTest {
public void checkArrayWrap() {
int n = 1024; //longs
byte[] arr = new byte[n * 8];
- WritableMemory wmem = WritableMemory.writableWrap(arr);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(arr);
for (int i = 0; i < n; i++) {
wmem.putLong(i * 8, i);
}
@@ -93,20 +94,20 @@ public class MemoryTest {
long v = wmem.getLong(i * 8);
assertEquals(v, i);
}
- Memory mem = Memory.wrap(arr, ByteOrder.nativeOrder());
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(arr, ByteOrder.nativeOrder());
for (int i = 0; i < n; i++) {
long v = mem.getLong(i * 8);
assertEquals(v, i);
}
// check 0 length array wraps
- Memory memZeroLengthArrayBoolean = WritableMemory.writableWrap(new boolean[0]);
- Memory memZeroLengthArrayByte = WritableMemory.writableWrap(new byte[0]);
- Memory memZeroLengthArrayChar = WritableMemory.writableWrap(new char[0]);
- Memory memZeroLengthArrayShort = WritableMemory.writableWrap(new short[0]);
- Memory memZeroLengthArrayInt = WritableMemory.writableWrap(new int[0]);
- Memory memZeroLengthArrayLong = WritableMemory.writableWrap(new long[0]);
- Memory memZeroLengthArrayFloat = WritableMemory.writableWrap(new float[0]);
- Memory memZeroLengthArrayDouble = WritableMemory.writableWrap(new double[0]);
+ Memory memZeroLengthArrayBoolean = DefaultMemoryFactory.DEFAULT.writableWrap(new boolean[0]);
+ Memory memZeroLengthArrayByte = DefaultMemoryFactory.DEFAULT.writableWrap(new byte[0]);
+ Memory memZeroLengthArrayChar = DefaultMemoryFactory.DEFAULT.writableWrap(new char[0]);
+ Memory memZeroLengthArrayShort = DefaultMemoryFactory.DEFAULT.writableWrap(new short[0]);
+ Memory memZeroLengthArrayInt = DefaultMemoryFactory.DEFAULT.writableWrap(new int[0]);
+ Memory memZeroLengthArrayLong = DefaultMemoryFactory.DEFAULT.writableWrap(new long[0]);
+ Memory memZeroLengthArrayFloat = DefaultMemoryFactory.DEFAULT.writableWrap(new float[0]);
+ Memory memZeroLengthArrayDouble = DefaultMemoryFactory.DEFAULT.writableWrap(new double[0]);
assertEquals(memZeroLengthArrayBoolean.getCapacity(), 0);
assertEquals(memZeroLengthArrayByte.getCapacity(), 0);
assertEquals(memZeroLengthArrayChar.getCapacity(), 0);
@@ -118,25 +119,25 @@ public class MemoryTest {
// check 0 length array wraps
List<Memory> memoryToCheck = Lists.newArrayList();
- memoryToCheck.add(WritableMemory.allocate(0));
- memoryToCheck.add(WritableMemory.writableWrap(ByteBuffer.allocate(0)));
- memoryToCheck.add(WritableMemory.writableWrap(new boolean[0]));
- memoryToCheck.add(WritableMemory.writableWrap(new byte[0]));
- memoryToCheck.add(WritableMemory.writableWrap(new char[0]));
- memoryToCheck.add(WritableMemory.writableWrap(new short[0]));
- memoryToCheck.add(WritableMemory.writableWrap(new int[0]));
- memoryToCheck.add(WritableMemory.writableWrap(new long[0]));
- memoryToCheck.add(WritableMemory.writableWrap(new float[0]));
- memoryToCheck.add(WritableMemory.writableWrap(new double[0]));
- memoryToCheck.add(Memory.wrap(ByteBuffer.allocate(0)));
- memoryToCheck.add(Memory.wrap(new boolean[0]));
- memoryToCheck.add(Memory.wrap(new byte[0]));
- memoryToCheck.add(Memory.wrap(new char[0]));
- memoryToCheck.add(Memory.wrap(new short[0]));
- memoryToCheck.add(Memory.wrap(new int[0]));
- memoryToCheck.add(Memory.wrap(new long[0]));
- memoryToCheck.add(Memory.wrap(new float[0]));
- memoryToCheck.add(Memory.wrap(new double[0]));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.allocate(0));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.writableWrap(ByteBuffer.allocate(0)));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.writableWrap(new boolean[0]));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.writableWrap(new byte[0]));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.writableWrap(new char[0]));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.writableWrap(new short[0]));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.writableWrap(new int[0]));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.writableWrap(new long[0]));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.writableWrap(new float[0]));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.writableWrap(new double[0]));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.wrap(ByteBuffer.allocate(0)));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.wrap(new boolean[0]));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.wrap(new byte[0]));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.wrap(new char[0]));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.wrap(new short[0]));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.wrap(new int[0]));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.wrap(new long[0]));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.wrap(new float[0]));
+ memoryToCheck.add(DefaultMemoryFactory.DEFAULT.wrap(new double[0]));
//Check the Memory lengths
for (Memory memory : memoryToCheck) {
assertEquals(memory.getCapacity(), 0);
@@ -149,7 +150,7 @@ public class MemoryTest {
byte[] arr = new byte[n * 8];
ByteBuffer bb = ByteBuffer.wrap(arr);
bb.order(ByteOrder.nativeOrder());
- WritableMemory wmem = WritableMemory.writableWrap(bb);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wmem
wmem.putLong(i * 8, i);
}
@@ -161,7 +162,7 @@ public class MemoryTest {
long v = bb.getLong(i * 8);
assertEquals(v, i);
}
- Memory mem1 = Memory.wrap(arr);
+ Memory mem1 = DefaultMemoryFactory.DEFAULT.wrap(arr);
for (int i = 0; i < n; i++) { //read from wrapped arr
long v = mem1.getLong(i * 8);
assertEquals(v, i);
@@ -179,7 +180,7 @@ public class MemoryTest {
int n = 1024; //longs
ByteBuffer bb = ByteBuffer.allocateDirect(n * 8);
bb.order(ByteOrder.nativeOrder());
- WritableMemory wmem = WritableMemory.writableWrap(bb);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wmem
wmem.putLong(i * 8, i);
}
@@ -191,7 +192,7 @@ public class MemoryTest {
long v = bb.getLong(i * 8);
assertEquals(v, i);
}
- Memory mem1 = Memory.wrap(bb);
+ Memory mem1 = DefaultMemoryFactory.DEFAULT.wrap(bb);
for (int i = 0; i < n; i++) { //read from wrapped bb RO
long v = mem1.getLong(i * 8);
assertEquals(v, i);
@@ -209,9 +210,9 @@ public class MemoryTest {
int n = 1024; //longs
ByteBuffer bb = ByteBuffer.allocate(n * 8);
bb.order(ByteOrder.BIG_ENDIAN);
- Memory mem = Memory.wrap(bb);
- assertFalse(mem.getTypeByteOrder() == ByteOrder.nativeOrder());
- assertEquals(mem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(bb);
+ assertFalse(mem.getByteOrder() == ByteOrder.nativeOrder());
+ assertEquals(mem.getByteOrder(), ByteOrder.BIG_ENDIAN);
}
@Test
@@ -222,7 +223,7 @@ public class MemoryTest {
bb.position(64);
ByteBuffer slice = bb.slice().asReadOnlyBuffer();
slice.order(ByteOrder.nativeOrder());
- Memory mem = Memory.wrap(slice);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(slice);
for (int i = 0; i < 64; i++) {
assertEquals(mem.getByte(i), 64 + i);
}
@@ -235,7 +236,7 @@ public class MemoryTest {
int n = 1024; //longs
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableMemory wmem = WritableMemory.allocate(n * 8);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(n * 8);
wmem.putLongArray(0, arr, 0, n);
long[] arr2 = new long[n];
wmem.getLongArray(0, arr2, 0, n);
@@ -250,7 +251,7 @@ public class MemoryTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- Memory mem = Memory.wrap(arr);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(arr);
Memory reg = mem.region(n2 * 8, n2 * 8); //top half
for (int i = 0; i < n2; i++) {
long v = reg.getLong(i * 8);
@@ -265,7 +266,7 @@ public class MemoryTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- Memory mem = Memory.wrap(arr);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(arr);
Memory reg = mem.region(n2 * 8, n2 * 8, Util.NON_NATIVE_BYTE_ORDER); //top half
for (int i = 0; i < n2; i++) {
long v = Long.reverseBytes(reg.getLong(i * 8));
@@ -280,7 +281,7 @@ public class MemoryTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableMemory wmem = WritableMemory.writableWrap(arr);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(arr);
for (int i = 0; i < n; i++) {
assertEquals(wmem.getLong(i * 8), i);
//println("" + wmem.getLong(i * 8));
@@ -300,7 +301,7 @@ public class MemoryTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableMemory wmem = WritableMemory.writableWrap(arr);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(arr);
for (int i = 0; i < n; i++) {
assertEquals(wmem.getLong(i * 8), i);
//println("" + wmem.getLong(i * 8));
@@ -322,7 +323,7 @@ public class MemoryTest {
@Test(expectedExceptions = AssertionError.class)
public void checkParentUseAfterFree() throws Exception {
int bytes = 64 * 8;
- WritableHandle wh = WritableMemory.allocateDirect(bytes);
+ WritableHandle wh = DefaultMemoryFactory.DEFAULT.allocateDirect(bytes);
WritableMemory wmem = wh.getWritable();
wh.close();
//with -ea assert: Memory not valid.
@@ -333,7 +334,7 @@ public class MemoryTest {
@Test(expectedExceptions = AssertionError.class)
public void checkRegionUseAfterFree() throws Exception {
int bytes = 64;
- WritableHandle wh = WritableMemory.allocateDirect(bytes);
+ WritableHandle wh = DefaultMemoryFactory.DEFAULT.allocateDirect(bytes);
Memory wmem = wh.get();
Memory region = wmem.region(0L, bytes);
wh.close();
@@ -345,23 +346,23 @@ public class MemoryTest {
@Test
public void checkMonitorDirectStats() throws Exception {
int bytes = 1024;
- long curAllocations = BaseState.getCurrentDirectMemoryAllocations();
- long curAllocated = BaseState.getCurrentDirectMemoryAllocated();
+ long curAllocations = ResourceImpl.getCurrentDirectMemoryAllocations();
+ long curAllocated = ResourceImpl.getCurrentDirectMemoryAllocated();
if (curAllocations != 0) { System.err.println(curAllocations + " should be zero!"); }
- WritableHandle wh1 = WritableMemory.allocateDirect(bytes);
- WritableHandle wh2 = WritableMemory.allocateDirect(bytes);
- assertEquals(BaseState.getCurrentDirectMemoryAllocations(), 2L + curAllocations);
- assertEquals(BaseState.getCurrentDirectMemoryAllocated(), 2 * bytes + curAllocated);
+ WritableHandle wh1 = DefaultMemoryFactory.DEFAULT.allocateDirect(bytes);
+ WritableHandle wh2 = DefaultMemoryFactory.DEFAULT.allocateDirect(bytes);
+ assertEquals(ResourceImpl.getCurrentDirectMemoryAllocations(), 2L + curAllocations);
+ assertEquals(ResourceImpl.getCurrentDirectMemoryAllocated(), 2 * bytes + curAllocated);
wh1.close();
- assertEquals(BaseState.getCurrentDirectMemoryAllocations(), 1L + curAllocations);
- assertEquals(BaseState.getCurrentDirectMemoryAllocated(), bytes + curAllocated);
+ assertEquals(ResourceImpl.getCurrentDirectMemoryAllocations(), 1L + curAllocations);
+ assertEquals(ResourceImpl.getCurrentDirectMemoryAllocated(), bytes + curAllocated);
wh2.close();
wh2.close(); //check that it doesn't go negative.
//even though the handles are closed, these methods are static access
- assertEquals(BaseState.getCurrentDirectMemoryAllocations(), 0L + curAllocations);
- assertEquals(BaseState.getCurrentDirectMemoryAllocated(), 0L + curAllocated);
+ assertEquals(ResourceImpl.getCurrentDirectMemoryAllocations(), 0L + curAllocations);
+ assertEquals(ResourceImpl.getCurrentDirectMemoryAllocated(), 0L + curAllocated);
}
@Test
@@ -369,35 +370,35 @@ public class MemoryTest {
File file = getResourceFile("GettysburgAddress.txt");
long bytes = file.length();
- MapHandle mmh1 = Memory.map(file);
- MapHandle mmh2 = Memory.map(file);
+ MmapHandle mmh1 = DefaultMemoryFactory.DEFAULT.map(file);
+ MmapHandle mmh2 = DefaultMemoryFactory.DEFAULT.map(file);
- assertEquals(BaseState.getCurrentDirectMemoryMapAllocations(), 2L);
- assertEquals(BaseState.getCurrentDirectMemoryMapAllocated(), 2 * bytes);
+ assertEquals(ResourceImpl.getCurrentDirectMemoryMapAllocations(), 2L);
+ assertEquals(ResourceImpl.getCurrentDirectMemoryMapAllocated(), 2 * bytes);
mmh1.close();
- assertEquals(BaseState.getCurrentDirectMemoryMapAllocations(), 1L);
- assertEquals(BaseState.getCurrentDirectMemoryMapAllocated(), bytes);
+ assertEquals(ResourceImpl.getCurrentDirectMemoryMapAllocations(), 1L);
+ assertEquals(ResourceImpl.getCurrentDirectMemoryMapAllocated(), bytes);
mmh2.close();
mmh2.close(); //check that it doesn't go negative.
//even though the handles are closed, these methods are static access
- assertEquals(BaseState.getCurrentDirectMemoryMapAllocations(), 0L);
- assertEquals(BaseState.getCurrentDirectMemoryMapAllocated(), 0L);
+ assertEquals(ResourceImpl.getCurrentDirectMemoryMapAllocations(), 0L);
+ assertEquals(ResourceImpl.getCurrentDirectMemoryMapAllocated(), 0L);
}
@Test
public void checkMemReqSvr() throws Exception {
WritableMemory wmem;
WritableBuffer wbuf;
- if (BaseState.defaultMemReqSvr == null) { //This is a policy choice
+ if (DefaultMemoryRequestServer.DEFAULT == null) { //This is a policy choice
//ON HEAP
- wmem = WritableMemory.writableWrap(new byte[16]);
+ wmem = DefaultMemoryFactory.DEFAULT.writableWrap(new byte[16]);
assertNull(wmem.getMemoryRequestServer());
wbuf = wmem.asWritableBuffer();
assertNull(wbuf.getMemoryRequestServer());
//OFF HEAP
- try (WritableHandle wdh = WritableMemory.allocateDirect(16)) { //OFF HEAP
+ try (WritableHandle wdh = DefaultMemoryFactory.DEFAULT.allocateDirect(16)) { //OFF HEAP
wmem = wdh.getWritable();
assertNull(wmem.getMemoryRequestServer());
wbuf = wmem.asWritableBuffer();
@@ -405,18 +406,18 @@ public class MemoryTest {
}
//ByteBuffer
ByteBuffer bb = ByteBuffer.allocate(16);
- wmem = WritableMemory.writableWrap(bb);
+ wmem = DefaultMemoryFactory.DEFAULT.writableWrap(bb);
assertNull(wmem.getMemoryRequestServer());
wbuf = wmem.asWritableBuffer();
assertNull(wbuf.getMemoryRequestServer());
} else {
//ON HEAP
- wmem = WritableMemory.writableWrap(new byte[16]);
+ wmem = DefaultMemoryFactory.DEFAULT.writableWrap(new byte[16]);
assertNotNull(wmem.getMemoryRequestServer());
wbuf = wmem.asWritableBuffer();
assertNotNull(wbuf.getMemoryRequestServer());
//OFF HEAP
- try (WritableHandle wdh = WritableMemory.allocateDirect(16)) {
+ try (WritableHandle wdh = DefaultMemoryFactory.DEFAULT.allocateDirect(16)) {
WritableMemory wmem2 = wdh.getWritable();
assertNotNull(wmem2.getMemoryRequestServer());
wbuf = wmem.asWritableBuffer();
@@ -424,7 +425,7 @@ public class MemoryTest {
}
//ByteBuffer
ByteBuffer bb = ByteBuffer.allocate(16);
- wmem = WritableMemory.writableWrap(bb);
+ wmem = DefaultMemoryFactory.DEFAULT.writableWrap(bb);
assertNotNull(wmem.getMemoryRequestServer());
wbuf = wmem.asWritableBuffer();
assertNotNull(wbuf.getMemoryRequestServer());
@@ -433,7 +434,7 @@ public class MemoryTest {
@Test
public void checkHashCode() {
- WritableMemory wmem = WritableMemory.allocate(32 + 7);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(32 + 7);
int hc = wmem.hashCode();
assertEquals(hc, -1895166923);
}
@@ -441,7 +442,7 @@ public class MemoryTest {
@Test
public void checkSelfEqualsToAndCompareTo() {
int len = 64;
- WritableMemory wmem = WritableMemory.allocate(len);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(len);
for (int i = 0; i < len; i++) { wmem.putByte(i, (byte) i); }
assertTrue(wmem.equalTo(0, wmem, 0, len));
assertFalse(wmem.equalTo(0, wmem, len/2, len/2));
@@ -453,7 +454,7 @@ public class MemoryTest {
public void wrapBigEndianAsLittle() {
ByteBuffer bb = ByteBuffer.allocate(64);
bb.putChar(0, (char)1); //as NNO
- Memory mem = Memory.wrap(bb, ByteOrder.LITTLE_ENDIAN);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(bb, ByteOrder.LITTLE_ENDIAN);
assertEquals(mem.getChar(0), 256);
}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/MemoryWriteToTest.java b/src/test/java/org/apache/datasketches/memory/internal/MemoryWriteToTest.java
index 78e51ab..b060c86 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/MemoryWriteToTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/MemoryWriteToTest.java
@@ -28,6 +28,7 @@ import java.nio.channels.WritableByteChannel;
import java.util.concurrent.ThreadLocalRandom;
import org.apache.datasketches.memory.WritableHandle;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.Assert;
@@ -58,7 +59,7 @@ public class MemoryWriteToTest {
@Test
public void testOffHeap() throws Exception {
try (WritableHandle handle =
- WritableMemory.allocateDirect((UNSAFE_COPY_THRESHOLD_BYTES * 5) + 10)) {
+ DefaultMemoryFactory.DEFAULT.allocateDirect((UNSAFE_COPY_THRESHOLD_BYTES * 5) + 10)) {
WritableMemory mem = handle.getWritable();
testWriteTo(mem.region(0, 0));
testOffHeap(mem, 7);
@@ -77,12 +78,12 @@ public class MemoryWriteToTest {
private static Memory createRandomBytesMemory(int size) {
byte[] bytes = new byte[size];
ThreadLocalRandom.current().nextBytes(bytes);
- return Memory.wrap(bytes);
+ return DefaultMemoryFactory.DEFAULT.wrap(bytes);
}
private static Memory createRandomIntsMemory(int size) {
int[] ints = ThreadLocalRandom.current().ints(size).toArray();
- return Memory.wrap(ints);
+ return DefaultMemoryFactory.DEFAULT.wrap(ints);
}
private static void testWriteTo(Memory mem) throws IOException {
@@ -91,6 +92,6 @@ public class MemoryWriteToTest {
mem.writeTo(0, mem.getCapacity(), out);
}
byte[] result = baos.toByteArray();
- Assert.assertTrue(mem.equals(Memory.wrap(result)));
+ Assert.assertTrue(mem.equals(DefaultMemoryFactory.DEFAULT.wrap(result)));
}
}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/MurmurHash3v2Test.java b/src/test/java/org/apache/datasketches/memory/internal/MurmurHash3v2Test.java
index 6949008..5d46e87 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/MurmurHash3v2Test.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/MurmurHash3v2Test.java
@@ -20,11 +20,12 @@
package org.apache.datasketches.memory.internal;
import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.apache.datasketches.memory.MurmurHash3v2.hash;
+import static org.apache.datasketches.memory.hash.MurmurHash3v2.hash;
import static org.testng.Assert.fail;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.MurmurHash3v2;
+import org.apache.datasketches.memory.hash.MurmurHash3v2;
import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.Assert;
@@ -251,10 +252,10 @@ public class MurmurHash3v2Test {
} catch (final IllegalArgumentException e) { }
try {
long[] out = new long[2];
- Memory mem = Memory.wrap(new byte[0]);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(new byte[0]);
out = hash(mem, 0L, 4L, 1L, out);
} catch (final IllegalArgumentException e) { }
- try (WritableHandle wh = WritableMemory.allocateDirect(8)) {
+ try (WritableHandle wh = DefaultMemoryFactory.DEFAULT.allocateDirect(8)) {
long[] out = new long[2];
Memory mem = wh.get();
out = hash(mem, 0L, 4L, 1L, out);
@@ -264,7 +265,7 @@ public class MurmurHash3v2Test {
@Test
public void checkHashTails() {
long[] out = new long[2];
- WritableMemory mem = WritableMemory.allocate(32);
+ WritableMemory mem = DefaultMemoryFactory.DEFAULT.allocate(32);
mem.fill((byte)85);
for (int i = 16; i <= 32; i++) {
diff --git a/src/test/java/org/apache/datasketches/memory/internal/NativeWritableBufferImplTest.java b/src/test/java/org/apache/datasketches/memory/internal/NativeWritableBufferImplTest.java
index 0461104..80ca382 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/NativeWritableBufferImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/NativeWritableBufferImplTest.java
@@ -28,11 +28,13 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.DefaultBufferFactory;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.ReadOnlyException;
import org.apache.datasketches.memory.WritableBuffer;
import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.unsafe.UnsafeUtil;
import org.testng.Assert;
import org.testng.annotations.Test;
@@ -43,7 +45,7 @@ public class NativeWritableBufferImplTest {
@Test
public void checkNativeCapacityAndClose() throws Exception {
int memCapacity = 64;
- WritableHandle wmh = WritableMemory.allocateDirect(memCapacity);
+ WritableHandle wmh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity);
WritableMemory wmem = wmh.getWritable();
WritableBuffer wbuf = wmem.asWritableBuffer();
assertEquals(wbuf.getCapacity(), memCapacity);
@@ -61,13 +63,13 @@ public class NativeWritableBufferImplTest {
boolean[] srcArray = { true, false, true, false, false, true, true, false };
boolean[] dstArray = new boolean[8];
- Buffer buf = Memory.wrap(srcArray).asBuffer();
+ Buffer buf = DefaultMemoryFactory.DEFAULT.wrap(srcArray).asBuffer();
buf.getBooleanArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray).asWritableBuffer();
wbuf.getBooleanArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -80,13 +82,13 @@ public class NativeWritableBufferImplTest {
byte[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
byte[] dstArray = new byte[8];
- Buffer buf = Memory.wrap(srcArray).asBuffer();
+ Buffer buf = DefaultMemoryFactory.DEFAULT.wrap(srcArray).asBuffer();
buf.getByteArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray).asWritableBuffer();
wbuf.getByteArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -98,13 +100,13 @@ public class NativeWritableBufferImplTest {
char[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
char[] dstArray = new char[8];
- Buffer buf = Memory.wrap(srcArray).asBuffer();
+ Buffer buf = DefaultMemoryFactory.DEFAULT.wrap(srcArray).asBuffer();
buf.getCharArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray).asWritableBuffer();
wbuf.getCharArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -116,13 +118,13 @@ public class NativeWritableBufferImplTest {
short[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
short[] dstArray = new short[8];
- Buffer buf = Memory.wrap(srcArray).asBuffer();
+ Buffer buf = DefaultMemoryFactory.DEFAULT.wrap(srcArray).asBuffer();
buf.getShortArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray).asWritableBuffer();
wbuf.getShortArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -134,13 +136,13 @@ public class NativeWritableBufferImplTest {
int[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
int[] dstArray = new int[8];
- Buffer buf = Memory.wrap(srcArray).asBuffer();
+ Buffer buf = DefaultMemoryFactory.DEFAULT.wrap(srcArray).asBuffer();
buf.getIntArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray).asWritableBuffer();
wbuf.getIntArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -152,13 +154,13 @@ public class NativeWritableBufferImplTest {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
long[] dstArray = new long[8];
- Buffer buf = Memory.wrap(srcArray).asBuffer();
+ Buffer buf = DefaultMemoryFactory.DEFAULT.wrap(srcArray).asBuffer();
buf.getLongArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray).asWritableBuffer();
wbuf.getLongArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -170,13 +172,13 @@ public class NativeWritableBufferImplTest {
float[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
float[] dstArray = new float[8];
- Buffer buf = Memory.wrap(srcArray).asBuffer();
+ Buffer buf = DefaultMemoryFactory.DEFAULT.wrap(srcArray).asBuffer();
buf.getFloatArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray).asWritableBuffer();
wbuf.getFloatArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -188,13 +190,13 @@ public class NativeWritableBufferImplTest {
double[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
double[] dstArray = new double[8];
- Buffer buf = Memory.wrap(srcArray).asBuffer();
+ Buffer buf = DefaultMemoryFactory.DEFAULT.wrap(srcArray).asBuffer();
buf.getDoubleArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray).asWritableBuffer();
wbuf.getDoubleArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -204,7 +206,7 @@ public class NativeWritableBufferImplTest {
@Test
public void checkNativeBaseBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory wmem = wrh.getWritable();
WritableBuffer wbuf = wmem.asWritableBuffer();
wbuf.toHexString("Force Assertion Error", memCapacity, 8);
@@ -216,7 +218,7 @@ public class NativeWritableBufferImplTest {
@Test
public void checkNativeSrcArrayBound() throws Exception {
long memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory wmem = wrh.getWritable();
WritableBuffer wbuf = wmem.asWritableBuffer();
byte[] srcArray = { 1, -2, 3, -4 };
@@ -230,10 +232,10 @@ public class NativeWritableBufferImplTest {
@Test(expectedExceptions = IllegalArgumentException.class)
public void checkRegionBounds() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory wmem = wrh.getWritable();
WritableBuffer wbuf = wmem.asWritableBuffer();
- wbuf.writableRegion(1, 64, wbuf.getTypeByteOrder()); //wrong!
+ wbuf.writableRegion(1, 64, wbuf.getByteOrder()); //wrong!
}
}
@@ -247,7 +249,7 @@ public class NativeWritableBufferImplTest {
byteBuf.put(i, (byte) i);
}
- WritableBuffer wbuf = WritableBuffer.writableWrap(byteBuf);
+ WritableBuffer wbuf = DefaultBufferFactory.DEFAULT.writableWrap(byteBuf);
for (int i=0; i<memCapacity; i++) {
assertEquals(wbuf.getByte(), byteBuf.get(i));
@@ -269,7 +271,7 @@ public class NativeWritableBufferImplTest {
byteBuf.put(i, (byte) i);
}
- Buffer buf = WritableBuffer.writableWrap(byteBuf);
+ Buffer buf = DefaultBufferFactory.DEFAULT.writableWrap(byteBuf);
for (int i = 0; i < memCapacity; i++) {
assertEquals(buf.getByte(), byteBuf.get(i));
@@ -278,7 +280,7 @@ public class NativeWritableBufferImplTest {
//println(mem.toHexString("HeapBB", 0, memCapacity));
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void checkWrapWithBBReadonly2() {
int memCapacity = 64;
ByteBuffer byteBuf = ByteBuffer.allocate(memCapacity);
@@ -286,7 +288,7 @@ public class NativeWritableBufferImplTest {
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
byteBufRO.order(ByteOrder.nativeOrder());
assertTrue(true);
- WritableBuffer wbuf = WritableBuffer.writableWrap(byteBufRO);
+ WritableBuffer wbuf = DefaultBufferFactory.DEFAULT.writableWrap(byteBufRO);
assertTrue(wbuf.isReadOnly());
}
@@ -302,7 +304,7 @@ public class NativeWritableBufferImplTest {
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
byteBufRO.order(ByteOrder.nativeOrder());
- Buffer buf = Buffer.wrap(byteBufRO);
+ Buffer buf = DefaultBufferFactory.DEFAULT.wrap(byteBufRO);
for (int i = 0; i < memCapacity; i++) {
assertEquals(buf.getByte(), byteBuf.get(i));
@@ -311,14 +313,14 @@ public class NativeWritableBufferImplTest {
//println(mem.toHexString("HeapBB", 0, memCapacity));
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void checkWrapWithDirectBBReadonlyPut() {
int memCapacity = 64;
ByteBuffer byteBuf = ByteBuffer.allocateDirect(memCapacity);
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
byteBufRO.order(ByteOrder.nativeOrder());
- WritableBuffer.writableWrap(byteBufRO);
+ DefaultBufferFactory.DEFAULT.writableWrap(byteBufRO);
}
@Test
@@ -331,7 +333,7 @@ public class NativeWritableBufferImplTest {
byteBuf.put(i, (byte) i);
}
- Buffer buf = Buffer.wrap(byteBuf);
+ Buffer buf = DefaultBufferFactory.DEFAULT.wrap(byteBuf);
for (int i=0; i<memCapacity; i++) {
assertEquals(buf.getByte(), byteBuf.get(i));
@@ -343,9 +345,9 @@ public class NativeWritableBufferImplTest {
@Test
public void checkIsDirect() throws Exception {
int memCapacity = 64;
- WritableBuffer mem = WritableMemory.allocate(memCapacity).asWritableBuffer();
+ WritableBuffer mem = DefaultMemoryFactory.DEFAULT.allocate(memCapacity).asWritableBuffer();
assertFalse(mem.isDirect());
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem2 = wrh.getWritable();
WritableBuffer wbuf = mem2.asWritableBuffer();
assertTrue(wbuf.isDirect());
@@ -357,7 +359,7 @@ public class NativeWritableBufferImplTest {
public void checkIsReadOnly() {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
- WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray).asWritableBuffer();
assertFalse(wbuf.isReadOnly());
Buffer buf = wbuf;
@@ -379,9 +381,9 @@ public class NativeWritableBufferImplTest {
byte[] arr2 = new byte[] {0, 1, 2, 4};
byte[] arr3 = new byte[] {0, 1, 2, 3, 4};
- Buffer buf1 = Memory.wrap(arr1).asBuffer();
- Buffer buf2 = Memory.wrap(arr2).asBuffer();
- Buffer buf3 = Memory.wrap(arr3).asBuffer();
+ Buffer buf1 = DefaultMemoryFactory.DEFAULT.wrap(arr1).asBuffer();
+ Buffer buf2 = DefaultMemoryFactory.DEFAULT.wrap(arr2).asBuffer();
+ Buffer buf3 = DefaultMemoryFactory.DEFAULT.wrap(arr3).asBuffer();
int comp = buf1.compareTo(0, 3, buf2, 0, 3);
assertEquals(comp, 0);
@@ -402,9 +404,9 @@ public class NativeWritableBufferImplTest {
byte[] arr2 = new byte[] {0, 1, 2, 4};
byte[] arr3 = new byte[] {0, 1, 2, 3, 4};
- try (WritableHandle h1 = WritableMemory.allocateDirect(4);
- WritableHandle h2 = WritableMemory.allocateDirect(4);
- WritableHandle h3 = WritableMemory.allocateDirect(5))
+ try (WritableHandle h1 = DefaultMemoryFactory.DEFAULT.allocateDirect(4);
+ WritableHandle h2 = DefaultMemoryFactory.DEFAULT.allocateDirect(4);
+ WritableHandle h3 = DefaultMemoryFactory.DEFAULT.allocateDirect(5))
{
WritableMemory mem1 = h1.getWritable();
mem1.putByteArray(0, arr1, 0, 4);
@@ -435,7 +437,7 @@ public class NativeWritableBufferImplTest {
@Test
public void checkAsBuffer() {
- WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(64);
WritableBuffer wbuf = wmem.asWritableBuffer();
wbuf.setPosition(32);
for (int i = 32; i < 64; i++) { wbuf.putByte((byte)i); }
@@ -450,7 +452,7 @@ public class NativeWritableBufferImplTest {
@Test
public void checkDuplicate() {
- WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(64);
for (int i = 0; i < 64; i++) { wmem.putByte(i, (byte)i); }
WritableBuffer wbuf = wmem.asWritableBuffer().writableDuplicate();
@@ -473,7 +475,7 @@ public class NativeWritableBufferImplTest {
@Test
public void checkCumAndRegionOffset() {
- WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(64);
WritableMemory reg = wmem.writableRegion(32, 32);
WritableBuffer buf = reg.asWritableBuffer();
assertEquals(buf.getRegionOffset(), 32);
@@ -485,14 +487,14 @@ public class NativeWritableBufferImplTest {
@Test
public void checkIsSameResource() {
byte[] byteArr = new byte[64];
- WritableBuffer wbuf1 = WritableMemory.writableWrap(byteArr).asWritableBuffer();
- WritableBuffer wbuf2 = WritableMemory.writableWrap(byteArr).asWritableBuffer();
+ WritableBuffer wbuf1 = DefaultMemoryFactory.DEFAULT.writableWrap(byteArr).asWritableBuffer();
+ WritableBuffer wbuf2 = DefaultMemoryFactory.DEFAULT.writableWrap(byteArr).asWritableBuffer();
assertTrue(wbuf1.isSameResource(wbuf2));
}
@Test
public void checkDegenerateRegionReturn() {
- Memory mem = Memory.wrap(new byte[0]);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(new byte[0]);
Buffer buf = mem.asBuffer();
Buffer reg = buf.region();
assertEquals(reg.getCapacity(), 0);
@@ -501,16 +503,16 @@ public class NativeWritableBufferImplTest {
@Test
public void checkAsWritableMemoryRO() {
ByteBuffer bb = ByteBuffer.allocate(64);
- WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
+ WritableBuffer wbuf = DefaultBufferFactory.DEFAULT.writableWrap(bb);
WritableMemory wmem = wbuf.asWritableMemory(); //OK
assertNotNull(wmem);
try {
- Buffer buf = Buffer.wrap(bb.asReadOnlyBuffer());
+ Buffer buf = DefaultBufferFactory.DEFAULT.wrap(bb.asReadOnlyBuffer());
wbuf = (WritableBuffer) buf;
wmem = wbuf.asWritableMemory();
Assert.fail();
- } catch (ReadOnlyException expected) {
+ } catch (IllegalArgumentException expected) {
// expected
}
}
@@ -518,17 +520,17 @@ public class NativeWritableBufferImplTest {
@Test
public void checkWritableDuplicateRO() {
ByteBuffer bb = ByteBuffer.allocate(64);
- WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
+ WritableBuffer wbuf = DefaultBufferFactory.DEFAULT.writableWrap(bb);
@SuppressWarnings("unused")
WritableBuffer wdup = wbuf.writableDuplicate();
try {
- Buffer buf = Buffer.wrap(bb);
+ Buffer buf = DefaultBufferFactory.DEFAULT.wrap(bb);
wbuf = (WritableBuffer) buf;
@SuppressWarnings("unused")
WritableBuffer wdup2 = wbuf.writableDuplicate();
Assert.fail();
- } catch (ReadOnlyException expected) {
+ } catch (IllegalArgumentException expected) {
// ignore
}
}
@@ -536,17 +538,17 @@ public class NativeWritableBufferImplTest {
@Test
public void checkWritableRegionRO() {
ByteBuffer bb = ByteBuffer.allocate(64);
- WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
+ WritableBuffer wbuf = DefaultBufferFactory.DEFAULT.writableWrap(bb);
@SuppressWarnings("unused")
WritableBuffer wreg = wbuf.writableRegion();
try {
- Buffer buf = Buffer.wrap(bb);
+ Buffer buf = DefaultBufferFactory.DEFAULT.wrap(bb);
wbuf = (WritableBuffer) buf;
@SuppressWarnings("unused")
WritableBuffer wreg2 = wbuf.writableRegion();
Assert.fail();
- } catch (ReadOnlyException expected) {
+ } catch (IllegalArgumentException expected) {
// ignore
}
}
@@ -554,32 +556,32 @@ public class NativeWritableBufferImplTest {
@Test
public void checkWritableRegionWithParamsRO() {
ByteBuffer bb = ByteBuffer.allocate(64);
- WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
+ WritableBuffer wbuf = DefaultBufferFactory.DEFAULT.writableWrap(bb);
@SuppressWarnings("unused")
- WritableBuffer wreg = wbuf.writableRegion(0, 1, wbuf.getTypeByteOrder());
+ WritableBuffer wreg = wbuf.writableRegion(0, 1, wbuf.getByteOrder());
try {
- Buffer buf = Buffer.wrap(bb);
+ Buffer buf = DefaultBufferFactory.DEFAULT.wrap(bb);
wbuf = (WritableBuffer) buf;
@SuppressWarnings("unused")
- WritableBuffer wreg2 = wbuf.writableRegion(0, 1, wbuf.getTypeByteOrder());
+ WritableBuffer wreg2 = wbuf.writableRegion(0, 1, wbuf.getByteOrder());
Assert.fail();
- } catch (ReadOnlyException expected) {
+ } catch (IllegalArgumentException expected) {
// ignore
}
}
@Test
public void checkZeroBuffer() {
- WritableMemory wmem = WritableMemory.allocate(8);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(8);
WritableBuffer wbuf = wmem.asWritableBuffer();
- WritableBuffer reg = wbuf.writableRegion(0, 0, wbuf.getTypeByteOrder());
+ WritableBuffer reg = wbuf.writableRegion(0, 0, wbuf.getByteOrder());
assertEquals(reg.getCapacity(), 0);
}
@Test
public void checkDuplicateNonNative() {
- WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(64);
wmem.putShort(0, (short) 1);
Buffer buf = wmem.asWritableBuffer().duplicate(Util.NON_NATIVE_BYTE_ORDER);
assertEquals(buf.getShort(0), 256);
diff --git a/src/test/java/org/apache/datasketches/memory/internal/NativeWritableMemoryImplTest.java b/src/test/java/org/apache/datasketches/memory/internal/NativeWritableMemoryImplTest.java
index 8d52250..68e1e40 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/NativeWritableMemoryImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/NativeWritableMemoryImplTest.java
@@ -29,10 +29,11 @@ import java.nio.ByteOrder;
import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.ReadOnlyException;
import org.apache.datasketches.memory.WritableBuffer;
import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.unsafe.UnsafeUtil;
import org.testng.annotations.Test;
public class NativeWritableMemoryImplTest {
@@ -42,7 +43,7 @@ public class NativeWritableMemoryImplTest {
@Test
public void checkNativeCapacityAndClose() throws Exception {
int memCapacity = 64;
- WritableHandle wmh = WritableMemory.allocateDirect(memCapacity);
+ WritableHandle wmh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity);
WritableMemory mem = wmh.getWritable();
assertEquals(memCapacity, mem.getCapacity());
@@ -59,13 +60,13 @@ public class NativeWritableMemoryImplTest {
boolean[] srcArray = { true, false, true, false, false, true, true, false };
boolean[] dstArray = new boolean[8];
- Memory mem = Memory.wrap(srcArray);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(srcArray);
mem.getBooleanArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray);
wmem.getBooleanArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -78,13 +79,13 @@ public class NativeWritableMemoryImplTest {
byte[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
byte[] dstArray = new byte[8];
- Memory mem = Memory.wrap(srcArray);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(srcArray);
mem.getByteArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray);
wmem.getByteArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -96,13 +97,13 @@ public class NativeWritableMemoryImplTest {
char[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
char[] dstArray = new char[8];
- Memory mem = Memory.wrap(srcArray);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(srcArray);
mem.getCharArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray);
wmem.getCharArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -114,13 +115,13 @@ public class NativeWritableMemoryImplTest {
short[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
short[] dstArray = new short[8];
- Memory mem = Memory.wrap(srcArray);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(srcArray);
mem.getShortArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray);
wmem.getShortArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -132,13 +133,13 @@ public class NativeWritableMemoryImplTest {
int[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
int[] dstArray = new int[8];
- Memory mem = Memory.wrap(srcArray);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(srcArray);
mem.getIntArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray);
wmem.getIntArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -150,13 +151,13 @@ public class NativeWritableMemoryImplTest {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
long[] dstArray = new long[8];
- Memory mem = Memory.wrap(srcArray);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(srcArray);
mem.getLongArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray);
wmem.getLongArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -168,13 +169,13 @@ public class NativeWritableMemoryImplTest {
float[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
float[] dstArray = new float[8];
- Memory mem = Memory.wrap(srcArray);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(srcArray);
mem.getFloatArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray);
wmem.getFloatArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -186,13 +187,13 @@ public class NativeWritableMemoryImplTest {
double[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
double[] dstArray = new double[8];
- Memory mem = Memory.wrap(srcArray);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(srcArray);
mem.getDoubleArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray);
wmem.getDoubleArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -202,7 +203,7 @@ public class NativeWritableMemoryImplTest {
@Test
public void checkNativeBaseBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
mem.toHexString("Force Assertion Error", memCapacity, 8);
} catch (IllegalArgumentException e) {
@@ -213,7 +214,7 @@ public class NativeWritableMemoryImplTest {
@Test
public void checkNativeSrcArrayBound() throws Exception {
long memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
byte[] srcArray = { 1, -2, 3, -4 };
mem.putByteArray(0L, srcArray, 0, 5);
@@ -226,7 +227,7 @@ public class NativeWritableMemoryImplTest {
@Test(expectedExceptions = IllegalArgumentException.class)
public void checkDegenerateCopyTo() {
- WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(64);
wmem.copyTo(0, wmem, 0, 64);
}
@@ -234,7 +235,7 @@ public class NativeWritableMemoryImplTest {
public void checkCopyWithinNativeSmall() throws Exception {
int memCapacity = 64;
int half = memCapacity/2;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
mem.clear();
@@ -256,7 +257,7 @@ public class NativeWritableMemoryImplTest {
int memCapLongs = memCapacity / 8;
int halfBytes = memCapacity / 2;
int halfLongs = memCapLongs / 2;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
mem.clear();
@@ -275,7 +276,7 @@ public class NativeWritableMemoryImplTest {
@Test
public void checkCopyWithinNativeSrcBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
mem.copyTo(32, mem, 32, 33); //hit source bound check
fail("Did Not Catch Assertion Error: source bound");
@@ -288,7 +289,7 @@ public class NativeWritableMemoryImplTest {
@Test
public void checkCopyWithinNativeDstBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
mem.copyTo(0, mem, 32, 33); //hit dst bound check
fail("Did Not Catch Assertion Error: dst bound");
@@ -302,8 +303,8 @@ public class NativeWritableMemoryImplTest {
public void checkCopyCrossNativeSmall() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity);
- WritableHandle wrh2 = WritableMemory.allocateDirect(memCapacity))
+ try (WritableHandle wrh1 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity);
+ WritableHandle wrh2 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity))
{
WritableMemory mem1 = wrh1.getWritable();
WritableMemory mem2 = wrh2.getWritable();
@@ -327,8 +328,8 @@ public class NativeWritableMemoryImplTest {
int memCapacity = (2<<20) + 64;
int memCapLongs = memCapacity / 8;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity);
- WritableHandle wrh2 = WritableMemory.allocateDirect(memCapacity))
+ try (WritableHandle wrh1 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity);
+ WritableHandle wrh2 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity))
{
WritableMemory mem1 = wrh1.getWritable();
WritableMemory mem2 = wrh2.getWritable();
@@ -349,14 +350,14 @@ public class NativeWritableMemoryImplTest {
@Test
public void checkCopyCrossNativeAndByteArray() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh1 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem1 = wrh1.getWritable();
for (int i= 0; i < mem1.getCapacity(); i++) {
mem1.putByte(i, (byte) i);
}
- WritableMemory mem2 = WritableMemory.allocate(memCapacity);
+ WritableMemory mem2 = DefaultMemoryFactory.DEFAULT.allocate(memCapacity);
mem1.copyTo(8, mem2, 16, 16);
for (int i=0; i<16; i++) {
@@ -370,7 +371,7 @@ public class NativeWritableMemoryImplTest {
public void checkCopyCrossRegionsSameNative() throws Exception {
int memCapacity = 128;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh1 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem1 = wrh1.getWritable();
for (int i= 0; i < mem1.getCapacity(); i++) {
@@ -396,7 +397,7 @@ public class NativeWritableMemoryImplTest {
@Test
public void checkCopyCrossNativeArrayAndHierarchicalRegions() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh1 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem1 = wrh1.getWritable();
for (int i= 0; i < mem1.getCapacity(); i++) { //fill with numbers
@@ -404,7 +405,7 @@ public class NativeWritableMemoryImplTest {
}
//println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
- WritableMemory mem2 = WritableMemory.allocate(memCapacity);
+ WritableMemory mem2 = DefaultMemoryFactory.DEFAULT.allocate(memCapacity);
Memory reg1 = mem1.region(8, 32);
Memory reg1B = reg1.region(8, 16);
@@ -426,7 +427,7 @@ public class NativeWritableMemoryImplTest {
@Test(expectedExceptions = IllegalArgumentException.class)
public void checkRegionBounds() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
mem.writableRegion(1, 64);
}
@@ -442,7 +443,7 @@ public class NativeWritableMemoryImplTest {
byteBuf.put(i, (byte) i);
}
- WritableMemory wmem = WritableMemory.writableWrap(byteBuf);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(byteBuf);
for (int i=0; i<memCapacity; i++) {
assertEquals(wmem.getByte(i), byteBuf.get(i));
@@ -464,7 +465,7 @@ public class NativeWritableMemoryImplTest {
byteBuf.put(i, (byte) i);
}
- Memory mem = WritableMemory.writableWrap(byteBuf);
+ Memory mem = DefaultMemoryFactory.DEFAULT.writableWrap(byteBuf);
for (int i = 0; i < memCapacity; i++) {
assertEquals(mem.getByte(i), byteBuf.get(i));
@@ -473,14 +474,14 @@ public class NativeWritableMemoryImplTest {
//println(mem.toHexString("HeapBB", 0, memCapacity));
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void checkWrapWithBBReadonly2() {
int memCapacity = 64;
ByteBuffer byteBuf = ByteBuffer.allocate(memCapacity);
byteBuf.order(ByteOrder.nativeOrder());
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
- WritableMemory.writableWrap(byteBufRO);
+ DefaultMemoryFactory.DEFAULT.writableWrap(byteBufRO);
}
@Test
@@ -495,7 +496,7 @@ public class NativeWritableMemoryImplTest {
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
byteBufRO.order(ByteOrder.nativeOrder());
- Memory mem = Memory.wrap(byteBufRO);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(byteBufRO);
for (int i = 0; i < memCapacity; i++) {
assertEquals(mem.getByte(i), byteBuf.get(i));
@@ -504,14 +505,14 @@ public class NativeWritableMemoryImplTest {
//println(mem.toHexString("HeapBB", 0, memCapacity));
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void checkWrapWithDirectBBReadonlyPut() {
int memCapacity = 64;
ByteBuffer byteBuf = ByteBuffer.allocateDirect(memCapacity);
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
byteBufRO.order(ByteOrder.nativeOrder());
- WritableMemory.writableWrap(byteBufRO);
+ DefaultMemoryFactory.DEFAULT.writableWrap(byteBufRO);
}
@Test
@@ -524,7 +525,7 @@ public class NativeWritableMemoryImplTest {
byteBuf.put(i, (byte) i);
}
- Memory mem = Memory.wrap(byteBuf);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(byteBuf);
for (int i=0; i<memCapacity; i++) {
assertEquals(mem.getByte(i), byteBuf.get(i));
@@ -536,9 +537,9 @@ public class NativeWritableMemoryImplTest {
@Test
public void checkIsDirect() throws Exception {
int memCapacity = 64;
- WritableMemory mem = WritableMemory.allocate(memCapacity);
+ WritableMemory mem = DefaultMemoryFactory.DEFAULT.allocate(memCapacity);
assertFalse(mem.isDirect());
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
mem = wrh.getWritable();
assertTrue(mem.isDirect());
wrh.close();
@@ -549,7 +550,7 @@ public class NativeWritableMemoryImplTest {
public void checkIsReadOnly() {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
- WritableMemory wmem = WritableMemory.writableWrap(srcArray);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(srcArray);
assertFalse(wmem.isReadOnly());
Memory memRO = wmem;
@@ -571,10 +572,10 @@ public class NativeWritableMemoryImplTest {
byte[] arr2 = new byte[] {0, 1, 2, 4};
byte[] arr3 = new byte[] {0, 1, 2, 3, 4};
- Memory mem1 = Memory.wrap(arr1);
- Memory mem2 = Memory.wrap(arr2);
- Memory mem3 = Memory.wrap(arr3);
- Memory mem4 = Memory.wrap(arr3); //same resource
+ Memory mem1 = DefaultMemoryFactory.DEFAULT.wrap(arr1);
+ Memory mem2 = DefaultMemoryFactory.DEFAULT.wrap(arr2);
+ Memory mem3 = DefaultMemoryFactory.DEFAULT.wrap(arr3);
+ Memory mem4 = DefaultMemoryFactory.DEFAULT.wrap(arr3); //same resource
int comp = mem1.compareTo(0, 3, mem2, 0, 3);
assertEquals(comp, 0);
@@ -600,9 +601,9 @@ public class NativeWritableMemoryImplTest {
byte[] arr2 = new byte[] {0, 1, 2, 4};
byte[] arr3 = new byte[] {0, 1, 2, 3, 4};
- try (WritableHandle h1 = WritableMemory.allocateDirect(4);
- WritableHandle h2 = WritableMemory.allocateDirect(4);
- WritableHandle h3 = WritableMemory.allocateDirect(5))
+ try (WritableHandle h1 = DefaultMemoryFactory.DEFAULT.allocateDirect(4);
+ WritableHandle h2 = DefaultMemoryFactory.DEFAULT.allocateDirect(4);
+ WritableHandle h3 = DefaultMemoryFactory.DEFAULT.allocateDirect(5))
{
WritableMemory mem1 = h1.getWritable();
mem1.putByteArray(0, arr1, 0, 4);
@@ -629,7 +630,7 @@ public class NativeWritableMemoryImplTest {
@Test
public void testCompareToSameStart() {
- Memory mem = WritableMemory.allocate(3);
+ Memory mem = DefaultMemoryFactory.DEFAULT.allocate(3);
assertEquals(-1, mem.compareTo(0, 1, mem, 0, 2));
assertEquals(0, mem.compareTo(1, 1, mem, 1, 1));
assertEquals(1, mem.compareTo(1, 2, mem, 1, 1));
@@ -637,7 +638,7 @@ public class NativeWritableMemoryImplTest {
@Test
public void checkAsBuffer() {
- WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(64);
WritableBuffer wbuf = wmem.asWritableBuffer();
wbuf.setPosition(32);
for (int i = 32; i < 64; i++) { wbuf.putByte((byte)i); }
@@ -652,7 +653,7 @@ public class NativeWritableMemoryImplTest {
@Test
public void checkCumAndRegionOffset() {
- WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(64);
WritableMemory reg = wmem.writableRegion(32, 32);
assertEquals(reg.getRegionOffset(), 32);
assertEquals(reg.getRegionOffset(0), 32);
@@ -663,8 +664,8 @@ public class NativeWritableMemoryImplTest {
@Test
public void checkIsSameResource() {
byte[] byteArr = new byte[64];
- WritableMemory wmem1 = WritableMemory.writableWrap(byteArr);
- WritableMemory wmem2 = WritableMemory.writableWrap(byteArr);
+ WritableMemory wmem1 = DefaultMemoryFactory.DEFAULT.writableWrap(byteArr);
+ WritableMemory wmem2 = DefaultMemoryFactory.DEFAULT.writableWrap(byteArr);
assertTrue(wmem1.isSameResource(wmem2));
}
@@ -673,36 +674,36 @@ public class NativeWritableMemoryImplTest {
ByteBuffer byteBuf = ByteBuffer.allocate(64);
byteBuf.position(16);
byteBuf.limit(48);
- WritableMemory wmem = WritableMemory.writableWrap(byteBuf);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(byteBuf);
WritableBuffer wbuf = wmem.asWritableBuffer();
assertEquals(wbuf.getCapacity(), 64);
assertEquals(wbuf.getPosition(), 0);
assertEquals(wbuf.getEnd(), 64);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void checkAsWritableRegionRO() {
ByteBuffer byteBuf = ByteBuffer.allocate(64);
- WritableMemory wmem = (WritableMemory) Memory.wrap(byteBuf);
+ WritableMemory wmem = (WritableMemory) DefaultMemoryFactory.DEFAULT.wrap(byteBuf);
wmem.writableRegion(0, 1);
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void checkAsWritableBufferRO() {
ByteBuffer byteBuf = ByteBuffer.allocate(64);
- WritableMemory wmem = (WritableMemory) Memory.wrap(byteBuf);
+ WritableMemory wmem = (WritableMemory) DefaultMemoryFactory.DEFAULT.wrap(byteBuf);
wmem.asWritableBuffer();
}
@Test void checkZeroMemory() {
- WritableMemory wmem = WritableMemory.allocate(8);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(8);
WritableMemory reg = wmem.writableRegion(0, 0);
assertEquals(reg.getCapacity(), 0);
}
@Test
public void checkAsBufferNonNative() {
- WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(64);
wmem.putShort(0, (short) 1);
Buffer buf = wmem.asBuffer(Util.NON_NATIVE_BYTE_ORDER);
assertEquals(buf.getShort(0), 256);
diff --git a/src/test/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImplTest.java b/src/test/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImplTest.java
index 57d481a..225cec1 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/NonNativeWritableBufferImplTest.java
@@ -24,6 +24,7 @@ import static org.testng.Assert.assertEquals;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.WritableBuffer;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@@ -40,7 +41,7 @@ public class NonNativeWritableBufferImplTest {
int m = Character.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemory wmem = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
WritableBuffer wbuf = wmem.asWritableBuffer();
char ch = 'a';
for (int i = 0; i < n; i++) { wbuf.putChar(i * m, ch++); }
@@ -61,7 +62,7 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getCharArray(cArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = DefaultMemoryFactory.DEFAULT.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putCharArray(cArr, 0, n);
assertEquals(arr2, arr1);
@@ -73,7 +74,7 @@ public class NonNativeWritableBufferImplTest {
int m = Double.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemory wmem = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
WritableBuffer wbuf = wmem.asWritableBuffer();
double dbl = 1.0;
for (int i = 0; i < n; i++) { wbuf.putDouble(i * m, dbl++); }
@@ -94,7 +95,7 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getDoubleArray(dblArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = DefaultMemoryFactory.DEFAULT.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putDoubleArray(dblArr, 0, n);
assertEquals(arr2, arr1);
@@ -106,7 +107,7 @@ public class NonNativeWritableBufferImplTest {
int m = Float.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemory wmem = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
WritableBuffer wbuf = wmem.asWritableBuffer();
float flt = 1.0F;
for (int i = 0; i < n; i++) { wbuf.putFloat(i * m, flt++); }
@@ -127,7 +128,7 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getFloatArray(fltArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = DefaultMemoryFactory.DEFAULT.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putFloatArray(fltArr, 0, n);
assertEquals(arr2, arr1);
@@ -139,7 +140,7 @@ public class NonNativeWritableBufferImplTest {
int m = Integer.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemory wmem = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
WritableBuffer wbuf = wmem.asWritableBuffer();
int intg = 1;
for (int i = 0; i < n; i++) { wbuf.putInt(i * m, intg++); }
@@ -160,7 +161,7 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getIntArray(intArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = DefaultMemoryFactory.DEFAULT.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putIntArray(intArr, 0, n);
assertEquals(arr2, arr1);
@@ -172,7 +173,7 @@ public class NonNativeWritableBufferImplTest {
int m = Long.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemory wmem = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
WritableBuffer wbuf = wmem.asWritableBuffer();
long lng = 1;
for (int i = 0; i < n; i++) { wbuf.putLong(i * m, lng++); }
@@ -193,7 +194,7 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getLongArray(longArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = DefaultMemoryFactory.DEFAULT.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putLongArray(longArr, 0, n);
assertEquals(arr2, arr1);
@@ -205,7 +206,7 @@ public class NonNativeWritableBufferImplTest {
int m = Short.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemory wmem = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
WritableBuffer wbuf = wmem.asWritableBuffer();
short sht = 1;
for (int i = 0; i < n; i++) { wbuf.putShort(i * m, sht++); }
@@ -226,7 +227,7 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getShortArray(shortArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = DefaultMemoryFactory.DEFAULT.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putShortArray(shortArr, 0, n);
assertEquals(arr2, arr1);
@@ -236,25 +237,25 @@ public class NonNativeWritableBufferImplTest {
@Test
public void checkDuplicate() {
byte[] bArr = new byte[8];
- WritableMemory wmem = WritableMemory.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
WritableBuffer wbuf = wmem.asWritableBuffer();
WritableBuffer wdup = wbuf.writableDuplicate();
- assertEquals(wdup.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
+ assertEquals(wdup.getByteOrder(), ByteOrder.BIG_ENDIAN);
WritableBuffer wreg = wbuf.writableRegion();
- assertEquals(wreg.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
+ assertEquals(wreg.getByteOrder(), ByteOrder.BIG_ENDIAN);
}
@Test
public void checkDuplicateZeros() {
byte[] bArr = new byte[0];
- WritableMemory wmem = WritableMemory.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
Buffer buf = wmem.asBuffer();
Buffer dup = buf.duplicate();
- assertEquals(dup.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
+ assertEquals(dup.getByteOrder(), ByteOrder.LITTLE_ENDIAN);
Buffer reg = buf.region();
- assertEquals(reg.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
+ assertEquals(reg.getByteOrder(), ByteOrder.LITTLE_ENDIAN);
}
}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImplTest.java b/src/test/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImplTest.java
index c6bd5d0..c52e235 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/NonNativeWritableMemoryImplTest.java
@@ -23,6 +23,7 @@ import static org.testng.Assert.assertEquals;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@@ -32,7 +33,7 @@ import org.testng.annotations.Test;
*/
public class NonNativeWritableMemoryImplTest {
private byte[] bArr = new byte[8];
- private final WritableMemory wmem = WritableMemory.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
+ private final WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
//Check primitives
@Test
@@ -41,7 +42,7 @@ public class NonNativeWritableMemoryImplTest {
int n = ((1 << 20) / m) + m;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemory wmem1 = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem1 = DefaultMemoryFactory.DEFAULT.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
for (int i = 0; i < n; i++) { wmem1.putChar(i * m, (char) i++); }
for (int i = 0; i < n; i++) {
assertEquals(wmem1.getChar(i * m), (char) i++);
@@ -50,7 +51,7 @@ public class NonNativeWritableMemoryImplTest {
char[] cArr = new char[n]; //native
wmem1.getCharArray(0, cArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = DefaultMemoryFactory.DEFAULT.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
wmem2.putCharArray(0, cArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -61,7 +62,7 @@ public class NonNativeWritableMemoryImplTest {
int n = ((1 << 20) / m) + m;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemory wmem1 = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem1 = DefaultMemoryFactory.DEFAULT.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
double dbl = 1.0;
for (int i = 0; i < n; i++) { wmem1.putDouble(i * m, dbl++); }
dbl = 1.0;
@@ -72,7 +73,7 @@ public class NonNativeWritableMemoryImplTest {
double[] dblArr = new double[n]; //native
wmem1.getDoubleArray(0, dblArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = DefaultMemoryFactory.DEFAULT.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
wmem2.putDoubleArray(0, dblArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -83,7 +84,7 @@ public class NonNativeWritableMemoryImplTest {
int n = ((1 << 20) / m) + m;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemory wmem1 = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem1 = DefaultMemoryFactory.DEFAULT.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
float flt = 1.0F;
for (int i = 0; i < n; i++) { wmem1.putFloat(i * m, flt++); }
flt = 1.0F;
@@ -94,7 +95,7 @@ public class NonNativeWritableMemoryImplTest {
float[] fltArr = new float[n]; //native
wmem1.getFloatArray(0, fltArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = DefaultMemoryFactory.DEFAULT.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
wmem2.putFloatArray(0, fltArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -105,7 +106,7 @@ public class NonNativeWritableMemoryImplTest {
int n = ((1 << 20) / m) + m;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemory wmem1 = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem1 = DefaultMemoryFactory.DEFAULT.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
int intg = 1;
for (int i = 0; i < n; i++) { wmem1.putInt(i * m, intg++); }
intg = 1;
@@ -116,7 +117,7 @@ public class NonNativeWritableMemoryImplTest {
int[] intArr = new int[n]; //native
wmem1.getIntArray(0, intArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = DefaultMemoryFactory.DEFAULT.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
wmem2.putIntArray(0, intArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -127,7 +128,7 @@ public class NonNativeWritableMemoryImplTest {
int n = ((1 << 20) / m) + m;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemory wmem1 = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem1 = DefaultMemoryFactory.DEFAULT.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
long lng = 1;
for (int i = 0; i < n; i++) { wmem1.putLong(i * m, lng++); }
lng = 1;
@@ -138,7 +139,7 @@ public class NonNativeWritableMemoryImplTest {
long[] longArr = new long[n]; //native
wmem1.getLongArray(0, longArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = DefaultMemoryFactory.DEFAULT.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
wmem2.putLongArray(0, longArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -149,7 +150,7 @@ public class NonNativeWritableMemoryImplTest {
int n = ((1 << 20) / m) + m;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemory wmem1 = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem1 = DefaultMemoryFactory.DEFAULT.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
short sht = 1;
for (int i = 0; i < n; i++) { wmem1.putShort(i * m, sht++); }
sht = 1;
@@ -160,7 +161,7 @@ public class NonNativeWritableMemoryImplTest {
short[] shortArr = new short[n]; //native
wmem1.getShortArray(0, shortArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = DefaultMemoryFactory.DEFAULT.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
wmem2.putShortArray(0, shortArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -205,15 +206,15 @@ public class NonNativeWritableMemoryImplTest {
@Test
public void checkRegion() {
WritableMemory wreg = wmem.writableRegion(0, wmem.getCapacity());
- assertEquals(wreg.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
+ assertEquals(wreg.getByteOrder(), ByteOrder.BIG_ENDIAN);
}
@Test
public void checkRegionZeros() {
byte[] bArr1 = new byte[0];
- WritableMemory wmem1 = WritableMemory.writableWrap(bArr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem1 = DefaultMemoryFactory.DEFAULT.writableWrap(bArr1, ByteOrder.BIG_ENDIAN);
Memory reg = wmem1.region(0, wmem1.getCapacity());
- assertEquals(reg.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
+ assertEquals(reg.getByteOrder(), ByteOrder.LITTLE_ENDIAN);
}
}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/RandomCodePoints.java b/src/test/java/org/apache/datasketches/memory/internal/RandomCodePoints.java
new file mode 100644
index 0000000..488ffa2
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/memory/internal/RandomCodePoints.java
@@ -0,0 +1,83 @@
+/**
+ * Copyright 2022 Yahoo Inc. All rights reserved.
+ */
+package org.apache.datasketches.memory.internal;
+
+import java.util.Random;
+
+public class RandomCodePoints {
+ private Random rand; //
+ private static final int ALL_CP = Character.MAX_CODE_POINT + 1;
+ private static final int MIN_SUR = Character.MIN_SURROGATE;
+ private static final int MAX_SUR = Character.MAX_SURROGATE;
+
+ /**
+ * @param deterministic if true, configure java.util.Random with a fixed seed.
+ */
+ public RandomCodePoints(final boolean deterministic) {
+ rand = deterministic ? new Random(0) : new Random();
+ }
+
+ /**
+ * Fills the given array with random valid Code Points from 0, inclusive, to
+ * <i>Character.MAX_CODE_POINT</i>, inclusive.
+ * The surrogate range, which is from <i>Character.MIN_SURROGATE</i>, inclusive, to
+ * <i>Character.MAX_SURROGATE</i>, inclusive, is always <u>excluded</u>.
+ * @param cpArr the array to fill
+ */
+ public final void fillCodePointArray(final int[] cpArr) {
+ fillCodePointArray(cpArr, 0, ALL_CP);
+ }
+
+ /**
+ * Fills the given array with random valid Code Points from <i>startCP</i>, inclusive, to
+ * <i>endCP</i>, exclusive.
+ * The surrogate range, which is from <i>Character.MIN_SURROGATE</i>, inclusive, to
+ * <i>Character.MAX_SURROGATE</i>, inclusive, is always <u>excluded</u>.
+ * @param cpArr the array to fill
+ * @param startCP the starting Code Point, included.
+ * @param endCP the ending Code Point, excluded. This value cannot exceed 0x110000.
+ */
+ public final void fillCodePointArray(final int[] cpArr, final int startCP, final int endCP) {
+ final int arrLen = cpArr.length;
+ final int numCP = Math.min(endCP, 0X110000) - Math.min(0, startCP);
+ int idx = 0;
+ while (idx < arrLen) {
+ final int cp = startCP + rand.nextInt(numCP);
+ if ((cp >= MIN_SUR) && (cp <= MAX_SUR)) {
+ continue;
+ }
+ cpArr[idx++] = cp;
+ }
+ }
+
+ /**
+ * Return a single valid random Code Point from 0, inclusive, to
+ * <i>Character.MAX_CODE_POINT</i>, inclusive.
+ * The surrogate range, which is from <i>Character.MIN_SURROGATE</i>, inclusive, to
+ * <i>Character.MAX_SURROGATE</i>, inclusive, is always <u>excluded</u>.
+ * @return a single valid random CodePoint.
+ */
+ public final int getCodePoint() {
+ return getCodePoint(0, ALL_CP);
+ }
+
+ /**
+ * Return a single valid random Code Point from <i>startCP</i>, inclusive, to
+ * <i>endCP</i>, exclusive.
+ * The surrogate range, which is from <i>Character.MIN_SURROGATE</i>, inclusive, to
+ * <i>Character.MAX_SURROGATE</i>, inclusive, is always <u>excluded</u>.
+ * @param startCP the starting Code Point, included.
+ * @param endCP the ending Code Point, excluded. This value cannot exceed 0x110000.
+ * @return a single valid random CodePoint.
+ */
+ public final int getCodePoint(final int startCP, final int endCP) {
+ final int numCP = Math.min(endCP, 0X110000) - Math.min(0, startCP);
+ while (true) {
+ final int cp = startCP + rand.nextInt(numCP);
+ if ((cp < MIN_SUR) || (cp > MAX_SUR)) {
+ return cp;
+ }
+ }
+ }
+ } //End class RandomCodePoints
\ No newline at end of file
diff --git a/src/test/java/org/apache/datasketches/memory/internal/SpecificLeafTest.java b/src/test/java/org/apache/datasketches/memory/internal/SpecificLeafTest.java
index 87f7e35..6ab9689 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/SpecificLeafTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/SpecificLeafTest.java
@@ -28,9 +28,10 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMapHandle;
+import org.apache.datasketches.memory.WritableMmapHandle;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@@ -45,30 +46,30 @@ public class SpecificLeafTest {
ByteBuffer bb = ByteBuffer.allocate(bytes);
bb.order(ByteOrder.nativeOrder());
- Memory mem = Memory.wrap(bb).region(0, bytes, ByteOrder.nativeOrder());
- assertTrue(((BaseStateImpl)mem).isBBType());
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(bb).region(0, bytes, ByteOrder.nativeOrder());
+ assertTrue(((ResourceImpl)mem).isBBType());
assertTrue(mem.isReadOnly());
checkCrossLeafTypeIds(mem);
Buffer buf = mem.asBuffer().region(0, bytes, ByteOrder.nativeOrder());
bb.order(Util.NON_NATIVE_BYTE_ORDER);
- Memory mem2 = Memory.wrap(bb).region(0, bytes, Util.NON_NATIVE_BYTE_ORDER);
+ Memory mem2 = DefaultMemoryFactory.DEFAULT.wrap(bb).region(0, bytes, Util.NON_NATIVE_BYTE_ORDER);
Buffer buf2 = mem2.asBuffer().region(0, bytes, Util.NON_NATIVE_BYTE_ORDER);
Buffer buf3 = buf2.duplicate();
- assertTrue(((BaseStateImpl)mem).isRegionType());
- assertTrue(((BaseStateImpl)mem2).isRegionType());
- assertTrue(((BaseStateImpl)buf).isRegionType());
- assertTrue(((BaseStateImpl)buf2).isRegionType());
- assertTrue(((BaseStateImpl)buf3).isDuplicateType());
+ assertTrue(((ResourceImpl)mem).isRegionType());
+ assertTrue(((ResourceImpl)mem2).isRegionType());
+ assertTrue(((ResourceImpl)buf).isRegionType());
+ assertTrue(((ResourceImpl)buf2).isRegionType());
+ assertTrue(((ResourceImpl)buf3).isDuplicateType());
}
@Test
public void checkDirectLeafs() throws Exception {
int bytes = 128;
- try (WritableHandle h = WritableMemory.allocateDirect(bytes)) {
+ try (WritableHandle h = DefaultMemoryFactory.DEFAULT.allocateDirect(bytes)) {
WritableMemory wmem = h.getWritable(); //native mem
- assertTrue(((BaseStateImpl)wmem).isDirectType());
+ assertTrue(((ResourceImpl)wmem).isDirectType());
assertFalse(wmem.isReadOnly());
checkCrossLeafTypeIds(wmem);
WritableMemory nnwmem = wmem.writableRegion(0, bytes, Util.NON_NATIVE_BYTE_ORDER);
@@ -81,11 +82,11 @@ public class SpecificLeafTest {
Buffer buf2 = mem2.asBuffer().region(0, bytes, Util.NON_NATIVE_BYTE_ORDER);
Buffer buf3 = buf2.duplicate();
- assertTrue(((BaseStateImpl)mem).isRegionType());
- assertTrue(((BaseStateImpl)mem2).isRegionType());
- assertTrue(((BaseStateImpl)buf).isRegionType());
- assertTrue(((BaseStateImpl)buf2).isRegionType());
- assertTrue(((BaseStateImpl)buf3).isDuplicateType());
+ assertTrue(((ResourceImpl)mem).isRegionType());
+ assertTrue(((ResourceImpl)mem2).isRegionType());
+ assertTrue(((ResourceImpl)buf).isRegionType());
+ assertTrue(((ResourceImpl)buf2).isRegionType());
+ assertTrue(((ResourceImpl)buf3).isDuplicateType());
}
}
@@ -106,9 +107,9 @@ public class SpecificLeafTest {
final long bytes = 128;
- try (WritableMapHandle h = WritableMemory.writableMap(file, 0L, bytes, ByteOrder.nativeOrder())) {
+ try (WritableMmapHandle h = DefaultMemoryFactory.DEFAULT.writableMap(file, 0L, bytes, ByteOrder.nativeOrder())) {
WritableMemory mem = h.getWritable(); //native mem
- assertTrue(((BaseStateImpl)mem).isMapType());
+ assertTrue(((ResourceImpl)mem).isMapType());
assertFalse(mem.isReadOnly());
checkCrossLeafTypeIds(mem);
Memory nnreg = mem.region(0, bytes, Util.NON_NATIVE_BYTE_ORDER);
@@ -121,21 +122,21 @@ public class SpecificLeafTest {
Buffer buf2 = reg2.asBuffer().region(0, bytes, Util.NON_NATIVE_BYTE_ORDER);
Buffer buf3 = buf2.duplicate();
- assertTrue(((BaseStateImpl)reg).isRegionType());
- assertTrue(((BaseStateImpl)reg2).isRegionType());
- assertTrue(((BaseStateImpl)buf).isRegionType());
- assertTrue(((BaseStateImpl)buf2).isRegionType());
- assertTrue(((BaseStateImpl)buf3).isDuplicateType());
- assertTrue(((BaseStateImpl)buf4).isDuplicateType());
+ assertTrue(((ResourceImpl)reg).isRegionType());
+ assertTrue(((ResourceImpl)reg2).isRegionType());
+ assertTrue(((ResourceImpl)buf).isRegionType());
+ assertTrue(((ResourceImpl)buf2).isRegionType());
+ assertTrue(((ResourceImpl)buf3).isDuplicateType());
+ assertTrue(((ResourceImpl)buf4).isDuplicateType());
}
}
@Test
public void checkHeapLeafs() {
int bytes = 128;
- Memory mem = Memory.wrap(new byte[bytes]);
- assertTrue(((BaseStateImpl)mem).isHeapType());
- assertTrue(((BaseStateImpl)mem).isReadOnlyType());
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(new byte[bytes]);
+ assertTrue(((ResourceImpl)mem).isHeapType());
+ assertTrue(((ResourceImpl)mem).isReadOnlyType());
checkCrossLeafTypeIds(mem);
Memory nnreg = mem.region(0, bytes, Util.NON_NATIVE_BYTE_ORDER);
@@ -147,47 +148,47 @@ public class SpecificLeafTest {
Buffer buf2 = reg2.asBuffer().region(0, bytes, Util.NON_NATIVE_BYTE_ORDER);
Buffer buf3 = buf2.duplicate();
- assertFalse(((BaseStateImpl)mem).isRegionType());
- assertTrue(((BaseStateImpl)reg2).isRegionType());
- assertTrue(((BaseStateImpl)buf).isRegionType());
- assertTrue(((BaseStateImpl)buf2).isRegionType());
- assertTrue(((BaseStateImpl)buf3).isDuplicateType());
- assertTrue(((BaseStateImpl)buf4).isDuplicateType());
+ assertFalse(((ResourceImpl)mem).isRegionType());
+ assertTrue(((ResourceImpl)reg2).isRegionType());
+ assertTrue(((ResourceImpl)buf).isRegionType());
+ assertTrue(((ResourceImpl)buf2).isRegionType());
+ assertTrue(((ResourceImpl)buf3).isDuplicateType());
+ assertTrue(((ResourceImpl)buf4).isDuplicateType());
}
private static void checkCrossLeafTypeIds(Memory mem) {
Memory reg1 = mem.region(0, mem.getCapacity());
- assertTrue(((BaseStateImpl)reg1).isRegionType());
+ assertTrue(((ResourceImpl)reg1).isRegionType());
Buffer buf1 = reg1.asBuffer();
- assertTrue(((BaseStateImpl)buf1).isRegionType());
- assertTrue(((BaseStateImpl)buf1).isBufferType());
+ assertTrue(((ResourceImpl)buf1).isRegionType());
+ assertTrue(((ResourceImpl)buf1).isBufferType());
assertTrue(buf1.isReadOnly());
Buffer buf2 = buf1.duplicate();
- assertTrue(((BaseStateImpl)buf2).isRegionType());
- assertTrue(((BaseStateImpl)buf2).isBufferType());
- assertTrue(((BaseStateImpl)buf2).isDuplicateType());
+ assertTrue(((ResourceImpl)buf2).isRegionType());
+ assertTrue(((ResourceImpl)buf2).isBufferType());
+ assertTrue(((ResourceImpl)buf2).isDuplicateType());
assertTrue(buf2.isReadOnly());
Memory mem2 = buf1.asMemory(); //
- assertTrue(((BaseStateImpl)mem2).isRegionType());
- assertFalse(((BaseStateImpl)mem2).isBufferType());
- assertFalse(((BaseStateImpl)mem2).isDuplicateType());
+ assertTrue(((ResourceImpl)mem2).isRegionType());
+ assertFalse(((ResourceImpl)mem2).isBufferType());
+ assertFalse(((ResourceImpl)mem2).isDuplicateType());
assertTrue(mem2.isReadOnly());
Buffer buf3 = buf1.duplicate(Util.NON_NATIVE_BYTE_ORDER);
- assertTrue(((BaseStateImpl)buf3).isRegionType());
- assertTrue(((BaseStateImpl)buf3).isBufferType());
- assertTrue(((BaseStateImpl)buf3).isDuplicateType());
- assertTrue(((BaseStateImpl)buf3).isNonNativeType());
+ assertTrue(((ResourceImpl)buf3).isRegionType());
+ assertTrue(((ResourceImpl)buf3).isBufferType());
+ assertTrue(((ResourceImpl)buf3).isDuplicateType());
+ assertTrue(((ResourceImpl)buf3).isNonNativeType());
assertTrue(buf3.isReadOnly());
Memory mem3 = buf3.asMemory();
- assertTrue(((BaseStateImpl)mem3).isRegionType());
- assertFalse(((BaseStateImpl)mem3).isBufferType());
- assertTrue(((BaseStateImpl)mem3).isDuplicateType());
- assertTrue(((BaseStateImpl)mem3).isNonNativeType());
+ assertTrue(((ResourceImpl)mem3).isRegionType());
+ assertFalse(((ResourceImpl)mem3).isBufferType());
+ assertTrue(((ResourceImpl)mem3).isDuplicateType());
+ assertTrue(((ResourceImpl)mem3).isNonNativeType());
assertTrue(mem3.isReadOnly());
}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/TestUtils.java b/src/test/java/org/apache/datasketches/memory/internal/TestUtils.java
new file mode 100644
index 0000000..b925fbb
--- /dev/null
+++ b/src/test/java/org/apache/datasketches/memory/internal/TestUtils.java
@@ -0,0 +1,238 @@
+/**
+ * Copyright 2022 Yahoo Inc. All rights reserved.
+ */
+package org.apache.datasketches.memory.internal;
+
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.internal.unsafe.UnsafeUtil;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Paths;
+import java.nio.file.attribute.PosixFileAttributeView;
+import java.nio.file.attribute.PosixFileAttributes;
+import java.nio.file.attribute.PosixFilePermissions;
+import java.util.Objects;
+
+/**
+ * Utility functions used in unit tests
+ */
+public class TestUtils {
+ public static final String LS = System.lineSeparator();
+
+ /**
+ *
+ * Return true if all the masked bits of value are zero
+ *
+ * @param value the value to be tested
+ * @param bitMask defines the bits of interest
+ * @return true if all the masked bits of value are zero
+ */
+ public static final boolean isAllBitsClear(final long value, final long bitMask) {
+ return (~value & bitMask) == bitMask;
+ }
+
+ /**
+ * Return true if all the masked bits of value are one
+ *
+ * @param value the value to be tested
+ * @param bitMask defines the bits of interest
+ * @return true if all the masked bits of value are one
+ */
+ public static final boolean isAllBitsSet(final long value, final long bitMask) {
+ return (value & bitMask) == bitMask;
+ }
+
+ /**
+ * Return true if any the masked bits of value are zero
+ *
+ * @param value the value to be tested
+ * @param bitMask defines the bits of interest
+ * @return true if any the masked bits of value are zero
+ */
+ public static final boolean isAnyBitsClear(final long value, final long bitMask) {
+ return (~value & bitMask) != 0;
+ }
+
+ /**
+ * Return true if any the masked bits of value are one
+ *
+ * @param value the value to be tested
+ * @param bitMask defines the bits of interest
+ * @return true if any the masked bits of value are one
+ */
+ public static final boolean isAnyBitsSet(final long value, final long bitMask) {
+ return (value & bitMask) != 0;
+ }
+
+ // Resources NOTE: these 3 methods are duplicated in Java/ datasketches/Util
+
+ /**
+ * Gets the absolute path of the given resource file's shortName.
+ *
+ * <p>
+ * Note that the ClassLoader.getResource(shortName) returns a URL,
+ * which can have special characters, e.g., "%20" for spaces. This method
+ * obtains the URL, converts it to a URI, then does a uri.getPath(), which
+ * decodes any special characters in the URI path. This is required to make
+ * obtaining resources operating-system independent.
+ * </p>
+ *
+ * @param shortFileName the last name in the pathname's name sequence.
+ * @return the absolute path of the given resource file's shortName.
+ */
+ public static String getResourcePath(final String shortFileName) {
+ Objects.requireNonNull(shortFileName, "input parameter " + shortFileName + " cannot be null.");
+ try {
+ final URL url = Util.class.getClassLoader().getResource(shortFileName);
+ Objects.requireNonNull(url, "resource " + shortFileName + " could not be acquired.");
+ final URI uri = url.toURI();
+ // decodes any special characters
+ final String path = uri.isAbsolute() ? Paths.get(uri).toAbsolutePath().toString() : uri.getPath();
+ return path;
+ } catch (final URISyntaxException e) {
+ throw new IllegalArgumentException("Cannot find resource: " + shortFileName + LS + e);
+ }
+ }
+
+ /**
+ * Gets the file defined by the given resource file's shortFileName.
+ *
+ * @param shortFileName the last name in the pathname's name sequence.
+ * @return the file defined by the given resource file's shortFileName.
+ */
+ public static File getResourceFile(final String shortFileName) {
+ return new File(getResourcePath(shortFileName));
+ }
+
+ /**
+ * Returns a byte array of the contents of the file defined by the given resource file's
+ * shortFileName.
+ *
+ * @param shortFileName the last name in the pathname's name sequence.
+ * @return a byte array of the contents of the file defined by the given resource file's
+ * shortFileName.
+ */
+ public static byte[] getResourceBytes(final String shortFileName) {
+ try {
+ return Files.readAllBytes(Paths.get(getResourcePath(shortFileName)));
+ } catch (final IOException e) {
+ throw new IllegalArgumentException("Cannot read resource: " + shortFileName + LS + e);
+ }
+ }
+
+ public static final String getFileAttributes(File file) {
+ try {
+ PosixFileAttributes attrs =
+ Files.getFileAttributeView(file.toPath(), PosixFileAttributeView.class, new LinkOption[0])
+ .readAttributes();
+ String s = String.format("%s: %s %s %s%n", file.getPath(), attrs.owner().getName(), attrs.group().getName(),
+ PosixFilePermissions.toString(attrs.permissions()));
+ return s;
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * Searches a range of the specified array of longs for the specified value using the binary
+ * search algorithm. The range must be sorted method) prior to making this call.
+ * If it is not sorted, the results are undefined. If the range contains
+ * multiple elements with the specified value, there is no guarantee which one will be found.
+ * @param mem the Memory to be searched
+ * @param fromLongIndex the index of the first element (inclusive) to be searched
+ * @param toLongIndex the index of the last element (exclusive) to be searched
+ * @param key the value to be searched for
+ * @return index of the search key, if it is contained in the array within the specified range;
+ * otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which
+ * the key would be inserted into the array: the index of the first element in the range greater
+ * than the key, or toIndex if all elements in the range are less than the specified key.
+ * Note that this guarantees that the return value will be ≥ 0 if and only if the key is found.
+ */
+ public static long binarySearchLongs(final Memory mem, final long fromLongIndex,
+ final long toLongIndex, final long key) {
+ UnsafeUtil.checkBounds(fromLongIndex << 3, (toLongIndex - fromLongIndex) << 3, mem.getCapacity());
+ long low = fromLongIndex;
+ long high = toLongIndex - 1L;
+
+ while (low <= high) {
+ final long mid = (low + high) >>> 1;
+ final long midVal = mem.getLong(mid << 3);
+
+ if (midVal < key) { low = mid + 1; }
+ else if (midVal > key) { high = mid - 1; }
+ else { return mid; } // key found
+ }
+ return -(low + 1); // key not found.
+ }
+
+ public static final void nullCheck(final Object obj, final String arg) {
+ if (obj == null) {
+ throw new IllegalArgumentException("The argument '" + arg + "' may not be null.");
+ }
+ }
+
+ public static final void setGettysburgAddressFileToReadOnly() {
+ File file = getResourceFile("GettysburgAddress.txt");
+ file.setWritable(false);
+ }
+
+
+ /**
+ * Prepend the given string with zeros. If the given string is equal or greater than the given
+ * field length, it will be returned without modification.
+ *
+ * @param s the given string
+ * @param fieldLength desired total field length including the given string
+ * @return the given string prepended with zeros.
+ */
+ public static final String zeroPad(final String s, final int fieldLength) {
+ return characterPad(s, fieldLength, '0', false);
+ }
+
+ /**
+ * Prepend or postpend the given string with the given character to fill the given field length.
+ * If the given string is equal or greater than the given field length, it will be returned
+ * without modification.
+ *
+ * @param s the given string
+ * @param fieldLength the desired field length
+ * @param padChar the desired pad character
+ * @param postpend if true append the pacCharacters to the end of the string.
+ * @return prepended or postpended given string with the given character to fill the given field
+ * length.
+ */
+ public static final String characterPad(final String s, final int fieldLength, final char padChar,
+ final boolean postpend) {
+ final char[] chArr = s.toCharArray();
+ final int sLen = chArr.length;
+ if (sLen < fieldLength) {
+ final char[] out = new char[fieldLength];
+ final int blanks = fieldLength - sLen;
+
+ if (postpend) {
+ for (int i = 0; i < sLen; i++) {
+ out[i] = chArr[i];
+ }
+ for (int i = sLen; i < fieldLength; i++) {
+ out[i] = padChar;
+ }
+ } else { // prepend
+ for (int i = 0; i < blanks; i++) {
+ out[i] = padChar;
+ }
+ for (int i = blanks; i < fieldLength; i++) {
+ out[i] = chArr[i - blanks];
+ }
+ }
+
+ return String.valueOf(out);
+ }
+ return s;
+ }
+}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/Utf8Test.java b/src/test/java/org/apache/datasketches/memory/internal/Utf8Test.java
index 762efe3..3086b3a 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/Utf8Test.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/Utf8Test.java
@@ -28,10 +28,9 @@ import java.nio.CharBuffer;
import java.util.ArrayList;
import java.util.List;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.Utf8CodingException;
import org.apache.datasketches.memory.WritableMemory;
-import org.apache.datasketches.memory.internal.Util.RandomCodePoints;
import org.testng.annotations.Test;
import com.google.protobuf.ByteString;
@@ -58,8 +57,8 @@ public class Utf8Test {
@Test
public void testPutInvalidChars() { //The surrogates must be a pair, thus invalid alone
- WritableMemory mem = WritableMemory.allocate(10);
- WritableMemory emptyMem = WritableMemory.allocate(0);
+ WritableMemory mem = DefaultMemoryFactory.DEFAULT.allocate(10);
+ WritableMemory emptyMem = DefaultMemoryFactory.DEFAULT.allocate(0);
for (int c = Character.MIN_SURROGATE; c <= Character.MAX_SURROGATE; c++) {
assertSurrogate(mem, (char) c);
assertSurrogate(emptyMem, (char) c);
@@ -77,7 +76,7 @@ public class Utf8Test {
@Test
public void testPutInvaidSurrogatePairs() {
- WritableMemory mem = WritableMemory.allocate(4);
+ WritableMemory mem = DefaultMemoryFactory.DEFAULT.allocate(4);
StringBuilder sb = new StringBuilder();
sb.append(Character.MIN_HIGH_SURROGATE);
sb.append(Character.MAX_HIGH_SURROGATE);
@@ -90,7 +89,7 @@ public class Utf8Test {
@Test
public void testPutHighBMP() {
- WritableMemory mem = WritableMemory.allocate(2);
+ WritableMemory mem = DefaultMemoryFactory.DEFAULT.allocate(2);
StringBuilder sb = new StringBuilder();
sb.append("\uE000");
try {
@@ -102,7 +101,7 @@ public class Utf8Test {
@Test
public void testPutExtendedAscii() {
- WritableMemory mem = WritableMemory.allocate(1);
+ WritableMemory mem = DefaultMemoryFactory.DEFAULT.allocate(1);
StringBuilder sb = new StringBuilder();
sb.append("\u07FF");
try {
@@ -114,7 +113,7 @@ public class Utf8Test {
@Test
public void testPutOneAsciiToEmpty() {
- WritableMemory mem = WritableMemory.allocate(0);
+ WritableMemory mem = DefaultMemoryFactory.DEFAULT.allocate(0);
StringBuilder sb = new StringBuilder();
sb.append("a");
try {
@@ -126,7 +125,7 @@ public class Utf8Test {
@Test
public void testPutValidSurrogatePair() {
- WritableMemory mem = WritableMemory.allocate(4);
+ WritableMemory mem = DefaultMemoryFactory.DEFAULT.allocate(4);
StringBuilder sb = new StringBuilder();
sb.append(Character.MIN_HIGH_SURROGATE);
sb.append(Character.MIN_LOW_SURROGATE);
@@ -217,7 +216,7 @@ public class Utf8Test {
rcp.fillCodePointArray(cpArr, 0, minPlane2CP);
String rcpStr = new String(cpArr, 0, numCP);
//println(rcpStr);
- WritableMemory wmem = WritableMemory.allocate(4 * numCP);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(4 * numCP);
int utf8Bytes = (int) wmem.putCharsToUtf8(0, rcpStr);
StringBuilder sb = new StringBuilder();
@@ -301,7 +300,7 @@ public class Utf8Test {
String refStr = "Quizdeltagerne spiste jordb\u00e6r med fl\u00f8de, mens cirkusklovnen";
byte[] refByteArr = refStr.getBytes(UTF_8);
int addBytes = refByteArr.length;
- WritableMemory refMem = WritableMemory.writableWrap(refByteArr);
+ WritableMemory refMem = DefaultMemoryFactory.DEFAULT.writableWrap(refByteArr);
int decodedChars = refMem.getCharsFromUtf8(0, addBytes, sb);
String finalStr = sb.toString();
int finalChars = finalStr.toCharArray().length;
@@ -317,7 +316,7 @@ public class Utf8Test {
byte[] refByteArr = refStr.getBytes(UTF_8);
int refBytes = refByteArr.length;
int offset = 100;
- WritableMemory tgtMem = WritableMemory.allocate(refBytes + offset);
+ WritableMemory tgtMem = DefaultMemoryFactory.DEFAULT.allocate(refBytes + offset);
long bytesEncoded = tgtMem.putCharsToUtf8(offset, refStr);
assertEquals(bytesEncoded, refBytes);
}
@@ -388,14 +387,14 @@ public class Utf8Test {
private static void assertInvalid(byte[] bytes) {
int bytesLen = bytes.length;
try {
- Memory.wrap(bytes).getCharsFromUtf8(0, bytesLen, new StringBuilder());
+ DefaultMemoryFactory.DEFAULT.wrap(bytes).getCharsFromUtf8(0, bytesLen, new StringBuilder());
fail();
} catch (Utf8CodingException e) {
// Expected.
}
try {
CharBuffer cb = CharBuffer.allocate(bytesLen);
- Memory.wrap(bytes).getCharsFromUtf8(0, bytesLen, cb);
+ DefaultMemoryFactory.DEFAULT.wrap(bytes).getCharsFromUtf8(0, bytesLen, cb);
fail();
} catch (Utf8CodingException | IOException e) {
// Expected.
@@ -404,7 +403,7 @@ public class Utf8Test {
private static void assertInvalidSlice(byte[] bytes, int index, int size) {
try {
- Memory mem = Memory.wrap(bytes);
+ Memory mem = DefaultMemoryFactory.DEFAULT.wrap(bytes);
mem.getCharsFromUtf8(index, size, new StringBuilder());
fail();
} catch (IllegalArgumentException e) { //Pure bounds violation
@@ -435,15 +434,15 @@ public class Utf8Test {
if (utf8LengthBytes == -1) {
utf8LengthBytes = refByteArr.length;
}
- Memory refMem = Memory.wrap(refByteArr);
+ Memory refMem = DefaultMemoryFactory.DEFAULT.wrap(refByteArr);
byte[] refByteArr2 = new byte[refByteArr.length + 1];
System.arraycopy(refByteArr, 0, refByteArr2, 1, refByteArr.length);
- Memory refReg = Memory.wrap(refByteArr2).region(1, refByteArr.length);
+ Memory refReg = DefaultMemoryFactory.DEFAULT.wrap(refByteArr2).region(1, refByteArr.length);
- WritableMemory dstMem = WritableMemory.allocate(refByteArr.length);
+ WritableMemory dstMem = DefaultMemoryFactory.DEFAULT.allocate(refByteArr.length);
WritableMemory dstMem2 =
- WritableMemory.allocate(refByteArr.length + 1).writableRegion(1, refByteArr.length);
+ DefaultMemoryFactory.DEFAULT.allocate(refByteArr.length + 1).writableRegion(1, refByteArr.length);
// Test with Memory objects, where base offset != 0
assertRoundTrips(refStr, refSubCharLen, offsetBytes, utf8LengthBytes, refByteArr, refMem, dstMem);
@@ -475,7 +474,7 @@ public class Utf8Test {
assertEquals(0, dstMem.compareTo(0, refByteArr.length, refMem, 0, refByteArr.length));
// Test write overflow
- WritableMemory writeMem2 = WritableMemory.allocate(refByteArr.length - 1);
+ WritableMemory writeMem2 = DefaultMemoryFactory.DEFAULT.allocate(refByteArr.length - 1);
try {
writeMem2.putCharsToUtf8(0, refStr);
fail();
diff --git a/src/test/java/org/apache/datasketches/memory/internal/UtilTest.java b/src/test/java/org/apache/datasketches/memory/internal/UtilTest.java
index 8dc1081..60d8743 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/UtilTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/UtilTest.java
@@ -23,43 +23,37 @@
package org.apache.datasketches.memory.internal;
-import static org.apache.datasketches.memory.internal.Util.characterPad;
-import static org.apache.datasketches.memory.internal.Util.getResourceBytes;
-import static org.apache.datasketches.memory.internal.Util.getResourceFile;
+import static org.apache.datasketches.memory.internal.TestUtils.getResourceFile;
+import static org.apache.datasketches.memory.internal.TestUtils.getResourceBytes;
+import static org.apache.datasketches.memory.internal.TestUtils.zeroPad;
+import static org.apache.datasketches.memory.internal.TestUtils.characterPad;
+import static org.apache.datasketches.memory.internal.TestUtils.nullCheck;
import static org.apache.datasketches.memory.internal.Util.negativeCheck;
-import static org.apache.datasketches.memory.internal.Util.nullCheck;
import static org.apache.datasketches.memory.internal.Util.zeroCheck;
-import static org.apache.datasketches.memory.internal.Util.zeroPad;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;
import java.io.File;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.LinkOption;
-import java.nio.file.attribute.PosixFileAttributeView;
-import java.nio.file.attribute.PosixFileAttributes;
-import java.nio.file.attribute.PosixFilePermissions;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.unsafe.UnsafeUtil;
import org.testng.annotations.Test;
public class UtilTest {
- private static final String LS = System.getProperty("line.separator");
-
//Binary Search
@Test
public void checkBinarySearch() {
int k = 1024; //longs
- WritableMemory wMem = WritableMemory.allocate(k << 3); //1024 longs
+ WritableMemory wMem = DefaultMemoryFactory.DEFAULT.allocate(k << 3); //1024 longs
for (int i = 0; i < k; i++) { wMem.putLong(i << 3, i); }
- long idx = Util.binarySearchLongs(wMem, 0, k - 1, k / 2);
+ long idx = TestUtils.binarySearchLongs(wMem, 0, k - 1, k / 2);
long val = wMem.getLong(idx << 3);
assertEquals(idx, k/2);
assertEquals(val, k/2);
- idx = Util.binarySearchLongs(wMem, 0, k - 1, k);
+ idx = TestUtils.binarySearchLongs(wMem, 0, k - 1, k);
assertEquals(idx, -1024);
}
@@ -106,7 +100,7 @@ public class UtilTest {
@Test
public void checkCodePointArr() {
- final Util.RandomCodePoints rvcp = new Util.RandomCodePoints(true);
+ final RandomCodePoints rvcp = new RandomCodePoints(true);
final int n = 1000;
final int[] cpArr = new int[n];
rvcp.fillCodePointArray(cpArr);
@@ -120,7 +114,7 @@ public class UtilTest {
@Test
public void checkCodePoint() {
- final Util.RandomCodePoints rvcp = new Util.RandomCodePoints(true);
+ final RandomCodePoints rvcp = new RandomCodePoints(true);
final int n = 1000;
for (int i = 0; i < n; i++) {
int cp = rvcp.getCodePoint();
@@ -130,30 +124,6 @@ public class UtilTest {
}
}
- static final String getFileAttributes(File file) {
- try {
- PosixFileAttributes attrs = Files.getFileAttributeView(
- file.toPath(), PosixFileAttributeView.class, new LinkOption[0]).readAttributes();
- String s = String.format("%s: %s %s %s%n",
- file.getPath(),
- attrs.owner().getName(),
- attrs.group().getName(),
- PosixFilePermissions.toString(attrs.permissions()));
- return s;
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- }
-
- static final void setGettysburgAddressFileToReadOnly() {
- File file = getResourceFile("GettysburgAddress.txt");
- try {
- Files.setPosixFilePermissions(file.toPath(), PosixFilePermissions.fromString("r--r--r--"));
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- }
-
//Resources
@Test
@@ -173,7 +143,7 @@ public class UtilTest {
public void resourceBytesCorrect() {
final String shortFileName = "GettysburgAddress.txt";
final byte[] bytes = getResourceBytes(shortFileName);
- assertTrue(bytes.length == 1541);
+ assertEquals(bytes.length, 1534 + (System.lineSeparator().length() * 7));
}
@Test(expectedExceptions = NullPointerException.class)
@@ -188,8 +158,8 @@ public class UtilTest {
}
static void println(final Object o) {
- if (o == null) { print(LS); }
- else { print(o.toString() + LS); }
+ if (o == null) { print(TestUtils.LS); }
+ else { print(o.toString() + TestUtils.LS); }
}
/**
diff --git a/src/test/java/org/apache/datasketches/memory/internal/WritableDirectCopyTest.java b/src/test/java/org/apache/datasketches/memory/internal/WritableDirectCopyTest.java
index f52aa34..3aa182d 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/WritableDirectCopyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/WritableDirectCopyTest.java
@@ -23,6 +23,7 @@ import static org.testng.Assert.assertEquals;
import static org.testng.Assert.fail;
import org.apache.datasketches.memory.WritableHandle;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@@ -38,7 +39,7 @@ public class WritableDirectCopyTest {
public void checkCopyWithinNativeSmall() throws Exception {
int memCapacity = 64;
int half = memCapacity / 2;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
mem.clear();
@@ -60,7 +61,7 @@ public class WritableDirectCopyTest {
int memCapLongs = memCapacity / 8;
int halfBytes = memCapacity / 2;
int halfLongs = memCapLongs / 2;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
mem.clear();
@@ -79,7 +80,7 @@ public class WritableDirectCopyTest {
@Test
public void checkCopyWithinNativeOverlap() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
mem.clear();
//println(mem.toHexString("Clear 64", 0, memCapacity));
@@ -95,7 +96,7 @@ public class WritableDirectCopyTest {
@Test
public void checkCopyWithinNativeSrcBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
mem.copyTo(32, mem, 32, 33); //hit source bound check
fail("Did Not Catch Assertion Error: source bound");
@@ -107,7 +108,7 @@ public class WritableDirectCopyTest {
@Test
public void checkCopyWithinNativeDstBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem = wrh.getWritable();
mem.copyTo(0, mem, 32, 33); //hit dst bound check
fail("Did Not Catch Assertion Error: dst bound");
@@ -120,8 +121,8 @@ public class WritableDirectCopyTest {
public void checkCopyCrossNativeSmall() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity);
- WritableHandle wrh2 = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh1 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity);
+ WritableHandle wrh2 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem1 = wrh1.getWritable();
WritableMemory mem2 = wrh2.getWritable();
@@ -144,8 +145,8 @@ public class WritableDirectCopyTest {
int memCapacity = (2 << 20) + 64;
int memCapLongs = memCapacity / 8;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity);
- WritableHandle wrh2 = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh1 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity);
+ WritableHandle wrh2 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem1 = wrh1.getWritable();
WritableMemory mem2 = wrh2.getWritable();
@@ -165,14 +166,14 @@ public class WritableDirectCopyTest {
@Test
public void checkCopyCrossNativeAndByteArray() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh1 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem1 = wrh1.getWritable();
for (int i = 0; i < mem1.getCapacity(); i++) {
mem1.putByte(i, (byte) i);
}
- WritableMemory mem2 = WritableMemory.allocate(memCapacity);
+ WritableMemory mem2 = DefaultMemoryFactory.DEFAULT.allocate(memCapacity);
mem1.copyTo(8, mem2, 16, 16);
for (int i = 0; i < 16; i++) {
@@ -186,7 +187,7 @@ public class WritableDirectCopyTest {
public void checkCopyCrossRegionsSameNative() throws Exception {
int memCapacity = 128;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh1 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem1 = wrh1.getWritable();
for (int i = 0; i < mem1.getCapacity(); i++) {
@@ -212,7 +213,7 @@ public class WritableDirectCopyTest {
@Test
public void checkCopyCrossNativeArrayAndHierarchicalRegions() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ try (WritableHandle wrh1 = DefaultMemoryFactory.DEFAULT.allocateDirect(memCapacity)) {
WritableMemory mem1 = wrh1.getWritable();
for (int i = 0; i < mem1.getCapacity(); i++) { //fill with numbers
@@ -220,7 +221,7 @@ public class WritableDirectCopyTest {
}
//println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
- WritableMemory mem2 = WritableMemory.allocate(memCapacity);
+ WritableMemory mem2 = DefaultMemoryFactory.DEFAULT.allocate(memCapacity);
Memory reg1 = mem1.region(8, 32);
Memory reg1B = reg1.region(8, 16);
diff --git a/src/test/java/org/apache/datasketches/memory/internal/WritableMemoryTest.java b/src/test/java/org/apache/datasketches/memory/internal/WritableMemoryTest.java
index 1226cc5..ec3c2d2 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/WritableMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/WritableMemoryTest.java
@@ -27,6 +27,7 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.concurrent.ThreadLocalRandom;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableBuffer;
import org.apache.datasketches.memory.WritableMemory;
@@ -37,34 +38,34 @@ public class WritableMemoryTest {
@Test
public void wrapBigEndian() {
ByteBuffer bb = ByteBuffer.allocate(64); //big endian
- WritableMemory wmem = WritableMemory.writableWrap(bb);
- assertEquals(wmem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
- wmem = WritableMemory.writableWrap(bb, ByteOrder.nativeOrder());
- assertEquals(wmem.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(bb);
+ assertEquals(wmem.getByteOrder(), ByteOrder.BIG_ENDIAN);
+ wmem = DefaultMemoryFactory.DEFAULT.writableWrap(bb, ByteOrder.nativeOrder());
+ assertEquals(wmem.getByteOrder(), ByteOrder.LITTLE_ENDIAN);
}
@Test
public void wrapBigEndianAsLittle() {
ByteBuffer bb = ByteBuffer.allocate(64);
bb.putChar(0, (char)1); //as NNO
- WritableMemory wmem = WritableMemory.writableWrap(bb, ByteOrder.LITTLE_ENDIAN, null);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(bb, ByteOrder.LITTLE_ENDIAN, null);
assertEquals(wmem.getChar(0), 256);
}
@Test
public void allocateWithByteOrder() {
- WritableMemory wmem = WritableMemory.allocate(64, ByteOrder.BIG_ENDIAN);
- assertEquals(wmem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
- wmem = WritableMemory.allocate(64, ByteOrder.LITTLE_ENDIAN);
- assertEquals(wmem.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
- wmem = WritableMemory.writableWrap(new byte[64], 32, 32, ByteOrder.BIG_ENDIAN);
- assertEquals(wmem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(64, ByteOrder.BIG_ENDIAN);
+ assertEquals(wmem.getByteOrder(), ByteOrder.BIG_ENDIAN);
+ wmem = DefaultMemoryFactory.DEFAULT.allocate(64, ByteOrder.LITTLE_ENDIAN);
+ assertEquals(wmem.getByteOrder(), ByteOrder.LITTLE_ENDIAN);
+ wmem = DefaultMemoryFactory.DEFAULT.writableWrap(new byte[64], 32, 32, ByteOrder.BIG_ENDIAN);
+ assertEquals(wmem.getByteOrder(), ByteOrder.BIG_ENDIAN);
}
@Test
public void checkGetArray() {
byte[] byteArr = new byte[64];
- WritableMemory wmem = WritableMemory.writableWrap(byteArr);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(byteArr);
assertTrue(wmem.getArray() == byteArr);
WritableBuffer wbuf = wmem.asWritableBuffer();
assertTrue(wbuf.getArray() == byteArr);
@@ -73,26 +74,26 @@ public class WritableMemoryTest {
@Test(expectedExceptions = IllegalArgumentException.class)
public void checkSelfArrayCopy() {
byte[] srcAndDst = new byte[128];
- WritableMemory wmem = WritableMemory.writableWrap(srcAndDst);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(srcAndDst);
wmem.getByteArray(0, srcAndDst, 64, 64); //non-overlapping
}
@Test
public void checkEquals() {
int len = 7;
- WritableMemory wmem1 = WritableMemory.allocate(len);
+ WritableMemory wmem1 = DefaultMemoryFactory.DEFAULT.allocate(len);
//@SuppressWarnings({"EqualsWithItself", "SelfEquals"}) //unsupported
//SelfEquals for Plexus, EqualsWithItself for IntelliJ
//boolean eq1 = wmem1.equals(wmem1); //strict profile complains
//assertTrue(eq1);
- WritableMemory wmem2 = WritableMemory.allocate(len + 1);
+ WritableMemory wmem2 = DefaultMemoryFactory.DEFAULT.allocate(len + 1);
assertFalse(wmem1.equals(wmem2));
WritableMemory reg1 = wmem1.writableRegion(0, wmem1.getCapacity());
assertTrue(wmem1.equals(reg1));
- wmem2 = WritableMemory.allocate(len);
+ wmem2 = DefaultMemoryFactory.DEFAULT.allocate(len);
for (int i = 0; i < len; i++) {
wmem1.putByte(i, (byte) i);
wmem2.putByte(i, (byte) i);
@@ -104,8 +105,8 @@ public class WritableMemoryTest {
assertTrue(wmem1.equalTo(0, reg1, 0, len));
len = 24;
- wmem1 = WritableMemory.allocate(len);
- wmem2 = WritableMemory.allocate(len);
+ wmem1 = DefaultMemoryFactory.DEFAULT.allocate(len);
+ wmem2 = DefaultMemoryFactory.DEFAULT.allocate(len);
for (int i = 0; i < len; i++) {
wmem1.putByte(i, (byte) i);
wmem2.putByte(i, (byte) i);
@@ -122,14 +123,14 @@ public class WritableMemoryTest {
@Test
public void checkEquals2() {
int len = 23;
- WritableMemory wmem1 = WritableMemory.allocate(len);
+ WritableMemory wmem1 = DefaultMemoryFactory.DEFAULT.allocate(len);
assertFalse(wmem1.equals(null));
//@SuppressWarnings({"EqualsWithItself", "SelfEquals"}) //unsupported
//SelfEquals for Plexus, EqualsWithItself for IntelliJ
//boolean eq1 = wmem1.equals(wmem1); //strict profile complains
//assertTrue(eq1);
- WritableMemory wmem2 = WritableMemory.allocate(len + 1);
+ WritableMemory wmem2 = DefaultMemoryFactory.DEFAULT.allocate(len + 1);
assertFalse(wmem1.equals(wmem2));
for (int i = 0; i < len; i++) {
@@ -148,8 +149,8 @@ public class WritableMemoryTest {
byte[] bytes1 = new byte[(thresh * 2) + 7];
ThreadLocalRandom.current().nextBytes(bytes1);
byte[] bytes2 = bytes1.clone();
- Memory mem1 = Memory.wrap(bytes1);
- Memory mem2 = Memory.wrap(bytes2);
+ Memory mem1 = DefaultMemoryFactory.DEFAULT.wrap(bytes1);
+ Memory mem2 = DefaultMemoryFactory.DEFAULT.wrap(bytes2);
assertTrue(mem1.equals(mem2));
bytes2[thresh + 10] = (byte) (bytes1[thresh + 10] + 1);
@@ -162,12 +163,12 @@ public class WritableMemoryTest {
@Test
public void checkWrapWithBO() {
- WritableMemory wmem = WritableMemory.writableWrap(new byte[0], ByteOrder.BIG_ENDIAN);
- boolean nativeBO = wmem.getTypeByteOrder() == ByteOrder.nativeOrder();
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(new byte[0], ByteOrder.BIG_ENDIAN);
+ boolean nativeBO = wmem.getByteOrder() == ByteOrder.nativeOrder();
assertFalse(nativeBO);
println("" + nativeBO);
- wmem = WritableMemory.writableWrap(new byte[8], ByteOrder.BIG_ENDIAN);
- nativeBO = wmem.getTypeByteOrder() == ByteOrder.nativeOrder();
+ wmem = DefaultMemoryFactory.DEFAULT.writableWrap(new byte[8], ByteOrder.BIG_ENDIAN);
+ nativeBO = wmem.getByteOrder() == ByteOrder.nativeOrder();
assertFalse(nativeBO);
println("" + nativeBO);
}
@@ -175,7 +176,7 @@ public class WritableMemoryTest {
@Test
@SuppressWarnings("unused")
public void checkOwnerClientCase() {
- WritableMemory owner = WritableMemory.allocate(64);
+ WritableMemory owner = DefaultMemoryFactory.DEFAULT.allocate(64);
Memory client1 = owner; //Client1 cannot write (no API)
owner.putInt(0, 1); //But owner can write
((WritableMemory)client1).putInt(0, 2); //Client1 can write, but with explicit effort.
diff --git a/src/test/java/org/apache/datasketches/memory/internal/XxHash64LoopingTest.java b/src/test/java/org/apache/datasketches/memory/internal/XxHash64LoopingTest.java
index 6fc4f81..7250721 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/XxHash64LoopingTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/XxHash64LoopingTest.java
@@ -21,6 +21,7 @@ package org.apache.datasketches.memory.internal;
import static org.testng.Assert.assertEquals;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@@ -41,7 +42,7 @@ public class XxHash64LoopingTest {
for (int i = 0; i < 1025; i++) {
byte[] byteArr = new byte[i];
for (int j = 0; j < byteArr.length; j++) { byteArr[j] = (byte) j; }
- WritableMemory wmem = WritableMemory.writableWrap(byteArr);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(byteArr);
long hash = wmem.xxHash64(0, byteArr.length, seed);
assertEquals(hash, HASHES_OF_LOOPING_BYTES_WITH_SEED_42[i]);
}
diff --git a/src/test/java/org/apache/datasketches/memory/internal/XxHash64Test.java b/src/test/java/org/apache/datasketches/memory/internal/XxHash64Test.java
index 9656420..67b5183 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/XxHash64Test.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/XxHash64Test.java
@@ -19,15 +19,15 @@
package org.apache.datasketches.memory.internal;
-import static org.apache.datasketches.memory.XxHash.*;
+import static org.apache.datasketches.memory.hash.XxHash.*;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
-import org.apache.datasketches.memory.BaseState;
-import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
+import org.apache.datasketches.memory.Resource;
import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@@ -46,7 +46,7 @@ public class XxHash64Test {
long hash;
- WritableMemory wmem = WritableMemory.allocate(cap);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(cap);
for (int i = 0; i < cap; i++) { wmem.putByte(i, (byte)(-128 + i)); }
for (int offset = 0; offset < 16; offset++) {
@@ -65,7 +65,7 @@ public class XxHash64Test {
for (int j = 1; j < bytes; j++) {
byte[] in = new byte[bytes];
- WritableMemory wmem = WritableMemory.writableWrap(in);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(in);
for (int i = 0; i < j; i++) { wmem.putByte(i, (byte) (-128 + i)); }
long hash =wmem.xxHash64(offset, bytes, seed);
@@ -82,7 +82,7 @@ public class XxHash64Test {
*/
@Test
public void collisionTest() {
- WritableMemory wmem = WritableMemory.allocate(128);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(128);
wmem.putLong(0, 1);
wmem.putLong(16, 42);
wmem.putLong(32, 2);
@@ -101,7 +101,7 @@ public class XxHash64Test {
}
/**
- * This simple test compares the output of {@link BaseState#xxHash64(long, long, long)} with the
+ * This simple test compares the output of {@link Resource#xxHash64(long, long, long)} with the
* output of {@link net.openhft.hashing.LongHashFunction}, that itself is tested against the
* reference implementation in C. This increase confidence that the xxHash function implemented
* in this package is in fact the same xxHash function implemented in C.
@@ -116,7 +116,7 @@ public class XxHash64Test {
byte[] bytes = new byte[len];
for (int i = 0; i < 10; i++) {
long zahXxHash = LongHashFunction.xx().hashBytes(bytes);
- long memoryXxHash = Memory.wrap(bytes).xxHash64(0, len, 0);
+ long memoryXxHash = DefaultMemoryFactory.DEFAULT.wrap(bytes).xxHash64(0, len, 0);
assertEquals(memoryXxHash, zahXxHash);
random.nextBytes(bytes);
}
@@ -127,7 +127,7 @@ public class XxHash64Test {
@Test
public void testArrHashes() {
- WritableMemory wmem = WritableMemory.writableWrap(barr);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.writableWrap(barr);
long hash0 = wmem.xxHash64(8, 8, 0);
long hash1 = hashByteArr(barr, 8, 8, 0);
assertEquals(hash1, hash0);
diff --git a/src/test/java/org/apache/datasketches/memory/internal/ZeroCapacityTest.java b/src/test/java/org/apache/datasketches/memory/internal/ZeroCapacityTest.java
index 5979e37..175c607 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/ZeroCapacityTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/ZeroCapacityTest.java
@@ -23,6 +23,7 @@ import static org.testng.Assert.assertEquals;
import java.nio.ByteBuffer;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.WritableMemory;
@@ -36,16 +37,16 @@ public class ZeroCapacityTest {
@Test
public void checkZeroCapacity() throws Exception {
- WritableMemory wmem = WritableMemory.allocate(0);
+ WritableMemory wmem = DefaultMemoryFactory.DEFAULT.allocate(0);
assertEquals(wmem.getCapacity(), 0);
- Memory.wrap(new byte[0]);
- Memory.wrap(ByteBuffer.allocate(0));
- Memory mem3 = Memory.wrap(ByteBuffer.allocateDirect(0));
+ DefaultMemoryFactory.DEFAULT.wrap(new byte[0]);
+ DefaultMemoryFactory.DEFAULT.wrap(ByteBuffer.allocate(0));
+ Memory mem3 = DefaultMemoryFactory.DEFAULT.wrap(ByteBuffer.allocateDirect(0));
mem3.region(0, 0);
WritableHandle wh = null;
try {
- wh = WritableMemory.allocateDirect(0);
+ wh = DefaultMemoryFactory.DEFAULT.allocateDirect(0);
Assert.fail();
} catch (IllegalArgumentException ignore) {
if (wh != null) { wh.close(); }
diff --git a/src/test/java/org/apache/datasketches/memory/internal/direct/AllocateDirectMemoryTest.java b/src/test/java/org/apache/datasketches/memory/internal/direct/AllocateDirectMemoryTest.java
index 7ebe3e5..4a63998 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/direct/AllocateDirectMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/direct/AllocateDirectMemoryTest.java
@@ -17,17 +17,18 @@
* under the License.
*/
-package org.apache.datasketches.memory.internal;
+package org.apache.datasketches.memory.internal.direct;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.fail;
-import org.apache.datasketches.memory.BaseState;
-import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableHandle;
import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.internal.ResourceImpl;
+import org.apache.datasketches.memory.internal.Util;
import org.testng.annotations.AfterClass;
import org.testng.annotations.Test;
@@ -37,19 +38,19 @@ public class AllocateDirectMemoryTest {
public void simpleAllocateDirect() throws Exception {
int longs = 32;
WritableMemory wMem;
- try (WritableHandle wh = WritableMemory.allocateDirect(longs << 3)) {
+ try (WritableHandle wh = DefaultMemoryFactory.DEFAULT.allocateDirect(longs << 3)) {
wMem = wh.getWritable();
for (int i = 0; i<longs; i++) {
wMem.putLong(i << 3, i);
assertEquals(wMem.getLong(i << 3), i);
}
//inside the TWR block the memory should be valid
- ((BaseStateImpl)wMem).checkValid();
+ ((ResourceImpl)wMem).checkValid();
//OK
}
//The TWR block has exited, so the memory should be invalid
try {
- ((BaseStateImpl)wMem).checkValid();
+ ((ResourceImpl)wMem).checkValid();
fail();
} catch (final RuntimeException e) {
//OK
@@ -60,7 +61,7 @@ public class AllocateDirectMemoryTest {
public void checkDefaultMemoryRequestServer() throws Exception {
int longs1 = 32;
int bytes1 = longs1 << 3;
- try (WritableHandle wh = WritableMemory.allocateDirect(bytes1)) {
+ try (WritableHandle wh = DefaultMemoryFactory.DEFAULT.allocateDirect(bytes1)) {
WritableMemory origWmem = wh.getWritable();
for (int i = 0; i<longs1; i++) { //puts data in wMem1
origWmem.putLong(i << 3, i);
@@ -71,11 +72,7 @@ public class AllocateDirectMemoryTest {
int longs2 = 64;
int bytes2 = longs2 << 3;
MemoryRequestServer memReqSvr;
- if (BaseState.defaultMemReqSvr == null) {
- memReqSvr = new DefaultMemoryRequestServer();
- } else {
- memReqSvr = origWmem.getMemoryRequestServer();
- }
+ memReqSvr = origWmem.getMemoryRequestServer();
WritableMemory newWmem = memReqSvr.request(origWmem, bytes2);
assertFalse(newWmem.isDirect()); //on heap by default
for (int i = 0; i < longs2; i++) {
@@ -90,7 +87,7 @@ public class AllocateDirectMemoryTest {
@Test
public void checkNonNativeDirect() throws Exception {
- try (WritableHandle h = WritableMemory.allocateDirect(128, Util.NON_NATIVE_BYTE_ORDER, null)) {
+ try (WritableHandle h = DefaultMemoryFactory.DEFAULT.allocateDirect(128, Util.NON_NATIVE_BYTE_ORDER, null)) {
WritableMemory wmem = h.getWritable();
wmem.putChar(0, (char) 1);
assertEquals(wmem.getByte(1), (byte) 1);
@@ -100,7 +97,7 @@ public class AllocateDirectMemoryTest {
@Test
public void checkExplicitClose() throws Exception {
final long cap = 128;
- try (WritableHandle wdh = WritableMemory.allocateDirect(cap)) {
+ try (WritableHandle wdh = DefaultMemoryFactory.DEFAULT.allocateDirect(cap)) {
wdh.close(); //explicit close. Does the work of closing
} //end of scope call to Cleaner/Deallocator also will be redundant
}
@@ -108,8 +105,8 @@ public class AllocateDirectMemoryTest {
@AfterClass
public void checkDirectCounter() {
- WritableMemory.writableWrap(new byte[8]);
- long count = BaseState.getCurrentDirectMemoryAllocations();
+ DefaultMemoryFactory.DEFAULT.writableWrap(new byte[8]);
+ long count = ResourceImpl.getCurrentDirectMemoryAllocations();
if (count != 0) {
println(""+count);
fail();
diff --git a/src/test/java/org/apache/datasketches/memory/internal/direct/AllocateDirectWritableMapMemoryTest.java b/src/test/java/org/apache/datasketches/memory/internal/direct/AllocateDirectWritableMapMemoryTest.java
index 9cecaaa..e6e7cdb 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/direct/AllocateDirectWritableMapMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/direct/AllocateDirectWritableMapMemoryTest.java
@@ -21,10 +21,10 @@
* Note: Lincoln's Gettysburg Address is in the public domain. See LICENSE.
*/
-package org.apache.datasketches.memory.internal;
+package org.apache.datasketches.memory.internal.direct;
import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.apache.datasketches.memory.internal.Util.getResourceFile;
+import static org.apache.datasketches.memory.internal.TestUtils.getResourceFile;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;
@@ -36,29 +36,29 @@ import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.BaseState;
-import org.apache.datasketches.memory.MapHandle;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.ReadOnlyException;
+import org.apache.datasketches.memory.MmapHandle;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.WritableMapHandle;
import org.apache.datasketches.memory.WritableMemory;
+import org.apache.datasketches.memory.WritableMmapHandle;
+import org.apache.datasketches.memory.internal.ResourceImpl;
+import org.apache.datasketches.memory.internal.TestUtils;
+import org.apache.datasketches.memory.internal.Util;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
public class AllocateDirectWritableMapMemoryTest {
- private static final String LS = System.getProperty("line.separator");
-
@BeforeClass
public void setReadOnly() {
- UtilTest.setGettysburgAddressFileToReadOnly();
+ TestUtils.setGettysburgAddressFileToReadOnly();
}
@Test
public void simpleMap() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (MapHandle h = Memory.map(file); WritableMapHandle wh = (WritableMapHandle) h) {
+ try (MmapHandle h = DefaultMemoryFactory.DEFAULT.map(file); WritableMmapHandle wh = (WritableMmapHandle) h) {
Memory mem = h.get();
byte[] bytes = new byte[(int)mem.getCapacity()];
mem.getByteArray(0, bytes, 0, bytes.length);
@@ -67,7 +67,7 @@ public class AllocateDirectWritableMapMemoryTest {
try {
wh.force();
fail();
- } catch (ReadOnlyException e) {
+ } catch (IllegalArgumentException e) {
//OK
}
}
@@ -92,9 +92,9 @@ public class AllocateDirectWritableMapMemoryTest {
file.deleteOnExit(); //comment out if you want to examine the file.
try (
- WritableMapHandle dstHandle
- = WritableMemory.writableMap(file, 0, bytes, ByteOrder.nativeOrder());
- WritableHandle srcHandle = WritableMemory.allocateDirect(bytes)) {
+ WritableMmapHandle dstHandle
+ = DefaultMemoryFactory.DEFAULT.writableMap(file, 0, bytes, ByteOrder.nativeOrder());
+ WritableHandle srcHandle = DefaultMemoryFactory.DEFAULT.allocateDirect(bytes)) {
WritableMemory dstMem = dstHandle.getWritable();
WritableMemory srcMem = srcHandle.getWritable();
@@ -128,7 +128,7 @@ public class AllocateDirectWritableMapMemoryTest {
file.deleteOnExit(); //comment out if you want to examine the file.
final long bytes = 8;
- try (WritableMapHandle h = WritableMemory.writableMap(file, 0L, bytes, Util.NON_NATIVE_BYTE_ORDER)) {
+ try (WritableMmapHandle h = DefaultMemoryFactory.DEFAULT.writableMap(file, 0L, bytes, Util.NON_NATIVE_BYTE_ORDER)) {
WritableMemory wmem = h.getWritable();
wmem.putChar(0, (char) 1);
assertEquals(wmem.getByte(1), (byte) 1);
@@ -139,24 +139,24 @@ public class AllocateDirectWritableMapMemoryTest {
public void testMapException() throws IOException {
File dummy = createFile("dummy.txt", ""); //zero length
//throws java.lang.reflect.InvocationTargetException
- Memory.map(dummy, 0, dummy.length(), ByteOrder.nativeOrder());
+ DefaultMemoryFactory.DEFAULT.map(dummy, 0, dummy.length(), ByteOrder.nativeOrder());
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void simpleMap2() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
assertTrue(file.canRead() && !file.canWrite());
- try (WritableMapHandle rh =
- WritableMemory.writableMap(file)) { //throws
+ try (WritableMmapHandle rh =
+ DefaultMemoryFactory.DEFAULT.writableMap(file)) { //throws
//
}
}
- @Test(expectedExceptions = ReadOnlyException.class)
+ @Test(expectedExceptions = IllegalArgumentException.class)
public void checkOverLength() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (WritableMapHandle rh =
- WritableMemory.writableMap(file, 0, 1 << 20, ByteOrder.nativeOrder())) {
+ try (WritableMmapHandle rh =
+ DefaultMemoryFactory.DEFAULT.writableMap(file, 0, 1 << 20, ByteOrder.nativeOrder())) {
//
} catch (IOException e) {
throw new RuntimeException(e);
@@ -173,7 +173,7 @@ public class AllocateDirectWritableMapMemoryTest {
byte[] correctByteArr = correctStr.getBytes(UTF_8);
long corrBytes = correctByteArr.length;
- try (MapHandle rh = Memory.map(origFile, 0, origBytes, ByteOrder.nativeOrder())) {
+ try (MmapHandle rh = DefaultMemoryFactory.DEFAULT.map(origFile, 0, origBytes, ByteOrder.nativeOrder())) {
Memory map = rh.get();
rh.load();
assertTrue(rh.isLoaded());
@@ -184,7 +184,7 @@ public class AllocateDirectWritableMapMemoryTest {
assertEquals(bufStr, origStr);
}
- try (WritableMapHandle wrh = WritableMemory.writableMap(origFile, 0, corrBytes,
+ try (WritableMmapHandle wrh = DefaultMemoryFactory.DEFAULT.writableMap(origFile, 0, corrBytes,
ByteOrder.nativeOrder())) {
WritableMemory wMap = wrh.getWritable();
wrh.load();
@@ -217,14 +217,14 @@ public class AllocateDirectWritableMapMemoryTest {
@Test
public void checkExplicitClose() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (MapHandle wmh = Memory.map(file)) {
+ try (MmapHandle wmh = DefaultMemoryFactory.DEFAULT.map(file)) {
wmh.close(); //explicit close.
} //end of scope call to Cleaner/Deallocator also will be redundant
}
@AfterClass
public void checkDirectCounter() {
- long count = BaseState.getCurrentDirectMemoryMapAllocations();
+ long count = ResourceImpl.getCurrentDirectMemoryMapAllocations();
if (count != 0) {
println(""+count);
fail();
@@ -237,8 +237,8 @@ public class AllocateDirectWritableMapMemoryTest {
}
static void println(final Object o) {
- if (o == null) { print(LS); }
- else { print(o.toString() + LS); }
+ if (o == null) { print(TestUtils.LS); }
+ else { print(o.toString() + TestUtils.LS); }
}
/**
diff --git a/src/test/java/org/apache/datasketches/memory/internal/mmap/AllocateDirectMapMemoryTest.java b/src/test/java/org/apache/datasketches/memory/internal/mmap/AllocateDirectMapMemoryTest.java
index 4911e7d..dc9f31b 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/mmap/AllocateDirectMapMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/mmap/AllocateDirectMapMemoryTest.java
@@ -21,9 +21,9 @@
* Note: Lincoln's Gettysburg Address is in the public domain. See LICENSE.
*/
-package org.apache.datasketches.memory.internal;
+package org.apache.datasketches.memory.internal.mmap;
-import static org.apache.datasketches.memory.internal.Util.*;
+import static org.apache.datasketches.memory.internal.TestUtils.getResourceFile;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
@@ -32,26 +32,28 @@ import static org.testng.Assert.fail;
import java.io.File;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.MapHandle;
+import org.apache.datasketches.memory.DefaultMemoryFactory;
import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.MmapHandle;
+import org.apache.datasketches.memory.internal.TestUtils;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
public class AllocateDirectMapMemoryTest {
private static final String LS = System.getProperty("line.separator");
- MapHandle hand = null;
+ MmapHandle hand = null;
@BeforeClass
public void setReadOnly() {
- UtilTest.setGettysburgAddressFileToReadOnly();
+ TestUtils.setGettysburgAddressFileToReadOnly();
}
@Test
public void simpleMap() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- assertTrue(AllocateDirectMap.isFileReadOnly(file));
- try (MapHandle rh = Memory.map(file)) {
+ assertTrue(AllocateDirectMmap.isFileReadOnly(file));
+ try (MmapHandle rh = DefaultMemoryFactory.DEFAULT.map(file)) {
rh.close();
}
}
@@ -59,13 +61,13 @@ public class AllocateDirectMapMemoryTest {
@Test
public void testIllegalArguments() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (MapHandle rh = Memory.map(file, -1, Integer.MAX_VALUE, ByteOrder.nativeOrder())) {
+ try (MmapHandle rh = DefaultMemoryFactory.DEFAULT.map(file, -1, Integer.MAX_VALUE, ByteOrder.nativeOrder())) {
fail("Failed: testIllegalArgumentException: Position was negative.");
} catch (IllegalArgumentException e) {
//ok
}
- try (MapHandle rh = Memory.map(file, 0, -1, ByteOrder.nativeOrder())) {
+ try (MmapHandle rh = DefaultMemoryFactory.DEFAULT.map(file, 0, -1, ByteOrder.nativeOrder())) {
fail("Failed: testIllegalArgumentException: Size was negative.");
} catch (IllegalArgumentException e) {
//ok
@@ -76,7 +78,7 @@ public class AllocateDirectMapMemoryTest {
public void testMapAndMultipleClose() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- try (MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
+ try (MmapHandle rh = DefaultMemoryFactory.DEFAULT.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
Memory map = rh.get();
assertEquals(memCapacity, map.getCapacity());
rh.close();
@@ -91,7 +93,7 @@ public class AllocateDirectMapMemoryTest {
public void testReadFailAfterClose() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- try (MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
+ try (MmapHandle rh = DefaultMemoryFactory.DEFAULT.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
Memory mmf = rh.get();
rh.close();
mmf.getByte(0);
@@ -104,7 +106,7 @@ public class AllocateDirectMapMemoryTest {
public void testLoad() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- try (MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
+ try (MmapHandle rh = DefaultMemoryFactory.DEFAULT.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
rh.load();
assertTrue(rh.isLoaded());
rh.close();
@@ -116,7 +118,7 @@ public class AllocateDirectMapMemoryTest {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
Memory mem;
- try (MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
+ try (MmapHandle rh = DefaultMemoryFactory.DEFAULT.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
rh.load();
assertTrue(rh.isLoaded());
hand = rh;
@@ -130,7 +132,7 @@ public class AllocateDirectMapMemoryTest {
public void testHandoffWithoutClose() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder());
+ MmapHandle rh = DefaultMemoryFactory.DEFAULT.map(file, 0, memCapacity, ByteOrder.nativeOrder());
rh.load();
assertTrue(rh.isLoaded());
hand = rh;
diff --git a/src/test/java/org/apache/datasketches/memory/internal/unsafe/NioBitsTest.java b/src/test/java/org/apache/datasketches/memory/internal/unsafe/NioBitsTest.java
index 8ed5916..d72956e 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/unsafe/NioBitsTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/unsafe/NioBitsTest.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory.internal;
+package org.apache.datasketches.memory.internal.unsafe;
import static org.testng.Assert.assertEquals;
diff --git a/src/test/java/org/apache/datasketches/memory/internal/unsafe/UnsafeUtilTest.java b/src/test/java/org/apache/datasketches/memory/internal/unsafe/UnsafeUtilTest.java
index baaf90a..18059b7 100644
--- a/src/test/java/org/apache/datasketches/memory/internal/unsafe/UnsafeUtilTest.java
+++ b/src/test/java/org/apache/datasketches/memory/internal/unsafe/UnsafeUtilTest.java
@@ -17,7 +17,7 @@
* under the License.
*/
-package org.apache.datasketches.memory.internal;
+package org.apache.datasketches.memory.internal.unsafe;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
@@ -26,6 +26,7 @@ import static org.testng.Assert.fail;
import java.util.ArrayList;
import java.util.List;
+import org.apache.datasketches.memory.internal.Ints;
import org.testng.annotations.Test;
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org