You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datasketches.apache.org by le...@apache.org on 2021/05/18 19:57:15 UTC
[datasketches-memory] 08/08: Refactoring complete.
This is an automated email from the ASF dual-hosted git repository.
leerho pushed a commit to branch CreateInternal2
in repository https://gitbox.apache.org/repos/asf/datasketches-memory.git
commit f686454a3520004993a2a67220efd4a1c13e7db9
Author: Lee Rhodes <le...@users.noreply.github.com>
AuthorDate: Tue May 18 12:55:42 2021 -0700
Refactoring complete.
Move all main classes to internal package. Create interface proxies for
the memory package. This creates possibility to restrict access to
internal package using JPMS in JDK 9+.
All tests pass and the vast majority of tests are black-box tests.
---
.../org/apache/datasketches/memory/BaseBuffer.java | 2 +-
.../apache/datasketches/memory/WritableBuffer.java | 2 +-
.../memory/internal/AllocateDirect.java | 2 +-
.../apache/datasketches/memory/internal/Util.java | 8 +-
.../memory/test/AllocateDirectMapMemoryTest.java | 29 +--
.../memory/test/AllocateDirectMemoryTest.java | 41 ++--
.../test/AllocateDirectWritableMapMemoryTest.java | 59 +++---
.../datasketches/memory/test/BaseBufferTest.java | 22 +-
.../datasketches/memory/test/BaseStateTest.java | 22 +-
.../datasketches/memory/test/Buffer2Test.java | 86 ++++----
.../memory/test/BufferBoundaryCheckTest.java | 4 +-
.../memory/test/BufferInvariantsTest.java | 54 ++---
.../memory/test/BufferReadWriteSafetyTest.java | 16 +-
.../datasketches/memory/test/BufferTest.java | 102 +++++-----
.../datasketches/memory/test/CommonBufferTest.java | 56 +++---
.../datasketches/memory/test/CommonMemoryTest.java | 58 +++---
.../memory/test/CopyMemoryOverlapTest.java | 34 ++--
.../datasketches/memory/test/CopyMemoryTest.java | 62 +++---
.../test/ExampleMemoryRequestServerTest.java | 45 +++--
.../memory/test/IgnoredArrayOverflowTest.java | 13 +-
.../datasketches/memory/test/LeafImplTest.java | 64 +++---
.../memory/test/MemoryBoundaryCheckTest.java | 6 +-
.../memory/test/MemoryReadWriteSafetyTest.java | 49 +++--
.../datasketches/memory/test/MemoryTest.java | 199 +++++++++---------
.../memory/test/MemoryWriteToTest.java | 24 +--
...Test.java => NativeWritableBufferImplTest.java} | 210 +++++++++----------
...Test.java => NativeWritableMemoryImplTest.java} | 222 ++++++++++-----------
.../test/NonNativeWritableBufferImplTest.java | 70 +++----
.../test/NonNativeWritableMemoryImplTest.java | 36 ++--
.../datasketches/memory/test/ReflectUtil.java | 24 ---
.../datasketches/memory/test/SpecificLeafTest.java | 84 ++++----
.../apache/datasketches/memory/test/Utf8Test.java | 50 ++---
.../apache/datasketches/memory/test/UtilTest.java | 4 +-
.../memory/test/WritableDirectCopyTest.java | 86 ++++----
.../memory/test/WritableMemoryTest.java | 52 ++---
.../memory/test/XxHash64LoopingTest.java | 4 +-
.../datasketches/memory/test/XxHash64Test.java | 16 +-
.../datasketches/memory/test/ZeroCapacityTest.java | 16 +-
38 files changed, 959 insertions(+), 974 deletions(-)
diff --git a/src/main/java/org/apache/datasketches/memory/BaseBuffer.java b/src/main/java/org/apache/datasketches/memory/BaseBuffer.java
index 68c18c3..220092d 100644
--- a/src/main/java/org/apache/datasketches/memory/BaseBuffer.java
+++ b/src/main/java/org/apache/datasketches/memory/BaseBuffer.java
@@ -19,7 +19,7 @@
package org.apache.datasketches.memory;
-public interface BaseBuffer {
+public interface BaseBuffer extends BaseState {
/**
* Increments the current position by the given increment.
diff --git a/src/main/java/org/apache/datasketches/memory/WritableBuffer.java b/src/main/java/org/apache/datasketches/memory/WritableBuffer.java
index 0a4e282..bfb3834 100644
--- a/src/main/java/org/apache/datasketches/memory/WritableBuffer.java
+++ b/src/main/java/org/apache/datasketches/memory/WritableBuffer.java
@@ -25,7 +25,7 @@ import java.nio.ByteOrder;
import org.apache.datasketches.memory.internal.WritableBufferImpl;
-public interface WritableBuffer {
+public interface WritableBuffer extends Buffer {
//BYTE BUFFER
/**
diff --git a/src/main/java/org/apache/datasketches/memory/internal/AllocateDirect.java b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirect.java
index bc47f57..f5c1bdf 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/AllocateDirect.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/AllocateDirect.java
@@ -59,7 +59,7 @@ final class AllocateDirect implements AutoCloseable {
nativeAddress = unsafe.allocateMemory(allocationSize);
} catch (final OutOfMemoryError err) {
NioBits.unreserveMemory(allocationSize, capacityBytes);
- throw err;
+ throw new RuntimeException(err);
}
if (pageAligned && ((nativeAddress % pageSize) != 0)) {
//Round up to page boundary
diff --git a/src/main/java/org/apache/datasketches/memory/internal/Util.java b/src/main/java/org/apache/datasketches/memory/internal/Util.java
index f44c52d..1c6758f 100644
--- a/src/main/java/org/apache/datasketches/memory/internal/Util.java
+++ b/src/main/java/org/apache/datasketches/memory/internal/Util.java
@@ -31,6 +31,8 @@ import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Random;
+import org.apache.datasketches.memory.Memory;
+
/**
* @author Lee Rhodes
*/
@@ -47,7 +49,7 @@ public final class Util {
* threshold, because internally it doesn't have safepoint polls, that may cause long
* "Time To Safe Point" pauses in the application. This has been fixed in JDK 9 (see
* https://bugs.openjdk.java.net/browse/JDK-8149596 and
- * https://bugs.openjdk.java.net/browse/JDK-8141491), but not in JDK 8, so the MemoryImpl library
+ * https://bugs.openjdk.java.net/browse/JDK-8141491), but not in JDK 8, so the Memory library
* should keep having this boilerplate as long as it supports Java 8.
*
* <p>A reference to this can be found in java.nio.Bits.</p>
@@ -84,7 +86,7 @@ public final class Util {
* 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 MemoryImpl to be searched
+ * @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
@@ -94,7 +96,7 @@ public final class Util {
* 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 MemoryImpl mem, final long fromLongIndex,
+ public static long binarySearchLongs(final Memory mem, final long fromLongIndex,
final long toLongIndex, final long key) {
checkBounds(fromLongIndex << 3, (toLongIndex - fromLongIndex) << 3, mem.getCapacity());
long low = fromLongIndex;
diff --git a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java
index a78e27f..f044453 100644
--- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMapMemoryTest.java
@@ -33,7 +33,7 @@ import java.io.File;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.MapHandle;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Memory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
@@ -51,7 +51,8 @@ public class AllocateDirectMapMemoryTest {
@Test
public void simpleMap() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (MapHandle rh = MemoryImpl.map(file)) {
+ assertTrue(ReflectUtil.isFileReadOnly(file));
+ try (MapHandle rh = Memory.map(file)) {
rh.close();
}
}
@@ -59,13 +60,13 @@ public class AllocateDirectMapMemoryTest {
@Test
public void testIllegalArguments() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (MapHandle rh = MemoryImpl.map(file, -1, Integer.MAX_VALUE, ByteOrder.nativeOrder())) {
+ try (MapHandle rh = Memory.map(file, -1, Integer.MAX_VALUE, ByteOrder.nativeOrder())) {
fail("Failed: testIllegalArgumentException: Position was negative.");
} catch (IllegalArgumentException e) {
//ok
}
- try (MapHandle rh = MemoryImpl.map(file, 0, -1, ByteOrder.nativeOrder())) {
+ try (MapHandle rh = Memory.map(file, 0, -1, ByteOrder.nativeOrder())) {
fail("Failed: testIllegalArgumentException: Size was negative.");
} catch (IllegalArgumentException e) {
//ok
@@ -76,8 +77,8 @@ public class AllocateDirectMapMemoryTest {
public void testMapAndMultipleClose() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- try (MapHandle rh = MemoryImpl.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
- MemoryImpl map = rh.get();
+ try (MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
+ Memory map = rh.get();
assertEquals(memCapacity, map.getCapacity());
rh.close();
rh.close();
@@ -91,8 +92,8 @@ public class AllocateDirectMapMemoryTest {
public void testReadFailAfterClose() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- try (MapHandle rh = MemoryImpl.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
- MemoryImpl mmf = rh.get();
+ try (MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
+ Memory mmf = rh.get();
rh.close();
mmf.getByte(0);
} catch (AssertionError e) {
@@ -104,7 +105,7 @@ public class AllocateDirectMapMemoryTest {
public void testLoad() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- try (MapHandle rh = MemoryImpl.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
+ try (MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
rh.load();
assertTrue(rh.isLoaded());
rh.close();
@@ -115,8 +116,8 @@ public class AllocateDirectMapMemoryTest {
public void testHandlerHandoffWithTWR() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- MemoryImpl mem;
- try (MapHandle rh = MemoryImpl.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
+ Memory mem;
+ try (MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder())) {
rh.load();
assertTrue(rh.isLoaded());
hand = rh;
@@ -130,7 +131,7 @@ public class AllocateDirectMapMemoryTest {
public void testHandoffWithoutClose() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
long memCapacity = file.length();
- MapHandle rh = MemoryImpl.map(file, 0, memCapacity, ByteOrder.nativeOrder());
+ MapHandle rh = Memory.map(file, 0, memCapacity, ByteOrder.nativeOrder());
rh.load();
assertTrue(rh.isLoaded());
hand = rh;
@@ -138,9 +139,9 @@ public class AllocateDirectMapMemoryTest {
}
@AfterClass
- public void afterAllTests() {
+ public void afterAllTests() throws Exception {
if (hand != null) {
- MemoryImpl mem = hand.get();
+ Memory mem = hand.get();
if ((mem != null) && mem.isValid()) {
hand.close();
assertFalse(mem.isValid());
diff --git a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMemoryTest.java
index c487b91..a70098f 100644
--- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectMemoryTest.java
@@ -26,11 +26,12 @@ import static org.testng.Assert.fail;
import java.lang.reflect.InvocationTargetException;
+import org.apache.datasketches.memory.BaseState;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableDirectHandle;
import org.apache.datasketches.memory.WritableHandle;
+import org.apache.datasketches.memory.WritableMemory;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
import org.testng.annotations.AfterClass;
import org.testng.annotations.Test;
@@ -38,11 +39,11 @@ import org.testng.annotations.Test;
public class AllocateDirectMemoryTest {
@Test
- public void simpleAllocateDirect() {
+ public void simpleAllocateDirect() throws Exception {
int longs = 32;
- WritableMemoryImpl wMem;
- try (WritableHandle wh = WritableMemoryImpl.allocateDirect(longs << 3)) {
- wMem = wh.get();
+ WritableMemory wMem;
+ try (WritableHandle wh = WritableMemory.allocateDirect(longs << 3)) {
+ wMem = wh.getWritable();
for (int i = 0; i<longs; i++) {
wMem.putLong(i << 3, i);
assertEquals(wMem.getLong(i << 3), i);
@@ -67,11 +68,11 @@ public class AllocateDirectMemoryTest {
}
@Test
- public void checkDefaultMemoryRequestServer() {
+ public void checkDefaultMemoryRequestServer() throws Exception {
int longs1 = 32;
int bytes1 = longs1 << 3;
- try (WritableHandle wh = WritableMemoryImpl.allocateDirect(bytes1)) {
- WritableMemoryImpl origWmem = wh.get();
+ try (WritableHandle wh = WritableMemory.allocateDirect(bytes1)) {
+ WritableMemory origWmem = wh.getWritable();
for (int i = 0; i<longs1; i++) { //puts data in wMem1
origWmem.putLong(i << 3, i);
assertEquals(origWmem.getLong(i << 3), i);
@@ -81,7 +82,7 @@ public class AllocateDirectMemoryTest {
int longs2 = 64;
int bytes2 = longs2 << 3;
MemoryRequestServer memReqSvr = origWmem.getMemoryRequestServer();
- WritableMemoryImpl newWmem = memReqSvr.request(bytes2);
+ WritableMemory newWmem = memReqSvr.request(bytes2);
assertFalse(newWmem.isDirect()); //on heap by default
for (int i = 0; i < longs2; i++) {
newWmem.putLong(i << 3, i);
@@ -94,37 +95,37 @@ public class AllocateDirectMemoryTest {
}
@Test
- public void checkNullMemoryRequestServer() {
- try (WritableHandle wh = WritableMemoryImpl.allocateDirect(128, null)) {
- WritableMemoryImpl wmem = wh.get();
+ public void checkNullMemoryRequestServer() throws Exception {
+ try (WritableHandle wh = WritableMemory.allocateDirect(128, null)) {
+ WritableMemory wmem = wh.getWritable();
assertNotNull(wmem.getMemoryRequestServer());
}
}
@Test
- public void checkNonNativeDirect() { //not allowed in public API
+ public void checkNonNativeDirect() throws Exception { //not allowed in public API
try (WritableDirectHandle h = ReflectUtil.wrapDirect(8, Util.nonNativeByteOrder, null)) {
- //BaseWritableMemoryImpl.wrapDirect(8, Util.nonNativeByteOrder, null)) {
- WritableMemoryImpl wmem = h.get();
+ //BaseWritableMemory.wrapDirect(8, Util.nonNativeByteOrder, null)) {
+ WritableMemory wmem = h.getWritable();
wmem.putChar(0, (char) 1);
assertEquals(wmem.getByte(1), (byte) 1);
}
}
@Test
- public void checkExplicitClose() {
+ public void checkExplicitClose() throws Exception {
final long cap = 128;
- try (WritableDirectHandle wdh = WritableMemoryImpl.allocateDirect(cap)) {
+ try (WritableDirectHandle wdh = WritableMemory.allocateDirect(cap)) {
wdh.close(); //explicit close. Does the work of closing
} //end of scope call to Cleaner/Deallocator also will be redundant
}
- @SuppressWarnings("static-access")
+
@AfterClass
public void checkDirectCounter() {
- WritableMemoryImpl mem = WritableMemoryImpl.writableWrap(new byte[8]);
- long count = mem.getCurrentDirectMemoryAllocations();
+ WritableMemory.writableWrap(new byte[8]);
+ long count = BaseState.getCurrentDirectMemoryAllocations();
if (count != 0) {
println(""+count);
fail();
diff --git a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java
index 5761068..23c915c 100644
--- a/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/AllocateDirectWritableMapMemoryTest.java
@@ -24,7 +24,7 @@
package org.apache.datasketches.memory.test;
import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.apache.datasketches.memory.internal.Util.*;
+import static org.apache.datasketches.memory.internal.Util.getResourceFile;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;
@@ -37,13 +37,14 @@ import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.nio.ByteOrder;
+import org.apache.datasketches.memory.BaseState;
import org.apache.datasketches.memory.MapHandle;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.WritableMapHandle;
+import org.apache.datasketches.memory.WritableMemory;
import org.apache.datasketches.memory.internal.ReadOnlyException;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
-import org.apache.datasketches.memory.WritableMapHandle;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
@@ -53,13 +54,10 @@ public class AllocateDirectWritableMapMemoryTest {
private static final String LS = System.getProperty("line.separator");
static final Method IS_FILE_READ_ONLY;
- static final Method GET_CURRENT_DIRECT_MEMORY_MAP_ALLOCATIONS;
static {
IS_FILE_READ_ONLY =
ReflectUtil.getMethod(ReflectUtil.ALLOCATE_DIRECT_MAP, "isFileReadOnly", File.class);
- GET_CURRENT_DIRECT_MEMORY_MAP_ALLOCATIONS =
- ReflectUtil.getMethod(ReflectUtil.BASE_STATE, "getCurrentDirectMemoryMapAllocations", (Class<?>[])null); //static
}
private static boolean isFileReadOnly(final File file) {
@@ -67,12 +65,6 @@ public class AllocateDirectWritableMapMemoryTest {
return (boolean) IS_FILE_READ_ONLY.invoke(null, file);
} catch (Exception e) { throw new RuntimeException(e); }
}
-
- private static long getCurrentDirectMemoryMapAllocations() {
- try {
- return (long) GET_CURRENT_DIRECT_MEMORY_MAP_ALLOCATIONS.invoke(null);
- } catch (Exception e) { throw new RuntimeException(e); }
- }
@BeforeClass
public void setReadOnly() {
@@ -82,8 +74,8 @@ public class AllocateDirectWritableMapMemoryTest {
@Test
public void simpleMap() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (MapHandle h = MemoryImpl.map(file); WritableMapHandle wh = (WritableMapHandle) h) {
- MemoryImpl mem = h.get();
+ try (MapHandle h = Memory.map(file); WritableMapHandle wh = (WritableMapHandle) h) {
+ Memory mem = h.get();
byte[] bytes = new byte[(int)mem.getCapacity()];
mem.getByteArray(0, bytes, 0, bytes.length);
String text = new String(bytes, UTF_8);
@@ -117,11 +109,11 @@ public class AllocateDirectWritableMapMemoryTest {
try (
WritableMapHandle dstHandle
- = WritableMemoryImpl.writableMap(file, 0, bytes, ByteOrder.nativeOrder());
- WritableHandle srcHandle = WritableMemoryImpl.allocateDirect(bytes)) {
+ = WritableMemory.writableMap(file, 0, bytes, ByteOrder.nativeOrder());
+ WritableHandle srcHandle = WritableMemory.allocateDirect(bytes)) {
- WritableMemoryImpl dstMem = dstHandle.get();
- WritableMemoryImpl srcMem = srcHandle.get();
+ WritableMemory dstMem = dstHandle.getWritable();
+ WritableMemory srcMem = srcHandle.getWritable();
for (long i = 0; i < longs; i++) {
srcMem.putLong(i << 3, i); //load source with consecutive longs
@@ -137,7 +129,7 @@ public class AllocateDirectWritableMapMemoryTest {
}
@Test
- public void checkNonNativeFile() throws IOException {
+ public void checkNonNativeFile() throws Exception {
File file = new File("TestFile2.bin");
if (file.exists()) {
try {
@@ -152,8 +144,8 @@ public class AllocateDirectWritableMapMemoryTest {
file.deleteOnExit(); //comment out if you want to examine the file.
final long bytes = 8;
- try (WritableMapHandle h = WritableMemoryImpl.writableMap(file, 0L, bytes, Util.nonNativeByteOrder)) {
- WritableMemoryImpl wmem = h.get();
+ try (WritableMapHandle h = WritableMemory.writableMap(file, 0L, bytes, Util.nonNativeByteOrder)) {
+ WritableMemory wmem = h.getWritable();
wmem.putChar(0, (char) 1);
assertEquals(wmem.getByte(1), (byte) 1);
}
@@ -164,22 +156,22 @@ public class AllocateDirectWritableMapMemoryTest {
public void testMapException() throws IOException {
File dummy = createFile("dummy.txt", ""); //zero length
//throws java.lang.reflect.InvocationTargetException
- MemoryImpl.map(dummy, 0, dummy.length(), ByteOrder.nativeOrder());
+ Memory.map(dummy, 0, dummy.length(), ByteOrder.nativeOrder());
}
@Test(expectedExceptions = ReadOnlyException.class)
- public void simpleMap2() throws IOException {
+ public void simpleMap2() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
assertTrue(isFileReadOnly(file));
- try (WritableMapHandle rh = WritableMemoryImpl.writableMap(file)) { //throws
+ try (WritableMapHandle rh = WritableMemory.writableMap(file)) { //throws
//
}
}
@Test(expectedExceptions = IllegalArgumentException.class)
- public void checkOverLength() {
+ public void checkOverLength() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (WritableMapHandle rh = WritableMemoryImpl.writableMap(file, 0, 1 << 20, ByteOrder.nativeOrder())) {
+ try (WritableMapHandle rh = WritableMemory.writableMap(file, 0, 1 << 20, ByteOrder.nativeOrder())) {
//
} catch (IOException e) {
throw new RuntimeException(e);
@@ -196,8 +188,8 @@ public class AllocateDirectWritableMapMemoryTest {
byte[] correctByteArr = correctStr.getBytes(UTF_8);
long corrBytes = correctByteArr.length;
- try (MapHandle rh = MemoryImpl.map(origFile, 0, origBytes, ByteOrder.nativeOrder())) {
- MemoryImpl map = rh.get();
+ try (MapHandle rh = Memory.map(origFile, 0, origBytes, ByteOrder.nativeOrder())) {
+ Memory map = rh.get();
rh.load();
assertTrue(rh.isLoaded());
//confirm orig string
@@ -207,9 +199,9 @@ public class AllocateDirectWritableMapMemoryTest {
assertEquals(bufStr, origStr);
}
- try (WritableMapHandle wrh = WritableMemoryImpl.writableMap(origFile, 0, corrBytes,
+ try (WritableMapHandle wrh = WritableMemory.writableMap(origFile, 0, corrBytes,
ByteOrder.nativeOrder())) {
- WritableMemoryImpl wMap = wrh.get();
+ WritableMemory wMap = wrh.getWritable();
wrh.load();
assertTrue(wrh.isLoaded());
// over write content
@@ -240,15 +232,14 @@ public class AllocateDirectWritableMapMemoryTest {
@Test
public void checkExplicitClose() throws Exception {
File file = getResourceFile("GettysburgAddress.txt");
- try (MapHandle wmh = MemoryImpl.map(file)) {
+ try (MapHandle wmh = Memory.map(file)) {
wmh.close(); //explicit close.
} //end of scope call to Cleaner/Deallocator also will be redundant
}
@AfterClass
public void checkDirectCounter() {
- long count = getCurrentDirectMemoryMapAllocations();
- //final long count = BaseStateImpl.getCurrentDirectMemoryMapAllocations();
+ long count = BaseState.getCurrentDirectMemoryMapAllocations();
if (count != 0) {
println(""+count);
fail();
diff --git a/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java b/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
index ac2579a..659bdf4 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BaseBufferTest.java
@@ -22,9 +22,9 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.fail;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
@@ -35,7 +35,7 @@ public class BaseBufferTest {
@Test
public void checkLimits() {
- BufferImpl buf = MemoryImpl.wrap(new byte[100]).asBuffer();
+ Buffer buf = Memory.wrap(new byte[100]).asBuffer();
buf.setStartPositionEnd(40, 45, 50);
buf.setStartPositionEnd(0, 0, 100);
try {
@@ -48,7 +48,7 @@ public class BaseBufferTest {
@Test
public void checkLimitsAndCheck() {
- BufferImpl buf = MemoryImpl.wrap(new byte[100]).asBuffer();
+ Buffer buf = Memory.wrap(new byte[100]).asBuffer();
buf.setAndCheckStartPositionEnd(40, 45, 50);
buf.setAndCheckStartPositionEnd(0, 0, 100);
try {
@@ -75,14 +75,14 @@ public class BaseBufferTest {
}
@Test
- public void checkCheckValid() {
- WritableMemoryImpl wmem;
- BufferImpl buf;
- try (WritableHandle hand = WritableMemoryImpl.allocateDirect(100)) {
- wmem = hand.get();
+ public void checkCheckValid() throws Exception {
+ WritableMemory wmem;
+ Buffer buf;
+ try (WritableHandle hand = WritableMemory.allocateDirect(100)) {
+ wmem = hand.getWritable();
buf = wmem.asBuffer();
}
@SuppressWarnings("unused")
- MemoryImpl mem = buf.asMemory();
+ Memory mem = buf.asMemory();
}
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java b/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java
index 598710f..550e378 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BaseStateTest.java
@@ -27,13 +27,13 @@ import static org.testng.Assert.fail;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.Prim;
import org.apache.datasketches.memory.internal.StepBoolean;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
@@ -47,13 +47,13 @@ public class BaseStateTest {
@Test
public void checkIsSameResource() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(16);
- MemoryImpl mem = wmem;
+ WritableMemory wmem = WritableMemory.allocate(16);
+ Memory mem = wmem;
assertFalse(wmem.isSameResource(null));
assertTrue(wmem.isSameResource(mem));
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
- BufferImpl buf = wbuf;
+ WritableBuffer wbuf = wmem.asWritableBuffer();
+ Buffer buf = wbuf;
assertFalse(wbuf.isSameResource(null));
assertTrue(wbuf.isSameResource(buf));
}
@@ -61,7 +61,7 @@ public class BaseStateTest {
@Test
public void checkNotEqualTo() {
byte[] arr = new byte[8];
- MemoryImpl mem = MemoryImpl.wrap(arr);
+ Memory mem = Memory.wrap(arr);
assertFalse(mem.equalTo(0, arr, 0, 8));
}
@@ -90,14 +90,14 @@ public class BaseStateTest {
@Test
public void checkGetNativeBaseOffset_Heap() throws Exception {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(8); //heap
+ WritableMemory wmem = WritableMemory.allocate(8); //heap
final long offset = ReflectUtil.getNativeBaseOffset(wmem);
assertEquals(offset, 0L);
}
@Test
public void checkIsByteOrderCompatible() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(8);
+ WritableMemory wmem = WritableMemory.allocate(8);
assertTrue(wmem.isByteOrderCompatible(ByteOrder.nativeOrder()));
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/Buffer2Test.java b/src/test/java/org/apache/datasketches/memory/test/Buffer2Test.java
index b2a7f1d..73660a4 100644
--- a/src/test/java/org/apache/datasketches/memory/test/Buffer2Test.java
+++ b/src/test/java/org/apache/datasketches/memory/test/Buffer2Test.java
@@ -26,11 +26,11 @@ import static org.testng.Assert.assertTrue;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.ReadOnlyException;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
@@ -47,7 +47,7 @@ public class Buffer2Test {
}
bb.position(0);
- BufferImpl buffer = BufferImpl.wrap(bb.asReadOnlyBuffer().order(ByteOrder.nativeOrder()));
+ Buffer buffer = Buffer.wrap(bb.asReadOnlyBuffer().order(ByteOrder.nativeOrder()));
while (buffer.hasRemaining()) {
assertEquals(bb.get(), buffer.getByte());
}
@@ -67,7 +67,7 @@ public class Buffer2Test {
}
bb.position(0);
- BufferImpl buffer = BufferImpl.wrap(bb);
+ Buffer buffer = Buffer.wrap(bb);
while (buffer.hasRemaining()) {
assertEquals(bb.get(), buffer.getByte());
}
@@ -84,7 +84,7 @@ public class Buffer2Test {
byteArray[i] = i;
}
- BufferImpl buffer = MemoryImpl.wrap(byteArray).asBuffer();
+ Buffer buffer = Memory.wrap(byteArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(byteArray[i++], buffer.getByte());
@@ -107,7 +107,7 @@ public class Buffer2Test {
charArray[i] = i;
}
- BufferImpl buffer = MemoryImpl.wrap(charArray).asBuffer();
+ Buffer buffer = Memory.wrap(charArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(charArray[i++], buffer.getChar());
@@ -127,7 +127,7 @@ public class Buffer2Test {
shortArray[i] = i;
}
- BufferImpl buffer = MemoryImpl.wrap(shortArray).asBuffer();
+ Buffer buffer = Memory.wrap(shortArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(shortArray[i++], buffer.getShort());
@@ -147,7 +147,7 @@ public class Buffer2Test {
intArray[i] = i;
}
- BufferImpl buffer = MemoryImpl.wrap(intArray).asBuffer();
+ Buffer buffer = Memory.wrap(intArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(intArray[i++], buffer.getInt());
@@ -167,7 +167,7 @@ public class Buffer2Test {
longArray[i] = i;
}
- BufferImpl buffer = MemoryImpl.wrap(longArray).asBuffer();
+ Buffer buffer = Memory.wrap(longArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(longArray[i++], buffer.getLong());
@@ -187,7 +187,7 @@ public class Buffer2Test {
floatArray[i] = i;
}
- BufferImpl buffer = MemoryImpl.wrap(floatArray).asBuffer();
+ Buffer buffer = Memory.wrap(floatArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(floatArray[i++], buffer.getFloat());
@@ -207,7 +207,7 @@ public class Buffer2Test {
doubleArray[i] = i;
}
- BufferImpl buffer = MemoryImpl.wrap(doubleArray).asBuffer();
+ Buffer buffer = Memory.wrap(doubleArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(doubleArray[i++], buffer.getDouble());
@@ -229,7 +229,7 @@ public class Buffer2Test {
}
}
- BufferImpl buffer = MemoryImpl.wrap(booleanArray).asBuffer();
+ Buffer buffer = Memory.wrap(booleanArray).asBuffer();
int i = 0;
while (buffer.hasRemaining()) {
assertEquals(booleanArray[i++], buffer.getBoolean());
@@ -254,7 +254,7 @@ public class Buffer2Test {
}
bb.position(10);
- BufferImpl buffer = BufferImpl.wrap(bb);
+ Buffer buffer = Buffer.wrap(bb);
while (buffer.hasRemaining()) {
assertEquals(bb.get(), buffer.getByte());
}
@@ -271,7 +271,7 @@ public class Buffer2Test {
}
bb.position(10);
- BufferImpl buffer = BufferImpl.wrap(bb);
+ Buffer buffer = Buffer.wrap(bb);
assertEquals(bb.hasRemaining(), buffer.hasRemaining());
assertEquals(bb.remaining(), buffer.getRemaining());
}
@@ -287,7 +287,7 @@ public class Buffer2Test {
}
bb.position(10);
- BufferImpl buffer = BufferImpl.wrap(bb);
+ Buffer buffer = Buffer.wrap(bb);
assertEquals(bb.position(), buffer.getPosition());
assertEquals(30, buffer.setPosition(30).getPosition());
assertEquals(40, buffer.incrementPosition(10).getPosition());
@@ -305,7 +305,7 @@ public class Buffer2Test {
}
bb.position(10);
- BufferImpl buffer = BufferImpl.wrap(bb.slice().order(ByteOrder.nativeOrder()));
+ Buffer buffer = Buffer.wrap(bb.slice().order(ByteOrder.nativeOrder()));
while (buffer.hasRemaining()) {
assertEquals(bb.get(), buffer.getByte());
}
@@ -327,10 +327,10 @@ public class Buffer2Test {
}
bb.position(10);
- BufferImpl buffer = BufferImpl.wrap(bb.slice().order(ByteOrder.nativeOrder())); //slice = 54
+ Buffer buffer = Buffer.wrap(bb.slice().order(ByteOrder.nativeOrder())); //slice = 54
buffer.setPosition(30);//remaining = 24
- BufferImpl dupBuffer = buffer.duplicate(); //all 54
- BufferImpl regionBuffer = buffer.region(); //24
+ Buffer dupBuffer = buffer.duplicate(); //all 54
+ Buffer regionBuffer = buffer.region(); //24
assertEquals(dupBuffer.getStart(), buffer.getStart());
assertEquals(regionBuffer.getStart(), buffer.getStart());
@@ -348,9 +348,9 @@ public class Buffer2Test {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- MemoryImpl mem = MemoryImpl.wrap(arr);
- BufferImpl buf = mem.asBuffer();
- BufferImpl reg = buf.region(n2 * 8, n2 * 8, buf.getTypeByteOrder()); //top half
+ Memory mem = Memory.wrap(arr);
+ Buffer buf = mem.asBuffer();
+ Buffer reg = buf.region(n2 * 8, n2 * 8, buf.getTypeByteOrder()); //top half
for (int i = 0; i < n2; i++) {
long v = reg.getLong(i * 8);
long e = i + n2;
@@ -369,8 +369,8 @@ public class Buffer2Test {
}
bb.position(10);
- BufferImpl buffer = BufferImpl.wrap(bb);
- MemoryImpl memory = buffer.asMemory();
+ Buffer buffer = Buffer.wrap(bb);
+ Memory memory = buffer.asMemory();
assertEquals(buffer.getCapacity(), memory.getCapacity());
@@ -383,8 +383,8 @@ public class Buffer2Test {
public void testROByteBuffer() {
byte[] arr = new byte[64];
ByteBuffer roBB = ByteBuffer.wrap(arr).asReadOnlyBuffer();
- BufferImpl buf = BufferImpl.wrap(roBB);
- WritableBufferImpl wbuf = (WritableBufferImpl) buf;
+ Buffer buf = Buffer.wrap(roBB);
+ WritableBuffer wbuf = (WritableBuffer) buf;
wbuf.putByte(0, (byte) 1);
}
@@ -392,8 +392,8 @@ public class Buffer2Test {
public void testROByteBuffer2() {
byte[] arr = new byte[64];
ByteBuffer roBB = ByteBuffer.wrap(arr).asReadOnlyBuffer();
- BufferImpl buf = BufferImpl.wrap(roBB);
- WritableBufferImpl wbuf = (WritableBufferImpl) buf;
+ Buffer buf = Buffer.wrap(roBB);
+ WritableBuffer wbuf = (WritableBuffer) buf;
wbuf.putByteArray(arr, 0, 64);
}
@@ -401,38 +401,38 @@ public class Buffer2Test {
public void testIllegalFill() {
byte[] arr = new byte[64];
ByteBuffer roBB = ByteBuffer.wrap(arr).asReadOnlyBuffer();
- BufferImpl buf = BufferImpl.wrap(roBB);
- WritableBufferImpl wbuf = (WritableBufferImpl) buf;
+ Buffer buf = Buffer.wrap(roBB);
+ WritableBuffer wbuf = (WritableBuffer) buf;
wbuf.fill((byte)0);
}
@Test
public void testWritableDuplicate() {
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(new byte[1]);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
- WritableBufferImpl wbuf2 = wbuf.writableDuplicate();
+ WritableMemory wmem = WritableMemory.writableWrap(new byte[1]);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBuffer wbuf2 = wbuf.writableDuplicate();
assertEquals(wbuf2.getCapacity(), 1);
- BufferImpl buf = wmem.asBuffer();
+ Buffer buf = wmem.asBuffer();
assertEquals(buf.getCapacity(), 1);
}
@Test
public void checkIndependence() {
int cap = 64;
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(cap);
- WritableBufferImpl wbuf1 = wmem.asWritableBuffer();
- WritableBufferImpl wbuf2 = wmem.asWritableBuffer();
+ WritableMemory wmem = WritableMemory.allocate(cap);
+ WritableBuffer wbuf1 = wmem.asWritableBuffer();
+ WritableBuffer wbuf2 = wmem.asWritableBuffer();
assertFalse(wbuf1 == wbuf2);
assertTrue(wbuf1.isSameResource(wbuf2));
- WritableMemoryImpl reg1 = wmem.writableRegion(0, cap);
- WritableMemoryImpl reg2 = wmem.writableRegion(0, cap);
+ WritableMemory reg1 = wmem.writableRegion(0, cap);
+ WritableMemory reg2 = wmem.writableRegion(0, cap);
assertFalse(reg1 == reg2);
assertTrue(reg1.isSameResource(reg2));
- WritableBufferImpl wbuf3 = wbuf1.writableRegion();
- WritableBufferImpl wbuf4 = wbuf1.writableRegion();
+ WritableBuffer wbuf3 = wbuf1.writableRegion();
+ WritableBuffer wbuf4 = wbuf1.writableRegion();
assertFalse(wbuf3 == wbuf4);
assertTrue(wbuf3.isSameResource(wbuf4));
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/BufferBoundaryCheckTest.java b/src/test/java/org/apache/datasketches/memory/test/BufferBoundaryCheckTest.java
index 356862d..03d428d 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferBoundaryCheckTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferBoundaryCheckTest.java
@@ -19,13 +19,13 @@
package org.apache.datasketches.memory.test;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class BufferBoundaryCheckTest {
- private final WritableMemoryImpl writableMemory = WritableMemoryImpl.allocate(8);
+ private final WritableMemory writableMemory = WritableMemory.allocate(8);
@Test
public void testGetBoolean() {
diff --git a/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java b/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
index 46f340d..73acaa9 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferInvariantsTest.java
@@ -25,9 +25,9 @@ import static org.testng.Assert.fail;
import java.nio.ByteBuffer;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
@@ -40,10 +40,10 @@ public class BufferInvariantsTest {
public void testRegion() {
ByteBuffer byteBuffer = ByteBuffer.allocate(10);
byteBuffer.limit(7);
- BufferImpl buff = BufferImpl.wrap(byteBuffer); //assuming buff has cap of 8
+ Buffer buff = Buffer.wrap(byteBuffer); //assuming buff has cap of 8
assertEquals(buff.getCapacity(), 10); //wrong should be 8
buff.getByte(); //pos moves to 1
- BufferImpl copyBuff = buff.region(); //pos: 0, start: 0, end: 6: cap: 7
+ Buffer copyBuff = buff.region(); //pos: 0, start: 0, end: 6: cap: 7
assertEquals(copyBuff.getEnd(), 6);
assertEquals(copyBuff.getCapacity(), 6);
assertEquals(copyBuff.getStart(), 0);
@@ -51,7 +51,7 @@ public class BufferInvariantsTest {
buff.setStartPositionEnd(1, 1, 5);
buff.getByte();
- BufferImpl copyBuff2 = buff.region();
+ Buffer copyBuff2 = buff.region();
assertEquals(copyBuff2.getEnd(), 3);
assertEquals(copyBuff2.getCapacity(), 3);
assertEquals(copyBuff2.getStart(), 0);
@@ -93,7 +93,7 @@ public class BufferInvariantsTest {
@Test
public void testBuf() {
int n = 25;
- WritableBufferImpl buf = WritableMemoryImpl.allocate(n).asWritableBuffer();
+ WritableBuffer buf = WritableMemory.allocate(n).asWritableBuffer();
for (byte i = 0; i < n; i++) { buf.putByte(i); }
buf.setPosition(0);
assertEquals(buf.getPosition(), 0);
@@ -110,7 +110,7 @@ public class BufferInvariantsTest {
// print("Set : ");
// printbuf(buf);
- BufferImpl dup = buf.duplicate();
+ Buffer dup = buf.duplicate();
assertEquals(dup.getRemaining(), 15);
assertEquals(dup.getCapacity(), 25);
assertEquals(dup.getByte(), 5);
@@ -119,7 +119,7 @@ public class BufferInvariantsTest {
// printbuf(dup);
- BufferImpl reg = buf.region();
+ Buffer reg = buf.region();
assertEquals(reg.getPosition(), 0);
assertEquals(reg.getEnd(), 15);
assertEquals(reg.getRemaining(), 15);
@@ -139,7 +139,7 @@ public class BufferInvariantsTest {
bb.position(5);
bb.limit(20);
- BufferImpl buf = BufferImpl.wrap(bb);
+ Buffer buf = Buffer.wrap(bb);
assertEquals(buf.getPosition(), 5);
assertEquals(buf.getEnd(), 20);
assertEquals(buf.getRemaining(), 15);
@@ -149,7 +149,7 @@ public class BufferInvariantsTest {
// print("Buf.wrap: ");
// printbuf(buf);
- BufferImpl reg = buf.region();
+ Buffer reg = buf.region();
assertEquals(reg.getPosition(), 0);
assertEquals(reg.getEnd(), 15);
assertEquals(reg.getRemaining(), 15);
@@ -161,10 +161,10 @@ public class BufferInvariantsTest {
}
@Test
- public void checkLimitsDirect() {
- try (WritableHandle hand = WritableMemoryImpl.allocateDirect(100)) {
- WritableMemoryImpl wmem = hand.get();
- BufferImpl buf = wmem.asBuffer();
+ public void checkLimitsDirect() throws Exception {
+ try (WritableHandle hand = WritableMemory.allocateDirect(100)) {
+ WritableMemory wmem = hand.getWritable();
+ Buffer buf = wmem.asBuffer();
buf.setStartPositionEnd(40, 45, 50);
buf.setStartPositionEnd(0, 0, 100);
try {
@@ -180,10 +180,10 @@ public class BufferInvariantsTest {
public void testRegionDirect() {
ByteBuffer byteBuffer = ByteBuffer.allocate(10);
byteBuffer.limit(7);
- BufferImpl buff = BufferImpl.wrap(byteBuffer); //assuming buff has cap of 8
+ Buffer buff = Buffer.wrap(byteBuffer); //assuming buff has cap of 8
assertEquals(buff.getCapacity(), 10); //wrong should be 8
buff.getByte(); //pos moves to 1
- BufferImpl copyBuff = buff.region(); //pos: 0, start: 0, end: 6: cap: 7
+ Buffer copyBuff = buff.region(); //pos: 0, start: 0, end: 6: cap: 7
assertEquals(copyBuff.getEnd(), 6);
assertEquals(copyBuff.getCapacity(), 6);
assertEquals(copyBuff.getStart(), 0);
@@ -191,7 +191,7 @@ public class BufferInvariantsTest {
buff.setStartPositionEnd(1, 1, 5);
buff.getByte();
- BufferImpl copyBuff2 = buff.region();
+ Buffer copyBuff2 = buff.region();
assertEquals(copyBuff2.getEnd(), 3);
assertEquals(copyBuff2.getCapacity(), 3);
assertEquals(copyBuff2.getStart(), 0);
@@ -231,11 +231,11 @@ public class BufferInvariantsTest {
}
@Test
- public void testBufDirect() {
+ public void testBufDirect() throws Exception {
int n = 25;
- try (WritableHandle whand = WritableMemoryImpl.allocateDirect(n)) {
- WritableMemoryImpl wmem = whand.get();
- WritableBufferImpl buf = wmem.asWritableBuffer();
+ try (WritableHandle whand = WritableMemory.allocateDirect(n)) {
+ WritableMemory wmem = whand.getWritable();
+ WritableBuffer buf = wmem.asWritableBuffer();
for (byte i = 0; i < n; i++) { buf.putByte(i); }
buf.setPosition(0);
assertEquals(buf.getPosition(), 0);
@@ -252,7 +252,7 @@ public class BufferInvariantsTest {
// print("Set : ");
// printbuf(buf);
- BufferImpl dup = buf.duplicate();
+ Buffer dup = buf.duplicate();
assertEquals(dup.getRemaining(), 15);
assertEquals(dup.getCapacity(), 25);
assertEquals(dup.getByte(), 5);
@@ -261,7 +261,7 @@ public class BufferInvariantsTest {
// printbuf(dup);
- BufferImpl reg = buf.region();
+ Buffer reg = buf.region();
assertEquals(reg.getPosition(), 0);
assertEquals(reg.getEnd(), 15);
assertEquals(reg.getRemaining(), 15);
@@ -282,7 +282,7 @@ public class BufferInvariantsTest {
bb.position(5);
bb.limit(20);
- BufferImpl buf = BufferImpl.wrap(bb);
+ Buffer buf = Buffer.wrap(bb);
assertEquals(buf.getPosition(), 5);
assertEquals(buf.getEnd(), 20);
assertEquals(buf.getRemaining(), 15);
@@ -292,7 +292,7 @@ public class BufferInvariantsTest {
// print("Buf.wrap: ");
// printbuf(buf);
- BufferImpl reg = buf.region();
+ Buffer reg = buf.region();
assertEquals(reg.getPosition(), 0);
assertEquals(reg.getEnd(), 15);
assertEquals(reg.getRemaining(), 15);
@@ -315,7 +315,7 @@ public class BufferInvariantsTest {
println(bb.get(i + pos) + "\n");
}
- static void printbuf(BufferImpl buf) {
+ static void printbuf(Buffer buf) {
println("pos: " + buf.getPosition() + ", end: " + buf.getEnd() + ", cap: " + buf.getCapacity());
long rem = buf.getRemaining();
long pos = buf.getPosition();
diff --git a/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java b/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java
index b076dee..de56ca3 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferReadWriteSafetyTest.java
@@ -21,18 +21,18 @@ package org.apache.datasketches.memory.test;
import java.nio.ByteBuffer;
-import org.apache.datasketches.memory.internal.BufferImpl;
+import org.apache.datasketches.memory.Buffer;
import org.apache.datasketches.memory.internal.ReadOnlyException;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class BufferReadWriteSafetyTest {
- // Test various operations with read-only BufferImpl
+ // Test various operations with read-only Buffer
- private final WritableBufferImpl buf = (WritableBufferImpl) BufferImpl.wrap(ByteBuffer.allocate(8));
+ private final WritableBuffer buf = (WritableBuffer) Buffer.wrap(ByteBuffer.allocate(8));
@Test(expectedExceptions = AssertionError.class)
public void testPutByte() {
@@ -158,19 +158,19 @@ public class BufferReadWriteSafetyTest {
@Test(expectedExceptions = AssertionError.class)
public void testWritableMemoryAsBuffer() {
- WritableBufferImpl buf1 = (WritableBufferImpl) WritableMemoryImpl.allocate(8).asBuffer();
+ WritableBuffer buf1 = (WritableBuffer) WritableMemory.allocate(8).asBuffer();
buf1.putInt(1);
}
@Test(expectedExceptions = AssertionError.class)
public void testWritableBufferRegion() {
- WritableBufferImpl buf1 = (WritableBufferImpl) WritableMemoryImpl.allocate(8).asWritableBuffer().region();
+ WritableBuffer buf1 = (WritableBuffer) WritableMemory.allocate(8).asWritableBuffer().region();
buf1.putInt(1);
}
@Test(expectedExceptions = AssertionError.class)
public void testWritableBufferDuplicate() {
- WritableBufferImpl buf1 = (WritableBufferImpl) WritableMemoryImpl.allocate(8).asWritableBuffer().duplicate();
+ WritableBuffer buf1 = (WritableBuffer) WritableMemory.allocate(8).asWritableBuffer().duplicate();
buf1.putInt(1);
}
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/BufferTest.java b/src/test/java/org/apache/datasketches/memory/test/BufferTest.java
index 123bbbf..267f5ab 100644
--- a/src/test/java/org/apache/datasketches/memory/test/BufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/BufferTest.java
@@ -26,10 +26,10 @@ import java.nio.ByteOrder;
import java.util.List;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
import org.testng.collections.Lists;
@@ -37,11 +37,11 @@ import org.testng.collections.Lists;
public class BufferTest {
@Test
- public void checkDirectRoundTrip() {
+ public void checkDirectRoundTrip() throws Exception {
int n = 1024; //longs
- try (WritableHandle wh = WritableMemoryImpl.allocateDirect(n * 8)) {
- WritableMemoryImpl wmem = wh.get();
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ try (WritableHandle wh = WritableMemory.allocateDirect(n * 8)) {
+ WritableMemory wmem = wh.getWritable();
+ WritableBuffer wbuf = wmem.asWritableBuffer();
for (int i = 0; i < n; i++) {
wbuf.putLong(i);
}
@@ -56,7 +56,7 @@ public class BufferTest {
@Test
public void checkAutoHeapRoundTrip() {
int n = 1024; //longs
- WritableBufferImpl wbuf = WritableMemoryImpl.allocate(n * 8).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.allocate(n * 8).asWritableBuffer();
for (int i = 0; i < n; i++) {
wbuf.putLong(i);
}
@@ -71,7 +71,7 @@ public class BufferTest {
public void checkArrayWrap() {
int n = 1024; //longs
byte[] arr = new byte[n * 8];
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(arr).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.writableWrap(arr).asWritableBuffer();
for (int i = 0; i < n; i++) {
wbuf.putLong(i);
}
@@ -80,31 +80,31 @@ public class BufferTest {
long v = wbuf.getLong();
assertEquals(v, i);
}
- BufferImpl buf = MemoryImpl.wrap(arr).asBuffer();
+ Buffer buf = Memory.wrap(arr).asBuffer();
buf.resetPosition();
for (int i = 0; i < n; i++) {
long v = buf.getLong();
assertEquals(v, i);
}
// Check Zero length array wraps
- MemoryImpl mem = MemoryImpl.wrap(new byte[0]);
- BufferImpl buffZeroLengthArrayWrap = mem.asBuffer();
+ Memory mem = Memory.wrap(new byte[0]);
+ Buffer buffZeroLengthArrayWrap = mem.asBuffer();
assertEquals(buffZeroLengthArrayWrap.getCapacity(), 0);
// check 0 length array wraps
- List<BufferImpl> buffersToCheck = Lists.newArrayList();
- buffersToCheck.add(WritableMemoryImpl.allocate(0).asBuffer());
- buffersToCheck.add(WritableBufferImpl.writableWrap(ByteBuffer.allocate(0)));
- buffersToCheck.add(BufferImpl.wrap(ByteBuffer.allocate(0)));
- buffersToCheck.add(MemoryImpl.wrap(new boolean[0]).asBuffer());
- buffersToCheck.add(MemoryImpl.wrap(new byte[0]).asBuffer());
- buffersToCheck.add(MemoryImpl.wrap(new char[0]).asBuffer());
- buffersToCheck.add(MemoryImpl.wrap(new short[0]).asBuffer());
- buffersToCheck.add(MemoryImpl.wrap(new int[0]).asBuffer());
- buffersToCheck.add(MemoryImpl.wrap(new long[0]).asBuffer());
- buffersToCheck.add(MemoryImpl.wrap(new float[0]).asBuffer());
- buffersToCheck.add(MemoryImpl.wrap(new double[0]).asBuffer());
+ 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());
//Check the buffer lengths
- for (BufferImpl buffer : buffersToCheck) {
+ for (Buffer buffer : buffersToCheck) {
assertEquals(buffer.getCapacity(), 0);
}
}
@@ -116,7 +116,7 @@ public class BufferTest {
ByteBuffer bb = ByteBuffer.wrap(arr);
bb.order(ByteOrder.nativeOrder());
- WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wbuf
wbuf.putLong(i);
}
@@ -138,7 +138,7 @@ public class BufferTest {
ByteBuffer bb = ByteBuffer.wrap(arr);
bb.order(ByteOrder.nativeOrder());
- WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wbuf
wbuf.putLong(i);
}
@@ -151,13 +151,13 @@ public class BufferTest {
long v = bb.getLong(i * 8);
assertEquals(v, i);
}
- BufferImpl buf1 = MemoryImpl.wrap(arr).asBuffer();
+ Buffer buf1 = Memory.wrap(arr).asBuffer();
for (int i = 0; i < n; i++) { //read from wrapped arr
long v = buf1.getLong();
assertEquals(v, i);
}
//convert to wbuf to RO
- BufferImpl buf = wbuf;
+ Buffer buf = wbuf;
buf.resetPosition();
for (int i = 0; i < n; i++) {
long v = buf.getLong();
@@ -171,7 +171,7 @@ public class BufferTest {
ByteBuffer bb = ByteBuffer.allocateDirect(n * 8);
bb.order(ByteOrder.nativeOrder());
- WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wmem
wbuf.putLong(i);
}
@@ -184,13 +184,13 @@ public class BufferTest {
long v = bb.getLong(i * 8);
assertEquals(v, i);
}
- BufferImpl buf1 = BufferImpl.wrap(bb);
+ Buffer buf1 = Buffer.wrap(bb);
for (int i = 0; i < n; i++) { //read from wrapped bb RO
long v = buf1.getLong();
assertEquals(v, i);
}
//convert to RO
- BufferImpl buf = wbuf;
+ Buffer buf = wbuf;
buf.resetPosition();
for (int i = 0; i < n; i++) {
long v = buf.getLong();
@@ -203,7 +203,7 @@ public class BufferTest {
int n = 1024; //longs
ByteBuffer bb = ByteBuffer.allocate(n * 8);
bb.order(ByteOrder.BIG_ENDIAN);
- BufferImpl buf = BufferImpl.wrap(bb);
+ Buffer buf = Buffer.wrap(bb);
assertEquals(buf.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
}
@@ -217,7 +217,7 @@ public class BufferTest {
ByteBuffer slice = bb.slice().asReadOnlyBuffer();
slice.order(ByteOrder.nativeOrder());
- BufferImpl buf = BufferImpl.wrap(slice);
+ Buffer buf = Buffer.wrap(slice);
for (int i = 0; i < 64; i++) {
assertEquals(buf.getByte(), 64 + i);
}
@@ -231,7 +231,7 @@ public class BufferTest {
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableBufferImpl wbuf = WritableMemoryImpl.allocate(n * 8).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.allocate(n * 8).asWritableBuffer();
wbuf.putLongArray(arr, 0, n);
long[] arr2 = new long[n];
wbuf.resetPosition();
@@ -248,9 +248,9 @@ public class BufferTest {
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- BufferImpl buf = MemoryImpl.wrap(arr).asBuffer();
+ Buffer buf = Memory.wrap(arr).asBuffer();
buf.setPosition(n2 * 8);
- BufferImpl reg = buf.region();
+ Buffer reg = buf.region();
for (int i = 0; i < n2; i++) {
long v = reg.getLong();
assertEquals(v, i + n2);
@@ -264,14 +264,14 @@ public class BufferTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(arr).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.writableWrap(arr).asWritableBuffer();
for (int i = 0; i < n; i++) {
assertEquals(wbuf.getLong(), i); //write all
//println("" + wmem.getLong(i * 8));
}
//println("");
wbuf.setPosition(n2 * 8);
- WritableBufferImpl reg = wbuf.writableRegion();
+ WritableBuffer reg = wbuf.writableRegion();
for (int i = 0; i < n2; i++) { reg.putLong(i); } //rewrite top half
wbuf.resetPosition();
for (int i = 0; i < n; i++) {
@@ -281,35 +281,35 @@ public class BufferTest {
}
@Test(expectedExceptions = AssertionError.class)
- public void checkParentUseAfterFree() {
+ public void checkParentUseAfterFree() throws Exception {
int bytes = 64 * 8;
@SuppressWarnings("resource") //intentionally not using try-with-resources here
- WritableHandle wh = WritableMemoryImpl.allocateDirect(bytes);
- WritableMemoryImpl wmem = wh.get();
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableHandle wh = WritableMemory.allocateDirect(bytes);
+ WritableMemory wmem = wh.getWritable();
+ WritableBuffer wbuf = wmem.asWritableBuffer();
wh.close();
- //with -ea assert: MemoryImpl not valid.
+ //with -ea assert: Memory not valid.
//with -da sometimes segfaults, sometimes passes!
wbuf.getLong();
}
@SuppressWarnings("resource")
@Test(expectedExceptions = AssertionError.class)
- public void checkRegionUseAfterFree() {
+ public void checkRegionUseAfterFree() throws Exception {
int bytes = 64;
- WritableHandle wh = WritableMemoryImpl.allocateDirect(bytes);
- MemoryImpl wmem = wh.get();
+ WritableHandle wh = WritableMemory.allocateDirect(bytes);
+ Memory wmem = wh.get();
- BufferImpl reg = wmem.asBuffer().region();
+ Buffer reg = wmem.asBuffer().region();
wh.close();
- //with -ea assert: MemoryImpl not valid.
+ //with -ea assert: Memory not valid.
//with -da sometimes segfaults, sometimes passes!
reg.getByte();
}
@Test(expectedExceptions = AssertionError.class)
public void checkBaseBufferInvariants() {
- WritableBufferImpl wbuf = WritableMemoryImpl.allocate(64).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.allocate(64).asWritableBuffer();
wbuf.setStartPositionEnd(1, 0, 2); //out of order
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java b/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
index 1e12d32..9633b3d 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CommonBufferTest.java
@@ -22,26 +22,26 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.assertEquals;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class CommonBufferTest {
@Test
- public void checkSetGet() {
+ public void checkSetGet() throws Exception {
int memCapacity = 60; //must be at least 60
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
- WritableBufferImpl buf = mem.asWritableBuffer();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
setGetTests(buf);
setGetTests2(buf);
}
}
- public static void setGetTests(WritableBufferImpl buf) {
+ public static void setGetTests(WritableBuffer buf) {
buf.putBoolean(true);
buf.putBoolean(false);
buf.putByte((byte) -1);
@@ -95,7 +95,7 @@ public class CommonBufferTest {
assertEquals(buf.getDouble(), Double.MIN_VALUE);
}
- public static void setGetTests2(WritableBufferImpl buf) {
+ public static void setGetTests2(WritableBuffer buf) {
buf.putBoolean(0, true);
buf.putBoolean(1, false);
buf.putByte(2, (byte) -1);
@@ -132,17 +132,17 @@ public class CommonBufferTest {
}
@Test
- public void checkSetGetArrays() {
+ public void checkSetGetArrays() throws Exception {
int memCapacity = 32;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
- WritableBufferImpl buf = mem.asWritableBuffer();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
setGetArraysTests(buf);
}
}
- public static void setGetArraysTests(WritableBufferImpl buf) {
+ public static void setGetArraysTests(WritableBuffer buf) {
int words = 4;
boolean[] srcArray1 = {true, false, true, false};
@@ -229,17 +229,17 @@ public class CommonBufferTest {
}
@Test
- public void checkSetGetPartialArraysWithOffset() {
+ public void checkSetGetPartialArraysWithOffset() throws Exception {
int memCapacity = 32;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
- WritableBufferImpl buf = mem.asWritableBuffer();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
setGetPartialArraysWithOffsetTests(buf);
}
}
- public static void setGetPartialArraysWithOffsetTests(WritableBufferImpl buf) {
+ public static void setGetPartialArraysWithOffsetTests(WritableBuffer buf) {
int items= 4;
boolean[] srcArray1 = {true, false, true, false};
boolean[] dstArray1 = new boolean[items];
@@ -323,11 +323,11 @@ public class CommonBufferTest {
}
@Test
- public void checkSetClearMemoryRegions() {
+ public void checkSetClearMemoryRegions() throws Exception {
int memCapacity = 64; //must be 64
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh1.get();
- WritableBufferImpl buf = mem.asWritableBuffer();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh1.getWritable();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
setClearMemoryRegionsTests(buf); //requires println enabled to visually check
@@ -339,7 +339,7 @@ public class CommonBufferTest {
}
//enable println statements to visually check
- public static void setClearMemoryRegionsTests(WritableBufferImpl buf) {
+ public static void setClearMemoryRegionsTests(WritableBuffer buf) {
int accessCapacity = (int)buf.getCapacity();
//define regions
@@ -412,18 +412,18 @@ public class CommonBufferTest {
}
@Test
- public void checkToHexStringAllMem() {
+ public void checkToHexStringAllMem() throws Exception {
int memCapacity = 48; //must be 48
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh1.get();
- WritableBufferImpl buf = mem.asWritableBuffer();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh1.getWritable();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.getCapacity(), memCapacity);
toHexStringAllMemTests(buf); //requires println enabled to visually check
}
}
//enable println to visually check
- public static void toHexStringAllMemTests(WritableBufferImpl buf) {
+ public static void toHexStringAllMemTests(WritableBuffer buf) {
int memCapacity = (int)buf.getCapacity();
for (int i=0; i<memCapacity; i++) {
diff --git a/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java
index 5e237b6..51f1407 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CommonMemoryTest.java
@@ -28,23 +28,23 @@ import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class CommonMemoryTest {
@Test
- public void checkSetGet() {
+ public void checkSetGet() throws Exception {
int memCapacity = 16; //must be at least 8
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
assertEquals(mem.getCapacity(), memCapacity);
setGetTests(mem);
}
}
- public static void setGetTests(WritableMemoryImpl mem) {
+ public static void setGetTests(WritableMemory mem) {
mem.putBoolean(0, true);
assertEquals(mem.getBoolean(0), true);
mem.putBoolean(0, false);
@@ -87,16 +87,16 @@ public class CommonMemoryTest {
}
@Test
- public void checkSetGetArrays() {
+ public void checkSetGetArrays() throws Exception {
int memCapacity = 32;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
assertEquals(memCapacity, mem.getCapacity());
setGetArraysTests(mem);
}
}
- public static void setGetArraysTests(WritableMemoryImpl mem) {
+ public static void setGetArraysTests(WritableMemory mem) {
int accessCapacity = (int)mem.getCapacity();
int words = 4;
@@ -167,16 +167,16 @@ public class CommonMemoryTest {
}
@Test
- public void checkSetGetPartialArraysWithOffset() {
+ public void checkSetGetPartialArraysWithOffset() throws Exception {
int memCapacity = 32;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
assertEquals(memCapacity, mem.getCapacity());
setGetPartialArraysWithOffsetTests(mem);
}
}
- public static void setGetPartialArraysWithOffsetTests(WritableMemoryImpl mem) {
+ public static void setGetPartialArraysWithOffsetTests(WritableMemory mem) {
int items= 4;
boolean[] srcArray1 = {true, false, true, false};
boolean[] dstArray1 = new boolean[items];
@@ -244,17 +244,17 @@ public class CommonMemoryTest {
}
@Test
- public void checkSetClearIsBits() {
+ public void checkSetClearIsBits() throws Exception {
int memCapacity = 8;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
assertEquals(memCapacity, mem.getCapacity());
mem.clear();
setClearIsBitsTests(mem);
}
}
- public static void setClearIsBitsTests(WritableMemoryImpl mem) {
+ public static void setClearIsBitsTests(WritableMemory mem) {
//single bits
for (int i = 0; i < 8; i++) {
long bitMask = (1 << i);
@@ -285,16 +285,16 @@ public class CommonMemoryTest {
}
@Test
- public void checkAtomicMethods() {
+ public void checkAtomicMethods() throws Exception {
int memCapacity = 8;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
assertEquals(mem.getCapacity(), memCapacity);
atomicMethodTests(mem);
}
}
- public static void atomicMethodTests(WritableMemoryImpl mem) {
+ public static void atomicMethodTests(WritableMemory mem) {
mem.putLong(0, 500);
mem.getAndAddLong(0, 1);
assertEquals(mem.getLong(0), 501);
@@ -312,10 +312,10 @@ public class CommonMemoryTest {
}
@Test
- public void checkSetClearMemoryRegions() {
+ public void checkSetClearMemoryRegions() throws Exception {
int memCapacity = 64; //must be 64
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh1.getWritable();
setClearMemoryRegionsTests(mem); //requires println enabled to visually check
for (int i = 0; i < memCapacity; i++) {
@@ -325,7 +325,7 @@ public class CommonMemoryTest {
}
//enable println stmts to visually check
- public static void setClearMemoryRegionsTests(WritableMemoryImpl mem) {
+ public static void setClearMemoryRegionsTests(WritableMemory mem) {
int accessCapacity = (int)mem.getCapacity();
//define regions
@@ -383,16 +383,16 @@ public class CommonMemoryTest {
}
@Test
- public void checkToHexStringAllMem() {
+ public void checkToHexStringAllMem() throws Exception {
int memCapacity = 48; //must be 48
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh1.getWritable();
toHexStringAllMemTests(mem); //requires println enabled to visually check
}
}
//enable println to visually check
- public static void toHexStringAllMemTests(WritableMemoryImpl mem) {
+ public static void toHexStringAllMemTests(WritableMemory mem) {
int memCapacity = (int)mem.getCapacity();
for (int i = 0; i < memCapacity; i++) {
diff --git a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java
index e81d369..771cdd8 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryOverlapTest.java
@@ -22,8 +22,8 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.assertEquals;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
@@ -33,7 +33,7 @@ import org.testng.annotations.Test;
public class CopyMemoryOverlapTest {
@Test
- public void checkOverlapUsingMemory() {
+ public void checkOverlapUsingMemory() throws Exception {
long copyLongs = 1 << 20;
double overlap = 0.5;
long start_mS = System.currentTimeMillis();
@@ -49,7 +49,7 @@ public class CopyMemoryOverlapTest {
}
@Test
- public void checkOverlapUsingRegions() {
+ public void checkOverlapUsingRegions() throws Exception {
long copyLongs = 1 << 20;
double overlap = 0.5;
long start_mS = System.currentTimeMillis();
@@ -64,8 +64,8 @@ public class CopyMemoryOverlapTest {
println("CopyDn Time Sec: " + ((end2_mS - end1_mS)/1000.0));
}
- private static final void copyUsingDirectMemory(long copyLongs, double overlap, boolean copyUp) {
- println("Copy Using Direct MemoryImpl");
+ private static final void copyUsingDirectMemory(long copyLongs, double overlap, boolean copyUp) throws Exception {
+ println("Copy Using Direct Memory");
long overlapLongs = (long) (overlap * copyLongs);
long backingLongs = (2 * copyLongs) - overlapLongs;
@@ -93,8 +93,8 @@ public class CopyMemoryOverlapTest {
println("CopyUp : " + copyUp);
println("Backing longs: " + backingLongs + "\t bytes: " + backingBytes);
- try (WritableHandle backHandle = WritableMemoryImpl.allocateDirect(backingBytes)) {
- WritableMemoryImpl backingMem = backHandle.get();
+ try (WritableHandle backHandle = WritableMemory.allocateDirect(backingBytes)) {
+ WritableMemory backingMem = backHandle.getWritable();
fill(backingMem); //fill mem with 0 thru copyLongs -1
//listMem(backingMem, "Original");
backingMem.copyTo(fromOffsetBytes, backingMem, toOffsetBytes, copyBytes);
@@ -104,8 +104,8 @@ public class CopyMemoryOverlapTest {
println("");
}
- private static final void copyUsingDirectRegions(long copyLongs, double overlap, boolean copyUp) {
- println("Copy Using Direct MemoryImpl");
+ private static final void copyUsingDirectRegions(long copyLongs, double overlap, boolean copyUp) throws Exception {
+ println("Copy Using Direct Memory");
long overlapLongs = (long) (overlap * copyLongs);
long backingLongs = (2 * copyLongs) - overlapLongs;
@@ -133,12 +133,12 @@ public class CopyMemoryOverlapTest {
println("CopyUp : " + copyUp);
println("Backing longs: " + backingLongs + "\t bytes: " + backingBytes);
- try (WritableHandle backHandle = WritableMemoryImpl.allocateDirect(backingBytes)) {
- WritableMemoryImpl backingMem = backHandle.get();
+ try (WritableHandle backHandle = WritableMemory.allocateDirect(backingBytes)) {
+ WritableMemory backingMem = backHandle.getWritable();
fill(backingMem); //fill mem with 0 thru copyLongs -1
//listMem(backingMem, "Original");
- WritableMemoryImpl reg1 = backingMem.writableRegion(fromOffsetBytes, copyBytes);
- WritableMemoryImpl reg2 = backingMem.writableRegion(toOffsetBytes, copyBytes);
+ WritableMemory reg1 = backingMem.writableRegion(fromOffsetBytes, copyBytes);
+ WritableMemory reg2 = backingMem.writableRegion(toOffsetBytes, copyBytes);
reg1.copyTo(0, reg2, 0, copyBytes);
//listMem(backingMem, "After");
@@ -147,13 +147,13 @@ public class CopyMemoryOverlapTest {
println("");
}
- private static final void fill(WritableMemoryImpl wmem) {
+ private static final void fill(WritableMemory wmem) {
long longs = wmem.getCapacity() >>> 3;
for (long i = 0; i < longs; i++) { wmem.putLong(i << 3, i); } //fill with 0 .. (longs - 1)
//checkMemLongs(wmem, 0L, 0L, longs);
}
- private static final void checkMemLongs(MemoryImpl mem, long fromOffsetLongs, long toOffsetLongs, long copyLongs) {
+ private static final void checkMemLongs(Memory mem, long fromOffsetLongs, long toOffsetLongs, long copyLongs) {
for (long i = 0; i < copyLongs; i++) {
long memVal = mem.getLong((toOffsetLongs + i) << 3);
assertEquals(memVal, fromOffsetLongs + i);
@@ -161,7 +161,7 @@ public class CopyMemoryOverlapTest {
}
@SuppressWarnings("unused")
- private static final void listMem(MemoryImpl mem, String comment) {
+ private static final void listMem(Memory mem, String comment) {
println(comment);
println("Idx\tValue");
long longs = mem.getCapacity() >>> 3;
diff --git a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryTest.java
index 4a760bc..f2cc2c8 100644
--- a/src/test/java/org/apache/datasketches/memory/test/CopyMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/CopyMemoryTest.java
@@ -25,8 +25,8 @@ import static org.testng.Assert.assertEquals;
import java.util.concurrent.ThreadLocalRandom;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.Test;
@@ -37,9 +37,9 @@ public class CopyMemoryTest {
public void heapWSource() {
int k1 = 1 << 20; //longs
int k2 = 2 * k1;
- WritableMemoryImpl srcMem = genMem(k1, false); //!empty
+ WritableMemory srcMem = genMem(k1, false); //!empty
//println(srcMem.toHexString("src: ", 0, k1 << 3));
- WritableMemoryImpl dstMem = genMem(k2, true);
+ WritableMemory dstMem = genMem(k2, true);
srcMem.copyTo(0, dstMem, k1 << 3, k1 << 3);
//println(dstMem.toHexString("dst: ", 0, k2 << 3));
check(dstMem, k1, k1, 1);
@@ -49,31 +49,31 @@ public class CopyMemoryTest {
public void heapROSource() {
int k1 = 1 << 20; //longs
int k2 = 2 * k1;
- MemoryImpl srcMem = genMem(k1, false); //!empty
- WritableMemoryImpl dstMem = genMem(k2, true);
+ Memory srcMem = genMem(k1, false); //!empty
+ WritableMemory dstMem = genMem(k2, true);
srcMem.copyTo(0, dstMem, k1 << 3, k1 << 3);
check(dstMem, k1, k1, 1);
}
@Test
- public void directWSource() {
+ public void directWSource() throws Exception {
int k1 = 1 << 20; //longs
int k2 = 2 * k1;
try (WritableHandle wrh = genWRH(k1, false)) {
- WritableMemoryImpl srcMem = wrh.get();
- WritableMemoryImpl dstMem = genMem(k2, true);
+ WritableMemory srcMem = wrh.getWritable();
+ WritableMemory dstMem = genMem(k2, true);
srcMem.copyTo(0, dstMem, k1 << 3, k1 << 3);
check(dstMem, k1, k1, 1);
}
}
@Test
- public void directROSource() {
+ public void directROSource() throws Exception {
int k1 = 1 << 20; //longs
int k2 = 2 * k1;
try (WritableHandle wrh = genWRH(k1, false)) {
- MemoryImpl srcMem = wrh.get();
- WritableMemoryImpl dstMem = genMem(k2, true);
+ Memory srcMem = wrh.get();
+ WritableMemory dstMem = genMem(k2, true);
srcMem.copyTo(0, dstMem, k1 << 3, k1 << 3);
check(dstMem, k1, k1, 1);
}
@@ -83,10 +83,10 @@ public class CopyMemoryTest {
public void heapWSrcRegion() {
int k1 = 1 << 20; //longs
//gen baseMem of k1 longs w data
- WritableMemoryImpl baseMem = genMem(k1, false); //!empty
+ WritableMemory baseMem = genMem(k1, false); //!empty
//gen src region of k1/2 longs, off= k1/2
- WritableMemoryImpl srcReg = baseMem.writableRegion((k1/2) << 3, (k1/2) << 3);
- WritableMemoryImpl dstMem = genMem(2 * k1, true); //empty
+ WritableMemory srcReg = baseMem.writableRegion((k1/2) << 3, (k1/2) << 3);
+ WritableMemory dstMem = genMem(2 * k1, true); //empty
srcReg.copyTo(0, dstMem, k1 << 3, (k1/2) << 3);
//println(dstMem.toHexString("dstMem: ", k1 << 3, (k1/2) << 3));
check(dstMem, k1, k1/2, (k1/2) + 1);
@@ -96,23 +96,23 @@ public class CopyMemoryTest {
public void heapROSrcRegion() {
int k1 = 1 << 20; //longs
//gen baseMem of k1 longs w data
- WritableMemoryImpl baseMem = genMem(k1, false); //!empty
+ WritableMemory baseMem = genMem(k1, false); //!empty
//gen src region of k1/2 longs, off= k1/2
- MemoryImpl srcReg = baseMem.region((k1/2) << 3, (k1/2) << 3);
- WritableMemoryImpl dstMem = genMem(2 * k1, true); //empty
+ Memory srcReg = baseMem.region((k1/2) << 3, (k1/2) << 3);
+ WritableMemory dstMem = genMem(2 * k1, true); //empty
srcReg.copyTo(0, dstMem, k1 << 3, (k1/2) << 3);
check(dstMem, k1, k1/2, (k1/2) + 1);
}
@Test
- public void directROSrcRegion() {
+ public void directROSrcRegion() throws Exception {
int k1 = 1 << 20; //longs
//gen baseMem of k1 longs w data, direct
try (WritableHandle wrh = genWRH(k1, false)) {
- MemoryImpl baseMem = wrh.get();
+ Memory baseMem = wrh.get();
//gen src region of k1/2 longs, off= k1/2
- MemoryImpl srcReg = baseMem.region((k1/2) << 3, (k1/2) << 3);
- WritableMemoryImpl dstMem = genMem(2 * k1, true); //empty
+ Memory srcReg = baseMem.region((k1/2) << 3, (k1/2) << 3);
+ WritableMemory dstMem = genMem(2 * k1, true); //empty
srcReg.copyTo(0, dstMem, k1 << 3, (k1/2) << 3);
check(dstMem, k1, k1/2, (k1/2) + 1);
}
@@ -123,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();
- MemoryImpl referenceMem = MemoryImpl.wrap(referenceBytes);
- WritableMemoryImpl mem = WritableMemoryImpl.writableWrap(bytes);
+ Memory referenceMem = Memory.wrap(referenceBytes);
+ WritableMemory mem = WritableMemory.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,
@@ -136,15 +136,15 @@ public class CopyMemoryTest {
byte[] bytes = new byte[((UNSAFE_COPY_THRESHOLD_BYTES * 5) / 2) + 1];
ThreadLocalRandom.current().nextBytes(bytes);
byte[] referenceBytes = bytes.clone();
- MemoryImpl referenceMem = MemoryImpl.wrap(referenceBytes);
- WritableMemoryImpl mem = WritableMemoryImpl.writableWrap(bytes);
+ Memory referenceMem = Memory.wrap(referenceBytes);
+ WritableMemory mem = WritableMemory.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,
copyLen));
}
- private static void check(MemoryImpl mem, int offsetLongs, int lengthLongs, int startValue) {
+ private static void check(Memory mem, int offsetLongs, int lengthLongs, int startValue) {
int offBytes = offsetLongs << 3;
for (long i = 0; i < lengthLongs; i++) {
assertEquals(mem.getLong(offBytes + (i << 3)), i + startValue);
@@ -152,8 +152,8 @@ public class CopyMemoryTest {
}
private static WritableHandle genWRH(int longs, boolean empty) {
- WritableHandle wrh = WritableMemoryImpl.allocateDirect(longs << 3);
- WritableMemoryImpl mem = wrh.get();
+ WritableHandle wrh = WritableMemory.allocateDirect(longs << 3);
+ WritableMemory mem = wrh.getWritable();
if (empty) {
mem.clear();
} else {
@@ -163,8 +163,8 @@ public class CopyMemoryTest {
}
- private static WritableMemoryImpl genMem(int longs, boolean empty) {
- WritableMemoryImpl mem = WritableMemoryImpl.allocate(longs << 3);
+ private static WritableMemory genMem(int longs, boolean empty) {
+ WritableMemory mem = WritableMemory.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/test/ExampleMemoryRequestServerTest.java b/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java
index c0438a7..398409a 100644
--- a/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/ExampleMemoryRequestServerTest.java
@@ -25,7 +25,7 @@ import java.util.IdentityHashMap;
import org.apache.datasketches.memory.MemoryRequestServer;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
@@ -43,7 +43,7 @@ public class ExampleMemoryRequestServerTest {
public void checkExampleMemoryRequestServer1() {
int bytes = 8;
ExampleMemoryRequestServer svr = new ExampleMemoryRequestServer();
- WritableMemoryImpl wMem = svr.request(bytes);
+ WritableMemory wMem = svr.request(bytes);
MemoryClient client = new MemoryClient(wMem);
client.process();
svr.cleanup();
@@ -55,13 +55,14 @@ 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
*/
@Test
- public void checkExampleMemoryRequestServer2() {
+ public void checkExampleMemoryRequestServer2() throws Exception {
int bytes = 8;
ExampleMemoryRequestServer svr = new ExampleMemoryRequestServer();
- try (WritableHandle handle = WritableMemoryImpl.allocateDirect(bytes, svr)) {
- WritableMemoryImpl wMem = handle.get();
+ try (WritableHandle handle = WritableMemory.allocateDirect(bytes, svr)) {
+ WritableMemory wMem = handle.getWritable();
MemoryClient client = new MemoryClient(wMem);
client.process();
svr.cleanup();
@@ -72,7 +73,7 @@ public class ExampleMemoryRequestServerTest {
@Test(expectedExceptions = IllegalArgumentException.class)
public void checkZeroCapacity() {
ExampleMemoryRequestServer svr = new ExampleMemoryRequestServer();
- WritableMemoryImpl.allocateDirect(0, svr);
+ WritableMemory.allocateDirect(0, svr);
}
/**
@@ -83,10 +84,10 @@ public class ExampleMemoryRequestServerTest {
* <p>In reality, these memory requests should be quite rare.</p>
*/
static class MemoryClient {
- WritableMemoryImpl smallMem;
+ WritableMemory smallMem;
MemoryRequestServer svr;
- MemoryClient(WritableMemoryImpl wmem) {
+ MemoryClient(WritableMemory wmem) {
smallMem = wmem;
svr = wmem.getMemoryRequestServer();
}
@@ -96,7 +97,7 @@ public class ExampleMemoryRequestServerTest {
smallMem.fill((byte) 1); //fill it, but not big enough
println(smallMem.toHexString("Small", 0, (int)cap1));
- WritableMemoryImpl bigMem = svr.request(2 * cap1); //get bigger mem
+ WritableMemory bigMem = svr.request(2 * cap1); //get bigger mem
long cap2 = bigMem.getCapacity();
smallMem.copyTo(0, bigMem, 0, cap1); //copy data from small to big
svr.requestClose(smallMem, bigMem); //done with smallMem, release it
@@ -104,7 +105,7 @@ public class ExampleMemoryRequestServerTest {
bigMem.fill(cap1, cap1, (byte) 2); //fill the rest of bigMem, still not big enough
println(bigMem.toHexString("Big", 0, (int)cap2));
- WritableMemoryImpl giantMem = svr.request(2 * cap2); //get giant mem
+ WritableMemory giantMem = svr.request(2 * cap2); //get giant mem
long cap3 = giantMem.getCapacity();
bigMem.copyTo(0, giantMem, 0, cap2); //copy data from small to big
svr.requestClose(bigMem, giantMem); //done with bigMem, release it
@@ -120,13 +121,13 @@ public class ExampleMemoryRequestServerTest {
* possibly manage the continuous requests for larger memory.
*/
public static class ExampleMemoryRequestServer implements MemoryRequestServer {
- IdentityHashMap<WritableMemoryImpl, WritableHandle> map = new IdentityHashMap<>();
+ IdentityHashMap<WritableMemory, WritableHandle> map = new IdentityHashMap<>();
@SuppressWarnings("resource")
@Override
- public WritableMemoryImpl request(long capacityBytes) {
- WritableHandle handle = WritableMemoryImpl.allocateDirect(capacityBytes, this);
- WritableMemoryImpl wmem = handle.get();
+ public WritableMemory request(long capacityBytes) {
+ WritableHandle handle = WritableMemory.allocateDirect(capacityBytes, this);
+ WritableMemory wmem = handle.getWritable();
map.put(wmem, handle); //We track the newly allocated memory and its handle.
return wmem;
}
@@ -134,11 +135,15 @@ public class ExampleMemoryRequestServerTest {
@SuppressWarnings("resource")
@Override
//here we actually release it, in reality it might be a lot more complex.
- public void requestClose(WritableMemoryImpl memToRelease, WritableMemoryImpl newMemory) {
+ public void requestClose(WritableMemory memToRelease, WritableMemory newMemory) {
if (memToRelease != null) {
WritableHandle handle = map.get(memToRelease);
- if (handle != null && handle.get() == memToRelease) {
- handle.close();
+ if (handle != null && handle.getWritable() == memToRelease) {
+ try {
+ handle.close();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
}
}
}
@@ -146,7 +151,11 @@ public class ExampleMemoryRequestServerTest {
public void cleanup() {
map.forEach((k,v) -> {
assertFalse(k.isValid()); //all entries in the map should be invalid
- v.close(); //harmless
+ try {
+ v.close();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ } //harmless
});
}
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java b/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java
index 1653bc6..2af7572 100644
--- a/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/IgnoredArrayOverflowTest.java
@@ -20,27 +20,26 @@
package org.apache.datasketches.memory.test;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
-import org.testng.annotations.Ignore;
import org.testng.annotations.Test;
-@Ignore("Test causes OutOfMemoryError in Travis CI, run only locally")
@SuppressWarnings("javadoc")
public class IgnoredArrayOverflowTest {
private WritableHandle h;
- private WritableMemoryImpl memory;
+ private WritableMemory memory;
+ private static final long MAX_SIZE = (1L << 10); // use 1L << 31 to test int overrange
@BeforeClass
public void allocate() {
- h = WritableMemoryImpl.allocateDirect(Integer.MAX_VALUE + 100L);
- memory = h.get();
+ h = WritableMemory.allocateDirect(MAX_SIZE);
+ memory = h.getWritable();
}
@AfterClass
- public void close() {
+ public void close() throws Exception {
h.close();
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/LeafImplTest.java b/src/test/java/org/apache/datasketches/memory/test/LeafImplTest.java
index 19f8b8c..c8f739c 100644
--- a/src/test/java/org/apache/datasketches/memory/test/LeafImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/LeafImplTest.java
@@ -32,9 +32,9 @@ import java.nio.ByteOrder;
import org.apache.datasketches.memory.WritableDirectHandle;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
+import org.apache.datasketches.memory.WritableBuffer;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.apache.datasketches.memory.WritableMapHandle;
import org.testng.annotations.Test;
@@ -47,17 +47,17 @@ public class LeafImplTest {
static final ByteOrder BE = ByteOrder.BIG_ENDIAN;
@Test
- public void checkDirectLeafs() {
+ public void checkDirectLeafs() throws Exception {
long off = 0;
long cap = 128;
- try (WritableDirectHandle wdh = WritableMemoryImpl.allocateDirect(cap)) {
- WritableMemoryImpl memLE = wdh.get();
+ try (WritableDirectHandle wdh = WritableMemory.allocateDirect(cap)) {
+ WritableMemory memLE = wdh.getWritable();
memLE.putShort(0, (short) 1);
- checkDirectImpl(memLE, off, cap);
+ checkDirect(memLE, off, cap);
}
}
- private static void checkDirectImpl(WritableMemoryImpl mem, long off, long cap) {
+ private static void checkDirect(WritableMemory mem, long off, long cap) {
assertEquals(mem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(mem.writableRegion(off, cap, BE).getShort(0), 256);
assertEquals(mem.asWritableBuffer(LE).getShort(0), 1);
@@ -71,7 +71,7 @@ public class LeafImplTest {
//assertTrue(mem.getUnsafeObject() == null);
assertTrue(mem.isValid() == true);
- WritableBufferImpl buf = mem.asWritableBuffer();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(buf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -86,7 +86,7 @@ public class LeafImplTest {
//assertTrue(buf.getUnsafeObject() == null);
assertTrue(buf.isValid() == true);
- WritableMemoryImpl nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
+ WritableMemory nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
assertEquals(nnMem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnMem.writableRegion(off, cap, BE).getShort(0), 256);
@@ -101,7 +101,7 @@ public class LeafImplTest {
//assertTrue(nnMem.getUnsafeObject() == null);
assertTrue(nnMem.isValid() == true);
- WritableBufferImpl nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
+ WritableBuffer nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
assertEquals(nnBuf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnBuf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -118,7 +118,7 @@ public class LeafImplTest {
}
@Test
- public void checkMapLeafs() throws IOException {
+ public void checkMapLeafs() throws Exception {
long off = 0;
long cap = 128;
File file = new File("TestFile2.bin");
@@ -134,15 +134,15 @@ public class LeafImplTest {
assertTrue(file.isFile());
file.deleteOnExit(); //comment out if you want to examine the file.
- try (WritableMapHandle wmh = WritableMemoryImpl.writableMap(file, off, cap, Util.nativeByteOrder)) {
- WritableMemoryImpl mem = wmh.get();
+ try (WritableMapHandle wmh = WritableMemory.writableMap(file, off, cap, Util.nativeByteOrder)) {
+ WritableMemory mem = wmh.getWritable();
mem.putShort(0, (short) 1);
assertEquals(mem.getByte(0), (byte) 1);
- checkMapImpl(mem, off, cap);
+ checkMap(mem, off, cap);
}
}
- private static void checkMapImpl(WritableMemoryImpl mem, long off, long cap) {
+ private static void checkMap(WritableMemory mem, long off, long cap) {
assertEquals(mem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(mem.writableRegion(off, cap, BE).getShort(0), 256);
assertEquals(mem.asWritableBuffer(LE).getShort(0), 1);
@@ -156,7 +156,7 @@ public class LeafImplTest {
//assertTrue(mem.getUnsafeObject() == null);
assertTrue(mem.isValid() == true);
- WritableBufferImpl buf = mem.asWritableBuffer();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(buf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -171,7 +171,7 @@ public class LeafImplTest {
//assertTrue(buf.getUnsafeObject() == null);
assertTrue(buf.isValid() == true);
- WritableMemoryImpl nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
+ WritableMemory nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
assertEquals(nnMem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnMem.writableRegion(off, cap, BE).getShort(0), 256);
@@ -186,7 +186,7 @@ public class LeafImplTest {
//assertTrue(nnMem.getUnsafeObject() == null);
assertTrue(nnMem.isValid() == true);
- WritableBufferImpl nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
+ WritableBuffer nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
assertEquals(nnBuf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnBuf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -209,17 +209,17 @@ public class LeafImplTest {
ByteBuffer bb = ByteBuffer.allocate((int)cap);
bb.order(ByteOrder.nativeOrder());
bb.putShort(0, (short) 1);
- WritableMemoryImpl mem = WritableMemoryImpl.writableWrap(bb);
- checkByteBufferImpl(mem, off, cap, false);
+ WritableMemory mem = WritableMemory.writableWrap(bb);
+ checkByteBuffer(mem, off, cap, false);
ByteBuffer dbb = ByteBuffer.allocateDirect((int)cap);
dbb.order(ByteOrder.nativeOrder());
dbb.putShort(0, (short) 1);
- mem = WritableMemoryImpl.writableWrap(dbb);
- checkByteBufferImpl(mem, off, cap, true);
+ mem = WritableMemory.writableWrap(dbb);
+ checkByteBuffer(mem, off, cap, true);
}
- private static void checkByteBufferImpl(WritableMemoryImpl mem, long off, long cap, boolean direct) {
+ private static void checkByteBuffer(WritableMemory mem, long off, long cap, boolean direct) {
assertEquals(mem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(mem.writableRegion(off, cap, BE).getShort(0), 256);
assertEquals(mem.asWritableBuffer(LE).getShort(0), 1);
@@ -239,7 +239,7 @@ public class LeafImplTest {
}
assertTrue(mem.isValid() == true);
- WritableBufferImpl buf = mem.asWritableBuffer();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(buf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -260,7 +260,7 @@ public class LeafImplTest {
}
assertTrue(buf.isValid() == true);
- WritableMemoryImpl nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
+ WritableMemory nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
assertEquals(nnMem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnMem.writableRegion(off, cap, BE).getShort(0), 256);
@@ -281,7 +281,7 @@ public class LeafImplTest {
}
assertTrue(nnMem.isValid() == true);
- WritableBufferImpl nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
+ WritableBuffer nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
assertEquals(nnBuf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnBuf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -307,12 +307,12 @@ public class LeafImplTest {
public void checkHeapLeafs() {
long off = 0;
long cap = 128;
- WritableMemoryImpl mem = WritableMemoryImpl.allocate((int)cap);
+ WritableMemory mem = WritableMemory.allocate((int)cap);
mem.putShort(0, (short) 1);
- checkHeapImpl(mem, off, cap);
+ checkHeap(mem, off, cap);
}
- private static void checkHeapImpl(WritableMemoryImpl mem, long off, long cap) {
+ private static void checkHeap(WritableMemory mem, long off, long cap) {
assertEquals(mem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(mem.writableRegion(off, cap, BE).getShort(0), 256);
assertEquals(mem.asWritableBuffer(LE).getShort(0), 1);
@@ -326,7 +326,7 @@ public class LeafImplTest {
//assertTrue(mem.getUnsafeObject() != null);
assertTrue(mem.isValid() == true);
- WritableBufferImpl buf = mem.asWritableBuffer();
+ WritableBuffer buf = mem.asWritableBuffer();
assertEquals(buf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(buf.writableRegion(off, cap, BE).getShort(0), 256);
@@ -341,7 +341,7 @@ public class LeafImplTest {
//assertTrue(buf.getUnsafeObject() != null);
assertTrue(buf.isValid() == true);
- WritableMemoryImpl nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
+ WritableMemory nnMem = mem.writableRegion(off, cap, Util.nonNativeByteOrder);
assertEquals(nnMem.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnMem.writableRegion(off, cap, BE).getShort(0), 256);
@@ -356,7 +356,7 @@ public class LeafImplTest {
//assertTrue(nnMem.getUnsafeObject() != null);
assertTrue(nnMem.isValid() == true);
- WritableBufferImpl nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
+ WritableBuffer nnBuf = mem.asWritableBuffer(Util.nonNativeByteOrder);
assertEquals(nnBuf.writableRegion(off, cap, LE).getShort(0), 1);
assertEquals(nnBuf.writableRegion(off, cap, BE).getShort(0), 256);
diff --git a/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java b/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java
index 7654af8..c45387f 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryBoundaryCheckTest.java
@@ -19,14 +19,14 @@
package org.apache.datasketches.memory.test;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class MemoryBoundaryCheckTest {
- private final WritableBufferImpl writableBuffer = WritableMemoryImpl.allocate(8).asWritableBuffer();
+ private final WritableBuffer writableBuffer = WritableMemory.allocate(8).asWritableBuffer();
@Test
public void testGetBoolean() {
diff --git a/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java b/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java
index ece9cdf..9181f94 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryReadWriteSafetyTest.java
@@ -20,23 +20,22 @@
package org.apache.datasketches.memory.test;
import java.io.File;
-import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.MapHandle;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.ReadOnlyException;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class MemoryReadWriteSafetyTest {
- // Test various operations with read-only MemoryImpl
+ // Test various operations with read-only Memory
- final WritableMemoryImpl mem = (WritableMemoryImpl) MemoryImpl.wrap(new byte[8]);
+ final WritableMemory mem = (WritableMemory) Memory.wrap(new byte[8]);
@Test(expectedExceptions = AssertionError.class)
public void testPutByte() {
@@ -122,108 +121,108 @@ public class MemoryReadWriteSafetyTest {
@Test(expectedExceptions = AssertionError.class)
public void testWritableMemoryRegion() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) WritableMemoryImpl.allocate(8).region(0, 8);
+ WritableMemory mem1 = (WritableMemory) WritableMemory.allocate(8).region(0, 8);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testByteArrayWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new byte[8]);
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new byte[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testByteArrayWrapWithBO() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new byte[8], ByteOrder.nativeOrder());
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new byte[8], ByteOrder.nativeOrder());
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testByteArrayWrapWithOffsetsAndBO() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new byte[8], 0, 4, ByteOrder.nativeOrder());
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new byte[8], 0, 4, ByteOrder.nativeOrder());
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testBooleanArrayWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new boolean[8]);
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new boolean[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testShortArrayWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new short[8]);
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new short[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testCharArrayWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new char[8]);
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new char[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testIntArrayWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new int[8]);
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new int[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testLongArrayWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new long[8]);
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new long[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testFloatArrayWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new float[8]);
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new float[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testDoubleArrayWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(new double[8]);
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(new double[8]);
mem1.putInt(0, 1);
}
@Test(expectedExceptions = AssertionError.class)
public void testByteBufferWrap() {
- WritableMemoryImpl mem1 = (WritableMemoryImpl) MemoryImpl.wrap(ByteBuffer.allocate(8));
+ WritableMemory mem1 = (WritableMemory) Memory.wrap(ByteBuffer.allocate(8));
mem1.putInt(0, 1);
}
//@SuppressWarnings("resource")
@Test(expectedExceptions = AssertionError.class)
- public void testMapFile() throws IOException {
+ public void testMapFile() throws Exception {
File tempFile = File.createTempFile("test", null);
tempFile.deleteOnExit();
try (RandomAccessFile raf = new RandomAccessFile(tempFile, "rw")) {
raf.setLength(8);
//System.out.println(UtilTest.getFileAttributes(tempFile));
- try (MapHandle h = MemoryImpl.map(tempFile)) {
- ((WritableMemoryImpl) h.get()).putInt(0, 1);
+ try (MapHandle h = Memory.map(tempFile)) {
+ ((WritableMemory) h.get()).putInt(0, 1);
}
}
}
@SuppressWarnings("resource")
@Test(expectedExceptions = AssertionError.class)
- public void testMapFileWithOffsetsAndBO() throws IOException {
+ public void testMapFileWithOffsetsAndBO() throws Exception {
File tempFile = File.createTempFile("test", "test");
tempFile.deleteOnExit();
new RandomAccessFile(tempFile, "rw").setLength(8);
- try (MapHandle h = MemoryImpl.map(tempFile, 0, 4, ByteOrder.nativeOrder())) {
- ((WritableMemoryImpl) h.get()).putInt(0, 1);
+ try (MapHandle h = Memory.map(tempFile, 0, 4, ByteOrder.nativeOrder())) {
+ ((WritableMemory) h.get()).putInt(0, 1);
}
}
@SuppressWarnings("resource")
@Test(expectedExceptions = IllegalArgumentException.class)
- public void testMapFileBeyondTheFileSize() throws IOException {
+ public void testMapFileBeyondTheFileSize() throws Exception {
File tempFile = File.createTempFile("test", "test");
tempFile.deleteOnExit();
new RandomAccessFile(tempFile, "rw").setLength(8);
- try (MapHandle unused = MemoryImpl.map(tempFile, 0, 16, ByteOrder.nativeOrder())) {
+ try (MapHandle unused = Memory.map(tempFile, 0, 16, ByteOrder.nativeOrder())) {
}
}
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/MemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/MemoryTest.java
index e882209..ed6b210 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryTest.java
@@ -35,12 +35,13 @@ 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.WritableDirectHandle;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
@@ -56,10 +57,10 @@ public class MemoryTest {
}
@Test
- public void checkDirectRoundTrip() {
+ public void checkDirectRoundTrip() throws Exception {
int n = 1024; //longs
- try (WritableHandle wh = WritableMemoryImpl.allocateDirect(n * 8)) {
- WritableMemoryImpl mem = wh.get();
+ try (WritableHandle wh = WritableMemory.allocateDirect(n * 8)) {
+ WritableMemory mem = wh.getWritable();
for (int i = 0; i < n; i++) {
mem.putLong(i * 8, i);
}
@@ -73,7 +74,7 @@ public class MemoryTest {
@Test
public void checkAutoHeapRoundTrip() {
int n = 1024; //longs
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(n * 8);
+ WritableMemory wmem = WritableMemory.allocate(n * 8);
for (int i = 0; i < n; i++) {
wmem.putLong(i * 8, i);
}
@@ -87,7 +88,7 @@ public class MemoryTest {
public void checkArrayWrap() {
int n = 1024; //longs
byte[] arr = new byte[n * 8];
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr);
+ WritableMemory wmem = WritableMemory.writableWrap(arr);
for (int i = 0; i < n; i++) {
wmem.putLong(i * 8, i);
}
@@ -95,20 +96,20 @@ public class MemoryTest {
long v = wmem.getLong(i * 8);
assertEquals(v, i);
}
- MemoryImpl mem = MemoryImpl.wrap(arr, ByteOrder.nativeOrder());
+ Memory mem = Memory.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
- MemoryImpl memZeroLengthArrayBoolean = WritableMemoryImpl.writableWrap(new boolean[0]);
- MemoryImpl memZeroLengthArrayByte = WritableMemoryImpl.writableWrap(new byte[0]);
- MemoryImpl memZeroLengthArrayChar = WritableMemoryImpl.writableWrap(new char[0]);
- MemoryImpl memZeroLengthArrayShort = WritableMemoryImpl.writableWrap(new short[0]);
- MemoryImpl memZeroLengthArrayInt = WritableMemoryImpl.writableWrap(new int[0]);
- MemoryImpl memZeroLengthArrayLong = WritableMemoryImpl.writableWrap(new long[0]);
- MemoryImpl memZeroLengthArrayFloat = WritableMemoryImpl.writableWrap(new float[0]);
- MemoryImpl memZeroLengthArrayDouble = WritableMemoryImpl.writableWrap(new double[0]);
+ 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]);
assertEquals(memZeroLengthArrayBoolean.getCapacity(), 0);
assertEquals(memZeroLengthArrayByte.getCapacity(), 0);
assertEquals(memZeroLengthArrayChar.getCapacity(), 0);
@@ -119,28 +120,28 @@ public class MemoryTest {
assertEquals(memZeroLengthArrayDouble.getCapacity(), 0);
// check 0 length array wraps
- List<MemoryImpl> memoryToCheck = Lists.newArrayList();
- memoryToCheck.add(WritableMemoryImpl.allocate(0));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(ByteBuffer.allocate(0)));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(new boolean[0]));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(new byte[0]));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(new char[0]));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(new short[0]));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(new int[0]));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(new long[0]));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(new float[0]));
- memoryToCheck.add(WritableMemoryImpl.writableWrap(new double[0]));
- memoryToCheck.add(MemoryImpl.wrap(ByteBuffer.allocate(0)));
- memoryToCheck.add(MemoryImpl.wrap(new boolean[0]));
- memoryToCheck.add(MemoryImpl.wrap(new byte[0]));
- memoryToCheck.add(MemoryImpl.wrap(new char[0]));
- memoryToCheck.add(MemoryImpl.wrap(new short[0]));
- memoryToCheck.add(MemoryImpl.wrap(new int[0]));
- memoryToCheck.add(MemoryImpl.wrap(new long[0]));
- memoryToCheck.add(MemoryImpl.wrap(new float[0]));
- memoryToCheck.add(MemoryImpl.wrap(new double[0]));
- //Check the MemoryImpl lengths
- for (MemoryImpl memory : memoryToCheck) {
+ 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]));
+ //Check the Memory lengths
+ for (Memory memory : memoryToCheck) {
assertEquals(memory.getCapacity(), 0);
}
}
@@ -151,7 +152,7 @@ public class MemoryTest {
byte[] arr = new byte[n * 8];
ByteBuffer bb = ByteBuffer.wrap(arr);
bb.order(ByteOrder.nativeOrder());
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bb);
+ WritableMemory wmem = WritableMemory.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wmem
wmem.putLong(i * 8, i);
}
@@ -163,13 +164,13 @@ public class MemoryTest {
long v = bb.getLong(i * 8);
assertEquals(v, i);
}
- MemoryImpl mem1 = MemoryImpl.wrap(arr);
+ Memory mem1 = Memory.wrap(arr);
for (int i = 0; i < n; i++) { //read from wrapped arr
long v = mem1.getLong(i * 8);
assertEquals(v, i);
}
//convert to RO
- MemoryImpl mem = wmem;
+ Memory mem = wmem;
for (int i = 0; i < n; i++) {
long v = mem.getLong(i * 8);
assertEquals(v, i);
@@ -181,7 +182,7 @@ public class MemoryTest {
int n = 1024; //longs
ByteBuffer bb = ByteBuffer.allocateDirect(n * 8);
bb.order(ByteOrder.nativeOrder());
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bb);
+ WritableMemory wmem = WritableMemory.writableWrap(bb);
for (int i = 0; i < n; i++) { //write to wmem
wmem.putLong(i * 8, i);
}
@@ -193,13 +194,13 @@ public class MemoryTest {
long v = bb.getLong(i * 8);
assertEquals(v, i);
}
- MemoryImpl mem1 = MemoryImpl.wrap(bb);
+ Memory mem1 = Memory.wrap(bb);
for (int i = 0; i < n; i++) { //read from wrapped bb RO
long v = mem1.getLong(i * 8);
assertEquals(v, i);
}
//convert to RO
- MemoryImpl mem = wmem;
+ Memory mem = wmem;
for (int i = 0; i < n; i++) {
long v = mem.getLong(i * 8);
assertEquals(v, i);
@@ -211,7 +212,7 @@ public class MemoryTest {
int n = 1024; //longs
ByteBuffer bb = ByteBuffer.allocate(n * 8);
bb.order(ByteOrder.BIG_ENDIAN);
- MemoryImpl mem = MemoryImpl.wrap(bb);
+ Memory mem = Memory.wrap(bb);
assertFalse(mem.getTypeByteOrder() == Util.nativeByteOrder);
assertEquals(mem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
}
@@ -224,7 +225,7 @@ public class MemoryTest {
bb.position(64);
ByteBuffer slice = bb.slice().asReadOnlyBuffer();
slice.order(ByteOrder.nativeOrder());
- MemoryImpl mem = MemoryImpl.wrap(slice);
+ Memory mem = Memory.wrap(slice);
for (int i = 0; i < 64; i++) {
assertEquals(mem.getByte(i), 64 + i);
}
@@ -237,7 +238,7 @@ public class MemoryTest {
int n = 1024; //longs
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(n * 8);
+ WritableMemory wmem = WritableMemory.allocate(n * 8);
wmem.putLongArray(0, arr, 0, n);
long[] arr2 = new long[n];
wmem.getLongArray(0, arr2, 0, n);
@@ -252,8 +253,8 @@ public class MemoryTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- MemoryImpl mem = MemoryImpl.wrap(arr);
- MemoryImpl reg = mem.region(n2 * 8, n2 * 8); //top half
+ Memory mem = Memory.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);
long e = i + n2;
@@ -267,8 +268,8 @@ public class MemoryTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- MemoryImpl mem = MemoryImpl.wrap(arr);
- MemoryImpl reg = mem.region(n2 * 8, n2 * 8, Util.nonNativeByteOrder); //top half
+ Memory mem = Memory.wrap(arr);
+ Memory reg = mem.region(n2 * 8, n2 * 8, Util.nonNativeByteOrder); //top half
for (int i = 0; i < n2; i++) {
long v = Long.reverseBytes(reg.getLong(i * 8));
long e = i + n2;
@@ -282,13 +283,13 @@ public class MemoryTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr);
+ WritableMemory wmem = WritableMemory.writableWrap(arr);
for (int i = 0; i < n; i++) {
assertEquals(wmem.getLong(i * 8), i);
//println("" + wmem.getLong(i * 8));
}
//println("");
- WritableMemoryImpl reg = wmem.writableRegion(n2 * 8, n2 * 8);
+ WritableMemory reg = wmem.writableRegion(n2 * 8, n2 * 8);
for (int i = 0; i < n2; i++) { reg.putLong(i * 8, i); }
for (int i = 0; i < n; i++) {
assertEquals(wmem.getLong(i * 8), i % 8);
@@ -302,13 +303,13 @@ public class MemoryTest {
int n2 = n / 2;
long[] arr = new long[n];
for (int i = 0; i < n; i++) { arr[i] = i; }
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr);
+ WritableMemory wmem = WritableMemory.writableWrap(arr);
for (int i = 0; i < n; i++) {
assertEquals(wmem.getLong(i * 8), i);
//println("" + wmem.getLong(i * 8));
}
//println("");
- WritableMemoryImpl reg = wmem.writableRegion(n2 * 8, n2 * 8, Util.nonNativeByteOrder);
+ WritableMemory reg = wmem.writableRegion(n2 * 8, n2 * 8, Util.nonNativeByteOrder);
for (int i = 0; i < n2; i++) { reg.putLong(i * 8, i); }
for (int i = 0; i < n; i++) {
long v = wmem.getLong(i * 8);
@@ -325,10 +326,14 @@ public class MemoryTest {
public void checkParentUseAfterFree() {
int bytes = 64 * 8;
@SuppressWarnings("resource") //intentionally not using try-with-resouces here
- WritableHandle wh = WritableMemoryImpl.allocateDirect(bytes);
- WritableMemoryImpl wmem = wh.get();
- wh.close();
- //with -ea assert: MemoryImpl not valid.
+ WritableHandle wh = WritableMemory.allocateDirect(bytes);
+ WritableMemory wmem = wh.getWritable();
+ try {
+ wh.close();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ //with -ea assert: Memory not valid.
//with -da sometimes segfaults, sometimes passes!
wmem.getLong(0);
}
@@ -337,36 +342,40 @@ public class MemoryTest {
public void checkRegionUseAfterFree() {
int bytes = 64;
@SuppressWarnings("resource") //intentionally not using try-with-resouces here
- WritableHandle wh = WritableMemoryImpl.allocateDirect(bytes);
- MemoryImpl wmem = wh.get();
- MemoryImpl region = wmem.region(0L, bytes);
- wh.close();
- //with -ea assert: MemoryImpl not valid.
+ WritableHandle wh = WritableMemory.allocateDirect(bytes);
+ Memory wmem = wh.get();
+ Memory region = wmem.region(0L, bytes);
+ try {
+ wh.close();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ //with -ea assert: Memory not valid.
//with -da sometimes segfaults, sometimes passes!
region.getByte(0);
}
@Test
- public void checkUnsafeByteBufferView() {
- try (WritableDirectHandle wmemDirectHandle = WritableMemoryImpl.allocateDirect(2)) {
- WritableMemoryImpl wmemDirect = wmemDirectHandle.get();
+ public void checkUnsafeByteBufferView() throws Exception {
+ try (WritableDirectHandle wmemDirectHandle = WritableMemory.allocateDirect(2)) {
+ WritableMemory wmemDirect = wmemDirectHandle.getWritable();
wmemDirect.putByte(0, (byte) 1);
wmemDirect.putByte(1, (byte) 2);
checkUnsafeByteBufferView(wmemDirect);
}
- checkUnsafeByteBufferView(MemoryImpl.wrap(new byte[] {1, 2}));
+ checkUnsafeByteBufferView(Memory.wrap(new byte[] {1, 2}));
try {
@SuppressWarnings("unused")
- ByteBuffer unused = MemoryImpl.wrap(new int[]{1}).unsafeByteBufferView(0, 1);
+ ByteBuffer unused = Memory.wrap(new int[]{1}).unsafeByteBufferView(0, 1);
Assert.fail();
} catch (UnsupportedOperationException ingore) {
// expected
}
}
- private static void checkUnsafeByteBufferView(final MemoryImpl mem) {
+ private static void checkUnsafeByteBufferView(final Memory mem) {
ByteBuffer emptyByteBuffer = mem.unsafeByteBufferView(0, 0);
Assert.assertEquals(emptyByteBuffer.capacity(), 0);
ByteBuffer bb = mem.unsafeByteBufferView(1, 1);
@@ -385,23 +394,22 @@ public class MemoryTest {
@SuppressWarnings({ "resource", "static-access" })
@Test
- public void checkMonitorDirectStats() {
+ public void checkMonitorDirectStats() throws Exception {
int bytes = 1024;
- WritableHandle wh1 = WritableMemoryImpl.allocateDirect(bytes);
- WritableHandle wh2 = WritableMemoryImpl.allocateDirect(bytes);
- WritableMemoryImpl wMem2 = wh2.get();
- assertEquals(wMem2.getCurrentDirectMemoryAllocations(), 2L);
- assertEquals(wMem2.getCurrentDirectMemoryAllocated(), 2 * bytes);
+ WritableHandle wh1 = WritableMemory.allocateDirect(bytes);
+ WritableHandle wh2 = WritableMemory.allocateDirect(bytes);
+ assertEquals(BaseState.getCurrentDirectMemoryAllocations(), 2L);
+ assertEquals(BaseState.getCurrentDirectMemoryAllocated(), 2 * bytes);
wh1.close();
- assertEquals(wMem2.getCurrentDirectMemoryAllocations(), 1L);
- assertEquals(wMem2.getCurrentDirectMemoryAllocated(), bytes);
+ assertEquals(BaseState.getCurrentDirectMemoryAllocations(), 1L);
+ assertEquals(BaseState.getCurrentDirectMemoryAllocated(), bytes);
wh2.close();
wh2.close(); //check that it doesn't go negative.
//even though the handles are closed, these methods are static access
- assertEquals(wMem2.getCurrentDirectMemoryAllocations(), 0L);
- assertEquals(wMem2.getCurrentDirectMemoryAllocated(), 0L);
+ assertEquals(BaseState.getCurrentDirectMemoryAllocations(), 0L);
+ assertEquals(BaseState.getCurrentDirectMemoryAllocated(), 0L);
}
@SuppressWarnings({ "resource", "static-access" })
@@ -410,30 +418,29 @@ public class MemoryTest {
File file = getResourceFile("GettysburgAddress.txt");
long bytes = file.length();
- MapHandle mmh1 = MemoryImpl.map(file);
- MapHandle mmh2 = MemoryImpl.map(file);
- MemoryImpl wmem2 = mmh2.get();
+ MapHandle mmh1 = Memory.map(file);
+ MapHandle mmh2 = Memory.map(file);
- assertEquals(wmem2.getCurrentDirectMemoryMapAllocations(), 2L);
- assertEquals(wmem2.getCurrentDirectMemoryMapAllocated(), 2 * bytes);
+ assertEquals(BaseState.getCurrentDirectMemoryMapAllocations(), 2L);
+ assertEquals(BaseState.getCurrentDirectMemoryMapAllocated(), 2 * bytes);
mmh1.close();
- assertEquals(wmem2.getCurrentDirectMemoryMapAllocations(), 1L);
- assertEquals(wmem2.getCurrentDirectMemoryMapAllocated(), bytes);
+ assertEquals(BaseState.getCurrentDirectMemoryMapAllocations(), 1L);
+ assertEquals(BaseState.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(wmem2.getCurrentDirectMemoryMapAllocations(), 0L);
- assertEquals(wmem2.getCurrentDirectMemoryMapAllocated(), 0L);
+ assertEquals(BaseState.getCurrentDirectMemoryMapAllocations(), 0L);
+ assertEquals(BaseState.getCurrentDirectMemoryMapAllocated(), 0L);
}
@Test
- public void checkNullMemReqSvr() {
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(new byte[16]);
+ public void checkNullMemReqSvr() throws Exception {
+ WritableMemory wmem = WritableMemory.writableWrap(new byte[16]);
assertNull(wmem.getMemoryRequestServer());
- try (WritableDirectHandle wdh = WritableMemoryImpl.allocateDirect(16)) {
- WritableMemoryImpl wmem2 = wdh.get();
+ try (WritableDirectHandle wdh = WritableMemory.allocateDirect(16)) {
+ WritableMemory wmem2 = wdh.getWritable();
assertNotNull(wmem2.getMemoryRequestServer());
}
println(wmem.toHexString("Test", 0, 16));
@@ -441,7 +448,7 @@ public class MemoryTest {
@Test
public void checkHashCode() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(32 + 7);
+ WritableMemory wmem = WritableMemory.allocate(32 + 7);
int hc = wmem.hashCode();
assertEquals(hc, -1895166923);
}
@@ -449,7 +456,7 @@ public class MemoryTest {
@Test
public void checkSelfEqualsToAndCompareTo() {
int len = 64;
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(len);
+ WritableMemory wmem = WritableMemory.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));
@@ -461,7 +468,7 @@ public class MemoryTest {
public void wrapBigEndianAsLittle() {
ByteBuffer bb = ByteBuffer.allocate(64);
bb.putChar(0, (char)1); //as BE
- MemoryImpl mem = MemoryImpl.wrap(bb, ByteOrder.LITTLE_ENDIAN);
+ Memory mem = Memory.wrap(bb, ByteOrder.LITTLE_ENDIAN);
assertEquals(mem.getChar(0), 256);
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java b/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java
index 08e8bf8..f65374c 100644
--- a/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/MemoryWriteToTest.java
@@ -28,8 +28,8 @@ import java.nio.channels.WritableByteChannel;
import java.util.concurrent.ThreadLocalRandom;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.Test;
@@ -57,10 +57,10 @@ public class MemoryWriteToTest {
}
@Test
- public void testOffHeap() throws IOException {
+ public void testOffHeap() throws Exception {
try (WritableHandle handle =
- WritableMemoryImpl.allocateDirect((UNSAFE_COPY_THRESHOLD_BYTES * 5) + 10)) {
- WritableMemoryImpl mem = handle.get();
+ WritableMemory.allocateDirect((UNSAFE_COPY_THRESHOLD_BYTES * 5) + 10)) {
+ WritableMemory mem = handle.getWritable();
testWriteTo(mem.region(0, 0));
testOffHeap(mem, 7);
testOffHeap(mem, 1023);
@@ -70,28 +70,28 @@ public class MemoryWriteToTest {
}
}
- private static void testOffHeap(WritableMemoryImpl mem, int size) throws IOException {
+ private static void testOffHeap(WritableMemory mem, int size) throws IOException {
createRandomBytesMemory(size).copyTo(0, mem, 0, size);
testWriteTo(mem.region(0, size));
}
- private static MemoryImpl createRandomBytesMemory(int size) {
+ private static Memory createRandomBytesMemory(int size) {
byte[] bytes = new byte[size];
ThreadLocalRandom.current().nextBytes(bytes);
- return MemoryImpl.wrap(bytes);
+ return Memory.wrap(bytes);
}
- private static MemoryImpl createRandomIntsMemory(int size) {
+ private static Memory createRandomIntsMemory(int size) {
int[] ints = ThreadLocalRandom.current().ints(size).toArray();
- return MemoryImpl.wrap(ints);
+ return Memory.wrap(ints);
}
- private static void testWriteTo(MemoryImpl mem) throws IOException {
+ private static void testWriteTo(Memory mem) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try (WritableByteChannel out = Channels.newChannel(baos)) {
mem.writeTo(0, mem.getCapacity(), out);
}
byte[] result = baos.toByteArray();
- Assert.assertTrue(mem.equals(MemoryImpl.wrap(result)));
+ Assert.assertTrue(mem.equals(Memory.wrap(result)));
}
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java b/src/test/java/org/apache/datasketches/memory/test/NativeWritableBufferImplTest.java
similarity index 66%
rename from src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java
rename to src/test/java/org/apache/datasketches/memory/test/NativeWritableBufferImplTest.java
index 18a43da..06f6697 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableBufferImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/NativeWritableBufferImplTest.java
@@ -27,28 +27,28 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.ReadOnlyException;
import org.apache.datasketches.memory.internal.UnsafeUtil;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
-public class WritableBufferImplTest {
+public class NativeWritableBufferImplTest {
//Simple Native direct
@SuppressWarnings("resource")
@Test
- public void checkNativeCapacityAndClose() {
+ public void checkNativeCapacityAndClose() throws Exception {
int memCapacity = 64;
- WritableHandle wmh = WritableMemoryImpl.allocateDirect(memCapacity);
- WritableMemoryImpl wmem = wmh.get();
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableHandle wmh = WritableMemory.allocateDirect(memCapacity);
+ WritableMemory wmem = wmh.getWritable();
+ WritableBuffer wbuf = wmem.asWritableBuffer();
assertEquals(wbuf.getCapacity(), memCapacity);
wmh.close(); //intentional
@@ -64,13 +64,13 @@ public class WritableBufferImplTest {
boolean[] srcArray = { true, false, true, false, false, true, true, false };
boolean[] dstArray = new boolean[8];
- BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
buf.getBooleanArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
wbuf.getBooleanArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -83,13 +83,13 @@ public class WritableBufferImplTest {
byte[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
byte[] dstArray = new byte[8];
- BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
buf.getByteArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
wbuf.getByteArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -101,13 +101,13 @@ public class WritableBufferImplTest {
char[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
char[] dstArray = new char[8];
- BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
buf.getCharArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
wbuf.getCharArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -119,13 +119,13 @@ public class WritableBufferImplTest {
short[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
short[] dstArray = new short[8];
- BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
buf.getShortArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
wbuf.getShortArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -137,13 +137,13 @@ public class WritableBufferImplTest {
int[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
int[] dstArray = new int[8];
- BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
buf.getIntArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
wbuf.getIntArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -155,13 +155,13 @@ public class WritableBufferImplTest {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
long[] dstArray = new long[8];
- BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
buf.getLongArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
wbuf.getLongArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -173,13 +173,13 @@ public class WritableBufferImplTest {
float[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
float[] dstArray = new float[8];
- BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
buf.getFloatArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
wbuf.getFloatArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -191,13 +191,13 @@ public class WritableBufferImplTest {
double[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
double[] dstArray = new double[8];
- BufferImpl buf = MemoryImpl.wrap(srcArray).asBuffer();
+ Buffer buf = Memory.wrap(srcArray).asBuffer();
buf.getDoubleArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
wbuf.getDoubleArray(dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -205,11 +205,11 @@ public class WritableBufferImplTest {
}
@Test
- public void checkNativeBaseBound() {
+ public void checkNativeBaseBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl wmem = wrh.get();
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory wmem = wrh.getWritable();
+ WritableBuffer wbuf = wmem.asWritableBuffer();
wbuf.toHexString("Force Assertion Error", memCapacity, 8);
} catch (IllegalArgumentException e) {
//ok
@@ -217,11 +217,11 @@ public class WritableBufferImplTest {
}
@Test
- public void checkNativeSrcArrayBound() {
+ public void checkNativeSrcArrayBound() throws Exception {
long memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl wmem = wrh.get();
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory wmem = wrh.getWritable();
+ WritableBuffer wbuf = wmem.asWritableBuffer();
byte[] srcArray = { 1, -2, 3, -4 };
wbuf.putByteArray(srcArray, 0, 5); //wrong!
} catch (IllegalArgumentException e) {
@@ -231,11 +231,11 @@ public class WritableBufferImplTest {
@Test(expectedExceptions = IllegalArgumentException.class)
- public void checkRegionBounds() {
+ public void checkRegionBounds() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl wmem = wrh.get();
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory wmem = wrh.getWritable();
+ WritableBuffer wbuf = wmem.asWritableBuffer();
wbuf.writableRegion(1, 64, wbuf.getTypeByteOrder()); //wrong!
}
}
@@ -250,7 +250,7 @@ public class WritableBufferImplTest {
byteBuf.put(i, (byte) i);
}
- WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(byteBuf);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(byteBuf);
for (int i=0; i<memCapacity; i++) {
assertEquals(wbuf.getByte(), byteBuf.get(i));
@@ -272,7 +272,7 @@ public class WritableBufferImplTest {
byteBuf.put(i, (byte) i);
}
- BufferImpl buf = WritableBufferImpl.writableWrap(byteBuf);
+ Buffer buf = WritableBuffer.writableWrap(byteBuf);
for (int i = 0; i < memCapacity; i++) {
assertEquals(buf.getByte(), byteBuf.get(i));
@@ -288,7 +288,7 @@ public class WritableBufferImplTest {
byteBuf.order(ByteOrder.nativeOrder());
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
- WritableBufferImpl.writableWrap(byteBufRO);
+ WritableBuffer.writableWrap(byteBufRO);
}
@Test
@@ -303,7 +303,7 @@ public class WritableBufferImplTest {
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
byteBufRO.order(ByteOrder.nativeOrder());
- BufferImpl buf = BufferImpl.wrap(byteBufRO);
+ Buffer buf = Buffer.wrap(byteBufRO);
for (int i = 0; i < memCapacity; i++) {
assertEquals(buf.getByte(), byteBuf.get(i));
@@ -319,7 +319,7 @@ public class WritableBufferImplTest {
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
byteBufRO.order(ByteOrder.nativeOrder());
- WritableBufferImpl.writableWrap(byteBufRO);
+ WritableBuffer.writableWrap(byteBufRO);
}
@Test
@@ -332,7 +332,7 @@ public class WritableBufferImplTest {
byteBuf.put(i, (byte) i);
}
- BufferImpl buf = BufferImpl.wrap(byteBuf);
+ Buffer buf = Buffer.wrap(byteBuf);
for (int i=0; i<memCapacity; i++) {
assertEquals(buf.getByte(), byteBuf.get(i));
@@ -342,15 +342,15 @@ public class WritableBufferImplTest {
}
@Test
- public void checkIsDirect() {
+ public void checkIsDirect() throws Exception {
int memCapacity = 64;
- WritableBufferImpl mem = WritableMemoryImpl.allocate(memCapacity).asWritableBuffer();
+ WritableBuffer mem = WritableMemory.allocate(memCapacity).asWritableBuffer();
assertFalse(mem.isDirect());
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem2 = wrh.get();
- WritableBufferImpl wbuf = mem2.asWritableBuffer();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem2 = wrh.getWritable();
+ WritableBuffer wbuf = mem2.asWritableBuffer();
assertTrue(wbuf.isDirect());
- wrh.close();
+ wrh.close(); //immediate close
}
}
@@ -358,10 +358,10 @@ public class WritableBufferImplTest {
public void checkIsReadOnly() {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
- WritableBufferImpl wbuf = WritableMemoryImpl.writableWrap(srcArray).asWritableBuffer();
+ WritableBuffer wbuf = WritableMemory.writableWrap(srcArray).asWritableBuffer();
assertFalse(wbuf.isReadOnly());
- BufferImpl buf = wbuf;
+ Buffer buf = wbuf;
assertFalse(buf.isReadOnly());
for (int i = 0; i < srcArray.length; i++) {
@@ -380,9 +380,9 @@ public class WritableBufferImplTest {
byte[] arr2 = new byte[] {0, 1, 2, 4};
byte[] arr3 = new byte[] {0, 1, 2, 3, 4};
- BufferImpl buf1 = MemoryImpl.wrap(arr1).asBuffer();
- BufferImpl buf2 = MemoryImpl.wrap(arr2).asBuffer();
- BufferImpl buf3 = MemoryImpl.wrap(arr3).asBuffer();
+ Buffer buf1 = Memory.wrap(arr1).asBuffer();
+ Buffer buf2 = Memory.wrap(arr2).asBuffer();
+ Buffer buf3 = Memory.wrap(arr3).asBuffer();
int comp = buf1.compareTo(0, 3, buf2, 0, 3);
assertEquals(comp, 0);
@@ -398,27 +398,27 @@ public class WritableBufferImplTest {
}
@Test
- public void checkCompareToDirect() {
+ public void checkCompareToDirect() throws Exception {
byte[] arr1 = new byte[] {0, 1, 2, 3};
byte[] arr2 = new byte[] {0, 1, 2, 4};
byte[] arr3 = new byte[] {0, 1, 2, 3, 4};
- try (WritableHandle h1 = WritableMemoryImpl.allocateDirect(4);
- WritableHandle h2 = WritableMemoryImpl.allocateDirect(4);
- WritableHandle h3 = WritableMemoryImpl.allocateDirect(5))
+ try (WritableHandle h1 = WritableMemory.allocateDirect(4);
+ WritableHandle h2 = WritableMemory.allocateDirect(4);
+ WritableHandle h3 = WritableMemory.allocateDirect(5))
{
- WritableMemoryImpl mem1 = h1.get();
+ WritableMemory mem1 = h1.getWritable();
mem1.putByteArray(0, arr1, 0, 4);
- WritableMemoryImpl mem2 = h2.get();
+ WritableMemory mem2 = h2.getWritable();
mem2.putByteArray(0, arr2, 0, 4);
- WritableMemoryImpl mem3 = h3.get();
+ WritableMemory mem3 = h3.getWritable();
mem3.putByteArray(0, arr3, 0, 5);
- BufferImpl buf1 = mem1.asBuffer();
- BufferImpl buf2 = mem2.asBuffer();
- BufferImpl buf3 = mem3.asBuffer();
+ Buffer buf1 = mem1.asBuffer();
+ Buffer buf2 = mem2.asBuffer();
+ Buffer buf3 = mem3.asBuffer();
int comp = buf1.compareTo(0, 3, buf2, 0, 3);
assertEquals(comp, 0);
@@ -436,13 +436,13 @@ public class WritableBufferImplTest {
@Test
public void checkAsBuffer() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableMemory wmem = WritableMemory.allocate(64);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
wbuf.setPosition(32);
for (int i = 32; i < 64; i++) { wbuf.putByte((byte)i); }
//println(wbuf.toHexString("Buf", 0, (int)wbuf.getCapacity()));
- BufferImpl buf = wmem.asBuffer();
+ Buffer buf = wmem.asBuffer();
buf.setPosition(32);
for (int i = 32; i < 64; i++) {
assertEquals(buf.getByte(), i);
@@ -451,32 +451,32 @@ public class WritableBufferImplTest {
@Test
public void checkDuplicate() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
+ WritableMemory wmem = WritableMemory.allocate(64);
for (int i = 0; i < 64; i++) { wmem.putByte(i, (byte)i); }
- WritableBufferImpl wbuf = wmem.asWritableBuffer().writableDuplicate();
+ WritableBuffer wbuf = wmem.asWritableBuffer().writableDuplicate();
wbuf.checkValidAndBounds(0, 64);
for (int i = 0; i < 64; i++) {
assertEquals(wbuf.getByte(), i);
}
- BufferImpl buf = wmem.asBuffer().duplicate();
+ Buffer buf = wmem.asBuffer().duplicate();
for (int i = 0; i < 64; i++) {
assertEquals(buf.getByte(), i);
}
- WritableMemoryImpl wmem2 = wbuf.asWritableMemory();
+ WritableMemory wmem2 = wbuf.asWritableMemory();
for (int i = 0; i < 64; i++) {
assertEquals(wmem2.getByte(i), i);
}
- WritableMemoryImpl wmem3 = wbuf.asWritableMemory();
+ WritableMemory wmem3 = wbuf.asWritableMemory();
wmem3.checkValidAndBounds(0, 64);
}
@Test
public void checkCumAndRegionOffset() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
- WritableMemoryImpl reg = wmem.writableRegion(32, 32);
- WritableBufferImpl buf = reg.asWritableBuffer();
+ WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemory reg = wmem.writableRegion(32, 32);
+ WritableBuffer buf = reg.asWritableBuffer();
assertEquals(buf.getRegionOffset(), 32);
assertEquals(buf.getRegionOffset(0), 32);
assertEquals(buf.getCumulativeOffset(), 32 + 16);
@@ -486,31 +486,31 @@ public class WritableBufferImplTest {
@Test
public void checkIsSameResource() {
byte[] byteArr = new byte[64];
- WritableBufferImpl wbuf1 = WritableMemoryImpl.writableWrap(byteArr).asWritableBuffer();
- WritableBufferImpl wbuf2 = WritableMemoryImpl.writableWrap(byteArr).asWritableBuffer();
+ WritableBuffer wbuf1 = WritableMemory.writableWrap(byteArr).asWritableBuffer();
+ WritableBuffer wbuf2 = WritableMemory.writableWrap(byteArr).asWritableBuffer();
assertTrue(wbuf1.isSameResource(wbuf2));
}
@Test
public void checkDegenerateRegionReturn() {
- MemoryImpl mem = MemoryImpl.wrap(new byte[0]);
- BufferImpl buf = mem.asBuffer();
- BufferImpl reg = buf.region();
+ Memory mem = Memory.wrap(new byte[0]);
+ Buffer buf = mem.asBuffer();
+ Buffer reg = buf.region();
assertEquals(reg.getCapacity(), 0);
}
@Test
public void checkAsWritableMemoryRO() {
ByteBuffer bb = ByteBuffer.allocate(64);
- WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
@SuppressWarnings("unused")
- WritableMemoryImpl wmem = wbuf.asWritableMemory();
+ WritableMemory wmem = wbuf.asWritableMemory();
try {
- BufferImpl buf = BufferImpl.wrap(bb);
- wbuf = (WritableBufferImpl) buf;
+ Buffer buf = Buffer.wrap(bb);
+ wbuf = (WritableBuffer) buf;
@SuppressWarnings("unused")
- WritableMemoryImpl wmem2 = wbuf.asWritableMemory();
+ WritableMemory wmem2 = wbuf.asWritableMemory();
Assert.fail();
} catch (ReadOnlyException expected) {
// expected
@@ -520,15 +520,15 @@ public class WritableBufferImplTest {
@Test
public void checkWritableDuplicateRO() {
ByteBuffer bb = ByteBuffer.allocate(64);
- WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
@SuppressWarnings("unused")
- WritableBufferImpl wdup = wbuf.writableDuplicate();
+ WritableBuffer wdup = wbuf.writableDuplicate();
try {
- BufferImpl buf = BufferImpl.wrap(bb);
- wbuf = (WritableBufferImpl) buf;
+ Buffer buf = Buffer.wrap(bb);
+ wbuf = (WritableBuffer) buf;
@SuppressWarnings("unused")
- WritableBufferImpl wdup2 = wbuf.writableDuplicate();
+ WritableBuffer wdup2 = wbuf.writableDuplicate();
Assert.fail();
} catch (ReadOnlyException expected) {
// ignore
@@ -538,15 +538,15 @@ public class WritableBufferImplTest {
@Test
public void checkWritableRegionRO() {
ByteBuffer bb = ByteBuffer.allocate(64);
- WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
@SuppressWarnings("unused")
- WritableBufferImpl wreg = wbuf.writableRegion();
+ WritableBuffer wreg = wbuf.writableRegion();
try {
- BufferImpl buf = BufferImpl.wrap(bb);
- wbuf = (WritableBufferImpl) buf;
+ Buffer buf = Buffer.wrap(bb);
+ wbuf = (WritableBuffer) buf;
@SuppressWarnings("unused")
- WritableBufferImpl wreg2 = wbuf.writableRegion();
+ WritableBuffer wreg2 = wbuf.writableRegion();
Assert.fail();
} catch (ReadOnlyException expected) {
// ignore
@@ -556,15 +556,15 @@ public class WritableBufferImplTest {
@Test
public void checkWritableRegionWithParamsRO() {
ByteBuffer bb = ByteBuffer.allocate(64);
- WritableBufferImpl wbuf = WritableBufferImpl.writableWrap(bb);
+ WritableBuffer wbuf = WritableBuffer.writableWrap(bb);
@SuppressWarnings("unused")
- WritableBufferImpl wreg = wbuf.writableRegion(0, 1, wbuf.getTypeByteOrder());
+ WritableBuffer wreg = wbuf.writableRegion(0, 1, wbuf.getTypeByteOrder());
try {
- BufferImpl buf = BufferImpl.wrap(bb);
- wbuf = (WritableBufferImpl) buf;
+ Buffer buf = Buffer.wrap(bb);
+ wbuf = (WritableBuffer) buf;
@SuppressWarnings("unused")
- WritableBufferImpl wreg2 = wbuf.writableRegion(0, 1, wbuf.getTypeByteOrder());
+ WritableBuffer wreg2 = wbuf.writableRegion(0, 1, wbuf.getTypeByteOrder());
Assert.fail();
} catch (ReadOnlyException expected) {
// ignore
@@ -573,17 +573,17 @@ public class WritableBufferImplTest {
@Test
public void checkZeroBuffer() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(8);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
- WritableBufferImpl reg = wbuf.writableRegion(0, 0, wbuf.getTypeByteOrder());
+ WritableMemory wmem = WritableMemory.allocate(8);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBuffer reg = wbuf.writableRegion(0, 0, wbuf.getTypeByteOrder());
assertEquals(reg.getCapacity(), 0);
}
@Test
public void checkDuplicateNonNative() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
+ WritableMemory wmem = WritableMemory.allocate(64);
wmem.putShort(0, (short) 1);
- BufferImpl buf = wmem.asWritableBuffer().duplicate(Util.nonNativeByteOrder);
+ Buffer buf = wmem.asWritableBuffer().duplicate(Util.nonNativeByteOrder);
assertEquals(buf.getShort(0), 256);
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java b/src/test/java/org/apache/datasketches/memory/test/NativeWritableMemoryImplTest.java
similarity index 71%
rename from src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java
rename to src/test/java/org/apache/datasketches/memory/test/NativeWritableMemoryImplTest.java
index 2cb8460..017d4e2 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/NativeWritableMemoryImplTest.java
@@ -28,26 +28,26 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.ReadOnlyException;
import org.apache.datasketches.memory.internal.UnsafeUtil;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
-public class WritableMemoryImplTest {
+public class NativeWritableMemoryImplTest {
//Simple Native direct
@SuppressWarnings("resource")
@Test
- public void checkNativeCapacityAndClose() {
+ public void checkNativeCapacityAndClose() throws Exception {
int memCapacity = 64;
- WritableHandle wmh = WritableMemoryImpl.allocateDirect(memCapacity);
- WritableMemoryImpl mem = wmh.get();
+ WritableHandle wmh = WritableMemory.allocateDirect(memCapacity);
+ WritableMemory mem = wmh.getWritable();
assertEquals(memCapacity, mem.getCapacity());
wmh.close(); //intentional
@@ -63,13 +63,13 @@ public class WritableMemoryImplTest {
boolean[] srcArray = { true, false, true, false, false, true, true, false };
boolean[] dstArray = new boolean[8];
- MemoryImpl mem = MemoryImpl.wrap(srcArray);
+ Memory mem = Memory.wrap(srcArray);
mem.getBooleanArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
wmem.getBooleanArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -82,13 +82,13 @@ public class WritableMemoryImplTest {
byte[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
byte[] dstArray = new byte[8];
- MemoryImpl mem = MemoryImpl.wrap(srcArray);
+ Memory mem = Memory.wrap(srcArray);
mem.getByteArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
wmem.getByteArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -100,13 +100,13 @@ public class WritableMemoryImplTest {
char[] srcArray = { 1, 2, 3, 4, 5, 6, 7, 8 };
char[] dstArray = new char[8];
- MemoryImpl mem = MemoryImpl.wrap(srcArray);
+ Memory mem = Memory.wrap(srcArray);
mem.getCharArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
wmem.getCharArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -118,13 +118,13 @@ public class WritableMemoryImplTest {
short[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
short[] dstArray = new short[8];
- MemoryImpl mem = MemoryImpl.wrap(srcArray);
+ Memory mem = Memory.wrap(srcArray);
mem.getShortArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
wmem.getShortArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -136,13 +136,13 @@ public class WritableMemoryImplTest {
int[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
int[] dstArray = new int[8];
- MemoryImpl mem = MemoryImpl.wrap(srcArray);
+ Memory mem = Memory.wrap(srcArray);
mem.getIntArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
wmem.getIntArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -154,13 +154,13 @@ public class WritableMemoryImplTest {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
long[] dstArray = new long[8];
- MemoryImpl mem = MemoryImpl.wrap(srcArray);
+ Memory mem = Memory.wrap(srcArray);
mem.getLongArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
wmem.getLongArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -172,13 +172,13 @@ public class WritableMemoryImplTest {
float[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
float[] dstArray = new float[8];
- MemoryImpl mem = MemoryImpl.wrap(srcArray);
+ Memory mem = Memory.wrap(srcArray);
mem.getFloatArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
wmem.getFloatArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -190,13 +190,13 @@ public class WritableMemoryImplTest {
double[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
double[] dstArray = new double[8];
- MemoryImpl mem = MemoryImpl.wrap(srcArray);
+ Memory mem = Memory.wrap(srcArray);
mem.getDoubleArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
wmem.getDoubleArray(0, dstArray, 0, 8);
for (int i=0; i<8; i++) {
assertEquals(dstArray[i], srcArray[i]);
@@ -204,10 +204,10 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkNativeBaseBound() {
+ public void checkNativeBaseBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.toHexString("Force Assertion Error", memCapacity, 8);
} catch (IllegalArgumentException e) {
//ok
@@ -215,10 +215,10 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkNativeSrcArrayBound() {
+ public void checkNativeSrcArrayBound() throws Exception {
long memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
byte[] srcArray = { 1, -2, 3, -4 };
mem.putByteArray(0L, srcArray, 0, 5);
} catch (IllegalArgumentException e) {
@@ -230,16 +230,16 @@ public class WritableMemoryImplTest {
@Test(expectedExceptions = IllegalArgumentException.class)
public void checkDegenerateCopyTo() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
+ WritableMemory wmem = WritableMemory.allocate(64);
wmem.copyTo(0, wmem, 0, 64);
}
@Test
- public void checkCopyWithinNativeSmall() {
+ public void checkCopyWithinNativeSmall() throws Exception {
int memCapacity = 64;
int half = memCapacity/2;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.clear();
for (int i=0; i<half; i++) { //fill first half
@@ -255,13 +255,13 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCopyWithinNativeLarge() {
+ public void checkCopyWithinNativeLarge() throws Exception {
int memCapacity = (2 << 20) + 64;
int memCapLongs = memCapacity / 8;
int halfBytes = memCapacity / 2;
int halfLongs = memCapLongs / 2;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.clear();
for (int i=0; i < halfLongs; i++) {
@@ -277,10 +277,10 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCopyWithinNativeSrcBound() {
+ public void checkCopyWithinNativeSrcBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.copyTo(32, mem, 32, 33); //hit source bound check
fail("Did Not Catch Assertion Error: source bound");
}
@@ -290,10 +290,10 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCopyWithinNativeDstBound() {
+ public void checkCopyWithinNativeDstBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.copyTo(0, mem, 32, 33); //hit dst bound check
fail("Did Not Catch Assertion Error: dst bound");
}
@@ -303,14 +303,14 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCopyCrossNativeSmall() {
+ public void checkCopyCrossNativeSmall() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity);
- WritableHandle wrh2 = WritableMemoryImpl.allocateDirect(memCapacity))
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity);
+ WritableHandle wrh2 = WritableMemory.allocateDirect(memCapacity))
{
- WritableMemoryImpl mem1 = wrh1.get();
- WritableMemoryImpl mem2 = wrh2.get();
+ WritableMemory mem1 = wrh1.getWritable();
+ WritableMemory mem2 = wrh2.getWritable();
for (int i=0; i < memCapacity; i++) {
mem1.putByte(i, (byte) i);
@@ -327,15 +327,15 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCopyCrossNativeLarge() {
+ public void checkCopyCrossNativeLarge() throws Exception {
int memCapacity = (2<<20) + 64;
int memCapLongs = memCapacity / 8;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity);
- WritableHandle wrh2 = WritableMemoryImpl.allocateDirect(memCapacity))
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity);
+ WritableHandle wrh2 = WritableMemory.allocateDirect(memCapacity))
{
- WritableMemoryImpl mem1 = wrh1.get();
- WritableMemoryImpl mem2 = wrh2.get();
+ WritableMemory mem1 = wrh1.getWritable();
+ WritableMemory mem2 = wrh2.getWritable();
for (int i=0; i < memCapLongs; i++) {
mem1.putLong(i*8, i);
@@ -351,16 +351,16 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCopyCrossNativeAndByteArray() {
+ public void checkCopyCrossNativeAndByteArray() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem1 = wrh1.getWritable();
for (int i= 0; i < mem1.getCapacity(); i++) {
mem1.putByte(i, (byte) i);
}
- WritableMemoryImpl mem2 = WritableMemoryImpl.allocate(memCapacity);
+ WritableMemory mem2 = WritableMemory.allocate(memCapacity);
mem1.copyTo(8, mem2, 16, 16);
for (int i=0; i<16; i++) {
@@ -371,21 +371,21 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCopyCrossRegionsSameNative() {
+ public void checkCopyCrossRegionsSameNative() throws Exception {
int memCapacity = 128;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem1 = wrh1.getWritable();
for (int i= 0; i < mem1.getCapacity(); i++) {
mem1.putByte(i, (byte) i);
}
//println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
- MemoryImpl reg1 = mem1.region(8, 16);
+ Memory reg1 = mem1.region(8, 16);
//println(reg1.toHexString("Reg1", 0, (int)reg1.getCapacity()));
- WritableMemoryImpl reg2 = mem1.writableRegion(24, 16);
+ WritableMemory reg2 = mem1.writableRegion(24, 16);
//println(reg2.toHexString("Reg2", 0, (int)reg2.getCapacity()));
reg1.copyTo(0, reg2, 0, 16);
@@ -398,24 +398,24 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCopyCrossNativeArrayAndHierarchicalRegions() {
+ public void checkCopyCrossNativeArrayAndHierarchicalRegions() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem1 = wrh1.getWritable();
for (int i= 0; i < mem1.getCapacity(); i++) { //fill with numbers
mem1.putByte(i, (byte) i);
}
//println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
- WritableMemoryImpl mem2 = WritableMemoryImpl.allocate(memCapacity);
+ WritableMemory mem2 = WritableMemory.allocate(memCapacity);
- MemoryImpl reg1 = mem1.region(8, 32);
- MemoryImpl reg1B = reg1.region(8, 16);
+ Memory reg1 = mem1.region(8, 32);
+ Memory reg1B = reg1.region(8, 16);
//println(reg1.toHexString("Reg1", 0, (int)reg1.getCapacity()));
//println(reg1B.toHexString("Reg1B", 0, (int)reg1B.getCapacity()));
- WritableMemoryImpl reg2 = mem2.writableRegion(32, 16);
+ WritableMemory reg2 = mem2.writableRegion(32, 16);
reg1B.copyTo(0, reg2, 0, 16);
//println(reg2.toHexString("Reg2", 0, (int)reg2.getCapacity()));
@@ -428,10 +428,10 @@ public class WritableMemoryImplTest {
}
@Test(expectedExceptions = IllegalArgumentException.class)
- public void checkRegionBounds() {
+ public void checkRegionBounds() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.writableRegion(1, 64);
}
}
@@ -446,7 +446,7 @@ public class WritableMemoryImplTest {
byteBuf.put(i, (byte) i);
}
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(byteBuf);
+ WritableMemory wmem = WritableMemory.writableWrap(byteBuf);
for (int i=0; i<memCapacity; i++) {
assertEquals(wmem.getByte(i), byteBuf.get(i));
@@ -468,7 +468,7 @@ public class WritableMemoryImplTest {
byteBuf.put(i, (byte) i);
}
- MemoryImpl mem = WritableMemoryImpl.writableWrap(byteBuf);
+ Memory mem = WritableMemory.writableWrap(byteBuf);
for (int i = 0; i < memCapacity; i++) {
assertEquals(mem.getByte(i), byteBuf.get(i));
@@ -484,7 +484,7 @@ public class WritableMemoryImplTest {
byteBuf.order(ByteOrder.nativeOrder());
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
- WritableMemoryImpl.writableWrap(byteBufRO);
+ WritableMemory.writableWrap(byteBufRO);
}
@Test
@@ -499,7 +499,7 @@ public class WritableMemoryImplTest {
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
byteBufRO.order(ByteOrder.nativeOrder());
- MemoryImpl mem = MemoryImpl.wrap(byteBufRO);
+ Memory mem = Memory.wrap(byteBufRO);
for (int i = 0; i < memCapacity; i++) {
assertEquals(mem.getByte(i), byteBuf.get(i));
@@ -515,7 +515,7 @@ public class WritableMemoryImplTest {
ByteBuffer byteBufRO = byteBuf.asReadOnlyBuffer();
byteBufRO.order(ByteOrder.nativeOrder());
- WritableMemoryImpl.writableWrap(byteBufRO);
+ WritableMemory.writableWrap(byteBufRO);
}
@Test
@@ -528,7 +528,7 @@ public class WritableMemoryImplTest {
byteBuf.put(i, (byte) i);
}
- MemoryImpl mem = MemoryImpl.wrap(byteBuf);
+ Memory mem = Memory.wrap(byteBuf);
for (int i=0; i<memCapacity; i++) {
assertEquals(mem.getByte(i), byteBuf.get(i));
@@ -538,12 +538,12 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkIsDirect() {
+ public void checkIsDirect() throws Exception {
int memCapacity = 64;
- WritableMemoryImpl mem = WritableMemoryImpl.allocate(memCapacity);
+ WritableMemory mem = WritableMemory.allocate(memCapacity);
assertFalse(mem.isDirect());
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ mem = wrh.getWritable();
assertTrue(mem.isDirect());
wrh.close();
}
@@ -553,10 +553,10 @@ public class WritableMemoryImplTest {
public void checkIsReadOnly() {
long[] srcArray = { 1, -2, 3, -4, 5, -6, 7, -8 };
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcArray);
+ WritableMemory wmem = WritableMemory.writableWrap(srcArray);
assertFalse(wmem.isReadOnly());
- MemoryImpl memRO = wmem;
+ Memory memRO = wmem;
assertFalse(memRO.isReadOnly());
for (int i = 0; i < wmem.getCapacity(); i++) {
@@ -575,10 +575,10 @@ public class WritableMemoryImplTest {
byte[] arr2 = new byte[] {0, 1, 2, 4};
byte[] arr3 = new byte[] {0, 1, 2, 3, 4};
- MemoryImpl mem1 = MemoryImpl.wrap(arr1);
- MemoryImpl mem2 = MemoryImpl.wrap(arr2);
- MemoryImpl mem3 = MemoryImpl.wrap(arr3);
- MemoryImpl mem4 = MemoryImpl.wrap(arr3); //same resource
+ Memory mem1 = Memory.wrap(arr1);
+ Memory mem2 = Memory.wrap(arr2);
+ Memory mem3 = Memory.wrap(arr3);
+ Memory mem4 = Memory.wrap(arr3); //same resource
int comp = mem1.compareTo(0, 3, mem2, 0, 3);
assertEquals(comp, 0);
@@ -599,22 +599,22 @@ public class WritableMemoryImplTest {
}
@Test
- public void checkCompareToDirect() {
+ public void checkCompareToDirect() throws Exception {
byte[] arr1 = new byte[] {0, 1, 2, 3};
byte[] arr2 = new byte[] {0, 1, 2, 4};
byte[] arr3 = new byte[] {0, 1, 2, 3, 4};
- try (WritableHandle h1 = WritableMemoryImpl.allocateDirect(4);
- WritableHandle h2 = WritableMemoryImpl.allocateDirect(4);
- WritableHandle h3 = WritableMemoryImpl.allocateDirect(5))
+ try (WritableHandle h1 = WritableMemory.allocateDirect(4);
+ WritableHandle h2 = WritableMemory.allocateDirect(4);
+ WritableHandle h3 = WritableMemory.allocateDirect(5))
{
- WritableMemoryImpl mem1 = h1.get();
+ WritableMemory mem1 = h1.getWritable();
mem1.putByteArray(0, arr1, 0, 4);
- WritableMemoryImpl mem2 = h2.get();
+ WritableMemory mem2 = h2.getWritable();
mem2.putByteArray(0, arr2, 0, 4);
- WritableMemoryImpl mem3 = h3.get();
+ WritableMemory mem3 = h3.getWritable();
mem3.putByteArray(0, arr3, 0, 5);
int comp = mem1.compareTo(0, 3, mem2, 0, 3);
@@ -633,7 +633,7 @@ public class WritableMemoryImplTest {
@Test
public void testCompareToSameStart() {
- MemoryImpl mem = WritableMemoryImpl.allocate(3);
+ Memory mem = WritableMemory.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));
@@ -641,13 +641,13 @@ public class WritableMemoryImplTest {
@Test
public void checkAsBuffer() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableMemory wmem = WritableMemory.allocate(64);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
wbuf.setPosition(32);
for (int i = 32; i < 64; i++) { wbuf.putByte((byte)i); }
//println(wbuf.toHexString("Buf", 0, (int)wbuf.getCapacity()));
- BufferImpl buf = wmem.asBuffer();
+ Buffer buf = wmem.asBuffer();
buf.setPosition(32);
for (int i = 32; i < 64; i++) {
assertEquals(buf.getByte(), i);
@@ -656,8 +656,8 @@ public class WritableMemoryImplTest {
@Test
public void checkCumAndRegionOffset() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
- WritableMemoryImpl reg = wmem.writableRegion(32, 32);
+ WritableMemory wmem = WritableMemory.allocate(64);
+ WritableMemory reg = wmem.writableRegion(32, 32);
assertEquals(reg.getRegionOffset(), 32);
assertEquals(reg.getRegionOffset(0), 32);
assertEquals(reg.getCumulativeOffset(), 32 + 16);
@@ -667,8 +667,8 @@ public class WritableMemoryImplTest {
@Test
public void checkIsSameResource() {
byte[] byteArr = new byte[64];
- WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(byteArr);
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(byteArr);
+ WritableMemory wmem1 = WritableMemory.writableWrap(byteArr);
+ WritableMemory wmem2 = WritableMemory.writableWrap(byteArr);
assertTrue(wmem1.isSameResource(wmem2));
}
@@ -677,8 +677,8 @@ public class WritableMemoryImplTest {
ByteBuffer byteBuf = ByteBuffer.allocate(64);
byteBuf.position(16);
byteBuf.limit(48);
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(byteBuf);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableMemory wmem = WritableMemory.writableWrap(byteBuf);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
assertEquals(wbuf.getCapacity(), 64);
assertEquals(wbuf.getPosition(), 0);
assertEquals(wbuf.getEnd(), 64);
@@ -687,28 +687,28 @@ public class WritableMemoryImplTest {
@Test(expectedExceptions = ReadOnlyException.class)
public void checkAsWritableRegionRO() {
ByteBuffer byteBuf = ByteBuffer.allocate(64);
- WritableMemoryImpl wmem = (WritableMemoryImpl) MemoryImpl.wrap(byteBuf);
+ WritableMemory wmem = (WritableMemory) Memory.wrap(byteBuf);
wmem.writableRegion(0, 1);
}
@Test(expectedExceptions = ReadOnlyException.class)
public void checkAsWritableBufferRO() {
ByteBuffer byteBuf = ByteBuffer.allocate(64);
- WritableMemoryImpl wmem = (WritableMemoryImpl) MemoryImpl.wrap(byteBuf);
+ WritableMemory wmem = (WritableMemory) Memory.wrap(byteBuf);
wmem.asWritableBuffer();
}
@Test void checkZeroMemory() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(8);
- WritableMemoryImpl reg = wmem.writableRegion(0, 0);
+ WritableMemory wmem = WritableMemory.allocate(8);
+ WritableMemory reg = wmem.writableRegion(0, 0);
assertEquals(reg.getCapacity(), 0);
}
@Test
public void checkAsBufferNonNative() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64);
+ WritableMemory wmem = WritableMemory.allocate(64);
wmem.putShort(0, (short) 1);
- BufferImpl buf = wmem.asBuffer(Util.nonNativeByteOrder);
+ Buffer buf = wmem.asBuffer(Util.nonNativeByteOrder);
assertEquals(buf.getShort(0), 256);
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableBufferImplTest.java b/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableBufferImplTest.java
index 84c2f1c..7753e6e 100644
--- a/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableBufferImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableBufferImplTest.java
@@ -23,9 +23,9 @@ import static org.testng.Assert.assertEquals;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
@@ -41,8 +41,8 @@ public class NonNativeWritableBufferImplTest {
int m = Character.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableMemory wmem = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
char ch = 'a';
for (int i = 0; i < n; i++) { wbuf.putChar(i * m, ch++); }
ch = 'a';
@@ -62,8 +62,8 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getCharArray(cArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putCharArray(cArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -74,8 +74,8 @@ public class NonNativeWritableBufferImplTest {
int m = Double.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableMemory wmem = WritableMemory.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++); }
dbl = 1.0;
@@ -95,8 +95,8 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getDoubleArray(dblArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putDoubleArray(dblArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -107,8 +107,8 @@ public class NonNativeWritableBufferImplTest {
int m = Float.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableMemory wmem = WritableMemory.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++); }
flt = 1.0F;
@@ -128,8 +128,8 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getFloatArray(fltArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putFloatArray(fltArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -140,8 +140,8 @@ public class NonNativeWritableBufferImplTest {
int m = Integer.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableMemory wmem = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
int intg = 1;
for (int i = 0; i < n; i++) { wbuf.putInt(i * m, intg++); }
intg = 1;
@@ -161,8 +161,8 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getIntArray(intArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putIntArray(intArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -173,8 +173,8 @@ public class NonNativeWritableBufferImplTest {
int m = Long.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableMemory wmem = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
long lng = 1;
for (int i = 0; i < n; i++) { wbuf.putLong(i * m, lng++); }
lng = 1;
@@ -194,8 +194,8 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getLongArray(longArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putLongArray(longArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -206,8 +206,8 @@ public class NonNativeWritableBufferImplTest {
int m = Short.BYTES;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableMemory wmem = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
short sht = 1;
for (int i = 0; i < n; i++) { wbuf.putShort(i * m, sht++); }
sht = 1;
@@ -227,8 +227,8 @@ public class NonNativeWritableBufferImplTest {
wbuf.setPosition(0);
wbuf.getShortArray(shortArr, 0, n); //wmem is non-native
byte[] arr2 = new byte[n * m];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf2 = wmem2.asWritableBuffer();
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf2 = wmem2.asWritableBuffer();
wbuf2.putShortArray(shortArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -237,24 +237,24 @@ public class NonNativeWritableBufferImplTest {
@Test
public void checkDuplicate() {
byte[] bArr = new byte[8];
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
- WritableBufferImpl wdup = wbuf.writableDuplicate();
+ WritableMemory wmem = WritableMemory.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
+ WritableBuffer wbuf = wmem.asWritableBuffer();
+ WritableBuffer wdup = wbuf.writableDuplicate();
assertEquals(wdup.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
- WritableBufferImpl wreg = wbuf.writableRegion();
+ WritableBuffer wreg = wbuf.writableRegion();
assertEquals(wreg.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
}
@Test
public void checkDuplicateZeros() {
byte[] bArr = new byte[0];
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
- BufferImpl buf = wmem.asBuffer();
- BufferImpl dup = buf.duplicate();
+ WritableMemory wmem = WritableMemory.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
+ Buffer buf = wmem.asBuffer();
+ Buffer dup = buf.duplicate();
assertEquals(dup.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
- BufferImpl reg = buf.region();
+ Buffer reg = buf.region();
assertEquals(reg.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableMemoryImplTest.java b/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableMemoryImplTest.java
index f9e60f6..c6351dc 100644
--- a/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableMemoryImplTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/NonNativeWritableMemoryImplTest.java
@@ -23,8 +23,8 @@ import static org.testng.Assert.assertEquals;
import java.nio.ByteOrder;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
@@ -33,7 +33,7 @@ import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
public class NonNativeWritableMemoryImplTest {
private byte[] bArr = new byte[8];
- private final WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
+ private final WritableMemory wmem = WritableMemory.writableWrap(bArr, ByteOrder.BIG_ENDIAN);
//Check primitives
@Test
@@ -42,7 +42,7 @@ public class NonNativeWritableMemoryImplTest {
int n = ((1 << 20) / m) + m;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem1 = WritableMemory.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++);
@@ -51,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];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
wmem2.putCharArray(0, cArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -62,7 +62,7 @@ public class NonNativeWritableMemoryImplTest {
int n = ((1 << 20) / m) + m;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem1 = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
double dbl = 1.0;
for (int i = 0; i < n; i++) { wmem1.putDouble(i * m, dbl++); }
dbl = 1.0;
@@ -73,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];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
wmem2.putDoubleArray(0, dblArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -84,7 +84,7 @@ public class NonNativeWritableMemoryImplTest {
int n = ((1 << 20) / m) + m;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem1 = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
float flt = 1.0F;
for (int i = 0; i < n; i++) { wmem1.putFloat(i * m, flt++); }
flt = 1.0F;
@@ -95,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];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
wmem2.putFloatArray(0, fltArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -106,7 +106,7 @@ public class NonNativeWritableMemoryImplTest {
int n = ((1 << 20) / m) + m;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem1 = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
int intg = 1;
for (int i = 0; i < n; i++) { wmem1.putInt(i * m, intg++); }
intg = 1;
@@ -117,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];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
wmem2.putIntArray(0, intArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -128,7 +128,7 @@ public class NonNativeWritableMemoryImplTest {
int n = ((1 << 20) / m) + m;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem1 = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
long lng = 1;
for (int i = 0; i < n; i++) { wmem1.putLong(i * m, lng++); }
lng = 1;
@@ -139,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];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
wmem2.putLongArray(0, longArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -150,7 +150,7 @@ public class NonNativeWritableMemoryImplTest {
int n = ((1 << 20) / m) + m;
byte[] arr1 = new byte[n * m]; //non-native
//put & get
- WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem1 = WritableMemory.writableWrap(arr1, ByteOrder.BIG_ENDIAN);
short sht = 1;
for (int i = 0; i < n; i++) { wmem1.putShort(i * m, sht++); }
sht = 1;
@@ -161,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];
- WritableMemoryImpl wmem2 = WritableMemoryImpl.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem2 = WritableMemory.writableWrap(arr2, ByteOrder.BIG_ENDIAN);
wmem2.putShortArray(0, shortArr, 0, n);
assertEquals(arr2, arr1);
}
@@ -205,15 +205,15 @@ public class NonNativeWritableMemoryImplTest {
//check Region
@Test
public void checkRegion() {
- WritableMemoryImpl wreg = wmem.writableRegion(0, wmem.getCapacity());
+ WritableMemory wreg = wmem.writableRegion(0, wmem.getCapacity());
assertEquals(wreg.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
}
@Test
public void checkRegionZeros() {
byte[] bArr1 = new byte[0];
- WritableMemoryImpl wmem1 = WritableMemoryImpl.writableWrap(bArr1, ByteOrder.BIG_ENDIAN);
- MemoryImpl reg = wmem1.region(0, wmem1.getCapacity());
+ WritableMemory wmem1 = WritableMemory.writableWrap(bArr1, ByteOrder.BIG_ENDIAN);
+ Memory reg = wmem1.region(0, wmem1.getCapacity());
assertEquals(reg.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java b/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java
index daea055..1947316 100644
--- a/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java
+++ b/src/test/java/org/apache/datasketches/memory/test/ReflectUtil.java
@@ -221,30 +221,6 @@ public final class ReflectUtil {
CHECK_VALID.invoke(target);
}
-// static long getCurrentDirectMemoryAllocated() {
-// try {
-// return (long) GET_CURRENT_DIRECT_MEMORY_ALLOCATED.invoke(null);
-// } catch (Exception e) { throw new RuntimeException(e); }
-// }
-//
-// static long getCurrentDirectMemoryAllocations() {
-// try {
-// return (long) GET_CURRENT_DIRECT_MEMORY_ALLOCATIONS.invoke(null);
-// } catch (Exception e) { throw new RuntimeException(e); }
-// }
-//
-// static long getCurrentDirectMemoryMapAllocated() {
-// try {
-// return (long) GET_CURRENT_DIRECT_MEMORY_MAP_ALLOCATED.invoke(null);
-// } catch (Exception e) { throw new RuntimeException(e); }
-// }
-//
-// static long getCurrentDirectMemoryMapAllocations() {
-// try {
-// return (long) GET_CURRENT_DIRECT_MEMORY_MAP_ALLOCATIONS.invoke(null);
-// } catch (Exception e) { throw new RuntimeException(e); }
-// }
-
static long getDirectAllocationsCount() {
try {
return (long) GET_DIRECT_ALLOCATIONS_COUNT.invoke(null);
diff --git a/src/test/java/org/apache/datasketches/memory/test/SpecificLeafTest.java b/src/test/java/org/apache/datasketches/memory/test/SpecificLeafTest.java
index a1e5ce7..5b342d9 100644
--- a/src/test/java/org/apache/datasketches/memory/test/SpecificLeafTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/SpecificLeafTest.java
@@ -26,10 +26,10 @@ import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
-import org.apache.datasketches.memory.internal.BufferImpl;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Buffer;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.apache.datasketches.memory.WritableMapHandle;
import org.apache.datasketches.memory.WritableDirectHandle;
import org.testng.annotations.Test;
@@ -46,16 +46,16 @@ public class SpecificLeafTest {
ByteBuffer bb = ByteBuffer.allocate(bytes);
bb.order(Util.nativeByteOrder);
- MemoryImpl mem = MemoryImpl.wrap(bb).region(0, bytes, Util.nativeByteOrder);
+ Memory mem = Memory.wrap(bb).region(0, bytes, Util.nativeByteOrder);
assertTrue(ReflectUtil.isBBType(mem));
assertTrue(mem.isReadOnly());
checkCrossLeafTypeIds(mem);
- BufferImpl buf = mem.asBuffer().region(0, bytes, Util.nativeByteOrder);
+ Buffer buf = mem.asBuffer().region(0, bytes, Util.nativeByteOrder);
bb.order(Util.nonNativeByteOrder);
- MemoryImpl mem2 = MemoryImpl.wrap(bb).region(0, bytes, Util.nonNativeByteOrder);
- BufferImpl buf2 = mem2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
- BufferImpl buf3 = buf2.duplicate();
+ Memory mem2 = Memory.wrap(bb).region(0, bytes, Util.nonNativeByteOrder);
+ Buffer buf2 = mem2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
+ Buffer buf3 = buf2.duplicate();
assertTrue(ReflectUtil.isRegionType(mem));
assertTrue(ReflectUtil.isRegionType(mem2));
@@ -65,22 +65,22 @@ public class SpecificLeafTest {
}
@Test
- public void checkDirectLeafs() {
+ public void checkDirectLeafs() throws Exception {
int bytes = 128;
- try (WritableDirectHandle h = WritableMemoryImpl.allocateDirect(bytes)) {
- WritableMemoryImpl wmem = h.get(); //native mem
+ try (WritableDirectHandle h = WritableMemory.allocateDirect(bytes)) {
+ WritableMemory wmem = h.getWritable(); //native mem
assertTrue(ReflectUtil.isDirectType(wmem));
assertFalse(wmem.isReadOnly());
checkCrossLeafTypeIds(wmem);
- WritableMemoryImpl nnwmem = wmem.writableRegion(0, bytes, Util.nonNativeByteOrder);
+ WritableMemory nnwmem = wmem.writableRegion(0, bytes, Util.nonNativeByteOrder);
- MemoryImpl mem = wmem.region(0, bytes, Util.nativeByteOrder);
- BufferImpl buf = mem.asBuffer().region(0, bytes, Util.nativeByteOrder);
+ Memory mem = wmem.region(0, bytes, Util.nativeByteOrder);
+ Buffer buf = mem.asBuffer().region(0, bytes, Util.nativeByteOrder);
- MemoryImpl mem2 = nnwmem.region(0, bytes, Util.nonNativeByteOrder);
- BufferImpl buf2 = mem2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
- BufferImpl buf3 = buf2.duplicate();
+ Memory mem2 = nnwmem.region(0, bytes, Util.nonNativeByteOrder);
+ Buffer buf2 = mem2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
+ Buffer buf3 = buf2.duplicate();
assertTrue(ReflectUtil.isRegionType(mem));
assertTrue(ReflectUtil.isRegionType(mem2));
@@ -91,7 +91,7 @@ public class SpecificLeafTest {
}
@Test
- public void checkMapLeafs() throws IOException {
+ public void checkMapLeafs() throws Exception {
File file = new File("TestFile2.bin");
if (file.exists()) {
try {
@@ -107,20 +107,20 @@ public class SpecificLeafTest {
final long bytes = 128;
- try (WritableMapHandle h = WritableMemoryImpl.writableMap(file, 0L, bytes, Util.nativeByteOrder)) {
- WritableMemoryImpl mem = h.get(); //native mem
+ try (WritableMapHandle h = WritableMemory.writableMap(file, 0L, bytes, Util.nativeByteOrder)) {
+ WritableMemory mem = h.getWritable(); //native mem
assertTrue(ReflectUtil.isMapType(mem));
assertFalse(mem.isReadOnly());
checkCrossLeafTypeIds(mem);
- MemoryImpl nnreg = mem.region(0, bytes, Util.nonNativeByteOrder);
+ Memory nnreg = mem.region(0, bytes, Util.nonNativeByteOrder);
- MemoryImpl reg = mem.region(0, bytes, Util.nativeByteOrder);
- BufferImpl buf = reg.asBuffer().region(0, bytes, Util.nativeByteOrder);
- BufferImpl buf4 = buf.duplicate();
+ Memory reg = mem.region(0, bytes, Util.nativeByteOrder);
+ Buffer buf = reg.asBuffer().region(0, bytes, Util.nativeByteOrder);
+ Buffer buf4 = buf.duplicate();
- MemoryImpl reg2 = nnreg.region(0, bytes, Util.nonNativeByteOrder);
- BufferImpl buf2 = reg2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
- BufferImpl buf3 = buf2.duplicate();
+ Memory reg2 = nnreg.region(0, bytes, Util.nonNativeByteOrder);
+ Buffer buf2 = reg2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
+ Buffer buf3 = buf2.duplicate();
assertTrue(ReflectUtil.isRegionType(reg));
assertTrue(ReflectUtil.isRegionType(reg2));
@@ -134,19 +134,19 @@ public class SpecificLeafTest {
@Test
public void checkHeapLeafs() {
int bytes = 128;
- MemoryImpl mem = MemoryImpl.wrap(new byte[bytes]);
+ Memory mem = Memory.wrap(new byte[bytes]);
assertTrue(ReflectUtil.isHeapType(mem));
assertTrue(ReflectUtil.isReadOnlyType(mem));
checkCrossLeafTypeIds(mem);
- MemoryImpl nnreg = mem.region(0, bytes, Util.nonNativeByteOrder);
+ Memory nnreg = mem.region(0, bytes, Util.nonNativeByteOrder);
- MemoryImpl reg = mem.region(0, bytes, Util.nativeByteOrder);
- BufferImpl buf = reg.asBuffer().region(0, bytes, Util.nativeByteOrder);
- BufferImpl buf4 = buf.duplicate();
+ Memory reg = mem.region(0, bytes, Util.nativeByteOrder);
+ Buffer buf = reg.asBuffer().region(0, bytes, Util.nativeByteOrder);
+ Buffer buf4 = buf.duplicate();
- MemoryImpl reg2 = nnreg.region(0, bytes, Util.nonNativeByteOrder);
- BufferImpl buf2 = reg2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
- BufferImpl buf3 = buf2.duplicate();
+ Memory reg2 = nnreg.region(0, bytes, Util.nonNativeByteOrder);
+ Buffer buf2 = reg2.asBuffer().region(0, bytes, Util.nonNativeByteOrder);
+ Buffer buf3 = buf2.duplicate();
assertFalse(ReflectUtil.isRegionType(mem));
assertTrue(ReflectUtil.isRegionType(reg2));
@@ -156,31 +156,31 @@ public class SpecificLeafTest {
assertTrue(ReflectUtil.isDuplicateType(buf4));
}
- private static void checkCrossLeafTypeIds(MemoryImpl mem) {
- MemoryImpl reg1 = mem.region(0, mem.getCapacity());
+ private static void checkCrossLeafTypeIds(Memory mem) {
+ Memory reg1 = mem.region(0, mem.getCapacity());
assertTrue(ReflectUtil.isRegionType(reg1));
- BufferImpl buf1 = reg1.asBuffer();
+ Buffer buf1 = reg1.asBuffer();
assertTrue(ReflectUtil.isRegionType(buf1));
assertTrue(ReflectUtil.isBufferType(buf1));
- BufferImpl buf2 = buf1.duplicate();
+ Buffer buf2 = buf1.duplicate();
assertTrue(ReflectUtil.isRegionType(buf2));
assertTrue(ReflectUtil.isBufferType(buf2));
assertTrue(ReflectUtil.isDuplicateType(buf2));
- MemoryImpl mem2 = buf1.asMemory();
+ Memory mem2 = buf1.asMemory();
assertTrue(ReflectUtil.isRegionType(mem2));
assertFalse(ReflectUtil.isBufferType(mem2));
assertFalse(ReflectUtil.isDuplicateType(mem2));
- BufferImpl buf3 = buf1.duplicate(Util.nonNativeByteOrder);
+ Buffer buf3 = buf1.duplicate(Util.nonNativeByteOrder);
assertTrue(ReflectUtil.isRegionType(buf3));
assertTrue(ReflectUtil.isBufferType(buf3));
assertTrue(ReflectUtil.isDuplicateType(buf3));
assertTrue(ReflectUtil.isNonNativeType(buf3));
- MemoryImpl mem3 = buf3.asMemory();
+ Memory mem3 = buf3.asMemory();
assertTrue(ReflectUtil.isRegionType(mem3));
assertFalse(ReflectUtil.isBufferType(mem3));
assertFalse(ReflectUtil.isDuplicateType(mem3));
diff --git a/src/test/java/org/apache/datasketches/memory/test/Utf8Test.java b/src/test/java/org/apache/datasketches/memory/test/Utf8Test.java
index 0a710c8..96c3921 100644
--- a/src/test/java/org/apache/datasketches/memory/test/Utf8Test.java
+++ b/src/test/java/org/apache/datasketches/memory/test/Utf8Test.java
@@ -28,9 +28,9 @@ import java.nio.CharBuffer;
import java.util.ArrayList;
import java.util.List;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.Utf8CodingException;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.apache.datasketches.memory.internal.Util.RandomCodePoints;
import org.testng.annotations.Test;
@@ -59,15 +59,15 @@ public class Utf8Test {
@Test
public void testPutInvalidChars() { //The surrogates must be a pair, thus invalid alone
- WritableMemoryImpl mem = WritableMemoryImpl.allocate(10);
- WritableMemoryImpl emptyMem = WritableMemoryImpl.allocate(0);
+ WritableMemory mem = WritableMemory.allocate(10);
+ WritableMemory emptyMem = WritableMemory.allocate(0);
for (int c = Character.MIN_SURROGATE; c <= Character.MAX_SURROGATE; c++) {
assertSurrogate(mem, (char) c);
assertSurrogate(emptyMem, (char) c);
}
}
- private static void assertSurrogate(WritableMemoryImpl mem, char c) {
+ private static void assertSurrogate(WritableMemory mem, char c) {
try {
mem.putCharsToUtf8(0, new String(new char[] {c}));
fail();
@@ -78,7 +78,7 @@ public class Utf8Test {
@Test
public void testPutInvaidSurrogatePairs() {
- WritableMemoryImpl mem = WritableMemoryImpl.allocate(4);
+ WritableMemory mem = WritableMemory.allocate(4);
StringBuilder sb = new StringBuilder();
sb.append(Character.MIN_HIGH_SURROGATE);
sb.append(Character.MAX_HIGH_SURROGATE);
@@ -91,7 +91,7 @@ public class Utf8Test {
@Test
public void testPutHighBMP() {
- WritableMemoryImpl mem = WritableMemoryImpl.allocate(2);
+ WritableMemory mem = WritableMemory.allocate(2);
StringBuilder sb = new StringBuilder();
sb.append("\uE000");
try {
@@ -103,7 +103,7 @@ public class Utf8Test {
@Test
public void testPutExtendedAscii() {
- WritableMemoryImpl mem = WritableMemoryImpl.allocate(1);
+ WritableMemory mem = WritableMemory.allocate(1);
StringBuilder sb = new StringBuilder();
sb.append("\u07FF");
try {
@@ -115,7 +115,7 @@ public class Utf8Test {
@Test
public void testPutOneAsciiToEmpty() {
- WritableMemoryImpl mem = WritableMemoryImpl.allocate(0);
+ WritableMemory mem = WritableMemory.allocate(0);
StringBuilder sb = new StringBuilder();
sb.append("a");
try {
@@ -127,7 +127,7 @@ public class Utf8Test {
@Test
public void testPutValidSurrogatePair() {
- WritableMemoryImpl mem = WritableMemoryImpl.allocate(4);
+ WritableMemory mem = WritableMemory.allocate(4);
StringBuilder sb = new StringBuilder();
sb.append(Character.MIN_HIGH_SURROGATE);
sb.append(Character.MIN_LOW_SURROGATE);
@@ -218,7 +218,7 @@ public class Utf8Test {
rcp.fillCodePointArray(cpArr, 0, minPlane2CP);
String rcpStr = new String(cpArr, 0, numCP);
//println(rcpStr);
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(4 * numCP);
+ WritableMemory wmem = WritableMemory.allocate(4 * numCP);
int utf8Bytes = (int) wmem.putCharsToUtf8(0, rcpStr);
StringBuilder sb = new StringBuilder();
@@ -302,7 +302,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;
- WritableMemoryImpl refMem = WritableMemoryImpl.writableWrap(refByteArr);
+ WritableMemory refMem = WritableMemory.writableWrap(refByteArr);
int decodedChars = refMem.getCharsFromUtf8(0, addBytes, sb);
String finalStr = sb.toString();
int finalChars = finalStr.toCharArray().length;
@@ -318,7 +318,7 @@ public class Utf8Test {
byte[] refByteArr = refStr.getBytes(UTF_8);
int refBytes = refByteArr.length;
int offset = 100;
- WritableMemoryImpl tgtMem = WritableMemoryImpl.allocate(refBytes + offset);
+ WritableMemory tgtMem = WritableMemory.allocate(refBytes + offset);
long bytesEncoded = tgtMem.putCharsToUtf8(offset, refStr);
assertEquals(bytesEncoded, refBytes);
}
@@ -370,7 +370,7 @@ public class Utf8Test {
}
@Test
- public void testInvalidBufferSlice() { //these are pure MemoryImpl bounds violations
+ public void testInvalidBufferSlice() { //these are pure Memory bounds violations
byte[] bytes = "The quick brown fox jumps over the lazy dog".getBytes(UTF_8);
assertInvalidSlice(bytes, bytes.length - 3, 4);
assertInvalidSlice(bytes, bytes.length, 1);
@@ -389,14 +389,14 @@ public class Utf8Test {
private static void assertInvalid(byte[] bytes) {
int bytesLen = bytes.length;
try {
- MemoryImpl.wrap(bytes).getCharsFromUtf8(0, bytesLen, new StringBuilder());
+ Memory.wrap(bytes).getCharsFromUtf8(0, bytesLen, new StringBuilder());
fail();
} catch (Utf8CodingException e) {
// Expected.
}
try {
CharBuffer cb = CharBuffer.allocate(bytesLen);
- MemoryImpl.wrap(bytes).getCharsFromUtf8(0, bytesLen, cb);
+ Memory.wrap(bytes).getCharsFromUtf8(0, bytesLen, cb);
fail();
} catch (Utf8CodingException | IOException e) {
// Expected.
@@ -405,7 +405,7 @@ public class Utf8Test {
private static void assertInvalidSlice(byte[] bytes, int index, int size) {
try {
- MemoryImpl mem = MemoryImpl.wrap(bytes);
+ Memory mem = Memory.wrap(bytes);
mem.getCharsFromUtf8(index, size, new StringBuilder());
fail();
} catch (IllegalArgumentException e) { //Pure bounds violation
@@ -436,17 +436,17 @@ public class Utf8Test {
if (utf8LengthBytes == -1) {
utf8LengthBytes = refByteArr.length;
}
- MemoryImpl refMem = MemoryImpl.wrap(refByteArr);
+ Memory refMem = Memory.wrap(refByteArr);
byte[] refByteArr2 = new byte[refByteArr.length + 1];
System.arraycopy(refByteArr, 0, refByteArr2, 1, refByteArr.length);
- MemoryImpl refReg = MemoryImpl.wrap(refByteArr2).region(1, refByteArr.length);
+ Memory refReg = Memory.wrap(refByteArr2).region(1, refByteArr.length);
- WritableMemoryImpl dstMem = WritableMemoryImpl.allocate(refByteArr.length);
- WritableMemoryImpl dstMem2 =
- WritableMemoryImpl.allocate(refByteArr.length + 1).writableRegion(1, refByteArr.length);
+ WritableMemory dstMem = WritableMemory.allocate(refByteArr.length);
+ WritableMemory dstMem2 =
+ WritableMemory.allocate(refByteArr.length + 1).writableRegion(1, refByteArr.length);
- // Test with MemoryImpl objects, where base offset != 0
+ // Test with Memory objects, where base offset != 0
assertRoundTrips(refStr, refSubCharLen, offsetBytes, utf8LengthBytes, refByteArr, refMem, dstMem);
assertRoundTrips(refStr, refSubCharLen, offsetBytes, utf8LengthBytes, refByteArr, refMem, dstMem2);
assertRoundTrips(refStr, refSubCharLen, offsetBytes, utf8LengthBytes, refByteArr, refReg, dstMem);
@@ -454,7 +454,7 @@ public class Utf8Test {
}
private static void assertRoundTrips(String refStr, int refSubCharLen, int offsetBytes,
- int utf8LengthBytes, byte[] refByteArr, MemoryImpl refMem, WritableMemoryImpl dstMem)
+ int utf8LengthBytes, byte[] refByteArr, Memory refMem, WritableMemory dstMem)
throws IOException {
StringBuilder sb = new StringBuilder();
@@ -476,7 +476,7 @@ public class Utf8Test {
assertEquals(0, dstMem.compareTo(0, refByteArr.length, refMem, 0, refByteArr.length));
// Test write overflow
- WritableMemoryImpl writeMem2 = WritableMemoryImpl.allocate(refByteArr.length - 1);
+ WritableMemory writeMem2 = WritableMemory.allocate(refByteArr.length - 1);
try {
writeMem2.putCharsToUtf8(0, refStr);
fail();
diff --git a/src/test/java/org/apache/datasketches/memory/test/UtilTest.java b/src/test/java/org/apache/datasketches/memory/test/UtilTest.java
index fbc2962..144618f 100644
--- a/src/test/java/org/apache/datasketches/memory/test/UtilTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/UtilTest.java
@@ -44,7 +44,7 @@ import java.nio.file.attribute.PosixFilePermissions;
import org.apache.datasketches.memory.internal.UnsafeUtil;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
@@ -55,7 +55,7 @@ public class UtilTest {
@Test
public void checkBinarySearch() {
int k = 1024; //longs
- WritableMemoryImpl wMem = WritableMemoryImpl.allocate(k << 3); //1024 longs
+ WritableMemory wMem = WritableMemory.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 val = wMem.getLong(idx << 3);
diff --git a/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java b/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java
index d29dff3..e93352b 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableDirectCopyTest.java
@@ -23,8 +23,8 @@ import static org.testng.Assert.assertEquals;
import static org.testng.Assert.fail;
import org.apache.datasketches.memory.WritableHandle;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
@@ -36,11 +36,11 @@ public class WritableDirectCopyTest {
//Copy Within tests
@Test
- public void checkCopyWithinNativeSmall() {
+ public void checkCopyWithinNativeSmall() throws Exception {
int memCapacity = 64;
int half = memCapacity / 2;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.clear();
for (int i = 0; i < half; i++) { //fill first half
@@ -56,13 +56,13 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyWithinNativeLarge() {
+ public void checkCopyWithinNativeLarge() throws Exception {
int memCapacity = (2 << 20) + 64;
int memCapLongs = memCapacity / 8;
int halfBytes = memCapacity / 2;
int halfLongs = memCapLongs / 2;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.clear();
for (int i = 0; i < halfLongs; i++) {
@@ -78,10 +78,10 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyWithinNativeOverlap() {
+ public void checkCopyWithinNativeOverlap() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.clear();
//println(mem.toHexString("Clear 64", 0, memCapacity));
@@ -94,10 +94,10 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyWithinNativeSrcBound() {
+ public void checkCopyWithinNativeSrcBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.copyTo(32, mem, 32, 33); //hit source bound check
fail("Did Not Catch Assertion Error: source bound");
} catch (IllegalArgumentException e) {
@@ -106,10 +106,10 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyWithinNativeDstBound() {
+ public void checkCopyWithinNativeDstBound() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem = wrh.get();
+ try (WritableHandle wrh = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem = wrh.getWritable();
mem.copyTo(0, mem, 32, 33); //hit dst bound check
fail("Did Not Catch Assertion Error: dst bound");
} catch (IllegalArgumentException e) {
@@ -118,13 +118,13 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyCrossNativeSmall() {
+ public void checkCopyCrossNativeSmall() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity);
- WritableHandle wrh2 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem1 = wrh1.get();
- WritableMemoryImpl mem2 = wrh2.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity);
+ WritableHandle wrh2 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem1 = wrh1.getWritable();
+ WritableMemory mem2 = wrh2.getWritable();
for (int i = 0; i < memCapacity; i++) {
mem1.putByte(i, (byte) i);
@@ -141,14 +141,14 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyCrossNativeLarge() {
+ public void checkCopyCrossNativeLarge() throws Exception {
int memCapacity = (2 << 20) + 64;
int memCapLongs = memCapacity / 8;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity);
- WritableHandle wrh2 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem1 = wrh1.get();
- WritableMemoryImpl mem2 = wrh2.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity);
+ WritableHandle wrh2 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem1 = wrh1.getWritable();
+ WritableMemory mem2 = wrh2.getWritable();
for (int i = 0; i < memCapLongs; i++) {
mem1.putLong(i * 8, i);
@@ -164,16 +164,16 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyCrossNativeAndByteArray() {
+ public void checkCopyCrossNativeAndByteArray() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem1 = wrh1.getWritable();
for (int i = 0; i < mem1.getCapacity(); i++) {
mem1.putByte(i, (byte) i);
}
- WritableMemoryImpl mem2 = WritableMemoryImpl.allocate(memCapacity);
+ WritableMemory mem2 = WritableMemory.allocate(memCapacity);
mem1.copyTo(8, mem2, 16, 16);
for (int i = 0; i < 16; i++) {
@@ -184,21 +184,21 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyCrossRegionsSameNative() {
+ public void checkCopyCrossRegionsSameNative() throws Exception {
int memCapacity = 128;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem1 = wrh1.getWritable();
for (int i = 0; i < mem1.getCapacity(); i++) {
mem1.putByte(i, (byte) i);
}
//println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
- MemoryImpl reg1 = mem1.region(8, 16);
+ Memory reg1 = mem1.region(8, 16);
//println(reg1.toHexString("Reg1", 0, (int)reg1.getCapacity()));
- WritableMemoryImpl reg2 = mem1.writableRegion(24, 16);
+ WritableMemory reg2 = mem1.writableRegion(24, 16);
//println(reg2.toHexString("Reg2", 0, (int)reg2.getCapacity()));
reg1.copyTo(0, reg2, 0, 16);
@@ -211,24 +211,24 @@ public class WritableDirectCopyTest {
}
@Test
- public void checkCopyCrossNativeArrayAndHierarchicalRegions() {
+ public void checkCopyCrossNativeArrayAndHierarchicalRegions() throws Exception {
int memCapacity = 64;
- try (WritableHandle wrh1 = WritableMemoryImpl.allocateDirect(memCapacity)) {
- WritableMemoryImpl mem1 = wrh1.get();
+ try (WritableHandle wrh1 = WritableMemory.allocateDirect(memCapacity)) {
+ WritableMemory mem1 = wrh1.getWritable();
for (int i = 0; i < mem1.getCapacity(); i++) { //fill with numbers
mem1.putByte(i, (byte) i);
}
//println(mem1.toHexString("Mem1", 0, (int)mem1.getCapacity()));
- WritableMemoryImpl mem2 = WritableMemoryImpl.allocate(memCapacity);
+ WritableMemory mem2 = WritableMemory.allocate(memCapacity);
- MemoryImpl reg1 = mem1.region(8, 32);
- MemoryImpl reg1B = reg1.region(8, 16);
+ Memory reg1 = mem1.region(8, 32);
+ Memory reg1B = reg1.region(8, 16);
//println(reg1.toHexString("Reg1", 0, (int)reg1.getCapacity()));
//println(reg1B.toHexString("Reg1B", 0, (int)reg1B.getCapacity()));
- WritableMemoryImpl reg2 = mem2.writableRegion(32, 16);
+ WritableMemory reg2 = mem2.writableRegion(32, 16);
reg1B.copyTo(0, reg2, 0, 16);
//println(reg2.toHexString("Reg2", 0, (int)reg2.getCapacity()));
diff --git a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryTest.java b/src/test/java/org/apache/datasketches/memory/test/WritableMemoryTest.java
index e0765a9..ea49e69 100644
--- a/src/test/java/org/apache/datasketches/memory/test/WritableMemoryTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/WritableMemoryTest.java
@@ -27,10 +27,10 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.concurrent.ThreadLocalRandom;
-import org.apache.datasketches.memory.internal.MemoryImpl;
+import org.apache.datasketches.memory.Memory;
import org.apache.datasketches.memory.internal.Util;
-import org.apache.datasketches.memory.internal.WritableBufferImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableBuffer;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
@SuppressWarnings("javadoc")
@@ -39,7 +39,7 @@ public class WritableMemoryTest {
@Test
public void wrapBigEndian() {
ByteBuffer bb = ByteBuffer.allocate(64); //big endian
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bb);
+ WritableMemory wmem = WritableMemory.writableWrap(bb);
assertEquals(wmem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
}
@@ -47,50 +47,50 @@ public class WritableMemoryTest {
public void wrapBigEndianAsLittle() {
ByteBuffer bb = ByteBuffer.allocate(64);
bb.putChar(0, (char)1); //as BE
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(bb, ByteOrder.LITTLE_ENDIAN);
+ WritableMemory wmem = WritableMemory.writableWrap(bb, ByteOrder.LITTLE_ENDIAN);
assertEquals(wmem.getChar(0), 256);
}
@Test
public void allocateWithByteOrder() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(64, ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem = WritableMemory.allocate(64, ByteOrder.BIG_ENDIAN);
assertEquals(wmem.getTypeByteOrder(), ByteOrder.BIG_ENDIAN);
- wmem = WritableMemoryImpl.allocate(64, ByteOrder.LITTLE_ENDIAN);
+ wmem = WritableMemory.allocate(64, ByteOrder.LITTLE_ENDIAN);
assertEquals(wmem.getTypeByteOrder(), ByteOrder.LITTLE_ENDIAN);
}
@Test
public void checkGetArray() {
byte[] byteArr = new byte[64];
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(byteArr);
+ WritableMemory wmem = WritableMemory.writableWrap(byteArr);
assertTrue(wmem.getArray() == byteArr);
- WritableBufferImpl wbuf = wmem.asWritableBuffer();
+ WritableBuffer wbuf = wmem.asWritableBuffer();
assertTrue(wbuf.getArray() == byteArr);
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void checkSelfArrayCopy() {
byte[] srcAndDst = new byte[128];
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(srcAndDst);
+ WritableMemory wmem = WritableMemory.writableWrap(srcAndDst);
wmem.getByteArray(0, srcAndDst, 64, 64); //non-overlapping
}
@Test
public void checkEquals() {
int len = 7;
- WritableMemoryImpl wmem1 = WritableMemoryImpl.allocate(len);
+ WritableMemory wmem1 = WritableMemory.allocate(len);
//@SuppressWarnings({"EqualsWithItself", "SelfEquals"}) //unsupported
//SelfEquals for Plexus, EqualsWithItself for IntelliJ
//boolean eq1 = wmem1.equals(wmem1); //strict profile complains
//assertTrue(eq1);
- WritableMemoryImpl wmem2 = WritableMemoryImpl.allocate(len + 1);
+ WritableMemory wmem2 = WritableMemory.allocate(len + 1);
assertFalse(wmem1.equals(wmem2));
- WritableMemoryImpl reg1 = wmem1.writableRegion(0, wmem1.getCapacity());
+ WritableMemory reg1 = wmem1.writableRegion(0, wmem1.getCapacity());
assertTrue(wmem1.equals(reg1));
- wmem2 = WritableMemoryImpl.allocate(len);
+ wmem2 = WritableMemory.allocate(len);
for (int i = 0; i < len; i++) {
wmem1.putByte(i, (byte) i);
wmem2.putByte(i, (byte) i);
@@ -102,8 +102,8 @@ public class WritableMemoryTest {
assertTrue(wmem1.equalTo(0, reg1, 0, len));
len = 24;
- wmem1 = WritableMemoryImpl.allocate(len);
- wmem2 = WritableMemoryImpl.allocate(len);
+ wmem1 = WritableMemory.allocate(len);
+ wmem2 = WritableMemory.allocate(len);
for (int i = 0; i < len; i++) {
wmem1.putByte(i, (byte) i);
wmem2.putByte(i, (byte) i);
@@ -120,14 +120,14 @@ public class WritableMemoryTest {
@Test
public void checkEquals2() {
int len = 23;
- WritableMemoryImpl wmem1 = WritableMemoryImpl.allocate(len);
+ WritableMemory wmem1 = WritableMemory.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);
- WritableMemoryImpl wmem2 = WritableMemoryImpl.allocate(len + 1);
+ WritableMemory wmem2 = WritableMemory.allocate(len + 1);
assertFalse(wmem1.equals(wmem2));
for (int i = 0; i < len; i++) {
@@ -146,8 +146,8 @@ public class WritableMemoryTest {
byte[] bytes1 = new byte[(thresh * 2) + 7];
ThreadLocalRandom.current().nextBytes(bytes1);
byte[] bytes2 = bytes1.clone();
- MemoryImpl mem1 = MemoryImpl.wrap(bytes1);
- MemoryImpl mem2 = MemoryImpl.wrap(bytes2);
+ Memory mem1 = Memory.wrap(bytes1);
+ Memory mem2 = Memory.wrap(bytes2);
assertTrue(mem1.equals(mem2));
bytes2[thresh + 10] = (byte) (bytes1[thresh + 10] + 1);
@@ -160,11 +160,11 @@ public class WritableMemoryTest {
@Test
public void checkWrapWithBO() {
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(new byte[0], ByteOrder.BIG_ENDIAN);
+ WritableMemory wmem = WritableMemory.writableWrap(new byte[0], ByteOrder.BIG_ENDIAN);
boolean nativeBO = wmem.getTypeByteOrder() == Util.nativeByteOrder;
assertTrue(nativeBO); //remains true for ZeroSizeMemory
println("" + nativeBO);
- wmem = WritableMemoryImpl.writableWrap(new byte[8], ByteOrder.BIG_ENDIAN);
+ wmem = WritableMemory.writableWrap(new byte[8], ByteOrder.BIG_ENDIAN);
nativeBO = wmem.getTypeByteOrder() == Util.nativeByteOrder;
assertFalse(nativeBO);
println("" + nativeBO);
@@ -173,11 +173,11 @@ public class WritableMemoryTest {
@Test
@SuppressWarnings("unused")
public void checkOwnerClientCase() {
- WritableMemoryImpl owner = WritableMemoryImpl.allocate(64);
- MemoryImpl client1 = owner; //Client1 cannot write (no API)
+ WritableMemory owner = WritableMemory.allocate(64);
+ Memory client1 = owner; //Client1 cannot write (no API)
owner.putInt(0, 1); //But owner can write
- ((WritableMemoryImpl)client1).putInt(0, 2); //Client1 can write, but with explicit effort.
- MemoryImpl client2 = owner.region(0, owner.getCapacity()); //client2 cannot write (no API)
+ ((WritableMemory)client1).putInt(0, 2); //Client1 can write, but with explicit effort.
+ Memory client2 = owner.region(0, owner.getCapacity()); //client2 cannot write (no API)
owner.putInt(0, 3); //But Owner should be able to write
}
diff --git a/src/test/java/org/apache/datasketches/memory/test/XxHash64LoopingTest.java b/src/test/java/org/apache/datasketches/memory/test/XxHash64LoopingTest.java
index 6d1f6c1..76a2e59 100644
--- a/src/test/java/org/apache/datasketches/memory/test/XxHash64LoopingTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/XxHash64LoopingTest.java
@@ -21,7 +21,7 @@ package org.apache.datasketches.memory.test;
import static org.testng.Assert.assertEquals;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
/**
@@ -42,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; }
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(byteArr);
+ WritableMemory wmem = WritableMemory.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/test/XxHash64Test.java b/src/test/java/org/apache/datasketches/memory/test/XxHash64Test.java
index 50f44c4..13e77ed 100644
--- a/src/test/java/org/apache/datasketches/memory/test/XxHash64Test.java
+++ b/src/test/java/org/apache/datasketches/memory/test/XxHash64Test.java
@@ -26,8 +26,8 @@ import static org.testng.Assert.assertTrue;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.annotations.Test;
import net.openhft.hashing.LongHashFunction;
@@ -46,7 +46,7 @@ public class XxHash64Test {
long hash;
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(cap);
+ WritableMemory wmem = WritableMemory.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];
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(in);
+ WritableMemory wmem = WritableMemory.writableWrap(in);
for (int i = 0; i < j; i++) { wmem.putByte(i, (byte) (-128 + i)); }
long hash =wmem.xxHash64(offset, bytes, seed);
@@ -81,7 +81,7 @@ public class XxHash64Test {
*/
@Test
public void collisionTest() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(128);
+ WritableMemory wmem = WritableMemory.allocate(128);
wmem.putLong(0, 1);
wmem.putLong(16, 42);
wmem.putLong(32, 2);
@@ -100,7 +100,7 @@ public class XxHash64Test {
}
/**
- * This simple test compares the output of {@link BaseStateImpl#xxHash64(long, long, long)} with the
+ * This simple test compares the output of {@link BaseState#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.
@@ -115,7 +115,7 @@ public class XxHash64Test {
byte[] bytes = new byte[len];
for (int i = 0; i < 10; i++) {
long zahXxHash = LongHashFunction.xx().hashBytes(bytes);
- long memoryXxHash = MemoryImpl.wrap(bytes).xxHash64(0, len, 0);
+ long memoryXxHash = Memory.wrap(bytes).xxHash64(0, len, 0);
assertEquals(memoryXxHash, zahXxHash);
random.nextBytes(bytes);
}
@@ -126,7 +126,7 @@ public class XxHash64Test {
@Test
public void testArrHashes() {
- WritableMemoryImpl wmem = WritableMemoryImpl.writableWrap(barr);
+ WritableMemory wmem = WritableMemory.writableWrap(barr);
long hash0 = wmem.xxHash64(8, 8, 0);
long hash1 = hashBytes(barr, 8, 8, 0);
assertEquals(hash1, hash0);
diff --git a/src/test/java/org/apache/datasketches/memory/test/ZeroCapacityTest.java b/src/test/java/org/apache/datasketches/memory/test/ZeroCapacityTest.java
index fea92ae..1c2c7b7 100644
--- a/src/test/java/org/apache/datasketches/memory/test/ZeroCapacityTest.java
+++ b/src/test/java/org/apache/datasketches/memory/test/ZeroCapacityTest.java
@@ -23,8 +23,8 @@ import static org.testng.Assert.assertEquals;
import java.nio.ByteBuffer;
-import org.apache.datasketches.memory.internal.MemoryImpl;
-import org.apache.datasketches.memory.internal.WritableMemoryImpl;
+import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.WritableMemory;
import org.testng.Assert;
import org.testng.annotations.Test;
@@ -37,15 +37,15 @@ public class ZeroCapacityTest {
@SuppressWarnings({ "unused", "resource" })
@Test
public void checkZeroCapacity() {
- WritableMemoryImpl wmem = WritableMemoryImpl.allocate(0);
+ WritableMemory wmem = WritableMemory.allocate(0);
assertEquals(wmem.getCapacity(), 0);
- MemoryImpl mem1 = MemoryImpl.wrap(new byte[0]);
- MemoryImpl mem2 = MemoryImpl.wrap(ByteBuffer.allocate(0));
- MemoryImpl mem3 = MemoryImpl.wrap(ByteBuffer.allocateDirect(0));
- MemoryImpl reg = mem3.region(0, 0);
+ Memory mem1 = Memory.wrap(new byte[0]);
+ Memory mem2 = Memory.wrap(ByteBuffer.allocate(0));
+ Memory mem3 = Memory.wrap(ByteBuffer.allocateDirect(0));
+ Memory reg = mem3.region(0, 0);
try {
- WritableMemoryImpl.allocateDirect(0);
+ WritableMemory.allocateDirect(0);
Assert.fail();
} catch (IllegalArgumentException ignore) {
// expected
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org